def caprate(self, attacker=None):
maxcap = PA.getfloat("roids", "maxcap")
mincap = PA.getfloat("roids", "mincap")
if not attacker or not self.value:
return maxcap
modifier = (float(self.value) / float(attacker.value)) ** 0.5
return max(mincap, min(maxcap * modifier, maxcap))
def execute(self, message, user, params):
roids, cost, bonus = params.groups()
roids, cost, bonus = int(roids), self.short2num(cost), int(bonus or 0)
mining = PA.getint("roids", "mining")
if roids == 0:
message.reply("Another NewDawn landing, eh?")
return
mining = mining * ((float(bonus) + 100) / 100)
ticks = (cost * PA.getint("numbers", "ship_value")) / (roids * mining)
reply = "Capping %s roids at %s value with %s%% bonus will repay in %s ticks (%s days)" % (
roids,
self.num2short(cost),
bonus,
int(ticks),
int(ticks / 24),
)
for gov in PA.options("govs"):
bonus = PA.getfloat(gov, "prodcost")
if bonus == 0:
continue
ticks_b = ticks * (1 + bonus)
reply += " %s: %s ticks (%s days)" % (PA.get(gov, "name"), int(ticks_b), int(ticks_b / 24))
message.reply(reply)
def execute(self, message, user, params):
num, name = params.groups()
ship = Ship.load(name=name)
if ship is None:
message.alert("No Ship called: %s" % (name,))
return
num = self.short2num(num)
reply="Buying %s %s will cost %s metal, %s crystal and %s eonium."%(num,ship.name,
self.num2short(ship.metal*num),
self.num2short(ship.crystal*num),
self.num2short(ship.eonium*num))
for gov in PA.options("govs"):
bonus = PA.getfloat(gov, "prodcost")
if bonus == 0:
continue
reply += " %s: %s metal, %s crystal and %s eonium."%(
PA.get(gov, "name"),
self.num2short(ship.metal*(1+bonus)*num),
self.num2short(ship.crystal*(1+bonus)*num),
self.num2short(ship.eonium*(1+bonus)*num))
reply+=" It will add %s value"%(self.num2short(ship.total_cost*num/100),)
message.reply(reply)
def planet(self, message, user, params):
planet = Planet.load(*params.group(1,3,5))
if planet is None:
message.reply("No planet with coords %s:%s:%s found" % params.group(1,3,5))
return
# List of last 10 scans
if params.group(6) == "o":
scans = planet.scans.filter_by(scantype=self.type).order_by(desc(Scan.id))[:10]
if len(scans) < 1:
message.reply("No %s Scans of %s:%s:%s found"%(PA.get(self.type,"name"),planet.x,planet.y,planet.z))
return
prev = []
for scan in scans:
prev.append("(pt%s %s)" % (scan.tick, scan.pa_id,))
reply = "Last 10 %s Scans on %s:%s:%s "%(PA.get(self.type,"name"),planet.x,planet.y,planet.z) + " ".join(prev)
message.reply(reply)
return
# Latest scan
scan = planet.scan(self.type)
if scan is None:
message.reply("No %s Scans of %s:%s:%s found"%(PA.get(self.type,"name"),planet.x,planet.y,planet.z))
return
# Link to scan
if params.group(7) == "l":
reply = "%s on %s:%s:%s " % (scan.type,planet.x,planet.y,planet.z,)
reply+= self.url(scan.link, user)
message.reply(reply)
return
# Display the scan
message.reply(self.url(str(scan), user))
def execute(self, request, user, x, y, z, h=False, hs=False, ticks=None):
planet = Planet.load(x,y,z)
if planet is None:
return HttpResponseRedirect(reverse("planet_ranks"))
ticks = int(ticks or 0) if (h or hs) else 12
if not hs:
sizediffvalue = PlanetHistory.rdiff * PA.getint("numbers", "roid_value")
valuediffwsizevalue = PlanetHistory.vdiff - sizediffvalue
resvalue = valuediffwsizevalue * PA.getint("numbers", "res_value")
shipvalue = valuediffwsizevalue * PA.getint("numbers", "ship_value")
xpvalue = PlanetHistory.xdiff * PA.getint("numbers", "xp_value")
Q = session.query(PlanetHistory,
sizediffvalue,
valuediffwsizevalue,
resvalue, shipvalue,
xpvalue,
)
Q = Q.filter(PlanetHistory.current == planet)
Q = Q.order_by(desc(PlanetHistory.tick))
history = Q[:ticks] if ticks else Q.all()
else:
history = None
if not (h or hs):
landings = session.query(PlanetLandings.hour, count()).filter(PlanetLandings.planet==planet).group_by(PlanetLandings.hour).all()
landed = session.query(PlanetLandedOn.hour, count()).filter(PlanetLandedOn.planet==planet).group_by(PlanetLandedOn.hour).all()
vdrops = session.query(PlanetValueDrops.hour, count()).filter(PlanetValueDrops.planet==planet).group_by(PlanetValueDrops.hour).all()
idles = session.query(PlanetIdles.hour, count()).filter(PlanetIdles.planet==planet).group_by(PlanetIdles.hour).all()
hourstats = {
'landings' : dict(landings), 'landingsT' : sum([c for hour,c in landings]),
'landed' : dict(landed), 'landedT' : sum([c for hour,c in landed]),
'vdrops' : dict(vdrops), 'vdropsT' : sum([c for hour,c in vdrops]),
'idles' : dict(idles), 'idlesT' : sum([c for hour,c in idles]),
}
else:
hourstats = None
if not h:
Q = session.query(PlanetHistory)
Q = Q.filter(or_(PlanetHistory.hour == 23, PlanetHistory.tick == Updates.current_tick()))
Q = Q.filter(PlanetHistory.current == planet)
Q = Q.order_by(desc(PlanetHistory.tick))
hsummary = Q.all() if hs else Q[:14]
else:
hsummary = None
return render(["planet.tpl",["hplanet.tpl","hsplanet.tpl"][hs]][h or hs],
request,
planet = planet,
history = history,
hour = datetime.utcnow().hour, hourstats = hourstats,
hsummary = hsummary,
ticks = ticks,
)
def execute(self, request, user, x, y, h=False, hs=False, ticks=None):
galaxy = Galaxy.load(x,y)
if galaxy is None:
return HttpResponseRedirect(reverse("galaxy_ranks"))
ticks = int(ticks or 0) if (h or hs) else 12
if not (h or hs):
Q = session.query(Planet, Intel.nick, Alliance.name)
Q = Q.outerjoin(Planet.intel)
Q = Q.outerjoin(Intel.alliance)
Q = Q.filter(Planet.active == True)
Q = Q.filter(Planet.galaxy == galaxy)
Q = Q.order_by(asc(Planet.z))
planets = Q.all()
exiles = galaxy.exiles[:10]
else:
planets, exiles = None, None
if not hs:
sizediffvalue = GalaxyHistory.rdiff * PA.getint("numbers", "roid_value")
valuediffwsizevalue = GalaxyHistory.vdiff - sizediffvalue
resvalue = valuediffwsizevalue * PA.getint("numbers", "res_value")
shipvalue = valuediffwsizevalue * PA.getint("numbers", "ship_value")
xpvalue = GalaxyHistory.xdiff * PA.getint("numbers", "xp_value")
Q = session.query(GalaxyHistory,
sizediffvalue,
valuediffwsizevalue,
resvalue, shipvalue,
xpvalue,
)
Q = Q.filter(GalaxyHistory.current == galaxy)
Q = Q.order_by(desc(GalaxyHistory.tick))
history = Q[:ticks] if ticks else Q.all()
else:
history = None
if not h:
Q = session.query(GalaxyHistory)
Q = Q.filter(or_(GalaxyHistory.hour == 23, GalaxyHistory.tick == Updates.current_tick()))
Q = Q.filter(GalaxyHistory.current == galaxy)
Q = Q.order_by(desc(GalaxyHistory.tick))
hsummary = Q.all() if hs else Q[:14]
else:
hsummary = None
return render(["galaxy.tpl",["hgalaxy.tpl","hsgalaxy.tpl"][hs]][h or hs],
request,
galaxy = galaxy,
planets = planets,
exiles = exiles,
history = history,
hsummary = hsummary,
ticks = ticks,
)
def execute(self, message, user, params):
p = Planet.load(*params.group(1,3,5))
if p is None:
message.reply("No planet with coords %s:%s:%s found" % params.group(1,3,5))
return
ship = Ship.load(name=params.group(6))
if ship is None:
message.alert("No Ship called: %s" % (params.group(6),))
return
scan = p.scan("P")
if scan is None:
message.reply("No planet scans available on %s:%s:%s" % (p.x,p.y,p.z,))
return
planetscan = scan.planetscan
tick=scan.tick
res_m=planetscan.res_metal
res_c=planetscan.res_crystal
res_e=planetscan.res_eonium
prod_res=planetscan.prod_res
rand_id=scan.pa_id
cost_m=ship.metal
cost_c=ship.crystal
cost_e=ship.eonium
total_cost=ship.total_cost
class_factory_table = {'Fighter': 'factory_usage_light', 'Corvette': 'factory_usage_light', 'Frigate': 'factory_usage_medium',
'Destroyer': 'factory_usage_medium', 'Cruiser': 'factory_usage_heavy', 'Battleship': 'factory_usage_heavy'}
prod_modifier_table = {'None': 0, 'Low': 33, 'Medium': 66, 'High': 100}
capped_number=min(res_m/cost_m, res_c/cost_c, res_e/cost_e)
overflow=res_m+res_c+res_e-(capped_number*(cost_m+cost_c+cost_e))
buildable = capped_number + ((overflow*.95)/total_cost)
demo = 1/(1+PA.getfloat("demo","prodcost"))
total = 1/(1+PA.getfloat("total","prodcost"))
reply="Newest planet scan on %s:%s:%s (id: %s, pt: %s)" % (p.x,p.y,p.z,rand_id,tick)
reply+=" can purchase %s: %s | Demo: %s | Total: %s"%(ship.name,int(buildable),int(buildable*demo),int(buildable*total))
if prod_res > 0:
factory_usage=getattr(planetscan,class_factory_table[ship.class_])
max_prod_modifier=prod_modifier_table[factory_usage]
buildable_from_prod = buildable + max_prod_modifier*(prod_res)/100/total_cost
reply+=" Counting %d res in prod at %s usage:" % (prod_res,factory_usage)
reply+=" %s | Demo: %s | Total: %s "%(int(buildable_from_prod), int(buildable_from_prod*demo),int(buildable*total))
message.reply(reply)
def robocop(self, message, scantype, pa_id, x, y, z, names):
nicks = []
[nicks.extend(nick) for nick in [CUT.list_user_nicks(name) for name in names.split(",")]]
reply = "%s on %s:%s:%s " % (PA.get(scantype,"name"),x,y,z,)
reply+= Config.get("URL","viewscan") % (pa_id,)
for nick in nicks:
message.privmsg(reply, nick)
reply = "%s on %s:%s:%s " % (PA.get(scantype,"name"),x,y,z,)
reply+= "delivered to: "
reply+= ", ".join(nicks)
from Hooks.scans.request import request
message.privmsg(reply, request().scanchan())
def execute(self, message, user, params):
# Planet
if len(params.groups()) > 1:
planet = Planet.load(*params.group(1,3,5))
if planet is None:
message.reply("No planet with coords %s:%s:%s found" % params.group(1,3,5))
return
# List of last 10 scans
if params.group(6) == "o":
scans = planet.scans.filter_by(scantype=self.type).order_by(desc(Scan.id))[:10]
if len(scans) < 1:
message.reply("No %s Scans of %s:%s:%s found"%(PA.get(self.type,"name"),planet.x,planet.y,planet.z))
return
prev = []
for scan in scans:
prev.append("(pt%s %s)" % (scan.tick, scan.pa_id,))
reply = "Last 10 %s Scans on %s:%s:%s "%(PA.get(self.type,"name"),planet.x,planet.y,planet.z) + " ".join(prev)
message.reply(reply)
return
# Latest scan
scan = planet.scan(self.type)
if scan is None:
message.reply("No %s Scans of %s:%s:%s found"%(PA.get(self.type,"name"),planet.x,planet.y,planet.z))
return
# Link to scan
if params.group(7) == "l":
reply = "%s on %s:%s:%s " % (PA.get(self.type,"name"),planet.x,planet.y,planet.z,)
reply+= Config.get("URL","viewscan") % (scan.pa_id,)
message.reply(reply)
return
# Display the scan
message.reply(str(scan))
# ID
else:
Q = session.query(Scan)
Q = Q.filter(Scan.pa_id.ilike("%"+params.group(1)+"%"))
Q = Q.order_by(desc(Scan.id))
scan = Q.first()
if scan is None:
message.reply("No Scans matching ID '%s'"%(params.group(1),))
return
# Display the scan
message.reply(str(scan))
def tick(self, message, user, params):
tick = Updates.load(params.group(1)) or Updates.current_tick()
if tick is None:
message.reply("Ticks haven't started yet, go back to masturbating.")
elif isinstance(tick, Updates):
message.reply(str(tick))
else:
diff = int(params.group(1)) - tick
now = datetime.utcnow()
tick_length = PA.getint("numbers", "tick_length")
tdiff = timedelta(seconds=tick_length * diff) - timedelta(minutes=now.minute % (tick_length / 60))
seconds = 0
retstr = "%sd " % abs(tdiff.days) if tdiff.days else ""
retstr += "%sh " % abs(tdiff.seconds / 3600) if tdiff.seconds / 3600 else ""
retstr += "%sm " % abs(tdiff.seconds % 3600 / 60) if tdiff.seconds % 3600 / 60 else ""
if diff == 1:
retstr = "Next tick is %s (in %s" % (params.group(1), retstr)
elif diff > 1:
retstr = "Tick %s is expected to happen in %s ticks (in %s" % (params.group(1), diff, retstr)
elif diff <= 0:
retstr = "Tick %s was expected to happen %s ticks ago but was not scraped (%s ago" % (
params.group(1),
-diff,
retstr,
)
time = now + tdiff
retstr += " - %s)" % (time.strftime("%a %d/%m %H:%M"),)
message.reply(retstr)
def link(self):
return Config.get("URL", "reqscan") % (
PA.get(self.scantype, "type"),
self.target.x,
self.target.y,
self.target.z,
)
def new(self, message, user, params):
tick = Updates.current_tick()
comment = params.group(3) or ""
when = int(params.group(1))
if when < PA.getint("numbers", "protection"):
eta = when
when += tick
elif when <= tick:
message.alert(
"Can not create attacks in the past. You wanted tick %s, but current tick is %s." % (when, tick)
)
return
else:
eta = when - tick
if when > 32767:
when = 32767
attack = Attack(landtick=when, comment=comment)
session.add(attack)
for coord in re.findall(loadable.coord, params.group(2)):
if not coord[4]:
galaxy = Galaxy.load(coord[0], coord[2])
if galaxy:
attack.addGalaxy(galaxy)
else:
planet = Planet.load(coord[0], coord[2], coord[4])
if planet:
attack.addPlanet(planet)
session.commit()
message.reply(str(attack))
def execute(self, message, user, params):
roids=int(params.group(1))
ticks=int(params.group(2))
bonus=int(params.group(3) or 0)
mining = PA.getint("roids","mining")
mining = mining *(float(bonus+100)/100)
cost=self.num2short(ticks*roids*mining/100)
reply="In %s ticks (%s days) %s roids with %s%% bonus will mine %s value" % (ticks,ticks/24,roids,bonus,cost)
cost=self.num2short(ticks*roids*mining/100*(1/(1+PA.getfloat("feud","prodcost"))))
reply+=" Feudalism: %s value" % (cost)
message.reply(reply)
def robocop(self, message, scantype, pa_id, x, y, z, names):
nicks = []
reply = "%s on %s:%s:%s " % (PA.get(scantype,"name"),x,y,z,)
reply+= Config.get("URL","viewscan") % (pa_id,)
for name in names.split(","):
user = User.load(name)
for nick in CUT.get_user_nicks(name):
nicks.append(nick)
message.privmsg(self.url(reply, user), nick)
reply = "%s on %s:%s:%s " % (PA.get(scantype,"name"),x,y,z,)
reply+= "delivered to: "
reply+= ", ".join(nicks) if not Config.getboolean("Misc", "anonscans") else "Anon"
from Hooks.scans.request import request
message.privmsg(reply, request().scanchan())
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 bonus(self, message, user, params):
# Check if tick is provided
tick = int(params.group(1) or 0)
if tick > PA.getint("numbers", "last_tick"):
message.reply("Use your bonus during the round, not after.")
return
# If there is no tick provided in the command then check what the current tick is.
if not tick:
# Retrieve current tick
tick = Updates.current_tick()
if not tick:
# Game not ticking yet.
message.reply("Game is not ticking yet!")
return
resources = 10000 + tick * 4800
roids = int(6 + tick * 0.15)
research = 4000 + tick * 24
construction = 2000 + tick * 18
message.reply(
"Upgrade Bonus calculation for tick {} | Resources: {:,} EACH | Roids: {:,} EACH | Research Points: {:,} | Construction Units: {:,}".format(
tick, resources, roids, research, construction
)
)
def land(self, message, user, params):
id = int(params.group(1))
attack = Attack.load(id)
if attack is None:
message.alert("No attack exists with id %d" %(id))
return
tick = Updates.current_tick()
when = int(params.group(2))
if when == 0:
session.delete(attack)
session.commit()
message.reply("Deleted Attack %d LT: %d | %s" %(attack.id,attack.landtick,attack.comment,))
return
if when < PA.getint("numbers", "protection"):
eta = when
when += tick
elif when <= tick:
message.alert("Can not create attacks in the past. You wanted tick %s, but current tick is %s." % (when, tick,))
return
else:
eta = when - tick
if when > 32767:
when = 32767
old = attack.landtick
attack.landtick = when
session.commit()
message.reply("Changed LT for attack %d from %d to %d"%(id,old,when))
def execute(self, request, user, page="1", sort="score", race="all"):
page = int(page)
offset = (page - 1)*50
order = {"score" : (asc(Planet.score_rank),),
"value" : (asc(Planet.value_rank),),
"size" : (asc(Planet.size_rank),),
"xp" : (asc(Planet.xp_rank),),
"race" : (asc(Planet.race), asc(Planet.size_rank),),
}
if sort not in order.keys():
sort = "score"
order = order.get(sort)
tick = Updates.midnight_tick()
Q = session.query(Planet, PlanetHistory, Intel.nick, Alliance.name)
Q = Q.outerjoin(Planet.intel)
Q = Q.outerjoin(Intel.alliance)
Q = Q.outerjoin((PlanetHistory, and_(Planet.id == PlanetHistory.id, PlanetHistory.tick == tick)))
Q = Q.filter(Planet.active == True)
if race.lower() in PA.options("races"):
Q = Q.filter(Planet.race.ilike(race))
else:
race = "all"
count = Q.count()
pages = count/50 + int(count%50 > 0)
pages = range(1, 1+pages)
for o in order:
Q = Q.order_by(o)
Q = Q.limit(50).offset(offset)
return render("planets.tpl", request, planets=Q.all(), offset=offset, pages=pages, page=page, sort=sort, race=race)
def execute(self, message, user, params):
num, name, target = params.groups()
target = (target or "t1").lower()
ship = Ship.load(name=name)
num = self.short2num(num)
if ship is None:
message.alert("No Ship called: %s" % (name,))
return
efficiency = PA.getfloat("teffs",target.lower())
target_class = getattr(ship, target)
if ship.damage:
total_damage = ship.damage * num
if ship.t1 == "Roids":
killed = total_damage/50
message.reply("%s %s (%s) will capture Asteroid: %s (%s)" % (
num, ship.name, self.num2short(num*ship.total_cost/100),
killed, self.num2short(killed*PA.getint("numbers", "roid_value")),))
return
if ship.t1 == "Struct":
killed = total_damage/500
message.reply("%s %s (%s) will destroy Structure: %s (%s)" % (
num, ship.name, self.num2short(num*ship.total_cost/100),
killed, self.num2short(killed*PA.getint("numbers", "cons_value")),))
return
targets = session.query(Ship).filter(Ship.class_ == target_class)
if targets.count() == 0:
message.reply("%s does not have any targets in that category (%s)" % (ship.name,target))
return
reply="%s %s (%s) hitting %s will " % (num, ship.name,self.num2short(num*ship.total_cost/100),target_class)
if ship.type.lower() == "norm" or ship.type.lower() == 'cloak':
reply+="destroy "
elif ship.type.lower() == "emp":
reply+="hug "
elif ship.type.lower() == "steal":
reply+="steal "
else:
raise Exception("Erroneous type %s" % (ship.type,))
for target in targets:
if ship.type.lower() == "emp" :
killed=int(efficiency * ship.guns*num*float(100-target.empres)/100)
else:
killed=int(efficiency * total_damage/target.armor)
reply+="%s: %s (%s) " % (target.name,killed,self.num2short(target.total_cost*killed/100))
message.reply(reply)
def execute(self, message, user, params):
name, ticks, factories = params.group(1,2,3)
ship = Ship.load(name=name)
if ship is None:
message.alert("%s is not a ship." % name)
return
ticks = int(ticks)
factories = int(factories)
race = gov = None
pop = 0
for p in (params.group(4) or "").split():
m=self.racere.match(p)
if m and not race:
race=m.group(1).lower()
continue
m=self.govre.match(p)
if m and not gov:
gov=m.group(1).lower()
continue
if p.isdigit() and not pop:
pop = int(p)
continue
cost = ship.total_cost
bonus = 1 + pop/100.0
if gov:
cost *= (1+PA.getfloat(gov,"prodcost"))
bonus += PA.getfloat(gov,"prodtime")
if race:
bonus += PA.getfloat(race,"prodtime")
res = int(self.revprod(ticks, factories, bonus))
ships = int(res / cost)
reply = "You can build %s %s (%s) in %d ticks" % (self.num2short(ships), ship.name, self.num2short(ships*ship.total_cost/100), ticks)
reply += " using %s factories" % (factories,) if factories > 1 else ""
reply += " with a" if race or gov else ""
reply += " %s"%(PA.get(gov,"name"),) if gov else ""
reply += " %s"%(PA.get(race,"name"),) if race else ""
reply += " planet" if race or gov else ""
reply += " with %s%% population"%(pop,) if pop else ""
message.reply(reply)
def execute(self, message, user, params):
num, name, factories = params.group(1,2,3)
ship = Ship.load(name=name)
if ship is None:
message.alert("%s is not a ship." % name)
return
num = self.short2num(num)
factories = int(factories)
race = gov = None
pop = 0
for p in (params.group(4) or "").split():
m=self.racere.match(p)
if m and not race:
race=m.group(1).lower()
continue
m=self.govre.match(p)
if m and not gov:
gov=m.group(1).lower()
continue
if p.isdigit() and not pop:
pop = int(p)
continue
cost = ship.total_cost
bonus = 1 + pop/100.0
if gov:
cost *= (1+PA.getfloat(gov,"prodcost"))
bonus += PA.getfloat(gov,"prodtime")
if race:
bonus += PA.getfloat(race,"prodtime")
ticks = self.calc_ticks(cost, num, bonus, factories)
reply = "It will take %s ticks to build %s %s (%s)" % (ticks, self.num2short(num), ship.name, self.num2short(num*ship.total_cost/100))
reply += " with a" if race or gov else ""
reply += " %s"%(PA.get(gov,"name"),) if gov else ""
reply += " %s"%(PA.get(race,"name"),) if race else ""
reply += " planet" if race or gov else ""
reply += " with %s%% population"%(pop,) if pop else ""
message.reply(reply)
def execute(self, message, user, params):
alliance = Alliance(name="Unknown") if params.group(1).lower() == "unknown" else Alliance.load(params.group(1))
if alliance is None:
message.reply("No alliance matching '%s' found"%(params.group(1),))
return
tick = Updates.current_tick()
when = int(params.group(2) or 0)
if when and when < PA.getint("numbers", "protection"):
when += tick
elif when and when <= tick:
message.alert("Can not check status on the past. You wanted tick %s, but current tick is %s." % (when, tick,))
return
Q = session.query(Planet, User.name, Target.tick)
Q = Q.join(Target.planet)
Q = Q.join(Planet.intel) if alliance.id else Q.outerjoin(Planet.intel)
Q = Q.join(Target.user)
Q = Q.filter(Planet.active == True)
Q = Q.filter(Intel.alliance == (alliance if alliance.id else None))
Q = Q.filter(Target.tick == when) if when else Q.filter(Target.tick > tick)
Q = Q.order_by(asc(Planet.x))
Q = Q.order_by(asc(Planet.y))
Q = Q.order_by(asc(Planet.z))
result = Q.all()
if len(result) < 1:
reply="No active bookings matching alliance %s" %(alliance.name)
if when:
reply+=" for tick %s."%(when,)
message.reply(reply)
return
reply="Target information for %s"%(alliance.name)
reply+=" landing on tick %s (eta %s): "%(when,when-tick) if when else ": "
ticks={}
for planet, user, land in result:
if not ticks.has_key(land):
ticks[land]=[]
ticks[land].append((planet, user,))
sorted_keys=ticks.keys()
sorted_keys.sort()
replies = []
for land in sorted_keys:
prev=[]
for planet, user in ticks[land]:
prev.append("(%s:%s:%s %s)" % (planet.x,planet.y,planet.z,user))
replies.append("Tick %s (eta %s) "%(land,land-tick) +", ".join(prev))
replies[0] = reply + replies[0]
message.reply("\n".join(replies))
def execute(self, message, user, params):
roids=int(params.group(1))
ticks=int(params.group(2))
bonus=int(params.group(3) or 0)
mining = PA.getint("roids","mining")
mining = mining *(float(bonus+100)/100)
value = ticks*roids*mining/100
reply = "In %s ticks (%s days) %s roids with %s%% bonus will mine %s value" % (ticks,ticks/24,roids,bonus,self.num2short(value))
for gov in PA.options("govs"):
bonus = PA.getfloat(gov, "prodcost")
if bonus == 0:
continue
value_b = value/(1+bonus)
reply += " %s: %s value" % (PA.get(gov, "name"), self.num2short(value_b))
message.reply(reply)
def execute(self, message, user, params):
roids, cost, bonus = params.groups()
roids, cost, bonus = int(roids), self.short2num(cost), int(bonus or 0)
mining = PA.getint("roids","mining")
if roids == 0:
message.reply("Another NewDawn landing, eh?")
return
mining=mining * ((float(bonus)+100)/100)
repay=int((cost*100)/(roids*mining))
reply="Capping %s roids at %s value with %s%% bonus will repay in %s ticks (%s days)" % (roids,self.num2short(cost),bonus,repay,repay/24)
repay = int((cost*100)/(roids*mining*(1/(1+PA.getfloat("feud","prodcost")))))
reply+=" Feudalism: %s ticks (%s days)" % (repay,repay/24)
message.reply(reply)
def execute(self, message, user, params, override):
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) or 0)
if 0 < when < PA.getint("numbers", "protection"):
eta = when
when += tick
elif 0 < when <= tick:
message.alert("Can not unbook 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
Q = session.query(Target)
Q = Q.join(Target.user)
Q = Q.filter(Target.planet == planet)
Q = Q.filter(Target.user == user) if override is False else Q
Q = Q.filter(Target.tick == when) if when else Q.filter(Target.tick >= tick)
Q = Q.order_by(asc(Target.tick))
result = Q.all()
for target in result:
session.delete(target)
count = len(result)
session.commit()
if count < 1:
reply=("You have no " if override is False else "No ") +"bookings matching %s:%s:%s"%(planet.x,planet.y,planet.z,)
if when:
reply+=" for landing on tick %s"%(when,)
reply+=". If you are trying to unbook someone else's target, you must confirm with 'yes'." if override is False else ""
else:
reply="You have unbooked %s:%s:%s"%(planet.x,planet.y,planet.z,)
if when:
reply+=" for landing pt %s"%(when,)
if override:
reply+=" (previously held by user %s)"%(result[0].user.name)
else:
reply+=" for %d booking(s)"%(count,)
if override:
prev=[]
for target in result:
prev.append("(%s user:%s)" % (target.tick,target.user.name))
reply+=": "+", ".join(prev)
reply+="."
message.reply(reply)
return
def execute(self, message, user, params):
p = Planet.load(*params.group(1,3,5))
if p is None:
message.reply("No planet with coords %s:%s:%s found" % params.group(1,3,5))
return
ship = Ship.load(name=params.group(6))
if ship is None:
message.alert("No Ship called: %s" % (params.group(6),))
return
scan = p.scan("P")
if scan is None:
message.reply("No planet scans available on %s:%s:%s" % (p.x,p.y,p.z,))
return
planetscan = scan.planetscan
tick=scan.tick
res_m=planetscan.res_metal
res_c=planetscan.res_crystal
res_e=planetscan.res_eonium
prod_res=planetscan.prod_res
rand_id=scan.pa_id
cost_m=ship.metal
cost_c=ship.crystal
cost_e=ship.eonium
total_cost=ship.total_cost
class_factory_table = {'Fighter': 'factory_usage_light', 'Corvette': 'factory_usage_light', 'Frigate': 'factory_usage_medium',
'Destroyer': 'factory_usage_medium', 'Cruiser': 'factory_usage_heavy', 'Battleship': 'factory_usage_heavy'}
prod_modifier_table = {'None': 0.0, 'Low': 0.33, 'Medium': 0.66, 'High': 1.0}
capped_number = min(res_m/cost_m, res_c/cost_c, res_e/cost_e)
overflow = res_m+res_c+res_e-(capped_number*(cost_m+cost_c+cost_e))
buildable = capped_number + ((overflow*.95)/total_cost)
reply="Newest planet scan on %s:%s:%s (id: %s, pt: %s)" % (p.x,p.y,p.z,rand_id,tick)
reply+=" can purchase %s: %s"%(ship.name,int(buildable))
for gov in PA.options("govs"):
bonus = PA.getfloat(gov, "prodcost")
if bonus == 0:
continue
reply+=" | %s: %s"%(PA.get(gov, "name"),int(buildable/(1+bonus)))
factory_usage=getattr(planetscan,class_factory_table[ship.class_])
if prod_res > 0 and factory_usage != "None":
max_prod_modifier=prod_modifier_table[factory_usage]
buildable_from_prod = buildable + max_prod_modifier*prod_res/total_cost
reply+=" Counting %s res in prod at %s usage:" % (self.num2short(prod_res),factory_usage)
reply+=" %s"%(int(buildable_from_prod))
for gov in PA.options("govs"):
bonus = PA.getfloat(gov, "prodcost")
if bonus == 0:
continue
reply+=" | %s: %s"%(PA.get(gov, "name"),int(buildable_from_prod/(1+bonus)))
message.reply(reply)
def execute(self, message, user, params):
tag_count = PA.getint("numbers", "tag_count")
alliance = Alliance.load(params.group(1))
if alliance is None:
message.reply("No alliance matching '%s' found"%(params.group(1),))
return
Q = session.query(sum(Planet.value), sum(Planet.score),
sum(Planet.size), sum(Planet.xp),
count())
Q = Q.join(Planet.intel)
Q = Q.filter(Planet.active == True)
Q = Q.filter(Intel.alliance==alliance)
Q = Q.group_by(Intel.alliance_id)
result = Q.first()
if result is None:
message.reply("No planets in intel match alliance %s"%(alliance.name,))
return
value, score, size, xp, members = result
if members <= tag_count:
reply="%s Members: %s/%s, Value: %s, Avg: %s," % (alliance.name,members,alliance.members,value,value//members)
reply+=" Score: %s, Avg: %s," % (score,score//members)
reply+=" Size: %s, Avg: %s, XP: %s, Avg: %s" % (size,size//members,xp,xp//members)
message.reply(reply)
return
Q = session.query(Planet.value, Planet.score,
Planet.size, Planet.xp,
Intel.alliance_id)
Q = Q.join(Planet.intel)
Q = Q.filter(Planet.active == True)
Q = Q.filter(Intel.alliance==alliance)
Q = Q.order_by(desc(Planet.score))
Q = Q.limit(tag_count)
Q = Q.from_self(sum(Planet.value), sum(Planet.score),
sum(Planet.size), sum(Planet.xp),
count())
Q = Q.group_by(Intel.alliance_id)
ts_result = Q.first()
ts_value, ts_score, ts_size, ts_xp, ts_members = ts_result
reply="%s Members: %s/%s (%s)" % (alliance.name,members,alliance.members,ts_members)
reply+=", Value: %s (%s), Avg: %s (%s)" % (value,ts_value,value//members,ts_value//ts_members)
reply+=", Score: %s (%s), Avg: %s (%s)" % (score,ts_score,score//members,ts_score//ts_members)
reply+=", Size: %s (%s), Avg: %s (%s)" % (size,ts_size,size//members,ts_size//ts_members)
reply+=", XP: %s (%s), Avg: %s (%s)" % (xp,ts_xp,xp//members,ts_xp//ts_members)
message.reply(reply)
def execute(self, message, target, attacker):
reply="Target "
reply+="%s:%s:%s (%s|%s) "%(target.x,target.y,target.z,
self.num2short(target.value),self.num2short(target.score))
reply+="| Attacker %s:%s:%s (%s|%s) "%(attacker.x,attacker.y,attacker.z,
self.num2short(attacker.value),self.num2short(attacker.score))
reply+="| Bravery: %.2f " % (attacker.bravery(target),)
cap=target.maxcap(attacker)
xp=attacker.calc_xp(target)
reply+="| Roids: %s | XP: %s | Score: %s" % (cap,xp,xp*PA.getint("numbers", "xp_value"))
message.reply(reply)
def robocop(self, message, scantype, pa_id, x, y, z, names, scanner, reqs, old=False):
nicks = []
reply = "Old " if old else ""
reply += "%s on %s:%s:%s " % (PA.get(scantype,"name"),x,y,z,)
if ("showscanner" in Config.options("Misc") and Config.getboolean("Misc", "showscanner") and scanner != 'None'):
reply+= "from %s " % (User.load(id=scanner).name) if User.load(id=scanner) not in (None, 'None') else ""
reply += Config.get("URL","viewscan") % (pa_id,)
if old:
reply += " !request cancel %s if this is suitable." % (reqs)
for name in names.split(","):
user = User.load(name)
for nick in CUT.get_user_nicks(name):
nicks.append(nick)
message.privmsg(self.url(reply, user), nick)
if not old:
reply = "[-%s] %s on %s:%s:%s " % (reqs,PA.get(scantype,"name"),x,y,z,)
reply+= "delivered to: "
reply+= ", ".join(nicks) if not Config.getboolean("Misc", "anonscans") else "Anon"
if Config.getboolean("Misc", "showurls"):
reply += " (%s)" % (Config.get("URL","viewscan") % (pa_id,))
from Hooks.scans.request import request
message.privmsg(reply, request().scanchan())
def execute(self, message, user, params):
num, name, attacker = params.groups()
attacker = (attacker or "t1").lower()
num = self.short2num(num)
ship = Ship.load(name=name)
if ship is not None:
pass
elif "asteroids".rfind(name.lower()) > -1:
ship = Ship(name="Asteroids",class_="Roids",armor=50,total_cost=PA.getint("numbers", "roid_value")*100)
elif "constructions".rfind(name.lower()) > -1:
ship = Ship(name="Constructions",class_="Struct",armor=500,total_cost=PA.getint("numbers", "cons_value")*100)
else:
message.alert("No Ship called: %s" % (name,))
return
efficiency = PA.getfloat("teffs",attacker.lower())
attacker_class = getattr(Ship, attacker)
attackers = session.query(Ship).filter(attacker_class == ship.class_)
if attackers.count() == 0:
message.reply("%s are not hit by anything as that category (%s)" % (ship.name,attacker))
return
if ship.class_ == "Roids":
reply="Capturing"
elif ship.class_ == "Struct":
reply="Destroying"
else:
reply="Stopping"
reply+=" %s %s (%s) as %s requires " % (num, ship.name,self.num2short(num*ship.total_cost/100),attacker)
for attacker in attackers:
if attacker.type.lower() == "emp" :
needed=int((math.ceil(num/(float(100-ship.empres)/100)/attacker.guns))/efficiency)
else:
needed=int((math.ceil(float(ship.armor*num)/attacker.damage))/efficiency)
reply+="%s: %s (%s) " % (attacker.name,needed,self.num2short(attacker.total_cost*needed/100))
message.reply(reply)
def execute(self, request, user, params=""):
Q = session.query(Planet, Intel.nick, Alliance.name)
Q = Q.outerjoin(Planet.intel)
Q = Q.outerjoin(Intel.alliance)
Q = Q.join(Planet.galaxy)
Q = Q.filter(Planet.active == True)
query = False
page = 1
search = {
"ruler" : "", "planet" : "", "galaxy" : "", "nick" : "", "alliance" : "",
"ter" : 'checked="checked"', "cat" : 'checked="checked"', "xan" : 'checked="checked"', "zik" : 'checked="checked"', "etd" : 'checked="checked"',
"sizemin" : "", "sizemax" : "", "valuemin" : "", "valuemax" : "", "scoremin" : "", "scoremax" : "", "x" : "",
"galsizemin" : "", "galsizemax" : "", "galvaluemin" : "", "galvaluemax" : "", "galscoremin" : "", "galscoremax" : "", "planets" : "",
"bash" : "" if params else 'checked="checked"',
"rankmin" : "", "rankmax" : "", "galrankmin" : "", "galrankmax" : "",
"ratiomin" : "", "ratiomax" : "", "galratiomin" : "", "galratiomax" : "",
"order1" : "", "order1o" : "", "order2" : "", "order2o" : "",
}
intfilts = {
"score" : Planet.score,
"value" : Planet.value,
"size" : Planet.size,
"xp" : Planet.xp,
"galscore" : Galaxy.score,
"galreal_score" : Galaxy.real_score,
"galvalue" : Galaxy.value,
"galsize" : Galaxy.size,
"galxp" : Galaxy.xp,
"idle" : Planet.idle,
"x" : Planet.x,
"y" : Planet.y,
"planets" : Galaxy.members,
"totalroundroids" : Planet.totalroundroids,
"totallostroids" : Planet.totallostroids,
"ticksroiding" : Planet.ticksroiding,
"ticksroided" : Planet.ticksroided,
"tickroids" : Planet.tickroids,
}
floatfilts = {
"ratio" : Planet.ratio,
"galratio" : Galaxy.ratio,
"avroids" : Planet.avroids,
}
rankfilts = {
"rank" : Planet.score_rank,
"valuerank" : Planet.value_rank,
"sizerank" : Planet.size_rank,
"xprank" : Planet.xp_rank,
"galrank" : Galaxy.score_rank,
"galrealrank" : Galaxy.real_score_rank,
"galvaluerank" : Galaxy.value_rank,
"galsizerank" : Galaxy.size_rank,
"galxprank" : Galaxy.xp_rank,
}
filters = {}
filters.update(intfilts)
filters.update(floatfilts)
filters.update(rankfilts)
order = {
"xyz" : (Planet.x, Planet.y, Planet.z,),
"score_growth" : Planet.score_growth,
"value_growth" : Planet.value_growth,
"size_growth" : Planet.size_growth,
"xp_growth" : Planet.xp_growth,
"score_growth_pc" : Planet.score_growth_pc,
"value_growth_pc" : Planet.value_growth_pc,
"size_growth_pc" : Planet.size_growth_pc,
"xp_growth_pc" : Planet.xp_growth_pc,
"galscore_growth" : Galaxy.score_growth,
"galreal_score_growth" : Galaxy.real_score_growth,
"galvalue_growth" : Galaxy.value_growth,
"galsize_growth" : Galaxy.size_growth,
"galxp_growth" : Galaxy.xp_growth,
"galscore_growth_pc" : Galaxy.score_growth_pc,
"galreal_score_growth_pc" : Galaxy.real_score_growth_pc,
"galvalue_growth_pc" : Galaxy.value_growth_pc,
"galsize_growth_pc" : Galaxy.size_growth_pc,
"galxp_growth_pc" : Galaxy.xp_growth_pc,
}
order.update(filters)
orders = []
wordfilts = {
"ruler" : Planet.rulername,
"planet" : Planet.planetname,
"galaxy" : Galaxy.name,
}
if request.REQUEST.get("search"):
r = request.REQUEST
search = "/search/"
for word in wordfilts.keys() + ["nick", "alliance"]:
filt = (r.get(word) or "").strip()
if not filt:
continue
search += "%s:%s/" %(word,filt,)
for filt in filters.keys():
one = (r.get("min"+filt) or "").strip()
two = (r.get("max"+filt) or "").strip()
if not one and not two:
continue
if one and one == two:
search += "%s:%s/" %(filt,one,)
elif one and not two:
search += "%s:%s|/" %(filt,one,)
elif two and not one:
search += "%s:|%s/" %(filt,two,)
elif one and two:
search += "%s:%s|%s/" %(filt,one,two,)
races = []
for race in PA.options("races"):
if (r.get(race) or "").strip():
races.append(race)
if len(races) != len(PA.options("races")):
search += "race:%s/" %("|".join(races),)
if (r.get("bash") or "").strip():
search += "bash/"
o1 = (r.get("order1") or "").strip()
o1o = (r.get("order1o") or "").strip()
o2 = (r.get("order2") or "").strip()
o2o = (r.get("order2o") or "").strip()
if o1 not in order:
o1, o1o = o2, o2o
if o1 in order and (o1 == o2 or o2 not in order):
if o1 == "score" and o1o == "desc":
pass
else:
o1o = "^" if o1o == "asc" else "_"
search += "order:%s%s/" %(o1o,o1,)
elif o1 in order and o2 in order:
o1o = "^" if o1o == "asc" else "_"
o2o = "^" if o2o == "asc" else "_"
search += "order:%s%s|%s%s/" %(o1o,o1,o2o,o2,)
return HttpResponseRedirect(search)
for param in params.lower().split("/"):
if param == "bash" and user.planet is not None:
Q = Q.filter(or_(Planet.value.op(">")(user.planet.value*PA.getfloat("bash","value")),
Planet.score.op(">")(user.planet.score*PA.getfloat("bash","score"))))
Q = Q.filter(Planet.x < 200)
search[param] = 'checked="checked"'
continue
arg, sep, val = param.partition(":")
if not (arg and val):
continue
if arg in filters:
one, two = "", ""
if "|" not in val:
one, two = val, val
elif val[-1] == "|":
one, two = val[:-1], ""
elif val[0] == "|":
one, two = "", val[1:]
elif "|" in val:
one, two = val.split("|",1)
else:
continue
try:
if one:
one = float(one) if arg in floatfilts else int(one)
if two:
two = float(two) if arg in floatfilts else int(two)
except ValueError:
continue
if one and one == two:
Q = Q.filter(filters[arg] == one)
elif one and not two:
Q = Q.filter(filters[arg] <= one) if arg in rankfilts else Q.filter(filters[arg] >= one)
elif two and not one:
Q = Q.filter(filters[arg] >= two) if arg in rankfilts else Q.filter(filters[arg] <= two)
elif one and two:
Q = Q.filter(filters[arg].between(min(one,two), max(one,two)))
else:
continue
search[arg+"min"], search[arg+"max"] = one, two
query = True
elif arg in wordfilts:
Q = Q.filter(wordfilts[arg].ilike("%"+val+"%"))
search[arg] = val
query = True
elif arg == "nick" and getattr(user, "is_" + Config.get("Arthur", "intel"))():
Q = Q.filter(Intel.nick.ilike("%"+val+"%"))
search["nick"] = val
query = True
elif arg == "alliance" and getattr(user, "is_" + Config.get("Arthur", "intel"))():
if val[0] == "!":
val = val[1:]
inv = True
else:
inv = False
alliance = Alliance.load(val)
if alliance:
Q = Q.filter(Intel.alliance == alliance) if not inv else Q.filter(Intel.alliance != alliance)
search["alliance"] = ["","!"][inv] + alliance.name
query = True
elif arg == "race":
races = []
for race in val.split("|"):
if race in PA.options("races") and race not in races:
races.append(Planet.race.ilike(race))
search[race] = True
if len(races):
Q = Q.filter(or_(*races))
for race in PA.options("races"):
search[race] = 'checked="checked"' if search[race] is True else ""
query = True
elif arg == "order":
for sort in val.split("|"):
if sort[0] == "^":
f = asc
elif sort[0] == "_":
f = desc
else:
continue
if sort[1:] in order:
orders.append((f, sort[1:],))
query = True
elif arg == "page" and val.isdigit():
page = int(val)
if len(orders) < 1:
orders.append((desc, "score",))
if len(orders) < 2:
orders.append((desc, "score",))
search["order1"] = orders[0][1]
search["order1o"] = orders[0][0].__name__
search["order2"] = orders[1][1]
search["order2o"] = orders[1][0].__name__
for d, os in orders:
if type(order[os]) is tuple:
for o in order[os]:
Q = Q.order_by(d(o))
else:
Q = Q.order_by(d(order[os]))
showsort = True if search["order1"] not in ("xyz","size","value","score","ratio","xp",
"size_growth","value_growth","score_growth",
"size_growth_pc","value_growth_pc","score_growth_pc",) else False
count = Q.count()
pages = count/50 + int(count%50 > 0)
pages = range(1, 1+pages)
offset = (page - 1)*50
Q = Q.limit(50).offset(offset)
results = Q.all() if query else None
return render("search.tpl", request, planets=results, sort=search["order1"],
showsort=showsort, s=search, params=params,
offset=offset, pages=pages, page=page)
def execute(self, message, user, params):
num, name, target = params.groups()
target = (target or "t1").lower()
ship = Ship.load(name=name)
num = self.short2num(num)
if ship is None:
message.alert("No Ship called: %s" % (name, ))
return
efficiency = PA.getfloat("teffs", target.lower())
target_class = getattr(ship, target)
if ship.damage:
total_damage = ship.damage * num
if ship.t1 == "Roids":
killed = total_damage / 50
message.reply("%s %s (%s) will capture Asteroid: %s (%s)" % (
num,
ship.name,
self.num2short(num * ship.total_cost /
PA.getint("numbers", "ship_value")),
killed,
self.num2short(killed * PA.getint("numbers", "roid_value")),
))
return
if ship.t1 == "Struct":
killed = total_damage / 500
message.reply("%s %s (%s) will destroy Structure: %s (%s)" % (
num,
ship.name,
self.num2short(num * ship.total_cost /
PA.getint("numbers", "ship_value")),
killed,
self.num2short(killed * PA.getint("numbers", "cons_value")),
))
return
targets = session.query(Ship).filter(Ship.class_ == target_class)
if targets.count() == 0:
message.reply(
"%s does not have any targets in that category (%s)" %
(ship.name, target))
return
reply = "%s %s (%s) hitting %s will " % (
num, ship.name,
self.num2short(num * ship.total_cost /
PA.getint("numbers", "ship_value")), target_class)
if ship.type.lower() == "norm" or ship.type.lower() == 'cloak':
reply += "destroy "
elif ship.type.lower() == "emp":
reply += "hug "
elif ship.type.lower() == "steal":
reply += "steal "
else:
raise Exception("Erroneous type %s" % (ship.type, ))
for target in targets:
if ship.type.lower() == "emp":
if ship.init < target.init:
killed = int(efficiency * ship.guns * num *
float(100 - target.empres) / 100)
else:
target_num = 0
while 1:
target_num += 1
killed = int(efficiency * target.guns * target_num *
float(100 - ship.empres) / 100)
if killed >= num:
break
killed = target_num
else:
if ship.init < target.init:
killed = int(efficiency * total_damage / target.armor)
else:
target_num = 0
while 1:
target_num += 1
killed = int(efficiency * target.damage * target_num /
ship.armor)
if killed >= num:
break
killed = target_num
reply += "%s: %s (%s) " % (target.name, killed,
self.num2short(
target.total_cost * killed /
PA.getint("numbers", "ship_value")))
message.reply(reply)
