def pointify(self, csv_string, group_offset=Vec2d.zero()): if group_offset.y: offset = self.map_size.y - group_offset.y else: offset = 0 point_strings = [p.split(',') for p in csv_string.split()] return [(group_offset.x + int(p[0]), offset-int(p[1])) for p in point_strings]
def add_ball(impulse): inertia = pm.moment_for_circle(ball_mass, 0, ball_radius, (0,0)) body = pm.Body(ball_mass, inertia) body.position = (610, 150) body.apply_impulse(Vec2d.unit() * impulse, (-100, 0)) shape = pm.Circle(body, ball_radius, (0,0)) shape.elasticity = ball_elast space.add(body, shape) balls.append(shape)
def curriculum_angled_trajectory_factory( min_speed=5, max_speed=45, speed_step=4.0, num_turning_rate_steps=4, min_turn_rate_multiplier=0, max_turn_rate_multiplier=1.5, # num_turns_per_step=2, step_length=300, transition_length=10, min_turn_arc=60 * pi / 180, max_turn_arc=120 * pi / 180, random_seed=2, ) -> Callable[['TrajectoryTrackingProcess'], Tuple[List[Tuple[Vec2d, float]], bool]]: r = random.Random(random_seed) # length = 0.0 angle = 0.0 num_speed_steps = 1 + int(ceil((max_speed - min_speed) / speed_step)) previous_speed = min_speed # start with a straight line # waypoints = [(Vec2d(0, 0), min_speed), (Vec2d(transition_length, 0), min_speed)] waypoints = [(Vec2d(0, 0), previous_speed)] # print('num_speed_steps', num_speed_steps) for s in range(num_speed_steps): min_step_speed = s * speed_step + min_speed # http://dotapp7.dot.state.mn.us/edms/download?docId=1062356 mid_turning_radius = 1.0 * ((min_step_speed * 3.6) ** 2) / (127 * (0.0 + .12)) mid_turning_rate = 1.0 / mid_turning_radius min_turning_rate = min_turn_rate_multiplier * mid_turning_rate max_turning_rate = max_turn_rate_multiplier * mid_turning_rate # num_turning_steps = 1 + int(ceil((min_turning_rate - max_turning_rate) / turning_rate_step)) # print('num_turning_steps', num_turning_rate_steps) turning_rate_step = (max_turning_rate - min_turning_rate) / num_turning_rate_steps for t in range(num_turning_rate_steps): base_turn_rate = min_turning_rate + t * turning_rate_step # for i in range(num_turns_per_step): remaining_length = step_length while remaining_length > 0: target_speed = min_step_speed + r.uniform(0, speed_step) # straightaway at beginning of each turn line_length = min(transition_length, remaining_length) delta = Vec2d(line_length, 0.0) delta.rotate(angle) next = waypoints[-1][0] + delta waypoints.append((next, (target_speed + previous_speed) / 2)) remaining_length -= line_length turn_rate = min(max_turning_rate, base_turn_rate + r.uniform(0, turning_rate_step)) turn_arc = r.uniform(min_turn_arc, max_turn_arc) turn_direction = 1 if bool(r.getrandbits(1)) else -1 # turn_length = turn_rate / turn_arc remaining_arc = turn_arc while remaining_arc > 1e-3 and remaining_length > 0: # arc = 0.0 # max_arc = 5.0 * pi / 180.0 # min_arc = 1.0 * pi / 180.0 # if remaining_arc >= max_arc: # arc = r.uniform(min_arc, max_arc) # else: # arc = remaining_arc arc = min(remaining_arc, 2.0 * pi / 180.0) remaining_arc -= arc line_length = min(remaining_length, arc / turn_rate) line_angle = turn_direction * arc # if arc >= remaining_arc: line_angle += r.gauss(0.0, 2.0 * pi / 180.0) target_speed = clamp(target_speed + r.gauss(0.0, .5), min_speed, max_speed) angle += line_angle delta = Vec2d(line_length, 0.0) delta.rotate(angle) next = waypoints[-1][0] + delta waypoints.append((next, target_speed)) remaining_length -= line_length previous_speed = target_speed # Plotting curriculum path for jul14_2020_experiments: # import matplotlib.pyplot as plt # import numpy as np # point_locations = np.array([[point[0].x, point[0].y] for point in waypoints]) # speeds = np.array([elem[1] for elem in waypoints]) # # plt.figure() # plt.plot(point_locations[:, 0], point_locations[:, 1], color = 'gray', label = 'path') # plt.fill_between(x = point_locations[:, 0], y1 = point_locations[:, 1] - speeds, # y2 = point_locations[:, 1] + speeds, color = 'gray', label = '2 * target speed', # alpha = 0.7) # plt.scatter(point_locations[0, 0], point_locations[0, 1], color='b', marker='o', label='start') # plt.scatter(point_locations[-1, 0], point_locations[-1, 1], color='r', marker='o', label='end') # plt.legend() # plt.xlabel('X [m]', fontsize = 14) # plt.ylabel('Y [m]', fontsize = 14) # plt.title("RL Training Path", fontsize = 24) # plt.savefig('curriculum_path.svg', format = 'svg') #### def curriculum_angled_trajectory_generator(process: 'TrajectoryTrackingProcess') -> Tuple[List[Tuple[Vec2d, float]], bool]: return waypoints, False return curriculum_angled_trajectory_generator
def parse(screen): CurrentScore = 0 mode = 'Kawai' pause = False file = open('CreepyDeblock.txt', 'r') creepydeblock = int(file.readline()) file.close() ### Physics stuff space = pymunk.Space() space.gravity = (0.0, -800.0) draw_options = pymunk.pygame_util.DrawOptions(screen) ## Balls balls = [] timeball1, timeball2 = 0, 0 balle = Images[mode + 'Balle'] ############################ ######## Var à Théo ######## x, y = 585, 490 mouv = Images[mode + 'Balle'].get_rect() mouv.x = 586 mouv.y = 479 rotation_center_body = pymunk.Body(body_type=pymunk.Body.STATIC) rotation_center_body.position = (305, 10) body = space.static_body body.position = (303, 10) largeur_trait = 1.0 l1 = pymunk.Segment(body, (5.0, 75.0), (5.0, 515.0), largeur_trait) l1.elasticity = 0.1 l2 = pymunk.Segment(body, (25.0, 534.0), (110.0, 534.0), largeur_trait) l2.elasticity = 0.05 l3 = pymunk.Segment(body, (110.0, 534.0), (156.0, 550.0), largeur_trait) l3.elasticity = 0.05 l4 = pymunk.Segment(body, (156.0, 550.0), (300.0, 550.0), largeur_trait) l4.elasticity = 0.035 l5 = pymunk.Segment(body, (376.0, 480.0), (376.0, 67.0), largeur_trait) l5.elasticity = 0.1 l6 = pymunk.Segment(body, (330.0, 67.0), (376.0, 67.0), largeur_trait) l6.elasticity = 3.5 # Renvoie a balle (petite étoile) l7 = pymunk.Segment(body, (356.0, 397), (356.0, 67), 3.0) l7.elasticity = 0.25 l8 = pymunk.Segment(body, (355, 105), (375.0, 105), largeur_trait) l8.elasticity = 0.15 addSegment([(5, 312), (45, 238), (45, 232), (5, 210)], body, space, largeur_trait, False) addSegment([(352, 395), (306, 314), (338, 275), (326, 256), (352, 208)], body, space, largeur_trait, False) addSegment([(27, 482), (27, 337), (72, 276), (144, 311), (144, 390), (155, 418), (155, 471), (133, 455), (133, 330), (48, 331), (41, 338), (41, 471), (33, 482), (27, 482)], body, space, largeur_trait, True) addSegment([(108, 356), (72, 356), (60, 366), (60, 464), (62, 468), (94, 499), (100, 499), (122, 487), (126, 478), (126, 474), (114, 461), (113, 360)], body, space, largeur_trait, True) l9 = pymunk.Segment(body, (174, 370), (174, 331), 4.0) l9.elasticity = 0.5 addSegment([(93, 64), (93, 59), (67, 59), (59, 51), (59, 62), (41, 62), (41, 105), (34, 105), (34, 160), (39, 160), (39, 109), (49, 109)], body, space, largeur_trait, False) addSegment([(322, 146), (322, 103), (330, 94), (330, 67), (301, 67), (301, 49), (284, 66), (259, 66), (312, 96), (312, 146)], body, space, largeur_trait, False) addSegment([(95, 97), (99, 97), (102, 99), (102, 105), (80, 160), (80, 116), (77, 112), (77, 107)], body, space, largeur_trait, True) addSegment([(258, 98), (252, 103), (279, 160), (282, 160), (282, 110)], body, space, largeur_trait, True) addSegment([(309, 214), (317, 194), (317, 159), (315, 159), (296, 201), (295, 206), (302, 214)], body, space, largeur_trait, True) arcG((5.0, 75), (160, -5), (160, 185), body, space, largeur_trait) arcG((190.0, -5.0), (330.0, 67.0), (190, 173), body, space, largeur_trait) arcG((25, 534), (5, 515), (24.5, 514.5), body, space, largeur_trait) arcG((376, 480), (300, 550), (303, 477), body, space, largeur_trait) arcG((49, 109), (93, 64), (139, 157), body, space, largeur_trait) arcG((322, 146), (312, 146), (317, 146), body, space, largeur_trait) ## Barage_raquette ## # todo : Ajouter un joint pour faire s'ouvrir et se fermer les barages... l10 = pymunk.Segment(body, (8, 177), (33, 162), largeur_trait) # Barage en bas à droite l13 = pymunk.Segment(body, (125, 479), (146, 466), largeur_trait) # Barage chambre l13.elasticity = 1.75 ## Bloqueur gauche et droit (bloc vert) ## l11 = pymunk.Segment(body, (80, 160), (101, 108), largeur_trait) l11.elasticity = 2.05 l12 = pymunk.Segment(body, (278, 160), (252, 105), largeur_trait) l12.elasticity = 2.05 l19 = pymunk.Segment(body, (204, 458), (204, 424), largeur_trait) l19.elasticity = 0.5 l14 = pymunk.Segment(body, (227, 465), (227, 424), largeur_trait) l14.elasticity = 0.5 l15 = pymunk.Segment(body, (248, 476), (248, 424), largeur_trait) l15.elasticity = 0.5 l16 = pymunk.Segment(body, (271, 476), (271, 424), largeur_trait) l16.elasticity = 0.5 l17 = pymunk.Segment(body, (298, 465), (298, 424), largeur_trait) l17.elasticity = 0.5 l18 = pymunk.Segment(body, (319, 458), (319, 424), largeur_trait) l18.elasticity = 0.5 ## On ajoute des segments space.add(l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13) space.add(l14, l15, l16, l17, l18, l19) #Traits pour NIGHT # Test barage lanceur (apparait après avoir lancer la balle, disparait avant d'en lancer une nouvelle """## Barage lanceur ## body_brg_lcr = space.static_body body_brg_lcr.position = (123, 10) brg_lcr = pymunk.Segment(body_brg_lcr, (453, 390), (474, 407), 1) # Barage lanceur brg_lcr.elasticity = 1.75 space.add(brg_lcr)""" # joint pour le barage du lanceur # todo : joint pour la sortir du lanceur """body_joint_brg_lcr = pymunk.Body(body_type=pymunk.Body.STATIC) body_joint_brg_lcr.position = body_brg_lcr.position j_brg_lcr = pymunk.PinJoint(body_brg_lcr, body_joint_brg_lcr, (0, 0), (0, 0)) s_brg_lcr = pymunk.DampedRotarySpring(body_brg_lcr, body_joint_brg_lcr, 0.3, 50000000, 2000000) space.add(j_brg_lcr, s_brg_lcr)""" ############################### ############################### ### Raquette gauche et droite fp = [(7, -7), (-55, 0), (10, 10)] mass = 100 moment = pymunk.moment_for_poly(mass, fp) # right flip r_flipper_body = pymunk.Body(mass, moment) r_flipper_body.position = 550, 60 r_flipper_shape = pymunk.Poly(r_flipper_body, fp) space.add(r_flipper_body, r_flipper_shape) # joint right flip r_flipper_joint_body = pymunk.Body(body_type=pymunk.Body.KINEMATIC) r_flipper_joint_body.position = r_flipper_body.position j_r = pymunk.PinJoint(r_flipper_body, r_flipper_joint_body, (0, 0), (0, 0)) s_r = pymunk.DampedRotarySpring(r_flipper_body, r_flipper_joint_body, 0.34, 50000000, 2000000) space.add(j_r, s_r) # left flip l_flipper_body = pymunk.Body(mass, moment) l_flipper_body.position = 410, 60 l_flipper_shape = pymunk.Poly(l_flipper_body, [(-x, y) for x, y in fp]) space.add(l_flipper_body, l_flipper_shape) # joint left flip l_flipper_joint_body = pymunk.Body(body_type=pymunk.Body.KINEMATIC) l_flipper_joint_body.position = l_flipper_body.position j_l = pymunk.PinJoint(l_flipper_body, l_flipper_joint_body, (0, 0), (0, 0)) s_l = pymunk.DampedRotarySpring(l_flipper_body, l_flipper_joint_body, -0.34, 70000000, 900000) space.add(j_l, s_l) r_flipper_shape.group = l_flipper_shape.group = 1 r_flipper_shape.elasticity = l_flipper_shape.elasticity = 0 ### Ajout + Physic bumpers for p in [(506, 400), (623, 401), (559, 283)]: body = pymunk.Body(body_type=pymunk.Body.KINEMATIC) body.position = p shape = pymunk.Circle(body, 11) shape.elasticity = 2 space.add(shape) for p in [(487, 283), (558, 353)]: body = pymunk.Body(body_type=pymunk.Body.KINEMATIC) body.position = p shape = pymunk.Circle(body, 14) shape.elasticity = 2 space.add(shape) # Position initiale des raquettes left_x, left_y = 96, 295 right_x, right_y = 235, 294 # Est-ce que la balle est lancé ? ball_lancer = 0 # 0 = non / 1 = oui running = True # Menu a afficher menu = 0 clock = pygame.time.Clock() while running: playMusic(menu, mode) if menu == 0: screen.blit(Images['MenuBackground'], (0, 0)) if 15 <= pygame.mouse.get_pos()[0] <= 185 and 460 <= pygame.mouse.get_pos()[1] <= 516: screen.blit(Images['MenuKawaiO'], (10, 460)) else: screen.blit(Images['MenuKawai'], (10, 460)) if creepydeblock == 0: screen.blit(Images['MenuCreepyV'], (15, 520)) else: if 15 <= pygame.mouse.get_pos()[0] <= 185 and 520 <= pygame.mouse.get_pos()[1] <= 576: screen.blit(Images['MenuCreepyO'], (15, 520)) else: screen.blit(Images['MenuCreepy'], (15, 520)) if menu == 1: screen.blit(Images[mode + 'Background'], (0, 0)) space.debug_draw(draw_options) screen.blit(balle, (body.position.x - 5, 595 - body.position.y)) if 65 <= pygame.mouse.get_pos()[0] <= 245 and 90 <= pygame.mouse.get_pos()[1] <= 146: screen.blit(Images[mode + 'BMenuO'], (60, 90)) else: screen.blit(Images[mode + 'BMenu'], (60, 90)) if 65 <= pygame.mouse.get_pos()[0] <= 245 and 160 <= pygame.mouse.get_pos()[1] <= 216: screen.blit(Images[mode + 'BAideO'], (60, 160)) else: screen.blit(Images[mode + 'BAide'], (60, 160)) if 65 <= pygame.mouse.get_pos()[0] <= 245 and 230 <= pygame.mouse.get_pos()[1] <= 286: screen.blit(Images[mode + 'BQuitterO'], (60, 230)) else: screen.blit(Images[mode + 'BQuitter'], (60, 230)) if 740 <= pygame.mouse.get_pos()[0] <= 812 and 510 <= pygame.mouse.get_pos()[1] <= 582: screen.blit(Images[mode + 'BRestartO'], (740, 510)) else: screen.blit(Images[mode + 'BRestart'], (740, 510)) if 880 <= pygame.mouse.get_pos()[0] <= 952 and 510 <= pygame.mouse.get_pos()[1] <= 582: screen.blit(Images[mode + 'BPauseO'], (880, 510)) else: screen.blit(Images[mode + 'BPause'], (880, 510)) ## Flips Gauche et droit ## screen.blit(Images[mode + 'left'], (left_x, left_y)) screen.blit(Images[mode + 'right'], (right_x, right_y)) r_flipper_body.position = 550, 69 l_flipper_body.position = 410, 69 r_flipper_body.velocity = l_flipper_body.velocity = 0, 0 if menu == 2: screen.blit(Images[mode + 'Win'], (0, 0)) for event in pygame.event.get(): if event.type == QUIT: running = False if event.type == KEYDOWN and event.key == K_ESCAPE: running = False if event.type == KEYDOWN and event.key == K_p: now = datetime.datetime.now() date = str(now.year) + str(now.month) + str(now.day) + str(now.hour) + str(now.minute) + str(now.second) print(date) pygame.image.save(screen, "screenshots/screenshot" + date + ".png") if menu == 0: if event.type == MOUSEBUTTONDOWN and event.button == 1: if 15 <= pygame.mouse.get_pos()[0] <= 185 and 460 <= pygame.mouse.get_pos()[1] <= 516: mode = 'Kawai' menu = 1 elif 15 <= pygame.mouse.get_pos()[0] <= 185 and 520 <= pygame.mouse.get_pos()[1] <= 576 and creepydeblock == 1: mode = 'Creepy' menu = 1 if menu == 1: # Clic if event.type == MOUSEBUTTONDOWN and event.button == 1: if 65 <= pygame.mouse.get_pos()[0] <= 245 and 90 <= pygame.mouse.get_pos()[1] <= 146: print('Menu') if 65 <= pygame.mouse.get_pos()[0] <= 245 and 160 <= pygame.mouse.get_pos()[1] <= 216: print('Aide') if 65 <= pygame.mouse.get_pos()[0] <= 245 and 230 <= pygame.mouse.get_pos()[1] <= 286: print('Quitter') if 740 <= pygame.mouse.get_pos()[0] <= 812 and 510 <= pygame.mouse.get_pos()[1] <= 582: print('Restart') if 880 <= pygame.mouse.get_pos()[0] <= 952 and 510 <= pygame.mouse.get_pos()[1] <= 582: pause = False if pause else True # Raquettes gauche(f) et droite(j) # Raquettes levé if event.type == KEYDOWN and event.key == K_j: # Mouvement raquette space.remove(j_r, s_r) s_r = pymunk.DampedRotarySpring(r_flipper_body, r_flipper_joint_body, -0.4, 70000000, 1300000) s_r.angular_velocity = 10000 space.add(j_r, s_r) right_x, right_y = 137, 197 if event.type == KEYDOWN and event.key == K_f: # Mouvement raquette space.remove(j_l, s_l) s_l = pymunk.DampedRotarySpring(l_flipper_body, l_flipper_joint_body, 0.4, 70000000, 1300000) s_l.angular_velocity = 10000 space.add(j_l, s_l) left_x, left_y = -2, 198 # Raquettes baissé if event.type == KEYUP and event.key == K_j: # Mouvement raquette space.remove(j_r, s_r) s_r = pymunk.DampedRotarySpring(r_flipper_body, r_flipper_joint_body, 0.34, 70000000, 1300000) space.add(j_r, s_r) right_x, right_y = 235, 294 if event.type == KEYUP and event.key == K_f: # Mouvement raquette space.remove(j_l, s_l) s_l = pymunk.DampedRotarySpring(l_flipper_body, l_flipper_joint_body, -0.34, 70000000, 1300000) space.add(j_l, s_l) left_x, left_y = 96, 295 # Tilt gauche(d) et droit(k) / Non fonctionnel # todo : rendre le tilt fonctionnel # Si le joueur tilt 3 fois de suite, il perd sa balle... if event.type == KEYDOWN and event.key == K_d: body.position.y = body.position.y + 30 if event.type == KEYDOWN and event.key == K_k: body.position.y = body.position.y - 30 # Balle en jeu if event.type == KEYDOWN and event.key == K_b: mass = 1 radius = 5 ball_lancer = 0 inertia = pymunk.moment_for_circle(mass, 0, radius, (0, 0)) body = pymunk.Body(mass, inertia) body.position = 670, 125 # Normale shape = pymunk.Circle(body, radius, (0, 0)) shape.elasticity = 0.95 space.add(body, shape) balls.append(shape) ##### Partie Lanceur ##### timeball = pygame.time.get_ticks() if event.type == KEYDOWN and event.key == K_SPACE: # space.remove(brg_lcr) pygame.key.set_repeat(1, 1000) y += 10 timeball1 = timeball if event.type == KEYUP and event.key == K_SPACE: y = 490 timeball2 = timeball energyball = ((timeball2 - timeball1) + 500) * 320 / 200 if energyball > 3000 and ball_lancer == 0: energyball = random.randint(2800, 3200) body.apply_impulse_at_local_point(Vec2d.unit() * energyball, (-100, 0)) ball_lancer = 1 elif energyball <= 3000 and ball_lancer == 0: body.apply_impulse_at_local_point(Vec2d.unit() * energyball, (-100, 0)) ball_lancer = 1 ########################### ### Remove any balls outside to_remove = [] for ball in balls: if ball.body.position.get_distance((300, 300)) > 1000: to_remove.append(ball) for ball in to_remove: space.remove(ball.body, ball) balls.remove(ball) ball_lancer = 0 ### Update physics if not pause: dt = 1.0 / 60.0 / 5. for x in range(5): space.step(dt) ### Flip screen pygame.display.flip() clock.tick(50)
import time import configparser config = configparser.ConfigParser() config.read('config.ini') pygame.init() screen = pygame.display.set_mode((600, 600)) clock = pygame.time.Clock() running = True ### Physics stuff space = pymunk.Space() #space.gravity = (0.0, -900.0) space._set_gravity(Vec2d(0, -981)) #space.gravity = (0.0, 0.0) draw_options = pymunk.pygame_util.DrawOptions(screen) w = 400 h = 20 fp = [(w / 2, -h / 2), (-w / 2, h / 2), (w / 2, h / 2), (-w / 2, -h / 2)] mass = 100 moment = pymunk.moment_for_poly(mass, fp[0:2]) x_pos = 300 y_pos = 100 angle = np.pi / 24 trayBody = pymunk.Body(mass, moment) trayBody.position = x_pos, y_pos
def main(): pygame.init() screen = pygame.display.set_mode((600, 600)) pygame.display.set_caption( "NEAT ball keeper [Press F to turn on/off fast mode, arrow keys to move ball]" ) ### Physics stuff space = pm.Space() space.gravity = Vec2d(0.0, -500.0) # walls - the left-top-right walls body = pm.Body() walls = [ pm.Segment(body, (50, 50), (50, 1550), 10), pm.Segment(body, (50, 1550), (560, 1550), 10), pm.Segment(body, (560, 1550), (560, 50), 10) ] floor = pm.Segment(body, (50, 50), (560, 50), 10) floor.friction = 1.0 floor.elasticity = 0.0 floor.collision_type = collision_type_floor for s in walls: s.friction = 0 s.elasticity = 0.99 s.collision_type = collision_type_wall space.add(walls) space.add(floor) g = NEAT.Genome(0, 6, 0, 2, False, NEAT.ActivationFunction.TANH, NEAT.ActivationFunction.UNSIGNED_SIGMOID, 0, params) pop = NEAT.Population(g, params, True, 1.0, rnd.randint(0, 1000)) best_genome_ever = None fast_mode = True for generation in range(1000): print("Generation:", generation) now = time.time() genome_list = [] for s in pop.Species: for i in s.Individuals: genome_list.append(i) print('All individuals:', len(genome_list)) for i, g in enumerate(genome_list): total_fitness = 0 for trial in range(20): f, fast_mode = evaluate(g, space, screen, fast_mode, rnd.randint(80, 400), rnd.randint(-200, 200), rnd.randint(80, 400)) total_fitness += f g.SetFitness(total_fitness / 20) print() best = max([x.GetLeader().GetFitness() for x in pop.Species]) print('Best fitness:', best, 'Species:', len(pop.Species)) # Draw the best genome's phenotype if best >= 10000: break # evolution is complete if an individual keeps the ball up for that many timesteps print("Evaluation took", time.time() - now, "seconds.") print("Reproducing..") now = time.time() pop.Epoch() print("Reproduction took", time.time() - now, "seconds.") # Show the best genome's performance forever pygame.display.set_caption("Best genome ever") while True: evaluate(pop.Species[0].GetLeader(), space, screen, False, rnd.randint(80, 400), rnd.randint(-200, 200), rnd.randint(80, 400))
def __init__(self): self.ctx = moderngl.create_context() self.prog = self.ctx.program( vertex_shader=''' #version 330 uniform vec4 Camera; // Per vertex in vec2 in_vert; in vec2 in_texture; // Per instance in vec3 in_pos; in vec2 in_size; in vec4 in_tint; out vec2 v_vert; out vec2 v_texture; out vec4 v_tint; void main() { mat2 rotate = mat2( cos(in_pos.z), sin(in_pos.z), -sin(in_pos.z), cos(in_pos.z) ); v_vert = rotate * (in_vert * in_size) + in_pos.xy; gl_Position = vec4((v_vert - Camera.xy) / Camera.zw, 0.0, 1.0); v_texture = in_texture; v_tint = in_tint; } ''', fragment_shader=''' #version 330 uniform sampler2D Texture; in vec2 v_vert; in vec2 v_texture; in vec4 v_tint; out vec4 f_color; void main() { vec4 tex = texture(Texture, v_texture); vec3 color = tex.rgb * (1.0 - v_tint.a) + v_tint.rgb * v_tint.a; f_color = vec4(color, tex.a); } ''', ) img = Image.open(local('data', 'crate.png')).convert('RGBA') self.tex1 = self.ctx.texture(img.size, 4, img.tobytes()) self.tex1.use(0) img = Image.open(local('data', 'ball.png')).convert('RGBA') self.tex2 = self.ctx.texture(img.size, 4, img.tobytes()) self.tex2.use(1) vertices = np.array([ -1.0, -1.0, 0.0, 0.0, -1.0, 1.0, 0.0, 1.0, 1.0, -1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, ]) vbo1 = self.ctx.buffer(vertices.astype('f4').tobytes()) self.vbo2 = self.ctx.buffer(reserve=1024 * 1024) vao_content = [ (vbo1, '2f 2f', 'in_vert', 'in_texture'), (self.vbo2, '3f 2f 4f/i', 'in_pos', 'in_size', 'in_tint'), ] self.vao = self.ctx.vertex_array(self.prog, vao_content) self.space = pymunk.Space() self.space.gravity = (0.0, -900.0) shape = pymunk.Segment(self.space.static_body, (5, 100), (595, 100), 1.0) shape.friction = 1.0 self.space.add(shape) self.bodies = [] self.balls = [] for x in range(5): for y in range(10): size = 20 mass = 10.0 moment = pymunk.moment_for_box(mass, (size, size)) body = pymunk.Body(mass, moment) body.position = Vec2d(300 + x * 50, 105 + y * (size + 0.1)) shape = pymunk.Poly.create_box(body, (size, size)) shape.friction = 0.3 self.space.add(body, shape) self.bodies.append(body)
def bottom_right_extent(self): return Vec2d(self.width_bottom, -self.height) / 2
def main(): # Primatians - woo print "Running Python version:", sys.version print "Running PyGame version:", pygame.ver print "Running PyMunk version:", pymunk.version print "Running Primatians version:", __version__ pygame.init() screen = pygame.display.set_mode((800, 500), pygame.RESIZABLE) bg, bg_rect = background_image('rainforest.jpg') screen.blit(bg, (0, 0)) pygame.display.set_caption("Primatians - A Nanho Games Production") clock = pygame.time.Clock() running = True # Physics stuff space = pymunk.Space(50) space.gravity = (90, -90.0) # Balls balls = [] mass = 1 radius = 25 inertia = pymunk.moment_for_circle(mass, 0, radius, (0, 0)) body = pymunk.Body(mass, inertia) x = random.randint(0, 500) body.position = 400, 400 shape = pymunk.Circle(body, radius, (0, 0)) shape.elasticity = 0.95 space.add(body, shape) balls.append(shape) # Primates primates = [] mass = 1 radius = 25 inertia = pymunk.moment_for_circle(mass, 0, radius, (0, 0)) body = pymunk.Body(mass, inertia) x = random.randint(0, 500) body.position = 10, 10 shape = pymunk.Circle(body, radius, (0, 0)) shape.elasticity = 0.95 space.add(body, shape) primates.append(shape) # Walls first static_body = pymunk.Body() # x1,y1, x2,y2 static_lines = [pymunk.Segment(static_body, (0.0, 0.0), (0.0, 500.0), 5.0), pymunk.Segment(static_body, (0.0, 500.0), (800.0, 500.0), 5.0), pymunk.Segment(static_body, (800.0, 500.0), (800.0, 0.0), 5.0), pymunk.Segment(static_body, (800.0, 0.0), (0.0, 0.0), 5.0) ] for line in static_lines: line.elasticity = 0.7 line.group = 1 space.add(static_lines) # Some Logs static_logs = [pymunk.Segment(static_body, (200, 250), (600, 250), 5)] for logs in static_logs: logs.elasticity = 1 logs.group = 1 space.add(static_logs) # Add Flippers ( handler tree logs) fp = [(20, -20), (-120, 0), (20, 20)] mass = 100 moment = pymunk.moment_for_poly(mass, fp) # right flipper r_flipper_body = pymunk.Body(mass, moment) r_flipper_body.position = 750, 10 r_flipper_shape = pymunk.Poly(r_flipper_body, fp) space.add(r_flipper_body, r_flipper_shape) r_flipper_joint_body = pymunk.Body() r_flipper_joint_body.position = r_flipper_body.position j = pymunk.PinJoint(r_flipper_body, r_flipper_joint_body, (0, 0), (0, 0)) #todo: tweak values of spring better s = pymunk.DampedRotarySpring(r_flipper_body, r_flipper_joint_body, 0.15, 20000000, 900000) space.add(j, s) # left flipper l_flipper_body = pymunk.Body(mass, moment) l_flipper_body.position = 10, 10 l_flipper_shape = pymunk.Poly(l_flipper_body, [(-x, y) for x, y in fp]) space.add(l_flipper_body, l_flipper_shape) l_flipper_joint_body = pymunk.Body() l_flipper_joint_body.position = l_flipper_body.position j = pymunk.PinJoint(l_flipper_body, l_flipper_joint_body, (0, 0), (0, 0)) s = pymunk.DampedRotarySpring(l_flipper_body, l_flipper_joint_body, -0.15, 20000000, 900000) space.add(j, s) r_flipper_shape.group = l_flipper_shape.group = 1 r_flipper_shape.elasticity = l_flipper_shape.elasticity = 0.4 # sprites ball_sprite = GameSprite('banana-small.png') primate1_sprite = GameSprite('primate2.png') #ball_sprite = pygame.image.load('assets/banana-small.png') #primate1_sprite = pygame.image.load('assets/primate2.png') while running: for event in pygame.event.get(): if event.type == QUIT: running = False elif event.type == KEYDOWN and event.key == K_ESCAPE: running = False elif event.type == KEYDOWN and event.key == K_z: l_flipper_body.apply_impulse(Vec2d.unit() * -40000, (-100, 0)) elif event.type == KEYDOWN and event.key == K_x: r_flipper_body.apply_impulse(Vec2d.unit() * 40000, (-100, 0)) # Draw # backgroundLayer.draw() #screen.fill(THECOLORS["darkolivegreen"]) screen.blit(bg, (0, 0)) # Draw lines for line in static_lines: body = line.body pv1 = body.position + line.a.rotated(body.angle) pv2 = body.position + line.b.rotated(body.angle) p1 = to_pygame(pv1) p2 = to_pygame(pv2) pygame.draw.lines(screen, THECOLORS["black"], False, [p1, p2]) # Draw logs for log in static_logs: body = log.body pv1 = body.position + log.a.rotated(body.angle) pv2 = body.position + log.b.rotated(body.angle) p1 = to_pygame(pv1) p2 = to_pygame(pv2) pygame.draw.lines(screen, THECOLORS["brown"], False, [p1,p2]) for ball in balls: p = to_pygame(ball.body.position) #angle_degrees = math.degrees(ball.body.angle) + 180 #rotated_logo_img = pygame.transform.rotate(ball_sprite, angle_degrees) #offset = Vec2d(rotated_logo_img.get_size()) / 2. #x, y = ball.get_points()[0] #p = Vec2d(x,y) #p = p - offset screen.blit(ball_sprite.image, p) ball_sprite.rect.center = p pygame.draw.circle(screen, THECOLORS["yellow"], p, int(ball.radius), 2) for primate in primates: p = to_pygame(primate.body.position) screen.blit(primate1_sprite.image, p) primate1_sprite.rect.center = p r_flipper_body.position = 790, 10 l_flipper_body.position = 10, 10 r_flipper_body.velocity = l_flipper_body.velocity = 0,0 for f in [r_flipper_shape, l_flipper_shape]: ps = f.get_points() ps.append(ps[0]) ps = map(to_pygame, ps) color = THECOLORS["burlywood4"] # we need to rotate 180 degrees because of the y coordinate flip # angle_degrees = math.degrees(f.body.angle) + 180 # rotated_logo_img = pygame.transform.rotate(log_sprite, angle_degrees) # offset = Vec2d(rotated_logo_img.get_size()) / 2. # x, y = f.get_points()[0] # p = Vec2d(x,y) # p = p - offset # screen.blit(log_sprite, p) #pygame.draw.lines(screen, color, False, ps) pygame.draw.polygon(screen, color, ps, 0) #if pygame.sprite.spritecollide(primate1_sprite, [ball_sprite], 1): if pygame.sprite.collide_rect(primate1_sprite, ball_sprite): print primate1_sprite.rect print ball_sprite.rect print 'Sprites Collide' # Update physics dt = 1.0/60.0/5 for x in range(5): space.step(dt) pygame.display.flip() clock.tick(50)
def top_left_extent(self): return Vec2d(-self.extent.x, self.extent.y)
def bottom_right_extent(self): return Vec2d(self.extent.x, -self.extent.y)
def __init__(self, position, extent, angle=0., **parameters): super().__init__(position=position, angle=angle, **parameters) self.extent = Vec2d(extent)
def iter_points(self): for i in range(self.segments): t = i / self.segments * math.pi * 2 yield Vec2d((math.sin(t), math.cos(t))) * self.radius
def iter_points(self): steps = 6 for i in range(steps): t = i / steps * math.pi * 2 yield Vec2d((math.sin(t), math.cos(t))) * self.radius
def top_right_extent(self): return Vec2d(self.width_top, self.height) / 2
shape = pymunk.Circle(body, 10) shape.elasticity = 1.5 space.add(shape) balls.append(shape) while running: for event in pygame.event.get(): if event.type == QUIT: running = False elif event.type == KEYDOWN and event.key == K_ESCAPE: running = False elif event.type == KEYDOWN and event.key == K_p: pygame.image.save(screen, "flipper.png") elif event.type == KEYDOWN and event.key == K_j: r_flipper_body.apply_impulse(Vec2d.unit() * 40000, (-100,0)) elif event.type == KEYDOWN and event.key == K_f: l_flipper_body.apply_impulse(Vec2d.unit() * -40000, (-100,0)) elif event.type == KEYDOWN and event.key == K_b: mass = 1 radius = 25 inertia = pymunk.moment_for_circle(mass, 0, radius, (0,0)) body = pymunk.Body(mass, inertia) x = random.randint(115,350) body.position = x, 400 shape = pymunk.Circle(body, radius, (0,0)) shape.elasticity = 0.95 space.add(body, shape) balls.append(shape)
def setup(self): for segment in self.segments: length = utils.distance(segment.a, segment.b) angle = utils.angle_between_points(segment.a, segment.b) verts = [ Vec2d(-length / 2, segment.radius), Vec2d(length / 2, segment.radius), Vec2d(length / 2, -segment.radius), Vec2d(-length / 2, -segment.radius) ] cap_l = [ Vec2d(-length / 2, segment.radius), Vec2d(-length / 2, -segment.radius), Vec2d((-length / 2) - segment.radius, 0), ] cap_r = [ Vec2d(length / 2, segment.radius), Vec2d(length / 2, -segment.radius), Vec2d((length / 2) + segment.radius, 0), ] for vert in verts: vert.rotate_degrees(angle) vert += utils.midpoint(segment.a, segment.b) points = [] for vert in verts: points.append(vert[0]) points.append(vert[1]) res = len(points) // 2 segment.pyglet_debug = self.scene.debug_batch.add_indexed( res, GL_TRIANGLES, self.scene.ordered_group1, calc_index_tri(res), ('v2f', points), ('c3B', self.seg_color * res)) # Segment end caps for vert in cap_l: vert.rotate_degrees(angle) vert += utils.midpoint(segment.a, segment.b) points = [] for vert in cap_l: points.append(vert[0]) points.append(vert[1]) segment.cap_l = self.scene.debug_batch.add_indexed( 3, GL_TRIANGLES, self.scene.ordered_group1, calc_index_tri(3), ('v2f', points), ('c3B', self.seg_color * 3)) for vert in cap_r: vert.rotate_degrees(angle) vert += utils.midpoint(segment.a, segment.b) points = [] for vert in cap_r: points.append(vert[0]) points.append(vert[1]) segment.cap_r = self.scene.debug_batch.add_indexed( 3, GL_TRIANGLES, self.scene.ordered_group1, calc_index_tri(3), ('v2f', points), ('c3B', self.seg_color * 3)) for circle in self.circles: if not hasattr(circle, 'fill_color'): circle.fill_color = random.choice(self.rand_colors) circle.outline_color = (255, 255, 255) circle.line_color = (255, 255, 255) circle.sleep_color = self.sleep_color # divisible by 3! if circle.radius <= 150: circle.circle_res = 21 if circle.radius <= 100: circle.circle_res = 18 if circle.radius <= 50: circle.circle_res = 15 if circle.radius <= 25: circle.circle_res = 12 if circle.radius <= 10: circle.circle_res = 9 if circle.radius <= 5: circle.circle_res = 6 if circle.radius <= 2: circle.circle_res = 3 points = define_circle_points(circle.radius, circle.body.position, circle.circle_res) res = len(points) // 2 circle.res = res circle.pyglet_outline = self.scene.debug_batch.add_indexed( res, GL_LINES, self.scene.ordered_group3, calc_index(res), ('v2f', points), ('c3B', (255, 255, 255) * res)) fill_points = points fill_points.insert(0, circle.body.position[0]) fill_points.insert(1, circle.body.position[1]) circle.pyglet_fill = self.scene.debug_batch.add_indexed( res + 1, GL_TRIANGLES, self.scene.ordered_group4, calc_circle_index(res + 1), ('v2f', fill_points), ('c4B', circle.fill_color * (res + 1))) circle.rotation_line = self.scene.debug_batch.add_indexed( 2, GL_LINES, self.scene.ordered_group5, [0, 1, 1, 0], ('v2f', (0, 0, 0, 0)), ('c3B', (255, 255, 255) * 2)) for poly in self.polygons: if not hasattr(poly, 'fill_color'): poly.fill_color = random.choice(self.rand_colors) poly.outline_color = (255, 255, 255, 255) poly.sleep_fill_color = self.poly_sleep_fill poly.sleep_color = (255, 255, 255, 255) poly.outline_color = (255, 255, 255, 255) p = poly.get_points() #.get_vertices() points = [] for vert in p: points.append(vert[0]) points.append(vert[1]) res = len(points) // 2 poly.res = res # fill and outline for polygons poly.pyglet_fill = self.scene.debug_batch.add_indexed( res, GL_TRIANGLES, self.scene.ordered_group2, calc_index_tri(res), ('v2f', points), ('c4B', (0, 0, 0, 0) * res)) poly.pyglet_outline = self.scene.debug_batch.add_indexed( res, GL_LINES, self.scene.ordered_group1, calc_index(res), ('v2f', points), ('c4B', poly.outline_color * res))
def keyControl(self): isMinJerk = False isPointToPoint = False while (self.running): """ angle calculated from mouse cursor position""" mouse_position = from_pygame( Vec2d(self.pygame.mouse.get_pos()), self.screen ) forced_angle = (mouse_position-self.gForearm_body.position).angle # calculate angle with mouse cursor loc. # move the unfired arrow together with the cannon # arrow_body.position = cannon_body.position + Vec2d(cannon_shape.radius + 40, 0).rotated(cannon_body.angle) # arrow_body.angle = cannon_body.angle # self.gForearm_body.torque = -0.1 # rest-length change if (isMinJerk): d = 10 # 40 , speed jmax = 0.8 # 1.0 , joint maxzz t = jmax * (10*(self.timeMinJerk/d)**3 - 15*(self.timeMinJerk/d)**4 + 6*(self.timeMinJerk/d)**5) if t > jmax: self.jointMin = jmax xem_cortical_bic.SendButton(False, BUTTON_INPUT_FROM_TRIGGER) # BUTTON_INPUT_FROM_TRIGGER = 1 xem_cortical_tri.SendButton(False, BUTTON_INPUT_FROM_TRIGGER) # BUTTON_INPUT_FROM_TRIGGER = 1 print "t > jmax" else: self.jointMin = t if self.timeMinJerk == 0.0: # enter only once print "time 0" xem_cortical_bic.SendButton(True, BUTTON_INPUT_FROM_TRIGGER) # BUTTON_INPUT_FROM_TRIGGER = 1 xem_cortical_tri.SendButton(True, BUTTON_INPUT_FROM_TRIGGER) # BUTTON_INPUT_FROM_TRIGGER = 1 # xem_cortical_bic.SendPara(bitVal = 5000, trigEvent = 8) # up (TONIC ON triceps) elif self.timeMinJerk == 7.0: # xem_cortical_tri.SendPara(bitVal = 5000, trigEvent = 8) # down (TONIC ON biceps) print "time 7" self.timeMinJerk+= 1.0 # time step # point to point trigger in for only one cycle (non-repetitive) if (isPointToPoint): if self.p2ptime > 500.0: # 50.0 xem_cortical_bic.SendButton(False, BUTTON_INPUT_FROM_TRIGGER) # BUTTON_INPUT_FROM_TRIGGER = 1 xem_cortical_tri.SendButton(False, BUTTON_INPUT_FROM_TRIGGER) # BUTTON_INPUT_FROM_TRIGGER = 1 self.p2ptime += 1.0 print self.p2ptime """ key control """ for event in self.pygame.event.get(): if event.type == QUIT: self.running = False elif event.type == KEYDOWN and event.key == K_ESCAPE: self.plotData(self.data_bic, self.data_tri) self.running = False elif event.type == KEYDOWN and event.key == K_p: # Point-to-point # isMinJerk = True bitVal = convertType(0.0, fromType = 'f', toType = 'I') xem_cortical_bic.SendPara(bitVal = 0, trigEvent = 8) xem_cortical_tri.SendPara(bitVal = 0, trigEvent = 8) # xem_cortical_bic.SendButton(True, BUTTON_RESET_SIM) # # xem_cortical_tri.SendButton(True, BUTTON_RESET_SIM) # # # xem_cortical_tri.SendButton(False, BUTTON_RESET_SIM) # # xem_cortical_bic.SendButton(False, BUTTON_RESET_SIM) # self.point2pointForce(True) # point-to-point movement # bitVal = convertType(200.0, fromType = 'f', toType = 'I') # xem_cortical_bic.SendPara(bitVal = 5000, trigEvent = 8) # xem_cortical_tri.SendPara(bitVal = 5000, trigEvent = 8) elif event.type == KEYDOWN and event.key == K_j: self.gForearm_body.torque -= 14.0 elif event.type == KEYDOWN and event.key == K_f: #self.gForearm_body.apply_force(Vec2d.unit() * -40000, (-100,0)) self.gForearm_body.torque += 14.0 elif event.type == KEYDOWN and event.key == K_t: # tonic on # bitVal = convertType(6000.0, fromType = 'f', toType = 'I') xem_cortical_bic.SendPara(bitVal = 18000, trigEvent = 8) xem_cortical_tri.SendPara(bitVal = 12000, trigEvent = 8) elif event.type == KEYDOWN and event.key == K_y: # tonic off bitVal = convertType(0.0, fromType = 'f', toType = 'I') xem_cortical_bic.SendPara(bitVal = 0, trigEvent = 8) xem_cortical_tri.SendPara(bitVal = 0, trigEvent = 8) elif event.type == KEYDOWN and event.key == K_z: # self.gRest_joint_angle = self.angle self.gForearm_body.angle = 0.0 elif event.type == KEYDOWN and event.key == K_r: self.gForearm_body.apply_impulse(Vec2d.unit()*0.3, (4, 0)) elif event.type == KEYDOWN and event.key == K_u: self.gForearm_body.apply_impulse(Vec2d.unit()*0.3, (-4, 0)) elif event.type == KEYDOWN and event.key == K_s: #reset-sim boards xem_cortical_bic.SendButton(True, BUTTON_RESET_SIM) # xem_cortical_tri.SendButton(True, BUTTON_RESET_SIM) # # xem_cortical_tri.SendButton(False, BUTTON_RESET_SIM) # # xem_cortical_bic.SendButton(False, BUTTON_RESET_SIM) # elif event.type == KEYDOWN and event.key == K_d: #reset-sim boards xem_cortical_bic.SendButton(False, BUTTON_RESET_SIM) # xem_cortical_tri.SendButton(False, BUTTON_RESET_SIM) # # elif event.type == KEYDOWN and event.key == K_d: #reset-sim boards elif event.type == KEYDOWN and event.key == K_e: # trigger off xem_cortical_bic.SendButton(False, BUTTON_INPUT_FROM_TRIGGER) # BUTTON_INPUT_FROM_TRIGGER = 1 xem_cortical_tri.SendButton(False, BUTTON_INPUT_FROM_TRIGGER) # BUTTON_INPUT_FROM_TRIGGER = 1 elif event.type == KEYDOWN and event.key == K_w: # trigger on isPointToPoint = True xem_cortical_bic.SendButton(True, BUTTON_INPUT_FROM_TRIGGER) # BUTTON_INPUT_FROM_TRIGGER = 1 xem_cortical_tri.SendButton(True, BUTTON_INPUT_FROM_TRIGGER) # BUTTON_INPUT_FROM_TRIGGER = 1 # elif event.type == KEYDOWN and event.key == K_o: # CN syn gain 50 # bitVal50 = convertType(50.0, fromType = 'f', toType = 'I') # xem_muscle_bic.SendPara(bitVal = bitVal50, trigEvent = 10) # xem_muscle_tri.SendPara(bitVal = bitVal50, trigEvent = 10) # elif event.type == KEYDOWN and event.key == K_p: # CN syn gain 100 # bitVal100 = convertType(100.0, fromType = 'f', toType = 'I') # xem_muscle_bic.SendPara(bitVal = bitVal100, trigEvent = 10) # xem_muscle_tri.SendPara(bitVal = bitVal100, trigEvent = 10) elif event.type == KEYDOWN and event.key == K_l: # forced movement, follow the mouse if (self.record == True): self.record = False if (self.record == False): self.record = True k = 1 """ Minos - A simple angle servo """ # servo_torque = 3.0 * (30.0/180.0 * 3.141592 - self.gForearm_body.angle) # self.gForearm_body.torque += servo_torque """ mouse cursor controlled forced (passive) movement""" if (self.record == True): #self.gForearm_body.angle =forced_angle if k == len(self.j2List)-1: self.gForearm_body.angle = 0.0 else: self.gForearm_body.angle = (self.j2List[k])*3.141592/180 # in radian k = k + 1 #print self.j2List[k] """ Clear screen """ self.screen.fill(THECOLORS["white"]) # ~1ms """ Draw stuff """ for f in [self.gForearm_shape,]: ps = f.get_points() ps.append(ps[0]) ps = map(self.to_pygame, ps) color = THECOLORS["black"] self.pygame.draw.lines(self.screen, color, False, ps, 2) #if abs(flipper_body.angle) < 0.001: flipper_body.angle = 0 """draw circle """ # pygame.draw.circle(self.screen, THECOLORS["black"], (300, 300), int(42), 0) # pygame.draw.circle(self.screen, THECOLORS["white"], (300, 300), int(40), 0) # pygame.draw.circle(self.screen, THECOLORS["black"], (300, 300), int(3), 0) # pygame.draw.line(self.screen, THECOLORS["black"], [300, 300-42], [500, 300-42], 2) # pygame.draw.line(self.screen, THECOLORS["black"], [300, 300+40], [500, 300+40], 2) """ Update physics """ fps = 30.0 #was 30.0 step = 1 dt = 1.0/fps/step for x in range(step): # self.gSpace.step(dt) self.gSpace.step(0.001*8*2) """ text message""" myfont = self.pygame.font.SysFont("monospace", 15) label1 = myfont.render("j:torque down, f: torque up" , 1, THECOLORS["black"]) label2 = myfont.render("l: mouse-controlled movement, esc:out" , 1, THECOLORS["black"]) self.screen.blit(label1, (10, 10)) self.screen.blit(label2, (10, 40)) """ Flip screen (big delay from here!) """ self.pygame.display.flip() # ~1ms self.gClock.tick(fps) # target fps # self.gClock.tick(80) # oscillate self.pygame.display.set_caption("fps: " + str(self.gClock.get_fps()))
def flipy(p): """Convert chipmunk coordinates to pygame coordinates.""" return Vec2d(p[0], -p[1] + 600)
def kick_ball(dt): impulse = 10000 * Vec2d(1, 0) impulse.rotate_degrees(random.randint(0, 360)) ball_sprite.body.apply_impulse_at_local_point(impulse)
def main(): # Primatians - woo print "Running Python version:", sys.version print "Running PyGame version:", pygame.ver print "Running PyMunk version:", pymunk.version print "Running Primatians version:", __version__ pygame.init() screen = pygame.display.set_mode((800, 500), pygame.RESIZABLE) pygame.display.set_caption("Primatians - A Nanho Games Production") # make our background object colorBackground = Color("darkolivegreen4") backgroundLayer = DrawSurf(screen, colorBackground) clock = pygame.time.Clock() running = True # Physics stuff space = pymunk.Space(50) space.gravity = (90, -90.0) # Balls balls = [] mass = 1 radius = 25 inertia = pymunk.moment_for_circle(mass, 0, radius, (0,0)) body = pymunk.Body(mass, inertia) x = random.randint(0,500) body.position = 400, 400 shape = pymunk.Circle(body, radius, (0,0)) shape.elasticity = 0.95 space.add(body, shape) balls.append(shape) # Walls first static_body = pymunk.Body() # x1,y1, x2,y2 static_lines = [pymunk.Segment(static_body, (0.0, 0.0), (0.0, 500.0), 5.0), pymunk.Segment(static_body, (0.0, 500.0), (800.0, 500.0), 5.0), pymunk.Segment(static_body, (800.0, 500.0), (800.0, 0.0), 5.0), pymunk.Segment(static_body, (800.0, 0.0), (0.0, 0.0), 5.0) ] for line in static_lines: line.elasticity = 0.7 line.group = 1 space.add(static_lines) # Some Logs static_logs = [pymunk.Segment(static_body, (200, 250), (600, 250), 5)] for logs in static_logs: logs.elasticity = 1 logs.group = 1 space.add(static_logs) # Add Flippers ( handler tree logs) fp = [(20,-20), (-120, 0), (20,20)] mass = 100 moment = pymunk.moment_for_poly(mass, fp) # right flipper r_flipper_body = pymunk.Body(mass, moment) r_flipper_body.position = 750, 10 r_flipper_shape = pymunk.Poly(r_flipper_body, fp) space.add(r_flipper_body, r_flipper_shape) r_flipper_joint_body = pymunk.Body() r_flipper_joint_body.position = r_flipper_body.position j = pymunk.PinJoint(r_flipper_body, r_flipper_joint_body, (0,0), (0,0)) #todo: tweak values of spring better s = pymunk.DampedRotarySpring(r_flipper_body, r_flipper_joint_body, 0.15, 20000000,900000) space.add(j, s) # left flipper l_flipper_body = pymunk.Body(mass, moment) l_flipper_body.position = 10, 10 l_flipper_shape = pymunk.Poly(l_flipper_body, [(-x,y) for x,y in fp]) space.add(l_flipper_body, l_flipper_shape) l_flipper_joint_body = pymunk.Body() l_flipper_joint_body.position = l_flipper_body.position j = pymunk.PinJoint(l_flipper_body, l_flipper_joint_body, (0,0), (0,0)) s = pymunk.DampedRotarySpring(l_flipper_body, l_flipper_joint_body, -0.15, 20000000,900000) space.add(j, s) # new flippers fp = [(20,-20), (-120, 0), (20,20)] #fp = [(120, 0), (120,-20),(-120,0)] mass = 100 moment = pymunk.moment_for_poly(mass, fp) # top-right flipper tr_flipper_body = pymunk.Body(mass, moment) tr_flipper_body.position = 750, 450 tr_flipper_shape = pymunk.Poly(tr_flipper_body, fp) space.add(tr_flipper_body, tr_flipper_shape) tr_flipper_joint_body = pymunk.Body() tr_flipper_joint_body.position = tr_flipper_body.position j = pymunk.PinJoint(tr_flipper_body, tr_flipper_joint_body, (0,0), (0,0)) #todo: tweak values of spring better s = pymunk.DampedRotarySpring(tr_flipper_body, tr_flipper_joint_body, 0.15, 20000000,900000) space.add(j, s) # top-left flipper tl_flipper_body = pymunk.Body(mass, moment) tl_flipper_body.position = 50, 850 tl_flipper_shape = pymunk.Poly(tl_flipper_body, [(-x,y) for x,y in fp]) space.add(tl_flipper_body, tl_flipper_shape) tl_flipper_joint_body = pymunk.Body() tl_flipper_joint_body.position = tl_flipper_body.position j = pymunk.PinJoint(tl_flipper_body, tl_flipper_joint_body, (0,0), (0,0)) s = pymunk.DampedRotarySpring(tl_flipper_body, tl_flipper_joint_body, -0.15, 20000000,900000) space.add(j, s) r_flipper_shape.group = l_flipper_shape.group = tr_flipper_shape.group = tl_flipper_shape.group = 1 r_flipper_shape.elasticity = l_flipper_shape.elasticity = tr_flipper_shape.elasticity = tl_flipper_shape.elasticity = 0.4 while running: for event in pygame.event.get(): if event.type == QUIT: running = False elif event.type == KEYDOWN and event.key == K_ESCAPE: running = False elif event.type == KEYDOWN and event.key == K_j: r_flipper_body.apply_impulse(Vec2d.unit() * 40000, (-100,0)) elif event.type == KEYDOWN and event.key == K_f: l_flipper_body.apply_impulse(Vec2d.unit() * -40000, (-100,0)) elif event.type == KEYDOWN and event.key == K_g: tl_flipper_body.apply_impulse(Vec2d.unit() * 40000, (-100,0)) elif event.type == KEYDOWN and event.key == K_h: tr_flipper_body.apply_impulse(Vec2d.unit() * -40000, (-100,0)) if event.type == pygame.VIDEORESIZE: screen_size = event.size screen = pygame.display.set_mode(screen_size, pygame.RESIZABLE) oldBg = backgroundLayer.surface.copy() backgroundLayer = DrawSurf(screen, backgroundLayer.color) backgroundLayer.surface.blit(oldBg, (0, 0)) # Draw # backgroundLayer.draw() screen.fill(THECOLORS["darkolivegreen"]) # Draw lines for line in static_lines: body = line.body pv1 = body.position + line.a.rotated(body.angle) pv2 = body.position + line.b.rotated(body.angle) p1 = to_pygame(pv1) p2 = to_pygame(pv2) pygame.draw.lines(screen, THECOLORS["black"], False, [p1,p2]) # Draw logs for log in static_logs: body = log.body pv1 = body.position + log.a.rotated(body.angle) pv2 = body.position + log.b.rotated(body.angle) p1 = to_pygame(pv1) p2 = to_pygame(pv2) pygame.draw.lines(screen, THECOLORS["brown"], False, [p1,p2]) for ball in balls: p = to_pygame(ball.body.position) pygame.draw.circle(screen, THECOLORS["yellow"], p, int(ball.radius), 2) r_flipper_body.position = 790, 10 l_flipper_body.position = 10, 10 tr_flipper_body.position = 790, 490 tl_flipper_body.position = 10, 490 r_flipper_body.velocity = l_flipper_body.velocity = tr_flipper_body.velocity = tl_flipper_body.velocity = 0,0 for f in [r_flipper_shape, l_flipper_shape, tr_flipper_shape, tl_flipper_shape,]: ps = f.get_points() ps.append(ps[0]) ps = map(to_pygame, ps) color = THECOLORS["red"] pygame.draw.lines(screen, color, False, ps) # Update physics dt = 1.0/60.0/5 for x in range(5): space.step(dt) pygame.display.flip() clock.tick(50)
def main(): pygame.init() screen = pygame.display.set_mode(display_size, display_flags) width, height = screen.get_size() def to_pygame(p): """Small hack to convert pymunk to pygame coordinates""" return int(p.x), int(-p.y + height) def from_pygame(p): return to_pygame(p) clock = pygame.time.Clock() running = True font = pygame.font.Font(None, 16) ### Physics stuff space = pm.Space() space.gravity = (0.0, -1900.0) space.damping = 0.999 # to prevent it from blowing up. mouse_body = pm.Body(body_type=pm.Body.KINEMATIC) bodies = [] for x in range(-100, 150, 50): x += width / 2 offset_y = height / 2 mass = 10 radius = 25 moment = pm.moment_for_circle(mass, 0, radius, (0, 0)) body = pm.Body(mass, moment) body.position = (x, -125 + offset_y) body.start_position = Vec2d(*body.position) shape = pm.Circle(body, radius) shape.elasticity = 0.9999999 space.add(body, shape) bodies.append(body) pj = pm.PinJoint(space.static_body, body, (x, 125 + offset_y), (0, 0)) space.add(pj) reset_bodies(space) selected = None if not is_interactive: pygame.time.set_timer(pygame.USEREVENT + 1, 70000) # apply force pygame.time.set_timer(pygame.USEREVENT + 2, 120000) # reset pygame.event.post(pygame.event.Event(pygame.USEREVENT + 1)) pygame.mouse.set_visible(False) while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False elif event.type == pygame.KEYDOWN and event.key == pygame.K_p: pygame.image.save(screen, "newtons_cradle.png") if event.type == pygame.USEREVENT + 1: r = random.randint(1, 4) for body in bodies[0:r]: body.apply_impulse_at_local_point((-6000, 0)) if event.type == pygame.USEREVENT + 2: reset_bodies(space) elif (event.type == pygame.KEYDOWN and event.key == pygame.K_r and is_interactive): reset_bodies(space) elif (event.type == pygame.KEYDOWN and event.key == pygame.K_f and is_interactive): r = random.randint(1, 4) for body in bodies[0:r]: body.apply_impulse_at_local_point((-6000, 0)) elif event.type == pygame.MOUSEBUTTONDOWN and is_interactive: if selected != None: space.remove(selected) p = from_pygame(Vec2d(*event.pos)) hit = space.point_query_nearest(p, 0, pm.ShapeFilter()) if hit != None: shape = hit.shape rest_length = mouse_body.position.get_distance( shape.body.position) ds = pm.DampedSpring(mouse_body, shape.body, (0, 0), (0, 0), rest_length, 1000, 10) space.add(ds) selected = ds elif event.type == pygame.MOUSEBUTTONUP and is_interactive: if selected != None: space.remove(selected) selected = None elif event.type == pygame.KEYDOWN: running = False elif event.type == pygame.MOUSEBUTTONDOWN: running = False mpos = pygame.mouse.get_pos() p = from_pygame(Vec2d(*mpos)) mouse_body.position = p ### Clear screen screen.fill(pygame.Color("black")) ### Draw stuff for c in space.constraints: pv1 = c.a.position + c.anchor_a pv2 = c.b.position + c.anchor_b p1 = to_pygame(pv1) p2 = to_pygame(pv2) pygame.draw.aalines(screen, pygame.Color("lightgray"), False, [p1, p2]) for ball in space.shapes: p = to_pygame(ball.body.position) drawcircle(screen, ball.color, p, int(ball.radius), 0) # pygame.draw.circle(screen, ball.color, p, int(ball.radius), 0) ### Update physics fps = 50 iterations = 25 dt = 1.0 / float(fps) / float(iterations) for x in range( iterations): # 10 iterations to get a more stable simulation space.step(dt) ### Flip screen if is_interactive: screen.blit( font.render("fps: " + str(clock.get_fps()), True, pygame.Color("white")), (0, 0), ) screen.blit( font.render( "Press left mouse button and drag to interact", True, pygame.Color("darkgrey"), ), (5, height - 35), ) screen.blit( font.render( "Press R to reset, any other key to quit", True, pygame.Color("darkgrey"), ), (5, height - 20), ) pygame.display.flip() clock.tick(fps)
def window_focus(self): # TODO: Дописать метод pass def smooth_focus(self, dt): if isinstance(self.__target, Entity): self.__smooth_focus(self.__target.body_rect.centre, dt) elif isinstance(self.__target, MidPoint): self.__smooth_focus(self.__target.get(), dt) elif isinstance(self.__target, Vec2d): self.__smooth_focus(self.__target, dt) elif isinstance(self.__target, PhysicalRect): self.__smooth_focus(self.__target.centre, dt) def __smooth_focus(self, point, dt): # TODO: поколдовать с функцией, и учесть всякие точки перегиба direction = point - self.camera.position velocity = direction if (sm := self.smooth_func(self.alpha * direction.length)) != 0: velocity.scale_to_length(self.max_speed * sm) else: velocity = Vec2d(0, 0) self.camera.position += velocity * dt def smooth_func(self, x): return 1 - sigmoid(self.bias - x) / self.scale def inverse_smooth_func(self, x): return self.bias - inverse_sigmoid((1 - x) * self.scale)
def render(self, view: 'KRoadView'): view.draw_circle_on_entity(self, (64, 225, 64), False, Vec2d(0, 0), self.radius) if self.radius < 5: view.draw_circle_on_entity(self, (64, 225, 64), False, Vec2d(0, 0), 5)
def main(): pygame.init() screen = pygame.display.set_mode((600, 600)) clock = pygame.time.Clock() running = True ### Physics stuff space = pm.Space() space.gravity = Vec2d(0.0, -900.0) draw_options = pymunk.pygame_util.DrawOptions(screen) ## Balls balls = [] ### walls static_lines = [ pm.Segment(space.static_body, Vec2d(111.0, 280.0), Vec2d(407.0, 246.0), 1.0), pm.Segment(space.static_body, Vec2d(407.0, 246.0), Vec2d(407.0, 343.0), 1.0) ] space.add(static_lines) ticks_to_next_ball = 10 while running: for event in pygame.event.get(): if event.type == QUIT: running = False pygame.quit() elif event.type == KEYDOWN and event.key == K_ESCAPE: running = False elif event.type == KEYDOWN and event.key == K_p: pygame.image.save(screen, "point_query.png") ticks_to_next_ball -= 1 if ticks_to_next_ball <= 0: ticks_to_next_ball = 100 mass = 10 radius = 25 inertia = pm.moment_for_circle(mass, 0, radius, Vec2d(0, 0)) body = pm.Body(mass, inertia) x = random.randint(115, 350) body.position = x, 400 shape = pm.Circle(body, radius, Vec2d(0, 0)) shape.color = THECOLORS["lightgrey"] space.add(body, shape) balls.append(shape) ### Clear screen screen.fill(THECOLORS["white"]) ### Draw stuff space.debug_draw(draw_options) balls_to_remove = [] for ball in balls: if ball.body.position.y < 200: balls_to_remove.append(ball) for ball in balls_to_remove: space.remove(ball, ball.body) balls.remove(ball) mouse_pos = pymunk.pygame_util.get_mouse_pos(screen) shape = space.point_query_nearest(mouse_pos, pymunk.inf, pymunk.ShapeFilter()).shape if shape is not None: if hasattr(shape, "radius"): r = shape.radius + 4 else: r = 10 p = pymunk.pygame_util.to_pygame(shape.body.position, screen) pygame.draw.circle(screen, THECOLORS["red"], p, int(r), 2) ### Update physics dt = 1.0 / 60.0 for x in range(1): space.step(dt) ### Flip screen pygame.display.flip() clock.tick(50) pygame.display.set_caption("fps: " + str(clock.get_fps()))
def start(self): """ Fonction pour commencer le jeux :return: """ self.cam.start() balls = [] point_num = 0 color_trai = (0, 0, 255) while True: self.space.step(1 / 50.0) ball_shape = self.add_ball() balls.append(ball_shape) # on track la balle center, img_out = self.traking.tick( cv2.getTrackbarPos('iterations', 'Main')) # Si on a decter la balle if center is not None: point_num += 1 # on ajoute sa position dans la liste self.point_que.appendleft(center) # on rajout un vector que si on a 2 point if point_num == 2: # on cree nos 2 point en pymunk line_point_1 = Vec2d(self.point_que[1][0], self.to_pymunk_y(self.point_que[1][1])) line_point_2 = Vec2d(self.point_que[0][0], self.to_pymunk_y(self.point_que[0][1])) body = pymunk.Body(body_type=pymunk.Body.STATIC) # on cree un segment shape = pymunk.Segment(body, line_point_1, line_point_2, 0.0) shape.fraction = 0.99 self.space.add(shape) self.static_line.append(shape) point_num = 0 # on regarde si le buffer n'est pas plein if len(self.point_que) >= self.buffer: try: # on enlève le premier vector shape = self.static_line.pop(0) self.space.remove(shape, shape.body) self.static_line.remove(shape) except KeyError: pass # on dessine les boulles for ball in balls: # On supprime les boulles en dehord de l'écrant if self.to_pymunk_y(ball.body.position.y) > self.height + 20: self.space.remove(ball, ball.body) balls.remove(ball) else: r = ball.radius v = ball.body.position p = int(v.x), int(self.to_pymunk_y(v.y)) cv2.circle(img_out, p, int(r), (0, 255, 255), 2) # on affiche l'image cv2.imshow("Main", self.draw_point(img_out, color_trai)) if cv2.waitKey(1) & 0xFF == ord('q'): cv2.destroyAllWindows() break self.cam.stop()
def main(): pygame.init() screen = pygame.display.set_mode((600, 600), pygame.DOUBLEBUF) clock = pygame.time.Clock() running = True ### Physics stuff space = pymunk.Space() space.gravity = 0.0, 0.0 ## initiating circles circles = [] ## Balls balls = [] ### Mouse mouse_body = pymunk.Body(body_type=pymunk.Body.KINEMATIC) mouse_shape = pymunk.Circle(mouse_body, 3, (0, 0)) mouse_shape.collision_type = COLLTYPE_MOUSE space.add(mouse_shape) space.add_collision_handler(COLLTYPE_MOUSE, COLLTYPE_BALL).pre_solve = mouse_coll_func ### Static line line_point1 = None static_lines = [] run_physics = True expanding = True x0 = 0 y0 = 0 x1 = 600 y1 = 600 pts = [(x0, y0), (x1, y0), (x1, y1), (x0, y1)] ## 벽 정 for i in range(4): body = pymunk.Body(body_type=pymunk.Body.STATIC) segment = pymunk.Segment(body, pts[i], pts[(i + 1) % 4], 20) segment.collision_type = COLLTYPE_WALL segment.elasticity = 0.999 segment.friction = 1 space.add(segment) space.add_collision_handler( COLLTYPE_WALL, COLLTYPE_BALL).pre_solve = collision_detection_wall while running: running = not final_state() expanding = not final_state() for event in pygame.event.get(): if event.type == QUIT: running = False expanding = False elif event.type == KEYDOWN and event.key == K_ESCAPE: running = False expanding = False elif event.type == KEYDOWN and event.key == K_p: pygame.image.save(screen, "balls_and_lines.png") elif event.type == MOUSEBUTTONDOWN and event.button == 1: p = event.pos[X], flipy(event.pos[Y]) body = pymunk.Body(100, 100) # 원의 초기 속도 정의 # 모양 정의 (실제 생성되는 오브젝트) body.velocity_func = limit_velocity body.velocity = (random.uniform(-50, 50), random.uniform(-50, 50)) body.position = p shape = pymunk.Circle(body, 10, (10, 10)) shape.elasticity = 0.999 shape.friction = 1 shape.collision_type = COLLTYPE_BALL space.add_collision_handler( COLLTYPE_BALL, COLLTYPE_BALL).pre_solve = collision_detection space.add(body, shape) circles.append(shape) elif event.type == MOUSEBUTTONDOWN and event.button == 3: if line_point1 is None: line_point1 = Vec2d(event.pos[X], flipy(event.pos[Y])) elif event.type == MOUSEBUTTONUP and event.button == 3: if line_point1 is not None: line_point2 = Vec2d(event.pos[X], flipy(event.pos[Y])) body = pymunk.Body(body_type=pymunk.Body.STATIC) shape = pymunk.Segment(body, line_point1, line_point2, 0.0) shape.friction = 0.99 space.add(shape) static_lines.append(shape) line_point1 = None elif event.type == KEYDOWN and event.key == K_SPACE: run_physics = not run_physics expanding = not expanding p = pygame.mouse.get_pos() mouse_pos = Vec2d(p[X], flipy(p[Y])) mouse_body.position = mouse_pos if pygame.key.get_mods() & KMOD_SHIFT and pygame.mouse.get_pressed( )[0]: body = pymunk.Body(10, 10) body.velocity = (100, 100) body.position = mouse_pos shape = pymunk.Circle(body, 10, (1, 1)) shape.collision_type = COLLTYPE_BALL space.add(body, shape) circle.append(shape) ### Update physics if run_physics: dt = 1.0 / 60.0 for x in range(1): space.step(dt) ### Draw stuff screen.fill(THECOLORS["white"]) # Display some text font = pygame.font.Font(None, 16) text = """LMB: Create ball Space: Pause physics simulation""" y = 5 for line in text.splitlines(): text = font.render(line, 1, THECOLORS["black"]) screen.blit(text, (5, y)) y += 10 for i, circle in enumerate(circles): r = circle.radius v = circle.body.position # 원이 프레임당 얼마나 커지나 # 0.05가 변수 """ To do """ if (expanding): circle.unsafe_set_radius(r + 0.05) rot = circle.body.rotation_vector p = int(v.x), int(flipy(v.y)) p2 = Vec2d(rot.x, -rot.y) * r * 0.9 pygame.draw.circle(screen, Color(color[i % 12]), p, int(r), 0) pygame.draw.line(screen, THECOLORS["black"], p, p + p2) if line_point1 is not None: p1 = line_point1.x, flipy(line_point1.y) p2 = mouse_pos.x, flipy(mouse_pos.y) pygame.draw.lines(screen, THECOLORS["black"], False, [p1, p2]) for line in static_lines: body = line.body pv1 = body.position + line.a.rotated(body.angle) pv2 = body.position + line.b.rotated(body.angle) p1 = pv1.x, flipy(pv1.y) p2 = pv2.x, flipy(pv2.y) pygame.draw.lines(screen, THECOLORS["lightgray"], False, [p1, p2]) ### Flip screen pygame.display.flip() clock.tick(1000) pygame.display.set_caption("fps: " + str(clock.get_fps()))
def curriculum_trajectory_generator(process: 'TrajectoryTrackingProcess') -> Tuple[List[Tuple[Vec2d, float]], bool]: r = random.Random(random_seed) # speed_step = (max_speed - min_speed) / num_speed_stages angle = 0.0 waypoints = [(Vec2d(0, 0), min_speed), (Vec2d(.01, 0), min_speed)] ''' increase curvature increasing speeds? random speeds random speed, curvature, length ''' # length_remaining = stage_length # while length_remaining > 0: # # https://www.fhwa.dot.gov/publications/research/safety/17098/004.cfm # # http://dotapp7.dot.state.mn.us/edms/download?docId=1062356 # # target_speed = random.uniform(min_speed, max_speed) # suggested_turning_radius = ((target_speed * 3.6) ** 2) / (127 * (0.0 + .12)) # turn_rate_multiplier = min_turn_rate_multiplier + (t + random.uniform(0, 1)) * turning_rate_step # turn_rate = turn_rate_multiplier / suggested_turning_radius # # turning_rate_step = (max_turn_rate_multiplier - min_turn_rate_multiplier) / num_turning_rate_stages target_speed = min_speed for t in range(num_turning_rate_stages): # https://www.fhwa.dot.gov/publications/research/safety/17098/004.cfm # http://dotapp7.dot.state.mn.us/edms/download?docId=1062356 # num_turning_steps = 1 + int(ceil((min_turning_rate - max_turning_rate) / turning_rate_step)) # print('num_turning_steps', num_turning_steps, min_turning_rate, mid_turning_rate, max_turning_rate) # place straightaway if transition_length > 0: target_speed = r.uniform(min_speed, max_speed) waypoints.append((waypoints[-1][0] + Vec2d(transition_length, 0.0).rotated(angle), target_speed)) print('stage ', t) # place curves stage_length_remaining = stage_length while stage_length_remaining > 0: # target_speed = r.uniform(min_speed, max_speed) target_speed = max(min_speed, min(max_speed, target_speed + r.uniform(-max_speed_delta, max_speed_delta))) suggested_turning_radius = ((target_speed * 3.6) ** 2) / (127 * (0.0 + .12)) turn_rate_multiplier = min_turn_rate_multiplier + (t + r.uniform(0, 1)) * turning_rate_step turn_rate = turn_rate_multiplier / suggested_turning_radius # turn_arc = random.uniform(min_turn_arc, max_turn_arc) turn_direction = 1 if bool(r.getrandbits(1)) else -1 turn_length = min(stage_length_remaining, r.uniform(min_turn_length, max_turn_length)) stage_length_remaining -= turn_length print('curve ', target_speed, turn_rate_multiplier, turn_rate, turn_length) # remaining_arc = turn_arc # while remaining_arc > 1e-3: while turn_length > 1e-3: # arc = min(remaining_arc, .5 * pi / 180.0) # remaining_arc -= arc arc = .5 * pi / 180 line_length = min(turn_length, arc / (turn_rate + 1e-6)) line_angle = turn_direction * arc angle += line_angle delta = Vec2d(line_length, 0.0) # print(line_length) delta.rotate(angle) last = waypoints[-1] next = last[0] + delta waypoints.append((next, target_speed)) turn_length -= line_length # pprint(waypoints) # print('length: ', length) return waypoints, False
def loop(self): for event in pygame.event.get(): if event.type == QUIT: self.running = False elif event.type == KEYDOWN and event.key == K_ESCAPE: self.running = False elif event.type == KEYDOWN and event.key == K_p: pygame.image.save(self.screen, "playground.png") elif event.type == MOUSEBUTTONDOWN and event.button == 1: # LMB if pygame.key.get_mods() & KMOD_SHIFT: p = self.flipyv(Vec2d(event.pos)) self.polys.append(self.create_box(pos=p)) else: #t = -10000 p = self.flipyv(Vec2d(event.pos)) self.balls.append(self.create_ball(p)) print p elif event.type == MOUSEBUTTONDOWN and event.button == 3: #RMB if pygame.key.get_mods() & KMOD_SHIFT: pass elif pygame.key.get_mods() & KMOD_CTRL: p = self.flipyv(Vec2d(event.pos)) self.wall_points.append(p) elif self.shape_to_remove is not None: print self.shape_to_remove self.balls = filter(lambda a: a != self.shape_to_remove, self.balls) self.walls = filter(lambda a: a != self.shape_to_remove, self.walls) self.polys = filter(lambda a: a != self.shape_to_remove, self.polys) self.space.remove(self.shape_to_remove.body, self.shape_to_remove) elif event.type == KEYUP and event.key in (K_RCTRL, K_LCTRL): ### Create Wall self.create_wall_segments(self.wall_points) self.wall_points = [] elif event.type == KEYUP and event.key in (K_RSHIFT, K_LSHIFT): ### Create Polygon if len(self.poly_points) > 0: self.poly_points = u.reduce_poly(self.poly_points, tolerance=5) if len(self.poly_points) > 2: self.poly_points = u.convex_hull(self.poly_points) if not u.is_clockwise(self.poly_points): self.poly_points.reverse() center = u.calc_center(self.poly_points) self.poly_points = u.poly_vectors_around_center( self.poly_points) self.polys.append( self.create_poly(self.poly_points, pos=center)) self.poly_points = [] elif event.type == KEYDOWN and event.key == K_SPACE: self.run_physics = not self.run_physics elif event.type == KEYDOWN and event.key == K_k: for x in range(-100, 100, 25): for y in range(-100, 100, 25): p = pygame.mouse.get_pos() p = self.flipyv(Vec2d(p)) + (x, y) self.polys.append(self.create_box(pos=p)) elif event.type == KEYDOWN and event.key == K_b: p = flipyv(Vec2d(pygame.mouse.get_pos())) self.polys.append(self.create_box(p, size=10, mass=1)) elif event.type == KEYDOWN and event.key == K_f: bp = Vec2d(100, 500) p = self.flipyv(Vec2d(pygame.mouse.get_pos())) - bp ball = self.create_ball(bp) p = p.normalized() ball.body.apply_impulse(p * 1000, (0, 0)) self.balls.append(ball) elif event.type == KEYDOWN and event.key == K_g: g = self.space.gravity g.rotate(45) self.space.gravity = g mpos = pygame.mouse.get_pos() if pygame.key.get_mods() & KMOD_SHIFT and pygame.mouse.get_pressed( )[2]: p = self.flipyv(Vec2d(mpos)) self.poly_points.append(p) self.shape_to_remove = self.space.point_query_first( self.flipyv(Vec2d(mpos))) ### Update physics if self.run_physics: x = 1 dt = 1.0 / 60.0 / x for x in range(x): self.space.step(dt) for ball in self.balls: #ball.body.reset_forces() pass for poly in self.polys: #poly.body.reset_forces() pass ### Draw stuff self.draw() ### Check for objects outside of the screen, we can remove those # Balls xs = [] for ball in self.balls: if ball.body.position.x < -1000 or ball.body.position.x > 1000 \ or ball.body.position.y < -1000 or ball.body.position.y > 1000: xs.append(ball) for ball in xs: self.space.remove(ball, ball.body) self.balls.remove(ball) # Polys xs = [] for poly in self.polys: if poly.body.position.x < -1000 or poly.body.position.x > 1000 \ or poly.body.position.y < -1000 or poly.body.position.y > 1000: xs.append(poly) for poly in xs: self.space.remove(poly, poly.body) self.polys.remove(poly) ### Tick clock and update fps in title self.clock.tick(50) pygame.display.set_caption("fps: " + str(self.clock.get_fps()))
def curriculum_trajectory_factory( min_speed=4, max_speed=50, min_turn_rate_multiplier=0, max_turn_rate_multiplier=2, total_length=10000, random_seed=3, ) -> Callable[['TrajectoryTrackingProcess'], Tuple[List[Tuple[Vec2d, float]], bool]]: r = random.Random(random_seed) # speed = (max_speed + min_speed) / 2 # start with a straight line # waypoints = [(Vec2d(0, 0), speed), (Vec2d(.001, 0), speed)] waypoints = [(Vec2d(0, 0), min_speed)] length = 0.0 angle = 0.0 def add_segment(segment_length, segment_angle): nonlocal angle, length, speed angle += segment_angle length += segment_length delta = Vec2d(segment_length, 0.0) delta.rotate(angle) waypoints.append((waypoints[-1][0] + delta, speed)) # segment_length = .5 # turn_rate = 0.001 while length < total_length: d = length / total_length # max_delta_speed = d * 2 * segment_length # speed = min(max_speed, max(min_speed, speed + r.gauss(0, d * 5))) speed = r.uniform(min_speed, min_speed + (d * (max_speed - min_speed))) suggested_turning_radius = ((speed * 3.6) ** 2) / (127 * (0.0 + .12)) turn_rate = (d * 5) / suggested_turning_radius # turn_arc = r.uniform(.1, .75 * 2 * pi) turn_length = r.uniform(20, 100) turn_direction = 1 if bool(r.getrandbits(1)) else -1 # turn_rate *= turn_direction # remaining_arc = turn_arc # while remaining_arc > 1e-3: while turn_length > 0: # line_angle = min(remaining_arc, .5 * pi / 180.0) # remaining_arc -= line_angle # max_line_angle = .5 * pi / 180 line_angle = min(2 * pi / 180, turn_rate * turn_length) # line_length = min(turn_length, line_angle / (turn_rate + 1e-6)) line_length = turn_length if turn_rate < 1e-3 else line_angle / turn_rate line_angle *= turn_direction add_segment(line_length, line_angle) turn_length -= line_length def curriculum_angled_trajectory_generator(process: 'TrajectoryTrackingProcess') -> Tuple[List[Tuple[Vec2d, float]], bool]: return deepcopy(waypoints), False return curriculum_angled_trajectory_generator
import arcade import logic import importlib.util import numpy as np import random from pymunk import Vec2d VALUE_TO_ACTION = { Vec2d(0, 1).int_tuple: (1, 1), Vec2d(0, -1).int_tuple: (1, 2), Vec2d(-1, 0).int_tuple: (0, 1), Vec2d(1, 0).int_tuple: (0, 2), "shoot": (2, 1), "dash": (3, 1), } class MultiDiscrete(): def __init__(self, nvec): self.rng = np.random.default_rng() self.nvec = nvec def sample(self): self.rng.random() actions = list() for i, value in enumerate(self.nvec): actions.append((i, random.randint(0, value - 1))) return actions
listA.append([i, i]) listB = [[i, i] for i in range(6)] # triks listC = [[i, i] for i in range(6) if i > 3] # triks2 print(listA) print(listB) print(listC) vec1 = (listA[0][0], listA[0][1]) vec2 = (listA[1][0], listA[1][1]) print(vec1) print(vec2) vec = [Vec2d(x, y) for x, y in listB] print(vec[1]) print(vec) print(len(vec)) vec1 = Vec2d(1, 1) print(vec1 / 2) import datetime from time import sleep t_a = datetime.datetime.now() sleep(3) t_b = datetime.datetime.now() delta_t = t_b - t_a print(delta_t)
def __init__(self, screen): super().__init__(screen) self.offset = Vec2d(0, 0)
body.position = p shape = pymunk.Circle(body, 10) shape.elasticity = 1.5 space.add(shape) while running: for event in pygame.event.get(): if event.type == QUIT: running = False elif event.type == KEYDOWN and event.key == K_ESCAPE: running = False elif event.type == KEYDOWN and event.key == K_p: pygame.image.save(screen, "flipper.png") elif event.type == KEYDOWN and event.key == K_j: r_flipper_body.apply_impulse_at_local_point(Vec2d.unit() * 40000, (-100,0)) elif event.type == KEYDOWN and event.key == K_f: l_flipper_body.apply_impulse_at_local_point(Vec2d.unit() * -40000, (-100,0)) elif event.type == KEYDOWN and event.key == K_b: mass = 1 radius = 25 inertia = pymunk.moment_for_circle(mass, 0, radius, (0,0)) body = pymunk.Body(mass, inertia) x = random.randint(115,350) body.position = x, 400 shape = pymunk.Circle(body, radius, (0,0)) shape.elasticity = 0.95 space.add(body, shape) balls.append(shape)
def main(): pygame.init() screen = pygame.display.set_mode((600, 600)) clock = pygame.time.Clock() running = True ### Physics stuff space = pm.Space() space.gravity = Vec2d(0.0, -900.0) ## Balls balls = [] ### Mouse mouse_body = pm.Body() mouse_shape = pm.Circle(mouse_body, 3, Vec2d(0, 0)) mouse_shape.collision_type = COLLTYPE_MOUSE space.add(mouse_shape) space.add_collision_handler(COLLTYPE_MOUSE, COLLTYPE_BALL, None, mouse_coll_func, None, None) ### Static line line_point1 = None static_lines = [] run_physics = True while running: for event in pygame.event.get(): if event.type == QUIT: running = False elif event.type == KEYDOWN and event.key == K_ESCAPE: running = False elif event.type == KEYDOWN and event.key == K_p: pygame.image.save(screen, "balls_and_lines.png") elif event.type == MOUSEBUTTONDOWN and event.button == 1: p = event.pos[X], flipy(event.pos[Y]) body = pm.Body(10, 100) body.position = p shape = pm.Circle(body, 10, (0, 0)) shape.friction = 0.5 shape.collision_type = COLLTYPE_BALL space.add(body, shape) balls.append(shape) elif event.type == MOUSEBUTTONDOWN and event.button == 3: if line_point1 is None: line_point1 = Vec2d(event.pos[X], flipy(event.pos[Y])) elif event.type == MOUSEBUTTONUP and event.button == 3: if line_point1 is not None: line_point2 = Vec2d(event.pos[X], flipy(event.pos[Y])) print(line_point1, line_point2) body = pm.Body() shape = pm.Segment(body, line_point1, line_point2, 0.0) shape.friction = 0.99 space.add(shape) static_lines.append(shape) line_point1 = None elif event.type == KEYDOWN and event.key == K_SPACE: run_physics = not run_physics p = pygame.mouse.get_pos() mouse_pos = Vec2d(p[X], flipy(p[Y])) mouse_body.position = mouse_pos if pygame.key.get_mods() & KMOD_SHIFT and pygame.mouse.get_pressed( )[0]: body = pm.Body(10, 10) body.position = mouse_pos shape = pm.Circle(body, 10, (0, 0)) shape.collision_type = COLLTYPE_BALL space.add(body, shape) balls.append(shape) ### Update physics if run_physics: dt = 1.0 / 60.0 for x in range(1): space.step(dt) ### Draw stuff screen.fill(THECOLORS["white"]) # Display some text font = pygame.font.Font(None, 16) text = """LMB: Create ball LMB + Shift: Create many balls RMB: Drag to create wall, release to finish Space: Pause physics simulation""" y = 5 for line in text.splitlines(): text = font.render(line, 1, THECOLORS["black"]) screen.blit(text, (5, y)) y += 10 for ball in balls: r = ball.radius v = ball.body.position rot = ball.body.rotation_vector p = int(v.x), int(flipy(v.y)) p2 = Vec2d(rot.x, -rot.y) * r * 0.9 pygame.draw.circle(screen, THECOLORS["blue"], p, int(r), 2) pygame.draw.line(screen, THECOLORS["red"], p, p + p2) if line_point1 is not None: p1 = line_point1.x, flipy(line_point1.y) p2 = mouse_pos.x, flipy(mouse_pos.y) pygame.draw.lines(screen, THECOLORS["black"], False, [p1, p2]) for line in static_lines: body = line.body pv1 = body.position + line.a.rotated(body.angle) pv2 = body.position + line.b.rotated(body.angle) p1 = pv1.x, flipy(pv1.y) p2 = pv2.x, flipy(pv2.y) pygame.draw.lines(screen, THECOLORS["lightgray"], False, [p1, p2]) ### Flip screen pygame.display.flip() clock.tick(50) pygame.display.set_caption("fps: " + str(clock.get_fps()))
def __init__(self, name, img, up=None, left=None, right=None, down=None, shoot=None): self.name = name # sprites img = pygame.image.load(img) flip_img = pygame.transform.flip(img, True, False) images = (img, flip_img) # animations self.idle_loop = Animation(images, 1, 8, loop=True) self.walk_loop = Animation(images, 3, 8, loop=True) self.jump_loop = Animation(images, 5, 2, start_frame=4, loop=True) self.spin_loop = Animation( images, 7, 4, loop=True, frame_rate=0.4) self.death_sequence = Animation(images, 8, 7) # sounds self.fall_sound = pygame.mixer.Sound("res/sfx/fall.wav") self.fall_sound.set_volume(0.5) self.jump_sound = pygame.mixer.Sound("res/sfx/jump.wav") self.jump_sound.set_volume(0.5) # keybindings self.jump_key = up self.left_key = left self.right_key = right self.down_key = down self.shoot_key = shoot # physics self.body = pymunk.Body(5, pymunk.inf) # mass, moment self.body.position = 100, 100 self.body.player = weakref.proxy(self) # TODO: heads should be a separate collision type self.head = pymunk.Circle(self.body, 14, (12, 7)) self.head.collision_type = PLAYER_COLLISION_TYPE self.head.friction = 0 self.feet = pymunk.Circle(self.body, 14, (12, -16)) self.feet.collision_type = 1 # TODO: Make this zero whilst falling self.feet.friction = 2 SPACE.add(self.body, self.head, self.feet) # Character stats self.max_jumps = 2 self.remaining_jumps = self.max_jumps self.speed = 200 # 100 self.jump_speed = 400 self.max_health = 10 self.health = self.max_health self.shot_cooldown = 0 # State tracking self.landed = False self.landed_hard = False self.ground_velocity = Vec2d.zero() self.ground_slope = 0 self.current_facing = self.right_key self.bullets = []
def main(): pygame.init() screen = pygame.display.set_mode((600, 600)) clock = pygame.time.Clock() running = True ### Physics stuff space = pymunk.Space() space.gravity = Vec2d(0.0, -900.0) ## logo logo_img = pygame.image.load("pymunk_logo_googlecode.png") logos: List[pymunk.Shape] = [] ### Static line static_lines = [ pymunk.Segment(space.static_body, (11.0, 280.0), (407.0, 246.0), 0.0), pymunk.Segment(space.static_body, (407.0, 246.0), (407.0, 343.0), 0.0), ] for l in static_lines: l.friction = 0.5 space.add(*static_lines) ticks_to_next_spawn = 10 while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE: running = False elif event.type == pygame.KEYDOWN and event.key == pygame.K_p: pygame.image.save(screen, "using_sprites.png") ticks_to_next_spawn -= 1 if ticks_to_next_spawn <= 0: ticks_to_next_spawn = 100 x = random.randint(20, 400) y = 500 angle = random.random() * math.pi vs = [(-23, 26), (23, 26), (0, -26)] mass = 10 moment = pymunk.moment_for_poly(mass, vs) body = pymunk.Body(mass, moment) shape = pymunk.Poly(body, vs) shape.friction = 0.5 body.position = x, y body.angle = angle space.add(body, shape) logos.append(shape) ### Update physics dt = 1.0 / 60.0 for x in range(1): space.step(dt) ### Draw stuff screen.fill(pygame.Color("black")) for logo_shape in logos: # image draw p = logo_shape.body.position p = Vec2d(p.x, flipy(p.y)) # we need to rotate 180 degrees because of the y coordinate flip angle_degrees = math.degrees(logo_shape.body.angle) + 180 rotated_logo_img = pygame.transform.rotate(logo_img, angle_degrees) offset = Vec2d(*rotated_logo_img.get_size()) / 2 p = p - offset screen.blit(rotated_logo_img, (round(p.x), round(p.y))) # debug draw ps = [ p.rotated(logo_shape.body.angle) + logo_shape.body.position for p in logo_shape.get_vertices() ] ps = [(round(p.x), round(flipy(p.y))) for p in ps] ps += [ps[0]] pygame.draw.lines(screen, pygame.Color("red"), False, ps, 1) for line in static_lines: body = line.body pv1 = body.position + line.a.rotated(body.angle) pv2 = body.position + line.b.rotated(body.angle) p1 = round(pv1.x), round(flipy(pv1.y)) p2 = round(pv2.x), round(flipy(pv2.y)) pygame.draw.lines(screen, pygame.Color("lightgray"), False, [p1, p2], 2) ### Flip screen pygame.display.flip() clock.tick(50) pygame.display.set_caption("fps: " + str(clock.get_fps()))
def main(): # Primatians - woo print "Running Python version:", sys.version print "Running PyGame version:", pygame.ver print "Running PyMunk version:", pymunk.version print "Running Primatians version:", __version__ pygame.init() screen = pygame.display.set_mode((800, 500), pygame.RESIZABLE) pygame.display.set_caption("Primatians - A Nanho Games Production") bg, bg_rect = background_image('rainforest.png') screen.blit(bg, (0, 0)) clock = pygame.time.Clock() running = True # Physics stuff space = pymunk.Space(50) space.gravity = (90, -90.0) # Balls bananas = [] for n in range(1): b = create_bananas(space) bananas.append(b) # Primates primates = [] p = create_primate(space) primates.append(p) static_lines = draw_border_walls(space) static_logs = draw_logs(space) r_flipper_body, r_flipper_shape, l_flipper_body, l_flipper_shape = draw_flippers(space) # sprites banana_sprite = GameSprite('banana-small.png') primate1_sprite = GameSprite('primate3.png') log_sprite = GameSprite("log2.png") # Game Ahoy! while running: for event in pygame.event.get(): if event.type == QUIT: running = False elif event.type == KEYDOWN and event.key == K_ESCAPE: running = False elif event.type == KEYDOWN and event.key == K_z: l_flipper_body.apply_impulse(Vec2d.unit() * -40000, (-100, 0)) elif event.type == KEYDOWN and event.key == K_x: r_flipper_body.apply_impulse(Vec2d.unit() * 40000, (-100, 0)) screen.blit(bg, (0, 0)) # Draw lines for line in static_lines: body = line.body pv1 = body.position + line.a.rotated(body.angle) pv2 = body.position + line.b.rotated(body.angle) p1 = to_pygame(pv1) p2 = to_pygame(pv2) pygame.draw.lines(screen, THECOLORS["black"], False, [p1, p2]) # Draw logs #p = to_pygame(static_logs.body.position) #screen.blit(log_sprite.image, p) for log in static_logs: body = log.body pv1 = body.position + log.a.rotated(body.angle) pv2 = body.position + log.b.rotated(body.angle) p1 = to_pygame(pv1) p2 = to_pygame(pv2) screen.blit(log_sprite.image, p2) #screen.blit(log_sprite.image, p2) #pygame.draw.lines(screen, THECOLORS["red"], False, [p1,p2]) for banana in bananas: p = to_pygame(banana.body.position) angle_degrees = math.degrees(banana.body.angle) + 180 rotated_img = pygame.transform.rotate(banana_sprite.image, angle_degrees) #offset = Vec2d(rotated_img.get_size()) / 2. #x, y = banana.get_points()[0] #p = Vec2d(x,y) #p = p - offset screen.blit(rotated_img, p) # Assigning to rect.center moves the Rect object. # Useful for collision detection banana_sprite.rect.center = p #color = THECOLORS["red"] #ps = banana.get_points() #ps = map(to_pygame, ps) #pygame.draw.polygon(screen, color, ps, 0) for primate in primates: p = to_pygame(primate.body.position) screen.blit(primate1_sprite.image, p) primate1_sprite.rect.center = p r_flipper_body.position = 790, 10 l_flipper_body.position = 10, 10 r_flipper_body.velocity = l_flipper_body.velocity = 0,0 for f in [r_flipper_shape, l_flipper_shape]: ps = f.get_points() ps.append(ps[0]) ps = map(to_pygame, ps) color = THECOLORS["burlywood4"] pygame.draw.polygon(screen, color, ps, 0) if pygame.sprite.collide_rect(primate1_sprite, banana_sprite): print primate1_sprite.rect print banana_sprite.rect print 'Sprites Collide' # Update physics dt = 1.0/60.0/5 for x in range(5): space.step(dt) pygame.display.flip() clock.tick(50)
def extent(self): return Vec2d(max(self.width_top, self.width_bottom), self.height) / 2