msecret/aronnax-deprecated

A JavaScript game engine that isn't necessarily more special then the rest.

aronnax-deprecated's Issues

Change accessor test so it uses test values that use better language

Rather the a test value like 'itemA' do a value like 'testItemA' so you know what the test data is.

Setup google closure dependency writer

Create a system possibly a class for having unique ids on all main game objects

Objects such as entities and maybe even particles should all be ID'd. This could maybe come in the form of a mixin class or an inherited class. There will also need to be a static property or class to correctly increment the id numbers.

This could be useful in hashing and linked list data structures. The linked list data structure could keep a hash table of the objects and ids for quick and easier lookup. The linked list class should still be available to take vanilla objects, so it should only be extended for ID'd objects.

Update code so it runs in strict mode

Create init function on Pool or Pooled to start out pools

The pools could be set up at the beginning of game load.

Setup closure compiler to generate source map

Create a linked list class

Incorperate properties into Object.create function in base and do not extend anymore

Attempt to get jasmine runner to use the src files rather then the built dist file

Add test coverage to grunt

Setup jasmine testing with phantomjs

Have it so classId is used by the store rather then id

Merge Pool and Pooled modules into one file

Put a length property on the activePool

Have more then one grunt task for building

One grunt task should only build essential things

Another grunt task should do extra things such as building docs, etc.

Setup global config object to provide configuration for all classes

See src/logger line 108 for instance where global config is needed

Make sure LinkedList class is 100% unit tested

Functions still missing:

• toFullString
• toFullArray

Setup google closure building, with the closure tools grunt task

This may include changing the directory structure

http://www.bdoran.co.uk/2011/11/28/introduction-to-googles-closure-tools/

Create the utility class, with array remove and add methods

Don't use real console in logger test

The logger test is using the real window.console and actually outputting. Using mocks to changes this so it doesn't actually log would be much better.

Setup grunt closure tools task so when on debug, it will write a reports file

Improve performance of lists by using internal array

Modify the Pooling so objects of a certain class returned have the correct prototype set up

Currently, when an object is returned from a pool, it's an empty object and has no prototype. It should have it's prototype set to the base classes prototype, so that only the instance specific properties need to be copied over. This will help with performance. The main properties of the base class should not be extended by copying though they should be on the prototype.

Add docs creation to grunt file

This will be done with jsdoc3:
https://npmjs.org/package/grunt-jsdoc-plugin

Create a hashtable class

Create a grunt task to copy the index file to php folder

Setup benchmarking framework to test engine performance

This will most likely be done with benchmarkjs: http://benchmarkjs.com/

There is a grunt task for benchmarkjs but its only supporting grunt 0.4.0. It still could possibly be modified to work for grunt 0.3 but might require more work then just writing a new task.
https://npmjs.org/package/grunt-benchmark

Add array insert and remove to utility class

Implement Object IDs for the Pooled

Allow Pooled class to get it's own pool object

This will allow some of the static methods that are called on the Pool class to be called on the Pooled prototyped object.

Figure out new hashing for the Pool

Turn hashtable into a bower component

Add a getPool method to the object pooled objects

This makes it useful for testing and other functionality.

Make methods in linked list return the node

Setup minification to use closure compiler

Create the release function on the Pooled object

Setup a JS framework

Google Closure:
There are some complications with setting up the correct folder directories: Google closure wants files to be saved all the the same directory as closure. I want closure to be in a separate lib directory. This article explains a solution to this:
http://www.bdoran.co.uk/2011/11/28/introduction-to-googles-closure-tools/

The closure builder and dependency management tools should be used. Using the grunt closure tools plugin is probably the best way to go. This will be switched out from current closure task:
https://npmjs.org/package/grunt-closure-tools

Set up deps require locations so it's read as a separate json config file

The deps range of modules are all dependencies that are being injected into the system at various points. Currently they are being configured on an individual basis in the requireJS config for only one environment. Modify this so that the configuration for them is in a separate json file based on environment so they can be switched around with relative ease.

Ensure ordered list search and find work for less the 3 items

Have length on LinkedList be a property not function

Keep an internal length property for the Linked list. All add and remove functions will manipulate this.

Create a wrapper class for handling errors

It could either hook into javascript throws, or it could be called directly and it would pick how errors are handled. Could have multiple options for how much it reports.

Make tests check strange params, to see if theres errors

Write one unit test to make sure jasmine tests are working

Make a util class for utils not in underscore

Use util cleaner in Pool class

Create a Pool class to handle pools

Move the log writer deps to the log

Currently the log writer dependency is set on the static logger class, rather then the individual log objects which actually use the logWriter.

Create the Pooled class to augment objects

The interface will be something like this:
NewObject.make(params);
Array.make(params);

So there will a new function that gets added to any constructor that will receive the new functionality. It would be nice if this function augmented the base object so this make function would not need to be created any time it inherits from Pooled.

Another decision is if the object should use mixins or other inheritance.

Add an object clearer in the util class

Watch for changes in html files and automatically move to php/