add rituals

Author: zeitlinger

client/src/advance_ui.rs

@@ -1,7 +1,7 @@
 use crate::client_state::{ActiveDialog, StateUpdate};
 use crate::layout_ui::{left_mouse_button_pressed_in_rect, top_centered_text};
 use crate::log_ui::break_text;
-use crate::payment_ui::{new_payment, payment_model_dialog, Payment};
+use crate::payment_ui::{new_payment, payment_dialog, Payment};
 use crate::player_ui::player_color;
 use crate::render_context::RenderContext;
 use crate::tooltip::show_tooltip_for_rect;
@@ -212,16 +212,10 @@ pub fn pay_advance_dialog(ap: &Payment, rc: &RenderContext) -> StateUpdate {
         // select a different advance
         return update;
     };
-    payment_model_dialog(
-        rc,
-        &[ap.clone()],
-        |p| ActiveDialog::AdvancePayment(p[0].clone()),
-        true,
-        |pile| {
-            StateUpdate::Execute(Action::Playing(PlayingAction::Advance {
-                advance: ap.name.to_string(),
-                payment: pile[0].clone(),
-            }))
-        },
-    )
+    payment_dialog(rc, ap, ActiveDialog::AdvancePayment, true, |payment| {
+        StateUpdate::Execute(Action::Playing(PlayingAction::Advance {
+            advance: ap.name.to_string(),
+            payment,
+        }))
+    })
 }

client/src/city_ui.rs

@@ -58,7 +58,7 @@ fn increase_happiness_button<'a>(rc: &'a RenderContext, city: &'a City) -> Optio
             open_increase_happiness_dialog(rc, |mut happiness| {
                 let mut target = city.mood_state.clone();
                 while target != MoodState::Happy {
-                    happiness = add_increase_happiness(city, &happiness);
+                    happiness = add_increase_happiness(rc, city, happiness);
                     target = target.clone().add(1);
                 }
                 happiness

client/src/combat_ui.rs

@@ -1,6 +1,6 @@
 use crate::client_state::{ActiveDialog, StateUpdate};
 use crate::dialog_ui::{cancel_button_with_tooltip, ok_button, OkTooltip};
-use crate::payment_ui::{new_payment, payment_model_dialog, Payment};
+use crate::payment_ui::{multi_payment_dialog, new_payment, payment_dialog, Payment};
 use crate::render_context::RenderContext;
 use crate::select_ui::ConfirmSelection;
 use crate::unit_ui;
@@ -125,7 +125,7 @@ impl SiegecraftPaymentDialog {
 }
 
 pub fn pay_siegecraft_dialog(p: &SiegecraftPaymentDialog, rc: &RenderContext) -> StateUpdate {
-    payment_model_dialog(
+    multi_payment_dialog(
         rc,
         &[p.extra_die.clone(), p.ignore_hit.clone()],
         |p| {
@@ -159,23 +159,23 @@ pub(crate) fn pay_steel_weapons_dialog(
 ) -> StateUpdate {
     let attacker = dialog.attacker;
 
-    payment_model_dialog(
+    payment_dialog(
         rc,
-        &[dialog.payment.clone()],
+        &dialog.payment.clone(),
         |p| {
             let mut n = dialog.clone();
-            n.payment = p[0].clone();
+            n.payment = p;
             ActiveDialog::SteelWeaponPayment(n)
         },
         false,
         |p| {
             if attacker {
                 StateUpdate::Execute(Action::CustomPhase(
-                    CustomPhaseAction::SteelWeaponsAttackerAction(p[0].clone()),
+                    CustomPhaseAction::SteelWeaponsAttackerAction(p),
                 ))
             } else {
                 StateUpdate::Execute(Action::CustomPhase(
-                    CustomPhaseAction::SteelWeaponsDefenderAction(p[0].clone()),
+                    CustomPhaseAction::SteelWeaponsDefenderAction(p),
                 ))
             }
         },

client/src/construct_ui.rs

@@ -1,5 +1,5 @@
 use crate::client_state::{ActiveDialog, StateUpdate};
-use crate::payment_ui::{new_payment, payment_model_dialog, Payment};
+use crate::payment_ui::{new_payment, payment_dialog, Payment};
 use crate::recruit_unit_ui::RecruitSelection;
 use crate::render_context::RenderContext;
 use server::action::Action;
@@ -37,21 +37,21 @@ pub fn new_building_positions(
 
 pub fn pay_construction_dialog(rc: &RenderContext, cp: &ConstructionPayment) -> StateUpdate {
     let city = rc.game.get_any_city(cp.city_position).unwrap();
-    payment_model_dialog(
+    payment_dialog(
         rc,
-        &[cp.payment.clone()],
+        &cp.payment.clone(),
         |p| {
             let mut new = cp.clone();
-            new.payment = p[0].clone();
+            new.payment = p;
             ActiveDialog::ConstructionPayment(new)
         },
         true,
-        |p| match &cp.project {
+        |payment| match &cp.project {
             ConstructionProject::Building(b, pos) => StateUpdate::execute_activation(
                 Action::Playing(PlayingAction::Construct(Construct {
                     city_position: cp.city_position,
                     city_piece: *b,
-                    payment: p[0].clone(),
+                    payment,
                     port_position: *pos,
                     temple_bonus: None,
                 })),
@@ -61,7 +61,7 @@ pub fn pay_construction_dialog(rc: &RenderContext, cp: &ConstructionPayment) ->
             ConstructionProject::Wonder(w) => StateUpdate::execute_activation(
                 Action::Playing(PlayingAction::Custom(CustomAction::ConstructWonder {
                     city_position: cp.city_position,
-                    payment: p[0].clone(),
+                    payment,
                     wonder: w.clone(),
                 })),
                 vec![],
@@ -71,7 +71,7 @@ pub fn pay_construction_dialog(rc: &RenderContext, cp: &ConstructionPayment) ->
                 Action::Playing(PlayingAction::Recruit(Recruit {
                     city_position: cp.city_position,
                     units: r.amount.units.clone().to_vec(),
-                    payment: p[0].clone(),
+                    payment,
                     replaced_units: r.replaced_units.clone(),
                     leader_name: r.amount.leader_name.clone(),
                 })),

client/src/happiness_ui.rs

@@ -1,23 +1,19 @@
 use crate::action_buttons::{base_or_custom_action, base_or_custom_available};
 use crate::client_state::{ActiveDialog, StateUpdate};
-use crate::dialog_ui::{
-    cancel_button, ok_button, BaseOrCustomAction, BaseOrCustomDialog, OkTooltip,
-};
+use crate::dialog_ui::{BaseOrCustomAction, BaseOrCustomDialog};
+use crate::payment_ui::{new_payment, payment_dialog, Payment};
 use crate::render_context::RenderContext;
-use crate::resource_ui::show_resource_pile;
 use server::action::Action;
 use server::city::City;
 use server::content::custom_actions::{CustomAction, CustomActionType};
 use server::player::Player;
 use server::playing_actions::{IncreaseHappiness, PlayingAction, PlayingActionType};
 use server::position::Position;
-use server::resource::ResourceType;
-use server::resource_pile::ResourcePile;
 
 #[derive(Clone)]
 pub struct IncreaseHappinessConfig {
     pub steps: Vec<(Position, u32)>,
-    pub cost: ResourcePile,
+    pub payment: Payment,
     pub custom: BaseOrCustomDialog,
 }
 
@@ -26,10 +22,23 @@ impl IncreaseHappinessConfig {
         let steps = p.cities.iter().map(|c| (c.position, 0)).collect();
         IncreaseHappinessConfig {
             steps,
-            cost: ResourcePile::empty(),
+            payment: Self::happiness_payment(p, &[(p.cities[0].position, 0)]),
             custom,
         }
     }
+
+    fn happiness_payment(p: &Player, new_steps: &[(Position, u32)]) -> Payment {
+        let payment = new_steps
+            .iter()
+            .map(|(pos, steps)| {
+                let city = p.get_city(*pos).unwrap();
+                p.increase_happiness_cost(city, *steps).unwrap()
+            })
+            .reduce(|a, b| a + b)
+            .unwrap();
+
+        new_payment(&payment, &p.resources, "Increase happiness", false)
+    }
 }
 
 pub fn can_play_increase_happiness(rc: &RenderContext) -> bool {
@@ -65,95 +74,80 @@ pub fn increase_happiness_click(
 ) -> StateUpdate {
     if let Some(city) = rc.shown_player.get_city(pos) {
         StateUpdate::OpenDialog(ActiveDialog::IncreaseHappiness(add_increase_happiness(
-            city, h,
+            rc,
+            city,
+            h.clone(),
         )))
     } else {
         StateUpdate::None
     }
 }
 
 pub fn add_increase_happiness(
+    rc: &RenderContext,
     city: &City,
-    increase_happiness: &IncreaseHappinessConfig,
+    mut increase_happiness: IncreaseHappinessConfig,
 ) -> IncreaseHappinessConfig {
-    let mut total_cost = increase_happiness.cost.clone();
-    let new_steps = increase_happiness
+    let new_steps: Vec<(Position, u32)> = increase_happiness
         .steps
         .iter()
         .map(|(p, steps)| {
             let old_steps = *steps;
             if *p == city.position {
-                if let Some(r) = increase_happiness_steps(city, &total_cost, old_steps) {
-                    total_cost = r.1;
-                    return (*p, r.0);
+                if let Some(r) = increase_happiness_steps(rc, city, old_steps) {
+                    return (*p, r);
                 };
             }
             (*p, old_steps)
         })
         .collect();
 
-    IncreaseHappinessConfig {
-        steps: new_steps,
-        cost: total_cost,
-        custom: increase_happiness.custom.clone(),
-    }
+    increase_happiness.payment =
+        IncreaseHappinessConfig::happiness_payment(rc.shown_player, &new_steps);
+    increase_happiness.steps = new_steps;
+    increase_happiness
 }
 
-fn increase_happiness_steps(
-    city: &City,
-    total_cost: &ResourcePile,
-    old_steps: u32,
-) -> Option<(u32, ResourcePile)> {
-    if let Some(value) = increase_happiness_new_steps(city, total_cost, old_steps, old_steps + 1) {
+fn increase_happiness_steps(rc: &RenderContext, city: &City, old_steps: u32) -> Option<u32> {
+    if let Some(value) = increase_happiness_new_steps(rc, city, old_steps + 1) {
         return Some(value);
     }
-    if let Some(value) = increase_happiness_new_steps(city, total_cost, old_steps, 0) {
+    if let Some(value) = increase_happiness_new_steps(rc, city, 0) {
         return Some(value);
     }
     None
 }
 
-fn increase_happiness_new_steps(
-    city: &City,
-    total_cost: &ResourcePile,
-    old_steps: u32,
-    new_steps: u32,
-) -> Option<(u32, ResourcePile)> {
-    if let Some(new_cost) = city.increase_happiness_cost(new_steps) {
-        let mut new_total = total_cost.clone();
-        if old_steps > 0 {
-            new_total -= city
-                .increase_happiness_cost(old_steps)
-                .expect("invalid steps");
-        }
-        new_total += new_cost;
-        return Some((new_steps, new_total));
-    }
-    None
+fn increase_happiness_new_steps(rc: &RenderContext, city: &City, new_steps: u32) -> Option<u32> {
+    rc.shown_player
+        .increase_happiness_cost(city, new_steps)
+        .map(|_| new_steps)
 }
 
 pub fn increase_happiness_menu(rc: &RenderContext, h: &IncreaseHappinessConfig) -> StateUpdate {
-    show_resource_pile(rc, &h.cost, &[ResourceType::MoodTokens]);
-
-    let tooltip = if rc.shown_player.resources.can_afford(&h.cost) {
-        OkTooltip::Valid("Increase happiness".to_string())
-    } else {
-        OkTooltip::Invalid("Not enough resources".to_string())
-    };
-    if ok_button(rc, tooltip) {
-        let i = IncreaseHappiness {
-            happiness_increases: h.steps.clone(),
-        };
-        let action = match &h.custom.custom {
-            BaseOrCustomAction::Base => PlayingAction::IncreaseHappiness(i),
-            BaseOrCustomAction::Custom { .. } => {
-                PlayingAction::Custom(CustomAction::VotingIncreaseHappiness(i))
-            }
-        };
-        return StateUpdate::Execute(Action::Playing(action));
-    }
-    if cancel_button(rc) {
-        return StateUpdate::Cancel;
-    }
-    StateUpdate::None
+    payment_dialog(
+        rc,
+        &h.payment,
+        |payment| {
+            ActiveDialog::IncreaseHappiness(IncreaseHappinessConfig {
+                steps: h.steps.clone(),
+                payment,
+                custom: h.custom.clone(),
+            })
+        },
+        true,
+        |payment| {
+            let i = IncreaseHappiness {
+                happiness_increases: h.steps.clone(),
+                payment,
+            };
+            let action = match &h.custom.custom {
+                BaseOrCustomAction::Base => PlayingAction::IncreaseHappiness(i),
+                BaseOrCustomAction::Custom { .. } => {
+                    PlayingAction::Custom(CustomAction::VotingIncreaseHappiness(i))
+                }
+            };
+            StateUpdate::execute(Action::Playing(action))
+        },
+    )
 }

client/src/influence_ui.rs

@@ -77,7 +77,7 @@ fn show_city(rc: &RenderContext, mouse_pos: Vec2, city: &City) -> Option<StateUp
                 city.position,
                 *b,
             ) {
-                if player.resources.can_afford(&cost) {
+                if player.can_afford_resources(&cost) {
                     let name = building_name(*b);
                     let _ = rc.with_camera(CameraMode::World, |rc| {
                         draw_circle_lines(center.x, center.y, BUILDING_SIZE, 1., WHITE);

client/src/payment_ui.rs

@@ -76,9 +76,25 @@ impl Payment {
     }
 }
 
-pub fn payment_model_dialog(
+pub fn payment_dialog(
     rc: &RenderContext,
-    payments: &[Payment], // None means the player can pay nothing
+    payments: &Payment,
+    to_dialog: impl FnOnce(Payment) -> ActiveDialog,
+    may_cancel: bool,
+    execute_action: impl FnOnce(ResourcePile) -> StateUpdate,
+) -> StateUpdate {
+    multi_payment_dialog(
+        rc,
+        &[payments.clone()],
+        |v| to_dialog(v[0].clone()),
+        may_cancel,
+        |v| execute_action(v[0].clone()),
+    )
+}
+
+pub fn multi_payment_dialog(
+    rc: &RenderContext,
+    payments: &[Payment],
     to_dialog: impl FnOnce(Vec<Payment>) -> ActiveDialog,
     may_cancel: bool,
     execute_action: impl FnOnce(Vec<ResourcePile>) -> StateUpdate,
@@ -202,6 +218,7 @@ fn sum_payment(a: &SumPaymentOptions, available: &ResourcePile) -> Vec<ResourceP
         .collect()
 }
 
+// todo: move to Payment::new
 #[must_use]
 pub fn new_payment(
     model: &PaymentModel,