def __init__(self, util):
self.util = util
self.level_solved = False
self.player_1 = Player(self, 2, 21)
self.player_2 = Player(self, 2, 18)
self.player_3 = Player(self, 2, 15)
self.player_4 = Player(self, 2, 12)
self.player_5 = Player(self, 2, 9)
self.players = [
self.player_1, self.player_2, self.player_3, self.player_4,
self.player_5
]
self.door_1 = Door(29, 21)
self.door_2 = Door(29, 18)
self.door_3 = Door(29, 15)
self.door_4 = Door(29, 12)
self.door_5 = Door(29, 9)
self.doors = [
self.door_1, self.door_2, self.door_3, self.door_4, self.door_5
]
self.walls = []
self.pillars = []
self.level = Level2(self)
def __init__(self, name, screen, screen_height, screen_width):
Player.__init__(self, name, screen, screen_height, screen_width)
try:
self.predictive_model = load_model('pong_conv2d.h5')
self.y_mean = joblib.load(y_mean_dir)
self.x_mean = joblib.load(x_mean_dir)
except Exception as e:
print Exception
print "Models or parameters above not found, train the model first"
print """To train the model use pong2players.py script to gather
def test_destroy(self):
game_data.game_objects.clear()
cords = Vector(10, 20)
size_p = Size(30, 30)
player = Player(cords.x, cords.y, size_p)
Player.fire(player)
bullet = self.find_bullet()
self.assertIsNotNone(bullet)
self.assertIsNotNone(player.bullet)
bullet.destroy()
self.assertEqual(game_data.game_objects[-1].name, "Animation")
self.assertIn(bullet.id, game_data.for_destroy)
self.assertIsNone(player.bullet)
def read_map_data(args):
args = clean_list(args)
# stage length is determined by the first map row.
stage_length = 0
y = 0
for index, line in enumerate(args):
x = 0
line = line.rstrip().split(',')
for column in line:
column = column.capitalize()
if column in map_data:
if column == 'G': # ground
ground = Ground(0, 0, 70, 70, x, y)
map_data[column].append(ground)
elif column == 'I': # ice
ice = Ice(0, 0, 70, 70, x, y)
map_data[column].append(ice)
elif column == 'R': # rock
rock = Rock(0, 0, 70, 70, x, y)
map_data[column].append(rock)
elif column == 'C': # coin
coin = Coin(0, 0, 38, 38, x + 19, y + 19)
map_data[column].append(coin)
elif column == 'E': # enemy
enemy = Enemy(0, 0, 70, 30, x, y)
map_data[column].append(enemy)
elif column == 'S': # spike
spike = Spike(0, 0, 70, 35, x, y + 35)
map_data[column].append(spike)
elif column == 'F': # flag
if map_data[
column] is not None: #only one winning flag per game
raise CorruptedMapFileError(
"Only one winning flag per game.")
else:
flag = Flag(0, 0, 70, 70, x, y)
map_data[column] = flag
elif column == 'B': # box
box = Box(0, 0, 70, 70, x, y)
map_data[column].append(box)
elif column == 'P': # player
if map_data[
column] is not None: # if there ia already an Player added
raise CorruptedMapFileError(
"Only one player per game!")
else:
player = Player(0, 0, 50, 29, x, y, None)
map_data[column] = player
x += 70
# set the stage_length when we are at the 0 index
if index == 0:
stage_length = x
map_data["length"] = stage_length
else:
if x != stage_length:
raise CorruptedMapFileError(
"Error while reading map data. All of the rows should have equal amount of blocks."
)
y += 70
def __init__(self, clients):
players = []
coordinates = self.get_coordinates(len(clients))
for index, client in enumerate(clients):
players.append(Player(index + 1, *next(coordinates), 'Player {}'.format(index + 1), PLAYER_COLORS[index], client))
self.players = players
self.losers = []
self.bonuses = []
self.game_log = []
self.tick = 1
def __init__(self, util):
self.util = util
self.level_solved = False
self.player = Player(self, 27, 27)
self.players = [self.player]
self.doors = []
self.walls = []
self.pillars = []
self.randomize_pillars()
self.level = Level6(self)
def __init__(self, util):
self.util = util
self.level_solved = False
self.player = Player(self, 1, 1)
self.players = [self.player]
self.door = Door(29, 15)
self.doors = [self.door]
self.walls = []
self.pillars = []
self.level = Level1(self)
def __init__(self, clients):
players = []
coordinates = self.get_coordinates(len(clients))
for index, client in enumerate(clients):
players.append(
Player(index + 1, *next(coordinates),
'Player {}'.format(index + 1),
CONSTS.PLAYER_COLORS[index], client))
self.players = players
self.losers = []
self.bonuses = []
self.game_log = []
self.events = []
self.tick = 1
self.available_bonuses = [
b for b in [Nitro, Slowdown, Saw]
if b.visio_name in CONSTS.AVAILABLE_BONUSES
]
def __init__(self, util):
self.util = util
self.level_solved = False
self.player = Player(self, 21, 22)
self.players = [self.player]
self.doors = []
self.walls = []
self.p_0 = Pillar(21, 22)
self.p_1 = Pillar(17, 22)
self.p_2 = Pillar(17, 18)
self.p_3 = Pillar(11, 18)
self.p_4 = Pillar(11, 12)
self.p_5 = Pillar(21, 12)
self.p_6 = Pillar(21, 18)
self.pillars = [self.p_0, self.p_1, self.p_2, self.p_3, self.p_4, self.p_5, self.p_6]
self.level = Level5(self)
class GameInterface(Interface):
attack: AttackPattern = None
aii: ArrayInterfaceImage = None
background_sprite: Sprite = None
batch: Batch = None
border: Rectangle = None
enemy: Enemy = None
image = None
facecam: Facecam = None
face_cascade = None
foreground_sprite: Sprite = None
fps_display: FPSDisplay = None
keys = key.KeyStateHandler()
player: Player = None
projectiles: List[Projectile] = []
powerup: Powerup = None
scheduled_functions = tuple()
def __init__(self):
super().__init__()
window = system.get_window()
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
base_path = os.path.join('images', 'space_background_pack', 'layers')
self.background = load(os.path.join(base_path, 'parallax-space-background.png'))
self.background_sprite = Sprite(self.background)
big_planet = load(os.path.join(base_path, 'parallax-space-big-planet.png'))
self.big_planet_sprite = Sprite(big_planet)
far_planet = load(os.path.join(base_path, 'parallax-space-far-planets.png'))
self.far_planet_sprite = Sprite(far_planet)
ring_planet = load(os.path.join(base_path, 'parallax-space-ring-planet.png'))
self.ring_planet_sprite = Sprite(ring_planet)
self.ring_planet_sprite.x = 100
self.ring_planet_sprite.y = 100
stars = load(os.path.join(base_path, 'parallax-space-stars.png'))
self.stars_sprite = Sprite(stars)
self.scheduled_functions = (
(self.randomize_projectiles, 2),
(self.check_direction, 1 / 120),
(self.generate_powerup, 20)
)
if config.get_config('control') == 1:
self.face_cascade = cv.CascadeClassifier(
'venv/Lib/site-packages/cv2/data/haarcascade_frontalface_default.xml')
self.facecam = Facecam(face_cascade=self.face_cascade).start()
self.aii = ArrayInterfaceImage(self.facecam.read(), 'BGR')
self.image = self.aii.texture
@self.facecam.event('on_face_move')
def follow_face(x, y, width, height):
# Need to flip things first to work
x = self.image.width - x
y = self.image.height - y
new_x = self.border.x + x - width // 2
new_y = self.border.y + y - height // 2
self.player.move(new_x, new_y)
self.scheduled_functions = (
(self.randomize_projectiles, 2),
(self.generate_powerup, 20),
)
window.push_handlers(self.facecam)
self.player = Player(src='images/ufo.png')
self.border = Rectangle(
width=(500 if not self.image else self.image.width) + 10,
height=(500 if not self.image else self.image.height) + 10,
color=(0, 0, 0, 127)
)
self.player.scale = 1.2
self.batch = Batch()
self.projectiles: List[Projectile] = []
window.push_handlers(self.keys)
def pause_game(symbol, modifiers):
if symbol == key.ESCAPE:
self.enemy.running = not self.enemy.running
self.enemy.attack_pattern.running = not self.enemy.attack_pattern.running
self.player.running = not self.player.running
window.on_key_press = pause_game
for func, interval in self.scheduled_functions:
clock.schedule_interval(func, interval)
self.fps_display = FPSDisplay(window)
self.generate_enemy(0)
self.resize()
def generate_enemy(self, dt):
enemy_index = config.get_config('enemy')
if enemy_index > len(enemies) - 1:
return system.get_window().load_interface(WinInterface())
window = system.get_window()
self.enemy = enemies[enemy_index](self.batch, speed=100)
self.enemy.move(window.width * 0.8, window.height / 2)
self.enemy.next_x, self.enemy.next_y = self.enemy.x, self.enemy.y
def on_die():
config.set_config('enemy', config.get_config('enemy') + 1)
clock.schedule_once(self.generate_enemy, 2)
self.enemy.on_die = on_die
def resize(self):
window = system.get_window()
scale = window.width / self.background.width
self.background_sprite.scale = scale
self.big_planet_sprite.scale = scale / 2
self.far_planet_sprite.scale = scale / 2
self.ring_planet_sprite.scale = scale / 2
self.stars_sprite.scale = scale
self.big_planet_sprite.x = window.width / 2
self.big_planet_sprite.y = window.height / 2
self.far_planet_sprite.x = window.width - self.far_planet_sprite.width
self.far_planet_sprite.y = window.height - self.far_planet_sprite.height
if self.image:
self.image.x = (window.width - self.image.width) / 2
self.image.y = (window.height - self.image.height) / 2
self.border.x = window.width / 2 * 0.3
self.border.y = (window.height - self.border.height) / 2
self.generate_powerup(0)
self.player.move(x=window.width / 2 * 0.3, y=window.height / 2)
def on_draw(self):
self.animate_background()
self.background_sprite.draw()
self.big_planet_sprite.draw()
self.far_planet_sprite.draw()
self.ring_planet_sprite.draw()
self.stars_sprite.draw()
self.border.draw()
if self.facecam:
img = self.facecam.read()
img = cv.flip(img, -1)
self.image.blit(self.border.x, self.border.y, 0)
self.aii.view_new_array(img)
# self.fps_display.draw()
self.player.draw()
self.batch.draw()
# self.attack.draw()
if self.enemy:
self.enemy.draw()
if self.powerup:
self.powerup.forward()
self.powerup.draw()
if self.player.check_for_collision(self.powerup):
self.powerup.on_collide(self.player)
self.powerup.delete()
self.powerup = None
def animate_background(self):
big_planet_sprite_depth = 3
far_planet_sprite_depth = 10
ring_planet_sprite_depth = 5
stars_sprite_depth = 8
window = system.get_window()
self.big_planet_sprite.x = self.big_planet_sprite.x - 1 * (1 / big_planet_sprite_depth)
if self.big_planet_sprite.x + self.big_planet_sprite.width <= 0:
self.big_planet_sprite.x = window.width
self.far_planet_sprite.x = self.far_planet_sprite.x - 1 * (1 / far_planet_sprite_depth)
if self.far_planet_sprite.x + self.far_planet_sprite.width <= 0:
self.far_planet_sprite.x = window.width
self.ring_planet_sprite.x = self.ring_planet_sprite.x - 1 * (1 / ring_planet_sprite_depth)
if self.ring_planet_sprite.x + self.ring_planet_sprite.width <= 0:
self.ring_planet_sprite.x = window.width
self.stars_sprite.x = self.stars_sprite.x - 1 * (1 / stars_sprite_depth)
if self.stars_sprite.x + self.stars_sprite.width <= 0:
self.stars_sprite.x = window.width
def generate_powerup(self, dt):
window = system.get_window()
# roll = random.randint(1, 10)
roll = 1
if roll <= 3: # 30% chance of getting a powerup
powerup = random.choice(powerups)(batch=self.batch)
x = random.randint(int(self.border.x), int(self.border.x + self.border.width))
powerup.move(x=x, y=window.height)
@powerup.movement
def movement():
powerup.move(powerup.x, powerup.y - powerup.calculate_speed())
self.powerup = powerup
def randomize_projectiles(self, dt):
if self.enemy:
self.enemy.attack_pattern.generate()
def check_direction(self, dt):
unit = 500 * dt
if self.keys[key.DOWN]:
if self.player.get_bot_bound() - unit >= self.border.y:
self.player.move(self.player.x, self.player.y - unit)
elif self.keys[key.UP]:
if self.player.get_bot_bound() + self.player.height + unit <= self.border.y + self.border.height:
self.player.move(self.player.x, self.player.y + unit)
# self.player.y += unit
if self.keys[key.LEFT]:
if self.player.get_left_bound() - unit >= self.border.x:
self.player.move(self.player.x - unit, self.player.y)
elif self.keys[key.RIGHT]:
if self.player.get_left_bound() + self.player.width + unit <= self.border.x + self.border.width:
self.player.move(self.player.x + unit, self.player.y)
# if self.keys[key.ESCAPE]:
# fg_ratio = 0.4
# bg_ratio = 0.1
# self.foreground_sprite.x = (window.width * (1 + fg_ratio)) / 2 - self.player.x * fg_ratio
# self.foreground_sprite.y = (window.height * (1 + fg_ratio)) / 2 - self.player.y * fg_ratio
# self.background_sprite.x = (window.width * (1 + bg_ratio)) / 2 - self.player.x * bg_ratio
# self.background_sprite.y = (window.height * (1 + bg_ratio)) / 2 - self.player.y * bg_ratio
def clean(self):
self.enemy.clean()
if self.facecam:
self.facecam.clean()
print(f'Deleting {self}')
super().clean()
def main():
backgscale = pygame.transform.scale(backg, (SCR_WID, SCR_HEI))
try:
ai_player = sys.argv[1]
except:
ai_player = 'linear'
SCREEN_REDUCE = 16
global player
if ai_player == 'conv':
player = Conv2DPlayer("player1", screen, SCR_HEI, SCR_WID)
elif ai_player == 'linear':
player = ElasticNetPlayer("player1", screen, SCR_HEI, SCR_WID)
global enemy
enemy = Player("player2", screen, SCR_HEI, SCR_WID)
block = Block()
got.add(block)
ball = Ball(screen, SCR_HEI, SCR_WID, player, enemy)
Call.add(ball)
prev_screen_1 = None
prev_screen_2 = None
i = 0
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
print("Game exited by user")
exit()
screen.blit(backg, (0, 0))
got.update()
Call.update()
backgscale = pygame.transform.scale(backg, (SCR_WID, SCR_HEI))
got.draw(screen)
Call.draw(screen)
screen_np = (pygame.surfarray.array2d(screen)[SCREEN_REDUCE *
2:SCR_WID -
SCREEN_REDUCE, :])
screen_np = screen_np.flatten().reshape(1, -1) - x_mean
prev_screen_2 = prev_screen_1
prev_screen_1 = screen_np
player.draw()
enemy.draw()
if i > 2:
screen_sequence = np.concatenate(
[prev_screen_2, prev_screen_1, screen_np], axis=1)
player.movement(screen_sequence)
else:
player.movement(None)
enemy.movement()
ball.movement()
enemy.scoring()
player.scoring()
i += 1
pygame.display.flip()
clock.tick(FPS)
def test_upd(self):
game_data.game_objects.clear()
game_data.for_destroy.clear()
game_data.map_width = 500
game_data.map_height = 500
cords_p = Vector(50, 50)
size_p = Size(30, 30)
player = Player(cords_p.x, cords_p.y, size_p)
cords = Vector(200, 200)
size = Size(12, 10)
bullet = Bullet(cords.x,
cords.y,
size,
Direction.Up,
False,
player=player)
player.bullet = bullet
BonusClock()
Bullet.upd(bullet)
self.check_obj_position(bullet, Vector(200, 197))
self.assertEqual(len(game_data.for_destroy), 0)
wall = Wall(200, 196, Size(40, 40))
Bullet.upd(bullet)
self.check_obj_position(bullet, Vector(200, 194))
self.assertIn(bullet.id, game_data.for_destroy)
self.assertNotIn(wall.id, game_data.for_destroy)
game_data.game_objects.pop()
game_data.for_destroy.clear()
player.position = Vector(200, 192)
Bullet.upd(bullet)
self.check_obj_position(bullet, Vector(200, 191))
self.assertIn(bullet.id, game_data.for_destroy)
self.assertIn(player.id, game_data.for_destroy)
size_by_direction = {
Direction.Up: Size(12, 10),
Direction.Right: Size(10, 13),
Direction.Down: Size(13, 10),
Direction.Left: Size(10, 13)
}
# r
bullet.direction = Direction.Right
bullet.size = size_by_direction[bullet.direction]
game_data.game_objects.pop(0)
game_data.for_destroy.clear()
Bullet.upd(bullet)
self.check_obj_position(bullet, Vector(203, 191))
# d
bullet.direction = Direction.Down
bullet.size = size_by_direction[bullet.direction]
Bullet.upd(bullet)
self.check_obj_position(bullet, Vector(203, 194))
# l
bullet.direction = Direction.Left
bullet.size = size_by_direction[bullet.direction]
Bullet.upd(bullet)
self.check_obj_position(bullet, Vector(200, 194))
bullet.position = Vector(26, 26)
bullet.direction = Direction.Up
bullet.size = size_by_direction[bullet.direction]
Bullet.upd(bullet)
self.assertIn(bullet.id, game_data.for_destroy)
def __init__(self, util):
self.util = util
self.level_solved = False
self.p_1 = Player(self, 1, 5)
self.p_2 = Player(self, 3, 25)
self.p_3 = Player(self, 5, 5)
self.p_4 = Player(self, 7, 25)
self.p_5 = Player(self, 9, 5)
self.p_6 = Player(self, 11, 25)
self.p_7 = Player(self, 13, 5)
self.p_8 = Player(self, 15, 25)
self.p_9 = Player(self, 17, 5)
self.p_10 = Player(self, 19, 25)
self.p_11 = Player(self, 21, 5)
self.p_12 = Player(self, 23, 25)
self.p_13 = Player(self, 25, 5)
self.p_14 = Player(self, 27, 25)
self.p_15 = Player(self, 29, 5)
self.p_16 = Player(self, 31, 25)
self.players = [
self.p_1, self.p_2, self.p_3, self.p_4, self.p_5, self.p_6,
self.p_7, self.p_8, self.p_9, self.p_10, self.p_11, self.p_12,
self.p_13, self.p_14, self.p_15, self.p_16
]
self.g_1 = Door(1, 25)
self.g_2 = Door(3, 5)
self.g_3 = Door(5, 25)
self.g_4 = Door(7, 5)
self.g_5 = Door(9, 25)
self.g_6 = Door(11, 5)
self.g_7 = Door(13, 25)
self.g_8 = Door(15, 5)
self.g_9 = Door(17, 25)
self.g_10 = Door(19, 5)
self.g_11 = Door(21, 25)
self.g_12 = Door(23, 5)
self.g_13 = Door(25, 25)
self.g_14 = Door(27, 5)
self.g_15 = Door(29, 25)
self.g_16 = Door(31, 5)
self.doors = [
self.g_1, self.g_2, self.g_3, self.g_4, self.g_5, self.g_6,
self.g_7, self.g_8, self.g_9, self.g_10, self.g_11, self.g_12,
self.g_13, self.g_14, self.g_15, self.g_16
]
self.pillars = []
self.walls = []
self.level = Level3(self)
def __init__(self, util):
self.util = util
self.level_solved = False
self.p_1 = Player(self, 1, 5)
self.p_2 = Player(self, 3, 5)
self.p_3 = Player(self, 5, 5)
self.p_4 = Player(self, 7, 5)
self.p_5 = Player(self, 9, 5)
self.p_6 = Player(self, 11, 5)
self.p_7 = Player(self, 13, 5)
self.p_8 = Player(self, 15, 5)
self.p_9 = Player(self, 17, 5)
self.p_10 = Player(self, 19, 5)
self.p_11 = Player(self, 21, 5)
self.p_12 = Player(self, 23, 5)
self.p_13 = Player(self, 25, 5)
self.p_14 = Player(self, 27, 5)
self.p_15 = Player(self, 29, 5)
self.p_16 = Player(self, 31, 5)
self.players = [
self.p_1, self.p_2, self.p_3, self.p_4, self.p_5, self.p_6,
self.p_7, self.p_8, self.p_9, self.p_10, self.p_11, self.p_12,
self.p_13, self.p_14, self.p_15, self.p_16
]
self.door = Door(15, 15)
self.doors = [self.door]
self.pillars = []
self.walls = []
self.level = Level4(self)
def __init__(self):
super().__init__()
window = system.get_window()
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
base_path = os.path.join('images', 'space_background_pack', 'layers')
self.background = load(os.path.join(base_path, 'parallax-space-background.png'))
self.background_sprite = Sprite(self.background)
big_planet = load(os.path.join(base_path, 'parallax-space-big-planet.png'))
self.big_planet_sprite = Sprite(big_planet)
far_planet = load(os.path.join(base_path, 'parallax-space-far-planets.png'))
self.far_planet_sprite = Sprite(far_planet)
ring_planet = load(os.path.join(base_path, 'parallax-space-ring-planet.png'))
self.ring_planet_sprite = Sprite(ring_planet)
self.ring_planet_sprite.x = 100
self.ring_planet_sprite.y = 100
stars = load(os.path.join(base_path, 'parallax-space-stars.png'))
self.stars_sprite = Sprite(stars)
self.scheduled_functions = (
(self.randomize_projectiles, 2),
(self.check_direction, 1 / 120),
(self.generate_powerup, 20)
)
if config.get_config('control') == 1:
self.face_cascade = cv.CascadeClassifier(
'venv/Lib/site-packages/cv2/data/haarcascade_frontalface_default.xml')
self.facecam = Facecam(face_cascade=self.face_cascade).start()
self.aii = ArrayInterfaceImage(self.facecam.read(), 'BGR')
self.image = self.aii.texture
@self.facecam.event('on_face_move')
def follow_face(x, y, width, height):
# Need to flip things first to work
x = self.image.width - x
y = self.image.height - y
new_x = self.border.x + x - width // 2
new_y = self.border.y + y - height // 2
self.player.move(new_x, new_y)
self.scheduled_functions = (
(self.randomize_projectiles, 2),
(self.generate_powerup, 20),
)
window.push_handlers(self.facecam)
self.player = Player(src='images/ufo.png')
self.border = Rectangle(
width=(500 if not self.image else self.image.width) + 10,
height=(500 if not self.image else self.image.height) + 10,
color=(0, 0, 0, 127)
)
self.player.scale = 1.2
self.batch = Batch()
self.projectiles: List[Projectile] = []
window.push_handlers(self.keys)
def pause_game(symbol, modifiers):
if symbol == key.ESCAPE:
self.enemy.running = not self.enemy.running
self.enemy.attack_pattern.running = not self.enemy.attack_pattern.running
self.player.running = not self.player.running
window.on_key_press = pause_game
for func, interval in self.scheduled_functions:
clock.schedule_interval(func, interval)
self.fps_display = FPSDisplay(window)
self.generate_enemy(0)
self.resize()
def __init__(self, name, screen, screen_height, screen_width):
Player.__init__(self, name, screen, screen_height, screen_width)
from game_objects.projectile import Projectile
from game_objects.player import Player
from pyglet import clock
from widgets.event_window import EventWindow
import pyglet
import cv2 as cv
import time
window = EventWindow(fullscreen=True)
# soul_image = pyglet.image.load('soul.png')
# soul = pyglet.sprite.Sprite(soul_image)
soul = Player(src='soul.png')
print(soul.width, soul.height)
print(window.width / 2, window.height / 2)
soul.move(window.width / 2 - soul.width, window.height / 2 - soul.height)
soul.scale = 1.3
print('Soul: ', soul.x, soul.y, soul.width, soul.height)
soul_np = cv.imread('soul.png')
projectile = Projectile(src='projectiles/dull_knife.png',
speed=10,
x=window.width * 0.7,
y=window.height)
# projectile.x = window.width / 3
# projectile.rectangle.x = projectile.x
# projectile.y = window.height / 2
# projectile.rectangle.y = projectile.y
projectile.point(soul.x, soul.y)
@window.event
def on_draw():
