amar-rpg 2.0.1

data/includes/class_npc_new.rb

@@ -0,0 +1,1187 @@
+# New NPC Class for 3-Tier System
+# Implements the Characteristics > Attributes > Skills structure
+
+class NpcNew
+  attr_accessor :name, :type, :level, :area, :sex, :age, :height, :weight
+  attr_accessor :tiers, :social_status, :marks, :description
+  attr_accessor :melee_weapon, :missile_weapon, :armor, :ENC, :spells
+  # Original CLI weapon format accessors
+  attr_accessor :melee1, :melee2, :melee3, :missile
+  attr_accessor :melee1s, :melee2s, :melee3s, :missiles
+  attr_accessor :melee1i, :melee1o, :melee1d, :melee1dam, :melee1hp
+  attr_accessor :melee2i, :melee2o, :melee2d, :melee2dam, :melee2hp
+  attr_accessor :melee3i, :melee3o, :melee3d, :melee3dam, :melee3hp
+  attr_accessor :missileo, :missiledam, :missilerange
+  attr_accessor :armour, :ap
+  
+  def initialize(name, type, level, area, sex, age, height, weight, description, predetermined_stats = nil)
+    # Generate random values for missing data
+    @name = name && !name.empty? ? name : generate_random_name(sex)
+    @type = type
+    @level = level.to_i
+    @area = area && !area.empty? ? area : ["Amaronir", "Merisir", "Calaronir", "Feronir", "Rauinir"].sample
+    @sex = sex && !sex.empty? ? sex : ["M", "F"].sample
+    
+    # Calculate realistic age based on experience level
+    # Assuming training starts at 15, each level requires years of dedication
+    if age.to_i > 0
+      @age = age.to_i
+    else
+      base_age = 15  # Starting age for training
+      years_training = case @level
+                      when 1 then rand(1..3)    # 16-18 years old
+                      when 2 then rand(3..7)    # 18-22 years old
+                      when 3 then rand(7..12)   # 22-27 years old
+                      when 4 then rand(12..20)  # 27-35 years old
+                      when 5 then rand(20..30)  # 35-45 years old
+                      when 6 then rand(30..45)  # 45-60 years old
+                      else rand(45..60)         # 60-75 years old
+                      end
+      @age = base_age + years_training
+    end
+    
+    # Generate realistic height and weight based on Amar averages
+    # Human average: 170cm height, 70kg weight
+    # But allowing for strongmen up to 195cm/125kg
+    if height.to_i > 0
+      @height = height.to_i
+    else
+      # Base height around 160 + variation using open-ended d6 rolls
+      # This gives a bell curve centered around 170cm
+      base_height = 160
+      variation = oD6 * 2 + oD6 + rand(10)
+      @height = base_height + variation
+      @height -= 5 if @sex == "F"  # Females slightly shorter on average
+      @height -= (3 * (16 - @age)) if @age < 17  # Youth adjustment
+
+      # Type-based adjustments for larger/smaller builds
+      case @type
+      when /Warrior|Guard|Soldier|Body guard|Barbarian/
+        @height += rand(0..10)  # Warriors tend to be taller
+      when /Thief|Assassin|Rogue/
+        @height -= rand(0..5)  # Rogues tend to be more average/shorter
+      end
+    end
+
+    if weight.to_i > 0
+      @weight = weight.to_i
+    else
+      # Weight based on height with more variation for different builds
+      # Base formula: height - 120 + variation
+      base_weight = @height - 120
+
+      # Build variation based on character type
+      build_modifier = case @type
+      when /Warrior|Guard|Soldier|Body guard|Barbarian|Worker|Farmer/
+        # Muscular builds: more weight for same height
+        aD6 * 5 + rand(15)  # Can add up to 55kg for strongman builds
+      when /Noble|Merchant|Scholar|Sage|Priest|Mage|Wizard/
+        # Average to lighter builds
+        aD6 * 3 + rand(10)  # Normal variation
+      when /Thief|Assassin|Rogue|Scout/
+        # Lean, agile builds
+        aD6 * 2 + rand(10)  # Lighter variation
+      else
+        # Default average build
+        aD6 * 4 + rand(10)
+      end
+
+      @weight = base_weight + build_modifier
+      @weight = [@weight, 40].max  # Minimum weight of 40kg
+    end
+    @description = description
+    
+    # Initialize tier system structures
+    @tiers = {
+      "BODY" => {},
+      "MIND" => {},
+      "SPIRIT" => {}
+    }
+    
+    # Initialize mark tracking for progression
+    @marks = {
+      "BODY" => {},
+      "MIND" => {},
+      "SPIRIT" => {}
+    }
+    
+    # Set social status
+    @social_status = ["S", "LC", "LMC", "MC", "UC", "N"].sample
+    
+    # Store predetermined stats for later use
+    @predetermined_stats = predetermined_stats
+
+    # Generate based on new tier system
+    generate_tiers()
+
+    # Generate spells if magic user
+    generate_spells()
+
+    # Select equipment
+    select_equipment()
+    
+    # Initialize encumbrance
+    @ENC = 0
+  end
+  
+  private
+  
+  def generate_tiers
+    # Load tier system and character templates
+    unless defined?($TierSystem)
+      load File.join($pgmdir, "includes/tables/tier_system.rb")
+    end
+    unless defined?($ChartypeNewFull)
+      load File.join($pgmdir, "includes/tables/chartype_new_full.rb")
+    end
+    
+    # Get template for this character type
+    template = $ChartypeNewFull[@type] || $ChartypeNewFull["Commoner"]
+    
+    # Generate characteristics
+    ["BODY", "MIND", "SPIRIT"].each do |char_name|
+      char_base = template["characteristics"][char_name] || 2
+      
+      # Initialize attributes for this characteristic
+      $TierSystem[char_name].each do |attr_name, attr_data|
+        @tiers[char_name][attr_name] = {
+          "level" => 0,
+          "skills" => {}
+        }
+        
+        # Set attribute base from template
+        attr_key = "#{char_name}/#{attr_name}"
+        if template["attributes"] && template["attributes"][attr_key]
+          attr_base = template["attributes"][attr_key]
+        else
+          attr_base = attr_data["base"] || 0
+        end
+        
+        # Calculate attribute level based on NPC level
+        @tiers[char_name][attr_name]["level"] = calculate_tier_level(attr_base, @level, 0.8)
+        
+        # Initialize skills for this attribute
+        if attr_data["skills"]
+          # Convert array to hash for skills
+          skill_list = attr_data["skills"]
+          skill_list = [] unless skill_list.is_a?(Array)
+          
+          skill_list.each do |skill_name|
+            # Check if template has specific skill values
+            skill_key = "#{char_name}/#{attr_name}/#{skill_name}"
+            skill_base = 0
+            
+            if template["skills"] && template["skills"][skill_key]
+              skill_base = template["skills"][skill_key]
+            end
+            
+            # Calculate skill level
+            @tiers[char_name][attr_name]["skills"][skill_name] = calculate_tier_level(skill_base, @level, 0.6)
+          end
+        end
+      end
+    end
+    
+    # Add template-specific skills
+    if template["skills"]
+      template["skills"].each do |skill_path, base_value|
+        parts = skill_path.split("/")
+        next unless parts.length == 3
+        
+        char_name, attr_name, skill_name = parts
+        next unless @tiers[char_name] && @tiers[char_name][attr_name]
+        
+        @tiers[char_name][attr_name]["skills"] ||= {}
+        current = @tiers[char_name][attr_name]["skills"][skill_name] || 0
+        new_value = calculate_tier_level(base_value, @level, 0.6)
+        @tiers[char_name][attr_name]["skills"][skill_name] = [current, new_value].max
+      end
+    end
+    
+    # Add weapon skills from template
+    add_weapon_skills(template)
+    
+    # Add Innate skills ONLY for specific character types
+    innate_types = ["Witch (white)", "Witch (black)", "Sorcerer", "Summoner"]
+    if innate_types.include?(@type)
+      # These types get innate magical abilities
+      innate_skills = ["Flying", "Camouflage", "Shape Shifting"]
+      innate_skills.sample(rand(1..2)).each do |skill|
+        @tiers["SPIRIT"]["Innate"]["skills"][skill] = rand(1..3) + (@level / 2)
+      end
+    end
+    
+    # For magic users, ensure they have appropriate Casting and Attunement
+    if has_template_magic?(template)
+      # Ensure minimum Casting level for spell use
+      min_casting = (@level / 2) + 1
+      if @tiers["SPIRIT"]["Casting"]["level"] < min_casting
+        @tiers["SPIRIT"]["Casting"]["level"] = min_casting
+      end
+      
+      # Add specific casting skills
+      ["Range", "Duration", "Area of Effect"].each do |skill|
+        @tiers["SPIRIT"]["Casting"]["skills"][skill] = rand(1..3) + (@level / 2)
+      end
+      
+      # Set attunement domains based on type
+      domains = case @type
+                when /Wizard \((.*?)\)/
+                  [$1.capitalize]
+                when "Priest"
+                  ["Life", "Body"]
+                when "Mage"
+                  ["Fire", "Air", "Mind"]
+                else
+                  ["Fire", "Water", "Air", "Earth"].sample(2)
+                end
+      
+      domains.each do |domain|
+        @tiers["SPIRIT"]["Attunement"]["skills"][domain] = rand(2..4) + (@level / 2)
+      end
+    end
+    
+    # Add experience-based skills for higher level NPCs
+    if @level >= 4
+      add_experience_skills()
+    end
+    
+    # Apply predetermined stats if provided (for encounter consistency)
+    apply_predetermined_stats() if @predetermined_stats
+
+    # Ensure essential skills are always present
+    ensure_essential_skills()
+  end
+  
+  def add_experience_skills
+    # Add additional skills for experienced characters
+    experience_bonus = @level - 3  # 1 for level 4, 2 for level 5, etc.
+    
+    # Significantly expand skill generation based on level
+    skill_count = case @level
+                  when 4 then rand(8..12)
+                  when 5 then rand(12..18)
+                  when 6 then rand(18..25)
+                  else rand(20..30)
+                  end
+    
+    skills_added = 0
+    
+    # Build skill pool based on actual tier system
+    skill_pool = []
+    
+    # BODY skills - more varied distribution
+    skill_pool += [
+      ["BODY", "Athletics", "Hide", rand(1..2) + (experience_bonus / 2)],
+      ["BODY", "Athletics", "Move Quietly", rand(1..2) + (experience_bonus / 2)],
+      ["BODY", "Athletics", "Climb", rand(0..2) + (experience_bonus / 2)],
+      ["BODY", "Athletics", "Swim", rand(0..2) + (experience_bonus / 2)],
+      ["BODY", "Athletics", "Ride", rand(0..1) + (experience_bonus / 3)],
+      ["BODY", "Athletics", "Jump", rand(0..1) + (experience_bonus / 3)],
+      ["BODY", "Athletics", "Balance", rand(1..2) + (experience_bonus / 2)],
+      ["BODY", "Endurance", "Running", rand(1..2) + (experience_bonus / 2)],
+      ["BODY", "Endurance", "Combat Tenacity", rand(0..2) + (experience_bonus / 2)],
+      ["BODY", "Sleight", "Pick pockets", rand(0..1) + (experience_bonus / 3)],
+      ["BODY", "Sleight", "Disarm Traps", rand(0..1) + (experience_bonus / 3)]
+    ]
+    
+    # MIND skills - more varied distribution
+    skill_pool += [
+      ["MIND", "Awareness", "Tracking", rand(1..2) + (experience_bonus / 2)],
+      ["MIND", "Awareness", "Detect Traps", rand(0..1) + (experience_bonus / 3)],
+      ["MIND", "Awareness", "Sense Emotions", rand(0..2) + (experience_bonus / 2)],
+      ["MIND", "Awareness", "Sense of Direction", rand(1..2) + (experience_bonus / 2)],
+      ["MIND", "Awareness", "Listening", rand(1..2) + (experience_bonus / 2)],
+      ["MIND", "Social Knowledge", "Social lore", rand(1..2) + (experience_bonus / 2)],
+      ["MIND", "Social Knowledge", "Spoken Language", rand(0..2) + (experience_bonus / 2)],
+      ["MIND", "Social Knowledge", "Literacy", rand(0..2) + (experience_bonus / 2)],
+      ["MIND", "Nature Knowledge", "Medical lore", rand(0..1) + (experience_bonus / 3)],
+      ["MIND", "Nature Knowledge", "Plant Lore", rand(0..1) + (experience_bonus / 3)],
+      ["MIND", "Nature Knowledge", "Animal Lore", rand(0..1) + (experience_bonus / 3)],
+      ["MIND", "Practical Knowledge", "Survival Lore", rand(1..2) + (experience_bonus / 2)],
+      ["MIND", "Practical Knowledge", "Set traps", rand(0..1) + (experience_bonus / 3)],
+      ["MIND", "Willpower", "Mental Fortitude", rand(1..2) + (experience_bonus / 2)],
+      ["MIND", "Willpower", "Courage", rand(0..2) + (experience_bonus / 2)]
+    ]
+    
+    # Type-specific skills
+    if has_magic?
+      skill_pool += [
+        ["MIND", "Awareness", "Sense Magick", rand(3..4) + experience_bonus],
+        ["MIND", "Nature Knowledge", "Magick Rituals", rand(3..5) + experience_bonus],
+        ["MIND", "Social Knowledge", "Mythology", rand(2..3) + experience_bonus],
+        ["MIND", "Social Knowledge", "Legend Lore", rand(2..3) + experience_bonus],
+        ["SPIRIT", "Casting", "Range", rand(2..4) + experience_bonus],
+        ["SPIRIT", "Casting", "Duration", rand(2..4) + experience_bonus],
+        ["SPIRIT", "Casting", "Area of Effect", rand(1..3) + experience_bonus]
+      ]
+    end
+    
+    # Physical combat types
+    type_str = @type.to_s
+    if ["Warrior", "Guard", "Soldier", "Gladiator", "Body guard", "Ranger", "Hunter"].any? { |t| type_str.include?(t) }
+      skill_pool += [
+        ["BODY", "Endurance", "Fortitude", rand(3..4) + experience_bonus],
+        ["BODY", "Endurance", "Combat Tenacity", rand(3..4) + experience_bonus],
+        ["MIND", "Practical Knowledge", "Ambush", rand(2..3) + experience_bonus],
+        ["MIND", "Awareness", "Sense Ambush", rand(2..3) + experience_bonus]
+      ]
+    end
+    
+    # Scholarly types
+    if ["Scholar", "Sage", "Scribe", "Wizard", "Mage"].any? { |t| type_str.include?(t) }
+      skill_pool += [
+        ["MIND", "Intelligence", "Innovation", rand(3..4) + experience_bonus],
+        ["MIND", "Intelligence", "Problem Solving", rand(3..4) + experience_bonus],
+        ["MIND", "Social Knowledge", "Literacy", rand(4..5) + experience_bonus],
+        ["MIND", "Nature Knowledge", "Alchemy", rand(2..3) + experience_bonus]
+      ]
+    end
+    
+    # Rogueish types
+    if ["Thief", "Rogue", "Assassin", "Scout"].any? { |t| type_str.include?(t) }
+      skill_pool += [
+        ["BODY", "Athletics", "Hide", rand(4..5) + experience_bonus],
+        ["BODY", "Athletics", "Move Quietly", rand(4..5) + experience_bonus],
+        ["BODY", "Sleight", "Pick pockets", rand(3..5) + experience_bonus],
+        ["BODY", "Sleight", "Disarm Traps", rand(3..4) + experience_bonus],
+        ["MIND", "Awareness", "Detect Traps", rand(3..4) + experience_bonus]
+      ]
+    end
+    
+    # Now randomly select and add skills
+    skill_pool.shuffle!
+    
+    skill_pool.each do |char_name, attr_name, skill_name, value|
+      break if skills_added >= skill_count
+      
+      # Ensure the tier structure exists
+      next unless @tiers[char_name] && @tiers[char_name][attr_name]
+      
+      # Initialize skills hash if needed
+      @tiers[char_name][attr_name]["skills"] ||= {}
+      
+      # Add skill if it doesn't exist or is 0
+      if !@tiers[char_name][attr_name]["skills"][skill_name] || 
+         @tiers[char_name][attr_name]["skills"][skill_name] == 0
+        @tiers[char_name][attr_name]["skills"][skill_name] = value
+        skills_added += 1
+      end
+    end
+  end
+  
+  def calculate_tier_level(base, npc_level, tier_modifier)
+    # Natural caps based on training difficulty
+    # The harder to train, the lower the natural cap
+    
+    # Determine tier type and apply realistic caps
+    # Adjusted to create proper population distribution
+    tier_caps = case tier_modifier
+                when 1.0  # Characteristic (hardest to train)
+                  { normal: 2, experienced: 3, master: 4, hero: 5 }
+                when 0.8  # Attribute (moderate training)
+                  { normal: 3, experienced: 5, master: 6, hero: 7 }
+                when 0.6  # Skill (easiest to train)
+                  { normal: 5, experienced: 7, master: 9, hero: 11 }
+                else
+                  { normal: 2, experienced: 3, master: 4, hero: 5 }
+                end
+    
+    # Determine NPC experience level - matches population distribution
+    experience = case npc_level
+                 when 1..2 then :normal       # Common folk
+                 when 3..4 then :experienced  # Town champions  
+                 when 5..6 then :master       # Regional masters
+                 else :hero                   # National/legendary
+                 end
+    
+    max_value = tier_caps[experience]
+    
+    # Calculate level with diminishing returns
+    # Characteristics grow very slowly, skills grow faster
+    growth_rate = case tier_modifier
+                  when 1.0 then 0.4  # Very slow for characteristics
+                  when 0.8 then 0.6  # Moderate for attributes
+                  when 0.6 then 0.8  # Faster for skills
+                  else 0.5
+                  end
+    
+    # Use square root for more realistic progression
+    level = (base * Math.sqrt(npc_level + 1) * growth_rate).to_i
+    
+    # Add minimal variation ONLY if base > 0
+    if base > 0
+      variation = rand(3) - 1  # -1, 0, or 1
+      level += variation
+    end
+    
+    # Ensure minimum competence for trained individuals
+    # Skills should rarely be below 3 for anyone with training
+    if tier_modifier == 0.6  # Skills
+      min_skill = case npc_level
+                  when 1..2 then 2
+                  when 3..4 then 3
+                  else 4
+                  end
+      level = min_skill if level < min_skill && base > 0
+    elsif tier_modifier == 0.8  # Attributes
+      min_attr = case npc_level
+                 when 1..2 then 1
+                 when 3..4 then 2
+                 else 3
+                 end
+      level = min_attr if level < min_attr && base > 0
+    end
+    
+    # Apply training reality - most people plateau
+    # Only exceptional individuals (high level + good base) reach max
+    if tier_modifier == 1.0  # Characteristics rarely exceed 3
+      level = 3 if level > 3 && rand(100) > 20  # 80% plateau at 3
+    elsif tier_modifier == 0.8  # Attributes occasionally reach 6
+      level = 5 if level > 5 && rand(100) > 40  # 60% plateau at 5
+    end
+    
+    # Ensure within bounds
+    level = 0 if level < 0
+    level = max_value if level > max_value
+    
+    level
+  end
+  
+  def add_weapon_skills(template)
+    # Add melee weapon skills
+    if template["melee_weapons"]
+      @tiers["BODY"]["Melee Combat"]["skills"] ||= {}
+      template["melee_weapons"].each do |weapon, skill_level|
+        base_level = calculate_tier_level(skill_level, @level, 0.6)
+        @tiers["BODY"]["Melee Combat"]["skills"][weapon] = base_level
+      end
+    end
+    
+    # Add missile weapon skills
+    if template["missile_weapons"]
+      @tiers["BODY"]["Missile Combat"]["skills"] ||= {}
+      template["missile_weapons"].each do |weapon, skill_level|
+        base_level = calculate_tier_level(skill_level, @level, 0.6)
+        @tiers["BODY"]["Missile Combat"]["skills"][weapon] = base_level
+      end
+    end
+    
+    # Add Unarmed combat for all NPCs (everyone can fight with fists)
+    @tiers["BODY"]["Melee Combat"]["skills"] ||= {}
+    if !@tiers["BODY"]["Melee Combat"]["skills"]["Unarmed"]
+      # Base unarmed skill based on type and level
+      unarmed_bonus = case @type
+                      when /Monk|Martial|Barbarian/
+                        2  # Better at unarmed
+                      when /Warrior|Guard|Soldier|Gladiator/
+                        1  # Decent at unarmed
+                      when /Wizard|Sage|Scholar|Scribe/
+                        -1  # Poor at unarmed
+                      else
+                        0  # Average
+                      end
+      unarmed_skill = calculate_tier_level(1 + unarmed_bonus, @level, 0.5)
+      @tiers["BODY"]["Melee Combat"]["skills"]["Unarmed"] = [unarmed_skill, 0].max
+    end
+  end
+  
+  def select_equipment
+    @weapons = []
+    @ENC = 0
+    
+    # Get melee combat skills
+    melee_skills = @tiers["BODY"]["Melee Combat"]["skills"] || {}
+    missile_skills = @tiers["BODY"]["Missile Combat"]["skills"] || {}
+    
+    # Check if has shield skill
+    has_shield = melee_skills["Shield"] && melee_skills["Shield"] > 0
+    
+    # Determine weapon loadout based on character type and skills
+    case @type
+    when /Warrior|Guard|Soldier|Knight/
+      # Warriors typically have weapon + shield or two-handed weapon
+      if has_shield && rand(100) < 70
+        # Weapon + shield combo (70% chance if has shield skill)
+        primary = select_best_weapon(melee_skills, ["Sword", "Axe", "Mace", "Spear"])
+        @weapons << primary if primary
+        @weapons << "Shield"
+      elsif rand(100) < 40
+        # Two-handed weapon (40% chance)
+        primary = select_best_weapon(melee_skills, ["2H Sword", "2H Axe", "Polearm", "Spear"])
+        @weapons << (primary || "Spear")
+      else
+        # Dual wield
+        primary = select_best_weapon(melee_skills, ["Sword", "Axe", "Mace"])
+        secondary = select_best_weapon(melee_skills, ["Short sword", "Dagger", "Hatchet"])
+        @weapons << (primary || "Sword")
+        @weapons << (secondary || "Dagger")
+      end
+    when /Thief|Assassin|Rogue/
+      # Thieves prefer light weapons, often dual wield
+      primary = select_best_weapon(melee_skills, ["Short sword", "Dagger", "Rapier"])
+      @weapons << (primary || "Dagger")
+      if rand(100) < 60
+        # Often carry a second weapon
+        @weapons << "Dagger"
+      end
+    when /Ranger|Hunter|Scout/
+      # Rangers typically have melee + ranged
+      primary = select_best_weapon(melee_skills, ["Sword", "Axe", "Spear"])
+      @weapons << (primary || "Sword")
+      if rand(100) < 30
+        @weapons << "Dagger"  # Backup weapon
+      end
+    when /Priest|Cleric|Monk/
+      # Religious types often use blunt weapons
+      primary = select_best_weapon(melee_skills, ["Mace", "Staff", "Hammer"])
+      @weapons << (primary || "Staff")
+      if has_shield && rand(100) < 40
+        @weapons << "Shield"
+      end
+    when /Wizard|Mage|Sorcerer/
+      # Mages usually just have a staff or dagger
+      primary = select_best_weapon(melee_skills, ["Staff", "Dagger"])
+      @weapons << (primary || "Staff")
+    when /Noble/
+      # Nobles have fancy weapons
+      primary = select_best_weapon(melee_skills, ["Sword", "Rapier"])
+      @weapons << (primary || "Sword")
+      if rand(100) < 50
+        @weapons << "Dagger"  # Ornamental backup
+      end
+    when /Barbarian/
+      # Barbarians use heavy weapons
+      if rand(100) < 60
+        primary = select_best_weapon(melee_skills, ["2H Axe", "2H Sword", "Spear"])
+        @weapons << (primary || "2H Axe")
+      else
+        # Dual wield
+        @weapons << select_best_weapon(melee_skills, ["Axe", "Sword"]) || "Axe"
+        @weapons << select_best_weapon(melee_skills, ["Axe", "Mace"]) || "Hatchet"
+      end
+    when /Gladiator/
+      # Gladiators have varied weapon combos
+      combo = rand(100)
+      if combo < 33
+        # Sword and shield
+        @weapons << select_best_weapon(melee_skills, ["Sword", "Spear"]) || "Sword"
+        @weapons << "Shield"
+      elsif combo < 66
+        # Dual wield
+        @weapons << "Sword"
+        @weapons << "Short sword"
+      else
+        # Exotic weapon
+        @weapons << select_best_weapon(melee_skills, ["Trident", "Net", "Spear"]) || "Spear"
+        if has_shield
+          @weapons << "Shield"
+        end
+      end
+    when /Smith/
+      # Smiths have varied hammers and tools - add randomization
+      weapon_choice = rand(100)
+      if weapon_choice < 40
+        @weapons << select_best_weapon(melee_skills, ["Hammer", "War hammer"]) || "Hammer"
+      elsif weapon_choice < 70
+        @weapons << select_best_weapon(melee_skills, ["Mace", "Hammer"]) || "Mace"
+      elsif weapon_choice < 85
+        # Smith with axe
+        @weapons << select_best_weapon(melee_skills, ["Axe", "Hatchet"]) || "Axe"
+      else
+        # Smith with sword (forged their own)
+        @weapons << select_best_weapon(melee_skills, ["Sword", "Short sword"]) || "Sword"
+      end
+      # Sometimes add a shield
+      if has_shield && rand(100) < 30
+        @weapons << "Shield"
+      end
+    when /Sailor|Seaman|Mariner/
+      # Sailors typically have cutlass or short sword
+      primary = select_best_weapon(melee_skills, ["Cutlass", "Short sword", "Hatchet"])
+      @weapons << (primary || "Cutlass")
+      if rand(100) < 40
+        @weapons << "Dagger"  # Utility knife
+      end
+    when /Farmer|Commoner/
+      # Common folk have simple weapons
+      @weapons << select_best_weapon(melee_skills, ["Pitchfork", "Staff", "Hatchet"]) || "Staff"
+    else
+      # Default: pick best available weapon with more variety
+      if melee_skills.any?
+        # Get all weapons with decent skill
+        good_weapons = melee_skills.select { |k, v| v > 0 && k != "Shield" }
+        if good_weapons.any?
+          # Sort weapons by skill level and pick from the better ones
+          sorted_weapons = good_weapons.sort_by { |_, v| -v }
+          # Take top weapons (those within 2 skill points of best)
+          best_skill = sorted_weapons.first[1]
+          top_weapons = sorted_weapons.select { |_, v| v >= best_skill - 2 }
+          
+          # Prefer weapons other than Dagger if available
+          preferred = top_weapons.reject { |k, _| k =~ /Dagger/ }
+          if preferred.any?
+            @weapons << preferred.sample[0]
+          else
+            @weapons << top_weapons.sample[0]
+          end
+          
+          # Sometimes add a secondary weapon
+          if rand(100) < 30 && good_weapons.size > 1
+            secondary = good_weapons.keys - [@weapons.first]
+            @weapons << secondary.sample
+          end
+        end
+      else
+        # No skills, give more varied basic weapons
+        basic_weapons = ["Staff", "Short sword", "Hatchet", "Mace", "Spear", "Knife"]
+        @weapons << basic_weapons.sample
+      end
+    end
+    
+    # Add missile weapon if applicable
+    if missile_skills.any?
+      best_missile = missile_skills.max_by { |_, v| v }
+      if best_missile && rand(100) < 70  # 70% chance to actually carry it
+        @missile_weapon = best_missile[0]
+        @ENC += 1
+      end
+    end
+    
+    # Set primary melee weapon for compatibility
+    @melee_weapon = @weapons.first if @weapons.any?
+    
+    # Calculate encumbrance
+    @ENC += @weapons.size
+    
+    # Use ORIGINAL armor selection logic from class_npc.rb
+    # Determine armor level based on strength (exact original logic)
+    strng = get_characteristic("BODY") || 3
+    arm_level = case strng
+                when 1..2 then 1
+                when 3 then 2
+                when 4 then 3
+                when 5 then 5
+                when 6 then 6
+                when 7 then 7
+                else 8
+                end
+
+    # Pick armor from ORIGINAL $Armour table
+    armor_index = rand(arm_level) + 1
+    armor_data = $Armour[armor_index]
+
+    @armour = armor_data[0]  # Armor name from original table
+    @ap = armor_data[1]      # Armor points from original table
+
+    # Set armor in new format for compatibility with output
+    @armor = {
+      name: @armour,
+      ap: @ap,
+      enc: armor_data[4] || 0  # Weight as encumbrance
+    }
+
+    # Add armor encumbrance
+    @ENC += @armor[:enc] if @armor
+
+    # Add ORIGINAL weapon selection using $Melee and $Missile tables
+    generate_original_weapons
+  end
+
+  def generate_original_weapons
+    # Use EXACT original CLI weapon selection logic
+    # Determine weapon level based on strength (like original)
+    strng = get_characteristic("BODY") || 3
+    wpn_level = case strng
+                when 1 then 2
+                when 2 then 4
+                when 3 then 11
+                when 4 then 18
+                when 5 then 22
+                when 7..8 then 28
+                else 30
+                end
+
+    # Initialize weapon variables
+    @melee1 = @melee2 = @melee3 = ""
+    @melee1s = @melee2s = @melee3s = 0
+    @melee1i = @melee1o = @melee1d = @melee1dam = @melee1hp = 0
+    @melee2i = @melee2o = @melee2d = @melee2dam = @melee2hp = 0
+    @melee3i = @melee3o = @melee3d = @melee3dam = @melee3hp = 0
+    @missile = ""
+    @missiles = @missileo = @missiledam = @missilerange = 0
+
+    # Get reaction speed for initiative calculations
+    reaction_speed = get_skill_total("MIND", "Awareness", "Reaction speed") || 0
+    dodge_total = get_skill_total("BODY", "Athletics", "Dodge") || 0
+
+    # Select melee weapon 1 from ORIGINAL $Melee table
+    melee1_idx = rand(wpn_level) + 1
+    melee1_data = $Melee[melee1_idx]
+    @melee1 = melee1_data[0]  # Weapon name like "Longsword/Buc"
+    @melee1s = calculate_weapon_skill_for_name(@melee1)
+    @melee1i = melee1_data[4] + reaction_speed     # Init = weapon init + reaction
+    @melee1o = melee1_data[5] + @melee1s           # Off = weapon off + skill
+    @melee1d = melee1_data[6] + @melee1s + (dodge_total / 5)  # Def = weapon def + skill + dodge/5
+    @melee1dam = melee1_data[3] + self.DB          # Damage = weapon dam + DB
+    @melee1hp = melee1_data[7]                     # Weapon hit points
+
+    # Select melee weapon 2 (if different)
+    melee2_idx = rand(wpn_level) + 1
+    if melee2_idx != melee1_idx
+      melee2_data = $Melee[melee2_idx]
+      @melee2 = melee2_data[0]
+      @melee2s = calculate_weapon_skill_for_name(@melee2)
+      @melee2i = melee2_data[4] + reaction_speed
+      @melee2o = melee2_data[5] + @melee2s
+      @melee2d = melee2_data[6] + @melee2s + (dodge_total / 5)
+      @melee2dam = melee2_data[3] + self.DB
+      @melee2hp = melee2_data[7]
+    end
+
+    # Select missile weapon from ORIGINAL $Missile table
+    msl_level = wpn_level
+    missile_idx = rand(msl_level) + 1
+    missile_data = $Missile[missile_idx]
+    @missile = missile_data[0]  # Weapon name like "Bow(H) [1]"
+    @missiles = calculate_missile_skill_for_name(@missile)
+    @missileo = missile_data[4] + @missiles        # Off = weapon off + skill
+    @missiledam = missile_data[3] + self.DB        # Damage = weapon dam + DB
+    @missilerange = missile_data[5]                # Range from table
+
+    # Apply strength bonus for throwing weapons (original logic)
+    if @missile && missile_data[1] != "Crossbow" && missile_data[1] != "Bow"
+      @missiledam += (strng / 5)
+    end
+  end
+
+  def calculate_weapon_skill_for_name(weapon_name)
+    # Map weapon names to 3-tier skills
+    case weapon_name.to_s.downcase
+    when /sword/
+      get_skill_total("BODY", "Melee Combat", "Sword")
+    when /axe/
+      get_skill_total("BODY", "Melee Combat", "Axe")
+    when /mace|club|hammer/
+      get_skill_total("BODY", "Melee Combat", "Club")
+    when /spear|polearm/
+      get_skill_total("BODY", "Melee Combat", "Spear")
+    when /staff/
+      get_skill_total("BODY", "Melee Combat", "Staff")
+    when /dagger|knife/
+      get_skill_total("BODY", "Melee Combat", "Dagger")
+    when /unarmed/
+      get_skill_total("BODY", "Melee Combat", "Unarmed")
+    else
+      get_skill_total("BODY", "Melee Combat", "Sword") || 0
+    end
+  end
+
+  def calculate_missile_skill_for_name(weapon_name)
+    case weapon_name.to_s.downcase
+    when /bow/
+      get_skill_total("BODY", "Missile Combat", "Bow")
+    when /crossbow|x-bow/
+      get_skill_total("BODY", "Missile Combat", "Crossbow")
+    when /sling/
+      get_skill_total("BODY", "Missile Combat", "Sling")
+    when /javelin/
+      get_skill_total("BODY", "Missile Combat", "Javelin")
+    when /rock|stone|throwing|th\s|knife/
+      get_skill_total("BODY", "Missile Combat", "Throwing")
+    else
+      get_skill_total("BODY", "Missile Combat", "Bow") || 0
+    end
+  end
+  
+  def select_best_weapon(skills, preferred_weapons)
+    # Find the best weapon from preferred list that character has skill in
+    best_weapon = nil
+    best_skill = 0
+    
+    preferred_weapons.each do |weapon|
+      if skills[weapon] && skills[weapon] > best_skill
+        best_weapon = weapon
+        best_skill = skills[weapon]
+      end
+    end
+    
+    # If no preferred weapon found, check for any weapon skill
+    if !best_weapon && skills.any?
+      # Filter out Shield as it's not a primary weapon
+      weapon_skills = skills.reject { |k, _| k == "Shield" }
+      if weapon_skills.any?
+        best = weapon_skills.max_by { |_, v| v }
+        best_weapon = best[0]
+      end
+    end
+    
+    best_weapon
+  end
+  
+  def has_template_magic?(template)
+    # Check if template indicates magical ability
+    return false unless template
+    
+    # Check if template has Casting attribute > 0
+    casting_attr = template["attributes"]["SPIRIT/Casting"] || 0
+    return true if casting_attr > 0
+    
+    # Check for specific magic-using types
+    magic_types = ["Mage", "Wizard", "Witch (white)", "Witch (black)", "Sorcerer", 
+                   "Summoner", "Priest", "Sage", "Seer"]
+    type_str = @type.to_s
+    magic_types.include?(type_str) || type_str.include?("Wizard")
+  end
+  
+  # Moved to public section below
+  
+  def generate_spells
+    # Generate spell cards based on character type and level
+    spirit = get_characteristic("SPIRIT")
+    casting_attr = get_attribute("SPIRIT", "Casting")
+    casting_total = spirit + casting_attr
+    
+    # Restrict spells to appropriate creatures
+    # Require SPIRIT >= 2 AND total Casting >= 5
+    # Exclude specific races and creature types
+    excluded_types = ["Araxi", "Troll", "Dwarf", "Ogre", "Lizard", "Animal", "Zombie", "Skeleton"]
+    type_lower = @type.to_s.downcase
+    
+    is_excluded = excluded_types.any? { |ex| type_lower.include?(ex.downcase) }
+    
+    # Only generate spells for intelligent magical beings
+    if spirit >= 2 && casting_total >= 5 && !is_excluded
+      # Load spell database if not already loaded
+      unless defined?($SpellDatabase)
+        load File.join($pgmdir, "includes/tables/spells_new.rb")
+      end
+      
+      @spells = generate_spell_cards(@type, @level, casting_total)
+    end
+  end
+  
+  # Dice rolling methods (matching old system)
+  def d6
+    rand(1..6)
+  end
+
+  def oD6
+    # Open-ended D6 roll
+    result = d6
+    return result if (2..5).include?(result)
+
+    if result == 1
+      down = d6
+      while down <= 3
+        result -= 1
+        down = d6
+      end
+    elsif result == 6
+      up = d6
+      while up >= 4
+        result += 1
+        up = d6
+      end
+    end
+    result
+  end
+
+  def aD6
+    # Average D6 roll (average of regular d6 and open-ended d6)
+    ((d6 + oD6) / 2.0).to_i
+  end
+
+  # Public methods for accessing tier data
+  public
+  
+  def has_magic?
+    # Check if character has any casting ability
+    casting_level = @tiers["SPIRIT"]["Casting"]["level"] || 0
+    casting_level > 0
+  end
+  
+  # Calculate derived stats
+  def SIZE
+    # SIZE system based on weight with half-sizes
+    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 BP
+    # Body Points: SIZE * 2 + Fortitude / 3
+    # Fortitude is under Endurance
+    fortitude = get_skill("BODY", "Endurance", "Fortitude")
+    endurance = get_attribute("BODY", "Endurance")
+    body = get_characteristic("BODY")
+    total_fortitude = body + endurance + fortitude
+    (self.SIZE * 2 + total_fortitude / 3.0).round
+  end
+  
+  def DB
+    # Damage Bonus: (SIZE + Strength total) / 3
+    strength = get_attribute("BODY", "Strength")
+    body = get_characteristic("BODY")
+    total_strength = body + strength
+    ((self.SIZE + total_strength) / 3.0).round
+  end
+  
+  def MD
+    # Magic Defense: (Mental Fortitude + Attunement Self) / 3
+    mental_fortitude = get_skill("MIND", "Willpower", "Mental Fortitude")
+    willpower = get_attribute("MIND", "Willpower")
+    mind = get_characteristic("MIND")
+    total_mental_fortitude = mind + willpower + mental_fortitude
+    
+    attunement_self = get_skill("SPIRIT", "Attunement", "Self")
+    attunement = get_attribute("SPIRIT", "Attunement")
+    spirit = get_characteristic("SPIRIT")
+    total_attunement_self = spirit + attunement + attunement_self
+    
+    ((total_mental_fortitude + total_attunement_self) / 3.0).round
+  end
+  
+  def get_characteristic(name)
+    # Calculate characteristic as weighted average of its attributes
+    # Reflects years of broad training across all aspects
+    total = 0
+    count = 0
+    @tiers[name].each do |attr_name, attr_data|
+      if attr_data["level"] && attr_data["level"] > 0
+        total += attr_data["level"]
+        count += 1
+      end
+    end
+    
+    return 0 if count == 0
+    
+    # Characteristics are very hard to improve - most people stay at 2-3
+    char_level = (total.to_f / count / 1.5).round  # Scaled down to reflect training difficulty
+    
+    # Apply realistic caps based on NPC level
+    max_char = case @level
+               when 1..2 then 2  # Novices rarely exceed 2
+               when 3..4 then 3  # Experienced typically max at 3
+               when 5..6 then 4  # Veterans might reach 4
+               else 5            # Only masters achieve 5
+               end
+    
+    char_level = max_char if char_level > max_char
+    char_level
+  end
+  
+  def get_attribute(char_name, attr_name)
+    @tiers[char_name][attr_name]["level"] || 0
+  end
+  
+  def get_skill(char_name, attr_name, skill_name)
+    @tiers[char_name][attr_name]["skills"][skill_name] || 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)
+    
+    # Natural progression based on training difficulty:
+    # - Getting to 10 is achievable with focused skill training
+    # - Getting to 15 requires years of dedicated work
+    # - Getting to 18+ is legendary, requiring lifetime mastery
+    total = char_level + attr_level + skill_level
+    
+    # Apply soft cap at 18 for game balance (only true masters exceed)
+    if total > 18 && @level < 7
+      # Small chance for exceptional individuals to exceed 18
+      total = 18 unless rand(100) < 5
+    end
+    
+    total
+  end
+  
+  # Mark system for progression
+  
+  def add_mark(char_name, attr_name, skill_name = nil)
+    if skill_name
+      # Add mark to skill
+      key = "#{attr_name}/#{skill_name}"
+      @marks[char_name][key] ||= 0
+      @marks[char_name][key] += 1
+      
+      # Check if ready to advance
+      check_advancement(char_name, attr_name, skill_name)
+    else
+      # Add mark to attribute
+      @marks[char_name][attr_name] ||= 0
+      @marks[char_name][attr_name] += 1
+    end
+  end
+  
+  def check_advancement(char_name, attr_name, skill_name)
+    current_level = get_skill(char_name, attr_name, skill_name)
+    required_marks = (current_level + 1) * 5
+    key = "#{attr_name}/#{skill_name}"
+    
+    if @marks[char_name][key] >= required_marks
+      # Roll for advancement (all but a 1)
+      if oD6 > 1
+        @tiers[char_name][attr_name]["skills"][skill_name] += 1
+        @marks[char_name][key] = 0
+        
+        # Add mark to attribute above
+        add_mark(char_name, attr_name)
+        
+        return true
+      end
+    end
+    false
+  end
+  
+  private
+  
+  def generate_random_name(sex)
+    # Use the proper name generator based on race
+    race = @type.to_s.sub(/(:| ).*/, '').capitalize
+
+    # Use naming function from functions.rb which uses the actual name generator
+    name = naming(race, sex)
+
+    # Fallback to basic names if name generator fails
+    if name.nil? || name.empty?
+      if sex == "F" || (sex.empty? && rand(2) == 0)
+        female_names = ["Aria", "Luna", "Sera", "Mira", "Lyra", "Nova", "Kira", "Zara", "Elara", "Thalia"]
+        name = female_names.sample + " " + ["Starweaver", "Moonwhisper", "Brightblade", "Swiftwind", "Ironheart"].sample
+      else
+        male_names = ["Gareth", "Marcus", "Aldric", "Kael", "Doran", "Lucian", "Theron", "Cassius", "Orion", "Zephyr"]
+        name = male_names.sample + " " + ["Ironforge", "Stormcaller", "Darkbane", "Goldhand", "Steelclaw"].sample
+      end
+    end
+
+    name
+  end
+  
+  def ensure_essential_skills
+    # Ensure all NPCs have essential combat/stealth awareness skills (even if at 0)
+    # These skills are frequently used in encounters
+    
+    # Ensure Athletics attribute exists with essential skills
+    @tiers["BODY"]["Athletics"] ||= {"level" => 0, "skills" => {}}
+    @tiers["BODY"]["Athletics"]["skills"] ||= {}
+    
+    # Add Move Quietly if missing
+    unless @tiers["BODY"]["Athletics"]["skills"].key?("Move Quietly")
+      @tiers["BODY"]["Athletics"]["skills"]["Move Quietly"] = 0
+    end
+    
+    # Add Hide if missing
+    unless @tiers["BODY"]["Athletics"]["skills"].key?("Hide")
+      @tiers["BODY"]["Athletics"]["skills"]["Hide"] = 0
+    end
+    
+    # Add Dodge if missing (often used in combat)
+    unless @tiers["BODY"]["Athletics"]["skills"].key?("Dodge")
+      @tiers["BODY"]["Athletics"]["skills"]["Dodge"] = 0
+    end
+    
+    # Ensure Awareness attribute exists with essential skills
+    @tiers["MIND"]["Awareness"] ||= {"level" => 0, "skills" => {}}
+    @tiers["MIND"]["Awareness"]["skills"] ||= {}
+    
+    # Add Alertness if missing (this is the general awareness skill)
+    unless @tiers["MIND"]["Awareness"]["skills"].key?("Alertness")
+      @tiers["MIND"]["Awareness"]["skills"]["Alertness"] = 0
+    end
+    
+    # Reaction speed should always be present for initiative calculations
+    unless @tiers["MIND"]["Awareness"]["skills"].key?("Reaction speed")
+      @tiers["MIND"]["Awareness"]["skills"]["Reaction speed"] = 0
+    end
+  end
+
+  def apply_predetermined_stats
+    # Apply predetermined stats to preserve encounter consistency
+    # This allows encounters to pass specific stats that should not be randomized
+
+    return unless @predetermined_stats.is_a?(Hash)
+
+    # Override characteristics if provided
+    if @predetermined_stats["characteristics"]
+      @predetermined_stats["characteristics"].each do |char_name, value|
+        # This would require modifying the SIZE calculation system
+        # For now, we'll focus on weapons/armor/skills
+      end
+    end
+
+    # Override specific weapon skills if provided
+    if @predetermined_stats["weapon_skills"]
+      @predetermined_stats["weapon_skills"].each do |weapon, skill_level|
+        # Add to melee combat skills
+        @tiers["BODY"]["Melee Combat"]["skills"] ||= {}
+        @tiers["BODY"]["Melee Combat"]["skills"][weapon] = skill_level.to_i
+      end
+    end
+
+    # Override missile skills if provided
+    if @predetermined_stats["missile_skills"]
+      @predetermined_stats["missile_skills"].each do |weapon, skill_level|
+        @tiers["BODY"]["Missile Combat"]["skills"] ||= {}
+        @tiers["BODY"]["Missile Combat"]["skills"][weapon] = skill_level.to_i
+      end
+    end
+
+    # Override armor if provided
+    if @predetermined_stats["armor"]
+      @armor = @predetermined_stats["armor"]
+    end
+
+    # Override other skills if provided
+    if @predetermined_stats["skills"]
+      @predetermined_stats["skills"].each do |skill_path, value|
+        parts = skill_path.split("/")
+        next unless parts.length == 3
+
+        char_name, attr_name, skill_name = parts
+        next unless @tiers[char_name] && @tiers[char_name][attr_name]
+
+        @tiers[char_name][attr_name]["skills"] ||= {}
+        @tiers[char_name][attr_name]["skills"][skill_name] = value.to_i
+      end
+    end
+  end
+end