han-yaeger / yaeger Goto Github PK

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

See the RectangleEntity for reference.

For now, this one will not be implemented.

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.

All javadoc should be in Dutch

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.

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

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.

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

https://github.com/collinbachi/fxsprite

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

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)

https://checkerframework.org/

See the RectangleEntity for reference

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).

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

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.

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

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

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.

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

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.

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

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

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

This will make everything much better testable

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

Add Unittests for the missing methods.

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

See the RectangleEntity for reference

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.

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.

Side doesn't work correctly yet.

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

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

Create a timer that will only call its handler once.

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

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