Exemplo n.º 1
0
 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]
Exemplo n.º 2
0
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)
Exemplo n.º 3
0
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
Exemplo n.º 4
0
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)
Exemplo n.º 5
0
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
Exemplo n.º 6
0
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))
Exemplo n.º 7
0
    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)
Exemplo n.º 8
0
 def bottom_right_extent(self):
     return Vec2d(self.width_bottom, -self.height) / 2
Exemplo n.º 9
0
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)
Exemplo n.º 10
0
 def top_left_extent(self):
     return Vec2d(-self.extent.x, self.extent.y)
Exemplo n.º 11
0
 def bottom_right_extent(self):
     return Vec2d(self.extent.x, -self.extent.y)
Exemplo n.º 12
0
 def __init__(self, position, extent, angle=0., **parameters):
     super().__init__(position=position, angle=angle, **parameters)
     self.extent = Vec2d(extent)
Exemplo n.º 13
0
 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
Exemplo n.º 14
0
 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
Exemplo n.º 15
0
 def top_right_extent(self):
     return Vec2d(self.width_top, self.height) / 2
Exemplo n.º 16
0
    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)
    
Exemplo n.º 17
0
    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())) 
Exemplo n.º 19
0
def flipy(p):
    """Convert chipmunk coordinates to pygame coordinates."""
    return Vec2d(p[0], -p[1] + 600)
Exemplo n.º 20
0
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)
Exemplo n.º 21
0
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)
Exemplo n.º 22
0
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)
Exemplo n.º 23
0
    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)
Exemplo n.º 24
0
 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)
Exemplo n.º 25
0
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()))
Exemplo n.º 26
0
    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()
Exemplo n.º 27
0
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()))
Exemplo n.º 28
0
    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
Exemplo n.º 29
0
    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()))
Exemplo n.º 30
0
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
Exemplo n.º 31
0
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

Exemplo n.º 32
0
    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)
Exemplo n.º 33
0
 def __init__(self, screen):
     super().__init__(screen)
     self.offset = Vec2d(0, 0)
Exemplo n.º 34
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)
    
Exemplo n.º 35
0
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()))
Exemplo n.º 36
0
    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 = []
Exemplo n.º 37
0
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()))
Exemplo n.º 38
0
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)
Exemplo n.º 39
0
 def extent(self):
     return Vec2d(max(self.width_top, self.width_bottom), self.height) / 2