class GameEvent(game_object.GameObject):
def __init__(self):
game_object.GameObject.__init__(self, 0, 0)
self.delay = FrameCounter(random.randint(200, 300))
self.platform_spawner = PlatformSpawner()
game_object.add(self.platform_spawner)
self.platform_flying_spawner = PlatformFlyingSpawner()
game_object.add(self.platform_flying_spawner)
self.platform_flying_spawner.counter.expired = True
self.carrot_spawner = CarrotSpawner()
game_object.add(self.carrot_spawner)
self.items_spawner = ItemsSpawner()
game_object.add(self.items_spawner)
def update(self):
self.delay.run()
if self.delay.expired:
self.platform_spawner.counter_blank.reset()
self.platform_flying_spawner.counter.reset()
self.delay.reset()
class EnemyTower(GameObject):
def __init__(self, x, y):
GameObject.__init__(self, x, y)
# 1 load image
self.image_urls = [
"assets/images/sprite/enemy/tower/tower1.png",
"assets/images/sprite/enemy/tower/tower2.png",
"assets/images/sprite/enemy/tower/tower3.png",
"assets/images/sprite/enemy/tower/tower4.png"
]
self.renderer = Animation(self.image_urls, True)
self.frame_counter = FrameCounter(100)
def update(self):
self.frame_counter.run()
if self.frame_counter.expired:
for game_object in game_objects:
if type(game_object) == Player:
pygame.mixer.Channel(4).play(
pygame.mixer.Sound("music/player/tower shoot.wav"))
bullet_enemy = BulletEnemy(11 * 16, 15 * 16, game_object.x,
game_object.y)
add(bullet_enemy)
self.frame_counter.reset()
def render(self, canvas):
GameObject.render(self, canvas)
class PlatformSpawner(GameObject):
def __init__(self):
GameObject.__init__(self, 0, 0)
self.counter_continue = FrameCounter(20)
self.counter_blank = FrameCounter(game_object.blank_time)
self.renderer = None
self.is_spawning = True
self.counter_blank.expired = True
def change_timer(self):
self.counter_blank.count_max = game_object.blank_time
print(game_object.blank_time)
def update(self):
if self.counter_blank.expired:
self.is_spawning = True
self.change_timer()
# print('hello')
else:
self.is_spawning = False
self.counter_blank.run()
print(self.counter_blank.count)
if self.is_spawning:
self.counter_continue.run()
if self.counter_continue.expired:
self.spawn()
self.counter_continue.reset()
def spawn(self):
platform = game_object.recycle(Platform, 1343, 650)
platform.v_x = 3
class Animation:
def __init__(self, image_urls, loop=False, frame_delay=3):
self.images = [
pygame.image.load(image_url) for image_url in image_urls
]
self.image_index = 0
self.finished = False
self.frame_counter = FrameCounter(frame_delay)
self.loop = loop
def render(self, canvas, x, y):
if not self.finished or self.loop:
# 1 Display current image
current_image = self.images[self.image_index]
width = current_image.get_width()
height = current_image.get_height()
render_pos = (x - width / 2, y - height / 2)
canvas.blit(current_image, render_pos)
# 2 Run frame counter
self.frame_counter.run()
# 3 If frame counter expires, change image
if self.frame_counter.expired:
self.frame_counter.reset()
if self.image_index < len(self.images) - 1:
self.image_index += 1
elif self.loop:
self.image_index = 0
else:
self.finished = True
class Carrot(GameObject):
def __init__(self, x, y):
GameObject.__init__(self, x, y)
self.box_collider = BoxCollider(64, 32)
self.renderer = Animation([
"images/carrot_animation/carrot1.png",
"images/carrot_animation/carrot2.png",
"images/carrot_animation/carrot3.png",
"images/carrot_animation/carrot4.png",
"images/carrot_animation/carrot5.png",
"images/carrot_animation/carrot6.png"
],
loop=True)
self.spawn_counter = FrameCounter(50)
def update(self):
GameObject.update(self)
self.spawn_counter.run()
if self.spawn_counter.expired:
self.x -= 20
self.deactivate_if_needed()
# self.spawn_counter.reset()
else:
self.x -= 0
def deactivate_if_needed(self):
if self.x + 64 < 0:
self.spawn_counter.reset()
self.deactivate()
class Animation:
def __init__(self, images_url, loop=False):
self.images = [
pygame.image.load(images_url) for images_url in images_url
]
self.image_index = 0
self.finished = False
self.frame_counter = FrameCounter(10)
self.loop = loop
def render(self, canvas, x, y):
if not self.finished or self.loop:
current_image = self.images[self.image_index]
width = current_image.get_width()
height = current_image.get_height()
render_pos = (x - width / 2, y - height / 2)
canvas.blit(current_image, render_pos)
self.frame_counter.run()
if self.frame_counter.expired:
self.frame_counter.reset()
if self.image_index < len(self.images) - 1:
self.image_index += 1
elif self.loop:
self.image_index = 0
else:
self.finished = True
class BlackScreen(GameObject):
def __init__(self, x=0, y=0):
GameObject.__init__(self, x, y)
self.counter = FrameCounter(120)
self.frame_counter = FrameCounter(120)
self.screen = True
self.box_collider = BoxCollider(800, 640)
def update(self):
GameObject.update(self)
self.counter.run()
if self.counter.expired:
self.frame_counter.run()
self.screen = False
if self.frame_counter.expired:
self.screen = True
self.counter.reset()
self.frame_counter.reset()
def render(self, canvas):
if not self.screen:
BLACK = (0, 0, 0)
rect = (0, 0, 800, 640)
pygame.draw.rect(canvas, BLACK, rect, 1)
canvas.fill(BLACK)
class EnemySpawner(GameObject):
def __init__(self):
GameObject.__init__(self, 0, 0)
self.counter = FrameCounter(100) # 2 / 0.017
def update(self):
self.counter.run()
if self.counter.expired:
enemy = Enemy(100, 0)
game_object.add(enemy)
self.counter.reset()
class Player(GameObject):
def __init__(self, x, y, input_manager):
GameObject.__init__(self, x, y)
self.image = pygame.image.load('image/player.png')
self.input_manager = input_manager
self.shoot_lock = False
self.counter = FrameCounter(30)
self.hp = 10
def update(self):
GameObject.update(self)
self.move()
self.shoot()
def move(self):
dx = 0
dy = 0
if self.input_manager.right_pressed:
if self.x + 3 > 775:
dx = 0
else:
dx += 3
if self.input_manager.left_pressed:
if self.x - 3 < 27:
dx = 0
else:
dx -= 3
if self.input_manager.down_pressed:
if self.y + 3 > 600:
dy = 0
else:
dy += 3
if self.input_manager.up_pressed:
if self.y - 3 < 40:
dy = 0
else:
dy -= 3
self.x += dx
self.y += dy
def shoot(self):
if self.input_manager.x_pressed and not self.shoot_lock:
game_object.recycle(PlayerBullet, self.x, self.y - 40)
self.shoot_lock = True
if self.shoot_lock:
self.counter.run()
if self.counter.expired:
self.shoot_lock = False
self.counter.reset()
class Shot1(GameObject):
def __init__(self, x, y):
GameObject.__init__(self, x, y)
self.image = pygame.image.load("images/player-bullet.png")
self.box_collider = BoxCollider(40, 40)
self.velocity = (0, 0)
self.returning = False
self.counter = FrameCounter(60)
def update(self):
GameObject.update(self)
self.move()
self.physics()
self.return_to_player()
def move(self):
self.vx, self.vy = self.velocity
self.y += self.vy
self.x += self.vx
# self.counter.reset()
self.counter.run()
if self.counter.expired:
self.returning = True
self.counter.reset()
def physics(self):
if self.is_active:
dog = game_object.collide_with(self.box_collider, Dog)
if dog is not None:
# self.deactivate()
# dog.deactivate()
self.returning = True
dog.returning = True
dog.stun_timer.reset()
enemy = game_object.collide_with(self.box_collider, Enemy)
if enemy is not None:
self.returning = True
enemy.returning = True
def return_to_player(self):
if self.is_active and self.returning:
try:
px, py = game_object.position
distance = (get_distance((self.x, self.y), (px, py)))
self.velocity = ((-px + self.x) / distance * -5,
(-py + self.y) / distance * -5)
except ZeroDivisionError:
pass
def clean(self):
self.returning = False
self.velocity = (0, 0)
class CarrotSpawner(GameObject):
def __init__(self):
GameObject.__init__(self, 0, 0)
self.image = None
self.spawn_counter = FrameCounter(200)
def update(self):
self.spawn_counter.run()
if self.spawn_counter.expired:
ran_y = random.randint(200, 600)
# print(warning_sign.x)
game_object.recycle(WarningSign, 1200, ran_y)
game_object.recycle(Carrot, 1365, ran_y)
self.spawn_counter.reset()
class DogSpawner(GameObject):
def __init__(self, x, y):
GameObject.__init__(self, x, y)
self.frame_counter = FrameCounter(700)
def update(self):
self.frame_counter.run()
if self.frame_counter.expired:
dog = self.spawn()
self.frame_counter.reset()
def spawn(self):
return game_object.recycle(Dog, self.x, self.y)
class EnemySpawner(GameObject):
def __init__(self):
GameObject.__init__(self, 0, 0)
self.counter = FrameCounter(2 // 0.017)
def update(self):
self.counter.run()
if self.counter.expired:
enemy = self.spawn()
# game_object.add(enemy)
self.counter.reset()
def spawn(self):
return game_object.recycle(Enemy, 300, 100)
class EnemySpawner(GameObject):
def __init__(self, x, y):
GameObject.__init__(self, 0, 200)
self.frame_counter = FrameCounter(tower_defense.game_object.wave)
def update(self):
GameObject.update(self)
self.frame_counter.run()
if tower_defense.game_object.hasTower == True:
if self.frame_counter.flag:
tower_defense.game_object.hasEnemy = True
enemy = Enemy(425, 0)
add(enemy)
self.frame_counter.reset()
if tower_defense.game_object.score >= 60 and tower_defense.game_object.score < 65:
self.frame_counter = FrameCounter(15)
class Player(GameObject):
# 1. Create constructor (properties)
def __init__(self, x, y, input_manager):
GameObject.__init__(self, x, y)
self.input_manager = input_manager
self.shoot_lock = False
self.counter = FrameCounter(30)
self.renderer = PlayerAnimator()
self.dx = 0
self.dy = 0
# 2. Describe action / method / behavior
def update(self):
GameObject.update(self)
self.move()
self.update_animator()
self.shoot()
def update_animator(self):
self.renderer.update(self.dx, self.dy)
def move(self):
self.dx = 0
self.dy = 0
if self.input_manager.right_pressed:
self.dx += 3
if self.input_manager.left_pressed:
self.dx -= 3
if self.input_manager.down_pressed:
self.dy += 3
if self.input_manager.up_pressed:
self.dy -= 3
self.x += self.dx
self.y += self.dy
def shoot(self):
if self.input_manager.x_pressed and not self.shoot_lock:
game_object.recycle(PlayerBullet, self.x, self.y - 40)
self.shoot_lock = True
if self.shoot_lock:
self.counter.run()
if self.counter.expired:
self.shoot_lock = False
self.counter.reset()
class ItemsSpawner(GameObject):
def __init__(self):
GameObject.__init__(self, 0, 0)
self.counter = FrameCounter(150)
self.image = None
def update(self):
self.counter.run()
if self.counter.expired:
self.spawn()
# enemy = Enemy(100, 0)
# game_object.add(enemy)
self.counter.reset()
def spawn(self):
ran_y = random.randint(100, 600)
game_object.recycle(Items, 1343, ran_y)
class EnemySpawner(GameObject):
def __init__(self):
GameObject.__init__(self, 0, 0)
self.counter = FrameCounter(100)
self.count = 0
def update(self):
self.counter.run()
self.count += 1
if self.counter.expired:
enemy = Enemy(randint(30, 670), randint(0, 50))
game_object.add(enemy)
self.counter.reset()
if self.count > 2000:
if self.counter.count == 50:
enemy = Enemy(randint(30, 670), randint(0, 50))
game_object.add(enemy)
class WarningSign(GameObject):
def __init__(self, x, y):
GameObject.__init__(self, x, y)
self.renderer = Animation(["images/warning_sign.png"], loop=True)
self.box_collider = BoxCollider(64, 64)
self.count = FrameCounter(50)
pygame.mixer.Channel(3).play(
pygame.mixer.Sound("music/warning (1).wav"))
def update(self):
GameObject.update(self)
# self.x = 1000
self.count.run()
if self.count.expired:
self.deactivate_if_needed()
self.count.reset()
def deactivate_if_needed(self):
self.deactivate()
class Player(GameObject):
def __init__(self, x, y, input_manager):
GameObject.__init__(self, x, y)
self.input_manager = input_manager
self.image = pygame.image.load("images/player/player1.png")
self.shoot_lock = False
self.counter = FrameCounter(20)
def update(self):
self.move()
self.shoot()
def move(self):
dx = 0
dy = 0
step = 5
if self.input_manager.up_pressed:
dy -= step
if self.input_manager.down_pressed:
dy += step
if self.input_manager.left_pressed:
dx -= step
if self.input_manager.right_pressed:
dx += step
self.x += dx
self.y += dy
def shoot(self):
if self.input_manager.x_pressed and not self.shoot_lock:
bullet = game_object.recycle(PlayerBullet, self.x, self.y - 25)
# game_object.add(bullet)
self.shoot_lock = True
if self.shoot_lock:
self.counter.run()
if self.counter.expired:
self.shoot_lock = False
self.counter.reset()
class PlatformFlyingSpawner(GameObject):
def __init__(self):
GameObject.__init__(self, 0, 0)
self.counter = FrameCounter(game_object.flying_counter)
self.image = None
def change_counter(self):
self.counter.count_max = game_object.flying_counter
def update(self):
self.counter.run()
if self.counter.expired:
self.spawn()
# platform_flying = PlatformFlying(1343, 450)
# game_object.add(platform_flying)
self.counter.reset()
self.change_counter()
def spawn(self):
platform_speed = 6
end_index = random.randint(4, 6)
ran_y = random.randint(200, 570)
for i in range(end_index):
if i == 0:
spike = game_object.recycle(SpikeLeft, 1343 + i * 64 - 64 + 27,
ran_y)
spike.v_x = platform_speed
if i == end_index - 1:
spike = game_object.recycle(SpikeRight, 1343 + i * 64 - 27,
ran_y)
spike.v_x = platform_speed
else:
platform = game_object.recycle(Platform, 1343 + i * 64, ran_y)
platform.v_x = platform_speed
class Player(GameObject):
def __init__(self, x, y, input_manager):
GameObject.__init__(self, x, y)
self.input_manager = input_manager
self.image = pygame.image.load("images/player/player1.png")
self.counter1 = FrameCounter(120)
self.counter2 = FrameCounter(120)
self.has_shoot1 = True
self.has_shoot2 = True
self.dog_count = 0
self.box_collider = BoxCollider(70, 70)
def update(self):
GameObject.update(self)
self.move()
self.shoot_left()
self.shoot_right()
self.physics()
# if self.has_shoot1 and self.has_shoot2:
# mouse.image = mouse.all
# elif self.has_shoot1:
# mouse.image = mouse.left
# elif self.has_shoot2:
# mouse.image = mouse.right
def move(self):
dx = 0
dy = 0
step = 5
if self.input_manager.up_pressed:
dy -= step
if self.input_manager.down_pressed:
dy += step
if self.input_manager.left_pressed:
dx -= step
if self.input_manager.right_pressed:
dx += step
self.x += dx
self.y += dy
def shoot_left(self):
if self.input_manager.left_mouse_clicked and self.has_shoot1:
self.has_shoot1 = False
# print('left hitu')
# game_object.recycle(Shot1)
try:
distance = (get_distance(
(self.x, self.y),
(self.input_manager.mouse_x, self.input_manager.mouse_y)))
shot1 = game_object.recycle(Shot1, self.x, self.y)
shot1.velocity = ((self.input_manager.mouse_x - self.x) /
distance * 5,
(self.input_manager.mouse_y - self.y) /
distance * 5)
shot1.counter.reset()
except ZeroDivisionError:
# game_object.add(shot1)
pass
# pass
def shoot_right(self):
if self.input_manager.right_mouse_clicked and self.has_shoot2:
self.has_shoot2 = False
try:
distance = (get_distance(
(self.x, self.y),
(self.input_manager.mouse_x, self.input_manager.mouse_y)))
shot2 = game_object.recycle(Shot2, self.x, self.y - 10)
shot2.velocity = ((self.input_manager.mouse_x - self.x) /
distance * 10,
(self.input_manager.mouse_y - self.y) /
distance * 10)
shot2.time_before_disappear.reset()
except ZeroDivisionError:
# game_object.add(shot1)
pass
if self.has_shoot2 == False:
self.counter2.run()
if self.counter2.expired:
self.has_shoot2 = True
self.counter2.reset()
def physics(self):
if self.is_active:
shot1 = game_object.collide_with(self.box_collider, Shot1)
if shot1 is not None and shot1.returning:
self.has_shoot1 = True
shot1.deactivate()
class Player(GameObject):
def __init__(self, x, y, input_manager):
GameObject.__init__(self, x, y)
self.overlap = False
# 1 load image
self.renderer = ImageRenderer("assets/images/sprite/player_left.png")
self.width = 15
self.height = 15
self.box_collider = BoxCollider(self.width, self.height)
self.speed = 4
self.dx = 0
self.dy = 0
self.shootX = -6
self.shootY = 0
self.frame_counter = FrameCounter(10)
self.shoot_lock = True
self.can_shoot = False
self.hp = 100
self.count_coin = 0
self.count_enemy = 0
self.input_manager = input_manager
def update(self):
if len(gamelevel) == 8:
self.lose()
self.move()
self.shoot()
self.check_overlap_with_enemy()
def render(self, canvas):
GameObject.render(self, canvas)
pygame.draw.rect(canvas, (173, 1, 1),
pygame.Rect(200, 10, self.hp, 10))
def check_overlap(self):
for game_object in game_objects:
if type(game_object) == Wall:
overlap = BoxCollider.overlap(self.box_collider,
game_object.box_collider)
if overlap:
self.overlap = True
def move(self):
self.dx = 0
self.dy = 0
GameObject.update(self)
if self.input_manager.up_pressed:
pygame.mixer.Channel(0).play(
pygame.mixer.Sound("music/player/player_move.wav"))
self.shootX = 0
self.shootY = -6
self.renderer = ImageRenderer("assets/images/sprite/player_up.png")
self.box_collider.y = self.y - self.speed
self.check_overlap()
if self.overlap:
self.dy += 0
else:
self.dy += -self.speed
elif self.input_manager.down_pressed:
pygame.mixer.Channel(1).play(
pygame.mixer.Sound("music/player/player_move.wav"))
self.shootX = 0
self.shootY = 6
self.renderer = ImageRenderer(
"assets/images/sprite/player_down.png")
self.box_collider.y = self.y + self.speed
self.check_overlap()
if self.overlap:
self.dy += 0
else:
self.dy += self.speed
elif self.input_manager.left_pressed:
pygame.mixer.Channel(1).play(
pygame.mixer.Sound("music/player/player_move.wav"))
self.shootX = -6
self.shootY = 0
self.renderer = ImageRenderer(
"assets/images/sprite/player_left.png")
self.box_collider.x = self.x - self.speed
self.check_overlap()
if self.overlap:
self.dx += 0
else:
self.dx += -self.speed
elif self.input_manager.right_pressed:
pygame.mixer.Channel(1).play(
pygame.mixer.Sound("music/player/player_move.wav"))
self.shootX = 6
self.shootY = 0
self.renderer = ImageRenderer(
"assets/images/sprite/player_right.png")
self.box_collider.x = self.x + self.speed
self.check_overlap()
if self.overlap:
self.dx += 0
else:
self.dx += self.speed
self.x += self.dx
self.y += self.dy
self.box_collider.x = self.x
self.box_collider.y = self.y
self.overlap = False
if len(gamelevel) == 3:
enemy = Enemy1(6 * 16, 13.5 * 16, 5, 0, 5, "tank")
enemy.hp = 50
enemy1 = Enemy1(10 * 16, 3 * 16, -2, 0, 2, "tank")
enemy1.hp = 50
game_object.add(enemy)
game_object.add(enemy1)
gamelevel.append("*")
def shoot(self):
if self.can_shoot:
if self.input_manager.x_pressed and not self.shoot_lock:
pygame.mixer.Channel(2).play(
pygame.mixer.Sound("music/player/player_shoot.wav"))
bullet_player = BulletPlayer(self.x, self.y, self.shootX,
self.shootY)
game_object.add(bullet_player)
self.shoot_lock = True
if self.shoot_lock:
self.frame_counter.run()
if self.frame_counter.expired:
self.shoot_lock = False
self.frame_counter.reset()
def lose(self):
global_scene_manager.change_scene(GameOverScene())
gamelevel.clear()
def check_overlap_with_enemy(self):
for game_object in game_objects:
if type(game_object) == Enemy or type(game_object) == Enemy1:
overlap = BoxCollider.overlap(self.box_collider,
game_object.box_collider)
if overlap:
self.lose()
for game_object in game_objects:
if type(game_object) == BulletEnemy or type(
game_object) == BulletTank:
overlap = BoxCollider.overlap(self.box_collider,
game_object.box_collider)
if overlap:
self.hp += -game_object.dam
game_object.deactivate()
if self.hp <= 0:
self.lose()
class Enemy1(GameObject):
def __init__(self, x, y, dx, dy, speed, _type):
GameObject.__init__(self, x, y)
self.frame_counter = FrameCounter(40)
self.overlap = False
self._type = _type
self.die = False
# 1 load image
self.renderer = EnemyAnimator(self._type)
self.width = 20
self.height = 20
self.box_collider = BoxCollider(self.width, self.height)
self.directory = [1, 2, 3, 4]
self.speed = speed
self.dx = 0
self.dy = self.speed
self.hp = 15
def update(self):
if self._type == "tank" and self.speed == 2:
self.frame_counter.run()
if self.frame_counter.expired:
pygame.mixer.Channel(5).play(
pygame.mixer.Sound("music/player/tank_fire.wav"))
bullet_enemy = BulletTank(self.x, self.y, self.dx, self.dy)
game_object.add(bullet_enemy)
self.frame_counter.reset()
GameObject.update(self)
self.renderer.update(self.dx, self.dy, self.die)
if self.x > 520:
self.dx = -self.speed
self.dy = 0
else:
self.check_overlap()
if not self.overlap:
self.directory = [1, 2, 3, 4]
else:
if len(self.directory) == 0:
self.directory = [1, 2, 3, 4]
move = choice(self.directory)
if move == 1:
self.dy = self.speed
self.dx = 0
elif move == 2:
self.dy = -self.speed
self.dx = 0
elif move == 3:
self.dx = self.speed
self.dy = 0
elif move == 4:
self.dx = -self.speed
self.dy = 0
self.reset_boxcollide()
self.check_overlap()
if self.overlap:
self.directory.remove(move)
self.x += self.dx
self.y += self.dy
self.overlap = False
def render(self, canvas):
GameObject.render(self, canvas)
self.renderer.render(canvas, self.x, self.y)
if self.die:
self.deactivate()
def reset_boxcollide(self):
self.box_collider.y = self.y
self.box_collider.x = self.x
def check_overlap(self):
self.box_collider.y = self.y + self.dy
self.box_collider.x = self.x + self.dx
for game_object in game_objects:
if type(game_object) == Wall:
overlap = BoxCollider.overlap(self.box_collider,
game_object.box_collider)
if overlap:
self.overlap = True
class Enemy(GameObject):
def __init__(self, x, y):
GameObject.__init__(self, x, y)
self.box_collider = BoxCollider(32, 32)
self.renderer = EnemyAnimator()
self.direct = True
self.frame_counter = FrameCounter(120)
self.black_screen = False
self.counter = FrameCounter(120)
self.dy = 8
self.dx = 0
self.overlap = False
self.directory = [1, 2, 3, 4]
self.step = 8
def update(self):
GameObject.update(self)
self.update_animator()
self.frame_counter.run()
if self.frame_counter.expired:
self.black_screen = True
self.counter.run()
if self.counter.expired:
self.black_screen = False
self.counter.reset()
self.frame_counter.reset()
if not self.black_screen:
self.move()
else:
pass
collide_list = collide_with(self.box_collider, Player)
for game_object in collide_list:
game_object.deactivate()
game_over = GameOverScene()
global_scene_manager.change_scene(game_over)
def move(self):
if self.x > 768:
self.dx = -self.step
self.dy = 0
elif self.x < 32:
self.dx = self.step
self.dy = 0
elif self.y > 608:
self.dy = -self.step
self.dx = 0
elif self.y < 32:
self.dy = self.step
self.dx = 0
else:
self.check_overlap()
if not self.overlap:
self.directory = [1, 2, 3, 4]
else:
if len(self.directory) == 0:
self.directory = [1, 2, 3, 4]
move = choice(self.directory)
if move == 1:
self.dy = self.step
self.dx = 0
elif move == 2:
self.dy = -self.step
self.dx = 0
elif move == 3:
self.dx = self.step
self.dy = 0
elif move == 4:
self.dx = -self.step
self.dy = 0
self.reset_boxcollider()
self.check_overlap()
if self.overlap:
self.directory.remove(move)
self.x += self.dx
self.y += self.dy
self.overlap = False
def update_animator(self):
self.renderer.update(self.dx, self.dy)
def check_overlap(self):
self.box_collider.y = self.y + self.dy
self.box_collider.x = self.x + self.dx
for game_object in game_objects:
if type(game_object) == Wall:
overlap = BoxCollider.overlap(self.box_collider,
game_object.box_collider)
if overlap:
self.overlap = True
def reset_boxcollider(self):
self.box_collider.x = self.x
self.box_collider.y = self.y
class Player(GameObject):
def __init__(self, x, y):
GameObject.__init__(self, x, y)
self.box_collider = BoxCollider(32, 32)
self.renderer = PlayerAnimator()
self.frame_counter = FrameCounter(120)
self.counter = FrameCounter(120)
self.black_screen = False
self.dx = 0
self.dy = 0
self.win = False
self.step = 8
self.overlap = False
def check_overlap(self):
for game_object in game_objects:
if type(game_object) == Wall:
overlap = BoxCollider.overlap(self.box_collider, game_object.box_collider)
if overlap:
self.overlap = True
def update(self):
GameObject.update(self)
self.update_animator()
self.frame_counter.run()
if self.frame_counter.expired:
self.black_screen = True
self.counter.run()
if self.counter.expired:
self.black_screen = False
self.counter.reset()
self.frame_counter.reset()
if self.black_screen:
self.move()
else:
self.dy = 0
self.dx = 0
# collide_list = collide_with(self.box_collider, BlackSlave)
# for game_object in collide_list:
# game_object.deactivate()
# self.win = True
# if self.win:
# collide_list1 = collide_with(self.box_collider, MainDoor)
# for game_object in collide_list1:
# # self.deactivate()
# pass
# print("aaaa")
def update_animator(self):
self.renderer.update(self.dx, self.dy)
def move(self):
self.dx = 0
self.dy = 0
# self.check_collision()
if self.x == 768:
global_input_manager.right_pressed = False
if self.x == 32:
global_input_manager.left_pressed = False
if self.y == 608:
global_input_manager.down_pressed = False
if self.y == 32:
global_input_manager.up_pressed = False
if global_input_manager.right_pressed:
self.box_collider.x = self.x + self.step
self.check_overlap()
if self.overlap:
self.dx += 0
else:
self.dx += self.step
elif global_input_manager.left_pressed:
self.box_collider.x = self.x - self.step
self.check_overlap()
if self.overlap:
self.dx += 0
else:
self.dx -= self.step
elif global_input_manager.down_pressed:
self.box_collider.y = self.y + self.step
self.check_overlap()
if self.overlap:
self.dy += 0
else:
self.dy += self.step
elif global_input_manager.up_pressed:
self.box_collider.y = self.y - self.step
self.check_overlap()
if self.overlap:
self.dy += 0
else:
self.dy -= self.step
self.x += self.dx
self.y += self.dy
self.box_collider.x = self.x
self.box_collider.y = self.y
self.overlap = False
class Dog(GameObject):
def __init__(self, x, y):
GameObject.__init__(self, x, y)
self.image = pygame.image.load("images/enemy.png")
self.box_collider = BoxCollider(100, 100)
self.returning = False
self.velocity = (0, 0)
self.counter = FrameCounter(100)
self.spawn_lock = False
# not stun
self.stun_timer = FrameCounter(90)
self.stun_timer.count = 90
def update(self):
GameObject.update(self)
self.move()
if not self.pushed:
self.decide_movement()
self.return_to_player()
def move(self):
if self.stun_timer.expired:
# input movement here
self.velocity = (0, 0)
pass
else:
self.stun_timer.run()
self.vx, self.vy = self.velocity
self.y += self.vy
self.x += self.vx
if self.x >= 1270:
self.x = 1270
if self.x <= 10:
self.x = 10
if self.y >= 710:
self.y = 710
if self.y <= 10:
self.y = 10
def return_to_player(self):
if self.is_active and self.returning:
try:
px, py = game_object.position
distance = (get_distance((self.x, self.y), (px, py)))
self.velocity = ((-px + self.x) / distance * -5,
(-py + self.y) / distance * -5)
except ZeroDivisionError:
pass
def clean(self):
self.velocity = (0, 0)
self.returning = False
self.pushed = False
def decide_movement(self):
if not self.spawn_lock:
self.spawn_lock = True
if self.spawn_lock:
self.counter.run()
if self.counter.expired:
self.spawn_lock = False
self.counter.reset()
