cleanup (#178)

Author: zeitlinger

client/src/action_buttons.rs

@@ -164,7 +164,7 @@ pub fn base_or_custom_available(
     custom: &CustomActionType,
 ) -> bool {
     rc.can_play_action(action)
-        || (rc.game.state() == &GameState::Playing
+        || (rc.game.state == GameState::Playing
             && rc
                 .game
                 .is_custom_action_available(rc.shown_player.index, custom))

client/src/advance_ui.rs

@@ -38,9 +38,7 @@ pub fn show_paid_advance_menu(rc: &RenderContext) -> StateUpdate {
         |a, p| {
             if p.has_advance(&a.name) {
                 AdvanceState::Owned
-            } else if game.state() == &GameState::Playing
-                && game.actions_left > 0
-                && p.can_advance(a)
+            } else if game.state == GameState::Playing && game.actions_left > 0 && p.can_advance(a)
             {
                 AdvanceState::Available
             } else {

client/src/client_state.rs

@@ -552,7 +552,7 @@ impl State {
                 }
             };
         }
-        match &game.state() {
+        match &game.state {
             GameState::Playing | GameState::Finished => ActiveDialog::None,
             GameState::Movement(move_state) => ActiveDialog::MoveUnits(MoveSelection::new(
                 game.active_player(),
@@ -561,7 +561,6 @@ impl State {
                 MoveIntent::Land, // is not used, because no tile is focused
                 &move_state.current_move,
             )),
-            GameState::Combat(_) | GameState::StatusPhase(_) => panic!("should be in custom phase"),
         }
     }
 

client/src/map_ui.rs

@@ -3,6 +3,7 @@ use crate::client_state::{ActiveDialog, State, StateUpdate, MAX_OFFSET, MIN_OFFS
 use crate::dialog_ui::{cancel_button_pos, ok_button, OkTooltip};
 use crate::layout_ui::{bottom_center_texture, bottom_right_texture, icon_pos};
 use crate::move_ui::{movable_units, MoveDestination, MoveIntent};
+use crate::player_ui::get_combat;
 use crate::render_context::RenderContext;
 use crate::select_ui::HighlightType;
 use crate::{collect_ui, hex_ui, unit_ui};
@@ -11,7 +12,6 @@ use macroquad::prelude::*;
 use server::action::Action;
 use server::combat::Combat;
 use server::content::custom_phase_actions::CurrentEventResponse;
-use server::game::GameState;
 use server::map::{Rotation, Terrain, UnexploredBlock};
 use server::playing_actions::{PlayingAction, PlayingActionType};
 use server::position::Position;
@@ -74,7 +74,8 @@ pub fn draw_map(rc: &RenderContext) -> StateUpdate {
             return update;
         }
     }
-    if let GameState::Combat(c) = &game.state() {
+    // get from current event
+    if let Some(c) = get_combat(game) {
         draw_combat_arrow(c);
     }
     let state = &rc.state;

client/src/move_ui.rs

@@ -265,7 +265,7 @@ impl MoveSelection {
 }
 
 pub(crate) fn move_units_dialog(rc: &RenderContext) -> StateUpdate {
-    if matches!(rc.game.state(), GameState::Playing)
+    if matches!(rc.game.state, GameState::Playing)
         && cancel_button_with_tooltip(rc, "Back to playing actions")
     {
         return StateUpdate::CloseDialog;

client/src/player_ui.rs

@@ -15,12 +15,14 @@ use crate::unit_ui;
 use macroquad::math::vec2;
 use macroquad::prelude::*;
 use server::action::Action;
+use server::combat::Combat;
 use server::consts::ARMY_MOVEMENT_REQUIRED_ADVANCE;
-use server::game::GameState::Movement;
+use server::content::custom_phase_actions::CurrentEventType;
 use server::game::{Game, GameState};
-use server::movement::{CurrentMove, MoveState};
+use server::movement::CurrentMove;
 use server::playing_actions::PlayingAction;
 use server::resource::ResourceType;
+use server::status_phase::get_status_phase;
 use server::unit::MovementAction;
 
 pub fn player_select(rc: &RenderContext) -> StateUpdate {
@@ -156,13 +158,14 @@ pub fn show_top_left(rc: &RenderContext) {
 
     let game = rc.game;
 
-    match &game.state() {
+    match &game.state {
         GameState::Finished => label("Finished"),
         _ => label(&format!("Age {}", game.age)),
     }
-    match &game.state() {
-        GameState::StatusPhase(ref p) => label(&format!("Status Phase: {p:?}")),
-        _ => label(&format!("Round {}", game.round)),
+    if let Some(s) = get_status_phase(game) {
+        label(&format!("Status Phase: {s:?}"));
+    } else {
+        label(&format!("Round {}", game.round));
     }
 
     let player = rc.shown_player;
@@ -181,11 +184,10 @@ pub fn show_top_left(rc: &RenderContext) {
     ));
 
     if game.current_player_index == player.index {
-        match &game.state() {
-            GameState::StatusPhase(_) | GameState::Finished => {}
-            _ => label(&format!("{} actions left", game.actions_left)),
+        if get_status_phase(game).is_none() && game.state != GameState::Finished {
+            label(&format!("{} actions left", game.actions_left));
         }
-        if let Some(moves) = move_state(game) {
+        if let GameState::Movement(moves) = &game.state {
             let movement_actions_left = moves.movement_actions_left;
             label(&format!("Move units: {movement_actions_left} moves left"));
             match moves.current_move {
@@ -201,7 +203,7 @@ pub fn show_top_left(rc: &RenderContext) {
         }
     }
 
-    if let GameState::Combat(c) = &game.state() {
+    if let Some(c) = get_combat(game) {
         if c.attacker == player.index {
             label(&format!("Attack - combat round {}", c.round));
         } else if c.defender == player.index {
@@ -247,10 +249,15 @@ pub fn show_top_left(rc: &RenderContext) {
     }
 }
 
-pub fn move_state(game: &Game) -> Option<&MoveState> {
-    game.state_stack
-        .iter()
-        .find_map(|s| if let Movement(m) = s { Some(m) } else { None })
+pub fn get_combat(game: &Game) -> Option<&Combat> {
+    game.current_events
+        .last()
+        .and_then(|e| match &e.event_type {
+            CurrentEventType::CombatStart(c) => Some(c),
+            CurrentEventType::CombatRoundEnd(e) => Some(&e.combat),
+            CurrentEventType::CombatEnd(e) => Some(&e.combat),
+            _ => None,
+        })
 }
 
 pub fn show_global_controls(rc: &RenderContext, features: &Features) -> StateUpdate {
@@ -291,15 +298,15 @@ pub fn show_global_controls(rc: &RenderContext, features: &Features) -> StateUpd
 }
 
 fn can_end_move(game: &Game) -> Option<&str> {
-    match game.state() {
+    match game.state {
         GameState::Movement { .. } => Some("End movement"),
         GameState::Playing => Some("End turn"),
-        _ => None,
+        GameState::Finished => None,
     }
 }
 
 fn end_move(game: &Game) -> StateUpdate {
-    if let GameState::Movement(m) = &game.state() {
+    if let GameState::Movement(m) = &game.state {
         let movement_actions_left = m.movement_actions_left;
         return StateUpdate::execute_with_warning(
             Action::Movement(MovementAction::Stop),

client/src/render_context.rs

@@ -65,7 +65,7 @@ impl RenderContext<'_> {
 
     pub fn can_play_action(&self, action: PlayingActionType) -> bool {
         self.can_control()
-            && self.game.state() == &GameState::Playing
+            && self.game.state == GameState::Playing
             && self.game.actions_left > 0
             && action.is_available(self.game, self.shown_player.index)
     }

server/src/action.rs

@@ -1,17 +1,17 @@
 use crate::advance::gain_advance;
 use crate::combat::{
-    combat_loop, combat_round_end, end_combat, move_with_possible_combat, start_combat, take_combat,
+    combat_loop, combat_round_end, end_combat, move_with_possible_combat, start_combat,
 };
 use crate::content::custom_phase_actions::{CurrentEventResponse, CurrentEventType};
 use crate::cultural_influence::ask_for_cultural_influence_payment;
 use crate::explore::{ask_explore_resolution, move_to_unexplored_tile};
-use crate::game::GameState::{Combat, Finished, Movement, Playing, StatusPhase};
+use crate::game::GameState::{Finished, Movement, Playing};
 use crate::game::{ActionLogItem, Game, GameState};
 use crate::incident::trigger_incident;
 use crate::log;
 use crate::map::Terrain::Unexplored;
 use crate::movement::{
-    has_movable_units, move_units_destinations, take_move_state, CurrentMove, MoveState,
+    get_move_state, has_movable_units, move_units_destinations, CurrentMove, MoveState,
 };
 use crate::playing_actions::PlayingAction;
 use crate::recruit::on_recruit;
@@ -148,19 +148,18 @@ pub(crate) fn execute_custom_phase_action(
         InfluenceCultureResolution(r) => {
             ask_for_cultural_influence_payment(game, player_index, r);
         }
-        CombatStart => {
-            start_combat(game);
+        CombatStart(c) => {
+            start_combat(game, c.clone());
         }
         CombatRoundEnd(r) => {
             if let Some(c) = combat_round_end(game, r) {
                 combat_loop(game, c);
             }
         }
         CombatEnd(r) => {
-            let c = take_combat(game);
-            end_combat(game, c, r.clone());
+            end_combat(game, r);
         }
-        StatusPhase => play_status_phase(game),
+        StatusPhase(s) => play_status_phase(game, s.clone()),
         TurnStart => game.start_turn(),
         Advance(a) => {
             gain_advance(game, player_index, a);
@@ -182,12 +181,16 @@ pub(crate) fn add_log_item_from_action(game: &mut Game, action: &Action) {
 }
 
 fn execute_regular_action(game: &mut Game, action: Action, player_index: usize) {
-    match game.state() {
+    match game.state {
         Playing => {
             if let Some(m) = action.clone().movement() {
+                if let MovementAction::Move(_) = m {
+                } else {
+                    panic!("Illegal action");
+                }
                 assert_ne!(game.actions_left, 0, "Illegal action");
                 game.actions_left -= 1;
-                game.push_state(GameState::Movement(MoveState::new()));
+                game.state = GameState::Movement(MoveState::new());
                 execute_movement_action(game, m, player_index);
             } else {
                 let action = action.playing().expect("action should be a playing action");
@@ -200,12 +203,6 @@ fn execute_regular_action(game: &mut Game, action: Action, player_index: usize)
                 .expect("action should be a movement action");
             execute_movement_action(game, action, player_index);
         }
-        Combat(_) => {
-            panic!("actions can't be executed when the game is in a combat state");
-        }
-        StatusPhase(_) => {
-            panic!("actions can't be executed when the game is in a status state");
-        }
         Finished => panic!("actions can't be executed when the game is finished"),
     }
 }
@@ -247,16 +244,16 @@ pub(crate) fn execute_movement_action(
                 }
             }
 
-            let mut move_state = take_move_state(game);
-            move_state.moved_units.extend(m.units.iter());
-            move_state.moved_units = move_state.moved_units.iter().unique().copied().collect();
             let current_move = get_current_move(
                 game,
                 &m.units,
                 starting_position,
                 m.destination,
                 m.embark_carrier_id,
             );
+            let move_state = get_move_state(game);
+            move_state.moved_units.extend(m.units.iter());
+            move_state.moved_units = move_state.moved_units.iter().unique().copied().collect();
 
             if matches!(current_move, CurrentMove::None) || move_state.current_move != current_move
             {
@@ -267,7 +264,6 @@ pub(crate) fn execute_movement_action(
                 // roads move ends the current move
                 move_state.current_move = CurrentMove::None;
             }
-            game.push_state(GameState::Movement(move_state));
 
             let dest_terrain = game
                 .map
@@ -290,16 +286,15 @@ pub(crate) fn execute_movement_action(
             }
         }
         Stop => {
-            game.pop_state();
+            game.state = GameState::Playing;
             return;
         }
     };
 
-    let state = take_move_state(game);
+    let state = get_move_state(game);
     let all_moves_used =
         state.movement_actions_left == 0 && state.current_move == CurrentMove::None;
     if all_moves_used || !has_movable_units(game, game.get_player(game.current_player_index)) {
-        return;
+        game.state = GameState::Playing;
     }
-    game.push_state(GameState::Movement(state));
 }

server/src/advance.rs

@@ -187,13 +187,16 @@ pub(crate) fn advance_with_incident_token(
 }
 
 pub(crate) fn gain_advance(game: &mut Game, player_index: usize, info: &AdvanceInfo) {
-    if game.trigger_current_event(
-        &[player_index],
-        |e| &mut e.on_advance,
-        info,
-        CurrentEventType::Advance,
-        None,
-    ) {
+    if game
+        .trigger_current_event(
+            &[player_index],
+            |e| &mut e.on_advance,
+            info,
+            CurrentEventType::Advance,
+            None,
+        )
+        .is_none()
+    {
         return;
     }
     let player = &mut game.players[player_index];