bevy 1.0.0

data/lib/bevy/resource.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Bevy
+  class ResourceDSL
+    class << self
+      def attribute(name, type, default: nil)
+        @attributes ||= {}
+        @attributes[name] = { type: type, default: default }
+
+        define_method(name) { @data[name] }
+        define_method(:"#{name}=") { |value| @data[name] = value }
+      end
+
+      def attributes
+        @attributes ||= {}
+      end
+
+      def resource_name
+        name || 'AnonymousResource'
+      end
+
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@attributes, attributes.dup)
+      end
+    end
+
+    def initialize(**attrs)
+      @data = {}
+      self.class.attributes.each do |attr_name, config|
+        default = config[:default]
+        default_value = default.respond_to?(:call) ? default.call : default
+        @data[attr_name] = attrs.fetch(attr_name, default_value)
+      end
+    end
+
+    def to_h
+      @data.dup
+    end
+  end
+
+  class Resources
+    def initialize
+      @resources = {}
+    end
+
+    def insert(resource)
+      type_name = resource_type_name(resource)
+      @resources[type_name] = resource
+    end
+
+    def get(resource_class)
+      type_name = resource_class_name(resource_class)
+      @resources[type_name]
+    end
+
+    def get_or_insert(resource_class, &block)
+      type_name = resource_class_name(resource_class)
+      @resources[type_name] ||= block.call
+    end
+
+    def remove(resource_class)
+      type_name = resource_class_name(resource_class)
+      @resources.delete(type_name)
+    end
+
+    def contains?(resource_class)
+      type_name = resource_class_name(resource_class)
+      @resources.key?(type_name)
+    end
+
+    def clear
+      @resources.clear
+    end
+
+    private
+
+    def resource_type_name(resource)
+      case resource
+      when ResourceDSL
+        resource.class.resource_name
+      else
+        resource.class.name || 'AnonymousResource'
+      end
+    end
+
+    def resource_class_name(resource_class)
+      case resource_class
+      when Class
+        resource_class.respond_to?(:resource_name) ? resource_class.resource_name : resource_class.name
+      when String
+        resource_class
+      else
+        raise ArgumentError, 'Expected Class or String'
+      end
+    end
+  end
+
+  class Time
+    attr_reader :delta, :elapsed, :delta_seconds, :elapsed_seconds, :time_scale
+
+    def initialize
+      @start_time = ::Time.now
+      @last_update = @start_time
+      @delta = 0.0
+      @elapsed = 0.0
+      @delta_seconds = 0.0
+      @elapsed_seconds = 0.0
+      @paused = false
+      @time_scale = 1.0
+    end
+
+    def update
+      return if @paused
+
+      now = ::Time.now
+      raw_delta = now - @last_update
+      @delta_seconds = raw_delta * @time_scale
+      @delta = @delta_seconds
+      @elapsed_seconds = now - @start_time
+      @elapsed = @elapsed_seconds
+      @last_update = now
+    end
+
+    def pause
+      @paused = true
+    end
+
+    def unpause
+      @paused = false
+      @last_update = ::Time.now
+    end
+
+    def paused?
+      @paused
+    end
+
+    def time_scale=(scale)
+      @time_scale = scale.clamp(0.0, 10.0)
+    end
+
+    def reset
+      @start_time = ::Time.now
+      @last_update = @start_time
+      @delta = 0.0
+      @elapsed = 0.0
+      @delta_seconds = 0.0
+      @elapsed_seconds = 0.0
+    end
+  end
+
+  class FixedTime
+    attr_reader :delta, :overstep, :accumulated, :timestep
+
+    def initialize(timestep: 1.0 / 60.0)
+      @timestep = timestep
+      @delta = timestep
+      @accumulated = 0.0
+      @overstep = 0.0
+    end
+
+    def timestep=(value)
+      @timestep = value.clamp(0.001, 1.0)
+      @delta = @timestep
+    end
+
+    def accumulate(delta)
+      @accumulated += delta
+    end
+
+    def expend
+      if @accumulated >= @timestep
+        @accumulated -= @timestep
+        @overstep = @accumulated
+        true
+      else
+        false
+      end
+    end
+
+    def steps_remaining
+      (@accumulated / @timestep).floor
+    end
+  end
+end

data/lib/bevy/scene.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Bevy
+  class Scene
+    attr_reader :name, :entities
+
+    def initialize(name = 'Untitled')
+      @name = name
+      @entities = []
+    end
+
+    def add_entity(components)
+      @entities << components
+      self
+    end
+
+    def spawn_all(world)
+      spawned = []
+      @entities.each do |components|
+        entity = world.spawn_entity(*components)
+        spawned << entity
+      end
+      spawned
+    end
+
+    def clear
+      @entities.clear
+      self
+    end
+
+    def entity_count
+      @entities.size
+    end
+
+    def type_name
+      'Scene'
+    end
+  end
+
+  class DynamicScene
+    attr_reader :name
+
+    def initialize(name = 'DynamicScene')
+      @name = name
+      @entity_data = []
+    end
+
+    def capture_world(world, &filter)
+      @entity_data.clear
+
+      world.all_entities.each do |entity|
+        next if block_given? && !filter.call(entity)
+
+        entity_components = {}
+        world.mesh_components[entity.id]&.each do |type_name, component|
+          entity_components[type_name] = serialize_component(component)
+        end
+
+        @entity_data << {
+          id: entity.id,
+          components: entity_components
+        }
+      end
+
+      self
+    end
+
+    def restore_to_world(world)
+      spawned = []
+      @entity_data.each do |data|
+        components = data[:components].map do |type_name, comp_data|
+          deserialize_component(type_name, comp_data)
+        end.compact
+
+        entity = world.spawn_entity(*components) if components.any?
+        spawned << entity if entity
+      end
+      spawned
+    end
+
+    def to_data
+      {
+        name: @name,
+        entities: @entity_data
+      }
+    end
+
+    def load_data(data)
+      @name = data[:name] || data['name'] || @name
+      @entity_data = data[:entities] || data['entities'] || []
+      self
+    end
+
+    def entity_count
+      @entity_data.size
+    end
+
+    def type_name
+      'DynamicScene'
+    end
+
+    private
+
+    def serialize_component(component)
+      case component
+      when Mesh::Rectangle
+        { type: 'Rectangle', width: component.width, height: component.height, color: component.color.to_a }
+      when Mesh::Circle
+        { type: 'Circle', radius: component.radius, color: component.color.to_a }
+      when Mesh::RegularPolygon
+        { type: 'RegularPolygon', radius: component.radius, sides: component.sides, color: component.color.to_a }
+      else
+        { type: component.class.name, data: component.respond_to?(:to_h) ? component.to_h : {} }
+      end
+    end
+
+    def deserialize_component(type_name, data)
+      case data[:type] || data['type']
+      when 'Rectangle'
+        color = data[:color] || data['color']
+        Mesh::Rectangle.new(
+          width: data[:width] || data['width'],
+          height: data[:height] || data['height'],
+          color: color.is_a?(Array) ? Color.rgba(*color) : Color.white
+        )
+      when 'Circle'
+        color = data[:color] || data['color']
+        Mesh::Circle.new(
+          radius: data[:radius] || data['radius'],
+          color: color.is_a?(Array) ? Color.rgba(*color) : Color.white
+        )
+      when 'RegularPolygon'
+        color = data[:color] || data['color']
+        Mesh::RegularPolygon.new(
+          radius: data[:radius] || data['radius'],
+          sides: data[:sides] || data['sides'],
+          color: color.is_a?(Array) ? Color.rgba(*color) : Color.white
+        )
+      else
+        nil
+      end
+    end
+  end
+
+  class SceneBundle
+    attr_reader :scene, :transform
+
+    def initialize(scene:, transform: nil)
+      @scene = scene
+      @transform = transform || Transform.identity
+    end
+
+    def type_name
+      'SceneBundle'
+    end
+  end
+
+  class SceneSpawner
+    def initialize
+      @pending_scenes = []
+      @spawned_scenes = {}
+    end
+
+    def spawn(scene, transform: nil)
+      @pending_scenes << { scene: scene, transform: transform }
+      self
+    end
+
+    def spawn_pending(world)
+      spawned = []
+      @pending_scenes.each do |pending|
+        scene = pending[:scene]
+        entities = scene.spawn_all(world)
+        spawned.concat(entities)
+        @spawned_scenes[scene.name] = entities
+      end
+      @pending_scenes.clear
+      spawned
+    end
+
+    def despawn_scene(name, world)
+      entities = @spawned_scenes.delete(name)
+      return [] unless entities
+
+      entities.each { |e| world.despawn(e) }
+      entities
+    end
+
+    def pending_count
+      @pending_scenes.size
+    end
+
+    def spawned_scenes
+      @spawned_scenes.keys
+    end
+
+    def type_name
+      'SceneSpawner'
+    end
+  end
+
+  module SceneSaver
+    def self.save_to_json(scene, file_path)
+      data = if scene.is_a?(DynamicScene)
+               scene.to_data
+             else
+               { name: scene.name, entities: scene.entities.map { |e| serialize_entity(e) } }
+             end
+
+      File.write(file_path, JSON.pretty_generate(data))
+      true
+    rescue StandardError => e
+      warn "Failed to save scene: #{e.message}"
+      false
+    end
+
+    def self.load_from_json(file_path)
+      return nil unless File.exist?(file_path)
+
+      data = JSON.parse(File.read(file_path), symbolize_names: true)
+      scene = DynamicScene.new(data[:name] || 'Loaded')
+      scene.load_data(data)
+      scene
+    rescue StandardError => e
+      warn "Failed to load scene: #{e.message}"
+      nil
+    end
+
+    def self.serialize_entity(components)
+      components.map do |comp|
+        {
+          type: comp.class.name,
+          data: comp.respond_to?(:to_h) ? comp.to_h : {}
+        }
+      end
+    end
+  end
+
+  class SceneInstance
+    attr_reader :scene_name, :root_entity, :entities
+
+    def initialize(scene_name, root_entity, entities)
+      @scene_name = scene_name
+      @root_entity = root_entity
+      @entities = entities
+    end
+
+    def type_name
+      'SceneInstance'
+    end
+  end
+end