osci.dialog.ProblemsDlg.ProblemsDlg._addProblemsFleets() - Code Metrics - Inspection of "Cleaning scrut hotspots" - ospaceteam/outerspace - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#291)

by Marek
created 2020-01-26 14:50 UTC
ProblemsDlg._addProblemsFleets() F

↳ Parent: osci.dialog.ProblemsDlg
Complexity

Conditions
Size

Total Lines	52
Code Lines	41
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	20
eloc	41
nop	3
dl	0
loc	52
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 pygameui as ui
import re
from osci import gdata, client, res
import ige.ospace.Const as Const
from ige.ospace import Utils, Rules
import string, math, copy

class ProblemsDlg:
    """Displays 'Problem locator' dialog.

    """
    def __init__(self, app):
        self.app = app
        self.createUI()

    def display(self):
        self.show()
        self.win.show()
        # register for updates
        if self not in gdata.updateDlgs:
            gdata.updateDlgs.append(self)

    def hide(self):
        self.win.setStatus(_("Ready."))
        self.win.hide()
        # unregister updates
        if self in gdata.updateDlgs:
            gdata.updateDlgs.remove(self)

    def update(self):
        self.show()

    class Problems:
        def __init__(self, win):
            self.items = []
            self.checkboxes = {gdata.CRI : win.vCritical.checked,
                               gdata.MAJ : win.vMajor.checked,
                               gdata.MIN : win.vMinor.checked,
                               gdata.INFO: win.vInfo.checked}

        def append(self, severity, item):
            if self.checkboxes[severity]:
                item.foreground = gdata.sevColors[severity]
                self.items.append(item)

    def _getProblemsProdQueues(self, objects):
        return prodQueueProblems


    def _addProblemsStructStatus(self, problems, struct, planet):
        player = client.getPlayer()
        status = struct[Const.STRUCT_IDX_STATUS]
        tech = client.getFullTechInfo(struct[Const.STRUCT_IDX_TECHID])

        if hasattr(player, 'techs'):
            techEff = Rules.techImprEff[player.techs.get(struct[Const.STRUCT_IDX_TECHID], Rules.techBaseImprovement)]
        else:
            techEff = Rules.techImprEff[Rules.techBaseImprovement]

        HPturn = max(1, int(0.02 * tech.maxHP * techEff))
        turnsToDestroy = math.ceil(struct[Const.STRUCT_IDX_HP] / HPturn)

        if turnsToDestroy < 48:
            severity = gdata.MAJ
            if turnsToDestroy < 24:
                severity = gdata.CRI
        else:
            severity = gdata.MIN

        if not status & Const.STRUCT_STATUS_ON:
            # structure is off
            problems.append(severity, ui.Item(planet.name, tOID = planet.oid, tType = Const.T_PLANET,
                    vDescription = _('Structure (%s) is off and will be destroyed in %s turns.') % (tech.name, res.formatTime(turnsToDestroy))))

        if status & Const.STRUCT_STATUS_DETER:
            problems.append(gdata.MAJ, ui.Item(planet.name, tOID = planet.oid, tType = Const.T_PLANET,
                vDescription = _('Structure (%s) is deteriorating.') % (tech.name,)))
        if status & Const.STRUCT_STATUS_NOBIO:
            problems.append(gdata.INFO, ui.Item(planet.name, tOID = planet.oid, tType = Const.T_PLANET,
                vDescription = _('Structure (%s) has insufficient supply of biomatter.') % (tech.name,)))
        if status & Const.STRUCT_STATUS_NOEN:
            problems.append(gdata.INFO, ui.Item(planet.name, tOID = planet.oid, tType = Const.T_PLANET,
                vDescription = _('Structure (%s) has insufficient supply of energy.') % (tech.name,)))
        if status & Const.STRUCT_STATUS_NOPOP:
            problems.append(gdata.INFO, ui.Item(planet.name, tOID = planet.oid, tType = Const.T_PLANET,
                vDescription = _('Structure (%s) has insufficient supply of workers.') % (tech.name,)))
        if status & Const.STRUCT_STATUS_REPAIRING:
            problems.append(gdata.INFO, ui.Item(planet.name, tOID = planet.oid, tType = Const.T_PLANET,
                vDescription = _('Structure (%s) is repairing.') % (tech.name,)))

    def _addProblemsFleets(self, problems, fleet):
        player = client.getPlayer()
        energyReserve = fleet.storEn  * 100 / fleet.maxEn
        system = None

        maxRefuelMax = 0
        if hasattr(fleet, 'orbiting') and fleet.orbiting:
            system = client.get(fleet.orbiting, noUpdate = 1)
            if hasattr(system, 'planets'):
                for planetID in system.planets:
                    planet = client.get(planetID, noUpdate = 1)
                    if hasattr(planet, 'owner') and hasattr(planet, 'refuelMax'):
                        if player.diplomacyRels.has_key(planet.owner):
                            dipl = client.getDiplomacyWith(planet.owner)
                            if dipl.pacts.has_key(Const.PACT_ALLOW_TANKING) and dipl.pacts[Const.PACT_ALLOW_TANKING][0] == Const.PACT_ACTIVE:
                                maxRefuelMax = max(maxRefuelMax, planet.refuelMax)
                        else:
                            if planet.owner == player.oid:
                                maxRefuelMax = max(maxRefuelMax, planet.refuelMax)
        else:
            # we do not report fleets in flight
            return

        systemName = res.getUnknownName()
        if system and hasattr(system, "name"):
            systemName = system.name

        # is fleet named?
        if hasattr(fleet,'customname') and fleet.customname:
            name = fleet.customname
        else:
            name = getattr(fleet, "name", None)

        note = _(' and is NOT refueling')
        if maxRefuelMax:
            severity = gdata.INFO
            if maxRefuelMax <= energyReserve:
                note = _(' and CAN refuel, but reached planet maximum refuel amount')
            else:
                note = _(' and IS refueling')
        elif energyReserve < 25:
            severity = gdata.CRI
        elif energyReserve < 50:
            severity = gdata.MAJ
        elif energyReserve == 100:
            problems.append(gdata.INFO, ui.Item(systemName, tOID = fleet.oid, tType = Const.T_FLEET,
                        vDescription = _('Fleet "%s" has full fuel tanks.') % (name)))
            return
        else:
            severity = gdata.INFO
        problems.append(severity, ui.Item(systemName, tOID = fleet.oid, tType = Const.T_FLEET,
                    vDescription = _('Fleet "%s" is low on fuel [%d %%]%s.') % (name, energyReserve, note)))

    def _addProblemsBio(self, problems, system, bio, totalBio):

        if bio >= 0:
            return
        surplusTurns = totalBio / (-bio)
        if surplusTurns < Rules.turnsPerDay * 7:
            severity = gdata.MAJ
        elif surplusTurns < Rules.turnsPerDay * 2:
            severity = gdata.CRI
        else:
            severity = gdata.MIN

        if totalBio > 0:
            note = _(' surplus %d (%s)' % (totalBio, res.formatTime(surplusTurns)))
        else:
            note = _(' with no surplus left!')
        problems.append(ui.Item(system.name, tOID = system.oid, tType = Const.T_SYSTEM,
                     vDescription = _('Bio decreasing - last turn change %d, %s.') % (bio, note)))

    def _addProblemsEn(self, problems, system, en, totalEn):

        if en >= 0:
            return
        surplusTurns = totalEn / (-en)
        if surplusTurns < Rules.turnsPerDay * 7:
            severity = gdata.MAJ
        elif surplusTurns < Rules.turnsPerDay * 2:
            severity = gdata.CRI
        else:
            severity = gdata.MIN

        if totalEn > 0:
            note = _(' surplus %d (%s)' % (totalEn, res.formatTime(surplusTurns)))
        else:
            note = _(' with no surplus left!')
        problems.append(ui.Item(system.name, tOID = system.oid, tType = Const.T_SYSTEM,
                     vDescription = _('Energy decreasing - last turn change %d, %s.') % (bio, note)))


    def _addProblemsResearch(self, problems):
        player = client.getPlayer()
        totalEtc = 0
        # compute length of research queue
        for task in player.rsrchQueue:
            tech = client.getTechInfo(task.techID)
            fulltech = client.getFullTechInfo(task.techID)
            researchSci = Utils.getTechRCost(player, task.techID, task.improvement)
            maxImprovement = min(Rules.techMaxImprovement,fulltech.maxImprovement)
            maxImpTotalSci = 0
            if task.improveToMax and task.improvement < maxImprovement:
                for impr in range(task.improvement+1,maxImprovement+1):
                    maxImpTotalSci += Utils.getTechRCost(player, task.techID, impr)
            if task.changeSci > 0:
                value = float(researchSci - task.currSci) / max(task.changeSci, player.effSciPoints)
                totalEtc += int(value + 1)
                if player.effSciPoints != 0:
                    totalEtc += float(maxImpTotalSci) / player.effSciPoints
            elif task.changeSci < 0:
                totalEtc -= float(task.currSci) / min(task.changeSci, player.effSciPoints)
            elif player.effSciPoints > 0:
                value = float(researchSci) / player.effSciPoints
                totalEtc += int(value + 1)
                totalEtc += float(maxImpTotalSci) / player.effSciPoints
            else:
                totalEtc = 99999
                break

        # check empty research queue
        if totalEtc == 0 and len(player.rsrchQueue) == 0 and player.effSciPoints > 0:
            problems.append(gdata.CRI, ui.Item(_('Research'), tType = Const.T_TECHNOLOGY,
                vDescription = _('Research queue is empty.')))
        # check short reseach queue
        elif totalEtc < Rules.turnsPerDay * 2:
            severity = gdata.MIN
            if totalEtc < Rules.turnsPerDay:
                severity = gdata.MAJ
            problems.append(severity, ui.Item(_('Research'), tType = Const.T_TECHNOLOGY,
                        vDescription = _('Research queue ends in %s turns, %d item(s) on list.') % (res.formatTime(totalEtc), len(player.rsrchQueue))))

    def show(self):
        critical = self.win.vCritical.checked
        major = self.win.vMajor.checked
        minor = self.win.vMinor.checked
        info = self.win.vInfo.checked

        disp = 1

        player = client.getPlayer()
        problems = self.Problems(self.win)
        # object list (all player's objects + systems)
        objects = player.fleets[:]
        objects += player.planets[:]
        systems = {}
        for planetID in player.planets:
            planet = client.get(planetID)
            if planet.compOf not in systems:
                systems[planet.compOf] = None
        objects += systems.keys()

        # counting construction points value of each global production queue
        # holder for (number , eff production) of planets set to each queue
        globalQueueStats=[(0,0), (0,0), (0,0), (0,0), (0,0)]
        prodQueueProblems = []

        # go through all objects
        for objID in objects:
            if objID < Const.OID_FREESTART:
                continue
            obj = client.get(objID, noUpdate = 1)
            if not hasattr(obj, "type"):
                continue
            if obj.type == Const.T_SYSTEM:
                if not hasattr(obj, 'planets'):
                    continue
                bio = 0
                totalBio = 0
                en = 0
                totalEn = 0
                buildingQuantity = {}
                buildingInfo = {}
                # holds modified planets
                planetCopies = {}

                for planetID in obj.planets:
                    planet = client.get(planetID, noUpdate = 1)
                    # copy of planet to change plSlots count
                    if not planetID in planetCopies:
                        cPlanet = copy.deepcopy(planet)
                        planetCopies[planetID] = cPlanet
                    else:
                        cPlanet = planetCopies[planetID]
                    if hasattr(planet, 'owner') and planet.owner == player.oid:
                        queuePlanetNumber, queueEffProd = globalQueueStats[planet.globalQueue]
                        queuePlanetNumber += 1
                        queueEffProd += planet.effProdProd
                        globalQueueStats[planet.globalQueue] = (queuePlanetNumber, queueEffProd)
                        # compute bio and en for system
                        bio += planet.changeBio
                        totalBio += max(0, planet.storBio - planet.minBio)
                        en  += planet.changeEn
                        totalEn += max(0, planet.storEn - planet.minEn)
                        # the planet needs to have global queue 0 - the default one - to have its queue reported
                        if hasattr(planet, 'prodQueue') and self.win.vPlanets.checked and not planet.globalQueue:
                            totalEtc = 0
                            # compute length of production queue
                            if cPlanet.prodQueue and cPlanet.effProdProd > 0:
                                for task in cPlanet.prodQueue:
                                    if task.isShip:
                                        tech = player.shipDesigns[task.techID]
                                    else:
                                        tech = client.getFullTechInfo(task.techID)
                                        if tech.isStructure and hasattr(task, "demolishStruct") and task.demolishStruct == 0:
                                            # total count of constructing buildings on target
                                            if buildingQuantity.has_key(task.targetID):
                                                buildingQuantity[task.targetID] += task.quantity
                                            else:
                                                buildingQuantity[task.targetID] = task.quantity

                                            # information about source and target of constructing
                                            if buildingInfo.has_key((planetID, task.targetID)):
                                                buildingInfo[(planetID, task.targetID)] += task.quantity
                                            else:
                                                buildingInfo[(planetID, task.targetID)] = task.quantity
                                        elif tech.isProject and tech.id == 3802:
                                            # we are constructing Habitable Surface Expansion
                                            # so after construction we got some new slots on planet
                                            if not task.targetID in planetCopies:
                                                targetPlanet = client.get(task.targetID, noUpdate = 1)
                                                cPlanet = copy.deepcopy(targetPlanet)
                                                planetCopies[task.targetID] = cPlanet

                                            planetCopies[task.targetID].plSlots += task.quantity

                                    if task.targetID != planetID:
                                        totalEtc += math.ceil(float(tech.buildProd * Rules.buildOnAnotherPlanetMod - task.currProd) / planet.effProdProd)
                                        totalEtc += math.ceil((task.quantity - 1) * float(tech.buildProd * Rules.buildOnAnotherPlanetMod) / planet.effProdProd)
                                    else:
                                        totalEtc += math.ceil(task.quantity * float(tech.buildProd - task.currProd) / planet.effProdProd)
                                        totalEtc += math.ceil((task.quantity - 1) * float(tech.buildProd) / planet.effProdProd)
                            else:
                                totalEtc = 99999

                            prodQueueProblems.append((planetID, totalEtc, len(planet.prodQueue)))


                        if hasattr(planet, 'slots') and self.win.vPlanets.checked:
                            for struct in planet.slots:
                                self._addProblemsStructStatus(problems, struct, planet)

                for planetID, quantity in buildingQuantity.items():
                    planet = planetCopies[planetID]
                    # test, if there is total quantity of building as target for this planet
                    if planet.plSlots < len(planet.slots) + quantity and major:
                        # walk infos and search for all planets, that are building
                        # on planet found above
                        for (sourceID, targetID), quantity in buildingInfo.items():
                            if planetID == targetID:
                                source = client.get(sourceID, noUpdate = 1)
                                items.append(ui.Item(source.name, tOID = sourceID, tType = Const.T_PLANET, foreground = gdata.sevColors[gdata.MAJ],

                                            vDescription = _('There is no space for all constructed buildings on %s.') % (planet.name)))

                # check bio for system
                if self.win.vSystems.checked:
                    self._addProblemsBio(problems, obj, bio, totalBio)
                    self._addProblemsEn(problems, obj, en, totalEn)

            # check fleets
            elif obj.type == Const.T_FLEET and self.win.vFleets.checked:
                if hasattr(obj, 'owner') and obj.owner == player.oid:
                    self._addProblemsFleets(problems, obj)


        queConstValues = [0, 0, 0, 0, 0]
        queEtc = [0, 0, 0, 0, 0]
        for queue in xrange(5):

            quePlanets, queEffProd = globalQueueStats[queue]
            for task in player.prodQueues[queue]:
                if task.isShip:
                    tech = player.shipDesigns[task.techID]
                else:
                    tech = client.getFullTechInfo(task.techID)
                queConstValues[queue] += task.quantity * tech.buildProd
            if queEffProd > 0:
                queEtc[queue] = math.ceil(float(queConstValues[queue])/queEffProd)
            else:
                queEtc[queue] = 99999

        # creation of items with production queue [default one] problems
        for planetID, totalEtc, queueLen in prodQueueProblems:
            planet = client.get(planetID, noUpdate = 1)

            # check empty production queue
            if queueLen == 0 and planet.effProdProd > 0 and queConstValues[0] == 0 and critical:
                items.append(ui.Item(planet.name, tOID = planetID, tType = Const.T_PLANET,
                    foreground = gdata.sevColors[gdata.CRI],
                    vDescription = _('Production queue is empty.')))

            # check end of production queue
            if totalEtc+queEtc[0] < 48:
                fgColor = None
                disp = minor
                if totalEtc+queEtc[0] < 24:
                    disp = major
                    fgColor = gdata.sevColors[gdata.MAJ]
                    if disp:
                        items.append(ui.Item(planet.name, tOID = planetID, tType = Const.T_PLANET, foreground = fgColor,
                            vDescription = _('Production queue may end in {0} turns ({1} directly in planet queue), {2} item(s) on list.'.format(res.formatTime(totalEtc+queEtc[0]), res.formatTime(totalEtc), queueLen))))

        # creation of items with global queue problems
        for queue in xrange(1, 5):
            queName = res.globalQueueName(queue)
            quePlanets = globalQueueStats[queue][0]
            # check empty global production queue with at least one planet [so its relevant]
            if queConstValues[queue] == 0 and  quePlanets > 0 and critical:
                items.append(ui.Item(_('Global queue ' + queName), tType = Const.T_QUEUE,
                    foreground = gdata.sevColors[gdata.CRI],
                    vDescription = _('Global production queue {0} used by {1} planet(s) is empty.'.format(queName, quePlanets))))

            # check end of global production queue
            elif queEtc[queue] < 48:
                fgColor = None
                disp = minor
                if queEtc[queue] < 24:
                    disp = major
                    fgColor = gdata.sevColors[gdata.MAJ]
                if disp:
                    items.append(ui.Item(_('Global queue ' + queName), tType = Const.T_QUEUE, foreground = fgColor,
                        vDescription = _('Global production queue {0} used by {1} planet(s) runs out in {2} turns.'.format(queName, quePlanets, res.formatTime(queEtc[queue])))))

        # check research queue
        if self.win.vResearch.checked:
            self._addProblemsResearch(problems)
            

        self.win.vProblems.items = problems.items
        self.win.vProblems.itemsChanged()

    def onClose(self, widget, action, data):
        self.hide()

    def onShowSource(self, widget, action, data):
        item = self.win.vProblems.selection[0]
        if item.tType == Const.T_FLEET:
            object = client.get(item.tOID, noUpdate = 1)
            # center on map
            if hasattr(object, "x"):
                gdata.mainGameDlg.win.vStarMap.highlightPos = (object.x, object.y)
                gdata.mainGameDlg.win.vStarMap.setPos(object.x, object.y)
                self.hide()
                return
        elif item.tType in (Const.T_SYSTEM, Const.T_PLANET):
            if item.tOID != Const.OID_NONE:
                gdata.mainGameDlg.onSelectMapObj(None, None, item.tOID)
                return
        elif item.tType == Const.T_TECHNOLOGY:
            gdata.mainGameDlg.researchDlg.display()
            return
        elif item.tType == Const.T_QUEUE:
            gdata.mainGameDlg.globalQueuesDlg.display()
        self.win.setStatus(_("Cannot show location."))

    def onShowLocation(self, widget, action, data):
        item = self.win.vProblems.selection[0]
        if item.tType in (Const.T_SYSTEM, Const.T_PLANET, Const.T_FLEET):
            object = client.get(item.tOID, noUpdate = 1)
            # center on map
            if hasattr(object, "x"):
                gdata.mainGameDlg.win.vStarMap.highlightPos = (object.x, object.y)
                gdata.mainGameDlg.win.vStarMap.setPos(object.x, object.y)
                self.hide()
                return
        self.win.setStatus(_("Cannot show location."))

    def onToggleCondition(self, widget, action, data):
        self.update()

    def createUI(self):
        screenWidth, screenHeight = gdata.scrnSize
        # size of dialog in layout metrics (for SimpleGridLM)
        cols = 40
        rows = 29
        # dialog width and height in pixels
        isSmallWin = screenHeight == 600 and screenWidth == 800
        width = cols * 20 + 4 * (not isSmallWin)
        height = rows * 20 + 4 * (not isSmallWin)
        #creating dialog window
        self.win = ui.Window(self.app,
            modal = 1,
            escKeyClose = 1,
            movable = 0,
            title = _("Problems Locator"),
            titleOnly = isSmallWin,
            #rect = ui.Rect((screenWidth - width) / 2, ((screenHeight - height) / 2) * (not isSmallWin), width, height),
            rect = ui.Rect((screenWidth - 800 - 4 * (not isSmallWin)) / 2, (screenHeight - 600 - 4 * (not isSmallWin)) / 2, width, height),
            layoutManager = ui.SimpleGridLM(),
        )
        self.win.subscribeAction('*', self)
        # first row is window title
        rows -= 1

        ui.Listbox(self.win, layout = (0, 0, cols, rows - 2), id = 'vProblems',
            columns = [(_('System'), 'text', 10, ui.ALIGN_W),
            (_('Problem description'), 'vDescription', 30, ui.ALIGN_W)],
            columnLabels = 1, action='onShowSource', rmbAction='onShowLocation')

        btnWidth = 4
        ui.Check(self.win, layout = (btnWidth * 0, rows - 2, btnWidth, 1), id = 'vSystems',
            text = _('Systems'), action = 'onToggleCondition', checked = 1)
        ui.Check(self.win, layout = (btnWidth * 1, rows - 2, btnWidth, 1), id = 'vPlanets',
            text = _('Planets'), action = 'onToggleCondition', checked = 1)
        ui.Check(self.win, layout = (btnWidth * 2, rows - 2, btnWidth, 1), id = 'vFleets',
            text = _('Fleets'), action = 'onToggleCondition', checked = 1)
        ui.Check(self.win, layout = (btnWidth * 3, rows - 2, btnWidth, 1), id = 'vResearch',
            text = _('Research'), action = 'onToggleCondition', checked = 1)

        ui.Check(self.win, layout = (btnWidth * 6, rows - 2, btnWidth, 1), id = 'vCritical',
            text = _('Critical'), action = 'onToggleCondition', checked = 1)
        ui.Check(self.win, layout = (btnWidth * 7, rows - 2, btnWidth, 1), id = 'vMajor',
            text = _('Major'), action = 'onToggleCondition', checked = 1)
        ui.Check(self.win, layout = (btnWidth * 8, rows - 2, btnWidth, 1), id = 'vMinor',
            text = _('Minor'), action = 'onToggleCondition', checked = 1)
        ui.Check(self.win, layout = (btnWidth * 9, rows - 2, btnWidth, 1), id = 'vInfo',
            text = _('Info'), action = 'onToggleCondition', checked = 0)

        # dialog bottom line
        ui.Title(self.win, layout = (0, rows - 1, cols - 5, 1))
        ui.TitleButton(self.win, layout = (cols - 5, rows - 1, 5, 1), text = _("Close"), action = 'onClose')

ospaceteam / outerspace

Pull Request — master (#291)

ProblemsDlg._addProblemsFleets() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like
