added playerid to avoid stringly typing

11 files changed, 60 insertions, 45 deletions

diff --git a/src/components.rs b/src/components.rs
index 1f5630d..126f20e 100644
--- a/src/components.rs
+++ b/src/components.rs
@@ -7,8 +7,8 @@ use specs::{
 	Component
 };
 
-use super::controls::Control;
-use super::pos::Pos;
+use crate::{Pos, PlayerId};
+use crate::controls::Control;
 use crate::template::Template;
 
 
@@ -58,11 +58,11 @@ pub struct Moved {
 #[derive(Component, Debug, Clone)]
 #[storage(HashMapStorage)]
 pub struct Player {
-	pub name: String
+	pub id: PlayerId
 }
 impl Player {
-	pub fn new(name: String) -> Self {
-		Self{name}
+	pub fn new(id: PlayerId) -> Self {
+		Self{id}
 	}
 }
 
diff --git a/src/componentwrapper.rs b/src/componentwrapper.rs
index 6e11a0b..951745d 100644
--- a/src/componentwrapper.rs
+++ b/src/componentwrapper.rs
@@ -2,6 +2,7 @@
 use std::collections::HashMap;
 use specs::{Builder, world::LazyBuilder};
 
+use crate::PlayerId;
 use crate::components::{Visible, Blocking, Player, Floor, Item, Inventory, Health, Serialise};
 use crate::parameter::{Parameter, ParameterType};
 
@@ -91,7 +92,7 @@ components!(
 	};
 	Blocking () {Blocking};
 	Floor () {Floor};
-	Player (name: String) {Player::new(name)};
+	Player (name: String) {Player::new(PlayerId{name})};
 	Item (ent: Template, name: String) {Item{ent, name}};
 	Inventory (capacity: Int) {Inventory{items: Vec::new(), capacity: capacity as usize}};
 	Health (health: Int, maxhealth: Int) {Health{health, maxhealth}};
diff --git a/src/controls.rs b/src/controls.rs
index d9432a5..a27348d 100644
--- a/src/controls.rs
+++ b/src/controls.rs
@@ -1,7 +1,7 @@
 
 
 use serde_json::Value;
-use super::pos::Pos;
+use crate::{PlayerId, Pos};
 
 #[derive(Debug, Clone)]
 pub enum Direction {
@@ -68,8 +68,8 @@ impl Control {
 
 #[derive(Debug, Clone)]
 pub enum Action {
-	Join(String),
-	Leave(String),
-	Input(String, Control)
+	Join(PlayerId),
+	Leave(PlayerId),
+	Input(PlayerId, Control)
 }
 
diff --git a/src/gameserver.rs b/src/gameserver.rs
index d7b2ccd..23efc7b 100644
--- a/src/gameserver.rs
+++ b/src/gameserver.rs
@@ -7,6 +7,7 @@ use serde_json::{Value, json};
 
 use super::controls::{Control, Action};
 use super::server::Server;
+use crate::PlayerId;
 
 
 #[derive(Debug)]
@@ -19,8 +20,8 @@ enum Message {
 
 
 pub struct GameServer {
-	players: HashMap<(usize, usize), String>,
-	connections: HashMap<String, (usize, usize)>,
+	players: HashMap<(usize, usize), PlayerId>,
+	connections: HashMap<PlayerId, (usize, usize)>,
 	servers: Vec<Box<dyn Server>>
 }
 
@@ -52,10 +53,10 @@ impl GameServer {
 				}
 			}
 			for id in left {
-				if let Some(name) = self.players.remove(&(serverid, id)){
-					self.connections.remove(&name);
-					self.broadcast_message(&format!("{} disconnected", name));
-					actions.push(Action::Leave(name.clone()));
+				if let Some(player) = self.players.remove(&(serverid, id)){
+					self.connections.remove(&player);
+					self.broadcast_message(&format!("{} disconnected", player.name));
+					actions.push(Action::Leave(player.clone()));
 				}
 			}
 		}
@@ -81,8 +82,8 @@ impl GameServer {
 		}
 	}
 	
-	pub fn send(&mut self, playername: &str, value: Value) -> Result<(), io::Error> {
-		match self.connections.get(playername) {
+	pub fn send(&mut self, player: &PlayerId, value: Value) -> Result<(), io::Error> {
+		match self.connections.get(player) {
 			Some((serverid, id)) => {
 				self.servers[*serverid].send(*id, value.to_string().as_str())
 			}
@@ -113,18 +114,19 @@ impl GameServer {
 					let _ = self.send_error(id, "invalidaction", &format!("You can not change your name"));
 					return None;
 				}
-				if self.connections.contains_key(&name) {
+				let player = PlayerId{name};
+				if self.connections.contains_key(&player) {
 					let _ = self.send_error(id, "nametaken", &format!("Another connections to this player exists already"));
 					return None;
 				}
-				self.broadcast_message(&format!("{} connected", name));
-				self.players.insert(id, name.clone());
-				self.connections.insert(name.clone(), id);
-				Some(Action::Join(name))
+				self.broadcast_message(&format!("{} connected", player.name));
+				self.players.insert(id, player.clone());
+				self.connections.insert(player.clone(), id);
+				Some(Action::Join(player))
 			}
 			Message::Chat(text) => {
-				if let Some(nameref) = self.players.get(&id) {
-					let name = nameref.clone();
+				if let Some(player) = self.players.get(&id) {
+					let name = player.name.clone();
 					self.broadcast_message(&format!("{}: {}", name, text));
 				} else {
 					let _ = self.send_error(id, "invalidaction", &format!("Set a name before you send other messages"));
@@ -132,10 +134,9 @@ impl GameServer {
 				None
 			}
 			Message::Input(inp) => {
-				if let Some(nameref) = self.players.get(&id) {
-					let name = nameref.clone();
+				if let Some(player) = self.players.get(&id) {
 					if let Some(control) = Control::from_json(&inp) {
-						Some(Action::Input(name, control))
+						Some(Action::Input(player.clone(), control))
 					} else {
 						let _ = self.send_error(id, "invalidaction", &format!("unknown action: {}", inp));
 						None
diff --git a/src/main.rs b/src/main.rs
index 483198a..92912c2 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -25,8 +25,12 @@ mod template;
 mod roomtemplate;
 mod savestate;
 mod defaultencyclopedia;
+mod playerstate;
+mod playerid;
 
 pub use self::pos::Pos;
+pub use self::playerid::PlayerId;
+
 use self::gameserver::GameServer;
 use self::server::unixserver::UnixServer;
 use self::server::tcpserver::TcpServer;
diff --git a/src/playerid.rs b/src/playerid.rs
new file mode 100644
index 0000000..8402a1c
--- /dev/null
+++ b/src/playerid.rs
@@ -0,0 +1,6 @@
+
+#[derive(Debug, PartialEq, Eq, Clone, Hash)]
+pub struct PlayerId {
+	pub name: String
+}
+
diff --git a/src/resources.rs b/src/resources.rs
index 15d93c4..0e40a00 100644
--- a/src/resources.rs
+++ b/src/resources.rs
@@ -4,10 +4,10 @@ use specs::Entity;
 
 use super::pos::Pos;
 use super::controls::Action;
-// use super::oldassemblage::Assemblage;
 use super::worldmessages::WorldMessage;
 use super::template::Template;
 use crate::encyclopedia::Encyclopedia;
+use crate::PlayerId;
 
 
 #[derive(Default)]
@@ -17,7 +17,7 @@ pub struct Input {
 
 #[derive(Default)]
 pub struct Output {
-	pub output: HashMap<String, WorldMessage>
+	pub output: HashMap<PlayerId, WorldMessage>
 }
 
 #[derive(Default)]
diff --git a/src/room.rs b/src/room.rs
index dbcfe0d..501b587 100644
--- a/src/room.rs
+++ b/src/room.rs
@@ -10,7 +10,6 @@ use specs::{
 };
 
 use super::controls::Action;
-use super::pos::Pos;
 use super::worldmessages::WorldMessage;
 use super::resources::{
 	Size,
@@ -32,6 +31,7 @@ use crate::components::{Position, Serialise};
 use crate::encyclopedia::Encyclopedia;
 use crate::roomtemplate::RoomTemplate;
 use crate::savestate::SaveState;
+use crate::{Pos, PlayerId};
 
 
 
@@ -82,14 +82,12 @@ impl <'a, 'b>Room<'a, 'b> {
 			let y = (idx as i64) / width;
 			
 			for template in templates {
-				let mut obj = template.clone();
-				obj.save = false;
-				self.world.fetch_mut::<NewEntities>().templates.push((Pos{x, y}, obj));
+				self.world.fetch_mut::<NewEntities>().templates.push((Pos{x, y}, template.clone().unsaved()));
 			}
 		}
 	}
 	
-	pub fn view(&self) -> HashMap<String, WorldMessage> {
+	pub fn view(&self) -> HashMap<PlayerId, WorldMessage> {
 		self.world.fetch::<Output>().output.clone()
 	}
 	
diff --git a/src/systems/controlinput.rs b/src/systems/controlinput.rs
index 608de06..e9b1103 100644
--- a/src/systems/controlinput.rs
+++ b/src/systems/controlinput.rs
@@ -11,10 +11,10 @@ use specs::{
 	Join
 };
 
+use crate::{PlayerId, hashmap};
 use crate::components::{Controller, Player, Removed};
 use crate::controls::{Control, Action};
 use crate::resources::{Input, NewEntities, Spawn};
-use crate::hashmap;
 use crate::template::Template;
 use crate::parameter::Parameter;
 
@@ -41,25 +41,25 @@ impl <'a> System<'a> for ControlInput {
 			}
 		}
 	
-		let mut playercontrols: HashMap<&str, Control> = HashMap::new();
+		let mut playercontrols: HashMap<&PlayerId, Control> = HashMap::new();
 		let mut leaving = HashSet::new();
 		for action in &input.actions {
 			match action {
-				Action::Join(name) => {
+				Action::Join(player) => {
 					new.templates.push((
 						spawn.pos,
-						Template::new("player", hashmap!("name".to_string() => Parameter::String(name.to_string())))
+						Template::new("player", hashmap!("name".to_string() => Parameter::String(player.name.clone()))).unsaved()
 					));
 				}
-				Action::Leave(name) => {leaving.insert(name);}
-				Action::Input(name, control) => {playercontrols.insert(name, control.clone());}
+				Action::Leave(player) => {leaving.insert(player);}
+				Action::Input(player, control) => {playercontrols.insert(player, control.clone());}
 			}
 		}
 		for (player, entity) in (&players, &entities).join() {
-			if let Some(control) = playercontrols.get(player.name.as_str()){
+			if let Some(control) = playercontrols.get(&player.id){
 				let _ = controllers.insert(entity, Controller(control.clone()));
 			}
-			if leaving.contains(&player.name) {
+			if leaving.contains(&player.id) {
 				let _ = removed.insert(entity, Removed);
 			}
 		}
diff --git a/src/systems/view.rs b/src/systems/view.rs
index 2bc971e..c452b2f 100644
--- a/src/systems/view.rs
+++ b/src/systems/view.rs
@@ -11,7 +11,7 @@ use specs::{
 	Entity
 };
 
-use crate::pos::Pos;
+use crate::Pos;
 use crate::components::{Visible, Player, Position, Inventory, New, Moved, Removed, Health};
 use crate::resources::{Size, Output, Ground};
 use crate::worldmessages::{WorldMessage, WorldUpdate, FieldMessage};
@@ -82,7 +82,7 @@ impl <'a> System<'a> for View {
 			}
 			updates.push(WorldUpdate::Pos(pos.pos));
 			let message = WorldMessage{updates};
-			output.output.insert(player.name.clone(), message);
+			output.output.insert(player.id.clone(), message);
 		}
 	}
 }
diff --git a/src/template.rs b/src/template.rs
index 5347e51..9072032 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -24,6 +24,11 @@ impl Template {
 		}
 	}
 	
+	pub fn unsaved(mut self) -> Self {
+		self.save = false;
+		self
+	}
+	
 	pub fn empty(name: &str) -> Self {
 		Self::new(name, HashMap::new())
 	}