class Level:
logger = logging.getLogger("Level")
def __init__(self, level_id: int, settings: Settings,
game_clock: GameClock):
self.settings = settings
self.game_clock = game_clock
level_loader = LevelLoader(level_id)
self.level_map = level_loader.get_level_map()
self.gravity = Vector(0, 1)
player_start_pos = Vector.from_tuple(self.level_map.player_start_pos)
self.player = Player(level_loader.get_player_images(),
player_start_pos)
# TODO: initialize environment
# self.walls =
# self.door =
# self.ladders =
# ....
def update(self):
self.game_clock.update(self.settings.fps)
game_surface = pygame.display.get_surface()
game_surface.fill(self.settings.background_color)
self.level_map.update(game_surface)
self.player.apply_force(self.gravity)
self.player.update(game_surface, self.game_clock.deltatime)
def init_player(self, color, player_type):
marbles = set()
target = set()
# target zone
target = initial_positions(oponent_color(color)) # modulo 6, but starting at 1 instead of 0
# initial zone
for position in initial_positions(color):
i,j = position
self.board[i][j] = color
marbles.add(Marble(self, position, color, target))
if color == GREEN:
if self.weights[0] is not None:
if player_type == NEURAL_TYPE:
self.players[color] = NeuralPlayer(target, marbles, color, self, self.weights[0])
else:
self.players[color] = Player(target, marbles, color, self, self.weights[0])
else:
if player_type == NEURAL_TYPE:
self.players[color] = NeuralPlayer(target, marbles, color, self, NNQFunction(color))
else:
self.players[color] = Player(target, marbles, color, self)
elif color == RED:
if self.weights[1] is not None:
if player_type == NEURAL_TYPE:
self.players[color] = NeuralPlayer(target, marbles, color, self, self.weights[1])
else:
self.players[color] = Player(target, marbles, color, self, self.weights[1])
else:
if player_type == NEURAL_TYPE:
self.players[color] = NeuralPlayer(target, marbles, color, self, NNQFunction(color))
else:
self.players[color] = Player(target, marbles, color, self)
def __init__(self):
self.changeTo = None
self.states = {"play", "intro", "pause", "setting"}
self.player = None
self.letter = []
# Creates src.player.Player object
self.player = Player()
# Summons a letterspit and creates enemy list
self.lettergen = Letterspit()
self.lettergen.cap = 20
self.lettergen.level = 1
self.enemylist = []
self.armageddon_status = False
self.armageddon_cur = 0
self.arma_counter = 0
self.money = 0
self.turrets = []
self.money_font = pygame.font.SysFont("Arial", 50)
self.timer = 0
self.cnter = 0
def setUp(self):
self.board_3x3 = Board(3)
self.board_5x5 = Board(5)
self.game = Game()
self.game.board = Board(3)
self.game.player1 = Player("Toothless", "X")
self.game.player2 = Player("Hiccup", "O")
def index():
overrideform = OverrideForm()
override = None
has_content = None
current_content = None
# Check if floppy exists
lsblk = get_floppy()
# Check if the floppy has content
if lsblk == "sda":
rec = Recorder(path=media_filepath)
has_content = rec.file_exists()
if has_content == False:
return redirect(url_for('record'))
else:
# Get current playback
pla = Player(config_path)
current_content = pla.get_current_playback()
# Check if the user decided to override the floppy or not
if overrideform.validate_on_submit():
form_data = request.form
override = form_data["override"]
if override == "1":
return redirect(url_for('record', override=override))
return render_template('index.html',
lsblk=lsblk,
has_content=has_content,
current_content=current_content,
override=override,
overrideform=overrideform)
def test_scoreboard_update(scoreboard):
player = Player()
player.score = 200
player.nickname = "LeeroyJenkins"
scoreboard.AddToScoreboard(player)
assert "LeeroyJenkins" in scoreboard._board
assert scoreboard._board["LeeroyJenkins"] == 200
class TestPlayerGetsHit(unittest.TestCase):
def setUp(self):
self.player = Player("P")
def test_player_gets_hit_increases_hits_against(self):
self.player.hit()
self.assertEqual(self.player.hits, 1)
class GameScreen(GameMixin):
player = Player('X', True)
opponent = Player('O', False)
_players = (player, opponent)
def set_attacker_text(self):
self.ids['attacker_text'].text = f'Ходит {self.attacker.name}'
def update_player_functionality(self, x: int, y: int):
players = self.get_players("remained")
player_buttons = list(map(lambda player: player.get_button(), players))
if self.player_panel is not None:
if self.player_panel.update(x, y, self.timer):
return # to not check for other buttons bellow the panel
des = False # random flag... This is fine
for i, btn in enumerate(player_buttons):
if btn.pressed(x, y):
# print("player {}".format(i + 1))
if players[i].select(
) == "selected": # select the clicked player
y = 140 if y < 140 else y # change player panel's position to not spawn over the down an left edges
x = WIDTH - 160 if x > WIDTH - 160 else x
self.player_panel = PlayerPanel(x, y, players[i],
(self.team1, self.team2))
if len(
list(
filter(lambda player: player.selected,
players))) == 2:
Player.de_select(
players, i) # de-select previous clicked player
else:
self.player_panel = None
des = True
if not des:
Player.de_select(players)
self.player_panel = None
def test_move_directly_do_not_pass_go(self):
# Resetting property instance
Properties.properties = _init_properties()
# Resetting game pieces
Player._game_pieces = [
'battleship', 'dog', 'iron', 'shoe', 'thimble', 'top hat',
'wheelbarrow'
]
self.player = Player()
self.player.action(Actions.MOVE_DIRECTLY_TO_TILE_DO_NOT_PASS_GO, 30)
self.assertEqual(self.player.position, 30,
'Moving directly to 30 (Do not pass GO)')
self.assertEqual(
self.player.cash, 1500,
'Should still be 1500 after moving to 30 (Do not pass GO)')
self.player.action(Actions.MOVE_DIRECTLY_TO_TILE_DO_NOT_PASS_GO, 10)
self.assertEqual(self.player.position, 10,
'Moving directly to 10 from 30 (Do not pass GO)')
self.assertEqual(
self.player.cash, 1500,
'Should have passed GO after moving to 10 from 30. Cash stays same.'
)
def __init__(self, config=None):
self.field_width = 10
self.field_height = 10
self.field_objects = []
for j in range(self.field_height):
self.field_objects.append(
[Objects.empty_field for i in range(self.field_width)])
self.checker = Checker(self)
self.player1 = Player(config.white, 1)
self.player2 = Player(config.black, 2)
self.timer1 = Timer(config.timer, config.duration)
self.timer2 = Timer(config.timer, config.duration)
self.cur_timer = None
self.new_game = False
self.is_first_move = True
self.is_over = False
self.cur_figure = None
self.cur_player = self.player1
self.cur_move = None
self.init_field()
self.was_taken = False
self.logger = Logger()
self.dump_logger = Logger()
self.moves_quantity = 0
self.game_file = config.game_file
self.pause = 0.2
self.load = config.load_game
self.loaded_moves = queue.Queue()
self.loaded_moves_amount = 0
if self.load:
self.load_moves()
self.interface = Interface(self)
def test_move_player(self):
# Resetting property instance
Properties.properties = _init_properties()
# Resetting game pieces
Player._game_pieces = [
'battleship', 'dog', 'iron', 'shoe', 'thimble', 'top hat',
'wheelbarrow'
]
self.player = Player()
self.player.action(Actions.MOVE_TO_TILE, 11)
self.assertEqual(self.player.position, 11,
'Moving from 0, 11 spaces. Should be 11')
self.assertEqual(self.player.cash, 1500,
'Should be 1500. Not passing GO (1)')
self.player.action(Actions.MOVE_TO_TILE, 11)
self.assertEqual(self.player.position, 22,
'Moving from 11, 11 spaces. Should be 22')
self.assertEqual(self.player.cash, 1500,
'Should be 1500. Not passing GO (2)')
self.player.action(Actions.MOVE_TO_TILE, 11)
self.assertEqual(self.player.position, 33,
'Moving from 22, 11 spaces. Should be 33')
self.assertEqual(self.player.cash, 1500,
'Should be 1500. Not passing GO (3)')
self.player.action(Actions.MOVE_TO_TILE, 11)
self.assertEqual(self.player.position, 4,
'Moving from 33, 11 spaces. Should be 4')
self.assertEqual(self.player.cash, 1700,
'Should be 1700 after passing GO')
def load(self, saveFile):
"""
Loads the game from a save file, creates an empty game if the save is None
"""
save = json.load(open(saveFile, "r"))
self.map = Map(save['map'])
self.player = Player(save['player'])
def __init__(self, screen: Surface, clock: Clock):
super().__init__(screen, clock)
self.environment = Environment(self.settings,
open("../assets/maps/default.txt",
"r").read())
self.animation_manager = AnimationManager(self)
self.vertical_shift = 0
self.environment_renderer = EnvironmentRenderer(self.environment,
self.settings)
self.text_event_handler = TextEventHandler(self)
self.add_event_handler(self.text_event_handler)
self.player_controller = PlayerController(self)
self.recording = Recording()
self.player = Player()
self.player.set_position(self.environment.get_starting_position())
self.player_sprite = PlayerSprite(self, self.player)
self.player_group = pygame.sprite.GroupSingle(self.player_sprite)
self.shard_group = pygame.sprite.Group([])
self.particle_group = pygame.sprite.Group([])
self.hud_ui_group = GameHudFactory.build_group(self)
self.player_group.update()
self.spawn_pack_of_shards()
def setUp(self):
self.player1 = Player('Evie')
self.player2 = Player('Amelia')
self.pg = Game()
self.pg.add_player(self.player1)
self.pg.add_player(self.player2)
self.pg.setup_game(SETTINGS_LOCATION)
def __init__(self):
self.run = True
self.player = Player()
self.board = Board(os.path.join("..", "worlds", "world.txt"))
self.screen = pygame.display.set_mode(Game.RESOLUTION)
self.clock = pygame.time.Clock()
self.execute()
def test_play_option_has_stand(self):
from src.player import Player
testPlayer = Player()
testCanSplit = True
testCanInsure = False
self.assertIn('stand', testPlayer.get_play_options(canSplit=testCanSplit, canInsure=testCanInsure).lower())
def test_play_option_cant_insure_when_unavalible(self):
from src.player import Player
testPlayer = Player()
testCanSplit = False
testCanInsure = False
self.assertNotIn('insure', testPlayer.get_play_options(canSplit=testCanSplit, canInsure=testCanInsure).lower())
def test_play_option_can_split_when_avalible(self):
from src.player import Player
testPlayer = Player()
testCanSplit = True
testCanInsure = False
self.assertIn('split', testPlayer.get_play_options(canSplit=testCanSplit, canInsure=testCanInsure).lower())
def test_player_moves(self):
mockProps = {'history': []}
mockPlayer = Player(mockProps)
mockPlayer.move(1)
mockPlayer.move(2)
self.assertEqual(len(mockPlayer.history), 2)
self.assertEqual(mockPlayer.history[0], 1)
self.assertEqual(mockPlayer.history[1], 2)
def move(self, player: Player, knight_id: int, move_id: int):
"""
Mueve el caballo a una posicion determinada, haciendo todo lo necesario
que implica el movimiento del caballo. Como lo es comerse a un caballo,
denegar movimientos no validos, etc.
Args:
player (Player): Jugador que está realizando el movimiento.
knight_id (int): Identificador de caballo que se esta moviendo.
move_id (int): Identificador del movimiento del caballo.
Raises:
NameError: MovimientoFueraDelTablero se gatilla cuando el movimiento
del caballo lo lleva fuera del tablero.
NameError: MovimientoInvalido se gatilla cuando el movimiento del
caballo no es valido.
"""
# Obteniendo jugador y caballo
knight = player.get_knight(knight_id)
# ? Prueba
x, y = knight.get_position()
knight2 = self.board[y][x]
x2, y2 = knight2.get_position()
if not knight2 == knight:
import sys
print(f"IDS: {knight.id_} {knight2.id_}")
print(f'POS: ({x},{y}) ({x2},{y2})')
print("Error, son distintos")
self.print_board()
#sys.exit()
if not knight.alive:
raise NameError("CaballoMuerto")
# Obtieniendo posiciones del caballo
x, y = knight.get_position()
nx, ny = knight.get_movement(move_id)
if ny < 0 or ny >= len(self.board) or nx < 0 or nx >= len(
self.board[ny]):
raise NameError("MovimientoFueraDelTablero")
other_knight = self.board[ny][nx]
if other_knight is None:
self.board[y][x] = None
self.board[ny][nx] = knight
knight.set_position(nx, ny)
elif player.is_enemy(other_knight):
player.add_point()
self.board[y][x] = None
self.board[ny][nx] = knight
knight.set_position(nx, ny)
other_knight.alive = False
else:
# Este error se gatilla cuando se intenta ir a una casilla con un
# aleado en ella.
raise NameError("MovimientoInvalido")
def setUp(self) -> None:
# 0 10 20 "
# 0123456789|123456789|12"
dummy_map = " .o/o///.Soo//o///.. \n" \
" ..//.. "
self.settings = GameSettings(scale_factor=1.)
self.environment = Environment(self.settings, dummy_map)
self.player = Player()
self.player.set_position(self.environment.get_starting_position())
def test_player_say_snap(capsys, auto_mode: bool):
"""Check say_snap function, behaviour depends on auto_mode attribute"""
player1 = Player(name="Witcher fan", hand=[], auto_mode=auto_mode)
with patch("sys.stdin", StringIO("".join("I pressed Enter here"))):
assert type(player1.say_snap()) is float
# If auto_mode if False, expect waiting for input
if not auto_mode:
msg = capsys.readouterr()
assert str(msg.out).startswith("Hurry! Press ENTER")
def test_get_winner_spade(self):
moves: List[Move] = [
Move(Player("Ann"), Card("10", "C")),
Move(Player("Betsy"), Card("K", "C")),
Move(Player("Caroline"), Card("3", "C")),
Move(Player("Diane"), Card("2", "S")),
]
t: Trick = Trick(moves)
self.assertEqual(t.get_winner(), Player("Diane"))
def __init__(self):
self.width = 1000
self.height = 800
self.player = Player(x=15, y=15, width=10, height=10, speed=1)
self.game_display = None
self.tile_size = 25
self.wall_size = 1
self.maze = Maze(x=20, y=10, tile_size=self.tile_size,
wall_size=self.wall_size) # , file="..\\image\\maze.png")
def __init__(self, window):
# Store a reference to the application window
self.window = window
# Key handler shortcut
self.keys = window.keys
# The rendering batch
self.batch = pyglet.graphics.Batch()
self.score_batch = pyglet.graphics.Batch()
#self.laser_batch = pyglet.graphics.Batch()
# The lasers
self.laser_group = LaserGroup()
# The foreground rendering groups
self.scoregroup_hi = pyglet.graphics.OrderedGroup(1)
self.scoregroup_lo = pyglet.graphics.OrderedGroup(0)
self.slime_group = pyglet.graphics.OrderedGroup(2)
self.print_group = pyglet.graphics.OrderedGroup(1)
self.bg_group = pyglet.graphics.OrderedGroup(0)
# Manages the background effects
self.bg = BackgroundManager(batch=self.batch, group=self.bg_group)
# The collision machinery
self.coll_funcs = CollisionDispatcher()
# Each entity pair has an algorithm
#self.coll_funcs.add(HorizontalLine, Player, coll_player_horizontal_line)
#self.coll_funcs.add(VerticalLine, Player, coll_player_vertical_line)
self.coll_funcs.add(HorizontalLaser, Player,
coll_player_horizontal_line)
self.coll_funcs.add(VerticalLaser, Player, coll_player_vertical_line)
self.coll_funcs.add(Blobule, Player, coll_blob_player)
# The player blob
self.blob_group = src.glsl.blob.BlobGroup(300, 300, 8,
(0.125, 0.375, 0.0))
self.blobule_group = src.glsl.blob.BlobGroup(0, 0, 8, (0.5, 0.0, 0.5))
self.player = Player(self, self.blob_group, self.slime_group,
self.batch)
logo = spr('logo.png', batch=self.batch, group=self.scoregroup_hi)
logo.image.anchor_x, logo.image.anchor_y = 300, logo.image.height / 2
logo.x, logo.y = 300, 300
self.logo = logo
self.logo_fade = False
self.load_sounds()
# The blobule powerup
self.blobule = Blobule(self.blobule_group)
# The lasers
self.lines = {}
self.do_horiz = True
#pyglet.graphics.glLineWidth(3)
# Score labels
self.score = 0
self.scores = []
def render_POST(self, request, conn):
#if conn.new_player and conn.new_player.code in database["players"]:
# return "\nImpossibile creare il personaggio %s perché già esistente.\n" % conn.new_player.name
page = self.check_number_of_players(request, conn)
if page:
return page
# Ricava gli argomenti del form dalla richiesta
race = ""
if "race" in request.args:
race = Element(request.args["race"][0])
sex = ""
if "sex" in request.args:
sex = Element(request.args["sex"][0])
constellation = ""
if "constellation" in request.args:
constellation = Element(request.args["constellation"][0])
# Controlla la validità degli argomenti inseriti nel form
err_msg_race = ""
if not race:
err_msg_race = "Scegli la razza che vuoi interpretare"
race = RACE.NONE
else:
# (TD) per ora gestisce la sessualità unica delle Frijen in maniera forzata
if race == RACE.FRIJEN:
sex = SEX.FEMALE
err_msg_sex = ""
if not sex:
err_msg_sex = "Scegli la sessualità che vuoi interpretare"
sex = SEX.NONE
err_msg_constellation = ""
if not constellation:
err_msg_constellation = "Scegli la costellazione sotto cui il tuo personaggio è nato"
constellation = CONSTELLATION.NONE
# Se tutti gli argomenti del form sono validi crea il personaggio e
# passa alla pagina di creazione successiva
if not err_msg_race and not err_msg_sex and not err_msg_constellation:
new_player = Player()
new_player.race = race
new_player.sex = sex
new_player.constellation = constellation
conn.new_player = new_player
request.redirect("create_player2.html")
request.finish()
return server.NOT_DONE_YET
return self.create_page(request, conn, race, sex, constellation,
err_msg_race, err_msg_sex,
err_msg_constellation)
def test_add_player(self):
players = [Player('Evie'), Player('Amelia')]
for player in players:
self.pg.add_player(player)
with self.subTest(player=player):
self.assertIs(self.pg, player.game)
self.assertIn(player, self.pg.players)
self.assertEqual(player.name, self.pg.players[-1].name)
def play_random_card(player: Player, lead_suit: Optional[str]) -> Card:
# To obey rules, player must play a card in lead suit if he/she has one
random_card: Card = choice(player.get_cards())
if lead_suit is None:
return random_card
cards_in_lead_suit: List[Card] = player.get_cards_in_suit(lead_suit)
if len(cards_in_lead_suit) > 0:
return choice(cards_in_lead_suit)
else:
return random_card
def game_player_information(self):
if self.number_players == 2:
self.players.append(
Player(self.menu.introduce_player_name("1"), 1, "x", True))
self.players.append(
Player(self.menu.introduce_player_name("2"), 2, "o", True))
else:
self.players.append(
Player(self.menu.introduce_player_name("1"), 1, "x", True))
self.players.append(Player("Machine", 2, "o", False))
def render_POST(self, request, conn):
#if conn.new_player and conn.new_player.code in database["players"]:
# return "\nImpossibile creare il personaggio %s perché già esistente.\n" % conn.new_player.name
page = self.check_number_of_players(request, conn)
if page:
return page
# Ricava gli argomenti del form dalla richiesta
race = ""
if "race" in request.args:
race = Element(request.args["race"][0])
sex = ""
if "sex" in request.args:
sex = Element(request.args["sex"][0])
constellation = ""
if "constellation" in request.args:
constellation = Element(request.args["constellation"][0])
# Controlla la validità degli argomenti inseriti nel form
err_msg_race = ""
if not race:
err_msg_race = "Scegli la razza che vuoi interpretare"
race = RACE.NONE
else:
# (TD) per ora gestisce la sessualità unica delle Frijen in maniera forzata
if race == RACE.FRIJEN:
sex = SEX.FEMALE
err_msg_sex = ""
if not sex:
err_msg_sex = "Scegli la sessualità che vuoi interpretare"
sex = SEX.NONE
err_msg_constellation = ""
if not constellation:
err_msg_constellation = "Scegli la costellazione sotto cui il tuo personaggio è nato"
constellation = CONSTELLATION.NONE
# Se tutti gli argomenti del form sono validi crea il personaggio e
# passa alla pagina di creazione successiva
if not err_msg_race and not err_msg_sex and not err_msg_constellation:
new_player = Player()
new_player.race = race
new_player.sex = sex
new_player.constellation = constellation
conn.new_player = new_player
request.redirect("create_player2.html")
request.finish()
return server.NOT_DONE_YET
return self.create_page(request, conn, race, sex, constellation,
err_msg_race, err_msg_sex, err_msg_constellation)
def __init__(self, window):
# Store a reference to the application window
self.window = window
# Key handler shortcut
self.keys = window.keys
# The rendering batch
self.batch = pyglet.graphics.Batch()
self.score_batch = pyglet.graphics.Batch()
#self.laser_batch = pyglet.graphics.Batch()
# The lasers
self.laser_group = LaserGroup()
# The foreground rendering groups
self.scoregroup_hi = pyglet.graphics.OrderedGroup(1)
self.scoregroup_lo = pyglet.graphics.OrderedGroup(0)
self.slime_group = pyglet.graphics.OrderedGroup(2)
self.print_group = pyglet.graphics.OrderedGroup(1)
self.bg_group = pyglet.graphics.OrderedGroup(0)
# Manages the background effects
self.bg = BackgroundManager(batch=self.batch, group=self.bg_group)
# The collision machinery
self.coll_funcs = CollisionDispatcher()
# Each entity pair has an algorithm
#self.coll_funcs.add(HorizontalLine, Player, coll_player_horizontal_line)
#self.coll_funcs.add(VerticalLine, Player, coll_player_vertical_line)
self.coll_funcs.add(HorizontalLaser, Player, coll_player_horizontal_line)
self.coll_funcs.add(VerticalLaser, Player, coll_player_vertical_line)
self.coll_funcs.add(Blobule, Player, coll_blob_player)
# The player blob
self.blob_group = src.glsl.blob.BlobGroup(300, 300, 8, (0.125, 0.375, 0.0))
self.blobule_group = src.glsl.blob.BlobGroup(0, 0, 8, (0.5, 0.0, 0.5))
self.player = Player(self, self.blob_group, self.slime_group, self.batch)
logo = spr('logo.png', batch = self.batch, group=self.scoregroup_hi)
logo.image.anchor_x, logo.image.anchor_y = 300, logo.image.height / 2
logo.x, logo.y = 300, 300
self.logo = logo
self.logo_fade = False
self.load_sounds()
# The blobule powerup
self.blobule = Blobule(self.blobule_group)
# The lasers
self.lines = {}
self.do_horiz = True
#pyglet.graphics.glLineWidth(3)
# Score labels
self.score = 0
self.scores = []
class World:
def __init__(self):
self.world_map = [
[5, 1, 1, 1, 1, 1, 1, 6],
[4, 0, 0, 0, 0, 0, 0, 2],
[4, 0, 0, 0, 0, 0, 0, 2],
[4, 0, 0, 0, 0, 0, 0, 2],
[4, 0, 0, 0, 0, 0, 0, 2],
[4, 0, 0, 0, 0, 0, 0, 2],
[4, 0, 0, 0, 0, 0, 0, 2],
[4, 0, 0, 0, 0, 0, 0, 2],
[8, 3, 3, 3, 3, 3, 3, 7]
]
self.player = Player("Name")
def update(self):
pass
def render(self, window):
self.player.render(window)
def __init__(self):
self.world_map = [
[5, 1, 1, 1, 1, 1, 1, 6],
[4, 0, 0, 0, 0, 0, 0, 2],
[4, 0, 0, 0, 0, 0, 0, 2],
[4, 0, 0, 0, 0, 0, 0, 2],
[4, 0, 0, 0, 0, 0, 0, 2],
[4, 0, 0, 0, 0, 0, 0, 2],
[4, 0, 0, 0, 0, 0, 0, 2],
[4, 0, 0, 0, 0, 0, 0, 2],
[8, 3, 3, 3, 3, 3, 3, 7]
]
self.player = Player("Name")
def __init__(self, game_info, sound_manager):
GameState.__init__(self, GameState.STATE_GAME, GameState.STATE_LOAD)
self.game_info = game_info
self.sound_manager = sound_manager
self.game_info.set_timer_in_seconds(300)
self.mario_game_time = -1
self.world_shift = 0
self.player = Player(self.sound_manager, game_info)
self.active_sprite_list = pygame.sprite.Group()
self.active_sprite_list.add(self.player)
self.level = Level(game_info, self.player, self.sound_manager)
if constants.DEBUG:
self.debug_overlay = DebugOverlay(self.game_info, self.player)
self.sound_manager.play_music(constants.MUSIC_MAIN_THEME)
class Engine(object):
def __init__(self):
self.world_map = None
self.start_new_game()
def start_new_game(self):
self.player = Player() # create the main player object
self.load_area('./src/worlds/world000.py', 's0') # first world map
def load_area(self, area_layout, start_scene):
del self.world_map # free up memory by releasing old map/scene data
self.world_map = Map(eval(open(area_layout).read()))
self.serve(start_scene) # serve up the new starting position
def serve(self, scene):
if scene == "death":
print("You have died. How unfortunate. Better luck next time!")
self.end_game()
elif scene == "win":
print("You made it out alive!\nYou win!!")
self.end_game()
elif scene == None:
return print("You cannot move there.")
elif scene.split('_')[0] == "map":
data = scene.split('_')
self.load_area('./src/worlds/world' + data[1] + '.py', data[2])
else:
self.current_scene = self.world_map.next_scene(scene)
return print(self.current_scene.description)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Player command functions will serve as the interface for the player and the rest of the game.
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def look(self, direction):
try:
imagery = self.current_scene.layout[direction]['look']
except KeyError:
imagery = "That is not a valid direction."
else:
if imagery == None:
imagery = "There is nothing to see in that direction."
return print(imagery)
def move(self, direction):
try:
destination = self.current_scene.layout[direction]['move']
except KeyError:
destination = None
return self.serve(destination)
def find(self, command):
if command == "items":
self.current_scene.list_items()
elif command == "npc":
return print("No NPCs found.")
else:
return print("Not a valid command.")
def check_inv(self, command="inv"):
return self.player.check_inv()
def take(self, command):
item_name = command.strip().lower()
try:
item = self.current_scene.items[item_name]
except KeyError:
return print("{} is not an item that can be taken.".format(item_name))
else:
self.player.add_item(item)
self.current_scene.remove_item(item_name)
def drop(self, command):
item_name = command.strip().lower()
try:
item = self.player.inventory[item_name][0]
except KeyError:
return print("{} is not an item in your inventory.".format(item_name))
else:
item = self.player.drop_item(item)
self.current_scene.add_item(item)
def examine(self, command):
return self.current_scene.examine_item(command)
def stats_check(self):
player_stats = self.player.stats_check()
return print("Health: {0}\nStamina: {1}".format(player_stats[0], player_stats[1]))
def setUp(self):
TestCase.setUp(self)
self.p = Player('X')
self.c = ComputerPlayer('O')
self.b = Board()
class TestTicTacToe(TestCase):
def setUp(self):
TestCase.setUp(self)
self.p = Player('X')
self.c = ComputerPlayer('O')
self.b = Board()
#
# - Test Human Player Object
#
def test_player_mark(self):
move = self.p.mark
self.assertEqual(move, 'X', "Player mark should be 'X'")
def test_player_first_move(self):
move = self.p.move(first_move=True)
self.assertEqual(move, move, "Should return input from player")
def test_player_subsequent_move(self):
move = self.p.move()
self.assertEqual(move, move, "Should return input from player")
#
# - Test Computer Player/AI Object
#
def test_computer_mark(self):
m = self.c.mark
self.assertEqual(m, 'O', "Computer mark should be 'X'")
def test_counter_first_move_center(self):
move = self.c.counter_first_move('4', self.b.center, self.b.corners)
self.assertEqual(move, '5', "Should be '5'")
def test_counter_first_move_corner(self):
move = self.c.counter_first_move('5', self.b.center, self.b.corners)
self.assertTrue(move in self.b.corners, "Should be a corner")
def test_counter_second_move_edge(self):
move = self.c.counter_second_move('1', '4', self.b.edges, self.b.corners, self.b.check_edges)
self.assertTrue(move in self.b.edges, "Should be an edge")
def test_counter_second_move_corner(self):
move = self.c.counter_second_move('4', '7', self.b.edges, self.b.corners, self.b.check_edges)
self.assertTrue(move in self.b.corners, "Should be a corner")
def test_counter_second_move_two_edges(self):
self.b.spaces['2'] = self.p.mark
self.b.spaces['6'] = self.p.mark
self.b.spaces['5'] = self.c.mark
move = self.c.counter_second_move('2', '6', self.b.available_edges(), self.b.available_corners(), self.b.check_edges)
self.assertEqual(move, '3', "Should be '3'. returned {0}".format(move))
def test_computer_move_none(self):
move = self.c.move([])
self.assertEqual(move, None, "Should be None")
def test_computer_move(self):
move = self.c.move(self.b.available_spaces())
self.assertTrue(move in self.b.available_spaces(),
"Should be one of {0}".format(self.b.available_spaces()))
def test_prevent_win(self):
self.b.spaces['1'] = self.p.mark
self.b.spaces['2'] = self.p.mark
self.b.spaces['3'] = ' '
space = self.c.prevent_win(self.b.spaces, self.p.mark, self.b.possible_wins)
self.assertEqual(space, '3', "Space to update should be '3'")
def test_prevent_win_none(self):
self.b.spaces['1'] = self.p.mark
self.b.spaces['2'] = ' '
self.b.spaces['3'] = ' '
space = self.c.prevent_win(self.b.spaces, self.p.mark, self.b.possible_wins)
self.assertEqual(space, None, "Space to update should be None")
def test_go_for_win(self):
self.b.spaces['1'] = self.c.mark
self.b.spaces['5'] = self.c.mark
self.b.spaces['9'] = ' '
space = self.c.go_for_win(self.b.spaces, self.c.mark, self.b.possible_wins)
self.assertEqual(space, '9', "Space to update should be '9'")
def test_go_for_win_none(self):
self.b.spaces['1'] = ' '
self.b.spaces['5'] = self.c.mark
self.b.spaces['9'] = ' '
space = self.c.go_for_win(self.b.spaces, self.c.mark, self.b.possible_wins)
self.assertEqual(space, None, "Space to update should be None")
def tearDown(self):
TestCase.tearDown(self)
class GameScene(Scene):
def __init__(self, window):
# Store a reference to the application window
self.window = window
# Key handler shortcut
self.keys = window.keys
# The rendering batch
self.batch = pyglet.graphics.Batch()
self.score_batch = pyglet.graphics.Batch()
#self.laser_batch = pyglet.graphics.Batch()
# The lasers
self.laser_group = LaserGroup()
# The foreground rendering groups
self.scoregroup_hi = pyglet.graphics.OrderedGroup(1)
self.scoregroup_lo = pyglet.graphics.OrderedGroup(0)
self.slime_group = pyglet.graphics.OrderedGroup(2)
self.print_group = pyglet.graphics.OrderedGroup(1)
self.bg_group = pyglet.graphics.OrderedGroup(0)
# Manages the background effects
self.bg = BackgroundManager(batch=self.batch, group=self.bg_group)
# The collision machinery
self.coll_funcs = CollisionDispatcher()
# Each entity pair has an algorithm
#self.coll_funcs.add(HorizontalLine, Player, coll_player_horizontal_line)
#self.coll_funcs.add(VerticalLine, Player, coll_player_vertical_line)
self.coll_funcs.add(HorizontalLaser, Player, coll_player_horizontal_line)
self.coll_funcs.add(VerticalLaser, Player, coll_player_vertical_line)
self.coll_funcs.add(Blobule, Player, coll_blob_player)
# The player blob
self.blob_group = src.glsl.blob.BlobGroup(300, 300, 8, (0.125, 0.375, 0.0))
self.blobule_group = src.glsl.blob.BlobGroup(0, 0, 8, (0.5, 0.0, 0.5))
self.player = Player(self, self.blob_group, self.slime_group, self.batch)
logo = spr('logo.png', batch = self.batch, group=self.scoregroup_hi)
logo.image.anchor_x, logo.image.anchor_y = 300, logo.image.height / 2
logo.x, logo.y = 300, 300
self.logo = logo
self.logo_fade = False
self.load_sounds()
# The blobule powerup
self.blobule = Blobule(self.blobule_group)
# The lasers
self.lines = {}
self.do_horiz = True
#pyglet.graphics.glLineWidth(3)
# Score labels
self.score = 0
self.scores = []
def enter(self):
self.reset_blobule()
if config.options['USE_SOUND']:
self.window.music_player = pyglet.media.Player()
self.window.music_player.eos_action = pyglet.media.Player.EOS_LOOP
self.window.music_player.volume = 0.1
self.window.music_player.queue(self.window.music_track)
self.window.music_player.play()
self.window.push_handlers(self.player)
gc.disable()
if __debug__: print "gc disabled"
def leave(self):
if __debug__: print "gc enabled"
self.window.remove_handlers(self.player)
gc.enable()
def load_sounds(self):
if config.options['USE_SOUND']:
self.scream1 = pyglet.media.load('dat/audio/fx/scream1.mp3', streaming=False)
self.scream2 = pyglet.media.load('dat/audio/fx/scream2.mp3', streaming=False)
self.scream3 = pyglet.media.load('dat/audio/fx/scream3.mp3', streaming=False)
self.eat = pyglet.media.load('dat/audio/fx/fx3.mp3', streaming=False)
def reset_blobule(self):
'''give the blobule a random position'''
self.blobule_group.setPosition(random.randint(30, 570), random.randint(30, 570))
def add_line(self, r=0):
'''add a new random line hazard'''
if r == 500:
return
t = 'h' if self.do_horiz else 'v'
pos = (t, random.randint(0, 600))
(player_x, player_y) = self.player.get_position()
if pos in self.lines:
self.add_line(r+1)
elif t=='h' and abs(pos[1] - player_y) <= 32:
self.add_line(r+1)
elif t=='v' and abs(pos[1] - player_x) <= 32:
self.add_line(r+1)
else:
if t == 'h':
#newline = HorizontalLine(self, self.laser_batch, None, pos[1])
newline = HorizontalLaser(self.laser_group, pos[1])
else:
#newline = VerticalLine(self, self.laser_batch, None, pos[1])
newline = VerticalLaser(self.laser_group, pos[1])
self.lines[pos] = newline
self.do_horiz = not self.do_horiz
def add_score(self):
self.score += 1
(blobule_x, blobule_y) = self.blobule.get_position()
newscore = ScoreLabel(str(self.score),
blobule_x, blobule_y,
color=(0, 255, 0), size=12,
batch=self.score_batch, group=self.scoregroup_hi)
self.scores.append(newscore)
def on_key_press(self, symbol, modifiers):
if not self.logo_fade and self.logo.opacity == 255:
self.logo_fade = True
def update(self, dt):
self.bg.update(dt) # background effects
self.laser_group.update(dt)
self.player.update(dt)
self.blob_group.tick()
self.blobule_group.tick()
# Line-Player collision
deleted_lines = []
for key, line in self.lines.iteritems():
#line.update(dt)
if self.coll_funcs.collide(line, self.player):
deleted_lines.append(key)
if not self.player.remove_dot():
if len(self.player.dots) > 3:
if config.options['USE_SOUND']:
random.choice((self.scream1, self.scream2)).play().volume = 0.1
else:
if config.options['USE_SOUND']:
self.scream3.play().volume = 0.1
else:
if config.options['USE_SOUND']:
random.choice((self.scream1, self.scream2)).play().volume = 0.1
self.window.scorescene(score=self.score)
# clean up the dead lines
for key in deleted_lines:
line = self.lines.pop(key)
line.delete()
# Player-Blobule collision
if self.coll_funcs.collide(self.blobule, self.player):
if config.options['USE_SOUND']:
self.eat.play().volume = 0.1
self.add_score()
self.reset_blobule() # new blobule position
player_pos = self.player.get_position()
self.player.add_dot(*player_pos) # increase bodymass
self.add_line() # new random hazard
if __debug__:
print "lines", len(self.lines)
if self.score >= 5:
self.bg.do_fade = True
if self.score >= 15:
self.bg.do_zoom = True
if self.score >= 25:
self.bg.do_spin = True
for label in list(self.scores):
if label.update(dt):
self.scores.remove(label)
label.delete()
if self.logo_fade and self.logo.opacity > 0:
self.logo.opacity -= 75 * dt
if self.logo.opacity <= 0:
self.logo.opacity = 0
self.logo_fade = False
def draw(self):
self.batch.draw()
self.blobule_group.draw(600, 600)
self.blob_group.draw(600, 600)
#self.laser_batch.draw()
self.laser_group.draw(600, 600, self.blob_group.x, self.blob_group.y, self.score >= 20)
self.score_batch.draw()
def testPlayerMakesAMove(self):
player = Player('X')
board = BoardMock()
player.make_move("5", board)
self.assertEquals(True, board.check_move_played)
class MarioGame(GameState):
def __init__(self, game_info, sound_manager):
GameState.__init__(self, GameState.STATE_GAME, GameState.STATE_LOAD)
self.game_info = game_info
self.sound_manager = sound_manager
self.game_info.set_timer_in_seconds(300)
self.mario_game_time = -1
self.world_shift = 0
self.player = Player(self.sound_manager, game_info)
self.active_sprite_list = pygame.sprite.Group()
self.active_sprite_list.add(self.player)
self.level = Level(game_info, self.player, self.sound_manager)
if constants.DEBUG:
self.debug_overlay = DebugOverlay(self.game_info, self.player)
self.sound_manager.play_music(constants.MUSIC_MAIN_THEME)
def process_events(self, events):
for event in events:
if event.type == pygame.KEYDOWN:
key = event.key
if key == pygame.K_LEFT:
self.player.go_left()
if key == pygame.K_RIGHT:
self.player.go_right()
if key == pygame.K_UP:
self.player.jump()
if key == pygame.K_DOWN:
self.player.crouch()
if key == pygame.K_a:
self.player.transition(constants.POWER_LARGE)
if key == pygame.K_s:
self.player.transition(constants.POWER_SMALL)
if key == pygame.K_t:
self.player.start_death_sequence()
if key == pygame.K_ESCAPE or key == pygame.K_q:
# TODO should be pause
pass
if event.type == pygame.KEYUP:
if event.key == pygame.K_LEFT and self.player.x_vel < 0:
self.player.stop()
if event.key == pygame.K_RIGHT and self.player.x_vel > 0:
self.player.stop()
if event.key == pygame.K_DOWN:
self.player.stop()
def update(self, game_time):
if self.mario_game_time == -1:
self.mario_game_time = game_time
else:
self.game_info.timer -= (game_time - self.mario_game_time)
self.mario_game_time = game_time
if self.player.rect.bottom > constants.SCREEN_HEIGHT and self.player.transition_state is not constants.TRANSITION_DEATH_SEQUENCE:
self.player.start_death_sequence()
if self.player.state == constants.STATE_DEAD:
self.switch = True
self.game_info.num_lives -= 1
if self.game_info.num_lives < 0:
self.set_next_state(GameState.STATE_GAME_OVER)
self.level.update(game_time)
def draw(self, screen):
self.level.draw(screen)
self.active_sprite_list.draw(screen)
if constants.DEBUG:
self.debug_overlay.draw(screen)
def start_new_game(self):
self.player = Player() # create the main player object
self.load_area('./src/worlds/world000.py', 's0') # first world map
