Ejemplo n.º 1
0
    def dispatch(self, message):
        try:
            request = json.loads(message.body)
            assert isinstance(request, dict), 'Request should be a dict().'
            assert 'request' in request, 'Required argument is missing: "request".'
            method_name = str(request['request'])
            assert not method_name.startswith(
                '_'), 'You are not allowed to call private API.'
            f = getattr(controller, method_name, None)
            assert callable(f), 'You are requesting an unknown API.'

            # Get Player record from server.
            sender = db.IM('xmpp', message.sender.split('/')[0])
            player = Player.all().filter('account =', sender).fetch(limit=1)
            if len(player) == 0:  # Create a new record for new Player.
                player = Player(account=sender)
                player.put()
            else:
                player = player[0]
            assert player is not None, 'Failed to get player data.'

            # Take action
            arg = request['arg'] if 'arg' in request else {}
            assert isinstance(arg, dict), 'Arguments should be a dict()'
            arg['sender'] = player  # append sender to arguments
            result = f(arg)
        except AssertionError, e:
            result = json.dumps({
                'response':
                method_name if 'method_name' in locals() else 'unknown',
                'stat':
                'fail',
                'msg':
                str(e)
            })
Ejemplo n.º 2
0
    def run(self):
        """Launch the program."""
        if len(Player.list()) < 1:
            Player.create_height_players()

        while self.running:
            self.view.display()
Ejemplo n.º 3
0
 def handle(self):
     username = self.request.get("u")
     if not username:
         return {"success": False, "error": "format"}
     player = Player.all().filter('username = '******'searching = ', True).filter('username !=', username).get()
     if other:
         
         other.searching = False
         other.match_server = server
         player.match_server = server
         server.free = False
         
         other.put()
         player.put()
         server.put()
         
         return {"success": True}
     
     player.searching = True
     player.put()
     
     return {"success": True}
Ejemplo n.º 4
0
    def test_update_player(self):
        self.assertEquals(self.norcal_dao.get_player_by_id(
            self.player_1_id), self.player_1)
        self.assertEquals(self.norcal_dao.get_player_by_id(
            self.player_2_id), self.player_2)
        self.assertEquals(self.norcal_dao.get_player_by_id(
            self.player_3_id), self.player_3)

        player_1_clone = Player(
            name='gaR',
            aliases=['gar', 'garr'],
            ratings={'norcal': Rating(), 'texas': Rating()},
            regions=['norcal', 'texas'],
            id=self.player_1_id)
        player_1_clone.name = 'garrr'
        player_1_clone.aliases.append('garrr')
        del player_1_clone.ratings['texas']
        self.assertNotEquals(self.norcal_dao.get_player_by_id(
            self.player_1_id), player_1_clone)

        self.norcal_dao.update_player(player_1_clone)

        self.assertNotEquals(self.norcal_dao.get_player_by_id(
            self.player_1_id), self.player_1)
        self.assertEquals(self.norcal_dao.get_player_by_id(
            self.player_2_id), self.player_2)
        self.assertEquals(self.norcal_dao.get_player_by_id(
            self.player_3_id), self.player_3)
        self.assertEquals(self.norcal_dao.get_player_by_id(
            self.player_1_id), player_1_clone)
Ejemplo n.º 5
0
    def test_update_player(self):
        self.assertEquals(self.norcal_dao.get_player_by_id(self.player_1_id),
                          self.player_1)
        self.assertEquals(self.norcal_dao.get_player_by_id(self.player_2_id),
                          self.player_2)
        self.assertEquals(self.norcal_dao.get_player_by_id(self.player_3_id),
                          self.player_3)

        player_1_clone = Player(name='gaR',
                                aliases=['gar', 'garr'],
                                ratings={
                                    'norcal': Rating(),
                                    'texas': Rating()
                                },
                                regions=['norcal', 'texas'],
                                id=self.player_1_id)
        player_1_clone.name = 'garrr'
        player_1_clone.aliases.append('garrr')
        del player_1_clone.ratings['texas']
        self.assertNotEquals(
            self.norcal_dao.get_player_by_id(self.player_1_id), player_1_clone)

        self.norcal_dao.update_player(player_1_clone)

        self.assertNotEquals(
            self.norcal_dao.get_player_by_id(self.player_1_id), self.player_1)
        self.assertEquals(self.norcal_dao.get_player_by_id(self.player_2_id),
                          self.player_2)
        self.assertEquals(self.norcal_dao.get_player_by_id(self.player_3_id),
                          self.player_3)
        self.assertEquals(self.norcal_dao.get_player_by_id(self.player_1_id),
                          player_1_clone)
Ejemplo n.º 6
0
    def setUp(self):
        self.player_1_id = ObjectId()
        self.player_1_name = 'gaR'
        self.player_1_aliases = ['gar', 'garr', 'garpr']
        self.player_1_rating = {
            'norcal': Rating(),
            'texas': Rating(mu=10., sigma=1.)
        }
        self.player_1_regions = ['norcal', 'texas']

        self.player_2_id = ObjectId()
        self.player_2_name = 'MIOM | SFAT'
        self.player_2_aliases = ['miom | sfat', 'sfat', 'miom|sfat']
        self.player_2_rating = {'norcal': Rating(mu=30., sigma=2.)}
        self.player_2_regions = ['norcal', 'socal']

        self.player_1 = Player(name=self.player_1_name,
                               aliases=self.player_1_aliases,
                               ratings=self.player_1_rating,
                               regions=self.player_1_regions,
                               id=self.player_1_id)
        self.player_1_missing_id = Player(name=self.player_1_name,
                                          aliases=self.player_1_aliases,
                                          ratings=self.player_1_rating,
                                          regions=self.player_1_regions)
        self.player_2 = Player(name=self.player_2_name,
                               aliases=self.player_2_aliases,
                               ratings=self.player_2_rating,
                               regions=self.player_2_regions,
                               id=self.player_2_id)

        self.player_1_json_dict = {
            '_id': self.player_1_id,
            'name': self.player_1_name,
            'aliases': self.player_1_aliases,
            'ratings': {
                region: rating.dump()
                for region, rating in self.player_1_rating.iteritems()
            },
            'regions': self.player_1_regions,
            'merge_children': [self.player_1_id],
            'merge_parent': None,
            'merged': False,
        }

        self.player_1_json_dict_missing_id = {
            'name': self.player_1_name,
            'aliases': self.player_1_aliases,
            'ratings': {
                region: rating.dump()
                for region, rating in self.player_1_rating.iteritems()
            },
            'regions': self.player_1_regions,
            'merge_children': [None],
            'merge_parent': None,
            'merged': False,
        }
Ejemplo n.º 7
0
    def build(self, testMode=True):
        """
        Initiate objects and views.
        """
        ''' init game objects '''
        self.deck = Deck()
        self.evaluator = Evaluator()

        self.player = []
        self.player.append(Player(0))
        self.player.append(Player(1))
        # board stands for public cards on board
        self.board = Board()

        # In test mode, both player select right-most cards for the turn automatically
        self.testMode = testMode
        ''' create view objects '''
        # Scatter that can be rotated to display players
        scatter_bot = ScatterLayout(do_rotation=False,
                                    do_translation=False,
                                    do_scale=False,
                                    size_hint=(1, 1),
                                    pos_hint={
                                        'x': 0,
                                        'y': 0
                                    },
                                    rotation=0)
        # For player on top, the widget rotates 180 degree
        scatter_top = ScatterLayout(do_rotation=False,
                                    do_translation=False,
                                    do_scale=False,
                                    size_hint=(1, 1),
                                    pos_hint={
                                        'x': 0,
                                        'y': 0
                                    },
                                    rotation=180)

        box = PlayerDeck()
        box2 = PlayerDeck()
        publicArea = PublicArea()
        box.build(self, "player1", 0, self.testMode)
        box2.build(self, "player2", 1, self.testMode)
        publicArea.build()

        scatter_bot.add_widget(box)
        scatter_top.add_widget(box2)

        self.add_widget(scatter_bot)
        self.add_widget(scatter_top)
        self.add_widget(publicArea)

        # register id of view objects
        self.ids[box.id] = box
        self.ids[box2.id] = box2
        self.ids[publicArea.id] = publicArea
Ejemplo n.º 8
0
 def modify_player():
     players = Player.read_player()
     View.show_number_alpha(players)
     choice = input("quel joueur voulait vous modifier (rentrer chiffre): ")
     name = input("Nom: ")
     birthday = input("Date de naissance: ")
     gender = input("Genre: ")
     rank = input("Classement: ")
     point = input("Point: ")
     Player.modify_player(choice, name, birthday, gender, rank, point)
Ejemplo n.º 9
0
def init_game(request):
    print "Init game..."
    player1 = Player("Player 1")
    player2 = Player("Player 2")
    game = Game(player1, player2)
    # Store game object to session
    request.session['game'] = game
    # Print game id for DEBUG
    print game.id()
    return game.toJSON()
Ejemplo n.º 10
0
def add_player(name, index_str):
    if index_str:
        player = Player(name, int(index_str))
        game.add_player(player)
        msg = f'Player {name} has been added with index {index_str}'
    else:
        player = Player(name)
        game.add_player(player)
        msg = f'Player {name} has been added'
    return display.message(msg, ''), 202
Ejemplo n.º 11
0
def add_player(player_name, player_sex, player_age, player_desc):
    session = connectToDatabase()
    player = Player()
    player.name = player_name
    player.sex = player_sex
    player.age = player_age
    player.desc = player_desc
    session.add(player)
    session.commit()
    session.close()
Ejemplo n.º 12
0
    def setUp(self):
        self.player_1_id = ObjectId()
        self.player_2_id = ObjectId()
        self.region_id = 'norcal'

        self.player_1 = Player(
                'gaR', ['gar', 'garr'], 
                {'norcal': TrueskillRating(), 'texas': TrueskillRating()}, 
                False, id=self.player_1_id)
        self.player_2 = Player(
                'sfat', ['sfat', 'miom | sfat'], 
                {'norcal': TrueskillRating(), 'socal': TrueskillRating()}, 
                False, id=self.player_2_id)
Ejemplo n.º 13
0
    def handle(self):
        host = self.request.get("h")
        players = self.request.get("p")
        scores = self.request.get("s")
        duration = self.request.get("d")
        
        # preconditions
        try:
            players = players.split(",")
            playera, playerb = tuple(players)
            scorea, scoreb = tuple([int(x) for x in scores.split(",")])
            scores = [scorea, scoreb]
        except Exception:
            players, scores = None, None
        try:
            duration = long(float(duration))
        except ValueError:
            duration = None
        if not host or not players or not scores or not duration:
            return {"success": False, "error": "format"}

        server = Server.all().filter('host = ', host).get()
        if not server:
            return {"success": False, "error": "nonexisting"}
        
        
        # actual processing
        server.free = True
        
        playera = Player.all().filter('username = '******'username = ', playerb).get()
        
        
        (pa_new_elo, pb_new_elo) = calculate_elos(playera.elo, playerb.elo, PLAYER_A if scorea > scoreb else PLAYER_B)
        
        mh = MatchHistory(
            players = players,
            scores = scores,
            elo_delta = playera.elo - playerb.elo,
            duration = duration)    
        
        playera.elo = int(pa_new_elo)
        playerb.elo = int(pb_new_elo)
        
        server.put()
        playera.put()
        playerb.put()
        mh.put()
        
        return {"success": True}
Ejemplo n.º 14
0
    def post(self, region, id):
        dao = Dao(region, mongo_client=mongo_client)

        pending_tournament = dao.get_pending_tournament_by_id(ObjectId(id))
        if not pending_tournament:
            return 'No pending tournament found with that id.', 400
        user = get_user_from_request(request, dao)
        if not user:
            return 'Permission denied', 403
        if not is_user_admin_for_region(user, pending_tournament.regions):
            return 'Permission denied', 403

        new_player_names = []
        for mapping in pending_tournament.alias_to_id_map:
            if mapping["player_id"] == None:
                new_player_names.append(mapping["player_alias"])

        for player_name in new_player_names:
            player = Player.create_with_default_values(player_name, region)
            player_id = dao.insert_player(player)
            pending_tournament.set_alias_id_mapping(player_name, player_id)

        dao.update_pending_tournament(pending_tournament)
        
        try:
            tournament = Tournament.from_pending_tournament(pending_tournament)
            tournament_id = dao.insert_tournament(tournament)
            dao.delete_pending_tournament(pending_tournament)
            return {"success": True, "tournament_id": str(tournament_id)}
        except ValueError:
            return 'Not all player aliases in this pending tournament have been mapped to player ids.', 400
Ejemplo n.º 15
0
 def add_user(self):
     user = User(self)
     db_session.add(user)
     # there should be improved to ensure User and Player have same user_id
     db_session.add(Player(nickname=self.username.data))
     db_session.commit()
     return user
Ejemplo n.º 16
0
    def post(self, region, id):
        dao = Dao(region, mongo_client=mongo_client)

        pending_tournament = dao.get_pending_tournament_by_id(ObjectId(id))
        if not pending_tournament:
            return 'No pending tournament found with that id.', 400
        user = get_user_from_request(request, dao)
        if not user:
            return 'Permission denied', 403
        if not is_user_admin_for_regions(user, pending_tournament.regions):
            return 'Permission denied', 403

        new_player_names = []
        for mapping in pending_tournament.alias_to_id_map:
            if mapping["player_id"] == None:
                new_player_names.append(mapping["player_alias"])

        for player_name in new_player_names:
            player = Player.create_with_default_values(player_name, region)
            player_id = dao.insert_player(player)
            pending_tournament.set_alias_id_mapping(player_name, player_id)

        dao.update_pending_tournament(pending_tournament)

        try:
            tournament = Tournament.from_pending_tournament(pending_tournament)
            tournament_id = dao.insert_tournament(tournament)
            dao.delete_pending_tournament(pending_tournament)
            return {"success": True, "tournament_id": str(tournament_id)}
        except ValueError:
            return 'Not all player aliases in this pending tournament have been mapped to player ids.', 400
Ejemplo n.º 17
0
 def join_game(self):
     """
     Join game
     """
     response = self.send_message("/games/{0}/players?name={1}".format(
         self.gameid, self.name))
     player = Player(**response)
     self.uuid = player.uuid
Ejemplo n.º 18
0
    def test_create_with_default_values(self):
        name = 'ASDF'
        region = 'r'

        player = Player.create_with_default_values(name, region)
        self.assertEqual(player.name, name)
        self.assertEqual(player.aliases, ['asdf'])
        self.assertEqual(player.ratings, {})
        self.assertEqual(player.regions, [region])
Ejemplo n.º 19
0
    def test_create_with_default_values(self):
        name = 'ASDF'
        region = 'r'

        player = Player.create_with_default_values(name, region)
        self.assertEqual(player.name, name)
        self.assertEqual(player.aliases, ['asdf'])
        self.assertEqual(player.ratings, {})
        self.assertEqual(player.regions, [region])
Ejemplo n.º 20
0
    def prepare_game(self):
        maze_map = MazeMap(self.map_width, self.map_heigth, self.start_point, self.finish_point)
        maze_map.generate_maze()
        maze_map.populate_borders()

        player = Player(self.start_point, maze_map, self.player_vision)
        maze_map.place_player(player)
        self.prepared_map = maze_map
        self.set_up_player = player
        self.displayer = Displayer(self.prepared_map)
Ejemplo n.º 21
0
    def setUp(self):
        self.player_1_id = ObjectId()
        self.player_2_id = ObjectId()
        self.region_id = 'norcal'

        self.player_1 = Player(name='gaR',
                               aliases=['gar', 'garr'],
                               ratings={
                                   'norcal': Rating(),
                                   'texas': Rating()
                               },
                               id=self.player_1_id)
        self.player_2 = Player(name='sfat',
                               aliases=['sfat', 'miom | sfat'],
                               ratings={
                                   'norcal': Rating(),
                                   'socal': Rating()
                               },
                               id=self.player_2_id)
Ejemplo n.º 22
0
def create_game(
    players_info: dict,
    num_disasters: int,
    num_catastrophes: int,
    num_safe: int,
) -> Game:
    if num_safe < SHOP_SIZE:
        raise RuntimeError("At least the first shop must be safe")

    deck = []
    for room_id in ROOM_LIST:
        room = int(room_id)
        if room < THRONE_ROOM_ID_START:
            deck.append(room)
    random.shuffle(deck)
    safe = deck[:num_safe]
    deck = deck[num_safe:]
    disasters = []
    catastrophes = []
    for card in DISASTER_LIST:
        if card[0] == "d":
            disasters += [card]
        elif card[0] == "c":
            catastrophes += [card]
    deck += random.sample(disasters, num_disasters) + random.sample(
        catastrophes, num_catastrophes)
    random.shuffle(deck)
    deck = deck + safe
    shop = []
    while len(shop) < SHOP_SIZE:
        shop.append(deck.pop())
    players = {}
    for player_id in players_info:
        info = players_info[player_id]
        players[player_id] = Player(
            info["username"],
            int(info["throne_room_id"]),
            Castle(int(info["throne_room_id"])).to_json_obj(),
            [],
        )
    turn_order = [player_id for player_id in players_info]
    random.shuffle(turn_order)
    return Game(
        players,
        turn_order,
        0,
        shop,
        [],
        deck,
        num_disasters,
        num_catastrophes,
        [],
        [],
    )
Ejemplo n.º 23
0
 def handle(self):
     username = self.request.get("u")
     password = self.request.get("p")
     
     if not username or not password:
         return {"success": False , "error": "format"}
     
     same_name = Player.all().filter('username =', username)
     if same_name.get():
         return {"success": False , "error": "username"}
     
     
     player = Player(
         username=username, 
         password=hash_digest(password),
         counter = 0,
         elo = DEFAULT_ELO,
         searching=False, 
         match_server=None)
     player.put()
     return {"success": True}
Ejemplo n.º 24
0
  def post(self,game_id=None):
    user = users.get_current_user()
    game = Game.get_by_id(int(game_id))
    ## need to make a check to see if game exceeds max players
    game.players_current = game.players_current + 1
    player = Player(
            game_id = int(game_id),
            player_id = user.user_id(),
            name = self.request.get('player_name'),
            tokens = 1000,
            cards_not_visible = game.deck,
            )
    if not game.current_turn:
      game.current_turn = user.user_id()
      player.cards_visible = GameUpdater(game).deal_cards()

    player.put()
    game.players.append(player)

    game.put()
    self.redirect_to('table',game_id=game_id)
Ejemplo n.º 25
0
def get_captain_by_game_id(gid: str) -> Player:
    """
    The captain of the game
    """
    query = f"SELECT player.* FROM player " \
        f"INNER JOIN game ON game.id = player.gid " \
        f"WHERE game.id = '{gid}' AND player.id = game.captain_id"
    res = conn.execute(query).fetchone()

    if res:
        return Player(*res)
    else:
        return None
Ejemplo n.º 26
0
 def test_get_players_with_similar_alias_match_name(self):
     player = Player(name='ivanvan',
                     aliases=['asdf'],
                     ratings={
                         'norcal': Rating(),
                         'texas': Rating()
                     },
                     regions=['norcal', 'texas'],
                     id=ObjectId())
     self.norcal_dao.insert_player(player)
     self.assertEquals(
         self.norcal_dao.get_players_with_similar_alias('ivanvan'),
         [player])
Ejemplo n.º 27
0
def player_info():
    """Get player info and pass to new route"""
    player_name = request.args.get('name')
    password = request.args.get('password')
    if password == 'bruder2020':
        player = Player(player_name=player_name, password=password)
        db.session.add(player)
        db.session.commit()
        return redirect(url_for('player', name=player.player_name))
    if password == 'lizhost':
        return redirect(url_for('player', name='host'))
    else:
        return redirect('/')
Ejemplo n.º 28
0
    def setUp(self):
        self.player_1_id = ObjectId()
        self.player_1_name = 'gaR'
        self.player_1_aliases = ['gar', 'garr', 'garpr']
        self.player_1_rating = {
            'norcal': Rating(),
            'texas': Rating(mu=10., sigma=1.)
        }
        self.player_1_regions = ['norcal', 'texas']

        self.player_2_id = ObjectId()
        self.player_2_name = 'MIOM | SFAT'
        self.player_2_aliases = ['miom | sfat', 'sfat', 'miom|sfat']
        self.player_2_rating = {'norcal': Rating(mu=30., sigma=2.)}
        self.player_2_regions = ['norcal', 'socal']

        self.player_1 = Player(name=self.player_1_name,
                               aliases=self.player_1_aliases,
                               ratings=self.player_1_rating,
                               regions=self.player_1_regions,
                               id=self.player_1_id)
        self.player_1_missing_id = Player(name=self.player_1_name,
                                          aliases=self.player_1_aliases,
                                          ratings=self.player_1_rating,
                                          regions=self.player_1_regions)
        self.player_2 = Player(name=self.player_2_name,
                               aliases=self.player_2_aliases,
                               ratings=self.player_2_rating,
                               regions=self.player_2_regions,
                               id=self.player_2_id)

        self.player_1_json_dict = {
            '_id': self.player_1_id,
            'name': self.player_1_name,
            'aliases': self.player_1_aliases,
            'ratings': {region: rating.dump() for region, rating in self.player_1_rating.iteritems()},
            'regions': self.player_1_regions,
            'merge_children': [self.player_1_id],
            'merge_parent': None,
            'merged': False,
        }

        self.player_1_json_dict_missing_id = {
            'name': self.player_1_name,
            'aliases': self.player_1_aliases,
            'ratings': {region: rating.dump() for region, rating in self.player_1_rating.iteritems()},
            'regions': self.player_1_regions,
            'merge_children': [None],
            'merge_parent': None,
            'merged': False,
        }
Ejemplo n.º 29
0
def to_player(json_dict: dict) -> Player:
    """
    Converts json dictionary to Player object
    :param json_dict:
    :return:
    """
    if json_dict is None:
        return None

    result = Player(json_dict['name'], json_dict['position'],
                    json_dict['jerseyNumber'], json_dict['dateOfBirth'],
                    json_dict['nationality'], json_dict['contractUntil'],
                    json_dict['marketValue'])
    return result
Ejemplo n.º 30
0
def main():

    game_service = GameService()

    board_size = int(input('Please Enter board size: '))
    num_players = int(input('Please enter number of players: '))

    players_list = []
    for num in range(num_players):
        player_name = input(f'Please enter {num} player name: ')
        players_list.append(Player(player_name))

    game_service.initialize_board(board_size, players_list)
    game_service.play_game()
Ejemplo n.º 31
0
 def default_values(self):
   "Set some default values in the database"
   
   # Add some information
   box = hub.getConnection()
   t1 = Team(city='Pittsburgh', nickname='Ferrous Metals')
   box.memorize(t1)
   t2 = Team(city='Seattle', nickname='Seagulls')
   box.memorize(t2)
   p1 = Player(name='Bob Waffleburger', birthdate=datetime.date(1982,3,2), points=21)
   box.memorize(p1)
   p2 = Player(name='Mike Handleback', birthdate=datetime.date(1975,9,25), points=10)
   box.memorize(p2)
   p1.team = t1.ID
   p2.team = t2.ID
   
   # Add a default Page
   page = Page( pagename="FrontPage", data="This is the main page, please edit it." )
   box.memorize( page )
   
   # Setup identity data 
   jrodrigo = TG_User( user_name = "jrodrigo" )
   box.memorize( jrodrigo )
   jrodrigo.password = "******"
   
   root = TG_User( user_name = "root" )
   box.memorize( root )
   root.password = "******"
   
   user = TG_Group( group_name = "user" )
   box.memorize( user )
   
   admin = TG_Group( group_name = "admin" )
   box.memorize( admin )
   
   format = TG_Permission( permission_name = "format" )
   box.memorize( format )
   ls = TG_Permission( permission_name = "ls" )
   box.memorize( ls )
   cat = TG_Permission( permission_name = "cat" )
   box.memorize( cat )
   
   o = TG_UserGroup( user_id = root.user_id, group_id = user.group_id )
   box.memorize( o )
   o = TG_UserGroup( user_id = root.user_id, group_id = admin.group_id )
   box.memorize( o )
   o = TG_UserGroup( user_id = jrodrigo.user_id, group_id = user.group_id )
   box.memorize( o )
   
   o = TG_GroupPermission( group_id = admin.group_id, permission_id = format.permission_id )
   box.memorize( o )
   o = TG_GroupPermission( group_id = user.group_id, permission_id = ls.permission_id )
   box.memorize( o )
   o = TG_GroupPermission( group_id = user.group_id, permission_id = cat.permission_id )
   box.memorize( o )
   
   return "done"
Ejemplo n.º 32
0
 def handle(self):
     username = self.request.get("u")
     password = self.request.get("p")
     
     if not username or not password:
         return {"success": False , "error": "format"}
     
     player = Player.all().filter('username ='******'password', hash_digest(password)).get()
     if not player:
         return {"success": False , "error": "failed"}
     if not player.counter:
         player.counter = 0
     player.counter += 1
     player.put()
     return {"success": True}
Ejemplo n.º 33
0
    def __init__(self):
        self.roundsPlayed = 0
        playersPool = [ Player([], 1500, 0, "PLayer_unu"),
                         Player([], 1500, 1, "GigiKent"),
                         Player([], 1500, 2, "GGValuta"),
                         Player([], 1500, 3, "AmTalent"),
                         Player([], 1500, 4, "SefuLaBani"),
                         Player([], 1500, 5, "SerifIntergalactic"),
                         Player([], 1500, 6, "Bombardieru"),
                         Player([], 1500, 7, "Bo$$uLaPoker"),
                         Player([], 1500, 8, "DauGherle")]
        self.players = []
        for i in range(MAX_PLAYERS):
            self.players.append(playersPool[i])

        self.dealer = -1
        self.actingPlayer = -1
        self.firstToAct = -1
        self.blindIndex = 0
        self.state = GameState.InitRound
        self.waitingHumanInput = False
Ejemplo n.º 34
0
def add_player():
    """
    We create a player with his name and lastname if the request is in POST 

    if it's in GET it only shows the template
    """
    form = Form_add_players(request.form)
    if form.validate_on_submit():
        name_player = form.name_player.data
        lastname_player = form.last_name_player.data
        player = Player(name=name_player, lastname=lastname_player)
        db.session.add(player)
        db.session.commit()
        return redirect(url_for('.show_players'))
    else:
        return render_template("add_player.html", form=form)
Ejemplo n.º 35
0
 def load_data(self):
     """
     from namelist.csv load data, if encoding get wrong, try to change form ut8-sig to utf-8
     :return:
     """
     if not os.path.exists('namelist.csv'):
         msg = QMessageBox.question(self, "警告", "未找到namelist.csv",
                                    QMessageBox.Yes | QMessageBox.No,
                                    QMessageBox.No)  # 这里是固定格式,yes/no不能动
         return msg
     with open('namelist.csv', 'r') as f:
         lines = csv.reader(f)
         self.namelist = []
         for line in lines:
             # log(line)
             # log(len(line))
             if not (len(line) > 3 and line[-1] != ''):
                 self.namelist.append(Player(line[0], line[1], line[2]))
Ejemplo n.º 36
0
    def handle(self):
        username = self.request.get("u")
        if not username:
            return {"success": False, "error": "format"}

        player = Player.all().filter('username = ', username).get()
        if not player:
            return {"success": False, "error": "nonexisting"}
        
        if not player.match_server:
            return {"success": True, "host": None}
        
        server_host = player.match_server.host
        
        player.match_server = None
        player.put()
        
        return {"success": True, "host": server_host}
Ejemplo n.º 37
0
def pridobi_igralce():
    seznam = []
    nadaljuj = True
    while nadaljuj and len(seznam) < 9:
        print('Ali želite dodati igralca?')
        print('1) Da')
        print('2) Ne')
        odgovor = input('> ')
        if odgovor == '2':
            nadaljuj = False
        elif odgovor == '1':
            ime = input('Vpišite ime igralca: ')
            stack = pridobi_stack()
            seznam.append(Player(ime, stack))
        else:
            print('Neveljaven odgovor!')
            pass
    return seznam
Ejemplo n.º 38
0
def load_players():
    """Load players from u.player into database."""

    print("Players")

    # Player.query.delete()

    for row in open("seed_data/u.player"):
        row = row.rstrip()
        player_id, user_id, games_played, games_not_played = row.split("|")

        player = Player(player_id=player_id,
                        user_id=user_id,
                        games_played=games_played,
                        games_not_played=games_not_played)

        db.session.add(player)

    db.session.commit()
Ejemplo n.º 39
0
Archivo: car.py Proyecto: Tzeusy/RL_car
def create_player(load_weights=True, user_model=False):
    env = create_env()
    env.reset()

    # Get screen size so that we can initialize layers correctly based on shape
    # returned from AI gym. Typical dimensions at this point are close to 3x40x90
    # which is the result of a clamped and down-scaled render buffer in get_screen()
    init_screen = get_screen(env)
    _, n_channels, screen_height, screen_width = init_screen.shape  # 3, 40, 60

    if user_model:
        policy_net = DQNUser(screen_height, screen_width, n_actions,
                             KERNEL_SIZE, N_LAYERS).to(device)
        policy_net.eval()
        target_net = DQNUser(screen_height, screen_width, n_actions,
                             KERNEL_SIZE, N_LAYERS).to(device)
        target_net.eval()
    else:
        policy_net = DQN(screen_height, screen_width, n_actions).to(device)
        policy_net.eval()
        target_net = DQN(screen_height, screen_width, n_actions).to(device)
        target_net.eval()

    if load_weights:
        model_dir = "models"
        model_file_name = "mean100_659.pth"
        policy_net.load_state_dict(
            torch.load(f"{model_dir}/{model_file_name}", map_location='cpu'))
        target_net.load_state_dict(policy_net.state_dict())

    optimizer = optim.Adam(policy_net.parameters(),
                           lr=LEARNING_RATE,
                           weight_decay=1e-6)
    scheduler = optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.9999999)
    memory = ReplayMemory(REPLAY_MEM)
    fake_memory = ReplayMemory(REPLAY_MEM)

    player = Player(env, policy_net, target_net, optimizer, scheduler, memory,
                    fake_memory)
    return player
Ejemplo n.º 40
0
def record_game_completed():
    # Get game ID from game.html
    game_id = request.args.get('game_id')

    # Get user ID from session
    user_id = session['active_session']

    # Query to see if player and game are already in player database
    player_game_record = db.session.query(Player).filter(
        Player.user_id == user_id, Player.games_played == game_id).first()
    print(player_game_record)

    # If statement to add if record doesn't exist, flash message if already in database
    if player_game_record is None:
        alert_mssg = 'Congrats on solving this game!'

        record_game = Player(user_id=user_id, games_played=game_id)
        db.session.add(record_game)
        db.session.commit()
    else:
        alert_mssg = 'Congrats on solving this game again!'

    return jsonify(alert_mssg)
Ejemplo n.º 41
0
    def __init__(self, playerFile, exclusionFile):
        self.playerFile = playerFile
        self.exclusionFile = exclusionFile

        players = []
        exclusions = []

        # First name, Last name, Email
        for row in csv.reader(self.playerFile):
            assert len(row) == 3
            players.append(Player(*row))

        # Firstname lastname, Firstname lastname
        for row in csv.reader(self.exclusionFile):
            assert len(row) == 2
            g, r = row
            # Verify players
            gifterExclusion = (x for x in players if x.getname() == g).next()
            receiverExclusion = (x for x in players if x.getname() == r).next()

            exclusions.append((gifterExclusion, receiverExclusion))
        self.players = players
        self.exclusions = exclusions
Ejemplo n.º 42
0
def add_test_data():
    """
    添加测试用的数据
    此数据不一定准确,仅做测试用
    """
    session = connectToDatabase()

    match = Match()
    match.name = u"第14届世界杯跳水赛男子单人10米跳台"
    session.add(match)

    match = Match()
    match.name = u"全国跳水冠军赛男子10米跳台"
    session.add(match)

    match = Match()
    match.name = u"雅典奥运会男子10米跳台"
    session.add(match)

    player = Player()
    player.name = u"田亮"
    player.sex = u"Male"
    player.age = int(25)
    player.desc = u"中国重庆人,跳水运动员,演员。前陕西跳水队注册运动员。在2000年悉尼奥运会,获得男子10米跳台跳水冠军;2004年雅典奥运会,和杨景辉一起获得男子双人10米跳台跳水冠军,同时还获得个人季军。"
    session.add(player)

    player = Player()
    player.name = u"胡佳"
    player.sex = u"Male"
    player.age = int(24)
    player.desc = u"湖北武汉人,中国跳水运动员(代表广东汕头)。2004雅典奥运会获得男子10米跳台跳水冠军。"
    session.add(player)

    player = Player()
    player.name = u"孟非"
    player.sex = u"Male"
    player.age = int(35)
    player.desc = u"江苏卫视著名主持人,主持过的节目《南京零距离》、《绝对唱响》、《名师高徒》、《非诚勿扰》"
    session.add(player)


    player = Player()
    player.name = u"秦凯"
    player.sex = u"Male"
    player.age = int(25)
    player.desc = u"中国男子跳水运动员,陕西西安人。"
    session.add(player)

    player = Player()
    player.name = u"郭德纲"
    player.sex = u"Male"
    player.age = int(33)
    player.desc = u"相声"
    session.add(player)

    referee = Referee()
    referee.name = u"乐嘉"
    referee.sex = u"Male"
    referee.age = int(36)
    referee.desc = u"中国性格色彩研究中心创办人,FPA(Four-colors Personality Analysis) 性格色彩创始人,培训师,电视节目主持人。"
    session.add(referee)

    referee = Referee()
    referee.name = u"黄函"
    referee.sex = u"Female"
    referee.age = int(47)
    referee.desc = u"出生于1966年,南京大学。主要著作有《走进震撼的精神世界》、《现代领导方略》、《管理者成功心理学》、《沟通协调能力》等。"
    session.add(referee)

    referee = Referee()
    referee.name = u"八哥"
    referee.sex = u"Male"
    referee.age = int(22)
    referee.desc = u"黑客"
    session.add(referee)

    referee = Referee()
    referee.name = u"球球"
    referee.sex = u"Male"
    referee.age = int(23)
    referee.desc = u"NC"
    session.add(referee)

    referee = Referee()
    referee.name = u"孙翔"
    referee.sex = u"Male"
    referee.age = int(22)
    referee.desc = u"船长"
    session.add(referee)

    referee = Referee()
    referee.name = u"建州"
    referee.sex = u"Male"
    referee.age = int(24)
    referee.desc = u"倒贴型选手"
    session.add(referee)

    referee = Referee()
    referee.name = u"晓敏"
    referee.sex = u"Male"
    referee.age = int(22)
    referee.desc = u"肾不够用了"
    session.add(referee)

    referee = Referee()
    referee.name = u"建模"
    referee.sex = u"Male"
    referee.age = int(23)
    referee.desc = u"投手"
    session.add(referee)

    referee = Referee()
    referee.name = u"YOYO"
    referee.sex = u"Male"
    referee.age = int(22)
    referee.desc = u"校长"
    session.add(referee)

    session.commit()
    session.close()
Ejemplo n.º 43
0
            if user.is_dead():
                print("You have died")
                return enemy

#         # need to assign point value for each enemy

#         for x in Enemies_template:
#             self.enemy_list.append(Enemies(name=x["name"], points = x["points"]))
#             #gives the ability to define enemies


# counting_points = 0    #calculate game points

#                 counting_points += enemy.get_points() - damage.get_points()
#                 print(self.player.add_points(counting_points)) #player we declared to add game points


#             else:
#                 running = False

# c = Controller()
# c.game()
# #activate game
view = View()
view.backstory()
game = Game()
user = Player("test_user1", 30, 100)
enemy = Enemy("enemy", 10, 200)
user.pick_weapon()
game.fight(user, enemy)
Ejemplo n.º 44
0
 def test_load(self):
     self.assertEqual(self.player_1, Player.load(
         self.player_1_json_dict, context='db'))
Ejemplo n.º 45
0
class TestPlayer(unittest.TestCase):

    def setUp(self):
        self.player_1_id = ObjectId()
        self.player_1_name = 'gaR'
        self.player_1_aliases = ['gar', 'garr', 'garpr']
        self.player_1_rating = {
            'norcal': Rating(),
            'texas': Rating(mu=10., sigma=1.)
        }
        self.player_1_regions = ['norcal', 'texas']

        self.player_2_id = ObjectId()
        self.player_2_name = 'MIOM | SFAT'
        self.player_2_aliases = ['miom | sfat', 'sfat', 'miom|sfat']
        self.player_2_rating = {'norcal': Rating(mu=30., sigma=2.)}
        self.player_2_regions = ['norcal', 'socal']

        self.player_1 = Player(name=self.player_1_name,
                               aliases=self.player_1_aliases,
                               ratings=self.player_1_rating,
                               regions=self.player_1_regions,
                               id=self.player_1_id)
        self.player_1_missing_id = Player(name=self.player_1_name,
                                          aliases=self.player_1_aliases,
                                          ratings=self.player_1_rating,
                                          regions=self.player_1_regions)
        self.player_2 = Player(name=self.player_2_name,
                               aliases=self.player_2_aliases,
                               ratings=self.player_2_rating,
                               regions=self.player_2_regions,
                               id=self.player_2_id)

        self.player_1_json_dict = {
            '_id': self.player_1_id,
            'name': self.player_1_name,
            'aliases': self.player_1_aliases,
            'ratings': {region: rating.dump() for region, rating in self.player_1_rating.iteritems()},
            'regions': self.player_1_regions,
            'merge_children': [self.player_1_id],
            'merge_parent': None,
            'merged': False,
        }

        self.player_1_json_dict_missing_id = {
            'name': self.player_1_name,
            'aliases': self.player_1_aliases,
            'ratings': {region: rating.dump() for region, rating in self.player_1_rating.iteritems()},
            'regions': self.player_1_regions,
            'merge_children': [None],
            'merge_parent': None,
            'merged': False,
        }

    def test_create_with_default_values(self):
        name = 'ASDF'
        region = 'r'

        player = Player.create_with_default_values(name, region)
        self.assertEqual(player.name, name)
        self.assertEqual(player.aliases, ['asdf'])
        self.assertEqual(player.ratings, {})
        self.assertEqual(player.regions, [region])

    def test_dump(self):
        self.assertEqual(self.player_1.dump(
            context='db'), self.player_1_json_dict)

    def test_load(self):
        self.assertEqual(self.player_1, Player.load(
            self.player_1_json_dict, context='db'))