tproom command

Author: Stivais

server/src/commands/command.rs

@@ -2,7 +2,7 @@ use crate::commands::string_reader::StringReader;
 use crate::{Player, PlayerExtension};
 use std::collections::HashMap;
 
-pub type CommandFunction<P> = fn(&mut StringReader, &mut Player<P>) -> anyhow::Result<()>;
+pub type CommandFunction<P> = Box<dyn for<'a> Fn(&'a mut StringReader<'a>, &mut Player<P>) -> anyhow::Result<()>>;
 
 pub struct Command<P: PlayerExtension> {
     pub literal: &'static str,
@@ -43,18 +43,17 @@ impl<P: PlayerExtension> CommandDispatcher<P> {
 
 #[macro_export]
 macro_rules! command {
-    // Syntax: literal, |first: Type, rest: Type,...| { body }
     ($lit:expr, | $first:ident : $first_ty:ty $(, $rest:ident : $ty:ty )* | $body:block) => {{
         server::commands::command::Command {
             literal: concat!("/", $lit),
-            callback: |reader: &mut StringReader, $first: $first_ty| -> anyhow::Result<()> {
+            callback: Box::new(|reader: &mut server::commands::string_reader::StringReader<'_>, $first: $first_ty| -> anyhow::Result<()> {
                 use server::commands::command_parse::CommandParse;
                 $(
                     let mut $rest: $ty = CommandParse::parse(reader)?;
                 )*
                 $body
                 Ok(())
-            }
+            })
         }
     }};
 }

server/src/commands/command_parse.rs

@@ -1,14 +1,36 @@
 use crate::commands::string_reader::StringReader;
+use anyhow::bail;
 use std::str::FromStr;
 
-pub trait CommandParse: Sized {
-    fn parse(reader: &mut StringReader) -> anyhow::Result<Self>;
+pub trait CommandParse<'a>: Sized {
+    fn parse(reader: &'a mut StringReader<'a>) -> anyhow::Result<Self>;
 }
 
-impl CommandParse for i32 {
-    fn parse(reader: &mut StringReader) -> anyhow::Result<Self> {
+impl<'a> CommandParse<'a> for i32 {
+    fn parse(reader: &'a mut StringReader<'a>) -> anyhow::Result<Self> {
         let str = reader.read_word();
         let int = Self::from_str(str)?;
         Ok(int)
     }
 }
+
+impl<'a> CommandParse<'a> for &'a str {
+    fn parse(reader: &'a mut StringReader<'a>) -> anyhow::Result<Self> {
+        let s = reader.read_word();
+        if s.is_empty() {
+            bail!("empty string")
+        }
+        Ok(s)
+    }
+}
+
+pub struct GreedyString<'a> {
+    pub str: &'a str
+}
+
+impl<'a> CommandParse<'a> for GreedyString<'a> {
+    fn parse(reader: &'a mut StringReader<'a>) -> anyhow::Result<Self> {
+        reader.skip_whitespace();
+        Ok(GreedyString { str: reader.remaining() })
+    }
+}

src/dungeon/dungeon.rs

@@ -9,16 +9,17 @@ use anyhow::bail;
 use glam::{ivec3, DVec3, IVec2};
 use server::block::block_parameter::Axis;
 use server::block::rotatable::Rotate;
+use server::commands::command_parse::GreedyString;
 use server::constants::Gamemode;
 use server::inventory::menu::OpenContainer;
 use server::network::binary::var_int::VarInt;
-use server::network::protocol::play::clientbound::{Chat, EntityProperties, PlayerAbilities};
+use server::network::protocol::play::clientbound::{Chat, EntityProperties, PlayerAbilities, PositionLook, Relative};
 use server::player::attribute::{Attribute, AttributeMap, AttributeModifier};
 use server::player::sidebar::Sidebar;
 use server::types::aabb::AABB;
 use server::types::chat_component::ChatComponent;
 use server::utils::hasher::deterministic_hasher::DeterministicHashMap;
-use server::{ClientId, GameProfile, Player, World, WorldExtension};
+use server::{command, ClientId, GameProfile, Player, World, WorldExtension};
 use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
 use std::rc::Rc;
@@ -202,6 +203,30 @@ impl WorldExtension for Dungeon {
         player.inventory.set_slot(43, Some(DungeonItem::AspectOfTheVoid));
         player.inventory.set_slot(44, Some(DungeonItem::SkyblockMenu));
         player.sync_inventory();
+
+        let cmd = command!("tproom", |player: &mut Player<DungeonPlayer>, room_name: GreedyString| {
+            let name = room_name.str;
+            for room_rc in player.world().rooms.iter() {
+                let room = room_rc.borrow();
+                if room.data.name.to_lowercase().contains(name) {
+                    for neighbour in room.neighbours() {
+                        let door = neighbour.door.borrow();
+                        player.write_packet(&PositionLook {
+                            x: door.x as f64 + 0.5,
+                            y: 69.0,
+                            z: door.z as f64 + 0.5,
+                            yaw: 0.0,
+                            pitch: 0.0,
+                            flags: Relative::Yaw | Relative::Pitch,
+                        });
+                    }
+                    return Ok(());
+                }
+            }
+            player.send_message(format!("no room with name containing {name}").as_str())
+        });
+        player.command_dispatcher_mut().register_command(cmd);
+
         player.flush_packets()
     }