def draw_gems(self, gems: Bundle, player: Player = None):
"""Collect a given bundle of gems on behalf of the given player. Uses the current player if none is given."""
# Set the player if none is given.
if not player:
player = self.cur_player
# Check that it is allowed to take the given gems.
if player.gems.total() + gems.total() > MAX_GEM_HAND_SIZE:
raise InvalidMoveError(
'These gems will violate the handsize limit.')
if gems.total() == 2 and len(gems.distinct_gems()) == 1:
if self.gems.amount(gems.distinct_gems()[0]) < 4:
raise InvalidMoveError(
"Can't take 2 gems when there are less than 4 left in the supply."
)
elif gems.total() == 3:
if len(gems.distinct_gems()) != 3:
raise InvalidMoveError(
"Can't take three gems unless they are all different.")
elif gems.total() > 3:
raise InvalidMoveError(
f"Can't take a total of {gems.total()} gems.")
# If we get to here, the move is valid, unless there are not enough gems in the supply.
try:
self.gems.subtract_bundle(gems)
except ValueError:
raise InvalidMoveError(
"Can't take these gems as there are not enough left in the supply."
)
player.draw_gems(gems)
self.next_player()
def go_to_enemy(enemy):
player = Player()
# Set target, face it, run to it
player.set_target(enemy.address)
MovementEngine.run_to(enemy.position, tolerance=20)
def test_DeadPlayerTarget(self):
""" test to make sure a dead player can't be targetted """
player = self.player
player2 = Player()
player2.alive = False
with self.assertRaises(action.DeadPlayer):
status, response = player.play(action.Captain, player2)
def test_DeadPlayerTarget(self):
""" test to make sure a dead player can't be targetted """
player = self.player
player2 = Player()
player2.alive = False
with self.assertRaises(action.DeadPlayer):
status, response = player.play(action.Captain, player2)
def __init__(self, *player_data):
self.queue = Queue()
for player in player_data:
name = player[0]
list_of_games = player[1:]
player = Player(name)
player.add_games(list_of_games)
self.queue.add_player(player)
def main():
configs = json.load(open('config.json', 'r'))
if not os.path.exists(configs['model']['save_dir']):
os.makedirs(configs['model']['save_dir'])
data = DataLoader(os.path.join('data', configs['data']['filename']),
configs['data']['train_test_split'],
configs['data']['columns'])
model = Model()
model.build_model(configs)
x, y = data.get_train_data(seq_len=configs['data']['sequence_length'],
normalise=configs['data']['normalise'])
'''
# in-memory training
model.train(
x,
y,
epochs = configs['training']['epochs'],
batch_size = configs['training']['batch_size'],
save_dir = configs['model']['save_dir']
)
'''
# out-of memory generative training
steps_per_epoch = math.ceil(
(data.len_train - configs['data']['sequence_length']) /
configs['training']['batch_size'])
model.train_generator(data_gen=data.generate_train_batch(
seq_len=configs['data']['sequence_length'],
batch_size=configs['training']['batch_size'],
normalise=configs['data']['normalise']),
epochs=configs['training']['epochs'],
batch_size=configs['training']['batch_size'],
steps_per_epoch=steps_per_epoch,
save_dir=configs['model']['save_dir'])
x_test, y_test = data.get_test_data(
seq_len=configs['data']['sequence_length'],
normalise=configs['data']['normalise'])
#predictions = model.predict_sequences_multiple(x_test, configs['data']['sequence_length'], configs['data']['sequence_length'])
# predictions = model.predict_sequence_full(x_test, configs['data']['sequence_length'])
predictions = model.predict_point_by_point(x_test)
player = Player("Himanshu", 10000, 50, predictions, y_test)
player.bet()
#plot_results_multiple(predictions, y_test, configs['data']['sequence_length'])
plot_results(predictions, y_test)
def __init__(self, width=500, height=500):
pygame.init()
self.window = pygame.display.set_mode((width, height))
self.graphics_loop_running = False
self.game_running = False
self.bullets = []
self.player = Player(250, 250, 0, 0)
def __init__(self):
# initialize pygame and create window
pygame.init()
pygame.mixer.init()
pygame.display.set_caption("UAS Bahasa Pemrograman 1")
# Load all game graphics
self.background = pygame.image.load(path.join(img_dir,
"bg.png")).convert()
self.background_rect = self.background.get_rect()
player_img = pygame.image.load(path.join(img_dir,
"player.png")).convert()
meteor_img = pygame.image.load(path.join(img_dir,
"meteor.png")).convert()
BaseApp.all_sprites = pygame.sprite.Group()
self.enemies = pygame.sprite.Group()
self.player = Player(player_img)
BaseApp.all_sprites.add(self.player)
for i in range(8):
enemy = Enemy(meteor_img)
BaseApp.all_sprites.add(enemy)
self.enemies.add(enemy)
self.running = False
def execute(self):
player = Player()
for _ in self.skill_num_list:
skill_num = self.skill_num_list[self.executable] - 1
skill = player.skills[skill_num]
is_buff = skill.type == 0
has_enough_tp = player.parameters.tp >= skill.tp_cost
action_exists = skill.class_id != 0
# It resets to 0 in memory after hitting 100 lol
is_ready = not 0 < skill.ready_percent < 100
if not action_exists:
logger.debug('action #%d is missing from hotkeys, skipping',
skill_num + 1)
self._next_skill()
if (has_enough_tp or is_buff) and skill.in_range and is_ready:
KeyboardInput.key_press(str(skill_num + 1))
self._next_skill()
elif is_buff and not is_ready:
self._next_skill()
def main(_):
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.4)
with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess:
if cfg.env_type == 'simple':
env = SimpleGymEnvironment(cfg)
else:
env = GymEnvironment(cfg)
if not os.path.exists('/tmp/model_dir'):
os.mkdir('/tmp/model_dir')
player = Player(cfg, env, sess, '/tmp/model_dir')
player.play(load_model=False)
def __init__(self, parent, height, width):
super(TicTacWidget, self).__init__(parent)
game_board = GameBoard(height, width)
user = Player(interface_callback=self.user_input)
robot = AI()
user_choise = ChoosePlayerDialog()
user_choise.exec_()
player_1, player_2 = (user,
robot) if user_choise.first_player else (robot,
user)
self.tictac = TicTacToe(game_board,
player_1,
player_2,
show_callback=self.update_board_signal.emit)
self.update_board_signal.connect(self.update_game_status)
# a bit overhead for user input organization
self.user_input_wait_condition = QtCore.QWaitCondition()
self.user_input_wait_mutex = QtCore.QMutex()
self.user_input_data = None
self.initBoard()
self.game_loop()
def test_Assassin(self):
player = self.player
player2 = Player()
# test for no player having insufficient money
player.coins = 2
self.assertEqual(len(player2.influence), 2)
with self.assertRaises(action.NotEnoughCoins) as exc:
status, response = player.play(action.Assassin, player2)
self.assertEqual(exc.exception.coinsNeeded, 3)
self.assertEqual(len(player2.influence), 2)
self.assertEqual(player.coins, 2)
# test with sufficient money, no target
player.coins = 3
with self.assertRaises(action.TargetRequired):
status, response = player.play(action.Assassin)
self.assertEqual(len(player2.influence), 2)
# test with sufficient money against player with 2 influences
self.assertEqual(player.coins, 3)
status, response = player.play(action.Assassin, player2)
self.assertEqual(player.coins, 0)
self.assertEqual(len(player2.influence), 1)
# test with sufficient money against 1 influence and killing them
player.coins = 3
status, response = player.play(action.Assassin, player2)
self.assertEqual(player.coins, 0)
self.assertEqual(len(player2.influence), 0)
self.assertFalse(player2.alive)
def __init__(self, player_names: List[str] = None):
if player_names:
# Add players.
assert len(player_names) <= 2
self.turns = 0
self.player_names = player_names
self.players = [Player(name) for name in player_names]
self.cur_player_idx = 0
self.cur_player = self.players[self.cur_player_idx]
self.cur_player.my_turn = True
# Add gems.
self.gems = Bundle()
for gem in Gem:
self.gems.add_multiple(gem, GEM_COUNT)
# Add cards.
self.deck = {} # type: Dict[str, List[Card]]
for tier, cards in deepcopy(CARDS).items():
self.deck[tier] = cards
random.shuffle(self.deck[tier])
# Display cards.
self.display = [] # type: List[Card]
for _ in range(4):
for tier in self.deck:
self.display.append(self.deck[tier].pop())
self.display.sort()
def __generate_players(self, player_names: list) -> list:
if len(set(player_names)) != len(player_names):
raise ValueError(f'Duplicate player names found: {player_names}')
elif len(player_names) > self.__max_players:
raise ValueError(f'Too many players: {len(player_names)}. '
f'The maximum is: {self.__max_players}')
else:
return [Player(player_name) for player_name in player_names]
def test_Coup(self):
player = self.player
player2 = Player()
# test for no target
player.coins = 7
with self.assertRaises(action.TargetRequired):
status, response = player.play(action.Coup)
# test for no player having insufficient money
player.coins = 6
with self.assertRaises(action.NotEnoughCoins) as exc:
status, response = player.play(action.Coup, player2)
self.assertEqual(exc.exception.coinsNeeded, 7)
# test for targetting self
player.coins = 7
with self.assertRaises(action.TargetRequired):
status, response = player.play(action.Coup, player)
# test for succesful coup with opponent has 2 influence
player2.alive = True
player.coins = 7
status, response = player.play(action.Coup, player2)
self.assertTrue(status, response)
self.assertLess(player.coins, 7)
self.assertEqual(len(player2.influence), 1)
self.assertTrue(player2.alive)
# test for succesful coup with opponent has 1 influence
player2.alive = True
player.coins = 7
self.assertEqual(len(player2.influence), 1)
status, response = player.play(action.Coup, player2)
self.assertTrue(status, response)
self.assertLess(player.coins, 7)
self.assertEqual(len(player2.influence), 0)
self.assertFalse(player2.alive)
# test for coup against dead opponent
player2.alive = False
player.coins = 7
with self.assertRaises(action.DeadPlayer):
status, response = player.play(action.Coup, player2)
def __init__(self, config=None, audio=None, interrupt_check=lambda: False):
self.done = False
self.config = config
self.audio = audio
self.logger = logging.getLogger(__name__)
# tts实体
self.tts = tts.get_engine_by_slug(config['tts_engine'])(config)
self.player = Player(self.audio,tts=self.tts)
self.interrupt = interrupt_check
def test_Coup(self):
player = self.player
player2 = Player()
# test for no target
player.coins = 7
with self.assertRaises(action.TargetRequired):
status, response = player.play(action.Coup)
# test for no player having insufficient money
player.coins = 6
with self.assertRaises(action.NotEnoughCoins) as exc:
status, response = player.play(action.Coup, player2)
self.assertEqual(exc.exception.coinsNeeded, 7)
# test for targetting self
player.coins = 7
with self.assertRaises(action.TargetRequired):
status, response = player.play(action.Coup, player)
# test for succesful coup with opponent has 2 influence
player2.alive = True
player.coins = 7
status, response = player.play(action.Coup, player2)
self.assertTrue(status, response)
self.assertLess(player.coins, 7)
self.assertEqual(len(player2.influence), 1)
self.assertTrue(player2.alive)
# test for succesful coup with opponent has 1 influence
player2.alive = True
player.coins = 7
self.assertEqual(len(player2.influence), 1)
status, response = player.play(action.Coup, player2)
self.assertTrue(status, response)
self.assertLess(player.coins, 7)
self.assertEqual(len(player2.influence), 0)
self.assertFalse(player2.alive)
# test for coup against dead opponent
player2.alive = False
player.coins = 7
with self.assertRaises(action.DeadPlayer):
status, response = player.play(action.Coup, player2)
def generate_player():
for i in range(10):
# Defining players here
player_name = names_team[i]
player_skill = skill_team[i]
player = Player(player_name, player_skill)
# Defining champion for each player
champion_name = names_champions[i]
champion_skill = skill_champions[i]
champion = Champion(champion_name, champion_skill)
# Assigns the champion to the player
player.champion = champion
players.append(player)
for i in range(5):
players_team1.append(players[i])
players_team2.append(players[i + 5])
def run_to(destination, tolerance=3, key_up=True):
"""
Primitively runs a straight line (x,y)
"""
_validate_position(destination)
position = Player().position
MovementEngine._rotate(position, destination)
MovementEngine._run(position, destination, tolerance, key_up)
logger.debug('arrived')
def get_player(self, uid):
if not uid:
player = Player()
self.add_player(player)
else:
player = None
for p in self.players:
if p.uid == uid:
player = p
break
return player
def __init__(self):
super(Ui_Form, self).__init__()
self.file_manager = FileManager()
self.song_data = Song()
self.queue = Queue.Queue(maxsize=10)
self.player_core = Player(self.song_data, self.queue, self)
self.setupUi(self)
self.connectActions()
self.refreshSongList()
self.quit = False
self.wasPlaying = False
self.is_paused = False
self.totalTime = '00:00'
self.total_int_time = 0
self.update_tick_process_start = False
self.slider_in_pressed_value = 0 # seekslider first value
Thread(target=self.about_to_stop).start()
class TestPlayer(unittest.TestCase):
def setUp(self):
self.player = Player('Rafael', 2000.0)
self.card_one = Card('Q', 'spades')
self.card_two = Card('A', 'spades')
def test_repr(self):
expected = ("Player(name='Rafael', money=Decimal('2000'), "
"hand=Hand(cards=[]))")
self.assertEqual(repr(self.player), expected)
def test_points(self):
self.player.hand.append(self.card_one)
self.assertEqual(self.player.points, 10)
def test_one_card_on_hand_append(self):
self.player.hand.append(self.card_one)
self.assertEqual(str(self.player.hand), "1 card: Q spades")
def test_two_cards_on_hand_append(self):
self.player.hand.append(self.card_one)
self.player.hand.append(self.card_two)
self.assertEqual(str(self.player.hand), "2 cards: Q spades,A spades")
def test_show_money(self):
self.assertEqual(str(self.player.money), "2000")
def test_bet(self):
coin = self.player.bet(100)
self.assertEqual(self.player.money, 1900.0)
self.assertEqual(coin, 100)
def test_bet_invalid_coin(self):
with self.assertRaises(ValueError):
self.player.bet(200)
def test_len_hand(self):
self.player.hand.append(self.card_one)
self.player.hand.append(self.card_one)
self.assertEqual(len(self.player.hand), 2)
def run():
logger.debug('going to say hi to err1')
player = Player()
client = Client()
entity_list = client.get_entity_list()
original_coords = deepcopy(player.position)
for entity in entity_list:
MovementEngine.teleport_to(entity.position)
time.sleep(0.75)
MovementEngine.teleport_to(original_coords)
logger.debug('homie im hon')
class TestPlayer(unittest.TestCase):
def setUp(self):
self.player = Player('Rafael', 2000.0)
self.card_one = Card('Q', 'spades')
self.card_two = Card('A', 'spades')
def test_repr(self):
expected = ("Player(name='Rafael', money=Decimal('2000'), "
"hand=Hand(cards=[]))")
self.assertEqual(repr(self.player), expected)
def test_points(self):
self.player.hand.append(self.card_one)
self.assertEqual(self.player.points, 10)
def test_one_card_on_hand_append(self):
self.player.hand.append(self.card_one)
self.assertEqual(str(self.player.hand), "1 card: Q spades")
def test_two_cards_on_hand_append(self):
self.player.hand.append(self.card_one)
self.player.hand.append(self.card_two)
self.assertEqual(str(self.player.hand), "2 cards: Q spades,A spades")
def test_show_money(self):
self.assertEqual(str(self.player.money), "2000")
def test_bet(self):
coin = self.player.bet(100)
self.assertEqual(self.player.money, 1900.0)
self.assertEqual(coin, 100)
def test_bet_invalid_coin(self):
with self.assertRaises(ValueError):
self.player.bet(200)
def test_len_hand(self):
self.player.hand.append(self.card_one)
self.player.hand.append(self.card_one)
self.assertEqual(len(self.player.hand), 2)
def __init__(self, title, width, height, scale):
SDL_Init(SDL_INIT_VIDEO)
self.width = width
self.height = height
self.assets_manager = AssetsManager()
self.display = Display(title,
width,
height,
scale,
asset_manager=self.assets_manager)
self.keyboard = Keyboard()
self.get_assets()
self.level = Level('wall', self.GRID_SIZE)
self.player = Player(self, 'player', 160, 120)
self.background = BackGround('bg', self.GRID_SIZE, self.height,
self.width)
self.current_time = 0
class Game:
def __init__(self, objects):
self.objects = objects
self.player = Player(objects)
def start(self):
self.player.start()
def multiplayer_start(self):
Remote.events_init()
self.start()
self.remote_player = RemotePlayer(self.player.objects)
self.remote_player.start()
Remote.receiver.player = self.remote_player
def create_server(self):
self.server = Server()
Remote.set_instance(self.server)
def create_client(self, ip):
self.client = Client(ip)
Remote.set_instance(self.client)
def _onCreateButtonClicked(self):
if self.state == MainWindow.STATE_GAME_HALL_GAME_LIST or \
self.state == MainWindow.STATE_GAME_HALL_GAME_SELECTED:
self._setState(MainWindow.STATE_GAME_HALL_MAP_LIST)
elif self.state == MainWindow.STATE_GAME_HALL_MAP_SELECTED:
self.selectedGame = Game(
-1, Game.randomGameName(), self.selectedMap,
self.leftPanel.gameHallPanel.playerName.text())
self.selectedGame.addPlayer(
Player(-1, self.leftPanel.gameHallPanel.playerName.text()))
self.selectedGame.createGame()
self._setState(MainWindow.STATE_GAME_ROOM_WAITING)
else:
qFatal('Invalid state %d when create button clicked' % self.state)
def fight_enemy(enemy):
player = Player()
my_rotation = SkillRotation([4, 1, 2, 3])
while player.target:
logger.debug(
'%s @ %d/%d hp',
enemy.name,
enemy.parameters.current_hp,
enemy.parameters.max_hp
)
my_rotation.execute()
time.sleep(1)
def __init__(self, ):
self.board = Board()
self.players = [Player('0'), Player('1')]
self.turn = 0
self.songs = {
1: 'Birth',
2: 'Death',
3: 'Resistance',
4: 'Reign',
5: 'Ascent',
6: 'Tirany',
7: 'the Mysteries'
}
self.buildings = {
'Birth': ['Garden', 'House'],
'Death': [],
'Resistance': ['Thorn wall', 'Barracks'],
'Reign': ['Bridge'],
'Ascent': ['Harbor', 'Library', 'Statue'],
'Tirany': ['Prison', 'Rebel camp'],
'the Mysteries': ['Shrine']
}
self.setupFigures()
self.loosers = None
def test_Captain(self):
player = self.player
player2 = Player()
# test for no target
with self.assertRaises(action.TargetRequired):
status, response = player.play(action.Captain)
self.assertEqual(player.coins, 2)
self.assertEqual(player2.coins, 2)
# test for targeting self
with self.assertRaises(action.TargetRequired):
status, response = player.play(action.Captain, player)
# test for steal from player 2
player.play(action.Captain, player2)
self.assertEqual(player.coins, 4)
self.assertEqual(player2.coins, 0)
# test for steal with only one coin
player2.coins = 1
player.play(action.Captain, player2)
self.assertEqual(player.coins, 5)
self.assertEqual(player2.coins, 0)
def test_Captain(self):
player = self.player
player2 = Player()
# test for no target
with self.assertRaises(action.TargetRequired):
status, response = player.play(action.Captain)
self.assertEqual(player.coins, 2)
self.assertEqual(player2.coins, 2)
# test for targeting self
with self.assertRaises(action.TargetRequired):
status, response = player.play(action.Captain, player)
# test for steal from player 2
player.play(action.Captain, player2)
self.assertEqual(player.coins, 4)
self.assertEqual(player2.coins, 0)
# test for steal with only one coin
player2.coins = 1
player.play(action.Captain, player2)
self.assertEqual(player.coins, 5)
self.assertEqual(player2.coins, 0)
def index(request):
will = Player("Will")
will.add_games(["TicTacToe"])
jason = Player("Jason")
jason.add_games(["TicTacToe", "Poker"])
queue = Queue()
queue.add_players([will, jason])
games = ["TicTacToe", "Chess", "Poker"]
context = {'queue': queue, 'games': games}
return render(request, 'web/index.html', context)
def auth_reg(self):
email = self.get_argument('email')
account = self.db.get('SELECT * FROM account WHERE email="%s"', email)
if account:
raise tornado.web.HTTPError(400, "email already taken")
username = self.get_argument('username')
password = self.get_argument('password')
password = bcrypt.hashpw(password.encode('utf8'), bcrypt.gensalt())
uid = self.db.insert('INSERT INTO account (email, username, password) VALUES ("%s", "%s", "%s")',
email, username, password)
self.set_secure_cookie('uid', str(uid))
self.session.save(uid, Player(uid, username=username))
self.redirect(self.get_argument("next", "/"))
class PlayerTests(unittest.TestCase):
def setUp(self):
self.TicTacToe = "TicTacToe"
self.Chess = "Chess"
self.player = Player("John")
def test_player_knows_what_games_have_been_added(self):
self.player.add_games([self.TicTacToe])
self.assertItemsEqual([self.TicTacToe], self.player.games)
def test_when_a_game_is_added_others_arent_overwritten(self):
self.player.add_games([self.TicTacToe])
self.player.add_games([self.Chess])
self.assertItemsEqual([self.TicTacToe, self.Chess], self.player.games)
def test_cannot_add_duplicate_games(self):
self.player.add_games([self.TicTacToe])
self.player.add_games([self.TicTacToe])
self.assertSetEqual(set([self.TicTacToe]), self.player.games)
def get_nearest_enemy():
player = Player()
client = Client()
# Exclude mobs this much higher/lower than you
MAX_LVL = 1
MIN_LVL = 2
# Gets all entities loaded in memory, <= 63
entity_list = client.get_entity_list()
min_dist = float('inf')
nearest_enemy = None
for entity in entity_list:
# Skip dead ones
if not entity.parameters.current_hp:
continue
# if entity.level < player.level - MIN_LVL:
# continue
if entity.level > player.level + MAX_LVL:
continue
distance = None
try:
distance = MovementEngine.get_2d_distance(
player.position, entity.position
)
except Exception:
import ipdb; ipdb.set_trace()
if distance < min_dist:
nearest_enemy = entity
min_dist = distance
assert nearest_enemy, 'Found no enemies :"('
logger.info(
'Nearest enemy: Lvl. %d %s, Address: %s',
nearest_enemy.level,
nearest_enemy.name,
hex(nearest_enemy.address)
)
return nearest_enemy
def buy_card(self, card: Card, player: Player = None):
"""Buy a card on behalf of the given player. Uses the current player if none is given."""
# Set the player if none is given.
if not player:
player = self.cur_player
# Check that the card is available for purchase.
if card not in self.display:
raise InvalidMoveError('This card is not available to be bought.')
# Buy the card for the player, if possible.
try:
self.gems.add_bundle(player.buy_card(card))
except ValueError:
raise InvalidMoveError('Player cannot afford this card.')
self.remove_card(card)
self.next_player()
def record_waypoints(step=100, duration=10000):
"""
Records a waypoint every step (ms) for duration (ms)
"""
waypoints = []
player = Player()
start_time = time.time()
while time.time() - start_time < duration / 1000:
logger.debug('recording waypoint... %r', player.position)
waypoints.append(deepcopy(player.position))
time.sleep(step / 1000.0)
logger.debug('stop moving!')
time.sleep(2)
return waypoints
def save_location(name):
position = Player().position
with open(YAML_FILE, 'a+') as file:
yaml_data = yaml.load(file)
if not yaml_data:
yaml_data = {
'fake_map_name': []
}
yaml_data['fake_map_name'].append({
'name': name,
'x': position.x,
'y': position.y,
'z': position.z
})
with open(YAML_FILE, 'w') as file:
logger.debug('saved %s', name)
yaml.dump(yaml_data, file, default_flow_style=False)
def __init__(self):
super(Ui_Form, self).__init__()
self.file_manager = FileManager()
self.song_data = Song()
self.queue = Queue.Queue(maxsize=10)
self.player_core = Player(self.song_data, self.queue, self)
self.setupUi(self)
self.connectActions()
self.refreshSongList()
self.quit = False
self.wasPlaying = False
self.is_paused = False
self.totalTime = '00:00'
self.total_int_time = 0
self.update_tick_process_start = False
self.slider_in_pressed_value = 0 # seekslider first value
Thread(target=self.about_to_stop).start()
def open(self):
self.player = Player(10, 'Jerry', self)
self.player.room = RoomManager.find_room(0, True)
logger.info('SOCKET[%s] OPEN', self.player.uid)
class SocketHandler(WebSocketHandler):
def __init__(self, application, request, **kwargs):
super().__init__(application, request, **kwargs)
self.db: torndb.Connection = self.application.db
self.player: Player = None
def data_received(self, chunk):
logger.info('socket data_received')
@property
def uid(self):
return self.player.uid
@property
def room(self):
return self.player.room
def open(self):
self.player = Player(10, 'Jerry', self)
self.player.room = RoomManager.find_room(0, True)
logger.info('SOCKET[%s] OPEN', self.player.uid)
def on_message(self, message):
packet = msgpack.unpackb(message, use_list=False)
# packet = json.loads(message)
logger.info('REQ[%d]: %s', self.uid, packet)
code = packet[0]
if code == Pt.REQ_LOGIN:
response = [Pt.RSP_LOGIN, self.player.uid, self.player.name]
self.write_message(response)
elif code == Pt.REQ_ROOM_LIST:
response = [Pt.RSP_ROOM_LIST]
self.write_message(response)
elif code == Pt.REQ_TABLE_LIST:
response = [Pt.RSP_TABLE_LIST, self.room.tables()]
self.write_message(response)
elif code == Pt.REQ_JOIN_TABLE:
table_id = packet[1]
table = self.find_table(table_id)
if not table:
response = [Pt.RSP_TABLE_LIST, self.room.tables()]
self.write_message(response)
logger.info('PLAYER[%d] JOIN FULL TABLE[%d]', self.uid, table.uid)
self.player.join_table(table)
logger.info('PLAYER[%s] JOIN TABLE[%d]', self.uid, table.uid)
table.sync_table()
if table.size() == 3:
table.deal_poker()
logger.info('TABLE[%s] GAME BEGIN[%s]', table.uid, table.players)
del self.room.waiting_tables[table.uid]
self.room.playing_tables[table.uid] = table
elif code == Pt.REQ_CALL_SCORE:
self.handle_call_score(packet)
elif code == Pt.REQ_DEAL_POKER:
if self.player.table.state == 2:
self.player.ready = True
self.player.table.ready()
elif code == Pt.REQ_SHOT_POKER:
self.handle_shot_poker(packet)
elif code == Pt.REQ_CHAT:
self.handle_chat(packet)
else:
logger.info('UNKNOWN PACKET: %s', code)
@shot_turn
def handle_call_score(self, packet):
score = packet[1]
self.player.handle_call_score(score)
@shot_turn
def handle_shot_poker(self, packet):
pokers = packet[1]
self.player.handle_shot_poker(pokers)
def find_table(self, table_id):
if table_id == -1: # fast join
return self.room.first_waiting_table()
return self.room.find_waiting_table(table_id)
def handle_chat(self, packet):
if self.player and self.player.table:
self.player.table.handle_chat(self.player, packet[1])
def write_message(self, message, binary=False):
if self.ws_connection is None:
raise WebSocketClosedError()
# packet = msgpack.packb(message)
logger.info('RSP[%d]: %s', self.uid, message)
packet = json.dumps(message)
return self.ws_connection.write_message(packet, binary=binary)
def on_close(self):
# self.session.get(self.uid).socket = None
logger.info('socket[%s] close', self.player.uid)
if self.player:
self.player.leave_table()
def send_updates(cls, chat):
logger.info('sending message to %d waiters', len(cls.waiters))
for waiter in cls.waiters:
waiter.write_message('tornado:' + chat)
def setUp(self):
self.player = Player('Rafael', 2000.0)
self.card_one = Card('Q', 'spades')
self.card_two = Card('A', 'spades')
def setUp(self):
self.TicTacToe = "TicTacToe"
self.Chess = "Chess"
self.player = Player("John")
class Game:
def __init__(self, width=500, height=500):
pygame.init()
self.window = pygame.display.set_mode((width, height))
self.graphics_loop_running = False
self.game_running = False
self.bullets = []
self.player = Player(250, 250, 0, 0)
def quit(self):
while self.graphics_loop_running:
pass
pygame.quit()
def play(self):
gu_thread = Thread(target=self.graphics_update_loop)
self.game_running = True
gu_thread.start()
while self.game_running:
event = pygame.event.wait()
if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
self.shoot(event.pos)
elif event.type == pygame.KEYDOWN:
if event.key == 119: # W
self.player.w_down = True
elif event.key == 97: # A
self.player.a_down = True
elif event.key == 115: # S
self.player.s_down = True
elif event.key == 100: # D
self.player.d_down = True
else:
print(event)
elif event.type == pygame.KEYUP:
if event.key == 119: # W
self.player.w_down = False
elif event.key == 97: # A
self.player.a_down = False
elif event.key == 115: # S
self.player.s_down = False
elif event.key == 100: # D
self.player.d_down = False
else:
print(event)
elif event.type == pygame.QUIT:
self.game_running = False
#else:
#print(event)
self.quit()
def shoot(self, pos):
self.bullets.append(Bullet(self.player, pos[0], pos[1], 1, 360))
def tick(self):
cleanup = []
for bullet in self.bullets:
bullet.tick()
if bullet.needs_cleanup:
cleanup.append(bullet)
self.player.tick()
for bullet in cleanup:
self.bullets.remove(bullet)
def graphics_update_loop(self):
seconds_per_frame = 1/30
next_update = clock() + seconds_per_frame
self.graphics_loop_running = True
while self.game_running:
while clock() < next_update:
pass
self.tick()
self.update()
next_update += seconds_per_frame
self.graphics_loop_running = False
def update(self):
self.window.fill((0,0,0))
baseLight = Note(1) * 500000
for bullet in self.bullets:
dist = self.player.distance(bullet)
if dist == 0:
light = 255
else:
light = min(255, (baseLight / (dist ** 2)).notes[1])
pygame.draw.circle(self.window, (light,light,light), bullet.position, 0, 0)
pygame.draw.circle(self.window, (255,0,0), self.player.position, 3, 0)
pygame.display.flip()
def __init__(self, CardToPick):
self.CardToPick = CardToPick
Player.__init__(self)
def __init__(self, position, Order):
self.position = position
self.Order = Order
Player.__init__(self)
def __init__(self, CardUsedToBlock):
self.CardUsedToBlock = CardUsedToBlock
Player.__init__(self)
from core.player import Player
from core.deck import Deck
if __name__ == "__main__":
p = Player('Vinicius')
d = Deck()
p.hit(d.deck)
print(p.hand.cards[0].rank)
def create_player(self, games=[], name="John"):
player = Player(name)
player.games = games
return player
from core.player import Player
if __name__ == "__main__":
player = Player()
player.run()
class Ui_Form(QtGui.QMainWindow):
def __init__(self):
super(Ui_Form, self).__init__()
self.file_manager = FileManager()
self.song_data = Song()
self.queue = Queue.Queue(maxsize=10)
self.player_core = Player(self.song_data, self.queue, self)
self.setupUi(self)
self.connectActions()
self.refreshSongList()
self.quit = False
self.wasPlaying = False
self.is_paused = False
self.totalTime = '00:00'
self.total_int_time = 0
self.update_tick_process_start = False
self.slider_in_pressed_value = 0 # seekslider first value
Thread(target=self.about_to_stop).start()
def closeEvent(self, *args, **kwargs):
# catch exit sinal and stop the subprocess
self.queue.put(None)
if self.wasPlaying:
self.wasPlaying = False
self.stopSong()
self.freePlayer()
self.quit = True
super(Ui_Form, self).closeEvent(*args, **kwargs)
def keyPressEvent(self, event):
key = event.key()
print key
# if key == QtCore.Qt.Key_Left:
# print('Left Arrow Pressed')
# 连接鼠标Action
def connectActions(self):
QtCore.QObject.connect(
self.playButton,
QtCore.SIGNAL('clicked()'),
self.playSong)
QtCore.QObject.connect(
self.stopButton,
QtCore.SIGNAL('clicked()'),
self.stopSong)
QtCore.QObject.connect(
self.addFilesButton,
QtCore.SIGNAL('clicked()'),
self.addFiles)
QtCore.QObject.connect(
self.delFilesButton,
QtCore.SIGNAL('clicked()'),
self.delFiles)
QtCore.QObject.connect(
self.nextButton,
QtCore.SIGNAL('clicked()'),
self.nextSong)
QtCore.QObject.connect(
self.previousButton,
QtCore.SIGNAL('clicked()'),
self.previousSong)
QtCore.QObject.connect(
self.seekSlider,
QtCore.SIGNAL('sliderPressed()'),
self.slider_pressed)
QtCore.QObject.connect(
self.seekSlider,
QtCore.SIGNAL('sliderReleased()'),
self.slider_released)
QtCore.QObject.connect(
self.volumeSlider,
QtCore.SIGNAL('sliderReleased()'),
self.volume_slider_released)
QtCore.QObject.connect(
self.volumeSlider,
QtCore.SIGNAL('valueChanged(int)'),
self.volume_slider_released)
# 连接DEL按钮
QtCore.QObject.connect(
(QtGui.QShortcut(
QtGui.QKeySequence( QtCore.Qt.Key_Delete), self.listWidget)), QtCore.SIGNAL('activated()'),
self.delFiles)
self.listWidget.mouseDoubleClickEvent = self.doubleSelectSong
def doubleSelectSong(self, a):
self.wasPlaying = False
song_id = unicode(self.listWidget.selectedItems()[
0].text()).split('#')[0].strip()
self.songSelected(song_id)
# 通过list选择歌曲
def songSelected(self, song_id):
self.player_core.double_select_song(
self.song_data.get_song_by_id(song_id).path)
self.getTotalTime()
self.updateMetaInfo()
self.wasPlaying = True
self.buttonChange(self.wasPlaying)
self.set_update_tick_sub_process()
def set_list_widget_selected(self, song_id):
for item in self.iter_all_list_items():
if str(song_id) in unicode(item[1].text()):
self.listWidget.setCurrentRow(item[0])
break
def iter_all_list_items(self):
for i in range(self.listWidget.count()):
yield i, self.listWidget.item(i)
def addFiles(self):
files = QtGui.QFileDialog.getOpenFileNames(
self, "Please select songs", "", self.tr("Song Files(*.*)"))
new = []
for file in files:
print unicode(file)
new.append(unicode(file).encode('utf-8'))
self.file_manager.add_files(new)
self.refreshSongList()
def delFiles(self):
selectedItems = self.listWidget.selectedItems()
if selectedItems:
ids = [int(unicode(s.text()).split('#')[0]) for s in selectedItems]
if self.song_data.current_song_id in ids:
self.stopSong()
self.file_manager.del_files(ids)
self.refreshSongList()
else:
warning = QtGui.QMessageBox(self)
warning.setWindowTitle('Warning!')
warning.setText('NO ITEM SELECTED!')
warning.show()
def buttonChange(self, playState):
if playState:
self.playButton.setStyleSheet(
_fromUtf8("border-image: url(:/btn/btn_pause.png);"))
self.playButton.clicked.disconnect()
QtCore.QObject.connect(
self.playButton,
QtCore.SIGNAL('clicked()'),
self.pauseSong)
else:
self.playButton.setStyleSheet(
_fromUtf8("border-image: url(:/btn/btn_play.png);"))
self.playButton.clicked.disconnect()
QtCore.QObject.connect(
self.playButton,
QtCore.SIGNAL('clicked()'),
self.playSong)
def set_update_tick_sub_process(self):
if not self.update_tick_process_start:
Thread(target=self.updateTick).start()
self.update_tick_process_start = True
def playSong(self):
if not self.wasPlaying and self.is_paused:
self.is_paused = False
self.player_core.pause()
self.wasPlaying = True
self.buttonChange(self.wasPlaying)
return
else:
self.player_core.play()
self.getTotalTime()
self.updateMetaInfo()
self.set_list_widget_selected(self.song_data.current_song_id)
self.wasPlaying = True
self.set_update_tick_sub_process()
self.buttonChange(self.wasPlaying)
def pauseSong(self):
self.wasPlaying = False
self.is_paused = True
self.player_core.pause()
self.buttonChange(self.wasPlaying)
def stopSong(self):
self.wasPlaying = False
self.is_paused = False
self.player_core.stop()
self.totalTime = '00:00'
self.buttonChange(self.wasPlaying)
self.setLabelText(1, True)
def freePlayer(self):
self.player_core.free_player()
def nextSong(self):
self.is_paused = False
self.wasPlaying = False
self.player_core.next()
self.getTotalTime()
self.updateMetaInfo()
self.set_list_widget_selected(self.song_data.current_song_id)
self.wasPlaying = True
self.buttonChange(self.wasPlaying)
self.set_update_tick_sub_process()
def previousSong(self):
self.is_paused = False
self.wasPlaying = False
self.player_core.previous()
self.getTotalTime()
self.updateMetaInfo()
self.set_list_widget_selected(self.song_data.current_song_id)
self.wasPlaying = True
self.buttonChange(self.wasPlaying)
self.set_update_tick_sub_process()
def slider_pressed(self):
self.slider_in_pressed_value = self.seekSlider.value()
def slider_released(self):
seek_time = (self.seekSlider.value() -
self.slider_in_pressed_value) * self.total_int_time / 100
if seek_time != 0:
self.player_core.seek(seek_time)
def volume_slider_released(self):
vol = self.volumeSlider.value()
if vol == 99:
vol = 100
self.volumeDisplayLabel.setText(_fromUtf8(str(vol)))
self.player_core.set_volume(vol)
def setLabelText(self, text, default=True):
if default:
self.label.setText(
_translate(
"Form",
"QPlayer\nAuthor：MarcoQin <*****@*****.**>",
None))
else:
self.label.setText(text)
def updateMetaInfo(self):
info = self.file_info
tp = ('album', 'artist', 'genre', 'title')
if not info['title']:
info['title'] = info['name'].split('.')[0]
if not info['genre']:
info['genre'] = 'ACG'
string = '\n'.join(
'{0}: {1}'.format(
k,
v.encode('utf-8')) for k,
v in info.items() if k in tp)
string = QtCore.QString.fromUtf8(string)
self.setLabelText(string, False)
# 设置播放器时间
def getTotalTime(self):
print 'get_total time'
self.file_info = self.player_core.file_info
t = self.file_info['length']
print t
int_t = int(float(t))
m, s = divmod(int(float(t)), 60)
if m < 10:
m = '0{0}'.format(m)
if s < 10:
s = '0{0}'.format(s)
t = '{0}:{1}'.format(m, s)
self.totalTime = t
self.total_int_time = int_t
def about_to_stop(self):
while True:
if self.quit:
break
cmd = self.queue.get()
print "self.queue.get(): ", cmd
if not cmd:
break
if cmd:
self.wasPlaying = False
self.is_paused = False
event = self.nextButton.click()
try:
QtGui.QApplication.sendEvent(event)
except Exception:
pass
def updateTick(self):
while True:
try:
if self.quit:
self.update_tick_process_start = False
break
if not self.wasPlaying and not self.is_paused:
time.sleep(1)
continue
songTime = int(self.player_core.time_pos)
self.total_int_time = self.player_core.total_length
persent = (songTime * 1.0 / self.total_int_time) * 100
m, s = divmod(songTime, 60)
if m < 10:
m = '0{0}'.format(m)
if s < 10:
s = '0{0}'.format(s)
songTime = '{0}:{1}'.format(m, s)
m, s = divmod(int(self.total_int_time), 60)
if m < 10:
m = '0{0}'.format(m)
if s < 10:
s = '0{0}'.format(s)
t = '{0}:{1}'.format(m, s)
self.totalTime = t
tick = songTime + '/' + self.totalTime
self.lcdNumber.display(tick)
self.seekSlider.setValue(persent)
time.sleep(1)
except Exception as e:
print e
time.sleep(1)
continue
def refreshSongList(self):
self.listWidget.clear()
song_data = self.song_data.get_all_songs()
for song in song_data:
self.listWidget.addItem(u'{0}# {1}'.format(song.id, song.name))
def setupUi(self, Form):
Form.setObjectName(_fromUtf8("Form"))
Form.resize(337, 475)
Form.setMinimumSize(QtCore.QSize(337, 475))
Form.setMaximumSize(QtCore.QSize(337, 475))
# 用“#name{语句}来限定form的背景，不会改变form上的别的widget的背景。
Form.setStyleSheet(
_fromUtf8("#Form{background-image: url(:/bg/bg2.jpg)}"))
self.gridLayoutWidget = QtGui.QWidget(Form)
self.gridLayoutWidget.setGeometry(QtCore.QRect(20, 127, 301, 41))
self.gridLayoutWidget.setObjectName(_fromUtf8("gridLayoutWidget"))
self.gridLayout_3 = QtGui.QGridLayout(self.gridLayoutWidget)
self.gridLayout_3.setMargin(0)
self.gridLayout_3.setObjectName(_fromUtf8("gridLayout_3"))
self.lcdNumber = QtGui.QLCDNumber(self.gridLayoutWidget)
self.lcdNumber.setFrameShadow(QtGui.QFrame.Plain)
self.lcdNumber.setLineWidth(1)
self.lcdNumber.setSmallDecimalPoint(False)
self.lcdNumber.setNumDigits(11)
self.lcdNumber.setObjectName(_fromUtf8("lcdNumber"))
self.gridLayout_3.addWidget(self.lcdNumber, 0, 5, 1, 1)
self.stopButton = QtGui.QPushButton(self.gridLayoutWidget)
self.stopButton.setMinimumSize(QtCore.QSize(35, 35))
self.stopButton.setMaximumSize(QtCore.QSize(35, 35))
self.stopButton.setStyleSheet(
_fromUtf8("border-image: url(:/btn/btn_stop.png);"))
self.stopButton.setText(_fromUtf8(""))
self.stopButton.setIconSize(QtCore.QSize(35, 35))
self.stopButton.setObjectName(_fromUtf8("stopButton"))
self.gridLayout_3.addWidget(self.stopButton, 0, 1, 1, 1)
self.playButton = QtGui.QPushButton(self.gridLayoutWidget)
self.playButton.setMinimumSize(QtCore.QSize(35, 35))
self.playButton.setMaximumSize(QtCore.QSize(35, 35))
self.playButton.setBaseSize(QtCore.QSize(35, 35))
self.playButton.setWhatsThis(_fromUtf8(""))
self.playButton.setStyleSheet(
_fromUtf8("border-image: url(:/btn/btn_play.png);"))
self.playButton.setText(_fromUtf8(""))
self.playButton.setObjectName(_fromUtf8("playButton"))
self.gridLayout_3.addWidget(self.playButton, 0, 0, 1, 1)
self.nextButton = QtGui.QPushButton(self.gridLayoutWidget)
self.nextButton.setMinimumSize(QtCore.QSize(35, 35))
self.nextButton.setMaximumSize(QtCore.QSize(35, 35))
self.nextButton.setStyleSheet(
_fromUtf8("border-image: url(:/btn/btn_next.png);"))
self.nextButton.setText(_fromUtf8(""))
self.nextButton.setObjectName(_fromUtf8("nextButton"))
self.gridLayout_3.addWidget(self.nextButton, 0, 3, 1, 1)
self.previousButton = QtGui.QPushButton(self.gridLayoutWidget)
self.previousButton.setMinimumSize(QtCore.QSize(35, 35))
self.previousButton.setMaximumSize(QtCore.QSize(35, 35))
self.previousButton.setStyleSheet( _fromUtf8("border-image: url(:/btn/btn_previous.png);"))
self.previousButton.setText(_fromUtf8(""))
self.previousButton.setIconSize(QtCore.QSize(35, 35))
self.previousButton.setObjectName(_fromUtf8("previousButton"))
self.gridLayout_3.addWidget(self.previousButton, 0, 2, 1, 1)
self.seekSlider = QtGui.QSlider(QtCore.Qt.Horizontal, self)
self.seekSlider.setGeometry(QtCore.QRect(20, 181, 301, 20))
font = QtGui.QFont()
font.setBold(False)
font.setWeight(50)
self.seekSlider.setFont(font)
self.seekSlider.setMouseTracking(False)
self.seekSlider.setAutoFillBackground(False)
self.seekSlider.setObjectName(_fromUtf8("seekSlider"))
# self.seekSlider.setEnabled(False)
self.horizontalLayoutWidget = QtGui.QWidget(Form)
self.horizontalLayoutWidget.setGeometry(QtCore.QRect(20, 419, 301, 41))
self.horizontalLayoutWidget.setObjectName(
_fromUtf8("horizontalLayoutWidget"))
self.horizontalLayout = QtGui.QHBoxLayout(self.horizontalLayoutWidget)
self.horizontalLayout.setMargin(0)
self.horizontalLayout.setObjectName(_fromUtf8("horizontalLayout"))
self.volumeLabel = QtGui.QLabel(self.horizontalLayoutWidget)
self.volumeLabel.setMinimumSize(QtCore.QSize(20, 20))
self.volumeLabel.setMaximumSize(QtCore.QSize(20, 20))
self.volumeLabel.setText(_fromUtf8("vol"))
self.volumeLabel.setObjectName(_fromUtf8("volumeLabel"))
self.horizontalLayout.addWidget(self.volumeLabel)
self.volumeSlider= QtGui.QSlider(QtCore.Qt.Horizontal, self)
self.volumeSlider.setMaximumWidth(100)
font = QtGui.QFont()
font.setBold(False)
font.setWeight(50)
self.volumeSlider.setFont(font)
self.volumeSlider.setMouseTracking(False)
self.volumeSlider.setAutoFillBackground(False)
self.volumeSlider.setObjectName(_fromUtf8("volumeSlider"))
self.horizontalLayout.addWidget(self.volumeSlider)
self.volumeSlider.setValue(100)
self.volumeDisplayLabel = QtGui.QLabel(self.horizontalLayoutWidget)
self.volumeDisplayLabel.setMinimumSize(QtCore.QSize(40, 20))
self.volumeDisplayLabel.setMaximumSize(QtCore.QSize(40, 20))
self.volumeDisplayLabel.setText(_fromUtf8("100"))
self.volumeDisplayLabel.setObjectName(_fromUtf8("volumeDisplayLabel"))
self.horizontalLayout.addWidget(self.volumeDisplayLabel)
self.addFilesButton = QtGui.QPushButton(self.horizontalLayoutWidget)
self.addFilesButton.setMinimumSize(QtCore.QSize(35, 35))
self.addFilesButton.setMaximumSize(QtCore.QSize(35, 35))
self.addFilesButton.setStyleSheet(
_fromUtf8("border-image: url(:/btn/btn_add.png);"))
self.addFilesButton.setText(_fromUtf8(""))
self.addFilesButton.setObjectName(_fromUtf8("addFilesButton"))
self.horizontalLayout.addWidget(self.addFilesButton)
self.delFilesButton = QtGui.QPushButton(self.horizontalLayoutWidget)
self.delFilesButton.setMinimumSize(QtCore.QSize(35, 35))
self.delFilesButton.setMaximumSize(QtCore.QSize(35, 35))
self.delFilesButton.setStyleSheet(
_fromUtf8("border-image: url(:/btn/btn_del.png);"))
self.delFilesButton.setText(_fromUtf8(""))
self.delFilesButton.setObjectName(_fromUtf8("delFilesButton"))
self.horizontalLayout.addWidget(self.delFilesButton)
self.listWidget = QtGui.QListWidget(Form)
self.listWidget.setGeometry(QtCore.QRect(20, 213, 301, 192))
self.listWidget.setStyleSheet(
_fromUtf8(
"background-color: rgb(189, 213, 231);\n"
"background-color: qlineargradient(spread:reflect, x1:0.358, y1:0.880682, x2:1, y2:0, stop:0.244318 rgba(125, 178, 236, 255), stop:1 rgba(255, 255, 255, 255));"))
self.listWidget.setObjectName(_fromUtf8("listWidget"))
self.listWidget.setSelectionMode(
QtGui.QAbstractItemView.ExtendedSelection) # 设置多选模式，用于多文件删除
self.label = QtGui.QLabel(Form)
self.label.setGeometry(QtCore.QRect(20, 10, 301, 110))
self.label.setAutoFillBackground(False)
self.label.setStyleSheet(
_fromUtf8(
"border-image: url(:/bg/lable.png);\n"
"background-image: url(:/bg/bg.png);"))
self.label.setFrameShadow(QtGui.QFrame.Plain)
self.label.setLineWidth(1)
self.label.setTextFormat(QtCore.Qt.AutoText)
self.label.setAlignment(QtCore.Qt.AlignCenter)
self.label.setObjectName(_fromUtf8("label"))
self.retranslateUi(Form)
QtCore.QMetaObject.connectSlotsByName(Form)
def retranslateUi(self, Form):
Form.setWindowTitle(_translate("Form", "QPlayer", None))
self.label.setText(
_translate(
"Form",
"QPlayer\nAuthor：MarcoQin <*****@*****.**>",
None))
def hide_ui(self):
items = [
'label',
'listWidget',
'delFilesButton',
'addFilesButton',
'neteasePlayListButton',
'normalPlayListButton',
'seekSlider',
'previousButton',
'nextButton',
'playButton',
'stopButton',
'lcdNumber',
'horizontalLayoutWidget']
self.setMaximumSize(QtCore.QSize(1280, 720))
self.setMinimumSize(QtCore.QSize(1280, 720))
self.resize(640, 480)
for item in items:
getattr(self, item).hide()
