Struct Size 

pub struct Size {
    pub width: u32,
    pub height: u32,
}

Size component defining how much space an entity occupies.

This component describes the entity’s spatial footprint, which can affect collision detection, movement constraints, and rendering.

Fields

width: u32

Width in grid units

height: u32

Height in grid units

Implementations

impl Size

pub fn new(width: u32, height: u32) -> Self

Creates a new size component.

pub fn single() -> Self

Creates a square size (1x1).

Examples found in repository

examples/tactical_rpg.rs (line 284)

  pub fn new() -> Self {
  let mut world = World::new();
  let player_team = Team::new(0);
  let enemy_team = Team::hostile(1);
  
  // Spawn player units
  let player_warrior = world.spawn((
    Position::new(HexCoord::<Axial, Pointy>::new(-2, 1)),
    Health::new(120),
    Stats::new(18, 12, 10, 1),
    player_team,
    Movable::new(3),
    Experience::new(1),
    Initiative::new(15),
    Equipment {
      weapon: Some(Weapon {
        name: "Iron Sword".to_string(),
        attack_bonus: 5,
        range: 1,
        damage_type: DamageType::Physical,
      }),
      armor: Some(Armor {
        name: "Chain Mail".to_string(),
        defense_bonus: 3,
        resistances: vec![DamageType::Physical],
      }),
      accessories: Vec::new(),
      inventory_slots: 10,
    },
    Size::single(),
  ));
  
  let player_mage = world.spawn((
    Position::new(HexCoord::<Axial, Pointy>::new(-1, 0)),
    Health::new(80),
    Stats::new(12, 8, 14, 1),
    player_team,
    Movable::new(2),
    Experience::new(1),
    Initiative::new(12),
    Equipment {
      weapon: Some(Weapon {
        name: "Fire Staff".to_string(),
        attack_bonus: 2,
        range: 3,
        damage_type: DamageType::Fire,
      }),
      armor: None,
      accessories: vec![Accessory {
        name: "Mana Crystal".to_string(),
        effect: AccessoryEffect::StatBonus(StatType::Speed, 2),
      }],
      inventory_slots: 8,
    },
    {
      let mut abilities = Abilities::new(50);
      abilities.add_ability(Ability {
        name: "Fireball".to_string(),
        mana_cost: 10,
        range: 4,
        area_of_effect: 1,
        damage: 25,
        damage_type: DamageType::Fire,
        cooldown: 2,
        current_cooldown: 0,
      });
      abilities.add_ability(Ability {
        name: "Heal".to_string(),
        mana_cost: 8,
        range: 2,
        area_of_effect: 0,
        damage: 0, // Actually healing
        damage_type: DamageType::Healing,
        cooldown: 1,
        current_cooldown: 0,
      });
      abilities
    },
    Size::single(),
  ));
  
  // Spawn enemy units
  let enemy_goblin = world.spawn((
    Position::new(HexCoord::<Axial, Pointy>::new(2, -1)),
    Health::new(60),
    Stats::new(12, 6, 12, 1),
    enemy_team,
    Movable::new(4),
    AI::new(1.0),
    Initiative::new(14),
    Equipment {
      weapon: Some(Weapon {
        name: "Rusty Dagger".to_string(),
        attack_bonus: 2,
        range: 1,
        damage_type: DamageType::Physical,
      }),
      armor: None,
      accessories: Vec::new(),
      inventory_slots: 5,
    },
    Size::single(),
  ));
  
  let enemy_orc = world.spawn((
    Position::new(HexCoord::<Axial, Pointy>::new(3, -2)),
    Health::new(100),
    Stats::new(16, 10, 8, 1),
    enemy_team,
    Movable::new(2),
    AI::new(1.5),
    Initiative::new(10),
    Equipment {
      weapon: Some(Weapon {
        name: "War Axe".to_string(),
        attack_bonus: 6,
        range: 1,
        damage_type: DamageType::Physical,
      }),
      armor: Some(Armor {
        name: "Hide Armor".to_string(),
        defense_bonus: 2,
        resistances: Vec::new(),
      }),
      accessories: Vec::new(),
      inventory_slots: 6,
    },
    Size::single(),
  ));
  
  let mut turn_queue = VecDeque::new();
  turn_queue.extend([player_warrior, player_mage, enemy_goblin, enemy_orc]);
  
  Self {
    world,
    turn_queue,
    current_turn: None,
    turn_number: 1,
    player_team,
    enemy_team,
    game_phase: GamePhase::Planning,
  }
  }

pub fn square(size: u32) -> Self

Creates a square size with the specified dimension.

pub fn area(&self) -> u32

Calculates the total area occupied.

Trait Implementations

impl Clone for Size

fn clone(&self) -> Size

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Size

impl Debug for Size

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Size

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Size

impl Hash for Size

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Size

fn eq(&self, other: &Size) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Size

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Size