Cleanup

.docker/run.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+
+PORT=${FAIRHOPPER_API_PORT=8010}
+
+echo "Starting FairHopper game server on port ${PORT}"
+
+uvicorn \
+    main:app \
+    --host 0.0.0.0 \
+    --port ${PORT} \
+    --workers=1

.docker/settings.py

@@ -0,0 +1,31 @@
+import os
+import logging
+
+from hopper.models.config import (
+    BoardSettings,
+    DebugSettings,
+    GameSettings,
+    InactivityWatchdogSettings,
+    Settings,
+    WSServerSettings,
+)
+
+settings = Settings(
+    game=GameSettings(),
+    board=BoardSettings(
+        WIDTH=20,
+        HEIGHT=20,
+        OBSTACLE_COUNT=0,
+    ),
+    inacivity_watchdog=InactivityWatchdogSettings(),
+    purchase_timeout=5,
+    log_level=logging.INFO,
+    ws_server=WSServerSettings(
+        HOST="0.0.0.0",
+        PORT=int(os.environ.get("FAIRHOPPER_WS_PORT", 8011)),
+    ),
+    debug=DebugSettings(
+        PRINT_BOARD=True,
+        PLAYERS=[],
+    ),
+)

.gitignore

@@ -4,3 +4,5 @@ __pycache__
 /env
 /.venv
 /settings.py
+/requirements.txt
+/frontend/js/config.js

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "fairhopper-sdk"]
+	path = fairhopper-sdk
+	url = git@gitea.ekirin.com:Intis/fairhopper-sdk.git

Dockerfile

@@ -0,0 +1,50 @@
+FROM python:3.10.11-alpine3.17 as env-builder
+
+# handle optional arguments
+ARG INTERNAL_API_PORT=8010
+ARG INTERNAL_WS_PORT=8011
+
+RUN \
+    apk add --no-cache gcc musl-dev libffi-dev && \
+    pip install pip -U --no-cache-dir --prefer-binary && \
+    pip install poetry --no-cache-dir --prefer-binary
+
+WORKDIR /app
+
+COPY pyproject.toml .
+COPY poetry.lock .
+
+# create virtual environment
+RUN python -m venv /venv
+# set python thingies, set environment variables and activate virtual environment
+ENV \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    FAIRHOPPER_API_PORT=${INTERNAL_API_PORT} \
+    FAIRHOPPER_WS_PORT=${INTERNAL_WS_PORT} \
+    PATH="/venv/bin:$PATH"
+
+RUN \
+    # dump python dependencies into requirements file
+    poetry export --without-hashes --format=requirements.txt > requirements.txt && \
+    # install python libs
+    pip install -r requirements.txt --no-cache-dir --prefer-binary
+
+
+FROM python:3.10.11-alpine3.17 as runner
+
+WORKDIR /app
+COPY --from=env-builder /venv /venv
+
+# set python thingies and activate virtual environment
+ENV \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PATH="/venv/bin:$PATH"
+
+# copy all relevant files
+COPY ./.docker/* ./
+COPY ./hopper ./hopper
+COPY ./main.py .
+
+ENTRYPOINT [ "/app/run.sh" ]

Makefile

@@ -1,5 +1,15 @@
+IMAGE_NAME=fairhopper-service
+CONTAINER_NAME=fairhopper-service
+INTERNAL_API_PORT=8010
+INTERNAL_WS_PORT=8011
+EXTERNAL_API_PORT=8010
+EXTERNAL_WS_PORT=8011
+
+timestamp := `/bin/date "+%Y-%m-%d-%H-%M-%S"`
+
 run:
-	@poetry run \
+	@ \
+	poetry run \
 		uvicorn \
 			main:app \
 			--host 0.0.0.0 \
@@ -7,10 +17,48 @@ run:
 			--workers=1
 
 run-dev:
-	@poetry run \
+	@ \
+	poetry run \
 		uvicorn \
 			main:app \
 			--host 0.0.0.0 \
 			--port 8010 \
 			--workers=1 \
 			--reload
+
+create-requirements:
+	@ \
+	poetry export \
+		--without-hashes \
+		--format=requirements.txt \
+		> requirements.txt
+
+docker-clean:
+	@echo "> Removing container $(CONTAINER_NAME)"
+	- @docker rm $(CONTAINER_NAME)
+	@echo "> Removing image $(CONTAINER_NAME)"
+	- @docker image rm $(CONTAINER_NAME)
+
+
+docker-build:
+	@ \
+	docker \
+		buildx build \
+			--build-arg INTERNAL_API_PORT=$(INTERNAL_API_PORT) \
+			--build-arg INTERNAL_WS_PORT=$(INTERNAL_WS_PORT) \
+			--tag $(CONTAINER_NAME):$(timestamp) \
+			.
+
+docker-run:
+	@ \
+	docker \
+		run \
+		--publish $(EXTERNAL_API_PORT):$(INTERNAL_API_PORT) \
+		--publish $(EXTERNAL_WS_PORT):$(INTERNAL_WS_PORT) \
+		--name=$(CONTAINER_NAME) \
+		$(IMAGE_NAME) \
+		--detach
+
+docker-clean-build:
+	make clean
+	make build

README.md

@@ -1,5 +1,14 @@
 # FairHopper
 
+## Useful links
+
+- [Frontend](https://fairhopper.mjerenja.com)
+- [API](https://api.fairhopper.mjerenja.com)
+- [API Docs](https://api.fairhopper.mjerenja.com/docs)
+- [FairHopper](https://gitea.ekirin.com/Intis/fairhopper)
+- [FairHopper SDK](https://gitea.ekirin.com/Intis/fairhopper-sdk)
+- Websockets: wss://fairhopper.mjerenja.com/ws
+
 ## Game
 
 ### Overview
@@ -21,12 +30,90 @@
 - Move timeout: 10s. Game is finished if timeout ocurrs.
 
 
+## Game States
+
+```plantuml
+scale 1024 width
+hide empty description
+
+state "Start Game" as StartGame
+state "Move" as MovePlayer: Destination reached?
+state "Destination Reached" as DestinationReached
+state "Product Selection" as ProductSelection: Enable product selection for winning player
+state "Product Selected" as ProductSelected
+state "Selection Timeout" as SelectionTimeout
+state "End Player's Game" as EndPlayer
+state "Lock Game" as LockGame <<end>>
+state "Unlock game and restart" as UnlockGame <<end>>
+
+[*] -> StartGame
+StartGame -> MovePlayer
+MovePlayer <-- MovePlayer: NO
+MovePlayer --> DestinationReached: YES
+DestinationReached --> ProductSelection
+DestinationReached -> LockGame: Lock game for all other players
+ProductSelection --> ProductSelected
+ProductSelection --> SelectionTimeout
+ProductSelected --> UnlockGame: Unlock game\nand restart
+SelectionTimeout -> EndPlayer
+EndPlayer --> UnlockGame: Unlock game\nand restart
+```
+
 ## FairHopper Game Server
 
+### Start server as docker container
+
+Build image:
+```sh
+docker build . -t CONTAINER_NAME
+```
+
+Create docker container:
+```sh
+docker \
+  create \
+  --publish EXTERNAL_API_PORT:8010 \
+  --publish EXTERNAL_WS_PORT:8011 \
+  --name=CONTAINER_NAME \
+  IMAGE_NAME
+```
+
+Parameters:
+- `EXTERNAL_API_PORT` - REST API port
+- `EXTERNAL_WS_PORT` - Websockets port
+- `CONTAINER_NAME` - FairHopper container name
+- `IMAGE_NAME` - FairHopper image name
+
+Start docker container:
+```sh
+docker start CONTAINER_NAME -d
+```
+
+Stop docker container:
+```sh
+docker stop CONTAINER_NAME
+```
+
+Example:
+```sh
+docker build . -t fairhopper-service
+docker \
+  run \
+  --publish 8010:8010 \
+  --publish 8011:8011 \
+  --name=fairhopper-service \
+  fairhopper \
+  --detach
+docker start fairhopper-service -d
+docker stop fairhopper-service
+```
+
+### Start server on local machine
+
 Requirements:
 - Python 3.10+
 
-### Install virtual envirnonment
+#### Install virtual envirnonment
 
 Project uses [Poetry](https://python-poetry.org), ultimate dependency management software for Python.
 
@@ -40,14 +127,14 @@ Install virtual environment:
 poetry install
 ```
 
-### Setting up
+#### Setting up
 
 Copy `settings_template.py` to `settings.py`.
 
 Edit `settings.py` and customize application.
 
 
-### Starting FairHopper Game Server
+#### Starting FairHopper Game Server
 
 ```sh
 make run
@@ -71,59 +158,108 @@ WebSockets server runs on port **8011**. To run WS Server on different port, edi
 ### Architecture
 
 ```plantuml
+scale 1024 width
 actor "Player 1" as P1
 actor "Player 2" as P2
 actor "Player 3" as P3
 
-
-package Masterpiece {
-    rectangle {
-        usecase Game as "FairHopper\nGame Server"
+package Masterpiece #seashell {
+    rectangle "FairHopper Game Server" #lightcyan {
+        usecase API as "API Server"
+        usecase Game as "Game Engine"
         usecase WS as "WS Server"
     }
-    usecase Vis as "Visualisation\nService"
+    usecase Vis as "Flutter\nVisualisation\nService"
 }
 
-P1 -left-> Game: REST API
-P2 -left-> Game: REST API
-P3 -left-> Game: REST API
+usecase ExtVis1 as "Visualisation\nClient"
+usecase ExtVis2 as "Visualisation\nClient"
+
+P1 -left-> API: REST API
+P2 -left-> API: REST API
+P3 -left-> API: REST API
+API --> Game
 Game --> WS: Game State
-WS --> Vis: WebSockets
+WS --> Vis: WS Game State
+WS --> ExtVis1: WS Game State
+WS --> ExtVis2: WS Game State
 ```
 
 ### WebSockets
 
 ```plantuml
-    participant Game as "FairHopper\nGame Server"
+scale 1024 width
+box "FairHopper Game Server" #lightcyan
+    participant Game as "Game Engine"
     participant WS as "WS Server"
+endbox
 participant Client1 as "Visualisation\nClient 1"
 participant Client2 as "Visualisation\nClient 2"
 
-    Game ->o WS: Server Connect
-    activate WS #coral
-        WS -> Game: Get game state
-        activate Game #yellow
-            Game -> WS: Game state
-        deactivate
-    deactivate
+== Player movement mode ==
 
-    Client1 ->o WS: Client Connect
+Game ->o WS: Send initial state
+
+Client1 ->o WS: Client connect
 activate WS #coral
 	WS -> Client1: Game state
-    deactivate
+deactivate WS
 
-    Client2 ->o WS: Client Connect
+Client2 ->o WS: Client connect
 activate WS #coral
 	WS -> Client2: Game state
-    deactivate
+deactivate WS
 
 loop #lightyellow On game state change
     Game ->o WS: Game state
     activate WS #coral
         WS o-> Client1: Game state
         WS o-> Client2: Game state
-    deactivate
+    deactivate WS
 end
+
+== Player reached destination ==
+
+Game -> Game: Lock game for other players
+activate Game #skyblue
+  Game -> WS: Player reached destination
+  activate WS #coral
+    WS o-> Client1: Select product
+    WS o-> Client2: Select product
+  deactivate WS
+deactivate Game
+
+loop #lightyellow Product select countdown timer (60s)
+	Game ->o WS: Timer timeout
+  activate Game #skyblue
+    activate WS #coral
+      WS o-> Client1: Selection timeout
+      WS o-> Client2: Selection timeout
+    deactivate WS
+    Game -> Game: Unlock game
+  deactivate Game
+end
+
+Client1 -> Client1: Product selection
+activate Client1 #greenyellow
+  Client1 -> Client1: Dispense product
+  Client1 ->o WS: Product selected
+deactivate Client1
+
+activate WS #coral
+	WS o-> Game: Product selected
+    activate Game #skyblue
+	WS o-> Client2: Product selected
+deactivate WS
+
+
+Game -> Game: Unlock game
+    Game ->o WS: Game state
+    activate WS #coral
+        WS o-> Client1: Game state
+        WS o-> Client2: Game state
+    deactivate WS
+deactivate Game
 ```
 
 
@@ -134,7 +270,7 @@ end
 - Move right
 - Move up
 - Move down
-- Get current position
+- Get player info
 - Get board info
 
 Check REST API interface on [FastAPI docs](http://localhost:8010/docs).
@@ -164,7 +300,7 @@ Response body:
     }
   },
   "player": {
-		"uuid": "75bba7cd-a4c1-4b50-b0b5-6382c2822a25",
+    "id": "75bba7cd-a4c1-4b50-b0b5-6382c2822a25",
     "name": "Pero",
     "position": {
       "x": 0,
@@ -178,25 +314,26 @@ Response body:
 
 ### Player Move
 
-- POST `/player/{uuid}/move/left`
-- POST `/player/{uuid}/move/right`
-- POST `/player/{uuid}/move/up`
-- POST `/player/{uuid}/move/down`
+- POST `/player/{id}/move/left`
+- POST `/player/{id}/move/right`
+- POST `/player/{id}/move/up`
+- POST `/player/{id}/move/down`
 
 Request body: None
 
 Response code:
 - 200 OK: Destination reached
 - 201 Created: Player moved successfully
-- 403 Forbidden: Player uuid not valid, probably timeout
+- 403 Forbidden: Player id not valid, probably timeout
 - 409 Conflict: Invalid move, obstacle or position out of board
 - 422 Unprocessable Content: Validation error
+- 423 Locked: Game locked, product selection in progress
 
 Response body:
 ```json
 {
   "player": {
-		"uuid": "string",
+    "id": "string",
     "name": "Pero",
     "position": {
       "x": 50,
@@ -210,7 +347,7 @@ Response body:
 
 ### Get Player Info
 
-GET `/player/{{uuid}}`
+GET `/player/{{id}}`
 
 Request body: None
 
@@ -218,7 +355,7 @@ Response body:
 ```json
 {
   "player": {
-		"uuid": "string",
+    "id": "string",
     "name": "Pero",
     "position": {
       "x": 50,
@@ -258,46 +395,57 @@ Response body:
 ### WS Data format
 - json
 
+```json
+{
+  "message": message_type,
+  "data": ...
+}
+```
+
 
 ### Game state structure
 
-URI: `/game-state`
+Direction: Game server -> Clients
+
+Message: `game_dump`
 
 Data:
 ```json
 {
   "board": {
-		"width": 21,
-		"height": 21
+    "width": 10,
+    "height": 10
   },
   "destination": {
     "position": {
-			"x": 10,
-			"y": 10
+      "x": 5,
+      "y": 5
     }
   },
   "players": [
     {
-			"uuid": "test-player-id",
+      "id": "test-player-pero",
       "name": "Pero",
       "active": true,
       "position": {
-				"x": 2,
-				"y": 2
+        "x": 3,
+        "y": 3
       },
-			"move_count": 3,
-			"move_attempt_count": 3
+      "move_count": 0,
+      "move_attempt_count": 0,
+      "state": "CREATED"
     },
     {
-			"uuid": "95962b49-0003-4bf2-b205-71f2590f2318",
+      "id": "test-player-mirko",
       "name": "Mirko",
       "active": true,
       "position": {
-				"x": 0,
-				"y": 0
+        "x": 4,
+        "y": 4
       },
-			"move_count": 15,
-			"move_attempt_count": 20
+      "move_count": 0,
+      "move_attempt_count": 0,
+      "state": "CREATED"
     }
   ],
   "layers": [
@@ -307,36 +455,22 @@ Data:
         {
           "type": "OBSTACLE",
           "position": {
-						"x": 4,
-						"y": 2
-					}
-				},
-				{
-					"type": "OBSTACLE",
-					"position": {
-						"x": 4,
-						"y": 13
-					}
-				},
-				{
-					"type": "OBSTACLE",
-					"position": {
-						"x": 18,
-						"y": 18
+            "x": 0,
+            "y": 6
           }
         },
         {
           "type": "OBSTACLE",
           "position": {
             "x": 5,
-						"y": 4
+            "y": 1
           }
         },
         {
           "type": "OBSTACLE",
           "position": {
-						"x": 7,
-						"y": 10
+            "x": 1,
+            "y": 6
           }
         }
       ]
@@ -347,8 +481,8 @@ Data:
         {
           "type": "DESTINATION",
           "position": {
-						"x": 10,
-						"y": 10
+            "x": 5,
+            "y": 5
           }
         }
       ]
@@ -359,15 +493,15 @@ Data:
         {
           "type": "PLAYER",
           "position": {
-						"x": 2,
-						"y": 2
+            "x": 3,
+            "y": 3
           }
         },
         {
           "type": "PLAYER",
           "position": {
-						"x": 0,
-						"y": 0
+            "x": 4,
+            "y": 4
           }
         }
       ]
@@ -375,3 +509,43 @@ Data:
   ]
 }
 ```
+
+### Player reached destination
+
+Direction: Game server -> Clients
+
+Message: `player_reached_destination`
+
+Data:
+```json
+{
+  "player": {
+    "id": "2e0f1a50-eaa6-4efd-b0c3-adbf7000eec2",
+    "name": "Joso",
+    "active": true,
+    "position": {
+      "x": 5,
+      "y": 5
+    },
+    "move_count": 6,
+    "move_attempt_count": 6,
+    "state": "ON_DESTINATION"
+  }
+}
+```
+
+### Product selection timeout
+
+Direction: Game server -> Clients
+
+Message: `product_selection_timeout`
+
+Data: `null`
+
+### Product selection done
+
+Message: `product_selection_done`
+
+Direction: Client -> Game server, Game server -> Clients
+
+Data: `null`

api_tests/requests.http

@@ -0,0 +1,41 @@
+GET http://localhost:8010/ping
+###
+
+# create new game
+POST http://localhost:8010/game
+Content-Type: application/json
+
+{
+  "player_name": "Mirko"
+}
+###
+
+# get game info
+GET http://localhost:8010/game
+###
+
+# get player info
+GET http://localhost:8010/player/test-player-pero
+###
+
+# move player left
+POST http://localhost:8010/player/test-player-pero/move/left
+###
+
+# move player right
+POST http://localhost:8010/player/test-player-pero/move/right
+###
+
+# move player up
+POST http://localhost:8010/player/test-player-pero/move/up
+###
+
+# move player down
+POST http://localhost:8010/player/test-player-pero/move/down
+###
+
+###
+
+# move Mirko left
+POST http://localhost:8010/player/test-player-mirko/move/left
+###

frontend/index.html

@@ -8,13 +8,20 @@
     <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.2.3/dist/css/bootstrap.min.css"
         integrity="sha384-rbsA2VBKQhggwzxH7pPCaAqO46MgnOM80zW1RWuH61DGLwZJEdK2Kadq2F9CUG65" crossorigin="anonymous">
     <link rel="stylesheet" href="styles.css">
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.2.3/dist/js/bootstrap.min.js"
+        integrity="sha384-cuYeSxntonz0PPNlHhBs68uyIAVpIIOZZ5JqeqvYYIcEL727kskC66kF92t6Xl2V"
+        crossorigin="anonymous"></script>
+    <script src="js/config.js"></script>
+    <script src="js/frontend.js"></script>
 
-    <title>Document</title>
+    <title>FairHopper Visualisation Client</title>
 </head>
 
 <body>
-    <div class="container-fluid">
-        <h1>FairHopper WS Client</h1>
+    <main class="container-fluid main-container">
+        <h1 class="mt-1 mb-2">
+            FairHopper Visualisation Client
+        </h1>
         <div class="row">
             <div class="col-10">
                 <div class="board-container">
@@ -22,123 +29,33 @@
                 </div>
             </div>
             <div class="col-2">
-                <h3>Players</h3>
+                <h3 class="pb-2 border-bottom">
+                    Players
+                </h3>
                 <ul class="players" id="players-content"></ul>
             </div>
         </div>
+    </main>
+
+    <div class="modal fade" id="player-on-destination-modal">
+        <div class="modal-dialog">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title">Player on destination</h5>
+                </div>
+                <div class="modal-body">
+                    Player <strong class="player-name"></strong>
+                    reached destination in <strong class="move-count"></strong>
+                    moves.
+                </div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-primary" id="finish-product-selection" data-bs-dismiss="modal">
+                        Finish product selection
+                    </button>
+                </div>
+            </div>
+        </div>
     </div>
 </body>
 
-<script>
-    function createBoard(board) {
-        let html = "";
-        for (let y = 0; y < board.height; y++) {
-            let colHtml = "";
-            for (let x = 0; x < board.width; x++) {
-                colHtml += `<div class="cell" id="cell-${x}-${y}">&nbsp;</div>`;
-            }
-            html += `
-                <div class="flex-grid">
-                    ${colHtml}
-                </div>
-            `;
-        }
-        document.getElementById("board-content").innerHTML = html;
-    }
-
-    function findCell(position) {
-        return document.getElementById(`cell-${position.x}-${position.y}`);
-    }
-
-    function renderCellContent(position, content) {
-        const cell = findCell(position);
-        if (cell) {
-            cell.innerText = content;
-        }
-    }
-
-    function renderPlayerList(players) {
-        const html = players.filter(player => player.active).map((player) => {
-            return `
-                <li class="${player.reached_destination ? "text-success" : ""}">
-                    ${player.name} (${player.move_count})
-                    ${player.reached_destination ? "✅" : ""}
-                </li>
-            `;
-        }).join("");
-        document.getElementById("players-content").innerHTML = html;
-    }
-
-    function renderPlayers(players) {
-        players.filter(player => player.active).forEach(player => {
-            const cell = findCell(player.position);
-            if (cell) {
-                const playerIcon = "😎";
-                const html = `
-                    <div class="player-tooltip">${player.name}</div>
-                    ${playerIcon}
-                `;
-                cell.innerHTML = html;
-            }
-        });
-    }
-
-    function getLayerObjectsOfType(layers, type) {
-        let objects = [];
-        layers.forEach(layer => {
-            objects = objects.concat(layer.objects.filter(obj => obj.type === type))
-        });
-        return objects;
-    }
-
-    function renderObstacles(layers) {
-        const objects = getLayerObjectsOfType(layers, "OBSTACLE");
-        objects.forEach(obj => {
-            renderCellContent(obj.position, "🔥");
-        });
-    }
-
-    function renderDestination(position) {
-        renderCellContent(position, "🏠");
-    }
-
-
-    function wsConnect() {
-        let ws = new WebSocket('ws://localhost:8011/bla-tra');
-        ws.onopen = function () {
-            /*
-            ws.send(JSON.stringify({
-            }));
-            */
-        };
-
-        ws.onmessage = function (e) {
-            const data = JSON.parse(e.data);
-            console.log("message received:", data)
-
-            createBoard(data.board);
-            renderObstacles(data.layers)
-            renderDestination(data.destination.position);
-            renderPlayerList(data.players);
-            renderPlayers(data.players);
-        };
-
-        ws.onclose = function (e) {
-            setTimeout(function () {
-                wsConnect();
-            }, 1000);
-        };
-
-        ws.onerror = function (err) {
-            console.error('Socket encountered error: ', err.message, 'Closing socket');
-            ws.close();
-        };
-    }
-
-    window.onload = function () {
-        wsConnect();
-    }
-</script>
-
-
 </html>

frontend/js/frontend.js

@@ -0,0 +1,178 @@
+if (typeof FAIRHOPPER_WS_SERVER === "undefined") {
+    var FAIRHOPPER_WS_SERVER = "ws://127.0.0.1:8011";
+}
+
+let ws = null;
+let playerOnDestinationModal = null;
+
+const BOARD_ICONS = {
+    PLAYER: "😀",
+    PLAYER_ON_DESTINATION: "😎",
+    OBSTACLE: "🔥",
+    DESTINATION: "🏠",
+};
+
+function createBoard(board) {
+    let html = "";
+    for (let y = 0; y < board.height; y++) {
+        let colHtml = "";
+        for (let x = 0; x < board.width; x++) {
+            colHtml += `<div class="cell" id="cell-${x}-${y}">&nbsp;</div>`;
+        }
+        html += `
+            <div class="flex-grid">
+                ${colHtml}
+            </div>
+        `;
+    }
+    document.getElementById("board-content").innerHTML = html;
+}
+
+function findCell(position) {
+    return document.getElementById(`cell-${position.x}-${position.y}`);
+}
+
+function renderCellContent(position, content) {
+    const cell = findCell(position);
+    if (cell) {
+        cell.innerText = content;
+    }
+}
+
+function renderPlayerList(players) {
+    document.getElementById("players-content").innerHTML = players
+        .filter((player) => player.active)
+        .map((player) => {
+            const onDestination = player.state === "ON_DESTINATION";
+            return `
+                <li class="${onDestination ? "text-success" : ""}">
+                    ${player.name} (${player.move_count})
+                    ${onDestination ? "✅" : ""}
+                </li>
+            `;
+        })
+        .join("");
+}
+
+function renderPlayers(players) {
+    players
+        .filter((player) => player.active)
+        .forEach((player) => {
+            const cell = findCell(player.position);
+            const onDestination = player.state === "ON_DESTINATION";
+            const playerIcon = onDestination ? BOARD_ICONS.PLAYER_ON_DESTINATION : BOARD_ICONS.PLAYER;
+            if (cell) {
+                cell.innerHTML = `
+                    <div class="player-tooltip">${player.name}</div>
+                    ${playerIcon}
+                `;
+            }
+        });
+}
+
+function getLayerObjectsOfType(layers, type) {
+    let objects = [];
+    layers.forEach((layer) => {
+        objects = objects.concat(layer.objects.filter((obj) => obj.type === type));
+    });
+    return objects;
+}
+
+function renderObstacles(layers) {
+    const objects = getLayerObjectsOfType(layers, "OBSTACLE");
+    objects.forEach((obj) => {
+        renderCellContent(obj.position, BOARD_ICONS.OBSTACLE);
+    });
+}
+
+function renderDestination(position) {
+    renderCellContent(position, BOARD_ICONS.DESTINATION);
+}
+
+function renderGameDump(data) {
+    createBoard(data.board);
+    renderObstacles(data.layers);
+    renderDestination(data.destination.position);
+    renderPlayerList(data.players);
+    renderPlayers(data.players);
+}
+
+function playerReachedDestination(data) {
+    const dlgElement = document.getElementById("player-on-destination-modal");
+    dlgElement.querySelector(".player-name").textContent = data.player.name;
+    dlgElement.querySelector(".move-count").textContent = data.player.move_count;
+    playerOnDestinationModal.show();
+}
+
+function productSelectionTimeout() {
+    playerOnDestinationModal.hide();
+}
+
+function productSelectionDone() {
+    playerOnDestinationModal.hide();
+}
+
+function wsConnect() {
+    console.log("Attempting to connect to", FAIRHOPPER_WS_SERVER);
+    ws = new WebSocket(FAIRHOPPER_WS_SERVER);
+
+    ws.onopen = () => {
+        console.log("WS connected");
+    };
+
+    ws.onmessage = (e) => {
+        const wsMessage = JSON.parse(e.data);
+        console.log("WS message received:", wsMessage);
+
+        switch (wsMessage.message) {
+            case "game_dump":
+                renderGameDump(wsMessage.data);
+                break;
+            case "player_reached_destination":
+                playerReachedDestination(wsMessage.data);
+                break;
+            case "product_selection_timeout":
+                productSelectionTimeout();
+                break;
+            case "product_selection_done":
+                productSelectionDone();
+                break;
+            default:
+                console.error("Unknown message:", wsMessage);
+        }
+    };
+
+    ws.onclose = (e) => {
+        ws = null;
+        setTimeout(() => {
+            wsConnect();
+        }, 1000);
+    };
+
+    ws.onerror = (err) => {
+        console.error("Socket encountered error:", err.message, "Closing socket");
+        ws.close();
+    };
+}
+
+function finishProductSelection() {
+    if (!ws) {
+        return;
+    }
+    const wsMessage = {
+        message: "product_selection_done",
+        data: null,
+    };
+    ws.send(JSON.stringify(wsMessage));
+}
+
+window.onload = () => {
+    const dlgElement = document.getElementById("player-on-destination-modal");
+    playerOnDestinationModal = new bootstrap.Modal(dlgElement);
+
+    document.getElementById("finish-product-selection").onclick = () => {
+        finishProductSelection();
+    };
+
+    wsConnect();
+};

frontend/styles.css

@@ -2,6 +2,10 @@ body {
     background-color: whitesmoke;
 }
 
+main.main-container {
+    position: relative;
+}
+
 .board-container {
     background-color: white;
     border: 1px solid black;
@@ -13,11 +17,18 @@ body {
     grid-gap: 2px;
     padding-bottom: 2px;
 }
+.flex-grid:last-of-type {
+    padding-bottom: 0;
+}
+
 .cell {
     flex: 1;
-    text-align: center;
+    aspect-ratio: 1;
     background-color: beige;
     position: relative;
+    display: flex;
+    align-items: center;
+    justify-content: center;
 }
 
 ul.players {
@@ -27,13 +38,12 @@ ul.players {
 
 .player-tooltip {
     position: absolute;
-    top: -25px;
+    margin-bottom: 50px;
     font-size: 8pt;
     padding: 2px 10px;
     color: white;
     background-color: darkred;
     border-radius: 5px;
-    z-index: 1000;
 }
 
 .player-tooltip::after {

hopper/api/dependencies.py

@@ -2,6 +2,7 @@ from typing import Optional
 
 from hopper.engine import GameEngine, GameEngineFactory
 from hopper.ws_server import WSServer
+from settings import settings
 
 game_engine: Optional[GameEngine] = None
 
@@ -12,7 +13,10 @@ def create_game_engine() -> GameEngine:
     if game_engine:
         raise RuntimeError("Can't call create_game_engine() more than once!")
 
-    ws_server = WSServer(daemon=True)
+    ws_server = WSServer(
+        host=settings.ws_server.HOST,
+        port=settings.ws_server.PORT,
+    )
     ws_server.start()
 
     game_engine = GameEngineFactory.create_default(ws_server=ws_server)

hopper/api/dto.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from pydantic import BaseModel as PydanticBaseModel
 
+from hopper.enums import PlayerState
+
 
 class BaseModel(PydanticBaseModel):
     class Config:
@@ -23,12 +25,13 @@ class PositionDto(BaseModel):
 
 
 class PlayerDto(BaseModel):
-    uuid: str
+    id: str
     name: str
     active: bool
     position: PositionDto
     move_count: int
     move_attempt_count: int
+    state: PlayerState
 
 
 class DestinationDto(BaseModel):

hopper/api/views.py

@@ -14,14 +14,18 @@ from hopper.api.dto import (
 )
 from hopper.engine import GameEngine
 from hopper.enums import Direction, PlayerMoveResult
-from hopper.errors import Collision, PositionOutOfBounds
+from hopper.errors import (
+    Collision,
+    GameLockForMovement,
+    PositionOutOfBounds,
+)
 from hopper.models.player import Player
 
 router = APIRouter()
 
 
-def get_player(uuid: str, engine: GameEngine = Depends(get_game_engine)) -> Player:
-    player = engine.players.find(uuid)
+def get_player(id: str, engine: GameEngine = Depends(get_game_engine)) -> Player:
+    player = engine.players.find(id)
     if player is None:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND, detail="Player not found"
@@ -53,12 +57,14 @@ async def get_game_info(
     )
 
 
-@router.post("/game", response_model=StartGameResponseDto)
+@router.post(
+    "/game", response_model=StartGameResponseDto, status_code=status.HTTP_201_CREATED
+)
 async def start_game(
     body: StartGameRequestDto,
     engine: GameEngine = Depends(get_game_engine),
 ) -> StartGameResponseDto:
-    new_player = await engine.start_game(player_name=body.player_name)
+    new_player = await engine.start_game_for_player(player_name=body.player_name)
 
     return StartGameResponseDto(
         board=engine.board,
@@ -70,9 +76,8 @@ async def start_game(
 
 
 @router.get(
-    "/player/{uuid}",
+    "/player/{id}",
     response_model=PlayerInfoResponseDto,
-    status_code=status.HTTP_201_CREATED,
     responses={
         status.HTTP_403_FORBIDDEN: {
             "model": ErrorResponseDto,
@@ -80,7 +85,7 @@ async def start_game(
         },
         status.HTTP_404_NOT_FOUND: {
             "model": ErrorResponseDto,
-            "description": " Player with uuid not found, probably kicked out",
+            "description": "Player with id not found, probably kicked out",
         },
     },
 )
@@ -91,7 +96,7 @@ async def get_player_info(
 
 
 @router.post(
-    "/player/{uuid}/move/{direction}",
+    "/player/{id}/move/{direction}",
     response_model=MovePlayerResponseDto,
     status_code=status.HTTP_201_CREATED,
     responses={
@@ -105,12 +110,16 @@ async def get_player_info(
         },
         status.HTTP_404_NOT_FOUND: {
             "model": ErrorResponseDto,
-            "description": " Player with uuid not found, probably kicked out",
+            "description": "Player with id not found, probably kicked out",
         },
         status.HTTP_409_CONFLICT: {
             "model": ErrorResponseDto,
             "description": "Position out of bounds or collision with an object",
         },
+        status.HTTP_423_LOCKED: {
+            "model": ErrorResponseDto,
+            "description": "Player reached destination. Can't move anymore.",
+        },
     },
 )
 async def move_player(
@@ -129,6 +138,11 @@ async def move_player(
         raise HTTPException(
             status_code=status.HTTP_409_CONFLICT, detail="Collision with an object"
         )
+    except GameLockForMovement:
+        raise HTTPException(
+            status_code=status.HTTP_423_LOCKED,
+            detail="Player reached destination. Can't move anymore.",
+        )
 
     if move_result == PlayerMoveResult.DESTINATION_REACHED:
         response.status_code = status.HTTP_200_OK

hopper/api_tests/requests.http

@@ -1,35 +0,0 @@
-GET http://localhost:8010/ping
-###
-
-# create new game
-POST http://localhost:8010/game
-Content-Type: application/json
-
-{
-  "player_name": "Mirko"
-}
-###
-
-# get game info
-GET http://localhost:8010/game
-###
-
-# get player info
-GET http://localhost:8010/player/test-player-id
-###
-
-# move player left
-POST http://localhost:8010/player/test-player-id/move/left
-###
-
-# move player right
-POST http://localhost:8010/player/test-player-id/move/right
-###
-
-# move player up
-POST http://localhost:8010/player/test-player-id/move/up
-###
-
-# move player down
-POST http://localhost:8010/player/test-player-id/move/down
-###

hopper/countdown_timer.py

@@ -0,0 +1,31 @@
+import time
+from threading import Event, Thread
+from typing import Callable, Optional
+
+
+class CountdownTimer(Thread):
+    def __init__(
+        self,
+        seconds: int,
+        timer_tick_callback: Optional[Callable[[int], None]] = None,
+        timer_done_callback: Optional[Callable[[], None]] = None,
+    ) -> None:
+        self.seconds = seconds
+        self.stop_event = Event()
+        self.timer_tick_callback = timer_tick_callback
+        self.timer_done_callback = timer_done_callback
+        super().__init__(daemon=True)
+
+    def run(self) -> None:
+        time_left = self.seconds
+        while time_left and not self.stop_event.is_set():
+            time.sleep(1)
+            time_left -= 1
+            if self.timer_tick_callback and not self.stop_event.is_set():
+                self.timer_tick_callback(time_left)
+
+        if time_left == 0 and self.timer_done_callback:
+            self.timer_done_callback()
+
+    def stop(self) -> None:
+        self.stop_event.set()

hopper/engine.py

@@ -3,8 +3,9 @@ import logging
 import random
 from typing import Optional
 
-from hopper.enums import Direction, PlayerMoveResult
-from hopper.errors import Collision, PositionOutOfBounds
+from hopper.countdown_timer import CountdownTimer
+from hopper.enums import Direction, GameState, PlayerMoveResult, PlayerState
+from hopper.errors import Collision, GameLockForMovement, PositionOutOfBounds
 from hopper.models.board import (
     BOARD_DUMP_CHARS,
     BoardLayout,
@@ -21,21 +22,42 @@ from hopper.ws_server import WSServer
 from settings import settings
 
 
+def create_player_start_position(board_width: int, board_height: int) -> Position:
+    """Create random position somewhere on the board border"""
+    border_len = (board_width + board_height) * 2
+    rnd_position = random.randint(0, border_len - 1)
+
+    if rnd_position < board_width * 2:
+        x = rnd_position % board_width
+        y = 0 if rnd_position < board_width else board_height - 1
+    else:
+        rnd_position -= 2 * board_width
+        x = 0 if rnd_position < board_height else board_width - 1
+        y = rnd_position % board_height
+
+    return Position(x=x, y=y)
+
+
 class GameEngine:
-    def __init__(self, board: GameBoard, ws_server: Optional[WSServer] = None) -> None:
+    def __init__(self, board: GameBoard, ws_server: WSServer = None) -> None:
         self.board = board
         self.ws_server = ws_server
         self.players = PlayerList()
         self._inacivity_watchdog = None
+        self._purchase_countdown_timer: Optional[CountdownTimer] = None
+        self.game_state = GameState.RUNNING
         self.__debug_print_board()
 
     def dump_board(self) -> list[list[str]]:
         dump = self.board.dump()
 
         for player in self.players:
-            if player.position.y < len(dump) and player.position.x < len(
-                dump[player.position.y]
-            ):
+            show_player = (
+                player.active
+                and player.position.y < len(dump)
+                and player.position.x < len(dump[player.position.y])
+            )
+            if show_player:
                 dump[player.position.y][player.position.x] = BOARD_DUMP_CHARS[
                     ObjectType.PLAYER
                 ]
@@ -53,42 +75,35 @@ class GameEngine:
             self._inacivity_watchdog = InactivityWatchdog(
                 players=self.players,
                 ws_server=self.ws_server,
-                daemon=True,
             )
             self._inacivity_watchdog.start()
 
-    async def start_game(self, player_name: str) -> Player:
+    async def send_game_dump(self):
+        self.__debug_print_board()
+        await self.ws_server.send_game_dump()
+
+    async def reset_game(self) -> None:
+        self.__debug_print_board()
+        self.game_state = GameState.RUNNING
+        self.players.clear()
+        await self.send_game_dump()
+
+    async def start_game_for_player(self, player_name: str) -> Player:
         self._start_inactivity_watchdog()
         player = Player(
             name=player_name,
-            position=self._create_player_start_position(),
+            position=create_player_start_position(self.board.width, self.board.height),
+            state=PlayerState.CREATED,
         )
         self.players.append(player)
 
         logging.info(f"Starting new game for player: {player}")
         self.__debug_print_board()
 
-        if self.ws_server:
-            await self.ws_server.send_game_state()
-
+        await self.send_game_dump()
         await asyncio.sleep(settings.game.MOVE_DELAY)
         return player
 
-    def _create_player_start_position(self) -> Position:
-        """Create random position somewhere on the board border"""
-        border_len = (self.board.width + self.board.height) * 2
-        rnd_position = random.randint(0, border_len - 1)
-
-        if rnd_position < self.board.width * 2:
-            x = rnd_position % self.board.width
-            y = 0 if rnd_position < self.board.width else self.board.height - 1
-        else:
-            rnd_position -= 2 * self.board.width
-            x = 0 if rnd_position < self.board.height else self.board.width - 1
-            y = rnd_position % self.board.height
-
-        return Position(x=x, y=y)
-
     def _move_position(self, position: Position, direction: Direction) -> Position:
         new_position = Position(position.x, position.y)
         if direction == Direction.LEFT:
@@ -108,14 +123,18 @@ class GameEngine:
     ) -> PlayerMoveResult:
         player.reset_timeout()
 
+        if self.game_state == GameState.LOCK_FOR_MOVEMENT:
+            raise GameLockForMovement("Player reached destination. Can't move anymore.")
+
         # player will not be able to move once they reach the destination
-        if player.reached_destination:
+        if player.state == PlayerState.ON_DESTINATION:
             return PlayerMoveResult.DESTINATION_REACHED
 
         logging.info(f"Player {player} move to {direction}")
         new_position = self._move_position(player.position, direction)
 
         player.move_attempt_count += 1
+        player.state = PlayerState.MOVING
 
         if not self._position_in_board_bounds(new_position):
             raise PositionOutOfBounds()
@@ -127,19 +146,13 @@ class GameEngine:
         player.move_count += 1
 
         if self._is_player_on_destination(player):
-            player.reached_destination = True
-            logging.info(f"Player {player} reached destination!")
-
-        if self.ws_server:
-            await self.ws_server.send_game_state()
-
-        self.__debug_print_board()
-
-        if player.reached_destination:
+            player.state = PlayerState.ON_DESTINATION
+            await self._player_on_destination(player)
             return PlayerMoveResult.DESTINATION_REACHED
 
-        await asyncio.sleep(settings.game.MOVE_DELAY)
+        await self.send_game_dump()
 
+        await asyncio.sleep(settings.game.MOVE_DELAY)
         return PlayerMoveResult.OK
 
     def _is_player_on_destination(self, player: Player) -> bool:
@@ -153,6 +166,54 @@ class GameEngine:
     def _colided_with_obstacle(self, position: Position) -> bool:
         return self.board.get_object_at_position(position) is not None
 
+    async def _player_on_destination(self, player: Player) -> None:
+        logging.info(f"Player {player} reached destination!")
+
+        self.game_state = GameState.LOCK_FOR_MOVEMENT
+        await self.send_game_dump()
+
+        await self.ws_server.send_player_reached_destination_message(player=player)
+
+        logging.info(
+            f"Starting product selection countdown timer for {settings.purchase_timeout} seconds"
+        )
+
+        def on_purchase_timer_tick(time_left) -> None:
+            logging.info(
+                f"Product selection countdown timer tick, time left: {time_left}"
+            )
+
+        def on_purchase_timer_done() -> None:
+            logging.info("Ding ding! Product selection countdown timer timeout")
+            self._purchase_countdown_timer = None
+            asyncio.run(self.ws_server.send_product_selection_timeout_message())
+            self.game_state = GameState.RUNNING
+            asyncio.run(self.send_game_dump())
+
+        self._purchase_countdown_timer = CountdownTimer(
+            seconds=settings.purchase_timeout,
+            timer_tick_callback=on_purchase_timer_tick,
+            timer_done_callback=on_purchase_timer_done,
+        )
+        self._purchase_countdown_timer.start()
+
+        await asyncio.sleep(settings.game.PURCHASE_START_DELAY)
+
+    async def product_selection_done(self) -> None:
+        logging.info("Product selection done, unlocking game")
+        if self._purchase_countdown_timer:
+            self._purchase_countdown_timer.stop()
+        await self.ws_server.send_product_selection_done_message()
+        await self.reset_game()
+
+    def _reset_player(self, player) -> None:
+        # move player to start position
+        player.position = create_player_start_position(
+            self.board.width, self.board.height
+        )
+        player.state = PlayerState.CREATED
+        player.last_seen = None
+
     def get_board_layout(self) -> BoardLayout:
         return BoardLayout(board=self.board, players=self.players)
 
@@ -163,7 +224,7 @@ class GameEngineFactory:
         board_width: int,
         board_height: int,
         obstacle_count: int = 0,
-        ws_server: Optional[WSServer] = None,
+        ws_server: WSServer = None,
     ) -> GameEngine:
         board = GameBoard(
             width=board_width,
@@ -184,11 +245,13 @@ class GameEngineFactory:
             board=board,
             ws_server=ws_server,
         )
-        GameEngineFactory.__add_test_player(game.players)
+        GameEngineFactory.__add_test_players(game.players)
         return game
 
     @staticmethod
-    def create_default(ws_server: Optional[WSServer] = None) -> GameEngine:
+    def create_default(
+        ws_server: WSServer = None,
+    ) -> GameEngine:
         return GameEngineFactory.create(
             board_width=settings.board.WIDTH,
             board_height=settings.board.HEIGHT,
@@ -197,18 +260,10 @@ class GameEngineFactory:
         )
 
     @staticmethod
-    def __add_test_player(players: PlayerList) -> None:
-        if not (settings.debug and settings.debug.CREATE_TEST_PLAYER):
+    def __add_test_players(players: PlayerList) -> None:
+        if not settings.debug:
             return
 
-        player = Player(
-            name="Pero",
-            uuid="test-player-id",
-            position=Position(
-                settings.debug.TEST_PLAYER_START_X,
-                settings.debug.TEST_PLAYER_START_Y,
-            ),
-            can_be_deactivated=False,
-        )
+        for player in settings.debug.PLAYERS:
             players.append(player)
             logging.info(f"Test player created: {player}")

hopper/enums.py

@@ -18,3 +18,16 @@ class ObjectType(str, Enum):
 class PlayerMoveResult(Enum):
     OK = auto()
     DESTINATION_REACHED = auto()
+
+
+class GameState(Enum):
+    RUNNING = auto()
+    LOCK_FOR_MOVEMENT = auto()
+    ENDGAME = auto()
+
+
+class PlayerState(str, Enum):
+    CREATED = "CREATED"
+    MOVING = "MOVING"
+    ON_DESTINATION = "ON_DESTINATION"
+    INACTIVE = "INACTIVE"

hopper/errors.py

@@ -8,3 +8,7 @@ class PositionOutOfBounds(BaseError):
 
 class Collision(BaseError):
     ...
+
+
+class GameLockForMovement(BaseError):
+    ...

hopper/models/board.py

@@ -14,6 +14,13 @@ BOARD_DUMP_CHARS: dict[ObjectType, str] = {
 }
 
 
+def create_random_position(board_width: int, board_height: int) -> Position:
+    return Position(
+        x=random.randint(0, board_width - 1),
+        y=random.randint(0, board_height - 1),
+    )
+
+
 @dataclass
 class LayerObject:
     type_: ObjectType
@@ -102,10 +109,3 @@ class BoardLayout:
             )
         )
         return layers
-
-
-def create_random_position(board_width: int, board_height: int) -> Position:
-    return Position(
-        x=random.randint(0, board_width - 1),
-        y=random.randint(0, board_height - 1),
-    )

hopper/models/config.py

@@ -1,10 +1,15 @@
 import logging
 from dataclasses import dataclass
-from typing import Optional
+from typing import List, Optional
+
+from hopper.models.player import Player
+
 
 @dataclass
 class GameSettings:
     MOVE_DELAY: float = 0.5  # seconds
+    PURCHASE_START_DELAY: float = 2  # seconds
+
 
 @dataclass
 class BoardSettings:
@@ -22,16 +27,14 @@ class InactivityWatchdogSettings:
 
 @dataclass
 class WSServerSettings:
-    HOST: str = "localhost"
+    HOST: str = "127.0.0.1"
     PORT: int = 8011
 
 
 @dataclass
 class DebugSettings:
     PRINT_BOARD: bool = False
-    CREATE_TEST_PLAYER: bool = False
-    TEST_PLAYER_START_X: int = 0
-    TEST_PLAYER_START_Y: int = 0
+    PLAYERS: Optional[List[Player]] = None
 
 
 @dataclass
@@ -40,5 +43,6 @@ class Settings:
     board: BoardSettings
     inacivity_watchdog: InactivityWatchdogSettings
     ws_server: WSServerSettings
+    purchase_timeout: int = 10  # seconds
     log_level: int = logging.INFO
     debug: Optional[DebugSettings] = None

hopper/models/player.py

@@ -3,6 +3,8 @@ import uuid
 from dataclasses import dataclass, field
 from typing import Optional
 
+from hopper.enums import PlayerState
+
 
 @dataclass
 class Position:
@@ -13,24 +15,24 @@ class Position:
 @dataclass
 class Player:
     name: str
-    uuid: str = field(default_factory=lambda: str(uuid.uuid4()))
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
     position: Position = field(default_factory=lambda: Position(0, 0))
     move_count: int = 0
     move_attempt_count: int = 0
     last_seen: datetime.datetime = field(
         default_factory=lambda: datetime.datetime.now()
     )
+    state: PlayerState = PlayerState.CREATED
     active: bool = True
     can_be_deactivated: bool = True
-    reached_destination: bool = False
 
     def reset_timeout(self) -> None:
         self.last_seen = datetime.datetime.now()
 
 
 class PlayerList(list[Player]):
-    def find(self, uuid: str) -> Optional[Player]:
+    def find(self, id: str) -> Optional[Player]:
         for player in self:
-            if player.uuid == uuid:
+            if player.id == id:
                 return player
         return None

hopper/models/ws_dto.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
+import json
+from typing import Optional, TypeVar
+
 from pydantic import Field
+from pydantic.generics import GenericModel
 
 from hopper.api.dto import BaseModel, BoardDto, DestinationDto, PlayerDto, PositionDto
 from hopper.enums import ObjectType
@@ -15,12 +19,50 @@ class LayerDto(BaseModel):
     name: str
     objects: list[LayerObjectDto]
 
-class GameStatePlayerDto(PlayerDto):
-    reached_destination: bool
 
-
-class GameStateDto(BaseModel):
+class GameDumpDto(BaseModel):
     board: BoardDto
     destination: DestinationDto
-    players: list[GameStatePlayerDto]
+    players: list[PlayerDto]
     layers: list[LayerDto]
+
+
+class PlayerReachedDestinationDto(BaseModel):
+    player: PlayerDto
+
+
+TMessageData = TypeVar("TMessageData", bound=BaseModel)
+
+
+class WSMessage(GenericModel):
+    message: str
+    data: Optional[TMessageData] = None
+
+    def __str__(self) -> str:
+        return self.to_str()
+
+    def to_str(self) -> str:
+        return json.dumps(self.dict())
+
+    @classmethod
+    @property
+    def message_type(cls) -> str:
+        return cls.__fields__["message"].default
+
+
+class WSGameDumpMessage(WSMessage):
+    message: str = "game_dump"
+    data: GameDumpDto
+
+
+class WSProductSelectionDoneMessage(WSMessage):
+    message: str = "product_selection_done"
+
+
+class WSProductSelectionTimeoutMessage(WSMessage):
+    message: str = "product_selection_timeout"
+
+
+class WSPlayerReachedDestinationMessage(WSMessage):
+    message: str = "player_reached_destination"
+    data: PlayerReachedDestinationDto

hopper/watchdog.py

@@ -2,8 +2,7 @@ import asyncio
 import datetime
 import logging
 import time
-from threading import Thread
-from typing import Optional
+from threading import Thread, Event
 
 from hopper.models.player import PlayerList
 from hopper.ws_server import WSServer
@@ -11,18 +10,17 @@ from settings import settings
 
 
 class InactivityWatchdog(Thread):
-    def __init__(
-        self, players: PlayerList, ws_server: Optional[WSServer] = None, *args, **kwargs
-    ) -> None:
+    def __init__(self, players: PlayerList, ws_server: WSServer = None) -> None:
         self.players = players
         self.ws_server = ws_server
-        self.stopped = False
-        super().__init__(*args, **kwargs)
+        self.stop_event = Event()
+        super().__init__(daemon=True)
 
     def run(self) -> None:
         logging.info("Starting inactivity watchdog")
-        while not self.stopped:
+        while not self.stop_event.is_set():
             self.cleanup_players()
+            if not self.stop_event.is_set():
                 time.sleep(settings.inacivity_watchdog.TICK_INTERVAL)
 
     def cleanup_players(self) -> None:
@@ -34,7 +32,7 @@ class InactivityWatchdog(Thread):
             seconds=settings.inacivity_watchdog.KICK_TIMEOUT
         )
 
-        send_game_state = False
+        send_game_dump = False
 
         for player in self.players:
             if (
@@ -44,7 +42,7 @@ class InactivityWatchdog(Thread):
             ):
                 player.active = False
                 logging.info(f"Player {player} set as inactive")
-                send_game_state = True
+                send_game_dump = True
 
         # safe remove from list
         n = 0
@@ -53,18 +51,16 @@ class InactivityWatchdog(Thread):
             if player.can_be_deactivated and player.last_seen < kick_threshold:
                 self.players.pop(n)
                 logging.info(f"Player {player} kicked out")
-                send_game_state = True
+                send_game_dump = True
             else:
                 n += 1
 
-        if send_game_state:
-            self.send_game_state()
+        if send_game_dump:
+            self.send_game_dump()
 
-    def send_game_state(self):
-        if not self.ws_server:
-            return
-        logging.info("Sending WS game state")
-        asyncio.run(self.ws_server.send_game_state())
+    def send_game_dump(self):
+        logging.info("Sending WS game dump")
+        asyncio.run(self.ws_server.send_game_dump())
 
     def stop(self) -> None:
-        self.stopped = True
+        self.stop_event.set()

hopper/ws_server.py

@@ -5,76 +5,146 @@ from threading import Thread
 
 import websockets
 from websockets import WebSocketServerProtocol
-from websockets.exceptions import ConnectionClosedOK
+from websockets.exceptions import ConnectionClosedError, ConnectionClosedOK
 
-from hopper.models.ws_dto import GameStateDto
-from settings import settings
+from hopper.models.player import Player
+from hopper.models.ws_dto import (
+    GameDumpDto,
+    PlayerReachedDestinationDto,
+    WSGameDumpMessage,
+    WSMessage,
+    WSPlayerReachedDestinationMessage,
+    WSProductSelectionDoneMessage,
+    WSProductSelectionTimeoutMessage,
+)
 
 
 class WSServer(Thread):
-    def __init__(self, *args, **kwargs) -> None:
-        self.connected_clients = set[WebSocketServerProtocol]()
-        super().__init__(*args, **kwargs)
+    def __init__(self, host: str, port: int) -> None:
+        self.host = host
+        self.port = port
+        super().__init__(daemon=True)
+
+    async def handle_rcv_message(
+        self, client: WebSocketServerProtocol, raw_message: str
+    ) -> None:
+        try:
+            ws_message = json.loads(raw_message)
+        except Exception as ex:
+            logging.error(
+                f"Error decoding WS message from {client.id} {raw_message}: {ex}"
+            )
+            return None
+
+        data_message = ws_message.get("message")
+        if data_message == WSProductSelectionDoneMessage.message_type:
+            await self.handle_rcv_product_selection_done(client)
+
+    async def handle_rcv_product_selection_done(
+        self, client: WebSocketServerProtocol
+    ) -> None:
+        logging.info(f"Handle WSProductSelectionDoneMessage: {client.id}")
+        # avoid circular imports
+        from hopper.api.dependencies import get_game_engine
+
+        engine = get_game_engine()
+        await engine.product_selection_done()
 
     async def handler(self, websocket: WebSocketServerProtocol) -> None:
+        """New handler instance spawns for each connected client"""
         self.connected_clients.add(websocket)
         logging.info(f"Add client: {websocket.id}")
 
         try:
-            await self.send_game_state_to_client(websocket)
+            # send initial game dump to connected client
+            await self.send_game_dump_to_client(websocket)
+            # loop and do nothing while client is connected
             connected = True
             while connected:
                 try:
-                    message = await websocket.recv()
+                    # we're expecting nothing from client, but read if client sends a message
+                    rcv_data = await websocket.recv()
+                    await self.handle_rcv_message(
+                        client=websocket, raw_message=rcv_data
+                    )
                 except ConnectionClosedOK:
+                    logging.info(f"Connection closed OK for client: {websocket.id}")
+                    connected = False
+                except ConnectionClosedError:
+                    logging.info(f"Connection closed error for client: {websocket.id}")
                     connected = False
         finally:
             self.connected_clients.remove(websocket)
             logging.info(f"Remove client: {websocket.id}")
 
-    def _create_game_state_message(self) -> str:
+    async def send_message_to_client(
+        self, client: WebSocketServerProtocol, message: WSMessage
+    ) -> None:
+        message_str = message.to_str()
+        logging.debug(
+            f"Sending message {message.message} to clients: {self.connected_clients}: {message_str}"
+        )
+        await client.send(message_str)
+
+    async def send_message_to_clients(self, message: WSMessage) -> None:
+        for client in self.connected_clients:
+            await self.send_message_to_client(client, message)
+
+    def _create_game_dump_message(self) -> WSGameDumpMessage:
         # avoid circular imports
         from hopper.api.dependencies import get_game_engine
 
         engine = get_game_engine()
 
-        game_state = GameStateDto(
+        game_dump = GameDumpDto(
             board=engine.board,
             destination=engine.board.destination,
             players=engine.players,
             layers=engine.get_board_layout().layers,
         )
-        return json.dumps(game_state.dict())
+        return WSGameDumpMessage(data=game_dump)
 
-    async def send_game_state_to_client(
+    async def send_game_dump_to_client(
         self, websocket: WebSocketServerProtocol
     ) -> None:
-        message = self._create_game_state_message()
-        logging.debug(f"Sending game state to client: {websocket.id}")
-        await websocket.send(message)
+        """Send game dump to the client"""
+        message = self._create_game_dump_message()
+        logging.debug(f"Sending game dump to client: {websocket.id}")
+        await websocket.send(message.to_str())
 
-    async def send_game_state(self) -> None:
-        if not self.connected_clients:
-            return
+    async def send_game_dump(self) -> None:
+        """Broadcast game state to all connected clients"""
+        message = self._create_game_dump_message()
+        await self.send_message_to_clients(message)
 
-        message = self._create_game_state_message()
-        logging.debug(
-            f"Sending game state to clients: {self.connected_clients}: {message}"
+    async def send_player_reached_destination_message(self, player: Player) -> None:
+        message = WSPlayerReachedDestinationMessage(
+            data=PlayerReachedDestinationDto(
+                player=player,
             )
-        for client in self.connected_clients:
-            await client.send(message)
+        )
+        await self.send_message_to_clients(message)
+
+    async def send_product_selection_done_message(self) -> None:
+        message = WSProductSelectionDoneMessage()
+        await self.send_message_to_clients(message)
+
+    async def send_product_selection_timeout_message(self) -> None:
+        message = WSProductSelectionTimeoutMessage()
+        await self.send_message_to_clients(message)
 
     async def run_async(self) -> None:
         logging.info(
-            f"Starting FairHopper Websockets Server on {settings.ws_server.HOST}:{settings.ws_server.PORT}"
+            f"Starting FairHopper Websockets Server on {self.host}:{self.port}"
         )
 
         async with websockets.serve(
             ws_handler=self.handler,
-            host=settings.ws_server.HOST,
-            port=settings.ws_server.PORT,
+            host=self.host,
+            port=self.port,
         ):
             await asyncio.Future()  # run forever
 
     def run(self) -> None:
+        self.connected_clients = set[WebSocketServerProtocol]()
         asyncio.run(self.run_async())

sdk/demo.py

@@ -0,0 +1,51 @@
+import random
+from fh_sdk import Direction, FairHopper, Position
+import math
+
+HOST = "http://localhost"
+PORT = 8010
+
+
+def calc_angle(position1: Position, position2: Position) -> float:
+    x1, y1 = position1.x, position1.y
+    x2, y2 = position2.x, position2.y
+    return math.atan2(y2 - y1, x2 - x1) * (180 / math.pi)
+
+
+fh = FairHopper(host=HOST, port=PORT)
+res = fh.ping()
+
+game = fh.start_game(player_name=f"Mirko {random.randint(0, 9999)}")
+print(game.player.position)
+quit()
+
+res = fh.get_game_info()
+print(">>>>>", res)
+
+res = fh.get_player_info("XX")
+print(">>>>>", res)
+
+position = game.player.position
+dest_position = game.destination.position
+
+# p1 = PositionDto(x=0, y=20)
+# p2 = PositionDto(x=10, y=10)
+# angle = calc_angle(p1, p2)
+# print(angle)
+# quit()
+
+for _ in range(10):
+    angle = calc_angle(position, dest_position) + 180
+    if 0 <= angle < 90:
+        direction = Direction.RIGHT
+    elif 90 <= angle <= 180:
+        direction = Direction.DOWN
+    elif 180 <= angle <= 270:
+        direction = Direction.RIGHT
+    else:
+        direction = Direction.UP
+
+    print(position, dest_position, int(angle), direction)
+
+    move_response = fh.move(game.player.id, direction)
+    position = move_response.player.position

sdk/fh_sdk.py

@@ -1,135 +0,0 @@
-from pydantic import BaseModel
-from enum import Enum
-
-import requests
-
-
-class BaseError(Exception):
-    ...
-
-
-class PositionError(BaseError):
-    ...
-
-
-class PlayerInactiveError(BaseError):
-    ...
-
-
-class PlayerNotFoundError(BaseError):
-    ...
-
-
-class Direction(str, Enum):
-    LEFT = "left"
-    RIGHT = "right"
-    UP = "up"
-    DOWN = "down"
-
-
-class Board(BaseModel):
-    width: int
-    height: int
-
-
-class Position(BaseModel):
-    x: int
-    y: int
-
-
-class Destination(BaseModel):
-    position: Position
-
-
-class Player(BaseModel):
-    uuid: str
-    name: str
-    active: bool
-    position: Position
-    move_count: int
-    move_attempt_count: int
-
-
-class PingResponse(BaseModel):
-    message: str
-
-
-class StartGameResponse(BaseModel):
-    board: Board
-    destination: Destination
-    player: Player
-
-
-class PlayerInfoResponse(BaseModel):
-    player: Player
-
-
-class GameInfoResponse(BaseModel):
-    board: Board
-    destination: Destination
-
-
-class FairHopper:
-    def __init__(self, host, port) -> None:
-        self.host = host
-        self.port = port
-
-    def format_url(self, path: str) -> str:
-        return f"{self.host}:{self.port}{path}"
-
-    def ping(self) -> PingResponse:
-        r = requests.get(self.format_url("/ping"))
-        r.raise_for_status()
-        return PingResponse(**r.json())
-
-    def start_game(self, player_name: str) -> StartGameResponse:
-        payload = {
-            "player_name": player_name,
-        }
-        r = requests.post(self.format_url("/game"), json=payload)
-        r.raise_for_status()
-        return StartGameResponse(**r.json())
-
-    def get_game_info(self) -> GameInfoResponse:
-        r = requests.get(self.format_url(f"/game"))
-        r.raise_for_status()
-        return GameInfoResponse(**r.json())
-
-    def get_player_info(self, uuid: str) -> PlayerInfoResponse:
-        r = requests.get(self.format_url(f"/player/{uuid}"))
-
-        if r.status_code == 403:
-            raise PlayerInactiveError()
-        elif r.status_code == 404:
-            raise PlayerNotFoundError()
-        else:
-            r.raise_for_status()
-
-        return PlayerInfoResponse(**r.json())
-
-    def move_left(self, uuid: str) -> PlayerInfoResponse:
-        return self.move(uuid, Direction.LEFT)
-
-    def move_right(self, uuid: str) -> PlayerInfoResponse:
-        return self.move(uuid, Direction.RIGHT)
-
-    def move_up(self, uuid: str) -> PlayerInfoResponse:
-        return self.move(uuid, Direction.UP)
-
-    def move_down(self, uuid: str) -> PlayerInfoResponse:
-        return self.move(uuid, Direction.DOWN)
-
-    def move(self, uuid: str, direction: Direction) -> PlayerInfoResponse:
-        path = f"/player/{uuid}/move/{direction}"
-        r = requests.post(self.format_url(path))
-
-        if r.status_code == 403:
-            raise PlayerInactiveError()
-        elif r.status_code == 404:
-            raise PlayerNotFoundError()
-        elif r.status_code == 409:
-            raise PositionError()
-        else:
-            r.raise_for_status()
-
-        return PlayerInfoResponse(**r.json())

sdk/poetry.lock

@@ -1,219 +0,0 @@
-# This file is automatically @generated by Poetry 1.4.1 and should not be changed by hand.
-
-[[package]]
-name = "certifi"
-version = "2022.12.7"
-description = "Python package for providing Mozilla's CA Bundle."
-category = "main"
-optional = false
-python-versions = ">=3.6"
-files = [
-    {file = "certifi-2022.12.7-py3-none-any.whl", hash = "sha256:4ad3232f5e926d6718ec31cfc1fcadfde020920e278684144551c91769c7bc18"},
-    {file = "certifi-2022.12.7.tar.gz", hash = "sha256:35824b4c3a97115964b408844d64aa14db1cc518f6562e8d7261699d1350a9e3"},
-]
-
-[[package]]
-name = "charset-normalizer"
-version = "3.1.0"
-description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet."
-category = "main"
-optional = false
-python-versions = ">=3.7.0"
-files = [
-    {file = "charset-normalizer-3.1.0.tar.gz", hash = "sha256:34e0a2f9c370eb95597aae63bf85eb5e96826d81e3dcf88b8886012906f509b5"},
-    {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e0ac8959c929593fee38da1c2b64ee9778733cdf03c482c9ff1d508b6b593b2b"},
-    {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d7fc3fca01da18fbabe4625d64bb612b533533ed10045a2ac3dd194bfa656b60"},
-    {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:04eefcee095f58eaabe6dc3cc2262f3bcd776d2c67005880894f447b3f2cb9c1"},
-    {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:20064ead0717cf9a73a6d1e779b23d149b53daf971169289ed2ed43a71e8d3b0"},
-    {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1435ae15108b1cb6fffbcea2af3d468683b7afed0169ad718451f8db5d1aff6f"},
-    {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c84132a54c750fda57729d1e2599bb598f5fa0344085dbde5003ba429a4798c0"},
-    {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75f2568b4189dda1c567339b48cba4ac7384accb9c2a7ed655cd86b04055c795"},
-    {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:11d3bcb7be35e7b1bba2c23beedac81ee893ac9871d0ba79effc7fc01167db6c"},
-    {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:891cf9b48776b5c61c700b55a598621fdb7b1e301a550365571e9624f270c203"},
-    {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:5f008525e02908b20e04707a4f704cd286d94718f48bb33edddc7d7b584dddc1"},
-    {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:b06f0d3bf045158d2fb8837c5785fe9ff9b8c93358be64461a1089f5da983137"},
-    {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:49919f8400b5e49e961f320c735388ee686a62327e773fa5b3ce6721f7e785ce"},
-    {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:22908891a380d50738e1f978667536f6c6b526a2064156203d418f4856d6e86a"},
-    {file = "charset_normalizer-3.1.0-cp310-cp310-win32.whl", hash = "sha256:12d1a39aa6b8c6f6248bb54550efcc1c38ce0d8096a146638fd4738e42284448"},
-    {file = "charset_normalizer-3.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:65ed923f84a6844de5fd29726b888e58c62820e0769b76565480e1fdc3d062f8"},
-    {file = "charset_normalizer-3.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9a3267620866c9d17b959a84dd0bd2d45719b817245e49371ead79ed4f710d19"},
-    {file = "charset_normalizer-3.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6734e606355834f13445b6adc38b53c0fd45f1a56a9ba06c2058f86893ae8017"},
-    {file = "charset_normalizer-3.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f8303414c7b03f794347ad062c0516cee0e15f7a612abd0ce1e25caf6ceb47df"},
-    {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaf53a6cebad0eae578f062c7d462155eada9c172bd8c4d250b8c1d8eb7f916a"},
-    {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3dc5b6a8ecfdc5748a7e429782598e4f17ef378e3e272eeb1340ea57c9109f41"},
-    {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e1b25e3ad6c909f398df8921780d6a3d120d8c09466720226fc621605b6f92b1"},
-    {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ca564606d2caafb0abe6d1b5311c2649e8071eb241b2d64e75a0d0065107e62"},
-    {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b82fab78e0b1329e183a65260581de4375f619167478dddab510c6c6fb04d9b6"},
-    {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:bd7163182133c0c7701b25e604cf1611c0d87712e56e88e7ee5d72deab3e76b5"},
-    {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:11d117e6c63e8f495412d37e7dc2e2fff09c34b2d09dbe2bee3c6229577818be"},
-    {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:cf6511efa4801b9b38dc5546d7547d5b5c6ef4b081c60b23e4d941d0eba9cbeb"},
-    {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:abc1185d79f47c0a7aaf7e2412a0eb2c03b724581139193d2d82b3ad8cbb00ac"},
-    {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:cb7b2ab0188829593b9de646545175547a70d9a6e2b63bf2cd87a0a391599324"},
-    {file = "charset_normalizer-3.1.0-cp311-cp311-win32.whl", hash = "sha256:c36bcbc0d5174a80d6cccf43a0ecaca44e81d25be4b7f90f0ed7bcfbb5a00909"},
-    {file = "charset_normalizer-3.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:cca4def576f47a09a943666b8f829606bcb17e2bc2d5911a46c8f8da45f56755"},
-    {file = "charset_normalizer-3.1.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:0c95f12b74681e9ae127728f7e5409cbbef9cd914d5896ef238cc779b8152373"},
-    {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fca62a8301b605b954ad2e9c3666f9d97f63872aa4efcae5492baca2056b74ab"},
-    {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ac0aa6cd53ab9a31d397f8303f92c42f534693528fafbdb997c82bae6e477ad9"},
-    {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c3af8e0f07399d3176b179f2e2634c3ce9c1301379a6b8c9c9aeecd481da494f"},
-    {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a5fc78f9e3f501a1614a98f7c54d3969f3ad9bba8ba3d9b438c3bc5d047dd28"},
-    {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:628c985afb2c7d27a4800bfb609e03985aaecb42f955049957814e0491d4006d"},
-    {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:74db0052d985cf37fa111828d0dd230776ac99c740e1a758ad99094be4f1803d"},
-    {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:1e8fcdd8f672a1c4fc8d0bd3a2b576b152d2a349782d1eb0f6b8e52e9954731d"},
-    {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:04afa6387e2b282cf78ff3dbce20f0cc071c12dc8f685bd40960cc68644cfea6"},
-    {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:dd5653e67b149503c68c4018bf07e42eeed6b4e956b24c00ccdf93ac79cdff84"},
-    {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:d2686f91611f9e17f4548dbf050e75b079bbc2a82be565832bc8ea9047b61c8c"},
-    {file = "charset_normalizer-3.1.0-cp37-cp37m-win32.whl", hash = "sha256:4155b51ae05ed47199dc5b2a4e62abccb274cee6b01da5b895099b61b1982974"},
-    {file = "charset_normalizer-3.1.0-cp37-cp37m-win_amd64.whl", hash = "sha256:322102cdf1ab682ecc7d9b1c5eed4ec59657a65e1c146a0da342b78f4112db23"},
-    {file = "charset_normalizer-3.1.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:e633940f28c1e913615fd624fcdd72fdba807bf53ea6925d6a588e84e1151531"},
-    {file = "charset_normalizer-3.1.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:3a06f32c9634a8705f4ca9946d667609f52cf130d5548881401f1eb2c39b1e2c"},
-    {file = "charset_normalizer-3.1.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7381c66e0561c5757ffe616af869b916c8b4e42b367ab29fedc98481d1e74e14"},
-    {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3573d376454d956553c356df45bb824262c397c6e26ce43e8203c4c540ee0acb"},
-    {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e89df2958e5159b811af9ff0f92614dabf4ff617c03a4c1c6ff53bf1c399e0e1"},
-    {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:78cacd03e79d009d95635e7d6ff12c21eb89b894c354bd2b2ed0b4763373693b"},
-    {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de5695a6f1d8340b12a5d6d4484290ee74d61e467c39ff03b39e30df62cf83a0"},
-    {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1c60b9c202d00052183c9be85e5eaf18a4ada0a47d188a83c8f5c5b23252f649"},
-    {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:f645caaf0008bacf349875a974220f1f1da349c5dbe7c4ec93048cdc785a3326"},
-    {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:ea9f9c6034ea2d93d9147818f17c2a0860d41b71c38b9ce4d55f21b6f9165a11"},
-    {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:80d1543d58bd3d6c271b66abf454d437a438dff01c3e62fdbcd68f2a11310d4b"},
-    {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:73dc03a6a7e30b7edc5b01b601e53e7fc924b04e1835e8e407c12c037e81adbd"},
-    {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:6f5c2e7bc8a4bf7c426599765b1bd33217ec84023033672c1e9a8b35eaeaaaf8"},
-    {file = "charset_normalizer-3.1.0-cp38-cp38-win32.whl", hash = "sha256:12a2b561af122e3d94cdb97fe6fb2bb2b82cef0cdca131646fdb940a1eda04f0"},
-    {file = "charset_normalizer-3.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:3160a0fd9754aab7d47f95a6b63ab355388d890163eb03b2d2b87ab0a30cfa59"},
-    {file = "charset_normalizer-3.1.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:38e812a197bf8e71a59fe55b757a84c1f946d0ac114acafaafaf21667a7e169e"},
-    {file = "charset_normalizer-3.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6baf0baf0d5d265fa7944feb9f7451cc316bfe30e8df1a61b1bb08577c554f31"},
-    {file = "charset_normalizer-3.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:8f25e17ab3039b05f762b0a55ae0b3632b2e073d9c8fc88e89aca31a6198e88f"},
-    {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3747443b6a904001473370d7810aa19c3a180ccd52a7157aacc264a5ac79265e"},
-    {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b116502087ce8a6b7a5f1814568ccbd0e9f6cfd99948aa59b0e241dc57cf739f"},
-    {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d16fd5252f883eb074ca55cb622bc0bee49b979ae4e8639fff6ca3ff44f9f854"},
-    {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21fa558996782fc226b529fdd2ed7866c2c6ec91cee82735c98a197fae39f706"},
-    {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6f6c7a8a57e9405cad7485f4c9d3172ae486cfef1344b5ddd8e5239582d7355e"},
-    {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:ac3775e3311661d4adace3697a52ac0bab17edd166087d493b52d4f4f553f9f0"},
-    {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:10c93628d7497c81686e8e5e557aafa78f230cd9e77dd0c40032ef90c18f2230"},
-    {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:6f4f4668e1831850ebcc2fd0b1cd11721947b6dc7c00bf1c6bd3c929ae14f2c7"},
-    {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:0be65ccf618c1e7ac9b849c315cc2e8a8751d9cfdaa43027d4f6624bd587ab7e"},
-    {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:53d0a3fa5f8af98a1e261de6a3943ca631c526635eb5817a87a59d9a57ebf48f"},
-    {file = "charset_normalizer-3.1.0-cp39-cp39-win32.whl", hash = "sha256:a04f86f41a8916fe45ac5024ec477f41f886b3c435da2d4e3d2709b22ab02af1"},
-    {file = "charset_normalizer-3.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:830d2948a5ec37c386d3170c483063798d7879037492540f10a475e3fd6f244b"},
-    {file = "charset_normalizer-3.1.0-py3-none-any.whl", hash = "sha256:3d9098b479e78c85080c98e1e35ff40b4a31d8953102bb0fd7d1b6f8a2111a3d"},
-]
-
-[[package]]
-name = "idna"
-version = "3.4"
-description = "Internationalized Domain Names in Applications (IDNA)"
-category = "main"
-optional = false
-python-versions = ">=3.5"
-files = [
-    {file = "idna-3.4-py3-none-any.whl", hash = "sha256:90b77e79eaa3eba6de819a0c442c0b4ceefc341a7a2ab77d7562bf49f425c5c2"},
-    {file = "idna-3.4.tar.gz", hash = "sha256:814f528e8dead7d329833b91c5faa87d60bf71824cd12a7530b5526063d02cb4"},
-]
-
-[[package]]
-name = "pydantic"
-version = "1.10.7"
-description = "Data validation and settings management using python type hints"
-category = "main"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "pydantic-1.10.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e79e999e539872e903767c417c897e729e015872040e56b96e67968c3b918b2d"},
-    {file = "pydantic-1.10.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:01aea3a42c13f2602b7ecbbea484a98169fb568ebd9e247593ea05f01b884b2e"},
-    {file = "pydantic-1.10.7-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:516f1ed9bc2406a0467dd777afc636c7091d71f214d5e413d64fef45174cfc7a"},
-    {file = "pydantic-1.10.7-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae150a63564929c675d7f2303008d88426a0add46efd76c3fc797cd71cb1b46f"},
-    {file = "pydantic-1.10.7-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:ecbbc51391248116c0a055899e6c3e7ffbb11fb5e2a4cd6f2d0b93272118a209"},
-    {file = "pydantic-1.10.7-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:f4a2b50e2b03d5776e7f21af73e2070e1b5c0d0df255a827e7c632962f8315af"},
-    {file = "pydantic-1.10.7-cp310-cp310-win_amd64.whl", hash = "sha256:a7cd2251439988b413cb0a985c4ed82b6c6aac382dbaff53ae03c4b23a70e80a"},
-    {file = "pydantic-1.10.7-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:68792151e174a4aa9e9fc1b4e653e65a354a2fa0fed169f7b3d09902ad2cb6f1"},
-    {file = "pydantic-1.10.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfe2507b8ef209da71b6fb5f4e597b50c5a34b78d7e857c4f8f3115effaef5fe"},
-    {file = "pydantic-1.10.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10a86d8c8db68086f1e30a530f7d5f83eb0685e632e411dbbcf2d5c0150e8dcd"},
-    {file = "pydantic-1.10.7-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d75ae19d2a3dbb146b6f324031c24f8a3f52ff5d6a9f22f0683694b3afcb16fb"},
-    {file = "pydantic-1.10.7-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:464855a7ff7f2cc2cf537ecc421291b9132aa9c79aef44e917ad711b4a93163b"},
-    {file = "pydantic-1.10.7-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:193924c563fae6ddcb71d3f06fa153866423ac1b793a47936656e806b64e24ca"},
-    {file = "pydantic-1.10.7-cp311-cp311-win_amd64.whl", hash = "sha256:b4a849d10f211389502059c33332e91327bc154acc1845f375a99eca3afa802d"},
-    {file = "pydantic-1.10.7-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:cc1dde4e50a5fc1336ee0581c1612215bc64ed6d28d2c7c6f25d2fe3e7c3e918"},
-    {file = "pydantic-1.10.7-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e0cfe895a504c060e5d36b287ee696e2fdad02d89e0d895f83037245218a87fe"},
-    {file = "pydantic-1.10.7-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:670bb4683ad1e48b0ecb06f0cfe2178dcf74ff27921cdf1606e527d2617a81ee"},
-    {file = "pydantic-1.10.7-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:950ce33857841f9a337ce07ddf46bc84e1c4946d2a3bba18f8280297157a3fd1"},
-    {file = "pydantic-1.10.7-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:c15582f9055fbc1bfe50266a19771bbbef33dd28c45e78afbe1996fd70966c2a"},
-    {file = "pydantic-1.10.7-cp37-cp37m-win_amd64.whl", hash = "sha256:82dffb306dd20bd5268fd6379bc4bfe75242a9c2b79fec58e1041fbbdb1f7914"},
-    {file = "pydantic-1.10.7-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:8c7f51861d73e8b9ddcb9916ae7ac39fb52761d9ea0df41128e81e2ba42886cd"},
-    {file = "pydantic-1.10.7-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:6434b49c0b03a51021ade5c4daa7d70c98f7a79e95b551201fff682fc1661245"},
-    {file = "pydantic-1.10.7-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64d34ab766fa056df49013bb6e79921a0265204c071984e75a09cbceacbbdd5d"},
-    {file = "pydantic-1.10.7-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:701daea9ffe9d26f97b52f1d157e0d4121644f0fcf80b443248434958fd03dc3"},
-    {file = "pydantic-1.10.7-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:cf135c46099ff3f919d2150a948ce94b9ce545598ef2c6c7bf55dca98a304b52"},
-    {file = "pydantic-1.10.7-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:b0f85904f73161817b80781cc150f8b906d521fa11e3cdabae19a581c3606209"},
-    {file = "pydantic-1.10.7-cp38-cp38-win_amd64.whl", hash = "sha256:9f6f0fd68d73257ad6685419478c5aece46432f4bdd8d32c7345f1986496171e"},
-    {file = "pydantic-1.10.7-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:c230c0d8a322276d6e7b88c3f7ce885f9ed16e0910354510e0bae84d54991143"},
-    {file = "pydantic-1.10.7-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:976cae77ba6a49d80f461fd8bba183ff7ba79f44aa5cfa82f1346b5626542f8e"},
-    {file = "pydantic-1.10.7-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7d45fc99d64af9aaf7e308054a0067fdcd87ffe974f2442312372dfa66e1001d"},
-    {file = "pydantic-1.10.7-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d2a5ebb48958754d386195fe9e9c5106f11275867051bf017a8059410e9abf1f"},
-    {file = "pydantic-1.10.7-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:abfb7d4a7cd5cc4e1d1887c43503a7c5dd608eadf8bc615413fc498d3e4645cd"},
-    {file = "pydantic-1.10.7-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:80b1fab4deb08a8292d15e43a6edccdffa5377a36a4597bb545b93e79c5ff0a5"},
-    {file = "pydantic-1.10.7-cp39-cp39-win_amd64.whl", hash = "sha256:d71e69699498b020ea198468e2480a2f1e7433e32a3a99760058c6520e2bea7e"},
-    {file = "pydantic-1.10.7-py3-none-any.whl", hash = "sha256:0cd181f1d0b1d00e2b705f1bf1ac7799a2d938cce3376b8007df62b29be3c2c6"},
-    {file = "pydantic-1.10.7.tar.gz", hash = "sha256:cfc83c0678b6ba51b0532bea66860617c4cd4251ecf76e9846fa5a9f3454e97e"},
-]
-
-[package.dependencies]
-typing-extensions = ">=4.2.0"
-
-[package.extras]
-dotenv = ["python-dotenv (>=0.10.4)"]
-email = ["email-validator (>=1.0.3)"]
-
-[[package]]
-name = "requests"
-version = "2.28.2"
-description = "Python HTTP for Humans."
-category = "main"
-optional = false
-python-versions = ">=3.7, <4"
-files = [
-    {file = "requests-2.28.2-py3-none-any.whl", hash = "sha256:64299f4909223da747622c030b781c0d7811e359c37124b4bd368fb8c6518baa"},
-    {file = "requests-2.28.2.tar.gz", hash = "sha256:98b1b2782e3c6c4904938b84c0eb932721069dfdb9134313beff7c83c2df24bf"},
-]
-
-[package.dependencies]
-certifi = ">=2017.4.17"
-charset-normalizer = ">=2,<4"
-idna = ">=2.5,<4"
-urllib3 = ">=1.21.1,<1.27"
-
-[package.extras]
-socks = ["PySocks (>=1.5.6,!=1.5.7)"]
-use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"]
-
-[[package]]
-name = "typing-extensions"
-version = "4.5.0"
-description = "Backported and Experimental Type Hints for Python 3.7+"
-category = "main"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "typing_extensions-4.5.0-py3-none-any.whl", hash = "sha256:fb33085c39dd998ac16d1431ebc293a8b3eedd00fd4a32de0ff79002c19511b4"},
-    {file = "typing_extensions-4.5.0.tar.gz", hash = "sha256:5cb5f4a79139d699607b3ef622a1dedafa84e115ab0024e0d9c044a9479ca7cb"},
-]
-
-[[package]]
-name = "urllib3"
-version = "1.26.15"
-description = "HTTP library with thread-safe connection pooling, file post, and more."
-category = "main"
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*"
-files = [
-    {file = "urllib3-1.26.15-py2.py3-none-any.whl", hash = "sha256:aa751d169e23c7479ce47a0cb0da579e3ede798f994f5816a74e4f4500dcea42"},
-    {file = "urllib3-1.26.15.tar.gz", hash = "sha256:8a388717b9476f934a21484e8c8e61875ab60644d29b9b39e11e4b9dc1c6b305"},
-]
-
-[package.extras]
-brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)", "brotlipy (>=0.6.0)"]
-secure = ["certifi", "cryptography (>=1.3.4)", "idna (>=2.0.0)", "ipaddress", "pyOpenSSL (>=0.14)", "urllib3-secure-extra"]
-socks = ["PySocks (>=1.5.6,!=1.5.7,<2.0)"]
-
-[metadata]
-lock-version = "2.0"
-python-versions = "^3.10"
-content-hash = "a8d95adf4819c22b47d4cac44f18a3bc5040d1c0487ead04cb2f09692de0d411"

sdk/pyproject.toml

@@ -1,17 +0,0 @@
-[tool.poetry]
-name = "fh-sdk"
-version = "0.1.0"
-description = ""
-authors = ["Eden Kirin <eden@ekirin.com>"]
-readme = "README.md"
-packages = [{include = "fh_sdk"}]
-
-[tool.poetry.dependencies]
-python = "^3.10"
-requests = "^2.28.2"
-pydantic = "^1.10.7"
-
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"

settings_template.py

@@ -2,17 +2,40 @@ import logging
 
 from hopper.models.config import (
     BoardSettings,
+    DebugSettings,
     GameSettings,
     InactivityWatchdogSettings,
     Settings,
     WSServerSettings,
 )
+from hopper.models.player import Player, Position
 
 settings = Settings(
     game=GameSettings(),
-    board=BoardSettings(),
+    board=BoardSettings(
+        WIDTH=20,
+        HEIGHT=20,
+        OBSTACLE_COUNT=10,
+    ),
     inacivity_watchdog=InactivityWatchdogSettings(),
+    purchase_timeout=5,
     log_level=logging.INFO,
     ws_server=WSServerSettings(),
-    debug=None,
+    debug=DebugSettings(
+        PRINT_BOARD=True,
+        PLAYERS=[
+            Player(
+                name="Pero",
+                id="test-player-pero",
+                position=Position(x=9, y=10),
+                can_be_deactivated=False,
+            ),
+            Player(
+                name="Mirko",
+                id="test-player-mirko",
+                position=Position(x=10, y=5),
+                can_be_deactivated=False,
+            ),
+        ],
+    ),
 )