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)