def execute(self, username, args, admin):
if not self.authorise(admin):
return self.not_auth_message
if len(args) < 2:
return "Missing argument (username)"
self.server.write_all_players()
requested_username = "******".join(args[1:])
player = self.server.get_player(requested_username)
if player:
now = datetime.datetime.now()
elapsed_time = now - player.session_start
session_time = elapsed_time.total_seconds()
else:
session_time = 0
player = Player(requested_username, "no-perk")
self.server.database.load_player(player)
time = seconds_to_hhmmss(player.total_time + session_time)
message = "Stats for {}:\n".format(player.username) +\
"Total play time: {} ({} sessions)\n"\
.format(time, player.total_logins) +\
"Total deaths: {}\n".format(player.total_deaths) +\
"Total kills: {}\n".format(millify(player.total_kills)) +\
"Total dosh earned: {}\n"\
.format(millify(player.total_dosh)) +\
"Dosh this game: {}".format(millify(player.game_dosh))
return message
def render_motd(self, src_motd):
# Wouldn't this be better to do with something like fuzzy?
if self.scoreboard_type in ['kills', 'Kills', 'kill', 'Kill']:
scores = self.server.database.top_kills()
elif self.scoreboard_type in ['Dosh','dosh']:
scores = self.server.database.top_dosh()
else:
logger.error("Bad configuration, scoreboard_type. "
"Options are: dosh, kills ({})"
.format(self.server.name))
return
for player in scores:
name = player[0].replace("<", "<")
name = trim_string(name, 12)
score = player[1]
src_motd = src_motd.replace("%PLR", name, 1)
src_motd = src_motd.replace("%SCR", millify(score), 1)
if "%SRV_K" in src_motd:
server_kills = self.server.database.server_kills()
src_motd = src_motd.replace("%SRV_K", millify(server_kills), 1)
if "%SRV_D" in src_motd:
server_dosh = self.server.database.server_dosh()
src_motd = src_motd.replace("%SRV_D", millify(server_dosh), 1)
return src_motd
def execute(self, username, args, admin):
if not self.authorise(admin):
return self.not_auth_message
self.server.write_all_players()
kills = self.server.database.server_kills()
return millify(kills) + " ZEDs have been killed on this server"
def execute(self, username, args, admin):
if not self.authorise(admin):
return self.not_auth_message
self.server.write_all_players()
dosh = self.server.database.server_dosh()
return millify(dosh) + " Dosh has been earned on this server"
def execute(self, username, args, admin):
if not self.authorise(admin):
return self.not_auth_message
if args[0] == "new_game":
logger.debug("Greeter received new game event")
self.new_game_time = datetime.datetime.now()
return None
now = datetime.datetime.now()
elapsed_time = now - self.new_game_time
seconds = elapsed_time.total_seconds()
if seconds < self.new_game_grace:
logger.debug("Skipping welcome {}, new_game happened recently ({})"
" [{}/{}]".format(username, self.server.name, seconds,
self.new_game_grace))
return None
if len(args) < 2:
return "Missing argument (username)"
requested_username = "******".join(args[1:])
player = self.server.get_player(requested_username)
if not player:
logger.debug(
"DEBUG: Bad player join command (not found) [{}]".format(
requested_username))
return "Couldn't greet player {}.".format(requested_username)
if player.total_logins > 1:
pos_kills = self.server.database.rank_kills(requested_username)
pos_dosh = self.server.database.rank_dosh(requested_username)
return "\nWelcome back {}.\n" \
"You've killed {} zeds (#{}) and \n" \
"earned £{} (#{}) \nover {} sessions " \
"({}).".format(player.username,
millify(player.total_kills),
pos_kills,
millify(player.total_dosh),
pos_dosh,
player.total_logins,
seconds_to_hhmmss(player.total_time))\
.encode("iso-8859-1", "ignore")
else:
return None
def execute(self, username, args, user_flags):
args, err = self.parse_args(username, args, user_flags)
if err:
return err
elif args.help:
return self.format_response(self.help_text, args)
self.server.write_all_players()
if args.username:
username = "******".join(args.username)
print(username)
player = self.server.get_player_by_username(username)
if player:
# TODO: Move this ...
now = time.time()
elapsed_time = now - player.session_start
else:
elapsed_time = 0
player = Player(username, "no-perk")
self.server.database.load_player(player)
# ... And this
fmt_time = seconds_to_hhmmss(player.total_time + elapsed_time)
pos_kills = self.server.database.rank_kills(player.steam_id) or 0
pos_dosh = self.server.database.rank_dosh(player.steam_id) or 0
# todo Add pos_time to output
# pos_time = self.server.database.rank_time(player.steam_id) or 0
message = "Stats for {}:\n" \
"Total play time: {} ({} sessions)\n" \
"Total deaths: {}\n" \
"Total kills: {} (rank #{}) \n" \
"Total dosh earned: £{} (rank #{})\n" \
"Dosh this game: {}".format(
player.username, fmt_time, player.sessions,
player.total_deaths, millify(player.total_kills), pos_kills,
millify(player.total_dosh), pos_dosh, millify(player.game_dosh)
)
return self.format_response(message, args)
def execute(self, username, args, user_flags):
args, err = self.parse_args(username, args, user_flags)
if err:
return err
if args.help:
return self.format_response(self.help_text, args)
kills = self.server.database.server_kills()
return self.format_response(
_("{} ZEDs have been killed on this server").format(
millify(kills)), args)
def execute(self, username, args, user_flags):
args, err = self.parse_args(username, args, user_flags)
if err:
return err
if args.help:
return self.format_response(self.help_text, args)
dosh = self.server.database.server_dosh()
return self.format_response(
_("£{} has been earned on this server").format(millify(dosh)),
args)
def execute(self, username, args, admin):
if not self.authorise(admin):
return self.not_auth_message
if len(args) > 1 and args[1] == '-w' and len(self.server.players) > 0:
self.server.players.sort(key=lambda player: player.wave_kills,
reverse=True)
top_killer = self.server.players[0]
return "Player {} killed the most zeds this wave: {} zeds"\
.format(top_killer.username, top_killer.wave_kills)
self.server.write_all_players()
killers = self.server.database.top_kills()
if len(killers) < 5:
return "Not enough data."
# [row][col]
return "\n\nTop 5 players by total kills:\n" + \
"\t"+str(millify(killers[0][1])) + "\t-\t" + trim_string(killers[0][0],20) + "\n" + \
"\t"+str(millify(killers[1][1])) + "\t-\t" + trim_string(killers[1][0],20) + "\n" + \
"\t"+str(millify(killers[2][1])) + "\t-\t" + trim_string(killers[2][0],20) + "\n" + \
"\t"+str(millify(killers[3][1])) + "\t-\t" + trim_string(killers[3][0],20) + "\n" + \
"\t"+str(millify(killers[4][1])) + "\t-\t" + trim_string(killers[4][0],20)
def execute(self, username, args, user_flags):
args, err = self.parse_args(username, args, user_flags)
if err:
return err
if args.help:
return self.format_response(self.help_text, args)
if not self.server.players:
return None
self.server.players.sort(key=lambda player: player.wave_dosh,
reverse=True)
top = self.server.players[0]
return self.format_response(
_("Player {} earned the most Dosh this wave: £{}").format(
top.username, millify(top.wave_dosh)), args)
def execute(self, username, args, user_flags):
args, err = self.parse_args(username, args, user_flags)
if err:
return err
if args.help:
return self.format_response(self.help_text, args)
if not self.server.players:
return self.format_response(_("No players in game"), args)
self.server.players.sort(key=lambda player: player.wave_kills,
reverse=True)
top = self.server.players[0]
return self.format_response(
_("Player {} killed the most ZEDs this wave: {}").format(
top.username, millify(top.wave_kills)), args)
def execute(self, username, args, user_flags):
args, err = self.parse_args(username, args, user_flags)
if err:
return err
if args.help:
return self.format_response(self.help_text, args)
records = self.server.database.top_dosh()
message = _("Top 5 players by Dosh earned:\n")
for player in records[:5]:
username = trim_string(player['username'], 20)
dosh = millify(player['score'])
message += "\t£{}\t- {}\n".format(dosh, username)
return self.format_response(message[:-1], args)
def execute(self, username, args, user_flags):
args, err = self.parse_args(username, args, user_flags)
if err:
return err
if args.help:
return self.format_response(self.help_text, args)
message = _("Scoreboard (name, kills, dosh):\n")
self.server.players.sort(key=lambda player: player.kills, reverse=True)
for player in self.server.players:
username = trim_string(player.username, 20)
dosh = millify(player.dosh)
kills = player.kills
message += _("{}\t- {} Kills, £{}\n").format(username, kills, dosh)
return self.format_response(message[:-1], args)
def test_millify():
tests = [
{
"num": "1000",
"expected": "1K"
},
{
"num": 1000,
"expected": "1K"
},
{
"num": 1200,
"expected": "1K"
},
{
"num": 1000000,
"expected": "1M"
},
{
"num": 1000000000,
"expected": "1B"
},
{
"num": 1000000000000,
"expected": "1T"
},
# TODO: This rounding is undesirable
{
"num": 1600000000000,
"expected": "2T"
},
{
"num": 0,
"expected": "0"
},
{
"num": "0",
"expected": "0"
},
]
for test in tests:
result = millify(test["num"])
assert result == test["expected"]
def execute(self, username, args, admin):
if not self.authorise(admin):
return self.not_auth_message
if len(args) > 1 and args[1] == '-w' and len(self.server.players) > 0:
self.server.players.sort(key=lambda player: player.wave_dosh,
reverse=True)
top_dosh = self.server.players[0]
return "Player {} earned the most this wave: £{}"\
.format(top_dosh.username, millify(top_dosh.wave_dosh))\
.encode("iso-8859-1", "ignore")
self.server.write_all_players()
doshers = self.server.database.top_dosh()
if len(doshers) < 5:
return "Not enough data."
message = "\n\nTop 5 players by earnings:\n" + \
"\t£"+str(millify(doshers[0][1])) + "\t-\t" + trim_string(doshers[0][0],20) + "\n" + \
"\t£"+str(millify(doshers[1][1])) + "\t-\t" + trim_string(doshers[1][0],20) + "\n" + \
"\t£"+str(millify(doshers[2][1])) + "\t-\t" + trim_string(doshers[2][0],20) + "\n" + \
"\t£"+str(millify(doshers[3][1])) + "\t-\t" + trim_string(doshers[3][0],20) + "\n" + \
"\t£"+str(millify(doshers[4][1])) + "\t-\t" + trim_string(doshers[4][0],20)
return message.encode("iso-8859-1", "ignore")