Пример #1
0
    def getProfile(self, JID):
        """
      Retrieves the profile for the specified JID
    """
        stats = {}
        player = db.query(Player).filter(Player.jid.ilike(str(JID)))

        if not player.first():
            return

        queried_player = player.first()
        playerID = queried_player.id
        if queried_player.rating != -1:
            stats['rating'] = str(queried_player.rating)
            rank = db.query(Player).filter(
                Player.rating >= queried_player.rating).count()
            stats['rank'] = str(rank)

        if queried_player.highest_rating != -1:
            stats['highestRating'] = str(queried_player.highest_rating)

        gamesPlayed = db.query(PlayerInfo).filter_by(
            player_id=playerID).count()
        wins = db.query(Game).filter_by(winner_id=playerID).count()
        stats['totalGamesPlayed'] = str(gamesPlayed)
        stats['wins'] = str(wins)
        stats['losses'] = str(gamesPlayed - wins)
        return stats
Пример #2
0
  def getProfile(self, JID):
    """
      Retrieves the profile for the specified JID
    """
    stats = {}
    player = db.query(Player).filter(Player.jid.ilike(str(JID)))

    if not player.first():
      return

    queried_player = player.first()
    playerID = queried_player.id
    if queried_player.rating != -1:
      stats['rating'] = str(queried_player.rating)
      rank = db.query(Player).filter(Player.rating >= queried_player.rating).count()
      stats['rank'] = str(rank)

    if queried_player.highest_rating != -1:
      stats['highestRating'] = str(queried_player.highest_rating)

    gamesPlayed = db.query(PlayerInfo).filter_by(player_id=playerID).count()
    wins = db.query(Game).filter_by(winner_id=playerID).count()
    stats['totalGamesPlayed'] = str(gamesPlayed)
    stats['wins'] = str(wins)
    stats['losses'] = str(gamesPlayed - wins)
    return stats
Пример #3
0
  def getProfile(self, JID):
    """
      Retrieves the profile for the specified JID
    """
    stats = {}
    player = db.query(Player).filter(Player.jid.ilike(str(JID)))
    if not player.first():
      return
    if player.first().rating != -1:
      stats['rating'] = str(player.first().rating)

    if player.first().highest_rating != -1:
      stats['highestRating'] = str(player.first().highest_rating)

    playerID = player.first().id
    players = db.query(Player).order_by(Player.rating.desc()).all()

    for rank, user in enumerate(players):
      if (user.jid.lower() == JID.lower()):
        stats['rank'] = str(rank+1)
        break

    stats['totalGamesPlayed'] = str(db.query(PlayerInfo).filter_by(player_id=playerID).count())
    stats['wins'] = str(db.query(Game).filter_by(winner_id=playerID).count())
    stats['losses'] = str(db.query(PlayerInfo).filter_by(player_id=playerID).count() - db.query(Game).filter_by(winner_id=playerID).count())
    return stats
Пример #4
0
  def getProfile(self, JID):
    """
      Retrieves the profile for the specified JID
    """
    stats = {}
    player = db.query(Player).filter(Player.jid.ilike(str(JID)))
    if not player.first():
      return
    if player.first().rating != -1:
      stats['rating'] = str(player.first().rating)

    if player.first().highest_rating != -1:
      stats['highestRating'] = str(player.first().highest_rating)

    playerID = player.first().id
    players = db.query(Player).order_by(Player.rating.desc()).all()

    for rank, user in enumerate(players):
      if (user.jid.lower() == JID.lower()):
        stats['rank'] = str(rank+1)
        break

    stats['totalGamesPlayed'] = str(db.query(PlayerInfo).filter_by(player_id=playerID).count())
    stats['wins'] = str(db.query(Game).filter_by(winner_id=playerID).count())
    stats['losses'] = str(db.query(PlayerInfo).filter_by(player_id=playerID).count() - db.query(Game).filter_by(winner_id=playerID).count())
    return stats
Пример #5
0
  def addGame(self, gamereport):
    """
      Adds a game to the database and updates the data
      on a player(JID) from game results.
      Returns the created Game object, or None if
      the creation failed for any reason.
      Side effects:
        Inserts a new Game instance into the database.
    """
    # Discard any games still in progress.
    if any(map(lambda state: state == 'active',
               dict.values(gamereport['playerStates']))):
      return None

    players = map(lambda jid: db.query(Player).filter_by(jid=jid).first(),
                  dict.keys(gamereport['playerStates']))

    winning_jid = list(dict.keys({jid: state for jid, state in
                                  gamereport['playerStates'].items()
                                  if state == 'won'}))[0]

    def get(stat, jid):
      return gamereport[stat][jid]

    stats = {'civ': 'civs', 'foodGathered': 'foodGathered', 'foodUsed': 'foodUsed',
             'woodGathered': 'woodGathered', 'woodUsed': 'woodUsed',
             'stoneGathered': 'stoneGathered', 'stoneUsed': 'stoneUsed',
             'metalGathered': 'metalGathered', 'metalUsed': 'metalUsed'}

    playerInfos = []
    for player in players:
      jid = player.jid
      playerinfo = PlayerInfo(player=player)
      for dbname, reportname in stats.items():
        setattr(playerinfo, dbname, get(reportname, jid))
      playerInfos.append(playerinfo)

    game = Game(map=gamereport['mapName'], duration=int(gamereport['timeElapsed']))
    game.players.extend(players)
    game.player_info.extend(playerInfos)
    game.winner = db.query(Player).filter_by(jid=winning_jid).first()
    db.add(game)
    db.commit()
    return game
Пример #6
0
 def getBoard(self):
   """
     Returns a dictionary of player rankings to
       JIDs for sending.
   """
   board = {}
   players = db.query(Player).filter(Player.rating != -1).order_by(Player.rating.desc()).limit(100).all()
   for rank, player in enumerate(players):
     board[player.jid] = {'name': '@'.join(player.jid.split('@')[:-1]), 'rating': str(player.rating)}
   return board
Пример #7
0
 def removePlayer(self, JID):
   """
     Remove a player(JID) from database.
     Returns the player that was removed, or None
     if that player didn't exist.
   """
   players = db.query(Player).filter_by(jid=JID)
   player = players.first()
   if not player:
     return None
   players.delete()
   return player
Пример #8
0
 def removePlayer(self, JID):
   """
     Remove a player(JID) from database.
     Returns the player that was removed, or None
     if that player didn't exist.
   """
   players = db.query(Player).filter_by(jid=JID)
   player = players.first()
   if not player:
     return None
   players.delete()
   return player
Пример #9
0
 def getBoard(self):
   """
     Returns a dictionary of player rankings to
       JIDs for sending.
   """
   board = {}
   players = db.query(Player).order_by(Player.rating.desc()).limit(100).all()
   for rank, player in enumerate(players):
     # Don't send uninitialized ratings.
     if player.rating == -1:
       continue
     board[player.jid] = {'name': '@'.join(player.jid.split('@')[:-1]), 'rating': str(player.rating)}
   return board
Пример #10
0
 def getBoard(self):
   """
     Returns a dictionary of player rankings to
       JIDs for sending.
   """
   board = {}
   players = db.query(Player).order_by(Player.rating.desc()).limit(100).all()
   for rank, player in enumerate(players):
     # Don't send uninitialized ratings.
     if player.rating == -1:
       continue
     board[player.jid] = {'name': '@'.join(player.jid.split('@')[:-1]), 'rating': str(player.rating)}
   return board
Пример #11
0
 def getOrCreatePlayer(self, JID):
   """
     Stores a player(JID) in the database if they don't yet exist.
     Returns either the newly created instance of
     the Player model, or the one that already
     exists in the database.
   """
   players = db.query(Player).filter_by(jid=str(JID))
   if not players.first():
     player = Player(jid=str(JID), rating=-1)
     db.add(player)
     db.commit()
     return player
   return players.first()
Пример #12
0
 def getOrCreatePlayer(self, JID):
   """
     Stores a player(JID) in the database if they don't yet exist.
     Returns either the newly created instance of
     the Player model, or the one that already
     exists in the database.
   """
   players = db.query(Player).filter_by(jid=str(JID))
   if not players.first():
     player = Player(jid=str(JID), rating=-1)
     db.add(player)
     db.commit()
     return player
   return players.first()
Пример #13
0
 def getBoard(self):
     """
   Returns a dictionary of player rankings to
     JIDs for sending.
 """
     board = {}
     players = db.query(Player).filter(Player.rating != -1).order_by(
         Player.rating.desc()).limit(100).all()
     for rank, player in enumerate(players):
         board[player.jid] = {
             'name': '@'.join(player.jid.split('@')[:-1]),
             'rating': str(player.rating)
         }
     return board
Пример #14
0
 def getRatingList(self, nicks):
   """
   Returns a rating list of players
   currently in the lobby by nick
   because the client can't link
   JID to nick conveniently.
   """
   ratinglist = {}
   players = db.query(Player.jid, Player.rating).filter(func.upper(Player.jid).in_([ str(JID).upper() for JID in list(nicks) ]))
   for player in players:
       rating = str(player.rating) if player.rating != -1 else ''
       for JID in list(nicks):
           if JID.upper() == player.jid.upper():
               ratinglist[nicks[JID]] = {'name': nicks[JID], 'rating': rating}
               break
   return ratinglist
Пример #15
0
 def getRatingList(self, nicks):
   """
   Returns a rating list of players
   currently in the lobby by nick
   because the client can't link
   JID to nick conveniently.
   """
   ratinglist = {}
   for JID in list(nicks):
     players = db.query(Player.jid, Player.rating).filter(Player.jid.ilike(str(JID)))
     if players.first():
       if players.first().rating == -1:
         ratinglist[nicks[JID]] = {'name': nicks[JID], 'rating': ''}
       else:
         ratinglist[nicks[JID]] = {'name': nicks[JID], 'rating': str(players.first().rating)}
     else:
       ratinglist[nicks[JID]] = {'name': nicks[JID], 'rating': ''}
   return ratinglist
Пример #16
0
 def getRatingList(self, nicks):
   """
   Returns a rating list of players
   currently in the lobby by nick
   because the client can't link
   JID to nick conveniently.
   """
   ratinglist = {}
   for JID in nicks.keys():
     players = db.query(Player).filter(Player.jid.ilike(str(JID)))
     if players.first():
       if players.first().rating == -1:
         ratinglist[nicks[JID]] = {'name': nicks[JID], 'rating': ''}
       else:
         ratinglist[nicks[JID]] = {'name': nicks[JID], 'rating': str(players.first().rating)}
     else:
       ratinglist[nicks[JID]] = {'name': nicks[JID], 'rating': ''}
   return ratinglist
Пример #17
0
 def getRatingList(self, nicks):
     """
 Returns a rating list of players
 currently in the lobby by nick
 because the client can't link
 JID to nick conveniently.
 """
     ratinglist = {}
     players = db.query(Player.jid, Player.rating).filter(
         func.upper(Player.jid).in_(
             [str(JID).upper() for JID in list(nicks)]))
     for player in players:
         rating = str(player.rating) if player.rating != -1 else ''
         for JID in list(nicks):
             if JID.upper() == player.jid.upper():
                 ratinglist[nicks[JID]] = {
                     'name': nicks[JID],
                     'rating': rating
                 }
                 break
     return ratinglist
Пример #18
0
  def addGame(self, gamereport):
    """
      Adds a game to the database and updates the data
      on a player(JID) from game results.
      Returns the created Game object, or None if
      the creation failed for any reason.
      Side effects:
        Inserts a new Game instance into the database.
    """
    # Discard any games still in progress.
    if any(map(lambda state: state == 'active',
               dict.values(gamereport['playerStates']))):
      return None

    players = map(lambda jid: db.query(Player).filter(Player.jid.ilike(str(jid))).first(),
                  dict.keys(gamereport['playerStates']))

    winning_jid = list(dict.keys({jid: state for jid, state in
                                  gamereport['playerStates'].items()
                                  if state == 'won'}))[0]
    def get(stat, jid):
      return gamereport[stat][jid]

    singleStats = {'timeElapsed', 'mapName', 'teamsLocked', 'matchID'}
    totalScoreStats = {'economyScore', 'militaryScore', 'totalScore'}
    resourceStats = {'foodGathered', 'foodUsed', 'woodGathered', 'woodUsed', 
            'stoneGathered', 'stoneUsed', 'metalGathered', 'metalUsed', 'vegetarianFoodGathered',
            'treasuresCollected', 'lootCollected', 'tributesSent', 'tributesReceived'}
    unitsStats = {'totalUnitsTrained', 'totalUnitsLost', 'enemytotalUnitsKilled', 'infantryUnitsTrained',
            'infantryUnitsLost', 'enemyInfantryUnitsKilled', 'workerUnitsTrained', 'workerUnitsLost',
            'enemyWorkerUnitsKilled', 'femaleUnitsTrained', 'femaleUnitsLost', 'enemyFemaleUnitsKilled',
            'cavalryUnitsTrained', 'cavalryUnitsLost', 'enemyCavalryUnitsKilled', 'championUnitsTrained',
            'championUnitsLost', 'enemyChampionUnitsKilled', 'heroUnitsTrained', 'heroUnitsLost',
            'enemyHeroUnitsKilled', 'shipUnitsTrained', 'shipUnitsLost', 'enemyShipUnitsKilled', 'traderUnitsTrained',
            'traderUnitsLost', 'enemyTraderUnitsKilled'}
    buildingsStats = {'totalBuildingsConstructed', 'totalBuildingsLost', 'enemytotalBuildingsDestroyed',
            'civCentreBuildingsConstructed', 'civCentreBuildingsLost', 'enemyCivCentreBuildingsDestroyed',
            'houseBuildingsConstructed', 'houseBuildingsLost', 'enemyHouseBuildingsDestroyed',
            'economicBuildingsConstructed', 'economicBuildingsLost', 'enemyEconomicBuildingsDestroyed',
            'outpostBuildingsConstructed', 'outpostBuildingsLost', 'enemyOutpostBuildingsDestroyed',
            'militaryBuildingsConstructed', 'militaryBuildingsLost', 'enemyMilitaryBuildingsDestroyed',
            'fortressBuildingsConstructed', 'fortressBuildingsLost', 'enemyFortressBuildingsDestroyed',
            'wonderBuildingsConstructed', 'wonderBuildingsLost', 'enemyWonderBuildingsDestroyed'}
    marketStats = {'woodBought', 'foodBought', 'stoneBought', 'metalBought', 'tradeIncome'}
    miscStats = {'civs', 'teams', 'percentMapExplored'}

    stats = totalScoreStats | resourceStats | unitsStats | buildingsStats | marketStats | miscStats
    playerInfos = []
    for player in players:
      jid = player.jid
      playerinfo = PlayerInfo(player=player)
      for reportname in stats:
        setattr(playerinfo, reportname, get(reportname, jid.lower()))
      playerInfos.append(playerinfo)

    game = Game(map=gamereport['mapName'], duration=int(gamereport['timeElapsed']), teamsLocked=bool(gamereport['teamsLocked']), matchID=gamereport['matchID'])
    game.players.extend(players)
    game.player_info.extend(playerInfos)
    game.winner = db.query(Player).filter(Player.jid.ilike(str(winning_jid))).first()
    db.add(game)
    db.commit()
    return game
Пример #19
0
  def addGame(self, gamereport):
    """
      Adds a game to the database and updates the data
      on a player(JID) from game results.
      Returns the created Game object, or None if
      the creation failed for any reason.
      Side effects:
        Inserts a new Game instance into the database.
    """
    # Discard any games still in progress.
    if any(map(lambda state: state == 'active',
               dict.values(gamereport['playerStates']))):
      return None

    players = map(lambda jid: db.query(Player).filter(Player.jid.ilike(str(jid))).first(),
                  dict.keys(gamereport['playerStates']))

    winning_jid = list(dict.keys({jid: state for jid, state in
                                  gamereport['playerStates'].items()
                                  if state == 'won'}))[0]
    def get(stat, jid):
      return gamereport[stat][jid]

    singleStats = {'timeElapsed', 'mapName', 'teamsLocked', 'matchID'}
    totalScoreStats = {'economyScore', 'militaryScore', 'totalScore'}
    resourceStats = {'foodGathered', 'foodUsed', 'woodGathered', 'woodUsed', 
            'stoneGathered', 'stoneUsed', 'metalGathered', 'metalUsed', 'vegetarianFoodGathered',
            'treasuresCollected', 'lootCollected', 'tributesSent', 'tributesReceived'}
    unitsStats = {'totalUnitsTrained', 'totalUnitsLost', 'enemytotalUnitsKilled', 'infantryUnitsTrained',
            'infantryUnitsLost', 'enemyInfantryUnitsKilled', 'workerUnitsTrained', 'workerUnitsLost',
            'enemyWorkerUnitsKilled', 'femaleUnitsTrained', 'femaleUnitsLost', 'enemyFemaleUnitsKilled',
            'cavalryUnitsTrained', 'cavalryUnitsLost', 'enemyCavalryUnitsKilled', 'championUnitsTrained',
            'championUnitsLost', 'enemyChampionUnitsKilled', 'heroUnitsTrained', 'heroUnitsLost',
            'enemyHeroUnitsKilled', 'shipUnitsTrained', 'shipUnitsLost', 'enemyShipUnitsKilled', 'traderUnitsTrained',
            'traderUnitsLost', 'enemyTraderUnitsKilled'}
    buildingsStats = {'totalBuildingsConstructed', 'totalBuildingsLost', 'enemytotalBuildingsDestroyed',
            'civCentreBuildingsConstructed', 'civCentreBuildingsLost', 'enemyCivCentreBuildingsDestroyed',
            'houseBuildingsConstructed', 'houseBuildingsLost', 'enemyHouseBuildingsDestroyed',
            'economicBuildingsConstructed', 'economicBuildingsLost', 'enemyEconomicBuildingsDestroyed',
            'outpostBuildingsConstructed', 'outpostBuildingsLost', 'enemyOutpostBuildingsDestroyed',
            'militaryBuildingsConstructed', 'militaryBuildingsLost', 'enemyMilitaryBuildingsDestroyed',
            'fortressBuildingsConstructed', 'fortressBuildingsLost', 'enemyFortressBuildingsDestroyed',
            'wonderBuildingsConstructed', 'wonderBuildingsLost', 'enemyWonderBuildingsDestroyed'}
    marketStats = {'woodBought', 'foodBought', 'stoneBought', 'metalBought', 'tradeIncome'}
    miscStats = {'civs', 'teams', 'percentMapExplored'}

    stats = totalScoreStats | resourceStats | unitsStats | buildingsStats | marketStats | miscStats
    playerInfos = []
    for player in players:
      jid = player.jid
      playerinfo = PlayerInfo(player=player)
      for reportname in stats:
        setattr(playerinfo, reportname, get(reportname, jid.lower()))
      playerInfos.append(playerinfo)

    game = Game(map=gamereport['mapName'], duration=int(gamereport['timeElapsed']), teamsLocked=bool(gamereport['teamsLocked']), matchID=gamereport['matchID'])
    game.players.extend(players)
    game.player_info.extend(playerInfos)
    game.winner = db.query(Player).filter(Player.jid.ilike(str(winning_jid))).first()
    db.add(game)
    db.commit()
    return game