游戏回合制中实现持续性效果的教程

// Effect.java - 定义效果类
import java.util.Objects;

public class Effect {
    // 效果类型枚举，可根据游戏需求扩展
    public enum EffectType {
        DAMAGE_REDUCTION, // 降低伤害
        HEAL_OVER_TIME,   // 持续治疗
        STUN,             // 眩晕
        // ... 其他效果类型
    }

    private String name;        // 效果名称，用于显示
    private EffectType type;    // 效果类型
    private int magnitude;      // 效果强度，例如伤害减免的百分比或固定值
    private int duration;       // 效果剩余回合数

    public Effect(String name, EffectType type, int magnitude, int duration) {
        this.name = name;
        this.type = type;
        this.magnitude = magnitude;
        this.duration = duration;
    }

    // Getter 方法
    public String getName() { return name; }
    public EffectType getType() { return type; }
    public int getMagnitude() { return magnitude; }
    public int getDuration() { return duration; }

    /**
     * 减少效果的持续回合数。
     * @return true 如果效果仍未过期，false 如果已过期。
     */
    public boolean decrementDuration() {
        if (duration > 0) {
            duration--;
        }
        return duration > 0;
    }

    /**
     * 检查效果是否已过期。
     * @return true 如果效果已过期（持续时间小于等于0），否则为 false。
     */
    public boolean isExpired() {
        return duration <= 0;
    }

    @Override
    public String toString() {
        return name + " (类型: " + type + ", 强度: " + magnitude + ", 剩余回合: " + duration + ")";
    }
}

// Character.java - 角色类，包含效果管理逻辑
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Character {
    public String name;
    public int baseMinDamage; // 基础最小伤害
    public int baseMaxDamage; // 基础最大伤害
    private int currentMinDamage; // 当前最小伤害
    private int currentMaxDamage; // 当前最大伤害

    private List<Effect> activeEffects; // 活跃效果列表

    public Character(String name, int baseMinDamage, int baseMaxDamage) {
        this.name = name;
        this.baseMinDamage = baseMinDamage;
        this.baseMaxDamage = baseMaxDamage;
        this.currentMinDamage = baseMinDamage;
        this.currentMaxDamage = baseMaxDamage;
        this.activeEffects = new ArrayList<>();
    }

    // 获取当前伤害值
    public int getCurrentMinDamage() { return currentMinDamage; }
    public int getCurrentMaxDamage() { return currentMaxDamage; }

    /**
     * 为角色添加一个新效果。
     * @param effect 要添加的效果对象。
     */
    public void addEffect(Effect effect) {
        // TODO: 在这里可以添加效果叠加、刷新或覆盖的复杂逻辑
        activeEffects.add(effect);
        System.out.println(this.name + " 获得了效果: " + effect.getName() + " (持续 " + effect.getDuration() + " 回合)");
        // 效果添加后立即重新计算属性，以反映效果的影响
        recalculateAttributes();
    }

    /**
     * 重新计算所有受效果影响的属性，例如伤害。
     * 这是一个关键方法，确保属性值始终是所有活跃效果综合作用的结果。
     */
    private void recalculateAttributes() {
        // 每次重新计算时，先恢复到基础属性
        int tempMinDamage = baseMinDamage;
        int tempMaxDamage = baseMaxDamage;

        // 遍历所有活跃效果，应用其对属性的修改
        for (Effect effect : activeEffects) {
            if (effect.getType() == Effect.EffectType.DAMAGE_REDUCTION) {
                // 假设 magnitude 是减免的百分比，例如 50 表示减半
                tempMinDamage = tempMinDamage * (100 - effect.getMagnitude()) / 100;
                tempMaxDamage = tempMaxDamage * (100 - effect.getMagnitude()) / 100;
            }
            // ... 处理其他效果类型对属性的修改
        }

        // 更新角色的当前属性
        this.currentMinDamage = tempMinDamage;
        this.currentMaxDamage = tempMaxDamage;
        System.out.println(this.name + " 的属性已更新。当前伤害: " + currentMinDamage + "-" + currentMaxDamage);
    }

    /**
     * 在每个回合结束时调用，处理所有活跃效果的持续时间及生效逻辑。
     */
    public void processTurnEffects() {
        System.out.println("\n--- " + this.name + " 回合效果处理 ---");
        Iterator<Effect> iterator = activeEffects.iterator();
        boolean attributesChanged = false; // 标记是否有效果过期，需要重新计算属性

        while (iterator.hasNext()) {
            Effect effect = iterator.next();

            // TODO: 在这里应用每回合持续生效的效果，例如持续伤害或治疗
            // if (effect.getType() == Effect.EffectType.HEAL_OVER_TIME) {
            //     this.takeDamage(-effect.getMagnitude()); // 负伤害表示治疗
            // }

            effect.decrementDuration(); // 持续回合数减1

            if (effect.isExpired()) {
                System.out.println(this.name + " 的效果 " + effect.getName() + " 已结束。");
                iterator.remove(); // 从列表中移除已过期的效果
                attributesChanged = true; // 效果移除，需要重新计算属性
            } else {
                System.out.println(this.name + " 的效果 " + effect.getName() + " 剩余 " + effect.getDuration() + " 回合。");
            }
        }

        // 如果有效果过期，重新计算属性以反映变化
        if (attributesChanged) {
            recalculateAttributes();
        } else {
            System.out.println(this.name + " 当前伤害: " + currentMinDamage + "-" + currentMaxDamage);
        }
    }
}

// GameLogic.java - 游戏主逻辑示例
public class GameLogic {
    /**
     * 模拟施放一个削弱法术，降低目标伤害。
     * @param caster 施法者
     * @param target 目标角色
     */
    public static void castCripplingSpell(Character caster, Character target) {
        // 假设“削弱”法术效果为降低目标50%伤害，持续3回合
        Effect crippleEffect = new Effect("削弱", Effect.EffectType.DAMAGE_REDUCTION, 50, 3);
        target.addEffect(crippleEffect);
        System.out.println(caster.name + " 对 " + target.name + " 施放了削弱法术！");
    }

    public static void main(String[] args) {
        // 创建两个角色
        Character hero1 = new Character("勇士A", 100, 120);
        Character hero2 = new Character("法师B", 80, 100);

        System.out.println("--- 游戏开始：初始状态 ---");
        System.out.println(hero1.name + " 伤害: " + hero1.getCurrentMinDamage() + "-" + hero1.getCurrentMaxDamage());
        System.out.println(hero2.name + " 伤害: " + hero2.getCurrentMinDamage() + "-" + hero2.getCurrentMaxDamage());

        // 模拟游戏回合
        for (int round = 1; round <= 5; round++) {
            System.out.println("\n==================== 回合 " + round + " ====================");

            // 假设在回合1，勇士A对法师B施放削弱法术
            if (round == 1) {
                castCripplingSpell(hero1, hero2);
            }

            // 处理每个角色的回合效果
            // 注意：实际游戏中可能需要更复杂的顺序，例如先玩家行动，后处理效果
            hero