pestilence (#167)

Author: zeitlinger

client/src/event_ui.rs

@@ -9,20 +9,21 @@ use server::events::EventOrigin;
 
 #[must_use]
 pub fn event_help(rc: &RenderContext, origin: &EventOrigin, do_break: bool) -> Vec<String> {
-    let h = match origin {
-        EventOrigin::Advance(a) => get_advance(a).description,
-        EventOrigin::Wonder(w) => get_wonder(w).description,
-        EventOrigin::Builtin(b) => get_builtin(b).description,
+    let mut h = vec![origin.name()];
+    h.extend(match origin {
+        EventOrigin::Advance(a) => vec![get_advance(a).description],
+        EventOrigin::Wonder(w) => vec![get_wonder(w).description],
+        EventOrigin::Builtin(b) => vec![get_builtin(b).description],
         EventOrigin::Incident(id) => get_incident(*id).description(),
-        EventOrigin::Leader(l) => {
+        EventOrigin::Leader(l) => vec![{
             let l = rc.shown_player.get_leader(l).unwrap();
             // todo: leader should have a 2 event sources - no each event source should have a description
             format!(
                 "{}, {}",
                 l.first_ability_description, l.second_ability_description
             )
-        }
-        EventOrigin::SpecialAdvance(s) => {
+        }],
+        EventOrigin::SpecialAdvance(s) => vec![{
             let s = rc
                 .shown_player
                 .civilization
@@ -31,15 +32,18 @@ pub fn event_help(rc: &RenderContext, origin: &EventOrigin, do_break: bool) -> V
                 .find(|sa| &sa.name == s)
                 .unwrap();
             s.description.clone()
-        }
-    };
-    let h = format!("{}: {}", origin.name(), h);
+        }],
+    });
     if do_break {
-        let mut result = vec![];
-        break_text(&h, 30, &mut result);
-        result
+        h.iter()
+            .flat_map(|s| {
+                let mut result = vec![];
+                break_text(s, 30, &mut result);
+                result
+            })
+            .collect()
     } else {
-        vec![h]
+        h
     }
 }
 

server/src/barbarians.rs

@@ -310,7 +310,7 @@ pub(crate) fn set_info(
                 let mut state = BarbariansEventState::new();
                 init(&mut state, game, p.player);
                 game.current_custom_phase_mut().barbarians = Some(state);
-                game.add_to_last_log_item(&name);
+                game.add_info_log_item(&format!("Base effect: {name}"));
             }
         },
     )

server/src/combat.rs

@@ -777,6 +777,7 @@ pub mod tests {
             wonders_left: Vec::new(),
             wonder_amount_left: 0,
             incidents_left: Vec::new(),
+            permanent_incident_effects: Vec::new(),
             undo_context_stack: Vec::new(),
         }
     }

server/src/content.rs

@@ -16,5 +16,8 @@ pub mod civilizations;
 pub mod custom_actions;
 pub mod custom_phase_actions;
 pub mod incidents;
+mod incidents_1;
+mod incidents_2;
+mod incidents_5;
 pub mod trade_routes;
 pub mod wonders;

server/src/content/advances_construction.rs

@@ -31,7 +31,7 @@ fn engineering() -> AdvanceBuilder {
 fn sanitation() -> AdvanceBuilder {
     Advance::builder(
         "Sanitation",
-        "When Recruiting, you may spend 1 mood token to pay for 1 Settler.",
+        "When Recruiting, you may spend 1 mood token to pay for 1 Settler. Ignore Pestilence and Epidemics events.",
     )
     .with_advance_bonus(MoodToken)
     .add_player_event_listener(

server/src/content/advances_democracy.rs

@@ -56,8 +56,9 @@ fn free_economy() -> AdvanceBuilder {
         .add_custom_action(FreeEconomyCollect)
         .add_player_event_listener(
             |event| &mut event.is_playing_action_available,
-            |available, action_type, player| {
-                if matches!(action_type, PlayingActionType::Collect) && player.played_once_per_turn_actions.contains(&FreeEconomyCollect) {
+            |available, game, i| {
+                let p = game.get_player(i.player);
+                if matches!(i.action_type, PlayingActionType::Collect) && p.played_once_per_turn_actions.contains(&FreeEconomyCollect) {
                     *available = false;
                 }
             },

server/src/content/builtin.rs

@@ -4,6 +4,7 @@ use crate::barbarians::barbarians_bonus;
 use crate::combat_listeners::{
     choose_carried_units_casualties, choose_fighter_casualties, offer_retreat, place_settler,
 };
+use crate::content::incidents_1::pestilence_permanent_effect;
 use crate::events::EventOrigin;
 use crate::pirates::{pirates_bonus, pirates_round_bonus};
 
@@ -65,6 +66,7 @@ pub fn get_all() -> Vec<Builtin> {
         barbarians_bonus(),
         pirates_bonus(),
         pirates_round_bonus(),
+        pestilence_permanent_effect(),
     ]
 }
 

server/src/content/incidents.rs

@@ -1,19 +1,24 @@
-use crate::content::custom_phase_actions::{PlayerRequest, PositionRequest, ResourceRewardRequest};
-use crate::game::Game;
-use crate::incident::{Incident, IncidentBaseEffect, IncidentBuilder};
-use crate::payment::PaymentOptions;
-use crate::player_events::IncidentTarget;
-use crate::resource::ResourceType;
-use crate::unit::UnitType;
+use crate::content::incidents_1::{good_year, pestilence};
+use crate::content::incidents_2::population_boom;
+use crate::content::incidents_5::successful_year;
+use crate::incident::Incident;
 use itertools::Itertools;
 use std::vec;
 
 #[must_use]
 pub(crate) fn get_all() -> Vec<Incident> {
-    let all = vec![good_year(), population_boom(), successful_year()]
-        .into_iter()
-        .flatten()
-        .collect_vec();
+    let all = vec![
+        // 1+
+        pestilence(),
+        good_year(),
+        // 11+
+        population_boom(),
+        // 51+
+        successful_year(),
+    ]
+    .into_iter()
+    .flatten()
+    .collect_vec();
     assert_eq!(
         all.iter().unique_by(|i| i.id).count(),
         all.len(),
@@ -22,171 +27,6 @@ pub(crate) fn get_all() -> Vec<Incident> {
     all
 }
 
-fn population_boom() -> Vec<Incident> {
-    let mut b = Incident::builder(
-        28,
-        "Population Boom",
-        "-",
-        IncidentBaseEffect::BarbariansMove,
-    );
-    b = select_settler(b, 2, |game, _| {
-        game.current_custom_phase().is_active_player()
-    });
-    b = b.add_incident_player_request(
-        IncidentTarget::ActivePlayer,
-        1,
-        |game, player_index, _incident| {
-            let choices = game
-                .players
-                .iter()
-                .filter(|p| p.available_units().settlers > 0 && p.index != player_index)
-                .map(|p| p.index)
-                .collect_vec();
-
-            if choices.is_empty() {
-                None
-            } else {
-                Some(PlayerRequest::new(
-                    choices,
-                    "Select a unit to gain 1 settler",
-                ))
-            }
-        },
-        |game, c| {
-            game.add_info_log_item(&format!(
-                "{} was selected to gain 1 settler from Population Boom",
-                game.get_player(c.choice).get_name()
-            ));
-            game.current_custom_phase_mut().selected_player = Some(c.choice);
-        },
-    );
-    b = select_settler(b, 0, |game, player| {
-        let c = game.current_custom_phase();
-        c.selected_player == Some(player)
-    });
-    vec![b.build()]
-}
-
-fn select_settler(
-    b: IncidentBuilder,
-    priority: i32,
-    pred: impl Fn(&Game, usize) -> bool + 'static + Clone,
-) -> IncidentBuilder {
-    b.add_incident_position_request(
-        IncidentTarget::AllPlayers,
-        priority,
-        move |game, player_index, _incident| {
-            let p = game.get_player(player_index);
-            if pred(game, player_index) && p.available_units().settlers > 0 {
-                Some(PositionRequest::new(
-                    p.cities.iter().map(|c| c.position).collect(),
-                    Some("Select a city to gain 1 settler".to_string()),
-                ))
-            } else {
-                None
-            }
-        },
-        |game, s| {
-            game.add_info_log_item(&format!(
-                "{} gained 1 settler in {}",
-                s.player_name, s.choice
-            ));
-            game.get_player_mut(s.player_index)
-                .add_unit(s.choice, UnitType::Settler);
-        },
-    )
-}
-
-fn successful_year() -> Vec<Incident> {
-    vec![Incident::builder(
-        54,
-        "A successful year",
-        "-",
-        IncidentBaseEffect::PiratesSpawnAndRaid,
-    )
-    .add_incident_resource_request(
-        IncidentTarget::AllPlayers,
-        0,
-        |game, player_index, _incident| {
-            let player_to_city_num = game
-                .players
-                .iter()
-                .map(|p| p.cities.len())
-                .collect::<Vec<_>>();
-
-            let min_cities = player_to_city_num.iter().min().unwrap_or(&0);
-            let max_cities = player_to_city_num.iter().max().unwrap_or(&0);
-            if min_cities == max_cities {
-                return Some(ResourceRewardRequest::new(
-                    PaymentOptions::sum(1, &[ResourceType::Food]),
-                    "-".to_string(),
-                ));
-            }
-
-            let cities = game.players[player_index].cities.len();
-            if cities == *min_cities {
-                Some(ResourceRewardRequest::new(
-                    PaymentOptions::sum((max_cities - min_cities) as u32, &[ResourceType::Food]),
-                    "-".to_string(),
-                ))
-            } else {
-                None
-            }
-        },
-        |_game, s| {
-            vec![format!(
-                "{} gained {} from A successful year",
-                s.player_name, s.choice
-            )]
-        },
-    )
-    .build()]
-}
-
-fn good_year() -> Vec<Incident> {
-    vec![
-        add_good_year(
-            IncidentTarget::AllPlayers,
-            Incident::builder(
-                9,
-                "A good year",
-                "Every player gains 1 food",
-                IncidentBaseEffect::BarbariansSpawn,
-            ),
-        ),
-        add_good_year(
-            IncidentTarget::ActivePlayer,
-            Incident::builder(
-                10,
-                "A good year",
-                "You gain 1 food",
-                IncidentBaseEffect::BarbariansSpawn,
-            ),
-        ),
-    ]
-}
-
-fn add_good_year(target: IncidentTarget, builder: IncidentBuilder) -> Incident {
-    builder
-        .add_incident_resource_request(
-            target,
-            0,
-            |_game, _player_index, _incident| {
-                Some(ResourceRewardRequest::new(
-                    PaymentOptions::sum(1, &[ResourceType::Food]),
-                    "Gain 1 food".to_string(),
-                ))
-            },
-            |_game, s| {
-                vec![format!(
-                    "{} gained {} from A good year",
-                    s.player_name, s.choice
-                )]
-            },
-        )
-        .build()
-}
-
 ///
 /// # Panics
 /// Panics if incident does not exist