Develop

.drone.yml

@@ -0,0 +1,10 @@
+pipeline:
+  build:
+    image: alpine
+    pull: true
+    commands:
+      - curl -s "https://get.sdkman.io" | bash 
+      - source "$HOME/.sdkman/bin/sdkman-init.sh"
+      - sdk env install
+      - mvn clean install
+

.sdkmanrc

@@ -1,4 +1,5 @@
 # Enable auto-env through the sdkman_auto_env config
 # Add key=value pairs of SDKs to use below
 java=19.0.2-zulu
-maven=3.8.7
+maven=3.9.0
+

README.md

@@ -1,6 +1,8 @@
 # README
 
-[![Drone Build Status](http://nextserver02-1/api/badges/SnapGames/minimal/status.svg?ref=refs/heads/master)](http://nextserver02-1/SnapGames/minimal) | [![GitHub Build Status](https://github.com/SnapGames/minimal/actions/workflows/maven.yml/badge.svg?branch=master)](https://github.com/SnapGames/minimal/actions/workflows/maven.yml)
+[![Drone Build Status](http://nextserver02/api/badges/SnapGames/minimal/status.svg?ref=refs/heads/master)](http://nextserver02/SnapGames/minimal) 
+| [![GitHub Build Status](https://github.com/SnapGames/minimal/actions/workflows/maven.yml/badge.svg?branch=master)](https://github.com/SnapGames/minimal/actions/workflows/maven.yml) 
+| [![Reports Cucumber Collection](https://messages.cucumber.io/api/report-collections/3cc52f6b-8997-4a02-9866-aeed7c91f215/badge)](https://reports.cucumber.io/report-collections/3cc52f6b-8997-4a02-9866-aeed7c91f215)
 
 This is a small Minimalistic Game project , based on a master Game Java class, with some subclasses to let keep the code
 ass short as possible.
@@ -46,7 +48,7 @@ $ java -jar target/game-0.0.1-SNAPSHOT-shaded.jar
 
 After starting the latest jar file, the following picture may appear:
 
-![Latest enhanced minimal game framework](docs/docs/illustrations/figure-screenshot-0.0.3.png "Latest enhanced minimal game framework")
+![Latest enhanced minimal game framework](docs/docs/illustrations/figure-new-balls-images.png "Latest enhanced minimal game framework")
 
 _figure 1 - Latest enhanced minimal game framework_
 

docs/docs/chapter-01-the_game_class.md

@@ -112,9 +112,9 @@ public class Game {
 }
 ```
 
-So, what do you think of my (too?) basic class ? nothing fancy, nothing "bling bling". only useful and mandatory.
+So, what do you think of my (too?) basic class ? nothing fancy, nothing fancy. only useful and mandatory.
 
-So yes, as you maybe now, the gameloop is the heart of any old school game. and even some Big game engine keep running
+So yes, as you may be now, the game loop is the heart of any old school game. and even some Big game engine keep running
 such old loop.
 Let's dive into some details.
 
@@ -159,27 +159,30 @@ public class Game {
         } catch (InterruptedException ie) {
             System.err.println("error while trying to wait for sometime");
         }
-    }}
-    //...
+    }
+}
+//...
 }
 ```
 
-So to maintain a sustainable frequency for that loop, I use the default current traditional FPS: 60 frames per second.
+So to maintain a sustainable frequency for that loop, I use the default current frame-per-second ratio: 60 frames per
+second. here we will get it from the method `getTargetFps()`.
 
 So starting with that , defining the waiting time is a simple calculus.
 
 ```java
-int timeFrame=1000/60;
-        int wait=timeFrame-elapsed;
+
+int timeFrame=1000/getTargetFps();
+int wait=(int)(elapsed<timeFrame ?timeFrame-elapsed:1);;
 ```
 
 and the rest of the loop process is simple calls:
 
 ```java
 elapsed=currentTime-previousTime;
-        input();
-        update(elapsed);
-        render();
+input();
+update(elapsed);
+render();
 ```
 
 - input() will manage all the player's device input like keyboard, mouse or joystick,
@@ -203,93 +206,102 @@ an overview of the solution:
 
 _figure 6 - An overview of my implementation_
 
-## The Game interface
+## The GameLoop interface
 
-The `Game` interface provides a standard contract to any application which want to be a game.
+The `GameLoop` interface provides a standard contract to delegate the loop management to a specialized class
+implementation.
 
-Defining a standard lifecycle to a game with:
+We will be able to create a Fixed time frame loop, where graphics are rendered in priority , or a Fixed time update loop
+where physic and gameplay are prioritized first.
 
-1. `initialize()`,
-2. `create()`,
-3. and then `loop()` on the created resources,
-4. and finally `dispose()` them.
+Defining a standard loop to a game with:
+
+1. `input()`,
+2. `update()`,
+3. and then `draw()` on the screen.
+
+This is exactly what our loop implementation will have to provide.
 
 ```java
 public interface Game {
-    void initialize(String[] args);
 
-    void create(Game g);
+    void loop(Map<String, Object> context);
 
-    void input(Game g);
+    boolean isExit();
 
-    void update(Game g, double elapsed);
+    boolean isTestMode();
 
-    void render(Game g, int fps);
+}
+```
 
-    default void loop() {
-    }
+Let's have a try with a FixedFrameGameLoop first, where the Game loop update and render everything even if it takes too
+long, freezing the game play.
 
-    default void run(String[] args) {
+### The Fixed Frame Loop
 
-        initialize(args);
-        loop();
-        dispose();
-    }
+The default loop implementation would be a simple time frame based one. Trying to stick as far as possible to the frame
+per second value set. In our sample code, we use a 1000.0/60.0 frame time corresponding to 60 frames per second.
 
-    void dispose();
+First things first, just initialize our GameLoop for the game :
 
-    boolean isPaused();
+```java
+public interface FixedFrameGameLoop {
 
-    boolean isExitRequested();
+    private final Game game;
+    double FPS = 60.0;
+    double fpsDelay = 1000000.0 / 60.0;
 
+    public FixedFrameGameLoop(Game game) {
+        this.game = game;
+    }
+    //...
 }
 ```
 
-Inside a loop, the 3 historical game operations are prformed:
-
-- input(),
-- update(),
-- render().
-
-but let's dive in the loop in the default loop implementation.
-
-### The loop
-
-The default loop implementation would be a simple time frame based one. Trying to stick as far as poosible to the frame
-per second value set. In our sample code, we use a 1000.0/60.0 frame time corresponding to 60 frames per second.
-
-And during a loop, we call the 3 parts of the loop : manage `input()`, `update()` all game objects and `render()` all of
-those.
-And if the loop is during less than a frame time, add a litle wait.
+And if the loop is during less than a frame time, add a little wait.
 
 ```java
-public interface Game {
+public interface FixedFrameGameLoop {
     //...
     default void loop() {
-        int frames = 0;
-        int fps = getTargetFps();
-        double internalTime = 0;
-        double previousTime = System.currentTimeMillis();
-        double currentTime = System.currentTimeMillis();
-        double elapsed = currentTime - previousTime;
-        create(this);
-        while (!isExitRequested()) {
-            currentTime = System.currentTimeMillis();
-            input(this);
-            elapsed = currentTime - previousTime;
-            if (!isPaused()) {
-                update(this, elapsed);
+        double start = 0;
+        double end = 0;
+        double dt = 0;
+        // FPS measure
+        long frames = 0;
+        long realFPS = 0;
+
+        long updates = 0;
+        long realUPS = 0;
+        long timeFrame = 0;
+        long loopCounter = 0;
+        int maxLoopCounter = (int) game.getConfiguration().get(ConfigAttribute.EXIT_TEST_COUNT_FRAME);
+        Map<String, Object> loopData = new HashMap<>();
+        while (!(isExit() || isTestMode() || isMaxLoopCounterReached(loopCounter, maxLoopCounter))) {
+            start = System.nanoTime() / 1000000.0;
+            loopCounter++;
+            game.input();
+            if (!game.isUpdatePause()) {
+                game.update(dt * .04);
+                updates += 1;
             }
-            render(this, fps);
+
             frames += 1;
-            internalTime += elapsed;
-            if (internalTime > 1000.0) {
-                fps = frames;
+            timeFrame += dt;
+            if (timeFrame > 1000) {
+                realFPS = frames;
                 frames = 0;
-                internalTime = 0;
+                realUPS = updates;
+                updates = 0;
+                timeFrame = 0;
             }
-            waitUntilNextFrame(elapsed);
-            previousTime = currentTime;
+            prepareData(realFPS, realUPS, loopCounter, loopData);
+
+            game.draw(loopData);
+            waitUntilStepEnd(dt);
+
+            end = System.nanoTime() / 1000000.0;
+            dt = end - start;
         }
     }
 
@@ -302,12 +314,39 @@ public interface Game {
             System.err.println("error while trying to wait for sometime");
         }
     }
+
+    private void prepareData(long realFPS, long realUPS, long loopCounter, Map<String, Object> loopData) {
+        loopData.put("cnt", loopCounter);
+        loopData.put("fps", realFPS);
+        loopData.put("ups", realUPS);
+        loopData.put("pause", game.isUpdatePause() ? "ON" : "OFF");
+        loopData.put("obj", game.getSceneManager().getActiveScene().getEntities().size());
+        loopData.put("scn", game.getSceneManager().getActiveScene().getName());
+        loopData.put("dbg", game.getDebug());
+    }
+    //...
+}
+```
+
+And we need to link the exit and pause mode to the game with these 2 methods:
+
+```java
+public class FixedFrameGameLoop {
     //...
+    @Override
+    public boolean isTestMode() {
+        return game.isTestMode();
+    }
+
+    @Override
+    public boolean isExit() {
+        return game.isExitRequested();
+    }
 }
 ```
 
-You can notice that we also compute the real frame rate (fps) with the `previousTime` and `currentTime` variables, and
-maintain an internal `frames` counter.
+You can notice that we also compute the real frame rate (`fps`) with the `end` and `start` variables, and
+maintain an internal `frames` counter. An `ups` counter is also maintained.
 
 ## Conclusion