Incidents

server/src/action.rs

@@ -172,7 +172,7 @@ pub(crate) fn execute_custom_phase_action(
             on_recruit(game, player_index, r);
         }
         Incident(i) => {
-            trigger_incident(game, player_index, i);
+            trigger_incident(game, i.clone());
         }
     }
 }

server/src/advance.rs

@@ -200,7 +200,7 @@ pub(crate) fn gain_advance(game: &mut Game, player_index: usize, info: &AdvanceI
     player.incident_tokens -= 1;
     if player.incident_tokens == 0 {
         player.incident_tokens = 3;
-        trigger_incident(game, player_index, &IncidentInfo::new(player_index));
+        trigger_incident(game, IncidentInfo::new(player_index));
     }
 }
 

server/src/barbarians.rs

@@ -7,7 +7,7 @@ use crate::content::custom_phase_actions::{
     new_position_request, ResourceRewardRequest, UnitTypeRequest,
 };
 use crate::game::Game;
-use crate::incident::{IncidentBuilder, BASE_EFFECT_PRIORITY};
+use crate::incident::{play_base_effect, IncidentBuilder, BASE_EFFECT_PRIORITY};
 use crate::map::Terrain;
 use crate::payment::PaymentOptions;
 use crate::player::Player;
@@ -230,7 +230,7 @@ pub(crate) fn barbarians_move(mut builder: IncidentBuilder) -> IncidentBuilder {
     builder.add_simple_incident_listener(
         IncidentTarget::ActivePlayer,
         BASE_EFFECT_PRIORITY,
-        |game, player, _| {
+        |game, player, _, _| {
             let s = get_barbarian_state(game);
             if s.move_units && get_movable_units(game, player, &s).is_empty() {
                 // after all moves are done
@@ -313,8 +313,8 @@ pub(crate) fn set_info(
     builder.add_simple_incident_listener(
         IncidentTarget::ActivePlayer,
         BASE_EFFECT_PRIORITY + 200,
-        move |game, player, _| {
-            if game.current_event().barbarians.is_none() {
+        move |game, player, _, _| {
+            if play_base_effect(game) && game.current_event().barbarians.is_none() {
                 game.add_info_log_item(&format!("Base effect: {name}"));
                 let mut state = BarbariansEventState::new();
                 init(&mut state, game, player);
@@ -417,9 +417,9 @@ fn possible_barbarians_reinforcements(game: &Game) -> Vec<Position> {
 
 fn get_barbarian_reinforcement_choices(game: &Game) -> Vec<UnitType> {
     let barbarian = get_barbarians_player(game);
-    let pos = get_barbarian_state(game)
-        .selected_position
-        .expect("selected position should exist");
+    let Some(pos) = get_barbarian_state(game).selected_position else {
+        return vec![];
+    };
     let possible = if barbarian
         .get_units(pos)
         .iter()

server/src/content.rs

@@ -22,6 +22,7 @@ mod incidents_earthquake;
 mod incidents_famine;
 mod incidents_good_year;
 mod incidents_population_boom;
+mod incidents_trade;
 mod incidents_trojan;
 pub mod trade_routes;
 pub mod wonders;

server/src/content/advances_autocracy.rs

@@ -4,7 +4,6 @@ use crate::content::advances::{advance_group_builder, AdvanceGroup};
 use crate::content::custom_actions::CustomActionType::{AbsolutePower, ForcedLabor};
 use crate::content::custom_phase_actions::ResourceRewardRequest;
 use crate::payment::PaymentOptions;
-use crate::resource::ResourceType;
 
 pub(crate) fn autocracy() -> AdvanceGroup {
     advance_group_builder(
@@ -35,10 +34,7 @@ fn nationalism() -> AdvanceBuilder {
                 .any(|u| u.is_army_unit() || u.is_ship())
             {
                 Some(ResourceRewardRequest::new(
-                    PaymentOptions::sum(
-                        1,
-                        &[ResourceType::MoodTokens, ResourceType::CultureTokens],
-                    ),
+                    PaymentOptions::tokens(1),
                     "Select token to gain".to_string(),
                 ))
             } else {

server/src/content/incidects_civil_war.rs

@@ -8,7 +8,6 @@ use crate::payment::{PaymentConversion, PaymentConversionType, PaymentOptions};
 use crate::player::Player;
 use crate::player_events::IncidentTarget;
 use crate::position::Position;
-use crate::resource::ResourceType;
 use crate::resource_pile::ResourcePile;
 use crate::status_phase::{add_change_government, can_change_government_for_free};
 use crate::unit::UnitType;
@@ -140,7 +139,7 @@ fn revolution() -> Incident {
         "Kill a unit to avoid losing an action",
         |game, _player| can_loose_action(game),
     );
-    b = b.add_simple_incident_listener(IncidentTarget::ActivePlayer, 2, |game, player, _| {
+    b = b.add_simple_incident_listener(IncidentTarget::ActivePlayer, 2, |game, player, _, _| {
         if can_loose_action(game) && game.current_event_player().sacrifice == 0 {
             loose_action(game, player);
         }
@@ -229,7 +228,7 @@ fn uprising() -> Incident {
             0,
             |game, player_index, _incident| {
                 let player = game.get_player(player_index);
-                let mut cost = PaymentOptions::sum(4, &[ResourceType::MoodTokens, ResourceType::CultureTokens]);
+                let mut cost = PaymentOptions::tokens(4);
                 cost.conversions.push(PaymentConversion::new(
                     vec![ResourcePile::mood_tokens(1), ResourcePile::culture_tokens(1)],
                     ResourcePile::empty(),
@@ -258,7 +257,7 @@ fn envoy() -> Incident {
         .add_simple_incident_listener(
             IncidentTarget::ActivePlayer,
             1,
-            |game, player, player_name | {
+            |game, player, player_name, _| {
                 game.add_info_log_item(&format!("{player_name} gained 1 idea and 1 culture token"));
                 game.get_player_mut(player).gain_resources(
                     ResourcePile::culture_tokens(1) + ResourcePile::ideas(1));
@@ -274,7 +273,7 @@ fn envoy() -> Incident {
         )
         .add_incident_player_request(
             "Select a player to gain 1 culture token",
-            |_p| true,
+            |_p, _| true,
             0,
             |game, s| {
                 let p = s.choice;

server/src/content/incidents.rs

@@ -4,6 +4,7 @@ use crate::content::incidents_earthquake::earthquakes;
 use crate::content::incidents_famine::{epidemics, famines, pestilence};
 use crate::content::incidents_good_year::{awesome_years, fantastic_years, good_years};
 use crate::content::incidents_population_boom::population_booms;
+use crate::content::incidents_trade::trades;
 use crate::content::incidents_trojan::trojan_incidents;
 use crate::incident::Incident;
 use itertools::Itertools;
@@ -30,6 +31,8 @@ pub(crate) fn get_all() -> Vec<Incident> {
         civil_wars(),
         // 41+
         trojan_incidents(),
+        // 45+
+        trades(),
         // 51+
         successful_year(),
     ]

server/src/content/incidents_famine.rs

@@ -32,7 +32,7 @@ pub(crate) fn pestilence() -> Vec<Incident> {
     });
     builder = pestilence_city(builder, 1);
     builder =
-        builder.add_simple_incident_listener(IncidentTarget::ActivePlayer, 0, |game, _, _| {
+        builder.add_simple_incident_listener(IncidentTarget::ActivePlayer, 0, |game, _, _, _| {
             game.permanent_incident_effects
                 .push(PermanentIncidentEffect::Pestilence);
         });

server/src/content/incidents_good_year.rs

@@ -141,7 +141,7 @@ fn good_year(mut builder: IncidentBuilder, amount: u32, good_year_type: &GoodYea
 
             builder = builder.add_incident_player_request(
                 "Select a player to gain 1 food",
-                |p| p.resources.food < p.resource_limit.food,
+                |p, _| p.resources.food < p.resource_limit.food,
                 i as i32,
                 move |game, c| {
                     game.add_info_log_item(&format!(

server/src/content/incidents_population_boom.rs

@@ -1,7 +1,6 @@
 use crate::content::custom_phase_actions::new_position_request;
-use crate::game::Game;
 use crate::incident::{Incident, IncidentBaseEffect, IncidentBuilder};
-use crate::player_events::{IncidentInfo, IncidentTarget};
+use crate::player_events::IncidentTarget;
 use crate::unit::UnitType;
 
 pub(crate) fn population_booms() -> Vec<Incident> {
@@ -13,16 +12,14 @@ pub(crate) fn population_booms() -> Vec<Incident> {
 
 fn population_boom(id: u8, effect: IncidentBaseEffect) -> Incident {
     let mut b = Incident::builder(id, "Population Boom", "-", effect);
-    b = select_settler(b, 13, |_game, player, i| {
-        i.is_active(IncidentTarget::ActivePlayer, player)
-    });
+    b = select_settler(b, 13, IncidentTarget::ActivePlayer);
     select_player_to_gain_settler(b).build()
 }
 
 pub(crate) fn select_player_to_gain_settler(mut b: IncidentBuilder) -> IncidentBuilder {
     b = b.add_incident_player_request(
         "Select a player to gain 1 settler",
-        |p| p.available_units().settlers > 0 && !p.cities.is_empty(),
+        |p, _| p.available_units().settlers > 0 && !p.cities.is_empty(),
         12,
         |game, c| {
             game.add_info_log_item(&format!(
@@ -32,22 +29,16 @@ pub(crate) fn select_player_to_gain_settler(mut b: IncidentBuilder) -> IncidentB
             game.current_event_mut().selected_player = Some(c.choice);
         },
     );
-    select_settler(b, 11, |game, player, _| {
-        game.current_event().selected_player == Some(player)
-    })
+    select_settler(b, 11, IncidentTarget::SelectedPlayer)
 }
 
-fn select_settler(
-    b: IncidentBuilder,
-    priority: i32,
-    pred: impl Fn(&Game, usize, &IncidentInfo) -> bool + 'static + Clone,
-) -> IncidentBuilder {
+fn select_settler(b: IncidentBuilder, priority: i32, target: IncidentTarget) -> IncidentBuilder {
     b.add_incident_position_request(
-        IncidentTarget::AllPlayers,
+        target,
         priority,
-        move |game, player_index, incident| {
+        move |game, player_index, _| {
             let p = game.get_player(player_index);
-            if pred(game, player_index, incident) && p.available_units().settlers > 0 {
+            if p.available_units().settlers > 0 {
                 Some(new_position_request(
                     p.cities.iter().map(|c| c.position).collect(),
                     1..=1,