Merge branch 'import_optimize' of https://github.com/0xnim/ferrumc into import_optimize

Author: 0xnim

.etc/example-config.toml

@@ -10,6 +10,8 @@ max_players = 100
 network_tick_rate = 30
 # World name to load
 world = "world"
+# Whether the server should validate players via the whitelist
+whitelist = false
 # Network compression threshold (can be negative). This decides how long a packet has to be before it is compressed.
 # Very small packets may actually increase in size when compressed, so setting it to 0 won't be perfect in all situations.
 # Set to -1 to disable compression.
@@ -34,3 +36,5 @@ map_size = 1_000
 cache_ttl = 60
 # How big the cache can be in kb.
 cache_capacity = 20_000
+
+whitelist = false

Cargo.toml

@@ -6,6 +6,7 @@
 # - Workspace lints
 # - Workspace dependencies.
 
+
 [workspace]
 resolver = "2"
 
@@ -104,6 +105,7 @@ ferrumc-utils = { path = "src/lib/utils" }
 ferrumc-world = { path = "src/lib/world" }
 
 
+
 # Asynchronous
 tokio = { version = "1.40.0", features = ["full"] }
 socket2 = "0.5.7"
@@ -114,12 +116,14 @@ async-trait = "0.1.82"
 tracing = "0.1.40"
 tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
 log = "0.4.22"
+console-subscriber = "0.4.1"
 
 # Concurrency/Parallelism
 parking_lot = "0.12.3"
 rayon = "1.10.0"
 
 # Network
+reqwest = { version = "0.12.9", features = ["json"] }
 
 # Error handling
 thiserror = "2.0.3"
@@ -136,6 +140,7 @@ serde_derive = "1.0.210"
 base64 = "0.22.1"
 bitcode = "0.6.3"
 bitcode_derive = "0.6.3"
+toml = "0.8.19"
 
 # Bit manipulation
 byteorder = "1.5.0"
@@ -145,6 +150,7 @@ hashbrown = "0.15.0"
 tinyvec = "1.8.0"
 dashmap = "6.1.0"
 uuid = { version = "1.1", features = ["v4", "v3", "serde"] }
+whirlwind = "0.1.1"
 
 # Macros
 lazy_static = "1.5.0"
@@ -180,6 +186,7 @@ colored = "2.1.0"
 # Misc
 deepsize = "0.2.0"
 page_size = "0.6.0"
+regex = "1.11.1"
 
 # I/O
 tempfile = "3.12.0"

README.md

@@ -72,7 +72,7 @@ our [Discord server](https://discord.gg/qT5J8EMjwk) for help or to discuss the p
       <h4>📝 Custom made network, NBT and Anvil encoding systems to allow for minimal I/O lag</h4>
    </li>
    <li>
-      <h4>💾 Multiple database options to finetune the server to your needs</h4>
+      <h4>💾 Crazy fast K/V database </h4>
       <i>32 render distance*</i>
       <img src="https://github.com/ferrumc-rs/ferrumc/blob/master/assets/README/chunk_loading.gif?raw=true" alt="Chunk Loading DEMO">
    </li>
@@ -94,7 +94,7 @@ our [Discord server](https://discord.gg/qT5J8EMjwk) for help or to discuss the p
         <h4>Optimizations</h4>
    </li>
     <li>
-        <h4>Plugin support (JVM currently, other languages will be considered later)</h4>
+        <h4>Plugin support (FFI currently, other languages will be considered later)</h4>
     </li>
 </ul>
 
@@ -148,9 +148,23 @@ cargo build --release
 
 ## 🖥️ Usage
 
+```plaintext
+Usage: ferrumc.exe [OPTIONS] [COMMAND]
+
+Commands:
+setup   Sets up the config
+import  Import the world data
+run     Start the server (default, if no command is given)
+help    Print this message or the help of the given subcommand(s)
+
+Options:
+--log <LOG>  [default: debug] [possible values: trace, debug, info, warn, error]
+-h, --help       Print help
+```
+
 1. Move the FerrumC binary (`ferrumc.exe` or `ferrumc` depending on the OS) to your desired server directory
 2. Open a terminal in that directory
-3. (Optional) Generate a config file: `./ferrumc --setup`
+3. (Optional) Generate a config file: `./ferrumc setup`
     - Edit the generated `config.toml` file to customize your server settings
 4. Import an existing world: Either copy your world files to the server directory or specify the path to the world files
    in the `config.toml` file. This should be the root directory of your world files, containing the `region` directory
@@ -218,10 +232,9 @@ with the vanilla server, but we do plan on implementing some sort of terrain gen
 
 ### Will there be plugins? And how?
 
-We do very much plan to have a plugin system and as of right now, our plan is to leverage the
-JVM to allow for plugins to be written in Kotlin, Java, or any other JVM language. We are also considering other
-languages
-such as Rust, JavaScript and possibly other native languages, but that is a fair way off for now.
+We do very much plan to have a plugin system and as of right now we are planning to use
+some kind of ffi (foreign function interface) to allow for plugins to be written in other languages.
+Not confirmed yet.
 
 ### What does 'FerrumC' mean?
 

scripts/new_packet.py

@@ -0,0 +1,64 @@
+import os.path
+
+incoming_template = """
+use crate::packets::IncomingPacket;
+use crate::NetResult;
+use ferrumc_macros::{packet, NetDecode};
+use ferrumc_state::ServerState;
+use std::sync::Arc;
+
+#[derive(NetDecode)]
+#[packet(packet_id = ++id++, state = "play")]
+pub struct ++name++ {
+}
+
+impl IncomingPacket for ++name++ {
+    async fn handle(self, conn_id: usize, state: Arc<ServerState>) -> NetResult<()> {
+        todo!()
+    }
+}
+"""
+
+outgoing_template = """
+use ferrumc_macros::{packet, NetEncode};\
+use std::io::Write;
+
+#[derive(NetEncode)]
+#[packet(packet_id = ++id++)]
+pub struct ++name++ {}
+"""
+
+
+def to_snake_case(string) -> str:
+    return string.lower().replace(" ", "_")
+
+
+def to_camel_case(string) -> str:
+    return string.title().replace(" ", "")
+
+
+packet_type_input = input("Incoming or outgoing packet? (i/o): ")
+packet_type = ""
+if packet_type_input == "i":
+    packet_type = "incoming"
+elif packet_type_input == "o":
+    packet_type = "outgoing"
+else:
+    print("Invalid input")
+    exit()
+
+packet_name = input("Packet name: ")
+packets_dir = os.path.join(os.path.join(os.path.dirname(__file__), ".."), "src/lib/net/src/packets")
+
+packet_id = input("Packet ID (formatted like 0x01): ")
+packet_id = packet_id[:-2] + packet_id[-2:].upper()
+
+with open(f"{packets_dir}/{packet_type}/{to_snake_case(packet_name)}.rs", "x") as f:
+    if packet_type == "incoming":
+        f.write(incoming_template.replace("++name++", to_camel_case(packet_name)).replace("++id++", packet_id))
+        with open(f"{packets_dir}/incoming/mod.rs", "a") as modfile:
+            modfile.write(f"\npub mod {to_snake_case(packet_name)};")
+    else:
+        f.write(outgoing_template.replace("++name++", to_camel_case(packet_name)).replace("++id++", packet_id))
+        with open(f"{packets_dir}/outgoing/mod.rs", "a") as modfile:
+            modfile.write(f"\npub mod {to_snake_case(packet_name)};")

src/bin/Cargo.toml

@@ -28,7 +28,7 @@ ferrumc-general-purpose = { workspace = true }
 ferrumc-state = { workspace = true }
 
 ctor = { workspace = true }
-parking_lot = { workspace = true }
+parking_lot = { workspace = true, features = ["deadlock_detection"] }
 tracing = { workspace = true }
 tokio = { workspace = true }
 rayon = { workspace = true }

src/bin/src/cli.rs

@@ -6,7 +6,7 @@ pub struct CLIArgs {
     #[command(subcommand)]
     pub command: Option<Command>,
     #[clap(long)]
-    #[arg(value_enum, default_value_t = LogLevel(Level::TRACE))]
+    #[arg(value_enum, default_value_t = LogLevel(Level::DEBUG))]
     pub log: LogLevel,
 }
 

src/bin/src/main.rs

@@ -5,11 +5,15 @@ extern crate core;
 use crate::errors::BinaryError;
 use clap::Parser;
 use ferrumc_config::statics::get_global_config;
+use ferrumc_config::whitelist::create_whitelist;
+use ferrumc_core::chunks::chunk_receiver::ChunkReceiver;
 use ferrumc_ecs::Universe;
 use ferrumc_general_purpose::paths::get_root_path;
+use ferrumc_net::connection::StreamWriter;
 use ferrumc_net::server::create_server_listener;
 use ferrumc_state::ServerState;
 use ferrumc_world::World;
+use std::hash::{Hash, Hasher};
 use std::sync::Arc;
 use systems::definition;
 use tracing::{error, info};
@@ -27,6 +31,19 @@ async fn main() {
     let cli_args = CLIArgs::parse();
     ferrumc_logging::init_logging(cli_args.log.into());
 
+    check_deadlocks();
+
+    {
+        let mut hasher = std::collections::hash_map::DefaultHasher::new();
+        std::any::TypeId::of::<ChunkReceiver>().hash(&mut hasher);
+        let digest = hasher.finish();
+        println!("ChunkReceiver: {:X}", digest);
+        let mut hasher = std::collections::hash_map::DefaultHasher::new();
+        std::any::TypeId::of::<StreamWriter>().hash(&mut hasher);
+        let digest = hasher.finish();
+        println!("StreamWriter: {:X}", digest);
+    }
+
     match cli_args.command {
         Some(Command::Setup) => {
             info!("Starting setup...");
@@ -59,10 +76,11 @@ async fn main() {
 async fn entry() -> Result<()> {
     let state = create_state().await?;
     let global_state = Arc::new(state);
+    create_whitelist().await;
 
     let all_system_handles = tokio::spawn(definition::start_all_systems(global_state.clone()));
 
-    // Start the systems and wait until all of them are done
+    //Start the systems and wait until all of them are done
     all_system_handles.await??;
 
     // Stop all systems
@@ -107,3 +125,28 @@ async fn create_state() -> Result<ServerState> {
         world: World::new().await,
     })
 }
+fn check_deadlocks() {
+    {
+        use parking_lot::deadlock;
+        use std::thread;
+        use std::time::Duration;
+
+        // Create a background thread which checks for deadlocks every 10s
+        thread::spawn(move || loop {
+            thread::sleep(Duration::from_secs(10));
+            let deadlocks = deadlock::check_deadlock();
+            if deadlocks.is_empty() {
+                continue;
+            }
+
+            println!("{} deadlocks detected", deadlocks.len());
+            for (i, threads) in deadlocks.iter().enumerate() {
+                println!("Deadlock #{}", i);
+                for t in threads {
+                    println!("Thread Id {:#?}", t.thread_id());
+                    println!("{:#?}", t.backtrace());
+                }
+            }
+        });
+    }
+}

src/bin/src/packet_handlers/animations.rs

@@ -0,0 +1,21 @@
+use ferrumc_macros::event_handler;
+use ferrumc_net::errors::NetError;
+use ferrumc_net::packets::outgoing::entity_animation::EntityAnimationEvent;
+use ferrumc_net::utils::broadcast::{broadcast, BroadcastOptions};
+use ferrumc_state::GlobalState;
+
+#[event_handler]
+async fn entity_animation(
+    event: EntityAnimationEvent,
+    state: GlobalState,
+) -> Result<EntityAnimationEvent, NetError> {
+    //TODO change this global broadcast to a broadcast that affects only players in the view distance
+    //      of the player doing it, but as long as we still cant see other players, this will be fine.
+    broadcast(
+        &event.packet,
+        &state,
+        BroadcastOptions::default().except([event.entity]),
+    )
+    .await?;
+    Ok(event)
+}

src/bin/src/packet_handlers/login_process.rs

@@ -1,3 +1,5 @@
+use ferrumc_config::statics::{get_global_config, get_whitelist};
+use ferrumc_core::chunks::chunk_receiver::ChunkReceiver;
 use ferrumc_core::identity::player_identity::PlayerIdentity;
 use ferrumc_core::transform::grounded::OnGround;
 use ferrumc_core::transform::position::Position;
@@ -15,6 +17,7 @@ use ferrumc_net::packets::outgoing::client_bound_known_packs::ClientBoundKnownPa
 use ferrumc_net::packets::outgoing::finish_configuration::FinishConfigurationPacket;
 use ferrumc_net::packets::outgoing::game_event::GameEventPacket;
 use ferrumc_net::packets::outgoing::keep_alive::OutgoingKeepAlivePacket;
+use ferrumc_net::packets::outgoing::login_disconnect::LoginDisconnectPacket;
 use ferrumc_net::packets::outgoing::login_play::LoginPlayPacket;
 use ferrumc_net::packets::outgoing::login_success::LoginSuccessPacket;
 use ferrumc_net::packets::outgoing::registry_data::get_registry_packets;
@@ -31,23 +34,47 @@ async fn handle_login_start(
     login_start_event: LoginStartEvent,
     state: GlobalState,
 ) -> Result<LoginStartEvent, NetError> {
-    debug!("Handling login start event");
-
     let uuid = login_start_event.login_start_packet.uuid;
     let username = login_start_event.login_start_packet.username.as_str();
-    debug!("Received login start from user with username {}", username);
+    let player_identity = PlayerIdentity::new(username.to_string(), uuid);
+    debug!("Handling login start event for user: {username}, uuid: {uuid}");
 
     // Add the player identity component to the ECS for the entity.
-    state.universe.add_component::<PlayerIdentity>(
-        login_start_event.conn_id,
-        PlayerIdentity::new(username.to_string(), uuid),
-    )?;
+    state
+        .universe
+        .add_component::<PlayerIdentity>(
+            login_start_event.conn_id,
+            PlayerIdentity::new(username.to_string(), uuid),
+        )?
+        .add_component::<ChunkReceiver>(login_start_event.conn_id, ChunkReceiver::default())?;
 
     //Send a Login Success Response to further the login sequence
     let mut writer = state
         .universe
         .get_mut::<StreamWriter>(login_start_event.conn_id)?;
 
+    if get_global_config().whitelist {
+        let whitelist = get_whitelist();
+
+        if whitelist.get(&uuid).is_none() {
+            writer
+                .send_packet(
+                    &LoginDisconnectPacket::new(
+                        "{\"translate\":\"multiplayer.disconnect.not_whitelisted\"}",
+                    ),
+                    &NetEncodeOpts::WithLength,
+                )
+                .await?;
+            return Ok(login_start_event);
+        }
+    }
+
+    // Add the player identity component to the ECS for the entity.
+    state
+        .universe
+        .add_component::<PlayerIdentity>(login_start_event.conn_id, player_identity)?;
+
+    //Send a Login Success Response to further the login sequence
     writer
         .send_packet(
             &LoginSuccessPacket::new(uuid, username),
@@ -168,6 +195,12 @@ async fn handle_ack_finish_configuration(
             &NetEncodeOpts::WithLength,
         )
         .await?;
+
+    let pos = state.universe.get_mut::<Position>(conn_id)?;
+    let mut chunk_recv = state.universe.get_mut::<ChunkReceiver>(conn_id)?;
+    chunk_recv.last_chunk = Some((pos.x as i32, pos.z as i32, String::from("overworld")));
+    chunk_recv.calculate_chunks().await;
+
     send_keep_alive(conn_id, state, &mut writer).await?;
 
     Ok(ack_finish_configuration_event)

src/bin/src/packet_handlers/mod.rs

@@ -1,3 +1,4 @@
+mod animations;
 mod handshake;
 mod login_process;
 mod tick_handler;