Semester 4 Week 7

[LPkkjHD]

Hello and welcome to this weeks development progress blog for our little game Underwatch 🎮

Code Refactoring

This week we decided to do a humongous refactoring of our code base, which happened to be long overdue and also this weeks task. Taking a look at the core problem we had to work around all this time:

In order for the path finding to work we rasterize the world into a 32x32 Grid and represent each of the cells as a single point in an array only containing information about whether or not this cell shall be considered walkable or not.

We had to use arcane combinations of -1 and +1 to add connections to the neighboring cells.

                     // check if wall is above and below
                     if (getNode(x, y + 1).type == FlatTiledNode.TILE_WALL
                             && getNode(x, y - 1).type == FlatTiledNode.TILE_WALL) {
-                        // W
-                        addConnection(n, -1, 0);
-                        // E
-                        addConnection(n, 1, 0);
+                        addConnection(n, Direction.W, Direction.E);
                         continue;
                     }
                     // check if wall is left and right
                     if (getNode(x + 1, y).type == FlatTiledNode.TILE_WALL
                             && getNode(x - 1, y).type == FlatTiledNode.TILE_WALL) {
-                        // S
-                        addConnection(n, 0, -1);
-                        // N
-                        addConnection(n, 0, 1);
+                        addConnection(n, Direction.N, Direction.S);
                         continue;
                     }
                     // check if wall is above
                     if (getNode(x, y + 1).type == FlatTiledNode.TILE_WALL) {
-                        // W
-                        addConnection(n, -1, 0);
-                        // S
-                        addConnection(n, 0, -1);
-                        // E
-                        addConnection(n, 1, 0);
-                        // N
-                        addConnection(n, 0, 1);
-                        // SE
-                        addConnection(n, 1, -1);
-                        // SW
-                        addConnection(n, -1, -1);
+                        addConnection(n, Direction.N, Direction.E, Direction.S, Direction.W, Direction.SE, Direction.SW);
                         continue;
                     }
         }
     }
     private void addConnection(FlatTiledNode n, int xOffset, int yOffset) {
         FlatTiledNode target = getNode(n.x + xOffset, n.y + yOffset);
-        if (target.type != FlatTiledNode.TILE_WALL) n.getConnections().add(new FlatTiledConnection(this, n, target));
+        if (target.type != FlatTiledNode.TILE_WALL)
+            n.getConnections().add(new FlatTiledConnection(this, n, target));
+    }
 }

This is very prone to errors made by the developer, so we decided to refactor it with the use of a private enum as well as allowing a flexible amount or arguments with the varargs feature of Java.

+    private enum Direction {
+        N, E, S, W, NE, NW, SE, SW
+    }
+
+    private void addConnection(FlatTiledNode n, Direction... directions) // throws Exception
+    {
+        // if (directions.length > 8 || directions.length < 0) {
+        // throw new Exception("Directions are fucked up");
+        // }
+        for (Direction direction : directions) {
+            switch (direction) {
+                case N:
+                    addConnection(n, 0, 1);
+                    break;
+                case E:
+                    addConnection(n, 1, 0);
+                    break;
+                case S:
+                    addConnection(n, 0, -1);
+                    break;
+                case W:
+                    addConnection(n, -1, 0);
+                    break;
+                case NE:
+                    addConnection(n, 1, 1);
+                    break;
+                case NW:
+                    addConnection(n, -1, 1);
+                    break;
+                case SE:
+                    addConnection(n, 1, -1);
+                    break;
+                case SW:
+                    addConnection(n, -1, -1);
+                    break;
+                default:
+                    break;
+            }
+        }
+   }

We took inspiration from the Book Clean Code, Chapter 3.1, "Funktionen sollten klein sein[...]" to make this refactoring and are quite happy with the results it yielded.

Progress on the Game 🎮

• We added new collectables such as HP potions as well as speed potions
• The came can now be won by collecting the holy grail
• New sounds, weapons and assets
• Some initial efforts on balancing the weapons and enemies
• A crucial bug responsible for crashing the game after a few seconds of gameplay has been squashed

Bugfixes on the Webpage 🐛

• Added an apply filter button, so we don't DDOS our backend server

What's Changed

• hitbox für tränke by @BenjaminB109 in hitbox für tränke #235
• Jeremias/month campion by @JAWolfs in Jeremias/month campion #237
• Benjamin/tranke by @LPkkjHD in Benjamin/tranke #240
• feat: added apply filter button for not ddos the server 🛜 by @JAWolfs in feat: added apply filter button for not ddos the server 🛜 #239
• feat: game balancing by @LPkkjHD in feat: game balancing #238
• Movement by @dolerich-hirnfiedler in Movement #241
• feat: bugfixing by @LPkkjHD in feat: bugfixing  #243
• Refactor jf by @dolerich-hirnfiedler in Refactor jf #244

Full Changelog: v0.0.4-alpha...v0.0.5-alpha

---

This discussion was created from the release Semester 4 Week 7.

[sfrancisw]

Dear Underwatch team,

great to see all the new stuff that got added to your game! We really like how easy it is to see what you worked on (the changelog etc). It's also nice that you're focusing on refactoring your code so everything will work smoothly for your demo.
Can't wait for the final demo btw.

Your team time2shine

[HowDoIUseGit]

Hi Underwatch,

It's awesome to see all the new additions to your game! It's appreciated how clear it is to see what you've worked on through the changelog and other updates. It's also commendable that you're focusing on refactoring your code to ensure everything runs smoothly for your demo. We're really looking forward to the final demo!

Your CookPit

[fehlend0]

Dear Underwatch team,

great to hear about the progress on Underwatch. The refactoring you've done on the pathfinding logic sounds like a big improvement. Using a private enum for directions and Java's varargs feature not only simplifies the code but also reduces the potential for developer errors. This should make future maintenance and enhancements much easier.

Well done!

Your Statify Team