Exemplo n.º 1
0
 def __fetch_players_list_thread(self):
     # fetch players list from remote server
     players = ServerCom.fetch_players()
     if players.__len__() > 0:
         PlayerData.setPlayers(players)
     self.__updatenum_players()
     # generate missing player names
     for player in players:
         SoundManager.create_player_sound(player)
Exemplo n.º 2
0
 def on_enter(self):
     self.all_players = PlayerData.get_players()
     self.elo_ranges = PlayerData.get_ranges()
     Clock.schedule_once(lambda dt: self.__setup_player_dropdown(), 0.2)
     self.current_player_slot = 0
     
     for (i, val) in enumerate(self.players):
         for p in self.all_players:
             if p['id'] == self.players[i].get('id', 0):
                 self.players[i] = p
Exemplo n.º 3
0
 def __handle_rfid(self, rfid):
     self.current_rfid = rfid
     SoundManager.play(Trigger.RFID)
     # RFID --> player ID
     player_id = PlayerData.get_player_by_rfid(rfid)
     # player ID --> player dict
     player = PlayerData.get_player_by_id(player_id)
     if player:
         time.sleep(0.5)
         self.current_player = player
     else:
         self.current_player = {}
Exemplo n.º 4
0
def main():
    # Init display & clock
    display = pygame.display.set_mode((800, 600), DOUBLEBUF)
    pygame.display.set_caption("Infinity Swarm")

    gem_list = ["amber", "amethyst", "emerald", "ruby", "sapphire", "topaz"]
    display_icon = pygame.transform.scale(
        pygame.image.load("assets/materials/" + random.choice(gem_list) +
                          ".png"), (64, 64))
    pygame.display.set_icon(display_icon)
    clock = pygame.time.Clock()

    # Player data holder
    player_data = PlayerData("Player")

    # Init screens
    screen_main = layouts.ScreenMain(display, player_data)
    screen_levelinfo = layouts.ScreenLevelInfo(display)
    screen_game = layouts.ScreenGame(display, player_data)

    current_screen = "main"
    screens = {
        "main": screen_main,
        "levelinfo": screen_levelinfo,
        "game": screen_game
    }

    frame = 0
    loop = True
    while loop:
        caught_events = pygame.event.get()
        for event in caught_events:
            if event.type == pygame.QUIT:
                loop = False
                break

        frame = (frame + 1) % 60

        if frame % 5 == 0:
            player_data.ccps_tick(12)

        cur_screen = screens[current_screen]
        upd_rects = cur_screen.update(caught_events)

        screen_switch = cur_screen.get_switch_screen()
        if screen_switch:
            current_screen = screen_switch
            screens[current_screen].init_screen(cur_screen)

        pygame.display.update(upd_rects)
        clock.tick(60)
Exemplo n.º 5
0
 def __handle_rfid(self, rfid):
     # RFID --> player ID
     player_id = PlayerData.get_player_by_rfid(rfid)
     # player ID --> player dict
     player = PlayerData.get_player_by_id(player_id)
     Logger.info('ScoreTracker: RFID: {0} - ID: {1} - Player: {2}'.format(rfid, player_id, player))
     # player does not exist
     if player == None:
         self.denied()
     # player does exist
     else:
         if self.dropdown_player:
             self.dropdown_player.dismiss()
         self.set_player(player)
Exemplo n.º 6
0
 def __submit_score_thread(self):
     # submit score to remote server
     (error, elo) = ServerCom.submit_score(self.players, GameData.get_score())
     if error is None:
         self.submit_success = True
         self.__set_elo(elo)
         # fetch ranking
         ranking_attacker = ServerCom.fetch_ranking('attacker')
         if ranking_attacker:
             PlayerData.set_ranking('attacker', ranking_attacker)
         ranking_defender = ServerCom.fetch_ranking('defender')
         if ranking_defender:
             PlayerData.set_ranking('defender', ranking_defender)
     else:
         self.submit_success = False
Exemplo n.º 7
0
    def __fetch_data(self, dt):
        cmd = 'wpa_cli status | egrep "(wpa_state|id_str|ip_address)"'
        proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, close_fds=True)
        output = proc.communicate()[0]
        entries = {}
        for line in output.splitlines():
            line = line.strip()
            if '=' in line:
                (key, value) = line.split('=')
                entries[key] = value

        self.state = entries.get('wpa_state', 'DISCONNECTED')
        self.ip_address = entries.get('ip_address', '')
        self.id_str = entries.get('id_str', '')

        connected = (self.state == 'COMPLETED' and self.ip_address != '')
        if connected != self.connected:
            self.connected = connected
            if self.connected:
                try:
                    player_id = int(self.id_str)
                    self.player = PlayerData.get_player_by_id(player_id)
                except Exception, e:
                    print e
                    self.player = None
            else:
                self.player = None

            self.say_connection_status()

            # notify all registered clients
            for cb_function in self.callbacks:
                cb_function(self.get_data())
Exemplo n.º 8
0
    def __setup_player_dropdown(self):
        self.dropdown_player = DropDown()
        self.dropdown_player.bind(on_select=self.on_player_select)

        players = sorted(PlayerData.get_players(), key=lambda player: player['name'])
        for player in players:
            btn = PlayerButton(data=player)
            btn.bind(on_release=lambda btn: self.dropdown_player.select(btn.data))
            self.dropdown_player.add_widget(btn)
Exemplo n.º 9
0
    def __setup_player_dropdown(self):
        # only create if not existing
        if not self.dropdown_player:
            self.dropdown_player = DropDown(auto_dismiss=False)
            self.dropdown_player.bind(on_select=self.on_player_select)
            self.dropdown_player.bind(on_dismiss=self.on_dropdown_dismiss)

            players = sorted(PlayerData.get_players(), key=lambda player: player['name'])
            for player in players:
                btn = PlayerButton(data=player)
                btn.bind(on_release=lambda btn: self.dropdown_player.select(btn.data))
                self.dropdown_player.add_widget(btn)
Exemplo n.º 10
0
class EvaluatingApp(App):
    pdata = ObjectProperty(PlayerData())

    def build(self):
        '''kivy's app init point'''
        self.build_root()
        self.build_data()
        self.show_prepare()

    def build_root(self):
        self.build_scene(self.root.scene)

    def build_scene(self, scene):
        Builder.load_file('prepare.kv')
        Builder.load_file('result.kv')

        scene.prepare = self.build_prepare()
        scene.lwin    = self.build_result(self.pdata.lwin)
        scene.draw    = self.build_result(self.pdata.draw)
        scene.rwin    = self.build_result(self.pdata.rwin)

    def build_prepare(self):
        prepare = PrepareScene() 
        prepare.build()
        prepare.associate(self.pdata)
        return prepare

    def build_result(self, ratefunc):
        result = ResultScene()
        result.build()
        result.associate(self.pdata, ratefunc)
        return result

    def build_data(self):
        players = self.pdata.players 
        cteam   = self.pdata.cteam
        for name in PLAYERS:
            players[name] = (MEAN, STDDEV)
            cteam.append(name)

    def show_prepare(self):
        self.root.show_prepare()
Exemplo n.º 11
0
 def __fetch_players_list_thread(self):
     # fetch players list from remote server
     players = ServerCom.fetch_players()
     if players:
         PlayerData.set_players(players)
     self.__updatenum_players()
     # generate missing player names
     for player in players:
         SoundManager.create_player_sound(player)
     # fetch ranking
     ranking_attacker = ServerCom.fetch_ranking('attacker')
     if ranking_attacker:
         PlayerData.set_ranking('attacker', ranking_attacker)
     ranking_defender = ServerCom.fetch_ranking('defender')
     if ranking_defender:
         PlayerData.set_ranking('defender', ranking_defender)
Exemplo n.º 12
0
            filter(PlayerGameStat.create_dt > cutoff_dt).\
            filter(Player.nick != None).\
            filter(Player.player_id > 2).\
            filter(Player.active_ind == True).\
            limit(NUM_PLAYERS).all()
else:
    players = DBSession.query(distinct(Player.player_id)).\
            filter(Player.player_id == PlayerElo.player_id).\
            filter(Player.player_id == PlayerGameStat.player_id).\
            filter(PlayerGameStat.create_dt > cutoff_dt).\
            filter(Player.nick != None).\
            filter(Player.player_id > 2).\
            filter(Player.active_ind == True).\
            all()

playerdata = PlayerData()

if len(players) > 0:
    stop = datetime.now()
    td = stop-start
    print "Query took %.2f seconds" % (datetime_seconds(td))

    print "Creating badges for %d players ..." % len(players)
    start = datetime.now()
    data_time, render_time = 0,0
    for player_id in players:
        req.matchdict['id'] = player_id

        sstart = datetime.now()
        playerdata.get_data(player_id)
        sstop = datetime.now()
Exemplo n.º 13
0
 def add_entry(self):
     PlayerData.add_rfid(self.current_rfid, self.current_player.get('id'))
     self.__reset()
Exemplo n.º 14
0
 def on_current_player(self, instance, value):
     self.ids.btnPlayer.iconText = self.current_player.get('name', u'---')
     SoundManager.play(Trigger.PLAYER_SELECTED, self.current_player)
     # enable "accept" button if current player is set and was not stored before
     self.ids.btnAccept.disabled = not (self.current_player.has_key('id') and self.current_player.get('id') != PlayerData.get_rfid_map().get(self.current_rfid))
Exemplo n.º 15
0
            filter(PlayerGameStat.create_dt > cutoff_dt).\
            filter(Player.nick != None).\
            filter(Player.player_id > 2).\
            filter(Player.active_ind == True).\
            limit(NUM_PLAYERS).all()
else:
    players = DBSession.query(distinct(Player.player_id)).\
            filter(Player.player_id == PlayerElo.player_id).\
            filter(Player.player_id == PlayerGameStat.player_id).\
            filter(PlayerGameStat.create_dt > cutoff_dt).\
            filter(Player.nick != None).\
            filter(Player.player_id > 2).\
            filter(Player.active_ind == True).\
            all()

playerdata = PlayerData()

if len(players) > 0:
    stop = datetime.now()
    td = stop - start
    print "Query took %.2f seconds" % (datetime_seconds(td))

    print "Creating badges for %d players ..." % len(players)
    start = datetime.now()
    data_time, render_time = 0, 0
    for player_id in players:
        req.matchdict['id'] = player_id

        sstart = datetime.now()
        playerdata.get_data(player_id)
        sstop = datetime.now()
Exemplo n.º 16
0
 def on_current_rfid(self, instance, value):
     # enable "remove" button if rfid mapping exists
     self.ids.btnClear.disabled = not PlayerData.get_rfid_map().has_key(self.current_rfid)
     # disable player selection box if no RFID is set
     self.ids.btnPlayer.disabled = not self.current_rfid
     self.teaching = True if self.current_rfid else False
Exemplo n.º 17
0
 def __updatenum_players(self):
     self.num_players = PlayerData.get_players().__len__()
Exemplo n.º 18
0
 def remove_entry(self):
     PlayerData.remove_rfid(self.current_rfid)
     self.__reset()