def handle_casual_combat(self):
"""
Handles combat for ships wandering around the map (not assigned to any fleet/mission).
"""
filters = self.unit_manager.filtering_rules
rules = (filters.not_in_fleet, filters.fighting(),
filters.ship_state(self.ships, self.shipStates.idle))
for ship in self.unit_manager.get_ships(rules):
# Turn into one-ship group, since reasoning is based around groups of ships
ship_group = [
ship,
]
# TODO: create artificial groups by dividing ships that are nearby into groups based on their distance.
# This may end up being costly, so postpone until we have more cpu resources to spare.
ships_around = self.unit_manager.find_ships_near_group(
ship_group, self.combat_range)
pirate_ships = self.unit_manager.filter_ships(
ships_around, (filters.pirate, ))
fighting_ships = self.unit_manager.filter_ships(
ships_around, (filters.fighting(), ))
working_ships = self.unit_manager.filter_ships(
ships_around, (filters.working(), ))
environment = {'ship_group': ship_group}
if fighting_ships:
environment['enemies'] = fighting_ships
environment[
'power_balance'] = UnitManager.calculate_power_balance(
ship_group, fighting_ships)
self.log.debug("Player: %s vs Player: %s -> power_balance:%s",
self.owner.name, fighting_ships[0].owner.name,
environment['power_balance'])
self.owner.behavior_manager.request_action(
BehaviorManager.action_types.offensive,
'fighting_ships_in_sight', **environment)
elif pirate_ships:
environment['enemies'] = pirate_ships
environment[
'power_balance'] = UnitManager.calculate_power_balance(
ship_group, pirate_ships)
self.log.debug("Player: %s vs Player: %s -> power_balance:%s",
self.owner.name, pirate_ships[0].owner.name,
environment['power_balance'])
self.owner.behavior_manager.request_action(
BehaviorManager.action_types.offensive,
'pirate_ships_in_sight', **environment)
elif working_ships:
environment['enemies'] = working_ships
self.owner.behavior_manager.request_action(
BehaviorManager.action_types.offensive,
'working_ships_in_sight', **environment)
else:
# execute idle action only if whole fleet is idle
# we check for AIPlayer state here
if all((self.owner.ships[ship] == self.owner.shipStates.idle
for ship in ship_group)):
self.owner.behavior_manager.request_action(
BehaviorManager.action_types.idle, 'no_one_in_sight',
**environment)
def handle_mission_combat(self, mission):
"""
Routine for handling combat in mission that requests for it.
"""
filters = self.unit_manager.filtering_rules
fleet = mission.fleet
ship_group = fleet.get_ships()
ship_group = self.unit_manager.filter_ships(
ship_group, (filters.ship_state(self.ships, self.shipStates.idle)))
if not ship_group:
mission.abort_mission()
ships_around = self.unit_manager.find_ships_near_group(
ship_group, self.combat_range)
ships_around = self.unit_manager.filter_ships(ships_around,
(filters.hostile(), ))
pirate_ships = self.unit_manager.filter_ships(ships_around,
(filters.pirate, ))
fighting_ships = self.unit_manager.filter_ships(
ships_around, (filters.fighting(), ))
working_ships = self.unit_manager.filter_ships(ships_around,
(filters.working(), ))
environment = {'ship_group': ship_group}
# begin combat if it's still unresolved
if fighting_ships:
environment['enemies'] = fighting_ships
environment['power_balance'] = UnitManager.calculate_power_balance(
ship_group, fighting_ships)
self.log.debug("Player: %s vs Player: %s -> power_balance:%s",
self.owner.name, fighting_ships[0].owner.name,
environment['power_balance'])
self.owner.behavior_manager.request_action(
BehaviorManager.action_types.offensive,
'fighting_ships_in_sight', **environment)
elif pirate_ships:
environment['enemies'] = pirate_ships
environment['power_balance'] = UnitManager.calculate_power_balance(
ship_group, pirate_ships)
self.log.debug("Player: %s vs Player: %s -> power_balance:%s",
self.owner.name, pirate_ships[0].owner.name,
environment['power_balance'])
self.owner.behavior_manager.request_action(
BehaviorManager.action_types.offensive,
'pirate_ships_in_sight', **environment)
elif working_ships:
environment['enemies'] = working_ships
self.owner.behavior_manager.request_action(
BehaviorManager.action_types.offensive,
'working_ships_in_sight', **environment)
else:
# no one else is around to fight -> continue mission
mission.continue_mission()
def handle_casual_combat(self):
"""
Combat with idle ships (not assigned to a mission)
"""
filters = self.unit_manager.filtering_rules
rules = (filters.not_in_fleet, filters.pirate, filters.ship_state(self.ships, self.shipStates.idle))
for ship in self.unit_manager.get_ships(rules):
# Turn into one-ship group, since reasoning is based around groups of ships
ship_group = [ship, ]
ships_around = self.unit_manager.find_ships_near_group(ship_group, self.combat_range)
fighting_ships = self.unit_manager.filter_ships(ships_around, (filters.fighting(), ))
working_ships = self.unit_manager.filter_ships(ships_around, (filters.working(), ))
environment = {'ship_group': ship_group}
if fighting_ships:
environment['enemies'] = fighting_ships
environment['power_balance'] = UnitManager.calculate_power_balance(ship_group, fighting_ships)
self.log.debug("Player: %s vs Player: %s -> power_balance:%s", self.owner.name, fighting_ships[0].owner.name, environment['power_balance'])
self.owner.behavior_manager.request_action(BehaviorManager.action_types.offensive,
'fighting_ships_in_sight', **environment)
elif working_ships:
environment['enemies'] = working_ships
self.owner.behavior_manager.request_action(BehaviorManager.action_types.offensive,
'working_ships_in_sight', **environment)
else:
self.owner.behavior_manager.request_action(BehaviorManager.action_types.idle,
'no_one_in_sight', **environment)
def handle_mission_combat(self, mission):
"""
Routine for handling combat in mission that requests for it.
"""
filters = self.unit_manager.filtering_rules
fleet = mission.fleet
ship_group = fleet.get_ships()
ship_group = self.unit_manager.filter_ships(ship_group, (filters.ship_state(self.ships, self.shipStates.idle)))
if not ship_group:
mission.abort_mission()
ships_around = self.unit_manager.find_ships_near_group(ship_group, self.combat_range)
ships_around = self.unit_manager.filter_ships(ships_around, (filters.hostile(), ))
fighting_ships = self.unit_manager.filter_ships(ships_around, (filters.fighting(), ))
working_ships = self.unit_manager.filter_ships(ships_around, (filters.working(), ))
environment = {'ship_group': ship_group}
# begin combat if it's still unresolved
if fighting_ships:
environment['enemies'] = fighting_ships
environment['power_balance'] = UnitManager.calculate_power_balance(ship_group, fighting_ships)
self.log.debug("Player: %s vs Player: %s -> power_balance:%s", self.owner.name, fighting_ships[0].owner.name, environment['power_balance'])
self.owner.behavior_manager.request_action(BehaviorManager.action_types.offensive,
'fighting_ships_in_sight', **environment)
elif working_ships:
environment['enemies'] = working_ships
self.owner.behavior_manager.request_action(BehaviorManager.action_types.offensive,
'working_ships_in_sight', **environment)
else:
# no one else is around to fight -> continue mission
mission.continue_mission()
def calculate_player_power_balance(self, other_player):
"""
Calculates power balance between two players.
Power balance of 1.2 means that self.owner is 1.2 times stronger than other_player
@param other_player: other player who is matched against self.owner
@type other_player: Player
@return: power balance between self.owner and other_player
@rtype: float
"""
min_balance = 10e-7
max_balance = 1000.0
ships = self.owner.ships.keys()
ships = self.unit_manager.filter_ships(
ships, (self.unit_manager.filtering_rules.fighting(), ))
enemy_ships = self.unit_manager.get_player_ships(other_player)
enemy_ships = self.unit_manager.filter_ships(
enemy_ships, (self.unit_manager.filtering_rules.fighting(), ))
# infinitely more powerful
if ships and not enemy_ships:
return max_balance
# infinitely less powerful
elif not ships and enemy_ships:
return min_balance
elif not ships and not enemy_ships:
return 1.0
return UnitManager.calculate_power_balance(ships, enemy_ships)
def calculate_player_power_balance(self, other_player): """ Calculates power balance between two players. Power balance of 1.2 means that self.owner is 1.2 times stronger than other_player @param other_player: other player who is matched against self.owner @type other_player: Player @return: power balance between self.owner and other_player @rtype: float """ min_balance = 10e-7 max_balance = 1000.0 ships = self.owner.ships.keys() ships = self.unit_manager.filter_ships(ships, (self.unit_manager.filtering_rules.fighting(),)) enemy_ships = self.unit_manager.get_player_ships(other_player) enemy_ships = self.unit_manager.filter_ships(enemy_ships, (self.unit_manager.filtering_rules.fighting(),)) # infinitely more powerful if ships and not enemy_ships: return max_balance # infinitely less powerful elif not ships and enemy_ships: return min_balance elif not ships and not enemy_ships: return 1.0 return UnitManager.calculate_power_balance(ships, enemy_ships)
def handle_casual_combat(self):
"""
Combat with idle ships (not assigned to a mission)
"""
filters = self.unit_manager.filtering_rules
rules = (filters.not_in_fleet, filters.pirate, filters.ship_state(self.ships, self.shipStates.idle))
for ship in self.unit_manager.get_ships(rules):
# Turn into one-ship group, since reasoning is based around groups of ships
ship_group = [ship, ]
ships_around = self.unit_manager.find_ships_near_group(ship_group, self.combat_range)
fighting_ships = self.unit_manager.filter_ships(ships_around, (filters.fighting(), ))
working_ships = self.unit_manager.filter_ships(ships_around, (filters.working(), ))
environment = {'ship_group': ship_group}
if fighting_ships:
environment['enemies'] = fighting_ships
environment['power_balance'] = UnitManager.calculate_power_balance(ship_group, fighting_ships)
self.log.debug("Player: %s vs Player: %s -> power_balance:%s", self.owner.name, fighting_ships[0].owner.name, environment['power_balance'])
self.owner.behavior_manager.request_action(BehaviorManager.action_types.offensive,
'fighting_ships_in_sight', **environment)
elif working_ships:
environment['enemies'] = working_ships
self.owner.behavior_manager.request_action(BehaviorManager.action_types.offensive,
'working_ships_in_sight', **environment)
else:
self.owner.behavior_manager.request_action(BehaviorManager.action_types.idle,
'no_one_in_sight', **environment)
def handle_casual_combat(self):
"""
Handles combat for ships wandering around the map (not assigned to any fleet/mission).
"""
filters = self.unit_manager.filtering_rules
rules = (filters.not_in_fleet, filters.fighting(), filters.ship_state(self.ships, self.shipStates.idle))
for ship in self.unit_manager.get_ships(rules):
# Turn into one-ship group, since reasoning is based around groups of ships
ship_group = [ship, ]
# TODO: create artificial groups by dividing ships that are nearby into groups based on their distance.
# This may end up being costly, so postpone until we have more cpu resources to spare.
ships_around = self.unit_manager.find_ships_near_group(ship_group, self.combat_range)
pirate_ships = self.unit_manager.filter_ships(ships_around, (filters.pirate, ))
fighting_ships = self.unit_manager.filter_ships(ships_around, (filters.fighting(), ))
working_ships = self.unit_manager.filter_ships(ships_around, (filters.working(), ))
environment = {'ship_group': ship_group}
if fighting_ships:
environment['enemies'] = fighting_ships
environment['power_balance'] = UnitManager.calculate_power_balance(ship_group, fighting_ships)
self.log.debug("Player: %s vs Player: %s -> power_balance:%s", self.owner.name, fighting_ships[0].owner.name, environment['power_balance'])
self.owner.behavior_manager.request_action(BehaviorManager.action_types.offensive,
'fighting_ships_in_sight', **environment)
elif pirate_ships:
environment['enemies'] = pirate_ships
environment['power_balance'] = UnitManager.calculate_power_balance(ship_group, pirate_ships)
self.log.debug("Player: %s vs Player: %s -> power_balance:%s", self.owner.name, pirate_ships[0].owner.name, environment['power_balance'])
self.owner.behavior_manager.request_action(BehaviorManager.action_types.offensive,
'pirate_ships_in_sight', **environment)
elif working_ships:
environment['enemies'] = working_ships
self.owner.behavior_manager.request_action(BehaviorManager.action_types.offensive,
'working_ships_in_sight', **environment)
else:
# execute idle action only if whole fleet is idle
# we check for AIPlayer state here
if all((self.owner.ships[ship] == self.owner.shipStates.idle for ship in ship_group)):
self.owner.behavior_manager.request_action(BehaviorManager.action_types.idle,
'no_one_in_sight', **environment)
