在游戏开发的世界里，策略模式是一种非常实用的设计模式，它允许我们在运行时动态地选择算法或行为。今天，我将带你走进一场星际争霸的奇幻之旅，用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. 游戏开发的乐趣：通过模拟星际争霸的战斗场景，我体验到了游戏开发的乐趣，激发了我对游戏开发的进一步学习兴趣。
结语
通过这次实验，我不仅在技术上有了新的突破，更对游戏开发充满了兴趣。策略模式虽然简单，但它在游戏开发中有着广泛的应用。如果你对Java编程或游戏开发感兴趣，欢迎一起交流探讨！让我们在技术的道路上共同进步，继续探索更多神奇的魔法！✨
