def create_team(self):
""" Create a new team """
if not self.config.teams:
team = Team.by_name(self.get_argument("handle", ""))
if team is None:
team = Team()
team.name = self.get_argument("handle", "")
else:
logging.info(
"Team %s already exists - Player Mode: reset team." % team.name
)
team.flags = []
team.hints = []
team.boxes = []
team.items = []
team.game_levels = []
team.purchased_source_code = []
team.motto = self.get_argument("motto", "")
team._avatar = identicon(team.name, 6)
if self.config.banking:
team.money = self.config.starting_team_money
else:
team.money = 0
levels = GameLevel.all()
for level in levels:
if level.type == "none":
team.game_levels.append(level)
elif level.type != "hidden" and level.buyout == 0:
team.game_levels.append(level)
return team
elif self.config.public_teams:
if Team.by_name(self.get_argument("team_name", "")) is not None:
raise ValidationError(
"This team name is already registered. Use team code to join that team."
)
team = Team()
team.name = self.get_argument("team_name", "")
team.motto = self.get_argument("motto", "")
if len(filter_avatars("team")) == 0:
team._avatar = identicon(team.name, 6)
if not self.config.banking:
team.money = 0
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
return team
else:
raise ValidationError("Public teams are not enabled")
def edit_game_level(self):
''' Update game level objects '''
try:
level = GameLevel.by_uuid(self.get_argument('uuid', ''))
if level is None:
raise ValidationError("Game level does not exist")
if int(self.get_argument('number', level.number)) != level.number:
level.number = self.get_argument('number')
level.buyout = self.get_argument('buyout', '1')
self.dbsession.add(level)
self.dbsession.flush()
# Fix the linked-list
game_levels = sorted(GameLevel.all())
for index, game_level in enumerate(game_levels[:-1]):
game_level.next_level_id = game_levels[index + 1].id
self.dbsession.add(game_level)
if game_levels[0].number != 0:
game_levels[0].number = 0
self.dbsession.add(game_levels[0])
game_levels[-1].next_level_id = None
self.dbsession.add(game_levels[-1])
self.dbsession.add(level)
self.dbsession.commit()
self.redirect('/admin/view/game_levels')
except ValueError:
raise ValidationError("That was not a number ...")
except ValidationError as error:
self.render("admin/view/game_levels.html", errors=[
str(error),
])
def flag_captured(self, player, flag):
""" Callback for when a flag is captured """
if isinstance(player, User):
team = player.team
else:
team = player
if isinstance(player, User) and options.teams:
message = '%s (%s) has completed "%s" in %s' % (
player.handle,
team.name,
flag.name,
flag.box.name,
)
else:
message = '%s has completed "%s" in %s' % (
team.name,
flag.name,
flag.box.name,
)
if len(GameLevel.all()) > 1:
message = message + " (%s)" % (
GameLevel.by_id(flag.box.game_level_id).name,
)
Notification.create_broadcast(team, "Flag Capture", message, SUCCESS)
self.io_loop.add_callback(self.push_broadcast)
self.io_loop.add_callback(self.push_scoreboard)
def create_game_level(self):
'''
Creates a new level in the database, the levels are basically a
linked-list where each level points to the next, and the last points to
None. This function creates a new level and sorts everything based on
the 'number' attrib
'''
try:
new_level = GameLevel()
new_level.number = self.get_argument('level_number', '')
new_level.buyout = self.get_argument('buyout', 0)
new_level.name = self.get_argument('name', None)
new_level._type = self.get_argument('type', 'buyout')
new_level._reward = self.get_argument('reward', 0)
if new_level._type == "progress":
new_level.buyout = min(new_level.buyout, 100)
elif new_level._type == "none":
new_level.buyout = 0
if new_level._type != "none" and new_level.buyout == 0:
new_level._type = "none"
self.dbsession.add(new_level)
self.dbsession.flush()
game_levels = sorted(GameLevel.all())
for index, level in enumerate(game_levels[:-1]):
level.next_level_id = game_levels[index + 1].id
self.dbsession.add(level)
if game_levels[0].number != 0:
game_levels[0].number = 0
self.dbsession.add(game_levels[0])
game_levels[-1].next_level_id = None
self.dbsession.add(game_levels[-1])
self.dbsession.commit()
self.redirect('/admin/view/game_levels')
except ValidationError as error:
self.render('admin/create/game_level.html', errors=[str(error), ])
def edit_game_level(self):
''' Update game level objects '''
errors = []
level = GameLevel.by_uuid(self.get_argument('uuid'))
try:
new_number = int(self.get_argument('number', ''))
new_buyout = int(self.get_argument('buyout', ''))
if level.number != new_number and GameLevel.by_number(new_number) is None:
level.number = new_number
self.dbsession.add(level)
# Fix the linked-list
game_levels = sorted(GameLevel.all())
index = 0
for game_level in game_levels[:-1]:
game_level.next_level_id = game_levels[index + 1].id
self.dbsession.add(game_level)
index += 1
game_levels[0].number = 0
self.dbsession.add(game_levels[0])
game_levels[-1].next_level_id = None
self.dbsession.add(game_levels[-1])
if GameLevel.by_number(new_number) is not None:
errors.append("GameLevel number is not unique")
if level.buyout != new_buyout:
level.buyout = new_buyout
self.dbsession.add(level)
self.dbsession.commit()
except ValueError:
errors.append("That was not a number ...")
self.render("admin/view/game_levels.html", errors=errors)
def edit_game_level(self):
''' Update game level objects '''
try:
level = GameLevel.by_uuid(self.get_argument('uuid', ''))
if level is None:
raise ValidationError("Game level does not exist")
if int(self.get_argument('number', level.number)) != level.number:
level.number = self.get_argument('number')
level.buyout = self.get_argument('buyout', '1')
self.dbsession.add(level)
self.dbsession.flush()
# Fix the linked-list
game_levels = sorted(GameLevel.all())
for index, game_level in enumerate(game_levels[:-1]):
game_level.next_level_id = game_levels[index + 1].id
self.dbsession.add(game_level)
if game_levels[0].number != 0:
game_levels[0].number = 0
self.dbsession.add(game_levels[0])
game_levels[-1].next_level_id = None
self.dbsession.add(game_levels[-1])
self.dbsession.add(level)
self.dbsession.commit()
self.redirect('/admin/view/game_levels')
except ValueError:
raise ValidationError("That was not a number ...")
except ValidationError as error:
self.render("admin/view/game_levels.html", errors=[str(error), ])
def create_team(self):
''' Admins can create teams manually '''
try:
name = self.get_argument('team_name', '')
if Team.by_name(name) is not None:
raise ValidationError("Team already exists")
team = Team()
team.name = self.get_argument('team_name', '')
team.motto = self.get_argument('motto', '')
if not self.config.banking:
team.money = 0
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
self.dbsession.add(team)
self.dbsession.commit()
# Avatar
avatar_select = self.get_argument('team_avatar_select', '')
if avatar_select and len(avatar_select) > 0:
team._avatar = avatar_select
elif hasattr(self.request,
'files') and 'avatar' in self.request.files:
team.avatar = self.request.files['avatar'][0]['body']
self.dbsession.add(team)
self.dbsession.commit()
self.redirect('/admin/users')
except ValidationError as error:
self.render("admin/create/team.html", errors=[
str(error),
])
def create_game_level(self):
"""
Creates a new level in the database, the levels are basically a
linked-list where each level points to the next, and the last points to
None. This function creates a new level and sorts everything based on
the 'number' attrib
"""
try:
new_level = GameLevel()
new_level.number = self.get_argument("level_number", "")
new_level.buyout = self.get_argument("buyout", 0)
new_level.name = self.get_argument("name", None)
new_level._type = self.get_argument("type", "buyout")
new_level._reward = self.get_argument("reward", 0)
if new_level._type == "progress":
new_level.buyout = min(new_level.buyout, 100)
elif new_level._type == "none":
new_level.buyout = 0
if new_level._type != "none" and new_level.buyout == 0:
new_level._type = "none"
self.dbsession.add(new_level)
self.dbsession.flush()
game_levels = sorted(GameLevel.all())
for index, level in enumerate(game_levels[:-1]):
level.next_level_id = game_levels[index + 1].id
self.dbsession.add(level)
if game_levels[0].number != 0:
game_levels[0].number = 0
self.dbsession.add(game_levels[0])
game_levels[-1].next_level_id = None
self.dbsession.add(game_levels[-1])
self.dbsession.commit()
self.redirect("/admin/view/game_levels")
except ValidationError as error:
self.render("admin/create/game_level.html", errors=[str(error)])
def create_team(self):
""" Admins can create teams manually """
try:
name = self.get_argument("team_name", "")
if Team.by_name(name) is not None:
raise ValidationError("Team already exists")
team = Team()
team.name = self.get_argument("team_name", "")
team.motto = self.get_argument("motto", "")
if not self.config.banking:
team.money = 0
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
self.dbsession.add(team)
self.dbsession.commit()
# Avatar
avatar_select = self.get_argument("team_avatar_select", "")
if avatar_select and len(avatar_select) > 0:
team._avatar = avatar_select
elif hasattr(self.request,
"files") and "avatar" in self.request.files:
team.avatar = self.request.files["avatar"][0]["body"]
self.dbsession.add(team)
self.dbsession.commit()
self.event_manager.push_score_update()
self.redirect("/admin/users")
except ValidationError as error:
self.render("admin/create/team.html", errors=[str(error)])
def create_game_level(self):
'''
Creates a new level in the database, the levels are basically a
linked-list where each level points to the next, and the last points to
None. This function creates a new level and sorts everything based on
the 'number' attrib
'''
try:
new_level = GameLevel()
new_level.number = self.get_argument('level_number', '')
new_level.buyout = self.get_argument('buyout', '')
self.dbsession.add(new_level)
self.dbsession.flush()
game_levels = sorted(GameLevel.all())
for index, level in enumerate(game_levels[:-1]):
level.next_level_id = game_levels[index + 1].id
self.dbsession.add(level)
if game_levels[0].number != 0:
game_levels[0].number = 0
self.dbsession.add(game_levels[0])
game_levels[-1].next_level_id = None
self.dbsession.add(game_levels[-1])
self.dbsession.commit()
self.redirect('/admin/view/game_levels')
except ValidationError as error:
self.render('admin/create/game_level.html', errors=[
str(error),
])
def create_team(self):
''' Admins can create teams manually '''
try:
name = self.get_argument('team_name', '')
if Team.by_name(name) is not None:
raise ValidationError("Team already exists")
team = Team()
team.name = self.get_argument('team_name', '')
team.motto = self.get_argument('motto', '')
if not self.config.banking:
team.money = 0
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
self.dbsession.add(team)
self.dbsession.commit()
# Avatar
avatar_select = self.get_argument('team_avatar_select', '')
if avatar_select and len(avatar_select) > 0:
team._avatar = avatar_select
elif hasattr(self.request, 'files') and 'avatar' in self.request.files:
team.avatar = self.request.files['avatar'][0]['body']
self.dbsession.add(team)
self.dbsession.commit()
self.redirect('/admin/users')
except ValidationError as error:
self.render("admin/create/team.html", errors=[str(error), ])
def post(self, *args, **kwargs):
'''
Reset the Game
'''
errors = []
success = None
try:
users = User.all()
for user in users:
user.money = 0
teams = Team.all()
for team in teams:
if options.banking:
team.money = options.starting_team_money
else:
team.money = 0
team.flags = []
team.hints = []
team.boxes = []
team.items = []
team.purchased_source_code = []
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels = [level_0]
self.dbsession.add(team)
self.dbsession.commit()
self.dbsession.flush()
for team in teams:
for paste in team.pastes:
self.dbsession.delete(paste)
for shared_file in team.files:
shared_file.delete_data()
self.dbsession.delete(shared_file)
self.dbsession.commit()
self.dbsession.flush()
Penalty.clear()
Notification.clear()
snapshot = Snapshot.all()
for snap in snapshot:
self.dbsession.delete(snap)
self.dbsession.commit()
snapshot_team = SnapshotTeam.all()
for snap in snapshot_team:
self.dbsession.delete(snap)
self.dbsession.commit()
game_history = GameHistory.instance()
game_history.take_snapshot() # Take starting snapshot
flags = Flag.all()
for flag in flags:
flag.value = flag._original_value if flag._original_value else flag.value
self.dbsession.add(flag)
self.dbsession.commit()
self.dbsession.flush()
success = "Successfully Reset Game"
self.render('admin/reset.html', success=success, errors=errors)
except BaseException as e:
errors.append("Failed to Reset Game")
logging.error(str(e))
self.render('admin/reset.html', success=None, errors=errors)
def create_team(self):
''' Create a new team '''
if not self.config.teams:
team = Team.by_name(self.get_argument('handle', ''))
if team is None:
team = Team()
team.name = self.get_argument('handle', '')
else:
logging.info(
"Team %s already exists - Player Mode: reset team." %
team.name)
team.flags = []
team.hints = []
team.boxes = []
team.items = []
team.game_levels = []
team.purchased_source_code = []
team.motto = self.get_argument('motto', '')
if self.config.banking:
team.money = self.config.starting_team_money
else:
team.money = 0
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
return team
elif self.config.public_teams:
if Team.by_name(self.get_argument('team_name', '')) is not None:
raise ValidationError(
"This team name is already registered. Use team code to join that team."
)
team = Team()
team.name = self.get_argument('team_name', '')
team.motto = self.get_argument('motto', '')
if not self.config.banking:
team.money = 0
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
return team
else:
raise ValidationError("Public teams are not enabled")
def create_team(self):
''' Create a new team in the database '''
team = Team()
team.name = self.get_argument('team_name', '')
team.motto = self.get_argument('motto', '')
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
self.dbsession.add(team)
self.dbsession.commit()
self.redirect('/admin/view/user_objects')
def create_team(self):
''' Create a new team '''
if self.config.public_teams:
team = Team()
team.name = self.get_argument('team_name', '')
team.motto = self.get_argument('motto', '')
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
return team
else:
raise ValidationError("Public teams are not enabled")
def create_team(self):
''' Create a new team '''
if self.config.public_teams:
team = Team()
team.name = self.get_argument('team_name', '')
team.motto = self.get_argument('motto', '')
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
return team
else:
raise ValidationError("Public teams are not enabled")
def create_box(corp=None):
if corp is None:
corp = create_corp()
game_level = GameLevel.all()[0]
box = Box(corporation_id=corp.id, game_level_id=game_level.id)
box.name = "TestBox"
box.description = "Some description"
box.difficuly = "Easy"
corp.boxes.append(box)
dbsession.add(box)
dbsession.commit()
return box, corp
def flag_penalty(self, user, flag):
''' Callback for when a flag is captured '''
if len(GameLevel.all()) > 1:
message = "%s was penalized on the '%s' flag in %s (Lvl %s)" % (
user.team.name, flag.name, flag.box.name,
GameLevel.by_id(flag.box.game_level_id).number)
else:
message = "%s was penalized on the '%s' flag in %s" % (
user.team.name, flag.name, flag.box.name)
Notification.create_team(user.team, "Flag Penalty", message, WARNING)
self.io_loop.add_callback(self.push_team, user.team.id)
self.io_loop.add_callback(self.push_scoreboard)
def create_box(corp=None):
if corp is None:
corp = create_corp()
game_level = GameLevel.all()[0]
box = Box(corporation_id=corp.id, game_level_id=game_level.id)
box.name = "TestBox"
box.description = "Some description"
box.difficuly = "Easy"
corp.boxes.append(box)
dbsession.add(box)
dbsession.commit()
return box, corp
def hint_taken(self, user, hint):
''' Callback for when a hint is taken '''
if len(GameLevel.all()) > 1:
message = "%s has taken a hint for %s (Lvl %s)" % (
user.team.name, hint.box.name,
GameLevel.by_id(hint.box.game_level_id).number)
else:
message = "%s has taken a hint for %s" % (user.team.name,
hint.box.name)
Notification.create_team(user.team, "Hint Taken", message, INFO)
self.io_loop.add_callback(self.push_team, user.team.id)
self.io_loop.add_callback(self.push_scoreboard)
def create_team(self):
''' Create a new team '''
if not self.config.teams:
team = Team.by_name(self.get_argument('handle', ''))
if team is None:
team = Team()
team.name = self.get_argument('handle', '')
else:
logging.info("Team %s already exists - Player Mode: reset team." % team.name)
team.flags = []
team.hints = []
team.boxes = []
team.items = []
team.game_levels = []
team.purchased_source_code = []
team.motto = self.get_argument('motto', '')
if self.config.banking:
team.money = self.config.starting_team_money
else:
team.money = 0
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
return team
elif self.config.public_teams:
if Team.by_name(self.get_argument('team_name', '')) is not None:
raise ValidationError("This team name is already registered. Use team code to join that team.")
team = Team()
team.name = self.get_argument('team_name', '')
team.motto = self.get_argument('motto', '')
if not self.config.banking:
team.money = 0
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
return team
else:
raise ValidationError("Public teams are not enabled")
def hint_taken(self, user, hint):
""" Callback for when a hint is taken """
if options.teams:
message = "%s has taken a hint for %s" % (user.handle, hint.box.name)
else:
message = "%s has taken a hint for %s" % (user.team.name, hint.box.name)
if len(GameLevel.all()) > 1:
message = message + " (%s)" % (
GameLevel.by_id(hint.box.game_level_id).name,
)
Notification.create_team(user.team, "Hint Taken", message, INFO)
self.io_loop.add_callback(self.push_team, user.team.id)
self.io_loop.add_callback(self.push_scoreboard)
def export_game_objects(self, root):
'''
Exports the game objects to an XML doc.
For the record, I hate XML with a passion.
'''
levels_elem = ET.SubElement(root, "gamelevels")
levels_elem.set("count", str(GameLevel.count()))
for level in GameLevel.all()[1:]:
level.to_xml(levels_elem)
corps_elem = ET.SubElement(root, "corporations")
corps_elem.set("count", str(Corporation.count()))
for corp in Corporation.all():
corp.to_xml(corps_elem)
def export_game_objects(self, root):
'''
Exports the game objects to an XML doc.
For the record, I hate XML with a passion.
'''
levels_elem = ET.SubElement(root, "gamelevels")
levels_elem.set("count", str(GameLevel.count()))
for level in GameLevel.all()[1:]:
level.to_xml(levels_elem)
corps_elem = ET.SubElement(root, "corporations")
corps_elem.set("count", str(Corporation.count()))
for corp in Corporation.all():
corp.to_xml(corps_elem)
def flag_captured(self, user, flag):
''' Callback for when a flag is captured '''
if len(GameLevel.all()) > 1:
message = "%s has captured the '%s' flag in %s (Lvl %s)" % (
user.team.name, flag.name, flag.box.name,
GameLevel.by_id(flag.box.game_level_id).number)
else:
message = "%s has captured the '%s' flag in %s" % (
user.team.name, flag.name, flag.box.name)
Notification.create_broadcast(user.team, "Flag Capture", message,
SUCCESS)
self.io_loop.add_callback(self.push_broadcast)
self.io_loop.add_callback(self.push_scoreboard)
def create_team(self, user):
team = Team()
team.name = user.handle
team.motto = ""
team._avatar = identicon(team.name, 6)
if self.config.banking:
team.money = self.config.starting_team_money
else:
team.money = 0
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels.append(level_0)
self.dbsession.add(team)
return team
def create_team(self):
''' Admins can create teams manually '''
try:
name = self.get_argument('team_name', '')
motto = self.get_argument('motto', '')
if Team.by_name(name) is not None:
raise ValidationError("Team already exists")
team = Team()
team.name = self.get_argument('team_name', '')
team.motto = self.get_argument('motto', '')
level_0 = GameLevel.all()[0]
self.dbsession.add(team)
self.dbsession.commit()
self.redirect('/admin/users')
except ValidationError as error:
self.render("admin/create/team.html", errors=[str(error), ])
def create_team(self):
''' Admins can create teams manually '''
try:
name = self.get_argument('team_name', '')
motto = self.get_argument('motto', '')
if Team.by_name(name) is not None:
raise ValidationError("Team already exists")
team = Team()
team.name = self.get_argument('team_name', '')
team.motto = self.get_argument('motto', '')
level_0 = GameLevel.all()[0]
self.dbsession.add(team)
self.dbsession.commit()
self.redirect('/admin/users')
except ValidationError as error:
self.render("admin/create/team.html", errors=[
str(error),
])
def del_game_level(self):
''' Deletes a game level, and fixes the linked list '''
game_level = GameLevel.by_uuid(self.get_argument('uuid', ''))
if game_level is not None:
game_levels = sorted(GameLevel.all())
game_levels.remove(game_level)
for index, level in enumerate(game_levels[:-1]):
level.next_level_id = game_levels[index + 1].id
self.dbsession.add(level)
if game_levels[0].number != 0:
game_levels[0].number = 0
self.dbsession.add(game_levels[0])
game_levels[-1].next_level_id = None
self.dbsession.add(game_levels[-1])
self.dbsession.delete(game_level)
self.dbsession.commit()
self.redirect('/admin/view/game_levels')
else:
self.render('admin/view/game_levels.html',
errors=["Game level does not exist in database."])
def create_demo_user():
from models.Team import Team
from models.User import User
from models.GameLevel import GameLevel
from models import dbsession
if Team.by_name("player") is None:
user = User()
user.handle = "player"
user.password = "******"
user.name = "player"
user.email = "*****@*****.**"
team = Team()
team.name = "player"
team.motto = "Don't hate the player"
team.money = 0
team.game_levels.append(GameLevel.all()[0])
team.members.append(user)
dbsession.add(user)
dbsession.add(team)
dbsession.commit()
def del_game_level(self):
''' Deletes a game level, and fixes the linked list '''
game_level = GameLevel.by_uuid(self.get_argument('uuid', ''))
if game_level is not None:
game_levels = sorted(GameLevel.all())
game_levels.remove(game_level)
for index, level in enumerate(game_levels[:-1]):
level.next_level_id = game_levels[index + 1].id
self.dbsession.add(level)
if game_levels[0].number != 0:
game_levels[0].number = 0
self.dbsession.add(game_levels[0])
game_levels[-1].next_level_id = None
self.dbsession.add(game_levels[-1])
self.dbsession.delete(game_level)
self.dbsession.commit()
self.redirect('/admin/view/game_levels')
else:
self.render('admin/view/game_levels.html',
errors=["Game level does not exist in database."]
)
def flag_penalty(self, user, flag):
""" Callback for when a flag is captured """
if options.teams:
message = "%s was penalized on '%s' in %s" % (
user.handle,
flag.name,
flag.box.name,
)
else:
message = "%s was penalized on '%s' in %s" % (
user.team.name,
flag.name,
flag.box.name,
)
if len(GameLevel.all()) > 1:
message = message + " (%s)" % (
GameLevel.by_id(flag.box.game_level_id).name,
)
Notification.create_team(user.team, "Flag Penalty", message, WARNING)
self.io_loop.add_callback(self.push_team, user.team.id)
self.io_loop.add_callback(self.push_scoreboard)
def edit_game_level(self):
""" Update game level objects """
try:
level = GameLevel.by_uuid(self.get_argument("uuid", ""))
if level is None:
raise ValidationError("Game level does not exist")
if int(self.get_argument("number", level.number)) != level.number:
level.number = self.get_argument("number", "")
level.buyout = self.get_argument("buyout", 1)
level._type = self.get_argument("type", "buyout")
level._reward = self.get_argument("reward", 0)
level.name = self.get_argument("name", None)
level.description = self.get_argument("description", "")
if level._type == "progress":
level.buyout = min(level.buyout, 100)
elif level._type == "none":
level.buyout = 0
if level._type != "none" and level.buyout == 0:
level._type = "none"
self.dbsession.add(level)
self.dbsession.flush()
# Fix the linked-list
game_levels = sorted(GameLevel.all())
for index, game_level in enumerate(game_levels[:-1]):
game_level.next_level_id = game_levels[index + 1].id
self.dbsession.add(game_level)
if game_levels[0].number != 0:
game_levels[0].number = 0
self.dbsession.add(game_levels[0])
game_levels[-1].next_level_id = None
self.dbsession.add(game_levels[-1])
self.dbsession.add(level)
self.dbsession.commit()
self.redirect("/admin/view/game_levels")
except ValueError:
raise ValidationError("That was not a number ...")
except ValidationError as error:
self.render("admin/view/game_levels.html", errors=[str(error)])
def _make_level(self, level_number):
'''
Creates a new level in the database, the levels are basically a
linked-list where each level points to the next, and the last points to
None. This function creates a new level and sorts everything based on
the 'number' attrib
'''
new_level = GameLevel()
new_level.number = level_number
new_level.buyout = self.get_argument('buyout', '')
game_levels = GameLevel.all()
game_levels.append(new_level)
game_levels = sorted(game_levels)
index = 0
for level in game_levels[:-1]:
level.next_level_id = game_levels[index + 1].id
self.dbsession.add(level)
index += 1
game_levels[0].number = 0
self.dbsession.add(game_levels[0])
game_levels[-1].next_level_id = None
self.dbsession.add(game_levels[-1])
self.dbsession.commit()
def success_capture(self, flag, old_reward=None):
if self.config.teams:
teamval = "team's "
else:
teamval = ""
user = self.get_current_user()
old_reward = flag.dynamic_value(user.team) if old_reward is None else old_reward
reward_dialog = flag.name + " answered correctly. "
if self.config.banking:
reward_dialog += (
"$"
+ str(old_reward)
+ " has been added to your "
+ teamval
+ "account."
)
else:
reward_dialog += (
str(old_reward) + " points added to your " + teamval + "score."
)
success = [reward_dialog]
# Fire capture webhook
send_capture_webhook(user, flag, old_reward)
# Check for Box Completion
box = flag.box
if box.is_complete(user):
if box.value > 0:
user.team.money += box.value
self.dbsession.add(user.team)
self.dbsession.flush()
self.dbsession.commit()
dialog = str(box.value) + " points added to your " + teamval + "score."
reward_dialog += dialog
success.append(
"Congratulations! You have completed " + box.name + ". " + dialog
)
# Fire box complete webhook
send_box_complete_webhook(user, box)
else:
success.append("Congratulations! You have completed " + box.name + ".")
# Check for Level Completion
level = GameLevel.by_id(box.game_level_id)
level_progress = old_div(
len(user.team.level_flags(level.number)), float(len(level.flags))
)
if level_progress == 1.0 and level not in user.team.game_levels:
reward_dialog = ""
if level._reward > 0:
user.team.money += level._reward
self.dbsession.add(user.team)
self.dbsession.flush()
self.dbsession.commit()
if self.config.banking:
reward_dialog += (
"$"
+ str(level._reward)
+ " has been added to your "
+ teamval
+ "account."
)
else:
reward_dialog += (
str(level._reward)
+ " points added to your "
+ teamval
+ "score."
)
success.append(
"Congratulations! You have completed "
+ level.name
+ ". "
+ reward_dialog
)
# Fire level complete webhook
send_level_complete_webhook(user, level)
# Unlock level if based on Game Score
for lv in GameLevel.all():
if (
lv.type == "points"
and lv.buyout <= user.team.money
and lv not in user.team.game_levels
):
logging.info(
"%s (%s) unlocked %s" % (user.handle, user.team.name, lv.name)
)
user.team.game_levels.append(lv)
self.dbsession.add(user.team)
self.dbsession.commit()
self.event_manager.level_unlocked(user, lv)
success.append("Congratulations! You have unlocked " + lv.name)
# Unlock next level if based on Game Progress
next_level = GameLevel.by_id(level.next_level_id)
if next_level and next_level not in user.team.game_levels:
if level_progress == 1.0 or (
next_level._type == "progress"
and level_progress * 100 >= next_level.buyout
):
logging.info(
"%s (%s) unlocked %s"
% (user.handle, user.team.name, next_level.name)
)
user.team.game_levels.append(next_level)
self.dbsession.add(user.team)
self.dbsession.commit()
self.event_manager.level_unlocked(user, next_level)
success.append("Congratulations! You have unlocked " + next_level.name)
self.event_manager.push_score_update()
return success
def update_gamestate(self, app):
game_state = {
"teams": {},
"levels": {},
"boxes": {},
"hint_count": len(Hint.all()),
"flag_count": len(Flag.all()),
"box_count": len(Box.all()),
"level_count": len(GameLevel.all()),
}
teams = Team.ranks()
for team in teams:
if len(team.members) > 0:
millis = int(round(time.time() * 1000))
game_state["teams"][team.name] = {
"uuid": team.uuid,
"flags": [str(flag) for flag in team.flags],
"game_levels": [str(lvl) for lvl in team.game_levels],
"members_count": len(team.members),
"hints_count": len(team.hints),
"bot_count":
BotManager.instance().count_by_team(team.name),
"money": team.money,
}
highlights = {"money": 0, "flag": 0, "bot": 0, "hint": 0}
for item in highlights:
value = team.get_score(item)
game_state["teams"][team.name][item] = value
game_history = app.settings["scoreboard_history"]
if team.name in game_history:
prev = game_history[team.name][item]
if prev < value:
highlights[item] = millis
else:
highlights[item] = game_history[
team.name]["highlights"][item]
highlights["now"] = millis
game_state["teams"][team.name]["highlights"] = highlights
app.settings["scoreboard_history"][
team.name] = game_state["teams"].get(team.name)
for level in GameLevel.all():
game_state["levels"][level.name] = {
"type": level.type,
"number": level.number,
"teams": {},
"boxes": {},
"box_count": len(level.boxes),
"flag_count": len(level.flags),
}
for team in teams:
game_state["levels"][level.name]["teams"][team.name] = {
"lvl_count": len(team.level_flags(level.number)),
"lvl_unlock": level in team.game_levels,
}
for box in level.boxes:
game_state["levels"][level.name]["boxes"][box.uuid] = {
"name": box.name,
"teams": {},
"flag_count": len(box.flags),
}
for team in teams:
game_state["levels"][level.name]["boxes"][
box.uuid]["teams"][team.name] = {
"box_count": len(team.box_flags(box))
}
app.settings["scoreboard_state"] = game_state
def post(self, *args, **kwargs):
"""
Reset the Game
"""
errors = []
success = None
try:
users = User.all()
for user in users:
user.money = 0
teams = Team.all()
for team in teams:
if options.banking:
team.money = options.starting_team_money
else:
team.money = 0
team.flags = []
team.hints = []
team.boxes = []
team.items = []
team.purchased_source_code = []
level_0 = GameLevel.by_number(0)
if not level_0:
level_0 = GameLevel.all()[0]
team.game_levels = [level_0]
self.dbsession.add(team)
self.dbsession.commit()
self.dbsession.flush()
for team in teams:
for paste in team.pastes:
self.dbsession.delete(paste)
for shared_file in team.files:
shared_file.delete_data()
self.dbsession.delete(shared_file)
self.dbsession.commit()
self.dbsession.flush()
Penalty.clear()
Notification.clear()
snapshot = Snapshot.all()
for snap in snapshot:
self.dbsession.delete(snap)
self.dbsession.commit()
snapshot_team = SnapshotTeam.all()
for snap in snapshot_team:
self.dbsession.delete(snap)
self.dbsession.commit()
game_history = GameHistory.instance()
game_history.take_snapshot() # Take starting snapshot
flags = Flag.all()
for flag in flags:
# flag.value = flag.value allows a fallback to when original_value was used
# Allows for the flag value to be reset if dynamic scoring was used
# Can be removed after depreciation timeframe
flag.value = flag.value
self.dbsession.add(flag)
self.dbsession.commit()
self.dbsession.flush()
self.event_manager.push_score_update()
self.flush_memcached()
success = "Successfully Reset Game"
self.render("admin/reset.html", success=success, errors=errors)
except BaseException as e:
errors.append("Failed to Reset Game")
logging.error(str(e))
self.render("admin/reset.html", success=None, errors=errors)
