def initAppFolder():
"""
Locates the directory that contains the BTS application.
"""
global _appFolderInitDone
if _appFolderInitDone:
return
BugUtil.debug("BugPath - initializing application folder")
global _appDir, _appFolder
# Determine the app directory that holds the executable and Mods
# as well as the folder name inside MY_GAMES_FOLDER that holds CustomAssets and Mods.
if isMac():
_appDir = os.getcwd()
else:
if isfile(sys.executable):
# BugUtil.debug("BugPath - exe is '%s'", sys.executable)
_appDir = dirname(sys.executable)
if _appDir:
_appFolder = basename(_appDir)
safeInfoPath("BugPath - app dir is '%s'", _appDir)
safeDebugPath("BugPath - app folder is '%s'", _appFolder)
else:
BugUtil.warn("BugPath - no executable found")
_appFolderInitDone = True
def initNoCustomAssetsSetting():
"""
Checks if the NoCustomAssets setting is enabled when running as a mod.
"""
global _noCustomAssetsSettingInitDone
if _noCustomAssetsSettingInitDone:
return
if isMod():
global _noCustomAssets
# EF: don't check game option because BUG is initialized only once at startup
# if CyGame().isOption(GameOptionTypes.GAMEOPTION_LOCK_MODS):
# _noCustomAssets = True
# BugUtil.debug("BugPath - Lock Modified Assets is set")
# else:
if getModDir() and getModFolder():
BugUtil.debug("BugPath - checking for NoCustomAssets")
try:
from configobj import ConfigObj
config = ConfigObj(join(getModDir(), getModFolder() + ".ini"), encoding="utf_8")
_noCustomAssets = config["CONFIG"].as_bool("NoCustomAssets")
except:
BugUtil.trace("BugPath - failed to parse mod INI file for NoCustomAssets")
BugUtil.info("BugPath - NoCustomAssets is %s", _noCustomAssets)
_noCustomAssetsSettingInitDone = True
def run(self):
try:
self._rev = _getRemoteRevision(self._url)
BugUtil.debug("RemoteRevisionThread.run - found revision %d", self._rev)
except BugError, e:
self._error = e
BugUtil.debug("RemoteRevisionThread.run - %s", self._error.message)
def _getAlertMessageIcon(self, city, passes):
if (passes):
BugUtil.debug("%s passed occupation test, ignoring", city.getName())
return (None, None)
else:
return (localText.getText("TXT_KEY_CIV4LERTS_ON_CITY_PACIFIED", (city.getName(), )),
HAPPY_ICON)
def dispatchEvent(eComment, eFromPlayer, eToPlayer, args):
event = g_eventsByCommentType.get(eComment, None)
if event:
event.dispatch(eFromPlayer, eToPlayer, args)
else:
key = gc.getDiplomacyInfo(eComment).getType()
BugUtil.debug("DiplomacyUtil - ignoring %s from %d to %d with %r", key, eFromPlayer, eToPlayer, args)
def init():
"""
Segregates units into two sets: those that require resources and those that don't.
Creates a map of units from ID to the set of tech prerequisites.
"""
global NUM_UNITS, NUM_CLASSES
NUM_UNITS = gc.getNumUnitInfos()
NUM_CLASSES = gc.getNumUnitClassInfos()
global NUM_OR_BONUSES, NUM_AND_TECHS
NUM_OR_BONUSES = gc.getNUM_UNIT_PREREQ_OR_BONUSES()
NUM_AND_TECHS = gc.getNUM_UNIT_AND_TECH_PREREQS()
for eUnit in range(NUM_UNITS):
unitInfo = gc.getUnitInfo(eUnit)
BugUtil.debug("==== %s ====", unitInfo.getDescription())
# generic unit
classInfo = gc.getUnitClassInfo(unitInfo.getUnitClassType())
eGenericUnit = classInfo.getDefaultUnitIndex()
genericUnitIDs[eUnit] = eGenericUnit
if eUnit == eGenericUnit:
genericUnits.add(eUnit)
else:
BugUtil.debug(" unique of %s",
gc.getUnitInfo(eGenericUnit).getDescription())
# resource sets
found = False
eBonus = unitInfo.getPrereqAndBonus()
if eBonus != -1:
found = True
strategicBonuses.add(eBonus)
BugUtil.debug(" requires %s", gc.getBonusInfo(eBonus).getDescription())
for i in range(NUM_OR_BONUSES):
eBonus = unitInfo.getPrereqOrBonuses(i)
if eBonus != -1:
found = True
strategicBonuses.add(eBonus)
BugUtil.debug(" requires %s", gc.getBonusInfo(eBonus).getDescription())
if found:
unitsWithBonuses.add(eUnit)
else:
unitsWithoutBonuses.add(eUnit)
# tech map
techs = set()
unitTechs[eUnit] = techs
eTech = unitInfo.getPrereqAndTech()
if eTech != -1:
techs.add(eTech)
for i in range(NUM_AND_TECHS):
eTech = unitInfo.getPrereqAndTechs(i)
if eTech != -1:
techs.add(eTech)
for eTech in techs:
BugUtil.debug(" requires %s", gc.getTechInfo(eTech).getDescription())
# upgrade maps
for eUnit in range(NUM_UNITS):
getOlderUnits(eUnit)
getNewerUnits(eUnit)
def _setValue(self, value, *args):
"""Sets the actual value in the INI file."""
BugUtil.debug("BugOptions - setting %s to %r", self.getID(), value)
if args:
return TYPE_SETTER_MAP[self.type](self.file, self.section, self.key % args, value)
else:
return TYPE_SETTER_MAP[self.type](self.file, self.section, self.key, value)
def _findTable(self, key):
if self._hasTable(key):
BugUtil.debug("BugTable - found %s in %s", key, self)
return self._getTable(key)
else:
BugUtil.debug("BugTable - %s not found in %s", key, self)
return None
def __init__ (self, iThisPlayer, iTargetPlayer):
pActiveTeam = gc.getTeam(gc.getActivePlayer().getTeam())
iThisTeam = gc.getPlayer(iThisPlayer).getTeam()
pThisTeam = gc.getTeam(iThisTeam)
iTargetTeam = gc.getPlayer(iTargetPlayer).getTeam()
self.iThisPlayer = iThisPlayer
self.iTargetPlayer = iTargetPlayer
self.iAttitudeSum = 0
self.iAttitudeModifiers = {}
self.bHasActiveMetBoth = CyGame().isDebugMode() or (pActiveTeam.isHasMet(iThisTeam) and pActiveTeam.isHasMet(iTargetTeam))
self.eAttitudeType = AttitudeTypes.NO_ATTITUDE
# This might be better off being something descriptive such as
# "players have not met" or "players are the same"
self.sAttitudeString = ""
if (iThisPlayer != iTargetPlayer and pThisTeam.isHasMet(iTargetTeam)):
self.eAttitudeType = gc.getPlayer(iThisPlayer).AI_getAttitude(iTargetPlayer)
self.sAttitudeString = CyGameTextMgr().getAttitudeString(iThisPlayer, iTargetPlayer)
for sLine in self.sAttitudeString.split("\n"):
#BugUtil.debug(u"LINE: %s" % (sLine))
pMatch = re.match("^.*>([-\+]\d+)\s?:\s+(\".+\")<.*$", sLine, re.UNICODE)
if (pMatch):
#BugUtil.debug(u"MATCH: (%s) (%s)" %(pMatch.group(1), pMatch.group(2)))
iValue = int(pMatch.group(1))
sString = unicode(pMatch.group(2))
if sString in MODIFIER_STRING_TO_KEY:
self.iAttitudeModifiers[MODIFIER_STRING_TO_KEY[sString]] = iValue
self.iAttitudeSum = self.iAttitudeSum + iValue
#BugUtil.debug(u"Attitude::init() - Added to dict: %s" % (sString))
else:
BugUtil.debug(u"Attitude::init() - Attitude string contains unknown modifier text: %s" % (sString))
#BugUtil.debug(u"Attitude::init() complete.")
BugUtil.debug(u"%s" % (self))
def createFileGetter(self, file):
"""Creates a getter for the given IniFile."""
def get():
return file
getter = "get" + file.id
setattr(self, getter, get)
BugUtil.debug("BugOptions - %s will return IniFile %s", getter, file.id)
def hideSign (self, pPlot, ePlayer):
""" Hides sign for given player at given plot if there's a current sign the same as the stored one.
Note that this function assumes gCurrentSigns is up-to-date so make sure you've updated first.
"""
if not pPlot or pPlot.isNone():
BugUtil.warn("MapSigns.hideSign() was passed an invalid plot: %s" % (str(pPlot)))
return False
thisKey = self.__getKey(pPlot)
if gCurrentSigns == None:
BugUtil.debug("MapSigns.hideSign() finds no current signs so there's nothing to hide.")
return False
if self.hasPlotSigns(pPlot):
szCaption = self.plotDict[thisKey].getSign(ePlayer)
if gCurrentSigns.hasPlotSigns(pPlot):
szExistingCaption = gCurrentSigns[pPlot].getSign(ePlayer)
if szCaption and szCaption == szExistingCaption:
BugUtil.debug("MapSigns.hideSign() found matching sign (%s) for player %d on plot %s; will remove it" % (szCaption, ePlayer, str(thisKey)))
if ePlayer == -1:
engine.removeLandmark(pPlot)
else:
engine.removeSign(pPlot, ePlayer)
return True
else:
BugUtil.debug("MapSigns.hideSign() found sign for player %d saying (%s) instead of (%s) on plot %s; will leave alone." % (ePlayer, szExistingCaption, szCaption, str(thisKey)))
else:
BugUtil.debug("MapSigns.hideSign() found no sign on plot %s to remove" % (str(thisKey)))
else:
BugUtil.debug("MapSigns.hideSign() found no saved signs at all for plot %s" % (str(thisKey)))
return False
def StatusDump_Basic(self):
BugUtil.debug("StatusDump - basic")
# dump basic stuff
# - leader name / civ
# - current game turn and year
# - current tech being researched
# - techs available to research
# - opponents
# - scoreboard
# - number of cities
# - bank balance
# player stuff
ePlayer = gc.getGame().getActivePlayer()
pPlayer = gc.getPlayer(ePlayer)
# human / game name
sMsg = BugUtil.getText("TXT_KEY_STATUS_DUMP_PLAYER_NAME", (pPlayer.getCivilizationShortDescription(0)))
self._writeMsg(sMsg, vColor="Black", vBold=False, vUnderline=False, vOpenSpoiler="", vCloseSpoiler=False)
# leader / civ name
sMsg = BugUtil.getText("TXT_KEY_STATUS_DUMP_LEADER_CIV", (gc.getLeaderHeadInfo(pPlayer.getLeaderType()).getDescription(), pPlayer.getCivilizationShortDescription(0)))
self._writeMsg(sMsg, vColor="Black", vBold=False, vUnderline=False, vOpenSpoiler="", vCloseSpoiler=False)
def init():
"""Performs the one-time initialization of the BUG core and all mods."""
global g_initDone
if g_initDone:
BugUtil.warn("BugInit - init() called again")
return
global g_initRunning
if g_initRunning:
BugUtil.warn("BugInit - init() already running")
return
g_initRunning = True
BugUtil.debug("BugInit - initializing...")
timer = BugUtil.Timer("BUG init")
try:
# test to see if global context is ready
CvUtil.initDynamicFontIcons()
except:
BugUtil.debug("BugInit - global context not ready")
g_initRunning = False
return False
loadMod("init")
BugCore.initDone()
timer.log("read configs").start()
callInits()
timer.log("call inits/events")
timer.logTotal()
g_initDone = True
g_initRunning = False
return True
def onPlayerRevolution(self, argsList):
ePlayer, iAnarchyTurns, leOldCivics, leNewCivics = argsList
civics = []
for eOldCivic, eNewCivic in zip(leOldCivics, leNewCivics):
if eOldCivic != eNewCivic:
civics.append(gc.getCivicInfo(eNewCivic).getDescription())
BugUtil.debug("Revolution for %s, %d turns: %s", gc.getPlayer(ePlayer).getCivilizationShortDescription(0), iAnarchyTurns, ", ".join(civics))
def onDealRejected(argsList):
#BugUtil.debug("DiplomacyUtil::onDealRejected %s" %(str(argsList)))
eTargetPlayer, eOfferPlayer, pTrade = argsList
BugUtil.debug("DiplomacyUtil - %s accepts trade offered by %s: %r",
PlayerUtil.getPlayer(eTargetPlayer).getName(),
PlayerUtil.getPlayer(eOfferPlayer).getName(),
pTrade)
def __init__(self, eventManager, *args, **kwargs):
super(StatusDumpEvent, self).__init__(eventManager, *args, **kwargs)
eventManager.addEventHandler("kbdEvent", self.onKbdEvent)
self.eventMgr = eventManager
BugUtil.debug("StatusDump-Start-0")
def onCivicRejected(argsList):
#BugUtil.debug("DiplomacyUtil::onCivicRejected %s" %(str(argsList)))
eTargetPlayer, eDemandPlayer, eCivic = argsList
BugUtil.debug("DiplomacyUtil - %s rejects demand from %s to switch to %s",
PlayerUtil.getPlayer(eTargetPlayer).getName(),
PlayerUtil.getPlayer(eDemandPlayer).getName(),
gc.getCivicInfo(eCivic).getDescription())
def onReligionRejected(argsList):
#BugUtil.debug("DiplomacyUtil::onReligionRejected %s" %(str(argsList)))
eTargetPlayer, eDemandPlayer, eReligion = argsList
BugUtil.debug("DiplomacyUtil - %s rejects demand from %s to convert to %s",
PlayerUtil.getPlayer(eTargetPlayer).getName(),
PlayerUtil.getPlayer(eDemandPlayer).getName(),
gc.getReligionInfo(eReligion).getDescription())
def onWarDemanded(argsList):
#BugUtil.debug("DiplomacyUtil::onWarDemanded %s" %(str(argsList)))
eDemandPlayer, eTargetPlayer, eVictim = argsList
BugUtil.debug("DiplomacyUtil - %s asks %s to declare war on %s",
PlayerUtil.getPlayer(eDemandPlayer).getName(),
PlayerUtil.getPlayer(eTargetPlayer).getName(),
PlayerUtil.getPlayer(eVictim).getName())
def onWarRejected(argsList):
#BugUtil.debug("DiplomacyUtil::onWarRejected %s" %(str(argsList)))
eTargetPlayer, eDemandPlayer, eVictim = argsList
BugUtil.debug("DiplomacyUtil - %s rejects demand from %s to declare war on %s",
PlayerUtil.getPlayer(eTargetPlayer).getName(),
PlayerUtil.getPlayer(eDemandPlayer).getName(),
PlayerUtil.getPlayer(eVictim).getName())
def onEmbargoRejected(argsList):
#BugUtil.debug("DiplomacyUtil::onEmbargoRejected %s" %(str(argsList)))
eTargetPlayer, eDemandPlayer, eVictim = argsList
BugUtil.debug("DiplomacyUtil - %s rejects demand from %s to stop trading with %s",
PlayerUtil.getPlayer(eTargetPlayer).getName(),
PlayerUtil.getPlayer(eDemandPlayer).getName(),
PlayerUtil.getPlayer(eVictim).getName())
def onHelpOffered(argsList):
#BugUtil.debug("DiplomacyUtil::onHelpOffered %s" %(str(argsList)))
eOfferPlayer, eTargetPlayer, pTrade = argsList
BugUtil.debug("DiplomacyUtil - %s offers help to %s: %r",
PlayerUtil.getPlayer(eOfferPlayer).getName(),
PlayerUtil.getPlayer(eTargetPlayer).getName(),
pTrade)
def setXMLOptionsfromIniFile():
BugUtil.debug("Initializing A New Dawn Diplomacy Settings")
ANewDawnOpt.setCanTradeTechs(not gc.getGame().isOption(GameOptionTypes.GAMEOPTION_NO_TECH_TRADING))
ANewDawnOpt.setCanBrokerTechs(not gc.getGame().isOption(GameOptionTypes.GAMEOPTION_NO_TECH_BROKERING))
gc.setDefineINT("CAN_TRADE_RESOURCES", ANewDawnOpt.isCanTradeResources())
gc.setDefineINT("CAN_TRADE_CITIES", ANewDawnOpt.isCanTradeCities())
gc.setDefineINT("CAN_TRADE_WORKERS", ANewDawnOpt.isCanTradeWorkers())
gc.setDefineINT("NO_MILITARY_UNIT_TRADING", not ANewDawnOpt.isCanTradeMilitary())
gc.setDefineINT("CAN_TRADE_GOLD", ANewDawnOpt.isCanTradeGold())
gc.setDefineINT("CAN_TRADE_GOLD_PER_TURN", ANewDawnOpt.isCanTradeGoldPerTurn())
gc.setDefineINT("CAN_TRADE_MAPS", ANewDawnOpt.isCanTradeMaps())
ANewDawnOpt.setCanTradeVassals(not gc.getGame().isOption(GameOptionTypes.GAMEOPTION_NO_VASSAL_STATES))
gc.setDefineINT("CAN_TRADE_EMBASSIES", ANewDawnOpt.isCanTradeEmbassies())
gc.setDefineINT("CAN_TRADE_CONTACT", ANewDawnOpt.isCanTradeContact())
gc.setDefineINT("CAN_TRADE_CORPORATIONS", ANewDawnOpt.isCanTradeCorporations())
gc.setDefineINT("CAN_TRADE_PEACE", ANewDawnOpt.isCanTradePeace())
gc.setDefineINT("CAN_TRADE_WAR", ANewDawnOpt.isCanTradeWar())
gc.setDefineINT("CAN_TRADE_EMBARGO", ANewDawnOpt.isCanTradeEmbargo())
gc.setDefineINT("CAN_TRADE_CIVICS", ANewDawnOpt.isCanTradeCivics())
gc.setDefineINT("CAN_TRADE_RELIGIONS", ANewDawnOpt.isCanTradeReligions())
gc.setDefineINT("CAN_TRADE_OPEN_BORDERS", ANewDawnOpt.isCanTradeOpenBorders())
gc.setDefineINT("CAN_TRADE_LIMITED_BORDERS", ANewDawnOpt.isCanTradeLimitedBorders())
gc.setDefineINT("CAN_TRADE_DEFENSIVE_PACT", ANewDawnOpt.isCanTradeDefensivePact())
ANewDawnOpt.setCanTradeAlliance(gc.getGame().isOption(GameOptionTypes.GAMEOPTION_PERMANENT_ALLIANCES))
ANewDawnOpt.setAdvancedDiplomacy(gc.getGame().isOption(GameOptionTypes.GAMEOPTION_ADVANCED_DIPLOMACY))
def DumpStatus(self):
BugUtil.debug("StatusDump")
# open the status dump file
self.StatusDump_OpenFile()
# Year
zyear = self._getGameYear()
zsTurn = self._getGameTurn()
zCurrDateTime = time.strftime("%d-%b-%Y %H:%M:%S")
sMsg = BugUtil.getText("TXT_KEY_STATUS_DUMP_TURN", (zsTurn, zyear, zCurrDateTime))
self._writeMsg(sMsg, vColor="Black", vBold=False, vUnderline=True, vOpenSpoiler=sMsg, vCloseSpoiler=False)
# basic leader information
self.StatusDump_Basic()
# tech, culture, espionage, gold per turn info
self.StatusDump_Spinners()
# loop over each city
self.StatusDump_Player_Cities()
# loop over each unit
self.StatusDump_Player_Units()
# tech, culture, espionage, gold per turn info
self.StatusDump_AIs()
self._writeMsg(" ", vColor="Black", vBold=False, vUnderline=False, vOpenSpoiler="", vCloseSpoiler=True)
self.StatusDump_CloseFile()
def __init__(
self,
comment,
event,
handler=None,
sendFromPlayer=True,
sendToPlayer=True,
sendData=False,
sendArgs=False,
argFunc=None,
sendTrade=False,
tradeType=None,
):
self.comment = comment
self.eComment = gc.getInfoTypeForString(comment)
if self.eComment == -1:
raise BugUtil.ConfigError("invalid comment type %s" % comment)
self.event = event
self.sendFromPlayer = sendFromPlayer
self.sendToPlayer = sendToPlayer
self.sendData = sendData
self.sendArgs = sendArgs
self.argFunc = argFunc
self.sendTrade = sendTrade
self.tradeType = tradeType
if tradeType:
BugUtil.debug("DiplomacyUtil - mapped %s to %s with %s", comment, event, str(tradeType))
else:
BugUtil.debug("DiplomacyUtil - mapped %s to %s", comment, event)
g_eventsByCommentType[self.eComment] = self
g_eventManager.addEventHandler(event, handler)
def initHelpers ():
""" Initialize the helper data structures, clearing all previous data.
Because most of the functions in this module always start out checking
whether detection is necessary, this is stored in a global Boolean which
is set here based on game options and then directly accessed everywhere
else; it can be also accessed outside the module via an accessor function.
The other helper which is setup here is a dict of civics keyed on their
category. This is useful because the civic detection algorithms often
need to exclude either an entire category or all but one civic in a
given category. This data structure allows us to simply iterate over a
specific category instead of having to iterate over all civics each time.
"""
global gDetectionNecessary
gDetectionNecessary = gc.getGame().isOption(GameOptionTypes.GAMEOPTION_RANDOM_PERSONALITIES)
BugUtil.debug("FavoriteCivicDetector.initHelpers() gDetectionNecessary: %s" % (str(gDetectionNecessary)))
if gDetectionNecessary:
BugUtil.debug("FavoriteCivicDetector.initHelpers() initializing gCivicsByCategory")
global gCivicsByCategory
gCivicsByCategory = {}
for eCategory in range(gc.getNumCivicOptionInfos()):
gCivicsByCategory[eCategory] = set()
for eCivic in range(gc.getNumCivicInfos()):
gCivicsByCategory[gc.getCivicInfo(eCivic).getCivicOptionType()].add(eCivic)
def dispatch(self, eFromPlayer, eToPlayer, args):
data = diplo.getData()
BugUtil.debug("DiplomacyUtil - %s [%d] from %d to %d with %r", self.comment, data, eFromPlayer, eToPlayer, args)
argList = []
if self.sendFromPlayer:
argList.append(eFromPlayer)
if self.sendToPlayer:
argList.append(eToPlayer)
if self.argFunc:
argList.extend(self.argFunc(eFromPlayer, eToPlayer, args, data))
BugUtil.debug("DiplomacyUtil - firing %s", self.event)
else:
if self.sendData:
argList.append(data)
if self.sendArgs:
argList.append(args)
if self.sendTrade or self.tradeType:
trade = getProposedTrade()
if self.sendTrade:
argList.append(trade)
if self.tradeType:
trades = trade.findType(self.tradeType)
if trade and trades:
iData = trades[0].iData
BugUtil.debug("DiplomacyUtil - firing %s with %s %d", self.event, str(self.tradeType), iData)
argList.append(iData)
else:
BugUtil.debug("DiplomacyUtil - firing %s without %s", self.event, str(self.tradeType))
argList.append(-1)
else:
BugUtil.debug("DiplomacyUtil - firing %s", self.event)
g_eventManager.fireEvent(self.event, *argList)
def __delitem__(self, key):
BugUtil.debug("BugData - del %s.%s", self, key)
try:
del self.data[key]
self.dirty = True
except:
pass
def _getRemoteRevision(url):
"""
Parses and returns the revision number from a remote SVN repository.
The URL must be correctly escaped (+ for space, etc).
A BugError exception is raised if the URL can't be connected to or it doesn't
have the expected format.
This function looks specifically for the string 'Revision: ####' anywhere
in the first MAX_READ_LINES
"""
try:
timer = BugUtil.Timer("SvnUtil.getRevision")
try:
BugUtil.debug("SvnUtil.getRevision - opening '%s'", url)
web = urllib.urlopen(urllib.quote(url, "/:"))
count = 0
try:
for line in web:
result = REVISION_PATTERN.search(line)
if result:
BugUtil.debug("SvnUtil.getRevision - found '%s'", result.group())
try:
return int(result.group(1))
except ValueError:
raise BugUtil.BugError("invalid SVN revision format '%s'"
% result.group(1))
count += 1
if count > MAX_READ_LINES:
return None
finally:
web.close()
except IOError, e:
raise BugUtil.BugError("failed to access SVN repository: %s" % str(e))
return None
def addOption(self, option):
"""Adds an Option to the dictionary if its ID doesn't clash."""
if option.id in self.options:
BugUtil.error("BugOptions - duplicate option %s", option.id)
else:
self.options[option.id] = option
BugUtil.debug("BugOptions - added option %s", str(option))
def __init__(self, eventManager):
BugUtil.debug(
"FavoriteCivicDetector.__init__(). Resetting data and initing event manager."
)
initHelpers()
eventManager.addEventHandler('BeginActivePlayerTurn',
self.onBeginActivePlayerTurn)
eventManager.addEventHandler("GameStart", self.onGameStart)
eventManager.addEventHandler("OnLoad", self.onLoadGame)
eventManager.addEventHandler("OnPreSave", self.onPreSave)
eventManager.addEventHandler("CivicDemanded", self.onCivicDemanded)
def onHelpDemanded(argsList):
#BugUtil.debug("DiplomacyUtil::onHelpDemanded %s" %(str(argsList)))
eDemandPlayer, eTargetPlayer, pTrade = argsList
szItems = ""
for i in range(pTrade.getCount()):
szItems = szItems + TradeUtil.format(eTargetPlayer, pTrade.getTrade(i))
BugUtil.debug(
"DiplomacyUtil - %s requests help (%s) from %s",
PlayerUtil.getPlayer(eDemandPlayer).getCivilizationShortDescription(0),
szItems,
PlayerUtil.getPlayer(eTargetPlayer).getCivilizationShortDescription(0))
def store():
global g_values, g_iTurn
g_iTurn = gc.getGame().getGameTurn()
g_values = getCurrentValuesByTeam()
data = {
SD_VERSION_ID: STORAGE_VERSION,
SD_TURN_ID: g_iTurn,
SD_VALUES_ID: g_values
}
BugData.getTable(SD_MOD_ID).setData(data)
BugUtil.debug("SpyUtil - stored: %s", data)
def addEvent(self, eventType):
"""Creates a new event type without any handlers.
Prints a warning if eventType is already defined.
"""
if self.hasEvent(eventType):
BugUtil.warn("BugEventManager - event '%s' already defined",
eventType)
else:
BugUtil.debug("BugEventManager - adding event '%s'", eventType)
self.EventHandlerMap[eventType] = []
def determineNewConceptSubCategory(self, iItem):
info = gc.getNewConceptInfo(iItem)
BugUtil.debug("NewConcept itme %d is %s" %
(iItem, info.getDescription()))
if (self.isTraitInfo(info)):
return SevoScreenEnums.PEDIA_TRAITS
if (self.isStrategyInfo(info)):
return SevoScreenEnums.PEDIA_STRATEGY
if (self.isShortcutInfo(info)):
return SevoScreenEnums.PEDIA_SHORTCUTS
return SevoScreenEnums.PEDIA_BTS_CONCEPTS
def init():
BugUtil.debug("Barbarian Diplomacy INIT.")
global gb_NoGoodyHuts
gb_NoGoodyHuts = CyGame().isOption(GameOptionTypes.GAMEOPTION_NO_GOODY_HUTS)
global giIndigenousPeopleImprovement
giIndigenousPeopleImprovement = gc.getInfoTypeForString("IMPROVEMENT_INDIGENOUS_COMMUNITY")
global gaIPattitude2Player
gaIPattitude2Player = []
def onTributeRejected(argsList):
#BugUtil.debug("DiplomacyUtil::onTributeRejected %s" %(str(argsList)))
eTargetPlayer, eDemandPlayer, pTrade = argsList
szItems = ""
for i in range(pTrade.getCount()):
szItems = szItems + TradeUtil.format(eTargetPlayer, pTrade.getTrade(i))
BugUtil.debug(
"DiplomacyUtil - %s refuses to give tribute (%s) to %s",
PlayerUtil.getPlayer(eTargetPlayer).getCivilizationShortDescription(0),
szItems,
PlayerUtil.getPlayer(eDemandPlayer).getCivilizationShortDescription(0))
def setPopupHandler(self, eventType, handler):
"""Removes all previously installed popup handlers for the given event type and installs a new pair of handlers.
The eventType should be an integer.
It must be unique with respect to the integers assigned to built in events.
The popupHandler should be a list made up of (name, applyFunction, beginFunction).
The name is used in debugging output.
The begin and apply functions are invoked by beginEvent and applyEvent,
respectively, to manage a popup dialog in response to the event.
"""
BugUtil.debug("BugEventManager - setting popup handler for event %s (%d)", handler[0], eventType)
self.Events[eventType] = handler
def removePopupHandler(self, eventType):
"""Removes all previously installed popup handlers for the given
event type.
The eventType should be an integer. It is an error to fire this
eventType after removing its handlers.
"""
if eventType in self.Events:
BugUtil.debug("BugEventManager - removing popup handler for event %d", eventType)
del self.Events[eventType]
else:
BugUtil.warn("BugEventManager - event %d has no popup handler", eventType)
def _addModuleUtils(self, utils, override=False, log=None):
# Registers all of the handler and listener functions in <utils> that match existing callbacks.
BugUtil.debug("BugGameUtils - registering %s", utils.__name__)
for name, func in utils.__dict__.iteritems():
if not name.startswith("_") and isinstance(func, types.FunctionType):
if name.endswith("Listener"):
name = name[:-len("Listener")]
if name in self._callbacks:
self._addListener(name, func, log)
else:
if name in self._callbacks:
self._addHandler(name, func, override, log)
def onKbdEvent(self, argsList):
eventType, key, mx, my, px, py = argsList
# BugUtil.debug("StatusDump-Start-1")
if (eventType == self.eventMgr.EventKeyDown
and int(key) == int(InputTypes.KB_D) and self.eventMgr.bCtrl
and self.eventMgr.bAlt):
BugUtil.debug("StatusDump-Start-2")
self.DumpStatus()
return 1
def setValue(self, value, *args):
"""Sets the value and calls onChanged() if different.
Sets it to the default if value is None.
"""
if value is None:
value = self.getDefault()
BugUtil.debug("AbstractOption - setting %s to its default %s", self.getID(), value)
else:
BugUtil.debug("AbstractOption - setting %s to %s", self.getID(), value)
if self._setValue(value, *args):
self.onChanged(*args)
def _createCallback(self, name, func, default=None, log=None):
if log is None:
log = self._log
if default is not None:
BugUtil.debug(
"BugGameUtils - creating callback %s with default %s", name,
default)
else:
BugUtil.debug("BugGameUtils - creating callback %s", name)
callback = Callback(name, func, default, log)
self._callbacks[name] = callback
setattr(self.__class__, name, callback)
def init():
"""
Initializes the entire module.
"""
BugUtil.debug("BugPath - initializing...")
initAppFolder()
initModName()
initModFolder()
initNoCustomAssetsSetting()
initRootFolder()
initDataFolder()
initSearchPaths()
def enabledOptionChanged(pIniObject, bNewValue):
""" Handler function for processing changes to the Enabled option. """
BugUtil.debug(
"EventSigns.enabledOptionsChanged(%s, %s) resetting g_bShowSigns." %
(str(pIniObject), str(bNewValue)))
global g_bShowSigns
if g_bShowSigns != bNewValue:
g_bShowSigns = bNewValue
if gSavedSigns == None:
initData()
gSavedSigns.processSigns(g_bShowSigns)
return True
def _setWidgetHelp(widget, type, func):
"""
Registers the hover text <func> for <widget> if it hasn't been already.
Do not call this function as it is used internally by the registration functions above.
"""
if widget in g_widgetHelp:
BugUtil.warn("WidgetTypes %d help already registered", widget)
else:
BugUtil.debug(
"WidgetUtil - registering %s hover help for WidgetTypes %d: %s",
type, widget, func)
g_widgetHelp[widget] = func
def showContents(self, bForce=False, iCategory=PEDIA_TECHS):
self.deleteAllWidgets()
BugUtil.debug("Drawing category list")
self.placeCategories(iCategory)
screen = self.getScreen()
screen.show(self.BACK_ID)
screen.show(self.NEXT_ID)
if self.iCategory != iCategory or bForce:
BugUtil.debug("Drawing item list %d" % iCategory)
self.mapListGenerators.get(iCategory)()
self.iCategory = iCategory
self.iItem = -1
self.iItemIndex = -1
def loadMod(name):
"""Load the given mod from its XML file using a custom parser."""
path = BugPath.findAssetFile(name + ".xml", "Config")
if path:
BugUtil.debug("BugInit - loading mod %s...", name)
parser = BugConfig.ConfigParser()
timer = BugUtil.Timer("load mod")
try:
parser.parse(path)
finally:
timer.log(name)
else:
BugUtil.error("BugInit - cannot find XML file for mod %s", name)
def triggerRandomEvent(argsList):
id = argsList[0]
iData1 = argsList[1]
BugUtil.debug("args: %r", argsList)
type = None
if id < gc.getNumEventTriggerInfos():
type = gc.getEventTriggerInfo(id).getType()
else:
return
BugUtil.alert("Event: %s [%d]", type, id)
pPlayer = PlayerUtil.getPlayer(iData1)
pPlayer.trigger(id)
def onKbdEvent(self, argsList):
"""
Handles onKbdEvent by firing the keystroke's handler if it has one registered.
"""
eventType, key, mx, my, px, py = argsList
if eventType == self.EventKeyDown:
if not InputUtil.isModifier(key):
stroke = InputUtil.Keystroke(key, self.bAlt, self.bCtrl, self.bShift)
if stroke in self.shortcuts:
BugUtil.debug("BugEventManager - calling handler for shortcut %s", stroke)
self.shortcuts[stroke](argsList)
return 1
return 0
def removeCity(self, ePlayer, city):
"""
Removes the city from the data set and erases its dot and cross.
"""
if city:
BugUtil.debug("DotMap - removing city %s", city)
del self.getCities(ePlayer)[city.point]
self.dirty = True
if ePlayer == PlayerUtil.getActivePlayerID():
self.redrawCrosses(city.layer)
self.eraseDot(city, self.DOT_ALPHA)
else:
BugUtil.warn("City doesn't exist")
def __init__(self, eventManager):
BugUtil.debug(
"EventSigns EventSignsEventHandler.__init__(). Resetting data and initing event manager."
)
initOptions()
initData()
## Init event handlers
eventManager.addEventHandler("GameStart", self.onGameStart)
eventManager.addEventHandler("OnLoad", self.onLoadGame)
eventManager.addEventHandler("OnPreSave", self.onPreSave)
eventManager.addEventHandler("plotRevealed", self.onPlotRevealed)
eventManager.addEventHandler("BeginActivePlayerTurn",
self.onBeginActivePlayerTurn)
def getKnownTrainableUnits(playerOrID,
askingPlayerOrID,
knowableUnits,
bonuses,
military=None):
player, team = PlayerUtil.getPlayerAndTeam(playerOrID)
askingPlayer = PlayerUtil.getPlayer(askingPlayerOrID)
eAskingTeam, askingTeam = PlayerUtil.getPlayerTeamAndID(askingPlayer)
#trade = player.canTradeNetworkWith(askingPlayer.getID())
cities = PlayerUtil.getPlayerCities(
player, lambda city: city.isRevealed(eAskingTeam, False))
# separate units into two groups: yes and maybe
units = getTrainableUnits(playerOrID, knowableUnits, False, military)
yesUnits = set()
maybeUnits = set()
BugUtil.debug("-----------------------")
for eUnit in units:
if not canAnyCityBuildUnit(eUnit, cities, eAskingTeam, False):
BugUtil.debug(" no %s", gc.getUnitInfo(eUnit).getDescription())
elif hasBonusesForUnit(eUnit, bonuses):
BugUtil.debug(" yes %s", gc.getUnitInfo(eUnit).getDescription())
yesUnits.add(eUnit)
elif bonuses is None:
BugUtil.debug(" maybe %s", gc.getUnitInfo(eUnit).getDescription())
maybeUnits.add(eUnit)
return yesUnits, maybeUnits
def initDataFolder():
"""
Finds the first directory that contains a folder named SETTINGS_FOLDER.
"""
global _dataFolderInitDone
if _dataFolderInitDone:
return
BugUtil.debug("BugPath - initializing data folder")
# K-Mod. If it doesn't already exist, create the folder in the user directory.
dir = join(getRootDir(), getModName(), SETTINGS_FOLDER)
if dir != None:
if not isdir(dir):
# copy the default settings from the K-Mod folder.
default_dir = join(getModDir(), SETTINGS_FOLDER)
if isdir(default_dir):
try:
safeInfoPath("BugPath - copying settings to '%s'", dir)
# copytree is suppose to create the missing parent directores, but apparently it doesn't work. So I need to do this:
try:
os.makedirs(join(getRootDir(), getModName()))
except OSError:
pass
# sucks.
shutil.copytree(default_dir, dir)
except:
BugUtil.trace("Failed to copy settings")
if not isdir(dir):
# Second attempt: create the directory manually
try:
safeInfoPath("BugPath - creating '%s'", dir)
os.makedirs(dir)
except OSError:
BugUtil.trace("Failed to create directory '%s'", dir)
# K-Mod end
dataDirs = (
join(getRootDir(), getModName()), # My Games\BTS\BUG Mod
join(getUserDir(), getModName()), # My Games\BUG Mod
join(getAppDir(), getModName()), # Civ4\BTS\BUG Mod
join(getModDir(), DATA_FOLDER), # Civ4\BTS\Mods\BUG Mod 3.6\Data
join(getModDir()), # Civ4\BTS\Mods\BUG Mod 3.6
)
for dir in dataDirs:
if setDataDir(dir):
break
else:
BugUtil.error("No valid data directory containing %s found",
SETTINGS_FOLDER)
_dataFolderInitDone = True
def updateCurrentSigns ():
""" Updates gCurrentSigns global with all current signs on map. Remember to clear when done."""
global gCurrentSigns
gCurrentSigns = MapSigns()
for iSign in range(engine.getNumSigns()):
pSign = engine.getSignByIndex(iSign)
pPlot = pSign.getPlot()
ePlayer = pSign.getPlayerType()
szCaption = pSign.getCaption()
if not gCurrentSigns.hasPlotSigns(pPlot):
gCurrentSigns[pPlot] = PlotSigns(pPlot)
gCurrentSigns[pPlot].setSign(ePlayer, szCaption)
BugUtil.debug("EventSigns.updateCurrentSigns() finished.\n %s" % (str(gCurrentSigns)))
return True
def initFractionalTrade():
"""
Sets the global fractional trade constants by testing for the function it adds.
Fractional Trade is an optional compile-time feature of BULL.
"""
global FRACTIONAL_TRADE, TRADE_PROFIT_FUNC
try:
TRADE_PROFIT_FUNC = CyCity.calculateTradeProfitTimes100
FRACTIONAL_TRADE = True
BugUtil.debug("TradeUtil - Fractional Trade Routes is active")
except:
TRADE_PROFIT_FUNC = CyCity.calculateTradeProfit
FRACTIONAL_TRADE = False
def addSign(self):
"""
Puts sign down on game interface
"""
if not self.isAdded:
if gc.getMap().plot(self.plotX,self.plotY):
self.plot = gc.getMap().plot(self.plotX,self.plotY)
else:
BugUtil.debug("Invalid Plot for sign at " + str(self.plotX) + "," + str(self.plotY))
self.playerType = gc.getGame().getActivePlayer()
CyEngine().addSign(self.plot,self.playerType,self.text)
self.isAdded = True
else:
BugUtil.debug("Tried to add sign already added to interface")
def __call__(self, argsList=None):
for handler in self.handlers:
if self.log:
BugUtil.debug("BugGameUtils - %s - dispatching to %s handler",
self.name, handler.__module__)
result = self.callHandler(handler, argsList)
if result is not None and result != self.default:
break
else:
if self.default is not None:
if self.log:
BugUtil.debug("BugGameUtils - %s - using default %s",
self.name, self.default)
result = self.default
else:
if self.log:
BugUtil.debug(
"BugGameUtils - %s - dispatching to base handler",
self.name)
result = self.callHandler(self.baseHandler, argsList)
if result is not None:
for listener in self.listeners:
if self.log:
BugUtil.debug("BugGameUtils - %s - calling %s listener",
self.name, listener.__module__)
self.callListener(listener, argsList, result)
else:
BugUtil.error("BugGameUtils - %s - no handler returned a value",
self.name)
return result
def displaySign(self, pPlot, ePlayer):
""" Displays stored sign for given player at given plot based on revealed status.
If there's a pre-existing sign, engine.addSign will silently fail, leaving the plot unchanged.
"""
if not g_bShowSigns:
BugUtil.debug(
"MapSigns.displaySign() called but EventSigns is disabled.")
return False
if not pPlot or pPlot.isNone():
BugUtil.warn(
"MapSigns.displaySign() was passed an invalid plot: %s" %
(str(pPlot)))
return False
thisKey = self.__getKey(pPlot)
szCaption = ""
if self.hasPlotSigns(pPlot):
szCaption = self.plotDict[thisKey].getSign(ePlayer)
else:
#BugUtil.debug("MapSigns.displaySign() could not show sign; we don't have any saved signs on plot %s" % (str(thisKey)))
return False
if not szCaption:
BugUtil.debug(
"MapSigns.displaySign() could not show sign; no caption found for player %d on plot %s"
% (ePlayer, str(thisKey)))
return False
if ePlayer == -1:
BugUtil.debug(
"MapSigns.displaySign() landmark (%s) shown on plot %s" %
(szCaption, ePlayer, str(thisKey)))
engine.addLandmark(pPlot, szCaption.encode('latin_1'))
else:
pPlayer = gc.getPlayer(ePlayer)
if not pPlayer or pPlayer.isNone():
BugUtil.warn(
"MapSigns.displaySign() was passed an invalid player id: %s"
% (str(ePlayer)))
return False
eTeam = pPlayer.getTeam()
if pPlot.isRevealed(eTeam, False):
BugUtil.debug(
"MapSigns.displaySign() sign (%s) shown for player %d on plot %s"
% (szCaption, ePlayer, str(thisKey)))
engine.addSign(pPlot, ePlayer, szCaption.encode('latin_1'))
return True
else:
BugUtil.debug(
"MapSigns.displaySign() could not show sign; player %d cannot see plot %s"
% (ePlayer, str(thisKey)))
return False
def _addClassUtils(self, utils, override=False, log=None):
"""
Registers all of the handler and listener functions in <utils> that match existing callbacks.
"""
clazz = utils.__class__
BugUtil.debug("BugGameUtils - registering %s.%s", clazz.__module__, clazz.__name__)
for name, func in clazz.__dict__.iteritems():
if not name.startswith("_") and isinstance(func, types.FunctionType):
if name.endswith(LISTENER_SUFFIX):
name = name[:-len(LISTENER_SUFFIX)]
if name in self._callbacks:
self._addBoundListener(name, utils, func, log)
else:
if name in self._callbacks:
self._addBoundHandler(name, utils, func, override, log)
