feat: extract bigworlds-core

Author: adamsky

Cargo.toml

@@ -2,10 +2,11 @@
 resolver = "2"
 members = [
     "bigworlds",
+    "bigworlds-core", 
     "bigworlds-cli",
     "clients/grpc-client",
     "examples/*/viewers/*",
-    "examples/*/behaviors/*",
+    "examples/*/behaviors/*", 
 ]
 
 exclude = [

bigworlds-cli/Cargo.toml

@@ -16,7 +16,6 @@ path = "src/main.rs"
 [features]
 default = ["ws_client"]
 ws_client = ["bigworlds/ws_transport"]
-archive = ["bigworlds/archive"]
 msgpack = ["bigworlds/msgpack_encoding"]
 
 [dependencies]

bigworlds-cli/src/interactive/mod.rs

@@ -20,7 +20,7 @@ use tokio_util::sync::CancellationToken;
 use uuid::Uuid;
 
 use bigworlds::client::r#async::AsyncClient;
-use bigworlds::query;
+use bigworlds::{query, Query};
 
 use crate::interactive::config::{Config, CONFIG_FILE};
 
@@ -323,6 +323,15 @@ pub async fn start(
                                         .inspect_err(|e| error!("{}", e));
                                 }
                             }
+                            "count" => {
+                                let prod = client
+                                    .query(Query {
+                                        mappings: vec![query::Map::Var("position".to_owned())],
+                                        ..Default::default()
+                                    })
+                                    .await?;
+                                println!("current entity count: {}", prod.to_vec().len());
+                            }
                             // Write an uncompressed snapshot to disk.
                             "snap" => {
                                 if args.contains(" ") {

bigworlds-core/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+name = "bigworlds-core"
+version = "0.1.1"
+edition = "2024"
+
+[features]
+# use fixed-size string ids (23 chars long)
+small_stringid = []
+# use fixed-size string ids (10 chars long)
+tiny_stringid = []
+# use 64 bit integers and floats instead of default 32 bit
+big_nums = []
+
+[dependencies]
+serde = "1"
+serde_repr = "0.1"
+serde_json = { version = "1" }
+
+uuid = { version = "1", features = ["v4", "serde"] }
+fnv = "1"
+
+thiserror = "1"
+
+rkyv = { version = "0.8", features = [
+  "uuid-1",
+  "smallvec-1",
+  "arrayvec-0_7",
+], optional = true }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+uuid = { version = "1.13.1", default-features = false, features = ["js"] }
+wasm-bindgen = "0.2.101"

bigworlds/src/address.rs renamed to bigworlds-core/src/address.rs

@@ -5,16 +5,17 @@ use std::str::FromStr;
 
 use serde::{Deserialize, Serialize};
 
-use crate::entity::StorageIndex;
+use crate::StorageIndex;
 use crate::error::{Error, Result};
-use crate::{CompName, EntityName, VarName, VarType};
+use crate::var::VarType;
+use crate::{CompName, EntityName, VarName};
 
 pub const SEPARATOR_SYMBOL: &'static str = ".";
 
 /// Entity-scope address that can also handle component-scope locality.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 #[cfg_attr(
-    feature = "archive",
+    feature = "rkyv",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
 pub struct ShortLocalAddress {
@@ -60,7 +61,7 @@ impl ShortLocalAddress {
                 var_name: s.to_owned(),
             })
         } else {
-            Err(Error::InvalidData("".to_owned()))
+            Err(Error::Other("".to_owned()))
         }
     }
 
@@ -140,10 +141,10 @@ impl ShortLocalAddress {
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
 #[cfg_attr(feature = "small_stringid", derive(Copy))]
 #[cfg_attr(
-    feature = "archive",
+    feature = "rkyv",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
-#[cfg_attr(feature = "archive", rkyv(derive(Hash, PartialEq, Eq)))]
+#[cfg_attr(feature = "rkyv", rkyv(derive(Hash, PartialEq, Eq)))]
 pub struct LocalAddress {
     pub comp: CompName,
     pub var_type: VarType,
@@ -193,10 +194,10 @@ impl LocalAddress {
 /// Globally unique reference to simulation variable.
 #[derive(Debug, Hash, Eq, PartialEq, Clone, Serialize, Deserialize)]
 #[cfg_attr(
-    feature = "archive",
+    feature = "rkyv",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
-#[cfg_attr(feature = "archive", rkyv(derive(Hash, PartialEq, Eq)))]
+#[cfg_attr(feature = "rkyv", rkyv(derive(Hash, PartialEq, Eq)))]
 pub struct Address {
     pub entity: EntityName,
     pub comp: CompName,
@@ -227,7 +228,7 @@ impl FromStr for Address {
     fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
         let split = s.split(SEPARATOR_SYMBOL).collect::<Vec<&str>>();
         if split.len() != 4 {
-            return Err(Error::FailedCreatingAddress(s.to_string()));
+            return Err(Error::InvalidAddress(s.to_string()));
         }
         Ok(Address {
             entity: split[0].to_owned(),
@@ -265,7 +266,7 @@ impl Address {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[cfg_attr(feature = "small_stringid", derive(Copy))]
 #[cfg_attr(
-    feature = "archive",
+    feature = "rkyv",
     derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)
 )]
 pub struct PartialAddress {
@@ -298,7 +299,7 @@ impl FromStr for PartialAddress {
                 var_name: split[2].to_owned(),
             })
         } else {
-            Err(Error::FailedCreatingAddress(s.to_string()))
+            Err(Error::InvalidPartialAddress(s.to_string()))
         }
     }
 }

bigworlds-core/src/error.rs

@@ -0,0 +1,68 @@
+use thiserror::Error;
+
+pub type Result<T> = core::result::Result<T, Error>;
+
+/// Enumeration of all possible errors.
+#[derive(Error, Clone, Debug, Serialize, Deserialize)]
+pub enum Error {
+    #[error("parsing error: {0}")]
+    ParsingError(String),
+    #[error("failed parsing int: {0}")]
+    ParseIntError(String),
+    #[error("failed parsing float: {0}")]
+    ParseFloatError(String),
+    #[error("failed parsing bool: {0}")]
+    ParseBoolError(String),
+
+    #[error("invalid var type: {0}")]
+    InvalidVarType(String),
+    #[error("failed creating var: {0}")]
+    FailedCreatingVar(String),
+
+    #[error("invalid address: {0}")]
+    InvalidAddress(String),
+    #[error("invalid partial address: {0}")]
+    InvalidPartialAddress(String),
+    #[error("invalid local address: {0}")]
+    InvalidLocalAddress(String),
+
+    #[error("failed conversion: {0}")]
+    FailedConversion(String),
+
+    #[error("serde json error: {0}")]
+    SerdeJsonError(String),
+
+    #[error("other: {0}")]
+    Other(String),
+}
+
+#[cfg(feature = "rkyv")]
+impl From<rkyv::rancor::Error> for Error {
+    fn from(e: rkyv::rancor::Error) -> Self {
+        Self::RkyvError(e.to_string())
+    }
+}
+
+impl From<serde_json::Error> for Error {
+    fn from(e: serde_json::Error) -> Self {
+        Self::SerdeJsonError(e.to_string())
+    }
+}
+
+impl From<std::num::ParseFloatError> for Error {
+    fn from(e: std::num::ParseFloatError) -> Self {
+        Self::ParseFloatError(e.to_string())
+    }
+}
+
+impl From<std::num::ParseIntError> for Error {
+    fn from(e: std::num::ParseIntError) -> Self {
+        Self::ParseIntError(e.to_string())
+    }
+}
+
+impl From<std::str::ParseBoolError> for Error {
+    fn from(e: std::str::ParseBoolError) -> Self {
+        Self::ParseBoolError(e.to_string())
+    }
+}

bigworlds-core/src/lib.rs

@@ -0,0 +1,43 @@
+// NOTE: extern crate syntax is obsolete, but still provides global macro
+// imports.
+#[macro_use]
+extern crate serde;
+// #[macro_use]
+// extern crate log;
+
+pub mod address;
+pub mod error;
+pub mod query;
+pub mod var;
+
+pub mod time;
+
+pub type StorageIndex = (CompName, VarName);
+
+/// Floating point numer type used throughout the library.
+#[cfg(feature = "big_nums")]
+pub type Float = f64;
+/// Floating point numer type used throughout the library.
+#[cfg(not(feature = "big_nums"))]
+pub type Float = f32;
+
+/// Integer number type used throughout the library.
+#[cfg(feature = "big_nums")]
+pub type Int = i64;
+/// Integer number type used throughout the library.
+#[cfg(not(feature = "big_nums"))]
+pub type Int = i32;
+
+/// Entity string identifier.
+pub type EntityName = String;
+/// Entity prefab string identifier.
+pub type PrefabName = String;
+/// Component string identifier.
+pub type CompName = String;
+/// Variable string identifier.
+pub type VarName = String;
+/// Event string identifier.
+pub type EventName = String;
+
+/// Entity unique integer identifier.
+pub type EntityId = u32;