コード例 #1
0
 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")
コード例 #2
0
 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),
         ])
コード例 #3
0
 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)
コード例 #4
0
 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), ])
コード例 #5
0
 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)
コード例 #6
0
 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), ])
コード例 #7
0
    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),
            ])
コード例 #8
0
 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)])
コード例 #9
0
    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)])
コード例 #10
0
 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),
         ])
コード例 #11
0
    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), ])
コード例 #12
0
 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)
コード例 #13
0
 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")
コード例 #14
0
 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')
コード例 #15
0
 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")
コード例 #16
0
ファイル: PublicHandlers.py プロジェクト: WeiEast/RootTheBox
 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")
コード例 #17
0
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
コード例 #18
0
 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)
コード例 #19
0
ファイル: Helpers.py プロジェクト: AdaFormacion/RootTheBox
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
コード例 #20
0
 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)
コード例 #21
0
ファイル: PublicHandlers.py プロジェクト: moloch--/RootTheBox
 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")
コード例 #22
0
 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)
コード例 #23
0
 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)
コード例 #24
0
 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)
コード例 #25
0
 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)
コード例 #26
0
 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
コード例 #27
0
 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), ])
コード例 #28
0
 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),
         ])
コード例 #29
0
 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."])
コード例 #30
0
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()
コード例 #31
0
 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."]
                     )
コード例 #32
0
 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)
コード例 #33
0
 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)])
コード例 #34
0
 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()
コード例 #35
0
    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
コード例 #36
0
ファイル: Scoreboard.py プロジェクト: optionalg/RootTheBox
    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
コード例 #37
0
 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)