diff --git a/minesweeper-lib/src/game.rs b/minesweeper-lib/src/game.rs
index d802e5a..a8694f0 100644
--- a/minesweeper-lib/src/game.rs
+++ b/minesweeper-lib/src/game.rs
@@ -178,7 +178,7 @@ impl Minesweeper {
             bail!("Tried to play flagged cell")
         }
         let mut update_revealed = None::<Vec<BoardPoint>>;
-        if !(self.players[player].played) && self.has_no_revealed_neighbors(cell_point) {
+        if !(self.players[player].played) && self.has_no_revealed_nearby(cell_point) {
             // on first click of empty board space, prevent mine
             self.players[player].played = true;
             update_revealed = Some(self.unplant(cell_point, self.superclick));
@@ -346,11 +346,13 @@ impl Minesweeper {
         })
     }
 
-    fn has_no_revealed_neighbors(&self, cell_point: BoardPoint) -> bool {
+    fn has_no_revealed_nearby(&self, cell_point: BoardPoint) -> bool {
         let neighbors = self.board.neighbors(cell_point);
         neighbors
             .iter()
             .copied()
+            .map(|n| self.board.neighbors(n))
+            .flatten()
             .filter(|i| self.board[*i].1.revealed)
             .count()
             == 0
@@ -786,25 +788,20 @@ mod test {
         }
     }
 
-    fn set_up_game(plant_3_0: bool) -> Minesweeper {
+    fn set_up_game() -> Minesweeper {
         let mut game = empty_game(2);
 
         game.plant(POINT_0_0);
         game.plant(POINT_1_1);
         game.plant(POINT_1_2);
-        if plant_3_0 {
-            game.plant(POINT_2_1);
-        }
+        game.plant(POINT_2_1);
         game
     }
 
-    fn set_up_game_with_replant() -> Minesweeper {
-        let mut game = empty_game(1);
+    fn set_up_game_no_superclick() -> Minesweeper {
+        let mut game = set_up_game();
+        game.superclick = false;
 
-        game.plant(POINT_0_0);
-        game.plant(POINT_1_1);
-        game.plant(POINT_1_2);
-        game.plant(POINT_2_1);
         game
     }
 
@@ -817,7 +814,7 @@ mod test {
         assert_eq!(num_mines, number);
     }
 
-    fn point_cell(game: &Minesweeper, point: BoardPoint, _cell: Cell) {
+    fn assert_point_cell(game: &Minesweeper, point: BoardPoint, _cell: Cell) {
         let board_cell = game.board[point].0;
         assert!(matches!(board_cell, _cell));
     }
@@ -853,61 +850,61 @@ mod test {
 
         num_mines(&game, 1);
         assert_eq!(game.available.len(), 9 * 9 - 1);
-        point_cell(&game, POINT_0_0, Cell::Mine);
-        point_cell(&game, POINT_0_1, Cell::Empty(1));
-        point_cell(&game, POINT_1_0, Cell::Empty(1));
-        point_cell(&game, POINT_1_1, Cell::Empty(1));
-        point_cell(&game, POINT_0_2, Cell::Empty(0));
+        assert_point_cell(&game, POINT_0_0, Cell::Mine);
+        assert_point_cell(&game, POINT_0_1, Cell::Empty(1));
+        assert_point_cell(&game, POINT_1_0, Cell::Empty(1));
+        assert_point_cell(&game, POINT_1_1, Cell::Empty(1));
+        assert_point_cell(&game, POINT_0_2, Cell::Empty(0));
 
         game.plant(POINT_1_1);
 
         num_mines(&game, 2);
         assert_eq!(game.available.len(), 9 * 9 - 2);
-        point_cell(&game, POINT_0_0, Cell::Mine);
-        point_cell(&game, POINT_0_1, Cell::Empty(2));
-        point_cell(&game, POINT_1_0, Cell::Empty(2));
-        point_cell(&game, POINT_1_1, Cell::Mine);
-        point_cell(&game, POINT_0_2, Cell::Empty(1));
+        assert_point_cell(&game, POINT_0_0, Cell::Mine);
+        assert_point_cell(&game, POINT_0_1, Cell::Empty(2));
+        assert_point_cell(&game, POINT_1_0, Cell::Empty(2));
+        assert_point_cell(&game, POINT_1_1, Cell::Mine);
+        assert_point_cell(&game, POINT_0_2, Cell::Empty(1));
 
         game.plant(POINT_1_2);
 
         num_mines(&game, 3);
         assert_eq!(game.available.len(), 9 * 9 - 3);
-        point_cell(&game, POINT_0_0, Cell::Mine);
-        point_cell(&game, POINT_0_1, Cell::Empty(3));
-        point_cell(&game, POINT_1_0, Cell::Empty(2));
-        point_cell(&game, POINT_1_1, Cell::Mine);
-        point_cell(&game, POINT_0_2, Cell::Empty(2));
+        assert_point_cell(&game, POINT_0_0, Cell::Mine);
+        assert_point_cell(&game, POINT_0_1, Cell::Empty(3));
+        assert_point_cell(&game, POINT_1_0, Cell::Empty(2));
+        assert_point_cell(&game, POINT_1_1, Cell::Mine);
+        assert_point_cell(&game, POINT_0_2, Cell::Empty(2));
     }
 
     #[test]
     fn unplant_mine_works() {
-        let mut game = set_up_game(false);
+        let mut game = set_up_game();
 
         game.unplant(POINT_0_0, true);
 
-        num_mines(&game, 1);
-        assert_eq!(game.available.len(), 9 * 9 - 3);
-        point_cell(&game, POINT_0_0, Cell::Empty(0));
-        point_cell(&game, POINT_1_1, Cell::Empty(1));
+        num_mines(&game, 4);
+        assert_eq!(game.available.len(), 9 * 9 - 6);
+        assert_point_cell(&game, POINT_0_0, Cell::Empty(0));
+        assert_point_cell(&game, POINT_1_1, Cell::Empty(1));
     }
 
     #[test]
     fn unplant_cell_works() {
-        let mut game = set_up_game(false);
+        let mut game = set_up_game();
 
         game.unplant(POINT_0_2, true);
 
-        num_mines(&game, 1);
-        assert_eq!(game.available.len(), 9 * 9 - 3);
-        point_cell(&game, POINT_0_2, Cell::Empty(0));
-        point_cell(&game, POINT_0_0, Cell::Mine);
-        point_cell(&game, POINT_1_1, Cell::Empty(1));
+        num_mines(&game, 4);
+        assert_eq!(game.available.len(), 9 * 9 - 6);
+        assert_point_cell(&game, POINT_0_2, Cell::Empty(0));
+        assert_point_cell(&game, POINT_0_0, Cell::Mine);
+        assert_point_cell(&game, POINT_1_1, Cell::Empty(1));
     }
 
     #[test]
     fn first_play_mine_works() {
-        let mut game = set_up_game(true);
+        let mut game = set_up_game();
 
         let res = game
             .play(Play {
@@ -918,19 +915,19 @@ mod test {
             .unwrap();
         assert_eq!(res.len(), 4);
 
-        num_mines(&game, 2);
-        assert_eq!(game.available.len(), 9 * 9 - 6);
-        point_cell(&game, POINT_0_0, Cell::Empty(0));
+        num_mines(&game, 4);
+        assert_eq!(game.available.len(), 9 * 9 - 8);
+        assert_point_cell(&game, POINT_0_0, Cell::Empty(0));
         point_cell_state(&game, POINT_0_0, true, Some(0));
-        point_cell(&game, POINT_1_1, Cell::Empty(2));
+        assert_point_cell(&game, POINT_1_1, Cell::Empty(2));
         point_cell_state(&game, POINT_1_1, true, Some(0));
-        point_cell(&game, POINT_1_2, Cell::Mine);
+        assert_point_cell(&game, POINT_1_2, Cell::Mine);
         point_cell_state(&game, POINT_1_2, false, None);
     }
 
     #[test]
     fn first_play_cell_works() {
-        let mut game = set_up_game(true);
+        let mut game = set_up_game();
 
         let res = game.play(Play {
             player: 0,
@@ -941,17 +938,17 @@ mod test {
 
         num_mines(&game, 4);
         assert_eq!(game.available.len(), 4); // not mine and not revealed
-        point_cell(&game, BoardPoint { row: 8, col: 8 }, Cell::Empty(0));
+        assert_point_cell(&game, BoardPoint { row: 8, col: 8 }, Cell::Empty(0));
         point_cell_state(&game, BoardPoint { row: 8, col: 8 }, true, Some(0));
-        point_cell(&game, POINT_1_1, Cell::Mine);
+        assert_point_cell(&game, POINT_1_1, Cell::Mine);
         point_cell_state(&game, POINT_1_1, false, None);
-        point_cell(&game, POINT_1_2, Cell::Mine);
+        assert_point_cell(&game, POINT_1_2, Cell::Mine);
         point_cell_state(&game, POINT_1_2, false, None);
     }
 
     #[test]
     fn second_click_mine_failure() {
-        let mut game = set_up_game(true);
+        let mut game = set_up_game();
 
         let _ = game
             .play(Play {
@@ -972,7 +969,7 @@ mod test {
 
     #[test]
     fn second_click_cell_success() {
-        let mut game = set_up_game(true);
+        let mut game = set_up_game();
 
         let _ = game
             .play(Play {
@@ -983,6 +980,7 @@ mod test {
             .unwrap();
 
         let cell_point = BoardPoint { row: 0, col: 2 };
+        game.unplant(cell_point, false); // guarantee not mine
         let res = game
             .play(Play {
                 player: 0,
@@ -990,13 +988,13 @@ mod test {
                 point: cell_point,
             })
             .unwrap();
-        assert!(matches!(res.clone(), PlayOutcome::Success(_)));
+        assert!(matches!(&res, PlayOutcome::Success(_)));
         assert_eq!(res.len(), 1);
     }
 
     #[test]
     fn flag_works() {
-        let mut game = set_up_game(true);
+        let mut game = set_up_game();
 
         let _ = game
             .play(Play {
@@ -1026,7 +1024,7 @@ mod test {
 
     #[test]
     fn unplant_updated_works() {
-        let mut game = set_up_game(true);
+        let mut game = set_up_game();
 
         let _ = game.play(Play {
             player: 0,
@@ -1034,13 +1032,13 @@ mod test {
             point: BoardPoint { col: 7, row: 7 },
         });
 
-        point_cell(&game, POINT_2_2, Cell::Empty(3));
-        point_cell(&game, POINT_0_3, Cell::Empty(1));
+        assert_point_cell(&game, POINT_2_2, Cell::Empty(3));
+        assert_point_cell(&game, POINT_0_3, Cell::Empty(1));
 
         let updated = game.unplant(POINT_1_1, true);
 
-        point_cell(&game, POINT_2_2, Cell::Empty(0));
-        point_cell(&game, POINT_0_3, Cell::Empty(0));
+        assert_point_cell(&game, POINT_2_2, Cell::Empty(0));
+        assert_point_cell(&game, POINT_0_3, Cell::Empty(0));
 
         assert!(updated.contains(&POINT_2_2));
         assert!(updated.contains(&POINT_0_3));
@@ -1049,7 +1047,7 @@ mod test {
 
     #[test]
     fn unflag_works() {
-        let mut game = set_up_game(true);
+        let mut game = set_up_game();
 
         let _ = game
             .play(Play {
@@ -1088,41 +1086,39 @@ mod test {
 
     #[test]
     fn double_click_works() {
-        let mut game = set_up_game(true);
+        let mut game = set_up_game_no_superclick();
 
         let res = game
             .play(Play {
                 player: 0,
                 action: Action::Reveal,
-                point: BoardPoint { row: 0, col: 0 },
+                point: BoardPoint { row: 2, col: 2 },
             })
             .unwrap();
-        assert_eq!(res.len(), 4);
-
-        num_mines(&game, 2);
+        assert_eq!(res.len(), 1);
+        assert_point_cell(&game, BoardPoint { row: 2, col: 2 }, Cell::Empty(3));
 
         let _ = game
             .play(Play {
                 player: 0,
                 action: Action::Flag,
-                point: POINT_1_2,
+                point: POINT_1_1,
             })
             .unwrap();
         let _ = game
             .play(Play {
                 player: 0,
                 action: Action::Flag,
-                point: POINT_2_1,
+                point: POINT_1_2,
             })
             .unwrap();
         let _ = game
             .play(Play {
                 player: 0,
-                action: Action::Reveal,
-                point: BoardPoint { row: 2, col: 2 },
+                action: Action::Flag,
+                point: POINT_2_1,
             })
             .unwrap();
-        point_cell(&game, BoardPoint { row: 2, col: 2 }, Cell::Empty(2));
 
         let res = game
             .play(Play {
@@ -1131,39 +1127,37 @@ mod test {
                 point: BoardPoint { row: 2, col: 2 },
             })
             .expect("double-click should work");
-        assert_eq!(res.len(), 9 * 9 - 9);
+        assert!(res.len() == 9 * 9 - 9); // 5 is worst case scenario for replant
     }
 
     #[test]
     fn bad_double_click_fails() {
-        let mut game = set_up_game(true);
+        let mut game = set_up_game_no_superclick();
 
         let res = game
             .play(Play {
                 player: 0,
                 action: Action::Reveal,
-                point: BoardPoint { row: 0, col: 0 },
+                point: BoardPoint { row: 2, col: 2 },
             })
             .unwrap();
-        assert_eq!(res.len(), 4);
-
-        num_mines(&game, 2);
+        assert_eq!(res.len(), 1);
+        assert_point_cell(&game, BoardPoint { row: 2, col: 2 }, Cell::Empty(3));
 
         let _ = game
             .play(Play {
                 player: 0,
                 action: Action::Flag,
-                point: POINT_1_2,
+                point: POINT_1_1,
             })
             .unwrap();
         let _ = game
             .play(Play {
                 player: 0,
-                action: Action::Reveal,
-                point: BoardPoint { row: 2, col: 2 },
+                action: Action::Flag,
+                point: POINT_1_2,
             })
             .unwrap();
-        point_cell(&game, BoardPoint { row: 2, col: 2 }, Cell::Empty(2));
 
         let res = game.play(Play {
             player: 0,
@@ -1175,7 +1169,7 @@ mod test {
 
     #[test]
     fn score_works() {
-        let mut game = set_up_game(true);
+        let mut game = set_up_game();
 
         let _ = game
             .play(Play {
@@ -1185,7 +1179,7 @@ mod test {
             })
             .unwrap();
 
-        num_mines(&game, 2);
+        num_mines(&game, 4);
 
         let cell_point = BoardPoint { row: 0, col: 2 };
         let res = game.play(Play {
@@ -1199,7 +1193,7 @@ mod test {
 
     #[test]
     fn dead_errors() {
-        let mut game = set_up_game(true);
+        let mut game = set_up_game();
 
         let _ = game
             .play(Play {
@@ -1226,7 +1220,7 @@ mod test {
 
     #[test]
     fn revealed_errors() {
-        let mut game = set_up_game(true);
+        let mut game = set_up_game();
 
         let _ = game
             .play(Play {
@@ -1265,13 +1259,20 @@ mod test {
 
     #[test]
     fn victory_works() {
-        let mut game = set_up_game(true);
+        let mut game = set_up_game_no_superclick();
 
         let _ = game
             .play(Play {
                 player: 0,
                 action: Action::Reveal,
-                point: POINT_0_0,
+                point: POINT_0_1,
+            })
+            .unwrap();
+        let _ = game
+            .play(Play {
+                player: 0,
+                action: Action::Reveal,
+                point: POINT_1_0,
             })
             .unwrap();
         let _ = game
@@ -1297,12 +1298,12 @@ mod test {
             })
             .unwrap();
         assert!(matches!(res, PlayOutcome::Victory(..)));
-        assert_eq!(game.players[0].score, 79);
+        assert_eq!(game.players[0].score, 77);
     }
 
     #[test]
     fn replant_works() {
-        let mut game = set_up_game_with_replant();
+        let mut game = set_up_game();
         let _ = game
             .play(Play {
                 player: 0,
@@ -1317,7 +1318,7 @@ mod test {
         assert_eq!(game.board[POINT_1_2].0, Cell::Mine);
         assert_eq!(game.board[POINT_2_1].0, Cell::Mine);
 
-        let mut game = set_up_game_with_replant();
+        let mut game = set_up_game();
         let _ = game
             .play(Play {
                 player: 0,
diff --git a/minesweeper-lib/src/replay.rs b/minesweeper-lib/src/replay.rs
index f73dbe0..d5ad9b2 100644
--- a/minesweeper-lib/src/replay.rs
+++ b/minesweeper-lib/src/replay.rs
@@ -39,8 +39,8 @@ impl MinesweeperReplay {
         self.current_play
     }
 
-    pub fn current_board(&self) -> Board<PlayerCell> {
-        self.current_board.clone()
+    pub fn current_board(&self) -> &Board<PlayerCell> {
+        &self.current_board
     }
 
     pub fn advance(&mut self) -> Result<()> {
@@ -287,37 +287,37 @@ mod test {
         // test advance
         assert_eq!(replay.len(), 5);
         assert!(matches!(replay.advance(), Ok(())));
-        assert_eq!(replay.current_board(), expected_board_1);
+        assert_eq!(replay.current_board(), &expected_board_1);
         assert!(matches!(replay.advance(), Ok(())));
-        assert_eq!(replay.current_board(), expected_board_2);
+        assert_eq!(replay.current_board(), &expected_board_2);
         assert!(matches!(replay.advance(), Ok(())));
-        assert_eq!(replay.current_board(), expected_board_3);
+        assert_eq!(replay.current_board(), &expected_board_3);
         assert!(matches!(replay.advance(), Ok(())));
-        assert_eq!(replay.current_board(), expected_final_board);
+        assert_eq!(replay.current_board(), &expected_final_board);
 
         // should error on advance at end
         assert!(replay.advance().is_err());
 
         // test rewind
         assert!(matches!(replay.rewind(), Ok(())));
-        assert_eq!(replay.current_board(), expected_board_3);
+        assert_eq!(replay.current_board(), &expected_board_3);
         assert!(matches!(replay.rewind(), Ok(())));
-        assert_eq!(replay.current_board(), expected_board_2);
+        assert_eq!(replay.current_board(), &expected_board_2);
         assert!(matches!(replay.rewind(), Ok(())));
-        assert_eq!(replay.current_board(), expected_board_1);
+        assert_eq!(replay.current_board(), &expected_board_1);
         assert!(matches!(replay.rewind(), Ok(())));
-        assert_eq!(replay.current_board(), expected_starting_board);
+        assert_eq!(replay.current_board(), &expected_starting_board);
 
         // should error on rewind at beginning
         assert!(replay.rewind().is_err());
 
         // try to_pos (auto advance/rewind)
         assert!(matches!(replay.to_pos(2), Ok(())));
-        assert_eq!(replay.current_board(), expected_board_2);
+        assert_eq!(replay.current_board(), &expected_board_2);
         assert!(matches!(replay.to_pos(4), Ok(())));
-        assert_eq!(replay.current_board(), expected_final_board);
+        assert_eq!(replay.current_board(), &expected_final_board);
         assert!(matches!(replay.to_pos(1), Ok(())));
-        assert_eq!(replay.current_board(), expected_board_1);
+        assert_eq!(replay.current_board(), &expected_board_1);
 
         assert!(replay.to_pos(5).is_err());
     }
diff --git a/web/src/app/auth.rs b/web/src/app/auth.rs
index f9adeba..046eb43 100644
--- a/web/src/app/auth.rs
+++ b/web/src/app/auth.rs
@@ -18,7 +18,7 @@ pub struct FrontendUser {
 }
 
 impl FrontendUser {
-    pub fn display_name_or_anon(display_name: &Option<String>, is_user: bool) -> String {
+    pub fn display_name_or_anon(display_name: Option<&String>, is_user: bool) -> String {
         if let Some(name) = display_name {
             name.to_owned()
         } else if is_user {
diff --git a/web/src/app/header.rs b/web/src/app/header.rs
index d7913a8..091efcd 100644
--- a/web/src/app/header.rs
+++ b/web/src/app/header.rs
@@ -14,18 +14,18 @@ fn logo() -> impl IntoView {
     let cell_class_flag = cell_class("", "bg-neutral-500 hover:bg-neutral-600/90");
     view! {
         <span class="whitespace-nowrap">
-            <span class=cell_class_4.clone()>M</span>
-            <span class=cell_class_2.clone()>i</span>
-            <span class=cell_class_3.clone()>n</span>
+            <span class=&cell_class_4>M</span>
+            <span class=&cell_class_2>i</span>
+            <span class=&cell_class_3>n</span>
             <span class=cell_class_3>e</span>
             <span class=cell_class_4>s</span>
-            <span class=cell_class_2.clone()>w</span>
+            <span class=&cell_class_2>w</span>
             <span class=cell_class_2>e</span>
-            <span class=cell_class_1.clone()>e</span>
+            <span class=&cell_class_1>e</span>
             <span class=cell_class_flag>
                 <Flag />
             </span>
-            <span class=cell_class_1.clone()>e</span>
+            <span class=&cell_class_1>e</span>
             <span class=cell_class_1>r</span>
         </span>
     }
@@ -42,18 +42,18 @@ where
             None => view! {
                 "Guest ("
                 <A href="/auth/login" class=aclass>
-                    Log in
+                    "Log in"
                 </A>
                 ")"
             }
             .into_view(),
             Some(user) => {
-                let name = FrontendUser::display_name_or_anon(&user.display_name, true);
+                let name = FrontendUser::display_name_or_anon(user.display_name.as_ref(), true);
                 view! {
                     {name}
                     " ("
                     <A href="/profile" class=aclass>
-                        Profile
+                        "Profile"
                     </A>
                     ")"
                 }
diff --git a/web/src/app/minesweeper.rs b/web/src/app/minesweeper.rs
index f01d8e9..4fe866c 100644
--- a/web/src/app/minesweeper.rs
+++ b/web/src/app/minesweeper.rs
@@ -40,7 +40,10 @@ impl From<&PlayerUser> for ClientPlayer {
     fn from(value: &PlayerUser) -> Self {
         ClientPlayer {
             player_id: value.player as usize,
-            username: FrontendUser::display_name_or_anon(&value.display_name, value.user.is_some()),
+            username: FrontendUser::display_name_or_anon(
+                value.display_name.as_ref(),
+                value.user.is_some(),
+            ),
             dead: value.dead,
             victory_click: value.victory_click,
             top_score: value.top_score,
diff --git a/web/src/app/minesweeper/client.rs b/web/src/app/minesweeper/client.rs
index 6db5c25..815d696 100644
--- a/web/src/app/minesweeper/client.rs
+++ b/web/src/app/minesweeper/client.rs
@@ -28,7 +28,7 @@ pub struct PlayersContext {
 impl PlayersContext {
     pub fn from(frontend_game: &FrontendGame) -> Self {
         PlayersContext {
-            game_id: frontend_game.game_id.clone(),
+            game_id: Rc::clone(&frontend_game.game_id),
             is_owner: frontend_game.is_owner,
             has_owner: frontend_game.has_owner,
             player_id: frontend_game.player_id,
@@ -103,7 +103,7 @@ impl FrontendGame {
         let rows = game_info.rows;
         let cols = game_info.cols;
         FrontendGame {
-            game_id: Rc::new(game_info.game_id.clone()),
+            game_id: Rc::new(game_info.game_id.to_owned()),
             is_owner: game_info.is_owner,
             has_owner: game_info.has_owner,
             cells: read_signals,
diff --git a/web/src/app/minesweeper/game.rs b/web/src/app/minesweeper/game.rs
index 0a98f89..fc67499 100644
--- a/web/src/app/minesweeper/game.rs
+++ b/web/src/app/minesweeper/game.rs
@@ -59,17 +59,7 @@ pub async fn get_game(game_id: String) -> Result<GameInfo, ServerFnError> {
     } else {
         None
     };
-    let players_simple = players
-        .into_iter()
-        .map(ClientPlayer::from)
-        .collect::<Vec<_>>();
-    let players_frontend =
-        players_simple
-            .iter()
-            .fold(vec![None; game.max_players as usize], |mut acc, p| {
-                acc[p.player_id] = Some(p.clone());
-                acc
-            });
+    let players_simple = players.iter().map(ClientPlayer::from).collect::<Vec<_>>();
     let final_board = match (game.final_board, game_log) {
         (Some(board), Some(game_log)) => {
             let completed_minesweeper = CompletedMinesweeper::from_log(
@@ -90,6 +80,14 @@ pub async fn get_game(game_id: String) -> Result<GameInfo, ServerFnError> {
             game.rows as usize
         ]),
     };
+    let players_frontend =
+        players
+            .into_iter()
+            .fold(vec![None; game.max_players as usize], |mut acc, p| {
+                let index = p.player as usize;
+                acc[index] = Some(ClientPlayer::from(p));
+                acc
+            });
     Ok(GameInfo {
         game_id: game.game_id,
         has_owner: game.owner.is_some(),
@@ -132,7 +130,8 @@ pub fn Game() -> impl IntoView {
                         view! {
                             <ErrorBoundary fallback=|_| {
                                 view! { <div class="text-red-600">"Game not found"</div> }
-                            }>{move || { game_info.clone().map(game_view) }}</ErrorBoundary>
+                            }>{game_info.map(game_view)
+                            }</ErrorBoundary>
                         }
                     })
             }}
@@ -168,19 +167,22 @@ where
 {
     let (error, set_error) = create_signal::<Option<String>>(None);
 
-    let game_id = game_info.game_id.clone();
     let UseWebSocketReturn {
         ready_state,
         message,
         send,
         ..
-    } = use_websocket::<String, FromToStringCodec>(&format!("/api/websocket/game/{}", &game_id));
+    } = use_websocket::<String, FromToStringCodec>(&format!(
+        "/api/websocket/game/{}",
+        &game_info.game_id
+    ));
 
     let game = FrontendGame::new(&game_info, set_error, Rc::new(send.clone()));
     let (game_signal, _) = create_signal(game.clone());
 
-    provide_context::<PlayersContext>(PlayersContext::from(&game));
+    let players_context = PlayersContext::from(&game);
 
+    let game_id = game_info.game_id.clone();
     create_effect(move |_| {
         log::debug!("before ready_state");
         let state = ready_state();
@@ -276,9 +278,9 @@ where
     view! {
         <div class="text-center">
             <h3 class="text-4xl my-4 text-gray-900 dark:text-gray-200">
-                Game: {{ game_info.game_id.clone() }}
+                "Game: "{ &game_info.game_id }
             </h3>
-            <ActivePlayers />
+            <ActivePlayers players_context />
             <GameWidgets>
                 <ActiveMines num_mines=game_info.num_mines flag_count=game.flag_count />
                 <CopyGameLink game_id=game_info.game_id />
@@ -322,7 +324,6 @@ where
 
 #[component]
 pub fn InactiveGame(game_info: GameInfo) -> impl IntoView {
-    let players = game_info.players.clone();
     let game_settings = GameSettings::from(&game_info);
     let game_time = match (game_info.start_time, game_info.end_time) {
         (Some(st), Some(et)) => et.signed_duration_since(st).num_seconds(),
@@ -338,9 +339,9 @@ pub fn InactiveGame(game_info: GameInfo) -> impl IntoView {
     view! {
         <div class="text-center">
             <h3 class="text-4xl my-4 text-gray-900 dark:text-gray-200">
-                Game: {{ game_info.game_id.clone() }}
+                "Game: "{ &game_info.game_id }
             </h3>
-            <InactivePlayers players />
+            <InactivePlayers players=game_info.players />
             <GameWidgets>
                 <InactiveMines num_mines=num_mines />
                 <CopyGameLink game_id=game_info.game_id />
diff --git a/web/src/app/minesweeper/players.rs b/web/src/app/minesweeper/players.rs
index 001d2ba..1d26068 100644
--- a/web/src/app/minesweeper/players.rs
+++ b/web/src/app/minesweeper/players.rs
@@ -1,6 +1,7 @@
 use anyhow::Result;
 use leptos::*;
 use leptos_router::*;
+use std::rc::Rc;
 
 use minesweeper_lib::client::ClientPlayer;
 
@@ -25,13 +26,13 @@ where
             <thead>
                 <tr>
                     <th class="border dark:border-slate-600 font-medium p-4 text-slate-400 dark:text-slate-200 ">
-                        Player
+                        "Player"
                     </th>
                     <th class="border dark:border-slate-600 font-medium p-4 text-slate-400 dark:text-slate-200 ">
-                        Username
+                        "Username"
                     </th>
                     <th class="border dark:border-slate-600 font-medium p-4 text-slate-400 dark:text-slate-200 ">
-                        Score
+                        "Score"
                     </th>
                 </tr>
             </thead>
@@ -42,27 +43,28 @@ where
 }
 
 #[component]
-pub fn ActivePlayers() -> impl IntoView {
-    let players_ctx = expect_context::<PlayersContext>();
+pub fn ActivePlayers(players_context: PlayersContext) -> impl IntoView {
     let start_game = create_server_action::<StartGame>();
 
-    let (player_id, players, loaded, started, join_trigger) = {
-        (
-            players_ctx.player_id,
-            players_ctx.players.clone(),
-            players_ctx.players_loaded,
-            players_ctx.started,
-            players_ctx.join_trigger,
-        )
-    };
+    let PlayersContext {
+        game_id,
+        is_owner,
+        has_owner,
+        player_id,
+        players,
+        players_loaded,
+        started,
+        join_trigger,
+    } = players_context;
     log::debug!("players: {players:?}");
     let num_players = players.len();
     let last_slot = *players.last().unwrap();
-    let show_play =
-        move || loaded() && last_slot().is_none() && player_id().is_none() && num_players > 1;
+    let show_play = move || {
+        players_loaded() && last_slot().is_none() && player_id().is_none() && num_players > 1
+    };
     let show_start = move || {
-        loaded()
-            && (players_ctx.is_owner || (!players_ctx.has_owner && player_id().is_some()))
+        players_loaded()
+            && (is_owner || (!has_owner && player_id().is_some()))
             && !started()
             && num_players > 1
     };
@@ -70,7 +72,7 @@ pub fn ActivePlayers() -> impl IntoView {
     if num_players == 1 {
         log::debug!("num players 1");
         create_effect(move |_| {
-            if loaded() {
+            if players_loaded() {
                 log::debug!("join_trigger");
                 join_trigger.notify();
             }
@@ -78,10 +80,10 @@ pub fn ActivePlayers() -> impl IntoView {
     }
 
     let buttons = move || {
-        let game_id = players_ctx.game_id.clone();
+        let game_id = Rc::clone(&game_id);
         view! {
             <Show when=show_play fallback=move || ()>
-                <PlayForm />
+                <PlayForm join_trigger />
             </Show>
             <Show when=show_start fallback=move || ()>
                 <StartForm start_game game_id=game_id.to_string() />
@@ -94,9 +96,9 @@ pub fn ActivePlayers() -> impl IntoView {
             <h4 class="text-2xl my-4 text-gray-900 dark:text-gray-200">Players</h4>
             <Scoreboard buttons>
                 {players
-                    .iter()
+                    .into_iter()
                     .enumerate()
-                    .map(move |(n, &player)| {
+                    .map(move |(n, player)| {
                         view! { <ActivePlayer player_num=n player=player /> }
                     })
                     .collect_view()}
@@ -119,10 +121,10 @@ pub fn InactivePlayers(players: Vec<Option<ClientPlayer>>) -> impl IntoView {
             <Scoreboard buttons=move || ()>
 
                 {players
-                    .iter()
+                    .into_iter()
                     .enumerate()
                     .map(|(i, player)| {
-                        view! { <PlayerRow player_num=i player=player.clone() /> }
+                        view! { <PlayerRow player_num=i player=player /> }
                     })
                     .collect_view()}
 
@@ -143,10 +145,10 @@ fn ActivePlayer(player_num: usize, player: ReadSignal<Option<ClientPlayer>>) ->
 #[component]
 fn PlayerRow(player_num: usize, player: Option<ClientPlayer>) -> impl IntoView {
     let (mut player_class, username, is_dead, victory_click, top_score, score) =
-        if let Some(player) = &player {
+        if let Some(player) = player {
             (
                 player_class(player.player_id),
-                player.username.clone(),
+                player.username,
                 player.dead,
                 player.victory_click,
                 player.top_score,
@@ -214,13 +216,11 @@ fn PlayerRow(player_num: usize, player: Option<ClientPlayer>) -> impl IntoView {
 }
 
 #[component]
-fn PlayForm() -> impl IntoView {
-    let players_ctx = expect_context::<PlayersContext>();
-    let (trigger_join, _) = create_signal(players_ctx.join_trigger);
+fn PlayForm(join_trigger: Trigger) -> impl IntoView {
     let (show, set_show) = create_signal(true);
 
     let join_game = move || {
-        trigger_join().notify();
+        join_trigger.notify();
         set_show(false);
     };
 
@@ -243,7 +243,7 @@ fn PlayForm() -> impl IntoView {
                 }
                     .into_view()
             } else {
-                view! { <div>Joining...</div> }.into_view()
+                view! { <div>"Joining..."</div> }.into_view()
             }
         }}
     }
diff --git a/web/src/app/minesweeper/widgets.rs b/web/src/app/minesweeper/widgets.rs
index a996fd6..6ae6967 100644
--- a/web/src/app/minesweeper/widgets.rs
+++ b/web/src/app/minesweeper/widgets.rs
@@ -72,7 +72,7 @@ pub fn ActiveTimer(
                 <StopWatch />
             </span>
             <div class="flex flex-col items-center justify-center border-4 border-slate-400 bg-neutral-200 text-neutral-800 text-lg font-bold px-2">
-                {{ display_time }}
+                { display_time }
             </div>
         </div>
     }
@@ -83,7 +83,7 @@ pub fn InactiveMines(num_mines: usize) -> impl IntoView {
     view! {
         <div class="flex items-center">
             <div class="flex flex-col items-center justify-center border-4 border-slate-400 bg-neutral-200 text-neutral-800 text-lg font-bold px-2">
-                {{ num_mines }}
+                { num_mines }
             </div>
             <span class=widget_icon_holder("bg-neutral-200", false)>
                 <Mine />
@@ -114,7 +114,7 @@ pub fn InactiveTimer(game_time: usize) -> impl IntoView {
                 <StopWatch />
             </span>
             <div class="flex flex-col items-center justify-center border-4 border-slate-400 bg-neutral-200 text-neutral-800 text-lg font-bold px-2">
-                {{ game_time }}
+                { game_time }
             </div>
         </div>
     }
@@ -139,12 +139,13 @@ pub fn CopyGameLink(game_id: String) -> impl IntoView {
             String::new()
         }
     };
+    let url = format!("{}/game/{}", origin, game_id);
     view! {
         <div class="flex flex-col items-center justify-center border-2 rounded-full border-slate-400 bg-neutral-200 text-neutral-800 font-medium px-2">
             <button
                 class=move || { if show_tooltip.get() { Some("show-tooltip") } else { None } }
                 on:click=move |_| {
-                    copy(&format!("{}/game/{}", origin, game_id));
+                    copy(&url);
                     set_show_tooltip(true);
                     start(());
                 }
diff --git a/web/src/app/profile.rs b/web/src/app/profile.rs
index 0133b60..8578dfd 100644
--- a/web/src/app/profile.rs
+++ b/web/src/app/profile.rs
@@ -122,12 +122,12 @@ fn SetDisplayName(user: FrontendUser, user_updated: WriteSignal<String>) -> impl
         _ => {}
     });
 
-    let curr_name = FrontendUser::display_name_or_anon(&user.display_name, true);
+    let curr_name = FrontendUser::display_name_or_anon(user.display_name.as_ref(), true);
 
     view! {
         <div class="flex flex-col space-y-2 w-full max-w-xs">
             <span class="text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70 text-neutral-950 dark:text-neutral-50">
-                {curr_name.clone()}
+                {&curr_name}
             </span>
             {move || {
                 name_err
@@ -228,10 +228,10 @@ fn GameHistory() -> impl IntoView {
         let player_class = player_class(0) + " text-black";
         view! {
                 <tr class=player_class>
-                    <td class=td_class>Game {num}</td>
+                    <td class=td_class>"Game "{num}</td>
                     <td class=td_class></td>
                     <td class=td_class></td>
-                    <td class=td_class>Loading...</td>
+                    <td class=td_class>"Loading..."</td>
                     <td class=td_class></td>
                     <td class=td_class></td>
                 </tr>
@@ -298,22 +298,22 @@ fn GameHistory() -> impl IntoView {
             <thead>
                 <tr>
                     <th class="border dark:border-slate-600 font-medium p-4 text-slate-400 dark:text-slate-200 ">
-                        Game
+                        "Game"
                     </th>
                     <th class="border dark:border-slate-600 font-medium p-4 text-slate-400 dark:text-slate-200 ">
-                        Date
+                        "Date"
                     </th>
                     <th class="border dark:border-slate-600 font-medium p-4 text-slate-400 dark:text-slate-200 ">
-                        Game Mode
+                        "Game Mode"
                     </th>
                     <th class="border dark:border-slate-600 font-medium p-4 text-slate-400 dark:text-slate-200 ">
-                        Duration
+                        "Duration"
                     </th>
                     <th class="border dark:border-slate-600 font-medium p-4 text-slate-400 dark:text-slate-200 ">
-                        Status
+                        "Status"
                     </th>
                     <th class="border dark:border-slate-600 font-medium p-4 text-slate-400 dark:text-slate-200 ">
-                        Score
+                        "Score"
                     </th>
                 </tr>
             </thead>
diff --git a/web/src/backend/fileserv.rs b/web/src/backend/fileserv.rs
index 625cad4..f2f8d87 100644
--- a/web/src/backend/fileserv.rs
+++ b/web/src/backend/fileserv.rs
@@ -17,22 +17,20 @@ pub async fn file_and_error_handler(
     State(options): State<LeptosOptions>,
     req: Request<Body>,
 ) -> AxumResponse {
-    let root = options.site_root.clone();
-    let res = get_static_file(uri.clone(), &root).await.unwrap();
+    let root = &options.site_root;
+    let res = get_static_file(uri, root).await.unwrap();
 
     if res.status() == StatusCode::OK {
         res.into_response()
     } else {
-        let handler = leptos_axum::render_app_to_stream(options.to_owned(), move || view! { <App /> });
+        let handler =
+            leptos_axum::render_app_to_stream(options.to_owned(), move || view! { <App /> });
         handler(req).await
     }
 }
 
 async fn get_static_file(uri: Uri, root: &str) -> Result<Response<Body>, (StatusCode, String)> {
-    let req = Request::builder()
-        .uri(uri.clone())
-        .body(Body::empty())
-        .unwrap();
+    let req = Request::builder().uri(uri).body(Body::empty()).unwrap();
     // `ServeDir` implements `tower::Service` so we can call it with `tower::ServiceExt::oneshot`
     // This path is relative to the cargo root
     match ServeDir::new(root).oneshot(req).await {
diff --git a/web/src/backend/game_manager.rs b/web/src/backend/game_manager.rs
index 791770c..84a69af 100644
--- a/web/src/backend/game_manager.rs
+++ b/web/src/backend/game_manager.rs
@@ -187,7 +187,7 @@ impl GameManager {
         }
         let handle = games.get_mut(game_id).unwrap();
         let user_id = user.as_ref().map(|u| u.id);
-        let display_name = user.as_ref().and_then(|u| u.display_name.clone());
+        let display_name = user.as_ref().and_then(|u| u.display_name.as_ref());
         let found = handle
             .players
             .iter_mut()
@@ -203,13 +203,13 @@ impl GameManager {
                 handle.players.push(PlayerHandle {
                     user_id,
                     player_id,
-                    display_name: FrontendUser::display_name_or_anon(&display_name, user.is_some()),
-                    ws_sender: ws_sender.clone(),
+                    display_name: FrontendUser::display_name_or_anon(display_name, user.is_some()),
+                    ws_sender: Arc::clone(&ws_sender),
                 });
                 player_id
             }
             Some(p) => {
-                p.ws_sender = ws_sender.clone();
+                p.ws_sender = Arc::clone(&ws_sender);
                 p.player_id
             }
         };
@@ -223,8 +223,8 @@ impl GameManager {
             .send(GameEvent::Player(PlayerHandle {
                 user_id,
                 player_id,
-                display_name: FrontendUser::display_name_or_anon(&display_name, user.is_some()),
-                ws_sender: ws_sender.clone(),
+                display_name: FrontendUser::display_name_or_anon(display_name, user.is_some()),
+                ws_sender: Arc::clone(&ws_sender),
             }))
             .await?;
         Ok(handle.from_client.clone())
@@ -325,7 +325,7 @@ fn handles_to_client_players(
                 let player_score = minesweeper.player_score(player.player_id).unwrap_or(0);
                 ClientPlayer {
                     player_id: player.player_id,
-                    username: player.display_name.clone(),
+                    username: player.display_name.to_owned(),
                     dead: minesweeper.player_dead(player.player_id).unwrap_or(false),
                     victory_click: minesweeper
                         .player_victory_click(player.player_id)
@@ -370,10 +370,12 @@ async fn handle_game_event(
 ) {
     match event {
         GameEvent::Player(player) => {
-            player_handles[player.player_id] = Some(player.clone());
-            let player_board = minesweeper.player_board(player.player_id);
+            let player_sender = Arc::clone(&player.ws_sender);
+            let player_id = player.player_id;
+            let player_board = minesweeper.player_board(player_id);
+            player_handles[player_id] = Some(player);
             {
-                let mut player_sender = player.ws_sender.lock().await;
+                let mut player_sender = player_sender.lock().await;
                 let player_msg = GameMessage::GameState(player_board).into_json();
                 log::debug!("Sending player_msg {:?}", player_msg);
                 let _ = player_sender.send(Message::Text(player_msg)).await;
@@ -453,7 +455,7 @@ async fn handle_message(
             let top_score = minesweeper.player_top_score(player.player_id).unwrap();
             let player_state = ClientPlayer {
                 player_id: player.player_id,
-                username: player.display_name.clone(),
+                username: player.display_name.to_owned(),
                 dead,
                 victory_click,
                 top_score,
@@ -578,13 +580,15 @@ pub async fn websocket(
     let (sender, mut receiver) = stream.split();
     let sender = Arc::new(Mutex::new(sender));
 
-    let sender_clone = sender.clone();
+    let game_id = game_id.as_str();
+
+    let sender_clone = Arc::clone(&sender);
     let mut rx = game_manager
-        .join_game(&game_id, sender_clone)
+        .join_game(game_id, sender_clone)
         .await
         .unwrap_or_else(|_| panic!("Failed to join game ({}) from websocket", game_id));
 
-    let sender_clone = sender.clone();
+    let sender_clone = Arc::clone(&sender);
     // Spawn the first task that will receive broadcast messages and send text
     // messages over the websocket to our client.
     let mut send_task = tokio::spawn(async move {
@@ -603,9 +607,9 @@ pub async fn websocket(
     });
 
     let mut game_sender = None;
-    if game_manager.was_playing(&game_id, &user).await {
+    if game_manager.was_playing(game_id, &user).await {
         let resp = game_manager
-            .play_game(&game_id, &user, sender.clone())
+            .play_game(game_id, &user, Arc::clone(&sender))
             .await;
         match resp {
             Ok(tx) => {
@@ -623,7 +627,7 @@ pub async fn websocket(
                     match recvd {
                         Some(Ok(Message::Text(msg))) if msg == "Play" => {
                             log::debug!("Trying to Play");
-                            let resp = game_manager.play_game(&game_id, &user, sender.clone()).await;
+                            let resp = game_manager.play_game(game_id, &user, Arc::clone(&sender)).await;
                             match resp {
                                 Ok(tx) => {
                                     game_sender = Some(tx);
diff --git a/web/src/components/info.rs b/web/src/components/info.rs
index f68223c..ffd63a6 100644
--- a/web/src/components/info.rs
+++ b/web/src/components/info.rs
@@ -30,7 +30,7 @@ pub fn ControlsInfoModal(set_show_info: WriteSignal<bool>) -> impl IntoView {
                 class="flex flex-col rounded-lg border border-black shadow-lg text-gray-900 dark:text-gray-300 bg-slate-200 dark:bg-slate-800 p-8 w-10/12 max-w-md max-h-10/12 overflow-auto"
                 on:click=move |ev| ev.stop_propagation()
             >
-                <h2 class="text-2xl font-bold tracking-wide my-3">Controls</h2>
+                <h2 class="text-2xl font-bold tracking-wide my-3">"Controls"</h2>
                 <div class="text-l my-2">
                     <span class=key_class>"Left Click"</span>
                     " or "
@@ -61,7 +61,7 @@ pub fn ControlsInfoModal(set_show_info: WriteSignal<bool>) -> impl IntoView {
                     <span class="font-medium">"Controls"</span>
                     " menu"
                 </div>
-                <h2 class="text-2xl font-bold tracking-wide my-3">Player Badges</h2>
+                <h2 class="text-2xl font-bold tracking-wide my-3">"Player Badges"</h2>
                 <div class="text-l my-2">
                     <span class=player_icon_holder("bg-red-600", false)>
                         <Mine />
@@ -83,13 +83,13 @@ pub fn ControlsInfoModal(set_show_info: WriteSignal<bool>) -> impl IntoView {
                     <span class="font-medium">"Victory Click"</span>
                     " - the player revealed the final non-mine cell on the map"
                 </div>
-                <h2 class="text-2xl font-bold tracking-wide my-3">Multiplayer Rules</h2>
+                <h2 class="text-2xl font-bold tracking-wide my-3">"Multiplayer Rules"</h2>
                 <div class="text-l my-2">
                     "Multiple players trying to reveal the same cell is hadled first-click-wins"
                 </div>
                 <div class="text-l my-2">
                     " Each player gets one " <span class="font-medium">"\"Super Click\""</span>
-                    " - that is, the first hidden cell they reveal that is not adjacent to any revealed cells is guaranteed to be an empty cell"
+                    " - that is, the first hidden cell they reveal that is not within a 2-cell distance to any revealed cells is guaranteed to be an empty cell"
                 </div>
                 <div class="text-l my-2">
                     "If a game is created by a " <span class="font-medium">"Guest"</span>
diff --git a/web/src/models/game.rs b/web/src/models/game.rs
index f933d69..5d221e9 100644
--- a/web/src/models/game.rs
+++ b/web/src/models/game.rs
@@ -150,21 +150,6 @@ pub struct PlayerUser {
     pub player: u8,
 }
 
-impl PlayerUser {
-    pub fn to_player(&self) -> Player {
-        Player {
-            game_id: self.game_id.clone(),
-            user: self.user,
-            player: self.player,
-            nickname: self.nickname.clone(),
-            dead: self.dead,
-            victory_click: self.victory_click,
-            top_score: self.top_score,
-            score: self.score,
-        }
-    }
-}
-
 #[derive(Clone, Debug, Serialize, Deserialize, FromRow)]
 pub struct PlayerGame {
     pub game_id: String,
@@ -194,20 +179,6 @@ impl Player {
         .await
     }
 
-    pub async fn get_player_from_user(
-        db: &SqlitePool,
-        game_id: &str,
-        user: &User,
-    ) -> Result<Option<PlayerUser>, sqlx::Error> {
-        sqlx::query_as(
-            "select players.*, users.display_name from players inner join users on players.user = users.id where players.game_id = ? and players.user = ?",
-        )
-        .bind(game_id)
-        .bind(user.id)
-        .fetch_optional(db)
-        .await
-    }
-
     pub async fn get_player_games_for_user(
         db: &SqlitePool,
         user: &User,
@@ -245,36 +216,6 @@ impl Player {
         .map(|_| ())
     }
 
-    pub async fn set_score(
-        db: &SqlitePool,
-        game_id: &str,
-        player: u8,
-        score: i64,
-    ) -> Result<(), sqlx::Error> {
-        sqlx::query("update players set score = ? where game_id = ? and player = ?")
-            .bind(score)
-            .bind(game_id)
-            .bind(player)
-            .execute(db)
-            .await
-            .map(|_| ())
-    }
-
-    pub async fn set_dead(
-        db: &SqlitePool,
-        game_id: &str,
-        player: u8,
-        dead: bool,
-    ) -> Result<(), sqlx::Error> {
-        sqlx::query("update players set dead = ? where game_id = ? and player = ?")
-            .bind(dead)
-            .bind(game_id)
-            .bind(player)
-            .execute(db)
-            .await
-            .map(|_| ())
-    }
-
     pub async fn update_players(
         db: &SqlitePool,
         game_id: &str,