cultural influence (#158)

Author: zeitlinger

client/src/influence_ui.rs

@@ -16,6 +16,7 @@ use server::city::City;
 use server::content::custom_actions::CustomAction;
 use server::game::CulturalInfluenceResolution;
 use server::player::Player;
+use server::player_events::InfluenceCulturePossible;
 use server::playing_actions::{InfluenceCultureAttempt, PlayingAction};
 use server::position::Position;
 use server::resource::ResourceType;
@@ -77,46 +78,43 @@ fn show_city(
                 closest_city_pos
             };
 
-            if let Some(cost) = rc.game.influence_culture_boost_cost(
+            let info = rc.game.influence_culture_boost_cost(
                 player.index,
                 start_position,
                 city.player_index,
                 city.position,
                 *b,
-            ) {
-                if player.can_afford(&cost) {
-                    let name = b.name();
-                    let _ = rc.with_camera(CameraMode::World, |rc| {
-                        draw_circle_lines(center.x, center.y, BUILDING_SIZE, 1., WHITE);
-                        show_tooltip_for_circle(
-                            rc,
-                            &format!("Attempt Influence {name} for {cost}"),
-                            center.to_vec2(),
-                            BUILDING_SIZE,
-                        );
-                        StateUpdate::None
-                    });
+            );
+            if !matches!(info.possible, InfluenceCulturePossible::Impossible) {
+                let name = b.name();
+                let _ = rc.with_camera(CameraMode::World, |rc| {
+                    draw_circle_lines(center.x, center.y, BUILDING_SIZE, 1., WHITE);
+                    show_tooltip_for_circle(
+                        rc,
+                        &format!("Attempt Influence {name} for {}", info.range_boost_cost),
+                        center.to_vec2(),
+                        BUILDING_SIZE,
+                    );
+                    StateUpdate::None
+                });
 
-                    if is_in_circle(mouse_pos, center, BUILDING_SIZE)
-                        && is_mouse_button_pressed(MouseButton::Left)
-                    {
-                        let attempt = InfluenceCultureAttempt {
-                            starting_city_position: start_position,
-                            target_player_index: city.player_index,
-                            target_city_position: city.position,
-                            city_piece: *b,
-                        };
-                        let action = match custom.custom {
-                            BaseOrCustomAction::Base => {
-                                PlayingAction::InfluenceCultureAttempt(attempt)
-                            }
-                            BaseOrCustomAction::Custom { .. } => PlayingAction::Custom(
-                                CustomAction::ArtsInfluenceCultureAttempt(attempt),
-                            ),
-                        };
+                if is_in_circle(mouse_pos, center, BUILDING_SIZE)
+                    && is_mouse_button_pressed(MouseButton::Left)
+                {
+                    let attempt = InfluenceCultureAttempt {
+                        starting_city_position: start_position,
+                        target_player_index: city.player_index,
+                        target_city_position: city.position,
+                        city_piece: *b,
+                    };
+                    let action = match custom.custom {
+                        BaseOrCustomAction::Base => PlayingAction::InfluenceCultureAttempt(attempt),
+                        BaseOrCustomAction::Custom { .. } => PlayingAction::Custom(
+                            CustomAction::ArtsInfluenceCultureAttempt(attempt),
+                        ),
+                    };
 
-                        return Some(StateUpdate::Execute(Action::Playing(action)));
-                    }
+                    return Some(StateUpdate::Execute(Action::Playing(action)));
                 }
             }
 

server/src/content/advances_autocracy.rs

@@ -6,14 +6,41 @@ use crate::content::custom_actions::CustomActionType::{AbsolutePower, ForcedLabo
 pub(crate) fn autocracy() -> AdvanceGroup {
     advance_group_builder(
         "Autocracy",
-        vec![nationalism(), absolute_power(), forced_labor()],
+        vec![
+            nationalism(),
+            totalitarianism(),
+            absolute_power(),
+            forced_labor(),
+        ],
     )
 }
 
 fn nationalism() -> AdvanceBuilder {
     Advance::builder("Nationalism", "todo")
 }
 
+fn totalitarianism() -> AdvanceBuilder {
+    Advance::builder(
+        "Totalitarianism",
+        "Attempts to influence your cities with Army Units may not be boosted by culture tokens",
+    )
+    .add_player_event_listener(
+        |event| &mut event.on_influence_culture_attempt,
+        |info, city, game| {
+            if info.is_defender
+                && game
+                    .get_player(city.player_index)
+                    .get_units(city.position)
+                    .iter()
+                    .any(|u| u.unit_type.is_army_unit())
+            {
+                info.set_no_boost();
+            }
+        },
+        0,
+    )
+}
+
 fn absolute_power() -> AdvanceBuilder {
     Advance::builder(
         "Absolute Power",

server/src/content/advances_construction.rs

@@ -24,7 +24,7 @@ pub(crate) fn construction() -> AdvanceGroup {
 fn engineering() -> AdvanceBuilder {
     Advance::builder(
         "Engineering",
-        "Immediately draw 1 wonder, May Construct wonder happy cities",
+        "Immediately draw 1 wonder card. May Construct wonders in happy cities",
     )
     .add_one_time_ability_initializer(Game::draw_wonder_card)
     .add_custom_action(ConstructWonder)

server/src/content/advances_culture.rs

@@ -14,7 +14,7 @@ use crate::resource_pile::ResourcePile;
 use std::vec;
 
 pub(crate) fn culture() -> AdvanceGroup {
-    advance_group_builder("Culture", vec![arts(), sports(), theaters()])
+    advance_group_builder("Culture", vec![arts(), sports(), monuments(), theaters()])
 }
 
 fn arts() -> AdvanceBuilder {
@@ -30,6 +30,21 @@ fn sports() -> AdvanceBuilder {
         .add_custom_action(CustomActionType::Sports)
 }
 
+fn monuments() -> AdvanceBuilder {
+    Advance::builder("Monuments", "Immediately draw 1 wonder card. Your cities with wonders may not be the target of influence culture attempts")
+        .add_one_time_ability_initializer(Game::draw_wonder_card)
+        .with_advance_bonus(CultureToken)
+        .add_player_event_listener(
+            |event| &mut event.on_influence_culture_attempt,
+            |info, city, _| {
+                if info.is_defender && !city.pieces.wonders.is_empty() {
+                    info.set_impossible();
+                }
+            },
+            1,
+        )
+}
+
 fn theaters() -> AdvanceBuilder {
     Advance::builder("Theaters",
                      "Once per turn, as a free action, you may convert 1 culture token into 1 mood token, or 1 mood token into 1 culture token")

server/src/content/advances_democracy.rs

@@ -1,13 +1,22 @@
 use crate::ability_initializer::AbilityInitializerSetup;
 use crate::advance::{Advance, AdvanceBuilder};
+use crate::city::MoodState;
 use crate::content::advances::{advance_group_builder, AdvanceGroup};
 use crate::content::custom_actions::CustomActionType::{
     CivilRights, FreeEconomyCollect, VotingIncreaseHappiness,
 };
 use crate::playing_actions::PlayingActionType;
 
 pub(crate) fn democracy() -> AdvanceGroup {
-    advance_group_builder("Democracy", vec![voting(), civil_rights(), free_economy()])
+    advance_group_builder(
+        "Democracy",
+        vec![
+            voting(),
+            separation_of_power(),
+            civil_rights(),
+            free_economy(),
+        ],
+    )
 }
 
 fn voting() -> AdvanceBuilder {
@@ -18,6 +27,22 @@ fn voting() -> AdvanceBuilder {
     .add_custom_action(VotingIncreaseHappiness)
 }
 
+fn separation_of_power() -> AdvanceBuilder {
+    Advance::builder(
+        "Separation of Power",
+        "Attempts to influence your happy cities may not be boosted by culture tokens",
+    )
+    .add_player_event_listener(
+        |event| &mut event.on_influence_culture_attempt,
+        |info, city, _| {
+            if matches!(city.mood_state, MoodState::Happy) {
+                info.set_no_boost();
+            }
+        },
+        0,
+    )
+}
+
 fn civil_rights() -> AdvanceBuilder {
     Advance::builder(
         "Civil Rights",

server/src/content/advances_theocracy.rs

@@ -10,26 +10,48 @@ pub(crate) fn theocracy() -> AdvanceGroup {
         "Theocracy",
         vec![
             dogma(),
-            Advance::builder("Dedication", "todo"),
-            Advance::builder("Conversion", "todo"),
+            devotion(),
+            conversion(),
             Advance::builder("Fanaticism", "todo"),
         ],
     )
 }
 
+fn conversion() -> AdvanceBuilder {
+    Advance::builder("Conversion", "You add +1 to your Influence Culture roll and gain 1 culture token when you make a successful Influence Culture attempt.")
+        .add_player_event_listener(
+            |event| &mut event.on_influence_culture_attempt,
+            |info, _, _| {
+                if !info.is_defender {
+                    info.roll_boost += 1;
+                    info.info.log.push("Player gets +1 to Influence Culture roll for Conversion Advance".to_string());
+                }
+            },
+            0,
+        )
+        .add_player_event_listener(
+            |event| &mut event.on_influence_culture_success,
+            |c, _, ()| {
+                c.gain_resources(ResourcePile::culture_tokens(1));
+                c.add_info_log_item("Player gained 1 culture token for a successful Influence Culture attempt for Conversion Advance");
+            },
+            0,
+        )
+}
+
 fn dogma() -> AdvanceBuilder {
     Advance::builder("Dogma", "Whenever you Construct a new Temple, either through the Construct Action or through playing of cards, you may immediately get a Theocracy Advance for free, marking it with a cube from your Event tracker as normal.
     You are now limited to a maximum of 2 ideas. If you have more than 2 ideas when
     getting this Advance, you must immediately reduce down to 2.
     Note: Dogma Advance does not apply when you conquer a city with a Temple.")
         .add_one_time_ability_initializer(|game, player_index| {
-            let p = & mut game.players[player_index];
+            let p = &mut game.players[player_index];
             p.resource_limit.ideas = 2;
             p.gain_resources(ResourcePile::ideas(0)); // to trigger the limit
-          })
-          .add_ability_undo_deinitializer(|game, player_index| {
-              game.players[player_index].resource_limit.ideas = 7;
-          })
+        })
+        .add_ability_undo_deinitializer(|game, player_index| {
+            game.players[player_index].resource_limit.ideas = 7;
+        })
         .add_advance_reward_request_listener(
             |event| &mut event.on_construct,
             0,
@@ -63,3 +85,19 @@ fn dogma() -> AdvanceBuilder {
             },
         )
 }
+
+fn devotion() -> AdvanceBuilder {
+    Advance::builder(
+        "Devotion",
+        "Attempts to influence your cities with a Temple may not be boosted by culture tokens",
+    )
+    .add_player_event_listener(
+        |event| &mut event.on_influence_culture_attempt,
+        |info, city, _| {
+            if info.is_defender && city.pieces.temple.is_some() {
+                info.set_no_boost();
+            }
+        },
+        0,
+    )
+}

server/src/content/custom_actions.rs

@@ -172,7 +172,7 @@ impl CustomAction {
             CustomAction::CivilRights =>
                 format!("{player_name} gained 3 mood tokens using Civil Rights"),
             CustomAction::ArtsInfluenceCultureAttempt(c) =>
-                format!("{} using Arts", format_cultural_influence_attempt_log_item(game, player_name, c)),
+                format!("{} using Arts", format_cultural_influence_attempt_log_item(game, player.index, player_name, c)),
             CustomAction::VotingIncreaseHappiness(i) =>
                 format!("{} using Voting", format_happiness_increase(player, player_name, i)),
             CustomAction::FreeEconomyCollect(c) =>