feat: Highlight last move

python/othello/ui.py

@@ -1,3 +1,5 @@
+import asyncio
+import time
 from uuid import uuid1
 from fasthtml.common import (
     fast_app,
@@ -18,7 +20,7 @@ app, rt = fast_app(
 )
 
 games = {}
-bot = AlphaBetaBot(7)
+bot = AlphaBetaBot(8)
 
 
 @rt("/")
@@ -34,7 +36,7 @@ def get(uuid: str = None):
 
 @app.get("/new")
 def new(uuid: str = None):
-    if uuid is not None:
+    if uuid is not None and uuid in games:
         del games[uuid]
     return RedirectResponse("/")
 
@@ -45,7 +47,13 @@ def make_app(uuid):
         Div(
             make_status_bar(state),
             Div(
-                *(make_cell(state.cells[i], i, uuid) for i in range(64)),
+                *(
+                    Div(
+                        make_stone(state.cells[i], i, uuid),
+                        cls="size-12 xl:size-16 border border-sky-100",
+                    )
+                    for i in range(64)
+                ),
                 cls="grid grid-cols-8 gap-0 bg-green-300 mb-5 lg:mt-5",
                 hx_ext="ws",
                 ws_connect="/wscon",
@@ -57,26 +65,23 @@ def make_app(uuid):
     )
 
 
-def make_cell(v, pos, uuid):
+def make_stone(v, pos, uuid, highlight=False):
     style = "m-2 size-8 lg:size-12 rounded-full"
-    stone = None
+    if highlight:
+        style += " border-indigo-500 border-2"
+    stone = {}
     if v == "?":
-        stone = Div(
+        stone = dict(
             hx_trigger="click",
             hx_vals=f'{{"pos": {pos}, "uuid": "{uuid}"}}',
             ws_send=True,
             cls=f"{style} cursor-pointer bg-purple-200 hover:bg-purple-300",
         )
     elif v == "B":
-        stone = Div(cls=f"{style} shadow-sm bg-black shadow-white")
+        stone = dict(cls=f"{style} shadow-sm bg-black shadow-white")
     elif v == "W":
-        stone = Div(cls=f"{style} shadow-sm bg-white shadow-black")
-    return Div(
-        stone,
-        id=f"cell-{pos}",
-        cls="size-12 xl:size-16 border border-sky-100",
-        hx_swap_oob="true",
-    )
+        stone = dict(cls=f"{style} shadow-sm bg-white shadow-black")
+    return Div(**stone, id=f"cell-{pos}", hx_swap_oob="true")
 
 
 def make_status_bar(state):
@@ -119,12 +124,11 @@ async def ws(uuid: str, pos: int, send):
         prev_state = game.state
         state = game.make_move(pos) if pos >= 0 else game.pass_move()
 
-        await send(make_cell(state.cells[pos], pos, uuid))
-        # await asyncio.sleep(1)
+        await send(make_stone(state.cells[pos], pos, uuid, highlight=True))
 
         for i, (c1, c2) in enumerate(zip(prev_state.cells, state.cells)):
-            if i != pos and c1 != c2:
-                await send(make_cell(c2, i, uuid))
+            if i != pos and c1 != c2 or i == prev_state.last_move:
+                await send(make_stone(c2, i, uuid))
         await send(make_status_bar(state))
         return state
 
@@ -135,7 +139,9 @@ async def ws(uuid: str, pos: int, send):
 
     # Bot
     while True:
+        now = time.time()
         pos = bot.find_move(game) if state.can_move else -1
+        await asyncio.sleep(abs(1 - time.time() + now))
         state = await play(pos)
         if not state.can_move and not state.ended:
             # Human has no move

src/bits.rs

@@ -1,18 +1,9 @@
-use std::fmt::Write;
-
 use pyo3::prelude::*;
 
 #[pyclass]
 #[derive(Clone)]
 pub struct BitBoard(pub u64, pub u64);
 
-impl core::fmt::Debug for BitBoard {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        f.write_str(&self.to_string(('B', 'W')))?;
-        Ok(())
-    }
-}
-
 #[pymethods]
 impl BitBoard {
     #[new]
@@ -20,27 +11,6 @@ impl BitBoard {
         Self(0x0000_0008_1000_0000, 0x0000_0010_0800_0000)
     }
 
-    fn __repr__(&self) -> String {
-        self.to_string(('B', 'W'))
-    }
-
-    pub fn to_string(&self, players: (char, char)) -> String {
-        let mut s = String::with_capacity(64 + 8);
-        for i in (0..64).rev() {
-            s.write_char(match (self.0 >> i & 1, self.1 >> i & 1) {
-                (0, 0) => '.',
-                (1, 0) => players.0,
-                (0, 1) => players.1,
-                (_, _) => unreachable!(),
-            })
-            .unwrap();
-            if i % 8 == 0 {
-                s.write_char('\n').unwrap();
-            }
-        }
-        s
-    }
-
     /// Returns bitboards of `self`.
     #[must_use]
     pub const fn get(&self) -> [u64; 2] {

src/game.rs

@@ -22,6 +22,7 @@ pub struct State {
     pub white_score: i32,
     pub cells: Vec<char>,
     pub can_move: bool,
+    pub last_move: i32,
 }
 
 #[pymethods]
@@ -36,7 +37,7 @@ impl Game {
     #[staticmethod]
     pub fn default() -> Self {
         let board = BitBoard::default();
-        let state = Self::compute_state(&board, 0);
+        let state = Self::compute_state(&board, 0, -1);
         Self {
             board,
             current_player: 0,
@@ -52,7 +53,7 @@ impl Game {
     pub fn pass_move(&mut self) -> State {
         self.board = self.board.pass_move();
         self.current_player = 1 - self.current_player;
-        self.state = Self::compute_state(&self.board, self.current_player);
+        self.state = Self::compute_state(&self.board, self.current_player, -1);
         self.state.clone()
     }
 
@@ -60,7 +61,7 @@ impl Game {
         let next = self.board.make_move(place).unwrap();
         self.current_player = 1 - self.current_player;
         self.board = next;
-        self.state = Self::compute_state(&self.board, self.current_player);
+        self.state = Self::compute_state(&self.board, self.current_player, place as i32);
         self.state.clone()
     }
 
@@ -91,7 +92,7 @@ impl Game {
 }
 
 impl Game {
-    fn compute_state(board: &BitBoard, current_player: usize) -> State {
+    fn compute_state(board: &BitBoard, current_player: usize, last_move: i32) -> State {
         let (cnt0, cnt1) = board.count();
         let moves = board.available_moves();
         let cells: Vec<_> = (0..64)
@@ -115,6 +116,7 @@ impl Game {
             white_score: if player == 'W' { cnt0 } else { cnt1 },
             cells,
             can_move: moves != 0,
+            last_move,
         }
     }
 }
@@ -146,7 +148,7 @@ mod tests {
         let b = BitBoard(2, 1);
         let mut g = Game {
             current_player: 0,
-            state: Game::compute_state(&b, 0),
+            state: Game::compute_state(&b, 0, -1),
             board: b,
         };
         assert_eq!(g.state.can_move, false);