From e69d9c3b5266fd6f9215d1e3f4a761b8027a785c Mon Sep 17 00:00:00 2001
From: troido <troido@protonmail.com>
Date: Fri, 21 Feb 2020 16:27:32 +0100
Subject: wrote world code for migrating players

---
 src/main.rs      |  4 ++--
 src/resources.rs | 25 +++++++++++++++++--------
 src/room.rs      | 14 +++++++++++---
 src/world.rs     | 33 +++++++++++++++++++++++++++------
 4 files changed, 57 insertions(+), 19 deletions(-)

(limited to 'src')

diff --git a/src/main.rs b/src/main.rs
index c8816bf..310fd0e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -80,10 +80,10 @@ fn main() {
 					let _ = world.control_player(player, control);
 				}
 				Action::Join(player) => {
-					world.add_player(player).unwrap();
+					world.add_player(&player).unwrap();
 				}
 				Action::Leave(player) => {
-					world.remove_player(player).unwrap();
+					world.remove_player(&player).unwrap();
 				}
 			}
 		}
diff --git a/src/resources.rs b/src/resources.rs
index f50d2bb..e0ac197 100644
--- a/src/resources.rs
+++ b/src/resources.rs
@@ -2,14 +2,17 @@
 use std::collections::{HashMap, HashSet};
 use specs::Entity;
 
-use super::pos::Pos;
-use super::controls::Control;
-use super::worldmessages::WorldMessage;
-use crate::componentwrapper::PreEntity;
-use crate::encyclopedia::Encyclopedia;
-use crate::PlayerId;
-use crate::util::Result;
-use crate::template::Template;
+use crate::{
+	pos::Pos,
+	controls::Control,
+	worldmessages::WorldMessage,
+	componentwrapper::PreEntity,
+	encyclopedia::Encyclopedia,
+	PlayerId,
+	RoomId,
+	util::Result,
+	template::Template
+};
 
 
 #[derive(Default)]
@@ -61,3 +64,9 @@ impl NewEntities {
 pub struct Players {
 	pub entities: HashMap<PlayerId, Entity>
 }
+
+#[derive(Default)]
+pub struct Emigrating {
+	pub emigrants: Vec<(PlayerId, RoomId)>
+}
+
diff --git a/src/room.rs b/src/room.rs
index c813e0c..44608c8 100644
--- a/src/room.rs
+++ b/src/room.rs
@@ -19,7 +19,8 @@ use super::resources::{
 	Input,
 	NewEntities,
 	Spawn,
-	Players
+	Players,
+	Emigrating
 };
 use super::systems::{
 	moving::Move,
@@ -62,6 +63,7 @@ impl <'a, 'b>Room<'a, 'b> {
 		world.insert(NewEntities::new(encyclopedia));
 		world.insert(Players::default());
 		world.insert(Spawn::default());
+		world.insert(Emigrating::default());
 		world.register::<Serialise>();
 		
 		let mut dispatcher = DispatcherBuilder::new()
@@ -135,8 +137,8 @@ impl <'a, 'b>Room<'a, 'b> {
 		self.world.fetch_mut::<Players>().entities.insert(state.id.clone(), ent);
 	}
 	
-	pub fn remove_player(&mut self, id: PlayerId) -> Result<PlayerState>{
-		let ent = self.world.fetch_mut::<Players>().entities.remove(&id).ok_or(aerr!("failed to remove player"))?;
+	pub fn remove_player(&mut self, id: &PlayerId) -> Result<PlayerState>{
+		let ent = self.world.fetch_mut::<Players>().entities.remove(id).ok_or(aerr!("failed to remove player"))?;
 		self.world.write_component::<Removed>().insert(ent, Removed)?;
 		self.save_player_ent(ent).ok_or(aerr!("failed to find player to remove"))
 	}
@@ -198,6 +200,12 @@ impl <'a, 'b>Room<'a, 'b> {
 		self.world.fetch_mut::<NewEntities>().create(pos, template)?;
 		Ok(())
 	}
+	
+	pub fn emigrate(&mut self) -> Vec<(PlayerId, RoomId)> {
+		let emigrants = self.world.remove::<Emigrating>().expect("World does not have Emigrating resource").emigrants;
+		self.world.insert(Emigrating::default());
+		emigrants
+	}
 }
 
 
diff --git a/src/world.rs b/src/world.rs
index 891e22b..62d80be 100644
--- a/src/world.rs
+++ b/src/world.rs
@@ -50,31 +50,52 @@ impl <'a, 'b>World<'a, 'b> {
 		self.rooms.get_mut(id)
 	}
 	
-	pub fn add_player(&mut self, playerid: PlayerId) -> Result<()> {
-		let state = self.persistence.load_player(playerid.clone()).unwrap_or(PlayerState::new(playerid.clone()));
+	fn add_loaded_player(&mut self, state: PlayerState) -> Result<()> {
 		let roomid = state.clone().room.unwrap_or(self.default_room.clone());
 		let room = self.get_room_mut(&roomid).ok_or(aerr!("room not found"))?;
 		room.add_player(&state);
-		self.players.insert(playerid, roomid);
+		self.players.insert(state.id.clone(), roomid);
 		Ok(())
 	}
 	
-	pub fn remove_player(&mut self, playerid: PlayerId) -> Result<()> {
-		let roomid = self.players.remove(&playerid).ok_or(aerr!("player not found"))?;
+	pub fn add_player(&mut self, playerid: &PlayerId) -> Result<()> {
+		let state = self.persistence.load_player(playerid.clone()).unwrap_or(PlayerState::new(playerid.clone()));
+		self.add_loaded_player(state)
+	}
+	
+	fn discorporate_player(&mut self, playerid: &PlayerId) -> Result<PlayerState> {
+		let roomid = self.players.remove(playerid).ok_or(aerr!("player not found"))?;
 		let room = self.get_room_mut(&roomid).ok_or(aerr!("room not found"))?;
-		let player_state = room.remove_player(playerid.clone())?;
+		room.remove_player(playerid)
+	}
+	
+	pub fn remove_player(&mut self, playerid: &PlayerId) -> Result<()> {
+		let player_state = self.discorporate_player(playerid)?;
 		self.persistence.save_player(playerid.clone(), player_state)?;
 		Ok(())
 	}
 	
+	
 	pub fn control_player(&mut self, player: PlayerId, control: Control) -> Result<()>{
 		let roomid = self.players.get(&player).ok_or(aerr!("player not found"))?.clone();
 		Ok(self.get_room_mut(&roomid).ok_or(aerr!("room not found"))?.control_player(player, control))
 	}
 	
+	fn migrate_player(&mut self, player: &PlayerId, destination: RoomId) -> Result<()> {
+		let mut state = self.discorporate_player(player)?;
+		state.room = Some(destination);
+		self.add_loaded_player(state)
+	}
+		
+	
 	pub fn update(&mut self) {
+		let mut migrants = Vec::new();
 		for room in self.rooms.values_mut() {
 			room.update();
+			migrants.append(&mut room.emigrate());
+		}
+		for (player, destination) in migrants {
+			self.migrate_player(&player, destination).unwrap();
 		}
 	}
 	
-- 
cgit