Update source files

crates/borders-core/src/app.rs

@@ -0,0 +1,146 @@
+//! Minimal ECS app wrapper to replace Bevy's App
+
+use bevy_ecs::message::{Message, Messages};
+use bevy_ecs::prelude::*;
+use bevy_ecs::schedule::{IntoScheduleConfigs, ScheduleLabel, Schedules};
+use bevy_ecs::system::ScheduleSystem;
+use std::fmt::Debug;
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone, ScheduleLabel)]
+pub struct Startup;
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone, ScheduleLabel)]
+pub struct Update;
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone, ScheduleLabel)]
+pub struct Last;
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone, ScheduleLabel)]
+pub struct Fixed;
+
+pub struct App {
+    world: World,
+}
+
+impl App {
+    pub fn new() -> Self {
+        let mut world = World::new();
+
+        // Initialize schedules
+        let mut schedules = Schedules::new();
+        schedules.insert(Schedule::new(Startup));
+        schedules.insert(Schedule::new(Update));
+        schedules.insert(Schedule::new(Last));
+        schedules.insert(Schedule::new(Fixed));
+
+        world.insert_resource(schedules);
+
+        Self { world }
+    }
+
+    pub fn world(&self) -> &World {
+        &self.world
+    }
+
+    pub fn world_mut(&mut self) -> &mut World {
+        &mut self.world
+    }
+
+    pub fn insert_resource<R: Resource>(&mut self, resource: R) -> &mut Self {
+        self.world.insert_resource(resource);
+        self
+    }
+
+    pub fn init_resource<R: Resource + FromWorld>(&mut self) -> &mut Self {
+        self.world.init_resource::<R>();
+        self
+    }
+
+    pub fn insert_non_send_resource<R: 'static>(&mut self, resource: R) -> &mut Self {
+        self.world.insert_non_send_resource(resource);
+        self
+    }
+
+    pub fn add_message<M: Message>(&mut self) -> &mut Self {
+        if !self.world.contains_resource::<Messages<M>>() {
+            self.world.init_resource::<Messages<M>>();
+
+            // Add system to update this message type each frame
+            self.add_systems(Last, |mut messages: ResMut<Messages<M>>| {
+                messages.update();
+            });
+        }
+        self
+    }
+
+    pub fn add_systems<M>(&mut self, schedule: impl ScheduleLabel, systems: impl IntoScheduleConfigs<ScheduleSystem, M>) -> &mut Self {
+        let mut schedules = self.world.resource_mut::<Schedules>();
+        if let Some(schedule_inst) = schedules.get_mut(schedule) {
+            schedule_inst.add_systems(systems);
+        }
+        self
+    }
+
+    pub fn update(&mut self) {
+        // Remove schedules temporarily to avoid resource_scope conflicts
+        let mut schedules = self.world.remove_resource::<Schedules>().unwrap();
+
+        // Run Update schedule
+        if let Some(schedule) = schedules.get_mut(Update) {
+            schedule.run(&mut self.world);
+        }
+
+        // Run Last schedule (includes event updates)
+        if let Some(schedule) = schedules.get_mut(Last) {
+            schedule.run(&mut self.world);
+        }
+
+        // Re-insert schedules
+        self.world.insert_resource(schedules);
+    }
+
+    pub fn run_startup(&mut self) {
+        let _span = tracing::trace_span!("run_startup_schedule").entered();
+
+        // Remove schedules temporarily to avoid resource_scope conflicts
+        let mut schedules = self.world.remove_resource::<Schedules>().unwrap();
+
+        // Run Startup schedule
+        if let Some(schedule) = schedules.get_mut(Startup) {
+            schedule.run(&mut self.world);
+        }
+
+        // Re-insert schedules
+        self.world.insert_resource(schedules);
+    }
+
+    pub fn finish(&mut self) {
+        // Finalize schedules
+        let mut schedules = self.world.remove_resource::<Schedules>().unwrap();
+
+        let system_count: usize = schedules.iter().map(|(_, schedule)| schedule.systems().map(|iter| iter.count()).unwrap_or(0)).sum();
+
+        let _span = tracing::trace_span!("finish_schedules", system_count = system_count).entered();
+
+        for (_, schedule) in schedules.iter_mut() {
+            schedule.graph_mut().initialize(&mut self.world);
+        }
+
+        self.world.insert_resource(schedules);
+    }
+
+    pub fn cleanup(&mut self) {
+        // Any cleanup needed before running
+    }
+}
+
+impl Default for App {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Plugin trait for modular setup
+pub trait Plugin {
+    fn build(&self, app: &mut App);
+}