253 lines
7.5 KiB
Rust
253 lines
7.5 KiB
Rust
//! Entities, zones, order of play, stats and the event log: the game's state.
|
|
//! The rules for resolving actions live in `queue.rs`.
|
|
|
|
use super::card::{CardDef, CardLibrary};
|
|
use super::event::Event;
|
|
|
|
/// A handle to an entity. Ids are never reused and stay valid when the entity changes zone.
|
|
pub type EntityId = u32;
|
|
pub type PlayerId = u8;
|
|
|
|
/// Starting Health of each hero.
|
|
pub const HERO_HEALTH: i32 = 30;
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum Zone {
|
|
Deck,
|
|
Hand,
|
|
Board,
|
|
Graveyard,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct Entity {
|
|
card: String,
|
|
owner: PlayerId,
|
|
zone: Zone,
|
|
/// Stamped each time the entity enters the board; `None` until it first does.
|
|
order_of_play: Option<u32>,
|
|
attack: i32,
|
|
/// Current Health. It can drop to 0 or below: Module 2 has no death step.
|
|
health: i32,
|
|
}
|
|
|
|
/// One player's zones. Each is an ordered list of ids (the board is left to right).
|
|
#[derive(Debug, Default)]
|
|
struct Side {
|
|
deck: Vec<EntityId>,
|
|
hand: Vec<EntityId>,
|
|
board: Vec<EntityId>,
|
|
graveyard: Vec<EntityId>,
|
|
hero: EntityId,
|
|
armor: i32,
|
|
}
|
|
|
|
impl Side {
|
|
fn zone(&self, zone: Zone) -> &Vec<EntityId> {
|
|
match zone {
|
|
Zone::Deck => &self.deck,
|
|
Zone::Hand => &self.hand,
|
|
Zone::Board => &self.board,
|
|
Zone::Graveyard => &self.graveyard,
|
|
}
|
|
}
|
|
|
|
fn zone_mut(&mut self, zone: Zone) -> &mut Vec<EntityId> {
|
|
match zone {
|
|
Zone::Deck => &mut self.deck,
|
|
Zone::Hand => &mut self.hand,
|
|
Zone::Board => &mut self.board,
|
|
Zone::Graveyard => &mut self.graveyard,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct World {
|
|
library: CardLibrary,
|
|
/// Indexed by `EntityId`.
|
|
entities: Vec<Entity>,
|
|
sides: [Side; 2],
|
|
next_order_of_play: u32,
|
|
log: Vec<Event>,
|
|
}
|
|
|
|
impl World {
|
|
/// A new game: both heroes are in play from the start, so they are the oldest entities.
|
|
pub fn new(library: CardLibrary) -> World {
|
|
let mut world = World {
|
|
library,
|
|
entities: Vec::new(),
|
|
sides: Default::default(),
|
|
next_order_of_play: 0,
|
|
log: Vec::new(),
|
|
};
|
|
for owner in 0..2 {
|
|
let id = world.entities.len() as EntityId;
|
|
world.next_order_of_play += 1;
|
|
world.entities.push(Entity {
|
|
card: "Hero".to_string(),
|
|
owner,
|
|
zone: Zone::Board,
|
|
order_of_play: Some(world.next_order_of_play),
|
|
attack: 0,
|
|
health: HERO_HEALTH,
|
|
});
|
|
// In play, but not on the board list: the board holds minions only.
|
|
world.sides[owner as usize].hero = id;
|
|
}
|
|
world
|
|
}
|
|
|
|
/// Create an entity of `card` for `owner` at the end of `zone` (the right end for the board).
|
|
pub fn create(&mut self, card: &str, owner: PlayerId, zone: Zone) -> EntityId {
|
|
assert!(owner < 2, "no player {owner}");
|
|
let def = self.library.get(card);
|
|
let entity = Entity {
|
|
card: def.name.clone(),
|
|
owner,
|
|
zone,
|
|
order_of_play: None,
|
|
attack: def.attack,
|
|
health: def.health,
|
|
};
|
|
let id = self.entities.len() as EntityId;
|
|
self.entities.push(entity);
|
|
self.enter(id, zone);
|
|
id
|
|
}
|
|
|
|
/// Move an entity to the end of `zone` on its owner's side, keeping its id.
|
|
pub fn move_to(&mut self, id: EntityId, zone: Zone) {
|
|
let (owner, from) = (self.entity(id).owner, self.entity(id).zone);
|
|
self.sides[owner as usize]
|
|
.zone_mut(from)
|
|
.retain(|&e| e != id);
|
|
self.enter(id, zone);
|
|
}
|
|
|
|
/// The single place an entity arrives in a zone. Entering the board starts a new order of play.
|
|
fn enter(&mut self, id: EntityId, zone: Zone) {
|
|
let owner = self.entity(id).owner;
|
|
self.sides[owner as usize].zone_mut(zone).push(id);
|
|
let entity = &mut self.entities[id as usize];
|
|
entity.zone = zone;
|
|
if zone == Zone::Board {
|
|
self.next_order_of_play += 1;
|
|
entity.order_of_play = Some(self.next_order_of_play);
|
|
self.record(Event::Summoned { id });
|
|
}
|
|
}
|
|
|
|
fn entity(&self, id: EntityId) -> &Entity {
|
|
self.entities
|
|
.get(id as usize)
|
|
.unwrap_or_else(|| panic!("unknown entity id {id}"))
|
|
}
|
|
|
|
fn entity_mut(&mut self, id: EntityId) -> &mut Entity {
|
|
self.entities
|
|
.get_mut(id as usize)
|
|
.unwrap_or_else(|| panic!("unknown entity id {id}"))
|
|
}
|
|
|
|
// ---- Queries -------------------------------------------------------
|
|
|
|
pub fn card(&self, name: &str) -> &CardDef {
|
|
self.library.get(name)
|
|
}
|
|
|
|
pub fn zone_of(&self, id: EntityId) -> Zone {
|
|
self.entity(id).zone
|
|
}
|
|
|
|
pub fn card_name(&self, id: EntityId) -> &str {
|
|
&self.entity(id).card
|
|
}
|
|
|
|
pub fn owner_of(&self, id: EntityId) -> PlayerId {
|
|
self.entity(id).owner
|
|
}
|
|
|
|
/// When the entity last entered the board (larger is later); `None` if it never has.
|
|
pub fn order_of_play(&self, id: EntityId) -> Option<u32> {
|
|
self.entity(id).order_of_play
|
|
}
|
|
|
|
/// The ids in one player's zone, in zone order (left to right for the board).
|
|
pub fn zone(&self, owner: PlayerId, zone: Zone) -> &[EntityId] {
|
|
assert!(owner < 2, "no player {owner}");
|
|
self.sides[owner as usize].zone(zone)
|
|
}
|
|
|
|
pub fn hero(&self, owner: PlayerId) -> EntityId {
|
|
assert!(owner < 2, "no player {owner}");
|
|
self.sides[owner as usize].hero
|
|
}
|
|
|
|
pub fn is_hero(&self, id: EntityId) -> bool {
|
|
self.sides.iter().any(|s| s.hero == id)
|
|
}
|
|
|
|
/// Every minion on either board, oldest first (order of play).
|
|
pub fn minions_in_play(&self) -> Vec<EntityId> {
|
|
let mut ids: Vec<EntityId> = self.sides.iter().flat_map(|s| s.board.clone()).collect();
|
|
ids.sort_by_key(|&id| self.order_of_play(id));
|
|
ids
|
|
}
|
|
|
|
pub fn attack(&self, id: EntityId) -> i32 {
|
|
self.entity(id).attack
|
|
}
|
|
|
|
pub fn health(&self, id: EntityId) -> i32 {
|
|
self.entity(id).health
|
|
}
|
|
|
|
pub fn armor(&self, owner: PlayerId) -> i32 {
|
|
self.sides[owner as usize].armor
|
|
}
|
|
|
|
pub fn log(&self) -> &[Event] {
|
|
&self.log
|
|
}
|
|
|
|
// ---- Changes: each one records its event ----------------------------
|
|
|
|
pub fn record(&mut self, event: Event) {
|
|
self.log.push(event);
|
|
}
|
|
|
|
pub fn clear_log(&mut self) {
|
|
self.log.clear();
|
|
}
|
|
|
|
pub fn damage(&mut self, target: EntityId, amount: i32) {
|
|
self.entity_mut(target).health -= amount;
|
|
self.record(Event::Damaged { target, amount });
|
|
}
|
|
|
|
/// Draw the top card of `player`'s deck (the first in the list). An empty deck
|
|
/// records `Fatigue` and changes nothing else.
|
|
pub fn draw(&mut self, player: PlayerId) {
|
|
match self.zone(player, Zone::Deck).first() {
|
|
Some(&id) => {
|
|
self.move_to(id, Zone::Hand);
|
|
self.record(Event::Drew { player, id });
|
|
}
|
|
None => self.record(Event::Fatigue { player }),
|
|
}
|
|
}
|
|
|
|
pub fn gain_armor(&mut self, player: PlayerId, amount: i32) {
|
|
self.sides[player as usize].armor += amount;
|
|
self.record(Event::ArmorGained { player, amount });
|
|
}
|
|
|
|
pub fn gain_attack(&mut self, id: EntityId, amount: i32) {
|
|
let entity = self.entity_mut(id);
|
|
entity.attack += amount;
|
|
let (attack, health) = (entity.attack, entity.health);
|
|
self.record(Event::StatsChanged { id, attack, health });
|
|
}
|
|
}
|