259 lines
9.8 KiB
Rust
259 lines
9.8 KiB
Rust
use std::{net::{TcpListener, SocketAddr}, thread, sync::mpsc::{Receiver, Sender, channel}, collections::HashSet};
|
|
|
|
use log::{info, warn, debug};
|
|
use serde_json::json;
|
|
|
|
use crate::{protocol::{data::PacketEncoder, serverbound::*, clientbound::*, command::{Commands, CommandNodeType}}, plugins::{Plugins, Response}, VERSION};
|
|
|
|
use super::{client::NetworkClient, Player};
|
|
|
|
pub struct NetworkServer<'lua> {
|
|
plugins: Plugins<'lua>,
|
|
commands: Commands,
|
|
new_clients: Receiver<NetworkClient>,
|
|
clients: Vec<NetworkClient>,
|
|
}
|
|
|
|
impl <'lua> NetworkServer<'lua> {
|
|
pub fn new(addr: SocketAddr, mut plugins: Plugins<'lua>) -> Self {
|
|
let (send, recv) = channel();
|
|
info!("Initializing plugins");
|
|
plugins.init();
|
|
let mut commands = Commands::new();
|
|
commands.create_simple_cmd("qc");
|
|
let commands = plugins.register_commands(commands).unwrap();
|
|
thread::spawn(move || Self::listen(&addr, send));
|
|
Self {
|
|
plugins,
|
|
commands,
|
|
new_clients: recv,
|
|
clients: Vec::new(),
|
|
}
|
|
}
|
|
|
|
fn listen(addr: &SocketAddr, send_clients: Sender<NetworkClient>) {
|
|
info!("Listening on {}", addr);
|
|
let listener = TcpListener::bind(addr).unwrap();
|
|
for (id, stream) in listener.incoming().enumerate() {
|
|
let stream = stream.unwrap();
|
|
debug!("Connection from {} (id {})", stream.peer_addr().unwrap(), id);
|
|
let stream_2 = stream.try_clone().unwrap();
|
|
let (send, recv) = channel();
|
|
thread::spawn(|| NetworkClient::listen(stream_2, send));
|
|
let client = NetworkClient {
|
|
id: id as i32,
|
|
play: false,
|
|
closed: false,
|
|
stream,
|
|
serverbound: recv,
|
|
player: None,
|
|
};
|
|
send_clients.send(client).unwrap();
|
|
}
|
|
}
|
|
|
|
pub fn get_new_clients(&mut self) {
|
|
while let Ok(client) = self.new_clients.try_recv() {
|
|
self.clients.push(client);
|
|
}
|
|
}
|
|
|
|
pub fn send_keep_alive(&mut self) {
|
|
let mut closed = Vec::new();
|
|
for client in self.clients.iter_mut() {
|
|
if client.play {
|
|
let result = client.send_packet(ClientBoundPacket::KeepAlive(0));
|
|
if result.is_err() {
|
|
client.close();
|
|
if let Some(pl) = &client.player {
|
|
self.plugins.player_leave(pl);
|
|
}
|
|
closed.push(client.id);
|
|
}
|
|
}
|
|
}
|
|
self.clients.retain(|x| !closed.contains(&x.id));
|
|
}
|
|
|
|
pub fn handle_connections(&mut self) {
|
|
let mut closed = HashSet::new();
|
|
for i in 0..self.clients.len() {
|
|
let client: &mut NetworkClient = unsafe {
|
|
&mut *(self.clients.get_unchecked_mut(i) as *mut _)
|
|
};
|
|
let mut alive = true;
|
|
while let Some(packet) = client.recv_packet(&mut alive) {
|
|
let result = self.handle_packet(client, packet);
|
|
if result.is_err() {
|
|
alive = false;
|
|
break
|
|
}
|
|
}
|
|
if !alive && !client.closed {
|
|
closed.insert(client.id);
|
|
if let Some(pl) = &client.player {
|
|
self.plugins.player_leave(pl);
|
|
}
|
|
client.close();
|
|
}
|
|
}
|
|
for response in self.plugins.get_responses() {
|
|
let _ = self.handle_plugin_response(response);
|
|
}
|
|
self.clients.retain(|x| !closed.contains(&x.id));
|
|
}
|
|
|
|
fn handle_plugin_response(&mut self, response: Response) -> std::io::Result<()> {
|
|
match response {
|
|
Response::Message { player, message } => {
|
|
for client in self.clients.iter_mut() {
|
|
if let Some(p) = &client.player {
|
|
if p.name == player || p.uuid.to_string() == player {
|
|
client.send_packet(ClientBoundPacket::SystemChatMessage(message, false))?;
|
|
break
|
|
}
|
|
}
|
|
}
|
|
},
|
|
Response::Broadcast { message } => {
|
|
for client in self.clients.iter_mut() {
|
|
if client.player.is_some() {
|
|
client.send_packet(ClientBoundPacket::SystemChatMessage(message.clone(), false))?;
|
|
}
|
|
}
|
|
},
|
|
Response::Disconnect { player, reason } => {
|
|
for client in self.clients.iter_mut() {
|
|
if let Some(pl) = &client.player {
|
|
if pl.name == player || pl.uuid.to_string() == player {
|
|
client.send_packet(ClientBoundPacket::Disconnect(reason.clone()))?;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn handle_packet(&mut self, client: &mut NetworkClient, packet: ServerBoundPacket) -> std::io::Result<()> {
|
|
match packet {
|
|
ServerBoundPacket::Ignored(_) => (),
|
|
ServerBoundPacket::Unknown(id) => warn!("Unknown packet: {}", id),
|
|
ServerBoundPacket::Handshake(_) => (),
|
|
ServerBoundPacket::StatusRequest()
|
|
=> client.send_packet(ClientBoundPacket::StatusResponse(
|
|
r#"{"version":{"name":"1.19.2","protocol":760}}"#.to_owned()
|
|
))?,
|
|
ServerBoundPacket::PingRequest(n) => {
|
|
client.send_packet(ClientBoundPacket::PingResponse(n))?;
|
|
client.close();
|
|
}
|
|
ServerBoundPacket::LoginStart(login_start) => {
|
|
if self.clients.iter().filter_map(|x| x.player.as_ref()).any(|x| x.uuid == login_start.uuid) {
|
|
client.send_packet(ClientBoundPacket::LoginDisconnect(json!({"translate": "multiplayer.disconnect.duplicate_login"})))?;
|
|
client.close();
|
|
} else {
|
|
client.player = Some(Player {
|
|
name: login_start.name.clone(),
|
|
uuid: login_start.uuid,
|
|
});
|
|
client.play = true;
|
|
client.send_packet(ClientBoundPacket::LoginSuccess(LoginSuccess {
|
|
name: login_start.name,
|
|
uuid: login_start.uuid,
|
|
}))?;
|
|
self.plugins.player_join(client.player.as_ref().unwrap());
|
|
self.post_login(client)?;
|
|
}
|
|
}
|
|
ServerBoundPacket::ChatMessage(msg) => {
|
|
self.plugins.chat_message(client.player.as_ref().unwrap(), &msg.message);
|
|
}
|
|
ServerBoundPacket::ChatCommand(msg) => {
|
|
let mut parts = msg.message.splitn(1, " ");
|
|
if let Some(cmd) = parts.next() {
|
|
if cmd == "qc" {
|
|
client.send_packet(ClientBoundPacket::SystemChatMessage(json!({
|
|
"text": format!("QuectoCraft version {}", VERSION),
|
|
"color": "green"
|
|
}), false))?;
|
|
} else {
|
|
let args = parts.next().unwrap_or_default();
|
|
self.plugins.command(client.player.as_ref().unwrap(), cmd, args);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn post_login(&mut self, client: &mut NetworkClient) -> std::io::Result<()> {
|
|
client.send_packet(ClientBoundPacket::LoginPlay(LoginPlay {
|
|
eid: client.id,
|
|
is_hardcore: false,
|
|
gamemode: 1,
|
|
prev_gamemode: 1,
|
|
dimensions: vec![
|
|
"qc:world".to_owned(),
|
|
],
|
|
registry_codec: include_bytes!("../resources/registry_codec.nbt").to_vec(),
|
|
dimension_type: "minecraft:the_end".to_owned(),
|
|
dimension_name: "qc:world".to_owned(),
|
|
seed_hash: 0,
|
|
max_players: 0,
|
|
view_distance: 8,
|
|
sim_distance: 8,
|
|
reduced_debug_info: false,
|
|
respawn_screen: false,
|
|
is_debug: false,
|
|
is_flat: false,
|
|
death_location: None,
|
|
}))?;
|
|
client.send_packet(ClientBoundPacket::PluginMessage(PluginMessage {
|
|
channel: "minecraft:brand".to_owned(),
|
|
data: {
|
|
let mut data = Vec::new();
|
|
data.write_string(32767, &format!("Quectocraft {}", VERSION));
|
|
data
|
|
}
|
|
}))?;
|
|
client.send_packet(ClientBoundPacket::Commands(self.commands.clone()))?;
|
|
let mut chunk_data: Vec<u8> = Vec::new();
|
|
for _ in 0..(384 / 16) {
|
|
// number of non-air blocks
|
|
chunk_data.write_short(0);
|
|
// block states
|
|
chunk_data.write_ubyte(0);
|
|
chunk_data.write_varint(0);
|
|
chunk_data.write_varint(0);
|
|
// biomes
|
|
chunk_data.write_ubyte(0);
|
|
chunk_data.write_varint(0);
|
|
chunk_data.write_varint(0);
|
|
}
|
|
let hmdata = vec![0i64; 37];
|
|
let mut heightmap = nbt::Blob::new();
|
|
heightmap.insert("MOTION_BLOCKING", hmdata).unwrap();
|
|
client.send_packet(ClientBoundPacket::ChunkData(ChunkData {
|
|
x: 0,
|
|
z: 0,
|
|
heightmap,
|
|
chunk_data,
|
|
}))?;
|
|
client.send_packet(ClientBoundPacket::SyncPlayerPosition(SyncPlayerPosition {
|
|
x: 0.0,
|
|
y: 64.0,
|
|
z: 0.0,
|
|
yaw: 0.0,
|
|
pitch: 0.0,
|
|
flags: 0,
|
|
teleport_id: 0,
|
|
dismount: false
|
|
}))?;
|
|
// TODO why doesn't this work with quilt?
|
|
// client.send_packet(ClientBoundPacket::PlayerAbilities(0x0f, 0.05, 0.1))?;
|
|
Ok(())
|
|
}
|
|
|
|
}
|