def onCityAcquired(self, argsList): iPreviousOwner, iNewOwner, city, bConquest, bTrade = argsList if not gc.getGame().isVictoryValid(iHistoricalVictory): return iYear = utils.getYear() return
def checkName(self, iPlayer):
return
#print "checkName"
if iPlayer >= iNumPlayers:
return
if not gc.getPlayer(iPlayer).isAlive:
return
bVassal = utils.isAVassal(iPlayer)
pPlayer = gc.getPlayer(iPlayer)
iReligion = pPlayer.getStateReligion()
capital = gc.getPlayer(iPlayer).getCapitalCity()
iGameTurn = gc.getGame().getGameTurn()
iCivilization = sd.getCivilization(iPlayer)
# 3 kingdoms > respawn > capital > religion > empire > vassal
if iPlayer == con.iJin:
if gc.getPlayer(con.iQin).isAlive() and gc.getPlayer(
con.iHan).isAlive():
self.setCivDesc(iPlayer, self.SpecialNames[iPlayer])
return
if iPlayer in [con.iRome, con.iByzantines]:
if utils.getYear() >= con.tBirth[con.iByzantines] and gc.getPlayer(
con.iByzantines).isAlive():
self.setCivDesc(iPlayer, self.SpecialNames[iPlayer])
self.setCivDesc(con.iByzantines,
self.SpecialNames[con.iByzantines])
return
#if iPlayer == con.iByzantines and utils.isActive(con.iRome) and sd.getCivilization(con.iByzantines) == con.iByzantines:
#self.setCivDesc(iPlayer, self.SpecialNames[iPlayer])
#self.setCivDesc(con.iRome, self.SpecialNames[con.iRome])
#return
# by vassalage
if bVassal and iCivilization in self.vassalNames:
szName = self.vassalNames[iCivilization]
else:
szName = self.defaultNames[iCivilization]
# by status (empires)
if not bVassal:
iCivic = pPlayer.getCivics(0)
if iCivilization in self.empireNames:
minCities = 5
if iCivic == con.iEmpireCivic or pPlayer.getNumCities(
) >= minCities:
if pPlayer.getNumCities() >= (minCities):
szName = self.empireNames[iCivilization]
self.setCivDesc(iPlayer, szName)
def foundCity(self, iCiv, sName, iX, iY, lReligions=[], lCorporations =[], lBuildings=[]):
#print ("CITY:", sName, "lReligions=", lReligions, "lCorporations=", lCorporations, "lBuildings=", lBuildings)
if not self.checkRegion(iX, iY):
return None
pCiv = gc.getPlayer(iCiv)
pCiv.initCity(iX, iY)
city = gc.getMap().plot(iX, iY).getPlotCity()
if not city or city.isNone():
return None
city.setName(sName, False)
if utils.getYear() < -100:
pCiv.initUnit(con.iMilitiaSpearman, iX, iY, UnitAITypes.NO_UNITAI, DirectionTypes.DIRECTION_SOUTH)
elif utils.getYear() < 100:
pCiv.initUnit(con.iSpearman, iX, iY, UnitAITypes.NO_UNITAI, DirectionTypes.DIRECTION_SOUTH)
else:
pCiv.initUnit(con.iHeavySpearman, iX, iY, UnitAITypes.NO_UNITAI, DirectionTypes.DIRECTION_SOUTH)
if utils.getYear() < 0:
pCiv.initUnit(con.iArcher, iX, iY, UnitAITypes.NO_UNITAI, DirectionTypes.DIRECTION_SOUTH)
elif utils.getYear() < 200:
pCiv.initUnit(con.iBowman, iX, iY, UnitAITypes.NO_UNITAI, DirectionTypes.DIRECTION_SOUTH)
else:
pCiv.initUnit(con.iHeavyBowman, iX, iY, UnitAITypes.NO_UNITAI, DirectionTypes.DIRECTION_SOUTH)
for iReligion in lReligions:
city.setHasReligion(iReligion, True, False, False)
for iCorporation in lCorporations:
city.setHasCorporation(iCorporation, True, False, False)
for iBuilding in lBuildings:
city.setNumRealBuilding(iBuilding, 1)
UnitArtStyler.updateUnitArtAtPlot(city.plot())
return city
def onGoldenAge(self, argsList):
'Golden Age'
iPlayer = argsList[0]
if iPlayer < iNumPlayers:
self.vic.onGoldenAge(iPlayer)
print("STABILITY RESET GA, iPlayer=",
gc.getPlayer(iPlayer).getCivilizationShortDescription(0),
"year=", utils.getYear())
pTeam = gc.getTeam(gc.getPlayer(iPlayer).getTeam())
pTeam.setHasTech(con.iStabilityStable, True, iPlayer, False,
False) ## srpt stability conversion
pTeam.setHasTech(con.iStabilityUnstable, False, iPlayer, False,
False)
pTeam.setHasTech(con.iStabilityCollapsing, False, iPlayer, False,
False)
def onRevolution(self, argsList):
'Called at the start of a revolution'
iPlayer = argsList[0]
if iPlayer < iNumPlayers:
self.dc.onRevolution(iPlayer)
if iPlayer < iNumPlayers:
self.rfccwaiw.onRevolution(iPlayer)
if iPlayer < iNumPlayers and gc.getPlayer(iPlayer).getNumCities(
) > 1 and gc.getPlayer(iPlayer).getGoldenAgeTurns() < 1:
utils.setCivicsStability(iPlayer)
print("STABILITY CHECK revolution, iPlayer=",
gc.getPlayer(iPlayer).getCivilizationShortDescription(0),
"year=", utils.getYear())
utils.stabilityCheck(iPlayer, 0)
def onTechAcquired(self, argsList):
'Tech Acquired'
iTechType, iTeam, iPlayer, bAnnounce = argsList
if iPlayer < iNumPlayers and iTechType not in [
con.iStabilityStable, con.iStabilityUnstable,
con.iStabilityCollapsing
]:
self.vic.onTechAcquired(iTechType, iPlayer) # Franks
self.res.onTechAcquired(iTechType)
self.rel.onTechAcquired(iTechType, iPlayer)
if iPlayer < con.iNumMajPlayers and gc.getPlayer(
iPlayer).getNumCities() > 1 and utils.getYear() > (
con.tBirth[sd.getCivilization(iPlayer)]
) + 50 and iTechType in con.lStabilityTechs:
#if iPlayer < con.iNumMajPlayers:
#if gc.getPlayer(iPlayer).getNumCities() > 1:
#print ("ERROR iPlayer=", iPlayer, "sd.getCivilization(iPlayer)", sd.getCivilization(iPlayer))
#if utils.getYear() > (con.tBirth[sd.getCivilization(iPlayer)]) + 50:
if utils.getYear() < con.tFall[iPlayer]:
if (sd.getLastRebellion(iPlayer)) < utils.getYear() - 30:
print(
"STABILITY CHECK tech, iPlayer=",
gc.getPlayer(
iPlayer).getCivilizationShortDescription(0),
"year=", utils.getYear())
utils.stabilityCheck(iPlayer, 0)
else:
if (sd.getLastRebellion(iPlayer)) < utils.getYear() - 10:
print(
"STABILITY CHECK tech, iPlayer=",
gc.getPlayer(
iPlayer).getCivilizationShortDescription(0),
"year=", utils.getYear())
utils.stabilityCheck(iPlayer, 0)
if iTechType == con.iTheStirrup:
gc.getTeam(gc.getPlayer(iPlayer).getTeam()).setHasTech(
con.iTrajansColumnFunctionTech, False, utils.getHumanID(),
False, False)
def onCityAcquired(self, argsList):
'City Acquired'
iPreviousOwner, iNewOwner, city, bConquest, bTrade = argsList
pNewOwner = gc.getPlayer(iNewOwner)
#print ("city acquired", city.getName(), "year=", utils.getYear())
#print ("iNewOwner=", gc.getPlayer(iNewOwner).getCivilizationShortDescription(0), "iPreviousOwner=", gc.getPlayer(iPreviousOwner).getCivilizationShortDescription(0))
self.cnm.renameCity(city, iNewOwner)
self.rnf.checkCapitalsOnCapture(
city, iNewOwner) # edead: free capital move for the AI
if bConquest:
if iNewOwner != con.iBarbarian or not (gc.getTeam(
gc.getPlayer(iPreviousOwner).getTeam()).isHasTech(
con.iTrajansColumnFunctionTech)):
if iPreviousOwner < con.iNumPlayers and gc.getPlayer(
iPreviousOwner).getNumCities() >= 1 and gc.getPlayer(
iPreviousOwner).getGoldenAgeTurns() < 1:
if utils.getYear() < con.tFall[iPreviousOwner]:
if (sd.getLastRebellion(iPreviousOwner)
) < utils.getYear() - 5:
print("STABILITY CHECK city lost iNewOwner=",
iNewOwner, "iPreviousOwner=", iPreviousOwner,
"year=", utils.getYear())
regionID = gc.getMap().plot(
city.getX(), city.getY()).getRegionID()
if regionID in utils.getCoreRegions(
sd.getCivilization(iPreviousOwner)):
utils.stabilityCheck(iPreviousOwner, -3)
elif regionID in utils.getNormalRegions(
sd.getCivilization(iPreviousOwner)):
if not (gc.getTeam(
gc.getPlayer(iPreviousOwner).getTeam()
).isHasTech(con.iStabilityStable)):
utils.stabilityCheck(iPreviousOwner, -2)
else:
if not (gc.getTeam(
gc.getPlayer(iPreviousOwner).getTeam()
).isHasTech(con.iStabilityStable)):
utils.stabilityCheck(iPreviousOwner, -1)
else:
print("STABILITY CHECK city lost iNewOwner=",
iNewOwner, "iPreviousOwner=", iPreviousOwner,
"year=", utils.getYear())
regionID = gc.getMap().plot(city.getX(),
city.getY()).getRegionID()
if regionID in utils.getCoreRegions(
sd.getCivilization(iPreviousOwner)):
utils.stabilityCheck(iPreviousOwner, -3)
elif regionID in utils.getNormalRegions(
sd.getCivilization(iPreviousOwner)):
if not (gc.getTeam(
gc.getPlayer(iPreviousOwner).getTeam()).
isHasTech(con.iStabilityStable)):
utils.stabilityCheck(iPreviousOwner, -2)
else:
if not (gc.getTeam(
gc.getPlayer(iPreviousOwner).getTeam()).
isHasTech(con.iStabilityStable)):
utils.stabilityCheck(iPreviousOwner, -1)
if iNewOwner < iNumPlayers:
utils.spreadMajorCulture(iNewOwner, city.getX(), city.getY())
#self.pla.onCityAcquired(iPreviousOwner, iNewOwner, city)
self.dc.onCityAcquired(argsList)
self.rel.onCityAcquired(argsList)
self.vic.maccabeanCheck()
self.corp.onCityAcquired(argsList)
self.vic.onCityAcquired(argsList)
self.rfccwaiw.onCityAcquired(argsList)
self.rnf.onCityAcquired(argsList)
# Move the palace to historical backup capital
if iPreviousOwner < iNumPlayers:
if (city.getX(), city.getY()) == con.tCapitals[iPreviousOwner]:
self.rnf.moveCapital(con.tBackupCapitals[iPreviousOwner],
iPreviousOwner, True)
def onCityRazed(self, argsList):
'City Razed'
city, iPlayer = argsList
iPreviousOwner = city.getOwner()
#print ("onCityRazed", city.getName(), "iPlayer=", gc.getPlayer(iPlayer).getCivilizationShortDescription(0), "iPreviousOwner=", gc.getPlayer(iPreviousOwner).getCivilizationShortDescription(0), "year=", utils.getYear())
if iPreviousOwner == iPlayer and city.getPreviousOwner() != -1:
iPreviousOwner = city.getPreviousOwner()
#self.pla.onCityRazed(argsList)
self.rel.onCityRazed(argsList)
self.rfccwaiw.onCityRazed(argsList)
if iPlayer != con.iBarbarian or not (gc.getTeam(
gc.getPlayer(iPreviousOwner).getTeam()).isHasTech(
con.iTrajansColumnFunctionTech)):
if iPreviousOwner < con.iNumPlayers and gc.getPlayer(
iPreviousOwner).getNumCities() > 1 and gc.getPlayer(
iPreviousOwner).getAnarchyTurns() < 1 and gc.getPlayer(
iPreviousOwner).getGoldenAgeTurns() < 1:
if utils.getYear() < con.tFall[iPreviousOwner]:
if (sd.getLastRebellion(iPreviousOwner)
) < utils.getYear() - 5:
print(
"STABILITY CHECK city razed iPreviousOwner=",
gc.getPlayer(iPreviousOwner).
getCivilizationShortDescription(0), "year=",
utils.getYear())
regionID = gc.getMap().plot(city.getX(),
city.getY()).getRegionID()
if regionID in utils.getCoreRegions(
sd.getCivilization(iPreviousOwner)):
utils.stabilityCheck(iPreviousOwner, -3)
elif regionID in utils.getNormalRegions(
sd.getCivilization(iPreviousOwner)):
if not (gc.getTeam(
gc.getPlayer(iPreviousOwner).getTeam()).
isHasTech(con.iStabilityStable)):
utils.stabilityCheck(iPreviousOwner, -2)
else:
if not (gc.getTeam(
gc.getPlayer(iPreviousOwner).getTeam()).
isHasTech(con.iStabilityStable)):
utils.stabilityCheck(iPreviousOwner, -1)
else:
print(
"STABILITY CHECK city razed iPreviousOwner=",
gc.getPlayer(
iPreviousOwner).getCivilizationShortDescription(0),
"year=", utils.getYear())
regionID = gc.getMap().plot(city.getX(),
city.getY()).getRegionID()
if regionID in utils.getCoreRegions(
sd.getCivilization(iPreviousOwner)):
utils.stabilityCheck(iPreviousOwner, -3)
elif regionID in utils.getNormalRegions(
sd.getCivilization(iPreviousOwner)):
if not (gc.getTeam(
gc.getPlayer(iPreviousOwner).getTeam()).
isHasTech(con.iStabilityStable)):
utils.stabilityCheck(iPreviousOwner, -2)
else:
if not (gc.getTeam(
gc.getPlayer(iPreviousOwner).getTeam()).
isHasTech(con.iStabilityStable)):
utils.stabilityCheck(iPreviousOwner, -1)
if iPlayer < con.iNumPlayers and gc.getPlayer(
iPreviousOwner).getNumCities() > 1 and gc.getPlayer(
iPreviousOwner).getAnarchyTurns(
) < 1 and gc.getPlayer(
iPreviousOwner).getGoldenAgeTurns() < 1:
print(
"STABILITY CHECK city razed iPlayer=",
gc.getPlayer(iPlayer).getCivilizationShortDescription(
0), "year=", utils.getYear())
regionID = gc.getMap().plot(city.getX(),
city.getY()).getRegionID()
if regionID in utils.getCoreRegions(
sd.getCivilization(iPlayer)):
utils.stabilityCheck(iPlayer, -9)
elif regionID in utils.getNormalRegions(
sd.getCivilization(iPlayer)):
utils.stabilityCheck(iPlayer, -6)
else:
utils.stabilityCheck(iPlayer, -3)
# Refugees
sd.setVal('tRazedCityData',
(city.getX(), city.getY(), city.getNameKey()))
def stabilityCheck(iPlayer, iAdjustment=0):
#print "stabilityCheck called"
#CyInterface().addMessage(utils.getHumanID(), True, iDuration, CyTranslator().getText("STABILITY CHECK", ()) + " " + gc.getPlayer(iPlayer).getCivilizationDescription(0), "", 0, "", ColorTypes(iRed), -1, -1, True, True)
if (iPlayer > iNumPlayers):
return
pPlayer = gc.getPlayer(iPlayer)
pTeam = gc.getTeam(pPlayer.getTeam())
apCityList = PyPlayer(iPlayer).getCityList()
iCiv = sd.getCivilization(iPlayer)
iGameTurn = gc.getGame().getGameTurn()
iCivicGovernment = pPlayer.getCivics(0)
iCivicLegal = pPlayer.getCivics(1)
iCivicLabor = pPlayer.getCivics(2)
iCivicReligion = pPlayer.getCivics(4)
# calibrate the system here:
#iAdjustment -= 1
if utils.getYear() > tFall[iCiv]:
iAdjustment -= 3
if iPlayer == iRome and (tBirth[iByzantines] +
20) > utils.getYear() > (tBirth[iByzantines] -
20):
#print "pass on Byzantine birth"
return
if (iGameTurn < getTurnForYear(tBirth[iPlayer]) + 50):
#print "pass, too early"
return
if iPlayer == iRome and gc.getPlayer(iByzantines).isAlive(
) and sd.getCivilization(iByzantines) == iRebelRome:
#print "pass for Rome during civil war"
return
'''if pTeam.isHasTech(iStabilityCollapsing):
if iGameTurn > getTurnForYear(tFall[iCiv]):
print ("quick terminal crisis, iCiv=", gc.getPlayer(iPlayer).getCivilizationShortDescription(0), "year=", utils.getYear())
self.terminalCrisis(iPlayer, iCiv, pPlayer, pTeam)
return
else:
print ("quick severe crisis, iCiv=", gc.getPlayer(iPlayer).getCivilizationShortDescription(0), "year=", utils.getYear())
self.severeCrisis(iPlayer, iCiv, pPlayer, pTeam)
return'''
## CIVICS ##
# combinations of civics and state religions
# Civics
#print "CIVICS"
iCivicsRating = sd.getCivicsStability(iPlayer)
## HAPPINESS AND HEALTH ##
#print "HEALTH & HAPPINESS"
# balance of health and happiness per city, with extra penalty for angry citizens
iNumCities = pPlayer.getNumCities()
if iNumCities < 1: iNumCities = 1
iHappinessAndHealthRating = 0
#print ("total happy", pPlayer.calculateTotalCityHappiness(), "total unhappy", pPlayer.calculateTotalCityUnhappiness(), "cities", iNumCities)
#print ("total health", pPlayer.calculateTotalCityHealthiness(), "total unhealth", pPlayer.calculateTotalCityUnhealthiness(), "cities", iNumCities)
iHappiness = ((pPlayer.calculateTotalCityHappiness()) -
(pPlayer.calculateTotalCityUnhappiness())) / (iNumCities)
iHealth = ((pPlayer.calculateTotalCityHealthiness()) -
(pPlayer.calculateTotalCityUnhealthiness())) / (iNumCities)
#print ("iHappiness=", iHappiness, "iHealth=", iHealth)
if iHappiness < 0: iHappinessAndHealthRating -= 1
elif iHappiness > 3: iHappinessAndHealthRating += 1
if iHealth < 0: iHappinessAndHealthRating -= 1
elif iHealth > 3: iHappinessAndHealthRating += 1
if iPlayer == utils.getHumanID(): # I think this kills the AI unfairly
for pLoopCity in apCityList:
if (pLoopCity.GetCy().angryPopulation(0) > 0):
iHappinessAndHealthRating -= 1
#print "angry city"
## ECONOMY ##
#print "ECONOMY"
# balance of income and costs
iEconomyRating = 0
iRate = (pPlayer.calculateGoldRate() +
pPlayer.calculateBaseNetResearch()) - (
pPlayer.calculateInflatedCosts())
#print ("gold=", pPlayer.calculateGoldRate(), "research=", pPlayer.calculateBaseNetResearch(), "costs=", pPlayer.calculateInflatedCosts(), "iRate", iRate)
if iRate < -300: iEconomyRating -= 4
elif iRate < -200: iEconomyRating -= 3
elif iRate < -100: iEconomyRating -= 2
elif iRate < -20: iEconomyRating -= 1
elif iRate > +10: iEconomyRating += 1
elif iRate > +30: iEconomyRating += 2
#else:
#iEconomyRating += 2
#print "pass on savings"
## EMPIRE ##
#print "EMPIRE"
# balance of core and empire populations, mitigated by courthouses and civics
iEmpireRating = 0
bExiled = True
for regionID in utils.getCoreRegions(iCiv):
if (utils.checkRegionOwnedCity(iPlayer, regionID)):
bExiled = False
if not (utils.checkRegionControl(iPlayer, regionID)):
iEmpireRating -= 4
#print "core province not controlled"
if bExiled:
#print "Exiled"
self.terminalCrisis(iPlayer, iCiv, pPlayer, pTeam)
iCorePop = 0
iEmpirePop = 0
for pLoopCity in apCityList:
if not pLoopCity.isNone(): # possible fix for C++ exception
if pLoopCity.GetCy().isCapital():
iCorePop += pLoopCity.getPopulation() * 3
else:
regionID = gc.getMap().plot(
pLoopCity.GetCy().getX(),
pLoopCity.GetCy().getY()).getRegionID()
if regionID in utils.getCoreRegions(
iCiv) or regionID in utils.getSpecialRegions(iCiv):
iCorePop += pLoopCity.getPopulation() * 2
elif regionID in utils.getNormalRegions(iCiv):
iFactor = 1
if not (
(iCivicGovernment == iTheocracyCivic) and
(pLoopCity.GetCy().isHasReligion(iStateReligion))):
if iCivicGovernment != iEmpireCivic: iFactor += 1
if not (iCivicLegal == iBureaucracyCivic):
iFactor += 1
print "C++ exception, Normal Regions", (
"iPlayer = ",
iPlayer), ("Year = ", utils.getYear()), (
"Location = ", "(", pLoopCity.GetCy().getX(),
",", pLoopCity.GetCy().getY())
if not (pLoopCity.GetCy().getNumRealBuilding(
iCourthouse)):
print "Courthouse statement answered no"
iFactor += 1
else:
print "Courthouse statement answered yes"
iEmpirePop += pLoopCity.getPopulation() * iFactor
else:
iFactor = 2
if not (
(iCivicGovernment == iTheocracyCivic) and
(pLoopCity.GetCy().isHasReligion(iStateReligion))):
if iCivicGovernment != iEmpireCivic: iFactor += 1
if not (iCivicLegal == iBureaucracyCivic):
iFactor += 1
print "C++ exception, Other Regions", (
"iPlayer = ",
iPlayer), ("Year = ", utils.getYear()), (
"Location = ", "(", pLoopCity.GetCy().getX(),
",", pLoopCity.GetCy().getY())
if not (pLoopCity.GetCy().getNumRealBuilding(
iCourthouse)):
print "Courthouse statement answered no"
iFactor += 1
else:
print "Courthouse statement answered yes"
iEmpirePop += pLoopCity.getPopulation() * iFactor
#print ("iCorePop=", iCorePop, "iEmpirePop=", iEmpirePop)
#if iCorePop > iEmpirePop *5: iEmpireRating += 5
#elif iCorePop > iEmpirePop *4: iEmpireRating += 4
#elif iCorePop > iEmpirePop *3: iEmpireRating += 3
#iEmpireRating += self.empireStability(iCorePop, iEmpirePop)
if iCorePop > iEmpirePop * 2: iEmpireRating += 2
elif iCorePop > iEmpirePop: iEmpireRating += 1
elif iCorePop * 5 < iEmpirePop: iEmpireRating -= 5
elif iCorePop * 4 < iEmpirePop: iEmpireRating -= 4
elif iCorePop * 3 < iEmpirePop: iEmpireRating -= 3
elif iCorePop * 2 < iEmpirePop: iEmpireRating -= 2
elif iCorePop < iEmpirePop: iEmpireRating -= 1
#if iCorePop < iEmpirePop:
#iEmpireRating -= (((iEmpirePop * 10) / iCorePop) * ((iEmpirePop * 10) / iCorePop)) / 100
#print ("iEmpireRating=", iEmpireRating)
## RELIGION ##
#print "RELIGION"
iReligionRating = 0
iNumForeignReligions = 0
iNumNonbelievingCities = 0
if (iCivicReligion == iDynasticCultCivic) or (iCivicReligion
== iPaganismCivic):
for pLoopCity in apCityList:
for iLoopReligion in range(iNumReligions):
if pLoopCity.GetCy().isHasReligion(iLoopReligion):
if iLoopReligion != iHinduism:
iNumForeignReligions += 1
elif iLoopReligion == iHinduism and iCivicLabor != iCasteSystemCivic:
iNumForeignReligions += 1
elif iCivicReligion == iStateReligionCivic:
for pLoopCity in apCityList:
if not pLoopCity.GetCy().isHasReligion(iStateReligion):
iNumNonbelievingCities += 2
for iLoopReligion in range(iNumReligions):
if pLoopCity.GetCy().isHasReligion(
iLoopReligion) and iLoopReligion != iStateReligion:
iNumForeignReligions += 1
elif (iCivicReligion == iMilitancyCivic) or (iCivicGovernment
== iTheocracyCivic):
for pLoopCity in apCityList:
if not pLoopCity.GetCy().isHasReligion(iStateReligion):
iNumNonbelievingCities += 2
for iLoopReligion in range(iNumReligions):
if pLoopCity.GetCy().isHasReligion(
iLoopReligion) and iLoopReligion != iStateReligion:
iNumForeignReligions += 2
#print ("iNumForeignReligions", iNumForeignReligions, "iNumNonbelievingCities", iNumNonbelievingCities, "iNumCities", iNumCities)
if iNumNonbelievingCities * 2 > iNumCities: iReligionRating -= 2
elif iNumNonbelievingCities * 4 > iNumCities: iReligionRating -= 1
if iNumForeignReligions > iNumCities * 2: iReligionRating -= 2
elif iNumForeignReligions > iNumCities: iReligionRating -= 1
#print ("iReligionRating=", iReligionRating)
#print "TOTALS"
#print ("Civics:", iCivicsRating, "Health & Happiness:", iHappinessAndHealthRating, "Economy:", iEconomyRating, "Empire:", iEmpireRating, "Religion:", iReligionRating)
#print ("Total:", iCivicsRating + iHappinessAndHealthRating + iEconomyRating + iEmpireRating + iReligionRating)
#iAdjustment = 3
#print ("iAdjustment=", iAdjustment)
iStability = iCivicsRating + iHappinessAndHealthRating + iEconomyRating + iEmpireRating + iReligionRating + iAdjustment
if iPlayer == iByzantines: iStability += 3 # Byzantine UP
if iGameTurn > getTurnForYear(tFall[iCiv]): iStability -= 3
### RESULTS ###
if pTeam.isHasTech(iStabilityCollapsing):
if iStability < -3:
if iGameTurn > getTurnForYear(tFall[iCiv]):
#print "RESULT"
#print ("already collapsing, terminal crisis, iCiv=", iCiv)
self.terminalCrisis(iPlayer, iCiv, pPlayer, pTeam)
return
else:
#print "RESULT"
#print ("already collapsing, severe crisis, iCiv=", iCiv)
self.severeCrisis(iPlayer, iCiv, pPlayer, pTeam)
return
elif iStability < 3:
#print "RESULT"
#print ("stability flat at collapsing, moderate crisis, iCiv=", iCiv)
self.moderateCrisis(iPlayer, iCiv, pPlayer, pTeam)
elif iStability > 3:
#print "RESULT"
#print ("upgrade from collapsing to unstable, iCiv=", iCiv)
pTeam.setHasTech(iStabilityCollapsing, False, iPlayer, False,
False)
pTeam.setHasTech(iStabilityUnstable, True, iPlayer, False,
False)
return
elif pTeam.isHasTech(iStabilityUnstable):
if iStability < -6:
if iGameTurn > getTurnForYear(tFall[iCiv]):
#print "RESULT"
#print ("downgrade from unstable to collapsing, severe crisis, iCiv=", iCiv)
pTeam.setHasTech(iStabilityUnstable, False, iPlayer, False,
False)
pTeam.setHasTech(iStabilityCollapsing, True, iPlayer,
False, False)
self.severeCrisis(iPlayer, iCiv, pPlayer, pTeam)
return
else:
#print "RESULT"
#print ("downgrade from unstable to collapsing, moderate crisis, iCiv=", iCiv)
pTeam.setHasTech(iStabilityUnstable, False, iPlayer, False,
False)
pTeam.setHasTech(iStabilityCollapsing, True, iPlayer,
False, False)
self.moderateCrisis(iPlayer, iCiv, pPlayer, pTeam)
return
elif iStability <= 0:
#print "RESULT"
#print ("stability flat at unstable, minor crisis, iCiv=", iCiv)
self.minorCrisis(iPlayer, iCiv, pPlayer, pTeam)
return
else:
#print "RESULT"
#print ("stability upgrade from unstable to stable, no crisis, iCiv=", iCiv)
pTeam.setHasTech(iStabilityUnstable, False, iPlayer, False,
False)
pTeam.setHasTech(iStabilityStable, True, iPlayer, False, False)
return
else:
if iStability < -6:
#print "RESULT"
#print ("downgrade from stable to unstable, minor crisis, iCiv=", iCiv)
pTeam.setHasTech(iStabilityStable, False, iPlayer, False,
False)
pTeam.setHasTech(iStabilityUnstable, True, iPlayer, False,
False)
self.minorCrisis(iPlayer, iCiv, pPlayer, pTeam)
return
elif iStability < -3:
#print "RESULT"
#print ("downgrade from stable to unstable, no crisis, iCiv=", iCiv)
pTeam.setHasTech(iStabilityStable, False, iPlayer, False,
False)
pTeam.setHasTech(iStabilityUnstable, True, iPlayer, False,
False)
return
#elif iStability >= 0: print ("stability flat at stable, no crisis, iCiv=", iCiv)
def checkGrid(self, iCiv):
pCiv = gc.getPlayer(iCiv)
tCiv = gc.getTeam(pCiv.getTeam())
lTargetCivs = []
#clean it, sometimes it takes old values in memory
for k in range(iNumTotalPlayers):
lTargetCivs.append(0)
#set alive civs to 1 to differentiate them from dead civs
for k in range(iNumTotalPlayers):
if gc.getPlayer(k).isAlive() and tCiv.isHasMet(k):
lTargetCivs[k] = 1
#set master or vassal to 0
for k in range(iNumPlayers):
if gc.getTeam(gc.getPlayer(k).getTeam()).isVassal(
iCiv) or tCiv.isVassal(k):
lTargetCivs[k] = 0
#if already at war
for k in range(iNumTotalPlayers):
if tCiv.isAtWar(k):
lTargetCivs[k] = 0
lTargetCivs[iCiv] = 0
#edead: changed Rhye's code to Regions (provinces)
map = CyMap()
for i in range(map.numPlots()):
plot = map.plotByIndex(i)
if plot.isCity():
iOwner = plot.getOwner()
if iOwner >= 0 and iOwner < iNumTotalPlayers and iOwner != iCiv:
if lTargetCivs[iOwner] > 0:
regionID = plot.getRegionID()
if regionID in utils.getCoreRegions(iCiv):
lTargetCivs[iOwner] += 10
elif regionID in utils.getNormalRegions(iCiv):
lTargetCivs[iOwner] += 5
elif regionID in utils.getBroaderRegions(iCiv):
lTargetCivs[iOwner] += 2
#srpt: important war
if utils.getYear() >= -250 and utils.getYear() < -150:
if iCiv == con.iRome:
lTargetCivs[con.iCarthage] += 30
elif iCiv == con.iCarthage:
lTargetCivs[con.iRome] += 30
#srpt: important war
if utils.getYear() >= -400 and utils.getYear() < -300:
if iCiv == con.iMacedon:
lTargetCivs[con.iAthens] += 30
elif iCiv == con.iAthens:
lTargetCivs[con.iMacedon] += 30
#srpt: important war
if utils.getYear() >= -350 and utils.getYear() < -300:
if iCiv == con.iQin:
lTargetCivs[con.iJinState] += 30
elif iCiv == con.iJinState:
lTargetCivs[con.iQin] += 30
#there are other routines for this
lTargetCivs[iIndependent1] /= 3
lTargetCivs[iIndependent2] /= 3
lTargetCivs[iIndependent3] /= 3
lTargetCivs[iIndependent4] /= 3
#no random silly wars - edead
for k in range(iNumTotalPlayers):
if lTargetCivs[k] == 1:
lTargetCivs[k] = 0
print("AIWars grid for ", iCiv)
print(lTargetCivs)
#normalization
iMaxTempValue = -1
for k in range(iNumTotalPlayers):
if (lTargetCivs[k] > iMaxTempValue):
iMaxTempValue = lTargetCivs[k]
if (iMaxTempValue > 0):
for k in range(iNumTotalPlayers):
if (lTargetCivs[k] > 0):
lTargetCivs[k] = lTargetCivs[k] * 500 / iMaxTempValue
print(lTargetCivs)
for iLoopCiv in range(iNumTotalPlayers):
if (lTargetCivs[iLoopCiv] <= 0):
continue
#add a random value
if (lTargetCivs[iLoopCiv] <= iThreshold):
lTargetCivs[iLoopCiv] += gc.getGame().getSorenRandNum(
100, 'random modifier')
if (lTargetCivs[iLoopCiv] > iThreshold):
lTargetCivs[iLoopCiv] += gc.getGame().getSorenRandNum(
300, 'random modifier')
#balanced with attitude
attitude = 2 * (pCiv.AI_getAttitude(iLoopCiv) - 2)
if (attitude > 0):
lTargetCivs[iLoopCiv] /= attitude
#exploit plague
if iLoopCiv < iNumPlayers:
if (sd.getPlagueCountdown(iLoopCiv) > 0
or sd.getPlagueCountdown(iLoopCiv) < -10
and not (gc.getGame().getGameTurn() <= getTurnForYear(
con.tBirth[iLoopCiv]) + utils.getTurns(20))):
lTargetCivs[iLoopCiv] *= 3
lTargetCivs[iLoopCiv] /= 2
#balanced with master's attitude
for j in range(iNumTotalPlayers):
if (tCiv.isVassal(j)):
attitude = 2 * (gc.getPlayer(j).AI_getAttitude(iLoopCiv) -
2)
if (attitude > 0):
lTargetCivs[iLoopCiv] /= attitude
#if already at war
if (not tCiv.isAtWar(iLoopCiv)):
#consider peace counter
iCounter = min(7, max(1, tCiv.AI_getAtPeaceCounter(iLoopCiv)))
if (iCounter <= 7):
lTargetCivs[iLoopCiv] *= 20 + 10 * iCounter
lTargetCivs[iLoopCiv] /= 100
#if under pact
if (tCiv.isDefensivePact(iLoopCiv)):
lTargetCivs[iLoopCiv] /= 4
#if friend of a friend
## for jLoopCiv in range( iNumTotalPlayers ):
## if (tCiv.isDefensivePact(jLoopCiv) and gc.getTeam(gc.getPlayer(iLoopCiv).getTeam()).isDefensivePact(jLoopCiv)):
## lTargetCivs[iLoopCiv] /= 2
print(lTargetCivs)
#find max
iMaxValue = 0
iTargetCiv = -1
for iLoopCiv in range(iNumTotalPlayers):
if (lTargetCivs[iLoopCiv] > iMaxValue):
iMaxValue = lTargetCivs[iLoopCiv]
iTargetCiv = iLoopCiv
print("maxvalue", iMaxValue)
print("target civ", iTargetCiv)
if (iMaxValue >= iMinValue):
return iTargetCiv
return -1
def chooseAttackingPlayer(self):
#finding max teams ever alive (countCivTeamsEverAlive() doesn't work as late human starting civ gets killed every turn)
iMaxCivs = iNumPlayers
for i in range(iNumPlayers):
j = iNumPlayers - 1 - i
if (gc.getPlayer(j).isAlive()):
iMaxCivs = j
break
#print ("iMaxCivs", iMaxCivs)
if (gc.getGame().countCivPlayersAlive() <= 3):
return -1
else:
iRndnum = gc.getGame().getSorenRandNum(iMaxCivs,
'attacking civ index')
# Important war: Carthage vs. Rome
if utils.getYear() >= -250 and utils.getYear() < -150:
if gc.getPlayer(con.iRome).isAlive() and gc.getPlayer(
con.iCarthage).isAlive():
if not gc.getTeam(gc.getPlayer(
con.iRome).getTeam()).isAtWar(con.iCarthage):
if gc.getPlayer(con.iRome) != utils.getHumanID():
iRndnum = con.iRome
elif gc.getPlayer(con.iCarthage) != utils.getHumanID():
iRndnum = con.iCarthage
# Important war: Macedon vs. Athens
if utils.getYear() >= -400 and utils.getYear() < -300:
if gc.getPlayer(con.iMacedon).isAlive() and gc.getPlayer(
con.iAthens).isAlive():
if not gc.getTeam(gc.getPlayer(
con.iMacedon).getTeam()).isAtWar(con.iAthens):
if gc.getPlayer(con.iMacedon) != utils.getHumanID():
iRndnum = con.iMacedon
elif gc.getPlayer(con.iAthens) != utils.getHumanID():
iRndnum = con.iAthens
iRndnum = con.iCarthage
# Important war: Qin vs. Jin
if utils.getYear() >= -350 and utils.getYear() < -300:
if gc.getPlayer(con.iQin).isAlive() and gc.getPlayer(
con.iJinState).isAlive():
if not gc.getTeam(gc.getPlayer(
con.iQin).getTeam()).isAtWar(con.iJinState):
if gc.getPlayer(con.iQin) != utils.getHumanID():
iRndnum = con.iQin
elif gc.getPlayer(con.iJinState) != utils.getHumanID():
iRndnum = con.iJinState
#print ("iRndnum", iRndnum)
iAlreadyAttacked = -100
iMin = 100
iCiv = -1
for i in range(iRndnum, iRndnum + iMaxCivs):
iLoopCiv = i % iMaxCivs
pLoopPlayer = gc.getPlayer(iLoopCiv)
if (pLoopPlayer.isAlive() and not pLoopPlayer.isHuman()):
if (sd.getPlagueCountdown(iLoopCiv) >= -10
and sd.getPlagueCountdown(iLoopCiv) <= 0
): #civ is not under plague or quit recently from it
iAlreadyAttacked = sd.getAttackingCivsArray(iLoopCiv)
if (utils.isAVassal(iLoopCiv)):
iAlreadyAttacked += 1 #less likely to attack
#check if a world war is already in place
iNumAlreadyWar = 0
tLoopCiv = gc.getTeam(pLoopPlayer.getTeam())
for kLoopCiv in range(iNumPlayers):
if (tLoopCiv.isAtWar(kLoopCiv)):
if gc.getPlayer(kLoopCiv).isAlive():
iNumAlreadyWar += 1
if (iNumAlreadyWar >= 4):
iAlreadyAttacked += 2 #much less likely to attack
elif (iNumAlreadyWar >= 2):
iAlreadyAttacked += 1 #less likely to attack
if (iAlreadyAttacked < iMin):
iMin = iAlreadyAttacked
iCiv = iLoopCiv
#print ("attacking civ", iCiv)
if (iAlreadyAttacked != -100):
sd.setAttackingCivsArray(iCiv, iAlreadyAttacked + 1)
return iCiv
else:
return -1
return -1
def killUnitsByPlague(self, city, pCurrent, baseValue, iDamage,
iPreserveDefenders):
iOwner = city.getOwner()
pOwner = gc.getPlayer(iOwner)
teamOwner = gc.getTeam(gc.getPlayer(city.getOwner()).getTeam())
#deadly plague when human player isn't born yet, will speed up the loading
if utils.getYear() <= getTurnForYear(con.tBirth[utils.getHumanID()]):
iDamage += 10
baseValue -= 5
# modify strength on per-plague basis
iDamage *= self.getPlagueMultiplier()
iDamage /= 100
# spare less urbanized civs
if iOwner in con.lBlackDeathSurvivors:
iDamage = (iDamage * 2) / 3
baseValue += 5
#print (city.getX(), city.getY())
iNumUnitsInAPlot = pCurrent.getNumUnits()
#iPreserveHumanDefenders = iPreserveDefenders -1 #human handicap
iPreserveHumanDefenders = iPreserveDefenders
iHuman = utils.getHumanID()
if (iPreserveDefenders > 0): #cities only
#handicap for civs distant from human player too
if (not pOwner.isHuman()): #if not human and close or at war
#iPreserveDefenders -= 1
if (teamOwner.isAtWar(iHuman)):
iPreserveDefenders += 2
# else:
# for j in range(len(con.lCivGroups)):
# if ((iOwner in con.lCivGroups[j]) and (utils.getHumanID() in con.lCivGroups[j])):
# iPreserveDefenders += 1
# break
if (iNumUnitsInAPlot):
for j in range(iNumUnitsInAPlot):
i = iNumUnitsInAPlot - j - 1
unit = pCurrent.getUnit(i)
if (gc.getPlayer(unit.getOwner()).isHuman()):
#print ("iPreserveHumanDefenders", iPreserveHumanDefenders)
if (iPreserveHumanDefenders > 0):
#if (utils.isDefenderUnit(unit)):
iPreserveHumanDefenders -= 1
if (pCurrent.getNumUnits() > iPreserveDefenders):
pass
else:
unit.setDamage(unit.getDamage() + iDamage - 20,
con.iBarbarian)
#print ("preserve")
continue
else:
if (iPreserveDefenders > 0):
#if (utils.isDefenderUnit(unit)):
iPreserveDefenders -= 1
if (pCurrent.getNumUnits() > iPreserveDefenders
or gc.getTeam(
gc.getPlayer(unit.getOwner()).getTeam()
).isAtWar(iHuman)):
pass
else:
unit.setDamage(unit.getDamage() + iDamage - 20,
con.iBarbarian)
#print ("preserve")
continue
if (utils.isMortalUnit(unit)): #another human handicap inside
iThreshold = baseValue + 5 * city.healthRate(False, 0)
#print ("iThreshold", iThreshold)
if (teamOwner.isAtWar(iHuman) and iOwner < iNumPlayers):
if (unit.getOwner() == iOwner):
iDamage *= 3
iDamage /= 4
if (gc.getGame().getSorenRandNum(100, 'roll') >
iThreshold):
if (iDamage == 100):
if (unit.getOwner() != city.getOwner() and
gc.getPlayer(unit.getOwner()).isHuman()):
CyInterface().addMessage(
unit.getOwner(), False, con.iDuration / 2,
CyTranslator().getText(
"TXT_KEY_PLAGUE_PROCESS_UNIT",
()) + " " + city.getName(),
"AS2D_PLAGUE", 0, "",
ColorTypes(con.iLime), -1, -1, True, True)
unit.kill(False, iBarbarian)
else:
if (iDamage - unit.getExperience() / 10 -
unit.baseCombatStr() * 3 / 7 >=
100 - unit.getDamage()):
if (unit.getOwner() != iOwner and gc.getPlayer(
unit.getOwner()).isHuman()):
CyInterface().addMessage(
unit.getOwner(), False,
con.iDuration / 2,
CyTranslator().getText(
"TXT_KEY_PLAGUE_PROCESS_UNIT",
()) + " " + city.getName(),
"AS2D_PLAGUE", 0, "",
ColorTypes(con.iLime), -1, -1, True,
True)
unit.setDamage(
unit.getDamage() + iDamage -
unit.getExperience() / 10 -
unit.baseCombatStr() / 2, con.iBarbarian)
#print ("process")
break
def processPlague(self, iPlayer):
pPlayer = gc.getPlayer(iPlayer)
#first spread to close locations
cityList = [] #see below
apCityList = PyPlayer(iPlayer).getCityList()
for pCity in apCityList:
city = pCity.GetCy()
cityList.append(city) #see below
if (city.getNumRealBuilding(iPlague) > 0):
#print ("plague in city", city.getName())
if (city.getPopulation() > 1):
#print("healthRate in city", 35 + 5*city.healthRate(False, 0))
if utils.getYear() < 1250:
iMin = 80
elif city.plot().getRegionID() in con.lBlackDeathRegions:
if city.getOwner() in con.lBlackDeathSurvivors:
iMin = 80
else:
iMin = 50
else:
iMin = 90
if (gc.getGame().getSorenRandNum(100, 'roll') >
iMin + 5 * city.healthRate(False, 0)):
city.changePopulation(-1)
if (city.isCapital()): #delete in vanilla
for iLoopCiv in range(iNumPlayers):
if (gc.getTeam(pPlayer.getTeam()).isVassal(iLoopCiv) or \
gc.getTeam(gc.getPlayer(iLoopCiv).getTeam()).isVassal(iPlayer)):
if (
gc.getPlayer(iLoopCiv).getNumCities() > 0
): #this check is needed, otherwise game crashes
capital = gc.getPlayer(
iLoopCiv).getCapitalCity()
if (self.isVulnerable(iLoopCiv) == True):
if (sd.getPlagueCountdown(iPlayer) >
2): #don't spread the last turns
self.spreadPlague(iLoopCiv)
self.infectCity(capital)
#print ("infect master/vassal", city.getName(), "to", capital.getName())
for x in range(city.getX() - 2, city.getX() + 3):
for y in range(city.getY() - 2, city.getY() + 3):
##print ("plagueXY", x, y)
pCurrent = gc.getMap().plot(x, y)
if (pCurrent.getOwner() != iPlayer
and pCurrent.getOwner() >= 0):
if (sd.getPlagueCountdown(iPlayer) >
2): #don't spread the last turns
if (self.isVulnerable(
pCurrent.getOwner()) == True):
self.spreadPlague(pCurrent.getOwner())
self.infectCitiesNear(
pCurrent.getOwner(), x, y)
#print ("infect foreign near", city.getName())
else:
if (pCurrent.isCity()
and not (x == city.getX()
and y == city.getY())):
#print ("is city", x, y)
cityNear = pCurrent.getPlotCity()
if (not cityNear.getNumRealBuilding(iPlague) >
0):
if (sd.getPlagueCountdown(iPlayer) >
2): #don't spread the last turns
self.infectCity(cityNear)
#print ("infect near", city.getName(), "to", cityNear.getName())
else:
if (x == city.getX() and y == city.getY()):
self.killUnitsByPlague(
city, pCurrent, 0, 42, 2)
else:
if (pCurrent.isRoute()):
self.killUnitsByPlague(
city, pCurrent, 10, 35, 0)
elif (pCurrent.isWater()):
self.killUnitsByPlague(
city, pCurrent, 30, 35, 0)
else:
self.killUnitsByPlague(
city, pCurrent, 30, 35, 0)
for x in range(city.getX() - 3, city.getX() + 4):
pCurrent = gc.getMap().plot(x, city.getY() - 3)
if (pCurrent.getOwner() == iPlayer
or not pCurrent.isOwned()):
if (not pCurrent.isCity()):
if (pCurrent.isRoute() or pCurrent.isWater()):
self.killUnitsByPlague(city, pCurrent, 30, 35,
0)
pCurrent = gc.getMap().plot(x, city.getY() + 4)
if (pCurrent.getOwner() == iPlayer
or not pCurrent.isOwned()):
if (not pCurrent.isCity()):
if (pCurrent.isRoute() or pCurrent.isWater()):
self.killUnitsByPlague(city, pCurrent, 30, 35,
0)
for y in range(city.getY() - 2, city.getY() + 3):
pCurrent = gc.getMap().plot(city.getX() - 3, y)
if (pCurrent.getOwner() == iPlayer
or not pCurrent.isOwned()):
if (not pCurrent.isCity()):
if (pCurrent.isRoute() or pCurrent.isWater()):
self.killUnitsByPlague(city, pCurrent, 30, 35,
0)
pCurrent = gc.getMap().plot(city.getX() + 4, y)
if (pCurrent.getOwner() == iPlayer
or not pCurrent.isOwned()):
if (not pCurrent.isCity()):
if (pCurrent.isRoute() or pCurrent.isWater()):
self.killUnitsByPlague(city, pCurrent, 30, 35,
0)
#spread to trade route cities
if (sd.getPlagueCountdown(iPlayer) >
2): #don't spread the last turns
for i in range(city.getTradeRoutes()):
#for i in range(gc.getDefineINT("MAX_TRADE_ROUTES")):
loopCity = city.getTradeCity(i)
if (not loopCity.isNone()):
if (not loopCity.getNumRealBuilding(iPlague) > 0):
#utils.echo("Plagued caravan arrives at %s" %(loopCity.getName()))
iOwner = loopCity.getOwner()
if (iPlayer == iOwner or gc.getTeam(pPlayer.getTeam()).isOpenBorders(iOwner) or \
gc.getTeam(pPlayer.getTeam()).isVassal(iOwner) or \
gc.getTeam(gc.getPlayer(iOwner).getTeam()).isVassal(iPlayer)): #own city, or open borders, or vassal
if (iPlayer != iOwner):
if (self.isVulnerable(iOwner) == True):
self.spreadPlague(iOwner)
self.infectCity(loopCity)
#utils.echo("infect by trade route: %s to %s" %(city.getName(), loopCity.getName()))
iHuman = utils.getHumanID()
if (gc.getPlayer(
iHuman).canContact(iOwner)
and iHuman != iOwner):
CyInterface().addMessage(
iHuman, True,
con.iDuration / 2,
CyTranslator().getText(
"TXT_KEY_PLAGUE_SPREAD_CITY",
()) + " " +
loopCity.getName() + " (" +
gc.getPlayer(iOwner).
getCivilizationAdjective(0)
+ ")",
"AS2D_PLAGUE", 0, "",
ColorTypes(con.iLime), -1,
-1, True, True)
else:
self.infectCity(loopCity)
#utils.echo("infect by trade route: %s to %s" %(city.getName(), loopCity.getName()))
#spread to other cities of the empire
if (len(cityList)):
if (sd.getPlagueCountdown(iPlayer) >
2): #don't spread the last turns
for city1 in cityList:
##print ("citylist", city1.getName())
if (not city1.getNumRealBuilding(iPlague) > 0):
for city2 in cityList:
if (city1 != city2):
if (city2.getNumRealBuilding(iPlague) > 0):
if (city1.isConnectedTo(city2)):
##print ("infect distant", city1.getName(), "to", city2.getName(), utils.calculateDistance(city1.getX(), city1.getY(), city2.getX(), city2.getY()))
if (utils.calculateDistance(
city1.getX(), city1.getY(),
city2.getX(), city2.getY()) <=
6):
#print ("infect distant", city2.getName(), "to", city1.getName())
self.infectCity(city1)
return
