Maya (#142)

Author: zeitlinger

client/src/assets.rs

@@ -89,10 +89,17 @@ impl Assets {
     }
 
     fn wonders() -> HashMap<String, Texture2D> {
-        [(
-            "Pyramids".to_string(),
-            load_png(include_bytes!("../assets/pyramid-svgrepo-com.png")),
-        )]
+        [
+            (
+                "Pyramids".to_string(),
+                load_png(include_bytes!("../assets/pyramid-svgrepo-com.png")),
+            ),
+            (
+                "Great Gardens".to_string(),
+                // todo find a better icon
+                load_png(include_bytes!("../assets/pyramid-svgrepo-com.png")),
+            ),
+        ]
         .iter()
         .cloned()
         .collect()

client/src/collect_ui.rs

@@ -7,9 +7,7 @@ use crate::dialog_ui::{
 };
 use crate::hex_ui;
 use crate::hex_ui::Point;
-use crate::layout_ui::{
-    draw_icon, draw_scaled_icon, is_in_circle, left_mouse_button_pressed, ICON_SIZE,
-};
+use crate::layout_ui::{draw_scaled_icon, is_in_circle, left_mouse_button_pressed};
 use crate::render_context::RenderContext;
 use crate::resource_ui::{new_resource_map, resource_name, show_resource_pile};
 use macroquad::color::BLACK;
@@ -150,19 +148,23 @@ pub fn draw_resource_collect_tile(rc: &RenderContext, pos: Position) -> StateUpd
 
             let c = hex_ui::center(pos);
             for (i, pile) in possible.iter().enumerate() {
-                let center = if possible.len() == 1 {
-                    c
-                } else {
-                    hex_ui::rotate_around(c, 30.0, 90 * i)
+                let deg = (360. / possible.len() as f32) as usize * i;
+                let (center, radius) = match possible.len() {
+                    1 => (c, 20.),
+                    2 => (hex_ui::rotate_around(c, 30.0, deg), 20.),
+                    n if n <= 4 => (hex_ui::rotate_around(c, 30.0, deg), 20.),
+                    _ => (hex_ui::rotate_around(c, 30.0, deg), 10.),
                 };
+                let size = radius * 1.3;
+
                 let color = if col.is_some_and(|r| r == pile) {
                     BLACK
                 } else {
                     WHITE
                 };
-                draw_circle(center.x, center.y, 20., color);
+                draw_circle(center.x, center.y, radius, color);
                 if let Some(p) = left_mouse_button_pressed(rc) {
-                    if is_in_circle(p, center, 20.) {
+                    if is_in_circle(p, center, radius) {
                         return click_collect_option(rc, collect, pos, pile);
                     }
                 }
@@ -175,32 +177,37 @@ pub fn draw_resource_collect_tile(rc: &RenderContext, pos: Position) -> StateUpd
                         a.is_some_and(|a| *a > 0).then(|| (*r, a.unwrap()))
                     })
                     .collect();
-                draw_collect_item(rc, center, &m);
+                draw_collect_item(rc, center, &m, size);
             }
         }
     };
     StateUpdate::None
 }
 
-fn draw_collect_item(rc: &RenderContext, center: Point, resources: &[(ResourceType, &u32)]) {
+fn draw_collect_item(
+    rc: &RenderContext,
+    center: Point,
+    resources: &[(ResourceType, &u32)],
+    size: f32,
+) {
     if resources.iter().len() == 1 {
         let (r, _) = resources.first().unwrap();
-        draw_icon(
+        draw_scaled_icon(
             rc,
             &rc.assets().resources[r],
             resource_name(*r),
-            center.to_vec2() - vec2(ICON_SIZE / 2., ICON_SIZE / 2.),
+            center.to_vec2() - vec2(size / 2., size / 2.),
+            size,
         );
     } else {
         resources.iter().enumerate().for_each(|(j, (r, _))| {
-            let size = ICON_SIZE / 2.;
             let c = hex_ui::rotate_around(center, 10.0, 180 * j);
             draw_scaled_icon(
                 rc,
                 &rc.assets().resources[r],
                 resource_name(*r),
                 c.to_vec2() - vec2(size / 2., size / 2.),
-                size,
+                size / 2.,
             );
         });
     }

client/src/local_client/bin/main.rs

@@ -155,9 +155,13 @@ pub fn setup_local_game() -> Game {
     //     .unwrap()
     //     .pieces
     //     .wonders = vec![game.wonders_left.pop().unwrap()];
-    game.players[player_index1]
-        .wonder_cards
-        .push(game.wonders_left.pop().unwrap());
+    let gardens = game.wonders_left.remove(
+        game.wonders_left
+            .iter()
+            .position(|w| w.name == "Great Gardens")
+            .unwrap(),
+    );
+    game.players[player_index1].wonder_cards.push(gardens);
     game.players[player_index1]
         .get_city_mut(Position::from_offset("C2"))
         .unwrap()
@@ -242,6 +246,9 @@ pub fn setup_local_game() -> Game {
 
     game.advance("Voting", player_index1);
     game.advance("Free Economy", player_index1);
+    game.advance("Storage", player_index1);
+    game.players[player_index1].gain_resources(ResourcePile::food(5));
+
     game
 }
 

server/src/combat.rs

@@ -2,7 +2,6 @@ use crate::action::{CombatAction, PlayActionCard};
 use crate::combat::CombatModifier::{
     CancelFortressExtraDie, SteelWeaponsAttacker, SteelWeaponsDefender,
 };
-use crate::content::advances::STEEL_WEAPONS;
 use crate::content::custom_phase_actions::{start_siegecraft_phase, start_steel_weapons_phase};
 use crate::game::GameState::Playing;
 use crate::game::{Game, GameState};
@@ -13,6 +12,30 @@ use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 use std::mem;
 
+#[derive(Clone, PartialEq)]
+pub struct CombatStrength {
+    pub attacker: bool,
+    pub player_index: usize,
+    pub extra_dies: u8,
+    pub extra_combat_value: u8,
+    pub hit_cancels: u8,
+    pub roll_log: Vec<String>,
+}
+
+impl CombatStrength {
+    #[must_use]
+    pub fn new(player_index: usize, attacker: bool) -> Self {
+        Self {
+            player_index,
+            attacker,
+            extra_dies: 0,
+            extra_combat_value: 0,
+            hit_cancels: 0,
+            roll_log: vec![],
+        }
+    }
+}
+
 #[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
 pub enum CombatPhase {
     PlayActionCard(usize),
@@ -259,90 +282,70 @@ fn remove_casualties(game: &mut Game, c: &mut Combat, units: Vec<u32>) -> Combat
     resolve_combat(game, c)
 }
 
+///
+/// # Panics
+/// Panics if events are not set
 pub fn combat_loop(game: &mut Game, mut c: Combat) {
     loop {
         game.add_info_log_item(format!("\nCombat round {}", c.round));
         //todo: go into tactics phase if either player has tactics card (also if they can not play it unless otherwise specified via setting)
 
-        let steel_weapon_value = if game.get_player(c.attacker).has_advance(STEEL_WEAPONS)
-            && game.get_player(c.defender).has_advance(STEEL_WEAPONS)
-        {
-            1
-        } else {
-            2
-        };
-        let mut steel_weapon_log = vec![];
         let attacker_name = game.players[c.attacker].get_name();
         let active_attackers = c.active_attackers(game);
-        let attacker_extra = if c.modifiers.contains(&SteelWeaponsAttacker) {
-            steel_weapon_log.push(format!(
-                "Attacker used steel weapons to add {steel_weapon_value} to their combat value"
-            ));
-            steel_weapon_value
-        } else {
-            0
-        };
+        let mut attacker_strength = CombatStrength::new(c.attacker, true);
+        game.players[c.attacker]
+            .events
+            .as_ref()
+            .expect("events should be set")
+            .on_combat_round
+            .trigger(&mut attacker_strength, &c, game);
         let mut attacker_log = vec![];
         let attacker_rolls = roll(
             game,
             c.attacker,
             &active_attackers,
-            0,
-            attacker_extra,
+            attacker_strength.extra_dies,
+            attacker_strength.extra_combat_value,
             &mut attacker_log,
         );
         let attacker_log_str = roll_log_str(&attacker_log);
 
         let active_defenders = active_defenders(game, c.defender, c.defender_position);
         let defender_name = game.players[c.defender].get_name();
         let mut defender_log = vec![];
-        let mut fortress_log = vec![];
-        let extra_defender_dies =
-            if c.defender_fortress(game) && !c.modifiers.contains(&CancelFortressExtraDie) {
-                fortress_log.push("added one extra die");
-                1
-            } else {
-                0
-            };
-        let defender_extra = if c.modifiers.contains(&SteelWeaponsDefender) {
-            steel_weapon_log.push(format!(
-                "Defender used steel weapons to add {steel_weapon_value} to their combat value"
-            ));
-            steel_weapon_value
-        } else {
-            0
-        };
+        let mut defender_strength = CombatStrength::new(c.defender, false);
+        game.players[c.defender]
+            .events
+            .as_ref()
+            .expect("events should be set")
+            .on_combat_round
+            .trigger(&mut defender_strength, &c, game);
         let defender_rolls = roll(
             game,
             c.defender,
             &active_defenders,
-            extra_defender_dies,
-            defender_extra,
+            defender_strength.extra_dies,
+            defender_strength.extra_combat_value,
             &mut defender_log,
         );
         let defender_log_str = roll_log_str(&defender_log);
         let attacker_combat_value = attacker_rolls.combat_value;
-        let attacker_hit_cancels = attacker_rolls.hit_cancels;
+        let attacker_hit_cancels = attacker_rolls.hit_cancels + attacker_strength.hit_cancels;
         let defender_combat_value = defender_rolls.combat_value;
-        let mut defender_hit_cancels = defender_rolls.hit_cancels;
-        if c.defender_fortress(game)
-            && !c
-                .modifiers
-                .contains(&CombatModifier::CancelFortressIgnoreHit)
-        {
-            defender_hit_cancels += 1;
-            fortress_log.push("cancelled one hit");
-        }
+        let defender_hit_cancels = defender_rolls.hit_cancels + defender_strength.hit_cancels;
         let attacker_hits = (attacker_combat_value / 5).saturating_sub(defender_hit_cancels);
         let defender_hits = (defender_combat_value / 5).saturating_sub(attacker_hit_cancels);
         game.add_info_log_item(format!("\t{attacker_name} rolled {attacker_log_str} for combined combat value of {attacker_combat_value} and gets {attacker_hits} hits against defending units. {defender_name} rolled {defender_log_str} for combined combat value of {defender_combat_value} and gets {defender_hits} hits against attacking units."));
-        if !steel_weapon_log.is_empty() {
-            game.add_info_log_item(steel_weapon_log.join(", "));
+        if !attacker_strength.roll_log.is_empty() {
+            game.add_info_log_item(format!(
+                ". {attacker_name} used the following combat modifiers: {}",
+                attacker_strength.roll_log.join(", ")
+            ));
         }
-        if !fortress_log.is_empty() {
+        if !defender_strength.roll_log.is_empty() {
             game.add_info_log_item(format!(
-                " {defender_name} has a fortress, which {}",
-                fortress_log.join(", ")
+                ". {defender_name} used the following combat modifiers: {}",
+                defender_strength.roll_log.join(", ")
             ));
         }
         if attacker_hits < active_defenders.len() as u8 && attacker_hits > 0 {