uuid -> id

Product purchase
2023-03-31 17:20:23 +02:00 · 2023-03-31 17:16:00 +02:00 · 2023-03-31 13:06:27 +02:00 · 2023-03-31 12:19:48 +02:00 · 2023-03-31 11:51:05 +02:00 · 2023-03-31 10:19:21 +02:00
26 changed files with 699 additions and 234 deletions
--- a/README.md
+++ b/README.md
@ -100,6 +100,7 @@ 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
@ -129,6 +130,7 @@ WS --> ExtVis2: WS Game State
 ### WebSockets

 ```plantuml
+scale 1024 width
 box "FairHopper Game Server" #lightcyan
    participant Game as "Game Engine"
    participant WS as "WS Server"
@ -136,6 +138,8 @@ endbox
 participant Client1 as "Visualisation\nClient 1"
 participant Client2 as "Visualisation\nClient 2"

+== Player movement mode ==
+
 Game ->o WS: Send initial state

 Client1 ->o WS: Client connect
@ -155,6 +159,27 @@ loop #lightyellow On game state change
        WS o-> Client2: Game state
    deactivate
 end
+
+== Product purchase mode ==
+
+Game -> WS: Purchase start
+activate WS #coral
+	WS o-> Client1: Purchase start
+	WS o-> Client2: Purchase start
+deactivate
+
+loop #lightyellow Purchase countdown timer
+	Game ->o WS: Timer count down
+    activate WS #coral
+        WS o-> Client1: Purchase time left
+        WS o-> Client2: Purchase time left
+    deactivate
+end
+Game -> WS: Purchase done
+activate WS #coral
+	WS o-> Client1: Purchase done
+	WS o-> Client2: Purchase done
+deactivate
 ```


@ -195,7 +220,7 @@ Response body:
 		}
 	},
 	"player": {
-		"uuid": "75bba7cd-a4c1-4b50-b0b5-6382c2822a25",
+		"id": "75bba7cd-a4c1-4b50-b0b5-6382c2822a25",
 		"name": "Pero",
 		"position": {
 			"x": 0,
@ -209,17 +234,17 @@ 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

@ -227,7 +252,7 @@ Response body:
 ```json
 {
 	"player": {
-		"uuid": "string",
+		"id": "string",
 		"name": "Pero",
 		"position": {
 			"x": 50,
@ -241,7 +266,7 @@ Response body:

 ### Get Player Info

-GET `/player/{{uuid}}`
+GET `/player/{{id}}`

 Request body: None

@ -249,7 +274,7 @@ Response body:
 ```json
 {
 	"player": {
-		"uuid": "string",
+		"id": "string",
 		"name": "Pero",
 		"position": {
 			"x": 50,
@ -309,7 +334,7 @@ Data:
 	},
 	"players": [
 		{
-			"uuid": "test-player-id",
+			"id": "test-player-id",
 			"name": "Pero",
 			"active": true,
 			"position": {
@ -320,7 +345,7 @@ Data:
 			"move_attempt_count": 3
 		},
 		{
-			"uuid": "95962b49-0003-4bf2-b205-71f2590f2318",
+			"id": "95962b49-0003-4bf2-b205-71f2590f2318",
 			"name": "Mirko",
 			"active": true,
 			"position": {
--- a/api_tests/requests.http
+++ b/api_tests/requests.http
@ -34,6 +34,15 @@ POST http://localhost:8010/player/test-player-pero/move/up
 POST http://localhost:8010/player/test-player-pero/move/down
 ###

+# purchase product
+POST http://localhost:8010/player/test-player-pero/product/purchase
+Content-Type: application/json
+
+{
+  "product_id": "cocacola-id"
+}
+###
+
 # move Mirko left
 POST http://localhost:8010/player/test-player-mirko/move/left
 ###
--- a/frontend/img/products/Burek.jpeg
+++ b/frontend/img/products/Burek.jpeg
--- a/frontend/img/products/CocaCola.jpeg
+++ b/frontend/img/products/CocaCola.jpeg
--- a/frontend/img/products/Fanta.jpeg
+++ b/frontend/img/products/Fanta.jpeg
--- a/frontend/img/products/Mars.jpeg
+++ b/frontend/img/products/Mars.jpeg
--- a/frontend/img/products/Pepsi.jpeg
+++ b/frontend/img/products/Pepsi.jpeg
--- a/frontend/img/products/Snickers.jpeg
+++ b/frontend/img/products/Snickers.jpeg
--- a/frontend/index.html
+++ b/frontend/index.html
@ -8,15 +8,25 @@
    <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="js/frontend.js"></script>

    <title>FairHopper Visualisation Client</title>
 </head>

 <body>
-    <div class="container-fluid">
+    <main class="container-fluid container">
        <h1 class="mt-1 mb-2">
            FairHopper Visualisation Client
        </h1>
+        <div id="purchase-container" class="purchase-container d-none">
+            <div class="d-flex header">
+                <h3>
+                    Product selection
+                </h3>
+                <h3 id="purchase-countdown" class="countdown"></h3>
+            </div>
+            <div id="products-content" class="products-content"></div>
+        </div>
        <div class="row">
            <div class="col-10">
                <div class="board-container">
@ -30,125 +40,7 @@
                <ul class="players" id="players-content"></ul>
            </div>
        </div>
-    </div>
+    </main>
 </body>

-<script>
-    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) {
-        const html = 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("");
-        document.getElementById("players-content").innerHTML = html;
-    }
-
-    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) {
-                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, BOARD_ICONS.OBSTACLE);
-        });
-    }
-
-    function renderDestination(position) {
-        renderCellContent(position, BOARD_ICONS.DESTINATION);
-    }
-
-
-    function wsConnect() {
-        let ws = new WebSocket('ws://localhost:8011');
-        ws.onopen = () => {
-            console.log("WS connected")
-        };
-
-        ws.onmessage = (e) => {
-            const data = JSON.parse(e.data);
-            console.log("WS message received:", data)
-
-            createBoard(data.board);
-            renderObstacles(data.layers)
-            renderDestination(data.destination.position);
-            renderPlayerList(data.players);
-            renderPlayers(data.players);
-        };
-
-        ws.onclose = (e) => {
-            setTimeout(function () {
-                wsConnect();
-            }, 1000);
-        };
-
-        ws.onerror = (err) => {
-            console.error("Socket encountered error:", err.message, "Closing socket");
-            ws.close();
-        };
-    }
-
-    window.onload = () => {
-        wsConnect();
-    }
-</script>
-
-
 </html>
--- a/frontend/js/frontend.js
+++ b/frontend/js/frontend.js
@ -0,0 +1,179 @@
+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) {
+    const html = 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("");
+    document.getElementById("players-content").innerHTML = html;
+}
+
+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) {
+                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, 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 productPurchaseStart(products, purchaseTimeout) {
+    console.log("productPurchaseStart:", products);
+    const containerElement = document.getElementById("purchase-container");
+    const contentElement = document.getElementById("products-content");
+    const purchaseTimeoutElement = document.getElementById("purchase-countdown");
+
+    const html = products
+        .map((product) => {
+            return `
+                <div class="card product">
+                    <img src="img/products/${product.name}.jpeg" class="card-img-topx" alt="${product.name}">
+                    <div class="card-body">
+                        <h5 class="card-title">${product.name}</h5>
+                    </div>
+                </div>
+            `;
+        })
+        .join("");
+
+    contentElement.innerHTML = html;
+    containerElement.classList.remove("d-none");
+    purchaseTimeoutElement.innerText = purchaseTimeout;
+}
+
+function productPurchaseTimerTick(timeLeft) {
+    const purchaseTimeoutElement = document.getElementById("purchase-countdown");
+    purchaseTimeoutElement.innerText = timeLeft;
+}
+
+function productPurchased(product) {
+    console.log("productPurchased:", product);
+}
+
+function productPurchaseDone() {
+    console.log("productPurchaseDone");
+    const container = document.getElementById("purchase-container");
+    container.classList.add("d-none");
+}
+
+function wsConnect() {
+    let ws = new WebSocket("ws://localhost:8011");
+    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 "product_purchase_start":
+                productPurchaseStart(wsMessage.data.products, wsMessage.data.timeout);
+                break;
+            case "product_purchase_timer_tick":
+                productPurchaseTimerTick(wsMessage.data.time_left);
+                break;
+            case "product_purchased":
+                productPurchased(wsMessage.data);
+                break;
+            case "product_purchase_done":
+                productPurchaseDone();
+                break;
+            default:
+                console.error("Unknown message:", wsMessage);
+        }
+    };
+
+    ws.onclose = (e) => {
+        setTimeout(function () {
+            wsConnect();
+        }, 1000);
+    };
+
+    ws.onerror = (err) => {
+        console.error("Socket encountered error:", err.message, "Closing socket");
+        ws.close();
+    };
+}
+
+window.onload = () => {
+    wsConnect();
+};
--- a/frontend/styles.css
+++ b/frontend/styles.css
@ -2,6 +2,10 @@ body {
    background-color: whitesmoke;
 }

+main.container {
+    position: relative;
+}
+
 .board-container {
    background-color: white;
    border: 1px solid black;
@ -40,7 +44,6 @@ ul.players {
    color: white;
    background-color: darkred;
    border-radius: 5px;
-    z-index: 1000;
 }

 .player-tooltip::after {
@ -53,3 +56,39 @@ ul.players {
    border-style: solid;
    border-color: darkred transparent transparent transparent;
 }
+
+.purchase-container {
+    width: 50vw;
+    position: fixed;
+    top: 200px;
+    left: 50%;
+    padding: 20px;
+    transform: translateX(-50%);
+    background-color: darkred;
+    z-index: 999;
+    border-radius: 10px;
+}
+
+.purchase-container .header {
+    color: white;
+    margin-bottom: 20px;
+}
+
+.purchase-container .header .countdown {
+    margin-left: auto;
+}
+
+.purchase-container .products-content {
+    display: grid;
+    grid-gap: 10px;
+    grid-template-columns: 1fr 1fr 1fr;
+}
+
+.purchase-container .products-content .product .card-title {
+    text-align: center;
+}
+
+.purchase-container .products-content .product img {
+    margin: 20px;
+    max-height: 300px;
+}
--- a/hopper/api/dependencies.py
+++ b/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)
--- a/hopper/api/dto.py
+++ b/hopper/api/dto.py
@ -1,5 +1,7 @@
 from __future__ import annotations

+from typing import Optional
+
 from pydantic import BaseModel as PydanticBaseModel

 from hopper.enums import PlayerState
@ -25,7 +27,7 @@ class PositionDto(BaseModel):


 class PlayerDto(BaseModel):
-    uuid: str
+    id: str
    name: str
    active: bool
    position: PositionDto
@ -38,6 +40,11 @@ class DestinationDto(BaseModel):
    position: PositionDto


+class ProductDto(BaseModel):
+    name: str
+    id: str
+    description: Optional[str] = None
+
 class StartGameRequestDto(BaseModel):
    player_name: str

@ -61,3 +68,11 @@ class PlayerInfoResponseDto(MovePlayerResponseDto):

 class ErrorResponseDto(BaseModel):
    detail: str
+
+
+class GetProductsResponse(BaseModel):
+    products: list[ProductDto]
+
+
+class PurchaseProductDto(BaseModel):
+    product_id: str
--- a/hopper/api/views.py
+++ b/hopper/api/views.py
@ -6,22 +6,26 @@ from hopper.api.dto import (
    DestinationDto,
    ErrorResponseDto,
    GameInfoDto,
+    GetProductsResponse,
    MovePlayerResponseDto,
    PingResponse,
    PlayerInfoResponseDto,
+    ProductDto,
+    PurchaseProductDto,
    StartGameRequestDto,
    StartGameResponseDto,
 )
 from hopper.engine import GameEngine
 from hopper.enums import Direction, PlayerMoveResult
-from hopper.errors import Collision, GameLockForMovement, PositionOutOfBounds
+from hopper.errors import Collision, GameLockForMovement, PositionOutOfBounds, PurchaseForbiddenForPlayer
 from hopper.models.player import Player
+from settings import settings

 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"
@ -72,7 +76,7 @@ async def start_game(


@router.get(
-    "/player/{uuid}",
+    "/player/{id}",
    response_model=PlayerInfoResponseDto,
    responses={
        status.HTTP_403_FORBIDDEN: {
@ -81,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",
        },
    },
 )
@ -92,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={
@ -106,7 +110,7 @@ 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,
@ -144,3 +148,42 @@ async def move_player(
        response.status_code = status.HTTP_200_OK

    return MovePlayerResponseDto(player=player)
+
+
+@router.get("/products", response_model=GetProductsResponse)
+async def get_products() -> GetProductsResponse:
+    return GetProductsResponse(
+        products=settings.products,
+    )
+
+
+@router.get("/products/{id}", response_model=ProductDto)
+async def get_product(id: str) -> ProductDto:
+    for product in settings.products:
+        if product.id == id:
+            return ProductDto.from_orm(product)
+    raise HTTPException(
+        status_code=status.HTTP_404_NOT_FOUND, detail="Product not found"
+    )
+
+
+@router.post("/player/{id}/product/purchase")
+async def purchase_product(
+    body: PurchaseProductDto,
+    engine: GameEngine = Depends(get_game_engine),
+    player: Player = Depends(get_player),
+):
+    for product in settings.products:
+        if product.id == body.product_id:
+            try:
+                await engine.purchase_product(player=player, product=product)
+            except PurchaseForbiddenForPlayer:
+                raise HTTPException(
+                    status_code=status.HTTP_403_FORBIDDEN,
+                    detail="Purchase forbidden for this player",
+                )
+            break
+    else:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Product not found"
+        )
--- a/hopper/countdown_timer.py
+++ b/hopper/countdown_timer.py
@ -5,21 +5,27 @@ from typing import Callable, Optional

 class CountdownTimer(Thread):
    def __init__(
-        self, seconds: int, callback: Optional[Callable[[], None]] = None
+        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.callback = callback
-        super().__init__()
+        self.timer_tick_callback = timer_tick_callback
+        self.timer_done_callback = timer_done_callback
+        super().__init__(daemon=True)

    def run(self) -> None:
-        cnt = self.seconds
-        while cnt > 0 and not self.stop_event.is_set():
-            cnt -= 1
+        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 cnt == 0 and self.callback:
-            self.callback()
+        if time_left == 0 and self.timer_done_callback:
+            self.timer_done_callback()

    def stop(self) -> None:
        self.stop_event.set()
--- a/hopper/engine.py
+++ b/hopper/engine.py
@ -4,9 +4,13 @@ import random
 from typing import Optional

 from hopper.countdown_timer import CountdownTimer
-from hopper.enums import Direction, PlayerMoveResult, GameState, PlayerState
-from hopper.errors import Collision, PositionOutOfBounds, GameLockForMovement
-from hopper.interfaces import SendGameDumpInterface
+from hopper.enums import Direction, GameState, PlayerMoveResult, PlayerState
+from hopper.errors import (
+    Collision,
+    GameLockForMovement,
+    PositionOutOfBounds,
+    PurchaseForbiddenForPlayer,
+)
 from hopper.models.board import (
    BOARD_DUMP_CHARS,
    BoardLayout,
@ -18,20 +22,37 @@ from hopper.models.board import (
    create_random_position,
 )
 from hopper.models.player import Player, PlayerList, Position
+from hopper.models.product import Product
 from hopper.watchdog import InactivityWatchdog
+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[SendGameDumpInterface] = 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.reset_game()
+        self.game_state = GameState.RUNNING
+        self.__debug_print_board()

    def dump_board(self) -> list[list[str]]:
        dump = self.board.dump()
@ -60,19 +81,24 @@ class GameEngine:
            self._inacivity_watchdog = InactivityWatchdog(
                players=self.players,
                ws_server=self.ws_server,
-                daemon=True,
            )
            self._inacivity_watchdog.start()

+    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)
@ -80,27 +106,10 @@ class GameEngine:
        logging.info(f"Starting new game for player: {player}")
        self.__debug_print_board()

-        if self.ws_server:
-            await self.ws_server.send_game_dump()
-
+        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:
@ -144,19 +153,12 @@ class GameEngine:

        if self._is_player_on_destination(player):
            player.state = PlayerState.ON_DESTINATION
-            logging.info(f"Player {player} reached destination!")
-
-        if self.ws_server:
-            await self.ws_server.send_game_dump()
-
-        self.__debug_print_board()
-
-        if player.state == PlayerState.ON_DESTINATION:
-            self.game_state = GameState.LOCK_FOR_MOVEMENT
+            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:
@ -170,9 +172,63 @@ class GameEngine:
    def _colided_with_obstacle(self, position: Position) -> bool:
        return self.board.get_object_at_position(position) is not None

-    def _player_on_destination(self, player: Player) -> None:
+    async def _player_on_destination(self, player: Player) -> None:
+        logging.info(f"Player {player} reached destination!")
+
        self.game_state = GameState.LOCK_FOR_MOVEMENT
-        self._purchase_countdown_timer = CountdownTimer()
+        await self.send_game_dump()
+
+        await self.ws_server.send_product_purchase_start_message(
+            player=player, products=settings.products
+        )
+
+        logging.info(
+            f"Starting purchase countdown timer for {settings.purchase_timeout} seconds"
+        )
+
+        def on_purchase_timer_tick(time_left) -> None:
+            logging.info(f"Purchase countdown timer tick, time left: {time_left}")
+            asyncio.run(
+                self.ws_server.send_product_purchase_time_left_message(
+                    player=player, time_left=time_left
+                )
+            )
+
+        def on_purchase_timer_done() -> None:
+            logging.info("Ding ding! Purchase countdown timer timeout")
+            self._purchase_countdown_timer = None
+            asyncio.run(
+                self.ws_server.send_product_purchase_done_message(
+                    player=player, product=None
+                )
+            )
+            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()
+
+    async def purchase_product(self, player: Player, product: Product) -> None:
+        if not player.state == PlayerState.ON_DESTINATION:
+            raise PurchaseForbiddenForPlayer()
+        if self._purchase_countdown_timer:
+            self._purchase_countdown_timer.stop()
+        await self.ws_server.send_product_purchase_done_message(
+            player=player, product=product
+        )
+        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)
@ -184,7 +240,7 @@ class GameEngineFactory:
        board_width: int,
        board_height: int,
        obstacle_count: int = 0,
-        ws_server: Optional[SendGameDumpInterface] = None,
+        ws_server: WSServer = None,
    ) -> GameEngine:
        board = GameBoard(
            width=board_width,
@ -210,7 +266,7 @@ class GameEngineFactory:

    @staticmethod
    def create_default(
-        ws_server: Optional[SendGameDumpInterface] = None,
+        ws_server: WSServer = None,
    ) -> GameEngine:
        return GameEngineFactory.create(
            board_width=settings.board.WIDTH,
--- a/hopper/errors.py
+++ b/hopper/errors.py
@ -12,3 +12,7 @@ class Collision(BaseError):

 class GameLockForMovement(BaseError):
    ...
+
+
+class PurchaseForbiddenForPlayer(BaseError):
+    ...
--- a/hopper/interfaces.py
+++ b/hopper/interfaces.py
@ -1,6 +0,0 @@
-from typing import Protocol
-
-
-class SendGameDumpInterface(Protocol):
-    async def send_game_dump(self) -> None:
-        ...
--- a/hopper/models/config.py
+++ b/hopper/models/config.py
@ -3,6 +3,7 @@ from dataclasses import dataclass
 from typing import List, Optional

 from hopper.models.player import Player
+from hopper.models.product import Product


@dataclass
@ -44,4 +45,5 @@ class Settings:
    ws_server: WSServerSettings
    purchase_timeout: int = 10 # seconds
    log_level: int = logging.INFO
+    products: Optional[List[Product]] = None
    debug: Optional[DebugSettings] = None
--- a/hopper/models/player.py
+++ b/hopper/models/player.py
@ -15,7 +15,7 @@ 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
@ -31,8 +31,8 @@ class Player:


 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
--- a/hopper/models/product.py
+++ b/hopper/models/product.py
@ -0,0 +1,10 @@
+import uuid
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class Product:
+    name: str
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    description: Optional[str] = None
--- a/hopper/models/ws_dto.py
+++ b/hopper/models/ws_dto.py
@ -1,8 +1,19 @@
 from __future__ import annotations

-from pydantic import Field
+import json
+from typing import Optional, TypeVar

-from hopper.api.dto import BaseModel, BoardDto, DestinationDto, PlayerDto, PositionDto
+from pydantic import Field
+from pydantic.generics import GenericModel
+
+from hopper.api.dto import (
+    BaseModel,
+    BoardDto,
+    DestinationDto,
+    PlayerDto,
+    PositionDto,
+    ProductDto,
+)
 from hopper.enums import ObjectType


@ -15,12 +26,59 @@ class LayerDto(BaseModel):
    name: str
    objects: list[LayerObjectDto]

-class GameDumpPlayerDto(PlayerDto):
-    ...
-

 class GameDumpDto(BaseModel):
    board: BoardDto
    destination: DestinationDto
-    players: list[GameDumpPlayerDto]
+    players: list[PlayerDto]
    layers: list[LayerDto]
+
+
+class ProductPurchaseStartDto(BaseModel):
+    player: PlayerDto
+    products: list[ProductDto]
+    timeout: int
+
+
+class ProductPurchaseTimerDto(BaseModel):
+    time_left: int
+    player: PlayerDto
+
+
+class ProductPurchaseDoneDto(BaseModel):
+    player: PlayerDto
+    product: Optional[ProductDto] = None
+
+
+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())
+
+
+class WSGameDumpMessage(WSMessage):
+    message: str = "game_dump"
+    data: GameDumpDto
+
+
+class WSProductPurchaseStartMessage(WSMessage):
+    message: str = "product_purchase_start"
+    data: ProductPurchaseStartDto
+
+
+class WSProductPurchaseTimerTickMessage(WSMessage):
+    message: str = "product_purchase_timer_tick"
+    data: ProductPurchaseTimerDto
+
+
+class WSProductPurchaseDoneMessage(WSMessage):
+    message: str = "product_purchase_done"
+    data: ProductPurchaseDoneDto
--- a/hopper/watchdog.py
+++ b/hopper/watchdog.py
@ -3,25 +3,20 @@ import datetime
 import logging
 import time
 from threading import Thread
-from typing import Optional

-from hopper.interfaces import SendGameDumpInterface
 from hopper.models.player import PlayerList
+from hopper.ws_server import WSServer
 from settings import settings


 class InactivityWatchdog(Thread):
    def __init__(
-        self,
-        players: PlayerList,
-        ws_server: Optional[SendGameDumpInterface] = None,
-        *args,
-        **kwargs,
+        self, players: PlayerList, ws_server: WSServer = None
    ) -> None:
        self.players = players
        self.ws_server = ws_server
        self.stopped = False
-        super().__init__(*args, **kwargs)
+        super().__init__(daemon=True)

    def run(self) -> None:
        logging.info("Starting inactivity watchdog")
@ -65,8 +60,6 @@ class InactivityWatchdog(Thread):
            self.send_game_dump()

    def send_game_dump(self):
-        if not self.ws_server:
-            return
        logging.info("Sending WS game dump")
        asyncio.run(self.ws_server.send_game_dump())

--- a/hopper/ws_server.py
+++ b/hopper/ws_server.py
@ -1,17 +1,34 @@
 import asyncio
-import json
 import logging
 from threading import Thread
+from typing import Iterable, Optional

 import websockets
 from websockets import WebSocketServerProtocol
 from websockets.exceptions import ConnectionClosedOK

-from hopper.models.ws_dto import GameDumpDto
+from hopper.models.player import Player
+from hopper.models.product import Product
+from hopper.models.ws_dto import (
+    GameDumpDto,
+    ProductPurchaseDoneDto,
+    ProductPurchaseStartDto,
+    ProductPurchaseTimerDto,
+    WSGameDumpMessage,
+    WSMessage,
+    WSProductPurchaseDoneMessage,
+    WSProductPurchaseStartMessage,
+    WSProductPurchaseTimerTickMessage,
+)
 from settings import settings


 class WSServer(Thread):
+    def __init__(self, host: str, port: int) -> None:
+        self.host = host
+        self.port = port
+        super().__init__(daemon=True)
+
    async def handler(self, websocket: WebSocketServerProtocol) -> None:
        """New handler instance spawns for each connected client"""
        self.connected_clients.add(websocket)
@ -32,7 +49,20 @@ class WSServer(Thread):
            self.connected_clients.remove(websocket)
            logging.info(f"Remove client: {websocket.id}")

-    def _create_game_dump_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

@ -44,7 +74,7 @@ class WSServer(Thread):
            players=engine.players,
            layers=engine.get_board_layout().layers,
        )
-        return json.dumps(game_dump.dict())
+        return WSGameDumpMessage(data=game_dump)

    async def send_game_dump_to_client(
        self, websocket: WebSocketServerProtocol
@ -52,29 +82,53 @@ class WSServer(Thread):
        """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)
+        await websocket.send(message.to_str())

    async def send_game_dump(self) -> None:
        """Broadcast game state to all connected clients"""
-        if not self.connected_clients:
-            return
-
        message = self._create_game_dump_message()
-        logging.debug(
-            f"Sending game dump to clients: {self.connected_clients}: {message}"
+        await self.send_message_to_clients(message)
+
+    async def send_product_purchase_start_message(
+        self, player: Player, products: Iterable[Product]
+    ) -> None:
+        message = WSProductPurchaseStartMessage(
+            data=ProductPurchaseStartDto(
+                player=player,
+                products=products,
+                timeout=settings.purchase_timeout,
+            )
        )
-        for client in self.connected_clients:
-            await client.send(message)
+        await self.send_message_to_clients(message)
+
+    async def send_product_purchase_time_left_message(
+        self, player: Player, time_left: int
+    ) -> None:
+        message = WSProductPurchaseTimerTickMessage(
+            data=ProductPurchaseTimerDto(
+                player=player,
+                time_left=time_left,
+            )
+        )
+        await self.send_message_to_clients(message)
+
+    async def send_product_purchase_done_message(
+        self, player: Player, product: Optional[Product] = None
+    ) -> None:
+        message = WSProductPurchaseDoneMessage(
+            data=ProductPurchaseDoneDto(player=player, product=product),
+        )
+        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

--- a/sdk/demo.py
+++ b/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
--- a/settings_template.py
+++ b/settings_template.py
@ -2,18 +2,49 @@ import logging

 from hopper.models.config import (
    BoardSettings,
+    DebugSettings,
    GameSettings,
    InactivityWatchdogSettings,
    Settings,
    WSServerSettings,
 )
+from hopper.models.player import Player, Position
+from hopper.models.product import Product

 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,
+    products=[
+        Product(name="CocaCola", id="cocacola-id"),
+        Product(name="Pepsi", id="pepsi-id"),
+        Product(name="Fanta", id="fanta-id"),
+        Product(name="Snickers", id="snickers-id"),
+        Product(name="Mars", id="mars-id"),
+        Product(name="Burek", id="burek-id"),
+    ],
    ws_server=WSServerSettings(),
-    purchase_timeout=10,
-    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,
+            ),
+        ],
+    ),
 )
Author	SHA1	Message	Date
Eden Kirin	80c7c80451	uuid -> id	2023-03-31 17:20:23 +02:00
Eden Kirin	d45aca6c30	uuid -> id	2023-03-31 17:16:00 +02:00
Eden Kirin	28a981980f	Product purchase	2023-03-31 13:06:27 +02:00
Eden Kirin	e1e77aba96	Optimizations	2023-03-31 12:19:48 +02:00
Eden Kirin	659ca82d74	Send player info with product purchase data	2023-03-31 11:51:05 +02:00
Eden Kirin	210a6aff7c	Producs on FE	2023-03-31 10:19:21 +02:00
Eden Kirin	c9707c0523	Threads creation optimization	2023-03-30 21:13:54 +02:00
Eden Kirin	059408242c	Send purchase state	2023-03-30 21:09:11 +02:00
Eden Kirin	6111d07f09	WSMessage object	2023-03-30 18:53:24 +02:00
Eden Kirin	b80130d942	Purchase timeout	2023-03-30 13:16:25 +02:00