2019-03-03 22:02:38 +00:00
|
|
|
#![feature(drain_filter)]
|
2019-01-02 17:23:31 +00:00
|
|
|
|
2019-03-03 22:02:38 +00:00
|
|
|
pub mod client;
|
|
|
|
pub mod error;
|
|
|
|
pub mod input;
|
|
|
|
|
|
|
|
// Reexports
|
|
|
|
pub use crate::{
|
|
|
|
error::Error,
|
|
|
|
input::Input,
|
|
|
|
};
|
|
|
|
|
|
|
|
use std::{
|
|
|
|
time::Duration,
|
|
|
|
net::SocketAddr,
|
2019-04-10 23:16:29 +00:00
|
|
|
sync::mpsc,
|
2019-04-10 23:41:37 +00:00
|
|
|
collections::HashSet,
|
2019-03-03 22:02:38 +00:00
|
|
|
};
|
2019-03-04 19:50:26 +00:00
|
|
|
use specs::{
|
|
|
|
Entity as EcsEntity,
|
|
|
|
world::EntityBuilder as EcsEntityBuilder,
|
|
|
|
Builder,
|
|
|
|
join::Join,
|
|
|
|
saveload::MarkedBuilder,
|
|
|
|
};
|
|
|
|
use vek::*;
|
2019-04-10 23:16:29 +00:00
|
|
|
use threadpool::ThreadPool;
|
2019-03-03 22:02:38 +00:00
|
|
|
use common::{
|
2019-03-04 19:50:26 +00:00
|
|
|
comp,
|
2019-03-03 22:02:38 +00:00
|
|
|
state::State,
|
|
|
|
net::PostOffice,
|
|
|
|
msg::{ServerMsg, ClientMsg},
|
2019-04-10 23:16:29 +00:00
|
|
|
terrain::TerrainChunk,
|
2019-03-03 22:02:38 +00:00
|
|
|
};
|
2019-01-15 15:13:11 +00:00
|
|
|
use world::World;
|
2019-03-04 19:50:26 +00:00
|
|
|
use crate::client::{
|
2019-04-10 17:23:27 +00:00
|
|
|
ClientState,
|
2019-03-04 19:50:26 +00:00
|
|
|
Client,
|
|
|
|
Clients,
|
|
|
|
};
|
2019-01-02 17:23:31 +00:00
|
|
|
|
2019-03-03 22:02:38 +00:00
|
|
|
const CLIENT_TIMEOUT: f64 = 5.0; // Seconds
|
2019-01-02 17:23:31 +00:00
|
|
|
|
2019-03-03 22:02:38 +00:00
|
|
|
pub enum Event {
|
|
|
|
ClientConnected {
|
2019-04-10 17:23:27 +00:00
|
|
|
entity: EcsEntity,
|
2019-03-03 22:02:38 +00:00
|
|
|
},
|
|
|
|
ClientDisconnected {
|
2019-04-10 17:23:27 +00:00
|
|
|
entity: EcsEntity,
|
2019-03-03 22:02:38 +00:00
|
|
|
},
|
|
|
|
Chat {
|
2019-04-10 17:23:27 +00:00
|
|
|
entity: EcsEntity,
|
2019-03-03 22:02:38 +00:00
|
|
|
msg: String,
|
|
|
|
},
|
2019-01-02 17:23:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub struct Server {
|
2019-01-02 19:22:01 +00:00
|
|
|
state: State,
|
2019-01-15 15:13:11 +00:00
|
|
|
world: World,
|
2019-01-02 17:23:31 +00:00
|
|
|
|
2019-03-03 22:02:38 +00:00
|
|
|
postoffice: PostOffice<ServerMsg, ClientMsg>,
|
2019-03-04 19:50:26 +00:00
|
|
|
clients: Clients,
|
2019-04-10 23:16:29 +00:00
|
|
|
|
|
|
|
thread_pool: ThreadPool,
|
|
|
|
chunk_tx: mpsc::Sender<(Vec3<i32>, TerrainChunk)>,
|
|
|
|
chunk_rx: mpsc::Receiver<(Vec3<i32>, TerrainChunk)>,
|
2019-04-10 23:41:37 +00:00
|
|
|
pending_chunks: HashSet<Vec3<i32>>,
|
2019-01-02 17:23:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Server {
|
2019-01-12 15:57:19 +00:00
|
|
|
/// Create a new `Server`.
|
2019-03-03 22:02:38 +00:00
|
|
|
#[allow(dead_code)]
|
|
|
|
pub fn new() -> Result<Self, Error> {
|
2019-04-10 23:16:29 +00:00
|
|
|
let (chunk_tx, chunk_rx) = mpsc::channel();
|
|
|
|
|
2019-03-03 22:02:38 +00:00
|
|
|
Ok(Self {
|
2019-03-05 00:00:11 +00:00
|
|
|
state: State::new(),
|
2019-01-15 15:13:11 +00:00
|
|
|
world: World::new(),
|
2019-03-03 22:02:38 +00:00
|
|
|
|
2019-03-05 18:39:18 +00:00
|
|
|
postoffice: PostOffice::bind(SocketAddr::from(([0; 4], 59003)))?,
|
2019-03-04 19:50:26 +00:00
|
|
|
clients: Clients::empty(),
|
2019-04-10 23:16:29 +00:00
|
|
|
|
|
|
|
thread_pool: threadpool::Builder::new()
|
|
|
|
.thread_name("veloren-worker".into())
|
|
|
|
.build(),
|
|
|
|
chunk_tx,
|
|
|
|
chunk_rx,
|
2019-04-10 23:41:37 +00:00
|
|
|
pending_chunks: HashSet::new(),
|
2019-03-03 22:02:38 +00:00
|
|
|
})
|
2019-01-02 17:23:31 +00:00
|
|
|
}
|
|
|
|
|
2019-01-15 15:13:11 +00:00
|
|
|
/// Get a reference to the server's game state.
|
2019-03-03 22:02:38 +00:00
|
|
|
#[allow(dead_code)]
|
2019-01-12 15:57:19 +00:00
|
|
|
pub fn state(&self) -> &State { &self.state }
|
2019-01-15 15:13:11 +00:00
|
|
|
/// Get a mutable reference to the server's game state.
|
2019-03-03 22:02:38 +00:00
|
|
|
#[allow(dead_code)]
|
2019-01-12 15:57:19 +00:00
|
|
|
pub fn state_mut(&mut self) -> &mut State { &mut self.state }
|
|
|
|
|
2019-01-15 15:13:11 +00:00
|
|
|
/// Get a reference to the server's world.
|
2019-03-03 22:02:38 +00:00
|
|
|
#[allow(dead_code)]
|
2019-01-15 15:13:11 +00:00
|
|
|
pub fn world(&self) -> &World { &self.world }
|
|
|
|
/// Get a mutable reference to the server's world.
|
2019-03-03 22:02:38 +00:00
|
|
|
#[allow(dead_code)]
|
2019-01-15 15:13:11 +00:00
|
|
|
pub fn world_mut(&mut self) -> &mut World { &mut self.world }
|
|
|
|
|
2019-01-02 17:23:31 +00:00
|
|
|
/// Execute a single server tick, handle input and update the game state by the given duration
|
2019-03-03 22:02:38 +00:00
|
|
|
#[allow(dead_code)]
|
|
|
|
pub fn tick(&mut self, input: Input, dt: Duration) -> Result<Vec<Event>, Error> {
|
2019-01-02 17:23:31 +00:00
|
|
|
// This tick function is the centre of the Veloren universe. Most server-side things are
|
|
|
|
// managed from here, and as such it's important that it stays organised. Please consult
|
|
|
|
// the core developers before making significant changes to this code. Here is the
|
|
|
|
// approximate order of things. Please update it as this code changes.
|
|
|
|
//
|
|
|
|
// 1) Collect input from the frontend, apply input effects to the state of the game
|
|
|
|
// 2) Go through any events (timer-driven or otherwise) that need handling and apply them
|
|
|
|
// to the state of the game
|
|
|
|
// 3) Go through all incoming client network communications, apply them to the game state
|
|
|
|
// 4) Perform a single LocalState tick (i.e: update the world and entities in the world)
|
|
|
|
// 5) Go through the terrain update queue and apply all changes to the terrain
|
|
|
|
// 6) Send relevant state updates to all clients
|
|
|
|
// 7) Finish the tick, passing control of the main thread back to the frontend
|
|
|
|
|
2019-03-03 22:02:38 +00:00
|
|
|
// Build up a list of events for this frame, to be passed to the frontend
|
|
|
|
let mut frontend_events = Vec::new();
|
|
|
|
|
|
|
|
// If networking has problems, handle them
|
2019-03-05 18:39:18 +00:00
|
|
|
if let Some(err) = self.postoffice.error() {
|
2019-03-03 22:02:38 +00:00
|
|
|
return Err(err.into());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Handle new client connections (step 2)
|
|
|
|
frontend_events.append(&mut self.handle_new_connections()?);
|
|
|
|
|
|
|
|
// Handle new messages from clients
|
|
|
|
frontend_events.append(&mut self.handle_new_messages()?);
|
|
|
|
|
2019-01-02 17:23:31 +00:00
|
|
|
// Tick the client's LocalState (step 3)
|
|
|
|
self.state.tick(dt);
|
|
|
|
|
2019-04-10 23:16:29 +00:00
|
|
|
// Fetch any generated `TerrainChunk`s and insert them into the terrain
|
|
|
|
// Also, send the chunk data to anybody that is close by
|
|
|
|
for (key, chunk) in self.chunk_rx.try_iter() {
|
|
|
|
// Send the chunk to all nearby players
|
|
|
|
for (entity, player, pos) in (
|
|
|
|
&self.state.ecs().internal().entities(),
|
|
|
|
&self.state.ecs().internal().read_storage::<comp::Player>(),
|
|
|
|
&self.state.ecs().internal().read_storage::<comp::phys::Pos>(),
|
|
|
|
).join() {
|
|
|
|
// TODO: Distance check
|
|
|
|
// if self.state.terrain().key_pos(key)
|
|
|
|
|
|
|
|
self.clients.notify(entity, ServerMsg::TerrainChunkUpdate {
|
|
|
|
key,
|
|
|
|
chunk: chunk.clone(),
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
self.state.insert_chunk(key, chunk);
|
|
|
|
}
|
|
|
|
|
2019-03-04 19:50:26 +00:00
|
|
|
// Synchronise clients with the new state of the world
|
|
|
|
self.sync_clients();
|
|
|
|
|
2019-01-02 17:23:31 +00:00
|
|
|
// Finish the tick, pass control back to the frontend (step 6)
|
2019-03-03 22:02:38 +00:00
|
|
|
Ok(frontend_events)
|
2019-01-02 17:23:31 +00:00
|
|
|
}
|
2019-01-30 12:11:34 +00:00
|
|
|
|
|
|
|
/// Clean up the server after a tick
|
2019-03-03 22:02:38 +00:00
|
|
|
#[allow(dead_code)]
|
2019-01-30 12:11:34 +00:00
|
|
|
pub fn cleanup(&mut self) {
|
|
|
|
// Cleanup the local state
|
|
|
|
self.state.cleanup();
|
|
|
|
}
|
2019-03-03 22:02:38 +00:00
|
|
|
|
|
|
|
/// Handle new client connections
|
|
|
|
fn handle_new_connections(&mut self) -> Result<Vec<Event>, Error> {
|
|
|
|
let mut frontend_events = Vec::new();
|
|
|
|
|
2019-03-05 00:00:11 +00:00
|
|
|
for mut postbox in self.postoffice.new_connections() {
|
2019-04-10 17:23:27 +00:00
|
|
|
let entity = self.state
|
|
|
|
.ecs_mut()
|
|
|
|
.create_entity_synced()
|
2019-03-05 18:39:18 +00:00
|
|
|
.build();
|
2019-03-03 22:02:38 +00:00
|
|
|
|
2019-04-10 23:16:29 +00:00
|
|
|
self.clients.add(entity, Client {
|
2019-04-10 17:23:27 +00:00
|
|
|
state: ClientState::Connecting,
|
2019-03-03 22:02:38 +00:00
|
|
|
postbox,
|
|
|
|
last_ping: self.state.get_time(),
|
|
|
|
});
|
2019-03-05 00:00:11 +00:00
|
|
|
|
|
|
|
frontend_events.push(Event::ClientConnected {
|
2019-04-10 17:23:27 +00:00
|
|
|
entity,
|
2019-03-05 00:00:11 +00:00
|
|
|
});
|
2019-03-03 22:02:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Ok(frontend_events)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Handle new client messages
|
|
|
|
fn handle_new_messages(&mut self) -> Result<Vec<Event>, Error> {
|
|
|
|
let mut frontend_events = Vec::new();
|
|
|
|
|
|
|
|
let state = &mut self.state;
|
|
|
|
let mut new_chat_msgs = Vec::new();
|
2019-03-05 00:00:11 +00:00
|
|
|
let mut disconnected_clients = Vec::new();
|
2019-04-10 23:41:37 +00:00
|
|
|
let mut requested_chunks = Vec::new();
|
2019-03-03 22:02:38 +00:00
|
|
|
|
2019-04-10 23:16:29 +00:00
|
|
|
self.clients.remove_if(|entity, client| {
|
2019-04-10 17:23:27 +00:00
|
|
|
let mut disconnect = false;
|
2019-03-03 22:02:38 +00:00
|
|
|
let new_msgs = client.postbox.new_messages();
|
|
|
|
|
|
|
|
// Update client ping
|
|
|
|
if new_msgs.len() > 0 {
|
|
|
|
client.last_ping = state.get_time();
|
|
|
|
|
|
|
|
// Process incoming messages
|
|
|
|
for msg in new_msgs {
|
2019-04-10 17:23:27 +00:00
|
|
|
match client.state {
|
|
|
|
ClientState::Connecting => match msg {
|
|
|
|
ClientMsg::Connect { player, character } => {
|
|
|
|
|
|
|
|
// Write client components
|
2019-04-10 23:16:29 +00:00
|
|
|
state.write_component(entity, player);
|
|
|
|
state.write_component(entity, comp::phys::Pos(Vec3::zero()));
|
|
|
|
state.write_component(entity, comp::phys::Vel(Vec3::zero()));
|
|
|
|
state.write_component(entity, comp::phys::Dir(Vec3::unit_y()));
|
2019-04-10 17:23:27 +00:00
|
|
|
if let Some(character) = character {
|
2019-04-10 23:16:29 +00:00
|
|
|
state.write_component(entity, character);
|
2019-04-10 17:23:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
client.state = ClientState::Connected;
|
|
|
|
|
|
|
|
// Return a handshake with the state of the current world
|
|
|
|
client.notify(ServerMsg::Handshake {
|
|
|
|
ecs_state: state.ecs().gen_state_package(),
|
|
|
|
player_entity: state
|
|
|
|
.ecs()
|
2019-04-10 23:16:29 +00:00
|
|
|
.uid_from_entity(entity)
|
2019-04-10 17:23:27 +00:00
|
|
|
.unwrap()
|
|
|
|
.into(),
|
|
|
|
});
|
|
|
|
},
|
|
|
|
_ => disconnect = true,
|
|
|
|
},
|
|
|
|
ClientState::Connected => match msg {
|
|
|
|
ClientMsg::Connect { .. } => disconnect = true, // Not allowed when already connected
|
2019-04-10 23:41:37 +00:00
|
|
|
ClientMsg::Disconnect => disconnect = true,
|
2019-04-10 17:23:27 +00:00
|
|
|
ClientMsg::Ping => client.postbox.send(ServerMsg::Pong),
|
|
|
|
ClientMsg::Pong => {},
|
2019-04-10 23:16:29 +00:00
|
|
|
ClientMsg::Chat(msg) => new_chat_msgs.push((entity, msg)),
|
2019-04-10 17:23:27 +00:00
|
|
|
ClientMsg::PlayerPhysics { pos, vel, dir } => {
|
2019-04-10 23:16:29 +00:00
|
|
|
state.write_component(entity, pos);
|
|
|
|
state.write_component(entity, vel);
|
|
|
|
state.write_component(entity, dir);
|
2019-04-10 17:23:27 +00:00
|
|
|
},
|
2019-04-10 23:41:37 +00:00
|
|
|
ClientMsg::TerrainChunkRequest { key } => match state.terrain().get_key(key) {
|
|
|
|
Some(chunk) => client.postbox.send(ServerMsg::TerrainChunkUpdate {
|
|
|
|
key,
|
|
|
|
chunk: chunk.clone(),
|
|
|
|
}),
|
|
|
|
None => requested_chunks.push(key),
|
|
|
|
},
|
2019-03-05 18:39:18 +00:00
|
|
|
},
|
2019-03-03 22:02:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if
|
2019-03-04 19:50:26 +00:00
|
|
|
state.get_time() - client.last_ping > CLIENT_TIMEOUT || // Timeout
|
2019-03-06 13:48:44 +00:00
|
|
|
client.postbox.error().is_some() // Postbox error
|
2019-03-03 22:02:38 +00:00
|
|
|
{
|
2019-04-10 17:23:27 +00:00
|
|
|
disconnect = true;
|
2019-03-06 13:51:01 +00:00
|
|
|
} else if state.get_time() - client.last_ping > CLIENT_TIMEOUT * 0.5 {
|
|
|
|
// Try pinging the client if the timeout is nearing
|
|
|
|
client.postbox.send(ServerMsg::Ping);
|
2019-03-03 22:02:38 +00:00
|
|
|
}
|
|
|
|
|
2019-04-10 17:23:27 +00:00
|
|
|
if disconnect {
|
2019-04-10 23:16:29 +00:00
|
|
|
disconnected_clients.push(entity);
|
2019-03-03 22:02:38 +00:00
|
|
|
true
|
|
|
|
} else {
|
|
|
|
false
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
// Handle new chat messages
|
2019-04-10 17:23:27 +00:00
|
|
|
for (entity, msg) in new_chat_msgs {
|
|
|
|
self.clients.notify_connected(ServerMsg::Chat(match state
|
|
|
|
.ecs()
|
|
|
|
.internal()
|
|
|
|
.read_storage::<comp::Player>()
|
|
|
|
.get(entity)
|
|
|
|
{
|
|
|
|
Some(player) => format!("[{}] {}", &player.alias, msg),
|
|
|
|
None => format!("[<anon>] {}", msg),
|
|
|
|
}));
|
2019-03-03 22:02:38 +00:00
|
|
|
|
|
|
|
frontend_events.push(Event::Chat {
|
2019-04-10 17:23:27 +00:00
|
|
|
entity,
|
2019-03-03 22:02:38 +00:00
|
|
|
msg,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-03-05 00:00:11 +00:00
|
|
|
// Handle client disconnects
|
2019-04-10 17:23:27 +00:00
|
|
|
for entity in disconnected_clients {
|
|
|
|
state.ecs_mut().delete_entity_synced(entity);
|
2019-03-05 00:00:11 +00:00
|
|
|
|
|
|
|
frontend_events.push(Event::ClientDisconnected {
|
2019-04-10 17:23:27 +00:00
|
|
|
entity,
|
2019-03-05 00:00:11 +00:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-04-10 23:41:37 +00:00
|
|
|
// Generate requested chunks
|
|
|
|
for key in requested_chunks {
|
|
|
|
self.generate_chunk(key);
|
|
|
|
}
|
|
|
|
|
2019-03-03 22:02:38 +00:00
|
|
|
Ok(frontend_events)
|
|
|
|
}
|
2019-03-04 19:50:26 +00:00
|
|
|
|
|
|
|
/// Sync client states with the most up to date information
|
|
|
|
fn sync_clients(&mut self) {
|
2019-04-10 17:23:27 +00:00
|
|
|
self.clients.notify_connected(ServerMsg::EcsSync(self.state.ecs_mut().next_sync_package()));
|
2019-03-04 19:50:26 +00:00
|
|
|
}
|
2019-04-10 23:41:37 +00:00
|
|
|
|
|
|
|
pub fn generate_chunk(&mut self, key: Vec3<i32>) {
|
|
|
|
if self.pending_chunks.insert(key) {
|
|
|
|
let chunk_tx = self.chunk_tx.clone();
|
|
|
|
self.thread_pool.execute(move || chunk_tx.send((key, World::generate_chunk(key))).unwrap());
|
|
|
|
}
|
|
|
|
}
|
2019-01-02 17:23:31 +00:00
|
|
|
}
|
2019-03-05 18:39:18 +00:00
|
|
|
|
|
|
|
impl Drop for Server {
|
|
|
|
fn drop(&mut self) {
|
2019-04-10 17:23:27 +00:00
|
|
|
self.clients.notify_connected(ServerMsg::Shutdown);
|
2019-03-05 18:39:18 +00:00
|
|
|
}
|
|
|
|
}
|