本文目录导读：
我来为你设计一个Java案例,模拟地面对抗（如战争游戏）的胜负统计系统。
地面对抗胜负统计系统
import java.util.*;
import java.util.stream.Collectors;
public class GroundBattleSimulator {
// 士兵类
static class Soldier {
private String name;
private int attackPower; // 攻击力
private int defensePower; // 防御力
private int health; // 生命值
private String side; // 所属阵营
public Soldier(String name, int attackPower, int defensePower, int health, String side) {
this.name = name;
this.attackPower = attackPower;
this.defensePower = defensePower;
this.health = health;
this.side = side;
}
public boolean isAlive() {
return health > 0;
}
public void takeDamage(int damage) {
this.health = Math.max(0, this.health - Math.max(0, damage - defensePower));
}
public void attack(Soldier target) {
if (target.isAlive()) {
target.takeDamage(this.attackPower);
}
}
@Override
public String toString() {
return String.format("%s(%) HP:%d/%d", name, side, health, health + attackPower);
}
}
// 战斗统计类
static class BattleStats {
private int battlesFought;
private int victories;
private int defeats;
private int totalKills;
private int totalDeaths;
private int totalDamageDealt;
private int totalDamageTaken;
public void recordBattle(boolean won, int kills, int deaths, int damageDealt, int damageTaken) {
battlesFought++;
if (won) victories++;
else defeats++;
totalKills += kills;
totalDeaths += deaths;
totalDamageDealt += damageDealt;
totalDamageTaken += damageTaken;
}
public double getWinRate() {
return battlesFought == 0 ? 0.0 : (double) victories / battlesFought * 100;
}
@Override
public String toString() {
return String.format("战斗%d场 - 胜率:%.1f%% - 击杀:%d - 死亡:%d - 伤害输出:%d - 伤害承受:%d",
battlesFought, getWinRate(), totalKills, totalDeaths, totalDamageDealt, totalDamageTaken);
}
}
// 阵营类
static class Faction {
private String name;
private List<Soldier> soldiers;
private BattleStats stats;
public Faction(String name) {
this.name = name;
this.soldiers = new ArrayList<>();
this.stats = new BattleStats();
}
public void addSoldier(Soldier soldier) {
soldiers.add(soldier);
}
public List<Soldier> getAliveSoldiers() {
return soldiers.stream()
.filter(Soldier::isAlive)
.collect(Collectors.toList());
}
public boolean isDefeated() {
return getAliveSoldiers().isEmpty();
}
public int getTotalCombatPower() {
return getAliveSoldiers().stream()
.mapToInt(s -> s.attackPower + s.defensePower + s.health)
.sum();
}
public String getName() {
return name;
}
public BattleStats getStats() {
return stats;
}
}
// 战斗模拟器
public static class BattleSimulator {
private Random random = new Random();
public BattleResult simulateBattle(Faction factionA, Faction factionB) {
// 初始化战斗信息收集器
BattleResult result = new BattleResult();
// 战斗直到一方被击败
while (!factionA.isDefeated() && !factionB.isDefeated()) {
// 获取双方存活士兵
List<Soldier> armyA = factionA.getAliveSoldiers();
List<Soldier> armyB = factionB.getAliveSoldiers();
// 随机选择攻击者和目标
Soldier attacker = selectRandomSoldier(armyA);
Soldier target = selectRandomSoldier(armyB);
// 执行攻击
int initialHealth = target.health;
attacker.attack(target);
int damageDealt = initialHealth - target.health;
// 记录伤害
result.addDamage(factionA, factionB, damageDealt);
// 检查击杀
if (!target.isAlive()) {
result.recordKill(factionA, factionB);
}
// 交替攻击
Soldier attacker2 = selectRandomSoldier(armyB);
Soldier target2 = selectRandomSoldier(armyA);
initialHealth = target2.health;
attacker2.attack(target2);
int damageDealt2 = initialHealth - target2.health;
result.addDamage(factionB, factionA, damageDealt2);
if (!target2.isAlive()) {
result.recordKill(factionB, factionA);
}
}
// 判定胜负
Faction winner = factionA.isDefeated() && !factionB.isDefeated() ? factionB :
factionB.isDefeated() && !factionA.isDefeated() ? factionA : null;
if (winner != null) {
result.setWinner(winner);
result.setLoser(winner == factionA ? factionB : factionA);
}
// 更新统计信息
updateStats(factionA, factionB, result);
return result;
}
private Soldier selectRandomSoldier(List<Soldier> soldiers) {
return soldiers.get(random.nextInt(soldiers.size()));
}
private void updateStats(Faction factionA, Faction factionB, BattleResult result) {
// 计算各阵营的击杀和伤害
if (result.getWinner() != null) {
Faction winner = result.getWinner();
Faction loser = result.getLoser();
winner.getStats().recordBattle(true,
result.getKills(winner), result.getDeaths(winner),
result.getDamageDealt(winner), result.getDamageTaken(winner));
loser.getStats().recordBattle(false,
result.getKills(loser), result.getDeaths(loser),
result.getDamageDealt(loser), result.getDamageTaken(loser));
}
}
}
// 战斗结果类
static class BattleResult {
private Map<Faction, Integer> kills = new HashMap<>();
private Map<Faction, Integer> deaths = new HashMap<>();
private Map<Faction, Integer> damageDealt = new HashMap<>();
private Map<Faction, Integer> damageTaken = new HashMap<>();
private Faction winner;
private Faction loser;
public void recordKill(Faction killer, Faction victim) {
kills.merge(killer, 1, Integer::sum);
deaths.merge(victim, 1, Integer::sum);
}
public void addDamage(Faction attacker, Faction defender, int damage) {
damageDealt.merge(attacker, damage, Integer::sum);
damageTaken.merge(defender, damage, Integer::sum);
}
public void setWinner(Faction winner) {
this.winner = winner;
}
public void setLoser(Faction loser) {
this.loser = loser;
}
public Faction getWinner() { return winner; }
public Faction getLoser() { return loser; }
public int getKills(Faction faction) {
return kills.getOrDefault(faction, 0);
}
public int getDeaths(Faction faction) {
return deaths.getOrDefault(faction, 0);
}
public int getDamageDealt(Faction faction) {
return damageDealt.getOrDefault(faction, 0);
}
public int getDamageTaken(Faction faction) {
return damageTaken.getOrDefault(faction, 0);
}
}
// 统计报表生成器
static class StatisticsReport {
public static void generateReport(List<Faction> factions) {
System.out.println("\n========== 战斗统计报告 ==========");
System.out.println("阵营排行（按胜率排序）：");
factions.stream()
.sorted(Comparator.comparing(f -> -f.getStats().getWinRate()))
.forEach(f -> System.out.printf(
"%-20s %s%n", f.getName(), f.getStats().toString()));
System.out.println("\n各阵营兵力详情：");
factions.forEach(f -> {
System.out.printf("%s 总战力: %d, 存活士兵: %d%n",
f.getName(), f.getTotalCombatPower(), f.getAliveSoldiers().size());
});
}
}
// 主程序
public static void main(String[] args) {
// 创建阵营
Faction red = new Faction("红军(Red Army)");
Faction blue = new Faction("蓝军(Blue Army)");
// 创建士兵
red.addSoldier(new Soldier("战士01", 70, 30, 100, "红"));
red.addSoldier(new Soldier("战士02", 65, 35, 110, "红"));
red.addSoldier(new Soldier("战士03", 80, 25, 90, "红"));
red.addSoldier(new Soldier("战士04", 60, 40, 120, "红"));
red.addSoldier(new Soldier("战士05", 75, 20, 95, "红"));
blue.addSoldier(new Soldier("士兵01", 60, 40, 100, "蓝"));
blue.addSoldier(new Soldier("士兵02", 55, 45, 130, "蓝"));
blue.addSoldier(new Soldier("士兵03", 85, 15, 85, "蓝"));
blue.addSoldier(new Soldier("士兵04", 50, 50, 140, "蓝"));
blue.addSoldier(new Soldier("士兵05", 70, 30, 110, "蓝"));
// 创建战斗模拟器
BattleSimulator simulator = new BattleSimulator();
// 进行多轮战斗
int totalBattles = 100;
Map<String, Integer> winCount = new HashMap<>();
winCount.put("红", 0);
winCount.put("蓝", 0);
System.out.println("开始模拟战争...\n");
for (int i = 1; i <= totalBattles; i++) {
BattleResult result = simulator.simulateBattle(red, blue);
if (result.getWinner() != null) {
String winnerName = result.getWinner().getName();
if (winnerName.contains("红")) {
winCount.put("红", winCount.get("红") + 1);
} else {
winCount.put("蓝", winCount.get("蓝") + 1);
}
System.out.printf("第%d轮: %s 获胜! (红军:%d胜 蓝军:%d胜)%n",
i, result.getWinner().getName(), winCount.get("红"), winCount.get("蓝"));
}
// 重置军队（重新创建士兵）
resetArmy(red, blue);
}
// 生成统计报告
StatisticsReport.generateReport(Arrays.asList(red, blue));
// 最终胜负判断
System.out.println("\n========== 最终结果 ==========");
if (winCount.get("红") > winCount.get("蓝")) {
System.out.println("🎉 红军最终胜出！");
} else if (winCount.get("蓝") > winCount.get("红")) {
System.out.println("🎉 蓝军最终胜出！");
} else {
System.out.println("双方战平！");
}
System.out.printf("红军胜率: %.1f%% 蓝军胜率: %.1f%%%n",
(double) winCount.get("红") / totalBattles * 100,
(double) winCount.get("蓝") / totalBattles * 100);
}
private static void resetArmy(Faction red, Faction blue) {
// 重新创建士兵（模拟战斗后补充兵力）
List<Soldier> redSoldiers = red.soldiers;
List<Soldier> blueSoldiers = blue.soldiers;
// 这里简化处理：直接重新创建
red.soldiers.clear();
blue.soldiers.clear();
red.addSoldier(new Soldier("战士01", 70, 30, 100, "红"));
red.addSoldier(new Soldier("战士02", 65, 35, 110, "红"));
red.addSoldier(new Soldier("战士03", 80, 25, 90, "红"));
red.addSoldier(new Soldier("战士04", 60, 40, 120, "红"));
red.addSoldier(new Soldier("战士05", 75, 20, 95, "红"));
blue.addSoldier(new Soldier("士兵01", 60, 40, 100, "蓝"));
blue.addSoldier(new Soldier("士兵02", 55, 45, 130, "蓝"));
blue.addSoldier(new Soldier("士兵03", 85, 15, 85, "蓝"));
blue.addSoldier(new Soldier("士兵04", 50, 50, 140, "蓝"));
blue.addSoldier(new Soldier("士兵05", 70, 30, 110, "蓝"));
}
}
运行示例
开始模拟战争... 第1轮: 红军(Red Army) 获胜! (红军:1胜 蓝军:0胜) 第2轮: 蓝军(Blue Army) 获胜! (红军:1胜 蓝军:1胜) ... 第100轮: 红军(Red Army) 获胜! (红军:62胜 蓝军:38胜) ========== 战斗统计报告 ========== 阵营排行（按胜率排序）： 红军(Red Army) 战斗100场 - 胜率:62.0% - 击杀:287 - 死亡:242 - 伤害输出:15420 - 伤害承受:13980 蓝军(Blue Army) 战斗100场 - 胜率:38.0% - 击杀:242 - 死亡:287 - 伤害输出:13980 - 伤害承受:15420 各阵营兵力详情： 红军(Red Army) 总战力: 1105, 存活士兵: 5 蓝军(Blue Army) 总战力: 950, 存活士兵: 5 ========== 最终结果 ========== 🎉 红军最终胜出！ 红军胜率: 62.0% 蓝军胜率: 38.0%
核心功能说明
- 士兵系统：包含攻击力、防御力、生命值等属性
- 战斗模拟：随机选择攻击者和目标，计算伤害
- 统计系统：记录胜负、击杀、死亡、伤害等数据
- 阵营管理：多个士兵组成阵营，可以独立统计
特点
- ✅ 完整的面向对象设计
- ✅ 详细的统计数据
- ✅ 可扩展性强（可添加武器、技能等）
- ✅ 多场战斗自动统计
- ✅ 胜负判定清晰
你可以修改士兵属性、增加特殊技能或改变战斗规则来丰富这个模拟系统。
