Example #1
0
 def _acquire_singlebody_now(self, singlebody, parent_unit):
     #Calculate the new velocity vector for the big body
     vx1, vy1 = self.body.velocity.x, self.body.velocity.y
     vx2, vy2 = singlebody.body.velocity.x, singlebody.body.velocity.y
     m1, m2 = self.body.mass, singlebody.body.mass
     vx3 = (m1*vx1+m2*vx2)/(m1+m2)
     vy3 = (m1*vy1+m2*vy2)/(m1+m2)
     
     #Find the body-local offset of the new unit
     new_offset = self.body.world_to_local(singlebody.body.position)
     #Define a shortcut to eliminate ambiguity
     new_unit = singlebody.unit
     new_unit.parent_unit = parent_unit
     
     #Kill the old body and shape
     physics.space.remove(singlebody.body)
     singlebody.unit.remove_shapes()
     physics.body_update_list.remove(singlebody)
     
     #Add the new unit to the big body
     self.units.append(new_unit)
     #Initialize it with the proper parent (big body)
     new_unit.initialize(self, collision_type=physics.PLAYER)
     new_unit.set_offset(new_offset.x,new_offset.y)
     #Give it the proper local rotation
     new_unit.local_angle = (new_unit.rotation+self.angle_degrees)
     new_unit.local_angle_target = new_unit.local_angle
     #Tell the physics engine about it
     new_unit.add_shapes()
     
     #Fix the big body
     self.update_center_of_mass()
     self.body.velocity=(vx3,vy3)
     
     if hasattr(singlebody.unit, 'obj_id'):
         if singlebody.unit.obj_id in event.attach_funcs.keys():
             for func in event.attach_funcs[singlebody.unit.obj_id]:
                 try:
                     func(singlebody.unit.obj_id)
                 except:
                     func()
     
     event.update_player_units(self.units)
     new_unit.attach()
Example #2
0
def load(level_name, keep_config=False, keep_velocity=False):
    global current_level, player
    reset()
    current_level = level_name
    
    path = os.path.join(level_dir, level_name+".yaml")
    stream = file(path, 'r')
    yaml_objects = yaml.load(stream)
    stream.close()
    
    load_geometry(yaml_objects)
    load_yaml_objects(yaml_objects)
    
    shapeloaders.add_line(0, 0, width, 0)
    shapeloaders.add_line(width, 0, width, height)
    shapeloaders.add_line(width, height, 0, height)
    shapeloaders.add_line(0, height, 0, 0)
    
    physics.space.resize_static_hash()
    physics.space.resize_active_hash()
    if not keep_config:
        init_player(player_start_x, player_start_y, math.pi/2, player_config)
        player.body.angle = player_start_angle
    else:
        player.body.position.x = player_start_x
        player.body.position.y = player_start_y
        if not keep_velocity:
            player.body.velocity.x = 0.0
            player.body.velocity.y = 0.0
        physics.body_update_list.append(player)
        physics.unit_update_list.extend(player.units)
        physics.space.add(player.body)
        for unit in player.units:
            if hasattr(unit, 'update_patients_now'):
                unit.update_patients_now = True
            unit.add_shapes()
            unit.batch = None
            unit.batch = batch
            unit.migrate()
    resources.wall_sound = resources.metal_against_metal2        
    event.update_player_units(player.units)
    level_module = __import__(level_name)
    if hasattr(level_module, 'init'): level_module.init()
Example #3
0
 def _release_unit_now(self, unit):
     #Find the new body's global coordinates and rotation
     physics.unit_update_list.remove(unit)
     new_body_position = self.body.local_to_world(unit.circle.center)
     new_body_rotation = math.degrees(self.body.angle) - unit.local_angle
     
     angle_to_unit = self.body.angle
     angle_to_unit += math.atan2(unit.offset[1], unit.offset[0])
     extra_angle = angle_to_unit + math.pi/2
     extra = self.body.angular_velocity * math.sqrt(unit.offset_dist_sq)
     new_body_velocity = (
         self.body.velocity.x + extra * math.cos(extra_angle),
         self.body.velocity.y + extra * math.sin(extra_angle)
     )
     
     unit.remove_shapes()
     
     #Create a new body, pass it the unit
     new_body = SingleBody(new_body_position, new_body_rotation, unit)
     new_body.body.velocity = new_body_velocity
     new_body.body.angular_velocity = self.body.angular_velocity
     unit.parent = None
     if unit.active:
         unit.active_timer = 1.0
         unit.deactivate()
     unit.release()
     #Fix self
     self.update_center_of_mass()
     
     if hasattr(unit, 'obj_id'):
         if unit.obj_id in event.release_funcs.keys():
             for func in event.release_funcs[unit.obj_id]:
                 try:
                     func(unit.obj_id)
                 except TypeError:
                     func()
     
     event.update_player_units(self.units)
Example #4
0
 def __init__(self, pos=(0.0,0.0), rot=0.0, child_units=[]):
     mass = 0.0
     inertia = 0.0
     self.units = []
     offset_r = 0.0
     
     for this_unit in child_units:
         offset_r = math.sqrt(this_unit.offset[0]**2+this_unit.offset[1]**2)
         mass += this_unit.mass
         inertia += pymunk.moment_for_circle(
             this_unit.mass, 0, this_unit.radius, this_unit.offset
         )
     
     self.body = pymunk.Body(mass, inertia)
     
     self.units = child_units
     for this_unit in self.units:
         this_unit.initialize(self,collision_type=physics.PLAYER)
         this_unit.add_shapes()
     
     physics.body_update_list.append(self)
     physics.unit_update_list.extend(self.units)
     physics.space.add(self.body)
     
     self.update_center_of_mass()
     self.body.angle = rot
     self.body.position = pos
     self.x, self.y = self.body.position.x, self.body.position.y
     self.angle_degrees = math.degrees(self.body.angle)
     self.to_acquire = []
     self.parent_units = []
     self.to_release = []
     
     self.attachable = False
     
     event.update_player_units(self.units)
Example #5
0
def load_save_from_path(path, keep_config=False, keep_velocity=False):
    global player, current_level
    reset()
    event.init()
    stream = file(path, 'r')
    yaml_objects = [obj for obj in yaml.load(stream) if obj != None]
    stream.close()
    
    level_module = None
    
    target_queue = []
    
    if player != None:
        for unit in player.units:
            unit.batch = None
    
    for obj in yaml_objects:
        try:
            getattr(saveloaders, obj.yaml_tag[3:])(obj)
        except:
            if obj.yaml_tag == u"!i_LevelData":
                change_level_set(obj.level_dir)
                current_level = obj.level_name
                savegame.set_current_level(obj.level_dir, current_level)
                level_module = __import__(current_level)
                path = os.path.join(level_dir, obj.level_name+".yaml")
                stream = file(path, 'r')
                yaml_geometry = yaml.load(stream)
                stream.close()
                load_geometry(yaml_geometry)
            elif obj.yaml_tag == u"!i_GlueBody":
                if not obj.is_player or not keep_config:
                    unit_list = [saveloaders.unit_from_dict(u) for u in obj.units]
                    new_gluebody = body.GlueBody(
                        obj.position, obj.angle, unit_list
                    )
                    new_gluebody.attachable = obj.attachable
                    new_gluebody.body.velocity = obj.velocity
                    new_gluebody.body.angular_velocity = obj.angular_velocity
                    if obj.is_player:
                        player = new_gluebody
                    for unit in unit_list:
                        if hasattr(unit, 'update_patients_now'):
                            unit.update_patients_now = True
                    
                if obj.is_player and keep_config:
                    player.body.position = obj.position
                    if not keep_velocity:
                        player.body.velocity.x = 0.0
                        player.body.velocity.y = 0.0
                    physics.body_update_list.append(player)
                    physics.unit_update_list.extend(player.units)
                    physics.space.add(player.body)
                    for unit in player.units:
                        unit.add_shapes()
                        unit.batch = batch
                        unit.migrate()
                        if unit.using_sound: unit.init_sound(unit.sound, unit.loop_sound)
            elif obj.yaml_tag == u"!i_Turret":
                new_turret = saveloaders.make_turret(obj)
                new_turret.active = obj.active
                target_queue.append((new_turret, obj.target))
                if not obj.visible: new_turret.make_invisible()
            else:
                print "Did not load", obj
    
    for obj, target in target_queue:
        if target > 0:
            obj.target = event.get_object(target)
    event.update_player_units(player.units)
    resources.wall_sound = resources.metal_against_metal2
    if hasattr(level_module, 'on_load'):
        level_module.on_load()