ellzord / jalse Goto Github PK

Make thread limit shared across entities not all jobs so X busy entities gets Y% of the threads to avoid long tasks holding up the total threads for every entity. Entities with no children and have no actions run that tick should be allocated no threads.

A remote JALSE server that allows instances of the model to be manipulated via REST and WebSockets (JSON based).

REST would be used to pull down detailed information (sync state, web statistics and specific entity details).

WebSockets would be used to stream attribute changes and when entities are created and killed (after sync).

NOTE: there is a need for user/client authentication or state the model is globally exposed and mutable.

• EntityContainer.export(UUID)
• EntityContainer.import(Entity)
• EntityFactory.export(UUID, EntityContainer)
• EntityFactory.import(Entity, EntityContainer)

Simple SQL for JALSE.

Build remote client/server JALSE. EntityFactory and ActionEngine can be implemented to achieve this.

• RMI implementation
• JMS implementation
• Socket implementation

Lag should be taken into account (estimation of attribute changes and dead reckoning). There should be visibility code for attributes (broadcast policy).

Maybe one project per implementation.

Must have code examples.

Add attributeReplaced(old, new) to AttributeListener instead of a remove then immediate add trigger.

Architecture diagrams and flow diagrams to describe normal JALSE usage.

• EntityType inheritence diagram for examples.
• Data flow for examples.
• Class/package diagram for JALSE landing README.md

Support:

• Default methods!
• Get/Set Attribute (orNull)
• Get/Set Attribute
• StreamEntitiesOfType
• StreamEntitiesAsType ?
• getEntitiesOfType
• getEntitiesAsType
• getEntityAsType ?
• killChildren ?
• newEntityOfType
• newEntityAsType ?

Will need an annotation most likely.

Currently classes are only linked once each file.

JALSE -> Messenger -> Message [text]

Generic arrays and full test.

Creation of neighbour tag to locate cluster "around" clusters.

Creation of a default attribute BehaviourTree or StateMachine.

JALSE needs some persistence API for saving Entities and re-importing them. This should be done using the generic entity and its named attribute key-value pairs and the types it is marked as (not using the EntityType system).

Can use @DontPersist annotation on Entity type to override default serialization.

May be useful for #50 when passing around data it needs to be transformed.

• jar
• docs
• maven repo
• ant builds?

• EntityContainer.hasListener(EntityListener)
• AttributeContainer.hasListeners(String, AttributeType)
• AttributeContainer.hasListeners(NamedAttributeType)
• AttributeContainer.hasListener(String, AttributeType, AttributeListener)
• AttributeContainer.hasListener(NamedAttributeType, AttributeListener)

Create a github readme.md for JALSE.

Aline JALSE system to how it deals with error handling. ListenerSet, ActionChain and Engine should handle a singular error in the same way (Logger.warning maybe).

Create Taggable.toString(Taggable) and use this within the default Entity implementation

scorpion or bunny

Plugin system is a directory/zip/jar with the right package JSON.

Needs defined plugin format:

• Files to process
• Resources to bind

There should be a number of interfaces that can be implemented in either Java or JS (using nashorn). I primarily see this being used to script entity behaviour and edit assets without build (as they are JS files).

Create new AttributeType system to allow more complex typing.
Meaning - Collection should be different from Collection or Collection<Collection>

It should still be easy to use and there should be the ability to have multiple of a supplied type.

{ "scary" : Boolean } different from { "hungry" : Boolean } - This should be allowed.

Use Supplier and Supplier in JALSE and Cluster constructors to allow future expansion of the framework.

Create JUnit tests for default implementations and common flows.

Ideally there should be a set of tests that:

• Passes for yielding expected behaviour for valid arguments/operation.
• Passes for failing expectedly for invalid arguments/operation.

This will help keep positive and negative behaviour of the system well defined.

NOTE: These tests can be used by bespoke implementations of core components to test they work as expected!

Context c = engine.createContext();
c.setX(x);
c.schedule();
c.await();

• AsyncActionEngine - ForkJoinPool
• SynchronousActionEngine - ExecutorCompletionService executes in order
• ManualActionEngine - Executes on resume and immediately goes back to paused
• ActionContext.getDelta()

Could use a commonPool() implementation AsyncActionEngine.getCommonPoolEngine().

It probably needs some Fork and Join functionality for a context (ForkJoinContext.fork()).

See: ActionContext and MultiActionBuilder

Create tutorial where the steps are individual branches.

Creation of Quadtree attribute to sit on Cluster and update on agent attribute change. For easy collision detection. Should work on rotated agents.

Entity, ActionEngine, JALSE

Use new Entity and Action framework. Any images provided should be replaced with ones made by JALSE dev (using different coloured cube combinations if lazy). Examples updated to be visual where possible. Embedded applet?

Capacity to manually tick the engine when needed.

Should have AI and GUI. Needs README.MD.

Allow more than one return where clean and easy to see.

Test general usage of JALSE and core components.

Create a defined JS plugin (folder, info.json, various .js files) and execute the contents to load up a simulation.

Should amend so it contains all features, code snippets and how everything can be used as a single component.

Look into adapting JALSE formatter for eclipse to something closer to the Google style guide.

http://google-styleguide.googlecode.com/svn/trunk/javaguide.html

For easy identification when an agent may have no attributes.

A Roomba-like example that bounces off walls cleaning the floor. Should be visual and have backing README.md!

EntitySet takes in no engine so cannot run actions upon entities.

This library should provide the building blocks for creating a number of different simulations every easily. It should consist of groups of:

• Generic entity types (Animal, FlyingAnimal, etc)
• Task specific attributes (Quadtree, state machine, behaviour tree, etc)
• Listeners that populate attributes or run actions (hunger over time, lonliness, etc)
• Task specific actions (Move randomly until condition, follow X entity, etc)
• Utilities for creating, killing and processing the above types and attributes

It should cover areas like movement, objects (tree, cow, pig, etc), common operations (may need some research). Each of these areas should be documented in the README.md!

Example:

NPCBuilder.newBuilder().setParent(jalse).setPosition(x, y).setBlocking().setSize(50, 50).build();

No doubt quicker than using the type resolvers now the options have increased. Some sort of cache on EntityTypeHandler. Would like to be able to check multiples get/sets across entire tree.

Create example JALSE project to go with release. Maybe cows in a field.

Create JALSE instance without threads for a model only version. Maybe separate engine and model so the model on its own.

Typing advantages in complex simulations (Zoo or city).

For easy filtering use type. Streams for ready only behaviour.

Add package-info.java for each package summarising the functional contents.

jalse.org / jalse.com / jalse.net / jalse.co.uk