bitbrain / chronos Goto Github PK

Create a class which provides the class of the inner type of a generic. For instance:

ReflectionTemplate<String> string = new ReflectionTemplate<String>();
// Should output: java.lang.String
System.out.println(string.getInnerClass().getName());

When a resource depends on another, the other one should be loaded first to avoid missing resources. Dependencies should be calculated before loading any resource and the loading order should be changed. This must affect on deferred resources as well.

When creating a new BasicEntity instance, it should be possible to give information about position and size. It has to look something like this:

public BasicEntity(float x, float y, float width, float height) {
/* ... */
}
By doing so it should be more easy to extend the class.

Make resource framework more extendable and implement XML independent loading.

Create a data provider which provides data for game updating via FTP(S).

Create a JSON data source which scans a resource file and translates it into resource definitions.

Write an listener interface and an observer, implement and write tests for it.

When using the resource manager scan the project for available loaders written by the user.

Create 3 dimensional vectors and add support for calculating positions, lengths and angles between different vectors.

Write a script component which is able to proceed python scripts.

Write a game updater which is able to update a game. It should be extendable, e.g. it should be able to update via FTP, FTPS, SVN or HTTP by injecting the functionality.
Also it should support listeners to abort the process or handling output.

A possible product would look like this:

DataProvider provider = new SVNProvider("path-to-repository", "username", "password");
GameUpdater updater = new BasicGameUpdater(provider);
updater.addListener(new GameUpdateListener() {

   @Override
   public void onStart(UpdateEvent event) {

   }

   @Override
   public void onProgress(UpdateEvent event) {

   }

   @Override
   public void onAbort(UpdateEvent event) {

   }

   @Override
   public void onSuccess(UpdateEvent event) {

   }
});

updater.execute();

Create an interface FamilyObject, which provides support for adding children and parents, implement it and test it.

Write a script implementation which invokes different scripts to an entity. Possible implementation:

ScriptFactory factory = new BasicScriptFactory();
Script pythonScript = factory.create("script.py");
Script luaScript = factory.create("script.lua");
Script jsScript = factory.create("script.js");

Entity entity = new Entity();
entity.addListener(pythonScript);
entity.addListener(luaScript);
entity.addListener(jsScript);

Scripts are listeners for entities so they can be easily added.

Create a script loader which is able to detect given script types and applies them to the resource manager like:

<resource type="script" id="script1">script.lua</resource>
<resource type="script" id="script2">script.js</resource>
<resource type="script" id="script3">script.py</resource>

Create a data provider which provides data for game updating via HTTP(S).

Implement resource loading of pre-defined resources.

Create interfaces and make the model framework extendable.

Write a singleton resource manager which provides resource loading. For example:

Resource<String> resource = ResourceManager.getInstance().getResource("my_id", String.class);

Therefore the manager needs to know which resources are supported.

Provide a data provider interface which can update a game:

public interface DataProvider {

   DataSource getMetaData();

   DataSource getChronosData();

   void download(String file) throws DownloadException;

}

Create a full documentation in github which explains the newest changes and contents.

Write a script component which is able to proceed LUA scripts.

Create a XML data source which scans a resource file and translates it into resource definitions.

Create a data provider which provides data for game updating via SVN.

Strings are too big when loading text resources from XML. They look something like this:

                                                          text                               

Scale the bounds of the children depending on the parent's scale factor.

Create an entity interface and test the implementation (BasicEntity)

Make an entity observable. It should be possible to add listeners to an entity like this:

Entity entity = new Entity();
entity.addListener(new EntityListener() {

   @Override
   public void onCreate(EntityChangedEvent) {

   }

   @Override
   public void onUpdate(EntityChangedEvent) {

   }
});

Write a script component which is able to proceed javascripts.

Create an interface Bounds, write an implementation and test it.

Create a XML scheme and DTD file for validation.

When scanning for annotations, a NullPointerException/ClassCastException will be thrown in ClassUtils.java

Create an interface Positionable, write an implementation and test it.

Rotate bounds around the parent's center position multiplied with the own rotation factor.

Create a data provider which provides data for game updating via Git.

Add functionality to stream from and into data sources.

Write an interface which represents a resource group. A resource group can be assigned to others.

Write an interface which defines how a resource should look like, implement it and test it.

Add support for a global and local coordinate system in the positionable and bounds implementation and test it.