Zay-ES and Zay-ES-Net 1.2.1 released

Small changes but significant enough to cut a formal release that anyone can use without building from source.

The big highlights:

  • WatchedEntity - acts sort of like an EntitySet of one but directly implements the Entity interface. Values can be directly set/get but applyChanges() can also get the latest value. Useful for player-specific entities that are basically singleton for that client.
  • Network performance improvements - the client/server entity set handling has been completely overhauled.
  • Network integration with JME 3.1 service model - includes entity data host and client services that can be trivially added to a JME SpiderMonkey server or client service manager. “plug and play”

Full Zay-ES Core changelog:

  • Upgraded the project to be JDK 1.7 and source 1.7 based.
  • Added the ability to get a WatchedEntity which acts like an entity
    except can be watched for changes in a way similar to a whole
    EntitySet. Useful for single-entity focused systems like player
  • Deprecated the EntitySet.applyChanges(Set) method as it’s not really
    possible to accurately return the changes that caused the set
    to be in its new state… especially not without a proper ordering.
    The network code that relies on this method has been reworked to
    do it more correctly.
  • DefaultEntityData.getEntities() now delegates loading of the entities
    to the set instead of hand-rolling it. (The DefaultEntitySet was
    already capable of loading its own data.)
  • DefaultEntitySet’s Transaction.completeEntity() method was moved to
    the outer class so that subclasses can override how incomplete entities
    are resolved by the set.

Full Zay-ES-Net changelog:

  • Upgraded the project to be JDK 1.7 and source 1.7 based.
  • Added support for a TransientComponent tagging interface
    that can be used to avoid sending certain component types over the
    wire. (They go over as null.) Note: the classes themselves still
    need to be registered with the Serializer so that the types can be
    sent. This is a compromise over a more invasive and ultimately less
    flexible transient design. (For example: this still lets you grab
    entities with a transient component for selection purposes, it just won’t
    have a value.)
  • Added support for the new WatchedEntity feature of EntityData. This can
    be a more efficient way of tracking one entity versus constantly polling
    using getComponent().
  • Added EntityDataHostedService and EntityDataClientService implementations
    to take advantage of JME 3.1’s new service model.
  • Server-side entity data services modified to require ObservableEntityData
  • Completely reworked how entity updates are sent to clients. The
    HostedEntityData.sendUpdates() method is entirely new and based on a new
    approach. In short: client interest is tracked in a mark-and-sweep data
    structure and only relevant changes are sent after the data structures
    have been updated. This avoids sending out of order information as well
    as redundant or hidden information.
  • RemoteEntityData’s internal RemoteEntitySet now avoids resolving incomplete
    entities. In the latest code, if the entity is a member of the set then
    it would already have received all of the necessary data. A round trip
    to the server to grab data that definitely won’t be there is a wasteful
    op, now avoided.