def execute(self, message, user, params):
chan = params.group(1)
access = params.group(2)
if not access.isdigit():
try:
access = Config.getint("Access", access)
except Exception:
message.reply("Invalid access level '%s'" % (access,))
return
else:
access = int(access)
if access > user.access:
message.reply("You may not add a user with higher access to your own")
return
try:
session.add(Channel(name=chan, userlevel=access, maxlevel=user.access))
session.commit()
message.reply("Added chan %s at level %s" % (chan, access))
message.privmsg("set %s autoinvite on" % (chan,), Config.get("Services", "nick"))
message.privmsg("invite %s" % (chan,), Config.get("Services", "nick"))
except IntegrityError:
session.rollback()
message.reply("Channel %s already exists" % (chan,))
def parse_N(self, scan_id, scan, page):
#incoming fleets
#<td class=left valign=top>Incoming</td><td valign=top>851</td><td class=left valign=top>We have detected an open jumpgate from Tertiary, located at 18:5:11. The fleet will approach our system in tick 855 and appears to have roughly 95 ships.</td>
for m in re.finditer('<td class="left" valign="top">Incoming</td><td valign="top">(\d+)</td><td class="left" valign="top">We have detected an open jumpgate from ([^<]+), located at (\d+):(\d+):(\d+). The fleet will approach our system in tick (\d+) and appears to have roughly (\d+) ships.</td>', page):
fleetscan = FleetScan()
newstick = m.group(1)
fleetname = m.group(2)
originx = m.group(3)
originy = m.group(4)
originz = m.group(5)
arrivaltick = int(m.group(6))
numships = m.group(7)
fleetscan.mission = "Unknown"
fleetscan.fleet_name = fleetname
fleetscan.launch_tick = newstick
fleetscan.landing_tick = arrivaltick
fleetscan.fleet_size = numships
owner=Planet.load(originx,originy,originz)
if owner is None:
continue
fleetscan.owner = owner
fleetscan.target = scan.planet
try:
scan.fleets.append(fleetscan)
session.commit()
except Exception, e:
session.rollback()
print "Exception in news: "+e.__str__()
traceback.print_exc()
continue
print 'Incoming: ' + newstick + ':' + fleetname + '-' + originx + ':' + originy + ':' + originz + '-' + arrivaltick + '|' + numships
def scan(self, uid, pa_id, gid=None):
page = urlopen(Config.get("URL","viewscan")%(pa_id,)).read()
page = decode(page)
m = re.search('>([^>]+) on (\d+)\:(\d+)\:(\d+) in tick (\d+)', page)
if not m:
print "Expired/non-matchinng scan (id: %s)" %(pa_id,)
return
scantype = m.group(1)[0].upper()
x = int(m.group(2))
y = int(m.group(3))
z = int(m.group(4))
tick = int(m.group(5))
planet = Planet.load(x,y,z)
if planet is None:
return
try:
scan = Scan(pa_id=pa_id, scantype=scantype, tick=tick, group_id=gid, scanner_id=uid)
planet.scans.append(scan)
session.commit()
scan_id = scan.id
except IntegrityError, e:
session.rollback()
print "Scan %s may already exist" %(pa_id,)
print e.__str__()
return
def execute(self, request, user, id, x, y, z, when):
planet = Planet.load(x,y,z)
if planet is None:
return self.attack(request, user, id, "No planet with coords %s:%s:%s" %(x,y,z,))
tick = Updates.current_tick()
when = int(when)
if when < PA.getint("numbers", "protection"):
eta = when
when += tick
elif when <= tick:
return self.attack(request, user, id, "Can not book targets in the past. You wanted tick %s, but current tick is %s." % (when, tick,))
else:
eta = when - tick
if when > 32767:
when = 32767
if planet.intel and planet.alliance and planet.alliance.name == Config.get("Alliance","name"):
return self.attack(request, user, id, "%s:%s:%s is %s in %s. Quick, launch before they notice!" % (x,y,z, planet.intel.nick or 'someone', Config.get("Alliance","name"),))
try:
planet.bookings.append(Target(user=user, tick=when))
session.commit()
except IntegrityError:
session.rollback()
target = planet.bookings.filter(Target.tick == when).first()
if target is not None:
return self.attack(request, user, id, "Target %s:%s:%s is already booked for landing tick %s by user %s" % (x,y,z, when, target.user.name,))
else:
return self.attack(request, user, id, "Booked landing on %s:%s:%s tick %s (eta %s) for user %s" % (x,y,z, when, (when-tick), user.name,))
return self.attack(request, user, id)
def execute(self, page, uid, pa_id, gid=None):
scanlog("Scan: %s (group: %s)" %(pa_id,gid,))
page = decode(page)
m = re.search('>([^>]+) on (\d+)\:(\d+)\:(\d+) in tick (\d+)', page)
if not m:
scanlog("Expired/non-matchinng scan (id: %s)" %(pa_id,))
return
scantype = m.group(1)[0].upper()
x = int(m.group(2))
y = int(m.group(3))
z = int(m.group(4))
tick = int(m.group(5))
m = re.search("<p class=\"right scan_time\">Scan time: ([^<]*)</p>", page)
scantime = m.group(1)
planet = Planet.load(x,y,z,)
try:
Q = session.query(Scan).filter(Scan.pa_id == pa_id).filter(Scan.planet_id == None)
if Q.count() > 0:
scan = Q.first()
else:
scan = Scan(pa_id=pa_id, scantype=scantype, tick=tick, time=scantime, group_id=gid, scanner_id=uid)
session.add(scan)
if planet:
planet.scans.append(scan)
session.commit()
scan_id = scan.id
except IntegrityError, e:
session.rollback()
scanlog("Scan %s may already exist: %s" %(pa_id,str(e),))
return
def execute(self, message, user, params):
chan = params.group(1)
access = params.group(2)
if not access.isdigit():
try:
access = Config.getint("Access",access)
except Exception:
message.reply("Invalid access level '%s'" % (access,))
return
else:
access = int(access)
if access > user.access:
message.reply("You may not add a user with higher access to your own")
return
try:
session.add(Channel(name=chan, userlevel=access, maxlevel=user.access))
session.commit()
message.reply("Added chan %s at level %s" % (chan,access,))
message.privmsg("set %s autoinvite on" %(chan,),Config.get("Services", "nick"));
message.privmsg("invite %s" %(chan,),Config.get("Services", "nick"));
except IntegrityError:
session.rollback()
message.reply("Channel %s already exists" % (chan,))
def execute(self, page, uid, pa_id, gid=None):
scanlog("Scan: %s (group: %s)" %(pa_id,gid,))
page = decode(page)
m = re.search('>([^>]+) on (\d+)\:(\d+)\:(\d+) in tick (\d+)', page)
if not m:
scanlog("Expired/non-matchinng scan (id: %s)" %(pa_id,))
return
scantype = m.group(1)[0].upper()
x = int(m.group(2))
y = int(m.group(3))
z = int(m.group(4))
tick = int(m.group(5))
planet = Planet.load(x,y,z)
if planet is None:
return
try:
scan = Scan(pa_id=pa_id, scantype=scantype, tick=tick, group_id=gid, scanner_id=uid)
planet.scans.append(scan)
session.commit()
scan_id = scan.id
except IntegrityError, e:
session.rollback()
scanlog("Scan %s may already exist: %s" %(pa_id,str(e),))
return
def __init__(self, message, m):
scanlog(asctime())
try:
pnick = "(%s)" % message.get_pnick()
except:
pnick = ""
scanlog("Galaxy status from %s%s" % (message.get_nick(), pnick))
target_x=m.group(1)
target_y=m.group(2)
target_z=m.group(3)
owner_x=m.group(4)
owner_y=m.group(5)
owner_z=m.group(6)
mission=m.group(7)
fleetname=m.group(8)
# race=m.group(10)
fleetsize=m.group(11)
eta=m.group(12)
if mission == "A":
mission = "Attack"
elif mission == "D":
mission = "Defend"
elif mission == "R":
mission = "Return"
target=Planet.load(target_x,target_y,target_z)
if target is None:
return
owner=Planet.load(owner_x,owner_y,owner_z)
if owner is None:
return
curtick=Updates.current_tick()
landing_tick = int(eta) + int(curtick)
scanlog("%s:%s:%s %s:%s:%s '%s' %s %s eta %s" % (owner_x,owner_y,owner_z,target_x,target_y,target_z,fleetname,fleetsize,mission,eta))
fleet = FleetScan(owner=owner, target=target, fleet_size=fleetsize, fleet_name=fleetname, landing_tick=landing_tick, mission=mission)
fleet.in_cluster = owner_x == target_x
fleet.in_galaxy = fleet.in_cluster and owner_y == target_y
try:
session.add(fleet)
session.commit()
except IntegrityError,e:
session.rollback()
print "Exception in galstatus: "+e.__str__()
scanlog("Exception in galstatus: "+e.__str__())
traceback.print_exc()
def parse_J(self, scan_id, scan, page):
# <td class=left>Origin</td><td class=left>Mission</td><td>Fleet</td><td>ETA</td><td>Fleetsize</td>
# <td class=left>13:10:5</td><td class=left>Attack</td><td>Gamma</td><td>5</td><td>265</td>
# <td class="left">15:7:11 </td><td class="left">Defend </td><td>Ad infinitum</td><td>9</td><td>0</td>
#<tr><td class="left">10:4:9</td><td class="left">Return</td><td>They look thirsty</td><td>5</td><td>3000</td></tr>
# <tr><td class="left">4:1:10</td><td class="left">Return</td><td>Or Is It?</td><td>9</td><td>3000</td></tr>
#<tr><td class="left">10:1:10</td><td class="left">Defend</td><td class="left">Pesticide IV</td><td class="right">1</td><td class="right">0</td></tr>
for m in re.finditer('<td[^>]*>(?:<a[^>]+>)?(\d+)\:(\d+)\:(\d+)(?:</a>)?[^/]*/[^/]*/td><td[^>]*>([^<]+)</td><td[^>]*>([^<]+)</td><td[^>]*>(\d+)</td><td[^>]*>(\d+(?:,\d{3})*)</td>', page):
scanlog("%s:%s:%s %s %s %s %s" %m.groups())
fleetscan = FleetScan()
originx = m.group(1)
originy = m.group(2)
originz = m.group(3)
mission = m.group(4)
fleet = m.group(5)
eta = int(m.group(6))
fleetsize = m.group(7).replace(',', '')
fleetscan.mission = mission
fleetscan.fleet_name = fleet
fleetscan.landing_tick = eta + scan.tick
fleetscan.fleet_size = fleetsize
attacker=PlanetHistory.load_planet(originx,originy,originz,scan.tick)
if attacker is None:
scanlog("Can't find attacker in db: %s:%s:%s tick: %s"%(originx,originy,originz, scan.tick))
continue
fleetscan.owner = attacker
fleetscan.target = scan.planet
fleetscan.in_cluster = fleetscan.owner.x == fleetscan.target.x
fleetscan.in_galaxy = fleetscan.in_cluster and fleetscan.owner.y == fleetscan.target.y
try:
scan.fleets.append(fleetscan)
session.commit()
except IntegrityError, e:
session.rollback()
scanlog("Caught integrity exception in jgp: %s"%(str(e),))
scanlog("Trying to update instead")
query = session.query(FleetScan).filter_by(owner=attacker, target=scan.planet, fleet_size=fleetsize, fleet_name=fleet, landing_tick=eta+scan.tick, mission=mission)
try:
query.update({"scan_id": scan_id})
session.commit()
except Exception, e:
session.rollback()
scanlog("Exception trying to update jgp: %s"%(str(e),), traceback=True)
continue
def execute(self, page, uid, pa_id, gid=None):
scanlog("Scan: %s (group: %s)" % (
pa_id,
gid,
))
page = decode(page)
m = re.search('>([^>]+) on (\d+)\:(\d+)\:(\d+) in tick (\d+)', page)
if not m:
scanlog("Expired/non-matchinng scan (id: %s)" % (pa_id, ))
return
scantype = m.group(1)[0].upper()
x = int(m.group(2))
y = int(m.group(3))
z = int(m.group(4))
tick = int(m.group(5))
m = re.search("<p class=\"right scan_time\">Scan time: ([^<]*)</p>",
page)
scantime = m.group(1)
planet = Planet.load(
x,
y,
z,
)
try:
Q = session.query(Scan).filter(Scan.pa_id == pa_id).filter(
Scan.planet_id == None)
if Q.count() > 0:
scan = Q.first()
else:
scan = Scan(pa_id=pa_id,
scantype=scantype,
tick=tick,
time=scantime,
group_id=gid,
scanner_id=uid)
session.add(scan)
if planet:
planet.scans.append(scan)
session.commit()
scan_id = scan.id
except IntegrityError, e:
session.rollback()
scanlog("Scan %s may already exist: %s" % (
pa_id,
str(e),
))
return
def parse_J(self, scan_id, scan, page):
# <td class=left>Origin</td><td class=left>Mission</td><td>Fleet</td><td>ETA</td><td>Fleetsize</td>
# <td class=left>13:10:5</td><td class=left>Attack</td><td>Gamma</td><td>5</td><td>265</td>
# <td class="left">15:7:11 </td><td class="left">Defend </td><td>Ad infinitum</td><td>9</td><td>0</td>
#<tr><td class="left">10:4:9</td><td class="left">Return</td><td>They look thirsty</td><td>5</td><td>3000</td></tr>
# <tr><td class="left">4:1:10</td><td class="left">Return</td><td>Or Is It?</td><td>9</td><td>3000</td></tr>
#<tr><td class="left">10:1:10</td><td class="left">Defend</td><td class="left">Pesticide IV</td><td class="right">1</td><td class="right">0</td></tr>
for m in re.finditer('<td[^>]*>(\d+)\:(\d+)\:(\d+)</td><td[^>]*>([^<]+)</td><td[^>]*>([^<]+)</td><td[^>]*>(\d+)</td><td[^>]*>(\d+(?:,\d{3})*)</td>', page):
fleetscan = FleetScan()
originx = m.group(1)
originy = m.group(2)
originz = m.group(3)
mission = m.group(4)
fleet = m.group(5)
eta = int(m.group(6))
fleetsize = m.group(7).replace(',', '')
fleetscan.mission = mission
fleetscan.fleet_name = fleet
fleetscan.landing_tick = eta + scan.tick
fleetscan.fleet_size = fleetsize
print "JGP fleet "
attacker=Planet.load(originx,originy,originz)
if attacker is None:
print "Can't find attacker in db: %s:%s:%s"%(originx,originy,originz)
continue
fleetscan.owner = attacker
fleetscan.target = scan.planet
try:
scan.fleets.append(fleetscan)
session.commit()
except IntegrityError, e:
session.rollback()
print "Caught integrity exception in jgp: "+e.__str__()
print "Trying to update instead"
query = session.query(FleetScan).filter_by(owner=attacker, target=scan.planet, fleet_size=fleetsize, fleet_name=fleet, landing_tick=eta+scan.tick, mission=mission)
try:
query.update({"scan_id": scan_id})
session.commit()
except Exception, e:
session.rollback()
print "Exception trying to update jgp: "+e.__str__()
traceback.print_exc()
continue
def __init__(self, message, m):
print m.groups()
target_x = m.group(1)
target_y = m.group(2)
target_z = m.group(3)
owner_x = m.group(4)
owner_y = m.group(5)
owner_z = m.group(6)
fleetname = m.group(7)
race = m.group(9)
fleetsize = m.group(10)
mission = m.group(11)
eta = m.group(12)
print "%s:%s:%s %s:%s:%s '%s' %s m:%s e:%s" % (
owner_x, owner_y, owner_z, target_x, target_y, target_z, fleetname,
fleetsize, mission, eta)
target = Planet.load(target_x, target_y, target_z)
if target is None:
return
owner = Planet.load(owner_x, owner_y, owner_z)
if owner is None:
return
curtick = Updates.current_tick()
landing_tick = int(eta) + int(curtick)
fleet = FleetScan(owner=owner,
target=target,
fleet_size=fleetsize,
fleet_name=fleetname,
landing_tick=landing_tick,
mission=mission)
fleet.in_cluster = owner_x == target_x
fleet.in_galaxy = fleet.in_cluster and owner_y == target_y
try:
session.add(fleet)
session.commit()
except IntegrityError, e:
session.rollback()
print "Exception in galstatus: " + e.__str__()
traceback.print_exc()
def execute(self, message, user, params):
chan = params.group(1)
if "galmate" in Config.options("Access"):
access = Config.getint("Access","galmate")
else:
access = 0
try:
session.add(Channel(name=chan, userlevel=access, maxlevel=access))
session.commit()
message.reply("Added your galchannel as %s (if you didn't add me to the channel with at least access 24 first, I'm never going to bother joining)" % (chan,))
message.privmsg("set %s autoinvite on" %(chan,),'P');
message.privmsg("invite %s" %(chan,),'P');
except IntegrityError:
session.rollback()
message.reply("Channel %s already exists" % (chan,))
def parse_N(self, scan_id, scan, page):
#incoming fleets
#<td class=left valign=top>Incoming</td><td valign=top>851</td><td class=left valign=top>We have detected an open jumpgate from Tertiary, located at 18:5:11. The fleet will approach our system in tick 855 and appears to have roughly 95 ships.</td>
for m in re.finditer(
'<td class="left" valign="top">Incoming</td><td valign="top">(\d+)</td><td class="left" valign="top">We have detected an open jumpgate from ([^<]+), located at <a[^>]+>(\d+):(\d+):(\d+)</a>. The fleet will approach our system in tick (\d+) and appears to have (\d+) visible ships.</td>',
page):
fleetscan = FleetScan()
newstick = m.group(1)
fleetname = m.group(2)
originx = m.group(3)
originy = m.group(4)
originz = m.group(5)
arrivaltick = m.group(6)
numships = m.group(7)
fleetscan.mission = "Unknown"
fleetscan.fleet_name = fleetname
fleetscan.launch_tick = newstick
fleetscan.landing_tick = int(arrivaltick)
fleetscan.fleet_size = numships
owner = PlanetHistory.load_planet(
originx,
originy,
originz,
newstick,
closest=not Config.getboolean("Misc", "catchup"))
if owner is None:
continue
fleetscan.owner = owner
fleetscan.target = scan.planet
fleetscan.in_cluster = fleetscan.owner.x == fleetscan.target.x
fleetscan.in_galaxy = fleetscan.in_cluster and fleetscan.owner.y == fleetscan.target.y
try:
scan.fleets.append(fleetscan)
session.commit()
except Exception, e:
session.rollback()
scanlog("Exception in news: %s" % (str(e), ), traceback=True)
continue
scanlog('Incoming: ' + newstick + ':' + fleetname + '-' + originx +
':' + originy + ':' + originz + '-' + arrivaltick + '|' +
numships)
def __init__(self, message, m):
print m.groups()
target_x=m.group(1)
target_y=m.group(2)
target_z=m.group(3)
owner_x=m.group(4)
owner_y=m.group(5)
owner_z=m.group(6)
fleetname=m.group(7)
race=m.group(9)
fleetsize=m.group(10)
mission=m.group(11)
eta=m.group(12)
print "%s:%s:%s %s:%s:%s '%s' %s m:%s e:%s"%(owner_x,owner_y,owner_z,target_x,target_y,target_z,fleetname,fleetsize,mission,eta)
target=Planet.load(target_x,target_y,target_z)
if target is None:
return
owner=Planet.load(owner_x,owner_y,owner_z)
if owner is None:
return
curtick=Updates.current_tick()
landing_tick = int(eta) + int(curtick)
fleet = FleetScan(owner=owner, target=target, fleet_size=fleetsize, fleet_name=fleetname, landing_tick=landing_tick, mission=mission)
fleet.in_cluster = owner_x == target_x
fleet.in_galaxy = fleet.in_cluster and owner_y == target_y
try:
session.add(fleet)
session.commit()
except IntegrityError,e:
session.rollback()
print "Exception in galstatus: "+e.__str__()
traceback.print_exc()
def execute(self, message, user, params):
chan = params.group(1)
if "galmate" in Config.options("Access"):
access = Config.getint("Access", "galmate")
else:
access = 0
try:
session.add(Channel(name=chan, userlevel=access, maxlevel=access))
session.commit()
message.reply(
"Added your galchannel as %s (if you didn't add me to the channel with at least access 24 first, I'm never going to bother joining)"
% (chan, ))
message.privmsg("set %s autoinvite on" % (chan, ),
Config.get("Services", "nick"))
message.privmsg("invite %s" % (chan, ),
Config.get("Services", "nick"))
except IntegrityError:
session.rollback()
message.reply("Channel %s already exists" % (chan, ))
def parse_N(self, scan_id, scan, page):
#incoming fleets
#<td class=left valign=top>Incoming</td><td valign=top>851</td><td class=left valign=top>We have detected an open jumpgate from Tertiary, located at 18:5:11. The fleet will approach our system in tick 855 and appears to have roughly 95 ships.</td>
for m in re.finditer('<td class="left" valign="top">Incoming</td><td valign="top">(\d+)</td><td class="left" valign="top">We have detected an open jumpgate from ([^<]+), located at <a[^>]+>(\d+):(\d+):(\d+)</a>. The fleet will approach our system in tick (\d+) and appears to have (\d+) visible ships.</td>', page):
fleetscan = FleetScan()
newstick = m.group(1)
fleetname = m.group(2)
originx = m.group(3)
originy = m.group(4)
originz = m.group(5)
arrivaltick = m.group(6)
numships = m.group(7)
fleetscan.mission = "Unknown"
fleetscan.fleet_name = fleetname
fleetscan.launch_tick = newstick
fleetscan.landing_tick = int(arrivaltick)
fleetscan.fleet_size = numships
owner = PlanetHistory.load_planet(originx,originy,originz,newstick,closest=not Config.getboolean("Misc", "catchup"))
if owner is None:
continue
fleetscan.owner = owner
fleetscan.target = scan.planet
fleetscan.in_cluster = fleetscan.owner.x == fleetscan.target.x
fleetscan.in_galaxy = fleetscan.in_cluster and fleetscan.owner.y == fleetscan.target.y
try:
scan.fleets.append(fleetscan)
session.commit()
except Exception, e:
session.rollback()
scanlog("Exception in news: %s"%(str(e),), traceback=True)
continue
scanlog('Incoming: ' + newstick + ':' + fleetname + '-' + originx + ':' + originy + ':' + originz + '-' + arrivaltick + '|' + numships)
def execute(self, page, uid, pa_id, gid=None):
scanlog("Scan: %s (group: %s)" % (
pa_id,
gid,
))
page = decode(page)
m = re.search('>([^>]+) on (\d+)\:(\d+)\:(\d+) in tick (\d+)', page)
if not m:
scanlog("Expired/non-matchinng scan (id: %s)" % (pa_id, ))
return
scantype = m.group(1)[0].upper()
x = int(m.group(2))
y = int(m.group(3))
z = int(m.group(4))
tick = int(m.group(5))
planet = Planet.load(x, y, z)
if planet is None:
return
try:
scan = Scan(pa_id=pa_id,
scantype=scantype,
tick=tick,
group_id=gid,
scanner_id=uid)
planet.scans.append(scan)
session.commit()
scan_id = scan.id
except IntegrityError, e:
session.rollback()
scanlog("Scan %s may already exist: %s" % (
pa_id,
str(e),
))
return
def parse_J(self, scan_id, scan, page):
# <td class=left>Origin</td><td class=left>Mission</td><td>Fleet</td><td>ETA</td><td>Fleetsize</td>
# <td class=left>13:10:5</td><td class=left>Attack</td><td>Gamma</td><td>5</td><td>265</td>
# <td class="left">15:7:11 </td><td class="left">Defend </td><td>Ad infinitum</td><td>9</td><td>0</td>
#<tr><td class="left">10:4:9</td><td class="left">Return</td><td>They look thirsty</td><td>5</td><td>3000</td></tr>
# <tr><td class="left">4:1:10</td><td class="left">Return</td><td>Or Is It?</td><td>9</td><td>3000</td></tr>
#<tr><td class="left">10:1:10</td><td class="left">Defend</td><td class="left">Pesticide IV</td><td class="right">1</td><td class="right">0</td></tr>
for m in re.finditer(
'<td[^>]*>(?:<a[^>]+>)?(\d+)\:(\d+)\:(\d+)(?:</a>)?[^/]*/[^/]*/td><td[^>]*>([^<]+)</td><td[^>]*>([^<]+)</td><td[^>]*>(\d+)</td><td[^>]*>(\d+(?:,\d{3})*)</td>',
page):
scanlog("%s:%s:%s %s %s %s %s" % m.groups())
fleetscan = FleetScan()
originx = m.group(1)
originy = m.group(2)
originz = m.group(3)
mission = m.group(4)
fleet = m.group(5)
eta = int(m.group(6))
fleetsize = m.group(7).replace(',', '')
fleetscan.mission = mission
fleetscan.fleet_name = fleet
fleetscan.landing_tick = eta + scan.tick
fleetscan.fleet_size = fleetsize
attacker = PlanetHistory.load_planet(originx, originy, originz,
scan.tick)
if attacker is None:
scanlog("Can't find attacker in db: %s:%s:%s tick: %s" %
(originx, originy, originz, scan.tick))
continue
fleetscan.owner = attacker
fleetscan.target = scan.planet
fleetscan.in_cluster = fleetscan.owner.x == fleetscan.target.x
fleetscan.in_galaxy = fleetscan.in_cluster and fleetscan.owner.y == fleetscan.target.y
try:
scan.fleets.append(fleetscan)
session.commit()
except IntegrityError, e:
session.rollback()
scanlog("Caught integrity exception in jgp: %s" % (str(e), ))
scanlog("Trying to update instead")
query = session.query(FleetScan).filter_by(
owner=attacker,
target=scan.planet,
fleet_size=fleetsize,
fleet_name=fleet,
landing_tick=eta + scan.tick,
mission=mission)
try:
query.update({"scan_id": scan_id})
session.commit()
except Exception, e:
session.rollback()
scanlog("Exception trying to update jgp: %s" % (str(e), ),
traceback=True)
continue
def execute(self, message, user, params):
planet = Planet.load(*params.group(1,3,5))
if planet is None:
message.alert("No planet with coords %s:%s:%s" % params.group(1,3,5))
return
tick = Updates.current_tick()
when = int(params.group(6))
if when < 32:
eta = when
when += tick
elif when <= tick:
message.alert("Can not book targets in the past. You wanted tick %s, but current tick is %s." % (when, tick,))
return
else:
eta = when - tick
if when > 32767:
when = 32767
override = params.group(7)
if planet.intel and planet.alliance and planet.alliance.name == Config.get("Alliance","name"):
message.reply("%s:%s:%s is %s in %s. Quick, launch before they notice the highlight." % (planet.x,planet.y,planet.z, planet.intel.nick or 'someone', Config.get("Alliance","name"),))
return
T = session.query(Attack)
T = T.join(AttackData)
T = T.filter(AttackData.planet_id == planet.id)
T = T.filter(Attack.start_time < datetime.datetime.now())
T = T.filter(Attack.book_time > datetime.datetime.now())
tresult = T.all()
if len(tresult) >= 1:
message.reply("Target %s:%s:%s is part of an upcoming attack" % (planet.x,planet.y,planet.z,))
return
Q = session.query(User.name, Target.tick)
Q = Q.join(Target.user)
Q = Q.filter(Target.planet == planet)
Q = Q.filter(Target.tick >= when)
Q = Q.order_by(asc(Target.tick))
result = Q.all()
if len(result) >= 1:
booker, land = result[0]
if land == when:
if str(params.group(7)) == "later" or str(params.group(8)) == "later":
later = when+1
Q2 = session.query(User.name, Target.tick)
Q2 = Q2.join(Target.user)
Q2 = Q2.filter(Target.planet == planet)
Q2 = Q2.filter(Target.tick >= later)
Q2 = Q2.order_by(asc(Target.tick))
result2 = Q2.all()
if len(result2) >= 1:
laterbooker, laterland = result2[0]
if laterland == later:
message.reply("YOU CANNOT HIT %s:%s:%s. NOT EVEN SLOPPY SECOND'S. THIS TARGET IS MORE TAKEN THAN YOUR MUM, AMIRITE?" % (planet.x,planet.y,planet.z,))
return
try:
planet.bookings.append(Target(user=user, tick=later))
session.commit()
message.reply("YOU HAVE BEEN BEATEN TO THIS TARGET. YOU ARE NOW GETTING SLOPPY SECOND'S ON %s:%s:%s TAKING PLACE ON TICK %s" % (planet.x,planet.y,planet.z, later,))
return
except IntegrityError:
session.rollback()
raise Exception("Integrity error? Unable to booking for pid %s and tick %s"%(planet.id, later,))
return
else:
message.reply("Target %s:%s:%s is already booked for landing tick %s by user %s" % (planet.x,planet.y,planet.z, land, booker,))
return
if params.group(7) is None or (str(params.group(7)) == "later" and params.group(8) is None):
reply="There are already bookings for that target after landing pt %s (eta %s). To see status on this target, do !status %s:%s:%s." % (when,eta, planet.x,planet.y,planet.z,)
reply+=" To force booking at your desired eta/landing tick, use !book %s:%s:%s %s yes (Bookers: " %(planet.x,planet.y,planet.z, when,)
prev=[]
for booker, land in result:
prev.append("(%s user:%s)" % (land, booker,))
reply += ", ".join(prev) + ")"
message.reply(reply)
return
try:
planet.bookings.append(Target(user=user, tick=when))
session.commit()
message.reply("Booked landing on %s:%s:%s tick %s for user %s" % (planet.x,planet.y,planet.z, when, user.name,))
return
except IntegrityError:
session.rollback()
raise Exception("Integrity error? Unable to booking for pid %s and tick %s"%(planet.id, when,))
return
owner=attacker,
target=scan.planet,
fleet_size=fleetsize,
fleet_name=fleet,
landing_tick=eta + scan.tick,
mission=mission)
try:
query.update({"scan_id": scan_id})
session.commit()
except Exception, e:
session.rollback()
scanlog("Exception trying to update jgp: %s" % (str(e), ),
traceback=True)
continue
except Exception, e:
session.rollback()
scanlog("Exception in jgp: %s" % (str(e), ), traceback=True)
continue
def parse_N(self, scan_id, scan, page):
#incoming fleets
#<td class=left valign=top>Incoming</td><td valign=top>851</td><td class=left valign=top>We have detected an open jumpgate from Tertiary, located at 18:5:11. The fleet will approach our system in tick 855 and appears to have roughly 95 ships.</td>
for m in re.finditer(
'<td class="left" valign="top">Incoming</td><td valign="top">(\d+)</td><td class="left" valign="top">We have detected an open jumpgate from ([^<]+), located at <a[^>]+>(\d+):(\d+):(\d+)</a>. The fleet will approach our system in tick (\d+) and appears to have (\d+) visible ships.</td>',
page):
fleetscan = FleetScan()
newstick = m.group(1)
fleetname = m.group(2)
originx = m.group(3)
originy = m.group(4)
def execute(self, message, user, params):
planet = Planet.load(*params.group(1,3,5))
if planet is None:
message.alert("No planet with coords %s:%s:%s" % params.group(1,3,5))
return
tick = Updates.current_tick()
when = int(params.group(6))
if when < PA.getint("numbers", "protection"):
eta = when
when += tick
elif when <= tick:
message.alert("Can not book targets in the past. You wanted tick %s, but current tick is %s." % (when, tick,))
return
else:
eta = when - tick
if when > 32767:
when = 32767
override = params.group(7)
later = params.group(8)
if planet.intel and planet.alliance and planet.alliance.name == Config.get("Alliance","name"):
message.reply("%s:%s:%s is %s in %s. Quick, launch before they notice the highlight." % (planet.x,planet.y,planet.z, planet.intel.nick or 'someone', Config.get("Alliance","name"),))
return
free, book1, book2 = self.get_free_book(planet, when, later)
if free is None:
if later is None:
message.reply("Target %s:%s:%s is already booked for landing tick %s by user %s" % (planet.x,planet.y,planet.z, when, book1.user.name,))
else:
message.reply("You cannot hit %s:%s:%s. Not even sloppy seconds. This target is more taken than your mum, amirite?" % (planet.x,planet.y,planet.z,))
return
if override is None and later is None:
books = planet.bookings.filter(Target.tick >= when).order_by(asc(Target.tick)).all()
if len(books) >= 1:
reply = "There are already bookings for that target after landing pt %s (eta %s). To see status on this target, do !status %s:%s:%s." % (when,eta, planet.x,planet.y,planet.z,)
reply+= " To force booking at your desired eta/landing tick, use !book %s:%s:%s %s yes (Bookers: " %(planet.x,planet.y,planet.z, when,)
prev=[]
for book in books:
prev.append("(%s user:%s)" % (book.tick, book.user.name,))
reply += ", ".join(prev) + ")"
message.reply(reply)
return
if free == when:
reply = "Booked landing on %s:%s:%s tick %s (eta %s) for user %s" % (planet.x,planet.y,planet.z, free, (free-tick), user.name,)
elif free == when + 1:
reply = "You have been beaten to %s:%s:%s by %s. You are now getting sloppy seconds at tick %s (eta %s)" % (planet.x,planet.y,planet.z, book1.user.name, free, (free-tick),)
elif free == when + 2:
reply = "You've been beaten to %s:%s:%s by %s and %s you slow retarded f****t. I feel sorry for you, so have tick %s (eta %s)" % (planet.x,planet.y,planet.z, book1.user.name, book2.user.name, free, (free-tick),)
try:
planet.bookings.append(Target(user=user, tick=free))
session.commit()
message.reply(reply)
return
except IntegrityError:
session.rollback()
raise Exception("Integrity error? Unable to booking for pid %s and tick %s"%(planet.id, when,))
return
def execute(self, message, user, params):
planet = Planet.load(*params.group(1, 3, 5))
if planet is None:
message.alert("No planet with coords %s:%s:%s" %
params.group(1, 3, 5))
return
tick = Updates.current_tick()
when = int(params.group(6))
if when < PA.getint("numbers", "protection"):
eta = when
when += tick
elif when <= tick:
message.alert(
"Can not book targets in the past. You wanted tick %s, but current tick is %s."
% (
when,
tick,
))
return
else:
eta = when - tick
if when > 32767:
when = 32767
override = params.group(7)
later = params.group(8)
if planet.intel and planet.alliance and planet.alliance.name == Config.get(
"Alliance", "name"):
message.reply(
"%s:%s:%s is %s in %s. Quick, launch before they notice the highlight."
% (
planet.x,
planet.y,
planet.z,
planet.intel.nick or 'someone',
Config.get("Alliance", "name"),
))
return
free, book1, book2 = self.get_free_book(planet, when, later)
if free is None:
if later is None:
message.reply(
"Target %s:%s:%s is already booked for landing tick %s by user %s"
% (
planet.x,
planet.y,
planet.z,
when,
book1.user.name,
))
else:
message.reply(
"You cannot hit %s:%s:%s. Not even sloppy seconds. This target is more taken than your mum, amirite?"
% (
planet.x,
planet.y,
planet.z,
))
return
if override is None and later is None:
books = planet.bookings.filter(Target.tick >= when).order_by(
asc(Target.tick)).all()
if len(books) >= 1:
reply = "There are already bookings for that target after landing pt %s (eta %s). To see status on this target, do !status %s:%s:%s." % (
when,
eta,
planet.x,
planet.y,
planet.z,
)
reply += " To force booking at your desired eta/landing tick, use !book %s:%s:%s %s yes (Bookers: " % (
planet.x,
planet.y,
planet.z,
when,
)
prev = []
for book in books:
prev.append("(%s user:%s)" % (
book.tick,
book.user.name,
))
reply += ", ".join(prev) + ")"
message.reply(reply)
return
if free == when:
reply = "Booked landing on %s:%s:%s tick %s (eta %s) for user %s" % (
planet.x,
planet.y,
planet.z,
free,
(free - tick),
user.name,
)
elif free == when + 1:
reply = "You have been beaten to %s:%s:%s by %s. You are now getting sloppy seconds at tick %s (eta %s)" % (
planet.x,
planet.y,
planet.z,
book1.user.name,
free,
(free - tick),
)
elif free == when + 2:
reply = "You've been beaten to %s:%s:%s by %s and %s you slow retarded f****t. I feel sorry for you, so have tick %s (eta %s)" % (
planet.x,
planet.y,
planet.z,
book1.user.name,
book2.user.name,
free,
(free - tick),
)
try:
planet.bookings.append(Target(user=user, tick=free))
session.commit()
message.reply(reply)
return
except IntegrityError:
session.rollback()
raise Exception(
"Integrity error? Unable to booking for pid %s and tick %s" % (
planet.id,
when,
))
return
)
)
# Finally we can commit!
session.commit()
t2 = time.time() - t1
print "History and final update in %.3f seconds" % (t2,)
t1 = time.time()
break
except Exception, e:
print "Something random went wrong, sleeping for 15 seconds to hope it improves"
print e.__str__()
traceback.print_exc()
session.rollback()
time.sleep(15)
continue
session.close()
t1 = time.time() - t_start
print "Total time taken: %.3f seconds" % (t1,)
# Measure some dicks
last_tick = Updates.current_tick()
history_tick = max(last_tick - 72, 1)
t_start = time.time()
t1 = t_start
session.execute(epenis.__table__.delete())
session.execute(text("SELECT setval('epenis_rank_seq', 1, :false);", bindparams=[false]))
def execute(self, request, user, id, x, y, z, when):
planet = Planet.load(x, y, z)
if planet is None:
return self.attack(request, user, id,
"No planet with coords %s:%s:%s" % (
x,
y,
z,
))
tick = Updates.current_tick()
when = int(when)
if when < PA.getint("numbers", "protection"):
eta = when
when += tick
elif when <= tick:
return self.attack(
request, user, id,
"Can not book targets in the past. You wanted tick %s, but current tick is %s."
% (
when,
tick,
))
else:
eta = when - tick
if when > 32767:
when = 32767
if planet.intel and planet.alliance and planet.alliance.name == Config.get(
"Alliance", "name"):
return self.attack(
request, user, id,
"%s:%s:%s is %s in %s. Quick, launch before they notice!" % (
x,
y,
z,
planet.intel.nick or 'someone',
Config.get("Alliance", "name"),
))
try:
planet.bookings.append(Target(user=user, tick=when))
session.commit()
except IntegrityError:
session.rollback()
target = planet.bookings.filter(Target.tick == when).first()
if target is not None:
return self.attack(
request, user, id,
"Target %s:%s:%s is already booked for landing tick %s by user %s"
% (
x,
y,
z,
when,
target.user.name,
))
else:
return self.attack(
request, user, id,
"Booked landing on %s:%s:%s tick %s (eta %s) for user %s" % (
x,
y,
z,
when,
(when - tick),
user.name,
))
return self.attack(request, user, id)
