Cargo.lock

@@ -586,26 +586,10 @@ dependencies = [
  "pin-project-lite",
  "tokio",
  "tokio-rustls 0.23.4",
- "tungstenite 0.17.3",
+ "tungstenite",
  "webpki-roots",
 ]
 
-[[package]]
-name = "async-tungstenite"
-version = "0.22.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce01ac37fdc85f10a43c43bc582cbd566720357011578a935761075f898baf58"
-dependencies = [
- "futures-io",
- "futures-util",
- "log 0.4.19",
- "native-tls",
- "pin-project-lite",
- "tokio",
- "tokio-native-tls",
- "tungstenite 0.19.0",
-]
-
 [[package]]
 name = "autocfg"
 version = "0.1.8"
@@ -940,7 +924,6 @@ name = "azalea-worker"
 version = "0.1.0"
 dependencies = [
  "async-trait",
- "async-tungstenite 0.22.2",
  "azalea-buf",
  "azalea-client",
  "azalea-core",
@@ -949,7 +932,6 @@ dependencies = [
  "bevy",
  "bevy_app",
  "bevy_ecs",
- "chrono",
  "common",
  "futures 0.3.28",
  "log 0.4.19",
@@ -964,6 +946,7 @@ dependencies = [
  "toml",
  "url 2.4.0",
  "uuid",
+ "websocket",
 ]
 
 [[package]]
@@ -5222,7 +5205,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d007dc45584ecc47e791f2a9a7cf17bf98ac386728106f111159c846d624be3f"
 dependencies = [
  "async-trait",
- "async-tungstenite 0.17.2",
+ "async-tungstenite",
  "base64 0.13.1",
  "bitflags 1.3.2",
  "bytes 1.4.0",
@@ -6020,26 +6003,6 @@ dependencies = [
  "webpki",
 ]
 
-[[package]]
-name = "tungstenite"
-version = "0.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15fba1a6d6bb030745759a9a2a588bfe8490fc8b4751a277db3a0be1c9ebbf67"
-dependencies = [
- "byteorder",
- "bytes 1.4.0",
- "data-encoding",
- "http",
- "httparse",
- "log 0.4.19",
- "native-tls",
- "rand 0.8.5",
- "sha1",
- "thiserror",
- "url 2.4.0",
- "utf-8",
-]
-
 [[package]]
 name = "twox-hash"
 version = "1.6.3"

azalea-worker/Cargo.toml

@@ -15,6 +15,7 @@ tokio = { version = "1", features = ["full"] }
 reqwest = { version = "0.11", features = ["json"] }
 serde_json = "1"
 async-trait = "0.1"
+websocket = { version = "0.26", features = ["async"] }
 common = { path = "../common" }
 tokio-threadpool = "0.1"
 bevy_ecs = "0.11"
@@ -29,5 +30,3 @@ azalea-crypto = { version = "0.7", git = "https://git.e3t.cc/~core/azalea" }
 azalea-core = { version = "0.7", git = "https://git.e3t.cc/~core/azalea" }
 azalea-buf = { version = "0.7", git = "https://git.e3t.cc/~core/azalea" }
 azalea-client = { version = "0.7", git = "https://git.e3t.cc/~core/azalea" }
-async-tungstenite = { version = "0.22", features = ["tokio-runtime", "tokio-native-tls"] }
-chrono = "0.4"

azalea-worker/config.toml

@@ -1,5 +1,5 @@
-api_status_url = "https://data-api.locationoverflow.coredoes.dev/status"
+api_status_url = "http://localhost:8171/status"
-token = "rw-minecraft-b1d648ab-498a-4499-b5a7-64aedcd7c836"
+token = "test-rw-token"
 
 [server]
 ip = "95.216.24.174"
@@ -15,5 +15,3 @@ ignored = []
 [permissions]
 owner = []
 admin = []
-
-[locations]

azalea-worker/src/bacon.rs

@@ -1,348 +0,0 @@
-use std::ops::DerefMut;
-use std::str::FromStr;
-use std::sync::{Arc};
-use azalea_client::chat::ChatPacket;
-use azalea_client::Client;
-use log::info;
-use crate::config::{Config};
-use uuid::Uuid;
-
-pub const BACON_FEATURE_FLAGS: &[&str] = &["F-A", "F-Q", "F-E", "F-T", "F-B", "C-B", "C-A", "C-O", "C-H", "C-S", "C-A-S", "C-A-C", "C-A-I", "C-A-U"];
-
-pub async fn handle_message(p: ChatPacket, client: &mut Client, config: &Config) {
-    if p.username().is_none() { return; }
-
-    {
-        info!("{} {} {:?}", p.username().unwrap(), p.uuid().unwrap(), config.server.ignored);
-
-        if config.server.ignored.contains(&p.username().unwrap()) || config.server.ignored.contains(&p.uuid().unwrap().to_string()) {
-            return;
-        }
-    }
-
-    let message = p.content().to_string();
-
-    let mut components = vec![];
-
-    let mut is_parsing_string = false;
-    let mut is_parsing_escape = false;
-    let mut component = "".to_string();
-    for char in message.chars() {
-        let mut char = char.to_string();
-        if !&is_parsing_escape && !&is_parsing_string {
-            if char == "\"" {
-                is_parsing_string = true;
-                continue;
-            }
-            if char == "\\" {
-                is_parsing_escape = true;
-                continue;
-            }
-            if char == " " {
-                components.push(component);
-                component = "".to_string();
-                continue;
-            }
-
-            component += char.as_str();
-        }
-        if is_parsing_escape {
-            if char == "\"" {
-                is_parsing_escape = false;
-                component += "\"";
-                continue;
-            }
-            if char == "n" {
-                is_parsing_escape = false;
-                component += "\n";
-                continue;
-            }
-            if char == "\\" {
-                is_parsing_escape = false;
-                component += "\\";
-                continue;
-            }
-            //client.chat(&format!("[bot] Sorry, I don't understand that message. (invalid escape char)"));
-            return;
-        }
-        if is_parsing_string {
-            if char == "\"" {
-                is_parsing_string = false;
-                components.push(component);
-                component = "".to_string();
-                continue;
-            }
-            component += char.as_str();
-        }
-    }
-
-    if !component.is_empty() {
-        components.push(component);
-    }
-
-    if is_parsing_string {
-        return;
-    }
-
-    if p.uuid() == Some(config.server.uuid) && components[0].starts_with('@') {
-        components.remove(0);
-    }
-
-    if components.len() == 0 {
-        return; // hotfix: fuck you dam
-    }
-
-    let is_for_me = components[0].starts_with(&format!("!@{}", config.server.username)) || (!components[0].starts_with("!@") && components[0].starts_with("!"));
-
-    if !is_for_me { return; }
-
-    if components[0] == format!("!@{}", config.server.username) && components.len() == 1 {
-        return;
-    }
-
-    let command = if components[0] == format!("!@{}", config.server.username) {
-        components[1].clone()
-    } else {
-        components[0].split('!').nth(1).unwrap().to_owned()
-    };
-
-    match command.as_str() {
-        "bacon" => {
-            client.chat("[bacon] F-A F-Q F-E F-T F-B C-B C-A C-O C-H C-S C-A-I C-A-U");
-            client.chat("[bacon end]");
-            return;
-        },
-        "bot" => {
-            client.chat("[iambot]");
-            return;
-        },
-        "about" => {
-            client.chat("[bot about] Hi, I'm CuberCore! I am a bot that provides the chat relay for this server as well as many other useful features.");
-            return;
-        },
-        "owner" => {
-            client.chat(&format!("[bot] I am owned by: {} ({})", config.server.owner_username, config.server.owner_uuid_undashed));
-            return;
-        },
-        "help" => {
-            client.chat("[bot help] Here are my commands:");
-            client.chat("[bot help] !bacon, !bot, !about, !owner, !help, !sleep, !ignore [player], !unignore [player], !disconnect, !reconnect, !reload, !op [uuid], !deop [uuid], !location, !location [location], !location [location] [newlocation], !location [location] remove");
-            return;
-        },
-        "reload" => {
-            client.chat("[bot] Reloading configuration...");
-
-            /*{
-                let _ = std::mem::replace(config.write().await.deref_mut(), load_config());
-            }*/
-
-            client.chat("[bot] Configuration not reloaded - not yet implemented");
-        },
-        "ignore" => {
-            if let Some(u) = p.uuid() {
-                if !config.permissions.admin.contains(&u) {
-                    return;
-                }
-            } else {
-                return;
-            }
-
-            if components.len() != 2 {
-                client.chat("[bot] usage: !ignore [player]");
-                return;
-            }
-
-            client.chat("Not yet implemented.");
-            return;
-/*
-            let player = components[1].clone();
-
-            {
-                let has = { config.write().await.relay.ignored.contains(&player) };
-                if !has {
-                    config.write().await.relay.ignored.push(player.clone());
-                }
-            }
-
-            save_config(&*config.read().await);
-
-            client.chat(&format!("[bot] {} has been ignored", player));
-
- */
-        },
-        "unignore" => {
-            if let Some(u) = p.uuid() {
-                if !config.permissions.admin.contains(&u) {
-                    return;
-                }
-            } else {
-                return;
-            }
-
-            if components.len() != 2 {
-                client.chat("[bot] usage: !unignore [player]");
-                return;
-            }
-
-            client.chat("not yet implemented");
-
-            return;
-            /*
-
-            let player = components[1].clone();
-
-            {
-                let has = { config.write().await.relay.ignored.contains(&player) };
-                if has {
-                    let index = { config.write().await.relay.ignored.iter().position(|u| u == &player).unwrap() };
-                    config.write().await.relay.ignored.remove(index);
-                }
-            }
-
-            save_config(&*config.read().await);
-
-            client.chat(&format!("[bot] {} has been unignored", player));
-
-             */
-        },
-        "op" => {
-            if let Some(u) = p.uuid() {
-                if !config.permissions.admin.contains(&u) {
-                    return;
-                }
-            } else {
-                return;
-            }
-
-            if components.len() != 2 {
-                client.chat("[bot] usage: !op [uuid]");
-                return;
-            }
-
-            let player = components[1].clone();
-            let player = match Uuid::from_str(&player) {
-                Ok(p) => p,
-                Err(e) => {
-                    client.chat(&format!("[bot] invalid uuid: {}", e));
-                    return;
-                }
-            };
-
-            client.chat("not yet implemented");
-
-            return;
-/*
-            {
-                let has = { config.write().await.permissions.admin.contains(&player) };
-                if !has {
-                    config.write().await.permissions.admin.push(player.clone());
-                }
-            }
-
-            save_config(&*config.read().await);
-
-            client.chat(&format!("[bot] {} has been opped", player))
-
- */
-        },
-        "deop" => {
-            if let Some(u) = p.uuid() {
-                if !config.permissions.admin.contains(&u) {
-                    return;
-                }
-            } else {
-                return;
-            }
-
-            if components.len() != 2 {
-                client.chat("[bot] usage: !deop [player]");
-                return;
-            }
-
-            let player = components[1].clone();
-            let player = match Uuid::from_str(&player) {
-                Ok(p) => p,
-                Err(e) => {
-                    client.chat(&format!("[bot] invalid uuid: {}", e));
-                    return;
-                }
-            };
-
-            client.chat("not yet implemented");
-            return;
-            /*
-
-            {
-                let has = { config.write().await.permissions.admin.contains(&player) };
-                if has {
-                    let index = { config.write().await.permissions.admin.iter().position(|u| u == &player).unwrap() };
-                    config.write().await.permissions.admin.remove(index);
-                }
-            }
-
-            save_config(&*config.read().await);
-
-            client.chat(&format!("[bot] {} has been deopped", player));
-
-             */
-        },
-        "location" => {
-            if components.len() == 1 {
-                client.chat(&format!("Here are the locations I know about: {:?}", config.locations.keys().collect::<Vec<_>>()));
-                return;
-            }
-
-            if components.len() == 2 {
-                if let Some(pos) = config.locations.get(&components[1]) {
-                    client.chat(&format!("{} is located at {}!", components[1], pos));
-                    return;
-                } else {
-                    client.chat(&format!("Sorry, I don't know where {} is.", components[1]));
-                    return;
-                }
-            }
-
-            if components.len() == 3 {
-                if let Some(u) = p.uuid() {
-                    if !config.permissions.admin.contains(&u) {
-                        return;
-                    }
-                } else {
-                    return;
-                }
-
-                // !location abode "1 2 3"
-                // !location abode remove
-
-                if components[2] == "remove" {
-                    client.chat("not yet implemented");
-                    /*
-                    {
-                        config.write().await.locations.remove(&components[1]);
-                    }
-
-                    save_config(&*config.read().await);
-
-                    client.chat(&format!("Okay, I removed the {} location.", components[1]));
-
-                     */
-                    return;
-                }
-
-                client.chat("not yet implemented");
-                /*
-                {
-                    config.write().await.locations.insert(components[1].clone(), components[2].clone());
-                }
-
-                save_config(&*config.read().await);
-
-                client.chat(&format!("Okay, I set the {} location to {}.", components[1], components[2]));
-
-                 */
-                return;
-            }
-        }
-        _ => ()
-    }
-}

azalea-worker/src/config.rs

@@ -1,4 +1,3 @@
-use std::collections::HashMap;
 use std::net::Ipv4Addr;
 use serde::{Deserialize, Serialize};
 use url::Url;
@@ -9,8 +8,7 @@ pub struct Config {
     pub api_status_url: Url,
     pub token: String,
     pub server: ServerConfig,
-    pub permissions: PermissionsConfig,
+    pub permissions: PermissionsConfig
-    pub locations: HashMap<String, String>
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]

azalea-worker/src/main.rs

@@ -1,41 +1,29 @@
 use std::error::Error;
-use std::{fs, thread};
+use std::fs;
 use std::net::SocketAddr;
-use std::sync::Arc;
+use azalea_client::{Account, Client, DefaultPlugins, start_ecs};
-use std::time::SystemTime;
-use async_tungstenite::tokio::{connect_async, ConnectStream};
-use async_tungstenite::tungstenite::Message;
-use async_tungstenite::WebSocketStream;
-use azalea_client::{Account, Client, DefaultPlugins, Event, start_ecs};
 use azalea_client::packet_handling::DeathEvent;
 use azalea_client::respawn::{perform_respawn, PerformRespawnEvent};
-use azalea_protocol::packets::game::ClientboundGamePacket;
 use azalea_protocol::packets::game::serverbound_client_information_packet::{ChatVisibility, ServerboundClientInformationPacket};
 use azalea_protocol::ServerAddress;
 use bevy_app::{App, Plugin, Update};
 use bevy_ecs::event::{EventReader, EventWriter};
 use bevy_ecs::prelude::IntoSystemConfigs;
-use chrono::DateTime;
+use log::{debug, error, info};
-use futures::{SinkExt, Stream, StreamExt};
-use log::{debug, error, info, Level};
-use regex::Regex;
-use tokio::select;
-use tokio::sync::broadcast::channel;
 use tokio::sync::mpsc;
-use tokio::sync::mpsc::Sender;
 use tokio_threadpool::ThreadPool;
 use url::Url;
-use common::message::{GatewayChatMessage, GatewayChatSource, GatewayPacketC2S, GatewayPacketS2C};
+use websocket::{ClientBuilder, Message, OwnedMessage};
+use websocket::websocket_base::result::WebSocketResult;
+use common::message::{GatewayChatMessage, GatewayPacketC2S, GatewayPacketS2C};
 use common::status::{DATA_API_VERSION, Status};
-use crate::bacon::handle_message;
 use crate::config::Config;
 
-pub mod bacon;
 pub mod config;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
-    simple_logger::init_with_level(Level::Info).unwrap();
+    simple_logger::init_with_env().unwrap();
 
     info!("Loading config");
 
@@ -55,7 +43,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     info!("Loading status from the API ({})...", config.api_status_url);
 
-    let status: Status = reqwest::get(config.api_status_url.clone()).await?.json().await?;
+    let status: Status = reqwest::get(config.api_status_url).await?.json().await?;
 
     debug!("{:?}", status);
 
@@ -66,66 +54,18 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     info!("Connecting to gateway uri {}", status.gateway_url.to_string());
 
-    let mut gateway_uri = status.gateway_url;
+    let mut client = ClientBuilder::new(status.gateway_url.as_str())?.connect(None)?;
-    if gateway_uri.scheme() == "http" {
-        gateway_uri.set_scheme("ws").unwrap();
-    } else if gateway_uri.scheme() == "https" {
-        gateway_uri.set_scheme("wss").unwrap();
-    }
 
-    let (mut ws_stream, _) = connect_async(&gateway_uri).await?;
+    // send the authentication packet, and then start listen
 
-    debug!("websocket connection opened - sending Authenticate");
+    let message = Message::text(serde_json::to_string(&GatewayPacketC2S::Authenticate {
-
-    ws_stream.send(Message::text(serde_json::to_string(&GatewayPacketC2S::Authenticate {
         token: config.token.clone(),
-        request_write_perms: true, // we *need* write perms for the relay
+        request_write_perms: true,
-    })?)).await?;
+    })?);
 
-    debug!("starting handshake loop (waiting for AuthenticationAccepted)");
+    client.send_message(&message)?;
 
-    loop {
+    //let (mut tx, mut rx) = client.split().unwrap();
-        let msg = ws_stream.next().await;
-
-        match msg {
-            Some(msg) => match msg? {
-                Message::Text(packet) => {
-                    debug!("recv gateway packet {}", packet);
-                    let packet: GatewayPacketS2C = serde_json::from_str(&packet)?;
-
-                    match packet {
-                        GatewayPacketS2C::AuthenticationAccepted { write_perms } => {
-                            info!("Gateway accepted our token.");
-
-                            if !write_perms {
-                                error!("Gateway server did not grant us write perms to the chat stream socket.");
-                                error!("This is REQUIRED for azalea-worker to function correctly.");
-                                error!("Check to ensure your token has `allow-write = true` set in the API config file.");
-                                error!("AuthenticationAccepted with write_perms:false");
-                                std::process::exit(1);
-                            }
-
-                            break;
-                        }
-                        GatewayPacketS2C::Disconnect { reason } => {
-                            error!("Disconnected by server: {:?}", reason);
-                            std::process::exit(1);
-                        }
-                        GatewayPacketS2C::Relayed { .. } => {} // ignore messages for now
-                    }
-                },
-                msg => {
-                    debug!("unknown message {:?}", msg);
-                }
-            },
-            None => {
-                debug!("didn't receive anything");
-                continue;
-            }
-        }
-    }
-
-    info!("Connected to gateway, starting the minecraft client");
 
     info!("Connecting to the Minecraft server...");
 
@@ -159,19 +99,6 @@ async fn main() -> Result<(), Box<dyn Error>> {
         allows_listing: true,
     }).await?;
 
-    loop {
-        select! {
-            msg = ws_stream.next() => handle_ws_message(msg, &mut client).await?,
-            e = rx.recv() => {
-                if let Some(e) = e {
-                    handle_packet(e, &config, &mut client, &mut ws_stream).await?
-                } else {
-                    std::process::exit(1);
-                }
-            }
-        }
-    }
-
     /*
     for msg in client.incoming_messages() {
         match msg {
@@ -215,7 +142,6 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
      */
 
-
     Ok(())
 }
 
@@ -238,146 +164,3 @@ fn auto_respawn(
         });
     }
 }
-
-async fn handle_ws_message(msg: Option<Result<Message, async_tungstenite::tungstenite::Error>>, client: &mut Client) -> Result<(), Box<dyn Error>> {
-    match msg {
-        Some(msg) => match msg? {
-            Message::Text(packet) => {
-                debug!("recv gateway packet {}", packet);
-                let packet: GatewayPacketS2C = serde_json::from_str(&packet)?;
-
-                match packet {
-                    GatewayPacketS2C::AuthenticationAccepted { .. } => {
-                        Ok(())
-                    },
-                    GatewayPacketS2C::Disconnect { reason } => {
-                        error!("Disconnected by server: {:?}", reason);
-                        std::process::exit(1);
-                    }
-                    GatewayPacketS2C::Relayed { msg } => {
-                        if matches!(msg.source, GatewayChatSource::Minecraft) { return Ok(()); }
-
-                        client.chat(&format!("{}: {}", msg.username, msg.message));
-
-                        Ok(())
-                    }
-                }
-            },
-            msg => {
-                debug!("unknown message {:?}", msg);
-                Ok(())
-            }
-        },
-        None => {
-            debug!("didn't receive anything");
-            Ok(())
-        }
-    }
-}
-
-async fn handle_packet(e: Event, config: &Config, client: &mut Client, ws_stream: &mut WebSocketStream<ConnectStream>) -> Result<(), Box<dyn Error>> {
-    match e {
-        Event::Init => {}
-        Event::Login => {}
-        Event::Chat(pkt) => {
-            if !pkt.content().starts_with("/skill") {
-                info!("<{} ({})> {}", pkt.username().unwrap_or("SYSTEM".to_string()), pkt.uuid().map(|u| u.to_string()).unwrap_or("SYSTEM".to_string()), pkt.message());
-                handle_message(pkt.clone(), client, config).await;
-
-                let re = Regex::new(r"@[a-z0-9_\-.]+:").unwrap();
-                if !(re.is_match(&pkt.content()) && pkt.uuid() == Some(config.server.uuid)) {
-                    info!("sending message");
-                    ws_stream.send(Message::Text(serde_json::to_string(&GatewayPacketC2S::Relay { msg: GatewayChatMessage {
-                        source: GatewayChatSource::Minecraft,
-                        username: pkt.username().unwrap_or("SYSTEM".to_string()),
-                        message: pkt.content(),
-                        timestamp: DateTime::from(SystemTime::now()),
-                    }})?)).await?;
-                }
-            }
-
-
-
-
-
-            /*
-
-            if pkt.content() == "!disconnect" {
-                if let Some(u) = pkt.uuid() {
-                    if !config.read().await.permissions.admin.uuid_members.contains(&u) {
-                        client.chat("Nice try. You need to be an 'admin' to do that.");
-                        continue;
-                    }
-                } else {
-                    client.chat("Nice try. You need to be an 'admin' to do that.");
-                    continue;
-                }
-                client.chat("Okay, disconnecting. Cya!");
-                client.disconnect();
-                return Err("Disconnected.".into());
-            }
-            if pkt.content() == "!reconnect" {
-                if let Some(u) = pkt.uuid() {
-                    if !config.read().await.permissions.admin.uuid_members.contains(&u) {
-                        client.chat("Nice try. You need to be an 'admin' to do that.");
-                        continue;
-                    }
-                } else {
-                    client.chat("Nice try. You need to be an 'admin' to do that.");
-                    continue;
-                }
-                client.chat("Okay, reconnecting. Cya!");
-                client.disconnect();
-                break;
-            }
-            if pkt.content() == "!help" {
-                client.chat("Hi, I'm CuberCore! I am owned by CoreCuber/@realcore.");
-                client.chat("I function as the chat relay for this server and also do other useful things.");
-                client.chat("My commands:");
-                client.chat("!sleep - Sleep in the nearest bed");
-                client.chat("!disconnect - Disconnect from the server (admin only)");
-                client.chat("!reconnect - Reconnect to the server (admin only)");
-                client.chat("!location - List all locations I know about");
-                client.chat("!location <location> - Get the coords of a location");
-            }
-            if pkt.content() == "!bot" {
-                client.chat("[iambot]");
-            }
-
-            if pkt.content().starts_with("!location") {
-                let content = pkt.content();
-                let split = content.split(' ').collect::<Vec<_>>();
-
-                if split.len() == 1 {
-                    client.chat(&format!("[bot response] Locations: {:?}", config.read().await.locations.keys().collect::<Vec<_>>()));
-                } else {
-                    let location = split[1];
-
-                    if let Some(coords) = config.read().await.locations.get(location) {
-                        client.chat(&format!("[bot response] Location '{}' is at {}", location, coords));
-                    } else {
-                        client.chat(&format!("[bot response] I don't know where '{}' is.", location));
-                    }
-                }
-            }
-
-             */
-        }
-        Event::Tick => {}
-        Event::Packet(p) => {
-            match p.as_ref() {
-                ClientboundGamePacket::Disconnect(_) => {
-                    info!("Disconnected, restarting");
-                    return Err("Disconnected".into());
-                }
-                _ => ()
-            }
-        }
-        Event::AddPlayer(_) => {}
-        Event::RemovePlayer(_) => {}
-        Event::UpdatePlayer(_) => {}
-        Event::Death(e) => {}
-        Event::KeepAlive(_) => {}
-    };
-    Ok(())
-}

websocket-worker/src/main.rs

@@ -9,7 +9,6 @@ use url::Url;
 use websocket::{ClientBuilder, Message, OwnedMessage, WebSocketError};
 use websocket::websocket_base::result::WebSocketResult;
 use common::message::{GatewayChatMessage, GatewayPacketC2S, GatewayPacketS2C};
-use common::message::GatewayChatSource::Discord;
 use common::status::{DATA_API_VERSION, Status};
 use crate::config::Config;
 
@@ -80,9 +79,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
                                 return Err("Disconnected by server")?;
                             }
                             GatewayPacketS2C::Relayed { msg } => {
-                                if msg.message.starts_with("/skill") { continue; } // fix chatspam problem
                                 info!("msg: {:?}", msg);
-                                if matches!(msg.source, Discord) { continue; }
                                 for wh in &config.websockets {
                                     tokio::spawn({
                                         let wh_clone = wh.clone();
@@ -117,12 +114,11 @@ async fn main() -> Result<(), Box<dyn Error>> {
 async fn send_webhook(msg: GatewayChatMessage, webhook: String) {
     let http = Http::new("");
     let wh = Webhook::from_url(&http, &webhook).await.unwrap();
-
     wh.execute(&http, false, |w| {
         w.content(msg.message)
             .username(&msg.username)
             .allowed_mentions(|am| am.parse(ParseValue::Users).parse(ParseValue::Roles))
-            .avatar_url(&format!("https://mc-heads.net/head/{}", msg.username.split(' ').next().unwrap()))
+            .avatar_url(&format!("https://mc-heads.net/head/{}", msg.username))
     }).await.unwrap();
     debug!("send job complete");
 }