Implement Game Visibility And Add Public Rooms Panel on Front Page

backend/src/main.rs

@@ -132,7 +132,8 @@ async fn main() -> Result<(), anyhow::Error> {
         .route(
             "/rules",
             get(|| async { Redirect::permanent("/rules.html") }),
-        );
+        )
+        .route("/public_games.json", get(state_dump::public_games));
 
     #[cfg(feature = "dynamic")]
     let app = app.fallback_service(

backend/src/state_dump.rs

@@ -7,6 +7,7 @@ use slog::{error, info, o, Logger};
 use tokio::sync::Mutex;
 
 use shengji_core::game_state::GameState;
+use shengji_core::settings::GameVisibility;
 use shengji_types::GameMessage;
 use storage::{HashMapStorage, Storage};
 
@@ -176,3 +177,27 @@ pub async fn dump_state(
 
     Ok(Json(state_dump))
 }
+
+pub async fn public_games(
+    Extension(backend_storage): Extension<HashMapStorage<VersionedGame>>,
+) -> Result<Json<HashMap<String, GameState>>, &'static str> {
+    let mut public_games: HashMap<String, GameState> = HashMap::new();
+
+    backend_storage.clone().prune().await;
+    let keys = backend_storage
+        .clone()
+        .get_all_keys()
+        .await
+        .map_err(|_| "failed to get ongoing games")?;
+    for room_name in keys {
+        if let Ok(versioned_game) = backend_storage.clone().get(room_name.clone()).await {
+            if versioned_game.game.game_visibility() == GameVisibility::Public {
+                if let Ok(name) = String::from_utf8(room_name.clone()) {
+                    public_games.insert(name, versioned_game.game);
+                }
+            }
+        }
+    }
+
+    Ok(Json(public_games))
+}

core/src/interactive.rs

@@ -15,11 +15,7 @@ use shengji_mechanics::types::{Card, PlayerID, Rank};
 
 use crate::game_state::{initialize_phase::InitializePhase, GameState};
 use crate::message::MessageVariant;
-use crate::settings::{
-    AdvancementPolicy, FirstLandlordSelectionPolicy, FriendSelection, FriendSelectionPolicy,
-    GameModeSettings, GameShadowingPolicy, GameStartPolicy, KittyBidPolicy, KittyPenalty,
-    KittyTheftPolicy, MultipleJoinPolicy, PlayTakebackPolicy, PropagatedState, ThrowPenalty,
-};
+use crate::settings::{AdvancementPolicy, FirstLandlordSelectionPolicy, FriendSelection, FriendSelectionPolicy, GameModeSettings, GameShadowingPolicy, GameStartPolicy, GameVisibility, KittyBidPolicy, KittyPenalty, KittyTheftPolicy, MultipleJoinPolicy, PlayTakebackPolicy, PropagatedState, ThrowPenalty};
 
 pub struct InteractiveGame {
     state: GameState,
@@ -220,6 +216,10 @@ impl InteractiveGame {
                 info!(logger, "Setting game mode"; "game_mode" => game_mode.variant());
                 state.set_game_mode(game_mode)?
             }
+            (Action::SetGameVisibility(visibility), GameState::Initialize(ref mut state)) => {
+                info!(logger, "Setting game visibility"; "visibility" => visibility);
+                state.set_game_visibility(visibility)?
+            }
             (Action::SetKittyPenalty(kitty_penalty), GameState::Initialize(ref mut state)) => {
                 info!(logger, "Setting kitty penalty"; "penalty" => kitty_penalty);
                 state.set_kitty_penalty(kitty_penalty)?
@@ -446,6 +446,7 @@ pub enum Action {
     SetShouldRevealKittyAtEndOfGame(bool),
     SetHideThrowHaltingPlayer(bool),
     SetTractorRequirements(TractorRequirements),
+    SetGameVisibility(GameVisibility),
     StartGame,
     DrawCard,
     RevealCard,

core/src/message.rs

@@ -13,11 +13,7 @@ use shengji_mechanics::trick::{ThrowEvaluationPolicy, TractorRequirements, Trick
 use shengji_mechanics::types::{Card, PlayerID, Rank};
 
 use crate::game_state::play_phase::PlayerGameFinishedResult;
-use crate::settings::{
-    AdvancementPolicy, FirstLandlordSelectionPolicy, FriendSelectionPolicy, GameModeSettings,
-    GameShadowingPolicy, GameStartPolicy, KittyBidPolicy, KittyPenalty, KittyTheftPolicy,
-    MultipleJoinPolicy, PlayTakebackPolicy, ThrowPenalty,
-};
+use crate::settings::{AdvancementPolicy, FirstLandlordSelectionPolicy, FriendSelectionPolicy, GameModeSettings, GameShadowingPolicy, GameStartPolicy, GameVisibility, KittyBidPolicy, KittyPenalty, KittyTheftPolicy, MultipleJoinPolicy, PlayTakebackPolicy, ThrowPenalty};
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 #[serde(tag = "type")]
@@ -102,6 +98,9 @@ pub enum MessageVariant {
     KittyTheftPolicySet {
         policy: KittyTheftPolicy,
     },
+    GameVisibilitySet {
+        visibility: GameVisibility,
+    },
     TookBackPlay,
     TookBackBid,
     PlayedCards {
@@ -370,6 +369,8 @@ impl MessageVariant {
             HideThrowHaltingPlayer { set: false } => format!("{} un-hid the player who prevents throws", n?),
             TractorRequirementsChanged { tractor_requirements } =>
                 format!("{} required tractors to be at least {} cards wide by {} tuples long", n?, tractor_requirements.min_count, tractor_requirements.min_length),
+            GameVisibilitySet { visibility: GameVisibility::Public} => format!("{} listed the game publicly", n?),
+            GameVisibilitySet { visibility: GameVisibility::Unlisted} => format!("{} unlisted the game", n?),
         })
     }
 }

core/src/settings.rs

@@ -246,6 +246,20 @@ impl Default for GameStartPolicy {
 
 shengji_mechanics::impl_slog_value!(GameStartPolicy);
 
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
+pub enum GameVisibility {
+    Public,
+    Unlisted,
+}
+
+impl Default for GameVisibility {
+    fn default() -> Self {
+        GameVisibility::Unlisted
+    }
+}
+
+shengji_mechanics::impl_slog_value!(GameVisibility);
+
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub struct MaxRank(Rank);
 shengji_mechanics::impl_slog_value!(MaxRank);
@@ -334,6 +348,8 @@ pub struct PropagatedState {
     pub(crate) tractor_requirements: TractorRequirements,
     #[serde(default)]
     pub(crate) max_rank: MaxRank,
+    #[serde(default)]
+    pub(crate) game_visibility: GameVisibility,
 }
 
 impl PropagatedState {
@@ -357,6 +373,10 @@ impl PropagatedState {
         self.num_decks.unwrap_or(self.players.len() / 2)
     }
 
+    pub fn game_visibility(&self) -> GameVisibility {
+        self.game_visibility
+    }
+
     pub fn decks(&self) -> Result<Vec<Deck>, Error> {
         let mut decks = self.special_decks.clone();
         let num_decks = self.num_decks();
@@ -790,6 +810,18 @@ impl PropagatedState {
         }
     }
 
+    pub fn set_game_visibility(
+        &mut self,
+        game_visibility: GameVisibility,
+    ) -> Result<Vec<MessageVariant>, Error> {
+        if game_visibility != self.game_visibility {
+            self.game_visibility = game_visibility;
+            Ok(vec![MessageVariant::GameVisibilitySet { visibility: game_visibility }])
+        } else {
+            Ok(vec![])
+        }
+    }
+
     pub fn set_user_multiple_game_session_policy(
         &mut self,
         policy: GameShadowingPolicy,

frontend/src/Initialize.tsx

@@ -731,6 +731,7 @@ const Initialize = (props: IProps): JSX.Element => {
   const setGameShadowingPolicy = onSelectString("SetGameShadowingPolicy");
   const setGameStartPolicy = onSelectString("SetGameStartPolicy");
   const setBidTakebackPolicy = onSelectString("SetBidTakebackPolicy");
+  const setGameVisibility = onSelectString("SetGameVisibility");
 
   const setShouldRevealKittyAtEndOfGame = (
     evt: React.ChangeEvent<HTMLSelectElement>
@@ -1291,6 +1292,18 @@ const Initialize = (props: IProps): JSX.Element => {
           setPlayTakebackPolicy={setPlayTakebackPolicy}
           setBidTakebackPolicy={setBidTakebackPolicy}
         />
+        <div>
+          <label>
+            Game Visibility{" "}
+            <select
+              value={props.state.propagated.game_visibility}
+              onChange={setGameVisibility}
+            >
+              <option value={"Unlisted"}>Unlisted</option>
+              <option value={"Public"}>Public</option>
+            </select>
+          </label>
+        </div>
         <h3>Continuation settings</h3>
         <LandlordSelector
           players={props.state.propagated.players}

frontend/src/JoinRoom.tsx

@@ -2,6 +2,7 @@ import * as React from "react";
 import { WebsocketContext } from "./WebsocketProvider";
 import { TimerContext } from "./TimerProvider";
 import LabeledPlay from "./LabeledPlay";
+import PublicRoomsPane from "./PublicRoomsPane";
 
 interface IProps {
   name: string;
@@ -136,6 +137,7 @@ const JoinRoom = (props: IProps): JSX.Element => {
           to you.
         </p>
       </div>
+      <PublicRoomsPane />
     </div>
   );
 };

frontend/src/PublicRoomsPane.tsx

@@ -0,0 +1,123 @@
+import * as React from "react";
+import { useEffect, useState } from "react";
+import styled from "styled-components";
+
+const Row = styled.div`
+  display: table-row;
+  line-height: 23px;
+`;
+const LabelCell = styled.div`
+  display: table-cell;
+  padding-right: 2em;
+  font-weight: bold;
+  width: 125px;
+`;
+const Cell = styled.div`
+  display: table-cell;
+`;
+
+interface RowIProps {
+  roomName: string;
+  numPlayers: number;
+}
+
+const PublicRoomRow = ({ roomName, numPlayers }: RowIProps): JSX.Element => {
+  return (
+    <Row>
+      <Cell>{roomName}</Cell>
+      <Cell>{numPlayers}</Cell>
+    </Row>
+  );
+};
+
+const PublicRoomsPane = (): JSX.Element => {
+  const [publicRooms, setPublicRooms] = useState([]);
+
+  useEffect(() => {
+    loadPublicRooms();
+  }, []);
+  const loadPublicRooms = (): void => {
+    try {
+      const fetchAsync = async (): Promise<void> => {
+        const fetchResult = await fetch("public_games.json");
+        const resultJSON = await fetchResult.json();
+        const resultArray = Object.entries(resultJSON);
+
+        // sort by number of players first, then name second
+        resultArray.sort((a: [string, any], b: [string, any]) => {
+          const aKey = a[0];
+          const aValue = a[1];
+          const bKey = b[0];
+          const bValue = b[1];
+
+          if (
+            aValue.Initialize === undefined ||
+            aValue.Initialize.propagated === undefined ||
+            aValue.Initialize.propagated.players === undefined ||
+            bValue.Initialize === undefined ||
+            bValue.Initialize.propagated === undefined ||
+            bValue.Initialize.propagated.players === undefined
+          ) {
+            throw new Error(
+              `failed validation while sorting public rooms between ${aKey} ${bKey}`
+            );
+          }
+
+          const playerDiff =
+            bValue.Initialize.propagated.players.length -
+            aValue.Initialize.propagated.players.length;
+
+          if (playerDiff !== 0) {
+            return playerDiff;
+          }
+
+          return aKey.localeCompare(bKey);
+        });
+        setPublicRooms(resultArray);
+      };
+
+      fetchAsync().catch((e) => {
+        console.error(e);
+      });
+    } catch (err) {
+      console.log(err);
+    }
+  };
+
+  return (
+    <div className="">
+      <h3>Public Rooms</h3>
+      <div>
+        <p>
+          The games listed below are open to the public. Join them to find new
+          friends to play with!
+        </p>
+        <p>
+          Copy the room name into the input above, fill out your player name,
+          and click join to enter the room.
+        </p>
+      </div>
+      <div style={{ display: "table", borderSpacing: 10 }}>
+        <Row>
+          <LabelCell>Room Name</LabelCell>
+          <LabelCell>Players</LabelCell>
+          <LabelCell>
+            <button onClick={loadPublicRooms}> Refresh </button>
+          </LabelCell>
+        </Row>
+        {publicRooms.length === 0 && <div>No rooms available</div>}
+        {publicRooms.map(([key, value]) => {
+          return (
+            <PublicRoomRow
+              key={key}
+              roomName={key}
+              numPlayers={value.Initialize.propagated.players.length}
+            />
+          );
+        })}
+      </div>
+    </div>
+  );
+};
+
+export default PublicRoomsPane;

frontend/src/gen-types.d.ts

@@ -129,6 +129,9 @@ export type Action =
   | {
       SetTractorRequirements: TractorRequirements;
     }
+  | {
+      SetGameVisibility: GameVisibility;
+    }
   | {
       /**
        * @minItems 2
@@ -206,6 +209,7 @@ export type BidTakebackPolicy = "AllowBidTakeback" | "NoBidTakeback";
 export type KittyTheftPolicy = "AllowKittyTheft" | "NoKittyTheft";
 export type GameShadowingPolicy = "AllowMultipleSessions" | "SingleSessionOnly";
 export type GameStartPolicy = "AllowAnyPlayer" | "AllowLandlordOnly";
+export type GameVisibility = "Public" | "Unlisted";
 export type Card = string;
 export type TrickUnit =
   | {
@@ -449,6 +453,11 @@ export type MessageVariant =
       type: "KittyTheftPolicySet";
       [k: string]: unknown;
     }
+  | {
+      type: "GameVisibilitySet";
+      visibility: GameVisibility;
+      [k: string]: unknown;
+    }
   | {
       type: "TookBackPlay";
       [k: string]: unknown;
@@ -866,6 +875,7 @@ export interface PropagatedState {
   game_scoring_parameters?: GameScoringParameters;
   game_shadowing_policy?: GameShadowingPolicy & string;
   game_start_policy?: GameStartPolicy & string;
+  game_visibility?: GameVisibility & string;
   hide_landlord_points?: boolean;
   hide_played_cards?: boolean;
   hide_throw_halting_player?: boolean;