tormenta20 0.2.1 → 0.2.2

data/src/ruby/tormenta20/models/classe.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "json"
+
+module Tormenta20
+  module Models
+    # Model representing a Classe (Character Class) in Tormenta20.
+    #
+    # Classes define the character's abilities, proficiencies, and progression.
+    #
+    # @example Find all spellcasting classes
+    #   Classe.conjuradores
+    #
+    # @example Get class HP information
+    #   guerreiro = Classe.find("guerreiro")
+    #   guerreiro.initial_hp    # => 20
+    #   guerreiro.hp_per_level  # => 5
+    #
+    # @!attribute [rw] id
+    #   @return [String] Unique identifier (e.g., "guerreiro")
+    # @!attribute [rw] name
+    #   @return [String] Class name (e.g., "Guerreiro")
+    # @!attribute [rw] hit_points
+    #   @return [Hash] Hit points data with "initial" and "per_level" keys
+    # @!attribute [rw] mana_points
+    #   @return [Hash] Mana points data with "per_level" key
+    # @!attribute [rw] skills
+    #   @return [Hash] Skills data with "mandatory", "choose_amount", "choose_from" keys
+    # @!attribute [rw] proficiencies
+    #   @return [Hash] Proficiencies with "weapons", "armors", "shields" keys
+    # @!attribute [rw] spellcasting
+    #   @return [Hash, nil] Spellcasting info or nil if class cannot cast spells
+    class Classe < Base
+      self.table_name = "classes"
+
+      validates :id, presence: true, uniqueness: true
+      validates :name, presence: true
+
+      # @!method conjuradores
+      #   Filter classes that can cast spells.
+      #   @return [ActiveRecord::Relation<Classe>]
+      scope :conjuradores, -> { where.not(spellcasting: nil) }
+
+      # Get initial hit points for this class.
+      #
+      # @return [Integer] Initial HP at level 1
+      def initial_hp
+        hit_points&.dig("initial") || 0
+      end
+
+      # Get hit points gained per level.
+      #
+      # @return [Integer] HP gained each level
+      def hp_per_level
+        hit_points&.dig("per_level") || 0
+      end
+
+      # Get mana points gained per level.
+      #
+      # @return [Integer] MP gained each level
+      def mp_per_level
+        mana_points&.dig("per_level") || 0
+      end
+
+      # Get mandatory skills for this class.
+      #
+      # @return [Array<String>] List of mandatory skill names
+      def mandatory_skills
+        skills&.dig("mandatory") || []
+      end
+
+      # Get number of skills to choose from available list.
+      #
+      # @return [Integer] Number of skills to choose
+      def choose_skills_amount
+        skills&.dig("choose_amount") || 0
+      end
+
+      # Get skills available to choose from.
+      #
+      # @return [Array<String>] List of available skill names
+      def available_skills
+        skills&.dig("choose_from") || []
+      end
+
+      # Get weapon proficiencies for this class.
+      #
+      # @return [Array<String>] List of weapon categories (e.g., ["simples", "marciais"])
+      def weapon_proficiencies
+        proficiencies&.dig("weapons") || []
+      end
+
+      # Get armor proficiencies for this class.
+      #
+      # @return [Array<String>] List of armor categories (e.g., ["leves", "pesadas"])
+      def armor_proficiencies
+        proficiencies&.dig("armors") || []
+      end
+
+      # Check if class has shield proficiency.
+      #
+      # @return [Boolean] true if proficient with shields
+      def shield_proficiency?
+        proficiencies&.dig("shields") || false
+      end
+
+      # Check if this class can cast spells.
+      #
+      # @return [Boolean] true if class has spellcasting ability
+      def conjurador?
+        !spellcasting.nil?
+      end
+
+      # Convert class to a hash representation.
+      #
+      # @return [Hash] Hash with all class attributes
+      def to_h
+        {
+          id: id,
+          name: name,
+          hit_points: hit_points,
+          mana_points: mana_points,
+          skills: skills,
+          proficiencies: proficiencies,
+          abilities: abilities,
+          powers: powers,
+          progression: progression,
+          spellcasting: spellcasting
+        }.compact
+      end
+    end
+  end
+end

data/src/ruby/tormenta20/models/divindade.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "json"
+
+module Tormenta20
+  module Models
+    # Model representing a Divindade (Deity) in Tormenta20.
+    #
+    # Deities grant powers to their followers and have specific energy types.
+    #
+    # @example Find deities with positive energy
+    #   Divindade.energia_positiva
+    #
+    # @example Get deity's granted powers
+    #   khalmyr = Divindade.find("khalmyr")
+    #   khalmyr.granted_powers  # => ["coragem_total", "espada_justiceira", ...]
+    #
+    # @!attribute [rw] id
+    #   @return [String] Unique identifier (e.g., "khalmyr")
+    # @!attribute [rw] name
+    #   @return [String] Deity name (e.g., "Khalmyr")
+    # @!attribute [rw] title
+    #   @return [String] Deity title (e.g., "O Deus da Justiça")
+    # @!attribute [rw] energy
+    #   @return [String] Energy type: "positiva", "negativa", or "qualquer"
+    # @!attribute [rw] granted_powers
+    #   @return [Array<String>] List of power IDs granted to followers
+    class Divindade < Base
+      self.table_name = "divindades"
+
+      # Valid energy types for deities.
+      ENERGIES = %w[positiva negativa qualquer].freeze
+
+      validates :id, presence: true, uniqueness: true
+      validates :name, presence: true
+      validates :energy, presence: true, inclusion: { in: ENERGIES }
+
+      # @!group Scopes
+
+      # @!method energia_positiva
+      #   Filter deities with positive energy.
+      #   @return [ActiveRecord::Relation<Divindade>]
+      scope :energia_positiva, -> { where(energy: "positiva") }
+
+      # @!method energia_negativa
+      #   Filter deities with negative energy.
+      #   @return [ActiveRecord::Relation<Divindade>]
+      scope :energia_negativa, -> { where(energy: "negativa") }
+
+      # @!method energia_qualquer
+      #   Filter deities with neutral/any energy.
+      #   @return [ActiveRecord::Relation<Divindade>]
+      scope :energia_qualquer, -> { where(energy: "qualquer") }
+
+      # @!method by_energy(energy)
+      #   Filter deities by energy type.
+      #   @param energy [String] Energy type (positiva, negativa, qualquer)
+      #   @return [ActiveRecord::Relation<Divindade>]
+      scope :by_energy, ->(e) { where(energy: e) }
+
+      # @!endgroup
+
+      # Get races that typically worship this deity.
+      #
+      # @return [Array<String>] List of race names
+      def races
+        devotees&.dig("races") || []
+      end
+
+      # Get classes that typically worship this deity.
+      #
+      # @return [Array<String>] List of class names
+      def classes
+        devotees&.dig("classes") || []
+      end
+
+      # Convert deity to a hash representation.
+      #
+      # @return [Hash] Hash with all deity attributes
+      def to_h
+        {
+          id: id,
+          name: name,
+          title: title,
+          description: description,
+          beliefs_objectives: beliefs_objectives,
+          holy_symbol: holy_symbol,
+          energy: energy,
+          preferred_weapon: preferred_weapon,
+          devotees: devotees,
+          granted_powers: granted_powers,
+          obligations_restrictions: obligations_restrictions
+        }.compact
+      end
+    end
+  end
+end

data/src/ruby/tormenta20/models/escudo.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "json"
+
+module Tormenta20
+  module Models
+    # Model representing an Escudo (Shield) in Tormenta20.
+    #
+    # Shields provide additional defense bonuses but may impose
+    # armor penalties on certain skill checks.
+    #
+    # @example Find all shields
+    #   Tormenta20.escudos.all
+    #
+    # @example Find shield with highest defense
+    #   Tormenta20.escudos.order(defense_bonus: :desc).first
+    #
+    # @!attribute [rw] id
+    #   @return [String] Unique identifier (e.g., "escudo_leve")
+    # @!attribute [rw] name
+    #   @return [String] Shield name in Portuguese
+    # @!attribute [rw] price
+    #   @return [String] Price in Tormenta currency
+    # @!attribute [rw] defense_bonus
+    #   @return [Integer] Defense bonus provided by the shield
+    # @!attribute [rw] armor_penalty
+    #   @return [Integer] Armor penalty for skill checks
+    # @!attribute [rw] weight
+    #   @return [String] Weight in slots/spaces
+    # @!attribute [rw] properties
+    #   @return [Array<String>] Special shield properties
+    # @!attribute [rw] description
+    #   @return [String, nil] Optional description
+    class Escudo < Base
+      self.table_name = "escudos"
+
+      validates :id, presence: true, uniqueness: true
+      validates :name, presence: true
+      validates :defense_bonus, presence: true
+
+      # Convert the shield to a hash representation.
+      #
+      # @return [Hash] Hash with all shield attributes (nil values excluded)
+      def to_h
+        {
+          id: id,
+          name: name,
+          price: price,
+          defense_bonus: defense_bonus,
+          armor_penalty: armor_penalty,
+          weight: weight,
+          properties: properties,
+          description: description
+        }.compact
+      end
+    end
+  end
+end

data/src/ruby/tormenta20/models/item.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "json"
+
+module Tormenta20
+  module Models
+    # Model representing an Item in Tormenta20.
+    #
+    # Items include general equipment, adventuring gear, tools,
+    # and other miscellaneous items.
+    #
+    # @example Find all items
+    #   Tormenta20.itens.all
+    #
+    # @example Find items by category
+    #   Tormenta20.itens.by_category("equipamento")
+    #
+    # @!attribute [rw] id
+    #   @return [String] Unique identifier (e.g., "corda_15m")
+    # @!attribute [rw] name
+    #   @return [String] Item name in Portuguese
+    # @!attribute [rw] category
+    #   @return [String, nil] Item category
+    # @!attribute [rw] price
+    #   @return [String] Price in Tormenta currency
+    # @!attribute [rw] weight
+    #   @return [String] Weight in slots/spaces
+    # @!attribute [rw] description
+    #   @return [String, nil] Item description
+    # @!attribute [rw] effects
+    #   @return [Array<String>, nil] Special effects or uses
+    class Item < Base
+      self.table_name = "itens"
+
+      validates :id, presence: true, uniqueness: true
+      validates :name, presence: true
+
+      # @!method by_category(category)
+      #   Filter items by category.
+      #   @param category [String] Category to filter by
+      #   @return [ActiveRecord::Relation<Item>]
+      scope :by_category, ->(c) { where(category: c) }
+
+      # Convert the item to a hash representation.
+      #
+      # @return [Hash] Hash with all item attributes (nil values excluded)
+      def to_h
+        {
+          id: id,
+          name: name,
+          category: category,
+          price: price,
+          weight: weight,
+          description: description,
+          effects: effects
+        }.compact
+      end
+    end
+  end
+end

data/src/ruby/tormenta20/models/magia.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "json"
+
+module Tormenta20
+  module Models
+    # Model representing a Magia (Spell) in Tormenta20.
+    #
+    # Spells are categorized by type (arcane, divine, universal), circle (1-5),
+    # and school (abjuration, evocation, etc.).
+    #
+    # @example Find all arcane spells
+    #   Magia.arcanas
+    #
+    # @example Find 3rd circle evocation spells
+    #   Magia.by_circle("3").by_school("evoc")
+    #
+    # @!attribute [rw] id
+    #   @return [String] Unique identifier (e.g., "bola_de_fogo")
+    # @!attribute [rw] name
+    #   @return [String] Spell name (e.g., "Bola de Fogo")
+    # @!attribute [rw] type
+    #   @return [String] Spell type: "arcana", "divina", or "universal"
+    # @!attribute [rw] circle
+    #   @return [String] Spell circle (1-5)
+    # @!attribute [rw] school
+    #   @return [String] Magic school code (abjur, adiv, conv, encan, evoc, ilus, necro, trans)
+    # @!attribute [rw] execution
+    #   @return [String] Casting time
+    # @!attribute [rw] range
+    #   @return [String] Spell range
+    # @!attribute [rw] duration
+    #   @return [String] Spell duration
+    # @!attribute [rw] description
+    #   @return [String] Full spell description
+    class Magia < Base
+      self.table_name = "magias"
+      self.inheritance_column = nil
+
+      validates :id, presence: true, uniqueness: true
+      validates :name, presence: true
+      validates :type, presence: true, inclusion: { in: %w[arcana divina universal] }
+      validates :circle, presence: true
+      validates :school, presence: true, inclusion: { in: %w[abjur adiv conv encan evoc ilus necro trans] }
+      validates :execution, presence: true
+      validates :range, presence: true
+      validates :duration, presence: true
+      validates :description, presence: true
+
+      # @!group Scopes
+
+      # @!method arcanas
+      #   Filter arcane spells only.
+      #   @return [ActiveRecord::Relation<Magia>]
+      scope :arcanas, -> { where(type: "arcana") }
+
+      # @!method divinas
+      #   Filter divine spells only.
+      #   @return [ActiveRecord::Relation<Magia>]
+      scope :divinas, -> { where(type: "divina") }
+
+      # @!method universais
+      #   Filter universal spells only.
+      #   @return [ActiveRecord::Relation<Magia>]
+      scope :universais, -> { where(type: "universal") }
+
+      # @!method by_circle(circle)
+      #   Filter spells by circle.
+      #   @param circle [String, Integer] The spell circle (1-5)
+      #   @return [ActiveRecord::Relation<Magia>]
+      scope :by_circle, ->(circle) { where(circle: circle.to_s) }
+
+      # @!method by_school(school)
+      #   Filter spells by magic school.
+      #   @param school [String] School code (abjur, adiv, conv, encan, evoc, ilus, necro, trans)
+      #   @return [ActiveRecord::Relation<Magia>]
+      scope :by_school, ->(school) { where(school: school) }
+
+      # @!method by_type(type)
+      #   Filter spells by type.
+      #   @param type [String] Spell type (arcana, divina, universal)
+      #   @return [ActiveRecord::Relation<Magia>]
+      scope :by_type, ->(type) { where(type: type) }
+
+      # @!endgroup
+
+      class << self
+        # Get all spells.
+        #
+        # @return [ActiveRecord::Relation<Magia>] All spells
+        def todas
+          all
+        end
+
+        # Get divine spells (alias for divinas scope).
+        #
+        # @return [ActiveRecord::Relation<Magia>] Divine spells
+        def divinas_list
+          divinas
+        end
+
+        # Get arcane spells (alias for arcanas scope).
+        #
+        # @return [ActiveRecord::Relation<Magia>] Arcane spells
+        def arcanas_list
+          arcanas
+        end
+
+        # Get universal spells (alias for universais scope).
+        #
+        # @return [ActiveRecord::Relation<Magia>] Universal spells
+        def universais_list
+          universais
+        end
+
+        # Find spells by circle (Portuguese alias).
+        #
+        # @param circle [String, Integer] The spell circle
+        # @return [ActiveRecord::Relation<Magia>] Spells of the given circle
+        def do_circulo(circle)
+          by_circle(circle)
+        end
+
+        # Find spells by school (Portuguese alias).
+        #
+        # @param school [String] The magic school code
+        # @return [ActiveRecord::Relation<Magia>] Spells of the given school
+        def da_escola(school)
+          by_school(school)
+        end
+      end
+
+      # Get target information as a structured hash.
+      #
+      # @return [Hash] Target info with :amount, :up_to, and :type keys
+      def target_info
+        {
+          amount: target_amount,
+          up_to: target_up_to&.positive?,
+          type: target_type
+        }
+      end
+
+      # Get effect details as a structured hash.
+      #
+      # @return [Hash, nil] Effect details or nil if no effect info exists
+      def effect_details_info
+        return nil unless effect_shape || effect_dimention || effect_size
+
+        {
+          shape: effect_shape,
+          dimention: effect_dimention,
+          size: effect_size,
+          other_details: effect_other_details
+        }.compact
+      end
+
+      # Get resistance information as a structured hash.
+      #
+      # @return [Hash, nil] Resistance info or nil if no resistance exists
+      def resistence_info
+        return nil unless resistence_effect || resistence_skill
+
+        {
+          effect: resistence_effect,
+          skill: resistence_skill
+        }.compact
+      end
+
+      # Get extra costs as a structured hash.
+      #
+      # @return [Hash, nil] Extra costs or nil if no extra costs exist
+      def extra_costs_info
+        return nil unless extra_costs_material_component
+
+        {
+          material_component: extra_costs_material_component,
+          material_component_cost: extra_costs_material_cost,
+          pm_debuff: extra_costs_pm_debuff,
+          pm_sacrifice: extra_costs_pm_sacrifice
+        }.compact
+      end
+
+      # Convert spell to a hash representation.
+      #
+      # @return [Hash] Hash with all spell attributes
+      def to_h
+        {
+          id: id,
+          name: name,
+          type: type,
+          circle: circle,
+          school: school,
+          execution: execution,
+          execution_details: execution_details,
+          range: range,
+          target: target_info,
+          effect: effect,
+          effect_details: effect_details_info,
+          area_effect: area_effect,
+          counterspell: counterspell,
+          duration: duration,
+          duration_details: duration_details,
+          resistence: resistence_info,
+          extra_costs: extra_costs_info,
+          description: description,
+          enhancements: enhancements,
+          effects: effects
+        }.compact
+      end
+
+      # @api private
+      def method_missing(method_name, *args)
+        return super unless respond_to_missing?(method_name)
+
+        send(method_name.to_s.gsub("?", ""), *args)
+      end
+
+      # @api private
+      def respond_to_missing?(method_name, include_private = false)
+        attributes.key?(method_name.to_s) || super
+      end
+    end
+  end
+end

data/src/ruby/tormenta20/models/material_especial.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "json"
+
+module Tormenta20
+  module Models
+    # Model representing a MaterialEspecial (Special Material) in Tormenta20.
+    #
+    # Special materials can be used to craft weapons and armor,
+    # providing additional effects and modifying the item's price.
+    #
+    # @example Find all special materials
+    #   Tormenta20.materiais_especiais.all
+    #
+    # @example Find a specific material
+    #   Tormenta20.materiais_especiais.find("adamante")
+    #
+    # @!attribute [rw] id
+    #   @return [String] Unique identifier (e.g., "adamante")
+    # @!attribute [rw] name
+    #   @return [String] Material name in Portuguese
+    # @!attribute [rw] description
+    #   @return [String, nil] Material description
+    # @!attribute [rw] applicable_to
+    #   @return [Array<String>, nil] Item types this material can be applied to
+    # @!attribute [rw] price_modifier
+    #   @return [String, nil] Price modifier when using this material
+    # @!attribute [rw] effects
+    #   @return [Array<String>, nil] Effects provided by this material
+    class MaterialEspecial < Base
+      self.table_name = "materiais_especiais"
+
+      validates :id, presence: true, uniqueness: true
+      validates :name, presence: true
+
+      # Convert the special material to a hash representation.
+      #
+      # @return [Hash] Hash with all material attributes (nil values excluded)
+      def to_h
+        {
+          id: id,
+          name: name,
+          description: description,
+          applicable_to: applicable_to,
+          price_modifier: price_modifier,
+          effects: effects
+        }.compact
+      end
+    end
+  end
+end

data/src/ruby/tormenta20/models/melhoria.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "json"
+
+module Tormenta20
+  module Models
+    # Model representing a Melhoria (Enhancement/Upgrade) in Tormenta20.
+    #
+    # Enhancements can be applied to weapons, armor, and other items
+    # to provide magical bonuses and special effects.
+    #
+    # @example Find all enhancements
+    #   Tormenta20.melhorias.all
+    #
+    # @example Find a specific enhancement
+    #   Tormenta20.melhorias.find("flamejante")
+    #
+    # @!attribute [rw] id
+    #   @return [String] Unique identifier (e.g., "flamejante")
+    # @!attribute [rw] name
+    #   @return [String] Enhancement name in Portuguese
+    # @!attribute [rw] description
+    #   @return [String, nil] Enhancement description
+    # @!attribute [rw] applicable_to
+    #   @return [Array<String>, nil] Item types this enhancement can be applied to
+    # @!attribute [rw] price
+    #   @return [String, nil] Price or price modifier for this enhancement
+    # @!attribute [rw] effects
+    #   @return [Array<String>, nil] Effects provided by this enhancement
+    class Melhoria < Base
+      self.table_name = "melhorias"
+
+      validates :id, presence: true, uniqueness: true
+      validates :name, presence: true
+
+      # Convert the enhancement to a hash representation.
+      #
+      # @return [Hash] Hash with all enhancement attributes (nil values excluded)
+      def to_h
+        {
+          id: id,
+          name: name,
+          description: description,
+          applicable_to: applicable_to,
+          price: price,
+          effects: effects
+        }.compact
+      end
+    end
+  end
+end