def loadup(self):
"""
Loads cookies, Logins,
Loads all villages, events and the hero.
"""
self.load_db()
self.load_cookie()
doc_resources = self.request_GET("/dorf1.php")
if not len(reader.read_resource_fields(doc_resources)):
self.clear_cookie()
doc_resources = self.login(doc_login = doc_resources)
self.save_cookie()
if not len(reader.read_resource_fields(doc_resources)):
logger.log_error("login failed", "The login failed")
else:
self.ajax_token = reader.read_ajax_token(doc_resources)
village = self.request_village(None, doc_resources)
other_villages = self.villages.keys() ^ { village.village_id } # all villages except the active
self.request_villages(other_villages)
self.request_hero()
self.production_boost = reader.read_production_boost(doc_resources)
def build_building(self, bld_gid, bld_lvl):
from_lvl = bld_lvl - 1
bld_bid = None
bld_new = None
for bid, gid, lvl in self.buildings + self.resource_fields:
if gid == bld_gid and lvl == from_lvl:
bld_bid = bid
bld_new = False
break
if bld_bid is None:
for bid, gid, lvl in self.buildings + self.resource_fields:
if gid == 0:
bld_bid = bid
bld_new = True
break
if bld_new is None:
logger.log_error("build not found", "Nothing to build found! ")
return False
if bld_new == True:
logger.log_info("build", "Building %s new lvl %s at %s" % (db.buildings[bld_gid]['gname'], bld_lvl, bld_bid) )
action.action_build_new(self.account, bld_bid, bld_gid)
else:
logger.log_info("build", "Building %s up from lvl %s to %s at %s" % (db.buildings[bld_gid]['gname'], from_lvl, bld_lvl, bld_bid) )
action.action_build_up(self.account, bld_bid)
self.fire_event(Event(self, 'resources_spent', datetime.now()))
def read_content(self, pages:dict):
'''
Reads the content of the given pages and writes them into the village.
possible keys:
- resources (dorf1.php)
resource_fields
resources
production
- village (dorf2.php)
- troops (rally_place)
'''
# dorf1.php:
if 'resources' in pages:
doc = pages['resources']
self.resource_fields = reader.read_resource_fields(doc)
self.resources = Resources(reader.read_resources(doc))
self.production = Resources(reader.read_production(doc))
if not self.resources or not self.production:
logger.log_error("page error", [ "%s: %s" % (t, p.find("html").html().strip()) for t,p in pages.items() ], 'Could not fetch village data')
try:
self.storage_capacity = Resources(reader.read_storage_capacity(doc))
self.name = reader.read_villages(doc, True)[0]['name']
except Exception as e:
traceback.print_exc()
self.storage_capacity = []
self.name = ""
# dorf2.php
if 'village' in pages:
doc = pages['village']
self.buildings = reader.read_buildings(doc)
def get_production_time(self, resr):
needed = +(self.resources - resr) - (self.resources - resr)
try:
return timedelta(hours=max(needed / (self.production + Resources((0.00001,)*4))))
except:
logger.log_error("production calculation failed", "resr: %s \n self.resources: %s \n self.production: %s" % (resr, self.resources, self.production))
raise
return timedelta(minutes=1)
def execute(self, village):
if not self['next_field'] in village.resource_fields:
self.next_field(village)
logger.log_note('build field', 'Build field %s' % (self['next_field'],))
village.build_building(self['next_field'][1], self['next_field'][2]+1)
pages = village.refresh('resources')
if not village.events.build: #any( event.building == self['next_field'][1] and event.level == self['next_field'][2]+1 for event in village.events.build ):
logger.log_error('build failed', pages['resources'].find('html').html(), title='Could not build %s level %s.' % (db.buildings[self['next_field'][1]]['gname'], self['next_field'][2]))
self.next_field(village)
def action_register(account):
r = account.session.post("http://travian.de/ajax.php?cmd=registration",
{"cmd": "registration", "activeServerId":account.server[0], "playerName":account.user_name, "password":account.password,
"email": account.email, "preRegistrationCode":"", "generalTermsAndConditions":"1", "newsletter":"false"})
if '"success":true' in r.text:
return True
else:
logger.log_error("register failed", "Registration failed:\n %s" % r.text)
return False
def __mysql_retry_func(*args, **kwargs):
count = 0
while True:
count += 1
if count > db_settings.restart_times:
raise Exception(msg)
exit(-1)
try:
return func(*args, **kwargs)
except MySQLdb.Error, e:
logger.log_error("mysql error %d: %s" %
(e.args[0], e.args[1]))
continue
except:
def action_quest(account, action, quest= None):
params = {}
if action is not None:
params["action"] = action
if quest is not None:
params["questTutorialId"] = quest
response = account.ajax_cmd("quest", params)
if response.text == "":
logger.log_error("ajax failed", "Ajax request failed at tutorial: action: %s, quest: %s" % (action, quest))
logger.log_note("quest", response.text, title="Execute %s %s" % (action, quest))
def db_execute(self, sql, hargs=()):
try:
conn = self.dbpool.connection()
cur = conn.cursor()
cur.execute("set names utf8")
cur.execute(sql, hargs)
conn.commit()
dataset = cur.fetchall()
cur.close()
conn.close()
return dataset
except:
logger.log_error("sql excute error:\n\tsql:%s\n\thargs:%s" %
(sql, hargs))
raise
def request_POST(self, url, params, add_headers = {}, createDom=True):
headers = dict(self.default_headers)
headers['Content-Type'] = 'application/x-www-form-urlencoded'
headers.update(add_headers)
# perform login
result = self.session.post(self.url + url, data=params, headers=headers)
logger.log_note("POST request", "POST issued for %s with %s" % (url, params))
try:
if createDom:
return HtmlDom().createDom(result.text)
except:
logger.log_error("POST failed", result.text, title="failed reading page in POST %s" % url)
return result
def refresh(self, *page_names):
'''
Refreshes all pages related with this village, or only
with the given pages.
'''
if self.suppress_refresh:
return
logger.log_note('refresh', 'refreshing %s' % str(page_names))
pages = {}
page_names = page_names or self.url_mapping.keys()
for page_name in page_names:
doc = self.account.request_GET(self.url_mapping[page_name])
if 'type="password"' in doc.find("html").html():
logger.log_info("logout", "Logout detected")
self.account.clear_cookie()
self.account.login()
self.account.save_cookie()
self.next_refresh_time = datetime.now() + timedelta(seconds=30)
return
pages[page_name] = doc
self.read_content(pages)
self.read_events(pages)
if not self.resources:
self.account.login()
self.refresh(*page_names)
print(self.events.build)
if not self.resources or not self.production or not self.storage_capacity:
logger.log_error("page error", [ "%s: %s" % (t, p.find("html").html().strip()) for t,p in pages.items() ], 'Could not fetch village data')
self.save_status()
self.new_refresh_time()
return pages
def get_gid_by_name(gname):
from log import logger
try:
return next(bld['gid'] for bld in buildings.values() if bld['gname'] == gname)
except:
logger.log_error("invalid gname", "Building name '%s' is invalid." % gname)
jm = JobManager(first_village)
first_village.event_handlers.append(jm)
if not jobs_from_db:
jm.init_from_def(build_roman)
first_village.fire_event( Event(first_village, 'job_completed', datetime.now(), job=jm.root) )
else:
jm.init_from_db()
first_village.refresh()
first_village.fire_event( Event(first_village, 'job_completed', datetime.now(), job=jm.root) )
account.logout()
first_village.refresh()
#first_village.fire_event( Event(first_village, 'baum', datetime.now()) )
#sys.exit()
def spawn_web_server():
pass
while running:
try:
account.update()
except Exception as e:
traceback.print_exc()
logger.log_error('exception', traceback.format_exc(), str(e))
time.sleep(10)
time.sleep(0.05)
def execute(self, village):
village.build_building(self.get_build_id(), self['level'])
pages = village.refresh('resources')
if not any( event.building == self.get_build_id() and event.level == self['level'] for event in village.events.build ):
logger.log_error('build failed', pages['resources'].find('html').html(), title='Could not build %s level %s.' % (self['name'], self['level']))
