bevy 1.0.0

data/ext/bevy/src/ruby_system.rs

@@ -0,0 +1,122 @@
+use bevy_ruby::system::{ScheduleLabel, SystemDescriptor};
+use magnus::{function, method, prelude::*, Error, RModule, Ruby, Symbol};
+use std::cell::RefCell;
+
+#[magnus::wrap(class = "Bevy::SystemDescriptor", free_immediately, size)]
+pub struct RubySystemDescriptor {
+    inner: RefCell<SystemDescriptor>,
+}
+
+impl RubySystemDescriptor {
+    fn new(schedule: Symbol) -> Result<Self, Error> {
+        let ruby = Ruby::get().unwrap();
+        let schedule_str = schedule.name().map_err(|e| {
+            Error::new(ruby.exception_runtime_error(), format!("Invalid schedule symbol: {}", e))
+        })?;
+        let label = ScheduleLabel::from_str(&schedule_str).map_err(|e| {
+            Error::new(ruby.exception_runtime_error(), e.to_string())
+        })?;
+        Ok(Self {
+            inner: RefCell::new(SystemDescriptor::new(label)),
+        })
+    }
+
+    fn with_param(&self, param_type: String) -> Self {
+        let inner = self.inner.borrow();
+        let new_descriptor = inner.clone().with_param(&param_type);
+        Self {
+            inner: RefCell::new(new_descriptor),
+        }
+    }
+
+    fn schedule(&self) -> String {
+        let inner = self.inner.borrow();
+        match inner.schedule {
+            ScheduleLabel::Startup => "startup".to_string(),
+            ScheduleLabel::Update => "update".to_string(),
+            ScheduleLabel::FixedUpdate => "fixed_update".to_string(),
+            ScheduleLabel::PostUpdate => "post_update".to_string(),
+        }
+    }
+
+    fn param_types(&self) -> Vec<String> {
+        self.inner.borrow().param_types.clone()
+    }
+
+    #[allow(dead_code)]
+    pub fn inner(&self) -> SystemDescriptor {
+        self.inner.borrow().clone()
+    }
+}
+
+unsafe impl Send for RubySystemDescriptor {}
+
+#[magnus::wrap(class = "Bevy::ScheduleLabel", free_immediately, size)]
+pub struct RubyScheduleLabel {
+    inner: ScheduleLabel,
+}
+
+impl RubyScheduleLabel {
+    fn startup() -> Self {
+        Self { inner: ScheduleLabel::Startup }
+    }
+
+    fn update() -> Self {
+        Self { inner: ScheduleLabel::Update }
+    }
+
+    fn fixed_update() -> Self {
+        Self { inner: ScheduleLabel::FixedUpdate }
+    }
+
+    fn post_update() -> Self {
+        Self { inner: ScheduleLabel::PostUpdate }
+    }
+
+    fn from_string(s: String) -> Result<Self, Error> {
+        let ruby = Ruby::get().unwrap();
+        let label = ScheduleLabel::from_str(&s).map_err(|e| {
+            Error::new(ruby.exception_runtime_error(), e.to_string())
+        })?;
+        Ok(Self { inner: label })
+    }
+
+    fn to_s(&self) -> String {
+        match self.inner {
+            ScheduleLabel::Startup => "startup".to_string(),
+            ScheduleLabel::Update => "update".to_string(),
+            ScheduleLabel::FixedUpdate => "fixed_update".to_string(),
+            ScheduleLabel::PostUpdate => "post_update".to_string(),
+        }
+    }
+
+    fn eq(&self, other: &RubyScheduleLabel) -> bool {
+        self.inner == other.inner
+    }
+
+    #[allow(dead_code)]
+    pub fn inner(&self) -> ScheduleLabel {
+        self.inner
+    }
+}
+
+unsafe impl Send for RubyScheduleLabel {}
+
+pub fn define(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let descriptor_class = module.define_class("SystemDescriptor", ruby.class_object())?;
+    descriptor_class.define_singleton_method("new", function!(RubySystemDescriptor::new, 1))?;
+    descriptor_class.define_method("with_param", method!(RubySystemDescriptor::with_param, 1))?;
+    descriptor_class.define_method("schedule", method!(RubySystemDescriptor::schedule, 0))?;
+    descriptor_class.define_method("param_types", method!(RubySystemDescriptor::param_types, 0))?;
+
+    let label_class = module.define_class("ScheduleLabel", ruby.class_object())?;
+    label_class.define_singleton_method("startup", function!(RubyScheduleLabel::startup, 0))?;
+    label_class.define_singleton_method("update", function!(RubyScheduleLabel::update, 0))?;
+    label_class.define_singleton_method("fixed_update", function!(RubyScheduleLabel::fixed_update, 0))?;
+    label_class.define_singleton_method("post_update", function!(RubyScheduleLabel::post_update, 0))?;
+    label_class.define_singleton_method("from_string", function!(RubyScheduleLabel::from_string, 1))?;
+    label_class.define_method("to_s", method!(RubyScheduleLabel::to_s, 0))?;
+    label_class.define_method("==", method!(RubyScheduleLabel::eq, 1))?;
+
+    Ok(())
+}

data/ext/bevy/src/ruby_world.rs

@@ -0,0 +1,107 @@
+use bevy_ruby::WorldWrapper;
+use magnus::{function, method, prelude::*, Error, RArray, RModule, Ruby};
+use std::cell::RefCell;
+
+use crate::ruby_component::RubyComponent;
+use crate::ruby_entity::RubyEntity;
+
+#[magnus::wrap(class = "Bevy::World", free_immediately, size)]
+pub struct RubyWorld {
+    inner: RefCell<WorldWrapper>,
+}
+
+impl RubyWorld {
+    pub fn new() -> Self {
+        Self {
+            inner: RefCell::new(WorldWrapper::new()),
+        }
+    }
+
+    pub fn from_wrapper(wrapper: WorldWrapper) -> Self {
+        Self {
+            inner: RefCell::new(wrapper),
+        }
+    }
+
+    fn spawn(&self) -> RubyEntity {
+        let entity = self.inner.borrow().spawn();
+        RubyEntity::new(entity)
+    }
+
+    fn spawn_with(&self, components: RArray) -> Result<RubyEntity, Error> {
+        let mut component_list = Vec::new();
+
+        for item in components.into_iter() {
+            let component = <&RubyComponent>::try_convert(item)?;
+            component_list.push(component.inner());
+        }
+
+        let entity = self.inner.borrow().spawn_with_components(component_list);
+        Ok(RubyEntity::new(entity))
+    }
+
+    fn entity_exists(&self, entity: &RubyEntity) -> bool {
+        self.inner.borrow().entity_exists(entity.inner())
+    }
+
+    fn despawn(&self, entity: &RubyEntity) -> Result<(), Error> {
+        self.inner
+            .borrow()
+            .despawn(entity.inner())
+            .map_err(|e| Error::new(Ruby::get().unwrap().exception_runtime_error(), e.to_string()))
+    }
+
+    fn insert(&self, entity: &RubyEntity, component: &RubyComponent) -> Result<(), Error> {
+        self.inner
+            .borrow()
+            .insert_component(entity.inner(), component.inner())
+            .map_err(|e| Error::new(Ruby::get().unwrap().exception_runtime_error(), e.to_string()))
+    }
+
+    fn get(&self, entity: &RubyEntity, type_name: String) -> Result<RubyComponent, Error> {
+        self.inner
+            .borrow()
+            .get_component(entity.inner(), &type_name)
+            .map(RubyComponent::from_dynamic)
+            .map_err(|e| Error::new(Ruby::get().unwrap().exception_runtime_error(), e.to_string()))
+    }
+
+    fn has_component(&self, entity: &RubyEntity, type_name: String) -> bool {
+        self.inner.borrow().has_component(entity.inner(), &type_name)
+    }
+
+    fn query(&self, type_names: RArray) -> Result<RArray, Error> {
+        let ruby = Ruby::get().unwrap();
+        let mut names: Vec<String> = Vec::new();
+
+        for item in type_names.into_iter() {
+            names.push(String::try_convert(item)?);
+        }
+
+        let name_refs: Vec<&str> = names.iter().map(|s| s.as_str()).collect();
+        let entities = self.inner.borrow().query_entities_with(&name_refs);
+
+        let result = ruby.ary_new();
+        for entity in entities {
+            result.push(RubyEntity::new(entity))?;
+        }
+
+        Ok(result)
+    }
+}
+
+unsafe impl Send for RubyWorld {}
+
+pub fn define(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("World", ruby.class_object())?;
+    class.define_singleton_method("new", function!(RubyWorld::new, 0))?;
+    class.define_method("spawn", method!(RubyWorld::spawn, 0))?;
+    class.define_method("spawn_with", method!(RubyWorld::spawn_with, 1))?;
+    class.define_method("entity_exists?", method!(RubyWorld::entity_exists, 1))?;
+    class.define_method("despawn_native", method!(RubyWorld::despawn, 1))?;
+    class.define_method("insert", method!(RubyWorld::insert, 2))?;
+    class.define_method("get", method!(RubyWorld::get, 2))?;
+    class.define_method("has_component?", method!(RubyWorld::has_component, 2))?;
+    class.define_method("query", method!(RubyWorld::query, 1))?;
+    Ok(())
+}