def _researchContext(self, tech):
player = client.getPlayer()
descr = []
improvement = player.techs.get(self.techID, 0)
if hasattr(tech, 'researchMod'):
prefix = _('Improvement') if improvement else _('Research')
descr.append(
_('%s costs: %d') %
(prefix, Utils.getTechRCost(player, self.techID)))
descr.append('')
# requires
if tech.researchRequires and improvement == 0:
descr.append(_('Research requires:'))
for tmpTechID, improvement in tech.researchRequires:
tmpTech = client.getTechInfo(tmpTechID)
descr.append(
_(' - %s improvement %d (TL%d)') %
(tmpTech.name, improvement, tmpTech.level))
if hasattr(tech, "researchReqSRes"):
for stratRes in tech.researchReqSRes:
descr.append(
_(" - %s (strategic resource)") %
(gdata.stratRes[stratRes]))
descr.append('')
if hasattr(tech, "researchDisables") and tech.researchDisables:
descr.append(_("Research disables:"))
for tmpTechID in tech.researchDisables:
tmpTech = client.getTechInfo(tmpTechID)
descr.append(_(" - %s (TL%d)") % (tmpTech.name, tmpTech.level))
descr.append('')
return descr
def _designRepresentation(self, player):
if self.highlightedDesignID is None:
if self.editMode:
if self.ctrlID:
eqIDs = {self.ctrlID: 1}
else:
eqIDs = {}
for eqID in self.eqIDs:
eqIDs[eqID] = self.eqIDs[eqID]
improvements = []
else:
self.hullID = self.ctrlID = None
self.win.vName.text = ""
self.eqIDs = {}
eqIDs = {}
improvements = []
else:
spec = player.shipDesigns[self.highlightedDesignID]
self.hullID = spec.hullID
eqIDs = spec.eqIDs
improvements = spec.improvements
self.win.vName.text = spec.name
self.win.vHull.text = client.getTechInfo(self.hullID).name
self.eqIDs = {}
for eqID in eqIDs:
tech = client.getTechInfo(eqID)
if tech.subtype == "seq_ctrl":
self.ctrlID = eqID
self.win.vCtrl.text = tech.name
else:
self.eqIDs[eqID] = eqIDs[eqID]
try:
result = ShipUtils.makeShipFullSpec(player, None, self.hullID,
eqIDs, improvements)
if self.editMode:
self.win.vConstruct.enabled = 1
except GameException as e:
self.win.setStatus(e.args[0])
self.win.vConstruct.enabled = 0
try:
result = ShipUtils.makeShipFullSpec(player,
None,
self.hullID,
eqIDs,
improvements,
raiseExs=False)
except GameException:
result = None
else:
self.win.setStatus(_("Ready."))
return result
def showItems(self):
items = []
selected = None
player = client.getPlayer()
for techID in player.techs:
tech = client.getTechInfo(techID)
if getattr(tech, self.techType) == 0:
continue
if self.techSubtype and tech.subtype not in self.techSubtype:
continue
# skip equipment not suitable for this hull
if tech.minHull > self.hullType:
continue
if tech.maxHull < self.hullType:
continue
techType = self.getTechType(tech)
if self.typeFilter & techType == 0:
continue
item = ui.Item(tech.name,
tData=sequip.getLongDescr(techID),
techID=techID,
tType=typeText[techType])
if techID == self.selected:
selected = item
items.append(item)
self.win.vList.items = items
self.win.vList.itemsChanged()
self.win.vList.selectItem(selected)
def show(self):
player = client.getPlayer()
self.buildingsCount = {}
self.buildingsPos = {}
for planetID in player.planets:
planet = client.get(planetID)
if hasattr(planet, "slots"):
for struct in planet.slots:
techID = struct[STRUCT_IDX_TECHID]
if not techID in self.buildingsCount:
self.buildingsCount[techID] = 1
else:
self.buildingsCount[techID] = self.buildingsCount[techID] + 1
if not techID in self.buildingsPos:
self.buildingsPos[techID] = {planetID: 1}
else:
planetList = self.buildingsPos[techID]
if not planetID in planetList:
planetList[planetID] = 1
else:
planetList[planetID] = planetList[planetID] + 1
items = []
for techID in self.buildingsCount:
tech = client.getTechInfo(techID)
items.append(ui.Item(tech.name, tStructCount = self.buildingsCount[techID], techID = techID))
self.win.vStructures.items = items
self.win.vStructures.itemsChanged()
def _showStructures(self, prodProd):
items = []
for techID in client.getPlayer().techs.keys():
tech = client.getTechInfo(techID)
if not tech.isStructure or tech.level not in self.showLevels or \
(tech.isStructure and not self._filterStructure(tech)):
continue
if prodProd > 0:
etc = math.ceil(float(tech.buildProd) / prodProd)
if self.sourceID != self.planetID:
etc *= Rules.buildOnAnotherPlanetMod
etc = res.formatTime(etc)
else:
etc = _("N/A")
item = ui.Item(
etc,
techID=techID,
tIsShip=0,
name=tech.name,
tl=tech.level,
subtype=tech.subtype,
icons=((res.getTechImg(techID), ui.ALIGN_N), ),
font="small-bold",
align=ui.ALIGN_S,
tooltipTitle=_("Details"),
tooltip="%s, %d %s, %s %d" %
(tech.name, tech.buildProd, _("CP"), _("TL"), tech.level),
statustip="%s, %d %s, %s %d" %
(tech.name, tech.buildProd, _("CP"), _("TL"), tech.level))
self.maxTechLevel = max(self.maxTechLevel, tech.level)
items.append(item)
return items
def showSlots(self):
# techs
items = []
techs = {}
if self.showStructures:
player = client.getPlayer()
target = client.get(self.targetID, noUpdate=1)
if hasattr(target, 'slots') and target.owner == player.oid:
if len(target.slots) < target.plSlots:
item = ui.Item(_("Free slot"), techID=0)
items.append(item)
for struct in target.slots:
if not struct[Const.STRUCT_IDX_TECHID] in techs:
techs[struct[Const.STRUCT_IDX_TECHID]] = 1
else:
techs[struct[Const.STRUCT_IDX_TECHID]] += 1
for tech in techs.keys():
techInfo = client.getTechInfo(tech)
item = ui.Item("%s (%d)" % (techInfo.name, techs[tech]),
techID=tech)
items.append(item)
self.win.vTSlots.items = items
self.win.vTSlots.itemsChanged()
self.structToDemolish = Const.OID_NONE
def show(self):
tech = client.getTechInfo(self.techID)
self.win.title = _('Technology: %s (TL%d)') % (tech.name, tech.level)
# fill data
# fill description
descr = []
descr.extend(self._researchContext(tech))
if hasattr(tech, 'partialData') and hasattr(tech, 'textPreRsrch'):
# preresearch info
descr.extend(self._preResearch(tech))
elif not hasattr(tech, 'partialData'):
descr.extend(self._researchEnablement(tech))
descr.extend(self._productionDependency(tech))
descr.extend(self._stratResources(tech))
descr.extend(self._descriptionFlavor(tech))
if not len(descr):
descr.append(_('No information available'))
#
self.win.vDescr.text = descr
self._prepareTypeButtons(tech)
self.win.vData.items = self._processAttributes(tech)
self.win.vData.itemsChanged()
def showItems(self):
items = []
selected = None
player = client.getPlayer()
for techID in player.techs:
tech = client.getTechInfo(techID)
if getattr(tech, self.techType) == 0:
continue
if self.techSubtype and tech.subtype not in self.techSubtype:
continue
# skip equipment not suitable for this hull
if tech.minHull > self.hullType:
continue
if tech.maxHull < self.hullType:
continue
techType = self.getTechType(tech)
if self.typeFilter & techType == 0:
continue
item = ui.Item(tech.name, tData = sequip.getLongDescr(techID), techID = techID,
tType = typeText[techType])
if techID == self.selected:
selected = item
items.append(item)
self.win.vList.items = items
self.win.vList.itemsChanged()
self.win.vList.selectItem(selected)
def onConstruct(self, widget, action, data):
planet = client.get(self.planetID, noUpdate = 1)
player = client.getPlayer()
if not self.techID:
self.win.setStatus(_('Select technology to construct.'))
return
if not self.targetID:
self.win.setStatus(_('Select planet to construct on.'))
return
try:
self.quantity = int(self.win.vQuantity.text)
except ValueError:
self.win.setStatus(_('Specify quantity (1, 2, 3, ...).'))
return
# government centers have additional query and if confirmed, another round of this function is called
if self.techID < 1000:
tech = player.shipDesigns[self.techID]
else:
tech = client.getTechInfo(self.techID)
if not getattr(tech, 'govPwr', 0) == 0 and not self.govTransferConfirm:
# confirm dialog doesn't send through parameters, so we have to save them
self.govTransferData = (widget, action, data)
self.confirmDlg.display(_("Do you want to issue relocation of your government?"),
_("Yes"), _("No"), self.onGovTransferConfirmed)
else:
try:
self.win.setStatus(_('Executing START CONSTRUCTION command...'))
planet.prodQueue, player.stratRes = client.cmdProxy.startConstruction(self.planetID,
self.techID, self.quantity, self.targetID, self.techID < 1000,
self.win.vReportFin.checked, self.structToDemolish)
self.win.setStatus(_('Command has been executed.'))
except GameException, e:
self.win.setStatus(e.args[0])
return
def show(self):
player = client.getPlayer()
self.buildingsCount = {}
self.buildingsPos = {}
for planetID in player.planets:
planet = client.get(planetID)
if hasattr(planet, "slots"):
for struct in planet.slots:
techID = struct[STRUCT_IDX_TECHID]
if not techID in self.buildingsCount:
self.buildingsCount[techID] = 1
else:
self.buildingsCount[
techID] = self.buildingsCount[techID] + 1
if not techID in self.buildingsPos:
self.buildingsPos[techID] = {planetID: 1}
else:
planetList = self.buildingsPos[techID]
if not planetID in planetList:
planetList[planetID] = 1
else:
planetList[planetID] = planetList[planetID] + 1
items = []
for techID in self.buildingsCount:
tech = client.getTechInfo(techID)
items.append(
ui.Item(tech.name,
tStructCount=self.buildingsCount[techID],
techID=techID))
self.win.vStructures.items = items
self.win.vStructures.itemsChanged()
def _processProdQueue(self, planet):
player = client.getPlayer()
if planet.prodQueue and planet.effProdProd > 0:
index = 0
totalProd = 0
for task in planet.prodQueue:
if task.isShip:
tech = player.shipDesigns[task.techID]
else:
tech = client.getFullTechInfo(task.techID)
prodFirst, prodNext = self._getTaskProd(task, tech, planet.oid)
if index == 0:
constrInfo = tech.name
etc = math.ceil(float(prodFirst) / planet.effProdProd)
totalProd += prodFirst + prodNext
index += 1
etc = res.formatTime(etc)
totalEtc = res.formatTime(math.ceil(float(totalProd) / planet.effProdProd))
elif planet.prodQueue:
task = planet.prodQueue[0]
if task.isShip:
tech = player.shipDesigns[task.techID]
else:
tech = client.getTechInfo(task.techID)
constrInfo = tech.name
etc = _('N/A')
totalEtc = _("N/A")
else:
constrInfo = _("-")
etc = "-"
totalEtc = _("-")
return constrInfo, etc, totalEtc
def _showProjects(self):
items = []
for techID in client.getPlayer().techs.keys():
tech = client.getTechInfo(techID)
if tech.level not in self.showLevels or not tech.isProject:
continue
items.append(self._processNonShips(tech))
return items
def _detailComputedAttributes(self, player, result):
if result:
hull = client.getTechInfo(result.hullID)
self.win.vAClass.text = _(gdata.shipClasses[result.combatClass])
self.win.vASignature.text = _("%d") % result.signature
if result.speed == result.battleSpeed:
self.win.vSpeed.text = _("Speed")
self.win.vASpeed.text = _("%.2f") % result.speed
else:
self.win.vSpeed.text = _("Spd FTL (STL)")
self.win.vASpeed.text = _("%.2f (%.2f)") % (result.speed,
result.battleSpeed)
self.win.vAHP.text = _("%d - %d") % (
result.maxHP, result.shieldHP
) if result.shieldHP > 0 else _("%d") % result.maxHP
self.win.vAAttack.text = _("%d") % result.combatAtt
self.win.vADefence.text = _("%d / %d") % (result.combatDef,
result.missileDef)
self.win.vAPayload.text = _("%d") % (hull.maxWeight -
result.weight) if getattr(
hull, "maxWeight",
None) else _("N/A")
self.win.vASlots.text = _("%d") % (hull.slots -
result.slots) if hasattr(
hull, "slots") else _("N/A")
self.win.vATanks.text = _("%d") % result.storEn
if result.speed > 0 and result.operEn > 0:
support = result.storEn / result.operEn
self.win.vARange.text = _("%.2f") % (support * result.speed /
Rules.turnsPerDay)
else:
self.win.vARange.text = _("None")
self.win.vACCPts.text = _("%d") % result.buildProd
self.win.vACombatPwr.text = _("%d") % result.combatPwr
if self.highlightedDesignID and player.shipDesigns[
self.highlightedDesignID].upgradeTo:
self.win.vAUpgrade.text = player.shipDesigns[
player.shipDesigns[
self.highlightedDesignID].upgradeTo].name
self.win.vAUpgrade.font = "normal-italic"
else:
self.win.vAUpgrade.text = _("N/A")
self.win.vAUpgrade.font = "normal"
else:
self.win.vAClass.text = _("N/A")
self.win.vASignature.text = _("N/A")
self.win.vASpeed.text = _("N/A")
self.win.vAHP.text = _("N/A")
self.win.vAAttack.text = _("N/A")
self.win.vADefence.text = _("N/A")
self.win.vAPayload.text = _("N/A")
self.win.vASlots.text = _("N/A")
self.win.vATanks.text = _("N/A")
self.win.vARange.text = _("N/A")
self.win.vACCPts.text = _("N/A")
self.win.vACombatPwr.text = _("N/A")
self.win.vAUpgrade.text = _("N/A")
def _designRepresentation(self, player):
if self.highlightedDesignID is None:
if self.editMode:
if self.ctrlID:
eqIDs = {self.ctrlID : 1}
else:
eqIDs = {}
for eqID in self.eqIDs:
eqIDs[eqID] = self.eqIDs[eqID]
improvements = []
else:
self.hullID = self.ctrlID = None
self.win.vName.text = ""
self.eqIDs = {}
eqIDs = {}
improvements = []
else:
spec = player.shipDesigns[self.highlightedDesignID]
self.hullID = spec.hullID
eqIDs = spec.eqIDs
improvements = spec.improvements
self.win.vName.text = spec.name
self.win.vHull.text = client.getTechInfo(self.hullID).name
self.eqIDs = {}
for eqID in eqIDs:
tech = client.getTechInfo(eqID)
if tech.subtype == "seq_ctrl":
self.ctrlID = eqID
self.win.vCtrl.text = tech.name
else:
self.eqIDs[eqID] = eqIDs[eqID]
try:
result = ShipUtils.makeShipFullSpec(player, None, self.hullID, eqIDs, improvements)
if self.editMode:
self.win.vConstruct.enabled = 1
except GameException, e:
self.win.setStatus(e.args[0])
self.win.vConstruct.enabled = 0
try:
result = ShipUtils.makeShipFullSpec(player, None, self.hullID, eqIDs,
improvements, raiseExs = False)
except GameException:
result = None
def onConstruct(self, widget, action, data):
if not data:
self.win.setStatus(_('Select technology to construct.'))
return
if not self.sourceID:
self.sourceID = self.planetID
try:
self.quantity = int(self.win.vQuantity.text)
except ValueError:
self.win.setStatus(_('Specify quantity (1, 2, 3, ...).'))
return
# government centers have additional query and if confirmed, another round of this function is called
tech = client.getTechInfo(data.techID)
if tech.govPwr and not self.govTransferConfirm:
# confirm dialog doesn't send through parameters, so we have to save them
self.govTransferData = (widget, action, data)
self.confirmDlg.display(_("Do you want to issue relocation of your government?"),
_("Yes"), _("No"), self.onGovTransferConfirmed)
else:
try:
self.win.setStatus(_('Executing START CONSTRUCTION command...'))
planet = client.get(self.sourceID, noUpdate = 1)
player = client.getPlayer()
if self.extraSlot:
# check required special resources, if not available, do not continue
# (without check, server start slot expansion but not the tech)
specialResources = player.stratRes
for sr in tech.buildSRes:
if specialResources.get(sr, 0) < self.quantity:
self.win.setStatus(_('You do not own required strategic resource(s)'))
return
else:
specialResources[sr] = specialResources.get(sr, 0) - self.quantity
for i in range(1, self.quantity + 1):
# as we need two slots instead of one, check whether is task queue short
# enough (ie 8 tasks max)
if len(planet.prodQueue) > 8:
self.win.setStatus(_('Queue is full'))
return
client.cmdProxy.startConstruction(self.sourceID,
Rules.Tech.ADDSLOT3, 1, self.planetID, False,
self.win.vReportFin.checked, OID_NONE)
planet.prodQueue, player.stratRes = client.cmdProxy.startConstruction(self.sourceID,
data.techID, 1, self.planetID, data.techID < 1000,
self.win.vReportFin.checked, self.structToDemolish)
else:
planet.prodQueue, player.stratRes = client.cmdProxy.startConstruction(self.sourceID,
data.techID, self.quantity, self.planetID, data.techID < 1000,
self.win.vReportFin.checked, self.structToDemolish)
self.win.setStatus(_('Command has been executed.'))
except GameException, e:
self.win.setStatus(e.args[0])
return
def _getPlayerRace(self):
player = client.getPlayer()
raceChoosen = None
if player.techLevel == 1:
techID = set(player.techs).intersection(set(
[1990, 1991,
1992])).pop() # these are the race-selecting techs
raceChoosen = client.getTechInfo(techID).data
else:
raceChoosen = player.race
return raceChoosen
def _detailComputedAttributes(self, player, result):
if result:
hull = client.getTechInfo(result.hullID)
self.win.vAClass.text = _(gdata.shipClasses[result.combatClass])
self.win.vASignature.text = _("%d") % result.signature
if result.speed == result.battleSpeed:
self.win.vSpeed.text = _("Speed")
self.win.vASpeed.text = _("%.2f") % result.speed
else:
self.win.vSpeed.text = _("Spd FTL (STL)")
self.win.vASpeed.text = _("%.2f (%.2f)") % (result.speed, result.battleSpeed)
if result.shieldHP > 0:
self.win.vAHP.text = _("%d - %d") % (result.maxHP, result.shieldHP)
else:
self.win.vAHP.text = _("%d") % result.maxHP
self.win.vAAttack.text = _("%d") % result.combatAtt
self.win.vADefence.text = _("%d / %d") % (result.combatDef, result.missileDef)
if hasattr(hull, "maxWeight"):
self.win.vAPayload.text = _("%d") % (hull.maxWeight - result.weight)
else:
self.win.vAPayload.text = _("N/A")
if hasattr(hull, "slots"):
self.win.vASlots.text = _("%d") % (hull.slots - result.slots)
else:
self.win.vASlots.text = _("N/A")
self.win.vATanks.text = _("%d") % result.storEn
if result.speed > 0:
support = 10000000
if result.operEn > 0: support = min(support, result.storEn / result.operEn)
self.win.vARange.text = _("%.2f") % (support * result.speed / Rules.turnsPerDay)
else:
self.win.vARange.text = _("None")
self.win.vACCPts.text = _("%d") % result.buildProd
self.win.vACombatPwr.text = _("%d") % result.combatPwr
if self.highlightedDesignID and player.shipDesigns[self.highlightedDesignID].upgradeTo:
self.win.vAUpgrade.text = player.shipDesigns[player.shipDesigns[self.highlightedDesignID].upgradeTo].name
self.win.vAUpgrade.font = "normal-italic"
else:
self.win.vAUpgrade.text = _("N/A")
self.win.vAUpgrade.font = "normal"
else:
self.win.vAClass.text = _("N/A")
self.win.vASignature.text = _("N/A")
self.win.vASpeed.text = _("N/A")
self.win.vAHP.text = _("N/A")
self.win.vAAttack.text = _("N/A")
self.win.vADefence.text = _("N/A")
self.win.vAPayload.text = _("N/A")
self.win.vASlots.text = _("N/A")
self.win.vATanks.text = _("N/A")
self.win.vARange.text = _("N/A")
self.win.vACCPts.text = _("N/A")
self.win.vACombatPwr.text = _("N/A")
self.win.vAUpgrade.text = _("N/A")
def onSelectStruct(self, widget, action, data):
planetList = self.buildingsPos[data.techID]
tech = client.getTechInfo(data.techID)
self.win.vPlanetsTitle.text = _("Planets with structure %s") % tech.name
if planetList:
items = []
for planetID in planetList:
planet = client.get(planetID)
items.append(ui.Item(planet.name, tStructCount = planetList[planetID], planetID = planetID))
self.win.vPlanets.items = items
self.win.vPlanets.itemsChanged()
def onSelectStruct(self, widget, action, data):
planetList = self.buildingsPos[data.techID]
tech = client.getTechInfo(data.techID)
self.win.vPlanetsTitle.text = _("Planets with structure %s") % tech.name
if planetList:
items = []
for planetID in planetList:
planet = client.get(planetID)
items.append(ui.Item(planet.name, tStructCount = planetList[planetID], planetID = planetID))
self.win.vPlanets.items = items
self.win.vPlanets.itemsChanged()
def _showStructures(self):
items = []
for techID in client.getPlayer().techs.keys():
tech = client.getTechInfo(techID)
if not tech.isStructure or tech.level not in self.showLevels or \
(tech.isStructure and not self._filterStructure(tech)):
continue
items.append(self._processNonShips(tech))
return items
def _processResearchable(self, disabled, queued):
player = client.getPlayer()
items = []
for techID in client.getAllTechIDs():
if techID in player.techs or techID in queued or techID in disabled:
continue
tech = client.getTechInfo(techID)
if not hasattr(tech, 'partialData') or not hasattr(
tech, 'researchMod'):
continue
items.append(self._processResearchableTech(tech))
self.win.vRTechs.items = items
self.win.vRTechs.itemsChanged()
def _processProjects(self):
items = []
for techID in client.getPlayer().techs.keys():
tech = client.getTechInfo(techID)
if not tech.isProject or tech.globalDisabled or tech.level not in self.showLevels:
continue
item = ui.Item(tech.name,
tLevel=tech.level,
tProd=tech.buildProd,
techID=techID,
tIsShip=0)
items.append(item)
return items
def _processKnownTech(self):
player = client.getPlayer()
items = []
disabled = []
scheduledIDs = set([task.techID for task in player.rsrchQueue])
for techID in player.techs.keys():
if techID in player.obsoleteTechs and not self.showObsolete:
continue
tech = client.getTechInfo(techID)
improvement = player.techs[techID]
if improvement == tech.maxImprovement and not self.showCompleted:
continue
items.append(self._processImprovableTech(tech, scheduledIDs))
disabled.extend(tech.researchDisables)
self.win.vKTechs.items = items
self.win.vKTechs.itemsChanged()
return disabled
def showShip(self, techID, exp):
tech = client.getPlayer().shipDesigns[techID]
level = Rules.shipExpToLevel.get(int(exp / tech.baseExp),
Rules.shipDefLevel)
self.win.vShipModel.text = tech.name
self.win.vShipClass.text = _(gdata.shipClasses[tech.combatClass])
self.win.vShipAtt.text = int(tech.combatAtt *
Rules.shipLevelEff[level])
self.win.vShipDef.text = _("%d / %d") % (
int(tech.combatDef * Rules.shipLevelEff[level]),
int(tech.missileDef * Rules.shipLevelEff[level]),
)
self.win.vShipMaxSpeed.text = _("%.2f") % tech.speed
self.win.vShipScannerPwr.text = tech.scannerPwr
self.win.vShipSupport.text = _("%d + %d") % (
tech.operEn, int(tech.buildProd * Rules.operProdRatio))
info = _("Support: %d energy and %d contruction points per turn.") % (
tech.operEn, int(tech.buildProd * Rules.operProdRatio))
self.win.vShipSupport.statustip = info
self.win.vShipSupport.tooltip = info
self.win.vShipStorages.text = _("%d") % tech.storEn
self.win.vShipSignature.text = tech.signature
if tech.shieldHP > 0:
self.win.vShipMaxHP.text = _("%d + %d") % (
tech.maxHP,
tech.shieldHP,
)
else:
self.win.vShipMaxHP.text = _("%d") % (tech.maxHP, )
# show equipment
items = []
for techID in tech.eqIDs:
eq = client.getTechInfo(techID)
short = sequip.getShortDescr(techID)
long = sequip.getLongDescr(techID)
item = ui.Item(_("%d x %s") % (tech.eqIDs[techID], eq.name),
tData=short,
tooltip=long,
statustip=long)
items.append(item)
self.win.vShipEquipment.items = items
self.win.vShipEquipment.itemsChanged()
def _researchEnablement(self, tech):
descr = []
tmp = []
raceChoosen = self._getPlayerRace()
for improvement in range(1, 6):
for tmpTechID in tech.researchEnables[improvement]:
tmpTech = client.getTechInfo(tmpTechID)
racesDispl = ""
if 0 < len(tmpTech.researchRaces) < 3 and not raceChoosen:
racesDispl = _(", only for %s") % tmpTech.researchRaces
if not raceChoosen or not tmpTech.researchRaces or raceChoosen in tmpTech.researchRaces:
tmp.append(
_(' - %s (with improvement %d, on TL%d%s)') %
(tmpTech.name, improvement, tmpTech.level, racesDispl))
if tmp:
descr.append(_('Research/Improvement enables:'))
descr.extend(tmp)
descr.append('')
return descr
def _processResearchQueueTask(self, task):
player = client.getPlayer()
tech = client.getTechInfo(task.techID)
fulltech = client.getFullTechInfo(task.techID)
researchSci = Utils.getTechRCost(player, task.techID, task.improvement)
item = ui.Item(tech.name, techID=task.techID)
item.tooltipTitle = _("Details")
item.tooltip = _("Research points %d/%d, change %d pts/turn.") % (
task.currSci, researchSci, task.changeSci)
item.statustip = item.tooltip
item.tImpToMax = "*" if task.improveToMax else ""
item.tImproveToMax = task.improveToMax
item.tProgress = _("%d %%") % int(
task.currSci * 100 / researchSci) if task.currSci > 0 else _("-")
totalSci = 0
if task.changeSci > 0:
etc = float(researchSci - task.currSci) / max(
task.changeSci, player.effSciPoints)
totalSci += researchSci - task.currSci
if player.effSciPoints > 0:
item.tETC = res.formatTime(etc)
else:
item.tETC = res.getNA()
elif task.changeSci < 0:
etc = -float(task.currSci) / min(task.changeSci,
player.effSciPoints)
item.tETC = _("[%s]") % res.formatTime(etc)
elif player.effSciPoints > 0:
etc = float(researchSci) / player.effSciPoints
totalSci += researchSci
item.tETC = res.formatTime(etc)
else:
item.tETC = res.getNA()
if task.improveToMax:
for impr in range(task.improvement + 1,
fulltech.maxImprovement + 1):
totalSci += Utils.getTechRCost(player, task.techID, impr)
item.tLevel = _("%d-%d") % (tech.level, task.improvement)
return item, totalSci
def showShip(self, techID, exp):
tech = client.getPlayer().shipDesigns[techID]
level = Rules.shipExpToLevel.get(int(exp / tech.baseExp), Rules.shipDefLevel)
self.win.vShipModel.text = tech.name
self.win.vShipClass.text = _(gdata.shipClasses[tech.combatClass])
self.win.vShipAtt.text = int(tech.combatAtt * Rules.shipLevelEff[level])
self.win.vShipDef.text = _("%d / %d") % (
int(tech.combatDef * Rules.shipLevelEff[level]),
int(tech.missileDef * Rules.shipLevelEff[level]),
)
self.win.vShipMaxSpeed.text = _("%.2f") % tech.speed
self.win.vShipScannerPwr.text = tech.scannerPwr
self.win.vShipSupport.text = _("%d + %d") % (tech.operEn, int(tech.buildProd * Rules.operProdRatio))
info = _("Support: %d energy and %d contruction points per turn.") % (tech.operEn, int(tech.buildProd * Rules.operProdRatio))
self.win.vShipSupport.statustip = info
self.win.vShipSupport.tooltip = info
self.win.vShipStorages.text = _("%d") % tech.storEn
self.win.vShipSignature.text = tech.signature
if tech.shieldHP > 0:
self.win.vShipMaxHP.text = _("%d + %d") % (
tech.maxHP,
tech.shieldHP,
)
else:
self.win.vShipMaxHP.text = _("%d") % (
tech.maxHP,
)
# show equipment
items = []
for techID in tech.eqIDs:
eq = client.getTechInfo(techID)
short = sequip.getShortDescr(techID)
long = sequip.getLongDescr(techID)
item = ui.Item(_("%d x %s") % (tech.eqIDs[techID], eq.name),
tData = short, tooltip = long, statustip = long)
items.append(item)
self.win.vShipEquipment.items = items
self.win.vShipEquipment.itemsChanged()
def onConstruct(self, widget, action, data):
planet = client.get(self.planetID, noUpdate=1)
player = client.getPlayer()
if not self.techID:
self.win.setStatus(_('Select technology to construct.'))
return
if not self.targetID:
self.win.setStatus(_('Select planet to construct on.'))
return
try:
self.quantity = int(self.win.vQuantity.text)
except ValueError:
self.win.setStatus(_('Specify quantity (1, 2, 3, ...).'))
return
# government centers have additional query and if confirmed, another round of this function is called
if self.techID < 1000:
tech = player.shipDesigns[self.techID]
else:
tech = client.getTechInfo(self.techID)
if not getattr(tech, 'govPwr', 0) == 0 and not self.govTransferConfirm:
# confirm dialog doesn't send through parameters, so we have to save them
self.govTransferData = (widget, action, data)
self.confirmDlg.display(
_("Do you want to issue relocation of your government?"),
_("Yes"), _("No"), self.onGovTransferConfirmed)
else:
try:
self.win.setStatus(
_('Executing START CONSTRUCTION command...'))
planet.prodQueue, player.stratRes = client.cmdProxy.startConstruction(
self.planetID, self.techID, self.quantity, self.targetID,
self.techID < 1000, self.win.vReportFin.checked,
self.structToDemolish)
self.win.setStatus(_('Command has been executed.'))
except GameException, e:
self.win.setStatus(e.args[0])
return
def showSlots(self):
# techs
items = []
techs = {}
if self.showStructures:
player = client.getPlayer()
target = client.get(self.targetID, noUpdate = 1)
if hasattr(target, 'slots') and target.owner == player.oid:
if len(target.slots) < target.plSlots:
item = ui.Item(_("Free slot"), techID = 0)
items.append(item)
for struct in target.slots:
if not struct[STRUCT_IDX_TECHID] in techs:
techs[struct[STRUCT_IDX_TECHID]] = 1
else:
techs[struct[STRUCT_IDX_TECHID]] += 1
for tech in techs.keys():
techInfo = client.getTechInfo(tech)
item = ui.Item("%s (%d)" % (techInfo.name, techs[tech]), techID = tech)
items.append(item)
self.win.vTSlots.items = items
self.win.vTSlots.itemsChanged()
self.structToDemolish = OID_NONE
def showTechs(self):
# techs
items = []
select = None
showSmall = self.win.vSmall.checked
showMed = self.win.vMedium.checked
showLarge = self.win.vLarge.checked
showCivShip = self.win.vCivShip.checked
showMilShip = self.win.vMilShip.checked
for techID in client.getPlayer().techs.keys():
tech = client.getTechInfo(techID)
# hide pirate techs
if tech.level == 99:
continue
if tech.isStructure or tech.globalDisabled:
continue
etc = _("N/A")
item = ui.Item(
tech.name,
tLevel=tech.level,
tProd=tech.buildProd,
techID=techID,
tIsShip=0,
)
if item.tLevel > self.maxTechLevel:
self.maxTechLevel = item.tLevel
if item.tLevel in self.showLevels and \
(self.showOther and (tech.isProject)):
items.append(item)
if techID == self.techID:
select = item
# special handling for ships
player = client.getPlayer()
if self.showShips:
for designID in player.shipDesigns.keys():
tech = player.shipDesigns[designID]
if not ((tech.combatClass == 0 and showSmall) or
(tech.combatClass == 1 and showMed) or
(tech.combatClass == 2 and showLarge)):
continue
if not ((tech.isMilitary and showMilShip) or
(not tech.isMilitary and showCivShip)):
continue
if tech.upgradeTo != Const.OID_NONE:
# skip ships that are set to upgrade
continue
etc = _("N/A")
item = ui.Item(
tech.name,
tLevel=tech.level,
tProd=tech.buildProd,
techID=designID,
tIsShip=1,
)
items.append(item)
if designID == self.techID:
select = item
# sort it by level and then by name
items.sort(key=lambda a: (100 - a.tLevel, a.text))
self.win.vTechs.items = items
self.win.vTechs.itemsChanged()
self.win.vTechs.selectItem(select)
# filter
for i in xrange(1, 10):
widget = getattr(self.win, 'vLevel%d' % i)
if i in self.showLevels and i <= self.maxTechLevel:
widget.visible = 1
widget.pressed = 1
elif i not in self.showLevels and i <= self.maxTechLevel:
widget.visible = 1
widget.pressed = 0
else:
widget.visible = 0
self.win.vShipsToggle.pressed = self.showShips
self.win.vOtherToggle.pressed = self.showOther
# quantity
self.win.vQuantity.text = str(self.quantity)
def _detailEquipmentLists(self):
# design info
if self.hullID:
tech = client.getTechInfo(self.hullID)
self.win.vHull.text = tech.name # TODO _(tech.name)
elif self.editMode:
self.win.vHull.text = _("[Click to select]")
else:
self.win.vHull.text = ""
if self.ctrlID:
tech = client.getTechInfo(self.ctrlID)
self.win.vCtrl.text = tech.name # TODO _(tech.name)
elif self.editMode:
self.win.vCtrl.text = _("[Click to select]")
else:
self.win.vCtrl.text = ""
# equipments
engines = []
weapons = []
equipment = []
selected = None
selected_type = None
for eqID in self.eqIDs:
tech = client.getTechInfo(eqID)
short = sequip.getShortDescr(eqID)
long = sequip.getLongDescr(eqID)
# cache has been introduced to let items preserve highlight information
if eqID in self.itemCache:
item = self.itemCache[eqID]
item.tNumber = self.eqIDs[eqID]
else:
item = ui.Item(tech.name, techID = eqID, tNumber = self.eqIDs[eqID],
tData = short, tooltipTitle = _("Details"), tooltip = long, statustip = long)
self.itemCache[eqID] = item
if eqID == self.selectedEqID:
selected = item
selected_type = tech.subtype
if tech.subtype == "seq_eng":
engines.append(item)
elif tech.subtype == "seq_wpn":
weapons.append(item)
elif tech.subtype in ["seq_mod", "seq_struct"]:
equipment.append(item)
self.win.vEngines.items = engines
self.win.vEngines.itemsChanged()
if selected_type == "seq_eng":
self.win.vEngines.selectItem(selected)
else:
self.win.vEngines.selectItem(None)
self.win.vWeapons.items = weapons
self.win.vWeapons.itemsChanged()
if selected_type == "seq_wpn":
self.win.vWeapons.selectItem(selected)
else:
self.win.vWeapons.selectItem(None)
self.win.vEquipment.items = equipment
self.win.vEquipment.itemsChanged()
if selected_type == "seq_mod":
self.win.vEquipment.selectItem(selected)
else:
self.win.vEquipment.selectItem(None)
def show(self):
player = client.getPlayer()
#
items = []
for planetID in client.db.keys():
planet = client.get(planetID, noUpdate=1)
# skip non-planets
if not hasattr(planet, "type") or planet.type != Const.T_PLANET:
continue
# shall be shown?
ok = 0
if hasattr(planet, 'owner'):
if self.showMine and planet.owner == player.oid:
ok = 1
if self.showOtherPlayers and planet.owner != Const.OID_NONE and \
planet.owner != player.oid:
ok = 1
if self.showColonizable and planet.owner == Const.OID_NONE and \
planet.plType not in ('G', 'A'):
ok = 1
if self.showUncolonizable and planet.plType in ('G', 'A'):
ok = 1
elif hasattr(planet, 'plType'):
if self.showColonizable and planet.plType not in ('G', 'A'):
ok = 1
if self.showUncolonizable and planet.plType in ('G', 'A'):
ok = 1
if not ok:
continue
# fill in data
#rel = Const.REL_UNDEF
maxNA = 999999
maxNone = 99999
ownerID = Const.OID_NONE
if hasattr(planet, 'owner'):
ownerID = planet.owner
#if planet.owner != Const.OID_NONE:
# rel = client.getRelationTo(planet.owner)
if planet.owner == Const.OID_NONE:
#else:
owner = _('[Nobody]')
if hasattr(planet, 'owner') and planet.owner == player.oid:
if planet.prodQueue and planet.effProdProd > 0:
index = 0
totalEtc = 0
for task in planet.prodQueue:
if task.isShip:
tech = client.getPlayer().shipDesigns[task.techID]
else:
tech = client.getFullTechInfo(task.techID)
if index == 0:
constrInfo = tech.name
# etc
if task.targetID != planetID:
if index == 0:
etc = math.ceil(
float(tech.buildProd *
Rules.buildOnAnotherPlanetMod -
task.currProd) / planet.effProdProd)
totalEtc += etc
totalEtc += math.ceil(
(task.quantity - 1) *
float(tech.buildProd *
Rules.buildOnAnotherPlanetMod) /
planet.effProdProd)
else:
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:
if index == 0:
etc = math.ceil(
float(tech.buildProd - task.currProd) /
planet.effProdProd)
totalEtc += etc
totalEtc += math.ceil(
(task.quantity - 1) *
float(tech.buildProd) / 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)
index += 1
etc_raw = etc
etc = res.formatTime(etc)
totalEtc_raw = totalEtc
totalEtc = res.formatTime(totalEtc)
elif planet.prodQueue:
task = planet.prodQueue[0]
if task.isShip:
tech = client.getPlayer().shipDesigns[task.techID]
else:
tech = client.getTechInfo(task.techID)
constrInfo = tech.name
etc = _('N/A')
etc_raw = maxNA
totalEtc = _("N/A")
totalEtc_raw = maxNA
elif planet.effProdProd > 0:
constrInfo = _("-")
etc = "-"
etc_raw = 0
totalEtc = _("-")
totalEtc_raw = 0
else:
constrInfo = _("-")
etc = "-"
etc_raw = maxNone
totalEtc = _("-")
totalEtc_raw = maxNone
else:
constrInfo = '?'
etc = '?'
etc_raw = maxNA
totalEtc = '?'
totalEtc_raw = maxNA
# used slots
if hasattr(planet, 'slots'):
freeSlots = planet.plSlots - len(planet.slots)
else:
freeSlots = '?'
# morale
if hasattr(planet, "morale"):
morale = int(planet.morale)
else:
morale = "?"
#
plType = gdata.planetTypes[getattr(planet, 'plType', None)]
# list item
item = ui.Item(
getattr(planet, 'name', res.getUnknownName()),
tPlType=_(plType),
tPlBio=getattr(planet, 'plBio', '?'),
tPlMin=getattr(planet, 'plMin', '?'),
tPlEn=getattr(planet, 'plEn', '?'),
tChangeBio=getattr(planet, 'changeBio', '?'),
tChangeEn=getattr(planet, 'changeEn', '?'),
tETC=etc,
tETC_raw=etc_raw,
tTotalETC=totalEtc,
tTotalETC_raw=totalEtc_raw,
tConstrInfo=constrInfo,
tFree=freeSlots,
tMorale=morale,
tSpace=getattr(planet, 'plSlots', '?'),
tDiam=getattr(planet, 'plDiameter', 0) / 1000,
tProd=getattr(planet, 'effProdProd', '?'),
tSci=getattr(planet, 'effProdSci', '?'),
tPlanetID=planetID,
#foreground = res.getFFColorCode(rel),
foreground=res.getPlayerColor(ownerID),
)
items.append(item)
self.win.vPlanets.items = items
self.win.vPlanets.itemsChanged()
# buttons
self.win.vMine.pressed = self.showMine
self.win.vOtherPlayers = self.showOtherPlayers
self.win.vColonizable = self.showColonizable
self.win.vUncolonizable = self.showUncolonizable
def showTechs(self):
# techs
items = []
select = None
showMilitary = self.win.vMilitary.checked
showBio = self.win.vBioProduction.checked
showEn = self.win.vEnProduction.checked
showCP = self.win.vCPProduction.checked
showRP = self.win.vRPProduction.checked
showMorale = self.win.vMorale.checked
showSmall = self.win.vSmall.checked
showMed = self.win.vMedium.checked
showLarge = self.win.vLarge.checked
showCivShip = self.win.vCivShip.checked
showMilShip = self.win.vMilShip.checked
for techID in client.getPlayer().techs.keys():
tech = client.getTechInfo(techID)
# hide pirate techs from ships and miscs view
if not self.showStructures and tech.level == 99:
continue
if tech.isStructure:
if (tech.isMilitary or getattr(tech, "prodBio", 0) > 0 or getattr(tech, "prodEnv", 0) > 0 or \
getattr(tech, "prodEn", 0) > 0 or getattr(tech, "prodProd", 0) > 0 or \
getattr(tech, "prodSci", 0) > 0 or getattr(tech, "moraleTrgt", 0) > 0):
if not ((tech.isMilitary and showMilitary) or \
((getattr(tech, "prodBio", 0) > 0 or getattr(tech, "prodEnv", 0) > 0) and showBio) or \
(getattr(tech, "prodEn", 0) > 0 and showEn) or \
(getattr(tech, "prodProd", 0) > 0 and showCP) or \
(getattr(tech, "prodSci", 0) > 0 and showRP) or \
(getattr(tech, "moraleTrgt", 0) > 0 and showMorale)):
continue
if self.prodProd > 0:
etc = math.ceil(float(tech.buildProd) / self.prodProd)
if self.targetID != self.planetID:
etc *= Rules.buildOnAnotherPlanetMod
etc = res.formatTime(etc)
else:
etc = _("N/A")
item = ui.Item(
tech.name,
tLevel=tech.level,
tProd=tech.buildProd,
techID=techID,
tIsShip=0,
tETC=etc,
)
if item.tLevel > self.maxTechLevel:
self.maxTechLevel = item.tLevel
if item.tLevel in self.showLevels and \
((self.showStructures and tech.isStructure) or \
(self.showOther and (tech.isProject))):
items.append(item)
if techID == self.techID:
select = item
# special handling for ships
player = client.getPlayer()
if self.showShips:
for designID in player.shipDesigns.keys():
tech = player.shipDesigns[designID]
if not ((tech.combatClass == 0 and showSmall) or
(tech.combatClass == 1 and showMed) or
(tech.combatClass == 2 and showLarge)):
continue
if not ((tech.isMilitary and showMilShip) or
(not tech.isMilitary and showCivShip)):
continue
if tech.upgradeTo != Const.OID_NONE:
# skip ships that are set to upgrade
continue
if self.prodProd > 0:
etc = res.formatTime(
math.ceil(float(tech.buildProd) / self.prodProd))
else:
etc = _("N/A")
item = ui.Item(
tech.name,
tLevel=tech.level,
tProd=tech.buildProd,
techID=designID,
tIsShip=1,
tETC=etc,
)
items.append(item)
if designID == self.techID:
select = item
# sort it by level and then by name
items.sort(key=lambda a: (100 - a.tLevel, a.text))
self.win.vTechs.items = items
self.win.vTechs.itemsChanged()
self.win.vTechs.selectItem(select)
# filter
for i in xrange(1, 10):
widget = getattr(self.win, 'vLevel%d' % i)
if i in self.showLevels and i <= self.maxTechLevel:
widget.visible = 1
widget.pressed = 1
elif i not in self.showLevels and i <= self.maxTechLevel:
widget.visible = 1
widget.pressed = 0
else:
widget.visible = 0
self.win.vStructuresToggle.pressed = self.showStructures
self.win.vShipsToggle.pressed = self.showShips
self.win.vOtherToggle.pressed = self.showOther
# targets
info = []
system = client.get(self.systemID, noUpdate=1)
select = None
if hasattr(system, 'planets'):
for planetID in system.planets:
planet = client.get(planetID, noUpdate=1)
owner = res.getUnknownName()
#rel = Const.REL_UNDEF
ownerID = Const.OID_NONE
if hasattr(planet, 'owner'):
ownerID = planet.owner
if planet.owner != Const.OID_NONE:
owner = client.get(planet.owner, noUpdate=1).name
#rel = client.getRelationTo(planet.owner)
else:
owner = _('[Nobody]')
if planet.plType in ("A", "G"):
color = gdata.sevColors[gdata.DISABLED]
else:
#color = res.getFFColorCode(rel)
color = res.getPlayerColor(ownerID)
plname = getattr(planet, 'name', res.getUnknownName())
item = ui.Item(
plname,
text_raw=getattr(planet, 'plEn', plname),
planetID=planetID,
plOwner=owner,
foreground=color,
)
info.append(item)
if planetID == self.targetID:
select = item
self.win.vTargets.items = info
self.win.vTargets.itemsChanged()
self.win.vTargets.selectItem(select)
# quantity
self.win.vQuantity.text = str(self.quantity)
def show(self):
player = client.getPlayer()
# title
self.win.vRQueueTitle.text = _('Research queue [%d pts/turn]') % (
player.effSciPoints,
)
self.win.title = _("Research [TL%d]") % player.techLevel
# Known techs
items = []
#~researchable = {}
disabled = []
taskIDs = {}
for task in player.rsrchQueue:
taskIDs[task.techID] = None
for techID in player.techs.keys():
tech = client.getTechInfo(techID)
improvement = player.techs[techID]
item = ui.Item(tech.name,
techID = techID,
tLevel = '%d-%d' % (tech.level, improvement),
tStruct = (' ', '*')[tech.isStructure],
tShip = (' ', '*')[tech.isShipEquip],
)
if improvement < Rules.techMaxImprovement and improvement < tech.maxImprovement:
neededSci = Utils.getTechRCost(player, techID)
if player.effSciPoints > 0:
item.tETC = res.formatTime(float(neededSci) / player.effSciPoints)
else:
item.tETC = _("N/A")
found = 0
if taskIDs.has_key(techID):
item.foreground = (0xd0, 0xd0, 0xd0)
else:
item.foreground = None
else:
item.tETC = res.getNA()
item.foreground = (0x80, 0x80, 0x80)
if not self.showCompleted:
# skip this item
continue
items.append(item)
disabled.extend(tech.researchDisables)
#~for improvement in range(1, improvement + 1):
#~ for techID in tech.researchEnables[improvement]:
#~ researchable[techID] = 1
self.win.vKTechs.items = items
self.win.vKTechs.itemsChanged()
# Research queue
items = []
index = 0
queueTechs = []
total = 0
for task in player.rsrchQueue:
tech = client.getTechInfo(task.techID)
fulltech = client.getFullTechInfo(task.techID)
queueTechs.append(task.techID)
item = ui.Item(tech.name, techID = task.techID, index = index)
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)
item.tooltip = _("Research points %d/%d, change %d pts/turn.") % (task.currSci, researchSci, task.changeSci)
item.statustip = item.tooltip
item.tImpToMax = ["", "*"][task.improveToMax]
item.tImproveToMax = task.improveToMax
if task.currSci > 0:
item.tProgress = _("%d %%") % int(task.currSci * 100 / researchSci)
else:
item.tProgress = _("-")
if task.changeSci > 0:
value = float(researchSci - task.currSci) / max(task.changeSci, player.effSciPoints)
total += int(value + 1)
if player.effSciPoints > 0:
total += float(maxImpTotalSci) / player.effSciPoints
item.tETC = res.formatTime(value)
else:
total = 0
item.tETC = res.getNA()
elif task.changeSci < 0:
value = - float(task.currSci) / min(task.changeSci, player.effSciPoints)
item.tETC = _("[%s]") % res.formatTime(value)
elif player.effSciPoints > 0:
value = float(researchSci) / player.effSciPoints
total += int(value + 1)
total += float(maxImpTotalSci) / player.effSciPoints
item.tETC = res.formatTime(value)
else:
item.tETC = res.getNA()
item.tLevel = _("%d-%d") % (tech.level, task.improvement)
items.append(item)
index += 1
self.win.vRQueue.items = items
self.win.vRQueue.itemsChanged()
self.win.vRQueueTop.enabled = 0
self.win.vRQueueUp.enabled = 0
self.win.vRQueueDown.enabled = 0
self.win.vRQueueAbort.enabled = 0
self.win.vRQueueRepat.enabled = 0
self.win.vRQueueRepat.pressed = 0
self.win.vRQueueInfo.enabled = 0
if total == 0:
self.win.vRTotal.text = _("N/A")
else:
self.win.vRTotal.text = res.formatTime(total)
# Researchable techs
items = []
for techID in client.getAllTechIDs():
if player.techs.has_key(techID) or techID in queueTechs \
or techID in disabled:
continue
# can check requirements
tech = client.getTechInfo(techID)
if not hasattr(tech, "partialData"):
continue
item = ui.Item(tech.name, tLevel = tech.level, techID = techID)
if hasattr(tech, 'isStructure'): item.tStruct = ('', '*')[tech.isStructure]
else: item.tStruct = ''
if hasattr(tech, 'isShipEquip'): item.tShip = ('', '*')[tech.isShipEquip]
else: item.tShip = ''
if hasattr(tech, 'researchMod'):
neededSci = Utils.getTechRCost(player, techID)
if player.effSciPoints > 0:
item.tETC = res.formatTime(float(neededSci) / player.effSciPoints)
else:
item.tETC = _("N/A")
item.foreground = None
else:
item.tSci = res.getNA()
item.foreground = (0xc0, 0xc0, 0xc0)
# skip this item
continue
if hasattr(tech, "researchDisables") and tech.researchDisables:
item.foreground = (0xff, 0xff, 0x00)
if client.getFullTechInfo(techID).finishResearchHandler == TechHandlers.finishResTLAdvance:
item.foreground = gdata.sevColors[gdata.CRI]
items.append(item)
self.win.vRTechs.items = items
self.win.vRTechs.itemsChanged()
def show(self):
player = client.getPlayer()
if not hasattr(player.stats, "prodProd"):
self.win.vText.text = [_("No data available")]
self.win.vText.offsetRow = 0
self.win.vText.vertScrollbar.slider.position = 0
self.win.vText.vertScrollbar.slider.max = 1
return
text = []
# imperator or leader
if player.imperator == 1:
text.append(_("You are LEADER of the galaxy."))
text.append("")
elif player.imperator == 2:
text.append(_("You are IMPERATOR of the galaxy."))
text.append("")
elif player.imperator >= 3:
text.append(_("You are IMPERATOR of the galaxy."))
text.append(_("You have the right to end this galaxy."))
text.append("")
# strategic resources
# check ownership of the strat. resources
srChange = {}
for planetID in player.planets:
planet = client.get(planetID)
if planet.plStratRes:
sr = planet.plStratRes
srChange[sr] = srChange.get(sr, 0) + Rules.stratResAmountBig
if player.stratRes or srChange:
text.append(_("Strategic resources:"))
# merge owned and change
srList = player.stratRes.keys()
for sr in srChange:
if sr not in srList:
srList.append(sr)
srList.sort()
for sr in srList:
# srChange is printed as integer - assumption is there are only
# full generators of special resources (i.e. planets)
text.append(u' %s: %s (+%d)' % (
gdata.stratRes[sr],
player.stratRes.get(sr, 0) /
float(Rules.stratResAmountBig),
srChange.get(sr, 0) / float(Rules.stratResAmountBig),
))
text.append('')
# statistics
# compute some stats
realProd = 0
realSci = 0
for planetID in player.planets:
planet = client.get(planetID)
realProd += planet.effProdProd
realSci += planet.effProdSci
for fleetID in player.fleets:
fleet = client.get(fleetID)
# display data
text.append(_("Statistics:"))
text.append(u' %s: %s' %
(_("Population"), getattr(player.stats, "storPop", "?")))
if hasattr(
player.stats, "storPop"
) and player.govPwr > player.stats.storPop and player.stats.storPop > 0:
text.append(u' %s: %s (%d %% %s)' %
(_("Gov. power"), player.govPwr, 100 *
(player.govPwr - player.stats.storPop) /
player.govPwr, _("unused")))
else:
text.append(u' %s: %s' % (_("Gov. power"), player.govPwr))
text.append(u' %s: %s' %
(_("Planets"), getattr(player.stats, "planets", "?")))
text.append(u' %s: %s' %
(_("Structures"), getattr(player.stats, "structs", "?")))
text.append(
u' %s: %s' %
(_("Raw production"), getattr(player.stats, "prodProd", "?")))
text.append(u' %s: %d' % (_("Total production"), realProd))
text.append(u' %s: %s' %
(_("Raw research"), getattr(player.stats, "prodSci", "?")))
text.append(u' %s: %s' % (_("Total reseach"), player.effSciPoints))
text.append(
u' %s: %s' %
(_("Military power"), getattr(player.stats, "fleetPwr", "?")))
if hasattr(player, "pirateFame"):
text.append(u' %s: %s (%+d %% %s)' %
(_("Fame"), player.pirateFame, player.pirateFame,
_("production eff.")))
text.append(u' %s: %s fame' % (
_("New colony on planet with TL3 resouce cost"),
int(Rules.pirateTL3StratResColonyCostMod *
Rules.pirateColonyCostMod * len(player.planets)),
))
text.append(u' %s: %s fame' % (
_("New colony cost multiplier"),
int(Rules.pirateColonyCostMod * len(player.planets)),
))
text.append(
u' %s' %
(_("(hover over system/planet to view actual cost)"), ))
text.append("")
# Production
text.append(_("Production:"))
text.append(
u' %s: %s' %
(_("Raw production"), getattr(player.stats, "prodProd", "?")))
if player.prodIncreasePool > 0:
ratio = (Rules.unusedProdMod *
player.prodIncreasePool) / player.stats.prodProd
text.append(u' %s: %d (%+d %% %s)' %
(_("Unused production"), player.prodIncreasePool,
min(ratio * 100,
math.sqrt(ratio) * 100), _("effectivity")))
# fleet support
total = getattr(player.stats, 'fleetSupportProd',
0) + player.fleetUpgradePool * Rules.operProdRatio
if total > player.stats.prodProd / 10:
effectivity = -100 * (total - player.stats.prodProd / 10) / max(
player.stats.prodProd, 1)
else:
effectivity = 0
text.append(
u' %s: %+d (%s %d %s, %+d %% %s)' %
(_("Fleet support"), -total, _("first"), player.stats.prodProd /
10, _("CP is free"), effectivity, _("effectivity")))
text.append(u" %s: %d %%" %
(_("Empire effectivity"), int(100 * player.prodEff)))
text.append(u' %s: %d' % (_("Total production"), realProd))
text.append("")
# Research
text.append(_("Research:"))
text.append(u" %s: %d %%" %
(_("Empire effectivity"), int(100 * player.sciEff)))
if hasattr(player.stats, "prodSci"):
text.append(
u" %s: %s" %
(_("Raw production"), getattr(player.stats, "prodSci", "?")))
text.append(u' %s: %s' % (_("Real production"), realSci))
if player.techLevel < 7:
popSupp = int(player.stats.storPop *
Rules.sciPtsPerCitizen[player.techLevel])
else:
popSupp = 0
text.append(u' %s: %+d' % (_("Population support"), -popSupp))
text.append(u' %s: %+d' % (_("From pacts"), player.effSciPoints +
popSupp - player.sciPoints))
text.append(u' %s: %d' % (_("Total research"), player.effSciPoints))
text.append("")
# Fleet
civ = [0, 0, 0, 0]
mil = [0, 0, 0, 0]
mp = [0, 0, 0, 0]
for fleetID in player.fleets:
fleet = client.get(fleetID)
for designID, hp, shield, exp in fleet.ships:
tech = player.shipDesigns[designID]
if tech.isMilitary:
mil[tech.combatClass] += 1
else:
civ[tech.combatClass] += 1
mp[tech.combatClass] += int(tech.combatPwr *
float(hp + shield) /
(tech.maxHP + tech.shieldHP))
text.append(_("Fleet:"))
text.append(u' %s: %d (%d %s)' %
(_("Upgrade Pool"), player.fleetUpgradePool,
-player.fleetUpgradePool * Rules.operProdRatio,
_("CP to support")))
text.append(u' %s: %d %s + %d %s, %d %s' %
(_("Small ships"), civ[0], _("civ"), mil[0], _("mil"),
mp[0], _("MP")))
text.append(u' %s: %d %s + %d %s, %d %s' %
(_("Medium ships"), civ[1], _("civ"), mil[1], _("mil"),
mp[1], _("MP")))
text.append(u' %s: %d %s + %d %s, %d %s' %
(_("Large ships"), civ[2], _("civ"), mil[2], _("mil"),
mp[2], _("MP")))
# Planetary Weapons
weapons = player.planetWeapons
if weapons[0] or weapons[1] or weapons[2]:
text.append("")
text.append(u'Planetary Weapons:')
if weapons[0] != None:
if weapons[0] in player.techs.keys():
tech = client.getTechInfo(weapons[0])
sweapon = tech.name
text.append(u' Anti-small: %s' % sweapon)
if weapons[1] != None:
if weapons[1] in player.techs.keys():
tech = client.getTechInfo(weapons[1])
mweapon = tech.name
text.append(u' Anti-medium: %s' % mweapon)
if weapons[2] != None:
if weapons[2] in player.techs.keys():
tech = client.getTechInfo(weapons[2])
lweapon = tech.name
text.append(u' Anti-large: %s' % lweapon)
self.win.vText.text = text
self.win.vText.offsetRow = 0
self.win.vText.vertScrollbar.slider.position = 0
self.win.vText.vertScrollbar.slider.max = len(text)
def showTechs(self):
# techs
items = []
select = None
showSmall = self.win.vSmall.checked
showMed = self.win.vMedium.checked
showLarge = self.win.vLarge.checked
showCivShip = self.win.vCivShip.checked
showMilShip = self.win.vMilShip.checked
for techID in client.getPlayer().techs.keys():
tech = client.getTechInfo(techID)
# hide pirate techs
if tech.level == 99:
continue
if tech.isStructure or tech.globalDisabled:
continue
etc = _("N/A")
item = ui.Item(tech.name,
tLevel = tech.level,
tProd = tech.buildProd,
techID = techID,
tIsShip = 0,
)
if item.tLevel > self.maxTechLevel:
self.maxTechLevel = item.tLevel
if item.tLevel in self.showLevels and \
(self.showOther and (tech.isProject)):
items.append(item)
if techID == self.techID:
select = item
# special handling for ships
player = client.getPlayer()
if self.showShips:
for designID in player.shipDesigns.keys():
tech = player.shipDesigns[designID]
if not ((tech.combatClass == 0 and showSmall) or (tech.combatClass == 1 and showMed) or (tech.combatClass == 2 and showLarge)):
continue
if not ((tech.isMilitary and showMilShip) or (not tech.isMilitary and showCivShip)):
continue
if tech.upgradeTo != OID_NONE:
# skip ships that are set to upgrade
continue
etc = _("N/A")
item = ui.Item(tech.name,
tLevel = tech.level,
tProd = tech.buildProd,
techID = designID,
tIsShip = 1,
)
items.append(item)
if designID == self.techID:
select = item
# sort it by level and then by name
items.sort(lambda a, b: cmp((100 - a.tLevel, a.text), (100 - b.tLevel, b.text)))
self.win.vTechs.items = items
self.win.vTechs.itemsChanged()
self.win.vTechs.selectItem(select)
# filter
for i in xrange(1, 10):
widget = getattr(self.win, 'vLevel%d' % i)
if i in self.showLevels and i <= self.maxTechLevel:
widget.visible = 1
widget.pressed = 1
elif i not in self.showLevels and i <= self.maxTechLevel:
widget.visible = 1
widget.pressed = 0
else:
widget.visible = 0
self.win.vShipsToggle.pressed = self.showShips
self.win.vOtherToggle.pressed = self.showOther
# quantity
self.win.vQuantity.text = str(self.quantity)
def show(self):
player = client.getPlayer()
if not hasattr(player.stats, "prodProd"):
self.win.vText.text = [_("No data available")]
self.win.vText.offsetRow = 0
self.win.vText.vertScrollbar.slider.position = 0
self.win.vText.vertScrollbar.slider.max = 1
return
text = []
# imperator or leader
if player.imperator == 1:
text.append(_("You are LEADER of the galaxy."))
text.append("")
elif player.imperator == 2:
text.append(_("You are IMPERATOR of the galaxy."))
text.append("")
elif player.imperator >= 3:
text.append(_("You are IMPERATOR of the galaxy."))
text.append(_("You have the right to end this galaxy."))
text.append("")
# strategic resources
# check ownership of the strat. resources
srChange = {}
for planetID in player.planets:
planet = client.get(planetID)
if planet.plStratRes:
sr = planet.plStratRes
srChange[sr] = srChange.get(sr, 0) + 1
if player.stratRes or srChange:
text.append(_("Strategic resources:"))
# merge owned and change
srList = player.stratRes.keys()
for sr in srChange:
if sr not in srList:
srList.append(sr)
srList.sort()
for sr in srList:
text.append(u' %s: %s (+%d)' % (
gdata.stratRes[sr],
player.stratRes.get(sr, 0),
srChange.get(sr, 0),
))
text.append('')
# statistics
# compute some stats
realProd = 0
realSci = 0
for planetID in player.planets:
planet = client.get(planetID)
realProd += planet.effProdProd
realSci += planet.effProdSci
for fleetID in player.fleets:
fleet = client.get(fleetID)
# display data
text.append(_("Statistics:"))
text.append(u' %s: %s' % (_("Population"), getattr(player.stats, "storPop", "?")))
if hasattr(player.stats, "storPop") and player.govPwr > player.stats.storPop and player.stats.storPop > 0:
text.append(u' %s: %s (%d %% %s)' % (_("Gov. power"), player.govPwr, 100 * (player.govPwr - player.stats.storPop) / player.govPwr, _("unused")))
else:
text.append(u' %s: %s' % (_("Gov. power"), player.govPwr))
text.append(u' %s: %s' % (_("Planets"), getattr(player.stats, "planets", "?")))
text.append(u' %s: %s' % (_("Structures"), getattr(player.stats, "structs", "?")))
text.append(u' %s: %s' % (_("Raw production"), getattr(player.stats, "prodProd", "?")))
text.append(u' %s: %d' % (_("Total production"), realProd))
text.append(u' %s: %s' % (_("Raw research"), getattr(player.stats, "prodSci", "?")))
text.append(u' %s: %s' % (_("Total reseach"), player.effSciPoints))
text.append(u' %s: %s' % (_("Military power"), getattr(player.stats, "fleetPwr", "?")))
if hasattr(player, "pirateFame"):
text.append(u' %s: %s (%+d %% %s)' % (
_("Fame"),
player.pirateFame,
player.pirateFame,
_("production eff.")
))
text.append(u' %s: %s fame' % (
_("New colony on planet with TL3 resouce cost"),
int(Rules.pirateTL3StratResColonyCostMod * Rules.pirateColonyCostMod * len(player.planets)),
))
text.append(u' %s: %s fame' % (
_("New colony cost multiplier"),
int(Rules.pirateColonyCostMod * len(player.planets)),
))
text.append(u' %s' % (
_("(hover over system/planet to view actual cost)"),
))
text.append("")
# Production
text.append(_("Production:"))
text.append(u' %s: %s' % (_("Raw production"), getattr(player.stats, "prodProd", "?")))
if player.prodIncreasePool > 0:
ratio = (Rules.unusedProdMod * player.prodIncreasePool) / player.stats.prodProd
text.append(u' %s: %d (%+d %% %s)' % (
_("Unused production"), player.prodIncreasePool, min(ratio * 100, math.sqrt(ratio) * 100), _("effectivity")
))
# fleet support
total = getattr(player.stats, 'fleetSupportProd', 0) + player.fleetUpgradePool * Rules.operProdRatio
if total > player.stats.prodProd / 10:
effectivity = - 100 * (total - player.stats.prodProd / 10) / max(player.stats.prodProd, 1)
else:
effectivity = 0
text.append(u' %s: %+d (%s %d %s, %+d %% %s)' % (
_("Fleet support"),
- total,
_("first"),
player.stats.prodProd / 10,
_("CP is free"),
effectivity,
_("effectivity")
))
text.append(u" %s: %d %%" % (_("Empire effectivity"), int(100 * player.prodEff)))
text.append(u' %s: %d' % (_("Total production"), realProd))
text.append("")
# Research
text.append(_("Research:"))
text.append(u" %s: %d %%" % (_("Empire effectivity"), int(100 * player.sciEff)))
if hasattr(player.stats, "prodSci"):
text.append(u" %s: %s" % (_("Raw production"), getattr(player.stats, "prodSci", "?")))
text.append(u' %s: %s' % (_("Real production"), realSci))
if player.techLevel < 7:
popSupp = int(player.stats.storPop * Rules.sciPtsPerCitizen[player.techLevel])
else:
popSupp = 0
text.append(u' %s: %+d' % (_("Population support"), -popSupp))
text.append(u' %s: %+d' % (_("From pacts"), player.effSciPoints + popSupp - player.sciPoints))
text.append(u' %s: %d' % (_("Total research"), player.effSciPoints))
text.append("")
# Fleet
civ = [0, 0, 0, 0]
mil = [0, 0, 0, 0]
mp = [0, 0, 0, 0]
for fleetID in player.fleets:
fleet = client.get(fleetID)
for designID, hp, shield, exp in fleet.ships:
tech = player.shipDesigns[designID]
if tech.isMilitary:
mil[tech.combatClass] += 1
else:
civ[tech.combatClass] += 1
mp[tech.combatClass] += int(tech.combatPwr * float(hp + shield) / (tech.maxHP + tech.shieldHP))
text.append(_("Fleet:"))
text.append(u' %s: %d (%d %s)' % (_("Upgrade Pool"), player.fleetUpgradePool, - player.fleetUpgradePool * Rules.operProdRatio,_("CP to support")))
text.append(u' %s: %d %s + %d %s, %d %s' % (_("Small ships"), civ[0], _("civ"), mil[0], _("mil"), mp[0],_("MP")))
text.append(u' %s: %d %s + %d %s, %d %s' % (_("Medium ships"), civ[1], _("civ"), mil[1], _("mil"), mp[1],_("MP")))
text.append(u' %s: %d %s + %d %s, %d %s' % (_("Large ships"), civ[2], _("civ"), mil[2], _("mil"), mp[2],_("MP")))
# Planetary Weapons
weapons = player.planetWeapons
if weapons[0] or weapons[1] or weapons[2]:
text.append("")
text.append(u'Planetary Weapons:')
if weapons[0] != None:
if weapons[0] in player.techs.keys():
tech = client.getTechInfo(weapons[0])
sweapon = tech.name
text.append(u' Anti-small: %s' % sweapon)
if weapons[1] != None:
if weapons[1] in player.techs.keys():
tech = client.getTechInfo(weapons[1])
mweapon = tech.name
text.append(u' Anti-medium: %s' % mweapon)
if weapons[2] != None:
if weapons[2] in player.techs.keys():
tech = client.getTechInfo(weapons[2])
lweapon = tech.name
text.append(u' Anti-large: %s' % lweapon)
self.win.vText.text = text
self.win.vText.offsetRow = 0
self.win.vText.vertScrollbar.slider.position = 0
self.win.vText.vertScrollbar.slider.max = len(text)
def showTechs(self):
# techs
items = []
select = None
showMilitary = self.win.vMilitary.checked
showBio = self.win.vBioProduction.checked
showEn = self.win.vEnProduction.checked
showCP = self.win.vCPProduction.checked
showRP = self.win.vRPProduction.checked
showMorale = self.win.vMorale.checked
for techID in client.getPlayer().techs.keys():
tech = client.getTechInfo(techID)
if not ((tech.isMilitary and showMilitary) or \
((getattr(tech, "prodBio", 0) > 0 or getattr(tech, "prodEnv", 0) > 0) and showBio) or \
(getattr(tech, "prodEn", 0) > 0 and showEn) or \
(getattr(tech, "prodProd", 0) > 0 and showCP) or \
(getattr(tech, "prodSci", 0) > 0 and showRP) or \
(getattr(tech, "moraleTrgt", 0) > 0 and showMorale)):
continue
sourcePlanet = client.get(self.sourceID, noUpdate = 1)
prodProd = getattr(sourcePlanet, "effProdProd", 0)
if prodProd > 0:
etc = math.ceil(float(tech.buildProd) / prodProd)
if self.sourceID != self.planetID:
etc *= Rules.buildOnAnotherPlanetMod
etc = res.formatTime(etc)
else:
etc = _("N/A")
item = ui.Item(etc,
techID = techID,
tIsShip = 0,
name = tech.name,
tl = tech.level,
subtype = tech.subtype,
icons = ((res.getTechImg(techID), ui.ALIGN_N),),
font = "small-bold",
align = ui.ALIGN_S,
tooltip = "%s, %d %s, %s %d" % (tech.name, tech.buildProd,_("CP"),_("TL"), tech.level),
statustip = "%s, %d %s, %s %d" % (tech.name, tech.buildProd,_("CP"),_("TL"), tech.level),
)
if tech.level > self.maxTechLevel:
self.maxTechLevel = tech.level
# TODO FIX ME
if tech.level in self.showLevels and \
((self.showStructures and tech.isStructure) or \
(self.showOther and (tech.isProject))) or tech.level == 99:
items.append(item)
if techID == self.techID:
select = item
# sort methods
if self.sort == 'none': # sort by name
items.sort(lambda a, b: cmp(a.name, b.name))
elif self.sort == 'tl': # sort by TL, subsort by name
items.sort(lambda a, b: cmp(a.name, b.name))
items.sort(lambda a, b: cmp(a.tl, b.tl))
elif self.sort == 'type': #sort by subtype, subsort by tl
items.sort(lambda a, b: cmp(a.tl, b.tl))
items.sort(lambda a, b: cmp(a.subtype, b.subtype))
self.win.vTechs.items = items
self.win.vTechs.itemsChanged()
if select:
self.win.vTechs.selectItem(select)
# filter
for i in xrange(1, 10):
widget = getattr(self.win, 'vLevel%d' % i)
if i in self.showLevels and i <= self.maxTechLevel:
widget.visible = 1
widget.pressed = 1
elif i not in self.showLevels and i <= self.maxTechLevel:
widget.visible = 1
widget.pressed = 0
else:
widget.visible = 0
# quantity
self.win.vQuantity.text = str(self.quantity)
def show(self):
player = client.getPlayer()
# title
self.win.vRQueueTitle.text = _('Research queue [%d pts/turn]') % (
player.effSciPoints,
)
self.win.title = _("Research [TL%d]") % player.techLevel
# Known techs
items = []
#~researchable = {}
disabled = []
taskIDs = {}
for task in player.rsrchQueue:
taskIDs[task.techID] = None
for techID in player.techs.keys():
if techID in player.obsoleteTechs and not self.showObsolete:
continue
tech = client.getTechInfo(techID)
improvement = player.techs[techID]
item = ui.Item(tech.name,
techID = techID,
tLevel = '%d-%d' % (tech.level, improvement),
tStruct = (' ', '*')[tech.isStructure],
tShip = (' ', '*')[tech.isShipEquip],
)
if improvement < Rules.techMaxImprovement and improvement < tech.maxImprovement:
neededSci = Utils.getTechRCost(player, techID)
if player.effSciPoints > 0:
item.tETC = res.formatTime(float(neededSci) / player.effSciPoints)
else:
item.tETC = _("N/A")
found = 0
if taskIDs.has_key(techID):
item.foreground = (0xd0, 0xd0, 0xd0)
else:
item.foreground = None
else:
item.tETC = res.getNA()
item.foreground = (0x80, 0x80, 0x80)
if not self.showCompleted:
# skip this item
continue
if techID in player.obsoleteTechs:
item.foreground = (0x80, 0x40, 0x40)
items.append(item)
disabled.extend(tech.researchDisables)
#~for improvement in range(1, improvement + 1):
#~ for techID in tech.researchEnables[improvement]:
#~ researchable[techID] = 1
self.win.vKTechs.items = items
self.win.vKTechs.itemsChanged()
# Research queue
items = []
index = 0
queueTechs = []
total = 0
for task in player.rsrchQueue:
tech = client.getTechInfo(task.techID)
fulltech = client.getFullTechInfo(task.techID)
queueTechs.append(task.techID)
item = ui.Item(tech.name, techID = task.techID, index = index)
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)
item.tooltipTitle = _("Details")
item.tooltip = _("Research points %d/%d, change %d pts/turn.") % (task.currSci, researchSci, task.changeSci)
item.statustip = item.tooltip
item.tImpToMax = ["", "*"][task.improveToMax]
item.tImproveToMax = task.improveToMax
if task.currSci > 0:
item.tProgress = _("%d %%") % int(task.currSci * 100 / researchSci)
else:
item.tProgress = _("-")
if task.changeSci > 0:
value = float(researchSci - task.currSci) / max(task.changeSci, player.effSciPoints)
total += int(value + 1)
if player.effSciPoints > 0:
total += float(maxImpTotalSci) / player.effSciPoints
item.tETC = res.formatTime(value)
else:
total = 0
item.tETC = res.getNA()
elif task.changeSci < 0:
value = - float(task.currSci) / min(task.changeSci, player.effSciPoints)
item.tETC = _("[%s]") % res.formatTime(value)
elif player.effSciPoints > 0:
value = float(researchSci) / player.effSciPoints
total += int(value + 1)
total += float(maxImpTotalSci) / player.effSciPoints
item.tETC = res.formatTime(value)
else:
item.tETC = res.getNA()
item.tLevel = _("%d-%d") % (tech.level, task.improvement)
items.append(item)
index += 1
self.win.vRQueue.items = items
self.win.vRQueue.itemsChanged()
self.win.vRQueueTop.enabled = 0
self.win.vRQueueUp.enabled = 0
self.win.vRQueueDown.enabled = 0
self.win.vRQueueAbort.enabled = 0
self.win.vRQueueRepat.enabled = 0
self.win.vRQueueRepat.pressed = 0
self.win.vRQueueInfo.enabled = 0
if total == 0:
self.win.vRTotal.text = _("N/A")
else:
self.win.vRTotal.text = res.formatTime(total)
# Researchable techs
items = []
for techID in client.getAllTechIDs():
if player.techs.has_key(techID) or techID in queueTechs \
or techID in disabled:
continue
# can check requirements
tech = client.getTechInfo(techID)
if not hasattr(tech, "partialData"):
continue
item = ui.Item(tech.name, tLevel = tech.level, techID = techID)
if hasattr(tech, 'isStructure'): item.tStruct = ('', '*')[tech.isStructure]
else: item.tStruct = ''
if hasattr(tech, 'isShipEquip'): item.tShip = ('', '*')[tech.isShipEquip]
else: item.tShip = ''
if hasattr(tech, 'researchMod'):
neededSci = Utils.getTechRCost(player, techID)
if player.effSciPoints > 0:
item.tETC = res.formatTime(float(neededSci) / player.effSciPoints)
else:
item.tETC = _("N/A")
item.foreground = None
else:
item.tSci = res.getNA()
item.foreground = (0xc0, 0xc0, 0xc0)
# skip this item
continue
if hasattr(tech, "researchDisables") and tech.researchDisables:
item.foreground = (0xff, 0xff, 0x00)
if client.getFullTechInfo(techID).finishResearchHandler == TechHandlers.finishResTLAdvance:
item.foreground = gdata.sevColors[gdata.CRI]
items.append(item)
self.win.vRTechs.items = items
self.win.vRTechs.itemsChanged()
def show(self):
player = client.getPlayer()
#
items = []
for planetID in client.db.keys():
planet = client.get(planetID, noUpdate = 1)
# skip non-planets
if not hasattr(planet, "type") or planet.type != T_PLANET:
continue
# shall be shown?
ok = 0
if hasattr(planet, 'owner'):
if self.showMine and planet.owner == player.oid:
ok = 1
if self.showOtherPlayers and planet.owner != OID_NONE and \
planet.owner != player.oid:
ok = 1
if self.showColonizable and planet.owner == OID_NONE and \
planet.plType not in ('G', 'A'):
ok = 1
if self.showUncolonizable and planet.plType in ('G', 'A'):
ok = 1
elif hasattr(planet, 'plType'):
if self.showColonizable and planet.plType not in ('G', 'A'):
ok = 1
if self.showUncolonizable and planet.plType in ('G', 'A'):
ok = 1
if not ok:
continue
# fill in data
#rel = REL_UNDEF
maxNA = 999999
maxNone = 99999
ownerID = OID_NONE
if hasattr(planet, 'owner'):
ownerID = planet.owner
#if planet.owner != OID_NONE:
# rel = client.getRelationTo(planet.owner)
if planet.owner == OID_NONE:
#else:
owner = _('[Nobody]')
if hasattr(planet, 'owner') and planet.owner == player.oid:
if planet.prodQueue and planet.effProdProd > 0:
index = 0
totalEtc = 0
for task in planet.prodQueue:
if task.isShip:
tech = client.getPlayer().shipDesigns[task.techID]
else:
tech = client.getFullTechInfo(task.techID)
if index == 0:
constrInfo = tech.name
# etc
if task.targetID != planetID:
if index == 0:
etc = math.ceil(float(tech.buildProd * Rules.buildOnAnotherPlanetMod - task.currProd) / planet.effProdProd)
totalEtc += etc
totalEtc += math.ceil((task.quantity - 1) * float(tech.buildProd * Rules.buildOnAnotherPlanetMod) / planet.effProdProd)
else:
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:
if index == 0:
etc = math.ceil(float(tech.buildProd - task.currProd) / planet.effProdProd)
totalEtc += etc
totalEtc += math.ceil((task.quantity - 1)* float(tech.buildProd) / 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)
index += 1
etc_raw = etc
etc = res.formatTime(etc)
totalEtc_raw = totalEtc
totalEtc = res.formatTime(totalEtc)
elif planet.prodQueue:
task = planet.prodQueue[0]
if task.isShip:
tech = client.getPlayer().shipDesigns[task.techID]
else:
tech = client.getTechInfo(task.techID)
constrInfo = tech.name
etc = _('N/A')
etc_raw = maxNA
totalEtc = _("N/A")
totalEtc_raw = maxNA
elif planet.effProdProd > 0:
constrInfo = _("-")
etc = "-"
etc_raw = 0
totalEtc = _("-")
totalEtc_raw = 0
else:
constrInfo = _("-")
etc = "-"
etc_raw = maxNone
totalEtc = _("-")
totalEtc_raw = maxNone
else:
constrInfo = '?'
etc = '?'
etc_raw = maxNA
totalEtc = '?'
totalEtc_raw = maxNA
# used slots
if hasattr(planet, 'slots'):
freeSlots = planet.plSlots - len(planet.slots)
else:
freeSlots = '?'
# morale
if hasattr(planet, "morale"):
morale = int(planet.morale)
else:
morale = "?"
#
plType = gdata.planetTypes[getattr(planet, 'plType', None)]
# list item
item = ui.Item(
getattr(planet, 'name', res.getUnknownName()),
tPlType = _(plType),
tPlBio = getattr(planet, 'plBio', '?'),
tPlMin = getattr(planet, 'plMin', '?'),
tPlEn = getattr(planet, 'plEn', '?'),
tChangeBio = getattr(planet, 'changeBio', '?'),
tChangeEn = getattr(planet, 'changeEn', '?'),
tETC = etc,
tETC_raw = etc_raw,
tTotalETC = totalEtc,
tTotalETC_raw = totalEtc_raw,
tConstrInfo = constrInfo,
tFree = freeSlots,
tMorale = morale,
tSpace = getattr(planet, 'plSlots', '?'),
tDiam = getattr(planet, 'plDiameter',0)/1000,
tProd = getattr(planet, 'effProdProd', '?'),
tSci = getattr(planet, 'effProdSci', '?'),
tPlanetID = planetID,
#foreground = res.getFFColorCode(rel),
foreground = res.getPlayerColor(ownerID),
)
items.append(item)
self.win.vPlanets.items = items
self.win.vPlanets.itemsChanged()
# buttons
self.win.vMine.pressed = self.showMine
self.win.vOtherPlayers = self.showOtherPlayers
self.win.vColonizable = self.showColonizable
self.win.vUncolonizable = self.showUncolonizable
def show(self):
player = client.getPlayer()
# check if selected ship design exists
if self.selectedDesignID not in player.shipDesigns:
self.selectedDesignID = None
# designs
items = []
selected = None
items = []
for designID in player.shipDesigns:
spec = player.shipDesigns[designID]
# number of ships with this design in fleet
countInService = 0
for fleetID in player.fleets:
fleet = client.get(fleetID)
for tmpDesignID, hp, shieldHP, exp in fleet.ships:
if tmpDesignID == designID:
countInService += 1
hullTech = client.getFullTechInfo(spec.hullID)
# number of ships in build queue
countInBuild = 0
for planetID in client.db.keys():
planet = client.get(planetID, noUpdate = 1)
# skip non-planets
if not hasattr(planet, "type") or planet.type != T_PLANET \
or not hasattr(planet, 'owner') or not planet.owner == player.oid \
or not planet.prodQueue:
continue
for task in planet.prodQueue:
if task.isShip and task.techID == designID:
countInBuild += task.quantity
# ui list item
item = ui.Item(spec.name, tDesignID = designID,
tClass = "%s/%s%d" % (
_(gdata.shipClasses[spec.combatClass][:1].upper()),_("TL"),
hullTech.level,
),
tNumber = countInService,
tInBuild = countInBuild
)
if spec.upgradeTo:
item.foreground = gdata.sevColors[gdata.NONE]
if designID == self.selectedDesignID:
selected = item
items.append(item)
self.win.vDesigns.items = items
self.win.vDesigns.itemsChanged()
self.win.vDesigns.selectItem(selected)
# compute
if self.selectedDesignID == None:
if self.ctrlID:
eqIDs = {self.ctrlID : 1}
else:
eqIDs = {}
for eqID in self.eqIDs:
eqIDs[eqID] = self.eqIDs[eqID]
improvements = []
self.win.vUpgrade.enabled = 0
self.win.vUpgrade.text = _("Upgrade")
self.win.vScrap.enabled = 0
self.win.vConstruct.enabled = 1
else:
spec = player.shipDesigns[self.selectedDesignID]
self.hullID = spec.hullID
eqIDs = spec.eqIDs
improvements = spec.improvements
self.win.vName.text = spec.name
self.win.vHull.text = client.getTechInfo(self.hullID).name
self.eqIDs = {}
for eqID in eqIDs:
tech = client.getTechInfo(eqID)
if tech.subtype == "seq_ctrl":
self.ctrlID = eqID
self.win.vCtrl.text = tech.name
else:
self.eqIDs[eqID] = eqIDs[eqID]
if player.shipDesigns[self.selectedDesignID].upgradeTo == 0:
self.win.vUpgrade.enabled = 1
self.win.vUpgrade.text = _("Upgrade")
else:
self.win.vUpgrade.enabled = 1
self.win.vUpgrade.text = _("Cancel Upgrd")
self.win.vScrap.enabled = 1
self.win.vConstruct.enabled = 0
try:
result = ShipUtils.makeShipFullSpec(player, None, self.hullID, eqIDs, improvements)
except GameException, e:
self.win.setStatus(e.args[0])
try:
result = ShipUtils.makeShipFullSpec(player, None, self.hullID, eqIDs,
improvements, raiseExs = False)
except GameException:
result = None
self.win.vScrap.enabled = 1
self.win.vConstruct.enabled = 0
try:
result = ShipUtils.makeShipFullSpec(player, None, self.hullID, eqIDs, improvements)
except GameException, e:
self.win.setStatus(e.args[0])
try:
result = ShipUtils.makeShipFullSpec(player, None, self.hullID, eqIDs,
improvements, raiseExs = False)
except GameException:
result = None
else:
self.win.setStatus(_("Ready."))
# design info
if self.hullID:
tech = client.getTechInfo(self.hullID)
self.win.vHull.text = tech.name # TODO _(tech.name)
else:
self.win.vHull.text = _("[Click to select]")
if self.ctrlID:
tech = client.getTechInfo(self.ctrlID)
self.win.vCtrl.text = tech.name # TODO _(tech.name)
else:
self.win.vCtrl.text = _("[Click to select]")
# equipments
items = []
selected = None
for eqID in self.eqIDs:
tech = client.getTechInfo(eqID)
short = sequip.getShortDescr(eqID)
long = sequip.getLongDescr(eqID)
def onConstruct(self, widget, action, data):
if not data:
self.win.setStatus(_('Select technology to construct.'))
return
if not self.sourceID:
self.sourceID = self.planetID
try:
self.quantity = int(self.win.vQuantity.text)
except ValueError:
self.win.setStatus(_('Specify quantity (1, 2, 3, ...).'))
return
# government centers have additional query and if confirmed, another round of this function is called
tech = client.getTechInfo(data.techID)
if tech.govPwr and not self.govTransferConfirm:
# confirm dialog doesn't send through parameters, so we have to save them
self.govTransferData = (widget, action, data)
self.confirmDlg.display(
_("Do you want to issue relocation of your government?"),
_("Yes"), _("No"), self.onGovTransferConfirmed)
else:
try:
self.win.setStatus(
_('Executing START CONSTRUCTION command...'))
planet = client.get(self.sourceID, noUpdate=1)
player = client.getPlayer()
if self.extraSlot:
# check required special resources, if not available, do not continue
# (without check, server start slot expansion but not the tech)
specialResources = player.stratRes
for sr in tech.buildSRes:
if specialResources.get(sr, 0) < self.quantity:
self.win.setStatus(
_('You do not own required strategic resource(s)'
))
return
else:
specialResources[sr] = specialResources.get(
sr, 0) - self.quantity
for i in range(1, self.quantity + 1):
# as we need two slots instead of one, check whether is task queue short
# enough (ie 8 tasks max)
if len(planet.prodQueue) > 8:
self.win.setStatus(_('Queue is full'))
return
client.cmdProxy.startConstruction(
self.sourceID, Rules.Tech.ADDSLOT3, 1,
self.planetID, False, self.win.vReportFin.checked,
Const.OID_NONE)
planet.prodQueue, player.stratRes = client.cmdProxy.startConstruction(
self.sourceID, data.techID, 1, self.planetID,
data.techID < 1000, self.win.vReportFin.checked,
self.structToDemolish)
else:
planet.prodQueue, player.stratRes = client.cmdProxy.startConstruction(
self.sourceID, data.techID, self.quantity,
self.planetID, data.techID < 1000,
self.win.vReportFin.checked, self.structToDemolish)
self.win.setStatus(_('Command has been executed.'))
except GameException, e:
self.win.setStatus(e.args[0])
return
def show(self):
tech = client.getTechInfo(self.techID)
player = client.getPlayer()
techEff = Rules.techImprEff[player.techs.get(self.techID, Rules.techBaseImprovement)]
self.win.title = _('Technology: %s (TL%d)') % (tech.name, tech.level)
# fill data
# fill description
descr = []
improvement = player.techs.get(self.techID, 0)
if hasattr(tech, 'researchMod'):
if improvement == 0:
descr.append(_('Research costs: %d') % Utils.getTechRCost(player, self.techID))
descr.append('')
elif improvement < Rules.techMaxImprovement:
descr.append(_('Improvement costs: %d') % Utils.getTechRCost(player, self.techID))
descr.append('')
# requires
if tech.researchRequires and improvement == 0:
descr.append(_('Research requires:'))
for tmpTechID, improvement in tech.researchRequires:
tmpTech = client.getTechInfo(tmpTechID)
descr.append(_(' - %s improvement %d (TL%d)') % (tmpTech.name, improvement, tmpTech.level))
if hasattr(tech, "researchReqSRes"):
for stratRes in tech.researchReqSRes:
descr.append(_(" - %s (strategic resource)") % (gdata.stratRes[stratRes]))
descr.append('')
if hasattr(tech, "researchDisables") and tech.researchDisables:
descr.append(_("Research disables:"))
for tmpTechID in tech.researchDisables:
tmpTech = client.getTechInfo(tmpTechID)
descr.append(_(" - %s (TL%d)") % (tmpTech.name, tmpTech.level))
descr.append('')
if hasattr(tech, 'partialData') and hasattr(tech, 'textPreRsrch'):
# preresearch info
descr.append(_('Estimated use:'))
descr.extend(tech.textPreRsrch.split('\n'))
descr.append('')
elif not hasattr(tech, 'partialData'):
tmp = []
for improvement in range(1, 6):
for tmpTechID in tech.researchEnables[improvement]:
tmpTech = client.getTechInfo(tmpTechID)
racesDispl = ""
raceChoosen = None
if player.techLevel == 1:
for techID in player.techs.keys():
if techID in (1990, 1991, 1992):
raceChoosen = client.getTechInfo(techID).data
else:
raceChoosen = player.race
if len(tmpTech.researchRaces) > 0 and len(tmpTech.researchRaces) < 3 and not raceChoosen:
racesDispl = _(", only for %s") % tmpTech.researchRaces
if not raceChoosen or len(tmpTech.researchRaces) == 0 or raceChoosen in tmpTech.researchRaces:
tmp.append(_(' - %s (with improvement %d, on TL%d%s)') % (tmpTech.name, improvement, tmpTech.level, racesDispl))
if tmp:
descr.append(_('Research/Improvement enables:'))
descr.extend(tmp)
descr.append('')
# production dependency
if tech.prodBioMod != [0, 0, 0, 0] and tech.prodBioMod != [0, 0, 0, 1]:
descr.append(_("Bio production depends:"))
if tech.prodBioMod[0]: descr.append(_(" - %d %% on planet's environment") % (tech.prodBioMod[0] * 100))
if tech.prodBioMod[1]: descr.append(_(" - %d %% on planet's min. abundance") % (tech.prodBioMod[1] * 100))
if tech.prodBioMod[2]: descr.append(_(" - %d %% on planet's en. abundance") % (tech.prodBioMod[2] * 100))
if tech.prodBioMod[3]: descr.append(_(" - %d %% is not dependent on any planet's attribute") % (tech.prodBioMod[3] * 100))
descr.append("")
if tech.prodEnMod != [0, 0, 0, 0] and tech.prodEnMod != [0, 0, 0, 1]:
descr.append(_("Energy production depends:"))
if tech.prodEnMod[0]: descr.append(_(" - %d %% on planet's environment") % (tech.prodEnMod[0] * 100))
if tech.prodEnMod[1]: descr.append(_(" - %d %% on planet's min. abundance") % (tech.prodEnMod[1] * 100))
if tech.prodEnMod[2]: descr.append(_(" - %d %% on planet's en. abundance") % (tech.prodEnMod[2] * 100))
if tech.prodEnMod[3]: descr.append(_(" - %d %% is not dependent on any planet's attribute") % (tech.prodEnMod[3] * 100))
descr.append("")
if tech.prodProdMod != [0, 0, 0, 0] and tech.prodProdMod != [0, 0, 0, 1]:
descr.append(_("Constr. points production depends:"))
if tech.prodProdMod[0]: descr.append(_(" - %d %% on planet's environment") % (tech.prodProdMod[0] * 100))
if tech.prodProdMod[1]: descr.append(_(" - %d %% on planet's min. abundance") % (tech.prodProdMod[1] * 100))
if tech.prodProdMod[2]: descr.append(_(" - %d %% on planet's en. abundance") % (tech.prodProdMod[2] * 100))
if tech.prodProdMod[3]: descr.append(_(" - %d %% is not dependent on any planet's attribute") % (tech.prodProdMod[3] * 100))
descr.append("")
if tech.prodSciMod != [0, 0, 0, 0] and tech.prodSciMod != [0, 0, 0, 1]:
descr.append(_("Research points production depends:"))
if tech.prodSciMod[0]: descr.append(_(" - %d %% on planet's environment") % (tech.prodSciMod[0] * 100))
if tech.prodSciMod[1]: descr.append(_(" - %d %% on planet's min. abundance") % (tech.prodSciMod[1] * 100))
if tech.prodSciMod[2]: descr.append(_(" - %d %% on planet's en. abundance") % (tech.prodSciMod[2] * 100))
if tech.prodSciMod[3]: descr.append(_(" - %d %% is not dependent on any planet's attribute") % (tech.prodSciMod[3] * 100))
descr.append("")
requiredStrategicResourcesForBuilding = self.getStrategicResourcesText(tech, "buildSRes")
requiredStrategicResourcesForResearch = self.getStrategicResourcesText(tech, "researchReqSRes")
if len(requiredStrategicResourcesForBuilding) > 0 or len(requiredStrategicResourcesForResearch) > 0:
descr.append(_("Required strategic resources:"))
if len(requiredStrategicResourcesForBuilding) > 0:
descr.append(_(" - for building: %s") % requiredStrategicResourcesForBuilding)
if len(requiredStrategicResourcesForResearch) > 0:
descr.append(_(" - for research: %s") % requiredStrategicResourcesForResearch)
descr.append("")
# decription
descr.append(_('Description:'))
if tech.textDescr != u'Not specified':
descr.extend(tech.textDescr.split('\n'))
else:
descr.extend(tech.textPreRsrch.split('\n'))
descr.append('')
# flavor
descr.append(_('Rumours:'))
descr.extend(tech.textFlavor.split('\n'))
descr.append('')
if not len(descr):
descr.append(_('No information available'))
#
self.win.vDescr.text = descr
# re-set techType if neccessary
self.techType = self.techType & (
getattr(tech ,'isStructure', 0) * V_STRUCT |
getattr(tech ,'isShipHull', 0) * V_HULL |
getattr(tech ,'isShipEquip', 0) * V_SEQUIP |
getattr(tech ,'isProject', 0) * V_PROJECT
)
if self.techType == V_NONE:
if getattr(tech ,'isStructure', 0): self.techType = V_STRUCT
elif getattr(tech ,'isShipHull', 0): self.techType = V_HULL
elif getattr(tech ,'isShipEquip', 0): self.techType = V_SEQUIP
elif getattr(tech ,'isProject', 0): self.techType = V_PROJECT
# set type buttons
self.win.vStruct.pressed = self.techType == V_STRUCT
self.win.vStruct.enabled = getattr(tech ,'isStructure', 0)
self.win.vHull.pressed = self.techType == V_HULL
self.win.vHull.enabled = getattr(tech, 'isShipHull', 0)
self.win.vSEquip.pressed = self.techType == V_SEQUIP
self.win.vSEquip.enabled = getattr(tech, 'isShipEquip', 0)
self.win.vProject.pressed = self.techType == V_PROJECT
self.win.vProject.enabled = getattr(tech, 'isProject', 0)
# fill data
items = []
for attr in dir(tech):
value = getattr(tech, attr)
descr, props, showIfDef, default, convertor = techAttrs.get(attr, defaultAttr)
if self.techType & props and (value != default or showIfDef):
item = ui.Item(descr, tValue = convertor(value))
if V_EFF & props:
item.font = 'normal-bold'
item.tValue = convertor(value * techEff)
if V_EFF_REV & props:
item.font = 'normal-bold'
item.tValue = convertor(value / techEff)
items.append(item)
self.win.vData.items = items
self.win.vData.itemsChanged()
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()
items = []
# 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 = client.getPlayer().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)))
# check for structures status
if hasattr(planet,
'slots') and self.win.vPlanets.checked:
for struct in planet.slots:
status = struct[Const.STRUCT_IDX_STATUS]
problem = None
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:
dispDestr = major
fgColorDestr = gdata.sevColors[gdata.MAJ]
if turnsToDestroy < 24:
dispDestr = critical
fgColorDestr = gdata.sevColors[
gdata.CRI]
else:
dispDestr = minor
fgColorDestr = None
if not status & Const.STRUCT_STATUS_ON:
# structure is off
if dispDestr:
items.append(
ui.Item(
planet.name,
tOID=planetID,
tType=Const.T_PLANET,
foreground=fgColorDestr,
vDescription=
_('Structure (%s) is off and will be destroyed in %s turns.'
) %
(tech.name,
res.formatTime(turnsToDestroy)
)))
elif status & Const.STRUCT_STATUS_DETER:
problem = _('is deteriorating')
disp = major
fgColor = gdata.sevColors[gdata.MAJ]
elif status & Const.STRUCT_STATUS_NOBIO:
problem = _(
'has insufficient supply of biomatter')
disp = info
fgColor = gdata.sevColors[gdata.INFO]
elif status & Const.STRUCT_STATUS_NOEN:
problem = _(
'has insufficient supply of energy')
disp = info
fgColor = gdata.sevColors[gdata.INFO]
elif status & Const.STRUCT_STATUS_NOPOP:
problem = _(
'has insufficient supply of workers')
disp = info
fgColor = gdata.sevColors[gdata.INFO]
elif status & Const.STRUCT_STATUS_REPAIRING:
problem = _('is repairing')
disp = info
fgColor = gdata.sevColors[gdata.INFO]
if problem and disp:
items.append(
ui.Item(planet.name,
tOID=planetID,
tType=Const.T_PLANET,
foreground=fgColor,
vDescription=_(
'Structure (%s) %s.') %
(tech.name, problem)))
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 founded 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 bio < 0 and self.win.vSystems.checked:
disp = minor
fgColor = None
surplusTurns = totalBio / (-bio)
if surplusTurns < 168:
disp = major
fgColor = gdata.sevColors[gdata.MAJ]
if surplusTurns < 48:
disp = critical
fgColor = gdata.sevColors[gdata.CRI]
if disp:
if totalBio > 0:
items.append(
ui.Item(
obj.name,
tOID=obj.oid,
tType=Const.T_SYSTEM,
foreground=fgColor,
vDescription=
_('Bio decreasing - last turn change %d, surplus %d (%s).'
) % (bio, totalBio,
res.formatTime(surplusTurns))))
else:
items.append(
ui.Item(
obj.name,
tOID=obj.oid,
tType=Const.T_SYSTEM,
foreground=fgColor,
vDescription=
_('Bio decreasing - last turn change %d, surplus %d.'
) % (bio, totalBio)))
#check en for system
if en < 0 and self.win.vSystems.checked:
disp = minor
fgColor = None
surplusTurns = totalEn / (-en)
if surplusTurns < 168:
disp = major
fgColor = gdata.sevColors[gdata.MAJ]
if surplusTurns < 48:
disp = critical
fgColor = gdata.sevColors[gdata.CRI]
if disp:
if totalEn > 0:
items.append(
ui.Item(
obj.name,
tOID=obj.oid,
tType=Const.T_SYSTEM,
foreground=fgColor,
vDescription=
_('Energy decreasing - last turn change %d, surplus %d (%s).'
) % (en, totalEn,
res.formatTime(surplusTurns))))
else:
items.append(
ui.Item(
obj.name,
tOID=obj.oid,
tType=Const.T_SYSTEM,
foreground=fgColor,
vDescription=
_('Energy decreasing - last turn change %d, surplus %d.'
) % (en, totalEn)))
# check fleets
elif obj.type == Const.T_FLEET and self.win.vFleets.checked:
if hasattr(obj, 'owner') and obj.owner == player.oid:
energyReserve = obj.storEn * 100 / obj.maxEn
system = None
disp = major
fgColor = gdata.sevColors[gdata.MAJ]
note = _(' and IS NOT refueling')
maxRefuelMax = 0
if hasattr(obj, 'orbiting') and obj.orbiting:
system = client.get(obj.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)
if maxRefuelMax > 0:
disp = info
fgColor = gdata.sevColors[gdata.INFO]
note = _(' and IS refueling')
if maxRefuelMax <= energyReserve:
note = _(
' and CAN refuel, but reach planet maximum refuel amount'
)
else:
continue
systemName = res.getUnknownName()
if system and hasattr(system, "name"):
systemName = system.name
# check fleets energy reserve
if energyReserve < 50 and maxRefuelMax == 0:
disp = major
fgColor = gdata.sevColors[gdata.MAJ]
if energyReserve < 25 and maxRefuelMax == 0:
disp = critical
fgColor = gdata.sevColors[gdata.CRI]
else:
fgColor = gdata.sevColors[gdata.INFO]
disp = info
# is fleet named?
if hasattr(obj, 'customname') and obj.customname:
name = obj.customname
else:
name = getattr(obj, "name", None)
if energyReserve == 100 and info and disp:
items.append(
ui.Item(systemName,
tOID=obj.oid,
tType=Const.T_FLEET,
foreground=gdata.sevColors[gdata.INFO],
vDescription=_(
'Fleet "%s" has full fuel tanks.') %
(name)))
elif disp:
items.append(
ui.Item(
systemName,
tOID=obj.oid,
tType=Const.T_FLEET,
foreground=fgColor,
vDescription=_(
'Fleet "%s" is low on fuel [%d %%]%s.') %
(name, energyReserve, note)))
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 = client.getPlayer().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:
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 and major:
items.append(
ui.Item(_('Research'),
tType=Const.T_TECHNOLOGY,
foreground=gdata.sevColors[gdata.MAJ],
vDescription=_('Research queue is empty.')))
# check short reseach queue
elif totalEtc < 48:
disp = minor
fgColor = None
if totalEtc < 24:
disp = major
fgColor = gdata.sevColors[gdata.MAJ]
if disp:
items.append(
ui.Item(
_('Research'),
tType=Const.T_TECHNOLOGY,
foreground=fgColor,
vDescription=
_('Research queue ends in %s turns, %d item(s) on list.'
) % (res.formatTime(totalEtc),
len(player.rsrchQueue))))
self.win.vProblems.items = items
self.win.vProblems.itemsChanged()
def _detailEquipmentLists(self):
# design info
if self.hullID:
tech = client.getTechInfo(self.hullID)
self.win.vHull.text = tech.name # TODO _(tech.name)
elif self.editMode:
self.win.vHull.text = _("[Click to select]")
else:
self.win.vHull.text = ""
if self.ctrlID:
tech = client.getTechInfo(self.ctrlID)
self.win.vCtrl.text = tech.name # TODO _(tech.name)
elif self.editMode:
self.win.vCtrl.text = _("[Click to select]")
else:
self.win.vCtrl.text = ""
# equipments
engines = []
weapons = []
equipment = []
selected = None
selected_type = None
for eqID in self.eqIDs:
tech = client.getTechInfo(eqID)
short = sequip.getShortDescr(eqID)
_long = sequip.getLongDescr(eqID)
# cache has been introduced to let items preserve highlight information
if eqID in self.itemCache:
item = self.itemCache[eqID]
item.tNumber = self.eqIDs[eqID]
else:
item = ui.Item(tech.name,
techID=eqID,
tNumber=self.eqIDs[eqID],
tData=short,
tooltipTitle=_("Details"),
tooltip=_long,
statustip=_long)
self.itemCache[eqID] = item
if eqID == self.selectedEqID:
selected = item
selected_type = tech.subtype
if tech.subtype == "seq_eng":
engines.append(item)
elif tech.subtype == "seq_wpn":
weapons.append(item)
elif tech.subtype in ["seq_mod", "seq_struct"]:
equipment.append(item)
self.win.vEngines.items = engines
self.win.vEngines.itemsChanged()
if selected_type == "seq_eng":
self.win.vEngines.selectItem(selected)
else:
self.win.vEngines.selectItem(None)
self.win.vWeapons.items = weapons
self.win.vWeapons.itemsChanged()
if selected_type == "seq_wpn":
self.win.vWeapons.selectItem(selected)
else:
self.win.vWeapons.selectItem(None)
self.win.vEquipment.items = equipment
self.win.vEquipment.itemsChanged()
if selected_type == "seq_mod":
self.win.vEquipment.selectItem(selected)
else:
self.win.vEquipment.selectItem(None)
def showTechs(self):
# techs
items = []
select = None
showMilitary = self.win.vMilitary.checked
showBio = self.win.vBioProduction.checked
showEn = self.win.vEnProduction.checked
showCP = self.win.vCPProduction.checked
showRP = self.win.vRPProduction.checked
showMorale = self.win.vMorale.checked
showSmall = self.win.vSmall.checked
showMed = self.win.vMedium.checked
showLarge = self.win.vLarge.checked
showCivShip = self.win.vCivShip.checked
showMilShip = self.win.vMilShip.checked
for techID in client.getPlayer().techs.keys():
tech = client.getTechInfo(techID)
# hide pirate techs from ships and miscs view
if not self.showStructures and tech.level == 99:
continue
if tech.isStructure:
if (tech.isMilitary or getattr(tech, "prodBio", 0) > 0 or getattr(tech, "prodEnv", 0) > 0 or \
getattr(tech, "prodEn", 0) > 0 or getattr(tech, "prodProd", 0) > 0 or \
getattr(tech, "prodSci", 0) > 0 or getattr(tech, "moraleTrgt", 0) > 0):
if not ((tech.isMilitary and showMilitary) or \
((getattr(tech, "prodBio", 0) > 0 or getattr(tech, "prodEnv", 0) > 0) and showBio) or \
(getattr(tech, "prodEn", 0) > 0 and showEn) or \
(getattr(tech, "prodProd", 0) > 0 and showCP) or \
(getattr(tech, "prodSci", 0) > 0 and showRP) or \
(getattr(tech, "moraleTrgt", 0) > 0 and showMorale)):
continue
if self.prodProd > 0:
etc = math.ceil(float(tech.buildProd) / self.prodProd)
if self.targetID != self.planetID:
etc *= Rules.buildOnAnotherPlanetMod
etc = res.formatTime(etc)
else:
etc = _("N/A")
item = ui.Item(tech.name,
tLevel = tech.level,
tProd = tech.buildProd,
techID = techID,
tIsShip = 0,
tETC = etc,
)
if item.tLevel > self.maxTechLevel:
self.maxTechLevel = item.tLevel
if item.tLevel in self.showLevels and \
((self.showStructures and tech.isStructure) or \
(self.showOther and (tech.isProject))):
items.append(item)
if techID == self.techID:
select = item
# special handling for ships
player = client.getPlayer()
if self.showShips:
for designID in player.shipDesigns.keys():
tech = player.shipDesigns[designID]
if not ((tech.combatClass == 0 and showSmall) or (tech.combatClass == 1 and showMed) or (tech.combatClass == 2 and showLarge)):
continue
if not ((tech.isMilitary and showMilShip) or (not tech.isMilitary and showCivShip)):
continue
if tech.upgradeTo != OID_NONE:
# skip ships that are set to upgrade
continue
if self.prodProd > 0:
etc = res.formatTime(math.ceil(float(tech.buildProd) / self.prodProd))
else:
etc = _("N/A")
item = ui.Item(tech.name,
tLevel = tech.level,
tProd = tech.buildProd,
techID = designID,
tIsShip = 1,
tETC = etc,
)
items.append(item)
if designID == self.techID:
select = item
# sort it by level and then by name
items.sort(lambda a, b: cmp((100 - a.tLevel, a.text), (100 - b.tLevel, b.text)))
self.win.vTechs.items = items
self.win.vTechs.itemsChanged()
self.win.vTechs.selectItem(select)
# filter
for i in xrange(1, 10):
widget = getattr(self.win, 'vLevel%d' % i)
if i in self.showLevels and i <= self.maxTechLevel:
widget.visible = 1
widget.pressed = 1
elif i not in self.showLevels and i <= self.maxTechLevel:
widget.visible = 1
widget.pressed = 0
else:
widget.visible = 0
self.win.vStructuresToggle.pressed = self.showStructures
self.win.vShipsToggle.pressed = self.showShips
self.win.vOtherToggle.pressed = self.showOther
# targets
info = []
system = client.get(self.systemID, noUpdate = 1)
select = None
if hasattr(system, 'planets'):
for planetID in system.planets:
planet = client.get(planetID, noUpdate = 1)
owner = res.getUnknownName()
#rel = REL_UNDEF
ownerID = OID_NONE
if hasattr(planet, 'owner'):
ownerID = planet.owner
if planet.owner != OID_NONE:
owner = client.get(planet.owner, noUpdate = 1).name
#rel = client.getRelationTo(planet.owner)
else:
owner = _('[Nobody]')
if planet.plType in ("A", "G"):
color = gdata.sevColors[gdata.DISABLED]
else:
#color = res.getFFColorCode(rel)
color = res.getPlayerColor(ownerID)
plname = getattr(planet, 'name', res.getUnknownName())
item = ui.Item(
plname,
text_raw = getattr(planet, 'plEn', plname),
planetID = planetID,
plOwner = owner,
foreground = color,
)
info.append(item)
if planetID == self.targetID:
select = item
self.win.vTargets.items = info
self.win.vTargets.itemsChanged()
self.win.vTargets.selectItem(select)
# quantity
self.win.vQuantity.text = str(self.quantity)
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()
items = []
# 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 < OID_FREESTART:
continue
obj = client.get(objID, noUpdate = 1)
if not hasattr(obj, "type"):
continue
if obj.type == 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 = client.getPlayer().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)))
# check for structures status
if hasattr(planet, 'slots') and self.win.vPlanets.checked:
for struct in planet.slots:
status = struct[STRUCT_IDX_STATUS]
problem = None
tech = client.getFullTechInfo(struct[STRUCT_IDX_TECHID])
if hasattr(player, 'techs'):
techEff = Rules.techImprEff[player.techs.get(struct[STRUCT_IDX_TECHID], Rules.techBaseImprovement)]
else:
techEff = Rules.techImprEff[Rules.techBaseImprovement]
HPturn = max(1, int(0.02 * tech.maxHP * techEff))
turnsToDestroy = math.ceil(struct[STRUCT_IDX_HP] / HPturn)
if turnsToDestroy < 48:
dispDestr = major
fgColorDestr = gdata.sevColors[gdata.MAJ]
if turnsToDestroy < 24:
dispDestr = critical
fgColorDestr = gdata.sevColors[gdata.CRI]
else:
dispDestr = minor
fgColorDestr = None
if not status & STRUCT_STATUS_ON:
# structure is off
if dispDestr:
items.append(ui.Item(planet.name, tOID = planetID, tType = T_PLANET, foreground = fgColorDestr,
vDescription = _('Structure (%s) is off and will be destroyed in %s turns.') % (tech.name, res.formatTime(turnsToDestroy))))
elif status & STRUCT_STATUS_DETER:
problem = _('is deteriorating and will be destroyed in %s turns') % res.formatTime(turnsToDestroy)
disp = major
fgColor = gdata.sevColors[gdata.MAJ]
elif status & STRUCT_STATUS_NOBIO:
problem = _('has insufficient supply of biomatter')
disp = info
fgColor = gdata.sevColors[gdata.INFO]
elif status & STRUCT_STATUS_NOEN:
problem = _('has insufficient supply of energy')
disp = info
fgColor = gdata.sevColors[gdata.INFO]
elif status & STRUCT_STATUS_NOPOP:
problem = _('has insufficient supply of workers')
disp = info
fgColor = gdata.sevColors[gdata.INFO]
elif status & STRUCT_STATUS_REPAIRING:
problem = _('is repairing')
disp = info
fgColor = gdata.sevColors[gdata.INFO]
if problem and disp:
items.append(ui.Item(planet.name, tOID = planetID, tType = T_PLANET, foreground = fgColor,
vDescription = _('Structure (%s) %s.') % (tech.name, problem)))
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 founded 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 = 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 bio < 0 and self.win.vSystems.checked:
disp = minor
fgColor = None
surplusTurns = totalBio / (-bio)
if surplusTurns < 168:
disp = major
fgColor = gdata.sevColors[gdata.MAJ]
if surplusTurns < 48:
disp = critical
fgColor = gdata.sevColors[gdata.CRI]
if disp:
if totalBio > 0:
items.append(ui.Item(obj.name, tOID = obj.oid, tType = T_SYSTEM, foreground = fgColor,
vDescription = _('Bio decreasing - last turn change %d, surplus %d (%s).') % (bio, totalBio,res.formatTime(surplusTurns))))
else:
items.append(ui.Item(obj.name, tOID = obj.oid, tType = T_SYSTEM, foreground = fgColor,
vDescription = _('Bio decreasing - last turn change %d, surplus %d.') % (bio, totalBio)))
#check en for system
if en < 0 and self.win.vSystems.checked:
disp = minor
fgColor = None
surplusTurns = totalEn / (-en)
if surplusTurns < 168:
disp = major
fgColor = gdata.sevColors[gdata.MAJ]
if surplusTurns < 48:
disp = critical
fgColor = gdata.sevColors[gdata.CRI]
if disp:
if totalEn > 0:
items.append(ui.Item(obj.name, tOID = obj.oid, tType = T_SYSTEM, foreground = fgColor,
vDescription = _('Energy decreasing - last turn change %d, surplus %d (%s).') % (en, totalEn,res.formatTime(surplusTurns))))
else:
items.append(ui.Item(obj.name, tOID = obj.oid, tType = T_SYSTEM, foreground = fgColor,
vDescription = _('Energy decreasing - last turn change %d, surplus %d.') % (en, totalEn)))
# check fleets
elif obj.type == T_FLEET and self.win.vFleets.checked:
if hasattr(obj, 'owner') and obj.owner == player.oid:
energyReserve = obj.storEn * 100 / obj.maxEn
system = None
disp = major
fgColor = gdata.sevColors[gdata.MAJ]
note = _(' and IS NOT refueling')
maxRefuelMax = 0
if hasattr(obj, 'orbiting') and obj.orbiting:
system = client.get(obj.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(PACT_ALLOW_TANKING) and dipl.pacts[PACT_ALLOW_TANKING][0] == PACT_ACTIVE:
maxRefuelMax = max(maxRefuelMax, planet.refuelMax)
else:
if planet.owner == player.oid:
maxRefuelMax = max(maxRefuelMax, planet.refuelMax)
if maxRefuelMax > 0:
disp = info
fgColor = gdata.sevColors[gdata.INFO]
note = _(' and IS refueling')
if maxRefuelMax <= energyReserve:
note = _(' and CAN refuel, but reach planet maximum refuel amount')
else:
continue
systemName = res.getUnknownName()
if system and hasattr(system, "name"):
systemName = system.name
# check fleets energy reserve
if energyReserve < 50 and maxRefuelMax == 0:
disp = major
fgColor = gdata.sevColors[gdata.MAJ]
if energyReserve < 25 and maxRefuelMax == 0:
disp = critical
fgColor = gdata.sevColors[gdata.CRI]
else:
fgColor = gdata.sevColors[gdata.INFO]
disp = info
# is fleet named?
if hasattr(obj,'customname') and obj.customname:
name = obj.customname
else:
name = getattr(obj, "name", None)
if energyReserve == 100 and info and disp:
items.append(ui.Item(systemName, tOID = obj.oid, tType = T_FLEET,foreground = gdata.sevColors[gdata.INFO],
vDescription = _('Fleet "%s" has full fuel tanks.') % (name)))
elif disp:
items.append(ui.Item(systemName, tOID = obj.oid, tType = T_FLEET,foreground = fgColor,
vDescription = _('Fleet "%s" is low on fuel [%d %%]%s.') % (name, energyReserve, note)))
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 = client.getPlayer().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 = 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 = 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 = 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 = 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:
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 and major:
items.append(ui.Item(_('Research'), tType = T_TECHNOLOGY, foreground = gdata.sevColors[gdata.MAJ],
vDescription = _('Research queue is empty.')))
# check short reseach queue
elif totalEtc < 48:
disp = minor
fgColor = None
if totalEtc < 24:
disp = major
fgColor = gdata.sevColors[gdata.MAJ]
if disp:
items.append(ui.Item(_('Research'), tType = T_TECHNOLOGY, foreground = fgColor,
vDescription = _('Research queue ends in %s turns, %d item(s) on list.') % (res.formatTime(totalEtc), len(player.rsrchQueue))))
self.win.vProblems.items = items
self.win.vProblems.itemsChanged()
