def __init__(self, agent, end_score=10):
self.agent = agent
self.score1 = 0
self.score2 = 0
self.end_score = end_score
pygame.init()
self.screen = pygame.display.set_mode([SCREEN_WIDTH, SCREEN_HEIGHT])
pygame.display.set_caption('Pong')
pygame.mouse.set_visible(1)
self.font = pygame.font.Font(None, 36)
self.background = pygame.Surface(self.screen.get_size())
self.ball = Ball(WHITE)
self.balls = pygame.sprite.Group()
self.balls.add(self.ball)
self.player_bottom = Player(580, PLAYER_WIDTH, WHITE)
self.player_top = Player(25, PLAYER_WIDTH, WHITE)
self.movingsprites = pygame.sprite.Group()
self.movingsprites.add(self.player_bottom)
self.movingsprites.add(self.player_top)
self.movingsprites.add(self.ball)
self.clock = pygame.time.Clock()
def handle_client_connected_message(self, msg):
player = Player(msg.clientid,
msg.clientaddress,
msg.clientport,
login_server=self)
player.set_state(UnauthenticatedState)
self.players[msg.clientid] = player
def __init__(self):
super(Game, self).__init__()
# the game neighborhood
self.neighborhood = Neighborhood()
# the game player
self.player = Player()
# current player location row
self.current_row = 0
# current player location column
self.current_col = 0
# current home the player is in
self.current_home = self.neighborhood.get_homes()[self.current_row][
self.current_col]
# total monster population
self.total_num_monsters = self.count_monsters()
# total people population
self.total_num_people = 0
# game over status
self.game_over = 0
def __init__(self, player_one: Player = None, player_two: Player = None, verbose: bool = True) -> None:
self._move_counter = 0
self._board = Board(MAX_ROWS, MAX_COLUMNS)
self._players = (
player_one if player_one is not None else Player(
SIGN_PLAYER_ONE, 'magenta'),
player_two if player_two is not None else Player(
SIGN_PLAYER_TWO, 'cyan')
)
self._verbose = verbose
def execute(self):
if not Utils.has_internet():
player = Player()
player.play_local()
else:
if Alarm.serverHandler is not None:
Alarm.serverHandler.emit(RequestHandler('music:discovering'))
if not self.repeat:
self.enable = False
Alarm.serverHandler.emit(RequestHandler('alarm:update', {"alarm": {"_id": self._id, "update": {"enable": False}}}))
def handle(self, *args):
arg = args[0] if args else ''
if not arg:
if self.player and self.player.is_paused:
self.player.play()
return self.INDENT + colorize(
Colors.BLUE,
'\u25B6 ' + self.client.active_station['name'])
self.stdout_print(self.INDENT +
colorize(Colors.GRAY, 'Pick random genre...'))
arg = random.choice(
[genre.get('title', '') for genre in self.client.genres])
genre = self.client.search_genre(arg)
genre_id = genre.get('id') if genre else None
if genre_id is None:
return self.INDENT + colorize(Colors.RED,
'Genre ') + arg + colorize(
Colors.RED, ' not found.')
self.stdout_print(self.INDENT + colorize(Colors.GREEN, 'Tuning in...'))
self.stdout_print(self.INDENT +
colorize(Colors.GREEN, 'Starting genre: ') +
genre.get('title', ''))
num_of_tries = 0
while num_of_tries < 3:
num_of_tries += 1
stream = self.client.get_stream(genre_id,
renew_active_station=True)
if not stream:
return self.INDENT + colorize(
Colors.RED,
'No active stations found... Please, try another genre.')
if self.player:
self.player.stop()
self.player = Player(stream)
self.player.play()
num_of_checks = 0
while num_of_checks < 5:
num_of_checks += 1
time.sleep(1)
if self.player.is_playing:
return self.INDENT + colorize(
Colors.BLUE,
'\u25B6 ' + self.client.active_station['name'])
return self.INDENT + colorize(
Colors.RED,
'No active stations found... Please, try another genre.')
def __init__(self):
pg.init()
pg.mouse.set_cursor(*CURSOR)
self._camera = Camera()
self._hotbar = Hotbar()
self._world = World()
self._main_player = Player("main_player",
spawn_pos=PLAYER_DEFAULT_SPAWN_POS)
self._action = GameAction.play
def on_new_level(self):
# Physics stuff
self.space = pymunk.Space()
self.space.gravity = Vec2d(0.0, -1200.0)
self.player = Player(x=100,
y=600,
group=self.background,
space=self.space,
game=self)
self.window.push_handlers(self.player.key_handler)
self.current_level().create(self.space, self.background)
def editPlayer(self, player_info):
''' Replaces given player with the player specified '''
if player_info.get('id', None):
player_info['player_id'] = player_info['id']
player_info.pop('id')
player_info = Player(**player_info)
player_info: Player
player_info = player_info.to_specified_db_format(Player.PLAYER_UPDATE_FORMAT)
p_dao = PlayerDAO()
player_result = PlayerDAO().edit(player_info)
if player_result:
return player_result
else:
return None
def _build_force(self, ship_type, amount, playr, attack_mode):
playr = Player(name=playr, planetary=Planetary(playr))
flt = fleet.Fleet(owner=playr)
ships = []
for i in range(amount):
ships.append(ship.Ship(**ship.TYPES[ship_type]))
playr.add_ships(ships, 0)
flt.assign_ships(ships)
flt.set_attack_mode(attack_mode)
frc = force.Force(flt)
frc._player = playr
return frc
def add_player(self, address, username):
self.address_player[address] = Player(username)
send_message(self.address_player[address].get_pokemon_info(), address,
self.sock)
self.pokemon_count[address], message = self.address_player[
address].get_number_of_each_pokemon()
send_message(message, address, self.sock)
def execute(self):
player1 = Player(Alliance.RED, PlayerType.HUMAN, name="Dia")
player2 = Player(Alliance.YELLOW, PlayerType.COMPUTER)
SelectDifficultyCommand().execute()
gm = GameManager(player1, player2)
care_taker = Caretaker(gm)
winner = None
while not gm.game_over and not gm.draw:
self.__print_format_table(gm)
move = gm.state.next_player.get_move
if isinstance(move, str):
UndoCommand(gm, care_taker).execute()
care_taker.backup()
winner = self.__handle_move(move, gm, care_taker)
self.__print_format_game_over(gm, winner)
def _build_force(self, ship_type, amount, playr, attack_mode):
playr = Player(name=playr, planetary=Planetary(playr))
flt = fleet.Fleet(owner=playr)
ships = []
for i in range(amount):
ships.append(ship.Ship(**ship.TYPES[ship_type]))
playr.add_ships(ships, 0)
flt.assign_ships(ships)
flt.set_attack_mode(attack_mode)
frc = force.Force(flt)
frc._player = playr
return frc
def __init__(self, redis_client):
self.redis = redis_client
self.games = []
self.user = User()
self.player = Player()
GameManagerParsing(self.redis).start()
GameManagerInitGame(self.redis, self.user).start()
def __init__(self):
self.state = GameState.State.NEW_GAME
self.Player = Player()
self.Labyrinth = Labyrinth()
self.TextData = TextData()
self.Player.current_location = self.Labyrinth.find_start_room().id
print(self.Player.current_location)
def setup(self):
#O jogo se inicia pausado, afim de faciliar para o jogador na hora da passagem de fase, dando a opção de lançar a bola.
self.jogo_pausado = True
#Para que a bola permaneça pausada no inicio de cada fase, colocamos esse atributo especifico para essa tarefa.
self.pausa_bola = 0
#Aqui se encontram as listas do jogo, onde ficarão os sprites.
self.lista_bola = arcade.SpriteList()
self.lista_blocos = arcade.SpriteList()
self.lista_power_up = arcade.SpriteList()
self.lista_jogador = arcade.SpriteList()
self.lista_jogador2 = arcade.SpriteList()
#O aleatorio_powerup é um atributo que determinara os power_ups aleatoriamentes, quando um bloco power_up for quebrado.
self.aleatorio_powerup = 0
#Ambos os contadores de colisao_paredes servem para garantir que a bola não saia do campo de visão do jogador.
self.contador_colisao_paredes_vertical = 0
self.contador_colisao_paredes_horizontal = 0
#O bloco delay serve para amenizar o contato da bola com os blocos, afim de que minimize os bugs de colisão.
self.bloco_delay = -1
#Para pôr tempo nos power_ups escolhemos manualmente fazer os contadores, sendo o contador_tempo o tempo total do power_up
#e o contador variador o qual ira zerar o tempo do powerup. Temos dois de cada, pois há a opção de dois players.
self.contador_tempo_power_up_1 = 600
self.contador_variador_1 = 0
self.contador_tempo_power_up_2 = 600
self.contador_variador_2 = 0
#A função run serve para realizar ações dependendo do estado do jogo.
self.run(self.estado_jogo)
#Se o modo de jogo for 1, ira ser posto apenas 1 player, se for dois, dois players.
if self.modo_de_jogo == 1:
self.lista_jogador.append(
Player('jogo/player/imagens/barra_normal.png', 1, 8,
arcade.key.LEFT, arcade.key.RIGHT, LARGURA_TELA / 2,
64))
if self.modo_de_jogo == 2:
self.lista_jogador.append(
Player('jogo/player/imagens/barra_normal.png', 1, 8,
arcade.key.LEFT, arcade.key.RIGHT, 64, 64))
self.lista_jogador2.append(
Player('jogo/player/imagens/barra_normal.png', 1, 8,
arcade.key.A, arcade.key.D, LARGURA_TELA - 64, 64))
#Se o jogo não estiver no menu,game_over,tela de ajuda, ou tela final haverá a bola no jogo.
if self.estado_jogo != MENU and self.estado_jogo != GAME_OVER and self.estado_jogo != AJUDA and self.estado_jogo != TELA_FINAL:
for player in self.lista_jogador:
self.lista_bola.append(
Bola(player.center_x + player.width / 4, 96))
break
#Cada nova fase ira iniciar com 3 vidas.
self.set_vida(3)
def setup(self):
game_object.add(Background())
generate_map("assets/maps/map.json")
player = Player(35 * 16, 27 * 16, global_input_manager)
game_object.add(player)
create_enemy.create_enemy()
create_gift.create_gift()
create_coin.create_coin()
def build_player(self, settings_dict, game_env):
player = Player(game_env, settings_dict['AGENT_HISTORY_LENGTH'], settings_dict['MEMORY_SIZE'],
settings_dict['BS'],
settings_dict['LEARNING_RATE'], settings_dict['INI_EPSILON'], settings_dict['END_EPSILON'],
settings_dict['MIN_OBSERVE_EPISODE'], settings_dict['NETW_UPDATE_FREQ'],
settings_dict['UPDATE_FREQ'], settings_dict['DISCOUNT_FACTOR'],
settings_dict['REPLAY_MEMORY_START_SIZE'], settings_dict['PUNISH'],
settings_dict['REWARD_EXTRAPOLATION_EXPONENT'], settings_dict['LINEAR_EXPLORATION_EXPONENT'],
settings_dict['USE_DOUBLE_MODEL'])
return player
def __init__(self, height, width, difficulty):
self.height = height
self.width = width
self.window = curses.newwin(self.height, self.width, 0, 0)
self.sky_height = round(self.height // 2.7)
self.water_height = round(self.height // 2.1)
self.beach_height = self.height // 6
self.sky = Sky(self.window.subwin(self.sky_height, self.width, 0, 0))
self.water = Water(self.window.subwin(self.water_height, self.width, self.sky_height, 0))
self.beach = Beach(self.window.subwin(self.beach_height, self.width, self.sky_height+self.water_height, 0))
self.difficulty = ['easy', 'medium', 'hard'][difficulty]
self.obstacles = Obstacles(self.water, self.difficulty)
self.player = Player(self.water)
# self.score = 0
self.connect()
def fim_powerup(self):
for player in self.lista_jogador:
if self.contador_tempo_power_up_1 < 0:
self.lista_jogador.append(
Player('jogo/player/imagens/barra_normal.png', 1, 8,
arcade.key.LEFT, arcade.key.RIGHT, player.center_x,
64))
player.kill()
self.contador_variador_1 = 0
self.contador_tempo_power_up_1 = 600
for player in self.lista_jogador2:
if self.contador_tempo_power_up_2 < 0:
self.lista_jogador2.append(
Player('jogo/player/imagens/barra_normal.png', 1, 8,
arcade.key.A, arcade.key.D, player.center_x, 64))
player.kill()
self.contador_variador_2 = 0
self.contador_tempo_power_up_2 = 600
def registerPlayer(self, playerDescription):
if self.getPlayer(playerDescription.name) is None:
if len(self.playerRegister) < 8:
position = len(self.playerRegister)
self.playerRegister.append(
Player(playerDescription.name, position))
else:
raise ValueError('Players are already registerd')
else:
raise ValueError('Player already registered')
def get_players(self):
car_img = pg.image.load('graphics/car.png')
player_list = []
for i in range(self.NUM_PLAYERS):
x_min = i * DISPLAY_WIDTH / self.NUM_PLAYERS
x_max = (i + 1) * DISPLAY_WIDTH / self.NUM_PLAYERS - 1 # -1 cause its inclusive and we want it exclusive
car = Car(x_min, x_max, 8, car_img)
player = Player(i, LIVES, car, KEYS[i]['left'], KEYS[i]['right'])
player_list.append(player)
return player_list
def test_messages_0(self):
player = Player("PlayerA")
player.sends("A")
# First test count.
self.assertEqual(1, player.messages_count(), "1 message")
# Now test message contents.
self.assertEqual(["A"], player.messages)
player.sends("B")
# First test count.
self.assertEqual(2, player.messages_count(), "2 messages")
# Now test message contents.
self.assertEqual(["A", "B"], player.messages)
player.sends("C")
# First test count.
self.assertEqual(3, player.messages_count(), "3 messages")
# Now test message contents.
self.assertEqual(["A", "B", "C"], player.messages)
def __init__(self):
super().__init__()
w = int(self.screen.get_width() / 1.7)
h = convert.scale_h([5504, 3808], w)
x = int(self.screen.get_width() / 2 - w / 2)
y = int(self.screen.get_height() / 2 - h / 2)
self.platform_rect = [x, y, w, h]
self.player = Player(
self.screen,
[self.platform_rect[0], self.platform_rect[1], 25, 25],
self.platform_rect,
150,
name='player',
save_entity=False)
self.inventory = Inventory()
self.inventory_display = InventoryDisplay(self.screen, [self.player])
self.inventory_open = False
def do_startup(self):
Gtk.Application.do_startup(self)
self.settings = Settings(self)
self.discoverer = Discoverer()
self.player = Player(self)
self.equalizer = Equalizer(self)
self.queue = Queue(self)
self.history = History(self)
self.integration = Integration(self)
self.win = MainWindow(self)
def add_player(self, address, user_name):
self.ip_players[address] = Player(user_name)
while True:
x = randint(0, self.world_size)
y = randint(0, self.world_size)
if self.world_map[x][y] == 0 and self.is_player_not_in_location(
(x, y)):
self.player_locations[address] = (x, y)
break
send_message(address=address,
sock=self.sock,
message=self.player_status(address))
def test_deaths_0(self):
player = Player("PlayerA")
player.dies("A")
self.assertEqual(1, player.died_count(), "1 death")
self.assertEqual(["A"], player.deaths)
player.dies("B")
self.assertEqual(2, player.died_count(), "2 deaths")
self.assertEqual(["A", "B"], player.deaths)
def setup(self):
player = Player(50, 400)
game_object.add(player)
game_event = GameEvent()
game_object.add(game_event)
# background = Background(640, 320)
# game_object.game_objects.insert(0, background)
for i in range(22):
platform2 = Platform(32 + i * 64, 650)
game_object.add(platform2)
class TestPlayer(unittest.TestCase):
def setUp(self):
self.gmap = GameMap(db = DataMap(), input_map = {(-1, -1):1, (-1, 0):1, (-1, 1): 1,
(0, -1): 2, (0, 0): 0, (0, 1): 0,
(1, -1): 1, (1, 0): 0, (1, 1): 1})
self.player = Player(local_map = self.gmap)
def tearDown(self):
pass
def testSetLocationIfOpen(self):
loc = (1, 0)
self.player.set_location(loc)
self.assertEqual(self.player.location, loc)
def testMoveSuccess(self):
p = self.player
dir = "e"
p.move(dir)
self.assertEqual(self.player.location, (1, 0))
def testMoveFail(self):
p = self.player
dir = "w"
p.move(dir)
self.assertEqual(self.player.location, (0, 0))
def testDigSuccess(self):
p = self.player
dir = "d"
p.dig(dir)
self.assertEqual(self.player.location, (0, -1))
self.assertEqual(self.gmap.get((0, -1)), 0)
self.assertEqual(p.inventory, [2])
def run_match_competition(date, competition):
player_list = []
match_details = []
for match in os.listdir(os.environ["TENNIS_HOME"] + "matches//year " + date[:4] + "//" + competition):
if match[-10:] == date:
with open(os.environ["TENNIS_HOME"] + "matches//year " + date[:4] + "//" + competition + "//" + match) as \
file:
match_details.append(yaml.safe_load(file))
for player in match_details[len(match_details) - 1]["player_ids"]:
player_list.append(Player(file=os.environ["TENNIS_HOME"] + "//players//players/Player_" +
player + ".yaml"))
pass
pass
def save_my_team(self):
request_json = json.loads(request.data)
_selected_players = request_json["_selected_players"]
for key, value in _selected_players.items():
if value in [player['name'] for player in self.players]:
if self.my_team[key] and value != self.my_team[key].name:
self.my_team[key] = Player().get_one(value)
if self.players_selected_by_position[key] != value:
self.players_selected_by_position[key] = value
elif value == "":
continue
else:
return jsonify({
"error":
"The players selected are not in list of my players."
}), 401
return self.do_save()
def play_game(self):
players = [Player(i) for i in range(1, self.player_amount + 1)]
game_on = True
round = 1
while game_on:
print(f"Round: {round}\n")
for player in players:
self.round(player)
self.check_winner(player)
if player.winner:
print(f"\n{player} wins the game!\n")
game_on = False
break
print("-" * 20)
round += 1
print("LeaderBoard\n")
self.print_score(players)
self.reset_game(players)
def setup(self):
generate_map("image/map/map.json")
enemy = Enemy(368, 608)
game_objects.add(enemy)
enemy1 = Enemy(640, 300)
game_objects.add(enemy1)
black_slave = BlackSlave(768, 240)
game_objects.add(black_slave)
main_door = MainDoor(16, 320)
game_objects.add(main_door)
black_screen = BlackScreen(0, 0)
game_objects.add(black_screen)
player = Player(64, 320)
game_objects.add(player)
def on_init(self):
pg.display.set_caption("PyMario")
self.display_surf = pg.display.set_mode(
self.WIN_SIZE,
pg.HWSURFACE | pg.DOUBLEBUF
)
self._running = True
# timer fps
self.timer = pg.time.Clock()
# camera
# self.camera = Camera(level_width=len(Level.MAP[0]) * 30,
# level_height=len(Level.MAP) * 30)
self.camera = Camera(level_width=100 * 30,
level_height=20 * 30)
# create level
self.level = Level(surface=self.display_surf, camera=self.camera)
# create player
self.player = Player(60, 60, surface=self.display_surf, camera=self.camera)
class GameCore:
def __init__(self, _main):
self.main = _main
## Set parent nodes in the scenegraph
self.physicsParentNode = render.attachNewNode("physicsParentNode")
self.levelParentNode = render.attachNewNode("levelParentNode")
self.objectsParentNode = render.attachNewNode("objectsParentNode")
self.lightsParentNode = render.attachNewNode("lightsParentNode")
self.aiParentNode = render.attachNewNode("aiParentNode")
## Start Event Manager
self.eventMgr = EventMgr(self)
def startGame(self, _playerName="DefaultPlayer"):
self.autoShader()
self.eventMgr.start()
print "---> Started EventSystem"
self.loadPhysicsSystem()
print "---> Loaded Physics System"
self.loadInputSystem()
print "---> Loaded Input System"
self.loadLevelSystem()
print "---> Loaded Level System"
self.loadPlayerSystem()
print "---> Loaded Player System"
self.loadCameraSystem()
print "---> Loaded Camera System"
def stopGame(self):
pass
##------- SUB SYSTEMS -------##
def loadPhysicsSystem(self):
self.physicsMgr = PhysicsMgr(self)
self.physicsMgr.startPhysics()
self.physicsMgr.setPhysicsDebug()
def loadInputSystem(self):
self.input = Input(self)
#self.input.start()
def loadLevelSystem(self):
self.level = Level(self)
self.level.buildLevel("assets/level/intro")
self.level.start()
def loadPlayerSystem(self):
self.player = Player(self, "Main Man")
self.player.start()
def loadCameraSystem(self):
self.camera = Camera(self)
self.camera.start()
def autoShader(self):
render.setShaderAuto()
def loadPlayerSystem(self):
self.player = Player(self, "Main Man")
self.player.start()
def main():
f = Player(base_dir)
f.main()
from player.player import Player
from flaskr.models import sess
from functions.songs import get_all_songs
for song in get_all_songs():
song.playing = 0
sess.commit()
player = Player()
player.start()
from pygame import sprite from settings import BLACK_COLOR, DISPLAY_SIZE, WHITE_COLOR from ship.ship import Ship from zergling.zergling import Zergling from brutalisk.brutalisk import Brutalisk from hydralisk.hydralisk import Hydralisk from player.player import Player from collision.collision import Collision clock = pygame.time.Clock() screen = pygame.display.set_mode(DISPLAY_SIZE) pygame.mouse.set_visible(0) # Create Player player = Player() collision = Collision() # Create Ship ship = sprite.Group() ship.add(Ship(screen)) # Init Bullet bullet = sprite.Group() # Create Enemies zerglings = sprite.Group() # Font Creations pygame.init() font = pygame.font.Font(None, 36)
def init_player(self, data, address, pl_id):
#check if name already exists
name = data.player.chat
i = 1
namegen = chain(self.players.itervalues(), self.specs.itervalues())
while name in [p.name for p in namegen]:
name = data.player.chat + '_' + str(i)
i += 1
player = Player(True, self.projectiles.add_projectile, pl_id)
player.timer = 0
player.address = address
player.name = name
player.colstring = data.input.name
print ' '.join((str(datetime.now()),
player.name, str(pl_id),
'joined the server', str(address)))
player.time = 0
self.specs[pl_id] = player
tosendplayer = proto.Player()
tosendplayer.id = pl_id
tosendplayer.chat = player.name
#send info do newly connected player
own = proto.Message()
player = proto.Player()
own.type = proto.connectResponse
player.id = pl_id
player.chat = self.specs[pl_id].name
inpt = proto.Input()
inpt.time = 0
inpt.name = self.map.name
own.input.CopyFrom(inpt)
own.player.CopyFrom(player)
self.ackman.send_rel(own, address)
#send other players to player
for idx, p in self.players.iteritems():
if idx != pl_id:
#other players
other = proto.Message()
player = self.players_pack[idx]
player.chat = p.name
other.type = proto.newPlayer
other.player.CopyFrom(player)
other.gameState = proto.wantsJoin
inpt = proto.Input()
inpt.name = p.colstring
other.input.CopyFrom(inpt)
self.ackman.send_rel(other, address)
#other.type = proto.playerUpdate
new = proto.Message()
new.type = proto.newPlayer
#player = self.players_pack[pl_id]
new.gameState = proto.goesSpec
new.player.CopyFrom(tosendplayer)
inpt = proto.Input()
inpt.name = self.specs[pl_id].colstring
new.input.CopyFrom(inpt)
self.ackman.send_rel(new, p.address)
for idx, p in self.specs.iteritems():
if idx != pl_id:
other = proto.Message()
player = proto.Player()
player.id = idx
player.chat = p.name
other.type = proto.newPlayer
other.player.CopyFrom(player)
other.gameState = proto.goesSpec
inpt = proto.Input()
inpt.name = p.colstring
other.input.CopyFrom(inpt)
self.ackman.send_rel(other, address)
new = proto.Message()
new.type = proto.newPlayer
#player = self.players_pack[pl_id]
new.gameState = proto.goesSpec
new.player.CopyFrom(tosendplayer)
inpt = proto.Input()
inpt.name = self.specs[pl_id].colstring
new.input.CopyFrom(inpt)
self.ackman.send_rel(new, p.address)
#TODO: send map status
self.map.items.send_mapstate(self.gamestate.send_mapupdate, address)
def setUp(self):
self.gmap = GameMap(db = DataMap(), input_map = {(-1, -1):1, (-1, 0):1, (-1, 1): 1,
(0, -1): 2, (0, 0): 0, (0, 1): 0,
(1, -1): 1, (1, 0): 0, (1, 1): 1})
self.player = Player(local_map = self.gmap)
class App(object):
WIN_SIZE = conf.WIN_SIZE
def __init__(self):
pg.init()
# joy stick
pg.joystick.init()
try:
self.joystick = pg.joystick.Joystick(0)
self.joystick.init()
print 'Enabled joystick: ' + self.joystick.get_name()
except pg.error:
print 'no joystick found.'
self.joystick = None
self._running = True
self.display_surf = None
self.level = None
self.player = None
self.timer = None
def on_init(self):
pg.display.set_caption("PyMario")
self.display_surf = pg.display.set_mode(
self.WIN_SIZE,
pg.HWSURFACE | pg.DOUBLEBUF
)
self._running = True
# timer fps
self.timer = pg.time.Clock()
# camera
# self.camera = Camera(level_width=len(Level.MAP[0]) * 30,
# level_height=len(Level.MAP) * 30)
self.camera = Camera(level_width=100 * 30,
level_height=20 * 30)
# create level
self.level = Level(surface=self.display_surf, camera=self.camera)
# create player
self.player = Player(60, 60, surface=self.display_surf, camera=self.camera)
def on_execute(self):
if self.on_init() == False:
self._running = False
while self._running:
self.timer.tick(conf.FPS)
for event in pg.event.get():
self.on_event(event)
self.on_loop()
self.on_render()
self._on_cleanup()
def on_event(self, event):
self._listen_event(event)
self.player.listen_event(event, joystick=self.joystick)
def on_loop(self):
# center camera on player
self.camera.update(self.player)
# update mario
self.player.update(self.level.get_elements())
def on_render(self):
# render level
self.level.render()
self.player.render()
pg.display.update()
def _on_cleanup(self):
pg.quit()
def _listen_event(self, event):
if event.type == pg.QUIT:
self._running = False
def __init__(self,id, cards):
Player.__init__(self,id,cards)
# -*- coding: utf-8 -*-
"""
Created on Wed Jun 29 22:11:53 2016
@author: alexis
"""
from interfacage.lylipond_parser import LyParser
from instruments.timbre import Timbre
from music.scale import Scale
from player.player import Player
player = Player()
interface = player.playRealTime()
player.enableLearning()
instrument = Timbre('orgue') # Defining an instrument
player.instrument = instrument # giving an instrument to the player
tempo = 200
# Defining a scale
majorScale = Scale('major',LyParser().getNote('c,').height)
#player.playScale(majorScale, tempo) # Asking the player to play the scale to a specific tempo
# Defining a sheet
#sheet="{ a,4 ais, b, c, cis, d, dis, e, f, fis, g, gis, a4 ais b c cis d dis e f fis g gis a'4 ais' b' c' cis' d' dis' e' f' fis' g' gis' }"
#sheet="{ ais8 ais a g,16 f, f, d,8. c,4 f,2 }"
sheet="{ r2 c,8 c, a4 g, f, g,2 e,4 f, r f, g,2 c,4 a b c g,2 e,8 e, f,4 e, d, c,2. r2. }"
#sheet="{ c4 c c d e2 d c4 e d d c2 c4 c c d e2 d c4 e d d c2 d4 d d d a2 a d4 c b a g,2 c4 c c d e2 d c4 e d d c2 }"
#parsedSheet = player.playLySheet(sheet, tempo, majorScale) # Asking the player to play the sheet to a specific tempo
def __init__(self, id, cards, nrCards):
Player.__init__(self, id, cards)
self.beliefs = np.ones(nrCards)/nrCards
self.currentCards = np.zeros(nrCards)
self.initNFQ()
