transporter change, transporter cant transport transporters targets... Fix double tick

Author: ItsSammyM

client/src/resources/lang/en_us.json

@@ -428,7 +428,7 @@
 
     "wiki.entry.role.transporter.title": "Transporter",
     "wiki.entry.role.transporter.abilities":"* Transport two players with each other.",
-    "wiki.entry.role.transporter.attributes":"* Transporting a target swaps all visitors to them; for example, all visitors that visit target A will instead visit target B, and vice versa\n* You can transport yourself",
+    "wiki.entry.role.transporter.attributes":"* Transporting a target swaps all visitors to them; for example, all visitors that visit target A will instead visit target B, and vice versa\n* You can transport yourself* Your targets do not change due to other transporters (your targets wont change due to your own transport either)",
 
     "wiki.entry.role.sheriff.title": "Sheriff",
     "wiki.entry.role.sheriff.abilities":"* Interrogate a player to find out if they're innocent or suspicious",

server/src/game/mod.rs

@@ -263,25 +263,30 @@ impl Game {
 pub mod test {
     use rand::{thread_rng, seq::SliceRandom};
 
-    use super::{Game, settings::Settings, role_list::{create_random_roles, RoleOutline}, player::{PlayerReference, test::mock_player}, phase::PhaseStateMachine, team::Teams};
+    use super::{Game, settings::Settings, role_list::{create_random_roles, RoleOutline}, player::{PlayerReference, test::mock_player}, phase::PhaseStateMachine, team::Teams, RejectStartReason};
 
-    pub fn mock_game(mut settings: Settings, number_of_players: usize) -> Game {
+    pub fn mock_game(settings: Settings, number_of_players: usize) -> Result<Game, RejectStartReason> {
+
+        //check settings are not completly off the rails
+        if [
+            settings.phase_times.evening, settings.phase_times.morning,
+            settings.phase_times.discussion, settings.phase_times.voting,
+            settings.phase_times.judgement, settings.phase_times.testimony,
+            settings.phase_times.night,
+        ].iter().all(|t| *t == 0) {
+            return Err(RejectStartReason::ZeroTimeGame);
+        }
+        
         let mut roles = match create_random_roles(&settings.excluded_roles, &settings.role_list){
             Some(roles) => {
                 roles
             },
             None => {
-                let mut new_list = vec![];
-                for _ in 0..number_of_players{
-                    new_list.push(RoleOutline::Any);
-                }
-                settings.role_list = new_list;
-                settings.excluded_roles = vec![];
-                create_random_roles(&settings.excluded_roles, &settings.role_list).expect("All any with no exclusions should have open roles")
+                return Err(RejectStartReason::RoleListCannotCreateRoles);
             }
         };
         roles.shuffle(&mut thread_rng());
-        
+
         let mut players = Vec::new();
         for player_index in 0..number_of_players {
             let new_player = mock_player(
@@ -293,7 +298,7 @@ pub mod test {
             );
             players.push(new_player);
         }
-        drop(roles);
+        drop(roles); // Ensure we don't use the order of roles anywhere
 
         let mut game = Game{
             ticking: true,
@@ -308,13 +313,14 @@ pub mod test {
             player_ref.send_join_game_data(&mut game);
         }
 
+        //on role creation needs to be called after all players roles are known
         for player_ref in PlayerReference::all_players(&game){
             let role_data_copy = player_ref.role_state(&game).clone();
             player_ref.set_role(&mut game, role_data_copy);
         }
 
         Teams::on_team_creation(&mut game);
-        
-        game
+
+        Ok(game)
     }
 }

server/src/game/role/transporter.rs

@@ -8,7 +8,7 @@ use crate::game::end_game_condition::EndGameCondition;
 use crate::game::visit::Visit;
 use crate::game::Game;
 use crate::game::team::Team;
-use super::{Priority, RoleStateImpl};
+use super::{Priority, RoleStateImpl, Role};
 
 #[derive(Clone, Debug, Serialize, Default)]
 pub struct Transporter;
@@ -44,6 +44,7 @@ impl RoleStateImpl for Transporter {
 
         for player_ref in PlayerReference::all_players(game){
             if player_ref == actor_ref {continue;}
+            if player_ref.role(game) == Role::Transporter {continue;}
 
             let new_visits = player_ref.night_visits(game).clone().into_iter().map(|mut v|{
                 if v.target == first_visit.target {

server/src/listener.rs

@@ -33,15 +33,15 @@ impl Listener{
         const DESIRED_FRAME_TIME: Duration = Duration::from_millis(1000);
 
         tokio::spawn(async move {
-            let mut last_tick = tokio::time::Instant::now();
+            let mut frame_start_time = tokio::time::Instant::now();
             loop {
-                let delta_time;
+                let delta_time = frame_start_time.elapsed();
+                frame_start_time = tokio::time::Instant::now();
 
                 if let Ok(mut listener) = listener.lock() {
                     let mut closed_lobbies = Vec::new();
 
-                    delta_time = last_tick.elapsed();
-                    last_tick = tokio::time::Instant::now();
+                    
 
                     let Listener { ref mut lobbies, ref mut players } = *listener;
 
@@ -74,7 +74,7 @@ impl Listener{
                     return;
                 }
 
-                tokio::time::sleep(DESIRED_FRAME_TIME.saturating_sub(delta_time)).await;
+                tokio::time::sleep(DESIRED_FRAME_TIME.saturating_sub(tokio::time::Instant::now() - frame_start_time)).await;
             }
         });
     }

server/tests/kit/mod.rs

@@ -65,10 +65,13 @@ pub mod _init {
             role_list.push(RoleOutline::Any);
         }
 
-        let mut game = mock_game(Settings {
+        let mut game = match mock_game(Settings {
             role_list,
             ..Default::default()
-        }, roles.len());
+        }, roles.len()){
+            Ok(game) => game,
+            Err(err) => panic!("Failed to create game: {:?}", err),
+        };
 
         let mut players = Vec::new();
 

server/tests/role.rs

@@ -618,3 +618,78 @@ fn transporter_cant_transport_dead() {
     assert_not_contains!(thomas.get_messages(), ChatMessage::Transported);
     assert_not_contains!(townie.get_messages(), ChatMessage::Transported);
 }
+
+#[test]
+fn double_transport() {
+    kit::scenario!(game in Night 1 where
+        mafioso: Mafioso,
+ 
+        townie_a: Sheriff,
+        townie_b: Jailor,
+
+        trans_a: Transporter,
+        trans_b: Transporter
+    );
+    
+    assert!(mafioso.set_night_target(townie_a));
+
+    assert!(trans_a.set_night_targets(vec![townie_a, townie_b]));
+    assert!(trans_b.set_night_targets(vec![townie_b, townie_a]));
+
+    game.next_phase();
+    assert!(!townie_a.alive());
+    assert!(townie_b.alive());
+}
+
+
+#[test]
+fn double_transport_single_player() {
+    kit::scenario!(game in Night 1 where
+        mafioso: Mafioso,
+ 
+        townie_a: Sheriff,
+        townie_b: Jailor,
+        townie_c: Vigilante,
+
+        trans_a: Transporter,
+        trans_b: Transporter
+    );
+    
+    assert!(mafioso.set_night_target(townie_a));
+
+    assert!(trans_a.set_night_targets(vec![townie_a, townie_b]));
+    assert!(trans_b.set_night_targets(vec![townie_a, townie_c]));
+
+
+    game.next_phase();
+    assert!(townie_a.alive());
+    assert!(!townie_b.alive());
+    assert!(townie_c.alive());
+}
+
+#[test]
+fn double_transport_three_players() {
+    kit::scenario!(game in Night 1 where
+        mafioso: Mafioso,
+ 
+        townie_a: Sheriff,
+        townie_b: Jailor,
+        townie_c: Vigilante,
+
+        trans_a: Transporter,
+        trans_b: Transporter,
+        trans_c: Transporter
+    );
+    
+    assert!(mafioso.set_night_target(townie_a));
+
+    assert!(trans_a.set_night_targets(vec![townie_a, townie_b]));
+    assert!(trans_b.set_night_targets(vec![townie_a, townie_c]));
+    assert!(trans_c.set_night_targets(vec![townie_b, townie_c]));
+
+
+    game.next_phase();
+    assert!(townie_a.alive());
+    assert!(townie_b.alive());
+    assert!(!townie_c.alive());
+}