taurus 0.1.1

A WIP roguelike game being developed in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

//! Game tiles.

use crate::actor::Actor;
use crate::console::Color;
use crate::database::Database;
use crate::error::GameError;
use crate::game_data::GameData;
use crate::item::ItemStash;
use crate::material::MaterialInfo;
use crate::object::Object;
use crate::ui::Draw;
use crate::{GameResult, GAMEDATA};
use std::cell::{Cell, RefCell};
use std::str::FromStr;
use std::sync::Arc;

/// Struct containing the tile information for a class of tiles.
#[derive(Debug)]
pub struct TileInfo {
    pub material: Arc<MaterialInfo>,

    pub name: String,
    pub c: char,

    /// Can the tile be walked on?
    pub passable: bool,
    /// Is the tile see-through?
    pub transparent: bool,

    pub staircase: Staircase,
}

impl TileInfo {
    pub fn new(game_data: &GameData, tile_data: &Database) -> GameResult<TileInfo> {
        let _material = tile_data.get_obj("material")?;
        let mname = _material.get_str("name")?;
        let id = _material.id();
        let material = game_data.material_info(id);

        let name = tile_data.get_str("name")?;
        let c = tile_data.get_char("c")?;

        let passable = tile_data.get_bool("passable")?;
        let transparent = tile_data.get_bool("transparent")?;

        let staircase = Staircase::from_str(&tile_data.get_str("staircase")?)?;

        // Create the `TileInfo`.
        let tile_info = TileInfo {
            material,

            name,
            c,

            passable,
            transparent,

            staircase,
        };

        Ok(tile_info)
    }

    pub fn full_name(&self) -> String {
        format!("{} {}", self.material.adjective, self.name)
    }
}

impl Draw for TileInfo {
    fn draw_c(&self) -> char {
        self.c
    }
    fn draw_color(&self) -> Color {
        self.material.color
    }
}

/// Tile object.
///
/// Tiles are represented differently from objects and actors. Because tiles are so common, we try
/// to save space by only storing a reference to a unique `TileInfo` object. Any two tiles of the
/// same type will store a reference to the same `TileInfo`. This has a slight negative impact on
/// performance but saves a considerable amount of memory.
#[derive(Clone, Debug)]
pub struct Tile {
    /// A reference to the `TileInfo`.
    pub info: Arc<TileInfo>,
    /// Last seen tile here. This also tells us whether this tile has been seen before.
    pub last_seen: Cell<Option<(char, Color)>>,

    /// Elevation of this tile in the heightmap. 0 is ground level, < 0 is below ground.
    pub height: i32,

    // Not serialized:
    pub actor: Option<Actor>,
    pub object: Option<Object>,
    pub item_stash: Option<Box<ItemStash>>,
}

impl Tile {
    /// Returns a new `Tile` object.
    pub fn new(tile_data: &Database) -> GameResult<Tile> {
        let id = tile_data.id();
        let info = GAMEDATA.read().unwrap().tile_info(id);

        Ok(Tile {
            info,
            last_seen: Cell::new(None),

            height: 0,

            actor: None,
            object: None,
            item_stash: None,
        })
    }

    pub fn set_tile_info(&mut self, tile_data: &Database) -> GameResult<()> {
        let id = tile_data.id();

        self.info = GAMEDATA.read().unwrap().tile_info(id);

        Ok(())
    }
}

impl Tile {
    pub fn passable(&self) -> bool {
        self.info.passable
    }

    pub fn transparent(&self) -> bool {
        self.info.transparent
    }

    pub fn staircase(&self) -> Staircase {
        self.info.staircase
    }
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Staircase {
    Up,
    Down,
    UpDown,
    None,
}

impl FromStr for Staircase {
    type Err = GameError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(match s {
            "up" => Staircase::Up,
            "down" => Staircase::Down,
            "updown" => Staircase::UpDown,
            "none" => Staircase::None,
            _ => {
                return Err(GameError::ConversionError {
                    val: s.into(),
                    msg: "Invalid staircase value",
                });
            }
        })
    }
}