AIs.ais_mutant.systemManager() - Code Metrics - Inspection of "AI code refactoring" - ospaceteam/outerspace - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#226)

by Marek

created 2018-07-08 10:50 UTC

AIs.ais_mutant.systemManager() F

↳ Parent: AIs.ais_mutant

Complexity

Conditions

Size

Total Lines	144
Code Lines	117

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	39
eloc	117
nop	0
dl	0
loc	144
rs	0
c	0
b	0
f	0

How to fix Long Method Complexity

#
#  Copyright 2001 - 2016 Ludek Smid [http://www.ospace.net/]
#
#  This file is part of Outer Space.
#
#  Outer Space is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version.
#
#  Outer Space is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with Outer Space; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
#
import random, copy, math

from ige import log
from ige.ospace import Const
from ige.ospace import Rules
from ige.ospace import Utils

import ai_tools as tool
from ais_base import AI

class Mutant(AI):
    def __init__(self, client):
        super(Mutant, self).__init__(client)
        tool.doRelevance(self.data, self.client, self.db, 10)

    def _system_worthiness(self, system, weights):
        """ Scans system, and based on planetary composition and weights returns constant.
        Weights are expected to be quadruplet of numbers, for [gaia, terrestial, marginal, rest]
        """
        worth = 0
        for planet_id in self.data.myPlanets & set(system.planets):
            planet = self.db[planet_id]
            if planet.plType == u"I":  # gaia
                worth += weights[0]
            elif planet.plType == u"E":  # terrestial
                worth += weights[1]
            elif planet.plType == u"M":  # marginal
                worth += weights[2]
            else:  # junk
                worth += weights[3]
        return worth

    def _create_gaia_blueprint(self, space):
        # preserve minefield position, and in case there is no
        # minefield in the system, try to place it on the first planet
        # available
        power_plants = math.ceil(max(space - 1, 0) / 6.0)
        factories = space - power_plants
        return {Rules.Tech.MUTANTBASE4:1,
                Rules.Tech.MUTANTPP2:power_plants,
                Rules.Tech.MUTANTFACT2:factories}

    def _create_terrestial_blueprint(self, space):
        # preserve minefield position, and in case there is no
        # minefield in the system, try to place it on the first planet
        # available
        power_plants = math.ceil(max(space - 1, 0) / 5.0)
        factories = space - power_plants
        return {Rules.Tech.MUTANTBASE3:1,
                Rules.Tech.MUTANTPP2:power_plants,
                Rules.Tech.MUTANTFACT2:factories}

    def _create_marginal_blueprint(self, space):
        # preserve minefield position, and in case there is no
        # minefield in the system, try to place it on the first planet
        # available
        power_plants = math.ceil(max(space - 1, 0) / 7.0)
        factories = space - power_plants
        return {Rules.Tech.MUTANTBASE2:1,
                Rules.Tech.MUTANTPP2:power_plants,
                Rules.Tech.MUTANTFACT1:factories}

    def _create_submarginal_blueprint(self, space):
        # preserve minefield position, and in case there is no
        # minefield in the system, try to place it on the first planet
        # available
        power_plants = math.ceil(max(space - 1, 0) / 5.0)
        factories = space - power_plants
        return {Rules.Tech.MUTANTBASE:1,
                Rules.Tech.MUTANTPP1:power_plants,
                Rules.Tech.MUTANTFACT1:factories}

    def _insert_minefield(self, system, system_blueprint):
        # pick worst possible planet to put minefield on, don't waste
        # precious gaia space if possible
        # also ignore actual state - don't be afraid to rebuild if planet is
        # promoted
        for avoided_types in [(u"I", u"E", u"M"), (u"I", u"E"), (u"I",), ()]:
            # sorting, to avoid rebuilds between equivalent planets
            for planet_id in sorted(system_blueprint):
                planet = self.db[planet_id]
                if planet.plType in avoided_types or planet.plSlots == 1:
                    continue
                if Rules.Tech.MUTANTFACT1 in system_blueprint[planet_id]:
                    assert system_blueprint[planet_id][Rules.Tech.MUTANTFACT1] > 0
                    system_blueprint[planet_id][Rules.Tech.MUTANTFACT1] -= 1
                elif Rules.Tech.MUTANTFACT2 in system_blueprint[planet_id]:
                    assert system_blueprint[planet_id][Rules.Tech.MUTANTFACT2] > 0
                    system_blueprint[planet_id][Rules.Tech.MUTANTFACT2] -= 1
                else:
                    continue
                system_blueprint[planet_id][Rules.Tech.MUTANTMINES] = 1
                return

    def _cleanup_dict(self, dict_):
        for key in dict_.keys():
            if not dict_[key]:
                del dict_[key]

    def _create_system_blueprint(self, system):
        # create appropriate build plans
        system_blueprint = {}
        for planet_id in self.data.freePlanets & set(system.planets):
            system_blueprint[planet_id] = {Rules.Tech.MUTANTBASE:1}
        for planet_id in self.data.myPlanets & set(system.planets):
            planet = self.db[planet_id]
            space = planet.plSlots - 1 # the main building is there every time
            if planet.plType == u"I":  # gaia
                system_blueprint[planet_id] = self._create_gaia_blueprint(space)
                continue
            elif planet.plType == u"E":  # terrestial
                system_blueprint[planet_id] = self._create_terrestial_blueprint(space)
                continue
            elif planet.plType == u"M":  # marginal
                system_blueprint[planet_id] = self._create_marginal_blueprint(space)
                continue
            else: # all sub-marginal types
                system_blueprint[planet_id] = self._create_submarginal_blueprint(space)
                continue
        self._cleanup_dict(system_blueprint)
        self._insert_minefield(system, system_blueprint)
        return system_blueprint

    def _system_manager(self):
        for planet_id in self.data.myPlanets:
            tool.sortStructures(self.client, self.db, planet_id)
        for system_id in self.data.mySystems:
            system = self.db[system_id]
            # creation of final system plans
            system_blueprint = self._create_system_blueprint(system)
            idle_planets = tool.buildSystem(self.data, self.client, self.db, system_id, self.data.myProdPlanets & set(system.planets), system_blueprint)
            # rest of the planets build ships
            # first get all our ships in the system
            system_fleet = {}
            for fleet_id in getattr(system, 'fleets', []):
                fleet = self.db[fleet_id]
                if getattr(fleet, 'owner', Const.OID_NONE) == self.player.oid:
                    system_fleet = Utils.dictAddition(system_fleet, tool.getFleetSheet(fleet))
            hasSeeders = False
            hasSeekers = False
            try:
                if system_fleet[2] >= 2: hasSeeders = True
            except KeyError:
                pass
            try:
                if system_fleet[3] >= 2: hasSeekers = True
            except KeyError:
                pass
            # this variable will gather how valuable system is in regards of fighter defense
            # in general, mutant has quite significant planetary defense, so our target is
            # to have only about 10 % production spend on support
            fighters_to_defend = self._system_worthiness(system, [15,8,5,3])

            for planet_id in idle_planets:
                planet = self.db[planet_id]
                shipDraw = random.randint(1, 10)
                if (not hasSeeders or not hasSeekers) and shipDraw < 9:
                    # there is 20% chance it won't build civilian ships, but military one
                    if not hasSeeders:
                        planet.prodQueue, self.player.stratRes = self.client.cmdProxy.startConstruction(planet_id, 2, 1, planet_id, True, False, Const.OID_NONE)
                        continue
                    elif not hasSeekers:
                        planet.prodQueue, self.player.stratRes = self.client.cmdProxy.startConstruction(planet_id, 3, 1, planet_id, True, False, Const.OID_NONE)
                        continue
                # rest is creation of ships based on current state + expected guard fighters
                try:
                    fighters = system_fleet[1]
                except KeyError:
                    fighters = 0
                try:
                    bombers = system_fleet[4]
                except KeyError:
                    bombers = 0
                expected_fighters = bombers * 1.5 + fighters_to_defend
                weight_fighter = 3
                weight_bomber = 2
                if expected_fighters > fighters:
                    # we have to build more fighters
                    weight_fighter += 1
                elif expected_fighters < fighters:
                    # we have too many fighters - let's prefer bombers for now
                    weight_bomber += 1
                choice = Utils.weightedRandom([1,4], [weight_fighter, weight_bomber])
                planet.prodQueue, self.player.stratRes = self.client.cmdProxy.startConstruction(planet_id, choice, 2, planet_id, True, False, Const.OID_NONE)

    def _explore(self, seeker_fleets):
        should_repeat = False
        for fleet_id in copy.copy(seeker_fleets & self.data.idleFleets):
            max_range = tool.subfleetMaxRange(self.client, self.db, {3:1}, fleet_id)
            nearest = tool.findNearest(self.db, self.db[fleet_id], self.data.unknownSystems, max_range)
            if len(nearest) > 0:
                system_id = nearest[0]
                # send the fleet
                fleet, new_fleet, my_fleets = tool.orderPartFleet(self.client, self.db,
                    {3:1}, True, fleet_id, Const.FLACTION_MOVE, system_id, None)
                self.data.myFleetSheets[fleet_id][3] -= 1
                if self.data.myFleetSheets[fleet_id][3] == 0:
                    del self.data.myFleetSheets[fleet_id][3]
                    seeker_fleets.remove(fleet_id)
                else:
                    should_repeat = True
                self.data.unknownSystems.remove(system_id)
        return should_repeat

    def _find_best_planet(self, planet_ids):
        # right now, it's simply the largest one
        max_slots = 0
        largest_planet_id = None
        for planet_id in planet_ids:
            planet = self.db[planet_id]
            if max_slots < planet.plSlots:
                max_slots = planet.plSlots
                largest_planet_id = planet_id
        return largets_planet_id


    def _colonize_free_systems(self, seeder_fleets):
        should_repeat = False
        for fleet_id in copy.copy(seeder_fleets & self.data.idleFleets):
            max_range = tool.subfleetMaxRange(self.client, self.db, {2:1}, fleet_id)
            nearest = tool.findNearest(self.db, self.db[fleet_id], self.data.freeSystems, max_range)
            if len(nearest) > 0:
                system_id = nearest[0]
                system = self.db[system_id]
                target_id = self._find_best_planet(system.planets)
                fleet, new_fleet, my_fleets = tool.orderPartFleet(self.client, self.db,
                    {2:1}, True, fleet_id, Const.FLACTION_DEPLOY, target_id, 2)
                self.data.myFleetSheets[fleet_id][2] -= 1
                if self.data.myFleetSheets[fleet_id][2] == 0:
                    del self.data.myFleetSheets[fleet_id][2]
                    seeder_fleets.remove(fleet_id)
                else:
                    should_repeat = True
                self.data.freeSystems.remove(system_id)
        return should_repeat

    def _colonize_occupied_systems(self, seeder_fleets):
        should_repeat = False
        for fleet_id in copy.copy(seeder_fleets & self.data.idleFleets):
            fleet = self.db[fleet_id]
            orbit_id = fleet.orbiting
            if orbit_id != Const.OID_NONE:
                orbit = self.db[orbit_id]
                if set(orbit.planets) & self.data.freePlanets and orbit_id in self.data.otherSystems:
                    target_id = self._find_best_planet(set(orbit.planets) & self.data.freePlanets)
                    fleet, new_fleet, my_fleets = tool.orderPartFleet(self.client, self.db,
                        {2:1}, True, fleet_id, Const.FLACTION_DEPLOY, target_id, 2)
                    self.data.myFleetSheets[fleet_id][2] -= 1
                    if self.data.myFleetSheets[fleet_id][2] == 0:
                        del self.data.myFleetSheets[fleet_id][2]
                        seeder_fleets.remove(fleet_id)
        return should_repeat

    def _expansion_manager(self):
        should_repeat = True
        seeker_fleets = self.data.myFleetsWithDesign.get(3, set())
        seeder_fleets = self.data.myFleetsWithDesign.get(2, set())
        while should_repeat:
            should_repeat = False
            should_repeat |= self._explore(seeker_fleets)
            should_repeat |= self._colonize_free_systems(seeder_fleets)
            should_repeat |= self._colonize_occupied_systems(seeder_fleets)

    def _ship_design_manager(self):
        # there are 4 basic designs    created by the server
        # 1: Swarmer [Small hull, Cockpit, 2x EMCannon, 2xFTL]
        # 2: Seeder [Medium hull, Cockpit, Mutant Colony Pod, 4xFTL]
        # 3: Seeker [Small hull, Cockpit, 1x ActiveScan, 2xFTL]
        # 4: Sower [Small hull, Cockpit, 1x Conv.Bomb, 2xFTL]
        pass

    def _logistics_manager(self):
        for system_id in self.data.mySystems - self.data.myRelevantSystems:
            system = self.db[system_id]
            for fleet_id in set(system.fleets) & self.data.idleFleets:
                fleet = self.db[fleet_id]
                subfleet = tool.getSubfleet(fleet, {1:0, 4:0}, False)
                if len(subfleet):
                    fleet_range = tool.subfleetMaxRange(self.client, self.db, {1:0, 4:0}, fleet_id)
                    relevant_sys_id = tool.findNearest(self.db, system, self.data.myRelevantSystems, fleet_range)
                    if relevant_sys_id:
                        relevant_sys_id = relevant_sys_id[0]
                        fleet, new_fleet, my_fleets = tool.orderPartFleet(self.client, self.db,
                            {1:0, 4:0}, True, fleet_id, Const.FLACTION_MOVE, relevant_sys_id, None)
                        self.data.idleFleets -= set([fleet_id])
                    else:
                        min_dist = fleet_range
                        min_dist_sys_id = None
                        min_dist_rel = self.data.distanceToRelevance[system_id]
                        for temp_id, dist in self.data.distanceToRelevance.items():
                            temp = self.db[temp_id]
                            distance = math.hypot(temp.x - system.x, temp.y - system.y)
                            if distance < min_dist and dist < min_dist_rel:
                                min_dist = distance
                                min_dist_sys_id = temp_id
                                min_dist_rel = dist
                        if min_dist_sys_id:
                            fleet, new_fleet, my_fleets = tool.orderPartFleet(self.client, self.db,
                                {1:0, 4:0}, True, fleet_id, Const.FLACTION_MOVE, min_dist_sys_id, None)
                            self.data.idleFleets -= set([fleet_id])

    def _get_attack_fleets(self):
        attack_fleets = set()
        for fleet_id in copy.copy(self.data.myFleets):
            fleet = self.db.get(fleet_id, None)
            # minimal size of attack fleet is determined by size of originating system - larger
            # more developed systems will stage stronger attack fleets
            try:
                system = self.db[fleet.orbiting]
            except KeyError:
                # this fleet is not on orbit, set legacy value
                minimum = 12
            else:
                minimum = self._system_worthiness(system, [8,5,3,2]) + 10
            if getattr(fleet, 'target', Const.OID_NONE) == Const.OID_NONE and getattr(fleet, 'ships', []):
                # this also covers fleets fighting over enemy systems - in that case, there
                # is slight chance the fleet will continue to the next system without conquering
                # the system first
                if fleet.orbiting in self.data.otherSystems and Utils.weightedRandom([True, False], [9,1]):
                    continue
                if tool.fleetContains(fleet, {1:minimum, 4:minimum}):
                    attack_fleets.add(fleet_id)
        return attack_fleets

    def _attack_manager(self):
        for fleet_id in self._get_attack_fleets():
            fleet = self.db[fleet_id]
            # send the attack fleet, if in range
            sheet = tool.getFleetSheet(fleet)
            sowers = sheet[4]
            swarmers = min(sheet[1], math.ceil(sowers * 1.5))
            max_range = 0.8 * tool.subfleetMaxRange(self.client, self.db, {1:swarmers, 4:sowers}, fleet_id)
            # four nearest systems are considered, with probability to be chosen based on order
            nearest = tool.findNearest(self.db, fleet, self.data.otherSystems, max_range, 4)
            if len(nearest):
                # range is adjusted to flatten probabilities a bit
                probability_map = map(lambda x: x ** 2, range(6, 2, -1))
                target = Utils.weightedRandom(nearest, probability_map)

                fleet, new_fleet, my_fleets = tool.orderPartFleet(self.client, self.db,
                    {1:swarmers, 4:sowers}, True,
                    fleet_id, Const.FLACTION_MOVE, target, None)

    def economy_manager(self):
        self._expansion_manager()
        self._system_manager()

    def offense_manager(self):
        self._ship_design_manager()
        self._logistics_manager()
        self._attack_manager()

    def run(self):
        self.economy_manager()
        self.offense_manager()

def run(aclient):
    ai = Mutant(aclient)
    ai.run()
    aclient.saveDB()



1			#
2			# Copyright 2001 - 2016 Ludek Smid [http://www.ospace.net/]
3			#
4			# This file is part of Outer Space.
5			#
6			# Outer Space is free software; you can redistribute it and/or modify
7			# it under the terms of the GNU General Public License as published by
8			# the Free Software Foundation; either version 2 of the License, or
9			# (at your option) any later version.
10			#
11			# Outer Space is distributed in the hope that it will be useful,
12			# but WITHOUT ANY WARRANTY; without even the implied warranty of
13			# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			# GNU General Public License for more details.
15			#
16			# You should have received a copy of the GNU General Public License
17			# along with Outer Space; if not, write to the Free Software
18			# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19			#
20			import random, copy, math
21
22			from ige import log
23			from ige.ospace import Const
24			from ige.ospace import Rules
25			from ige.ospace import Utils
26
27			import ai_tools as tool
28			from ais_base import AI
29
30			class Mutant(AI):
31			def __init__(self, client):
32			super(Mutant, self).__init__(client)
33			tool.doRelevance(self.data, self.client, self.db, 10)
34
35			def _system_worthiness(self, system, weights):
36			""" Scans system, and based on planetary composition and weights returns constant.
37			Weights are expected to be quadruplet of numbers, for [gaia, terrestial, marginal, rest]
38			"""
39			worth = 0
40			for planet_id in self.data.myPlanets & set(system.planets):
41			planet = self.db[planet_id]
42			if planet.plType == u"I": # gaia
43			worth += weights[0]
44			elif planet.plType == u"E": # terrestial
45			worth += weights[1]
46			elif planet.plType == u"M": # marginal
47			worth += weights[2]
48			else: # junk
49			worth += weights[3]
50			return worth
51
52			def _create_gaia_blueprint(self, space):
53			# preserve minefield position, and in case there is no
54			# minefield in the system, try to place it on the first planet
55			# available
56			power_plants = math.ceil(max(space - 1, 0) / 6.0)
57			factories = space - power_plants
58			return {Rules.Tech.MUTANTBASE4:1,
59			Rules.Tech.MUTANTPP2:power_plants,
60			Rules.Tech.MUTANTFACT2:factories}
61
62			def _create_terrestial_blueprint(self, space):
63			# preserve minefield position, and in case there is no
64			# minefield in the system, try to place it on the first planet
65			# available
66			power_plants = math.ceil(max(space - 1, 0) / 5.0)
67			factories = space - power_plants
68			return {Rules.Tech.MUTANTBASE3:1,
69			Rules.Tech.MUTANTPP2:power_plants,
70			Rules.Tech.MUTANTFACT2:factories}
71
72			def _create_marginal_blueprint(self, space):
73			# preserve minefield position, and in case there is no
74			# minefield in the system, try to place it on the first planet
75			# available
76			power_plants = math.ceil(max(space - 1, 0) / 7.0)
77			factories = space - power_plants
78			return {Rules.Tech.MUTANTBASE2:1,
79			Rules.Tech.MUTANTPP2:power_plants,
80			Rules.Tech.MUTANTFACT1:factories}
81
82			def _create_submarginal_blueprint(self, space):
83			# preserve minefield position, and in case there is no
84			# minefield in the system, try to place it on the first planet
85			# available
86			power_plants = math.ceil(max(space - 1, 0) / 5.0)
87			factories = space - power_plants
88			return {Rules.Tech.MUTANTBASE:1,
89			Rules.Tech.MUTANTPP1:power_plants,
90			Rules.Tech.MUTANTFACT1:factories}
91
92			def _insert_minefield(self, system, system_blueprint):
93			# pick worst possible planet to put minefield on, don't waste
94			# precious gaia space if possible
95			# also ignore actual state - don't be afraid to rebuild if planet is
96			# promoted
97			for avoided_types in [(u"I", u"E", u"M"), (u"I", u"E"), (u"I",), ()]:
98			# sorting, to avoid rebuilds between equivalent planets
99			for planet_id in sorted(system_blueprint):
100			planet = self.db[planet_id]
101			if planet.plType in avoided_types or planet.plSlots == 1:
102			continue
103			if Rules.Tech.MUTANTFACT1 in system_blueprint[planet_id]:
104			assert system_blueprint[planet_id][Rules.Tech.MUTANTFACT1] > 0
105			system_blueprint[planet_id][Rules.Tech.MUTANTFACT1] -= 1
106			elif Rules.Tech.MUTANTFACT2 in system_blueprint[planet_id]:
107			assert system_blueprint[planet_id][Rules.Tech.MUTANTFACT2] > 0
108			system_blueprint[planet_id][Rules.Tech.MUTANTFACT2] -= 1
109			else:
110			continue
111			system_blueprint[planet_id][Rules.Tech.MUTANTMINES] = 1
112			return
113
114			def _cleanup_dict(self, dict_):
115			for key in dict_.keys():
116			if not dict_[key]:
117			del dict_[key]
118
119			def _create_system_blueprint(self, system):
120			# create appropriate build plans
121			system_blueprint = {}
122			for planet_id in self.data.freePlanets & set(system.planets):
123			system_blueprint[planet_id] = {Rules.Tech.MUTANTBASE:1}
124			for planet_id in self.data.myPlanets & set(system.planets):
125			planet = self.db[planet_id]
126			space = planet.plSlots - 1 # the main building is there every time
127			if planet.plType == u"I": # gaia
128			system_blueprint[planet_id] = self._create_gaia_blueprint(space)
129			continue
130			elif planet.plType == u"E": # terrestial
131			system_blueprint[planet_id] = self._create_terrestial_blueprint(space)
132			continue
133			elif planet.plType == u"M": # marginal
134			system_blueprint[planet_id] = self._create_marginal_blueprint(space)
135			continue
136			else: # all sub-marginal types
137			system_blueprint[planet_id] = self._create_submarginal_blueprint(space)
138			continue
139			self._cleanup_dict(system_blueprint)
140			self._insert_minefield(system, system_blueprint)
141			return system_blueprint
142
143			def _system_manager(self):
144			for planet_id in self.data.myPlanets:
145			tool.sortStructures(self.client, self.db, planet_id)
146			for system_id in self.data.mySystems:
147			system = self.db[system_id]
148			# creation of final system plans
149			system_blueprint = self._create_system_blueprint(system)
150			idle_planets = tool.buildSystem(self.data, self.client, self.db, system_id, self.data.myProdPlanets & set(system.planets), system_blueprint)
151			# rest of the planets build ships
152			# first get all our ships in the system
153			system_fleet = {}
154			for fleet_id in getattr(system, 'fleets', []):
155			fleet = self.db[fleet_id]
156			if getattr(fleet, 'owner', Const.OID_NONE) == self.player.oid:
157			system_fleet = Utils.dictAddition(system_fleet, tool.getFleetSheet(fleet))
158			hasSeeders = False
159			hasSeekers = False
160			try:
161			if system_fleet[2] >= 2: hasSeeders = True
162			except KeyError:
163			pass
164			try:
165			if system_fleet[3] >= 2: hasSeekers = True
166			except KeyError:
167			pass
168			# this variable will gather how valuable system is in regards of fighter defense
169			# in general, mutant has quite significant planetary defense, so our target is
170			# to have only about 10 % production spend on support
171			fighters_to_defend = self._system_worthiness(system, [15,8,5,3])
172
173			for planet_id in idle_planets:
174			planet = self.db[planet_id]
175			shipDraw = random.randint(1, 10)
176			if (not hasSeeders or not hasSeekers) and shipDraw < 9:
177			# there is 20% chance it won't build civilian ships, but military one
178			if not hasSeeders:
179			planet.prodQueue, self.player.stratRes = self.client.cmdProxy.startConstruction(planet_id, 2, 1, planet_id, True, False, Const.OID_NONE)
180			continue
181			elif not hasSeekers:
182			planet.prodQueue, self.player.stratRes = self.client.cmdProxy.startConstruction(planet_id, 3, 1, planet_id, True, False, Const.OID_NONE)
183			continue
184			# rest is creation of ships based on current state + expected guard fighters
185			try:
186			fighters = system_fleet[1]
187			except KeyError:
188			fighters = 0
189			try:
190			bombers = system_fleet[4]
191			except KeyError:
192			bombers = 0
193			expected_fighters = bombers * 1.5 + fighters_to_defend
194			weight_fighter = 3
195			weight_bomber = 2
196			if expected_fighters > fighters:
197			# we have to build more fighters
198			weight_fighter += 1
199			elif expected_fighters < fighters:
200			# we have too many fighters - let's prefer bombers for now
201			weight_bomber += 1
202			choice = Utils.weightedRandom([1,4], [weight_fighter, weight_bomber])
203			planet.prodQueue, self.player.stratRes = self.client.cmdProxy.startConstruction(planet_id, choice, 2, planet_id, True, False, Const.OID_NONE)
204
205			def _explore(self, seeker_fleets):
206			should_repeat = False
207			for fleet_id in copy.copy(seeker_fleets & self.data.idleFleets):
208			max_range = tool.subfleetMaxRange(self.client, self.db, {3:1}, fleet_id)
209			nearest = tool.findNearest(self.db, self.db[fleet_id], self.data.unknownSystems, max_range)
210			if len(nearest) > 0:
211			system_id = nearest[0]
212			# send the fleet
213			fleet, new_fleet, my_fleets = tool.orderPartFleet(self.client, self.db,
214			{3:1}, True, fleet_id, Const.FLACTION_MOVE, system_id, None)
215			self.data.myFleetSheets[fleet_id][3] -= 1
216			if self.data.myFleetSheets[fleet_id][3] == 0:
217			del self.data.myFleetSheets[fleet_id][3]
218			seeker_fleets.remove(fleet_id)
219			else:
220			should_repeat = True
221			self.data.unknownSystems.remove(system_id)
222			return should_repeat
223
224			def _find_best_planet(self, planet_ids):
225			# right now, it's simply the largest one
226			max_slots = 0
227			largest_planet_id = None
228			for planet_id in planet_ids:
229			planet = self.db[planet_id]
230			if max_slots < planet.plSlots:
231			max_slots = planet.plSlots
232			largest_planet_id = planet_id
233			return largets_planet_id
			0 ignored issues – show Comprehensibility Best Practice introduced 2018-07-08 10:52 UTC by Report Bug Copy Issue Report The variable `largets_planet_id` does not seem to be defined. Loading history...
234
235			def _colonize_free_systems(self, seeder_fleets):
236			should_repeat = False
237			for fleet_id in copy.copy(seeder_fleets & self.data.idleFleets):
238			max_range = tool.subfleetMaxRange(self.client, self.db, {2:1}, fleet_id)
239			nearest = tool.findNearest(self.db, self.db[fleet_id], self.data.freeSystems, max_range)
240			if len(nearest) > 0:
241			system_id = nearest[0]
242			system = self.db[system_id]
243			target_id = self._find_best_planet(system.planets)
244			fleet, new_fleet, my_fleets = tool.orderPartFleet(self.client, self.db,
245			{2:1}, True, fleet_id, Const.FLACTION_DEPLOY, target_id, 2)
246			self.data.myFleetSheets[fleet_id][2] -= 1
247			if self.data.myFleetSheets[fleet_id][2] == 0:
248			del self.data.myFleetSheets[fleet_id][2]
249			seeder_fleets.remove(fleet_id)
250			else:
251			should_repeat = True
252			self.data.freeSystems.remove(system_id)
253			return should_repeat
254
255			def _colonize_occupied_systems(self, seeder_fleets):
256			should_repeat = False
257			for fleet_id in copy.copy(seeder_fleets & self.data.idleFleets):
258			fleet = self.db[fleet_id]
259			orbit_id = fleet.orbiting
260			if orbit_id != Const.OID_NONE:
261			orbit = self.db[orbit_id]
262			if set(orbit.planets) & self.data.freePlanets and orbit_id in self.data.otherSystems:
263			target_id = self._find_best_planet(set(orbit.planets) & self.data.freePlanets)
264			fleet, new_fleet, my_fleets = tool.orderPartFleet(self.client, self.db,
265			{2:1}, True, fleet_id, Const.FLACTION_DEPLOY, target_id, 2)
266			self.data.myFleetSheets[fleet_id][2] -= 1
267			if self.data.myFleetSheets[fleet_id][2] == 0:
268			del self.data.myFleetSheets[fleet_id][2]
269			seeder_fleets.remove(fleet_id)
270			return should_repeat
271
272			def _expansion_manager(self):
273			should_repeat = True
274			seeker_fleets = self.data.myFleetsWithDesign.get(3, set())
275			seeder_fleets = self.data.myFleetsWithDesign.get(2, set())
276			while should_repeat:
277			should_repeat = False
278			should_repeat \|= self._explore(seeker_fleets)
279			should_repeat \|= self._colonize_free_systems(seeder_fleets)
280			should_repeat \|= self._colonize_occupied_systems(seeder_fleets)
281
282			def _ship_design_manager(self):
283			# there are 4 basic designs created by the server
284			# 1: Swarmer [Small hull, Cockpit, 2x EMCannon, 2xFTL]
285			# 2: Seeder [Medium hull, Cockpit, Mutant Colony Pod, 4xFTL]
286			# 3: Seeker [Small hull, Cockpit, 1x ActiveScan, 2xFTL]
287			# 4: Sower [Small hull, Cockpit, 1x Conv.Bomb, 2xFTL]
288			pass
289
290			def _logistics_manager(self):
291			for system_id in self.data.mySystems - self.data.myRelevantSystems:
292			system = self.db[system_id]
293			for fleet_id in set(system.fleets) & self.data.idleFleets:
294			fleet = self.db[fleet_id]
295			subfleet = tool.getSubfleet(fleet, {1:0, 4:0}, False)
296			if len(subfleet):
297			fleet_range = tool.subfleetMaxRange(self.client, self.db, {1:0, 4:0}, fleet_id)
298			relevant_sys_id = tool.findNearest(self.db, system, self.data.myRelevantSystems, fleet_range)
299			if relevant_sys_id:
300			relevant_sys_id = relevant_sys_id[0]
301			fleet, new_fleet, my_fleets = tool.orderPartFleet(self.client, self.db,
302			{1:0, 4:0}, True, fleet_id, Const.FLACTION_MOVE, relevant_sys_id, None)
303			self.data.idleFleets -= set([fleet_id])
304			else:
305			min_dist = fleet_range
306			min_dist_sys_id = None
307			min_dist_rel = self.data.distanceToRelevance[system_id]
308			for temp_id, dist in self.data.distanceToRelevance.items():
309			temp = self.db[temp_id]
310			distance = math.hypot(temp.x - system.x, temp.y - system.y)
311			if distance < min_dist and dist < min_dist_rel:
312			min_dist = distance
313			min_dist_sys_id = temp_id
314			min_dist_rel = dist
315			if min_dist_sys_id:
316			fleet, new_fleet, my_fleets = tool.orderPartFleet(self.client, self.db,
317			{1:0, 4:0}, True, fleet_id, Const.FLACTION_MOVE, min_dist_sys_id, None)
318			self.data.idleFleets -= set([fleet_id])
319
320			def _get_attack_fleets(self):
321			attack_fleets = set()
322			for fleet_id in copy.copy(self.data.myFleets):
323			fleet = self.db.get(fleet_id, None)
324			# minimal size of attack fleet is determined by size of originating system - larger
325			# more developed systems will stage stronger attack fleets
326			try:
327			system = self.db[fleet.orbiting]
328			except KeyError:
329			# this fleet is not on orbit, set legacy value
330			minimum = 12
331			else:
332			minimum = self._system_worthiness(system, [8,5,3,2]) + 10
333			if getattr(fleet, 'target', Const.OID_NONE) == Const.OID_NONE and getattr(fleet, 'ships', []):
334			# this also covers fleets fighting over enemy systems - in that case, there
335			# is slight chance the fleet will continue to the next system without conquering
336			# the system first
337			if fleet.orbiting in self.data.otherSystems and Utils.weightedRandom([True, False], [9,1]):
338			continue
339			if tool.fleetContains(fleet, {1:minimum, 4:minimum}):
340			attack_fleets.add(fleet_id)
341			return attack_fleets
342
343			def _attack_manager(self):
344			for fleet_id in self._get_attack_fleets():
345			fleet = self.db[fleet_id]
346			# send the attack fleet, if in range
347			sheet = tool.getFleetSheet(fleet)
348			sowers = sheet[4]
349			swarmers = min(sheet[1], math.ceil(sowers * 1.5))
350			max_range = 0.8 * tool.subfleetMaxRange(self.client, self.db, {1:swarmers, 4:sowers}, fleet_id)
351			# four nearest systems are considered, with probability to be chosen based on order
352			nearest = tool.findNearest(self.db, fleet, self.data.otherSystems, max_range, 4)
353			if len(nearest):
354			# range is adjusted to flatten probabilities a bit
355			probability_map = map(lambda x: x ** 2, range(6, 2, -1))
356			target = Utils.weightedRandom(nearest, probability_map)
357
358			fleet, new_fleet, my_fleets = tool.orderPartFleet(self.client, self.db,
359			{1:swarmers, 4:sowers}, True,
360			fleet_id, Const.FLACTION_MOVE, target, None)
361
362			def economy_manager(self):
363			self._expansion_manager()
364			self._system_manager()
365
366			def offense_manager(self):
367			self._ship_design_manager()
368			self._logistics_manager()
369			self._attack_manager()
370
371			def run(self):
372			self.economy_manager()
373			self.offense_manager()
374
375			def run(aclient):
376			ai = Mutant(aclient)
377			ai.run()
378			aclient.saveDB()
379
380

ospaceteam / outerspace

Pull Request — master (#226)

AIs.ais_mutant.systemManager() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like