class CollectFruit:
def __init__(self):
self.game = Game()
self.tm = TiledMap(self.game)
self.player = Sprite(self.game, 'b.pac_right', (4, 1), speed=4)
self.tm.set_map(FRUITMAP)
self.draw()
self.events = None
self.score = 0
def draw(self):
self.player.move()
self.tm.draw()
self.player.draw()
self.check_player_square()
def move(self, direction):
if self.player.finished:
nearpos = self.player.pos + direction
near = self.tm.at(nearpos)
if near == WALL_TILE:
return
self.player.add_move(direction)
def check_player_square(self):
field = self.tm.at(self.player.pos)
if field == EXIT_TILE:
self.game.exit()
elif field in FRUIT:
self.score += 100
self.tm.set_tile(self.player.pos, '.')
def run(self):
self.game.event_loop(figure_moves=self.move, draw_func=self.draw)
class CollectFruit:
def __init__(self):
self.game = Game()
self.tm = TiledMap(self.game)
self.player = Sprite(self.game, 'b.pac_right', (4, 1), speed=4)
self.tm.set_map(FRUITMAP)
self.draw()
self.events = None
self.score = 0
def draw(self):
self.player.move()
self.tm.draw()
self.player.draw()
self.check_player_square()
def move(self, direction):
if self.player.finished:
nearpos = self.player.pos + direction
near = self.tm.at(nearpos)
if near == WALL_TILE:
return
self.player.add_move(direction)
def check_player_square(self):
field = self.tm.at(self.player.pos)
if field == EXIT_TILE:
self.game.exit()
elif field in FRUIT:
self.score += 100
self.tm.set_tile(self.player.pos, '.')
def run(self):
self.game.event_loop(figure_moves=self.move, draw_func=self.draw)
class Pac:
def __init__(self, frame, tile_factory, pos, level):
self.level = level
self.tile_factory = tile_factory
tile = tile_factory.get('b.pac_right')
self.sprite = Sprite(frame, tile, pos, speed=4)
self.eaten = None
self.score = 0
self.buffered_move = None
def set_direction(self, direction):
self.sprite.tile = self.tile_factory.get(PAC_TILES[direction])
def move(self, direction):
if not self.sprite.finished:
self.buffered_move = direction
return
newpos = self.sprite.pos + direction
self.set_direction(direction)
tile = self.level.at(newpos)
if tile != '#':
self.sprite.add_move(direction, when_finished=self.try_eating)
def try_eating(self):
tile = self.level.at(self.sprite.pos)
if tile != '.':
self.level.remove_dot(self.sprite.pos)
if tile == '*':
self.score += 100
else:
self.score += 1000
self.eaten = tile
def update(self):
"""Try eating dots and fruit"""
if self.sprite.finished and self.buffered_move:
self.move(self.buffered_move)
self.buffered_move = None
if not self.sprite.finished:
self.sprite.move()
def draw(self):
self.sprite.draw()
def collision(self, sprites):
for sprite in sprites:
if self.sprite.pos == sprite.sprite.pos:
return True
def die(self):
self.buffered_move = None
self.sprite.path = []
class Ghost:
def __init__(self, game, pos, level):
self.sprite = Sprite(game, GHOST_TILES[0], pos, speed=2)
self.sprite.tile = AnimatedTile(GHOST_TILES,
game.tile_factory,
game.frame,
pos,
loop=True)
self.level = level
self.direction = RIGHT
self.set_random_direction()
def get_possible_moves(self):
result = []
directions = [LEFT, RIGHT, UP, DOWN]
for vector in directions:
if not vector * -1 == self.direction:
newpos = self.sprite.pos + vector
tile = self.level.at(newpos)
if tile != '#':
result.append(vector)
if not result:
result = [self.direction * (-1)]
return result
def set_random_direction(self):
moves = self.get_possible_moves()
self.direction = random.choice(moves)
def move(self):
if self.sprite.finished:
self.set_random_direction()
self.sprite.add_move(self.direction)
else:
self.sprite.tile.move()
self.sprite.move()
def update(self):
self.move()
def draw(self):
self.sprite.draw()
class Ghost:
def __init__(self, frame, tile_factory, pos, level):
tile = tile_factory.get(GHOST_TILE)
self.level = level
self.sprite = Sprite(frame, tile, pos, self.level.get_speed())
self.direction = None
self.set_random_direction()
self.stuck = True
def get_possible_moves(self):
result = []
directions = [LEFT, RIGHT, UP, DOWN]
for vector in directions:
if vector * -1 != self.direction:
newpos = self.sprite.pos + vector
tile = self.level.at(newpos)
if tile != '#':
result.append(vector)
if not result:
result = [self.direction * (-1)]
return result
def set_random_direction(self):
moves = self.get_possible_moves()
i = random.randint(0, len(moves) - 1)
self.direction = moves[i]
def move(self):
if self.sprite.finished:
self.set_random_direction()
self.sprite.add_move(self.direction)
elif not self.stuck:
self.sprite.move()
def update(self):
self.move()
def draw(self):
self.sprite.draw()
def unstuck(self):
self.stuck = False
class MiniGame:
def __init__(self):
self.game = Game()
self.map = TiledMap(self.game)
self.map.fill_map('#', (10, 10))
self.map.set_map(MAZE)
self.map.set_tile((4,4), 'a')
self.game.frame.print_text("Hello World", (32, 330))
self.sprite = Sprite(self.game, 'b.pac_right', (1, 1), speed=4)
self.game.event_loop(figure_moves=self.move, draw_func=self.draw)
def draw(self):
self.sprite.move()
self.map.draw()
self.sprite.draw()
def move(self, direction):
self.sprite.add_move(direction)
class SpaceshipSprite:
def __init__(self, frame, tile_factory, pos, level):
self.frame = frame
self.tile_factory = tile_factory
self.level = level
self.sprite = None
self.create_sprite(pos)
self.direction = DOWN
self.crashed = False
self.finished = False
def is_moving(self):
if not self.sprite.finished:
return True
def create_sprite(self, pos):
tile = self.tile_factory.get('rot.rechts')
self.sprite = Sprite(self.frame, tile, pos, SHIP_SPEED)
def set_direction(self, direction):
if direction in (UP, DOWN):
self.direction = direction
self.sprite.add_move(self.direction)
newpos = self.sprite.pos + self.direction
#tile = self.level.at(newpos)
#if tile in ('#', '+'):
# self.crashed = True
def draw(self):
if self.is_moving():
self.sprite.move()
self.sprite.draw()
@property
def position(self):
return self.sprite.pos
def move_forward(self):
pass
class Ghost:
def __init__(self, game, pos, level):
self.sprite = Sprite(game, GHOST_TILES[0], pos, speed=2)
self.sprite.tile = AnimatedTile(GHOST_TILES, game.tile_factory, game.frame, pos, loop=True)
self.level = level
self.direction = RIGHT
self.set_random_direction()
def get_possible_moves(self):
result = []
directions = [LEFT, RIGHT, UP, DOWN]
for vector in directions:
if not vector * -1 == self.direction:
newpos = self.sprite.pos + vector
tile = self.level.at(newpos)
if tile != '#':
result.append(vector)
if not result:
result = [self.direction * (-1)]
return result
def set_random_direction(self):
moves = self.get_possible_moves()
self.direction = random.choice(moves)
def move(self):
if self.sprite.finished:
self.set_random_direction()
self.sprite.add_move(self.direction)
else:
self.sprite.tile.move()
self.sprite.move()
def update(self):
self.move()
def draw(self):
self.sprite.draw()
class Ghost:
def __init__(self, frame, tile_factory, pos, level):
tile = tile_factory.get(GHOST_TILE)
self.sprite = Sprite(frame, tile, pos, speed=2)
self.level = level
self.direction = None
self.set_random_direction()
def get_possible_moves(self):
result = []
directions = [LEFT, RIGHT, UP, DOWN]
for vector in directions:
if vector * -1 != self.direction:
newpos = self.sprite.pos + vector
tile = self.level.at(newpos)
if tile != '#':
result.append(vector)
if not result:
result = [self.direction * (-1)]
return result
def set_random_direction(self):
moves = self.get_possible_moves()
i = random.randint(0, len(moves) - 1)
self.direction = moves[i]
def move(self):
if self.sprite.finished:
self.set_random_direction()
self.sprite.add_move(self.direction)
else:
self.sprite.move()
def update(self):
self.move()
def draw(self):
self.sprite.draw()
class SpriteTests(TestCase):
def setUp(self):
self.factory = TEST_GAME_CONTEXT.tile_factory
self.tile = self.factory.get('g')
self.frame = Frame(TEST_GAME_CONTEXT.screen, Rect(40, 50, 160, 160))
self.sprite = Sprite(self.frame, self.tile, Vector(1, 1), speed=2)
def test_sprite_pos(self):
"""Sprite has a position."""
sprite = Sprite(self.frame, self.factory.get('g'), pos=Vector(4, 3))
self.assertEqual(sprite.pos.x, 4)
self.assertEqual(sprite.pos.y, 3)
def move(self):
"""Moves sprite until movement terminates."""
while self.sprite.is_moving():
self.sprite.move()
self.frame.clear()
self.sprite.draw()
pygame.display.update()
time.sleep(SHORT_DELAY)
@showdoc
def test_move_sprite(self):
"""Sprite moves east, then southeast."""
self.sprite.add_move(RIGHT)
self.sprite.add_move(DOWNRIGHT)
self.move()
self.assertEqual(self.sprite.pos.x, 3)
self.assertEqual(self.sprite.pos.y, 2)
@showdoc
def test_priority_move_sprite(self):
"""Sprite moves southeast, then east."""
self.sprite.add_move(RIGHT)
self.sprite.add_move(DOWNRIGHT, True)
self.move()
class MazeGame:
def __init__(self):
self.game = Game()
self.map = TiledMap(self.game)
self.map.set_map(MAZE)
self.fruechte = self.fruechte_zaehlen(MAZE)
self.sprite = Sprite(self.game, 'b.pac_right', (1, 1), speed=4)
self.geist = Sprite(self.game, 'b.ghost_center', (8, 8), speed=4)
self.game.event_loop(figure_moves=self.move,
draw_func=self.draw)
def fruechte_zaehlen(self, level):
"""Zählt die einzusammelnden Obststücke"""
return len([c for c in level if c in "abcdefgh"])
def draw(self):
"""
Alles bewegen und zeichnen.
Wird von event_loop() regelmäßig aufgerufen
"""
self.map.draw()
self.sprite.move()
self.sprite.draw()
self.geist_bewegen()
self.geist.draw()
self.frucht_fressen()
self.kollision()
def geist_bewegen(self):
"""Bewegt den Geist, aber nicht durch Wände"""
if self.geist.finished:
richtung = random.choice([UP, DOWN, LEFT, RIGHT])
neues_feld = self.geist.pos + richtung
if self.map.at(neues_feld) != '#':
self.geist.add_move(richtung)
self.geist.move()
def kollision(self):
"""Prüft, ob Geist und Spieler auf dem gleichen Feld sind."""
if self.sprite.pos == self.geist.pos:
self.game.frame.print_text('VERLOREN!!!', (50, 400))
pygame.display.update()
time.sleep(5)
self.game.exit()
def frucht_fressen(self):
"""Mampft ein Obststück weg"""
if self.map.at(self.sprite.pos) in 'abcdefgh':
self.map.set_tile(self.sprite.pos, '.')
self.fruechte -= 1
if self.fruechte == 0:
self.game.frame.print_text('GEWONNEN!!!', (50, 400))
pygame.display.update()
time.sleep(5)
self.game.exit()
def move(self, direction):
"""Bewegt die Spielfigur. Wird von event_loop()
aufgerufen, wenn Pfeiltaste gedrückt"""
neues_feld = self.sprite.pos + direction
if self.sprite.finished and \
not self.map.at(neues_feld) == '#':
self.sprite.add_move(direction)
class Pac:
def __init__(self, game, pos, level):
self.game = game
self.level = level
self.sprite = Sprite(game, 'b.pac_right', pos, speed=4)
self.set_direction(RIGHT)
self.eaten = None
self.score = 0
self.buffered_move = None
def set_direction(self, direction):
tiles = PAC_TILES[direction]
tile = AnimatedTile(tiles,
self.game.tile_factory,
self.game.frame,
self.sprite.pos,
loop=True)
self.sprite.tile = tile
self.direction = direction
self.move()
def move(self, direction=None):
if direction is None:
direction = self.direction
if not self.sprite.finished:
self.buffered_move = direction
return
newpos = self.sprite.pos + direction
tile = self.level.at(newpos)
if tile != '#':
self.sprite.add_move(direction, when_finished=self.try_eating)
def try_eating(self):
tile = self.level.at(self.sprite.pos)
if tile != '.':
self.level.remove_dot(self.sprite.pos)
if tile == '*':
self.score += 100
else:
self.score += 1000
self.eaten = tile
def update(self):
"""Try eating dots and fruit"""
self.sprite.tile.move()
if self.sprite.finished and not self.buffered_move is None:
self.move(self.buffered_move)
self.buffered_move = None
if not self.sprite.finished:
self.sprite.move()
else:
self.move()
def draw(self):
self.sprite.draw()
def collision(self, ghosts):
for g in ghosts:
if self.sprite.pos == g.sprite.pos:
return True
def die(self):
self.buffered_move = None
self.sprite.path = []
class Player:
def __init__(self, frame, tile_factory, pos, level):
self.level = level
self.tile_factory = tile_factory
tile = tile_factory.get('p_red_d')
self.sprite = Sprite(frame, tile, pos, speed=4)
self.eaten = None
self.buffered_move = None
self.color = RED
self.direction = DOWN
self.lives = 3
def get_sprite_from_table(self, color, direction):
row = 0
col = 0
if color == RED:
row = 0
elif color == BLUE:
row = 1
elif color == YELLOW:
row = 2
elif color == PURPLE:
row = 3
elif color == GREEN:
row = 4
elif color == ORANGE:
row = 5
if direction == UP:
col = 0
if direction == DOWN:
col = 1
if direction == LEFT:
col = 2
if direction == RIGHT:
col = 3
return self.tile_factory.get(FIGURE_SPRITES[row][col])
def set_direction(self, direction):
self.direction = direction
self.sprite.tile = self.get_sprite_from_table(self.color,
self.direction)
def set_color(self, color):
self.color = color
self.sprite.tile = self.get_sprite_from_table(self.color,
self.direction)
def move(self, direction):
if not self.sprite.finished:
self.buffered_move = direction
return
nearpos = self.sprite.pos + direction
self.set_direction(direction)
near = self.level.at(nearpos)
allowedToMove = near == self.color and near != '#' or near == 'w' or near == 'i' or near == 's'
# Allows movement to portal tiles if player color matches
if near == '1' and BLUE == self.color:
allowedToMove = True
elif near == '2' and RED == self.color:
allowedToMove = True
elif near == '3' and YELLOW == self.color:
allowedToMove = True
elif near == '4' and GREEN == self.color:
allowedToMove = True
elif near == '5' and ORANGE == self.color:
allowedToMove = True
elif near == '6' and PURPLE == self.color:
allowedToMove = True
if allowedToMove:
self.sprite.add_move(direction)
movesound.play()
else:
blocksound.play()
def update(self):
if self.sprite.finished and self.buffered_move:
self.move(self.buffered_move)
self.buffered_move = None
if not self.sprite.finished:
self.sprite.move()
def draw(self):
self.sprite.draw()
def collision(self, sprites):
for sprite in sprites:
if self.sprite.pos == sprite.sprite.pos:
return True
def die(self):
self.buffered_move = None
self.sprite.path = []
damsound.play()
class Pac:
def __init__(self, game, pos, level):
self.game = game
self.level = level
self.sprite = Sprite(game, 'b.pac_right', pos, speed=4)
self.set_direction(RIGHT)
self.eaten = None
self.score = 0
self.buffered_move = None
def set_direction(self, direction):
tiles = PAC_TILES[direction]
tile = AnimatedTile(tiles, self.game.tile_factory, self.game.frame, self.sprite.pos, loop=True)
self.sprite.tile = tile
self.direction = direction
self.move()
def move(self, direction=None):
if direction is None:
direction = self.direction
if not self.sprite.finished:
self.buffered_move = direction
return
newpos = self.sprite.pos + direction
tile = self.level.at(newpos)
if tile != '#':
self.sprite.add_move(direction, when_finished=self.try_eating)
def try_eating(self):
tile = self.level.at(self.sprite.pos)
if tile != '.':
self.level.remove_dot(self.sprite.pos)
if tile == '*':
self.score += 100
else:
self.score += 1000
self.eaten = tile
def update(self):
"""Try eating dots and fruit"""
self.sprite.tile.move()
if self.sprite.finished and not self.buffered_move is None:
self.move(self.buffered_move)
self.buffered_move = None
if not self.sprite.finished:
self.sprite.move()
else:
self.move()
def draw(self):
self.sprite.draw()
def collision(self, ghosts):
for g in ghosts:
if self.sprite.pos == g.sprite.pos:
return True
def die(self):
self.buffered_move = None
self.sprite.path = []
