def change_state(ball_var, tray, strength, dist, a_bin, sp): action = ball_var.current_action if action == 0: while tray.angle > get_centre_of_ang_bin((a_bin - 1)): tray.apply_force_at_local_point( Vec2d.unit() * strength, (-dist, 0)) # rotate flipper clockwise dt = 1.0 / 60.0 / 5. for x in range(5): sp.step(dt) ball_var.current_position = get_ball_pos_x(ball_var) ball_var.current_velocity = ball_var.body.velocity[0] ball_var.current_angle = tray.angle #p_new, v_new, a_new = get_state(ball_var.current_position, ball_var.current_velocity, ball_var.current_angle) elif action == 1: while tray.angle < get_centre_of_ang_bin((a_bin + 1)): tray.apply_force_at_local_point( Vec2d.unit() * strength, (dist, 0)) # rotate flipper anticlockwise dt = 1.0 / 60.0 / 5. for x in range(5): sp.step(dt) ball_var.current_position = get_ball_pos_x(ball_var) ball_var.current_velocity = ball_var.body.velocity[0] ball_var.current_angle = tray.angle ppp, vvv, aaa = get_state(ball_var.current_position, ball_var.current_velocity, ball_var.current_angle) tray.angular_velocity = 0 return ppp, vvv, aaa
def do_action(self, num_of_angs_to_move, direction, slow=False, record=True, draw=False, speed=60): turn = True if not abs(direction) == 1: direction = 0 turn = False print("DIRECTION VALUE IS WRONG IN do_action") target_bin = self.a + direction*num_of_angs_to_move # The bin of the angle we are aiming for target_angle = self.MIN_ANGLE + target_bin * (self.MAX_ANGLE - self.MIN_ANGLE)/self.NUM_ANGLE_BINS # The actual angle we are aiming for NUM_ANGLE_BINS should be changes, probably to a parameter if target_bin >= self.NUM_ANGLE_BINS: target_bin = self.NUM_ANGLE_BINS - 1 elif target_bin < 0: target_bin = 0 if target_angle > self.MAX_ANGLE: target_angle = self.MAX_ANGLE elif target_angle < self.MIN_ANGLE: target_angle = self.MIN_ANGLE while turn and self.is_ball_on_tray(self.length_on_tray): #print(self.trayBody.angle, target_angle, self.MIN_ANGLE, target_bin) if direction == -1: if self.trayBody.angle > target_angle and self.trayBody.angle > self.MIN_ANGLE: # Keep rotating util we are past the angle we are aiming for self.trayBody.apply_force_at_local_point(Vec2d.unit() * self.rotation, (-self.tray_width/2, 0)) # rotate flipper clockwise else: turn = False self.ball.body.velocity[1] = 0 #self.trayBody.angular_velocity = 0 elif direction == 1: #print(self.NUM_ANGLE_BINS, self.trayBody.angle, target_angle, self.MIN_ANGLE, target_bin) if self.trayBody.angle < target_angle and self.trayBody.angle < self.MAX_ANGLE: self.trayBody.apply_force_at_local_point(Vec2d.unit() * self.rotation, (self.tray_width/2, 0)) # rotate flipper anticlockwise else: turn = False self.ball.body.velocity[1] = 0 #self.trayBody.angular_velocity = 0 #dt = 1.0/60.0/5. #for x in range(5): # self.space.step(dt) self.step_simulation(slow, record, draw, speed) # if self.draw: # self.screen.fill(THECOLORS["white"]) # self.space.debug_draw(self.draw_options) # self.clock.tick(50) # pygame.display.flip() # c_speed = trainer.speed_of_ball_at_centre() # if c_speed is not None: # print(c_speed) self.a = target_bin self.trayBody.angular_velocity = 0 #self.ball.body.velocity[1] = 0 #self.ball_body.velocity[1] = 0.0 #print(self.ball_body.velocity) self.prev_ball_pos = self.get_pos_ball_along_tray()
def __change_state(self, dist, a_bin): action = self.ball.current_action #count = 0 turn = True while turn: if action == 0: if self.trayBody.angle > self.__get_centre_of_ang_bin( (a_bin - 1) % self.NUM_ANGLES ) and self.trayBody.angle > self.MIN_ANGLE: #print(self.trayBody.angle) self.trayBody.apply_force_at_local_point( Vec2d.unit() * self.rotation, (-dist, 0)) # rotate flipper clockwise else: turn = False elif action == 1: if self.trayBody.angle < self.__get_centre_of_ang_bin( (a_bin + 1) % self.NUM_ANGLES ) and self.trayBody.angle < self.MAX_ANGLE: self.trayBody.apply_force_at_local_point( Vec2d.unit() * self.rotation, (dist, 0)) # rotate flipper anticlockwise else: turn = False dt = 1.0 / 60.0 / 5. for x in range(5): self.space.step(dt) #print(self.trayBody.angle, action) #print(action, "ANG:", self.trayBody.angle > self.__get_centre_of_ang_bin((a_bin-1)%self.NUM_ANGLES), self.trayBody.angle, self.__get_centre_of_ang_bin((a_bin-1)%self.NUM_ANGLES)) #self.ball.current_position = self.__get_ball_pos_x(self.ball) #self.ball.current_velocity = self.ball.body.velocity[0] #self.ball.current_angle = self.trayBody.angle #p_new, v_new, a_new = get_state(self.ball.current_position, self.ball.current_velocity, self.ball.current_angle) #count+=1 #elif action == 1: # while self.trayBody.angle < self.__get_centre_of_ang_bin((a_bin+1)%self.NUM_ANGLES) and self.trayBody.angle < self.MAX_ANGLE: # self.trayBody.apply_force_at_local_point(Vec2d.unit() * self.rotation, (dist, 0)) # rotate flipper anticlockwise #print(self.trayBody.angle) # dt = 1.0/60.0/5. # for x in range(5): # self.space.step(dt) # count+=1 #print(action, "ANG:", self.trayBody.angle < self.__get_centre_of_ang_bin((a_bin+1)%self.NUM_ANGLES), self.trayBody.angle, self.__get_centre_of_ang_bin((a_bin+1)%self.NUM_ANGLES)) #print(count) self.ball.current_position = self.__get_ball_pos_x(self.ball) self.ball.current_velocity = self.ball.body.velocity[0] self.ball.current_angle = self.trayBody.angle ppp, vvv, aaa = self.__get_state(self.ball.current_position, self.ball.current_velocity, self.ball.current_angle) self.trayBody.angular_velocity = 0 return ppp, vvv, aaa
def __change_state(self, a_bin, action): """ Go to the next angle from the current angle, based on the action specified """ extra = self.step_size # Carry out any extra turns for i in range(0, extra): self.__step_simulation(self.sim_speed) self.trayBody.angular_velocity = 0 # Dont want tray to move under balls weight when not moving turn = True turn_counter = 0 while turn: if action == 0 and a_bin > 0: if self.trayBody.angle > self.__get_centre_of_ang_bin( (a_bin - 1)) and self.trayBody.angle > self.min_ang: self.trayBody.apply_force_at_local_point( Vec2d.unit() * self.rotation, (-self.force_distance, 0)) # rotate flipper clockwise else: turn = False elif action == 1 and a_bin < self.num_bins_ang - 1: if self.trayBody.angle < self.__get_centre_of_ang_bin( (a_bin + 1)) and self.trayBody.angle < self.max_ang: self.trayBody.apply_force_at_local_point( Vec2d.unit() * self.rotation, (self.force_distance, 0)) # rotate flipper anticlockwise else: turn = False #elif action == 2: else: turn = False # Do nothing # for i in range(0, 5): # self.__step_simulation() # else: # p, v, _ = self.get_state(self.prev_val_p, self.prev_val_v, self.prev_val_a) # p2, v2, _ = self.get_state(self.curr_val_p, self.curr_val_v, self.curr_val_a) # if p != p2 or v != v2: # turn = False # if action == 2 and self.prnt: # print("OK", p, p2, v, v2) turn_counter += 1 self.__step_simulation(self.sim_speed) self.trayBody.angular_velocity = 0 # To stop turning once turn has occured ppp, vvv, aaa = self.get_state(self.curr_val_p, self.curr_val_v, self.curr_val_a) return ppp, vvv, aaa
def get_start_points(self): if self._start_point is None: self._start_point = Vec2d(30, 30) left_end = Vec2d.unit() left_end.angle = self._start_angle - constants.PI_05 left_end.length = self._start_width / 2 right_end = Vec2d.unit() right_end.angle = self._start_angle + constants.PI_05 right_end.length = self._start_width / 2 return self.zero_border_vector(self._start_point + left_end), \ self.zero_border_vector(self._start_point + right_end)
def do_action(self, num_of_angs_to_move, direction, slow=False, record=True, draw=False, speed=60): turn = True if not abs(direction) <= 1: print("DIRECTION VALUE IS WRONG IN do_action", direction) direction = 0 turn = False target_bin = self.a + direction * num_of_angs_to_move # The bin of the angle we are aiming for target_angle = self.MIN_ANGLE + target_bin * ( self.MAX_ANGLE - self.MIN_ANGLE ) / self.num_bins_ang # The actual angle we are aiming for num_bins_ang should be changes, probably to a parameter if target_bin > self.num_bins_ang: target_bin = self.num_bins_ang elif target_bin < 0: target_bin = 0 if target_angle > self.MAX_ANGLE: target_angle = self.MAX_ANGLE elif target_angle < self.MIN_ANGLE: target_angle = self.MIN_ANGLE while turn and self.is_ball_on_tray(False, self.length_on_tray): if direction == -1: if self.trayBody.angle > target_angle and self.trayBody.angle > self.MIN_ANGLE: # Keep rotating util we are past the angle we are aiming for self.trayBody.apply_force_at_local_point( Vec2d.unit() * self.rotation, (-self.tray_width / 2, 0)) # rotate flipper clockwise else: turn = False self.ball.body.velocity[1] = 0 elif direction == 1: if self.trayBody.angle < target_angle and self.trayBody.angle < self.MAX_ANGLE: self.trayBody.apply_force_at_local_point( Vec2d.unit() * self.rotation, (self.tray_width / 2, 0)) # rotate flipper anticlockwise else: turn = False self.ball.body.velocity[1] = 0 self.step_simulation(slow, record, draw, speed) self.a = target_bin self.trayBody.angular_velocity = 0 self.prev_ball_pos = self.get_pos_ball_along_tray()
def update(self, dt): # atualiza o angulo da sprit self.rotation = -30 * self.orientation - (numpy.rad2deg(self.body.angle) * 0.9) # aplica o impulso no bastão if self.status == "PRESS": self.body.apply_impulse_at_local_point(Vec2d.unit() * -4000, (self.width * self.orientation, 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)
def get_next_endings(self, left_start, right_start, last_angle): center = Vec2d((left_start.x + right_start.x) / 2, (left_start.y + right_start.y) / 2) length = random.uniform(self._min_length, self._max_length) angle = random.uniform(self._min_angle, self._max_angle) angle = random.choice([last_angle + angle, last_angle - angle]) width = random.uniform(self._min_width, self._max_width) target_center = Vec2d.unit() target_center.angle = angle target_center.length = length target_center = target_center + center left_end = Vec2d.unit() left_end.angle = angle - constants.PI_05 left_end.length = width / 2 right_end = Vec2d.unit() right_end.angle = angle + constants.PI_05 right_end.length = width / 2 left_end = target_center + left_end right_end = target_center + right_end return left_end, right_end, angle, target_center
def main(): # Primatians - woo print "Running Python version:", sys.version print "Running PyGame version:", pygame.ver print "Running PyMunk version:", pymunk.version print "Running Primatians version:", __version__ pygame.init() screen = pygame.display.set_mode((800, 500), pygame.RESIZABLE) pygame.display.set_caption("Primatians - A Nanho Games Production") # make our background object colorBackground = Color("darkolivegreen4") backgroundLayer = DrawSurf(screen, colorBackground) clock = pygame.time.Clock() running = True # Physics stuff space = pymunk.Space(50) space.gravity = (90, -90.0) # Balls balls = [] mass = 1 radius = 25 inertia = pymunk.moment_for_circle(mass, 0, radius, (0,0)) body = pymunk.Body(mass, inertia) x = random.randint(0,500) body.position = 400, 400 shape = pymunk.Circle(body, radius, (0,0)) shape.elasticity = 0.95 space.add(body, shape) balls.append(shape) # Walls first static_body = pymunk.Body() # x1,y1, x2,y2 static_lines = [pymunk.Segment(static_body, (0.0, 0.0), (0.0, 500.0), 5.0), pymunk.Segment(static_body, (0.0, 500.0), (800.0, 500.0), 5.0), pymunk.Segment(static_body, (800.0, 500.0), (800.0, 0.0), 5.0), pymunk.Segment(static_body, (800.0, 0.0), (0.0, 0.0), 5.0) ] for line in static_lines: line.elasticity = 0.7 line.group = 1 space.add(static_lines) # Some Logs static_logs = [pymunk.Segment(static_body, (200, 250), (600, 250), 5)] for logs in static_logs: logs.elasticity = 1 logs.group = 1 space.add(static_logs) # Add Flippers ( handler tree logs) fp = [(20,-20), (-120, 0), (20,20)] mass = 100 moment = pymunk.moment_for_poly(mass, fp) # right flipper r_flipper_body = pymunk.Body(mass, moment) r_flipper_body.position = 750, 10 r_flipper_shape = pymunk.Poly(r_flipper_body, fp) space.add(r_flipper_body, r_flipper_shape) r_flipper_joint_body = pymunk.Body() r_flipper_joint_body.position = r_flipper_body.position j = pymunk.PinJoint(r_flipper_body, r_flipper_joint_body, (0,0), (0,0)) #todo: tweak values of spring better s = pymunk.DampedRotarySpring(r_flipper_body, r_flipper_joint_body, 0.15, 20000000,900000) space.add(j, s) # left flipper l_flipper_body = pymunk.Body(mass, moment) l_flipper_body.position = 10, 10 l_flipper_shape = pymunk.Poly(l_flipper_body, [(-x,y) for x,y in fp]) space.add(l_flipper_body, l_flipper_shape) l_flipper_joint_body = pymunk.Body() l_flipper_joint_body.position = l_flipper_body.position j = pymunk.PinJoint(l_flipper_body, l_flipper_joint_body, (0,0), (0,0)) s = pymunk.DampedRotarySpring(l_flipper_body, l_flipper_joint_body, -0.15, 20000000,900000) space.add(j, s) # new flippers fp = [(20,-20), (-120, 0), (20,20)] #fp = [(120, 0), (120,-20),(-120,0)] mass = 100 moment = pymunk.moment_for_poly(mass, fp) # top-right flipper tr_flipper_body = pymunk.Body(mass, moment) tr_flipper_body.position = 750, 450 tr_flipper_shape = pymunk.Poly(tr_flipper_body, fp) space.add(tr_flipper_body, tr_flipper_shape) tr_flipper_joint_body = pymunk.Body() tr_flipper_joint_body.position = tr_flipper_body.position j = pymunk.PinJoint(tr_flipper_body, tr_flipper_joint_body, (0,0), (0,0)) #todo: tweak values of spring better s = pymunk.DampedRotarySpring(tr_flipper_body, tr_flipper_joint_body, 0.15, 20000000,900000) space.add(j, s) # top-left flipper tl_flipper_body = pymunk.Body(mass, moment) tl_flipper_body.position = 50, 850 tl_flipper_shape = pymunk.Poly(tl_flipper_body, [(-x,y) for x,y in fp]) space.add(tl_flipper_body, tl_flipper_shape) tl_flipper_joint_body = pymunk.Body() tl_flipper_joint_body.position = tl_flipper_body.position j = pymunk.PinJoint(tl_flipper_body, tl_flipper_joint_body, (0,0), (0,0)) s = pymunk.DampedRotarySpring(tl_flipper_body, tl_flipper_joint_body, -0.15, 20000000,900000) space.add(j, s) r_flipper_shape.group = l_flipper_shape.group = tr_flipper_shape.group = tl_flipper_shape.group = 1 r_flipper_shape.elasticity = l_flipper_shape.elasticity = tr_flipper_shape.elasticity = tl_flipper_shape.elasticity = 0.4 while running: for event in pygame.event.get(): if event.type == QUIT: running = False elif event.type == KEYDOWN and event.key == K_ESCAPE: running = False elif event.type == KEYDOWN and event.key == K_j: r_flipper_body.apply_impulse(Vec2d.unit() * 40000, (-100,0)) elif event.type == KEYDOWN and event.key == K_f: l_flipper_body.apply_impulse(Vec2d.unit() * -40000, (-100,0)) elif event.type == KEYDOWN and event.key == K_g: tl_flipper_body.apply_impulse(Vec2d.unit() * 40000, (-100,0)) elif event.type == KEYDOWN and event.key == K_h: tr_flipper_body.apply_impulse(Vec2d.unit() * -40000, (-100,0)) if event.type == pygame.VIDEORESIZE: screen_size = event.size screen = pygame.display.set_mode(screen_size, pygame.RESIZABLE) oldBg = backgroundLayer.surface.copy() backgroundLayer = DrawSurf(screen, backgroundLayer.color) backgroundLayer.surface.blit(oldBg, (0, 0)) # Draw # backgroundLayer.draw() screen.fill(THECOLORS["darkolivegreen"]) # Draw lines for line in static_lines: body = line.body pv1 = body.position + line.a.rotated(body.angle) pv2 = body.position + line.b.rotated(body.angle) p1 = to_pygame(pv1) p2 = to_pygame(pv2) pygame.draw.lines(screen, THECOLORS["black"], False, [p1,p2]) # Draw logs for log in static_logs: body = log.body pv1 = body.position + log.a.rotated(body.angle) pv2 = body.position + log.b.rotated(body.angle) p1 = to_pygame(pv1) p2 = to_pygame(pv2) pygame.draw.lines(screen, THECOLORS["brown"], False, [p1,p2]) for ball in balls: p = to_pygame(ball.body.position) pygame.draw.circle(screen, THECOLORS["yellow"], p, int(ball.radius), 2) r_flipper_body.position = 790, 10 l_flipper_body.position = 10, 10 tr_flipper_body.position = 790, 490 tl_flipper_body.position = 10, 490 r_flipper_body.velocity = l_flipper_body.velocity = tr_flipper_body.velocity = tl_flipper_body.velocity = 0,0 for f in [r_flipper_shape, l_flipper_shape, tr_flipper_shape, tl_flipper_shape,]: ps = f.get_points() ps.append(ps[0]) ps = map(to_pygame, ps) color = THECOLORS["red"] pygame.draw.lines(screen, color, False, ps) # Update physics dt = 1.0/60.0/5 for x in range(5): space.step(dt) pygame.display.flip() clock.tick(50)
def 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()))
shape = pymunk.Circle(body, 10) shape.elasticity = 1.5 space.add(body, shape) 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, "flipper.png") elif event.type == pygame.KEYDOWN and event.key == pygame.K_j: r_flipper_body.apply_impulse_at_local_point( Vec2d.unit() * -40000, (-100, 0)) elif event.type == pygame.KEYDOWN and event.key == pygame.K_f: l_flipper_body.apply_impulse_at_local_point( Vec2d.unit() * 40000, (-100, 0)) elif event.type == pygame.KEYDOWN and event.key == pygame.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, 200 shape = pymunk.Circle(body, radius, (0, 0)) shape.elasticity = 0.95 space.add(body, shape) balls.append(shape)
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)
space.add(frm1_j, frm1_s) poussoir1(mass, coordfrm1y)""" 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() * 30000, (-100, 0)) elif event.type == KEYDOWN and event.key == K_f: l_flipper_body.apply_impulse_at_local_point( Vec2d.unit() * -30000, (-100, 0)) elif event.type == KEYDOWN and event.key == K_b: mass = 1 radius = 4 inertia = pymunk.moment_for_circle(mass, 0, radius, (0, 0)) body = pymunk.Body(mass, inertia) body.position = 590, 125 #body.position = 460, 260 shape = pymunk.Circle(body, radius, (0, 0)) shape.elasticity = 0.95
shape = pymunk.Circle(body, 10) shape.elasticity = 1.5 space.add(shape) balls.append(shape) while running: for event in pygame.event.get(): if event.type == QUIT: running = False elif event.type == KEYDOWN and event.key == K_ESCAPE: running = False elif event.type == KEYDOWN and event.key == K_p: pygame.image.save(screen, "flipper.png") elif event.type == KEYDOWN and event.key == K_j: r_flipper_body.apply_impulse(Vec2d.unit() * 40000, (-100,0)) elif event.type == KEYDOWN and event.key == K_f: l_flipper_body.apply_impulse(Vec2d.unit() * -40000, (-100,0)) elif event.type == KEYDOWN and event.key == K_b: mass = 1 radius = 25 inertia = pymunk.moment_for_circle(mass, 0, radius, (0,0)) body = pymunk.Body(mass, inertia) x = random.randint(115,350) body.position = x, 400 shape = pymunk.Circle(body, radius, (0,0)) shape.elasticity = 0.95 space.add(body, shape) balls.append(shape)
def main(): # Primatians - woo num_bananas = 0 trained = False play_bg = True load_music('bg.mp3') 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) or (event.type == KEYDOWN and event.key == K_LEFT): l_flipper_body.apply_impulse(Vec2d.unit() * -40000, (-100, 0)) elif (event.type == KEYDOWN and event.key == K_x) or (event.type == KEYDOWN and event.key == K_RIGHT): 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 for log in static_logs: body = log.body point = body.position + log.b.rotated(body.angle) p = to_pygame(point) screen.blit(log_sprite.image, p) 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) screen.blit(rotated_img, p) # Assigning to rect.center moves the Rect object. # Useful for collision detection banana_sprite.rect.center = p 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): num_bananas += 1 txt = "Yummy Bananas %d" % num_bananas text, textpos = add_text(txt) screen.blit(text, (750, 450)) if num_bananas == 5: trained = True play_bg = False # Reset Sprites location x = random.randint(0, 500) banana.body.position = Vec2d(x, x) banana.body.reset_forces() banana.body.velocity = Vec2d(10, 10) txt = "Yummy Bananas %d" % num_bananas text, textpos = add_text(txt) screen.blit(text, (400, 50)) if trained: txt = "You've trained me. Yay!" text, textpos = add_text(txt) screen.blit(text, (400, 100)) banana.body.velocity = Vec2d(0, 0) primate.body.velocity = Vec2d(0, 0) banana.body.rotation = Vec2d(0, 0) if not play_bg: pygame.mixer.quit() load_music('final.wav') play_bg = True # Update physics dt = 1.0 / 60.0 / 5 for x in range(5): space.step(dt) pygame.display.flip() clock.tick(50)
def go(self, apertao): self.circle_body.apply_impulse_at_local_point(Vec2d.unit() * 1500 * apertao, (0, 0))
def main(): # Init vars running = True progress = True clock = pygame.time.Clock() size = width, height = 1024, 768 screen = pygame.display.set_mode(size) surface = pygame.Surface(screen.get_size()) # Physics space = pymunk.Space() space.gravity = (0.0, -900.0) draw_options = pymunk.pygame_util.DrawOptions(surface) fp = [(5, -5), (-85, 0), (5, 5)] mass = 100 moment = pymunk.moment_for_poly(mass, fp) # Balls balls = [] drawSegments(space) # Right flipper r_flipper_body = pymunk.Body(mass, moment) r_flipper_body.position = 600, 82 r_flipper_shape = pymunk.Poly(r_flipper_body, fp) space.add(r_flipper_body, r_flipper_shape) r_flipper_joint_body = pymunk.Body(body_type=pymunk.Body.KINEMATIC) r_flipper_joint_body.position = r_flipper_body.position j = pymunk.PinJoint(r_flipper_body, r_flipper_joint_body, (0, 0), (0, 0)) 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 = 380, 82 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(body_type=pymunk.Body.KINEMATIC) 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 ### Main Loop ### while running: ### Clear screen and draw stuff surface.fill((0, 0, 0)) drawStuff(surface) # Define mouse position mouseX = pygame.mouse.get_pos()[1] mouseY = pygame.mouse.get_pos()[0] # Events loop for event in pygame.event.get(): # Manage quit / closing window event if event.type == pygame.QUIT: pygame.quit() sys.exit() elif event.type == KEYDOWN: if event.key == K_ESCAPE: pygame.quit() sys.exit() elif event.key == K_j: r_flipper_body.apply_impulse_at_local_point( Vec2d.unit() * 40000, (-100, 0)) elif 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 = 8 inertia = pymunk.moment_for_circle(mass, 0, radius, (0, 0)) body = pymunk.Body(mass, inertia) x = random.randint(350, 600) body.position = x, 400 shape = pymunk.Circle(body, radius, (0, 0)) shape.elasticity = 0.95 space.add(body, shape) balls.append(shape) # Display Rasta Rockets space.debug_draw(draw_options) r_flipper_body.position = 600, 82 l_flipper_body.position = 380, 82 r_flipper_body.velocity = l_flipper_body.velocity = 0, 0 # 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) # Update physics dt = 1.0 / 60.0 / 5. for x in range(5): space.step(dt) clock.tick(50) screen.blit(surface, (0, 0)) pygame.display.flip() pygame.display.set_caption( "Night Mission - PinBall - " + "FPS: " + str(clock.get_fps()) + " - Mouse Position : " + "mouseX: {0} - mouseY: {1}".format(mouseX, mouseY))
def main(): # Primatians - woo print "Running Python version:", sys.version print "Running PyGame version:", pygame.ver print "Running PyMunk version:", pymunk.version print "Running Primatians version:", __version__ pygame.init() screen = pygame.display.set_mode((800, 500), pygame.RESIZABLE) pygame.display.set_caption("Primatians - A Nanho Games Production") # make our background object colorBackground = Color("darkolivegreen4") backgroundLayer = DrawSurf(screen, colorBackground) clock = pygame.time.Clock() running = True # Physics stuff space = pymunk.Space(50) space.gravity = (90, -90.0) # Balls balls = [] mass = 1 radius = 25 inertia = pymunk.moment_for_circle(mass, 0, radius, (0, 0)) body = pymunk.Body(mass, inertia) x = random.randint(0, 500) body.position = 400, 400 shape = pymunk.Circle(body, radius, (0, 0)) shape.elasticity = 0.95 space.add(body, shape) balls.append(shape) # Walls first static_body = pymunk.Body() # x1,y1, x2,y2 static_lines = [ pymunk.Segment(static_body, (0.0, 0.0), (0.0, 500.0), 5.0), pymunk.Segment(static_body, (0.0, 500.0), (800.0, 500.0), 5.0), pymunk.Segment(static_body, (800.0, 500.0), (800.0, 0.0), 5.0), pymunk.Segment(static_body, (800.0, 0.0), (0.0, 0.0), 5.0) ] for line in static_lines: line.elasticity = 0.7 line.group = 1 space.add(static_lines) # Some Logs static_logs = [pymunk.Segment(static_body, (200, 250), (600, 250), 5)] for logs in static_logs: logs.elasticity = 1 logs.group = 1 space.add(static_logs) # Add Flippers ( handler tree logs) fp = [(20, -20), (-120, 0), (20, 20)] mass = 100 moment = pymunk.moment_for_poly(mass, fp) # right flipper r_flipper_body = pymunk.Body(mass, moment) r_flipper_body.position = 750, 10 r_flipper_shape = pymunk.Poly(r_flipper_body, fp) space.add(r_flipper_body, r_flipper_shape) r_flipper_joint_body = pymunk.Body() r_flipper_joint_body.position = r_flipper_body.position j = pymunk.PinJoint(r_flipper_body, r_flipper_joint_body, (0, 0), (0, 0)) #todo: tweak values of spring better s = pymunk.DampedRotarySpring(r_flipper_body, r_flipper_joint_body, 0.15, 20000000, 900000) space.add(j, s) # left flipper l_flipper_body = pymunk.Body(mass, moment) l_flipper_body.position = 10, 10 l_flipper_shape = pymunk.Poly(l_flipper_body, [(-x, y) for x, y in fp]) space.add(l_flipper_body, l_flipper_shape) l_flipper_joint_body = pymunk.Body() l_flipper_joint_body.position = l_flipper_body.position j = pymunk.PinJoint(l_flipper_body, l_flipper_joint_body, (0, 0), (0, 0)) s = pymunk.DampedRotarySpring(l_flipper_body, l_flipper_joint_body, -0.15, 20000000, 900000) space.add(j, s) # new flippers fp = [(20, -20), (-120, 0), (20, 20)] #fp = [(120, 0), (120,-20),(-120,0)] mass = 100 moment = pymunk.moment_for_poly(mass, fp) # top-right flipper tr_flipper_body = pymunk.Body(mass, moment) tr_flipper_body.position = 750, 450 tr_flipper_shape = pymunk.Poly(tr_flipper_body, fp) space.add(tr_flipper_body, tr_flipper_shape) tr_flipper_joint_body = pymunk.Body() tr_flipper_joint_body.position = tr_flipper_body.position j = pymunk.PinJoint(tr_flipper_body, tr_flipper_joint_body, (0, 0), (0, 0)) #todo: tweak values of spring better s = pymunk.DampedRotarySpring(tr_flipper_body, tr_flipper_joint_body, 0.15, 20000000, 900000) space.add(j, s) # top-left flipper tl_flipper_body = pymunk.Body(mass, moment) tl_flipper_body.position = 50, 850 tl_flipper_shape = pymunk.Poly(tl_flipper_body, [(-x, y) for x, y in fp]) space.add(tl_flipper_body, tl_flipper_shape) tl_flipper_joint_body = pymunk.Body() tl_flipper_joint_body.position = tl_flipper_body.position j = pymunk.PinJoint(tl_flipper_body, tl_flipper_joint_body, (0, 0), (0, 0)) s = pymunk.DampedRotarySpring(tl_flipper_body, tl_flipper_joint_body, -0.15, 20000000, 900000) space.add(j, s) r_flipper_shape.group = l_flipper_shape.group = tr_flipper_shape.group = tl_flipper_shape.group = 1 r_flipper_shape.elasticity = l_flipper_shape.elasticity = tr_flipper_shape.elasticity = tl_flipper_shape.elasticity = 0.4 while running: for event in pygame.event.get(): if event.type == QUIT: running = False elif event.type == KEYDOWN and event.key == K_ESCAPE: running = False elif event.type == KEYDOWN and event.key == K_j: r_flipper_body.apply_impulse(Vec2d.unit() * 40000, (-100, 0)) elif event.type == KEYDOWN and event.key == K_f: l_flipper_body.apply_impulse(Vec2d.unit() * -40000, (-100, 0)) elif event.type == KEYDOWN and event.key == K_g: tl_flipper_body.apply_impulse(Vec2d.unit() * 40000, (-100, 0)) elif event.type == KEYDOWN and event.key == K_h: tr_flipper_body.apply_impulse(Vec2d.unit() * -40000, (-100, 0)) if event.type == pygame.VIDEORESIZE: screen_size = event.size screen = pygame.display.set_mode(screen_size, pygame.RESIZABLE) oldBg = backgroundLayer.surface.copy() backgroundLayer = DrawSurf(screen, backgroundLayer.color) backgroundLayer.surface.blit(oldBg, (0, 0)) # Draw # backgroundLayer.draw() screen.fill(THECOLORS["darkolivegreen"]) # Draw lines for line in static_lines: body = line.body pv1 = body.position + line.a.rotated(body.angle) pv2 = body.position + line.b.rotated(body.angle) p1 = to_pygame(pv1) p2 = to_pygame(pv2) pygame.draw.lines(screen, THECOLORS["black"], False, [p1, p2]) # Draw logs for log in static_logs: body = log.body pv1 = body.position + log.a.rotated(body.angle) pv2 = body.position + log.b.rotated(body.angle) p1 = to_pygame(pv1) p2 = to_pygame(pv2) pygame.draw.lines(screen, THECOLORS["brown"], False, [p1, p2]) for ball in balls: p = to_pygame(ball.body.position) pygame.draw.circle(screen, THECOLORS["yellow"], p, int(ball.radius), 2) r_flipper_body.position = 790, 10 l_flipper_body.position = 10, 10 tr_flipper_body.position = 790, 490 tl_flipper_body.position = 10, 490 r_flipper_body.velocity = l_flipper_body.velocity = tr_flipper_body.velocity = tl_flipper_body.velocity = 0, 0 for f in [ r_flipper_shape, l_flipper_shape, tr_flipper_shape, tl_flipper_shape, ]: ps = f.get_points() ps.append(ps[0]) ps = map(to_pygame, ps) color = THECOLORS["red"] pygame.draw.lines(screen, color, False, ps) # Update physics dt = 1.0 / 60.0 / 5 for x in range(5): space.step(dt) pygame.display.flip() clock.tick(50)
def run(): pygame.init() pygame.display.set_caption("Pinball Simulator") screen = pygame.display.set_mode((600, 600)) clock = pygame.time.Clock() running = True ### Physics stuff space = pymunk.Space() space.gravity = (0.0, -900.0) draw_options = pymunk.pygame_util.DrawOptions(screen) ## Balls balls = [] ### walls static_lines = [ pymunk.Segment(space.static_body, (150, 100.0), (50.0, 550.0), 1.0), pymunk.Segment(space.static_body, (450.0, 100.0), (550.0, 550.0), 1.0), pymunk.Segment(space.static_body, (50.0, 550.0), (300.0, 600.0), 1.0), pymunk.Segment(space.static_body, (300.0, 600.0), (550.0, 550.0), 1.0), pymunk.Segment(space.static_body, (300.0, 420.0), (400.0, 400.0), 1.0) ] for line in static_lines: line.elasticity = 0.7 line.group = 1 space.add(static_lines) 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 = 450, 100 r_flipper_shape = pymunk.Poly(r_flipper_body, fp) space.add(r_flipper_body, r_flipper_shape) r_flipper_joint_body = pymunk.Body(body_type=pymunk.Body.KINEMATIC) 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 = 150, 100 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(body_type=pymunk.Body.KINEMATIC) 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 # "bumpers" for p in [(240, 500), (360, 500)]: body = pymunk.Body(body_type=pymunk.Body.KINEMATIC) 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 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, "flipper.png") elif event.type == KEYDOWN and event.key == K_d: r_flipper_body.apply_impulse_at_local_point( Vec2d.unit() * 40000, (-100, 0)) elif event.type == KEYDOWN and event.key == K_a: l_flipper_body.apply_impulse_at_local_point( Vec2d.unit() * -40000, (-100, 0)) elif event.type == KEYDOWN and event.key == K_s: 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) ### Clear screen screen.fill(THECOLORS["white"]) ### Draw stuff space.debug_draw(draw_options) r_flipper_body.position = 450, 100 l_flipper_body.position = 150, 100 r_flipper_body.velocity = l_flipper_body.velocity = 0, 0 ### 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) ### Update physics dt = 1.0 / 60.0 / 5. for x in range(5): space.step(dt) draw_helptext(screen) ### Flip screen pygame.display.flip() clock.tick(50)
closure, closure_object = physic.generateClosure(spaceFlipper) #Génération des décors windowFlipper.blit(backgroundFlipper, (0, 0)) windowFlipper.blit(data.jail1, (832, 517)) windowFlipper.blit(data.rotor1, (447, 136)) windowFlipper.blit(data.closure1, (875, 115)) generateGame = False #Cycle du jeu une fois ce dernier généré #Interaction du joueur avec le jeu for event in pg.event.get(): # Controle du flipper droit if useFlippers and event.type == KEYDOWN and event.key == K_c: right_flipper.apply_impulse_at_local_point(Vec2d.unit() * 45000, (-75, 0)) pg.mixer.Sound.play(data.flip_right) # Controle du flipper gauche if useFlippers and event.type == KEYDOWN and event.key == K_x: left_flipper.apply_impulse_at_local_point(Vec2d.unit() * -45000, (-75, 0)) pg.mixer.Sound.play(data.flip_right) # Réglage de la puissance du ressort if event.type == KEYDOWN and event.key == K_r and ballCreated == False: if numberBallPlayer[round - 1] > 0: ressort_position = ressort_position + 1 if ressort_position > 5: ressort_position = 1
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)
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)
credit += 1 sound = pygame.mixer.Sound("credit.ogg") sound.play() elif event.type == KEYDOWN and event.key == K_LSHIFT: startcredit = True if credit != 0: if balls == []: balls.append(newball()) credit -= 1 if hard == True: nball += 2 else: nball += 5 elif event.type == KEYDOWN and event.key == K_RIGHT and tilted == False: r_bar_body.apply_impulse_at_local_point( Vec2d.unit() * 15000, (-100, 0)) elif event.type == KEYDOWN and event.key == K_LEFT and tilted == False: l_bar_body.apply_impulse_at_local_point( Vec2d.unit() * -15000, (-100, 0)) elif event.type == KEYDOWN and event.key == K_DOWN: if springs != 704: springs += 30 elif event.type == KEYDOWN and event.key == K_UP: if springs != 584: springs -= 30 elif event.type == KEYDOWN and event.key == K_z: if balls != []: tilt += 1 ballbody.apply_impulse_at_local_point((Vec2d((100, 0)))) elif event.type == KEYDOWN and event.key == K_x: if balls != []:
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)
pygame.key.set_repeat(1, 1000) perm = False y += 10 Ppoussoir = (x, y) timeball1 = timeball if event.type == KEYUP and event.key == K_SPACE: perm = True y = 490 Ppoussoir = (x, y) 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)) #body.angular_velocity = 1 ball_lancer = 1 elif energyball <= 3000 and ball_lancer == 0: body.apply_impulse_at_local_point( Vec2d.unit() * energyball, (-100, 0)) #body.angular_velocity = 1 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)