felflame 1.0.0

data/lib/felflame/entity_manager.rb

@@ -0,0 +1,135 @@
+class FelFlame
+  class Entities
+    # Holds the unique ID of this entity
+    # @return [Integer]
+    attr_reader :id
+
+    # A seperate attr_writer was made for documentation readability reasons.
+    # Yard will list attr_reader is readonly which is my intention.
+    # This value needs to be changable as it is set by other functions.
+    # @!visibility private
+    attr_writer :id
+
+    # Creating a new Entity
+    # @param components [Components] Can be any number of components, identical duplicates will be automatically purged however different components from the same component manager are allowed.
+    # @return [Entity]
+    def initialize(*components)
+      # Assign new unique ID
+      new_id = self.class.data.find_index(&:nil?)
+      new_id = self.class.data.size if new_id.nil?
+      self.id = new_id
+
+      # Add each component
+      add(*components)
+
+      self.class.data[id] = self
+    end
+
+    # A hash that uses component manager constant names as keys, and where the values of those keys are arrays that contain the {FelFlame::ComponentManager#id IDs} of the components attached to this entity.
+    # @return [Hash<Component_Manager, Array<Integer>>]
+    def components
+      @components ||= {}
+    end
+
+    # An alias for the {#id ID reader}
+    # @return [Integer]
+    def to_i
+      id
+    end
+
+    # Removes this Entity from the list and purges all references to this Entity from other Components, as well as its {id ID} and data.
+    # @return [Boolean] +true+
+    def delete
+      components.each do |component_manager, component_array|
+        component_array.each do |component_id|
+          component_manager[component_id].entities.delete(id)
+          #self.remove FelFlame::Components.const_get(component_manager.name)[component_id]
+        end
+      end
+      FelFlame::Entities.data[id] = nil
+      @components = {}
+      @id = nil
+      true
+    end
+
+    # Add any number components to the Entity.
+    # @param components_to_add [Component] Any number of components created from any component manager
+    # @return [Boolean] +true+
+    def add(*components_to_add)
+      components_to_add.each do |component|
+        if components[component.class].nil?
+          components[component.class] = [component.id]
+          component.entities.push id
+          check_systems component, :addition_triggers
+        elsif !components[component.class].include? component.id
+          components[component.class].push component.id
+          component.entities.push id
+          check_systems component, :addition_triggers
+        end
+      end
+      true
+    end
+
+    # triggers every system associated with this component's trigger
+    # @return [Boolean] +true+
+    # @!visibility private
+    def check_systems(component, trigger_type)
+      component_calls = component.class.send(trigger_type)
+      component.send(trigger_type).each do |system|
+        component_calls |= [system]
+      end
+      component_calls.sort_by(&:priority).reverse.each(&:call)
+      true
+    end
+
+    # Remove a component from the Entity
+    # @param components_to_remove [Component] A component created from any component manager
+    # @return [Boolean] +true+
+    def remove(*components_to_remove)
+      components_to_remove.each do |component|
+        check_systems component, :removal_triggers if component.entities.include? id
+        component.entities.delete id
+        components[component.class].delete component.id
+      end
+      true
+    end
+
+    # Export all data into a JSON String which can then be saved into a file
+    # TODO: This function is not yet complete
+    # @return [String] A JSON formatted String
+    #def to_json() end
+
+    class <<self
+      include Enumerable
+      # @return [Array<Entity>] Array of all Entities that exist
+      # @!visibility private
+      def data
+        @data ||= []
+      end
+
+      # Gets an Entity from the given {id unique ID}. Usage is simular to how an Array lookup works
+      #
+      # @example
+      #   # This gets the Entity with ID 7
+      #   FelFlame::Entities[7]
+      # @param entity_id [Integer]
+      # @return [Entity] returns the Entity that uses the given unique ID, nil if there is no Entity associated with the given ID
+      def [](entity_id)
+        data[entity_id]
+      end
+
+      # Iterates over all entities. The data is compacted so that means index does not correlate to ID.
+      # You also call other enumerable methods instead of each, such as +each_with_index+ or +select+
+      # @return [Enumerator]
+      def each(&block)
+        data.compact.each(&block)
+      end
+
+      # Creates a new entity using the data from a JSON string
+      # TODO: This function is not yet complete
+      # @param json_string [String] A string that was exported originally using the {FelFlame::Entities#to_json to_json} function
+      # @param opts [Keywords] What values(its {FelFlame::Entities#id ID} or the {FelFlame::ComponentManager#id component IDs}) should be overwritten TODO: this might change
+      #def from_json(json_string, **opts) end
+    end
+  end
+end

data/lib/felflame/scene_manager.rb

@@ -0,0 +1,58 @@
+class FelFlame
+  class Scenes
+    # The Constant name assigned to this Scene
+    attr_reader :const_name
+
+    # Allows overwriting the storage of systems, such as for clearing.
+    # This method should generally only need to be used internally and
+    # not by a game developer/
+    # @!visibility private
+    attr_writer :systems
+
+    # Create a new Scene using the name given
+    # @param name [String] String format must follow requirements of a constant
+    def initialize(name)
+      FelFlame::Scenes.const_set(name, self)
+      @const_name = name
+    end
+
+    # The list of Systems this Scene contains
+    # @return [Array<System>]
+    def systems
+      @systems ||= []
+    end
+
+    # Execute all systems in this Scene, in the order of their priority
+    # @return [Boolean] +true+
+    def call
+      systems.each(&:call)
+      true
+    end
+
+    # Adds any number of Systems to this Scene
+    # @return [Boolean] +true+
+    def add(*systems_to_add)
+      self.systems |= systems_to_add
+      systems.sort_by!(&:priority)
+      FelFlame::Stage.update_systems_list if FelFlame::Stage.scenes.include? self
+      true
+    end
+
+    # Removes any number of SystemS from this Scene
+    # @return [Boolean] +true+
+    def remove(*systems_to_remove)
+      self.systems -= systems_to_remove
+      systems.sort_by!(&:priority)
+      FelFlame::Stage.update_systems_list if FelFlame::Stage.scenes.include? self
+      true
+    end
+
+    # Removes all Systems from this Scene
+    # @return [Boolean] +true+
+    def clear
+      systems.clear
+      FelFlame::Stage.update_systems_list if FelFlame::Stage.scenes.include? self
+      true
+    end
+  end
+end

data/lib/felflame/stage_manager.rb

@@ -0,0 +1,70 @@
+class FelFlame
+  class Stage
+    class <<self
+      # Allows clearing of scenes and systems.
+      # Used internally by FelFlame and shouldn't need to be ever used by developers
+      # @!visibility private
+      attr_writer :scenes, :systems
+
+      # Add any number of Scenes to the Stage
+      # @return [Boolean] +true+
+      def add(*scenes_to_add)
+        self.scenes |= scenes_to_add
+        scenes_to_add.each do |scene|
+          self.systems |= scene.systems
+        end
+        systems.sort_by!(&:priority)
+        true
+      end
+
+      # Remove any number of Scenes from the Stage
+      # @return [Boolean] +true+
+      def remove(*scenes_to_remove)
+        self.scenes -= scenes_to_remove
+        update_systems_list
+        true
+      end
+
+      # Updates the list of systems from the Scenes added to the Stage and make sure they are ordered correctly
+      # This is used internally by FelFlame and shouldn't need to be ever used by developers
+      # @return [Boolean] +true+
+      # @!visibility private
+      def update_systems_list
+        systems.clear
+        scenes.each do |scene|
+          self.systems |= scene.systems
+        end
+        systems.sort_by!(&:priority)
+        true
+      end
+
+      # Clears all Scenes that were added to the Stage
+      # @return [Boolean] +true+
+      def clear
+        systems.clear
+        scenes.clear
+        true
+      end
+
+      # Executes one frame of the game. This executes all the Systems in the Scenes added to the Stage. Systems that exist in two or more different Scenes will still only get executed once.
+      # @return [Boolean] +true+
+      def call
+        systems.each(&:call)
+        true
+      end
+
+      # Contains all the Scenes added to the Stage
+      # @return [Array<Scene>]
+      def scenes
+        @scenes ||= []
+      end
+
+      # Stores systems in the order the stage manager needs to call them
+      # This method should generally only need to be used internally and not by a game developer
+      # @!visibility private
+      def systems
+        @systems ||= []
+      end
+    end
+  end
+end

data/lib/felflame/system_manager.rb

@@ -0,0 +1,213 @@
+class FelFlame
+  class Systems
+    # How early this System should be executed in a list of Systems
+    attr_accessor :priority
+
+    # The Constant name assigned to this System
+    attr_reader :const_name
+
+    # Allows overwriting the storage of triggers, such as for clearing.
+    # This method should generally only need to be used internally and
+    # not by a game developer.
+    # @!visibility private
+    attr_writer :addition_triggers, :removal_triggers, :attr_triggers
+
+    def priority=(priority)
+      @priority = priority
+      FelFlame::Stage.systems.sort_by!(&:priority)
+    end
+    # Stores references to components or their managers that trigger
+    # this component when a component or component from that manager
+    # is added to an entity.
+    # Do not edit this hash as it is managed by FelFlame automatically.
+    # @return [Array<Component>]
+    def addition_triggers
+      @addition_triggers ||= []
+    end
+
+    # Stores references to components or their managers that trigger
+    # this component when a component or component from that manager
+    # is removed from an entity.
+    # Do not edit this hash as it is managed by FelFlame automatically.
+    # @return [Array<Component>]
+    def removal_triggers
+      @removal_triggers ||= []
+    end
+
+
+    # Stores references to systems that should be triggered when an
+    # attribute from this manager is changed
+    # Do not edit this hash as it is managed by FelFlame automatically.
+    # @return [Hash<Symbol, Array<Symbol>>]
+    def attr_triggers
+      @attr_triggers ||= {}
+    end
+
+    class <<self
+      include Enumerable
+
+      # Iterate over all Systems, sorted by their priority. You also call other enumerable methods instead of each, such as +each_with_index+ or +select+
+      # @return [Enumerator]
+      def each(&block)
+        constants.map { |sym| const_get(sym) }.sort_by(&:priority).reverse.each(&block)
+      end
+    end
+
+    # Creates a new System which can be accessed as a constant under the namespace {FelFlame::Systems}.
+    # The name given is what constant the system is assigned to
+    #
+    # @example
+    #   FelFlame::Systems.new('PassiveHeal', priority: -2) do
+    #     FelFlame::Components::Health.each do |component|
+    #       component.hp += 5
+    #     end
+    #   end
+    #   # Give it a low priority so other systems such as a
+    #   #   Poison system would kill the player first
+    #
+    # @param name [String] The name this system will use. Needs to to be in the Ruby Constant format.
+    # @param priority [Integer] Which priority order this system should be executed in relative to other systems. Higher means executed earlier.
+    # @param block [Proc] The code you wish to be executed when the system is triggered. Can be defined by using a +do end+ block or using +{ }+ braces.
+    def initialize(name, priority: 0, &block)
+      FelFlame::Systems.const_set(name, self)
+      @const_name = name
+      @priority = priority
+      @block = block
+    end
+
+    # Manually execute the system a single time
+    def call
+      @block.call
+    end
+    # Redefine what code is executed by this System when it is called upon.
+    # @param block [Proc] The code you wish to be executed when the system is triggered. Can be defined by using a +do end+ block or using +{ }+ braces.
+    def redefine(&block)
+      @block = block
+    end
+
+    # Removes triggers from this system. This function is fairly flexible so it can accept a few different inputs
+    # For addition and removal triggers, you can optionally pass in a component, or a manager to clear specifically
+    # the relevant triggers for that one component or manager. If you do not pass a component or manager then it will
+    # clear triggers for all components and managers.
+    # For attr_triggers
+    # @example
+    #   # To clear all triggers that execute this system when a component is added:
+    #   FelFlame::Systems::ExampleSystem.clear_triggers :addition_triggers
+    #   # Same as above but for when a component is removed instead
+    #   FelFlame::Systems::ExampleSystem.clear_triggers :removal_triggers
+    #   # Same as above but for when a component has a certain attribute changed
+    #   FelFlame::Systems::ExampleSystem.clear_triggers :attr_triggers
+    #
+    #   # Clear a trigger from a specific component
+    #   FelFlame::Systems::ExampleSystem.clear_triggers :addition_triggers, FelFlame::Component::ExampleComponent[0]
+    #   # Clear a trigger from a specific component manager
+    #   FelFlame::Systems::ExampleSystem.clear_triggers :addition_triggers, FelFlame::Component::ExampleComponent
+    #
+    #   # Clear the trigger that executes a system when the ':example_attr' is changes
+    #   FelFlame::Systems::ExampleSystem.clear_triggers :attr_triggers, :example_attr
+    # @param trigger_types [:Symbols] One or more of  the following trigger types: +:addition_triggers+, +:removal_triggers+, or +:attr_triggers+. If attr_triggers is used then you may pass attributes you wish to be cleared as symbols in this parameter as well
+    # @param component_or_manager [Component or ComponentManager] The object to clear triggers from. Use Nil to clear triggers from all components associated with this system.
+    # @return [Boolean] +true+
+    def clear_triggers(*trigger_types, component_or_manager: nil)
+      trigger_types = [:addition_triggers, :removal_triggers, :attr_triggers] if trigger_types.empty?
+
+      if trigger_types.include? :attr_triggers
+        if (trigger_types - [:addition_triggers,
+            :removal_triggers,
+            :attr_triggers]).empty?
+
+          if component_or_manager.nil?
+            #remove all attrs
+            self.attr_triggers.each do |cmp_or_mgr, attrs|
+              attrs.each do |attr|
+                next if cmp_or_mgr.attr_triggers[attr].nil?
+
+                cmp_or_mgr.attr_triggers[attr].delete self
+              end
+              self.attr_triggers = {}
+            end
+          else
+            #remove attrs relevant to comp_or_man
+            unless self.attr_triggers[component_or_manager].nil?
+              self.attr_triggers[component_or_manager].each do |attr|
+                component_or_manager.attr_triggers[attr].delete self
+              end
+              self.attr_triggers[component_or_manager] = []
+            end
+          end
+
+        else
+
+          if component_or_manager.nil?
+            (trigger_types - [:addition_triggers, :removal_triggers, :attr_triggers]).each do |attr|
+              #remove attr
+              self.attr_triggers.each do |cmp_or_mgr, attrs|
+                cmp_or_mgr.attr_triggers[attr].delete self
+              end
+            end
+            self.attr_triggers.delete (trigger_types - [:addition_triggers,
+                                                        :removal_triggers,
+                                                        :attr_triggers])
+          else
+            #remove attr from component_or_manager
+            (trigger_types - [:addition_triggers, :removal_triggers, :attr_triggers]).each do |attr|
+              next if component_or_manager.attr_triggers[attr].nil?
+              component_or_manager.attr_triggers[attr].delete self
+            end
+            self.attr_triggers[component_or_manager] -= trigger_types unless self.attr_triggers[component_or_manager].nil?
+          end
+
+        end
+      end
+
+      (trigger_types & [:removal_triggers, :addition_triggers] - [:attr_triggers]).each do |trigger_type|
+        if component_or_manager.nil?
+          #remove all removal triggers
+          self.send(trigger_type).each do |trigger|
+            trigger.send(trigger_type).delete self
+          end
+          self.send("#{trigger_type.to_s}=", [])
+        else
+          #remove removal trigger relevant to comp/man
+          self.send(trigger_type).delete component_or_manager
+          component_or_manager.send(trigger_type).delete self
+        end
+      end
+      true
+    end
+
+    # Add a component or component manager so that it triggers this system when the component or a component from the component manager is added to an entity
+    # @param component_or_manager [Component or ComponentManager] The component or component manager to trigger this system when added
+    # @return [Boolean] +true+
+    def trigger_when_added(component_or_manager)
+      self.addition_triggers |= [component_or_manager]
+      component_or_manager.addition_triggers |= [self]
+      true
+    end
+
+    # Add a component or component manager so that it triggers this system when the component or a component from the component manager is removed from an entity
+    # @param component_or_manager [Component or ComponentManager] The component or component manager to trigger this system when removed
+    # @return [Boolean] +true+
+    def trigger_when_removed(component_or_manager)
+      self.removal_triggers |= [component_or_manager]
+      component_or_manager.removal_triggers |= [self]
+      true
+    end
+
+    # Add a component or component manager so that it triggers this system when a component's attribute is changed.
+    # @return [Boolean] +true+
+    def trigger_when_is_changed(component_or_manager, attr)
+      if component_or_manager.attr_triggers[attr].nil?
+        component_or_manager.attr_triggers[attr] = [self]
+      else
+        component_or_manager.attr_triggers[attr] |= [self]
+      end
+      if self.attr_triggers[component_or_manager].nil?
+        self.attr_triggers[component_or_manager] = [attr]
+      else
+        self.attr_triggers[component_or_manager] |= [attr]
+      end
+      true
+    end
+  end
+end