Implement lobby parts of custom games #38

rc_services_room/src/operations/custom_game_adjust.rs

@@ -32,6 +32,17 @@ impl <C: Send + 'static> SimpleOperation<C> for CustomGameConfigChanger {
                         .filter(|mem| !mem.is_invited && mem.public_id != my_pub_id)
                         .map(|mem| &mem.public_id as &str);
                     self.mesh.broadcast_event_to(session_members_iter, event).await;
+                    user_info.update_custom_game(oj_rc_core::persist::user::intercom::IntercomLobbyCustomGameDataMessage {
+                        session_id: session.session_id.clone(),
+                        config: session.config_core,
+                        users: session.users.iter()
+                            .filter(|user| !user.is_invited)
+                            .map(|user| oj_rc_core::persist::user::intercom::IntercomLobbyCustomGameUserData {
+                                public_id: user.public_id.clone(),
+                                team: user.team,
+                            })
+                            .collect(),
+                    }).await;
                 }
                 params.insert(RESPONSE_CODE_PARAM_KEY, Typed::Int(resp_code as _));
             }

rc_services_room/src/operations/custom_game_create.rs

@@ -22,9 +22,19 @@ impl <C: Send + 'static> SimpleOperation<C> for CustomGameCreator {
             Err(e) => {
                 params.insert(RESPONSE_CODE_PARAM_KEY, Typed::Int(e as _));
             },
-            Ok(game_id) => {
+            Ok(session) => {
+                user_info.update_custom_game(oj_rc_core::persist::user::intercom::IntercomLobbyCustomGameDataMessage {
+                    session_id: session.session_id.clone(),
+                    config: session.config_core,
+                    users: vec![
+                        oj_rc_core::persist::user::intercom::IntercomLobbyCustomGameUserData {
+                            public_id: user_info.public_id().to_owned(),
+                            team: 0,
+                        }
+                    ],
+                }).await;
                 params.insert(RESPONSE_CODE_PARAM_KEY, Typed::Int(crate::data::custom_games::SessionCreateResponseCode::SessionCreated as _));
-                params.insert(IDK_PARAM_KEY, Typed::Str(game_id.into()));
+                params.insert(IDK_PARAM_KEY, Typed::Str(session.session_id.into()));
             }
         }
         Ok(params)

rc_services_room/src/operations/custom_game_invite_respond.rs

@@ -30,6 +30,18 @@ impl <C: Send + 'static> SimpleOperation<C> for CustomGameInviteResponder {
                         .filter(|mem| !mem.is_invited && mem.public_id != my_pub_id)
                         .map(|mem| &mem.public_id as &str);
                     self.mesh.broadcast_event_to(session_members_iter, event).await;
+                } else {
+                    user_info.update_custom_game(oj_rc_core::persist::user::intercom::IntercomLobbyCustomGameDataMessage {
+                        session_id: session.session_id.clone(),
+                        config: session.config_core,
+                        users: session.users.iter()
+                            .filter(|user| !user.is_invited)
+                            .map(|user| oj_rc_core::persist::user::intercom::IntercomLobbyCustomGameUserData {
+                                public_id: user.public_id.clone(),
+                                team: user.team,
+                            })
+                            .collect()
+                    }).await;
                 }
                 let event = crate::events::CustomGameRefresh {
                     session: session.session_id,

rc_services_room/src/operations/custom_game_kick.rs

@@ -29,11 +29,22 @@ impl <C: Send + 'static> SimpleOperation<C> for CustomGameMemberKicker {
                 };
                 self.mesh.send_event_to(&user_to_kick.string, kick_event).await;
                 let update_event = crate::events::CustomGameRefresh {
-                    session: session.session_id,
+                    session: session.session_id.clone(),
                 };
                 let members_iter = session.users.iter()
                     .map(|mem| &mem.public_id as &str);
                 self.mesh.broadcast_event_to(members_iter, update_event).await;
+                user_info.update_custom_game(oj_rc_core::persist::user::intercom::IntercomLobbyCustomGameDataMessage {
+                    session_id: session.session_id,
+                    config: session.config_core,
+                    users: session.users.iter()
+                        .filter(|user| !user.is_invited)
+                        .map(|user| oj_rc_core::persist::user::intercom::IntercomLobbyCustomGameUserData {
+                            public_id: user.public_id.clone(),
+                            team: user.team,
+                        })
+                        .collect()
+                }).await;
             }
             params.insert(RESPONSE_CODE_PARAM_KEY, Typed::Int(resp_code as _));
         }

rc_services_room/src/operations/custom_game_leave.rs

@@ -20,11 +20,22 @@ impl <C: Send + 'static> SimpleOperation<C> for CustomGameLeaver {
         let (resp_code, session_opt) = self.games.leave_game(user_info.public_id()).await;
         if let Some(session) = session_opt {
             let event = crate::events::CustomGameRefresh {
-                session: session.session_id,
+                session: session.session_id.clone(),
             };
             let session_members = session.users.iter()
                 .map(|mem| &mem.public_id as &str);
             self.mesh.broadcast_event_to(session_members, event).await;
+            user_info.update_custom_game(oj_rc_core::persist::user::intercom::IntercomLobbyCustomGameDataMessage {
+                session_id: session.session_id,
+                config: session.config_core,
+                users: session.users.iter()
+                    .filter(|user| !user.is_invited)
+                    .map(|user| oj_rc_core::persist::user::intercom::IntercomLobbyCustomGameUserData {
+                        public_id: user.public_id.clone(),
+                        team: user.team,
+                    })
+                    .collect()
+            }).await;
         }
         params.insert(RESPONSE_CODE_PARAM_KEY, Typed::Int(resp_code as _));
         Ok(params)

rc_services_room/src/operations/custom_game_team.rs

@@ -0,0 +1,59 @@
+use polariton_server::operations::{SimpleOpError, SimpleOperation, SimpleOpImpl};
+use polariton::operation::{ParameterTable, Typed};
+
+const CODE: u8 = 151;
+
+const USERNAME_PARAM_KEY: u8 = 185; // str; in
+//const CHANGER_PARAM_KEY: u8 = 186; // always null?; in
+const IS_TEAM_B_PARAM_KEY: u8 = 187; // bool; in
+const RESPONSE_CODE_PARAM_KEY: u8 = 168; // int enum; out
+
+pub(super) struct CustomGameTeamChanger {
+    games: std::sync::Arc<crate::custom_game_tracker::CustomGameMesh>,
+    mesh: std::sync::Arc<crate::user_service::UserMesh>,
+}
+
+#[async_trait::async_trait]
+impl <C: Send + 'static> SimpleOperation<C> for CustomGameTeamChanger {
+    type User = crate::UserTy;
+    const CODE: u8 = CODE;
+
+    async fn handle(&self, mut params: ParameterTable<C>, user: &Self::User) -> Result<ParameterTable<C>, SimpleOpError> {
+        if let Some(Typed::Str(username)) = params.remove(&USERNAME_PARAM_KEY) {
+            if let Some(Typed::Bool(is_team_b)) = params.remove(&IS_TEAM_B_PARAM_KEY) {
+                let user_info = user.user()?;
+                let my_pub_id = user_info.public_id();
+                let (resp_code, session_opt) = self.games.update_user_team(my_pub_id, &username.string, is_team_b).await;
+                if let Some(session) = session_opt {
+                    let event = crate::events::CustomGameRefresh {
+                        session: session.session_id.clone(),
+                    };
+                    let session_members_iter = session.users.iter()
+                        .filter(|mem| !mem.is_invited)
+                        .map(|mem| &mem.public_id as &str);
+                    self.mesh.broadcast_event_to(session_members_iter, event).await;
+                    user_info.update_custom_game(oj_rc_core::persist::user::intercom::IntercomLobbyCustomGameDataMessage {
+                        session_id: session.session_id,
+                        config: session.config_core,
+                        users: session.users.iter()
+                            .filter(|user| !user.is_invited)
+                            .map(|user| oj_rc_core::persist::user::intercom::IntercomLobbyCustomGameUserData {
+                                public_id: user.public_id.clone(),
+                                team: user.team,
+                            })
+                            .collect()
+                    }).await;
+                }
+                params.insert(RESPONSE_CODE_PARAM_KEY, Typed::Int(resp_code as _));
+            }
+        }
+        Ok(params)
+    }
+}
+
+pub(super) fn game_team_change_provider<C: Send + 'static>(init_ctx: &crate::InitConfig) -> SimpleOpImpl<C, crate::UserTy, CustomGameTeamChanger> {
+    SimpleOpImpl::new(CustomGameTeamChanger {
+        games: init_ctx.custom_games.clone(),
+        mesh: init_ctx.user_mesh.clone(),
+    })
+}

rc_services_room/src/operations/mod.rs

@@ -116,6 +116,7 @@ mod custom_game_invite_respond;
 mod custom_game_kick;
 mod custom_game_player_state;
 mod custom_game_can_join_queue;
+mod custom_game_team;
 
 use polariton_server::operations::OperationsHandler;
 
@@ -256,4 +257,5 @@ pub fn handler(init_ctx: &crate::InitConfig) -> OperationsHandler<crate::UserTy>
         .add(custom_game_kick::game_kick_provider(init_ctx))
         .add(custom_game_player_state::game_player_status_update_provider(init_ctx))
         .add(custom_game_can_join_queue::game_can_queue_provider(init_ctx))
+        .add(custom_game_team::game_team_change_provider(init_ctx))
 }