Merge pull request #9 from Big-Dungeons/packets

Packet macro and dungeon map

Author: SubAt0m1c

.github/workflows/build.yml

@@ -0,0 +1,77 @@
+name: Build
+
+on:
+  workflow_call:
+    inputs:
+      upload_artifacts:
+        required: false
+        type: boolean
+        default: true
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            ext: ""
+          - os: macos-latest
+            ext: ""
+          - os: windows-latest
+            ext: ".exe"
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Get ClearData Room Data
+        uses: actions/checkout@v4
+        with:
+          repository: Big-Dungeons/ClearData
+          ref: main
+          path: ClearData
+
+      - name: Copy room_data into project
+        shell: bash
+        run: |
+          mkdir -p src/room_data
+          cp -r ClearData/room_data/* src/room_data/
+
+      - name: Extract version from Cargo.toml
+        id: get_version
+        shell: bash
+        run: |
+          version=$(grep '^version =' Cargo.toml | head -n1 | cut -d '"' -f2)
+          echo "version=$version" >> $GITHUB_OUTPUT
+
+      - name: Cargo Cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-
+
+      - name: Build
+        run: cargo build --release --verbose
+
+      - name: Run tests
+        run: cargo test --verbose
+
+      - name: Prepare dist + OS-named binary
+        shell: bash
+        run: |
+          version=$(grep '^version =' Cargo.toml | head -n1 | cut -d '"' -f2)
+          mkdir -p dist
+          cp target/release/RustClear${{ matrix.ext }} \
+             "dist/RustClear-v${{ steps.get_version.outputs.version }}-${{ matrix.os }}${{ matrix.ext }}"
+
+      - name: Upload build artifact
+        if: ${{ inputs.upload_artifacts }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: RustClear-v${{ steps.get_version.outputs.version }}-${{ matrix.os }}
+          path: dist/*

.github/workflows/release.yml

@@ -0,0 +1,37 @@
+name: Release
+
+on:
+  workflow_dispatch:
+
+jobs:
+  build:
+    uses: ./.github/workflows/build.yml
+
+  release:
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Download Artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: ./dist
+
+      - name: Extract version from Cargo.toml
+        id: get_version
+        shell: bash
+        run: |
+          version=$(grep '^version =' Cargo.toml | head -n1 | cut -d '"' -f2)
+          echo "version=$version" >> $GITHUB_OUTPUT
+
+      - name: Generate Release
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: v${{ steps.get_version.outputs.version }}
+          name: Release v${{ steps.get_version.outputs.version }}
+          draft: true
+          files: ./dist/**
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/rust.yml

@@ -2,56 +2,15 @@ name: Rust
 
 on:
   push:
-    branches: [ "main", "packets", "bloom" ]
+    branches:
+      - "*"
   pull_request:
-    branches: [ "main", "packets", "bloom" ]
+    branches:
+      - "*"
 
 env:
   CARGO_TERM_COLOR: always
 
 jobs:
   build:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Get ClearData Room Data
-      uses: actions/checkout@v4
-      with: 
-        repository: Big-Dungeons/ClearData
-        ref: main
-        path: ClearData
-
-    - name: copy room_data into project
-      shell: bash
-      run: |
-        mkdir =p src/room_data
-        cp -r ClearData/room_data/* src/room_data/
-        
-
-    - name: Cargo Cache
-      uses: actions/cache@v4
-      with:          
-        path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-        key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-        restore-keys: |
-          ${{ runner.os }}-cargo-
-    
-    - name: Build
-      run: cargo build --release --verbose
-    - name: Run tests
-      run: cargo test --verbose
-
-    - name: Upload build artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: RustClear-${{ matrix.os }}
-        path: |
-          target/release/RustClear${{ matrix.os == 'windows-latest' && '.exe' || '' }}
+    uses: ./.github/workflows/build.yml

Cargo.lock

@@ -7,7 +7,6 @@ edition = "2024"
 bytes = "1.10.1"
 tokio = { version = "1.45.1", features = ["rt", "rt-multi-thread", "macros", "net", "io-util", "sync", "time"] }
 anyhow = "1.0.98"
-async-trait = "0.1.88"
 serde_json = "1.0.140"
 serde = { version = "1.0.219", features = ["derive"] }
 uuid = { version = "1.17.0", features = ["v4"] }
@@ -16,5 +15,13 @@ indoc = "2.0.6"
 include_dir = "0.7.4"
 blocks = { path = "crates/macros" }
 chrono = "0.4.41"
+rand_chacha = "0.9.0"
 base64 = "0.22.1"
 once_cell = "1.21.3"
+
+[profile.dev.package."*"]
+opt-level = 3
+
+[profile.release]
+codegen-units = 1
+lto = "thin"

Cargo.toml

@@ -1,7 +1,29 @@
+mod packet_serializable;
+mod packet_deserializable;
+
+use crate::packet_deserializable::packet_deserializable_macro;
+use crate::packet_serializable::packet_serializable_macro;
 use proc_macro::TokenStream;
 use quote::quote;
 use syn::{parse_macro_input, DeriveInput, Fields, Ident, ItemEnum};
 
+#[proc_macro]
+pub fn packet_serializable(input: TokenStream) -> TokenStream {
+    packet_serializable_macro(input)
+}
+
+#[proc_macro]
+pub fn packet_deserializable(input: TokenStream) -> TokenStream {
+    packet_deserializable_macro(input)
+}
+
+
+// todo: new file for block stuff
+// at that point im redoing the macro
+// because it is really annoying if a block has a niche metadata serializations
+// and i don't want to have a bunch of direction enum copies,
+// also want to be able to specify vanilla block toughness
+
 type TokenStream2 = proc_macro2::TokenStream;
 
 ///

crates/macros/src/lib.rs

@@ -0,0 +1,61 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::Fields::Unit;
+use syn::{parse_macro_input, Item};
+
+pub fn packet_deserializable_macro(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as Item);
+    match input {
+        Item::Struct(ref item_struct) => {
+            let name = &item_struct.ident;
+            let fields = item_struct.fields.iter().map(|field| {
+                let ident = &field.ident;
+                quote! { #ident: crate::net::packets::packet_deserialize::PacketDeserializable::read(buffer)?, }
+            });
+            quote! {
+                #input
+
+                impl crate::net::packets::packet_deserialize::PacketDeserializable for #name {
+                   fn read(buffer: &mut bytes::BytesMut) -> anyhow::Result<Self> {
+                        Ok(Self {
+                            #(#fields)*
+                        })
+                    }
+                }
+            }
+        }
+        Item::Enum(ref item_enum) => {
+            let name = &item_enum.ident;
+            let variants = item_enum.variants.iter().enumerate().map(|(index, variant)| {
+                if let Unit = variant.fields {
+                    let index = index as i8;
+                    let indent = &variant.ident;
+                    quote! {
+                        #index => Ok(#name::#indent),
+                    }
+                } else {
+                    return quote! {
+                        compile_error!("packet_deserializable doesn't support enums with fields");
+                    }.into()
+                }
+            });
+            quote! {
+                #input
+
+                impl crate::net::packets::packet_deserialize::PacketDeserializable for #name {
+                   fn read(buffer: &mut bytes::BytesMut) -> anyhow::Result<Self> {
+                        let id: i8 = crate::net::packets::packet_deserialize::PacketDeserializable::read(buffer)?;
+                        match id {
+                            #(#variants)*
+                            _ => Err(anyhow::anyhow!("Invalid id ({}) for enum {}", id, stringify!(#name)))
+                        }
+                    }
+                }
+            }
+        }
+        _ => {
+            syn::Error::new_spanned(input, "packet_deserializable only supports structs and enums")
+                .into_compile_error()
+        }
+    }.into()
+}