def update(self):
if self.turning_right:
self.rot -= 5
if self.turning_left:
self.rot += 5
a = [0.0,0.0]
if self.boost_endtime > rabbyt.get_time():
f = 3*(self.boost_endtime - rabbyt.get_time())/self.boost_length
a[0] += cos(radians(self.boost_rot))*f
a[1] += sin(radians(self.boost_rot))*f
self.create_boost_particle()
if self.accelerating:
a[0] += cos(radians(self.rot))*.9
a[1] += sin(radians(self.rot))*.9
self.create_dust_particle(self.dust_r)
self.create_dust_particle(self.dust_l)
ff = .9 # Friction Factor
self.velocity[0] *= ff
self.velocity[1] *= ff
self.velocity[0] += a[0]
self.velocity[1] += a[1]
self.x += self.velocity[0]
self.y += self.velocity[1]
def on_key_press(self, symbol, modifiers):
if symbol == self.keys.get(self.controls.get("[primary fire]")):
if self.player.inspace == 1:
self.sounds.weapon1.play(-1)
self.player.isfiring = 1
elif symbol == self.keys.get(self.controls.get("[secondary fire]")):
if self.player.inspace == 1:
self.sounds.weapon2.play(-1)
self.player.isfiring2 = 1
if self.mainmenu.open == 0:
if self.player.inspace == 1:
if symbol == self.keys.get(self.controls.get("[left]")):
self.player_rot=(1, -1)
self.player.rot_time = rabbyt.get_time()
elif symbol == self.keys.get(self.controls.get("[right]")):
self.player_rot=(1, 1)
self.player.rot_time = rabbyt.get_time()
elif symbol == self.keys.get(self.controls.get("[up]")):
self.player_accel = 1
self.player.pos_time = rabbyt.get_time()
elif symbol == self.keys.get(self.controls.get("[down]")):
self.player_about = 1
self.player.rot_time = rabbyt.get_time()
def create_boost_particle(self):
s = rabbyt.Sprite(self.texture_id, self.shape)
lifetime = .5
s.xy = self.xy
s.rot = self.rot
s.scale = rabbyt.lerp(1, 2, dt=lifetime)
s.alpha = rabbyt.lerp(.8, 0, dt=lifetime)
Car.boost_particles.add(s)
rabbyt.scheduler.add(rabbyt.get_time()+lifetime,
lambda:Car.boost_particles.remove(s))
lt = .8
star = rabbyt.Sprite("star2.png")
x = random.random()*80-40
y = random.random()*80-40
star.x = rabbyt.lerp(self.x+x, self.convert_offset((-20,0))[0]+x, dt=lt)
star.y = rabbyt.lerp(self.y+y, self.convert_offset((-20,0))[1]+y, dt=lt)
star.rot = rabbyt.lerp(0, 190*random.choice([-2,-1,1,2]), dt=5, extend="extrapolate")
star.scale = rabbyt.lerp(random.random()+.2,0, rabbyt.get_time()+lt/2, dt=lt/2)
star.rgb = 0, .5, .9
Car.boost_particles.add(star)
rabbyt.scheduler.add(rabbyt.get_time()+lt,
lambda:Car.boost_particles.remove(star))
def CalcOtherPos(player,other,visible_size):
new_time = rabbyt.get_time()
time = new_time - other.pos_time
other.pos = [other.pos[0] + (other.velocity * time * sin(radians(other.heading))),
other.pos[1] + (other.velocity * time * cos(radians(other.heading)))]
pos = (int(other.pos[0]) - player[0], int(other.pos[1]) - player[1])
other.pos_time = rabbyt.get_time()
if (abs(pos[0]) <= visible_size[0] / 2 + 200) and (abs(pos[1]) <= visible_size[1] / 2 + 200):
return (int(pos[0] + visible_size[0] / 2),int(pos[1]) + visible_size[1] / 2)
else:
return (1000,1000)
def __init__(self, window, panel):
self.isai = 0
self.name = "howard"
self.sprite = rabbyt.Sprite(texture="data/ships/Rebelfighterblank.png")
self.sprite.xy = ((window[0] - panel[0]) / 2, window[1] / 2)
print "CHECK IT"
print self.sprite.xy
print window
print panel
print "/CHECK IT"
self.speed = 250
self.accel = 175
self.velocity = 0
self.movement = 0
self.pos = [0, 0]
self.pos_time = 0
self.rps = 0.6
self.rot = 0
self.rot2 = self.sprite.rot
self.rot_step = 1
self.rot_time = 0
self.direction = 0
self.heading = 0
self.time = rabbyt.get_time()
self.isfiring = 0
self.isfiring2 = 0
self.secondary = "space bomb"
self.outfit = []
self.inspace = 1
self.docked = 0
self.system = None
self.destination = None
self.idnum = None
self.planet = None
self.location = ["system", "body"]
def accelerate(self, mapsize):
if self.rot == self.heading:
self.pos, self.velocity = tools.CalcPos(
self.pos, self.pos_time, self.speed, self.accel, self.velocity, self.heading
)
elif (self.rot == self.heading - 180) or (self.rot == self.heading + 180):
self.pos, self.velocity = tools.SlowDown(
self.pos, self.pos_time, self.speed, self.accel, self.velocity, self.heading
)
else:
self.heading, self.direction, self.velocity, self.pos = tools.CalcHeading(
self.pos,
self.pos_time,
self.speed,
self.accel,
self.velocity,
self.direction,
self.heading,
self.rot,
self.rot_step,
)
if self.velocity == 0:
self.heading, self.direction = self.rot, self.rot
self.pos_time = rabbyt.get_time()
# print "VEC ROT",self.direction,self.rot
return None
def CalcHeading(last_pos, prev_time, speed, accel, velocity, direction, heading, rot, step):
time = rabbyt.get_time() - prev_time
a = accel * time
#print "ACCEL DIRECTION VELOCITY HEADING ROTATION"
#print a, direction, velocity, heading, rot
vecx = sin(radians(direction)) * velocity
vecy = cos(radians(direction)) * velocity
thrustx = sin(radians(rot)) * a
thrusty = cos(radians(rot)) * a
#print "old velocity:", velocity
#print "vecx:",vecx,"vecy:",vecy,"thrustx:",thrustx,"thrusty:",thrusty
velocity = sqrt((vecx + thrustx)**2 + (vecy + thrusty)**2)
new_direction = degrees(atan((vecx + thrustx)/(vecy + thrusty)))
if vecy + thrusty < 0:
new_direction += 180
#new_heading = round(new_direction/10.0)*10 + 180
new_heading = round(new_direction/float(step))*step
#print "new velocity:",velocity
#print "old_direction:", direction
if new_heading < 0:
new_heading = 360 + new_heading
#print "new_direction:", new_direction
#print "NEW HEADING",new_heading
if velocity > speed:
velocity = speed
new_pos = [last_pos[0] + (velocity * time * sin(radians(new_heading))),
last_pos[1] + (velocity * time * cos(radians(new_heading)))]
return new_heading, new_direction, velocity, new_pos
def __init__(self,window,panel):
self.sprite = rabbyt.Sprite(texture = "asteroid.png")
self.sprite.xy = (0,0)
self.speed = 50
self.pos = [0, 0]
self.pos_time = 0
self.rps = .5
self.vector = 0
self.time = rabbyt.get_time()
def CalcRot(prev_time, rps, step, direction):
time = rabbyt.get_time()
rt = (1.0 / rps) / (360 / step)
if time - prev_time >= rt:
num_steps = int((time - prev_time) / rt)
rotate = direction * num_steps * step
else:
rotate = 0
return rotate
def run_waiters () :
while len ( waiters ) :
end_time = waiters [ 0 ] [ 0 ]
if end_time <= rabbyt.get_time () :
event = waiters [ 0 ] [ 1 ]
del waiters [ 0 ]
event.call_all ()
else :
break
def SlowDown(last_pos, prev_time, speed, accel, velocity, heading): #Calculate Position Based on last know position, vector, and amount of time passed
new_time = rabbyt.get_time()
time = new_time - prev_time
velocity = velocity - accel * time
if velocity < 0:
velocity = 0
new_pos = [last_pos[0] + (velocity * time * sin(radians(heading))),
last_pos[1] + (velocity * time * cos(radians(heading)))]
#print "slowpos",new_pos
return new_pos, velocity
def CalcPos(last_pos, prev_time, speed, accel, velocity, heading): #Calculate Position Based on last know position, vector, and amount of time passed
new_time = rabbyt.get_time()
time = new_time - prev_time
velocity = accel * time + velocity
if velocity > speed:
velocity = speed
new_pos = [last_pos[0] + (velocity * time * sin(radians(heading*1))),
last_pos[1] + (velocity * time * cos(radians(heading*1)))]
#print "gopos",new_pos
return new_pos, velocity
def create_dust_particle(self, offset):
s = rabbyt.Sprite("star.png")
lifetime = 4
x, y = self.convert_offset(offset)
r = random.random # (shortcut)
s.x = rabbyt.lerp(x+r()*10-5, x+r()*60-30, dt=lifetime)
s.y = rabbyt.lerp(y+r()*10-5, y+r()*60-30, dt=lifetime)
s.rot = rabbyt.lerp(0, 90*random.choice(range(-2,3)), dt=6)
s.scale = rabbyt.lerp(1, 4, dt=lifetime)
now = rabbyt.get_time()
s.rgba = .7, .5, 0, rabbyt.lerp(.1, 0, now+lifetime/2, now+lifetime)
Car.dust_particles.add(s)
rabbyt.scheduler.add(rabbyt.get_time()+lifetime,
lambda:Car.dust_particles.remove(s))
def rotate(self, direction):
rot_amt = tools.CalcRot(self.rot_time, self.rps, self.rot_step, direction)
if rot_amt > 0 and self.rot == (360 - rot_amt):
self.rot = 0
elif rot_amt < 0 and self.rot == (0):
self.rot = 360 - self.rot_step
else:
self.rot += rot_amt
self.sprite.rot = self.rot * -1
if rot_amt <> 0:
self.rot_time = rabbyt.get_time()
if self.velocity == 0:
self.heading, self.direction = self.rot, self.rot
# print "selfrot",self.rot,"sprite rot",self.sprite.rot
# print "self.heading",self.heading
return None
def wait ( arg ) :
if arg == None :
return
elif isinstance ( arg, Task ) :
while working ( arg ) :
work_async ()
elif isinstance ( arg, Event ) :
arg.wait ()
else :
if arg == 0 :
return
event = Event ()
end_time = rabbyt.get_time () + arg
waiters.append ( ( end_time, event ) )
waiters.sort ()
event.wait ()
def handle_event(self, event):
if hasattr(event, 'pos'):
# translate the position from mouse coordinates to viewport coordinates
x_factor = float(event.pos[0]) / self.size[0]
y_factor = float(event.pos[1]) / self.size[1]
system_x = x_factor * (self.size[0] - self.ratio * self.z)
system_y = y_factor * (self.size[1] - self.z)
if not self.panning:
system_x += self.viewport_x
system_y += self.viewport_y
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
return False
elif event.type == pygame.MOUSEBUTTONDOWN:
grabbed_piece = None
# sort based on z-order
location = rabbyt.Sprite(x=system_x, y=system_y)
collisions = sorted(rabbyt.collisions.aabb_collide_single(location, self.pieces),
cmp=lambda x, y: cmp(self.pieces.index(y), self.pieces.index(x)))
if collisions:
self.grabbed_piece = collisions[0]
if self.grabbed_piece and event.button == 3:
self.grabbed_piece.flip()
if self.grabbed_piece:
#keep the list in z-order
self.pieces.remove(self.grabbed_piece)
self.pieces.append(self.grabbed_piece)
self.grabbed_piece.rgba = (.5, .5, .5, .75)
#self.grabbed_piece.scale = rabbyt.lerp(1, 1.25, dt=100, extend="reverse")
# Have the scrollwheel zoom in and zoom out when not hovering over a piece
if not self.grabbed_piece:
if event.button == 1:
self.panning = True
self.original_vx = self.viewport_x
self.original_vy = self.viewport_y
(self.panning_x, self.panning_y) = (system_x - self.viewport_x, system_y - self.viewport_y)#(event.pos[0], event.pos[1])
if event.button == 4:
if pygame.key.get_mods() & pygame.KMOD_CTRL:
self.z += 100
else:
self.z += 20
self.update_viewport()
elif event.button == 5:
if pygame.key.get_mods() & pygame.KMOD_CTRL:
self.z -= 100
else:
self.z -= 20
self.update_viewport()
if event.button == 4 and self.grabbed_piece and self.grabbed_piece.animflag == False:
self.grabbed_piece.animflag = True
self.grabbed_piece.rot = rabbyt.lerp(self.grabbed_piece.rot, self.grabbed_piece.rot + 45, dt=100);
rabbyt.scheduler.add(rabbyt.get_time()+200, self.grabbed_piece.animendcallback)
elif event.button == 5 and self.grabbed_piece and self.grabbed_piece.animflag == False:
self.grabbed_piece.animflag = True
self.grabbed_piece.rot = rabbyt.lerp(self.grabbed_piece.rot, self.grabbed_piece.rot - 45, dt=100);
rabbyt.scheduler.add(rabbyt.get_time()+200, self.grabbed_piece.animendcallback)
else:
if self.grabbed_piece:
self.offset_x = -(system_x - self.grabbed_piece.x)
self.offset_y = -(system_y - self.grabbed_piece.y)
elif event.type == pygame.MOUSEMOTION:
if self.panning:
self.viewport_x = self.original_vx - (system_x - self.panning_x)
self.viewport_y = self.original_vy - (system_y - self.panning_y)
self.update_viewport()
if self.grabbed_piece:
if pygame.key.get_mods() & pygame.KMOD_CTRL:
self.grabbed_piece.xy = ((system_x + self.offset_x) - (system_x + self.offset_x) % self.grabbed_piece.width(), (system_y + self.offset_y) - (system_y + self.offset_y) % self.grabbed_piece.height())
else:
self.grabbed_piece.x = system_x + self.offset_x
self.grabbed_piece.y = system_y + self.offset_y
elif event.type == pygame.MOUSEBUTTONUP:
if self.grabbed_piece:
self.grabbed_piece.rgba = (1, 1, 1, 1)
self.grabbed_piece.drop()
# this is causing pieces to slide somewhere else when I drop them now...
#if pygame.key.get_mods() & pygame.KMOD_CTRL:
# self.grabbed_piece.xy = rabbyt.lerp((self.grabbed_piece.x, self.grabbed_piece.y), (self.grabbed_piece.x - self.grabbed_piece.x % self.grabbed_piece.width(), self.grabbed_piece.y - self.grabbed_piece.y % self.grabbed_piece.height()), dt=200)
#self.grabbed_piece.scale = rabbyt.lerp(1.25, 1, dt=200)
self.grabbed_piece = None
self.panning = False
# keep running
return True
def boost(self):
if self.boost_endtime > rabbyt.get_time():
return
self.boost_rot = self.rot
self.boost_endtime = rabbyt.get_time() + self.boost_length
def glide(self, mapsize):
self.pos, self.velocity = tools.CalcPos(self.pos, self.pos_time, self.speed, 0, self.velocity, self.heading)
self.pos_time = rabbyt.get_time()
# sort based on z-order
collisions = sorted(rabbyt.collisions.collide_single((event.pos[0], event.pos[1]), pieces), cmp=lambda x, y: cmp(pieces.index(y), pieces.index(x)))
if collisions:
grabbed_point = collisions[0]
if grabbed_point:
pieces.remove(grabbed_point)
pieces.append(grabbed_point)
grabbed_point.rgb = (.5, .5, .5)
#grabbed_point.scale = rabbyt.lerp(1, 1.25, dt=100, extend="reverse")
if event.button == 4 and grabbed_point and grabbed_point.animflag == False:
grabbed_point.animflag = True
grabbed_point.rot = rabbyt.lerp(grabbed_point.rot, grabbed_point.rot + 45, dt=200);
rabbyt.scheduler.add(rabbyt.get_time()+200, grabbed_point.animendcallback)
elif event.button == 5 and grabbed_point and grabbed_point.animflag == False:
grabbed_point.animflag = True
grabbed_point.rot = rabbyt.lerp(grabbed_point.rot, grabbed_point.rot - 45, dt=200);
rabbyt.scheduler.add(rabbyt.get_time()+200, grabbed_point.animendcallback)
else:
if grabbed_point:
offset_x = grabbed_point.x-event.pos[0]
offset_y = grabbed_point.y-event.pos[1]
elif event.type == pygame.MOUSEMOTION:
if grabbed_point:
grabbed_point.x = event.pos[0] + offset_x
grabbed_point.y = event.pos[1] + offset_y
elif event.type == pygame.MOUSEBUTTONUP:
