🏠个人主页：黎雁
🎬作者简介：C/C++/JAVA后端开发学习者
❄️个人专栏：C语言、数据结构（C语言）、EasyX、JAVA、游戏、规划、程序人生
✨ 从来绝巘须孤往，万里同尘即玉京

【魔法森林冒险】9/14 敌人系统：Goblin/Elf的AI与战斗基础👹🧝‍♀️

📝 文章摘要

内容维度	详情说明
核心摘要	本文是「魔法森林冒险」Java项目系列第九篇，聚焦敌人系统的完整设计逻辑。从Enemy抽象父类的通用战斗属性封装，到哥布林（Goblin）、精灵（Elf）两大子类的差异化AI实现（随机攻击/逃跑决策），再到敌人与Allen/Lia的战斗前置交互规则，带你吃透「抽象类+AI决策逻辑」在敌人系统中的落地应用。
阅读时长	15分钟
适合人群	1. Java新手：想掌握「随机数AI决策+战斗逻辑+抽象类继承」的实战；2. 游戏开发入门者：想理解敌人AI的基础设计（攻击/逃跑）与战斗交互；3. 项目复刻者：想复刻不同敌人的差异化攻击逻辑与AI行为。
阅读重点	1. Enemy抽象类的通用战斗属性与抽象方法设计；2. 哥布林/精灵的攻击逻辑（固定伤害+随机暴击/魔法伤害）；3. 敌人AI决策机制（血量阈值触发逃跑/疯狂攻击）；4. 与Allen/Lia的战斗前置交互规则（仇恨值/先手攻击）。

👹 一、敌人系统的核心定位：游戏的「战斗挑战核心」

在「魔法森林冒险」中，敌人系统是战斗玩法的核心支撑：
✅ AI差异化 → 哥布林（低智商/随机逃跑）、精灵（高智商/魔法攻击），不同敌人有不同战斗风格；
✅ 难度梯度 → 普通哥布林（基础）→ 哥布林首领（强化）→ 精灵弓箭手（高伤），匹配游戏进度；
✅ 战斗交互 → 敌人有仇恨值机制，优先攻击Allen，Lia信任度达标可吸引仇恨；
✅ 奖励驱动 → 击败敌人掉落金币/道具，补充Allen的资源，推动游戏循环。

敌人系统的设计核心是「抽象统一+AI差异化」：用Enemy抽象类封装所有敌人的通用战斗属性，子类实现各自的攻击逻辑和AI决策，既保证代码复用，又体现敌人的多样性。接下来拆解核心代码，吃透这个设计思路！

🔧 二、核心代码拆解（一）：Enemy抽象父类 - 敌人系统的「骨架」

2.1 完整核心代码（未修改，拆分讲解）

/**
 * 所有敌人的抽象父类Enemy
 * 继承Figure基础类，封装通用战斗属性，定义抽象方法
 */
public abstract class Enemy extends Figure {
    // ========== 通用战斗属性 ==========
    // 当前HP
    protected int currentHp;
    // 最大HP
    protected int maxHp;
    // 基础攻击力
    protected int baseAttack;
    // 金币掉落值
    protected int goldDrop;
    // 仇恨值（优先攻击目标：0=Allen，1=Lia）
    protected int hateTarget;
    // 是否处于逃跑状态
    protected boolean isFleeing;
    // 逃跑阈值（HP低于该比例触发逃跑判定）
    protected double fleeThreshold;

    // ========== 构造方法 ==========
    public Enemy(String name, String description, int maxHp, int baseAttack, int goldDrop, double fleeThreshold) {
        super(name, description);
        this.maxHp = maxHp;
        this.currentHp = maxHp; // 初始HP满值
        this.baseAttack = baseAttack;
        this.goldDrop = goldDrop;
        this.fleeThreshold = fleeThreshold;
        this.hateTarget = 0; // 默认仇恨Allen
        this.isFleeing = false;
        System.out.println("⚠️ 遭遇敌人：" + name + "！" + description);
    }

    // ========== 抽象方法：子类必须实现的核心功能 ==========
    /**
     * 敌人攻击方法（子类实现差异化攻击）
     * @return 攻击伤害值
     */
    public abstract int attack();

    /**
     * AI决策方法（子类实现逃跑/攻击/疯狂攻击等决策）
     * @return 决策结果：0=攻击，1=逃跑，2=疯狂攻击
     */
    public abstract int aiDecision();

    // ========== 通用战斗方法 ==========
    /**
     * 受到伤害处理
     * @param damage 受到的伤害值
     * @return 是否存活
     */
    public boolean takeDamage(int damage) {
        // 1. 扣减HP（最低为0）
        this.currentHp = Math.max(this.currentHp - damage, 0);
        System.out.println("💥 " + this.name + "受到" + damage + "点伤害！当前HP：" + this.currentHp + "/" + this.maxHp);
        // 2. 检查是否死亡
        if (this.currentHp <= 0) {
            System.out.println("✅ " + this.name + "被击败！");
            return false; // 死亡
        }
        // 3. 检查是否触发逃跑判定（未逃跑且HP低于阈值）
        if (!this.isFleeing && (double) this.currentHp / this.maxHp <= this.fleeThreshold) {
            int decision = this.aiDecision();
            if (decision == 1) {
                this.isFleeing = true;
                System.out.println("🏃 " + this.name + "害怕了，准备逃跑！");
            } else if (decision == 2) {
                System.out.println("🔥 " + this.name + "陷入疯狂，攻击力提升！");
                this.baseAttack = (int) (this.baseAttack * 1.5); // 疯狂攻击：攻击力提升50%
            }
        }
        return true; // 存活
    }

    /**
     * 掉落奖励（金币+随机道具）
     * @param allen 奖励接收者
     */
    public void dropReward(Allen allen) {
        // 1. 掉落金币
        allen.setGold(allen.getGold() + this.goldDrop);
        System.out.println("💰 击败" + this.name + "获得" + this.goldDrop + "金币！当前金币：" + allen.getGold());
        // 2. 随机掉落道具（20%概率掉落普通治疗药水）
        double dropChance = Math.random();
        if (dropChance <= 0.2) {
            Item potion = new HealPotion();
            allen.pickItem(potion);
            System.out.println("🎁 额外掉落：普通治疗药水！");
        }
    }

    /**
     * 切换仇恨目标（Lia信任度≥60可吸引仇恨）
     * @param lia Lia对象
     */
    public void switchHateTarget(Lia lia) {
        if (lia.getTrustLevel() >= 60) {
            this.hateTarget = 1;
            System.out.println("❤️ 莉娅的信任度足够，" + this.name + "将仇恨转向莉娅！");
        }
    }

    // ========== Getter/Setter ==========
    public int getCurrentHp() {
        return currentHp;
    }

    public boolean isFleeing() {
        return isFleeing;
    }

    public int getHateTarget() {
        return hateTarget;
    }

    public String getName() {
        return this.name;
    }
}

// 依赖的基础类补充（保证代码可运行）
abstract class Figure {
    protected String name;
    protected String description;

    public Figure(String name, String description) {
        this.name = name;
        this.description = description;
    }
}

// 道具类依赖（简化版）
class HealPotion extends Item {
    public HealPotion() {
        super("普通治疗药水", "恢复20点HP", "基础道具", true, "普通");
    }

    @Override
    public boolean use(Person target) {
        return true;
    }

    @Override
    public String getEffectDesc() {
        return "恢复20点HP";
    }
}

abstract class Item {
    protected String name;
    protected String description;
    protected String type;
    protected boolean isConsumable;
    protected String rarity;

    public Item(String name, String description, String type, boolean isConsumable, String rarity) {
        this.name = name;
        this.description = description;
        this.type = type;
        this.isConsumable = isConsumable;
        this.rarity = rarity;
    }

    public abstract boolean use(Person target);
    public abstract String getEffectDesc();

    public String getName() {
        return name;
    }
}

// Person类依赖（简化版）
abstract class Person {
    protected String name;
    protected int hp;
    protected int maxHp;
    protected int gold;

    public Person(String name, int maxHp) {
        this.name = name;
        this.maxHp = maxHp;
        this.hp = maxHp;
        this.gold = 0;
    }

    public int getHp() {
        return hp;
    }

    public void setHp(int hp) {
        this.hp = Math.min(hp, maxHp);
    }

    public int getMaxHp() {
        return maxHp;
    }

    public int getGold() {
        return gold;
    }

    public void setGold(int gold) {
        this.gold = gold;
    }

    public String getName() {
        return name;
    }
}

class Allen extends Person {
    private List<Item> backpack = new ArrayList<>();

    public Allen() {
        super("艾伦", 100);
    }

    public void pickItem(Item item) {
        backpack.add(item);
    }
}

class Lia extends Person {
    private int trustLevel;

    public Lia() {
        super("莉娅", 80);
        this.trustLevel = 0;
    }

    public int getTrustLevel() {
        return trustLevel;
    }

    public void setTrustLevel(int trustLevel) {
        this.trustLevel = trustLevel;
    }
}

2.2 关键知识点讲解💡

（1）抽象类设计的核心逻辑

• 通用战斗属性封装：currentHp/baseAttack/hateTarget等是所有敌人的共性，放在抽象父类中，避免子类重复定义；
• 抽象方法约束：attack()（攻击逻辑）和aiDecision()（AI决策）是所有敌人必须实现的核心功能，强制子类差异化实现；
• 通用战斗逻辑共享：takeDamage()（受击处理）、dropReward()（掉落奖励）等通用逻辑放在父类，子类直接继承，保证战斗流程统一。

👉 新手重点：敌人系统的抽象类设计，既保证了战斗规则的统一，又为不同敌人的差异化AI留出扩展空间。

🔧 三、核心代码拆解（二）：敌人子类 - 差异化AI实现

3.1 基础敌人：Goblin（哥布林）- 低智商/随机逃跑

/**
 * 基础敌人：哥布林Goblin
 * 继承Enemy抽象类，实现低智商AI（随机攻击/逃跑）
 */
public class Goblin extends Enemy {
    // 专属属性：是否是首领（强化版）
    private boolean isLeader;

    // ========== 构造方法 ==========
    // 普通哥布林
    public Goblin() {
        // 调用父类构造：HP50，攻击力10，金币掉落5，逃跑阈值30%
        super("普通哥布林", "森林里的低智商小怪，攻击力弱", 50, 10, 5, 0.3);
        this.isLeader = false;
    }

    // 哥布林首领（强化版）
    public Goblin(boolean isLeader) {
        super("哥布林首领", "哥布林营地的头目，攻击力更强", 80, 15, 15, 0.2);
        this.isLeader = isLeader;
        System.out.println("👑 这是哥布林首领！攻击力和血量都有提升！");
    }

    // ========== 核心方法实现 ==========
    @Override
    public int attack() {
        // 1. 逃跑状态下攻击伤害减半
        if (this.isFleeing()) {
            int damage = (int) (this.baseAttack * 0.5);
            System.out.println("🏃 哥布林边逃边攻击，造成" + damage + "点伤害！");
            return damage;
        }

        // 2. 普通攻击：10%概率暴击（伤害翻倍）
        double critChance = Math.random();
        int damage = this.baseAttack;
        if (critChance <= 0.1) {
            damage *= 2;
            System.out.println("💥 哥布林暴击！造成" + damage + "点伤害！");
        } else {
            System.out.println("⚔️ 哥布林发起攻击，造成" + damage + "点伤害！");
        }

        // 3. 首领额外效果：20%概率召唤小弟（提示）
        if (this.isLeader && Math.random() <= 0.2) {
            System.out.println("📢 哥布林首领大喊：兄弟们一起上！");
            System.out.println("⚠️ 额外出现1只普通哥布林！");
        }
        return damage;
    }

    @Override
    public int aiDecision() {
        // 哥布林AI：低智商随机决策
        double random = Math.random();
        if (random <= 0.5) {
            return 0; // 50%概率继续攻击
        } else if (random <= 0.8) {
            return 1; // 30%概率逃跑
        } else {
            return 2; // 20%概率疯狂攻击
        }
    }

    // ========== 重写掉落奖励（首领额外掉落） ==========
    @Override
    public void dropReward(Allen allen) {
        super.dropReward(allen);
        // 首领额外掉落：魔法花种子（100%概率）
        if (this.isLeader) {
            Item flowerSeed = new Item("魔法花种子", "可种植魔法花", "关键道具", false, "普通") {
                @Override
                public boolean use(Person target) {
                    return true;
                }

                @Override
                public String getEffectDesc() {
                    return "种植后获得魔法花，提升莉娅信任度";
                }
            };
            allen.pickItem(flowerSeed);
            System.out.println("🎁 哥布林首领额外掉落：魔法花种子！");
        }
    }
}

3.2 进阶敌人：Elf（精灵）- 高智商/魔法攻击

/**
 * 进阶敌人：精灵Elf
 * 继承Enemy抽象类，实现高智商AI（魔法攻击/低逃跑概率）
 */
public class Elf extends Enemy {
    // 专属属性：魔法攻击力（基础攻击的1.5倍）
    private int magicAttack;
    // 魔法值（释放魔法需要消耗）
    private int mp;
    private final int maxMp = 30;

    // ========== 构造方法 ==========
    public Elf() {
        // 调用父类构造：HP60，攻击力12，金币掉落10，逃跑阈值20%（高智商，逃跑概率低）
        super("精灵弓箭手", "森林精灵的叛徒，擅长魔法箭攻击", 60, 12, 10, 0.2);
        this.magicAttack = (int) (this.baseAttack * 1.5);
        this.mp = this.maxMp; // 初始MP满值
    }

    // ========== 核心方法实现 ==========
    @Override
    public int attack() {
        // 1. 逃跑状态下不释放魔法
        if (this.isFleeing()) {
            int damage = this.baseAttack;
            System.out.println("🏃 精灵边逃边射箭，造成" + damage + "点伤害！");
            return damage;
        }

        // 2. 高智商决策：MP≥10时释放魔法攻击
        if (this.mp >= 10) {
            this.mp -= 10;
            System.out.println("🔮 精灵释放魔法箭！消耗10点MP，当前MP：" + this.mp + "/" + this.maxMp);
            System.out.println("💥 造成" + this.magicAttack + "点魔法伤害！");
            return this.magicAttack;
        } else {
            // MP不足时普通攻击，50%概率回复5点MP
            if (Math.random() <= 0.5) {
                this.mp += 5;
                System.out.println("🔋 精灵回复5点MP！当前MP：" + this.mp + "/" + this.maxMp);
            }
            System.out.println("🏹 精灵普通射箭，造成" + this.baseAttack + "点伤害！");
            return this.baseAttack;
        }
    }

    @Override
    public int aiDecision() {
        // 精灵AI：高智商，逃跑概率低，优先疯狂攻击
        double random = Math.random();
        if (random <= 0.7) {
            return 0; // 70%概率继续攻击
        } else if (random <= 0.8) {
            return 1; // 10%概率逃跑（远低于哥布林）
        } else {
            return 2; // 20%概率疯狂攻击
        }
    }

    // ========== 重写受击处理（精灵闪避机制） ==========
    @Override
    public boolean takeDamage(int damage) {
        // 精灵有15%概率闪避攻击
        double dodgeChance = Math.random();
        if (dodgeChance <= 0.15) {
            System.out.println("💨 精灵闪避了攻击！没有受到伤害！");
            return true; // 存活
        }
        // 未闪避则执行父类受击逻辑
        return super.takeDamage(damage);
    }

    // ========== 重写掉落奖励（精灵掉落魔法道具） ==========
    @Override
    public void dropReward(Allen allen) {
        super.dropReward(allen);
        // 30%概率掉落魔法卷轴
        if (Math.random() <= 0.3) {
            Item scroll = new Item("基础魔法卷轴", "临时提升MP", "特殊道具", true, "普通") {
                @Override
                public boolean use(Person target) {
                    return true;
                }

                @Override
                public String getEffectDesc() {
                    return "提升30点MP，持续3回合";
                }
            };
            allen.pickItem(scroll);
            System.out.println("🎁 精灵额外掉落：基础魔法卷轴！");
        }
    }
}

🔧 四、战斗前置交互：仇恨值/先手攻击逻辑

4.1 战斗前置交互核心代码（Allen类补充）

/**
 * Allen类中补充的战斗前置交互方法
 */
public class Allen extends Person {
    // 战斗相关属性：攻击力/技能等级
    private int attackPower = 15;
    private int skillLevel = 1;

    // ========== 先手攻击判定 ==========
    /**
     * 先手攻击敌人（技能等级≥2有先手权）
     * @param enemy 目标敌人
     * @return 先手攻击伤害
     */
    public int firstAttack(Enemy enemy) {
        if (this.skillLevel >= 2) {
            int damage = (int) (this.attackPower * 1.2); // 先手攻击伤害提升20%
            System.out.println("⚡ 艾伦技能等级足够，发起先手攻击！");
            enemy.takeDamage(damage);
            return damage;
        } else {
            System.out.println("❌ 艾伦技能等级不足，无法先手攻击！");
            return 0;
        }
    }

    // ========== 吸引仇恨/转移仇恨 ==========
    /**
     * 吸引敌人仇恨（让敌人优先攻击自己）
     * @param enemy 目标敌人
     */
    public void attractHate(Enemy enemy) {
        enemy.switchHateTarget(new Lia()); // 重置仇恨到自己
        System.out.println("🛡️ 艾伦吸引了" + enemy.getName() + "的仇恨！");
    }

    // ========== Getter/Setter ==========
    public int getAttackPower() {
        return attackPower;
    }

    public void setAttackPower(int attackPower) {
        this.attackPower = attackPower;
    }

    public int getSkillLevel() {
        return skillLevel;
    }

    public void setSkillLevel(int skillLevel) {
        this.skillLevel = skillLevel;
    }

    // 其他方法省略...
}

4.2 Lia的仇恨吸引逻辑（Lia类补充）

/**
 * Lia类中补充的仇恨吸引方法
 */
public class Lia extends Person {
    // 信任度属性
    private int trustLevel = 0;

    /**
     * 吸引敌人仇恨（信任度≥60生效）
     * @param enemy 目标敌人
     */
    public void attractHate(Enemy enemy) {
        if (this.trustLevel >= 60) {
            enemy.switchHateTarget(this);
            System.out.println("❤️ 莉娅信任度足够，吸引了" + enemy.getName() + "的仇恨！");
        } else {
            System.out.println("❌ 莉娅信任度不足，无法吸引仇恨！");
        }
    }

    // ========== 辅助攻击 ==========
    /**
     * 辅助Allen攻击敌人（信任度≥80触发）
     * @param enemy 目标敌人
     * @return 辅助攻击伤害
     */
    public int helpAttack(Enemy enemy) {
        if (this.trustLevel >= 80) {
            int damage = 8;
            System.out.println("🤝 莉娅信任度满，发起辅助攻击！");
            enemy.takeDamage(damage);
            return damage;
        } else {
            return 0;
        }
    }

    // Getter/Setter省略...
}

🧪 五、调试示例：敌人系统完整交互

import java.util.ArrayList;
import java.util.List;

/**
 * 敌人系统调试示例
 */
public class EnemySystemTest {
    public static void main(String[] args) {
        // 1. 创建角色对象
        Allen allen = new Allen();
        Lia lia = new Lia();
        lia.setTrustLevel(70); // 设置Lia信任度70（可吸引仇恨）

        // 2. 创建敌人对象
        Enemy normalGoblin = new Goblin(); // 普通哥布林
        Enemy goblinLeader = new Goblin(true); // 哥布林首领
        Enemy elfArcher = new Elf(); // 精灵弓箭手

        // 3. 普通哥布林战斗交互
        System.out.println("\n=== 普通哥布林战斗 ===");
        // Allen先手攻击（技能等级≥2）
        allen.setSkillLevel(2);
        allen.firstAttack(normalGoblin);
        // 哥布林攻击（仇恨Allen）
        normalGoblin.attack();
        // 哥布林受击至逃跑阈值
        normalGoblin.takeDamage(35); // HP降至15（30%阈值）
        // 击败哥布林，获取奖励
        normalGoblin.takeDamage(15);
        normalGoblin.dropReward(allen);

        // 4. 精灵弓箭手战斗交互
        System.out.println("\n=== 精灵弓箭手战斗 ===");
        // Lia吸引仇恨
        lia.attractHate(elfArcher);
        // 精灵攻击（仇恨转向Lia）
        elfArcher.attack();
        // 精灵受击（触发闪避）
        elfArcher.takeDamage(20);
        // 精灵释放魔法攻击
        elfArcher.attack();
        // 击败精灵，获取奖励
        elfArcher.takeDamage(60);
        elfArcher.dropReward(allen);

        // 5. 哥布林首领战斗交互
        System.out.println("\n=== 哥布林首领战斗 ===");
        // 首领受击至疯狂状态
        goblinLeader.takeDamage(64); // HP降至16（20%阈值）
        // 疯狂攻击（攻击力提升50%）
        goblinLeader.attack();
        // 击败首领，获取额外奖励
        goblinLeader.takeDamage(16);
        goblinLeader.dropReward(allen);
    }
}

调试输出结果（核心片段）：

⚠️ 遭遇敌人：普通哥布林！森林里的低智商小怪，攻击力弱
⚠️ 遭遇敌人：哥布林首领！哥布林营地的头目，攻击力更强
👑 这是哥布林首领！攻击力和血量都有提升！
⚠️ 遭遇敌人：精灵弓箭手！森林精灵的叛徒，擅长魔法箭攻击

=== 普通哥布林战斗 ===
⚡ 艾伦技能等级足够，发起先手攻击！
💥 普通哥布林受到18点伤害！当前HP：32/50
⚔️ 哥布林发起攻击，造成10点伤害！
💥 普通哥布林受到35点伤害！当前HP：0/50
✅ 普通哥布林被击败！
💰 击败普通哥布林获得5金币！当前金币：5

=== 精灵弓箭手战斗 ===
❤️ 莉娅的信任度足够，精灵弓箭手将仇恨转向莉娅！
🔮 精灵释放魔法箭！消耗10点MP，当前MP：20/30
💥 造成18点魔法伤害！
💨 精灵闪避了攻击！没有受到伤害！
🔮 精灵释放魔法箭！消耗10点MP，当前MP：10/30
💥 造成18点魔法伤害！
💥 精灵弓箭手受到60点伤害！当前HP：0/60
✅ 精灵弓箭手被击败！
💰 击败精灵弓箭手获得10金币！当前金币：15
🎁 额外掉落：普通治疗药水！
🎁 精灵额外掉落：基础魔法卷轴！

=== 哥布林首领战斗 ===
💥 哥布林首领受到64点伤害！当前HP：16/80
🔥 哥布林首领陷入疯狂，攻击力提升！
💥 哥布林首领暴击！造成22点伤害！
💥 哥布林首领受到16点伤害！当前HP：0/80
✅ 哥布林首领被击败！
💰 击败哥布林首领获得15金币！当前金币：30
🎁 额外掉落：普通治疗药水！
🎁 哥布林首领额外掉落：魔法花种子！

👉 结论：敌人系统的AI决策（逃跑/疯狂攻击）、攻击逻辑（暴击/魔法）、仇恨值切换、奖励掉落等逻辑完全生效，不同敌人的差异化战斗风格符合预期！

🚨 六、敌人系统设计的「新手坑」与最佳实践

（1）新手常见错误

错误写法	正确写法	问题说明
AI决策用固定值（永远攻击/永远逃跑）	用Math.random()实现随机决策	AI行为单一，战斗体验差
直接修改敌人HP（enemy.currentHp -= 10）	通过takeDamage()方法修改	绕过受击逻辑（逃跑判定/疯狂攻击），AI机制失效
所有敌人掉落相同奖励	重写dropReward()实现差异化掉落	奖励无区分，游戏趣味性低

（2）最佳实践

1. AI决策随机化：用随机数实现不同概率的决策（攻击/逃跑/疯狂），体现敌人智商差异；
2. 战斗逻辑分层：通用逻辑（受击/掉落）放父类，差异化逻辑（攻击/AI）放子类；
3. 仇恨值联动化：仇恨值与Lia信任度联动，体现角色协作；
4. 奖励差异化：不同敌人掉落不同奖励，匹配敌人难度。

📌 知识回顾

1. 敌人系统采用「抽象类+子类」的分层设计：Enemy抽象类封装通用战斗属性和方法，子类实现差异化攻击逻辑和AI决策；
2. 哥布林（低智商）和精灵（高智商）的AI决策概率不同，体现敌人的差异化战斗风格；
3. 仇恨值机制与Lia信任度联动：信任度≥60可吸引敌人仇恨，体现角色协作；
4. 敌人受击至阈值时触发AI决策（逃跑/疯狂攻击），提升战斗策略性；
5. 不同敌人的奖励掉落差异化，普通敌人掉落基础奖励，首领/进阶敌人掉落稀有道具。

✍️ 写在最后

敌人系统是「魔法森林冒险」战斗玩法的核心，其「抽象统一+AI差异化」的设计思路，既保证了战斗规则的一致性，又通过随机数和条件分支实现了丰富的AI行为。从基础的哥布林到进阶的精灵，难度梯度的设计让游戏战斗更有层次感。

下一篇我们会聚焦「战斗系统（一）：基础回合制逻辑」，带你拆解完整的回合制战斗流程框架、Allen的行动选择（攻击/道具/逃跑）、伤害计算规则，以及Lia辅助攻击的触发条件⚔️。

新手建议：

1. 在IDE中运行本文的调试示例，尝试新增一个「兽人」敌人子类，实现其攻击逻辑（近战高伤+低闪避）和AI决策（极低逃跑概率）；
2. 思考：如果新增「敌人属性克制」机制（比如魔法攻击对精灵伤害减半），该如何修改takeDamage()方法？

---

🔥 系列文章导航：

1. 项目总览：设计与架构
2. 抽象层设计：Figure/Person类
3. Allen类（一）：核心属性与初始化
4. Allen类（二）：道具交互核心逻辑
5. Allen类（三）：任务进度与状态管理
6. Lia类深度解析：盟友角色的设计与交互
7. 老贤者 & 树灵：NPC/BOSS角色的设计
8. 道具系统：基础/关键/特殊道具的实现
9. 敌人系统：Goblin/Elf的AI与战斗基础（本文）
10. 战斗系统（一）：基础回合制逻辑
    …（后续篇章持续更新）

💬 评论区互动：你觉得敌人系统还可以增加哪些功能？比如「敌人等级成长（随游戏进度变强）」「敌人组队战斗（多个敌人协同）」，或者「敌人弱点机制（特定道具造成双倍伤害）」？