amar-rpg 2.0.1

data/includes/class_monster_new.rb

@@ -0,0 +1,551 @@
+# Monster/Animal NPC class for the new 3-tier system
+# This creates simplified NPCs for non-humanoid encounters
+
+class MonsterNew
+  attr_accessor :name, :type, :level, :sex, :description, :weight
+  attr_accessor :SIZE, :BP, :DB, :MD, :ENC
+  attr_accessor :tiers, :armor, :special_abilities, :spells
+  
+  def initialize(monster_type, level = 1)
+    @type = monster_type
+    @level = level
+    @sex = ["M", "F"].sample  # Even monsters have gender sometimes
+    
+    # Load monster stats if not loaded
+    unless defined?($MonsterStats)
+      load File.join($pgmdir, "includes/tables/monster_stats_new.rb")
+    end
+    
+    # Get stats template
+    stats = get_monster_stats(@type)
+    
+    # Set name based on type
+    @name = @type.gsub(/Monster:|Animal:|Small |Large /, "").strip.capitalize
+    @description = stats["description"]
+    @special_abilities = stats["special"]
+    
+    # Generate weight and SIZE
+    if stats["weight_range"]
+      # New system: use weight range and calculate SIZE
+      @weight = rand(stats["weight_range"][0]..stats["weight_range"][1])
+      @SIZE = calculate_size_from_weight(@weight)
+    elsif stats["size_range"]
+      # Legacy system: convert old SIZE to approximate weight
+      old_size = rand(stats["size_range"][0]..stats["size_range"][1])
+      # Convert old SIZE to weight (rough approximation)
+      @weight = size_to_weight(old_size)
+      @SIZE = calculate_size_from_weight(@weight)
+    else
+      # Default human-like range centered around 70kg
+      # Using a more realistic distribution
+      base_weight = 60
+      variation = rand(-10..20)  # Slightly skewed toward heavier
+      @weight = base_weight + variation + rand(10)
+      @weight = [@weight, 40].max  # Minimum weight
+      @SIZE = calculate_size_from_weight(@weight)
+    end
+    
+    # Initialize tiers with simplified structure for monsters
+    @tiers = {
+      "BODY" => {
+        "level" => stats["base_body"] + (@level / 2),
+        "Strength" => { "level" => stats["base_body"] + rand(0..1) },
+        "Endurance" => { "level" => stats["base_body"] + rand(0..1) },
+        "Melee Combat" => { 
+          "level" => stats["base_body"],
+          "skills" => generate_combat_skills(stats["skills"])
+        },
+        "Missile Combat" => {
+          "level" => 0,
+          "skills" => {}
+        },
+        "Athletics" => {
+          "level" => stats["base_body"] + rand(-1..1),
+          "skills" => generate_athletics_skills(stats)
+        }
+      },
+      "MIND" => {
+        "level" => stats["base_mind"] + (@level / 3),
+        "Intelligence" => { "level" => stats["base_mind"] },
+        "Awareness" => {
+          "level" => stats["base_mind"] + rand(0..1),
+          "skills" => generate_awareness_skills(stats)
+        }
+      },
+      "SPIRIT" => {
+        "level" => stats["base_spirit"],
+        "Casting" => { "level" => stats["base_spirit"] > 0 ? rand(1..3) : 0 },
+        "Attunement" => { "level" => stats["base_spirit"] > 0 ? rand(1..2) : 0, "skills" => {} }
+      }
+    }
+    
+    # Add magical abilities ONLY for truly magical creatures (not animals)
+    if stats["base_spirit"] > 0 && !@type.match?(/animal:/i)
+      # Dragons get Earth magic, other magical creatures get varied
+      if @type =~ /dragon/i
+        @tiers["SPIRIT"]["Attunement"]["skills"]["Earth"] = @level + rand(2..4)
+      elsif @type =~ /drake/i
+        @tiers["SPIRIT"]["Attunement"]["skills"]["Fire"] = @level + rand(1..3)
+      elsif @type =~ /elemental/i
+        element = ["Fire", "Water", "Air", "Earth"].sample
+        @tiers["SPIRIT"]["Attunement"]["skills"][element] = @level + rand(2..4)
+      elsif @type =~ /undead|zombie|skeleton|lich/i
+        @tiers["SPIRIT"]["Attunement"]["skills"]["Death"] = @level + rand(1..3)
+      elsif @type =~ /vampire|werewolf|faerie|wyvern/i
+        # Specific magical monsters
+        domain = ["Fire", "Water", "Air", "Earth", "Life", "Death", "Mind"].sample
+        @tiers["SPIRIT"]["Attunement"]["skills"][domain] = @level + rand(1..2)
+      end
+      # Do NOT give magic to generic creatures or animals
+    end
+    
+    # Calculate derived stats
+    calculate_derived_stats
+    
+    # Generate spells for magical creatures (not animals)
+    generate_spells if stats["base_spirit"] > 0 && !@type.match?(/animal:/i)
+    
+    # Set armor
+    set_armor(stats["armor"])
+  end
+  
+  private
+  
+  def size_to_weight(old_size)
+    # Convert old SIZE system to approximate weight for backward compatibility
+    # Old system: SIZE 8-10 for humans, SIZE 15-20 for dragons
+    case old_size
+    when 0..1 then rand(5..15)
+    when 2 then rand(15..30)
+    when 3 then rand(30..60)
+    when 4 then rand(60..90)
+    when 5 then rand(90..135)
+    when 6 then rand(135..180)
+    when 7 then rand(180..240)
+    when 8 then rand(240..300)
+    when 9 then rand(300..375)
+    when 10 then rand(375..450)
+    when 11 then rand(450..525)
+    when 12 then rand(525..600)
+    when 13 then rand(600..700)
+    when 14 then rand(700..800)
+    when 15 then rand(800..900)
+    when 16 then rand(900..1000)
+    when 17 then rand(1000..1200)
+    when 18 then rand(1200..1400)
+    when 19 then rand(1400..1600)
+    when 20 then rand(1600..1800)
+    else old_size * 90  # Rough approximation for very large creatures
+    end
+  end
+  
+  def calculate_size_from_weight(weight)
+    # SIZE system based on weight with half-sizes - matches NPC class
+    case weight
+    when 0...10 then 0.5
+    when 10...15 then 1
+    when 15...20 then 1.5
+    when 20...35 then 2
+    when 35...50 then 2.5
+    when 50...75 then 3
+    when 75...100 then 3.5
+    when 100...125 then 4
+    when 125...150 then 4.5
+    when 150...188 then 5
+    when 188...225 then 5.5
+    when 225...263 then 6
+    when 263...300 then 6.5
+    when 300...350 then 7
+    when 350...400 then 7.5
+    when 400...450 then 8
+    when 450...500 then 8.5
+    when 500...550 then 9
+    when 550...600 then 9.5
+    when 600...663 then 10
+    when 663...725 then 10.5
+    when 725...788 then 11
+    when 788...850 then 11.5
+    when 850...925 then 12
+    when 925...1000 then 12.5
+    when 1000...1075 then 13
+    when 1075...1150 then 13.5
+    when 1150...1225 then 14
+    when 1225...1300 then 14.5
+    when 1300...1375 then 15
+    when 1375...1450 then 15.5
+    when 1450...1525 then 16
+    when 1525...1600 then 16.5
+    else
+      # For very large creatures, add 0.5 per 100kg
+      16.5 + ((weight - 1600) / 100.0).floor * 0.5
+    end
+  end
+  
+  def generate_combat_skills(skill_list)
+    skills = {}
+
+    skill_list.each do |skill_name|
+      case skill_name.downcase
+      when /bite/
+        skills["Bite"] = @level + rand(2..4)  # Natural attacks are effective
+      when /claw/
+        skills["Claw"] = @level + rand(2..4)
+      when /tusk/
+        skills["Tusk"] = @level + rand(1..3)
+      when /tail/
+        skills["Tail"] = @level + rand(1..3)
+      when /sword/
+        skills["Sword"] = @level + rand(1..3)
+      when /spear/
+        skills["Spear"] = @level + rand(1..3)
+      when /dagger/
+        skills["Dagger"] = @level + rand(0..2)
+      when /club/
+        skills["Club"] = @level + rand(0..2)
+      when /unarmed/
+        skills["Unarmed"] = @level + rand(2..4)
+      when /grappl/
+        skills["Grappling"] = @level + rand(1..3)
+      end
+    end
+
+    # Ensure at least one combat skill with a reasonable level
+    if skills.empty?
+      skills["Unarmed"] = @level + rand(2..3)
+    end
+
+    skills
+  end
+
+  def generate_athletics_skills(stats)
+    skills = {}
+
+    # Base athletics skills appropriate for all creatures
+    skills["Dodge"] = @level + rand(0..2)
+
+    # Movement skills based on creature type
+    case stats["type"]
+    when "Undead"
+      # Undead don't swim or climb well, but can move quietly
+      skills["Move quietly"] = @level + rand(0..2)
+      skills["Hide"] = @level + rand(-1..1)
+      # Skeletons and zombies are slow
+      if @name.downcase.include?("skeleton") || @name.downcase.include?("zombie")
+        skills["Running"] = rand(0..1)  # Very slow
+      else
+        skills["Running"] = @level + rand(-1..1)
+      end
+    when "Animal"
+      # Animals have natural athletics
+      skills["Running"] = @level + rand(0..2)
+      skills["Jumping"] = @level + rand(0..1)
+      # Aquatic animals can swim
+      if @name.downcase.include?("fish") || @name.downcase.include?("shark")
+        skills["Swimming"] = @level + rand(2..4)
+      elsif @name.downcase.include?("bear") || @name.downcase.include?("dog")
+        skills["Swimming"] = rand(1..2)
+      end
+      # Climbing for appropriate animals
+      if @name.downcase.include?("bear") || @name.downcase.include?("monkey")
+        skills["Climbing"] = @level + rand(1..3)
+      end
+      # Stealth for predators
+      if stats["skills"].any? { |s| s.downcase.include?("stealth") || s.downcase.include?("ambush") }
+        skills["Move quietly"] = @level + rand(1..3)
+        skills["Hide"] = @level + rand(0..2)
+      end
+    when "Monster"
+      # Most monsters have standard athletics
+      skills["Running"] = @level + rand(-1..2)
+      # Flying creatures
+      if stats["skills"].any? { |s| s.downcase.include?("flight") || s.downcase.include?("fly") }
+        skills["Flying"] = @level + rand(2..4)
+      end
+      # Stealthy monsters
+      if @name.downcase.include?("goblin") || stats["skills"].include?("Stealth")
+        skills["Move quietly"] = @level + rand(1..3)
+        skills["Hide"] = @level + rand(1..3)
+      end
+      # Large monsters don't hide well
+      if @weight > 500
+        skills["Hide"] = rand(0..1) if skills["Hide"]
+        skills["Move quietly"] = rand(0..1) if skills["Move quietly"]
+      end
+    else
+      # Default fallback
+      skills["Running"] = @level + rand(-1..1)
+    end
+
+    # Remove any skills with 0 or negative values
+    skills.delete_if { |_, v| v <= 0 }
+
+    skills
+  end
+  
+  def calculate_derived_stats
+    body = @tiers["BODY"]["level"]
+    mind = @tiers["MIND"]["level"]
+    spirit = @tiers["SPIRIT"]["level"]
+
+    # Body Points: SIZE * 2 + Fortitude / 3 (same as NPC class)
+    fortitude = get_skill_total("BODY", "Endurance", "Fortitude")
+    @BP = (@SIZE * 2 + fortitude / 3.0).round
+
+    # Damage Bonus: (SIZE + Wield weapon) / 3 (same as NPC class)
+    wield_weapon = get_skill_total("BODY", "Strength", "Wield weapon")
+    @DB = ((@SIZE + wield_weapon) / 3.0).round
+
+    # Magic Defense: (Mental fortitude + Attunement/Self) / 3 (same as NPC class)
+    mental_fortitude = get_skill_total("MIND", "Learning", "Mental fortitude")
+    attunement_self = get_skill_total("SPIRIT", "Magic", "Attunement/Self")
+    @MD = ((mental_fortitude + attunement_self) / 3.0).round
+
+    # Encumbrance (monsters don't carry much)
+    @ENC = 0
+  end
+  
+  def set_armor(armor_desc)
+    return unless armor_desc
+    
+    if armor_desc =~ /Natural \((\d+) AP\)/
+      @armor = {
+        name: "Natural armor",
+        ap: $1.to_i,
+        enc: 0
+      }
+    else
+      @armor = {
+        name: armor_desc,
+        ap: 1,
+        enc: 0
+      }
+    end
+  end
+  
+  def generate_spells
+    # Load spell tables if not loaded
+    unless defined?($SpellDatabase)
+      load File.join($pgmdir, "includes/tables/spells_new.rb")
+    end
+    
+    @spells = []
+    
+    # Determine primary domain
+    domain = nil
+    highest_skill = 0
+    
+    if @tiers["SPIRIT"]["Attunement"]["skills"]
+      @tiers["SPIRIT"]["Attunement"]["skills"].each do |dom, skill|
+        if skill > highest_skill
+          domain = dom
+          highest_skill = skill
+        end
+      end
+    end
+    
+    return unless domain
+    
+    # Calculate spell count based on level and domain skill
+    spell_count = (@level + highest_skill) / 2
+    spell_count = [spell_count, 1].max
+    spell_count = [spell_count, 20].min  # Cap at 20 spells
+    
+    # Dragons get more spells
+    spell_count = (@level * 2) if @type =~ /dragon/i
+    spell_count = [spell_count, 30].min if @type =~ /dragon/i
+    
+    # Get spells from the appropriate domain
+    available_spells = []
+    
+    # Filter spells by domain from $SpellDatabase
+    $SpellDatabase.each do |spell_name, spell_data|
+      if spell_data["domain"] == domain
+        available_spells << {
+          'name' => spell_name,
+          'duration' => spell_data["duration"],
+          'range' => spell_data["distance"],
+          'area' => spell_data["aoe"]
+        }
+      end
+    end
+    
+    # If no spells found for domain, use some generic ones
+    if available_spells.empty?
+      # Create some basic spells for the domain
+      case domain
+      when "Earth"
+        available_spells = [
+          {'name' => "Stone Skin", 'duration' => "1 hour", 'range' => "Touch", 'area' => "Single"},
+          {'name' => "Earth Spike", 'duration' => "Instant", 'range' => "20m", 'area' => "Single"},
+          {'name' => "Tremor", 'duration' => "Instant", 'range' => "50m", 'area' => "10m radius"},
+          {'name' => "Stone Wall", 'duration' => "Permanent", 'range' => "10m", 'area' => "Wall 5m"},
+          {'name' => "Earth Bind", 'duration' => "1 minute", 'range' => "30m", 'area' => "Single"},
+          {'name' => "Quake", 'duration' => "Instant", 'range' => "100m", 'area' => "20m radius"}
+        ]
+      when "Fire"
+        available_spells = [
+          {'name' => "Flame Bolt", 'duration' => "Instant", 'range' => "30m", 'area' => "Single"},
+          {'name' => "Fire Shield", 'duration' => "10 minutes", 'range' => "Self", 'area' => "Self"},
+          {'name' => "Fireball", 'duration' => "Instant", 'range' => "50m", 'area' => "5m radius"}
+        ]
+      when "Water"
+        available_spells = [
+          {'name' => "Ice Bolt", 'duration' => "Instant", 'range' => "30m", 'area' => "Single"},
+          {'name' => "Water Walk", 'duration' => "1 hour", 'range' => "Touch", 'area' => "Single"},
+          {'name' => "Freeze", 'duration' => "1 minute", 'range' => "20m", 'area' => "Single"}
+        ]
+      when "Air"
+        available_spells = [
+          {'name' => "Lightning", 'duration' => "Instant", 'range' => "50m", 'area' => "Single"},
+          {'name' => "Wind Walk", 'duration' => "10 minutes", 'range' => "Touch", 'area' => "Single"},
+          {'name' => "Storm", 'duration' => "10 minutes", 'range' => "100m", 'area' => "50m radius"}
+        ]
+      when "Death"
+        available_spells = [
+          {'name' => "Drain Life", 'duration' => "Instant", 'range' => "Touch", 'area' => "Single"},
+          {'name' => "Animate Dead", 'duration' => "1 hour", 'range' => "10m", 'area' => "Corpse"},
+          {'name' => "Death Touch", 'duration' => "Instant", 'range' => "Touch", 'area' => "Single"}
+        ]
+      else
+        available_spells = [
+          {'name' => "Magic Bolt", 'duration' => "Instant", 'range' => "30m", 'area' => "Single"}
+        ]
+      end
+    end
+    
+    # Select random spells
+    selected_spells = available_spells.sample([spell_count, available_spells.length].min)
+    
+    selected_spells.each do |spell|
+      @spells << {
+        'name' => spell['name'],
+        'domain' => domain,
+        'duration' => spell['duration'] || "Instant",
+        'range' => spell['range'] || "Touch",
+        'area' => spell['area'] || "Target"
+      }
+    end
+  end
+  
+  public
+  
+  # Compatibility methods for encounter system
+  def get_characteristic(char_name)
+    @tiers[char_name]["level"] || 0
+  end
+  
+  def get_attribute(char_name, attr_name)
+    return 0 unless @tiers[char_name] && @tiers[char_name][attr_name]
+    @tiers[char_name][attr_name]["level"] || 0
+  end
+  
+  def get_skill(char_name, attr_name, skill_name)
+    return 0 unless @tiers[char_name] && @tiers[char_name][attr_name]
+    return 0 unless @tiers[char_name][attr_name]["skills"]
+    @tiers[char_name][attr_name]["skills"][skill_name] || 0
+  end
+  
+  
+  def age
+    "Unknown"
+  end
+  
+  def height
+    @SIZE * 20  # Rough estimate
+  end
+  
+  def weight
+    @SIZE * 10  # Rough estimate
+  end
+  
+  def area
+    "Wild"
+  end
+  
+  def has_magic?
+    # Check if monster has any casting ability
+    return false unless @tiers["SPIRIT"] && @tiers["SPIRIT"]["Casting"]
+    casting_level = @tiers["SPIRIT"]["Casting"]["level"] || 0
+    casting_level > 0
+  end
+  
+  def get_skill_total(char_name, attr_name, skill_name)
+    # Calculate total: Characteristic + Attribute + Skill
+    char_level = get_characteristic(char_name)
+    attr_level = get_attribute(char_name, attr_name)
+    skill_level = get_skill(char_name, attr_name, skill_name)
+    
+    char_level + attr_level + skill_level
+  end
+  
+  # Additional methods for compatibility with detailed views
+  def profession
+    @type.to_s.gsub(/Monster:|Animal:/, "")
+  end
+  
+  def cult
+    nil  # Monsters don't have religions
+  end
+  
+  def social_status
+    "Wild"  # Monsters are outside society
+  end
+  
+  def money
+    0  # Monsters don't carry money
+  end
+  
+  def equipment
+    []  # Monsters don't have equipment
+  end
+
+  def generate_awareness_skills(stats)
+    skills = {}
+
+    # Base awareness skills
+    skills["Reaction speed"] = @level + rand(0..2)
+    skills["Alertness"] = @level + rand(0..2)
+
+    case stats["type"]
+    when "Undead"
+      # Undead have poor awareness but don't get surprised
+      skills["Alertness"] = rand(1..2)
+      skills["Search"] = rand(0..1)
+      # No tracking or sense ambush for mindless undead
+      unless @name.downcase.include?("vampire") || @name.downcase.include?("lich")
+        skills.delete("Reaction speed")
+      end
+    when "Animal"
+      # Animals have good natural senses
+      skills["Alertness"] = @level + rand(1..3)
+      # Predators track
+      if stats["skills"].any? { |s| s.downcase.include?("track") || s.downcase.include?("hunt") }
+        skills["Tracking"] = @level + rand(2..4)
+      end
+      # Pack animals sense ambush
+      if stats["skills"].include?("Pack tactics")
+        skills["Sense ambush"] = @level + rand(1..3)
+      end
+    when "Monster"
+      # Standard monster awareness
+      skills["Search"] = @level + rand(0..1)
+      # Intelligent monsters have better awareness
+      if stats["base_mind"] >= 3
+        skills["Sense ambush"] = @level + rand(0..2)
+        skills["Search"] = @level + rand(1..2)
+      end
+      # Tracking for appropriate monsters
+      if stats["skills"].include?("Tracking")
+        skills["Tracking"] = @level + rand(1..3)
+      end
+    else
+      # Default fallback
+      skills["Search"] = rand(0..1)
+    end
+
+    # Remove any skills with 0 or negative values
+    skills.delete_if { |_, v| v <= 0 }
+
+    skills
+  end
+end