mirror of
https://github.com/italicsjenga/valence.git
synced 2024-12-23 22:41:30 +11:00
f4714cf255
Closes #82 Closes #43 Closes #64 # Changes and Improvements - Packet encoding/decoding happens within `Client` instead of being sent over a channel first. This is better for performance and lays the groundwork for #83. - Reduce the amount of copying necessary by leveraging the `bytes` crate and recent changes to `EncodePacket`. Performance is noticeably improved with maximum players in the `rust-mc-bot` test going from 750 to 1050. - Packet encoding/decoding code is decoupled from IO. This is easier to understand and more suitable for a future protocol lib. - Precise control over the number of bytes that are buffered for sending/receiving. This is important for limiting maximum memory usage correctly. - "packet controllers" are introduced, which are convenient structures for managing packet IO before and during the play state. - `byte_channel` module is created to help implement the `PlayPacketController`. This is essentially a channel of bytes implemented with an `Arc<Mutex<BytesMut>>`. - Error handling in the update procedure for clients was improved using `anyhow::Result<()>` to exit as early as possible. The `client` module is a bit cleaner as a result. - The `LoginPlay` packet is always sent before all other play packets. We no longer have to worry about the behavior of packets sent before that packet. Most packet deferring performed currently can be eliminated. - The packet_inspector was rewritten in response to the above changes. - Timeouts on IO operations behave better. # Known Issues - The packet_inspector now re-encodes packets rather than just decoding them. This will cause problems when trying to use it with the vanilla server because there are missing clientbound packets and other issues. This will be fixed when the protocol module is moved to a separate crate.
229 lines
7.9 KiB
Rust
229 lines
7.9 KiB
Rust
use std::net::SocketAddr;
|
|
use std::sync::atomic::{AtomicUsize, Ordering};
|
|
|
|
use log::LevelFilter;
|
|
use num::Integer;
|
|
use valence::client::{DiggingStatus, Hand};
|
|
use valence::prelude::*;
|
|
|
|
pub fn main() -> ShutdownResult {
|
|
env_logger::Builder::new()
|
|
.filter_module("valence", LevelFilter::Trace)
|
|
.parse_default_env()
|
|
.init();
|
|
|
|
valence::start_server(
|
|
Game {
|
|
player_count: AtomicUsize::new(0),
|
|
},
|
|
ServerState { player_list: None },
|
|
)
|
|
}
|
|
|
|
struct Game {
|
|
player_count: AtomicUsize,
|
|
}
|
|
|
|
struct ServerState {
|
|
player_list: Option<PlayerListId>,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct ClientState {
|
|
entity_id: EntityId,
|
|
}
|
|
|
|
const MAX_PLAYERS: usize = 10;
|
|
|
|
const SIZE_X: usize = 100;
|
|
const SIZE_Z: usize = 100;
|
|
|
|
#[async_trait]
|
|
impl Config for Game {
|
|
type ServerState = ServerState;
|
|
type ClientState = ClientState;
|
|
type EntityState = ();
|
|
type WorldState = ();
|
|
type ChunkState = ();
|
|
type PlayerListState = ();
|
|
|
|
fn dimensions(&self) -> Vec<Dimension> {
|
|
vec![Dimension {
|
|
fixed_time: Some(6000),
|
|
..Dimension::default()
|
|
}]
|
|
}
|
|
|
|
async fn server_list_ping(
|
|
&self,
|
|
_server: &SharedServer<Self>,
|
|
_remote_addr: SocketAddr,
|
|
_protocol_version: i32,
|
|
) -> ServerListPing {
|
|
ServerListPing::Respond {
|
|
online_players: self.player_count.load(Ordering::SeqCst) as i32,
|
|
max_players: MAX_PLAYERS as i32,
|
|
player_sample: Default::default(),
|
|
description: "Hello Valence!".color(Color::AQUA),
|
|
favicon_png: Some(include_bytes!("../assets/logo-64x64.png").as_slice().into()),
|
|
}
|
|
}
|
|
|
|
fn init(&self, server: &mut Server<Self>) {
|
|
let world = server.worlds.insert(DimensionId::default(), ()).1;
|
|
server.state.player_list = Some(server.player_lists.insert(()).0);
|
|
|
|
// initialize chunks
|
|
for chunk_z in -2..Integer::div_ceil(&(SIZE_Z as i32), &16) + 2 {
|
|
for chunk_x in -2..Integer::div_ceil(&(SIZE_X as i32), &16) + 2 {
|
|
world.chunks.insert(
|
|
[chunk_x as i32, chunk_z as i32],
|
|
UnloadedChunk::default(),
|
|
(),
|
|
);
|
|
}
|
|
}
|
|
|
|
// initialize blocks in the chunks
|
|
for chunk_x in 0..Integer::div_ceil(&SIZE_X, &16) {
|
|
for chunk_z in 0..Integer::div_ceil(&SIZE_Z, &16) {
|
|
let chunk = world
|
|
.chunks
|
|
.get_mut((chunk_x as i32, chunk_z as i32))
|
|
.unwrap();
|
|
for x in 0..16 {
|
|
for z in 0..16 {
|
|
let cell_x = chunk_x * 16 + x;
|
|
let cell_z = chunk_z * 16 + z;
|
|
|
|
if cell_x < SIZE_X && cell_z < SIZE_Z {
|
|
chunk.set_block_state(x, 63, z, BlockState::GRASS_BLOCK);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn update(&self, server: &mut Server<Self>) {
|
|
let (world_id, world) = server.worlds.iter_mut().next().unwrap();
|
|
|
|
let spawn_pos = [SIZE_X as f64 / 2.0, 1.0, SIZE_Z as f64 / 2.0];
|
|
|
|
server.clients.retain(|_, client| {
|
|
if client.created_this_tick() {
|
|
if self
|
|
.player_count
|
|
.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |count| {
|
|
(count < MAX_PLAYERS).then_some(count + 1)
|
|
})
|
|
.is_err()
|
|
{
|
|
client.disconnect("The server is full!".color(Color::RED));
|
|
return false;
|
|
}
|
|
|
|
match server
|
|
.entities
|
|
.insert_with_uuid(EntityKind::Player, client.uuid(), ())
|
|
{
|
|
Some((id, _)) => client.state.entity_id = id,
|
|
None => {
|
|
client.disconnect("Conflicting UUID");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
client.spawn(world_id);
|
|
client.set_flat(true);
|
|
client.teleport(spawn_pos, 0.0, 0.0);
|
|
client.set_player_list(server.state.player_list.clone());
|
|
|
|
if let Some(id) = &server.state.player_list {
|
|
server.player_lists.get_mut(id).insert(
|
|
client.uuid(),
|
|
client.username(),
|
|
client.textures().cloned(),
|
|
client.game_mode(),
|
|
0,
|
|
None,
|
|
);
|
|
}
|
|
|
|
client.set_game_mode(GameMode::Creative);
|
|
client.send_message("Welcome to Valence! Build something cool.".italic());
|
|
}
|
|
|
|
if client.is_disconnected() {
|
|
self.player_count.fetch_sub(1, Ordering::SeqCst);
|
|
server.entities.remove(client.state.entity_id);
|
|
if let Some(id) = &server.state.player_list {
|
|
server.player_lists.get_mut(id).remove(client.uuid());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
let player = server.entities.get_mut(client.state.entity_id).unwrap();
|
|
|
|
if client.position().y <= -20.0 {
|
|
client.teleport(spawn_pos, client.yaw(), client.pitch());
|
|
}
|
|
|
|
while let Some(event) = handle_event_default(client, player) {
|
|
match event {
|
|
ClientEvent::Digging {
|
|
position, status, ..
|
|
} => {
|
|
match status {
|
|
DiggingStatus::Start => {
|
|
// Allows clients in creative mode to break blocks.
|
|
if client.game_mode() == GameMode::Creative {
|
|
world.chunks.set_block_state(position, BlockState::AIR);
|
|
}
|
|
}
|
|
DiggingStatus::Finish => {
|
|
// Allows clients in survival mode to break blocks.
|
|
world.chunks.set_block_state(position, BlockState::AIR);
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
ClientEvent::InteractWithBlock {
|
|
hand,
|
|
location,
|
|
face,
|
|
..
|
|
} => {
|
|
if hand == Hand::Main {
|
|
if let Some(stack) = client.held_item() {
|
|
if let Some(held_block_kind) = stack.item.to_block_kind() {
|
|
let block_to_place = BlockState::from_kind(held_block_kind);
|
|
|
|
if world
|
|
.chunks
|
|
.block_state(location)
|
|
.map(|s| s.is_replaceable())
|
|
.unwrap_or(false)
|
|
{
|
|
world.chunks.set_block_state(location, block_to_place);
|
|
} else {
|
|
let place_at = location.get_in_direction(face);
|
|
world.chunks.set_block_state(place_at, block_to_place);
|
|
}
|
|
|
|
if client.game_mode() != GameMode::Creative {
|
|
client.consume_one_held_item();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
true
|
|
});
|
|
}
|
|
}
|