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
|
use std::fmt::{Debug, Formatter, Error};
use std::collections::HashMap;
trait HasInventory {
fn getInventory<'s>(&'s self) -> &'s mut Inventory;
fn addToInventory(&self, item: &Item);
fn removeFromInventory(&self, itemName: &str) -> bool;
}
trait TraversesWorld {
fn attemptTraverse(&self, room: &Room, directionStr: &str) -> Result<&Room, &str> {
let direction = str_to_direction(directionStr);
let maybe_room = room.direction_to_room.get(&direction);
match maybe_room {
Some(entry) => Ok(entry), //~ ERROR: lifetime may not live long enough
_ => Err("Direction does not exist in room.")
}
}
}
#[derive(Debug, Eq, PartialEq, Hash)]
enum RoomDirection {
West,
East,
North,
South,
Up,
Down,
In,
Out,
None
}
struct Room {
description: String,
items: Vec<Item>,
direction_to_room: HashMap<RoomDirection, Room>,
}
impl Room {
fn new(description: &'static str) -> Room {
Room {
description: description.to_string(),
items: Vec::new(),
direction_to_room: HashMap::new()
}
}
fn add_direction(&mut self, direction: RoomDirection, room: Room) {
self.direction_to_room.insert(direction, room);
}
}
struct Item {
name: String,
}
struct Inventory {
items: Vec<Item>,
}
impl Inventory {
fn new() -> Inventory {
Inventory {
items: Vec::new()
}
}
}
struct Player {
name: String,
inventory: Inventory,
}
impl Player {
fn new(name: &'static str) -> Player {
Player {
name: name.to_string(),
inventory: Inventory::new()
}
}
}
impl TraversesWorld for Player {
}
impl Debug for Player {
fn fmt(&self, formatter: &mut Formatter) -> Result<(), Error> {
formatter.write_str("Player{ name:");
formatter.write_str(&self.name);
formatter.write_str(" }");
Ok(())
}
}
fn str_to_direction(to_parse: &str) -> RoomDirection {
match to_parse {
"w" | "west" => RoomDirection::West,
"e" | "east" => RoomDirection::East,
"n" | "north" => RoomDirection::North,
"s" | "south" => RoomDirection::South,
"in" => RoomDirection::In,
"out" => RoomDirection::Out,
"up" => RoomDirection::Up,
"down" => RoomDirection::Down,
_ => None
}
//~^^ ERROR `match` arms have incompatible types
}
fn main() {
let mut player = Player::new("Test player");
let mut room = Room::new("A test room");
println!("Made a player: {:?}", player);
println!("Direction parse: {:?}", str_to_direction("east"));
match player.attemptTraverse(&room, "west") {
Ok(_) => println!("Was able to move west"),
Err(msg) => println!("Not able to move west: {}", msg)
};
}
|
