Using Dynamic

The improbable.worker.Dynamic class provides a way to execute arbitrary component-related logic in a type-safe way even when the component is not known statically. Dynamic.forComponent will invoke a custom handler for a component with a specific ID; Dynamic.forEachComponent will invoke a custom handler for every known component. These handlers have enough information to register Dispatcher callbacks, manipulate component updates and data, and so on.

This allows, for example, a custom View with any desired semantics to be implemented from scratch.

To do this, you would extend Dispatcher, adding data structures such as Map<EntityId, Entity> entities and Map<EntityId, HashSet<Integer>> authority below to track the entities in the worker’s view.

You would then also need to define a class which implements the Dynamic.Handler interface, providing type-safe behaviour in the accept(final Metaclass metaclass) method. Dynamic allows you to implement, for example, a custom View with any desired semantics from scratch.

package docs;

import improbable.worker.*;

public class CustomView extends Dispatcher {
    // Maintain a Map of the entities in this worker's view.
    public final java.util.Map<EntityId, Entity> entities = new java.util.LinkedHashMap<>();
    public final java.util.Map<EntityId, java.util.Map<Integer, Authority>> authority = new java.util.LinkedHashMap<>();

    public <Metaclass extends ComponentMetaclass>
    Authority getAuthority(Metaclass metaclass, EntityId entityId) {
        java.util.Map<Integer, Authority> componentAuthorities = authority.get(entityId);
        if (componentAuthorities == null) {
            return Authority.NOT_AUTHORITATIVE;
        }

        Authority authority = componentAuthorities.get(metaclass.getComponentId());
        return authority != null ? authority : Authority.NOT_AUTHORITATIVE;
    }

    // An implementation of Dynamic.Handler to provide type-safe behaviour for
    // the components.
    private class TrackComponent implements Dynamic.Handler {
        // The Accept method defines the type-safe behaviour.
        // Here, we are specifying callbacks to update our view's state
        // when components are added or removed, when the worker's authority changes,
        // or when we receive component updates.
        @Override
        public <Metaclass extends ComponentMetaclass<Data, Update>, Data, Update>
        void accept(final Metaclass metaclass) {
            onAddComponent(metaclass, op -> {
                Entity entity = entities.get(op.entityId);
                if (entity != null) {
                    entity.add(metaclass, op.data);
                }
                java.util.Map<Integer, Authority> entityAuthority = authority.get(op.entityId);
                if (entityAuthority != null) {
                    entityAuthority.put(metaclass.getComponentId(), Authority.NOT_AUTHORITATIVE);
                }
            });

            onRemoveComponent(metaclass, op -> {
                Entity entity = entities.get(op.entityId);
                if (entity != null) {
                    entity.remove(metaclass);
                }
                java.util.Map<Integer, Authority> entityAuthority = authority.get(op.entityId);
                if (entityAuthority != null) {
                    entityAuthority.remove(metaclass.getComponentId());
                }
            });

            onAuthorityChange(metaclass, op -> {
                java.util.Map<Integer, Authority> entityAuthority = authority.get(op.entityId);
                if (entityAuthority != null) {
                    entityAuthority.put(metaclass.getComponentId(), op.authority);
                }
            });

            onComponentUpdate(metaclass, op -> {
                Entity entity = entities.get(op.entityId);
                if (entity != null) {
                    entity.update(metaclass, op.update);
                }
            });
        }
    }

    public CustomView() {
        // Update the entities Map to reflect when entities are added or removed.
        onAddEntity(op -> {
            entities.put(op.entityId, new Entity());
            authority.put(op.entityId, new java.util.HashMap<>());
        });

        onRemoveEntity(op -> {
            entities.remove(op.entityId);
            authority.remove(op.entityId);
        });

        // Invoke the TrackComponent handler for every component.
        Dynamic.forEachComponent(new TrackComponent());
    }
}

Search results