星际争霸小程序：用Java实现策略模式的星际大战

最新推荐文章于 2025-05-20 22:23:34 发布

蓝瓶电液

最新推荐文章于 2025-05-20 22:23:34 发布

阅读量783

点赞数 8

文章标签： java 策略模式开发语言

本文链接：https://blog.csdn.net/wwzzh24/article/details/148077119

版权

在游戏开发的世界里，策略模式是一种非常实用的设计模式，它允许我们在运行时动态地选择算法或行为。今天，我将带你走进一场星际争霸的奇幻之旅，用Java实现一个简单的星际争霸小程序，通过策略模式来模拟不同种族单位的战斗行为。

实验背景

星际争霸是一款经典的即时战略游戏，玩家需要控制不同种族的单位进行战斗。每个种族都有其独特的单位和战斗策略。在本次实验中，我选择了Java语言，利用策略模式来实现不同种族单位的攻击行为。通过策略模式，我们可以轻松地为单位切换不同的攻击策略，从而使代码更加灵活和可扩展。

实验设计

1. 整体思路

为了实现星际争霸小程序，我们需要构建一个包含不同种族单位的战场。每个单位都有其生命值、攻击力和特定的攻击策略。通过策略模式，我们可以为单位动态切换攻击策略，从而模拟不同的战斗场景。

2.UML图

3. 主要模块设计

（1）攻击策略接口
定义一个攻击策略接口 'Strategy'，所有具体的攻击策略类都将实现这个接口。

package attack;

import creature.Creature;

public interface Strategy {
    void fight(Creature c);
    int getattack();
}

（2）具体攻击策略类
实现具体的攻击策略类，如 'Air' 和 'Ground'，分别对应空中攻击和地面攻击。

package attack;

import mutalisk.Mutalisk;
import creature.Creature;

public class Air implements Strategy {
    private int attack = 120;
    private int up = 200;
    private Mutalisk mutalisk;

    public Air(Mutalisk mutalisk) {
        this.mutalisk = mutalisk;
    }

    public void recover(int amount) {
        mutalisk.life += amount;
    }

    @Override
    public void fight(Creature c) {
        System.out.println("空中攻击模式");
        System.out.println(mutalisk.name + "攻击" + c.name + " " + attack + "滴血");
        c.updateLife(attack);
        recover(up);
    }

    @Override
    public int getattack() {
        return this.attack;
    }
}

package attack;

import mutalisk.Mutalisk;
import creature.Creature;

public class Ground implements Strategy {
    private int attack = 400;
    private int up_rc = 100;
    private Mutalisk mutalisk;

    public Ground(Mutalisk mutalisk) {
        this.mutalisk = mutalisk;
    }

    public void recover(int amount) {
        mutalisk.life += amount;
    }

    @Override
    public void fight(Creature c) {
        System.out.println("地面攻击模式");
        System.out.println(mutalisk.name + "攻击" + c.name + " " + attack + "滴血");
        c.updateLife(attack);
        recover(up_rc);
    }

    @Override
    public int getattack() {
        return this.attack;
    }
}

（3）单位抽象类
定义一个抽象类 'Creature'，所有具体的单位类都将继承这个类。

package creature;

import attack.Strategy;
import common.ICommon;

public abstract class Creature implements ICommon, Strategy {
    public String name;
    public int life;
    protected int attack;

    public Creature(String name, int life, int attack) {
        this.name = name;
        this.life = life;
        this.attack = attack;
    }

    public Creature(String name, int life) {
        this.name = name;
        this.life = life;
    }

    @Override
    public void state() {
        if (this.isDead()) {
            System.out.println("[" + this.name + "]已阵亡");
        } else {
            System.out.println("[" + this.name + "]的当前生命值为" + life + ";当前攻击值为" + attack);
        }
    }

    @Override
    public abstract void fight(Creature c);

    public boolean isDead() {
        return life <= 0;
    }

    public void updateLife(int damage) {
        life -= damage;
        if (life <= 0) {
            life = 0;
            System.out.println(name + "已阵亡");
        }
    }

    @Override
    public int getattack() {
        return 0;
    }
}

（4）具体单位类
实现具体的单位类，如 'Mutalisk' 和 'Terran'。

package mutalisk;

import attack.Air;
import attack.Strategy;
import creature.Creature;
import zerg.Zerg;

public class Mutalisk extends Zerg {
    private Strategy strategy;
    protected int attack;

    public Mutalisk(String name, int life) {
        super(name, life);
    }

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
        this.attack = strategy.getattack();
    }

    public void fightStrategy(Creature c) {
        strategy.fight(c);
    }

    public void healZerg(Zerg z) {
        if (z.isDead()) {
            z.setlife(this.life);
            this.life = 0;
            System.out.println("忠诚的献身");
        }
    }
}

package terran;

import creature.Creature;

public class Terran extends Creature {
    public int up = 500;

    public Terran(String name, int life, int attack) {
        super(name, life, attack);
    }

    @Override
    public void fight(Creature c) {
        System.out.println(name + "攻击" + c.name + " " + attack + "滴血");
        c.updateLife(attack);
        repair(up);
    }

    public void repair(int amount) {
        attack += amount;
    }
}

4. 测试程序

编写测试程序，模拟星际争霸的战斗场景。

package test;

import attack.Air;
import attack.Ground;
import attack.Strategy;
import creature.Creature;
import mutalisk.Mutalisk;
import terran.Terran;
import xrace.Xrace;
import zerg.Zerg;

public class Test {
    public static void main(String[] args) {
        // 创建战场人员
        int n = 1;
        Terran[] terrans = new Terran[n];
        for (int i = 0; i < terrans.length; i++) {
            terrans[i] = new Terran("Terran" + (i + 1), 800, 100);
        }
        Xrace xrace = new Xrace("Xrace", 100, 8000);
        Zerg zerg = new Zerg("Zerg", 50000, 400);
        Mutalisk mutalisk = new Mutalisk("Mutalisk", 20000);

        // 创建两种攻击策略
        Air air = new Air(mutalisk);
        Ground ground = new Ground(mutalisk);

        // 战争开始前展示人员状态
        for (Terran terran : terrans) {
            terran.state();
        }
        xrace.state();
        zerg.state();
        mutalisk.state();

        // 游戏开始
        boolean gameEnd = false;
        while (!gameEnd) {
            // 检测Terran是否死亡
            boolean zergAttacked = false;
            for (Terran terran : terrans) {
                if (!terran.isDead()) {
                    zerg.fight(terran);
                    zergAttacked = true;
                    break;
                }
            }
            if (!zergAttacked && !xrace.isDead()) {
                zerg.fight(xrace);
            }
            for (Creature terran : terrans) {
                if (!terran.isDead() && !zerg.isDead()) {
                    terran.fight(zerg);
                }
            }
            if (!xrace.isDead() && !zerg.isDead()) {
                xrace.fight(zerg);
            }
            if (zerg.isDead() && !mutalisk.isDead()) {
                mutalisk.healZerg(zerg);
            }
            if (!xrace.isDead() && !mutalisk.isDead()) {
                mutalisk.setStrategy(air);
                mutalisk.fightStrategy(xrace);
            } else if (xrace.isDead()) {
                for (Creature terran : terrans) {
                    if (!terran.isDead()) {
                        mutalisk.setStrategy(ground);
                        mutalisk.fightStrategy(terran);
                        break;
                    }
                }
            }

            // 更新状态
            for (Creature terran : terrans) {
                terran.state();
            }
            xrace.state();
            zerg.state();
            mutalisk.state();

            if ((xrace.isDead() && terrans[n - 1].isDead()) || (zerg.isDead() && mutalisk.isDead())) {
                gameEnd = true;
                if (xrace.isDead()) {
                    System.out.println(xrace.name + "已阵亡，游戏失败");
                }
                if (zerg.isDead()) {
                    System.out.println(zerg.name + "已阵亡，游戏胜利");
                }
                System.out.println("游戏结束！");
            }
        }
    }
}

实现效果

通过调试和验证，星际争霸小程序成功实现！程序能够模拟不同种族单位的战斗行为，包括空中攻击和地面攻击。每个单位都可以动态切换攻击策略，从而适应不同的战斗场景。整个程序运行流畅，战斗逻辑清晰，状态更新及时。

战斗场景模拟

策略模式验证

总结

1. 策略模式的魅力：通过策略模式，我们可以轻松地为单位切换不同的攻击策略，从而使代码更加灵活和可扩展。
2. 面向对象编程的优势：利用Java的面向对象特性，我们可以将不同种族单位的行为封装在各自的类中，从而使代码更加模块化和易于维护。
3. 编程技巧的提升：通过实现这个小程序，我进一步掌握了Java的接口、抽象类和多态等概念，提升了编程技巧。
4. 游戏开发的乐趣：通过模拟星际争霸的战斗场景，我体验到了游戏开发的乐趣，激发了我对游戏开发的进一步学习兴趣。