def distance(player: Player, trainingdata):
"""
Returns the distance between the given program's output and a "perfect" program
"""
incorrect = 0
for game, action in trainingdata:
if player.get_action(game) != action:
incorrect += 1
return incorrect
class PlayerTest(unittest.TestCase):
def setUp(self):
self.player = Player()
def test_check_initial_player_invinciblity(self):
self.assertEqual(False, self.player.is_player_invincible)
self.assertNotEqual(True, self.player.is_player_invincible)
def test_getting_initial_player_speed(self):
initial_speed = 10
self.assertEqual(initial_speed, self.player.player_speed)
def test_setting_player_invinciblity(self):
self.player.set_player_invinciblity()
self.assertEqual(True, self.player.is_player_invincible)
self.assertNotEqual(False, self.player.is_player_invincible)
self.player.set_player_invinciblity()
self.assertEqual(False, self.player.is_player_invincible)
self.assertNotEqual(True, self.player.is_player_invincible)
class PlayerTest(unittest.TestCase):
def setUp(self):
self.player = Player()
def test_check_initial_player_invinciblity(self):
self.assertEqual(False, self.player.is_player_invincible)
self.assertNotEqual(True, self.player.is_player_invincible)
def test_getting_initial_player_speed(self):
initial_speed = 10
self.assertEqual(initial_speed, self.player.player_speed)
def test_setting_player_invinciblity(self):
self.player.set_player_invinciblity()
self.assertEqual(True, self.player.is_player_invincible)
self.assertNotEqual(False, self.player.is_player_invincible)
self.player.set_player_invinciblity()
self.assertEqual(False, self.player.is_player_invincible)
self.assertNotEqual(True, self.player.is_player_invincible)
def AddPlayer(self, name):
i = len(self._playerNames)
## two-player test
if not (name in self._playerNames):
self._server.BroadcastMessage("player {0} in seat {1}".format(
name, i))
self._playerNames.append(name)
self._playerHooks[name] = Player(name, self._server)
if len(self._playerNames) == 2:
self.BroadcastScore()
self._bidding.SetPlayers(self._playerNames)
## start round
self.ChangeState(GameState.ROUNDSTART)
async def join(self, ctx, bijnaam=None): # add a new player to the game
response = ""
if bijnaam is not None: # if a nickname is given, check that it is correct
if not (isinstance(bijnaam, str) and bijnaam != ""
and len(bijnaam) <= 50): # no empty or long strings
raise commands.CheckFailure(message="wrong nickname input")
player = Player(ctx.author).set_nickname(
bijnaam) # initiate the Player and set its nickname
ctx.bot.spel.add_player(
player) # add the new Player object to the active player list
if len(ctx.bot.spel.players
) >= MIN_PLAYERS and ctx.bot.spel.beurt is None:
# when the minimum player limit is reached, initiate the turn to the first player who joined
ctx.bot.spel.beurt = ctx.bot.spel.players[0]
response += f"{player.name} ({player.nickname}) is in het spel gekomen."
await ctx.channel.send(response
) # send the built up response to the channel
def main():
gameplay.state.curr_id = 3389
if len(sys.argv) < 3:
print("Please provide player file name and player id")
sys.exit(1)
gameplay.state.my_player_id = None
players_str = None
with open(sys.argv[1], "r") as player_file:
gameplay.state.my_player_id = int(sys.argv[2])
players_str = player_file.read()
player_adds = players_str.split()
num_players = len(player_adds)
messaging = MessagingHandler()
messaging.connect(player_adds, num_players, gameplay.state.my_player_id)
running = True
graphics.view.initView()
gameplay.state.trapDoor = graphics.view.sprite_factory.from_file(
"./assets/trapdoor.png")
gameplay.state.floor = Floor()
if gameplay.state.my_player_id == 0:
gameplay.state.floor.genFloor(3, 3)
messaging.broadcast(gameplay.state.floor.serialize().encode("utf-8"))
else:
queue = messaging.get_messages()
while queue.empty():
sdl2.SDL_Delay(10)
queue = messaging.get_messages()
gameplay.state.floor.from_dict(json.loads(queue.get()))
gameplay.state.players = []
for i in range(num_players):
new_player = Player(i, 200 + 200 * i, 350)
gameplay.state.players.append(new_player)
new_player.roomX = gameplay.state.floor.startingLocs[i][0]
new_player.roomY = gameplay.state.floor.startingLocs[i][1]
print("Starting room: %d %d" % (new_player.roomX, new_player.roomY))
gameplay.state.floor.board[new_player.roomX][
new_player.roomY].simulation.add_object(new_player.collider)
gameplay.state.fullHeart = graphics.view.sprite_factory.from_file(
"./assets/hearts.png").subsprite(graphics.rect.Rect(0, 0, 300, 300))
gameplay.state.emptyHeart = graphics.view.sprite_factory.from_file(
"./assets/hearts.png").subsprite(graphics.rect.Rect(600, 0, 300, 300))
graphics.view.makeGameSubView()
my_player = gameplay.state.players[gameplay.state.my_player_id]
frame = 0
last_phys_time = sdl2.SDL_GetTicks()
while running == True:
frame_start = sdl2.SDL_GetTicks()
input_events = sdl2.ext.get_events()
game_events = []
for event in input_events:
if event.type == sdl2.SDL_QUIT:
running = False
break
else:
if not ControlsState.should_process_input_event(event):
continue
ControlsState.update_state(event)
player_event = gameplay.state.players[
gameplay.state.my_player_id].processInputEvent(event)
if player_event.params["code"] == "NONE":
continue
game_events.append(player_event)
messaging.broadcast(player_event.serialize().encode("utf-8"))
messages = messaging.get_messages()
while messages.qsize() > 0:
msg = messages.get()
game_events.append(GameEvent.deserialize(msg.decode("utf-8")))
for event in game_events:
if (event.params["type"] == "PLAYER"):
gameplay.state.players[
event.params["player_id"]].processPlayerEvent(event)
if (event.params["type"] == "STATUS"):
if (event.params["kind"] == "ROOM"):
gameplay.state.floor.handle_update_event(event)
for enemy in gameplay.state.floor.board[my_player.roomX][
my_player.roomY].enemies:
enemy.chooseNewDirection(gameplay.state.players, my_player.roomX,
my_player.roomY)
nearby_ps = []
for player in gameplay.state.players:
if nearby(player):
nearby_ps.append(player.id)
monster_update = gameplay.state.floor.get_update_event(
my_player.roomX, my_player.roomY)
monster_update_str = monster_update.serialize().encode("utf-8")
if nearby_ps[0] == gameplay.state.my_player_id and len(nearby_ps) > 1:
if frame % 30 == 0:
for p in nearby_ps:
if nearby_ps[p] != gameplay.state.my_player_id:
messaging.send_to(p, monster_update_str)
curr_time = sdl2.SDL_GetTicks()
delta = curr_time - last_phys_time
last_phys_time = curr_time
gameplay.state.global_queue = Queue()
gameplay.state.floor.board[my_player.roomX][
my_player.roomY].simulation.step(delta / 1000)
while not gameplay.state.global_queue.empty():
update_dict = gameplay.state.global_queue.get()
messaging.broadcast(update_dict.serialize().encode("utf-8"))
if update_dict.params["player_id"] == gameplay.state.my_player_id and \
update_dict.params["code"] == "CHANGE_ROOM":
messaging.broadcast(monster_update_str)
for player in gameplay.state.players:
if player.id != gameplay.state.my_player_id:
if player.roomX == my_player.roomX and player.roomY == my_player.roomY:
gameplay.state.floor.board[player.roomX][
player.roomY].simulation.add_object(player.collider)
graphics.view.render()
frame_end = sdl2.SDL_GetTicks()
remaining_time = (frame_start + FRAME_LENGTH) - frame_end
if remaining_time > 0:
sdl2.SDL_Delay(remaining_time)
frame += 1
sdl2.ext.quit()
def setUp(self):
self.player = Player()
def setUp(self):
self.player = Player()
def addPlayer(self, player_id):
self.players.append(Player(player_id))
self.numPlayers += 1