Resolve "Connect FindGameController to backend"

backend/src/index.ts

@@ -18,6 +18,8 @@ app.use((req, res, next) => {
   next();
 });
 
+app.use(express.json());
+
 app.get('/', (req, res) => {
   res.send('Hello, World!');
 });
@@ -123,26 +125,43 @@ app.get('/highscores', async (req, res) => {
 });
 
 // join a lobby with specific id
-app.post('/lobby/:id', async (req, res) => {
-  if (gameHandler.getLobbyById(req.params.id)) {
-    const lobby = gameHandler.getLobbyById(req.params.id);
+app.post('/lobby/create', async (req, res) => {
+  // if lobby doesn't exist, create a new lobby
+  const lobby = gameHandler.createLobby();
+  lobby.addUser(req.body.userId);
+  res.status(201).send({ lobbyId: lobby.getId() });
+});
 
-    if (!lobby) {
-      res.status(404).send('Lobby not found');
-      return;
-    }
+// Inform client if requested lobby is full or not
+app.get('/lobby/:id/status', async (req, res) => {
+  const lobby = gameHandler.getLobbyById(req.params.id);
 
-    lobby.addUser(req.body.userId);
-    gameHandler.createGame(lobby); // start game since 2 players are in lobby
-    res.status(200).send(lobby.getId());
+  if (!lobby) {
+    res.status(404).send('Lobby not found');
+    return;
+  }
+
+  if (lobby.isFull()) {
+    res.status(200).send({ isFull: true });
   } else {
-    // if lobby doesn't exist, create a new lobby
-    const lobby = gameHandler.createLobby();
-    lobby.addUser(req.body.userId);
-    res.status(201).send(lobby.getId());
+    res.status(200).send({ isFull: false });
   }
 });
 
+// join a lobby with specific id
+app.post('/lobby/:id/join', async (req, res) => {
+  const lobby = gameHandler.getLobbyById(req.params.id);
+
+  if (!lobby) {
+    res.status(404).send('Lobby not found');
+    return;
+  }
+
+  lobby.addUser(req.body.userId);
+  gameHandler.createGame(lobby); // start game since 2 players are in lobby
+  res.status(200).send({ lobbyId: lobby.getId() });
+});
+
 // leave a lobby with specific id
 app.post('/lobby/:id/leave', async (req, res) => {
   const lobby = gameHandler.getLobbyById(req.params.id);
@@ -151,7 +170,7 @@ app.post('/lobby/:id/leave', async (req, res) => {
   if (lobby?.getUsers().length === 0) {
     gameHandler.removeLobby(lobby);
   }
-  res.status(200).send(lobby?.getId());
+  res.status(200).send({ lobbyId: lobby?.getId() });
 });
 
 // Polling endpoint to check if its your turn (sends username)

backend/src/interfaces/ILobby.ts

@@ -6,5 +6,6 @@ export interface ILobby {
   getUsers(): User[];
   id: string;
   getId(): string;
+  isFull(): boolean;
   // maybe add a relation to a game?
 }

backend/src/lobby/Lobby.ts

@@ -44,4 +44,8 @@ export class Lobby implements ILobby {
   getUsers() {
     return this.users;
   }
+
+  isFull() {
+    return this.game != undefined;
+  }
 }

frontend/assets/menu-textures.atlas

@@ -67,13 +67,20 @@ logo
   orig: 134, 40
   offset: 0, 0
   index: -1
-transparent-white-box
+semi-transparent-white-box
   rotate: false
   xy: 921, 1009
   size: 1, 1
   orig: 1, 1
   offset: 0, 0
   index: -1
+transparent-white-box
+  rotate: false
+  xy: 892, 973
+  size: 1, 1
+  orig: 1, 1
+  offset: 0, 0
+  index: -1
 typing-cursor
   rotate: false
   xy: 2, 2

frontend/core/src/com/game/tankwars/HTTPRequestHandler.java

+package com.game.tankwars;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.Net;
+import com.badlogic.gdx.Net.HttpResponse;
+
+/**
+ * Handles request and response from the HTTP request using
+ * a passed callback function that treats request success, failure and cancellation.
+ * Implements the retry tactic by resending the request on failure
+ * a few times with increasing backoff time between resends.
+ */
+public class HTTPRequestHandler implements Net.HttpResponseListener {
+
+    public static final String PROTOCOL = "http";
+    public static final String HOST = "localhost";
+    public static final int PORT = 3000;
+
+    private final Callback callback;
+    private final Net.HttpRequest request;
+    private int attempts = 0;
+    private final int MAX_ATTEMPTS = 3;
+    private final int BACKOFF_TIME = 300;
+
+    public HTTPRequestHandler(Callback callback, Net.HttpRequest request) {
+        this.callback = callback;
+        this.request = request;
+    }
+
+    /**
+     * Send the HTTP request
+     */
+    public void sendRequest() {
+        Gdx.net.sendHttpRequest(request, this);
+    }
+
+    /**
+     * Request was successful and response received. Passes response body
+     * to callback.
+     *
+     * @param httpResponse The {@link HttpResponse} with the HTTP response values.
+     */
+    public void handleHttpResponse(HttpResponse httpResponse) {
+        callback.onResult(httpResponse.getResultAsString());
+    }
+
+    /**
+     * Request failed. Request will be retried until the attempts
+     * have been exhausted with an increasing backoff time between each retry.
+     *
+     * @param t If the HTTP request failed because an Exception, t encapsulates it to give more information.
+     */
+    public void failed(Throwable t) {
+        if (attempts < MAX_ATTEMPTS) {
+            attempts++;
+
+            try {
+                Thread.sleep((long) attempts * BACKOFF_TIME);
+                sendRequest();
+            } catch(InterruptedException e) {
+                System.err.println(e.getMessage());
+            }
+        } else {
+            callback.onFailed(t);
+        }
+    }
+
+    /**
+     * Request was cancelled
+     */
+    public void cancelled() {
+        System.out.println("Request cancelled");
+    }
+}
\ No newline at end of file

frontend/core/src/com/game/tankwars/ReceiverHandler.java

@@ -19,6 +19,10 @@ public class ReceiverHandler implements Net.HttpResponseListener {
     private final Callback callback;
     public static final int MAX_RETRIES = 5;
 
+    public static final String PROTOCOL = "http";
+    public static final String HOST = "localhost";
+    public static final int PORT = 3000;
+
     // Constructor to initialize the Callback instance
     public ReceiverHandler(Callback callback) {
         this.callback = callback;

frontend/core/src/com/game/tankwars/TankWarsGame.java

@@ -4,6 +4,7 @@
 package com.game.tankwars;
 
 import com.badlogic.gdx.Game;
+import com.game.tankwars.view.FindGameScreen;
 import com.game.tankwars.view.LoginScreen;
 
 public class TankWarsGame extends Game {

frontend/core/src/com/game/tankwars/controller/FindGameController.java

 package com.game.tankwars.controller;
 
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.Net;
+import com.badlogic.gdx.net.HttpRequestBuilder;
+import com.badlogic.gdx.scenes.scene2d.EventListener;
 import com.badlogic.gdx.scenes.scene2d.InputEvent;
 import com.badlogic.gdx.scenes.scene2d.InputListener;
 import com.badlogic.gdx.scenes.scene2d.Stage;
 import com.badlogic.gdx.scenes.scene2d.ui.Button;
+import com.badlogic.gdx.scenes.scene2d.ui.Label;
 import com.badlogic.gdx.scenes.scene2d.ui.TextButton;
 import com.badlogic.gdx.scenes.scene2d.ui.TextField;
 import com.badlogic.gdx.scenes.scene2d.utils.ClickListener;
+import com.badlogic.gdx.utils.Json;
+import com.badlogic.gdx.utils.SerializationException;
+import com.game.tankwars.Callback;
+import com.game.tankwars.ConfigReader;
+import com.game.tankwars.HTTPRequestHandler;
 import com.game.tankwars.ResourceManager;
 import com.game.tankwars.TankWarsGame;
+import com.game.tankwars.model.CurrentUser;
+import com.game.tankwars.model.LobbyId;
+import com.game.tankwars.model.LobbyStatus;
+import com.game.tankwars.view.FindGameScreen;
 import com.game.tankwars.view.GameScreen;
 import com.game.tankwars.view.MainMenuScreen;
 
+
 public class FindGameController {
 
     private final TankWarsGame tankWarsGame;
+    private final FindGameScreen screen;
     private final Stage stage;
     private final TextField gamePinField;
-    private final TextButton joinLobbyButton, createLobbyButton;
+    private final TextButton joinLobbyButton, createLobbyButton, cancelButton;
     private final Button backButton;
+    private final Label gamePinWaitingLabel;
+
+    private EventListener backButtonInputListener, gamePinFieldInputListener,
+            gamePinFieldClickListener, joinLobbyButtonInputListener,
+            createLobbyButtonInputListener, cancelButtonInputListener;
+
+    private String lobbyId = null;
+    private final Runnable gameScreenTransition;
+
 
     /**
+     * TODO: Ensure that user is logged in -> e.g. auth method in Auth/Utils class
      * Sets the event listeners of the buttons and the text field of the FindGameScreen,
-     * and allows for transitioning to MainMenuScreen and to GameScreen.
+     * and allows for transitioning to MainMenuScreen and to GameScreen. Handles communication
+     * with server to create, join and leave a lobbies.
      */
-    public FindGameController(final TankWarsGame tankWarsGame,
+    public FindGameController(final TankWarsGame tankWarsGame, FindGameScreen screen,
                               TextField gamePinField, TextButton joinLobbyButton,
-                              TextButton createLobbyButton, Button backButton, final Stage stage) {
+                              TextButton createLobbyButton, Button backButton,
+                              TextButton cancelButton, Label gamePinWaitingLabel,
+                              final Stage stage) {
         this.tankWarsGame = tankWarsGame;
+        this.screen = screen;
+
         this.gamePinField = gamePinField;
         this.joinLobbyButton = joinLobbyButton;
         this.createLobbyButton = createLobbyButton;
         this.backButton = backButton;
+        this.cancelButton = cancelButton;
+        this.gamePinWaitingLabel = gamePinWaitingLabel;
         this.stage = stage;
 
-        setEventListeners();
+        // This Runnable will be passed to the "render" thread
+        // using Gdx.app.postRunnable() from the threads of HTTP requests
+        gameScreenTransition = new Runnable() {
+            @Override
+            public void run() {
+                ResourceManager.getInstance().clear();
+                tankWarsGame.setScreen(new GameScreen(tankWarsGame));
+            }
+        };
+
+        defineEventListeners();
+        setMainListeners();
     }
 
-    public void setEventListeners() {
+    private void defineEventListeners() {
 
         /*
-         * Transitions back to MainMenuScreen
+         * Transition back to MainMenuScreen
          */
-        backButton.addListener(new InputListener() {
+        backButtonInputListener = new InputListener() {
             @Override
             public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
                 tankWarsGame.setScreen(new MainMenuScreen(tankWarsGame));
                 return true;
             }
-        });
+        };
 
         /*
-         * Filters text field input:
-         * Max 4 characters long and only digits
+         * Remove keyboard and reset camera position when "Enter" button is pressed.
+         * Enable the joinLobbyButton when gamePinField contains at least one character.
          */
-        gamePinField.setTextFieldFilter(new TextField.TextFieldFilter() {
-            @Override
-            public boolean acceptChar(TextField textField, char c) {
-                return textField.getText().length() < 4 && Character.isDigit(c);
-            }
-        });
-
-        /*
-         * Enables the joinLobbyButton when the gamePinField contains 4 digits,
-         * and disables it otherwise
-         */
-        gamePinField.addListener(new InputListener() {
+        gamePinFieldInputListener = new InputListener() {
             @Override
             public boolean keyTyped(InputEvent event, char character) {
                 super.keyTyped(event, character);
@@ -77,50 +110,236 @@ public class FindGameController {
                     stage.getViewport().apply();
                 }
 
-                joinLobbyButton.setDisabled(gamePinField.getText().length() != 4);
-
+                joinLobbyButton.setDisabled(gamePinField.getText().length() == 0);
                 return true;
             }
-        });
+        };
 
         /*
          * Move camera down when text field is clicked
          * to make the field appear above the keyboard.
          */
-        gamePinField.addListener(new ClickListener() {
+        gamePinFieldClickListener = new ClickListener() {
             @Override
             public void clicked(InputEvent event, float x, float y) {
                 super.clicked(event, x, y);
                 stage.getViewport().setScreenY((int) (2 * stage.getHeight() / 3));
                 stage.getViewport().apply();
             }
-        });
+        };
 
         /*
-         * Disables input listener when the button is disabled.
-         * TODO: Join a lobby by sending a request to the backend
+         * Send HTTP request to join lobby with game pin specified in text field.
+         * Avoid sending request if joinLobbyButton is disabled.
          */
-        joinLobbyButton.addListener(new InputListener() {
+        joinLobbyButtonInputListener = new InputListener() {
             @Override
             public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
                 if (joinLobbyButton.isDisabled()) return true;
 
-                System.out.println("Game pin: " + gamePinField.getText() + " - yet to be implemented");
+                joinLobby();
                 return true;
             }
-        });
+        };
 
         /*
-         * TODO: Create a lobby by sending request to backend - Transition to waiting screen?
+         * Create new lobby and display waiting window.
+         * Poll server for lobby status to know when to transition to game screen.
          */
-        createLobbyButton.addListener(new InputListener() {
+        createLobbyButtonInputListener = new InputListener() {
             @Override
             public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
-                ResourceManager.getInstance().clear();
-                tankWarsGame.setScreen(new GameScreen(tankWarsGame));
+                createLobby();
                 return true;
             }
-        });
+        };
+
+        /*
+         * Exit from waiting window and render normal FindGameScreen
+         */
+        cancelButtonInputListener = new InputListener() {
+          @Override
+          public boolean touchDown(InputEvent event, float x, float y, int pointer, int button) {
+              exitLobby();
+              return true;
+          }
+        };
+    }
+
+
+    public void setMainListeners() {
+        backButton.addListener(backButtonInputListener);
+        gamePinField.addListener(gamePinFieldInputListener);
+        gamePinField.addListener(gamePinFieldClickListener);
+        joinLobbyButton.addListener(joinLobbyButtonInputListener);
+        createLobbyButton.addListener(createLobbyButtonInputListener);
+    }
+
+    public void removeMainListeners() {
+        backButton.removeListener(backButtonInputListener);
+        gamePinField.removeListener(gamePinFieldInputListener);
+        gamePinField.removeListener(gamePinFieldClickListener);
+        joinLobbyButton.removeListener(joinLobbyButtonInputListener);
+        createLobbyButton.removeListener(createLobbyButtonInputListener);
+    }
+
+    public void setWaitingWindowListeners() {
+        cancelButton.addListener(cancelButtonInputListener);
+    }
+
+    public void removeWaitingWindowListeners() {
+        cancelButton.removeListener(cancelButtonInputListener);
     }
 
+
+    /**
+     * Send HTTP request to create a new lobby.
+     * On success, a waiting window is shown, and polling for
+     * the lobby status is initiated.
+     */
+    private void createLobby() {
+        new HTTPRequestHandler(new Callback() {
+            @Override
+            public void onResult(String result) {
+                try {
+                    LobbyId lobbyIdClass = new Json().fromJson(LobbyId.class, result);
+                    lobbyId = lobbyIdClass.getLobbyId();
+
+                    removeMainListeners();
+                    setWaitingWindowListeners();
+
+                    gamePinWaitingLabel.setText("Game pin: " + lobbyId);
+                    screen.showWaitingWindow();
+
+                    checkLobbyStatus();
+                } catch (SerializationException e) {
+                    System.err.println("Invalid HTTP response on create lobby");
+                }
+            }
+
+            @Override
+            public void onFailed(Throwable t) {
+                System.err.println("Create lobby request failed:\n" + t);
+            }
+        }, new HttpRequestBuilder()
+                .newRequest()
+                .url(String.format("%s/lobby/create", ConfigReader.getProperty("backend.url")))
+                .method(Net.HttpMethods.POST)
+                .header("Content-Type", "application/json")
+                .content(String.format("{\"userId\": \"%s\"}", CurrentUser.getCurrentUser().getUser().id))
+                .build())
+                .sendRequest();
+    }
+
+    /**
+     * Send HTTP request while waiting for lobby to fill,
+     * polling for the lobby's fill status with a set backoff period between requests.
+     * Transition to game screen when lobby is full.
+     */
+    private void checkLobbyStatus() {
+        new HTTPRequestHandler(new Callback() {
+            @Override
+            public void onResult(String result) {
+                try {
+                    LobbyStatus lobbyStatus = new Json().fromJson(LobbyStatus.class, result);
+
+                    if (lobbyStatus.isFull()) {
+                        Gdx.app.postRunnable(gameScreenTransition);
+                    } else if (lobbyId != null) {
+                        System.out.println("Awaiting opponent...");
+
+                        try {
+                            Thread.sleep(1500);
+                            if (lobbyId != null) checkLobbyStatus();
+                        } catch (InterruptedException e) {
+                            System.out.println(e.getMessage());
+                            exitLobby();
+                        }
+                    }
+                } catch (SerializationException e) {
+                    System.err.println("Invalid HTTP response on check lobby status");
+                    exitLobby();
+                }
+            }
+
+            @Override
+            public void onFailed(Throwable t) {
+                System.err.println("Check lobby status request failed:\n" + t);
+                exitLobby();
+            }
+        }, new HttpRequestBuilder()
+                .newRequest()
+                .url(String.format("%s/lobby/%s/status",
+                        ConfigReader.getProperty("backend.url"), lobbyId))
+                .method(Net.HttpMethods.GET)
+                .build())
+                .sendRequest();
+    }
+
+    /**
+     * Send HTTP request to exit the joined lobby while the lobby
+     * is not yet full. Hide the waiting window.
+     */
+    private void exitLobby() {
+        new HTTPRequestHandler(new Callback() {
+            @Override
+            public void onResult(String result) {
+                removeWaitingWindowListeners();
+                setMainListeners();
+
+                lobbyId = null;
+                screen.hideWaitingWindow();
+            }
+
+            @Override
+            public void onFailed(Throwable t) {
+                System.err.println("Exit lobby request failed:\n" + t);
+                removeWaitingWindowListeners();
+                setMainListeners();
+
+                lobbyId = null;
+                screen.hideWaitingWindow();
+            }
+        }, new HttpRequestBuilder()
+                .newRequest()
+                .url(String.format("%s/lobby/%s/leave",
+                        ConfigReader.getProperty("backend.url"), lobbyId))
+                .method(Net.HttpMethods.POST)
+                .header("Content-Type", "application/json")
+                .content(String.format("{\"userId\": \"%s\"}", CurrentUser.getCurrentUser().getUser().id))
+                .build())
+                .sendRequest();
+    }
+
+    /**
+     * Send HTTP request to join a lobby using the game pin in the text field.
+     * On success, transition to game screen.
+     */
+    private void joinLobby() {
+        new HTTPRequestHandler(new Callback() {
+            @Override
+            public void onResult(String result) {
+                try {
+                    new Json().fromJson(LobbyId.class, result);
+
+                    Gdx.app.postRunnable(gameScreenTransition);
+                } catch (SerializationException e) {
+                    System.out.println(result);
+                }
+            }
+
+            @Override
+            public void onFailed(Throwable t) {
+                System.err.println("Join lobby request failed:\n" + t);
+            }
+        }, new HttpRequestBuilder()
+                .newRequest()
+                .url(String.format("%s/lobby/%s/join",
+                        ConfigReader.getProperty("backend.url"), gamePinField.getText()))
+                .method(Net.HttpMethods.POST)
+                .header("Content-Type", "application/json")
+                .content(String.format("{\"userId\": \"%s\"}", CurrentUser.getCurrentUser().getUser().id))
+                .build())
+                .sendRequest();
+    }
 }

frontend/core/src/com/game/tankwars/model/LobbyId.java

+package com.game.tankwars.model;
+
+public class LobbyId {
+
+    private String lobbyId;
+
+    public String getLobbyId() {
+        return lobbyId;
+    }
+
+    public void setLobbyId(String lobbyId) {
+        this.lobbyId = lobbyId;
+    }
+}

frontend/core/src/com/game/tankwars/model/LobbyStatus.java

+package com.game.tankwars.model;
+
+public class LobbyStatus {
+    private boolean isFull;
+
+    public boolean isFull() {
+        return isFull;
+    }
+
+    public void setFull(boolean full) {
+        isFull = full;
+    }
+}

frontend/core/src/com/game/tankwars/view/FindGameScreen.java

@@ -28,6 +28,8 @@ public class FindGameScreen implements Screen {
 
     private final TankWarsGame tankWarsGame;
     private Stage stage;
+    private Group layoutGroup;
+    private Table windowTable;
 
     public FindGameScreen(final TankWarsGame tankWarsGame) {
         this.tankWarsGame = tankWarsGame;
@@ -65,7 +67,7 @@ public class FindGameScreen implements Screen {
         float rw = stage.getWidth() - lw;
 
         Table rootTable = new Table();
-        rootTable.setFillParent(true);
+        rootTable.setBounds(0, 0, stage.getWidth(), stage.getHeight());
 
         Group leftGroup = new Group();
         leftGroup.setSize(lw, stage.getHeight());
@@ -96,9 +98,42 @@ public class FindGameScreen implements Screen {
 
         rootTable.add(leftGroup).width(lw).height(stage.getHeight());
         rootTable.add(rightTable).expandX().height(stage.getHeight());
-        stage.addActor(rootTable);
 
-        new FindGameController(tankWarsGame, gamePinField, joinLobbyButton, createLobbyButton, backButton, stage);
+        //--- Awaiting opponent window
+        windowTable = new Table();
+        float ww = 3 * stage.getWidth() / 5f;
+        float wh = 3 * stage.getHeight() / 5f;
+
+        windowTable.setBounds(stage.getWidth() / 2f - ww / 2f, stage.getHeight() / 2f - wh / 2f, ww, wh);
+
+        Drawable windowBackground = skin.getDrawable("semi-transparent-white-box");
+        Label waitingLabel = new Label("Awaiting opponent...", skin.get("default", Label.LabelStyle.class));
+        Label gamePinWaitingLabel = new Label("Game pin: ---", skin.get("default", Label.LabelStyle.class));
+        TextButton cancelButton = new TextButton("Cancel", skin.get("default", TextButton.TextButtonStyle.class));
+
+        windowTable.background(windowBackground);
+        windowTable.row().expand();
+        windowTable.add(waitingLabel);
+        windowTable.row().expand();
+        windowTable.add(gamePinWaitingLabel);
+        windowTable.row().expand();
+        windowTable.add(cancelButton).width(2 * ww / 3f).height(30);
+
+
+        layoutGroup = new Group();
+        layoutGroup.addActor(rootTable);
+
+        stage.addActor(layoutGroup);
+
+        new FindGameController(tankWarsGame, this, gamePinField,
+                joinLobbyButton, createLobbyButton,
+                backButton, cancelButton, gamePinWaitingLabel, stage);
+    }
+
+    public void showWaitingWindow() { layoutGroup.addActor(windowTable); }
+
+    public void hideWaitingWindow() {
+        layoutGroup.removeActor(windowTable);
     }
 
     @Override