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
try:
self.win.setStatus(_('Executing START CONSTRUCTION command...'))
planet = client.get(self.sourceID, noUpdate = 1)
if self.extraSlot:
for i in range(1, self.quantity + 1):
client.cmdProxy.startConstruction(self.sourceID,
Rules.Tech.ADDSLOT3, 1, self.planetID, False,
self.win.vReportFin.checked, OID_NONE)
player = client.getPlayer()
planet.prodQueue, player.stratRes = client.cmdProxy.startConstruction(self.sourceID,
data.techID, 1, self.planetID, data.techID < 1000,
self.win.vReportFin.checked, self.structToDemolish)
else:
player = client.getPlayer()
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 onConstruct(self, widget, action, data):
name = self.win.vName.text
if not name:
self.win.setStatus(_("Enter name of the design."))
return
# compute
player = client.getPlayer()
if self.ctrlID:
eqIDs = {self.ctrlID: 1}
else:
eqIDs = {}
for eqID in self.eqIDs:
if self.eqIDs[eqID]:
eqIDs[eqID] = self.eqIDs[eqID]
try:
self.win.setStatus(_("Executing ADD SHIP DESIGN command..."))
player = client.getPlayer()
player.shipDesigns, self.selectedDesignID = \
client.cmdProxy.addShipDesign(player.oid, name, self.hullID, eqIDs)
self.win.vDuplDesign.enabled = 1
self.win.setStatus(_('Command has been executed.'))
except GameException as e:
self.win.setStatus(_(e.args[0]))
return
self.editMode = False
self.update()
def update(self,configUpdated=False): self.galaxyRestart(None, None, False) player = client.getPlayer() turn = client.getTurn() self.win.vTurn.text = res.formatTime(turn) if configUpdated: self.win.vStarMap.updateConfigModes() self.win.vStarMap.precompute() # center of 1st player star if not self.centered: player = client.getPlayer() if player.planets: planet = client.get(player.planets[0]) self.win.vStarMap.setPos(planet.x, planet.y) elif player.fleets: fleet = client.get(player.fleets[0]) self.win.vStarMap.setPos(fleet.x, fleet.y) self.centered = 1 self.refocus() #only fire off when dialog first updated # enable/disable construction self.win.vConstruction.enabled = Utils.enableConstruction(client) # enable/disable diplomacy #if player.diplomacyRels: self.win.vDiplomacy.enabled = 1 #else: # self.win.vDiplomacy.enabled = 0 # highlight messages button? self.messagesDlg.update() if self.messagesDlg.newMsgs > 0: self.win.vMessages.foreground = gdata.sevColors[gdata.MAJ] else: self.win.vMessages.foreground = None
def update(self, configUpdated=False):
self.galaxyFinishPopup(None, None, False)
self.alterMenu(None, None, False)
player = client.getPlayer()
turn = client.getTurn()
self.win.vTurn.text = res.formatTime(turn)
if configUpdated:
self.win.vStarMap.updateConfigModes()
self.win.vStarMap.precompute()
# center of 1st player star
if not self.centered:
player = client.getPlayer()
if player.planets:
planet = client.get(player.planets[0])
self.win.vStarMap.setPos(planet.x, planet.y)
elif player.fleets:
fleet = client.get(player.fleets[0])
self.win.vStarMap.setPos(fleet.x, fleet.y)
self.centered = 1
self.refocus() #only fire off when dialog first updated
# enable/disable construction
self.win.vConstruction.enabled = Utils.enableConstruction(client)
# enable/disable diplomacy
#if player.diplomacyRels:
self.win.vDiplomacy.enabled = 1
#else:
# self.win.vDiplomacy.enabled = 0
# highlight messages button?
self.messagesDlg.update()
if self.messagesDlg.newMsgs > 0:
self.win.vMessages.foreground = gdata.sevColors[gdata.MAJ]
else:
self.win.vMessages.foreground = None
def onScrapConfirmed(self):
try:
self.win.setStatus(_('Executing SCRAP FLEET command...'))
client.db[self.fleetID] = client.cmdProxy.disbandFleet(self.fleetID)
self.win.setStatus(_('Command has been executed.'))
client.getPlayer().fleets.remove(self.fleetID)
del client.db[self.fleetID]
self.hide()
gdata.mainGameDlg.update()
return 0
except ige.GameException, e:
self.win.setStatus(_(e.args[0]))
return 1
def onScrapConfirmed(self):
try:
self.win.setStatus(_('Executing SCRAP FLEET command...'))
client.db[self.fleetID] = client.cmdProxy.disbandFleet(
self.fleetID)
self.win.setStatus(_('Command has been executed.'))
client.getPlayer().fleets.remove(self.fleetID)
del client.db[self.fleetID]
self.hide()
gdata.mainGameDlg.update()
return 0
except ige.GameException, e:
self.win.setStatus(_(e.args[0]))
return 1
def onFinishConfirmed(self, imperatorMsg, scenario):
self.win.setStatus(_('Galaxy finish in progress...'))
oldMsgHandler = client.cmdProxy.msgHandler
client.cmdProxy.msgHandler = None
client.cmdProxy.keepAliveTime = 60 * 60 # do not try to connect to server (one hour)
if scenario == Const.SCENARIO_SINGLE:
client.cmdProxy.deleteSingle(client.getPlayer().galaxy)
elif scenario == Const.SCENARIO_OUTERSPACE:
client.cmdProxy.finishGalaxyImperator(Const.OID_UNIVERSE, client.getPlayer().galaxy, imperatorMsg)
else:
return
client.db.clear()
client.cmdProxy.msgHandler = oldMsgHandler
self.hide()
self.app.exitLocal()
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 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 _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 show(self):
player = client.getPlayer()
self.fleetsByDesign = {}
self.fleetCountsByDesign = {}
items = []
for designID in player.shipDesigns:
spec = player.shipDesigns[designID]
fleets = {}
fleetCounts = {}
for fleetID in player.fleets:
fleet = client.get(fleetID)
count = 0
for tmpDesignID, hp, shieldHP, exp in fleet.ships:
if tmpDesignID == designID:
count += 1
fleets[fleet] = 1
fleetCounts[fleetID] = count
self.fleetsByDesign[designID] = fleets.keys()
self.fleetCountsByDesign[designID] = fleetCounts
item = ui.Item(spec.name,
tDesignID=designID,
tShipsCount=len(fleets.keys()))
items.append(item)
self.win.vDesigns.items = items
self.win.vDesigns.itemsChanged()
def display(self, objID):
player = client.getPlayer()
text = []
if hasattr(player, "buoys") and objID in player.buoys:
label = _("Private buoy text")
if player.buoys[objID][1] == Const.BUOY_TO_ALLY:
label = u"%s%s:" % (label, _(" (visible to allies)"))
else:
label = u"%s:" % label
text.append(label)
text.extend(player.buoys[objID][0].split("\n"))
text.append("")
if hasattr(player, "alliedBuoys") and objID in player.alliedBuoys:
text.append(_("Buoy texts from allies:"))
for buoy in player.alliedBuoys[objID]:
text.extend(buoy[0].split("\n"))
text.append(_('(Author: %s)') % buoy[2]) #owner's name
text.append("")
self.win.vText.text = text
self.win.show()
# register for updates
if self not in gdata.updateDlgs:
gdata.updateDlgs.append(self)
def _processResearchQueue(self):
player = client.getPlayer()
items = []
index = 0
queued = []
totalSci = 0
for task in player.rsrchQueue:
queued.append(task.techID)
item, taskSci = self._processResearchQueueTask(task)
item.index = index
items.append(item)
totalSci += taskSci
index += 1
totalSci = math.ceil(float(totalSci) / player.effSciPoints)
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
self.win.vRTotal.text = res.formatTime(totalSci) if totalSci else _(
"N/A")
return queued
def alterMenu(self, widget, action, data):
""" Update menu according to current situation, being different in singleplayer
or when player is imperator of competitive galaxy, or player has no rights to
finish galaxy at all.
"""
if client.db != None:
player = client.getPlayer()
galaxy = client.get(player.galaxy)
# player can restart (finish) it's own singleplayer galaxy anytime
if galaxy.scenario == Const.SCENARIO_SINGLE:
# depends on state of galaxy
if not galaxy.timeEnabled:
self.systemMenu.items[7].text = _("Resume galaxy")
else:
self.systemMenu.items[7].text = _("Pause galaxy")
self.systemMenu.items[7].action = "onToggleTime"
self.systemMenu.items[6].enabled = True
self.systemMenu.items[7].enabled = True
elif galaxy.scenario == Const.SCENARIO_OUTERSPACE:
# standard behavior
if player.imperator > 2:
# player is imperator for more than two weeks - has right to finish galaxy
self.systemMenu.items[6].enabled = True
else:
# no right to finish galaxy
self.systemMenu.items[6].enabled = False
# you cannot resign when time is stopped
if galaxy.timeEnabled:
self.systemMenu.items[7].enabled = True
else:
self.systemMenu.items[7].enabled = False
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 onStats(self, widget, action, data):
url = 'http://%s/%s/galaxy%d.html' % (
gdata.config.game.server,
gdata.config.game.lastgameid,
client.getPlayer().galaxy,
)
webbrowser.open(url, new = 1)
def show(self):
# orig fleet
items = []
player = client.getPlayer()
grouped = {None: self.origShips}
self.groupShips(grouped, self.checks)
self.appendShips(grouped, items, player, self.checks)
self.win.vOShips.items = items
self.win.vOShips.itemsChanged()
self.win.vOShips.selectItem(None)
self.win.vOEn.text = str(self.origEn)
self.win.vOEnMax.text = _('/ %d') % self.origEnMax
# new fleet
items = []
grouped = {None: self.newShips}
self.groupShips(grouped, self.Nchecks)
self.appendShips(grouped, items, player, self.Nchecks)
self.win.vNShips.items = items
self.win.vNShips.itemsChanged()
self.win.vNShips.selectItem(None)
self.win.vNEn.text = str(self.newEn)
self.win.vNEnMax.text = _('/ %d') % self.newEnMax
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 groupShipsByDesign(ships):
player = client.getPlayer()
retShips = {}
for ship in ships:
appendToDict(retShips, ship[0], ship)
return retShips
def groupShipsByDesign(ships):
player = client.getPlayer()
retShips = {}
for ship in ships:
appendToDict(retShips, ship[0], ship)
return retShips
def _showShips(self):
items = []
player = client.getPlayer()
for designID in player.shipDesigns.keys():
tech = player.shipDesigns[designID]
if not self._filterShipSize(tech) or not self._filterShipMilitary(
tech):
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)
return items
def onRTaskAbortConfirmed(self):
self.win.setStatus(_('Executing ABORT RESEARCH command...'))
player = client.getPlayer()
index = self.win.vRQueue.items.index(self.win.vRQueue.selection[0])
player.rsrchQueue = client.cmdProxy.abortResearch(player.oid, index)
self.update()
self.win.setStatus(_('Command has been executed.'))
def onConstruct(self, widget, action, data):
if not self.techID:
self.win.setStatus(_('Select technology to construct.'))
return
try:
self.quantity = int(self.win.vQuantity.text)
except ValueError:
self.win.setStatus(_('Specify quantity (1, 2, 3, ...).'))
return
try:
self.win.setStatus(_('Executing START CONSTRUCTION command...'))
player = client.getPlayer()
player.prodQueues[
self.
queue], player.stratRes = client.cmdProxy.startGlobalConstruction(
self.playerID, self.techID, self.quantity,
self.techID < 1000, self.win.vReportFin.checked,
self.queue)
self.win.setStatus(_('Command has been executed.'))
except GameException as e:
self.win.setStatus(e.args[0])
return
self.hide()
self.caller.update()
def display(self, objID):
player = client.getPlayer()
text = []
if hasattr(player, "buoys") and objID in player.buoys:
label = _("Private buoy text")
if player.buoys[objID][1] == BUOY_TO_ALLY:
label = u"%s%s:" % (label, _(" (visible to allies)"))
else:
label = u"%s:" % label
text.append(label)
text.extend(player.buoys[objID][0].split("\n"))
text.append("")
if hasattr(player, "alliedBuoys") and objID in player.alliedBuoys:
text.append(_("Buoy texts from allies:"))
for buoy in player.alliedBuoys[objID]:
text.extend(buoy[0].split("\n"))
text.append(_('(Author: %s)') % buoy[2]) #owner's name
text.append("")
self.win.vText.text = text
self.win.show()
# register for updates
if self not in gdata.updateDlgs:
gdata.updateDlgs.append(self)
def alterMenu(self, widget, action, data):
""" Update menu according to current situation, being different in singleplayer
or when player is imperator of competitive galaxy, or player has no rights to
finish galaxy at all.
"""
if client.db != None:
player = client.getPlayer()
galaxy = client.get(player.galaxy)
# player can restart (finish) it's own singleplayer galaxy anytime
if galaxy.scenario == Const.SCENARIO_SINGLE:
# depends on state of galaxy
if not galaxy.timeEnabled:
self.systemMenu.items[7].text = _("Resume galaxy")
else:
self.systemMenu.items[7].text = _("Pause galaxy")
self.systemMenu.items[7].action = "onToggleTime"
self.systemMenu.items[6].enabled = True
self.systemMenu.items[7].enabled = True
elif galaxy.scenario == Const.SCENARIO_OUTERSPACE:
# standard behavior
if player.imperator > 2:
# player is imperator for more than two weeks - has right to finish galaxy
self.systemMenu.items[6].enabled = True
else:
# no right to finish galaxy
self.systemMenu.items[6].enabled = False
# you cannot resign when time is stopped
if galaxy.timeEnabled:
self.systemMenu.items[7].enabled = True
else:
self.systemMenu.items[7].enabled = False
def onPactChange(self, widget, action, data):
citem = self.win.vContacts.selection[0]
pitem = self.win.vPacts.selection[0]
pactState = pitem.tPactState
if widget.data == "ENABLE":
pactState = Const.PACT_INACTIVE
elif widget.data == "DISABLE":
pactState = Const.PACT_OFF
if widget.data == "CONDSRESET":
conditions = [pitem.tPactID]
else:
conditions = []
for item in self.win.vConditions.selection:
conditions.append(item.tPactID)
try:
self.win.setStatus(
_('Executing CHANGE PACT CONDITIONS command...'))
player = client.getPlayer()
player.diplomacyRels = client.cmdProxy.changePactCond(
player.oid, citem.tContactID, pitem.tPactID, pactState,
conditions)
self.win.setStatus(_('Command has been executed.'))
except ige.GameException, e:
self.win.setStatus(e.args[0])
return
def display(self, faultID, text):
self.win.title = _('Unhandled exception: %s') % faultID
self.faultID = faultID
# add more informations
more = [""]
more.append("--- ADDITIONAL DATA ---")
more.append(
"GMT date: %s" %
time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime()))
more.append("OS: %s" % os.name)
more.append("Platform: %s" % sys.platform)
more.append("OSCI version %s" % versionString)
more.append("Pygame version %s" % pygame.version.ver)
more.append("Python %s" % sys.version)
try:
more.append("turn: %d" % client.getTurn())
more.append("player: %s [%d]" %
(client.getPlayer().name, client.getPlayerID()))
except AttributeError:
pass
text = text + "\n".join(more)
#
self.excText = text
# dialog
self.win.vText.text = text.split("\n")
self.win.vSend.enabled = 1
self.win.show()
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 showDesigns(self):
player = client.getPlayer()
# check if highlighted ship design exists
if self.highlightedDesignID not in player.shipDesigns:
self.highlightedDesignID = None
# designs
highlighted = None
items = []
for designID in player.shipDesigns:
spec = player.shipDesigns[designID]
countInService = self._getNumberInFleets(designID)
countInBuild = self._getNumberInBuild(designID)
# ui list item
hullTech = client.getFullTechInfo(spec.hullID)
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.highlightedDesignID:
highlighted = item
items.append(item)
self.win.vDesigns.items = items
self.win.vDesigns.itemsChanged()
self.win.vDesigns.highlightItem(highlighted, 0)
def show(self):
# orig fleet
items = []
player = client.getPlayer()
grouped = {None: self.origShips}
self.groupShips(grouped, self.checks)
self.appendShips(grouped, items, player, self.checks)
self.win.vOShips.items = items
self.win.vOShips.itemsChanged()
self.win.vOShips.selectItem(None)
self.win.vOEn.text = str(self.origEn)
self.win.vOEnMax.text = _('/ %d') % self.origEnMax
# new fleet
items = []
grouped = {None: self.newShips}
self.groupShips(grouped, self.Nchecks)
self.appendShips(grouped, items, player, self.Nchecks)
self.win.vNShips.items = items
self.win.vNShips.itemsChanged()
self.win.vNShips.selectItem(None)
self.win.vNEn.text = str(self.newEn)
self.win.vNEnMax.text = _('/ %d') % self.newEnMax
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 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 _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 onStats(self, widget, action, data):
url = 'http://%s/%s/galaxy%d.html' % (
gdata.config.game.server,
gdata.config.game.lastgameid,
client.getPlayer().galaxy,
)
webbrowser.open(url, new=1)
def onRTaskAbortConfirmed(self):
self.win.setStatus(_('Executing ABORT RESEARCH command...'))
player = client.getPlayer()
index = self.win.vRQueue.items.index(self.win.vRQueue.selection[0])
player.rsrchQueue = client.cmdProxy.abortResearch(player.oid, index)
self.update()
self.win.setStatus(_('Command has been executed.'))
def calcDesign(self, designID, count=1, addHP=True):
player = client.getPlayer()
spec = player.shipDesigns[designID]
size = spec.combatClass
eqIDs = spec.weaponIDs #equipment list
for eqID in eqIDs:
tech = client.getFullTechInfo(eqID)
if tech.subtype == "seq_wpn":
try:
level = player.techs[eqID]
except:
level = 1 #tech not researched
improvement = Rules.techImprEff[level]
dmgMin = tech.weaponDmgMin * tech.weaponROF
dmgMax = tech.weaponDmgMax * tech.weaponROF
weaponclass = tech.weaponClass
if self.showOnlyShieldPiercing and not tech.weaponIgnoreShield:
continue
if size == 0:
self.sm_min[weaponclass] += int(count * dmgMin *
improvement)
self.sm_max[weaponclass] += int(count * dmgMax *
improvement)
elif size == 1:
self.med_min[weaponclass] += int(count * dmgMin *
improvement)
self.med_max[weaponclass] += int(count * dmgMax *
improvement)
elif size == 2:
self.lg_min[weaponclass] += int(count * dmgMin *
improvement)
self.lg_max[weaponclass] += int(count * dmgMax *
improvement)
if addHP:
if size == 0:
self.sm['num'] += count
self.sm['hp'] += spec.maxHP * count
self.sm['sh'] += spec.shieldHP * count
elif size == 1:
self.med['num'] += count
self.med['hp'] += spec.maxHP * count
self.med['sh'] += spec.shieldHP * count
elif size == 2:
self.lg['num'] += count
self.lg['hp'] += spec.maxHP * count
self.lg['sh'] += spec.shieldHP * count
if size == 0:
self.sm['catt'] += spec.combatAtt * count
self.sm['cdef'] += spec.combatDef * count
self.sm['mdef'] += spec.missileDef * count
elif size == 1:
self.med['catt'] += spec.combatAtt * count
self.med['cdef'] += spec.combatDef * count
self.med['mdef'] += spec.missileDef * count
elif size == 2:
self.lg['catt'] += spec.combatAtt * count
self.lg['cdef'] += spec.combatDef * count
self.lg['mdef'] += spec.missileDef * count
return size
def onFinishConfirmed(self, imperatorMsg, scenario):
self.win.setStatus(_('Galaxy finish in progress...'))
oldMsgHandler = client.cmdProxy.msgHandler
client.cmdProxy.msgHandler = None
client.cmdProxy.keepAliveTime = 60 * 60 # do not try to connect to server (one hour)
if scenario == Const.SCENARIO_SINGLE:
client.cmdProxy.deleteSingle(client.getPlayer().galaxy)
elif scenario == Const.SCENARIO_OUTERSPACE:
client.cmdProxy.finishGalaxyImperator(Const.OID_UNIVERSE,
client.getPlayer().galaxy,
imperatorMsg)
else:
return
client.db.clear()
client.cmdProxy.msgHandler = oldMsgHandler
self.hide()
self.app.exitLocal()
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
if not self._shallShow(planet, player):
continue
# fill in data
ownerID = getattr(planet, 'owner', Const.OID_NONE)
if hasattr(planet, 'owner') and planet.owner == player.oid:
constrInfo, etc, totalEtc = self._processProdQueue(planet)
else:
constrInfo = '?'
etc = '?'
totalEtc = '?'
# used slots
try:
freeSlots = planet.plSlots - len(planet.slots)
except AttributeError:
freeSlots = '?'
# morale
try:
morale = int(planet.morale)
except AttributeError:
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,
tTotalETC=totalEtc,
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.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 onSelectKTech(self, widget, action, data):
techID = self.win.vKTechs.selection[0].techID
player = client.getPlayer()
if techID in player.obsoleteTechs:
self.win.vObs.enabled = 0
self.win.vUnObs.enabled = 1
else:
self.win.vUnObs.enabled = 0
self.win.vObs.enabled = 1
def onAbstain(self, widget, action, data):
try:
self.win.setStatus(_('Executing ELECT command...'))
player = client.getPlayer()
player.voteFor = client.cmdProxy.setVoteFor(player.oid, Const.OID_NONE)
self.win.setStatus(_('Command has been executed.'))
except ige.GameException, e:
self.win.setStatus(e.args[0])
return
def moveShipsToLeft(self, ships):
for ship in ships:
self.newShips.remove(ship)
self.origShips.append(ship)
# move fuel to the new fleet
tech = client.getPlayer().shipDesigns[ship[0]]
avail = min(self.origEn, tech.storEn)
self.newEn -= avail
self.origEn += avail
def show(self):
self.player = client.getPlayer()
self.vPQueues = [
self.win.vPQueue0, self.win.vPQueue1, self.win.vPQueue2,
self.win.vPQueue3, self.win.vPQueue4
]
#
for queueNo in xrange(self.queueNo):
self.showProdQueue(queueNo)
def _getNumberInFleets(self, designID):
count = 0
for fleetID in client.getPlayer().fleets:
fleet = client.get(fleetID)
count += len([
designID for tmpDesignID, hp, shieldHP, exp in fleet.ships
if tmpDesignID == designID
])
return count
def onDeleteAll(self, widget, action, data):
self.win.setStatus(_('Executing DELETE ALL MESSAGES command...'))
player = client.getPlayer()
messages = client.cmdProxy.deleteAllMessages(player.oid)
# update related objects
player.messages = messages
# update client
self.win.setStatus(_('Command has been executed.'))
self.update()
def moveShipsToLeft(self, ships): for ship in ships: self.newShips.remove(ship) self.origShips.append(ship) # move fuel to the new fleet tech = client.getPlayer().shipDesigns[ship[0]] avail = min(self.origEn, tech.storEn) self.newEn -= avail self.origEn += avail
def galaxyFinishButton(self, widget, action, data):
player = client.getPlayer()
galaxy = client.get(player.galaxy)
if galaxy.scenario == Const.SCENARIO_OUTERSPACE and player.imperator > 2:
localTime = time.time()
gdata.config.game.lastGalaxyFinishShown = str(localTime)
self.galaxyFinishDlg.display(finishAction = self.onFinishConfirmedOuterspace)
elif galaxy.scenario == Const.SCENARIO_SINGLE:
self.confirmDlg.display(_('Are you really really sure you want to finish this single player galaxy of yours? You won\'t be able to get back.'), _('Finish'), _('No'), confirmAction = self.onFinishConfirmedSingle)
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 onSelectKTech(self, widget, action, data):
techID = self.win.vKTechs.selection[0].techID
player = client.getPlayer()
if techID in player.obsoleteTechs:
self.win.vObs.enabled = 0
self.win.vUnObs.enabled = 1
else:
self.win.vUnObs.enabled = 0
self.win.vObs.enabled = 1
def splitShip(self):
designID = self.sendShips[self.sendShipIndex]
ships = []
for ship in self.fleet.ships:
if ship[0] == designID:
ships = [ship]
break
if len(ships) == 0:
self.win.setStatus(_("No ships left of the class %s" % client.getPlayer().shipDesigns[designID].name))
return False
#there is only one ship left in the original fleet
if len(self.fleet.ships) == 1:
return self.fleet
#split the ship off the fleet; note: storeEn = self.fleet.storEn will result in max energy for the new fleet
newfleet, self.fleet, fleets = client.cmdProxy.splitFleet(self.fleet.oid,ships,self.fleet.storEn)
client.getPlayer().fleets = fleets
client.db[newfleet.oid] = newfleet
client.db[self.fleet.oid] = self.fleet
return newfleet
def onScrap(self, widget, action, data):
# count number of ships using this design
count = 0
for fleetID in client.getPlayer().fleets:
fleet = client.get(fleetID)
for designID, hp, shieldHP, exp in fleet.ships:
if designID == self.selectedDesignID:
count += 1
self.confirmDlg.display(_('Deletion of this design dismantle %d ship(s). Are you sure to scrap it?') % count, _('Yes'),
_('No'), confirmAction = self.onScrapConfirmed)
def onRestartConfirmed(self, imperatorMsg):
self.win.setStatus(_('Galaxy restart in progress...'))
oldMsgHandler = client.cmdProxy.msgHandler
client.cmdProxy.msgHandler = None
client.cmdProxy.keepAliveTime = 60 * 60 # do not try to connect to server (one hour)
client.cmdProxy.restartGalaxy(OID_UNIVERSE, client.getPlayer().galaxies[0], imperatorMsg)
client.db.clear()
client.cmdProxy.msgHandler = oldMsgHandler
self.hide()
self.app.exit()
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 onDeleteSelectedShipConfirmed(self):
if self.win.vShips.selection:
item = self.win.vShips.selection[0]
try:
self.win.setStatus(_('Executing SCRAP SHIP command...'))
client.db[self.fleetID] = client.cmdProxy.removeShips(self.fleetID,
[item.tSpec])
self.win.setStatus(_('Command has been executed.'))
if not client.get(self.fleetID, noUpdate = 1).ships:
# remove fleet
client.getPlayer().fleets.remove(self.fleetID)
del client.db[self.fleetID]
self.hide()
else:
self.update()
gdata.mainGameDlg.update()
return 0
except ige.GameException, e:
self.win.setStatus(_(e.args[0]))
return 1
def onVoteFor(self, widget, action, data):
citem = self.win.vContacts.selection[0]
try:
self.win.setStatus(_('Executing ELECT command...'))
player = client.getPlayer()
player.voteFor = client.cmdProxy.setVoteFor(player.oid,
citem.tContactID)
self.win.setStatus(_('Command has been executed.'))
except ige.GameException, e:
self.win.setStatus(e.args[0])
return
def onSelectContact(self, widget, action, data): player = client.getPlayer() items = [] for contactID in player.diplomacyRels: contact = client.get(contactID) item = ui.Item(contact.name, tRecipientID = contactID) items.append(item) self.cwin.vContacts.items = items self.cwin.vContacts.itemsChanged() self.cwin.show()
def onRTaskRepeat(self, widget, action, data):
self.win.setStatus(_('Executing EDIT RESEARCH command...'))
player = client.getPlayer()
index = self.win.vRQueue.items.index(self.win.vRQueue.selection[0])
repeat = not self.win.vRQueue.selection[0].tImproveToMax
# execute command
player.rsrchQueue = client.cmdProxy.editResearch(player.oid, index, repeat)
self.update()
self.win.vRQueue.selectItem(self.win.vRQueue.items[index])
self.win.setStatus(_('Command has been executed.'))
self.onSelectRQueueTech(widget, action, None)
def onChangeQtyConfirmed(self):
if self.changeQtyDlg.quantity != None:
try:
self.win.setStatus(_('Executing CHANGE TASK command...'))
player = client.getPlayer()
player.prodQueues[self.activeQueue], player.stratRes = client.cmdProxy.changeGlobalConstruction(self.playerID, self.activeQueue, self.activeIndex, self.changeQtyDlg.quantity)
self.win.setStatus(_('Command has been executed.'))
self.win.vTaskQuantity.text = player.prodQueues[self.activeQueue][self.activeIndex].quantity
self.win.vTaskConstPoints.text = player.prodQueues[self.activeQueue][self.activeIndex].const
except GameException, e:
self.win.setStatus(e.args[0])
return
def onDelete(self, widget, action, data):
messages = []
for item in self.win.vMessages.selection:
messages.append(item.message)
self.win.setStatus(_('Executing DELETE MESSAGES command...'))
player = client.getPlayer()
messages = client.cmdProxy.deleteMessages(player.oid, messages)
# update related objects
player.messages = messages
# update client
self.win.setStatus(_('Command has been executed.'))
self.update()
def onRedirectOFF(self, widget, action, data):
self.win.setStatus(_('Executing REDIRECT FLEETS OFF command...'))
player = client.getPlayer()
try:
player.shipRedirections = client.cmdProxy.redirectShips(player.oid,
self.systemID, Const.OID_NONE)
self.win.setStatus(_('Command has been executed.'))
gdata.mainGameDlg.update()
self.caller.update()
self.hide()
except GameException, e:
self.win.setStatus(e.args[0])
def calcDesign(self,designID,count=1,addHP=True): player = client.getPlayer() spec = player.shipDesigns[designID] size = spec.combatClass eqIDs = spec.weaponIDs #equipment list for eqID in eqIDs: tech = client.getFullTechInfo(eqID) if tech.subtype == "seq_wpn": try: level = player.techs[eqID] except: level = 1 #tech not researched improvement = Rules.techImprEff[level] dmgMin = tech.weaponDmgMin * tech.weaponROF dmgMax = tech.weaponDmgMax * tech.weaponROF weaponclass = tech.weaponClass if self.showOnlyShieldPiercing and not tech.weaponIgnoreShield: continue if size==0: self.sm_min[weaponclass] += int(count * dmgMin * improvement) self.sm_max[weaponclass] += int(count * dmgMax * improvement) elif size==1: self.med_min[weaponclass] += int(count * dmgMin * improvement) self.med_max[weaponclass] += int(count * dmgMax * improvement) elif size==2: self.lg_min[weaponclass] += int(count * dmgMin * improvement) self.lg_max[weaponclass] += int(count * dmgMax * improvement) if addHP: if size==0: self.sm['num'] += count self.sm['hp'] += spec.maxHP*count self.sm['sh'] += spec.shieldHP*count elif size==1: self.med['num'] += count self.med['hp'] += spec.maxHP*count self.med['sh'] += spec.shieldHP*count elif size==2: self.lg['num'] += count self.lg['hp'] += spec.maxHP*count self.lg['sh'] += spec.shieldHP*count if size==0: self.sm['catt'] += spec.combatAtt*count self.sm['cdef'] += spec.combatDef*count self.sm['mdef'] += spec.missileDef*count elif size==1: self.med['catt'] += spec.combatAtt*count self.med['cdef'] += spec.combatDef*count self.med['mdef'] += spec.missileDef*count elif size==2: self.lg['catt'] += spec.combatAtt*count self.lg['cdef'] += spec.combatDef*count self.lg['mdef'] += spec.missileDef*count return size
