jenniferemshepherd / dawn Goto Github PK

This may be from a cell factory or the object itself. Probably worth discussing 🐙

project logo for favicon

have a button to:

• switch wire frame on/off
• start, stop and pause

Currently it returns a number. Returning a vector could make the animator simpler and make future modifications easier - what do people think?

Nobody assigned initially as we'll address this tomorrow.

This could be the simplest version of 'inheritance' from parent cells.

We could spawn at the average of the two parent cells' locations.

This would help prevent the warnings in the console, and would result in more successful reproductions.

We could pass more of our objects to the constructors of other modules.

For example, in our dawn.js, we are doing this:

var decoratedEngine = new DecoratedEngine();
var eventController = new EventController(); 
var cellRepository = new CellRepository();
var animator = new Animator();
eventController.register(decoratedEngine.matterEngine(), 'afterUpdate', animator, cellRepository);

but it might be better if we could do this instead:

var decoratedEngine = new DecoratedEngine();
var eventController = new EventController(decoratedEngine.matterEngine()); 
var cellRepository = new CellRepository();
var animator = new Animator(cellRepository);
eventController.register('afterUpdate', animator);

In other words:

• the instance of Animator could have a cellRepository.
• the instance of EventController could have an engine.

That way we don't have to pass these objects in every time we call methods. See how the eventController.register method now only needs two arguments - an event string and a listener/handler/operator. Instead of also passing in an engine every time we register a listener (I've started calling them listeners now I'm afraid). A similar simplification is achieved by having the animator have its own cellRepository, instead of passing that as an argument.

A similar pattern could be followed for the cellFactory stuff. I.e. cellFactory could have a cellRepository. This would have the same benefit if we use our eventController to register a listener for collisions.

I think we we were concerned that we'd have to update each object's cellRepository if we do things this way (I know I was). But actually, this is why we pass objects in, instead of static arrays - so that these objects are updated across the entire app.

currently it looks overcrowded on a normal laptop screen. I remember we mentioned that this was the size we were making the app for. Might be worth doing the above! Let me know if ok with yall 🎆

We need a class that creates cells, with bodies and whatever other properties they need (e.g. gaits, etc).

• basic structure
• allocation sections
• slides
• demo video
• practice

Many of our methods do not have unit tests.

Currently the background is of a low quality. Thinking about making a huge one on a bigger screen (possibly on the screen in one of the rooms at makers).

we need somewhere where cells are stored so we can iterate through an array of cell objects in simulation.listenForUpdate rather than just cell bodies

how do we deal with time and growth (and potentially death)

We need a class that registers listeners.

In the short term, this could be used to register a listener so that after each update of the engine, the cells have forces applied to them.

In the future, this could be used to register a listener so that after each collision between cells, a new cell is created.

• canvas border
• background
• title

Phase 3: use the eventController to register a listener for two cells colliding, calling action on the cellFactory when the event is heard.

from now on we should use dawn.js for spiking/feature testing/etc.

this will ensure a consistent environment is used for manual feature testing.

from spiked wiki doc that ed and roland wrote yesterday

We could start this by just console logging the two parent cells when a collision happens.

We need a class that applies forces to all of the cells in the cell repository

Can one of the cells be named, Potent Billy Bookcase?

Really think this would add to the project, happy to discuss!

Possible new CellReaper class

removes cells from both Cell Repo and world when cell age reaches predefined value

I noticed we are executing the following line in our dawn.js:

decoratedRenderer.createRender(decoratedEngine.matterEngine());

Perhaps this is something we should do in the Simulation.setup() method? What do people think?

get cells by body id

• choose dependencies and install
• update README.md to document how to do so

Maybe some buttons would be nice to have for the user to have basic interactions after the simulation is running?

For example, they could be something like:

• Start
• Pause
• Stop
• Restart

What does everyone think?

triangle circle and rectangle?

Currently we can only add one cell to the world so here r C0D3 GURLZ sorting it out

https://github.com/jenniferemshepherd/dawn/wiki/Listeners