def launch_level(self, gl, music):
""" Initializing the main loop of a level,
where gl is a game level"""
gl.load_camera(self.win()) #Load the camera in the window fen
gl.get_camera().set_dimension(Vector(200, 150)) #Resize the camera
#2560,1440 is the biggest resolution)
gl.get_camera().set_position(Vector(-100,
-75)) #change pos of the camera
gl.optimise_data(
) #Call it before launching the game of making modification in camera (be careful it may take a while to execute)
success, score = gl.play(self.options["FPS"])
if not success: #reduce score of defeats
score //= 2
#leaderboard of this level
self.dict_score[gl.name] = insert_score(self.score(gl.name), score,
self.player_name,
self.max_number_scores)
msg_score = score_to_msg(self.dict_score[gl.name])
bubl = Dialogue_Bubble(msg_score, self.dict_char["narrator"],
self.dict_img["img_leaderboard"], 300, 50, True)
bubl.offsetX = 20
bubl.offsetY = 20
dial_score = Dialogue([bubl])
dial_score.show(self)
with open("data/json/scores.json", "w") as f:
f.write(json.dumps(self.dict_score))
#pour ne pas sortir du menu même si les boutons ont été trop appuyés
#mashed buttons are handled by pygameeventget (doesn't quit the menu)
return success #true ssi réussite !
class Entity(object):
def __init__(self, polygon=None, heading=None, position=None):
self.body = Polygon(polygon)
self.heading = heading
self.position = position
self.heading = random.randint(0, 360)
self.position = Vector([0, 0])
self.velocity = (0, 0)
self.rotation = 0
def translate(self, vector):
self.position += vector
def rotate(self, angle_degrees):
self.heading += angle_degrees
self.heading %= 360
def update(self):
self.translate(self.velocity)
self.rotate(self.rotation)
self.body.project(heading=self.heading, position=self.position)
def intersects(self, other):
if isinstance(other, Entity):
if self.position.distance(
other.position) < self.body.radius + other.body.radius:
return True
else:
if self.position.distance(
other.position) < self.body.radius + other.radius:
return True
return False
def testLength(self):
self.assertAlmostEqual(length(Vector(0.0, 0.0)), 0.0, geom_places)
self.assertAlmostEqual(length(Vector(1.0, 1.0)), 2**0.5, geom_places)
v = normalize(Vector(0.23, 1.45))
self.assertAlmostEqual(length(v * 23.145), 23.145)
self.assertAlmostEqual(length(v / 23.145), 1.0 / 23.145)
def fire(enemy, direction):
if enemy.bullet is None:
size_by_direction = {
Direction.Up: Size(12, 10),
Direction.Right: Size(10, 13),
Direction.Down: Size(13, 10),
Direction.Left: Size(10, 13)
}
size = size_by_direction[direction]
position_by_direction = {
Direction.Up:
Vector(
enemy.position.x + enemy.size.width / 2 - size.width / 2,
enemy.position.y - enemy.size.height / 2),
Direction.Down:
Vector(
enemy.position.x + enemy.size.width / 2 - size.width / 2,
enemy.position.y + 3 * enemy.size.height / 2),
Direction.Left:
Vector(
enemy.position.x - enemy.size.width / 2, enemy.position.y +
enemy.size.height / 2 - size.height / 2),
Direction.Right:
Vector(
enemy.position.x + 3 * enemy.size.width / 2,
enemy.position.y + enemy.size.height / 2 - size.height / 2)
}
position = position_by_direction[direction]
enemy.bullet = Bullet(position.x,
position.y,
size,
direction,
True,
enemy=enemy)
def upd(player):
if game_data.is_space_pressed:
Player.fire(player)
if not Player.set_player_sprite(player):
return
if game_data.pressed_key == Direction.Up \
and player.position.y - player.speed \
>= game_data.game_place_offset:
Player.check_next_step(
player,
Vector(player.position.x, player.position.y - player.speed))
elif game_data.pressed_key == Direction.Down \
and player.position.y + player.speed \
< game_data.map_height - 7:
Player.check_next_step(
player,
Vector(player.position.x, player.position.y + player.speed))
elif game_data.pressed_key == Direction.Right \
and player.position.x + player.speed \
< game_data.map_width - 7:
Player.check_next_step(
player,
Vector(player.position.x + player.speed, player.position.y))
elif game_data.pressed_key == Direction.Left \
and player.position.x - player.speed \
>= game_data.game_place_offset:
Player.check_next_step(
player,
Vector(player.position.x - player.speed, player.position.y))
def visualise(filepath="data/your music/"):
"""a Visualiser for music generated level, as required for part 2.
The white rectangle is the maximal jump height."""
parser = ArgumentParser()
parser.add_argument("filename",
help="name of the file you want to see.",
type=str,
default="cool.wav",
nargs='?')
name = parser.parse_args().filename
print("File chosen : " + name)
filepath += name
gl = generate_level(filepath)
pygame.display.flip()
FEN.set_alpha(None)
(mini_x, maxi_x, mini_y, maxi_y) = gl.get_size_level()
mini_x -= int(abs(mini_x) * 1.1)
maxi_x += int(abs(maxi_x)**0.7)
mini_y -= int(abs(mini_y) * 1.1)
maxi_y += int(abs(maxi_y) * 1.1)
gl.camera.set_position(Vector(mini_x, mini_y))
dx = maxi_x - mini_x
dy = maxi_y - mini_y
gl.camera.set_dimension(Vector(dx, dy))
gl.load_camera(FEN)
gl.aff(0.1, gl.objects)
pygame.draw.rect(FEN, (255, 255, 255),
pygame.Rect(W * 5 / 6, H * 5 / 6, 15, 50 / dy * H))
pygame.display.flip()
time.sleep(20)
def intersect_point(self, s):
""" Returns the intersection of this segment with the segment s """
if self.collide_segment(s):
lf = self.get_line()
ls = s.get_line()
ret = lf.intersect_point(
ls
) #Get the intersection point of lines extracted from segments
if isinstance(ret, Line): #If segments have the same line
#Cut a segment from this line
if ret.vert: #Vertical line
x = self.p1.x
#get y coord
miny = max(self.get_min_y(), s.get_min_y())
maxy = min(self.get_max_y(), s.get_max_y())
#Compute segment
p1 = Vector(x, miny)
p2 = Vector(x, maxy)
else: #Other line
#get x coord
minx = max(self.get_min_x(), s.get_min_x())
maxx = min(self.get_max_x(), s.get_max_x())
#Compute segment
p1 = Vector(minx, ret.a * minx + ret.b)
p2 = Vector(maxx, ret.a * maxx + ret.b)
return Segment(p1, p2)
return ret
else:
return None
def destroy(self, direction=None):
sprite_v = "./textures/sprites/breaks_v.png"
sprite_g = "./textures/sprites/breaks_g.png"
if self.is_broken:
game_data.for_destroy[self.id] = self
return
size_v = Size(40, 20)
size_g = Size(20, 40)
if direction == Direction.Up:
self.sprite = sprite_g
self.size = size_g
self.is_broken = True
elif direction == Direction.Down:
self.position = Vector(self.position.x,
self.position.y + size_g.height)
self.sprite = sprite_g
self.size = size_g
self.is_broken = True
elif direction == Direction.Left:
self.sprite = sprite_v
self.size = size_v
self.is_broken = True
elif direction == Direction.Right:
self.position = Vector(self.position.x + size_v.width,
self.position.y)
self.sprite = sprite_v
self.size = size_v
self.is_broken = True
def physics_step(self, dt, obj_opti):
""" Compute collisions """
for i, o in enumerate(obj_opti):
if True: #not(isinstance(o,SolidPlatform)): #On peut se permettre d'integrer les plateformes au calcul suite a de nombreux gains de performance
o.compute_speed(dt)
o.move(dt)
if o == self.player and self.player.alive:
#Reposition the player
pos = o.get_position()
new_pos = Vector(self.player_pos(self.time), pos.y)
o.translate(new_pos - pos)
#Cut X speed (for MAXSPEED)
speed = self.player.get_speed()
self.player.set_speed(Vector(
1, speed.y)) #Player needs to have a str pos speed
for j, o2 in enumerate(obj_opti):
if o.get_collide() and o2.get_collide():
coll = o.get_hit_box().collide_sides(o2.get_hit_box())
#print("--",o,o2,coll)
if o != o2 and coll:
o.collide(o2, coll, (coll + 2) % 4)
o2.collide(o, (coll + 2) % 4, coll)
while o.get_rigid_body() and o2.get_rigid_body(
) and o.get_rigid_hit_box().collide(
o2.get_rigid_hit_box(
)) and o.get_speed() != Vector(0, 0):
#print("rigid")
o.apply_solid_reaction(o2)
def testMiddleIntersection(self):
s = Segment(Point(-1.0, 0.0), Point(1.0, 0.0))
p = Ray(Point(-1.0, -1.0), Vector(1.0, 1.0)).intersect(s)
self.assertEqual(p, Point(0.0, 0.0))
p = Ray(Point(-2.0, -1.0), Vector(2.75, 1.0)).intersect(s)
self.assertEqual(p, Point(0.75, 0.0))
def testNoIntersection(self):
c = Circle(Point(10.0, 10.0), 1.0)
p = Ray(Point(0.0, 0.0), Vector(1.0, 0.0)).intersect(c)
self.assertIsNone(p)
p = Ray(Point(0.0, 0.0), Vector(-1.0, -1.0)).intersect(c)
self.assertIsNone(p)
def testOneIntersectionWithOrigInsideCircle(self):
c = Circle(Point(0.0, 0.0), 1.0)
p = Ray(Point(0.0, 0.0), Vector(1.0, 0.0)).intersect(c)
self.assertEqual(p, Point(1.0, 0.0))
p = Ray(Point(0.0, 0.0), Vector(1.0, 1.0)).intersect(c)
self.assertEqual(p, Point(0.5 * 2**0.5, 0.5 * 2**0.5))
def testBoundsIntersection(self):
s = Segment(Point(-1.0, 0.0), Point(1.0, 0.0))
p = Ray(Point(-1.0, -1.0), Vector(0.0, 1.0)).intersect(s)
self.assertEqual(p, Point(-1.0, 0.0))
p = Ray(Point(-2.0, -2.0), Vector(3.0, 2.0)).intersect(s)
self.assertEqual(p, Point(1.0, 0.0))
def testOneIntersectionWithIncidentRay(self):
c = Circle(Point(0.0, 0.0), 1.0)
p = Ray(Point(-10.0, 1.0), Vector(1.0, 0.0)).intersect(c)
self.assertEqual(p, Point(0.0, 1.0))
p = Ray(Point(-10.0 - 0.5 * 2**0.5, -10.0 + 0.5 * 2**0.5),
Vector(1.0, 1.0)).intersect(c)
self.assertEqual(p, Point(-0.5 * 2**0.5, 0.5 * 2**0.5))
def __init__(self):
super().__init__()
self.__speed = Vector(0, 0)
self.__acc = Vector(0, 0)
self.__ang_speed = 0
self.__ang_acc = 0
self.__force_effect = {}
self.__mass = 1 #kg
self.__ang_inertia = 1 #SI
def __init__(self, polygon=None, heading=None, position=None):
self.body = Polygon(polygon)
self.heading = heading
self.position = position
self.heading = random.randint(0, 360)
self.position = Vector([0, 0])
self.velocity = (0, 0)
self.rotation = 0
def __init__(self):
self.__origin = Vector(
0, 0
) # Origine du Transformable (0,0) and constant for now (it's easier this way)
self.__position = Vector(
0, 0) # Coordonnees du Transformable dans l'environnement
self.__rotation = 0 # Rotation actuelle du Transformable
self.__scale = Vector(1., 1.) # Ecard du transformable
self.__transform = None # Transformation
self.__tr_need_up = True # Transformation need update
self.__inverse_transform = None # Transformation inverse
self.__inv_tr_need_up = True # Inverse Transformation need update
def testOneIntersection(self):
s = Polygon([
Point(-1.0, -1.0),
Point(1.0, -1.0),
Point(1.0, 1.0),
Point(-1.0, 1.0)
])
p = Ray(Point(0.0, 0.0), Vector(1.0, 0.0)).intersect(s)
self.assertEqual(p, Point(1.0, 0.0))
p = Ray(Point(0.0, 0.0), Vector(1.0, 1.0)).intersect(s)
self.assertEqual(p, Point(1.0, 1.0))
def testTwoIntersections(self):
c = Circle(Point(0.0, 0.0), 1.0)
p = Ray(Point(-2.0, 0.0), Vector(1.0, 0.0)).intersect(c)
self.assertEqual(p, Point(-1.0, 0.0))
c = Circle(Point(0.0, 0.0), 2.0)
p = Ray(Point(100.0, 100.0), Vector(-1.0, -1.0)).intersect(c)
self.assertEqual(p, Point(2**0.5, 2**0.5))
c = Circle(Point(10.0, 10.0), 4.0)
p = Ray(Point(0.0, 0.0), Vector(1.0, 1.0)).intersect(c)
self.assertEqual(p, Point(10.0 - 2 * 2**0.5, 10.0 - 2 * 2**0.5))
def draw(self, screen, field):
draw_circle(screen, field, BOT_COLOR,
self.pos,
self.radius, 1)
top_angle = 40 * pi / 180
x = self.radius * sin(top_angle)
y = self.radius * cos(top_angle)
ang = signed_angle(Vector(0.0, 1.0), self.dir)
pa = self.pos + rotate(Vector(-x, -y), ang)
pb = self.pos + rotate(Vector( x, -y), ang)
pc = self.pos + rotate(Vector(0.0, self.radius), ang)
draw_line(screen, field, BOT_COLOR, pa, pb, 1)
draw_line(screen, field, BOT_COLOR, pa, pc, 1)
draw_line(screen, field, BOT_COLOR, pb, pc, 1)
def __init__(self, pos, pos_enemy):
game_data.count_enemies_in_game += 1
sprites = [
"./textures/animations/spawn_enemy_1.png",
"./textures/animations/spawn_enemy_2.png",
"./textures/animations/spawn_enemy_3.png"
]
self.init_pos = Vector(pos.x + 5, pos.y + 5)
super().__init__(self.init_pos.copy(), sprites, -1,
AnimationSpawnEnemy.upd)
self.size = Size(40, 40)
self.circles = 0
self.position_enemy = pos_enemy
self.name = "AnimationSpawnEnemy"
def __init__(self, x, y, size):
super().__init__(x, y, size, "Player",
"./textures/sprites/player_u_1.png", 3, 1, Player.upd)
self.spawn_position = Vector(x, y)
self.sprite_u_1 = "./textures/sprites/player_u_1.png"
self.sprite_r_1 = "./textures/sprites/player_r_1.png"
self.sprite_d_1 = "./textures/sprites/player_d_1.png"
self.sprite_l_1 = "./textures/sprites/player_l_1.png"
self.sprite_u_2 = "./textures/sprites/player_u_2.png"
self.sprite_r_2 = "./textures/sprites/player_r_2.png"
self.sprite_d_2 = "./textures/sprites/player_d_2.png"
self.sprite_l_2 = "./textures/sprites/player_l_2.png"
self.bullet = None
self.count_lifes = 2
self.is_dead = False
def load_map(self, path_to_map):
map_creator = MapCreator()
map_creator.create_map(path_to_map)
pos = Vector(
game_data.game_place_offset * 2 + game_data.map_width + 10,
game_data.game_place_offset)
for i in range(0, game_data.count_enemies):
self.icons_enemies.append(
IconEnemy(pos, QPixmap("./textures/icon_enemy.png")))
pos = pos.copy()
if i % 2 == 0:
pos.x += 15
else:
pos.x -= 15
pos.y += 15
def fire(player):
if player.bullet is None:
direction_by_sprite = {
player.sprite_u_1: Direction.Up,
player.sprite_r_1: Direction.Right,
player.sprite_d_1: Direction.Down,
player.sprite_l_1: Direction.Left,
player.sprite_u_2: Direction.Up,
player.sprite_r_2: Direction.Right,
player.sprite_d_2: Direction.Down,
player.sprite_l_2: Direction.Left
}
direction = direction_by_sprite[player.sprite]
size_by_direction = {
Direction.Up: Size(12, 10),
Direction.Right: Size(10, 13),
Direction.Down: Size(13, 10),
Direction.Left: Size(10, 13)
}
size = size_by_direction[direction]
position_by_direction = {
Direction.Up:
Vector(
player.position.x + player.size.width / 2 - size.width / 2,
player.position.y - player.size.height / 2),
Direction.Down:
Vector(
player.position.x + player.size.width / 2 - size.width / 2,
player.position.y + 3 * player.size.height / 2),
Direction.Left:
Vector(
player.position.x - player.size.width / 2,
player.position.y + player.size.height / 2 -
size.height / 2),
Direction.Right:
Vector(
player.position.x + 3 * player.size.width / 2,
player.position.y + player.size.height / 2 -
size.height / 2)
}
position = position_by_direction[direction]
player.bullet = Bullet(position.x,
position.y,
size,
direction,
False,
player=player)
game_data.is_space_pressed = False
def compute_camera_position(self, obj_opti):
""" Compute the camera position by trying to fix it on the platform below the player and smooth movements """
prect = self.player.get_hit_box().get_world_rect()
#Search for the platform right below the player
mini = None
for o in obj_opti:
if isinstance(o, SolidPlatform):
rect = o.get_hit_box().get_world_rect()
if rect.collidex(prect):
y = rect.get_min_y()
if (
mini is None and prect.get_min_y() < y
or prect.get_min_y() < y < mini
) and abs(
prect.get_min_y() - y
) < 100: #If it's too far it will forget it and fix on the player instead
mini = y
if mini is None: #No platform -> fix on the player
y = self.player.get_position().y
else: #Fix on a platform
y = mini
#Smooth moving of the camera
old_percent = 95 #The percentage of the old value of self.camera_y_pos that will be kept
self.camera_y_pos = self.camera_y_pos * old_percent / 100 + y * (
100 - old_percent
) / 100 #Computation of the new continous Y position of the camera
self.camera.threeforth_on(
Vector(self.player.get_position().x, self.camera_y_pos)
) #Position of the camera (pos X of the player et pos Y previously computed)
def calc_desired_velocity(self, bots, obstacles, targets):
vel = self.vel
if self.movement != Movement.Accel:
vel = Vector(0, 0)
for inter in bots:
if (not KNOW_BOT_POSITIONS) and dist(inter.real.pos, self.pos) > self.max_sensing_distance:
continue
force = -potential.gradient(potential.morse(r0=2 * BOT_RADIUS, k=2.5, a=4.0),
dist(inter.real.pos, self.pos),
self.pos - inter.real.pos,
self.radius + inter.virtual.radius)
vel += _FORCE_SENSITIVITY * force
for target in targets:
force = -potential.gradient(potential.linear(k=-2.0),
dist(target, self.pos),
target - self.pos,
0)
vel += _FORCE_SENSITIVITY * force
for obstacle in obstacles:
if obstacle.distance(self.pos) <= self.max_sensing_distance:
force = -potential.gradient(potential.inverse_quadratic(k=1.0),
obstacle.distance(self.pos),
obstacle.repulsion_dir(self.pos),
OBSTACLE_CLEARANCE + self.radius)
vel += _FORCE_SENSITIVITY * force
if self.movement == Movement.Dir:
if length(vel) > 0:
vel = normalize(vel)
return vel
def start_jump(self):
""" Starts jump (can be called several time to jump higher """
speed = self.get_speed()
if self.alive and self.can_jump and (
not self.is_jumping) and speed.y >= 0:
self.set_speed(Vector(speed.x, -self.jump_strength)) #JUMP
self.can_jump = False #Cannot jump anymore
def make_step_by_direction(enemy, direction):
if direction is None:
return
enemy.last_step = direction
Enemy.set_sprite(enemy, direction)
next_position_by_direction = {
Direction.Up:
Vector(enemy.position.x, enemy.position.y - enemy.speed),
Direction.Right:
Vector(enemy.position.x + enemy.speed, enemy.position.y),
Direction.Down:
Vector(enemy.position.x, enemy.position.y + enemy.speed),
Direction.Left:
Vector(enemy.position.x - enemy.speed, enemy.position.y)
}
enemy.position = next_position_by_direction[direction]
def testMultipleIntersections(self):
s = Polygon([
Point(-1.0, -1.0),
Point(1.0, -1.0),
Point(1.0, 1.0),
Point(-1.0, 1.0)
])
p = Ray(Point(-2.0, 0.0), Vector(1.0, 0.5)).intersect(s)
self.assertEqual(p, Point(-1.0, 0.5))
p = Ray(Point(-5.0, -2.0), Vector(4.0, 1.0)).intersect(s)
self.assertEqual(p, Point(-1.0, -1.0))
p = Ray(Point(-3.0, 0.0), Vector(4.0, 1.0)).intersect(s)
self.assertEqual(p, Point(-1.0, 0.5))
def get_position_for_enemy(self):
available_x = set()
for x in range(game_data.game_place_offset, game_data.map_width):
available_x.add(x)
skip_objects = {"Player", "Animation", "Bullet", "Grass"}
for game_object in game_data.game_objects:
if game_object.name in skip_objects:
continue
if game_data.game_place_offset \
<= game_object.position.y < 40:
for x in range(
game_object.position.x,
game_object.position.x + game_object.size.height):
if x not in available_x:
continue
available_x.remove(x)
available_positions = []
for x in available_x:
available_positions.append(Vector(x, game_data.game_place_offset))
if len(available_positions) == 0:
return None
random.seed()
return available_positions[random.randint(0,
len(available_positions) -
1)]
def __init__(self, x=0, y=0):
Vector.__init__(self, x, y)
def __setitem__(self, k, v):
if k == 'x':
k = 0
elif k == 'y':
k = 1
return Vector.__setitem__(self, k, v)