java案例统计地面对抗谁胜出？

wen java案例 2026-08-27 196

本文目录导读：

java案例统计地面对抗谁胜出？

地面对抗胜负统计系统
运行示例
核心功能说明
特点

我来为你设计一个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%