New draft (#149)

Author: zeitlinger

client/Cargo.lock

@@ -29,10 +29,7 @@ pub enum AdvanceState {
 }
 
 fn new_advance_payment(rc: &RenderContext, name: &str) -> Payment {
-    let p = rc.shown_player;
-    let options = &p.advance_cost(name);
-    let available = &p.resources;
-    Payment::new(options, available, name, false)
+    rc.new_payment(&rc.shown_player.advance_cost(name), name, false)
 }
 
 pub fn show_paid_advance_menu(rc: &RenderContext) -> StateUpdate {
@@ -214,7 +211,7 @@ pub fn pay_advance_dialog(ap: &Payment, rc: &RenderContext) -> StateUpdate {
         // select a different advance
         return update;
     };
-    payment_dialog(rc, ap, ActiveDialog::AdvancePayment, |payment| {
+    payment_dialog(rc, ap, true, ActiveDialog::AdvancePayment, |payment| {
         StateUpdate::Execute(Action::Playing(PlayingAction::Advance {
             advance: ap.name.to_string(),
             payment,

client/src/advance_ui.rs

@@ -146,6 +146,7 @@ fn render_active_dialog(rc: &RenderContext) -> StateUpdate {
         }
         ActiveDialog::ExploreResolution(r) => explore_dialog(rc, r),
         ActiveDialog::MoveUnits(_) => move_ui::move_units_dialog(rc),
+        ActiveDialog::MovePayment(p) => move_ui::move_payment_dialog(rc, p),
 
         //status phase
         ActiveDialog::FreeAdvance => show_free_advance_menu(rc),

client/src/client.rs

@@ -1,14 +1,3 @@
-use macroquad::prelude::*;
-use server::ability_initializer::EventOrigin;
-use server::action::Action;
-use server::city::{City, MoodState};
-use server::combat::{active_attackers, active_defenders, CombatPhase};
-use server::content::advances::{NAVIGATION, ROADS};
-use server::content::custom_phase_actions::CustomPhaseRequest;
-use server::game::{CulturalInfluenceResolution, CurrentMove, Game, GameState};
-use server::position::Position;
-use server::status_phase::{StatusPhaseAction, StatusPhaseState};
-
 use crate::assets::Assets;
 use crate::client::{Features, GameSyncRequest};
 use crate::collect_ui::CollectResources;
@@ -18,11 +7,21 @@ use crate::happiness_ui::IncreaseHappinessConfig;
 use crate::layout_ui::FONT_SIZE;
 use crate::log_ui::{add_advance_help, advance_help};
 use crate::map_ui::ExploreResolutionConfig;
-use crate::move_ui::{MoveDestination, MoveIntent, MoveSelection};
+use crate::move_ui::{MoveDestination, MoveIntent, MovePayment, MoveSelection};
 use crate::payment_ui::Payment;
 use crate::recruit_unit_ui::{RecruitAmount, RecruitSelection};
 use crate::render_context::RenderContext;
 use crate::status_phase_ui::ChooseAdditionalAdvances;
+use macroquad::prelude::*;
+use server::ability_initializer::EventOrigin;
+use server::action::Action;
+use server::city::{City, MoodState};
+use server::combat::{active_attackers, active_defenders, CombatPhase};
+use server::content::advances::{NAVIGATION, ROADS};
+use server::content::custom_phase_actions::CustomPhaseRequest;
+use server::game::{CulturalInfluenceResolution, CurrentMove, Game, GameState};
+use server::position::Position;
+use server::status_phase::{StatusPhaseAction, StatusPhaseState};
 
 #[derive(Clone)]
 pub enum ActiveDialog {
@@ -40,6 +39,7 @@ pub enum ActiveDialog {
     RecruitUnitSelection(RecruitAmount),
     ReplaceUnits(RecruitSelection),
     MoveUnits(MoveSelection),
+    MovePayment(MovePayment),
     CulturalInfluence,
     CulturalInfluenceResolution(CulturalInfluenceResolution),
     ExploreResolution(ExploreResolutionConfig),
@@ -78,6 +78,7 @@ impl ActiveDialog {
             ActiveDialog::RecruitUnitSelection(_) => "recruit unit selection",
             ActiveDialog::ReplaceUnits(_) => "replace units",
             ActiveDialog::MoveUnits(_) => "move units",
+            ActiveDialog::MovePayment(_) => "move payment",
             ActiveDialog::CulturalInfluence => "cultural influence",
             ActiveDialog::CulturalInfluenceResolution(_) => "cultural influence resolution",
             ActiveDialog::ExploreResolution(_) => "explore resolution",
@@ -109,7 +110,9 @@ impl ActiveDialog {
                     "Click on a city to increase happiness".to_string(),
                 ]
             }
-            ActiveDialog::AdvancePayment(_) | ActiveDialog::ConstructionPayment(_) => {
+            ActiveDialog::AdvancePayment(_)
+            | ActiveDialog::ConstructionPayment(_)
+            | ActiveDialog::MovePayment(_) => {
                 vec!["Pay resources".to_string()]
             }
             ActiveDialog::CollectResources(collect) => collect.help_text(rc.game),
@@ -144,7 +147,7 @@ impl ActiveDialog {
                 vec!["Click on a building to influence its culture".to_string()]
             }
             ActiveDialog::CulturalInfluenceResolution(c) => vec![format!(
-                "Pay {} culture tokens to influence {}",
+                "Pay {} to influence {}",
                 c.roll_boost_cost,
                 c.city_piece.name()
             )],
@@ -509,7 +512,7 @@ impl State {
                     r.iter()
                         .map(|p| {
                             Payment::new(
-                                &p.options,
+                                &p.cost,
                                 &game.get_player(game.active_player()).resources,
                                 &p.name,
                                 p.optional,
@@ -518,7 +521,7 @@ impl State {
                         .collect(),
                 ),
                 CustomPhaseRequest::Reward(r) => {
-                    ActiveDialog::CustomPhaseRewardRequest(Payment::new_gain(&r.options, &r.name))
+                    ActiveDialog::CustomPhaseRewardRequest(Payment::new_gain(&r.reward, &r.name))
                 }
             };
         }

client/src/client_state.rs

@@ -7,10 +7,8 @@ use server::city::City;
 use server::city_pieces::Building;
 use server::content::custom_actions::CustomAction;
 use server::map::Terrain;
-use server::payment::PaymentOptions;
 use server::playing_actions::{Construct, PlayingAction, Recruit};
 use server::position::Position;
-use server::unit::UnitType;
 
 pub fn new_building_positions(
     building: Building,
@@ -40,6 +38,7 @@ pub fn pay_construction_dialog(rc: &RenderContext, cp: &ConstructionPayment) ->
     payment_dialog(
         rc,
         &cp.payment.clone(),
+        true,
         |p| {
             let mut new = cp.clone();
             new.payment = p;
@@ -69,7 +68,7 @@ pub fn pay_construction_dialog(rc: &RenderContext, cp: &ConstructionPayment) ->
             ConstructionProject::Units(r) => StateUpdate::execute_activation(
                 Action::Playing(PlayingAction::Recruit(Recruit {
                     city_position: cp.city_position,
-                    units: r.amount.units.clone().to_vec(),
+                    units: r.amount.units.clone(),
                     payment,
                     replaced_units: r.replaced_units.clone(),
                     leader_name: r.amount.leader_name.clone(),
@@ -113,20 +112,18 @@ impl ConstructionPayment {
                 .unwrap()
                 .cost
                 .clone(),
-            ConstructionProject::Units(sel) => PaymentOptions::resources(
-                sel.amount
-                    .units
-                    .clone()
-                    .to_vec()
-                    .iter()
-                    .map(UnitType::cost)
-                    .sum(),
-            ),
+            ConstructionProject::Units(sel) => rc
+                .shown_player
+                .recruit_cost(
+                    &sel.amount.units,
+                    city.position,
+                    sel.amount.leader_name.as_ref(),
+                    &sel.replaced_units,
+                )
+                .unwrap(),
         };
 
-        let available = &rc.shown_player.resources;
-        let payment = Payment::new(&cost, available, name, false);
-
+        let payment = rc.new_payment(&cost, name, false);
         ConstructionPayment {
             player_index: city.player_index,
             city_position: city.position,

client/src/construct_ui.rs

@@ -8,6 +8,7 @@ pub fn reward_dialog(rc: &RenderContext, payment: &Payment) -> StateUpdate {
     payment_dialog(
         rc,
         payment,
+        false,
         |p| ActiveDialog::CustomPhaseRewardRequest(p.clone()),
         |p| {
             StateUpdate::Execute(Action::CustomPhaseEvent(CustomPhaseEventAction::Reward(

client/src/custom_actions_ui.rs

@@ -40,8 +40,7 @@ impl IncreaseHappinessConfig {
             })
             .unwrap();
 
-        let available = &p.resources;
-        Payment::new(&payment, available, "Increase happiness", false)
+        Payment::new(&payment, &p.resources, "Increase happiness", false)
     }
 }
 
@@ -132,6 +131,7 @@ pub fn increase_happiness_menu(rc: &RenderContext, h: &IncreaseHappinessConfig)
     payment_dialog(
         rc,
         &h.payment,
+        true,
         |payment| {
             ActiveDialog::IncreaseHappiness(IncreaseHappinessConfig {
                 steps: h.steps.clone(),

client/src/happiness_ui.rs

@@ -16,7 +16,6 @@ use server::player::Player;
 use server::playing_actions::{InfluenceCultureAttempt, PlayingAction};
 use server::position::Position;
 use server::resource::ResourceType;
-use server::resource_pile::ResourcePile;
 
 fn closest_city(player: &Player, position: Position) -> Position {
     player
@@ -32,8 +31,8 @@ pub fn cultural_influence_resolution_dialog(
     r: &CulturalInfluenceResolution,
 ) -> StateUpdate {
     let name = r.city_piece.name();
-    let pile = ResourcePile::culture_tokens(r.roll_boost_cost);
-    show_resource_pile(rc, &pile, &[ResourceType::CultureTokens]);
+    let pile = &r.roll_boost_cost;
+    show_resource_pile(rc, pile, &[ResourceType::CultureTokens]);
     if ok_button(rc, OkTooltip::Valid(format!("Influence {name} for {pile}"))) {
         return StateUpdate::Execute(Action::CulturalInfluenceResolution(true));
     }
@@ -77,7 +76,7 @@ fn show_city(rc: &RenderContext, mouse_pos: Vec2, city: &City) -> Option<StateUp
                 city.position,
                 *b,
             ) {
-                if player.can_afford_resources(&cost) {
+                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);

client/src/influence_ui.rs

@@ -9,7 +9,7 @@ use server::game::{Game, GameData};
 use server::map::Terrain;
 use server::position::Position;
 use server::resource_pile::ResourcePile;
-use server::unit::UnitType;
+use server::unit::{UnitType, Units};
 use std::env;
 use std::fs::File;
 use std::io::BufReader;
@@ -75,13 +75,9 @@ pub fn setup_local_game() -> Game {
     game.round = 6;
     game.dice_roll_outcomes = vec![1, 1, 10, 10, 10, 10, 10, 10, 10, 10];
     let add_unit = |game: &mut Game, pos: &str, player_index: usize, unit_type: UnitType| {
-        game.recruit(
-            player_index,
-            vec![unit_type],
-            Position::from_offset(pos),
-            None,
-            &[],
-        );
+        let mut units = Units::empty();
+        units += &unit_type;
+        game.recruit(player_index, units, Position::from_offset(pos), None, &[]);
     };
 
     let player_index1 = 0;

client/src/local_client/bin/main.rs

@@ -146,7 +146,7 @@ fn overlay_color(rc: &RenderContext, pos: Position) -> Color {
                 } else if s
                     .destinations
                     .iter()
-                    .any(|d| matches!(d, MoveDestination::Tile(p) if *p == pos))
+                    .any(|d| matches!(d, MoveDestination::Tile((p, _)) if *p == pos))
                 {
                     MOVE_DESTINATION
                 } else {

client/src/map_ui.rs

@@ -2,12 +2,15 @@ use macroquad::math::{u32, Vec2};
 use macroquad::prelude::Texture2D;
 use server::action::Action;
 use server::game::{CurrentMove, Game, GameState};
+use server::payment::PaymentOptions;
 use server::player::Player;
 use server::position::Position;
-use server::unit::{MovementAction, Unit, UnitType};
+use server::resource_pile::ResourcePile;
+use server::unit::{MoveUnits, MovementAction, Unit, UnitType};
 
 use crate::client_state::{ActiveDialog, StateUpdate};
 use crate::dialog_ui::cancel_button_with_tooltip;
+use crate::payment_ui::{payment_dialog, Payment};
 use crate::render_context::RenderContext;
 use crate::unit_ui::{click_unit, unit_selection_clicked};
 
@@ -18,6 +21,12 @@ pub enum MoveIntent {
     Disembark,
 }
 
+#[derive(Clone)]
+pub struct MovePayment {
+    pub action: MovementAction,
+    pub payment: Payment,
+}
+
 impl MoveIntent {
     pub fn to_predicate(self) -> impl Fn(&Unit) -> bool {
         match self {
@@ -56,7 +65,7 @@ pub fn possible_destinations(
         .move_units_destinations(game, units, start, None)
         .unwrap_or_default()
         .into_iter()
-        .map(|route| MoveDestination::Tile(route.destination))
+        .map(|route| MoveDestination::Tile((route.destination, route.cost)))
         .collect::<Vec<_>>();
 
     player.units.iter().for_each(|u| {
@@ -75,10 +84,12 @@ fn move_destination(
     dest: &MoveDestination,
     pos: Position,
     unit: Option<u32>,
-) -> Option<(Position, Option<u32>)> {
+) -> Option<(Position, Option<u32>, Option<PaymentOptions>)> {
     match dest {
-        MoveDestination::Tile(p) if p == &pos => Some((*p, None)),
-        MoveDestination::Carrier(id) if unit.is_some_and(|u| u == *id) => Some((pos, Some(*id))),
+        MoveDestination::Tile((p, cost)) if p == &pos => Some((*p, None, Some(cost.clone()))),
+        MoveDestination::Carrier(id) if unit.is_some_and(|u| u == *id) => {
+            Some((pos, Some(*id), None))
+        }
         _ => None,
     }
 }
@@ -87,17 +98,26 @@ pub fn click(rc: &RenderContext, pos: Position, s: &MoveSelection, mouse_pos: Ve
     let game = rc.game;
     let p = game.get_player(s.player_index);
     let carrier = click_unit(rc, pos, mouse_pos, p, false);
-    if let Some((destination, embark_carrier_id)) = s
+    if let Some((destination, embark_carrier_id, cost)) = s
         .destinations
         .iter()
         .find_map(|d| move_destination(d, pos, carrier))
     {
         let units = s.units.clone();
-        StateUpdate::execute(Action::Movement(MovementAction::Move {
+        let action = MovementAction::Move(MoveUnits {
             units,
             destination,
             embark_carrier_id,
-        }))
+            payment: ResourcePile::empty(),
+        });
+
+        if let Some(cost) = cost {
+            return StateUpdate::OpenDialog(ActiveDialog::MovePayment(MovePayment {
+                action,
+                payment: rc.new_payment(&cost, "Move units", true),
+            }));
+        }
+        StateUpdate::execute(Action::Movement(action))
     } else if s.start.is_some_and(|p| p != pos) {
         // first need to deselect units
         StateUpdate::None
@@ -168,7 +188,7 @@ pub fn movable_units(
 
 #[derive(Clone, Debug)]
 pub enum MoveDestination {
-    Tile(Position),
+    Tile((Position, PaymentOptions)),
     Carrier(u32),
 }
 
@@ -242,3 +262,24 @@ pub(crate) fn move_units_dialog(rc: &RenderContext) -> StateUpdate {
     }
     StateUpdate::None
 }
+
+pub(crate) fn move_payment_dialog(rc: &RenderContext, mp: &MovePayment) -> StateUpdate {
+    payment_dialog(
+        rc,
+        &mp.payment.clone(),
+        true,
+        |p| {
+            let mut new = mp.clone();
+            new.payment = p;
+            ActiveDialog::MovePayment(new)
+        },
+        |payment| {
+            if let MovementAction::Move(mut m) = mp.action.clone() {
+                m.payment = payment;
+                StateUpdate::execute(Action::Movement(MovementAction::Move(m)))
+            } else {
+                panic!("Unexpected action");
+            }
+        },
+    )
+}