g--o / jscf Goto Github PK

Physics engine, Rigidbody, Scene and Game aren't synced on tick_update vs. update methodology.
Delta time should be configurable at runtime and callbacks should have update vs tick_update.

Should be as follows:

• Update is roughly with periodic input/output (say music, rendering, keyboard updates, etc..)
• Tick Update is the logic update, roughly with the different managers (physics, gui, etc..), components, entities etc. It is called after their logic is done.
• Pre-Tick Update: Optional but can be really effective - a user tick that occures before the engine's tick.

These should allow customizability again, as manual update/render should be non-relevant as JSCF becomes an engine rather than just a library, as well as it's editor, which perhaps might be usable for meta-editing.

Documentation is lacking to say the least. We need to move from looking at source code to a page or two of API and explainations.

Making an auto fit for entity's dimentions via container component.
Simply set dimentions of fixed name background graphic renderer of the default container to the dimentions of the entity (automatically returns the largest/encapsulating dimentions).

Relevant source: gui.js

To make ui as simplistic and performant as possible we'll change the default theme to a flat one

Adding an existing web code editor to be combined with the editor (essentially meta-program).
Will allow to edit the game scripts and save them to disk. Will update engine as well.

Right now considering:

• ace-editor (tern plugin?)
• codeMirror
• Codiad

Note: Should work client-side only, AND work offline (beware of chrome cross origin stuff).

We need to consider wether or not to use existing code for layout management and either way - getting it up and running already because as of now all elements are centered and any repositioning is done manually.

Relevant files: gui.js mostly.

Right now even after deleting the owning entity, a textbox will still be invisibly active. This has to do with cleaning up after using CanvasInput textbox.

Probably we need to call Textbox.Destroy() in an elegant way.

Implement friction in the physics engine.
Relevant source files: physics.js, rigidbody.js

Rename Entity -> GameObject
Rename PhysicsEngine -> JSCFPhysics and allow physics engine selection

Basically using a paradigm of inheritance via:

function child_ctor(...) {
    parent_constructor.call(this, ...);

    // actual initiator
    this.init = function() { ... };

    //...

    this.init();
}

The problems considering this option are:

• Breaks the getComponent related methods somehow
• Different sprites want to override update/render while retaining parent's update/render as seperate method.
• For point2d: inherits methods that don't really apply to points as a concept like dot product

nope

We need to integrate JSCFEditor from external repo.
We can might want to use git-submodule

#11

assets viewer, including sprites.
drag 'n drop (external lib allowed)

simple and easy.

Visual controls of assets.

• Drag n drop / move tool to move entities and sprites.
• Resize tool for entities and sprites.
• Rotate tool for entities and sprites.

We want an inspection panel that will be updated with selected entity/component/object.
This is a huge step to making the engine more comfortable.
We can use the rectangle editor component for selection. (might want to add treeview later)

For now, we need help planning this out, and later on we'll make an implementation issue.

A resolve method that is type aware of other collider, and invokes the resolver.resolve if compatible.
Files: Components/Collider.js

moved to discussions.

To improve performance we need to use better scene management techniques like spacial trees.
A simple suggestion would be having a QuadTree to speed things up.
Implementing it without breaking other modules would be a great achievement.

Relevant files: scene.js, sceneManager.js and maybe entity.js.
Good luck!

A decision has to be made: Are making Transform a component as well? Or do we keep it a property of Entity?

Let's discuss!

Fixing stop() when using dynamic update() + render().
Need to set flag to call ClearTimeout().

Right now we've got linear momentum worked out but we're missing angular momentum conservation.

Relevant files: physics.js, rigidbody.js, components/collider.js, aabb.js

Seems like code conventions aren't as strict as they should
Differentiate member naming vs. function naming to solve the issue

Right now it's a property, but we'll want it to be a component.
This will create dependency between components but entity should be free of properties that aren't part of it's definition.

createEntity() will not add transform.
createGameObject() will.

Notes on the decision:

While a lot of engines might force you to keep the transform component, I suggest entity to be an abstract thing, that can exist without any definite location.

Since the core principal of the engine to begin with was extendibility - custom types and scripts can be made only if the entity is abstract as to allow to override update & render, but still provides hirarchy.

When the javascript inheritence concesus will arrive (issue #8 ) we might have actual Game Object that inherits from the abstract entity.

We need to add rectangle editor removal from all entities on toggle