adjective-rpg-engine 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd16149c10e34afcb91fdcc8588d8c4060752aff2926a948bcac4b606b320feb
-  data.tar.gz: 1f1852b092810dae02b68e99274c5ad4c2990b9d828ba58ac60fa20f7c884f8e
+  metadata.gz: 1e6db5b958ab81f3548404fa67db1822c9ca0c4a086e7eaf535dc0f917bc2ab7
+  data.tar.gz: 1e5174dd569949d858a020f4a1be2524b78d5c9800a59617f1b1f3bb67f381f7
 SHA512:
-  metadata.gz: 6a8a97be51c2d6d3ffa76bab818b85d6f4d52d3672e2325ccd52cdb2c93d26cb457318b9ddc2bdb2b50349e79ea5fb86f135397a2fc6a9b317bb5650c535a6ae
-  data.tar.gz: e0e74f3800caf3ae9040211266ff4adb7f9bddddfdf7ac3c57fa92ce4b472850fa7bcb2376421c7c75312d4657bf5ab6896403289e98e10f551c4ff03da57bee
+  metadata.gz: c15b279c70eac977095b596167e8905b851c5eec1d9bcaefc38fe11bafd398f26f9ab33ca8d987322d860e0d1728b6702be92607ce4280ef4661e539be7858f1
+  data.tar.gz: 15fb8216f0531aae3fad0e958975d79f3c5acee7102c846fcf13a09781fd970ae11bb26391ce0323a9c69bd6944245aee9706aba76ae86d8c1faa26ac41042b9

data/lib/adjective/concerns/imbibable.rb

@@ -0,0 +1,69 @@
+module Adjective
+
+  module Imbibable
+    # Able to be enhanced by experience
+
+    def initialize_experience(opts)
+      @level = opts[:level] ||= 1
+      @experience = opts[:initial_exp] ||= 0
+      # This may throw an error if the user decides to instantiate a class without a table present.
+      @active_exp_set = opts[:exp_table]
+      [:active_exp_set, :level].each {|attribute| self.class.send(:attr_reader, attribute)}
+      self.class.send(:attr_accessor, :experience)
+      set_experience_to_level_minimum
+    end
+
+    def set_experience_to_level_minimum
+      @experience = @active_exp_set[@level]
+    end
+
+    def level_up
+      until !can_level_up?
+        @level += 1
+      end
+    end
+
+    # Level down functionality should work the same way as simply setting a level.
+
+    def normalize_experience
+      @experience = 0 if @experience < 0
+    end        
+
+    def max_level
+      @active_exp_set.length - 1
+    end  
+
+    def max_level?
+      @active_exp_set.length - 1 <= @level
+    end
+    
+    def can_level_up?
+      return false if max_level?
+      @experience >= @active_exp_set[@level+1]
+    end  
+
+    def grant_experience(exp, opts = {})
+      return false if max_level?
+      @experience += exp
+      level_up if !opts[:suppress_level_up]      
+    end
+
+    def set_level(num, opts = {})
+      @level = num
+      @experience = @active_exp_set[num] if !opts[:constrain_exp]
+    end
+
+    def grant_levels(num, opts = {})
+      @level += num
+      @experience = @active_exp_set[@level] if !opts[:constrain_exp] 
+    end 
+
+    def experience_to_next_level
+      return nil if max_level?
+      return @active_exp_set[@level+1] - @experience
+    end 
+
+
+  end
+
+end

data/lib/adjective/concerns/statusable.rb

@@ -0,0 +1,79 @@
+module Adjective
+
+  # I plan on having this module handle the messier side of buff/debuff processing
+  # It will need to include a way to manage the coupling between Status and the target model.
+  # It will need to be able to process and return values that can be easily passed into other
+  # methods. 
+
+  module Statusable
+
+    def initialize_status_data
+      @statuses = []
+      self.class.send(:attr_accessor, :statuses)
+    end
+
+    def apply_status(status, &block)
+      validate_modifier_existence(status)
+      validate_initial_attributes(status.affected_attributes)
+      yield(self, status) if block_given?
+      @statuses.push(status)
+      return @statuses
+    end
+
+    # Actually has three cases
+    # 1: has and responds to given method PERIOD
+    def has_status?(attribute, match)
+      @statuses.each do |status|
+        if status.respond_to?(attribute)
+          return true if status.send(attribute) == match
+        end
+      end
+      return false
+    end
+
+    def tick_all(&block)
+      # Provides baseline functionality to + or - values from a given status, as this is
+      # the most common of implementations.
+      # Strings and other values are simply set.
+      # Yielding to an arbitrary block should curcumvent any issues with extension and post-effect hooks. 
+      @statuses.each do |status|
+        validate_modifier_existence(status)
+        status.modifiers.each do |key, value|
+          attribute = key.to_s
+          if (value.is_a?(Integer) || value.is_a?(Float))
+            eval("self.#{attribute} += #{value}") if self.respond_to?(attribute+"=")
+          else
+            send("#{attribute}=", value) if self.respond_to?(attribute+"=")
+          end
+        end
+        status.tick
+      end
+      yield(self, @statuses) if block_given?
+      return @statuses
+    end
+
+    def clear_expired_statuses
+      unexpired = @statuses.select { |status| status.duration != 0 }
+      diff = @statuses - unexpired
+      @statuses = unexpired
+      return diff
+    end
+
+    private
+
+    def validate_initial_attributes(affected_attributes)
+      invalid = affected_attributes.select {|att| !instance_variable_defined?(att) }
+      warn_about_attributes if invalid.length > 0
+    end
+
+    def validate_modifier_existence(status)
+      raise RuntimeError, "Given status does not respond to #modifiers." if !status.respond_to?(:modifiers)
+    end
+
+    def warn_about_attributes
+      warn("[#{Time.now}]: Gave affected_attributes in a Status that are not present on #{self.class.name}: #{invalids}.")
+    end
+
+  end
+
+end

data/lib/adjective/concerns/storable.rb

@@ -0,0 +1,134 @@
+module Adjective
+
+  module Storable
+
+    def initialize_storage_data(items = [], opts = {})
+      @items = items
+      @initialized_at = Time.now
+      @max_size = opts[:max_size] ||= :unlimited
+      @default_sort_method = opts[:default_sort_method] ||= :object_id
+      validate_inventory_capacity
+      [:items, :initialized_at, :max_size, :default_sort_method].each {|attribute| self.class.send(:attr_accessor, attribute) }
+    end
+
+    # Utility Methods
+    def empty?
+      @items.length === 0
+    end   
+
+    def full?
+      @max_size == :unlimited ? false : @items.length < @max_size
+    end
+
+    def can_store?(items)
+      return true if @max_size == :unlimited
+      return true if (Array(items).length + @items.length) <= @max_size
+      return false
+    end
+
+    def empty_slots
+      @max_size == :unlimited ? :unlimited : @max_size - @items.length
+    end
+
+    # Simple Search
+    # options for scope are: :all, :attributes, :values
+    def query(term, scope = :all)
+      validate_query_scope(scope)
+      matches = []
+      @items.each do |item|
+        chunks = []
+        attributes = item.instance_variables.map {|ivar| ivar.to_s.gsub("@", "").to_sym}
+        attributes.each do |attribute|
+          chunks.push(construct_query_data(attribute.to_s, item.send(attribute).to_s)[scope])
+        end
+        matches << item if chunks.join.include?(term)
+      end
+      return matches
+    end  
+
+    # Store - Put
+    def store(items)
+      if can_store?(items)
+        Array(items).each do |item|
+          @items << item 
+        end
+        return items
+      else
+        return false
+      end
+    end
+
+    # retrieve_by - Get
+    def retrieve_by(attribute, value)
+      @items.select do |item| 
+        item if item.respond_to?(attribute) && item.send(attribute) === value 
+      end
+    end  
+
+    # Dump - Delete all
+    def dump
+      outbound_items = @items
+      @items = []
+      return outbound_items
+    end
+
+    # Dump selection - Selective delete
+    def dump_by(attribute, value)
+      outbound_items = retrieve_by(attribute, value)
+      @items = @items.select {|item| !outbound_items.include?(item) }
+      return outbound_items
+    end    
+
+    # Sorting
+    def sort
+      @items.sort_by { |item| item.send(@default_sort_method) }
+      return @items
+    end
+
+    def sort!
+      @items = @items.sort_by { |item| item.send(@default_sort_method) }
+      return @items
+    end    
+
+    def sort_by(attribute, order = :asc)
+      sorted = @items.sort_by(&attribute)
+      return order == :asc ? sorted : sorted.reverse
+    end
+
+    def sort_by!(attribute, order = :asc)
+      sorted = @items.sort_by(&attribute)
+      return order == :asc ? @items = sorted : @items = sorted.reverse
+    end
+
+    alias_method :deposit, :store
+    alias_method :put, :store  
+    alias_method :get_by, :retrieve_by
+    alias_method :find_by, :retrieve_by        
+    alias_method :clear, :dump
+    alias_method :clear_by, :dump_by
+    alias_method :search, :query
+
+    private  
+
+    def validate_query_scope(scope)
+      raise ArgumentError, "[#{Time.now}]: Please provide :full, :attributes, or :values to the scope parameter: given #{scope}" if ![:all, :attributes, :values].include?(scope)
+    end
+
+    def construct_query_data(attribute, val)
+      # Delimiting with &: to avoid issues with intermingled data
+      return {
+        all: attribute + "&:" + val + "&:",
+        attributes: attribute + "&:",
+        values: val + "&:"
+      }
+    end      
+
+    def validate_inventory_capacity
+      return true if @max_size == :unlimited
+      total_length = @items.length
+      raise ArgumentError, "#{Time.now}]: items argument length larger than max size: max_size: #{@max_size}, items_length: #{total_length}" if total_length > @max_size   
+    end
+
+  end
+
+end

data/lib/adjective/concerns/temporable.rb

@@ -0,0 +1,94 @@
+module Adjective
+
+  module Temporable
+
+    # This is to be used to emulate turn-based interactions or to emulate basic time within the context of a parent class. 
+
+    # The idea behind setting an initial_duration is so you can see what the subject started out as
+    # instead of making an assumption. This could matter if multiple same-identity classes have the same attributes,
+    # but have different durations linked to them. 
+
+    # Initialize module data for Temporable
+    # @param opts [Hash]
+    # @return [Object]
+    # @example
+    #   initialize_temporality({max_duration: 5, remaining_duration: 4})
+    def initialize_temporality(opts={})
+      @max_duration = opts[:max_duration] ||= 1
+      @remaining_duration = opts[:remaining_duration] ||= @max_duration
+
+      throw_duration_theshold_error if invalid_durations?
+
+      [:max_duration, :remaining_duration].each do |attribute| 
+        self.class.send(:attr_accessor, attribute)
+      end
+      normalize_remaining_duration 
+      return self     
+    end
+
+    # Checks if the status is at it's maximum duration
+    # @return [Boolean]
+    # @example
+    #   SurrogateClass.max_duration? #=> True/False
+    def max_duration?
+      @max_duration == @remaining_duration
+    end
+
+    # Checks if remaining_duration is at 0.
+    # @return [Boolean]
+    # @example
+    #   SurrogateClass.expired? #=> True/False
+    def expired?
+      @remaining_duration == 0
+    end
+
+    # Checks if remaining_duration is at 1.
+    # @return [Boolean]
+    # @example
+    #   SurrogateClass.expired? #=> True/False
+    def expiring?
+      # This method seems like a meme, but I think it makes sense
+      @remaining_duration == 1
+    end
+
+    # Checks and sets remaining_duration if it is out of bounds.
+    # @return [Integer]
+    # @example
+    #   SurrogateClass.normalize_remaining_duration
+    def normalize_remaining_duration
+      @remaining_duration = @max_duration if @remaining_duration > @max_duration
+      @remaining_duration = 0 if @remaining_duration < 0
+    end   
+
+    # Extends the duration and keeps it within bounds.
+    # @param extension [Integer]
+    # @return [Integer]
+    # @example
+    #   SurrogateClass.extend_by(2)
+    def extend_by(extension)
+      @remaining_duration += extension
+      normalize_remaining_duration
+      return @remaining_duration
+    end           
+
+    private
+
+    # Triggers error to the thrown is thesholds are exceeed on initialization.
+    # @return [Boolean]
+    # @private
+    # @example
+    #   SurrogateClass.throw_duration_threshold_error
+    def throw_duration_theshold_error
+      raise ArgumentError, "Provded initial_duration or remaining_duration values exceed max_duration: max: #{@max_duration}, remaining: #{@remaining_duration}."
+    end
+
+    # Checks if initial durations are valid.
+    # @return [Boolean]
+    # @example
+    #   SurrogateClass.invalid_durations?
+    def invalid_durations?
+      @remaining_duration > @max_duration
+    end    
+  end
+
+end

data/lib/adjective/concerns/vulnerable.rb

@@ -0,0 +1,41 @@
+module Adjective
+
+  module Vulnerable
+    def initialize_vulnerability(hitpoints = 1, max_hitpoints = 10)
+      @hitpoints = hitpoints
+      @max_hitpoints = max_hitpoints
+      self.class.send(:attr_accessor, :hitpoints)
+      self.class.send(:attr_accessor, :max_hitpoints)     
+    end
+
+    def take_damage(damage)
+      @hitpoints -= damage
+      normalize_hitpoints
+      return self
+    end
+
+    def heal_to_full
+      @hitpoints = @max_hitpoints
+      normalize_hitpoints
+    end
+
+    def heal_for(healing)
+      @hitpoints += healing
+      normalize_hitpoints
+    end
+
+    def alive?
+      @hitpoints > 0
+    end
+
+    def dead?
+      @hitpoints == 0
+    end   
+
+    def normalize_hitpoints
+      @hitpoints = 0 if @hitpoints < 0
+      @hitpoints = @max_hitpoints if @hitpoints > @max_hitpoints
+    end  
+  end
+
+end

data/lib/adjective/status.rb

@@ -0,0 +1,137 @@
+module Adjective
+
+  # Status is different from something like an attack in that it applies
+  # to things that afflict the subject for one or more turns.
+  module Status
+
+    include Adjective::Temporable
+
+    # Initialize module data for Status
+    # @param opts [Hash]
+    # @return [Object]
+    # @example
+    #   class SurrogateClass
+    #     include Adjective::Status
+    #     initialize_status({affected_attributes: { hitpoints: 3}, max_duration: 5})
+    #   end
+    def initialize_status(opts = {})
+      attributes = opts[:affected_attributes] 
+      @modifiers = attributes ||= {}
+      @affected_attributes = attributes.map{|entry| entry[0]}
+
+      # @applied_at Can be used to track simple object intantation if class is created when status is applied.
+      # TODO: If held in memory, opts will need to be given a :timestamp with a value comparable with a Time object. (Custom values should help?)
+      # If the user wishes to sort by a specific attribute in Statusable, then they should pass a block and do so there. (Maybe?)
+      @applied_at = opts[:timestamp] ||= Time.now
+
+      [:initialized_at, :affected_attributes, :modifiers].each do |attribute| 
+        self.class.send(:attr_reader, attribute)
+      end
+      
+      initialize_temporality(opts)
+      normalize_remaining_duration
+      assign_affected_attributes
+      return self
+    end
+
+    # Will perform tick functionality, whose default action is to reduce @remaining_duration (from Temporable) by 1.
+    # Otherwise, it will accept a block and bypass all default functionality.
+    # @param block [Block]
+    # @return [Object]
+    # @example
+    #   SurrogateClass.tick
+    def tick(&block)
+      if block_given? 
+        yield(self) 
+      else
+        # Default
+        @remaining_duration -= 1
+      end
+      return self
+    end
+
+    # Checks if the status has a modifier present
+    # @return [Boolean]
+    # @example
+    #   SurrogateClass.has_modifier?(:hitpoints)
+    def has_modifier?(attribute)
+      @modifiers.key?(attribute)
+    end
+
+    # Adds or updates the modifier hash. 
+    # @param attribute [Symbol]
+    # @param value [Integer, Float, String]
+    # @return [Hash]
+    # @example
+    #   SurrogateClass.add_or_update_modifer(:hitpoints, 10)
+    def add_or_update_modifier(attribute, value)
+      if has_modifier?(attribute)
+        @modifiers[attribute] = value
+      else
+        @modifiers.store(attribute, value)
+      end
+      assign_affected_attributes
+      return @modifiers
+    end
+
+    # Updates the modifier in @modifiers. Will warn and NOT amend if modifier does not exist.
+    # @param attribute [Symbol]
+    # @param value [Integer, Float, String]
+    # @return [Hash]
+    # @example
+    #   SurrogateClass.update_modifier(:hitpoints, 12)
+    def update_modifier(attribute, value)
+      if has_modifier?(attribute)
+        @modifiers[attribute] = value
+        assign_affected_attributes
+      else
+        warn("[#{Time.now}]: Attempted to update a modifier that wasn't present: #{attribute}. Use #add_modifier or #add_or_update_modifier instead.")
+      end
+      return @modifiers
+    end
+
+    # Adds to the modifier to @modifiers. Will warn and NOT amend if modifier already exists.
+    # @param attribute [Symbol]
+    # @param value [Integer, Float, String]
+    # @return [Hash]
+    # @example
+    #   SurrogateClass.add_modifer(:strength, 20)
+    def add_modifier(attribute, value)
+      if !has_modifier?(attribute)
+        @modifiers.store(attribute, value)
+        assign_affected_attributes
+      else
+        warn("[#{Time.now}]: Attempted to add duplicate modifier: #{attribute}. The new value has NOT been set. (Currently '#{@modifiers[attribute]}'.")
+      end
+      return @modifiers
+    end 
+
+    # Removes the specified modifier from @modifers. 
+    # @param attribute [Symbol]
+    # @param value [Integer, Float, String]
+    # @return [Hash]
+    # @example
+    #   SurrogateClass.add_modifer(:strength, 20)
+    def remove_modifier(attribute)
+      if has_modifier?(attribute)
+        temp = {}.store(attribute, modifiers[attribute])
+        @modifiers.delete(attribute)
+      else
+        warn("[#{Time.now}]: Attempted to remove modifier that does not exist: #{attribute}")
+      end
+      return temp
+    end
+
+    private
+
+    # Converts the modifier hash into a digestable array for other modules to use. Includes '@' in modifier value,
+    # as the format for the metaprogramming in other modules requires the attribute to be called and set explicitly if not publicly writable.
+    # This should most likely be left alone and not called outside of the implementation here.
+    # @private
+    # @return [Hash]
+    def assign_affected_attributes
+      @affected_attributes.map!{|attribute| ("@"+attribute.to_s).to_sym }
+    end
+
+  end
+end

data/lib/adjective/table.rb

@@ -0,0 +1,73 @@
+require 'yaml'
+
+module Adjective
+  class Table
+    attr_accessor :name
+    attr_reader :data
+
+    def initialize(dir, name = nil)
+      file_existence_catch(dir)
+      @name = name
+      @data = YAML.load_file(dir)
+      @_created_at = Time.now
+    end
+
+    def load(dir)
+      file_existence_catch(dir)
+      @data = YAML.load_file(dir)
+    end
+
+    def set_exists?(name)
+      @data.key?(name)
+    end
+
+    private
+
+    def file_existence_catch(dir)
+      raise RuntimeError, "#{Time.now}]: Invalid path to YAML file: #{dir}" if !File.exist?(dir)
+    end
+
+  end
+
+  # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
+  # Will separate out when I get the dir structures set up properly.
+  # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
+   
+  class Table::Experience < Table
+    # This class sets a 'by index' paradigm and expects an ordered set
+    # to be present after being given the parsed YAML file data.
+
+    # This is primarily to keep the access points standardized and would only require
+    # someone consuming the library to call something like level.to_i to maintain the convention.
+
+    attr_reader :thresholds
+
+    def initialize(dir, name = nil)
+      # raise ArgumentError
+      super(dir, name)
+      @thresholds = @data[@name]
+
+      if !@thresholds.is_a?(Array)
+        raise RuntimeError, "#{Time.now}]: Experience table '#{@name}' is not an Array: #{@exp_thresholds.class}"
+      elsif threshold_sorted?
+        raise RuntimeError, "#{Time.now}]: Experience table '#{@name}' is not sequential: #{@exp_thresholds}"      
+      end
+    end
+
+    def at_level(level)
+      # Convenience methods to translate string cases might be worth it... but the 
+      # general convention is that you pass through whole integers to grab data that is 
+      # more reliable within the structure of the code itself. Going to just keep to
+      # convention for the moment.
+      raise RuntimeError, "#{Time.now}]: Level provided is not an Integer: #{level}" if !level.is_a?(Integer)
+      return @thresholds[level]
+    end
+
+    private
+
+    def threshold_sorted?
+      @thresholds != @thresholds.sort
+    end
+
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: adjective-rpg-engine
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Kevin Maze
@@ -45,6 +45,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/adjective.rb
+- lib/adjective/concerns/imbibable.rb
+- lib/adjective/concerns/statusable.rb
+- lib/adjective/concerns/storable.rb
+- lib/adjective/concerns/temporable.rb
+- lib/adjective/concerns/vulnerable.rb
+- lib/adjective/item.rb
+- lib/adjective/status.rb
+- lib/adjective/table.rb
 homepage: http://rubygems.org/gems/adjective-rpg-engine
 licenses:
 - MIT