人狗大战Java代码实战精析
从零构建完整游戏逻辑与交互体验

本页面系统梳理“人狗大战”游戏的完整实现方案,涵盖面向对象设计、核心算法、异常处理、UI交互、性能优化及扩展性设计。适合Java初学者巩固基础,也适合进阶开发者参考架构设计思路。

立即探索项目全貌

一、项目背景与技术定位

〈什么是“人狗大战”?为何选择Java实现?〉

“人狗大战”是经典的回合制策略游戏,玩家控制人类角色与敌方狗群进行对抗。本项目使用Java语言实现,旨在通过游戏开发实践,系统掌握面向对象编程核心思想(封装、继承、多态)、集合框架应用、异常处理机制、Swing图形界面开发及基础游戏循环逻辑。

选择Java实现该类项目具有显著优势:强类型系统保障运行稳定性;丰富的标准库降低开发成本;跨平台特性支持多终端部署;面向对象特性契合游戏实体建模需求。尤其对初学者而言,此项目可作为从语法学习过渡到工程实践的桥梁。

〔技术栈全景图〕

  • 核心语言:Java SE 11+(重点使用集合框架、IO流、反射机制)
  • 界面开发:Swing/AWT(JFrame、JPanel、Graphics2D)
  • 资源管理:本地文件读写(Config配置、图片/音效路径)
  • 并发控制:基础多线程(GameLoop线程、定时任务)
  • 设计模式:工厂模式(角色创建)、状态模式(战斗阶段切换)
  • 测试工具:JUnit 5(单元测试覆盖核心算法逻辑)

需强调的是:虽然现代游戏开发多采用C#(Unity)或C++(Unreal),但Java在教育场景中因其语法清晰、生态成熟,仍是教学项目首选语言。本项目严格遵循“低耦合、高内聚”原则,为后续迁移到Web端(Spring Boot+Vue)或移动端(Android)预留接口扩展能力。

〔用户价值定位〕

本项目不仅提供可运行源码,更注重知识体系化沉淀。通过本页面,您将掌握:

  • 如何将现实游戏规则抽象为类层次结构(如Unit基类、Human/Dog子类)
  • 如何设计状态机管理游戏阶段(准备→战斗→结算)
  • 如何通过接口隔离原则解耦UI与业务逻辑
  • 如何利用Map集合实现动态属性系统(如角色成长参数)
  • 如何构建可复用的游戏组件(血条、技能面板)

二、架构设计与类层次分析

〈核心类设计图谱〉

采用UML类图思想梳理关键类关系,实际代码中通过接口与抽象类实现解耦:

// 核心类关系示意(非完整代码)
abstract class Unit {
    protected String name;
    protected int hp, maxHp, attack, defense;
    protected boolean isAlive;
    public Unit(String name, int hp, int attack, int defense) {
        this.name = name;
        this.hp = hp;
        this.maxHp = hp;
        this.attack = attack;
        this.defense = defense;
        this.isAlive = true;
    }
    public abstract void attack(Unit target); // 多态:人类与狗类攻击逻辑不同
    public void takeDamage(int damage) { ... }
    public boolean isAlive() { return isAlive; }
}
class Human extends Unit {
    private int level;
    private Mapint> skills = new HashMap<>(); // 技能库
    public Human(String name) {
        super(name, 100, 15, 5);
        this.level = 1;
    }
    public void learnSkill(String skillName, int damage) {
        skills.put(skillName, damage);
    }
    @Override
    public void attack(Unit target) {
        if (!isAlive) return;
        System.out.println(name + "挥动武器攻击" + target.name);
        target.takeDamage(attack);
    }
}
class Dog extends Unit {
    private String breed;
    public Dog(String name, String breed) {
        super(name, 60, 10, 3);
        this.breed = breed;
    }
    @Override
    public void attack(Unit target) {
        if (!isAlive) return;
        System.out.println(breed + "汪汪叫着扑向" + target.name);
        target.takeDamage(attack);
    }
}

〔状态管理机制〕

游戏流程采用状态机模式拆解为明确阶段:

  • 准备阶段:初始化角色(HumanFactory创建人类,DogFactory生成狗群)
  • 回合阶段:循环执行“人类行动→狗群行动→状态检查”
  • 结算阶段:统计存活数、计算得分、记录存档

关键设计在于通过GameStatus枚举隔离状态逻辑:

public enum GameStatus {
    PREPARING("准备中..."),
    BATTLE("战斗进行中"),
    RESULT("结算阶段");
    private final String description;
    GameStatus(String desc) { this.description = desc; }
    public String desc() { return description; }
}
class GameEngine {
    private GameStatus status = GameStatus.PREPARING;
    public void startBattle() {
        status = GameStatus.BATTLE;
        new Thread(this::gameLoop).start(); // 独立线程运行游戏循环
    }
    private void gameLoop() {
        while (status == GameStatus.BATTLE) {
            humanTurn();
            dogTurn();
            checkWinCondition();
        }
    }
}

〔数据持久化方案〕

为实现“存档/读档”功能,采用JSON格式存储游戏状态(替代简单文本):

  • 使用Gson库序列化/反序列化
  • 存档文件:savegame.json(包含角色属性、关卡进度)
  • 配置文件:config.json(音效开关、难度参数)

关键代码示例:

public class SaveManager {
    private final Gson gson = new GsonBuilder().serializeNulls().create();
    public void saveGame(List units, int level) {
        GameData data = new GameData(units, level);
        try (Writer writer = new FileWriter("savegame.json")) {
            gson.toJson(data, writer);
        } catch (IOException e) {
            System.err.println("存档失败" + e.getMessage());
        }
    }
    public GameData loadGame() {
        try (Reader reader = new FileReader("savegame.json")) {
            return gson.fromJson(reader, GameData.class);
        } catch (IOException e) {
            System.err.println("读档失败" + e.getMessage());
            return null;
        }
    }
}

三、核心代码实现详解

〈回合制战斗核心流程〉

战斗逻辑严格遵循“先手判定→行动执行→伤害计算→状态更新”流程:

public class CombatSystem {
    public void executeRound(List humans, List dogs) {
        if (humans.isEmpty() || dogs.isEmpty()) return;
        // 1. 人类主动攻击(随机选择目标)
        humans.forEach(human -> {
            Unit target = dogs.stream().filter(Unit::isAlive)
                             .collect(Collectors.toList()).get(
                                 ThreadLocalRandom.current().nextInt(dogs.size())
                             );
            human.attack(target);
        });
        // 2. 存活狗群反击(仅当人类存活)
        dogs.stream().filter(Unit::isAlive).forEach(dog -> {
            Unit target = humans.stream().filter(Unit::isAlive)
                               .collect(Collectors.toList()).get(
                                   ThreadLocalRandom.current().nextInt(humans.size())
                               );
            dog.attack(target);
        });
        // 3. 更新状态(移除死亡单位)
        humans.removeIf(unit -> !unit.isAlive());
        dogs.removeIf(unit -> !unit.isAlive());
    }
}

〈Swing界面组件构建〉

使用JPanel分层绘制游戏画面,关键组件包括:

  • GamePanel:主画布,负责重绘游戏场景
  • StatusPanel:顶部信息栏(显示血量、关卡、得分)
  • LogPanel:底部日志区(记录战斗事件)

核心绘制逻辑:

class GamePanel extends JPanel {
    private final List humans = new ArrayList<>();
    private final List dogs = new ArrayList<>();
    public GamePanel() {
        setPreferredSize(new Dimension(800, 600));
        setBackground(Color.WHITE);
    }
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g;
        // 绘制人类(蓝色圆圈)
        humans.forEach(human -> {
            g2d.setColor(Color.BLUE);
            g2d.fillOval(human.x, human.y, 30, 30);
            g2d.setColor(Color.BLACK);
            g2d.drawString(human.name, human.x, human.y - 5);
        });
        // 绘制狗群(橙色圆圈)
        dogs.forEach(dog -> {
            g2d.setColor(Color.ORANGE);
            g2d.fillOval(dog.x, dog.y, 24, 24);
            g2d.setColor(Color.BLACK);
            g2d.drawString(dog.name, dog.x, dog.y - 5);
        });
    }
}

〈简易AI决策机制〉

狗群AI采用基于优先级的简单决策树,模拟“攻击→移动→追击”行为:

  • 当人类距离<30像素时:优先攻击
  • 否则:向最近人类移动(曼哈顿距离计算)
  • 死亡后:停止所有行为

关键实现:

public class DogAI {
    private final Unit dog;
    private final List humans;
    public void think() {
        if (!dog.isAlive()) return;
        Unit target = findNearestHuman();
        if (target == null) return;
        int distance = Math.abs(dog.x - target.x) + Math.abs(dog.y - target.y);
        if (distance <= 30) {
            dog.attack(target); // 攻击范围触发
        } else {
            moveTowards(target); // 移动逻辑
        }
    }
    private Unit findNearestHuman() {
        return humans.stream().filter(Unit::isAlive)
                  .min(Comparator.comparingInt(h -> Math.abs(dog.x - h.x) + Math.abs(dog.y - h.y)))
                  .orElse(null);
    }
    private void moveTowards(Unit target) {
        int dx = Integer.compare(target.x, dog.x);
        int dy = Integer.compare(target.y, dog.y);
        dog.x += dx;
        dog.y += dy;
    }
}

〔完整项目目录结构〕

src/
├── main/
│   ├── java/
│   │   ├── com/
│   │   │   └── xservx/
│   │   │       ├── game/
│   │   │       │   ├── Unit.java
│   │   │       │   ├── Human.java
│   │   │       │   ├── Dog.java
│   │   │       │   ├── CombatSystem.java
│   │   │       │   ├── GameEngine.java
│   │   │       │   └── GameStatus.java
│   │   │       ├── ui/
│   │   │       │   ├── GamePanel.java
│   │   │       │   ├── StatusPanel.java
│   │   │       │   └── MainFrame.java
│   │   │       ├── io/
│   │   │       │   ├── SaveManager.java
│   │   │       │   └── Config.java
│   │   │       └── Main.java // 入口类
│   └── resources/
│       ├── config.json
│       └── sounds/
│           └── battle.mp3
└── test/
    └── java/
        └── com/
            └── xservx/
                └── game/
                    └── CombatSystemTest.java

四、调试技巧与异常处理

〈典型问题与解决方案〉

  • 问题1:界面卡死 → 原因:Swing线程阻塞(在EDT中执行耗时操作) → 解决:使用SwingWorker或独立线程处理游戏逻辑,通过invokeLater更新UI
  • 问题2:对象状态不同步 → 原因:多线程直接修改集合导致ConcurrentModificationException → 解决:使用Collections.synchronizedList()或CopyOnWriteArrayList
  • 问题3:技能效果未生效 → 原因:Map中技能值未正确初始化(key为null) → 解决:添加非空校验,使用Optional包装

〈日志系统构建〉

采用SLF4J+Logback实现分级日志:

private static final Logger logger = LoggerFactory.getLogger(GameEngine.class);
public class GameEngine {
    public void startBattle() {
        logger.info("开始第{}轮战斗", level);
        try {
            executeCombat();
        } catch (Exception e) {
            logger.error("战斗异常", e);
            System.err.println("游戏崩溃!请查看日志");
        }
    }
}

配置文件logback.xml示例:

<configuration>
  <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logs/game.log</file>
    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
      <fileNamePattern>logs/game.%d{yyyy-MM-dd}.log</fileNamePattern>
    </rollingPolicy>
  </appender>
  <root level="INFO">
    <appender-ref ref="FILE" />
  </root>
</configuration>

〈单元测试实践〉

使用JUnit 5测试核心算法:

@ExtendWith(MockitoExtension.class)
class CombatSystemTest {
    @Mock
    Unit human;
    @Mock
    Unit dog;
    @BeforeEach
    void setup() {
        when(human.isAlive()).thenReturn(true);
        when(dog.isAlive()).thenReturn(true);
    }
    @Test
    void testDamageCalculation() {
        CombatSystem combat = new CombatSystem();
        List humans = Arrays.asList(human);
        List dogs = Arrays.asList(dog);
        combat.executeRound(humans, dogs);
        verify(human).attack(dog);
        verify(dog).attack(human);
    }
}

五、扩展方向与进阶思考

〈多线程优化方案〉

当前实现中游戏循环在独立线程运行,但存在以下可优化点:

  • 资源加载:使用Future异步加载图片/音效(避免启动卡顿)
  • 碰撞检测:空间分区(四叉树)替代全量遍历
  • 网络对战:引入WebSocket实现双人实时对战

示例:异步资源加载框架:

public class ResourceManager {
    private final ExecutorService executor = Executors.newFixedThreadPool(4);
    public CompletableFuture loadImage(String path) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                return ImageIO.read(new File(path));
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }, executor);
    }
}

〈游戏平衡性设计〉

通过参数化配置实现动态平衡调整:

public class GameConfig {
    public static final Mapint> DIFFICULTY = new HashMap<>();
    static {
        DIFFICULTY.put("EASY", 1); // 难度系数
        DIFFICULTY.put("NORMAL", 2);
        DIFFICULTY.put("HARD", 3);
    }
    public static int getDogAttack(int difficultyLevel) {
        return 10 * difficultyLevel;
    }
}

〈Web端迁移路径〉

将核心逻辑抽离为Spring Boot REST API:

  • 端点1:POST /api/game/start → 返回初始状态JSON
  • 端点2:POST /api/game/action → 接收玩家操作并返回新状态
  • 端点3:GET /api/game/status → 查询实时战况

前端使用Vue/React构建界面,通过WebSocket保持实时同步:

@RestController
@RequestMapping("/api/game")
public class GameController {
    @Autowired
    private GameEngine gameEngine;
    @PostMapping("/start")
    public ResponseEntity startGame() {
        GameState state = gameEngine.initGame();
        return ResponseEntity.ok(state);
    }
}

六、网友最关心问题汇总

⑴ 为什么人狗大战要用Java实现?Python不行吗?

Java在以下方面更具优势:① 编译型语言运行效率更高;② 强类型系统减少运行时错误;③ 企业级应用更常用;④ Swing图形界面开发更成熟。Python虽适合快速原型,但Java在工程化项目中更稳定可靠。

⑵ 如何解决Swing界面在高分屏显示模糊?

方案:① 启动时添加-Dsun.java2d.uiScale=1.5参数;② 使用Graphics2D.setRenderingHint设置高精度渲染;③ 优先使用矢量图形(SVG)替代位图。

⑶ 技能冷却时间如何实现?

使用TimerTask定期检查冷却状态:① 在Unit类添加Map cooldowns;② 每次使用技能记录System.currentTimeMillis();③ 每帧检查当前时间与记录时间差值是否≥冷却阈值。

⑷ 如何添加音效?

使用Java Sound API:① 通过AudioSystem.getClip()获取音频剪辑;② 加载WAV格式文件;③ 在攻击/死亡事件触发clip.start()。注意:需处理AudioSystem.getLine()异常。

⑸ 项目如何适配手机端?

直接方案:① 使用JavaFX Mobile(已废弃);② 改用GDX框架;③ 最优解:抽离核心逻辑为API,前端用React Native开发。推荐第三种方案以保持代码复用性。

〔网页端适配建议〕

若需在浏览器运行本项目,可采用以下技术栈组合:

  • 方案A:GWT(Google Web Toolkit)→ Java转JavaScript
  • 方案B:TeaVM → Java字节码转JS
  • 方案C:J2CL(推荐)→ 谷歌开源工具,支持现代JS特性

以J2CL为例,需添加依赖:

<dependency>
  <groupId>com.google.j2cl</groupId>
  <artifactId>j2cl</artifactId>
  <version>0.10.0</version>
</dependency>