bevy 1.0.0

data/lib/bevy/diagnostics.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module Bevy
+  class DiagnosticsStore
+    attr_reader :diagnostics
+
+    def initialize
+      @diagnostics = {}
+    end
+
+    def add(diagnostic)
+      @diagnostics[diagnostic.id] = diagnostic
+      self
+    end
+
+    def get(id)
+      @diagnostics[id]
+    end
+
+    def remove(id)
+      @diagnostics.delete(id)
+    end
+
+    def get_measurement(id)
+      diagnostic = @diagnostics[id]
+      diagnostic&.average
+    end
+
+    def type_name
+      'DiagnosticsStore'
+    end
+  end
+
+  class Diagnostic
+    attr_reader :id, :name, :suffix, :history
+
+    def initialize(id:, name:, max_history: 120, suffix: nil)
+      @id = id
+      @name = name
+      @suffix = suffix || ''
+      @max_history = max_history
+      @history = []
+    end
+
+    def add_measurement(value)
+      @history << { value: value.to_f, time: ::Time.now }
+      @history.shift while @history.size > @max_history
+    end
+
+    def value
+      @history.last&.fetch(:value)
+    end
+
+    def average
+      return nil if @history.empty?
+
+      @history.sum { |m| m[:value] } / @history.size
+    end
+
+    def smoothed
+      return nil if @history.size < 2
+
+      @history.last(10).sum { |m| m[:value] } / [10, @history.size].min
+    end
+
+    def clear_history
+      @history = []
+    end
+
+    def type_name
+      'Diagnostic'
+    end
+  end
+
+  class FrameTimeDiagnostics
+    FPS_ID = 'fps'
+    FRAME_TIME_ID = 'frame_time'
+    FRAME_COUNT_ID = 'frame_count'
+
+    attr_reader :fps, :frame_time, :frame_count
+
+    def initialize
+      @fps = Diagnostic.new(id: FPS_ID, name: 'FPS', suffix: ' fps')
+      @frame_time = Diagnostic.new(id: FRAME_TIME_ID, name: 'Frame Time', suffix: ' ms')
+      @frame_count = 0
+      @last_time = ::Time.now
+    end
+
+    def update
+      current_time = ::Time.now
+      delta = current_time - @last_time
+      @last_time = current_time
+      @frame_count += 1
+
+      @frame_time.add_measurement(delta * 1000.0)
+      @fps.add_measurement(1.0 / delta) if delta > 0
+    end
+
+    def diagnostics
+      [@fps, @frame_time]
+    end
+
+    def type_name
+      'FrameTimeDiagnostics'
+    end
+  end
+
+  class EntityCountDiagnostics
+    ENTITY_COUNT_ID = 'entity_count'
+
+    attr_reader :entity_count
+
+    def initialize
+      @entity_count = Diagnostic.new(id: ENTITY_COUNT_ID, name: 'Entity Count')
+    end
+
+    def update(world)
+      count = world.respond_to?(:entity_count) ? world.entity_count : 0
+      @entity_count.add_measurement(count)
+    end
+
+    def diagnostics
+      [@entity_count]
+    end
+
+    def type_name
+      'EntityCountDiagnostics'
+    end
+  end
+
+  class SystemDiagnostics
+    attr_reader :system_timings
+
+    def initialize
+      @system_timings = {}
+    end
+
+    def start_system(name)
+      @system_timings[name] ||= Diagnostic.new(id: "system_#{name}", name: name, suffix: ' ms')
+      @system_timings[name].instance_variable_set(:@start_time, ::Time.now)
+    end
+
+    def end_system(name)
+      diagnostic = @system_timings[name]
+      return unless diagnostic
+
+      start_time = diagnostic.instance_variable_get(:@start_time)
+      return unless start_time
+
+      elapsed = (::Time.now - start_time) * 1000.0
+      diagnostic.add_measurement(elapsed)
+    end
+
+    def diagnostics
+      @system_timings.values
+    end
+
+    def type_name
+      'SystemDiagnostics'
+    end
+  end
+
+  class LogDiagnostics
+    attr_accessor :enabled, :wait_duration
+
+    def initialize(wait_duration: 1.0)
+      @enabled = true
+      @wait_duration = wait_duration.to_f
+      @last_log_time = ::Time.now
+    end
+
+    def log(store)
+      return unless @enabled
+
+      current_time = ::Time.now
+      return unless current_time - @last_log_time >= @wait_duration
+
+      @last_log_time = current_time
+      store.diagnostics.each_value do |diagnostic|
+        puts format_diagnostic(diagnostic) if diagnostic.value
+      end
+    end
+
+    def type_name
+      'LogDiagnostics'
+    end
+
+    private
+
+    def format_diagnostic(diagnostic)
+      value = diagnostic.smoothed || diagnostic.value
+      "#{diagnostic.name}: #{value.round(2)}#{diagnostic.suffix}"
+    end
+  end
+
+  class PerformanceMetrics
+    attr_reader :draw_calls, :triangles, :vertices, :textures_bound
+
+    def initialize
+      @draw_calls = 0
+      @triangles = 0
+      @vertices = 0
+      @textures_bound = 0
+    end
+
+    def reset
+      @draw_calls = 0
+      @triangles = 0
+      @vertices = 0
+      @textures_bound = 0
+    end
+
+    def add_draw_call(triangles: 0, vertices: 0)
+      @draw_calls += 1
+      @triangles += triangles
+      @vertices += vertices
+    end
+
+    def bind_texture
+      @textures_bound += 1
+    end
+
+    def type_name
+      'PerformanceMetrics'
+    end
+  end
+end

data/lib/bevy/ecs_advanced.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+module Bevy
+  class Changed
+    attr_reader :component_type
+
+    def initialize(component_type)
+      @component_type = component_type
+    end
+
+    def type_name
+      'Changed'
+    end
+  end
+
+  class Added
+    attr_reader :component_type
+
+    def initialize(component_type)
+      @component_type = component_type
+    end
+
+    def type_name
+      'Added'
+    end
+  end
+
+  class With
+    attr_reader :component_types
+
+    def initialize(*component_types)
+      @component_types = component_types
+    end
+
+    def type_name
+      'With'
+    end
+  end
+
+  class Without
+    attr_reader :component_types
+
+    def initialize(*component_types)
+      @component_types = component_types
+    end
+
+    def type_name
+      'Without'
+    end
+  end
+
+  class Or
+    attr_reader :filters
+
+    def initialize(*filters)
+      @filters = filters
+    end
+
+    def type_name
+      'Or'
+    end
+  end
+
+  class ChangeTrackers
+    attr_reader :entity, :component_type
+
+    def initialize(entity:, component_type:)
+      @entity = entity
+      @component_type = component_type
+      @added_tick = 0
+      @changed_tick = 0
+      @last_run = 0
+    end
+
+    def is_added?(current_tick)
+      @added_tick > @last_run && @added_tick <= current_tick
+    end
+
+    def is_changed?(current_tick)
+      @changed_tick > @last_run && @changed_tick <= current_tick
+    end
+
+    def set_added(tick)
+      @added_tick = tick
+    end
+
+    def set_changed(tick)
+      @changed_tick = tick
+    end
+
+    def update_last_run(tick)
+      @last_run = tick
+    end
+
+    def type_name
+      'ChangeTrackers'
+    end
+  end
+
+  class ComponentTracker
+    def initialize
+      @trackers = {}
+      @current_tick = 0
+    end
+
+    def tick
+      @current_tick += 1
+    end
+
+    def current_tick
+      @current_tick
+    end
+
+    def track_add(entity, component_type)
+      key = [entity, component_type]
+      @trackers[key] ||= ChangeTrackers.new(entity: entity, component_type: component_type)
+      @trackers[key].set_added(@current_tick)
+    end
+
+    def track_change(entity, component_type)
+      key = [entity, component_type]
+      @trackers[key] ||= ChangeTrackers.new(entity: entity, component_type: component_type)
+      @trackers[key].set_changed(@current_tick)
+    end
+
+    def added?(entity, component_type)
+      key = [entity, component_type]
+      tracker = @trackers[key]
+      tracker&.is_added?(@current_tick) || false
+    end
+
+    def changed?(entity, component_type)
+      key = [entity, component_type]
+      tracker = @trackers[key]
+      tracker&.is_changed?(@current_tick) || false
+    end
+
+    def type_name
+      'ComponentTracker'
+    end
+  end
+
+  class SystemSet
+    attr_reader :name, :systems
+
+    def initialize(name)
+      @name = name
+      @systems = []
+      @run_condition = nil
+    end
+
+    def add_system(system)
+      @systems << system
+      self
+    end
+
+    def run_if(&condition)
+      @run_condition = condition
+      self
+    end
+
+    def should_run?(context)
+      return true unless @run_condition
+
+      @run_condition.call(context)
+    end
+
+    def type_name
+      'SystemSet'
+    end
+  end
+
+  class RunCondition
+    def self.resource_exists(resource_type)
+      ->(ctx) { ctx.has_resource?(resource_type) }
+    end
+
+    def self.resource_equals(resource_type, value)
+      ->(ctx) { ctx.get_resource(resource_type) == value }
+    end
+
+    def self.state_equals(state_type, value)
+      ->(ctx) { ctx.get_state(state_type) == value }
+    end
+
+    def self.in_state(state)
+      ->(ctx) { ctx.current_state == state }
+    end
+
+    def self.run_once
+      ran = false
+      lambda do |_ctx|
+        return false if ran
+
+        ran = true
+        true
+      end
+    end
+
+    def self.not(condition)
+      ->(ctx) { !condition.call(ctx) }
+    end
+
+    def self.and(cond1, cond2)
+      ->(ctx) { cond1.call(ctx) && cond2.call(ctx) }
+    end
+
+    def self.or(cond1, cond2)
+      ->(ctx) { cond1.call(ctx) || cond2.call(ctx) }
+    end
+  end
+
+  class Commands
+    def initialize(world)
+      @world = world
+      @command_queue = []
+    end
+
+    def spawn(*components)
+      entity = @world.spawn_entity(*components)
+      EntityCommands.new(entity, @world)
+    end
+
+    def entity(entity)
+      EntityCommands.new(entity, @world)
+    end
+
+    def despawn(entity)
+      @command_queue << [:despawn, entity]
+      self
+    end
+
+    def insert_resource(resource)
+      @command_queue << [:insert_resource, resource]
+      self
+    end
+
+    def remove_resource(resource_type)
+      @command_queue << [:remove_resource, resource_type]
+      self
+    end
+
+    def apply
+      @command_queue.each do |cmd, *args|
+        case cmd
+        when :despawn
+          @world.despawn(args[0])
+        when :insert_resource
+          @world.insert_resource(args[0])
+        when :remove_resource
+          @world.remove_resource(args[0])
+        end
+      end
+      @command_queue = []
+    end
+
+    def type_name
+      'Commands'
+    end
+  end
+
+  class EntityCommands
+    def initialize(entity, world)
+      @entity = entity
+      @world = world
+    end
+
+    def insert(*components)
+      components.each do |component|
+        @world.insert_component(@entity, component)
+      end
+      self
+    end
+
+    def remove(component_type)
+      @world.remove_component(@entity, component_type)
+      self
+    end
+
+    def despawn
+      @world.despawn(@entity)
+    end
+
+    def despawn_recursive
+      DespawnRecursive.despawn(@world, @entity)
+    end
+
+    def id
+      @entity
+    end
+
+    def type_name
+      'EntityCommands'
+    end
+  end
+end

data/lib/bevy/event.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Bevy
+  class EventDSL
+    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 event_name
+        name || 'AnonymousEvent'
+      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 Events
+    def initialize(event_class)
+      @event_class = event_class
+      @events = []
+      @events_last_frame = []
+    end
+
+    def send(event)
+      validate_event!(event)
+      @events << event
+    end
+
+    def read
+      @events_last_frame + @events
+    end
+
+    def drain
+      result = @events.dup
+      @events.clear
+      result
+    end
+
+    def clear
+      @events.clear
+    end
+
+    def update
+      @events_last_frame = @events.dup
+      @events.clear
+    end
+
+    def empty?
+      @events.empty? && @events_last_frame.empty?
+    end
+
+    def len
+      @events.length + @events_last_frame.length
+    end
+
+    private
+
+    def validate_event!(event)
+      return if event.is_a?(@event_class)
+
+      raise ArgumentError, "Expected #{@event_class}, got #{event.class}"
+    end
+  end
+
+  class EventReader
+    def initialize(events)
+      @events = events
+      @cursor = 0
+    end
+
+    def read
+      all_events = @events.read
+      new_events = all_events[@cursor..]
+      @cursor = all_events.length
+      new_events || []
+    end
+
+    def is_empty?
+      @events.read.length <= @cursor
+    end
+
+    def len
+      [@events.read.length - @cursor, 0].max
+    end
+
+    def clear
+      @cursor = @events.read.length
+    end
+  end
+
+  class EventWriter
+    def initialize(events)
+      @events = events
+    end
+
+    def send(event)
+      @events.send(event)
+    end
+
+    def send_batch(events)
+      events.each { |e| @events.send(e) }
+    end
+
+    def send_default
+      @events.send(@events.instance_variable_get(:@event_class).new)
+    end
+  end
+
+  class EventRegistry
+    def initialize
+      @events = {}
+      @readers = {}
+    end
+
+    def register(event_class)
+      type_name = event_class_name(event_class)
+      @events[type_name] ||= Events.new(event_class)
+    end
+
+    def get_events(event_class)
+      type_name = event_class_name(event_class)
+      @events[type_name]
+    end
+
+    def reader(event_class)
+      type_name = event_class_name(event_class)
+      events = @events[type_name]
+      return nil unless events
+
+      @readers[type_name] ||= EventReader.new(events)
+    end
+
+    def writer(event_class)
+      type_name = event_class_name(event_class)
+      events = @events[type_name]
+      return nil unless events
+
+      EventWriter.new(events)
+    end
+
+    def update_all
+      @events.each_value(&:update)
+    end
+
+    def clear_all
+      @events.each_value(&:clear)
+    end
+
+    private
+
+    def event_class_name(event_class)
+      case event_class
+      when Class
+        event_class.respond_to?(:event_name) ? event_class.event_name : event_class.name
+      when String
+        event_class
+      else
+        raise ArgumentError, 'Expected Class or String'
+      end
+    end
+  end
+
+  class PickingEvent < EventDSL
+    attribute :kind, :string, default: ''
+    attribute :target_id, :integer, default: 0
+    attribute :pointer_id, :string, default: ''
+    attribute :button, :string, default: nil
+    attribute :position, :vec2, default: -> { Vec2.zero }
+    attribute :camera_id, :integer, default: nil
+    attribute :depth, :float, default: nil
+    attribute :hit_position, :vec3, default: nil
+    attribute :hit_normal, :vec3, default: nil
+  end
+end