tormenta20 0.2.0 → 0.2.2

data/src/json/regras/propositos_armas.json

@@ -0,0 +1,37 @@
+{
+  "id": "propositos_armas",
+  "name": "Propósitos de Armas",
+  "description": "Armas são classificadas por propósito: corpo a corpo ou à distância.",
+  "tipos": [
+    {
+      "id": "corpo_a_corpo",
+      "name": "Corpo a Corpo",
+      "description": "Podem ser usadas para atacar alvos adjacentes.",
+      "teste": "Luta",
+      "bonus_dano": "Força"
+    },
+    {
+      "id": "distancia",
+      "name": "Ataque à Distância",
+      "description": "Podem ser usadas para atacar alvos adjacentes ou à distância.",
+      "teste": "Pontaria",
+      "subtipos": [
+        {
+          "id": "arremesso",
+          "name": "Arremesso",
+          "description": "A própria arma é atirada, como uma adaga ou azagaia.",
+          "sacar": "acao_movimento",
+          "bonus_dano": "Força"
+        },
+        {
+          "id": "disparo",
+          "name": "Disparo",
+          "description": "A arma dispara um projétil, como um arco atira flechas.",
+          "sacar_municao": "acao_livre",
+          "recarregar": "duas_maos",
+          "bonus_dano": null
+        }
+      ]
+    }
+  ]
+}

data/src/json/regras/tipos_dano.json

@@ -0,0 +1,25 @@
+{
+  "id": "tipos_dano",
+  "name": "Tipos de Dano",
+  "description": "Armas tipicamente causam dano por corte, impacto ou perfuração.",
+  "tipos": [
+    {
+      "id": "corte",
+      "name": "Corte",
+      "symbol": "C",
+      "description": "Dano causado por lâminas afiadas."
+    },
+    {
+      "id": "impacto",
+      "name": "Impacto",
+      "symbol": "I",
+      "description": "Dano causado por golpes contundentes."
+    },
+    {
+      "id": "perfuracao",
+      "name": "Perfuração",
+      "symbol": "P",
+      "description": "Dano causado por pontas penetrantes."
+    }
+  ]
+}

data/src/json/regras/venenos.json

@@ -0,0 +1,45 @@
+{
+  "id": "venenos",
+  "name": "Regras de Venenos",
+  "description": "Venenos são classificados de acordo com o método de inoculação.",
+  "metodos_inoculacao": [
+    {
+      "id": "contato",
+      "name": "Contato",
+      "description": "Inoculados via um ataque que acerte (ou se a vítima toca o objeto envenenado).",
+      "aplicar": {
+        "acao": "movimento",
+        "teste_acidente": {
+          "dado": "1d6",
+          "resultado_acidente": 1,
+          "efeito": "se envenena acidentalmente"
+        }
+      },
+      "duracao": "até acertar um ataque ou fim da cena"
+    },
+    {
+      "id": "inalacao",
+      "name": "Inalação",
+      "description": "Inoculados via respiração. São armazenados em frascos que podem ser arremessados em alcance curto.",
+      "area": {
+        "forma": "cubo",
+        "lado": 3
+      },
+      "nota": "Prender a respiração não impede a inoculação"
+    },
+    {
+      "id": "ingestao",
+      "name": "Ingestão",
+      "description": "Inoculados através da ingestão de comida ou bebida."
+    }
+  ],
+  "resistencia": {
+    "teste": "Fortitude",
+    "cd": "definida pelo aplicador",
+    "atributo_chave": "Int"
+  },
+  "condicao": {
+    "nome": "envenenada",
+    "nota": "Curar esta condição encerra quaisquer efeitos de veneno (mas não recupera PV perdidos)"
+  }
+}

data/src/ruby/tormenta20/database.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "sqlite3"
+require "fileutils"
+
+module Tormenta20
+  # Database connection and setup management for Tormenta20.
+  #
+  # This module handles all database operations including connection management,
+  # schema creation, and data seeding.
+  #
+  # @example Setup with default options
+  #   Tormenta20::Database.setup
+  #
+  # @example Setup with custom database path
+  #   Tormenta20::Database.setup(db_path: "/custom/path/tormenta20.sqlite3")
+  module Database
+    class << self
+      # @!attribute [rw] mode
+      #   @return [Symbol] Current database mode (:builtin, :build, or :lazy)
+      attr_accessor :mode
+
+      # @!attribute [rw] db_path
+      #   @return [String] Path to the SQLite database file
+      attr_accessor :db_path
+
+      # Initialize and configure the database connection.
+      #
+      # @param mode [Symbol] Database initialization mode:
+      #   - `:builtin` - Use pre-built database (connects immediately)
+      #   - `:build` - Build database on load (creates if missing, then connects)
+      #   - `:lazy` - Build database on first use (default)
+      # @param db_path [String, nil] Custom path to SQLite database file.
+      #   If nil, uses the default path.
+      # @return [void]
+      # @raise [ArgumentError] If an invalid mode is provided
+      #
+      # @example Default lazy setup
+      #   Database.setup
+      #
+      # @example Immediate connection with builtin database
+      #   Database.setup(mode: :builtin)
+      def setup(mode: :lazy, db_path: nil)
+        @mode = mode
+        @db_path = db_path || default_db_path
+        @setup_done = true
+
+        case mode
+        when :builtin
+          connect_to_database
+        when :build
+          ensure_database_exists
+          connect_to_database
+        when :lazy
+          # Connection will be established on first use via ensure_connected
+          nil
+        else
+          raise ArgumentError, "Invalid mode: #{mode}. Use :builtin, :build, or :lazy"
+        end
+      end
+
+      # Ensure database is connected, setting up if needed.
+      #
+      # This method is called automatically when models are accessed.
+      # It handles lazy initialization of the database connection.
+      #
+      # @return [void]
+      def ensure_connected
+        setup unless @setup_done
+        connect_to_database unless connected?
+      end
+
+      # Establish connection to the SQLite database.
+      #
+      # Creates the database if it doesn't exist (in lazy mode) and
+      # establishes an ActiveRecord connection.
+      #
+      # @return [void]
+      def connect_to_database
+        return if connected?
+
+        ensure_database_exists if mode == :lazy
+
+        ActiveRecord::Base.establish_connection(
+          adapter: "sqlite3",
+          database: db_path,
+          pool: 5,
+          timeout: 5000
+        )
+
+        @connected = true
+      end
+
+      # Check if database connection is active.
+      #
+      # @return [Boolean] true if connected, false otherwise
+      def connected?
+        @connected == true && ActiveRecord::Base.connected?
+      rescue StandardError
+        false
+      end
+
+      # Ensure database file and schema exist.
+      #
+      # Creates the database directory, file, and runs the schema
+      # if the database doesn't exist.
+      #
+      # @return [void]
+      def ensure_database_exists
+        db_dir = File.dirname(db_path)
+        FileUtils.mkdir_p(db_dir) unless Dir.exist?(db_dir)
+
+        needs_seed = !File.exist?(db_path)
+
+        return unless needs_seed
+
+        # Create empty database
+        SQLite3::Database.new(db_path).close
+
+        # Run schema if available
+        run_schema if schema_exists?
+
+        # Seed data after schema creation
+        seed_database
+      end
+
+      # Seed database with data from JSON files.
+      #
+      # @return [void]
+      def seed_database
+        return if Seeder.seeded?
+
+        Seeder.seed_all(verbose: false)
+      end
+
+      # Run pending database migrations.
+      #
+      # @return [void]
+      def migrate
+        connect_to_database
+        ActiveRecord::MigrationContext.new(migrations_path, ActiveRecord::SchemaMigration).migrate
+      end
+
+      # Rollback database migrations.
+      #
+      # @param steps [Integer] Number of migrations to rollback
+      # @return [void]
+      def rollback(steps: 1)
+        connect_to_database
+        ActiveRecord::MigrationContext.new(migrations_path, ActiveRecord::SchemaMigration).rollback(steps)
+      end
+
+      # Get current database migration version.
+      #
+      # @return [Integer] Current migration version number
+      def version
+        connect_to_database
+        ActiveRecord::Base.connection.migration_context.current_version
+      end
+
+      # Reset database by dropping and recreating it.
+      #
+      # @return [void]
+      # @note This will delete all data in the database
+      def reset
+        disconnect
+        File.delete(db_path) if File.exist?(db_path)
+        ensure_database_exists
+        connect_to_database
+      end
+
+      # Disconnect from the database.
+      #
+      # @return [void]
+      def disconnect
+        ActiveRecord::Base.remove_connection if connected?
+        @connected = false
+      end
+
+      # Get the default database file path.
+      #
+      # @return [String] Absolute path to the default database file
+      def default_db_path
+        File.expand_path("../../../db/tormenta20.sqlite3", __dir__)
+      end
+
+      # Get the schema SQL file path.
+      #
+      # @return [String] Absolute path to the schema.sql file
+      def schema_path
+        File.expand_path("../../../db/schema.sql", __dir__)
+      end
+
+      # Get the migrations directory path.
+      #
+      # @return [String] Absolute path to the migrations directory
+      def migrations_path
+        File.expand_path("../../../db/migrate", __dir__)
+      end
+
+      private
+
+      # Check if schema file exists.
+      #
+      # @return [Boolean] true if schema.sql exists
+      # @api private
+      def schema_exists?
+        File.exist?(schema_path)
+      end
+
+      # Run schema SQL file to create database tables.
+      #
+      # @return [void]
+      # @api private
+      def run_schema
+        connect_to_database
+        sql = File.read(schema_path)
+        # Use execute_batch to handle multi-statement SQL including triggers
+        ActiveRecord::Base.connection.raw_connection.execute_batch(sql)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "json"
+
+module Tormenta20
+  module Models
+    # Model representing an Arma (Weapon) in Tormenta20.
+    #
+    # Weapons are categorized by type (simple, martial, exotic, firearm)
+    # and can be either melee or ranged.
+    #
+    # @example Find all martial weapons
+    #   Tormenta20.armas.marciais
+    #
+    # @example Find ranged weapons
+    #   Tormenta20.armas.ranged
+    #
+    # @example Find weapons by damage type
+    #   Tormenta20.armas.by_damage_type("corte")
+    #
+    # @!attribute [rw] id
+    #   @return [String] Unique identifier (e.g., "espada_longa")
+    # @!attribute [rw] name
+    #   @return [String] Weapon name in Portuguese
+    # @!attribute [rw] category
+    #   @return [String] Weapon category: "simples", "marciais", "exoticas", or "fogo"
+    # @!attribute [rw] price
+    #   @return [String] Price in Tormenta currency
+    # @!attribute [rw] damage
+    #   @return [String] Damage dice (e.g., "1d8")
+    # @!attribute [rw] damage_type
+    #   @return [String] Type of damage: "corte", "perfuracao", "impacto"
+    # @!attribute [rw] critical
+    #   @return [String] Critical hit modifier (e.g., "19/x2")
+    # @!attribute [rw] range
+    #   @return [String, nil] Range for ranged weapons, nil for melee
+    # @!attribute [rw] weight
+    #   @return [String] Weight in slots/spaces
+    # @!attribute [rw] properties
+    #   @return [Array<String>] Special weapon properties
+    # @!attribute [rw] description
+    #   @return [String, nil] Optional description
+    class Arma < Base
+      self.table_name = "armas"
+
+      # @return [Array<String>] Valid weapon categories
+      CATEGORIES = %w[simples marciais exoticas fogo].freeze
+
+      validates :id, presence: true, uniqueness: true
+      validates :name, presence: true
+      validates :category, presence: true, inclusion: { in: CATEGORIES }
+
+      # @!method simples
+      #   Filter simple weapons only.
+      #   @return [ActiveRecord::Relation<Arma>]
+      scope :simples, -> { where(category: "simples") }
+
+      # @!method marciais
+      #   Filter martial weapons only.
+      #   @return [ActiveRecord::Relation<Arma>]
+      scope :marciais, -> { where(category: "marciais") }
+
+      # @!method exoticas
+      #   Filter exotic weapons only.
+      #   @return [ActiveRecord::Relation<Arma>]
+      scope :exoticas, -> { where(category: "exoticas") }
+
+      # @!method fogo
+      #   Filter firearms only.
+      #   @return [ActiveRecord::Relation<Arma>]
+      scope :fogo, -> { where(category: "fogo") }
+
+      # @!method by_category(category)
+      #   Filter weapons by category.
+      #   @param category [String] Category to filter by
+      #   @return [ActiveRecord::Relation<Arma>]
+      scope :by_category, ->(c) { where(category: c) }
+
+      # @!method by_damage_type(type)
+      #   Filter weapons by damage type.
+      #   @param type [String] Damage type: "corte", "perfuracao", or "impacto"
+      #   @return [ActiveRecord::Relation<Arma>]
+      scope :by_damage_type, ->(t) { where(damage_type: t) }
+
+      # @!method ranged
+      #   Filter ranged weapons only (weapons with a range value).
+      #   @return [ActiveRecord::Relation<Arma>]
+      scope :ranged, -> { where.not(range: nil) }
+
+      # @!method melee
+      #   Filter melee weapons only (weapons without a range value).
+      #   @return [ActiveRecord::Relation<Arma>]
+      scope :melee, -> { where(range: nil) }
+
+      # Check if this weapon is ranged.
+      #
+      # @return [Boolean] true if the weapon has a range value
+      def ranged?
+        !range.nil?
+      end
+
+      # Convert the weapon to a hash representation.
+      #
+      # @return [Hash] Hash with all weapon attributes (nil values excluded)
+      def to_h
+        {
+          id: id,
+          name: name,
+          category: category,
+          price: price,
+          damage: damage,
+          damage_type: damage_type,
+          critical: critical,
+          range: range,
+          weight: weight,
+          properties: properties,
+          description: description
+        }.compact
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "json"
+
+module Tormenta20
+  module Models
+    # Model representing an Armadura (Armor) in Tormenta20.
+    #
+    # Armors provide defense bonuses but may impose armor penalties.
+    # They are categorized as light (leve) or heavy (pesada).
+    #
+    # @example Find all light armors
+    #   Tormenta20.armaduras.leves
+    #
+    # @example Find heavy armors sorted by defense
+    #   Tormenta20.armaduras.pesadas.order(defense_bonus: :desc)
+    #
+    # @!attribute [rw] id
+    #   @return [String] Unique identifier (e.g., "couro")
+    # @!attribute [rw] name
+    #   @return [String] Armor name in Portuguese
+    # @!attribute [rw] category
+    #   @return [String] Armor category: "leve" or "pesada"
+    # @!attribute [rw] price
+    #   @return [String] Price in Tormenta currency
+    # @!attribute [rw] defense_bonus
+    #   @return [Integer] Defense bonus provided by the armor
+    # @!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 armor properties
+    # @!attribute [rw] description
+    #   @return [String, nil] Optional description
+    class Armadura < Base
+      self.table_name = "armaduras"
+
+      # @return [Array<String>] Valid armor categories
+      CATEGORIES = %w[leve pesada].freeze
+
+      validates :id, presence: true, uniqueness: true
+      validates :name, presence: true
+      validates :category, presence: true, inclusion: { in: CATEGORIES }
+      validates :defense_bonus, presence: true
+
+      # @!method leves
+      #   Filter light armors only.
+      #   @return [ActiveRecord::Relation<Armadura>]
+      scope :leves, -> { where(category: "leve") }
+
+      # @!method pesadas
+      #   Filter heavy armors only.
+      #   @return [ActiveRecord::Relation<Armadura>]
+      scope :pesadas, -> { where(category: "pesada") }
+
+      # @!method by_category(category)
+      #   Filter armors by category.
+      #   @param category [String] Category: "leve" or "pesada"
+      #   @return [ActiveRecord::Relation<Armadura>]
+      scope :by_category, ->(c) { where(category: c) }
+
+      # Check if this is a light armor.
+      #
+      # @return [Boolean] true if armor category is "leve"
+      def leve?
+        category == "leve"
+      end
+
+      # Check if this is a heavy armor.
+      #
+      # @return [Boolean] true if armor category is "pesada"
+      def pesada?
+        category == "pesada"
+      end
+
+      # Convert the armor to a hash representation.
+      #
+      # @return [Hash] Hash with all armor attributes (nil values excluded)
+      def to_h
+        {
+          id: id,
+          name: name,
+          category: category,
+          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/base.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module Tormenta20
+  # Contains all ActiveRecord models for Tormenta20 data.
+  module Models
+    # Abstract base class for all Tormenta20 models.
+    #
+    # All models in this library inherit from this class, which itself
+    # inherits from ActiveRecord::Base. This provides common functionality
+    # and ensures all models share the same database connection.
+    #
+    # @abstract Subclass and set table_name to create a new model
+    class Base < ActiveRecord::Base
+      self.abstract_class = true
+    end
+  end
+end