For debugging it would be very convenient to make the Bounds of all Nodes visible.
This should be a debug setting, triggered by a a specific key-combination.

We might need a composite entity to support this.

Using the setSpeedTo and setDirectionTo separately (instead of setMotionTo) does not work, when speed is 0 when setDirectionTo is called.
This comes from the fact that both methods are implemented as transformations on a movement vector. If speed=0, the magnitude of the vector is still 0 and after transformation it remains 0 (see DefaultMotionApplier).

This could be solved by storing the speed and direction as instance variables and using those to ensure the correct vector is created.

• Add Unit tests to force out the bug.
• Resolve the bug

Because a (JavaFX) Scene only gets it height and width set when it is added to the Stage, getScene().getWidth() will return 0 while a YaegerScene is constructed. (for instance during the addEntity())

It should be possible to acquire the width and height before it is added to the Stage

For this there should be both a static and dynamic version.

The plugin for generating the javadoc throws an error. This should be fixed and deployed on GH-Pages

There is still some duplicated code in all children of a JavaFXEntity.

Maybe this can be resolved by using a generic type. This one needs some more thinking.

Each Game should be preceded by a Yaeger startup screen.

It should show both a Yaeger logo, and all key combinations that are available: (e.g. show the debugger, show Bounds of all nodes, etc)

The current collisionside detection will not be applicable to a rotated GameObject. It will be applicable to a tile, so when that is implemented, it should be moved to tilecollision.

Since the Module system from Java 9, the module should be used instead of the ClassLoader for acquiring resources.

This will probably only affect the interface ResourceConsumer.

https://dev.to/sualeh/how-to-sign-and-release-to-the-central-repository-with-github-actions-9k6

https://github.com/marketplace/actions/create-release

https://blog.soebes.de/blog/2016/08/08/maven-how-to-create-a-release/

https://www.phillip-kruger.com/post/continuous_integration_to_maven_central/

Jira Ticket: https://issues.sonatype.org/browse/OSSRH-57512

Add Unittests for the missing methods.

Maybe an approach such as "The Tour of Heroes" from Angular is the way to go. Create a game called "The Game of Heroes", that contains all features from Yaeger.

A tilemap should consist of enities, either static or dynamic. It's main focus must be an easy way to define its layout.

Side doesn't work correctly yet.

Might be usefull: https://github.com/uphy/javafx-console

https://github.com/collinbachi/fxsprite

Create a timer/spawner that can be started, stopped and paused.

It should be possible to support a more fine grained system for collision detection. An approach using collision points could suffice.

The use of Google Guice requires an jvm argument when running a Yaeger game. Therefore Guice should be replaced with a DI framework such as Dagger2, which will not pose this problem.

According to guice/1133 a fix is coming to no longer need the JVM arguments. In that case, this issue can be closed

All javadoc should be in Dutch

There are still some overloaded constructors missing. These should be added.

See the RectangleEntity for reference

https://checkerframework.org/

We currently only handle mousebutton events. We should add the required code the also handle mousemovement events.

This one probably needs some good usecases to know what to implement.

Possibly through http://www.dyn4j.org/

It should be possible the set the contrast or brightness of a scene. Combined with a timer, this could for instance be used to create a fade in/out effect.

See https://stackoverflow.com/questions/42774025/change-brightness-of-whole-scene?noredirect=1&lq=1 for info

This will make everything much better testable

Create a timer that will only call its handler once.

The game seems to use the width/height from the background image. The width/height set during initialization seem to be ignored.

Step to reproduce:

1. Create a game with one scene and a background image
2. Set the game-deminensions to a different value

Right now we just use a map. Maybe this should be a subtype of linkedlist that handles all the setups and teardowns

Because GameObjects are fully constructed when a Scene is started, some Dependencies will not be available when the constructor of the GameObject is called.

In such cases, we should throw a Exception to make this explicit.

Objects where this happens:

• SceneChild

It should be possible to create a bounding box that has a close fit than only the trivial rectangular one.

At initialization time we should analyse the sprite image and create a bounding box that only covers the non-transparent parts.

For ease of development the games used to implement Yaeger are in the same repository and Maven project. They should be moved to their own Maven Project and Repository.

This change will expose which packages from Yaeger should be exported from the Module.

See the RectangleEntity for reference.

For now, this one will not be implemented.

An Entity should be able to calculate its distance and angle to a given (List of) Entity.

Currently a method called attachMouseListeners() in EntityCollection is responsible for calling the various attach() methods. If these methods were annotated we could use reflection to identify and invoke them (just like the @UpdateProvider).

See the RectangleEntity for reference