647 lines
25 KiB
Python
647 lines
25 KiB
Python
"""
|
||
KARDS 战斗引擎核心 - 专注于战斗系统
|
||
不包含卡牌系统，单位通过函数调用直接部署
|
||
"""
|
||
from typing import Dict, List, Optional, Any, Union
|
||
from uuid import UUID
|
||
|
||
from ..battlefield.battlefield import Battlefield, HQ
|
||
from ..units.unit import Unit
|
||
from .enums import LineType
|
||
from .unit_combat_rules import UnitCombatRules
|
||
from ..events.event_system import EventType, GameEvent, publish_event
|
||
from ..events.managers.smokescreen_manager import setup_smokescreen_for_unit
|
||
|
||
|
||
class BattleEngine:
|
||
"""KARDS 战斗引擎 - 纯战斗系统"""
|
||
|
||
def __init__(self, player1_name: str, player2_name: str, debug_mode: bool = False):
|
||
self.battlefield = Battlefield(player1_name, player2_name)
|
||
self.player_names = [player1_name, player2_name]
|
||
self.debug_mode = debug_mode
|
||
|
||
self.current_turn = 1
|
||
self.active_player = 0 # 0 for player1, 1 for player2
|
||
self.turn_phase = 0 # 0=player1回合, 1=player2回合
|
||
|
||
# Kredits Slot 系统 - 指挥点槽
|
||
self.player1_kredits_slot = 0 # 当前槽数
|
||
self.player2_kredits_slot = 0
|
||
self.max_kredits_slot = 12 # 自然增长上限
|
||
self.absolute_max_kredits = 24 # 绝对上限
|
||
|
||
# Kredits 系统 - 当前回合可用指挥点
|
||
self.player1_kredits = 0 # 每回合重置为槽数
|
||
self.player2_kredits = 0
|
||
|
||
# 事件历史
|
||
self.event_history = []
|
||
|
||
# 初始化第一回合的Kredits
|
||
self._start_player_turn()
|
||
|
||
def _start_player_turn(self):
|
||
"""开始玩家回合，更新Kredits Slot和Kredits"""
|
||
if self.active_player == 0:
|
||
# 玩家1在每次轮到自己时增长槽数（新回合开始时）
|
||
if self.turn_phase == 0 and self.player1_kredits_slot < self.max_kredits_slot:
|
||
self.player1_kredits_slot += 1
|
||
# 设置本回合Kredits为槽数
|
||
self.player1_kredits = self.player1_kredits_slot
|
||
else:
|
||
# 玩家2在每次轮到自己且完成一个完整回合后增长槽数
|
||
if self.turn_phase == 1 and self.player2_kredits_slot < self.max_kredits_slot:
|
||
self.player2_kredits_slot += 1
|
||
self.player2_kredits = self.player2_kredits_slot
|
||
|
||
def get_kredits(self, player_id: int) -> int:
|
||
"""获取玩家当前Kredits"""
|
||
if player_id == 0:
|
||
return self.player1_kredits
|
||
elif player_id == 1:
|
||
return self.player2_kredits
|
||
return 0
|
||
|
||
def get_kredits_slot(self, player_id: int) -> int:
|
||
"""获取玩家当前Kredits Slot"""
|
||
if player_id == 0:
|
||
return self.player1_kredits_slot
|
||
elif player_id == 1:
|
||
return self.player2_kredits_slot
|
||
return 0
|
||
|
||
def spend_kredits(self, player_id: int, amount: int) -> bool:
|
||
"""消耗Kredits"""
|
||
if amount <= 0:
|
||
return True
|
||
|
||
current_kredits = self.get_kredits(player_id)
|
||
if current_kredits >= amount:
|
||
if player_id == 0:
|
||
self.player1_kredits -= amount
|
||
elif player_id == 1:
|
||
self.player2_kredits -= amount
|
||
return True
|
||
return False
|
||
|
||
# === 单位直接部署功能 ===
|
||
|
||
def deploy_unit_to_support(self, unit: Unit, player_id: int, position: Optional[int] = None) -> Dict[str, Any]:
|
||
"""直接将单位部署到己方支援线的指定位置"""
|
||
if player_id not in [0, 1]:
|
||
return {"success": False, "reason": "Invalid player ID"}
|
||
|
||
support_line = self.battlefield.get_player_support_line(self.player_names[player_id])
|
||
if not support_line:
|
||
return {"success": False, "reason": "Support line not found"}
|
||
|
||
if support_line.is_full():
|
||
return {"success": False, "reason": "Support line is full"}
|
||
|
||
# 设置单位所有者
|
||
unit.owner = self.player_names[player_id]
|
||
|
||
# 如果指定了位置，尝试在该位置部署
|
||
if position is not None:
|
||
# 检查位置是否有效
|
||
if position < 0:
|
||
return {"success": False, "reason": "Invalid position: position cannot be negative"}
|
||
|
||
# 如果位置超出当前范围，添加到末尾
|
||
current_count = len(support_line.objectives)
|
||
if position >= current_count:
|
||
success = support_line.add_unit(unit)
|
||
actual_position = current_count if success else None
|
||
else:
|
||
# 在指定位置插入，其他目标向后挤
|
||
support_line.objectives.insert(position, unit)
|
||
support_line._reindex_objectives()
|
||
success = True
|
||
actual_position = position
|
||
else:
|
||
# 没有指定位置，添加到末尾
|
||
success = support_line.add_unit(unit)
|
||
objectives = support_line.get_all_objectives()
|
||
actual_position = len(objectives) - 1 if success else None
|
||
|
||
if success:
|
||
self.battlefield.unit_registry[unit.id] = unit
|
||
|
||
# 设置烟幕管理器
|
||
setup_smokescreen_for_unit(unit)
|
||
|
||
# 发布部署事件
|
||
publish_event(GameEvent(
|
||
event_type=EventType.UNIT_DEPLOYED,
|
||
source=unit,
|
||
data={
|
||
"position": unit.position,
|
||
"player_id": player_id,
|
||
"line_type": support_line.line_type,
|
||
"actual_position": actual_position
|
||
}
|
||
))
|
||
|
||
return {
|
||
"success": True,
|
||
"action": "deploy_to_support",
|
||
"unit_id": unit.id,
|
||
"player": player_id,
|
||
"position": actual_position
|
||
}
|
||
|
||
return {"success": False, "reason": "Failed to deploy unit"}
|
||
|
||
# === 单位操作（移动/攻击） ===
|
||
|
||
def move_unit(self, unit_id: UUID, target_position: tuple, player_id: int) -> Dict[str, Any]:
|
||
"""移动单位到指定位置"""
|
||
if player_id != self.active_player:
|
||
return {"success": False, "reason": "Not your turn"}
|
||
|
||
unit = self.battlefield.find_unit(unit_id)
|
||
if not unit or unit.owner != self.player_names[player_id]:
|
||
return {"success": False, "reason": "Unit not found or not yours"}
|
||
|
||
# 检查是否可以移动
|
||
if not unit.can_move():
|
||
if unit.deployed_this_turn and not unit.can_operate_immediately:
|
||
return {"success": False, "reason": "Unit was deployed this turn and cannot move"}
|
||
elif unit.has_moved_this_turn:
|
||
return {"success": False, "reason": "Unit has already moved this turn"}
|
||
elif unit.has_attacked_this_turn and not unit.can_move_and_attack:
|
||
return {"success": False, "reason": "Unit has attacked and cannot move"}
|
||
else:
|
||
return {"success": False, "reason": "Unit cannot move"}
|
||
|
||
# 检查激活成本
|
||
activation_cost = unit.stats.operation_cost
|
||
if not self.spend_kredits(player_id, activation_cost):
|
||
return {"success": False, "reason": "Insufficient Kredits for activation"}
|
||
|
||
result = self._handle_move_to_position(unit, target_position)
|
||
|
||
# 如果移动成功，标记单位已移动并发布事件
|
||
if result['success']:
|
||
old_position = unit.position
|
||
unit.perform_move()
|
||
|
||
# 发布移动事件
|
||
publish_event(GameEvent(
|
||
event_type=EventType.UNIT_MOVED,
|
||
source=unit,
|
||
data={
|
||
"old_position": old_position,
|
||
"new_position": target_position,
|
||
"player_id": player_id
|
||
}
|
||
))
|
||
|
||
# 发布位置改变事件
|
||
publish_event(GameEvent(
|
||
event_type=EventType.UNIT_POSITION_CHANGED,
|
||
source=unit,
|
||
data={
|
||
"old_position": old_position,
|
||
"new_position": unit.position
|
||
}
|
||
))
|
||
|
||
return result
|
||
|
||
def attack_target(self, attacker_id: UUID, target_id: Union[UUID, str], player_id: int) -> Dict[str, Any]:
|
||
"""攻击指定目标"""
|
||
if player_id != self.active_player:
|
||
return {"success": False, "reason": "Not your turn"}
|
||
|
||
attacker = self.battlefield.find_unit(attacker_id)
|
||
if not attacker or attacker.owner != self.player_names[player_id]:
|
||
return {"success": False, "reason": "Unit not found or not yours"}
|
||
|
||
# 检查是否可以攻击
|
||
if not attacker.can_attack():
|
||
if attacker.deployed_this_turn and not attacker.can_operate_immediately:
|
||
return {"success": False, "reason": "Unit was deployed this turn and cannot attack"}
|
||
elif attacker.attacks_this_turn >= attacker.max_attacks_per_turn:
|
||
return {"success": False, "reason": "Unit has reached maximum attacks per turn"}
|
||
elif attacker.has_moved_this_turn and not attacker.can_move_and_attack:
|
||
return {"success": False, "reason": "Unit has moved and cannot attack"}
|
||
else:
|
||
return {"success": False, "reason": "Unit cannot attack"}
|
||
|
||
# 检查激活成本
|
||
activation_cost = attacker.stats.operation_cost
|
||
if not self.spend_kredits(player_id, activation_cost):
|
||
return {"success": False, "reason": "Insufficient Kredits for activation"}
|
||
|
||
result = self._handle_attack_target(attacker, target_id)
|
||
|
||
# 如果攻击成功，标记单位已攻击并发布事件
|
||
if result['success']:
|
||
attacker.perform_attack()
|
||
|
||
# 发布单位攻击事件
|
||
publish_event(GameEvent(
|
||
event_type=EventType.UNIT_ATTACKED,
|
||
source=attacker,
|
||
data={
|
||
"target_id": target_id,
|
||
"attack_result": result
|
||
}
|
||
))
|
||
|
||
# 检查游戏是否结束（HQ被摧毁）
|
||
game_over, winner = self.battlefield.is_game_over()
|
||
if game_over:
|
||
result["game_over"] = True
|
||
result["winner"] = winner # winner是player_id字符串
|
||
result["winner_name"] = winner # 直接使用player_id作为名称
|
||
|
||
return result
|
||
|
||
def _handle_move_to_position(self, unit: Unit, target_pos: tuple) -> Dict[str, Any]:
|
||
"""处理移动到位置"""
|
||
target_line_type, target_index = target_pos
|
||
|
||
if not unit.position:
|
||
return {"success": False, "reason": "Unit not on battlefield"}
|
||
|
||
current_line, current_index = unit.position
|
||
|
||
# 只能从支援线移动到前线
|
||
if target_line_type != LineType.FRONT:
|
||
return {"success": False, "reason": "Can only move to front line"}
|
||
|
||
if current_line == LineType.FRONT:
|
||
return {"success": False, "reason": "Units on front line cannot move"}
|
||
|
||
return self._move_to_front_line(unit, target_index)
|
||
|
||
def _move_to_front_line(self, unit: Unit, target_index: int) -> Dict[str, Any]:
|
||
"""从支援线移动到前线"""
|
||
front_line = self.battlefield.front_line
|
||
|
||
# 检查前线控制权
|
||
if (self.battlefield.front_line_controller is not None and
|
||
self.battlefield.front_line_controller != unit.owner):
|
||
return {"success": False, "reason": "Front line controlled by enemy"}
|
||
|
||
# 检查是否要挤位置
|
||
if target_index < len(front_line.objectives):
|
||
if front_line.is_full():
|
||
return {"success": False, "reason": "Front line is full, cannot squeeze"}
|
||
else:
|
||
if front_line.is_full():
|
||
return {"success": False, "reason": "Front line is full"}
|
||
|
||
# 从支援线移除
|
||
support_line = self.battlefield.get_player_support_line(unit.owner)
|
||
if not support_line.remove_unit(unit):
|
||
return {"success": False, "reason": "Failed to remove from support line"}
|
||
|
||
# 执行移动
|
||
if target_index >= len(front_line.objectives):
|
||
front_line.add_unit(unit)
|
||
actual_position = len(front_line.objectives) - 1
|
||
else:
|
||
front_line.objectives.insert(target_index, unit)
|
||
front_line._reindex_objectives()
|
||
actual_position = target_index
|
||
|
||
# 更新前线控制权
|
||
self.battlefield._update_front_line_control()
|
||
|
||
return {
|
||
"success": True,
|
||
"action": "move_to_front",
|
||
"unit_id": unit.id,
|
||
"to_position": actual_position,
|
||
"front_line_controller": self.battlefield.front_line_controller
|
||
}
|
||
|
||
def _handle_attack_target(self, attacker: Unit, target_id: Union[UUID, str]) -> Dict[str, Any]:
|
||
"""处理攻击目标"""
|
||
# 查找目标
|
||
target = None
|
||
|
||
if isinstance(target_id, str) and target_id.startswith("hq"):
|
||
if target_id == "hq1":
|
||
target = self.battlefield.player1_hq
|
||
elif target_id == "hq2":
|
||
target = self.battlefield.player2_hq
|
||
else:
|
||
target = self.battlefield.find_unit(target_id)
|
||
|
||
if not target:
|
||
return {"success": False, "reason": "Target not found"}
|
||
|
||
# 检查是否能攻击该目标
|
||
if not UnitCombatRules.can_attack_target(attacker, target, self.battlefield):
|
||
return {"success": False, "reason": "Cannot attack this target"}
|
||
|
||
# 发布攻击前检查事件（可取消）
|
||
before_attack_event = GameEvent(
|
||
event_type=EventType.BEFORE_ATTACK_CHECK,
|
||
source=attacker,
|
||
target=target,
|
||
data={"attack_type": "unit_attack"},
|
||
cancellable=True
|
||
)
|
||
publish_event(before_attack_event)
|
||
|
||
# 如果攻击被阻止，返回失败
|
||
if before_attack_event.cancelled:
|
||
return {"success": False, "reason": before_attack_event.cancel_reason}
|
||
|
||
# 执行攻击
|
||
return self._execute_attack(attacker, target)
|
||
|
||
def _execute_attack(self, attacker: Unit, target: Union[Unit, HQ]) -> Dict[str, Any]:
|
||
"""执行攻击"""
|
||
damage = attacker.get_effective_attack()
|
||
|
||
if isinstance(target, Unit):
|
||
return self._unit_combat(attacker, target)
|
||
else:
|
||
# 攻击HQ
|
||
actual_damage = target.take_damage(damage)
|
||
return {
|
||
"success": True,
|
||
"action": "attack_hq",
|
||
"attacker_id": attacker.id,
|
||
"target": "HQ",
|
||
"damage_dealt": actual_damage,
|
||
"hq_destroyed": target.is_destroyed()
|
||
}
|
||
|
||
def _unit_combat(self, attacker: Unit, target: Unit) -> Dict[str, Any]:
|
||
"""单位间战斗"""
|
||
# 处理伏击
|
||
if target.has_keyword("AMBUSH"):
|
||
ambush_damage = target.get_effective_attack()
|
||
attacker_damage = attacker.stats.take_damage(ambush_damage)
|
||
if not attacker.stats.is_alive():
|
||
self.battlefield.remove_unit(attacker)
|
||
return {
|
||
"success": True,
|
||
"action": "attack_unit",
|
||
"ambush_triggered": True,
|
||
"attacker_destroyed": True,
|
||
"ambush_damage": attacker_damage
|
||
}
|
||
|
||
# 计算攻击伤害
|
||
attack_damage = attacker.get_effective_attack()
|
||
|
||
# 应用重甲减伤
|
||
for keyword in target.keywords:
|
||
if keyword.startswith("HEAVY_ARMOR_"):
|
||
armor_value = int(keyword.split("_")[-1])
|
||
attack_damage = max(0, attack_damage - armor_value)
|
||
break
|
||
|
||
# 战斗是同时进行的：先计算双方攻击力，再同时造成伤害
|
||
# 1. 计算双方攻击力
|
||
counter_attack = 0
|
||
counter_damage = 0
|
||
|
||
# 检查防御方是否能够反击
|
||
if UnitCombatRules.can_counter_attack(target, attacker):
|
||
counter_attack = target.get_effective_attack()
|
||
|
||
# 2. 同时造成伤害
|
||
actual_damage = target.stats.take_damage(attack_damage)
|
||
if counter_attack > 0:
|
||
counter_damage = attacker.stats.take_damage(counter_attack)
|
||
|
||
# 3. 发布伤害事件
|
||
if actual_damage > 0:
|
||
publish_event(GameEvent(
|
||
event_type=EventType.UNIT_TAKES_DAMAGE,
|
||
source=attacker,
|
||
target=target,
|
||
data={
|
||
"damage": actual_damage,
|
||
"damage_type": "attack"
|
||
}
|
||
))
|
||
|
||
if counter_damage > 0:
|
||
publish_event(GameEvent(
|
||
event_type=EventType.UNIT_COUNTER_ATTACKS,
|
||
source=target,
|
||
target=attacker,
|
||
data={
|
||
"damage": counter_damage,
|
||
"counter_attack_damage": counter_attack
|
||
}
|
||
))
|
||
|
||
publish_event(GameEvent(
|
||
event_type=EventType.UNIT_TAKES_DAMAGE,
|
||
source=target,
|
||
target=attacker,
|
||
data={
|
||
"damage": counter_damage,
|
||
"damage_type": "counter_attack"
|
||
}
|
||
))
|
||
|
||
# 检查单位死亡并发布事件
|
||
units_destroyed = []
|
||
if not target.stats.is_alive():
|
||
self.battlefield.remove_unit(target)
|
||
units_destroyed.append(target.id)
|
||
|
||
# 发布单位摧毁事件
|
||
publish_event(GameEvent(
|
||
event_type=EventType.UNIT_DESTROYED,
|
||
source=target,
|
||
data={
|
||
"destroyed_by": attacker.id,
|
||
"destruction_cause": "combat_damage"
|
||
}
|
||
))
|
||
|
||
if not attacker.stats.is_alive():
|
||
self.battlefield.remove_unit(attacker)
|
||
units_destroyed.append(attacker.id)
|
||
|
||
# 发布单位摧毁事件
|
||
publish_event(GameEvent(
|
||
event_type=EventType.UNIT_DESTROYED,
|
||
source=attacker,
|
||
data={
|
||
"destroyed_by": target.id,
|
||
"destruction_cause": "counter_attack_damage"
|
||
}
|
||
))
|
||
|
||
return {
|
||
"success": True,
|
||
"action": "attack_unit",
|
||
"attacker_id": attacker.id,
|
||
"target_id": target.id,
|
||
"damage_dealt": actual_damage,
|
||
"counter_damage": counter_damage,
|
||
"units_destroyed": units_destroyed
|
||
}
|
||
|
||
# === 回合管理 ===
|
||
|
||
def end_turn(self) -> Dict[str, Any]:
|
||
"""结束当前玩家的回合"""
|
||
old_player = self.active_player
|
||
old_phase = self.turn_phase
|
||
|
||
# 切换玩家
|
||
if self.turn_phase == 0:
|
||
# 从玩家1切换到玩家2，但还在同一回合
|
||
self.active_player = 1
|
||
self.turn_phase = 1
|
||
else:
|
||
# 从玩家2切换回玩家1，进入下一回合
|
||
self.active_player = 0
|
||
self.turn_phase = 0
|
||
self.current_turn += 1 # 只有双方都行动过才算一个完整回合
|
||
|
||
# 开始新玩家回合（更新Kredits Slot和Kredits）
|
||
self._start_player_turn()
|
||
|
||
# 重置活跃玩家的单位状态
|
||
for unit in self.battlefield.get_all_units(self.player_names[self.active_player]):
|
||
unit.start_new_turn() # 使用新的方法重置所有状态
|
||
|
||
# 检查游戏结束
|
||
game_over, winner = self.battlefield.is_game_over()
|
||
|
||
return {
|
||
"turn_ended": True,
|
||
"previous_player": old_player,
|
||
"new_active_player": self.active_player,
|
||
"turn_number": self.current_turn,
|
||
"turn_phase": self.turn_phase,
|
||
"is_new_round": self.turn_phase == 0, # 是否是新一轮的开始
|
||
"kredits": self.get_kredits(self.active_player),
|
||
"kredits_slot": self.get_kredits_slot(self.active_player),
|
||
"game_over": game_over,
|
||
"winner": winner
|
||
}
|
||
|
||
# === DEBUG 功能 ===
|
||
|
||
def debug_set_unit_stats(self, unit_id: UUID, attack: Optional[int] = None,
|
||
defense: Optional[int] = None) -> Dict[str, Any]:
|
||
"""DEBUG: 设置单位属性"""
|
||
if not self.debug_mode:
|
||
return {"success": False, "reason": "Debug mode not enabled"}
|
||
|
||
unit = self.battlefield.find_unit(unit_id)
|
||
if not unit:
|
||
return {"success": False, "reason": "Unit not found"}
|
||
|
||
changes = {}
|
||
if attack is not None:
|
||
unit.stats.attack = attack
|
||
changes["attack"] = attack
|
||
|
||
if defense is not None:
|
||
unit.stats.current_defense = defense
|
||
unit.stats.max_defense = defense
|
||
changes["defense"] = defense
|
||
|
||
return {
|
||
"success": True,
|
||
"action": "debug_set_unit_stats",
|
||
"unit_id": unit_id,
|
||
"changes": changes
|
||
}
|
||
|
||
def debug_set_kredits(self, player_id: int, kredits: Optional[int] = None,
|
||
kredits_slot: Optional[int] = None) -> Dict[str, Any]:
|
||
"""DEBUG: 设置玩家Kredits和Kredits Slot"""
|
||
if not self.debug_mode:
|
||
return {"success": False, "reason": "Debug mode not enabled"}
|
||
|
||
if player_id not in [0, 1]:
|
||
return {"success": False, "reason": "Invalid player ID"}
|
||
|
||
changes = {}
|
||
|
||
if kredits is not None:
|
||
kredits = max(0, min(kredits, self.absolute_max_kredits))
|
||
if player_id == 0:
|
||
self.player1_kredits = kredits
|
||
else:
|
||
self.player2_kredits = kredits
|
||
changes["kredits"] = kredits
|
||
|
||
if kredits_slot is not None:
|
||
kredits_slot = max(0, min(kredits_slot, self.absolute_max_kredits))
|
||
if player_id == 0:
|
||
self.player1_kredits_slot = kredits_slot
|
||
else:
|
||
self.player2_kredits_slot = kredits_slot
|
||
changes["kredits_slot"] = kredits_slot
|
||
|
||
return {
|
||
"success": True,
|
||
"action": "debug_set_kredits",
|
||
"player_id": player_id,
|
||
"changes": changes
|
||
}
|
||
|
||
def debug_set_hq_defense(self, player_id: int, defense: int) -> Dict[str, Any]:
|
||
"""DEBUG: 设置HQ防御值"""
|
||
if not self.debug_mode:
|
||
return {"success": False, "reason": "Debug mode not enabled"}
|
||
|
||
hq = None
|
||
if player_id == 0:
|
||
hq = self.battlefield.player1_hq
|
||
elif player_id == 1:
|
||
hq = self.battlefield.player2_hq
|
||
else:
|
||
return {"success": False, "reason": "Invalid player ID"}
|
||
|
||
defense = max(0, defense)
|
||
hq.current_defense = defense
|
||
# HQ没有max_defense属性，只更新current_defense
|
||
|
||
return {
|
||
"success": True,
|
||
"action": "debug_set_hq_defense",
|
||
"player_id": player_id,
|
||
"new_defense": defense
|
||
}
|
||
|
||
# === 游戏状态 ===
|
||
|
||
def get_game_state(self) -> Dict[str, Any]:
|
||
"""获取完整游戏状态"""
|
||
return {
|
||
"turn": self.current_turn,
|
||
"turn_phase": self.turn_phase,
|
||
"active_player": self.active_player,
|
||
"kredits": {
|
||
"player1": self.player1_kredits,
|
||
"player2": self.player2_kredits,
|
||
"active_player": self.get_kredits(self.active_player)
|
||
},
|
||
"kredits_slots": {
|
||
"player1": self.player1_kredits_slot,
|
||
"player2": self.player2_kredits_slot,
|
||
"active_player": self.get_kredits_slot(self.active_player)
|
||
},
|
||
"battlefield": str(self.battlefield),
|
||
"player1_hq": self.battlefield.player1_hq.current_defense,
|
||
"player2_hq": self.battlefield.player2_hq.current_defense,
|
||
"front_line_controller": self.battlefield.front_line_controller,
|
||
"units_count": {
|
||
"player1_total": len(self.battlefield.get_all_units(self.player_names[0])),
|
||
"player2_total": len(self.battlefield.get_all_units(self.player_names[1])),
|
||
"front_line": len(self.battlefield.front_line.get_all_units())
|
||
},
|
||
"debug_mode": self.debug_mode
|
||
} |