def __init__(self, game, x, y, hp):
self.groups = game.enemy_list, game.sprite_list
pg.sprite.Sprite.__init__(self, self.groups)
self.layer = ENEMY_LAYER
self.game = game
self.rot = random.randint(0, 360)
self.image = pg.transform.rotate(self.game.enemy_img, self.rot)
self.rect = self.image.get_rect()
self.width = self.rect.width
self.pos = vec(x, y)
self.vel = vec(0, 0)
self.acc = vec(0, 0)
self.avoid_wall = vec(0, 0)
self.avoid_enemy = vec(0, 0)
self.hp = hp
self.chase = False
self.speed = ENEMY_SPEED
self.damage = ENEMY_DAMAGE
self.hitbox = ENEMY_HITBOX
self.hitbox.center = self.pos
self.wait_count = 0
self.animation = self.game.enemy_idle
self.animation_count = 0
def __init__(self, pos, damage):
super().__init__()
self.rect = pg.Rect(0, 0, 5, 5)
self.rect.center = pos
self.speed = 20
self.damage = damage
self.pos = vec()
self.pos.xy = pos
self.vel = vec()
self.vel.xy = 0, 0
self.target_sprite = None
def remove_enemy(cls, index, enemies, enemies_start_pos):
# reposition for enemyes
enemies[index].grid_pos = vec(enemies_start_pos[index])
# form grid to pixel
enemies[index].pix_pos = enemies[index].from_grid_to_pix_pos(
enemies[index].grid_pos)
enemies[index].direction = NEUTRAL
def __init__(self, width=400, height=300):
self.width = width
self.height = height
self.cap = cv.VideoCapture()
self.cap.open(0)
self.frame = None
pygame.init()
self.screen = pygame.display.set_mode((width, height))
self.clock = pygame.time.Clock()
self.player = Player(vec(self.width // 2, self.height - 20))
self.ball = Ball(vec(self.width // 2 - 25, self.height // 2), 10.)
self.bricks = self.generate_bricks()
self.key_down = {}
self.state = None
self.set_state("standby")
def __init__(self, x, y, height, width):
self.x, self.y = x, y
# no image to draw, just used for rect dimensions
self.rect = Rect(x, y + height, width, height)
self.rect.x = x
self.rect.y = y
self.origin = vec(self.x, self.y)
def update_vel(self):
# Update the velocity and position
target = vec()
target.xy = self.target_sprite.rect.center
desired = (target - self.pos)
desired.normalize_ip()
desired *= self.speed
self.vel = desired
def remove_life(self, player, player_start_pos, enemies,
enemies_start_pos):
player.lives -= 1
if (player.lives == 0):
return "game over"
else:
player.grid_pos = vec(player_start_pos)
# form grid to pixel
player.pix_pos = player.from_grid_to_pix_pos(player.grid_pos)
player.direction = NEUTRAL
#reposition for enemyes
for index, enemy in enumerate(enemies):
enemy.grid_pos = vec(enemies_start_pos[index])
# form grid to pixel
enemy.pix_pos = enemy.from_grid_to_pix_pos(enemy.grid_pos)
enemy.direction = NEUTRAL
return 'playing'
def reset(self, player, enemies, player_start_pos, enemies_start_pos,
screen):
player.lives = 3
player.current_score = 0
player.grid_pos = vec(player_start_pos)
# form grid to pixel
player.pix_pos = player.from_grid_to_pix_pos(player.grid_pos)
player.direction = NEUTRAL
for index, enemy in enumerate(enemies):
enemy.grid_pos = vec(enemies_start_pos[index])
# form grid to pixel
enemy.pix_pos = enemy.from_grid_to_pix_pos(enemy.grid_pos)
enemy.direction = NEUTRAL
self.coins = []
# redraws coins
_, coins, biscuits, _, _ = Utils.read_layout(screen)
state = 'playing'
return state, coins, biscuits
def move(self, vx, vy):
self.vel = vec(vx, vy)
self.pos += self.vel * self.game.dt
##undo if results in a wall collision
if (self.wall_collision()):
self.pos -= self.vel * self.game.dt
self.rect.center = self.pos
self.hitbox.center = self.pos
def __init__(self, game, x, y):
self.groups = game.sprite_list
pg.sprite.Sprite.__init__(self, self.groups)
self.layer = WALL_LAYER
self.game = game
self.image = self.game.floor_img
self.rect = self.image.get_rect()
self.pos = vec(x + TILE_SIZE / 2, y + TILE_SIZE / 2)
self.rect.center = self.pos
def __init__(self, game, x, y, angle):
self.groups = game.bullet_list, game.sprite_list
pg.sprite.Sprite.__init__(self, self.groups)
self.layer = BULLET_LAYER
self.game = game
self.angle = angle
self.image = pg.Surface([4, 4])
self.image.fill(RED)
self.rect = self.image.get_rect()
self.speed_magnitude = BULLET_SPEED
self.damage = BULLET_DAMAGE
self.pos = vec(x, y)
self.orig_pos = vec(x, y)
self.rect.center = self.pos
self.vel = vec(self.speed_magnitude * cos(self.angle),
self.speed_magnitude * sin(self.angle))
self.vel.normalize()
self.vel *= BULLET_SPEED
def move(self):
self.rot = (self.game.player.pos - self.pos).angle_to(vec(1, 0))
self.image = pg.transform.rotate(self.animation[self.animation_count],
self.rot)
self.rect = self.image.get_rect()
self.acc = vec(1, 0).rotate(-self.rot)
self.avoid_enemies()
self.avoid_walls()
if self.acc.length() > 0:
self.acc.scale_to_length(self.speed)
self.acc -= 2 * self.vel
self.vel += self.acc * self.game.dt
self.pos += self.vel * self.game.dt + 0.5 * self.acc * self.game.dt**2
if (self.wall_collision()):
self.pos -= self.vel * self.game.dt + 0.5 * self.acc * self.game.dt**2
self.vel *= -WALL_BOUNCE
self.rect.center = self.pos
self.hitbox.center = self.pos
def __init__(self, game, x, y, list):
self.groups = game.sprite_list
pg.sprite.Sprite.__init__(self, self.groups)
self.game = game
self.pos = vec(x, y)
self.list = list
self.image = self.list[0]
self.rect = self.image.get_rect()
self.rect.center = self.pos
self.current = 0
def __init__(self, game, x, y):
self.groups = game.sprite_list
pg.sprite.Sprite.__init__(self, self.groups)
self.layer = PLAYER_LAYER
self.pos = vec(x, y)
self.vel = vec(0, 0)
self.rot = 0
self.game = game
self.image = self.game.player_img
self.rect = self.image.get_rect()
self.width = self.rect.width
self.game = game
self.rect.center = self.pos
self.hitbox = PLAYER_HITBOX
self.hp = PLAYER_HP
self.hitbox.center = self.pos
self.hit_vel = vec(0, 0)
self.hit_count = 0
self.hit = False
def read_layout(self, background):
walls = []
coins = []
biscuits = []
enemies_start_pos = []
with open('../media/wall.txt', 'r') as file:
for height, line in enumerate(file):
for width, char in enumerate(line):
if char == '1':
walls.append(vec(width, height))
elif char == 'C':
coins.append(vec(width, height))
elif char == 'P':
player_start_pos = [width, height]
elif char == 'R':
biscuits.append(vec(width, height))
elif char in ['2', '3', '4', '5']:
enemies_start_pos.append([width, height])
elif char == 'B':
pygame.draw.rect(
background, BLACK,
(width * CELL_W, height * CELL_H, CELL_W, CELL_H))
return walls, coins, biscuits, player_start_pos, enemies_start_pos
def __init__(self, game, x, y, rate, cap, range, hp, delay):
self.groups = game.spawner_list, game.sprite_list
pg.sprite.Sprite.__init__(self, self.groups)
self.layer = WALL_LAYER
self.game = game
self.pos = vec(x, y + TILE_SIZE)
self.image = self.game.spawner_img
self.rect = self.image.get_rect()
self.rect.bottomleft = self.pos
self.width = self.rect.width
self.hitbox = SPAWNER_HITBOX
self.hitbox.center = self.rect.center
self.rate = rate ##how many seconds to pass between spawns
self.count = 0
self.cap = cap #zombies per spawn
self.range = range ##radius of eligible spawn locations
self.delay = delay ##ticks to wait until first spawn
self.hp = hp
def spawn_enemies(self):
self.enemies_spawned = 0
num_tries = 0
while (self.enemies_spawned < self.cap):
r1 = random.randint(-self.range, self.range)
r2 = random.randint(-self.range, self.range)
spawn_pos = vec(r1, r2) + self.rect.center
too_close = False
for sprite in self.game.sprite_list:
dist = spawn_pos - sprite.pos
if abs(dist.length()) < SPAWNER_BUFFER:
too_close = True
break
if not too_close:
enemy = Enemy(self.game, (spawn_pos[0]), (spawn_pos[1]),
ENEMY_HP)
self.enemies_spawned += 1
num_tries += 1
if num_tries > SPAWN_ATTEMPTS:
break
def __init__(self, ball):
super().__init__(vec(ball.rect.center), ball.r)
def __init__(self, pos, r):
self.r = r
self.rect = pygame.Rect(pos.elementwise() - r, (r * 2, r * 2))
self.vel = vec(0, -BALL_SPEED)
def from_grid_to_pix_pos(self, grid_pos):
return vec(((grid_pos.x-1)%CELL_W)*CELL_W + TOP_BOTTOM_BUFFER+CELL_W //4,
((grid_pos.y-1)%CELL_H)*CELL_H + TOP_BOTTOM_BUFFER+CELL_H //4)