def permaRun(self, longestWait=10):
while not self._stop:
self.run()
timeToSleep = self.timeToNextTask()
if timeToSleep > 0:
time.sleep(min(timeToSleep, longestWait))
log(None, "Stopped")
def chooseTechToPick(self):
log(None, "Planning tech to research")
techId = None
if self.techsPickingOrder is not None:
tech = self.techsPickingOrder.nextTech(
self.techs) # the tech to research
if tech is None:
if self.techsPickingOrder.options.get(
"useDefaultTechPlanWhenEmpty", False):
tech = self.chooseTechToPickByDefault()
else:
log(
self,
"No more techs planned by the technology picking order !"
)
return None, None
else:
tech = self.chooseTechToPickByDefault()
if tech is not None:
# Now we need to find a suitable planet to research it
isLabUpgrading = lambda p: True in [
t[0] == 31 for t in p.upgradingBuildingsId
]
# The list contains a True if a research lab is being built or upgraded on this planet
condition = lambda p: not isLabUpgrading(
p) and tech.requirementsMet(p)
list = self.getPlanetsWithBuildingOrderedByLevelWithCondition(
31, condition)
if len(
list
) == 0: # No research lab that isn't upgrading or that mets requirements
return None, None
level, planet = list[
0] # The planet with highest lab and that lab isn't upgraded
return tech, planet
def getOfficersUsingLastRequest(player):
content = player.lastRequest.content
soup = BeautifulSoup(content, "html.parser")
#parse all officers
officersDiv = soup.find(id="tab1").find_all("div", recursive=False)
officers = {}
for o in officersDiv:
nameAndLevelText = o.find("a").text
nameAndLevel = player.ia.buildingNameParser.findall(
nameAndLevelText) #works for officers too
name = nameAndLevel[0][0]
level = 0
if nameAndLevel[0][1] != '':
level = int(nameAndLevel[0][1])
divs = o.find_all("div", recursive=False)
dmSpan = divs[2].span.find("span")
dmRequired = 0
if dmSpan != None:
dmRequired = int(dmSpan.text.replace(".", ""))
form = divs[3].find("input", attrs={"name": "id"})
id = Codes.strToId.get(name)
if form != None and id == None:
id = form.attrs['value']
if id == None:
log(None,
"Unknown officer with no id parsed.",
isError=True)
officer = Officer(name, id, player, level)
officer.darkMatterCost = dmRequired
officers[id] = officer
return officers
def execute(self):
log(None, "Planning launch of an expedition")
self.player.scanOwnShips()
stop = False
for planet in self.player.planets:
if not stop and planet.deut >= 10:
if planet.ships.get(232, 0) >= 1: #Deadalus
planet.sendFleet(planet.pos[0:2] + [16, 1],
Fleet.expeditionCode, {232: 1}, [0, 0, 0])
stop = True
elif planet.ships.get(202, 0) >= 1: #Small cargo
planet.sendFleet(planet.pos[0:2] + [16, 1],
Fleet.expeditionCode, {202: 1}, [0, 0, 0])
stop = True
elif planet.ships.get(203, 0) >= 1: #Big Cargo
planet.sendFleet(planet.pos[0:2] + [16, 1],
Fleet.expeditionCode, {203: 1}, [0, 0, 0])
stop = True
if stop:
log(planet, "Launched an expedition!")
if not stop: #ie no ship to send on any planet
log(None,
"No expedition launched, trying to build a small transporter")
combustionTech = self.player.techs.get(115, None)
if combustionTech is not None and combustionTech.level >= 2:
for planet in self.player.planets:
if not stop and planet.metal >= 2000 and planet.crystal >= 2000 and planet.deut >= 10:
spacePort = planet.buildingById(21)
if spacePort is not None and spacePort.level >= 2:
planet.buildShips({202: 1})
stop = True
log(planet,
"Small transporter construction started")
if not stop:
log(None, "Can't build any small transporter")
def wakeWatchdog(self):
timeToWake = self.watchdog - time.time()
if timeToWake > 0: # early wake up
log(None,
"Waking the watchdog " + str(timeToWake) + " seconds early")
else:
log(None, "Waking the watchdog")
self.initialize()
def execRequest(self, req):
req.connect(self.session)
if """var loginError = "Votre session a expir""" in req.content:
#if we were disconnected we will try to reconnect once
log(None, "Reconnecting")
self.player.connexion()
req.connect(self.session)
self.player.lastRequest = req
def requirementsMet(self, planet):
labLevel = planet.buildingLevelById(31)
if self.id == 106:
return labLevel >= 3
elif self.id == 108:
return labLevel >= 1
elif self.id == 109:
return labLevel >= 4
elif self.id == 110:
return labLevel >= 6 and self.player.getTechLevel(113) >= 3
elif self.id == 111:
return labLevel >= 2
elif self.id == 113:
return labLevel >= 1
elif self.id == 114:
return labLevel >= 7 and self.player.getTechLevel(
113) >= 5 and self.player.getTechLevel(110) >= 5
elif self.id == 115:
return labLevel >= 1 and self.player.getTechLevel(113) >= 1
elif self.id == 117:
return labLevel >= 2 and self.player.getTechLevel(113) >= 1
elif self.id == 118:
return labLevel >= 7 and self.player.getTechLevel(114) >= 3
elif self.id == 120:
return labLevel >= 1 and self.player.getTechLevel(113) >= 2
elif self.id == 121:
return labLevel >= 4 and self.player.getTechLevel(
113) >= 4 and self.player.getTechLevel(120) >= 5
elif self.id == 122:
return labLevel >= 5 and self.player.getTechLevel(
113) >= 8 and self.player.getTechLevel(
120) >= 10 and self.player.getTechLevel(121) >= 5
elif self.id == 123:
return labLevel >= 10 and self.player.getTechLevel(
108) >= 8 and self.player.getTechLevel(114) >= 8
elif self.id == 124:
return labLevel >= 3 and self.player.getTechLevel(
106) >= 3 and self.player.getTechLevel(117) >= 3
elif self.id == 131:
return labLevel >= 8 and self.player.getTechLevel(115) >= 5
elif self.id == 132:
return labLevel >= 8 and self.player.getTechLevel(115) >= 5
elif self.id == 133:
return labLevel >= 8 and self.player.getTechLevel(115) >= 5
elif self.id == 134:
return labLevel >= 12 and self.player.getTechLevel(
199) >= 1 and self.player.getTechLevel(
114) >= 8 and self.player.getTechLevel(123) >= 3
elif self.id == 199:
return labLevel >= 12
log(
planet,
"ERROR : Technology (id=%i) doesn't have it's requirements in the list. Contact the developper and send the logs"
% (self.id))
return False # Fallback
def timeToNextTask(self):
nextTaskTime = None
for prio in Task.descendingPrio:
if len(self.tasks[prio]) and (
nextTaskTime is None
or self.tasks[prio][0].t < nextTaskTime):
nextTaskTime = self.tasks[prio][0].t
if nextTaskTime == None:
log(None, "No more tasks ! ALERT")
return math.inf
return nextTaskTime - time.time()
def execute(self):
self.player.scanOfficers()
officer = self.player.chooseOfficerToPick()
if officer is not None and self.player.darkMatter >= 1000:
log(None, "Upgrading the officer " + officer.type)
req = officer.upgrade()
self.player.extractInfos(request=req,
darkMatter=True,
planets=False)
if self.player.darkMatter >= 1000:
newTask = PickOfficerTask(time.time(), self.player)
self.player.ia.addTask(newTask)
def execute(self):
req = self.bat.upgrade()
self.bat.planet.scanUsingRequest(req)
if self.bat.planet.upgradingEnd == 0: #the building wasn't upgraded
log(self.bat.planet, "Re-planning building")
newTask = PlanningTask(time.time(), self.bat.planet)
self.bat.planet.player.ia.addTask(newTask)
else:
log(
self.bat.planet, "Building " + self.bat.type + " to level " +
str(self.bat.level + 1) + " in " + str(self.bat.upgradeTime))
self.bat.planet.player.ia.addTask(
PlanningTask(time.time() + self.bat.upgradeTime,
self.bat.planet))
def run(self): # Executes one task
if not self.checkWatchdog():
# Execute the first task
taskExecuted = False
for prio in Task.descendingPrio:
if not taskExecuted and len(
self.tasks[prio]
) and self.tasks[prio][0].t < time.time():
taskToExecute = heapq.heappop(self.tasks[prio])
try:
taskToExecute.execute()
except Exception:
log(
None, "An exception occured while executing a " +
taskToExecute.__class__.__name__)
log(None, "Exception traceback :")
traceback.print_exc()
self.watchdog -= self.config.watchdogExceptionDelay
taskExecuted = True
# See if the watchdog wakes
self.checkWatchdog()
def planBuilding(self):
config = self.player.ia.config #to make lines smaller
buildingId = None
if config.activateCustomBuildOrders and self.customBuildOrder is not None:
building = self.customBuildOrder.nextBuilding(self) # the building to build
if building is None:
if self.customBuildOrder.options.get("useDefaultBuildPlanWhenEmpty", False):
buildingId = self.defaultPlanBuildingWithoutHangars()
else:
log(self, "No more building planned by the custom build order !")
return None
else:
buildingId = building.id
else:
buildingId = self.defaultPlanBuildingWithoutHangars()
buildingId = self.planHangarsInstead(buildingId)
building = self.buildingById(buildingId)
#now we need to know how much to wait
timeToWait = self.getTimeToWaitForResources(building.upgradeCost)
task = BuildingTask(self.lastExtracedInfosDate + timeToWait, building)
self.player.ia.addTask(task)
return task
def execute(self):
log(None, "Checking achievements")
hadNewAchievement = self.player.checkNewAchievement()
if hadNewAchievement:
log(None, "Just got an achievement!")
newTask = CheckAchievementsTask(time.time(), self.player)
self.player.ia.addTask(newTask)
else:
log(None, "No new achievement")
def connexion(self):
payload = {
'username': self.pseudo,
'password': self.mdp,
'universe': self.universe,
}
connexionRequest = Request(self.ia.mainURL + 'page=login', payload)
connexionRequest.connect(self.ia.session)
self.lastRequest = connexionRequest
if """var loginError = "Combinaison login""" in connexionRequest.content:
log(None, "Login/Password incorrect", isError=True)
sys.exit("Login/Password incorrect")
elif """var loginError = "Votre session a expir""" in connexionRequest.content:
#if the cookie we setup was false
log(
None,
"Bad Cookie. Clearing session cookies and trying to reconnect using credentials"
)
self.ia.session.cookies.clear()
self.connexion()
else:
log(None, "Connected")
log(None,
"Cookie : @2Moons = " + self.ia.session.cookies["2Moons"])
def sendFleet(self, target, missionType, ships, ressources, speed=10, staytime=1, allRessources=False):
firstPayload = {}
for shipId in ships.keys():
if shipId not in [212, 227, 228, 229, 230, 231]:
firstPayload["ship" + str(shipId)] = ships[shipId]
sendFleetStep1 = Request(self.player.ia.sendFleetStep1Page + "&cp=" + str(self.id), firstPayload)
self.player.ia.execRequest(sendFleetStep1)
soup = BeautifulSoup(sendFleetStep1.content, "html.parser")
tokenInput = soup.find("input", attrs={"name":"token"})
if tokenInput is not None:
token = tokenInput.attrs["value"]
secondPayload = {}
secondPayload["galaxy"] = target[0]
secondPayload["system"] = target[1]
secondPayload["planet"] = target[2]
secondPayload["type" ] = target[3] #1 = planet, 2 = CDR, 3 = moon
secondPayload["speed" ] = speed #the speed in multiples of 10%
secondPayload["token" ] = token
sendFleetStep2 = Request(self.player.ia.sendFleetStep2Page + "&cp=" + str(self.id), secondPayload)
self.player.ia.execRequest(sendFleetStep2)
thirdPayload = {}
if allRessources:
self.scanRessourcesUsingRequest(sendFleetStep2)
ressources[0] = self.metal
ressources[1] = self.crystal
ressources[2] = self.deut
soup = BeautifulSoup(sendFleetStep2.content, "html.parser")
scriptRessources = soup.findAll("script")[-1].text
fleetroom = int(scriptRessources.split(':"')[1].split('"')[0])
consumption = int(scriptRessources.split(':"')[2].split('"')[0])
fleetroom -= consumption
if missionType == Fleet.colonizeCode:
thirdPayload["metal"] = min(ressources[0], fleetroom/2)
fleetroom -= thirdPayload["metal"]
thirdPayload["crystal"] = min(ressources[1], fleetroom*2/3)
fleetroom -= thirdPayload["crystal"]
thirdPayload["deuterium"] = min(ressources[2], fleetroom)
fleetroom -= thirdPayload["deuterium"]
if fleetroom >= 0:
fleetroom += thirdPayload["metal"]
thirdPayload["metal"] = min(ressources[0], fleetroom)
fleetroom -= thirdPayload["metal"]
fleetroom += thirdPayload["crystal"]
thirdPayload["crystal"] = min(ressources[1], fleetroom)
fleetroom -= thirdPayload["crystal"]
fleetroom += thirdPayload["deuterium"]
thirdPayload["deuterium"] = min(ressources[2], fleetroom)
fleetroom -= thirdPayload["deuterium"]
else:
thirdPayload["deuterium"] = min(ressources[2], fleetroom)
fleetroom -= thirdPayload["deuterium"]
thirdPayload["crystal"] = min(ressources[1], fleetroom)
fleetroom -= thirdPayload["crystal"]
thirdPayload["metal"] = min(ressources[0], fleetroom)
fleetroom -= thirdPayload["metal"]
thirdPayload["mission" ] = missionType
thirdPayload["staytime" ] = staytime
thirdPayload["token" ] = token
sendFleetStep3 = Request(self.player.ia.sendFleetStep3Page + "&cp=" + str(self.id), thirdPayload)
self.player.ia.execRequest(sendFleetStep3)
log(self, "Fleet sent")
else:
log(self, "Error while sending the fleet", isError=True)
def execute(self):
self.player.scanTechs()
if self.player.ia.config.activateAutoColonization:
# Eventually add a colonization task
isAlreadyColonizing = False
for fleet in self.player.fleets.values():
if not isAlreadyColonizing and fleet.isColony():
isAlreadyColonizing = True
shouldAddTask = not isAlreadyColonizing
shouldAddTask = shouldAddTask and self.player.getActualNumberOfPlanets(
) < self.player.getMaximumNumberOfPlanets()
shouldAddTask = shouldAddTask and not self.player.ia.hasTaskOfType(
ColonizeTask)
if shouldAddTask:
newTask = ColonizeTask(time.time(), self.player)
self.player.ia.addTask(newTask)
if self.player.researchEnd > 0: #If there is already a tech being researched
log(
None, "Waiting for a research to finish in " +
str(self.player.researchEnd - time.time()))
newTask = PickTechTask(self.player.researchEnd + 1, self.player)
self.player.ia.addTask(newTask)
else:
tech, planet = self.player.chooseTechToPick()
if tech is not None:
if tech.upgradable(planet.expectedRessources()):
req = tech.upgrade(planet.id)
self.player.scanTechsUsingRequest(self.player.lastRequest)
log(
planet, "Researching %s in %s" %
(tech.type,
str(self.player.researchEnd - time.time())))
newTask = PickTechTask(self.player.researchEnd + 1,
self.player)
self.player.ia.addTask(newTask)
else:
#now we need to know how much to wait
log(planet,
"Waiting for resources for tech %s" % tech.type)
timeToWait = planet.getTimeToWaitForResources(
tech.upgradeCost)
timeToStart = planet.lastExtracedInfosDate + timeToWait
newTaskTime = timeToStart
if len(
planet.upgradingBuildingsId
) and planet.upgradingBuildingsId[0][1] < timeToStart:
# A building is planned before we can start the research
newTaskTime = planet.upgradingBuildingsId[0][1]
newTask = PickTechTask(newTaskTime, self.player)
self.player.ia.addTask(newTask)
else:
# This means no planet meets the requirements for the tech
# 2 cases :
# Either another tech is required (this comes from a bad tech pick order), we won't do anything
# We need a bigger lab that isn't upgrading. So just wait for the next building to end.
nextBuildingTask = self.player.ia.getNextTaskOfType(
PlanningTask)
if nextBuildingTask is None: # Shouldn't happen
newTaskTime = time.time() + 30
else:
newTaskTime = nextBuildingTask.t + 1
newTask = PickTechTask(newTaskTime, self.player)
self.player.ia.addTask(newTask)
log(
planet,
"Requirements not met for the choosed tech. Waiting for the next building to finish in %f"
% (newTaskTime - self.t))
def execute(self):
log(None, "Checking if colonization is possible")
isAlreadyColonizing = False
for fleet in self.player.fleets.values():
if not isAlreadyColonizing and fleet.isColony():
isAlreadyColonizing = True
if not isAlreadyColonizing and self.player.getMaximumNumberOfPlanets(
) > self.player.getActualNumberOfPlanets():
# This assures that tech is enough
# We just need to get a planet with a colonization ship or a shipyard 4
self.player.scanOwnShips()
scannedSystem = [] # We don't scan a scanned system
stop = False
for planet in self.player.planets:
if not stop and planet.ships.get(208, 0) >= 1:
if [planet.pos[0], planet.pos[1]] in scannedSystem:
location = planet.getColonizationTarget(
useLastKnownSystem=True)
else:
location = planet.getColonizationTarget()
scannedSystem.append([planet.pos[0], planet.pos[1]])
if location is not None:
stop = True
destination = [
planet.pos[0], planet.pos[1], location, 1
]
log(None, "Colonizing " + str(destination))
planet.sendFleet(destination,
Fleet.colonizeCode, {208: 1},
[0, 0, 0],
allRessources=True)
if not stop: #ie no ship to send to colonize
log(None,
"No colonization launched, trying to build a colony ship")
for planet in self.player.planets:
canBuild = planet.buildingLevelById(
21
) >= 4 and planet.metal >= 10000 and planet.crystal >= 20000 and planet.deut >= 11000
if not stop and planet.ships.get(208, 0) == 0 and canBuild:
if [planet.pos[0], planet.pos[1]] in scannedSystem:
location = planet.getColonizationTarget(
useLastKnownSystem=True)
else:
location = planet.getColonizationTarget()
scannedSystem.append(
[planet.pos[0], planet.pos[1]])
spacePort = planet.buildingById(21)
if location is not None:
stop = True
planet.buildShips({208: 1})
log(planet, "Started construction of colony ship")
timeToWait = 30000 / 14 / (
1 + planet.buildingLevelById(21)) / (
2**planet.buildingLevelById(15)) + 5
# The 14 is 2 * universe speed, the + 5 is just a security, could be 1
newTask = ColonizeTask(time.time() + timeToWait,
self.player)
self.player.ia.addTask(newTask)
if not stop:
log(
None,
"Can't build any colony ships in a system with a colonizable planet"
)
def execute(self):
log(self.planet, "Scanning planet")
self.planet.scan()
if self.planet.sizeMax is None:
log(self.planet, "Scanning planet size")
self.planet.getSize()
log(self.planet,
"Done scanning planet " + self.planet.getNameWithSize())
if self.planet.upgradingEnd: #if a building is currently being build
log(
self.planet, "Waiting for a building to end in " +
str(self.planet.upgradingEnd - time.time()))
newTask = PlanningTask(self.planet.upgradingEnd, self.planet)
self.planet.player.ia.addTask(newTask)
else:
if self.planet.sizeUsed < self.planet.sizeMax:
log(self.planet, "Planning building")
newTask = self.planet.planBuilding()
if newTask is not None:
log(self.planet, "Done planning building")
log(
self.planet,
"Planning to build a " + newTask.bat.type +
" to level " + str(newTask.bat.level + 1) + " in " +
str(newTask.t - time.time()))
else:
log(self.planet, "Planet filled ! Retrying in 10 minutes")
newTask = PlanningTask(time.time() + 600, self.planet)
self.planet.player.ia.addTask(newTask)
def changeCookie(self, newCookie):
log(None, "Changing cookie : 2Moons = " + newCookie)
self.session.cookies.set('2Moons', newCookie, domain=self.domain)
def stop(self):
log(None, "Stopping")
self._stop = True
