350 lines
7.6 KiB
Rust
350 lines
7.6 KiB
Rust
use std::collections::HashMap;
|
|
|
|
use ::rltk::{Point, RGB};
|
|
use ::serde::{Deserialize, Serialize};
|
|
use ::specs::error::NoError;
|
|
use ::specs::prelude::*;
|
|
use ::specs::saveload::{ConvertSaveload, Marker};
|
|
use ::specs_derive::*;
|
|
|
|
use crate::gamesystem::attr_bonus;
|
|
|
|
#[derive(Component, ConvertSaveload, Default, Copy, Clone)]
|
|
pub struct Position {
|
|
pub x: i32,
|
|
pub y: i32,
|
|
}
|
|
|
|
impl From<(i32, i32)> for Position {
|
|
fn from(f: (i32, i32)) -> Self {
|
|
Position { x: f.0, y: f.1 }
|
|
}
|
|
}
|
|
|
|
impl From<Point> for Position {
|
|
fn from(p: Point) -> Self {
|
|
Position { x: p.x, y: p.y }
|
|
}
|
|
}
|
|
|
|
impl From<Position> for Point {
|
|
fn from(p: Position) -> Self {
|
|
Point { x: p.x, y: p.y }
|
|
}
|
|
}
|
|
|
|
#[derive(Component, ConvertSaveload, Clone)]
|
|
pub struct Renderable {
|
|
pub glyph: rltk::FontCharType,
|
|
pub fg: RGB,
|
|
pub bg: RGB,
|
|
pub render_order: i32,
|
|
}
|
|
|
|
#[derive(Component, Debug, Clone, Serialize, Deserialize, Default)]
|
|
pub struct Player {}
|
|
|
|
#[derive(Component, ConvertSaveload, Clone)]
|
|
pub struct Viewshed {
|
|
pub visible_tiles: Vec<Point>,
|
|
pub range: i32,
|
|
pub dirty: bool,
|
|
}
|
|
|
|
impl Default for Viewshed {
|
|
fn default() -> Self {
|
|
Viewshed {
|
|
visible_tiles: Vec::new(),
|
|
range: 8,
|
|
dirty: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Component, Debug, Serialize, Deserialize, Clone, Default)]
|
|
pub struct Monster {}
|
|
|
|
#[derive(Component, Debug, ConvertSaveload, Clone)]
|
|
pub struct Name {
|
|
pub name: String,
|
|
}
|
|
|
|
impl Name {
|
|
pub fn from<S: ToString>(s: S) -> Self {
|
|
Name {
|
|
name: s.to_string(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Component, Debug, Serialize, Deserialize, Clone, Default)]
|
|
pub struct BlocksTile {}
|
|
|
|
#[derive(Component, Debug, ConvertSaveload, Clone)]
|
|
pub struct WantsToMelee {
|
|
pub target: Entity,
|
|
}
|
|
|
|
#[derive(Component, Debug, ConvertSaveload, Clone)]
|
|
pub struct SufferDamage {
|
|
pub amount: Vec<i32>,
|
|
}
|
|
|
|
impl SufferDamage {
|
|
pub fn new_damage(store: &mut WriteStorage<SufferDamage>, victim: Entity, amount: i32) {
|
|
if let Some(suffering) = store.get_mut(victim) {
|
|
suffering.amount.push(amount);
|
|
} else {
|
|
let dmg = SufferDamage {
|
|
amount: vec![amount],
|
|
};
|
|
store.insert(victim, dmg).expect("Unable to insert damage");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Component, Debug, Serialize, Deserialize, Clone, Default)]
|
|
pub struct Item {}
|
|
|
|
#[derive(Component, Debug, Serialize, Deserialize, Clone, Default)]
|
|
pub struct Consumable {}
|
|
|
|
#[derive(Component, Debug, ConvertSaveload, Clone)]
|
|
pub struct Ranged {
|
|
pub range: i32,
|
|
}
|
|
|
|
#[derive(Component, Debug, ConvertSaveload, Clone)]
|
|
pub struct InflictsDamage {
|
|
pub damage: i32,
|
|
}
|
|
|
|
#[derive(Component, Debug, ConvertSaveload, Clone)]
|
|
pub struct AreaOfEffect {
|
|
pub radius: i32,
|
|
}
|
|
|
|
#[derive(Component, Debug, ConvertSaveload, Clone)]
|
|
pub struct Confusion {
|
|
pub turns: i32,
|
|
}
|
|
|
|
#[derive(Component, Debug, ConvertSaveload, Clone)]
|
|
pub struct ProvidesHealing {
|
|
pub heal_amount: i32,
|
|
}
|
|
|
|
#[derive(Component, Debug, ConvertSaveload)]
|
|
pub struct InBackpack {
|
|
pub owner: Entity,
|
|
}
|
|
|
|
#[derive(Component, Debug, ConvertSaveload)]
|
|
pub struct WantsToPickupItem {
|
|
pub collected_by: Entity,
|
|
pub item: Entity,
|
|
}
|
|
|
|
#[derive(Component, Debug, ConvertSaveload)]
|
|
pub struct WantsToUseItem {
|
|
pub item: Entity,
|
|
pub target: Option<Point>,
|
|
}
|
|
|
|
#[derive(Component, Debug, ConvertSaveload)]
|
|
pub struct WantsToDropItem {
|
|
pub item: Entity,
|
|
}
|
|
|
|
#[derive(Component, Debug, ConvertSaveload, Clone)]
|
|
pub struct WantsToRemoveItem {
|
|
pub item: Entity,
|
|
}
|
|
|
|
#[derive(PartialEq, Copy, Clone, Serialize, Deserialize)]
|
|
pub enum EquipmentSlot {
|
|
Melee,
|
|
Shield,
|
|
Head,
|
|
Torso,
|
|
Legs,
|
|
Feet,
|
|
Hands,
|
|
}
|
|
|
|
#[derive(Component, Serialize, Deserialize, Clone)]
|
|
pub struct Equippable {
|
|
pub slot: EquipmentSlot,
|
|
}
|
|
|
|
#[derive(Component, ConvertSaveload, Clone)]
|
|
pub struct Equipped {
|
|
pub owner: Entity,
|
|
pub slot: EquipmentSlot,
|
|
}
|
|
|
|
#[derive(PartialEq, Copy, Clone, Serialize, Deserialize)]
|
|
pub enum WeaponAttribute {
|
|
Might,
|
|
Quickness,
|
|
}
|
|
|
|
#[derive(Component, ConvertSaveload, Clone)]
|
|
pub struct MeleeWeapon {
|
|
pub attribute: WeaponAttribute,
|
|
pub damage_n_dice: i32,
|
|
pub damage_die_type: i32,
|
|
pub damage_bonus: i32,
|
|
pub hit_bonus: i32,
|
|
}
|
|
|
|
#[derive(Component, ConvertSaveload, Clone)]
|
|
pub struct Wearable {
|
|
pub armor_class: f32,
|
|
pub slot: EquipmentSlot,
|
|
}
|
|
|
|
#[derive(Component, Serialize, Deserialize, Clone)]
|
|
pub struct ParticleLifetime {
|
|
pub lifetime_ms: f32,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Copy, Clone, PartialEq)]
|
|
pub enum HungerState {
|
|
WellFed,
|
|
Normal,
|
|
Hungry,
|
|
Starving,
|
|
}
|
|
|
|
#[derive(Component, Serialize, Deserialize, Clone)]
|
|
pub struct HungerClock {
|
|
pub state: HungerState,
|
|
pub duration: i32,
|
|
}
|
|
|
|
#[derive(Component, Debug, Serialize, Deserialize, Clone)]
|
|
pub struct ProvidesFood {}
|
|
|
|
#[derive(Component, Debug, Serialize, Deserialize, Clone)]
|
|
pub struct MagicMapper {}
|
|
|
|
#[derive(Component, Debug, Serialize, Deserialize, Clone)]
|
|
pub struct Hidden {}
|
|
|
|
#[derive(Component, Debug, Serialize, Deserialize, Clone)]
|
|
pub struct EntryTrigger {}
|
|
|
|
#[derive(Component, Debug, Serialize, Deserialize, Clone)]
|
|
pub struct EntityMoved {}
|
|
|
|
#[derive(Component, Debug, Serialize, Deserialize, Clone)]
|
|
pub struct SingleActivation {}
|
|
|
|
#[derive(Component, Debug, Serialize, Deserialize, Clone)]
|
|
pub struct BlocksVisibility {}
|
|
|
|
#[derive(Component, Debug, Serialize, Deserialize, Clone)]
|
|
pub struct Door {
|
|
pub open: bool,
|
|
}
|
|
|
|
#[derive(Component, Debug, Serialize, Deserialize, Clone)]
|
|
pub struct Bystander {}
|
|
|
|
#[derive(Component, Debug, Serialize, Deserialize, Clone)]
|
|
pub struct Vendor {}
|
|
|
|
#[derive(Component, Debug, Serialize, Deserialize, Clone)]
|
|
pub struct Quips {
|
|
pub available: Vec<String>,
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize, Clone)]
|
|
pub struct Attribute {
|
|
pub base: i32,
|
|
pub modifiers: i32,
|
|
pub bonus: i32,
|
|
}
|
|
|
|
impl Attribute {
|
|
pub fn new(base: i32) -> Self {
|
|
Attribute {
|
|
base,
|
|
modifiers: 0,
|
|
bonus: attr_bonus(base),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Component, Debug, Serialize, Deserialize, Clone)]
|
|
pub struct Attributes {
|
|
pub might: Attribute,
|
|
pub fitness: Attribute,
|
|
pub quickness: Attribute,
|
|
pub intelligence: Attribute,
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize, Clone, Eq, PartialEq, Hash)]
|
|
pub enum Skill {
|
|
Melee,
|
|
Defense,
|
|
Magic,
|
|
}
|
|
|
|
#[derive(Component, Debug, Default, Serialize, Deserialize, Clone)]
|
|
pub struct Skills {
|
|
pub skills: HashMap<Skill, i32>,
|
|
}
|
|
|
|
impl Skills {
|
|
pub fn new(level: i32) -> Self {
|
|
let mut skills = Skills::default();
|
|
skills.skills.insert(Skill::Melee, level);
|
|
skills.skills.insert(Skill::Defense, level);
|
|
skills.skills.insert(Skill::Magic, level);
|
|
|
|
skills
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize, Clone)]
|
|
pub struct Pool {
|
|
pub max: i32,
|
|
pub current: i32,
|
|
}
|
|
|
|
#[derive(Component, Debug, Serialize, Deserialize, Clone)]
|
|
pub struct Pools {
|
|
pub hit_points: Pool,
|
|
pub mana: Pool,
|
|
pub xp: i32,
|
|
pub level: i32,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Clone)]
|
|
pub struct NaturalAttack {
|
|
pub name: String,
|
|
pub damage_n_dice: i32,
|
|
pub damage_die_type: i32,
|
|
pub damage_bonus: i32,
|
|
pub hit_bonus: i32,
|
|
}
|
|
|
|
#[derive(Component, Serialize, Deserialize, Clone)]
|
|
pub struct NaturalAttackDefense {
|
|
pub armor_class: Option<i32>,
|
|
pub attacks: Vec<NaturalAttack>,
|
|
}
|
|
|
|
// Serialization helper code. We need to implement ConvertSaveLoad for each type that contains an
|
|
// Entity.
|
|
|
|
pub struct SerializeMe;
|
|
|
|
// Special component that exists to help serialize the game data
|
|
#[derive(Component, Serialize, Deserialize, Clone)]
|
|
pub struct SerializationHelper {
|
|
pub map: crate::map::Map,
|
|
}
|