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)
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 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)
