Uses prebuilt server image

Simplifies deployment by using a prebuilt Docker image for the server.

Removes build configuration and related port mappings from the compose file, relying on the image configuration instead.

Also adds a compose template file with the original configuration.

.sqlx/query-39e83c6ab9294d5b771f3e01ed3709e9ab08d8cf1287b325a0df57521c2d83bc.json

@@ -12,7 +12,8 @@
               "Enum": [
                 "waiting",
                 "p1turn",
-                "p2turn"
+                "p2turn",
+                "gameover"
               ]
             }
           }

.sqlx/query-6108a32cad01040d876e139b882da3d6a28c448b5a0ad12a67d8e77c64e7c230.json

@@ -23,7 +23,8 @@
               "Enum": [
                 "waiting",
                 "p1turn",
-                "p2turn"
+                "p2turn",
+                "gameover"
               ]
             }
           }

.sqlx/query-ae4cbc5afe767fbbceeb6c056dbbab2abcd3a8066bd48dde6cb559e4a74d73e9.json

@@ -13,7 +13,8 @@
               "Enum": [
                 "waiting",
                 "p1turn",
-                "p2turn"
+                "p2turn",
+                "gameover"
               ]
             }
           }

Cargo.lock

@@ -154,7 +154,7 @@ checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
 
 [[package]]
 name = "battleship"
-version = "1.1.2"
+version = "1.2.0"
 dependencies = [
  "axum",
  "dotenv",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "battleship"
-version = "1.1.2"
+version = "1.2.0"
 edition = "2021"
 
 [dependencies]

app/src/lib/state.svelte.ts

@@ -1,6 +1,6 @@
 import { io, Socket } from "socket.io-client";
 
-export type Phase = 'placement' | 'waiting' | 'selfturn' | 'otherturn';
+export type Phase = 'placement' | 'waiting' | 'selfturn' | 'otherturn' | 'gameover';
 export type CellType = 'e' | 's' | 'h' | 'm'; // empty, ship, hit, miss
 
 export class State {
@@ -29,15 +29,19 @@ export class State {
             this.room = room;
             this.users = users;
         });
-
         this.socket.on('upload', (_, callback) => {
+            if (this.phase == 'gameover') {
+                this.playerBoard.randomize();
+                this.opponentBoard = new Board(true);
+                this.phase = 'waiting';
+            }
             callback(this.playerBoard.board);
         });
         this.socket.on('turnover', (id) => {
             this.turn = (id == this.socket.id) ? 1 : -1;
             this.phase = this.turn ? 'selfturn' : 'otherturn';
         });
-        this.socket.on('attacked', ({ by, at, hit, sunk }) => {
+        this.socket.on('attacked', ({ by, at, hit, sunk, game_over }) => {
             const [i, j]: [number, number] = at;
             const board = by == this.socket.id ? this.opponentBoard : this.playerBoard;
             if (by == this.socket.id) {
@@ -70,13 +74,19 @@ export class State {
                     }
                 }
             }
+            if (game_over) {
+                this.phase = 'gameover';
+            }
         });
 
-        this.socket.on('restore', ({ turn, player, opponent }: { turn: boolean, player: string[], opponent: string[] }) => {
+        this.socket.on('restore', ({ turn, player, opponent, gameover }: { turn: boolean, player: string[], opponent: string[], gameover: boolean }) => {
             this.turn = turn ? 1 : -1;
             this.phase = this.turn ? 'selfturn' : 'otherturn';
             this.playerBoard.board = player.map((s) => s.split('').map(c => c as CellType));
             this.opponentBoard.board = opponent.map((s) => s.split('').map(c => c as CellType));
+            if (gameover) {
+                this.phase = 'gameover';
+            }
         })
     }
 
@@ -94,13 +104,17 @@ export class State {
 
     joinRoom(code: string) {
         code = code.toUpperCase();
-        if (code.length != 4 || code == this.room) return;
+        if (code.length != 4 || code == this.room && this.phase !== 'gameover') return;
         this.socket.emit('join', code);
     }
 
     hasNotStarted() {
         return this.phase == 'placement' || this.phase == 'waiting';
     }
+
+    playAgain() {
+        this.joinRoom(this.room);
+    }
 }
 
 

app/src/routes/+page.svelte

@@ -43,10 +43,7 @@
 								<div class="font-mono font-bold">{gameState.users}</div>
 								<Users />
 							</div>
-							<button
+							<button class="btn btn-error text-xl" onclick={leaveRoom}>Leave</button>
-								class="btn btn-error text-xl"
-								onclick={leaveRoom}>Leave</button
-							>
 						</div>
 					{/if}
 				</div>
@@ -69,13 +66,33 @@
 								board={gameState.opponentBoard}
 								callback={(i, j) => gameState.attack(i, j)}
 							/>
+
+							{#if gameState.phase === 'gameover'}
+								<div
+									class="absolute inset-0 flex items-center justify-center bg-black bg-opacity-50 pointer-events-none"
+								>
+									<div class="p-6 bg-base-300 rounded-xl text-center">
+										<h3 class="text-2xl font-semibold">Game Over</h3>
+										<p class="text-lg">
+											{gameState.turn >= 0 ? 'You win!' : 'You lose!'}
+										</p>
+										<button
+											class="btn btn-primary mt-4 pointer-events-auto"
+											onclick={() => gameState.playAgain()}
+										>
+											Play Again
+										</button>
+										<button class="btn btn-secondary mt-4 ml-4 pointer-events-auto" onclick={leaveRoom}>Leave</button>
+									</div>
+								</div>
+							{/if}
 							{#if gameState.hasNotStarted()}
 								<Join
 									class="absolute top-[24px] left-[15px] w-[calc(100%-15px)] h-[calc(100%-24px)]"
 									roomCode={gameState.room}
 									createRoom={() => gameState.createRoom()}
 									joinRoom={(code) => gameState.joinRoom(code)}
-									leaveRoom={leaveRoom}
+									{leaveRoom}
 								/>
 							{/if}
 						</div>

compose.yaml

@@ -1,12 +1,10 @@
 services:
   server:
-    build:
+    image: docker.registry.computerliebe.org/battleship
-      context: .
-      target: final
     environment:
       DATABASE_URL: postgres://postgres:${DATABASE_PASSWORD}@db:5432/${DATABASE_NAME}
-    ports:
+    # ports:
-      - 3000:3000
+    #   - 3000:3000
     depends_on:
       db:
         condition: service_healthy
@@ -20,10 +18,10 @@ services:
     environment:
       POSTGRES_DB: ${DATABASE_NAME}
       POSTGRES_PASSWORD: ${DATABASE_PASSWORD}
-    ports:
+    # ports:
-      - 5432:5432
+    #   - 5432:5432
-    expose:
+    # expose:
-      - 5432
+    #   - 5432
     healthcheck:
       test: [ "CMD", "pg_isready" ]
       interval: 10s

compose.yaml.template

@@ -0,0 +1,34 @@
+services:
+  server:
+    build:
+      context: .
+      target: final
+    environment:
+      DATABASE_URL: postgres://postgres:${DATABASE_PASSWORD}@db:5432/${DATABASE_NAME}
+    ports:
+      - 3000:3000
+    depends_on:
+      db:
+        condition: service_healthy
+
+  db:
+    image: postgres
+    restart: always
+    user: postgres
+    volumes:
+      - db-data:/var/lib/postgresql/data
+    environment:
+      POSTGRES_DB: ${DATABASE_NAME}
+      POSTGRES_PASSWORD: ${DATABASE_PASSWORD}
+    ports:
+      - 5432:5432
+    expose:
+      - 5432
+    healthcheck:
+      test: [ "CMD", "pg_isready" ]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+volumes:
+  db-data:
+

migrations/0001_schema.sql

@@ -1,5 +1,5 @@
 -- DROP OWNED BY CURRENT_USER CASCADE;
-CREATE TYPE STAT AS ENUM ('waiting', 'p1turn', 'p2turn');
+CREATE TYPE STAT AS ENUM ('waiting', 'p1turn', 'p2turn', 'gameover');
 
 CREATE TABLE IF NOT EXISTS players (
     id CHAR(16) PRIMARY KEY,

src/board.rs

@@ -134,6 +134,10 @@ impl Board {
         self
     }
 
+    pub fn is_game_over(&self) -> bool {
+        !self.iter().any(|row| row.iter().any(|&cell| cell == 's'))
+    }
+
     // fn validate_syntax(&self) -> bool {
     //     self
     //         .iter()

src/game.rs

@@ -15,6 +15,8 @@ pub enum Error {
     RoomFull(Option<String>),
     #[error("Room not full")]
     RoomNotFull,
+    #[error("GameOver room joined")]
+    GameOverRoom,
     #[error("Already in room")]
     AlreadyInRoom,
     #[error("Not in room")]
@@ -33,6 +35,7 @@ pub enum Status {
     Waiting,
     P1Turn,
     P2Turn,
+    GameOver,
 }
 
 pub async fn room_if_player_exists(sid: &str, pool: &sqlx::PgPool) -> Result<Option<String>> {
@@ -79,7 +82,7 @@ pub async fn add_room(sid: Sid, pool: &sqlx::PgPool) -> Result<String> {
 pub async fn join_room(sid: Sid, code: String, pool: &sqlx::PgPool) -> Result<()> {
     let code = code.to_uppercase();
     let room = sqlx::query!(
-        r#"SELECT player1_id, player2_id FROM rooms WHERE code = $1"#,
+        r#"SELECT player1_id, player2_id, stat AS "stat: Status" FROM rooms WHERE code = $1"#,
         code
     )
     .fetch_one(pool)
@@ -87,26 +90,40 @@ pub async fn join_room(sid: Sid, code: String, pool: &sqlx::PgPool) -> Result<()
 
     let sid = sid.as_str();
 
+    // if player is already in room
+    if [room.player1_id.as_ref(), room.player2_id.as_ref()]
+        .into_iter()
+        .flatten()
+        .any(|x| x == sid)
+    {
+        // if game was over, set status to waiting and return
+        if room.stat == Status::GameOver {
+            sqlx::query!(
+                r"UPDATE rooms SET stat = $1 WHERE code = $2",
+                Status::Waiting as Status,
+                code
+            )
+            .execute(pool)
+            .await?;
+            return Ok(());
+        }
+        return Err(Error::AlreadyInRoom);
+    }
+
+    if room.stat == Status::GameOver {
+        return Err(Error::GameOverRoom);
+    }
+
     if let (Some(p1), Some(p2)) = (room.player1_id.as_ref(), room.player2_id.as_ref()) {
         if in_delete_sid(p1, pool).await? {
-            update_sid(p1, sid, pool).await?;
+            // update_sid(p1, sid, pool).await?;
             return Err(Error::RoomFull(Some(p1.to_string())));
         } else if in_delete_sid(p2, pool).await? {
-            update_sid(p2, sid, pool).await?;
+            // update_sid(p2, sid, pool).await?;
             return Err(Error::RoomFull(Some(p2.to_string())));
         }
         return Err(Error::RoomFull(None));
     }
-    if let Some(id) = room.player1_id.as_ref() {
-        if id == sid {
-            return Err(Error::AlreadyInRoom);
-        }
-    }
-    if let Some(id) = room.player2_id.as_ref() {
-        if id == sid {
-            return Err(Error::AlreadyInRoom);
-        }
-    }
     delete_sid(sid, pool).await?;
     let mut txn = pool.begin().await?;
 
@@ -158,7 +175,7 @@ pub async fn get_game_state(
     sid: &str,
     room: &str,
     pool: &sqlx::PgPool,
-) -> Result<(bool, Vec<String>, Vec<String>)> {
+) -> Result<(bool, Vec<String>, Vec<String>, bool)> {
     let room_details = sqlx::query!(
         r#"SELECT player1_id, player2_id, stat AS "stat: Status" FROM rooms WHERE code = $1"#,
         room
@@ -188,7 +205,6 @@ pub async fn get_game_state(
     .board
     .unwrap()
     .into();
-    let player_board: Vec<String> = player_board.mark_redundant().into();
 
     let opponent_board: Board = sqlx::query!(
         r#"SELECT board FROM players WHERE id = $1 AND room_code = $2"#,
@@ -200,6 +216,11 @@ pub async fn get_game_state(
     .board
     .unwrap()
     .into();
+
+    let game_over = player_board.is_game_over() || opponent_board.is_game_over();
+
+    let player_board: Vec<String> = player_board.mark_redundant().into();
+
     let opponent_board: Vec<String> = opponent_board.mark_redundant().into();
     let opponent_board: Vec<String> = opponent_board
         .into_iter()
@@ -210,7 +231,7 @@ pub async fn get_game_state(
         })
         .collect::<Vec<_>>();
 
-    Ok((turn, player_board, opponent_board))
+    Ok((turn, player_board, opponent_board, game_over))
 }
 
 pub async fn start(sid: Sid, code: String, pool: &sqlx::PgPool) -> Result<()> {
@@ -247,7 +268,7 @@ pub async fn attack(
     sid: Sid,
     (i, j): (usize, usize),
     pool: &sqlx::PgPool,
-) -> Result<(bool, Option<[(usize, usize); 2]>)> {
+) -> Result<(bool, Option<[(usize, usize); 2]>, bool)> {
     let player = sqlx::query!(r"SELECT room_code FROM players WHERE id = $1", sid.as_str())
         .fetch_one(pool)
         .await?;
@@ -302,9 +323,23 @@ pub async fn attack(
         .execute(&mut *txn)
         .await?;
     }
+    let game_over = board.is_game_over();
+    if game_over {
+        sqlx::query!(
+            r#"UPDATE rooms SET stat = $1 WHERE code = $2"#,
+            Status::GameOver as Status,
+            player.room_code
+        )
+        .execute(&mut *txn)
+        .await?;
+    }
 
     txn.commit().await?;
-    Ok((hit, if hit { board.has_sunk((i, j)) } else { None }))
+    Ok((
+        hit,
+        if hit { board.has_sunk((i, j)) } else { None },
+        game_over,
+    ))
 }
 
 pub async fn update_sid(oldsid: &str, newsid: &str, pool: &sqlx::PgPool) -> Result<()> {

src/main.rs

@@ -60,7 +60,7 @@ async fn on_connect(socket: SocketRef, Data(auth): Data<AuthPayload>, pool: Stat
             socket
                 .emit(
                     "restore",
-                    serde_json::json!({"turn": data.0, "player": data.1, "opponent": data.2}),
+                    serde_json::json!({"turn": data.0, "player": data.1, "opponent": data.2, "gameover": data.3}),
                 )
                 .unwrap();
             socket.join(room.clone()).unwrap();
@@ -118,7 +118,7 @@ async fn on_connect(socket: SocketRef, Data(auth): Data<AuthPayload>, pool: Stat
                     socket
                         .emit(
                             "restore",
-                            serde_json::json!({"turn": data.0, "player": data.1, "opponent": data.2}),
+                            serde_json::json!({"turn": data.0, "player": data.1, "opponent": data.2, "gameover": data.3}),
                         )
                         .unwrap();
                 } else {
@@ -170,7 +170,7 @@ async fn on_connect(socket: SocketRef, Data(auth): Data<AuthPayload>, pool: Stat
     socket.on(
         "attack",
         |socket: SocketRef, Data::<[usize; 2]>([i, j]), pool: State<PgPool>| async move {
-            let (hit, sunk) = match attack(socket.id, (i, j), &pool).await {
+            let (hit, sunk, game_over) = match attack(socket.id, (i, j), &pool).await {
                 Ok(res) => res,
                 Err(e) => {
                     tracing::error!("{:?}", e);
@@ -182,7 +182,7 @@ async fn on_connect(socket: SocketRef, Data(auth): Data<AuthPayload>, pool: Stat
                 .within(socket.rooms().unwrap().first().unwrap().clone())
                 .emit(
                     "attacked",
-                    serde_json::json!({"by": socket.id.as_str(), "at": [i, j], "hit": hit, "sunk": sunk}),
+                    serde_json::json!({"by": socket.id.as_str(), "at": [i, j], "hit": hit, "sunk": sunk, "game_over": game_over}),
                 )
                 .unwrap();
         },