Blocked by junkdog/artemis-odb#112

Currently we only have BasicEventDispatcher, which isn't much more than a proof of concept. Implement something based on bukkit or guice style event busser, but without the static references.

Scan by prefix.
public void myEventListener( Event event );

Asynchronous events: Artemis doesn't seem to be particularly well suited for asynchronous activity, so we currently do not support it. It does have plenty of advanced use cases though.

Authoritive server/client setup.

Leverage Artemis' design and make networking accessible out of the box for ecs/networking newbies. High level convention/annotation based networking of components, on top of some networking systems with a nice example or two, client/server system reuse. The actual networking framework can be completely outside ECS.

Take an existing network framework, integrate it in Artemis ECS pattern like you would any externalized framework, and provide enough sauce so it both becomes a drop in solution and a great reference for prototype networking with Artemis.

junkdog/artemis-odb#103

Epic ticket, break up as we go!

** Reworked list **

• udp (lossy) channel
• tcp (robust) channel
• client packets
  • keyboard input packet
  • network event
    • refusal handling (client futures, basically a rollback request)
• mirror entity + component to clients
  • create from archetype
  • transfer component state
    • developer codes component <-> packet
    • subscribing clients to components
      • configurable lossy attributes
      • configurable lossy update interval.
      • configurable robust attributes
      • configurable robust update interval.
  • removeFromWorld
• subscribing clients to entities

Core

• authoritative listener server on client.
• component delta updates (server to client)
• scoping (what entities to network)
• entity network-id
• entity level networking metadata (what fields do we sync, how do we sync)
  • manual entity serialization helper & dirty state detection
  • automated reflection based (de)serialization helpers & dirty state detection
• dispatching networked events (see #4)
  • remote entity instancing
  • remote entity destruction
• customizable lifecycle management.

Not right now:

• Component or template level networking metadata.
• support for diverging systems, where client and server have different implementations of the same component.
• dedicated server
• component level networking metadata
• Interpolation
• Extrapolation
• gain/loss, min/max caps on fields.
• UDP support (error correction on lossy protocol)
• GWT support
• Ready system
• Lobby system
• Component recording (rollback for hitscanning)
• Client agnostic networking frameworks / swappable networking frameworks

• libgdx @Profile example
  see #17

Allow (groups of) systems to be supplied with a custom delta.

Support (temporary) rewinding of monitored components to a past reference frame. Typical use case would be rewinding position and animation state to perform hit detection to network clients reference frame, but could be used for non-network purposes as well.

see #5

How to elegantly do this. Provide two sets of components?

automatically wiring components to libgdx widgets, assisted by annotations for specifying ranges etc
#17

• Use @entityID
• odb io serialization support.
• mutable, to facilitate pooling.

Instead of dispatching events synchronously and possibly causing a stack overflow, run a queue between system calls.

Also reconsider asynchronous events, might be useful across world instances.

see #11

commandline/UI tool iterative scaffolding generator for:

• components + systems
• factories

@junkdog mused:
DSL-like configuration is too brittle, but an efficient UI could probably do the job + suggest sane defaults. Powered by FreeMarker, it should be pretty easy to stub a lot of things.

As for UI framework - I'd shy away from the graphical ones and instead use a text UI - Lanterna is pretty nice and works with real terminals + can fall back on emulating its own.

junkdog/artemis-odb#194

While it runs somewhat contrary to the client/server setup we're going for, consider if there is a practical way to achieve drop in artemis plugin for lock-step networking for situations where basic client/server solution would break down (high unit count RTS for example).

http://www.gamasutra.com/view/feature/3094
http://answers.unity3d.com/questions/568206/rts-multiplayer-lock-step-simulations-and-fixed-ga.html
http://clintonbrennan.com/2013/12/lockstep-implementation-in-unity3d/

see #5

Hey, @DaanVanYperen. Do you have any plans or solutions for object pooling in EventManager?

Delegating things like child/parent to Box2D might be a useful route to take.

Right now dispatching has two options, dispatch(Event) and dispatch(class). Convert the old strategies to the new dispatch method.

For systems tracking/comparing two sets of entities.

Start working in feature branches you dummy! you're making a mess.

junkdog/artemis-odb#191

Event Polling: https://github.com/apotapov/gdx-artemis has a polling event system.

Need some better use cases for pollable events in a system.

junkdog/artemis-odb#114

lots of the current systems are libgdx bound for no reason, generally by referencing color, vector2/vector3.

SuperSystem / SubSystem - transform DeferredEntitySystem from contrib into an easier to understand setup. This'll be the first step towards render pipelines and such.

• Look at @junkdog's super secret stuff.
• Talk it over with the rest!
• Replace subscriptions with ODB subscriptions (faster).

see junkdog/artemis-odb#76

These tickets are too much effort right now or need a sponsor.

• [Serialization] Entities lazy loading
• #29 clean keyboard/joystick control scheme.
• #18 Annotation assisted libgdx widget/component wiring.
• #25 Consider drop in support for lock-step networking.
• #26 Cumulative transformations
• #27 Entity hierarchy (parent/child)
• #66 smoothcam
• #84 Fire and forget systems.
• #65 System grouping and custom delta.
• #19 Examples for artemis-odb core functionality
• Advanced Networking
  • #23 Client/Server world matching.
  • #24 Support limited state rewinding.
  • #3 GWT REST
  • #16 Asynchronous events
  • #21 Refactor networking to support local (networkless) marshaling
  • #22 Support world lifecycle surviving connections.

Persist to:

• local storage
• remote storage (REST)

The split between libgdx and vanilla component packages is just causing a lot of work without much benefit, just merge into the libgdx package!

In a multiworld setup we need to ensure both parties are in a sane world state. Can't have a client in a lobby syncing with a server in gamemode.

Implement low throughput synchronous immediate delivery event system. Like all modules in this package, should provide drop-in and go functionality. Main reason to code this feature now is the potential synergy with the networking module.

junkdog/artemis-odb#17
junkdog/artemis-odb#102

Planned Features

Now:

• EventManager to register and dispatch events.
• @Subscribe in managers and systems on methods with one event argument to denote event handlers.

Nice to have:

• gwt support using the reflection tools available to us.
• Priority option on events. Otherwise order by system priority.
• Support to register eventhandlers and dispatch events outside artemis systems and managers.
• Event priority
• Event cancellation

Not right now

• High throughput
• Asynchronous events: Artemis doesn't seem to be particularly well suited for asynchronous activity, so first version will not support it.
• Event Polling: https://github.com/apotapov/gdx-artemis has a polling event system. I'm not convinced this is the way to go, regardless of the benefits (no reflection, process() inline execution). Need some better use cases for events in a system as opposed to using reflection. I'm confident we can emulate subscription in gwt, and it's a system I like the most, so we'll just go with that for now.
• Pooling: We'll get there if GC becomes an issue.

network connections will probably need to last longer than the world does. (lobby world to game world). Maybe nested worlds? Different worlds can share the same network profile, but not the same networking systems.

Initially for eventbus.

@junkdog: fixed count or fixed percentage of entities processed each tick,

• timeboxed entities.
• fixed count / percentage of entities
• write wiki for both

Just take care to still kryo everything ;)

Also reflection includes in artemis.