class RenderingLayer(common.Loggable, serialize.Serializable): """A layer on which to render things This is the abstract version of the layer. Create subclasses of this to do useful things. """ my_properties = ( serialize.S('name', '', 'the name of the layer'), serialize.I('order', 0, 'the order to render (0=low)'), serialize.B('active', True, 'whether this layer is active'), ) def __init__(self, name, order): """Initialise the Layer""" super(RenderingLayer, self).__init__() self.name = name self.order = order self.surface = None self.active = True def setSurface(self, surface): """Set our surface""" self.surface = surface def getSurface(self): """Return the surface""" return self.surface def initSurface(self, renderer): """Create the surface that we need to draw on""" raise NotImplementedError def getNiceName(self): """Return the nice name for this layer""" return '<Layer %d: %s - order %d>' % (id(self), self.name, self.order) ### Serializing ### def init(self): """Initialise from serialized state""" ### Rendering ### def clearSurface(self): """Clear our surface""" raise NotImplementedError def render(self, surface): """Render to a surface""" raise NotImplementedError
class Engine(common.Loggable, serialize.Serializable, common.EventAware): """The main Serge engine The engine manages a set of worlds and allows a single :doc:`world`, the current world, to be automatically updated on a certain time frequency. """ my_properties = ( serialize.L('_worlds', [], 'the worlds in this engine'), serialize.O('renderer', None, 'the renderer for this engine'), serialize.O('sprites', None, 'the sprite registry'), serialize.S('_current_world_name', '', 'the name of the current world'), serialize.L('_recent_worlds', [], 'the list of worlds recently visited'), serialize.B('fullscreen', False, 'whether to display in full screen or not'), ) def __init__(self, width=640, height=480, title='Serge', backcolour=(0,0,0), icon=None, fullscreen=False): """Initialise the engine :param width: width of the screen :param height: height of the screen """ self.title = title self.fullscreen = fullscreen self.addLogger() self.initEvents() self.log.info('Starting serge engine (v%s)' % common.version) SetCurrentEngine(self) super(Engine, self).__init__() self.clearWorlds() self.renderer = render.Renderer(width, height, title, backcolour, icon, fullscreen) self.sprites = visual.Register self._stop_requested = False self._current_world_name = '' self._builder = None self._keyboard = input.Keyboard() self._mouse = input.Mouse(self) self._stats = EngineStats() self._recent_worlds = [] def init(self): """Initialise ourself""" self.addLogger() self.log.info('Initializing serge engine (v%s)' % common.version) SetCurrentEngine(self) # # Prepare all the worlds for world in self._worlds.values(): world.init() self._current_world = None self._snapshots_enabled = True self._snapshot_count = 0 # # Recover the sprite registry from our own self.sprites.init() visual.Register = self.sprites self.setCurrentWorldByName(self._current_world_name) # self.renderer.init() # self._builder = None self._keyboard = input.Keyboard() self._mouse = input.Mouse(self) def addWorld(self, world): """Add a world to the engine :param world: the world instance to add """ if world.name in self._worlds: raise DuplicateWorld('A world named "%s" already exists' % world.name) if world in self._worlds.values(): raise DuplicateWorld('This world (named "%s") already exists' % world.name) self._worlds[world.name] = world world.setEngine(self) def removeWorld(self, world): """Remove a world from the engine :param world: the world instance to remove """ self.removeWorldNamed(world.name) def removeWorldNamed(self, name): """Remove a world with a given name :param name: the name of the world to remove """ try: del(self._worlds[name]) except KeyError: raise WorldNotFound('No world named "%s" in the worlds collection' % name) def clearWorlds(self): """Clear all the worlds""" self._worlds = {} self._current_world = None def getWorld(self, name): """Return the named world :param name: the name of the world to return """ try: return self._worlds[name] except KeyError: raise WorldNotFound('No world named "%s" in the worlds collection' % name) def getWorlds(self): """Return all the worlds""" return self._worlds.values() def getCurrentWorld(self): """Return the currently selected world""" if self._current_world: return self._current_world else: raise NoCurrentWorld('There is no current world') def setCurrentWorld(self, world): """Set the current world :param world: the world to set as the current world """ self.setCurrentWorldByName(world.name) def setCurrentWorldByName(self, name): """Set the current world to the one with the given name :param name: the name of the world to set as the current world """ self.log.info('Setting current world to %s' % name) if self._current_world_name: self._recent_worlds.append(self._current_world_name) new_world = self.getWorld(name) # # Send activation and deactivation callbacks to worlds to allow them to do # any housekeeping if new_world != self._current_world: if self._current_world: self._current_world.deactivateWorld() new_world.activateWorld() # self._current_world = new_world self._current_world_name = name return new_world def goBackToPreviousWorld(self, obj=None, arg=None): """Return to the world we were in before this one The arguments are never used and are just here to allow you to use this method as an event callback. """ try: name = self._recent_worlds.pop() except IndexError: raise WorldNotFound('There are no previous worlds') self.setCurrentWorldByName(name) # We will have pushed the current world onto the stack, which we don't want # so take it off again self._recent_worlds.pop() def updateWorld(self, interval): """Update the current world""" if self._current_world: self._current_world.updateWorld(interval) else: raise NoCurrentWorld('Cannot update when there is no current world') def run(self, fps, endat=None): """Run the updates at the specified frames per second until the optional endtime :param fps: the target frames per second (integer) :param endat: a time to stop the engine at (long), eg time.time()+60 to run for a minute """ self.log.info('Engine starting (requested fps=%d)' % fps) clock = pygame.time.Clock() self._stop_requested = False while True: # # Watch for ending conditions if self._stop_requested or (endat and time.time() >= endat): break # # Main render activity try: # # Pause clock.tick(fps) # # Do the update for our actors interval = clock.get_time() if self._current_world: self.updateWorld(interval) # # Do builder work if needed if self._builder: self._builder.updateBuilder(interval) # # Events that may have happened self._handleEvents() # Inputs self._mouse.update(interval) self._keyboard.update(interval) pygame.event.clear() # Sound sound.Music.update(interval) sound.Sounds.update(interval) if self._current_world: self.processEvents() # # Get ready to render self._stats.beforeRender() self.renderer.preRender() # # Render the active world if self._current_world: self._current_world.renderTo(self.renderer, interval) # # Render the builder if needed if self._builder: self._builder.renderTo(self.renderer, interval) # # And render all of our layers self.renderer.render() self.processEvent((events.E_AFTER_RENDER, self)) self._stats.afterRender() # # Show the screen pygame.display.flip() self._stats.recordFrame() # except NotImplementedError, err: self.log.error('Failed in main loop: %s' % err) # self.log.info('Engine stopping') self.processEvent((events.E_AFTER_STOP, self)) self.log.info('Engine info: %s' % (self._stats,))
class RenderingLayer(common.Loggable, serialize.Serializable, common.EventAware): """A layer on which to render things This is the abstract version of the layer. Create subclasses of this to do useful things. """ my_properties = ( serialize.S('name', '', 'the name of the layer'), serialize.I('order', 0, 'the order to render (0=low)'), serialize.B('active', True, 'whether this layer is active'), serialize.B('static', False, 'whether this layer is static with respect to the camera'), ) def __init__(self, name, order): """Initialise the Layer""" super(RenderingLayer, self).__init__() self.initEvents() self.name = name self.order = order self.surface = None self.active = True self.static = False def setSurface(self, surface): """Set our surface""" self.surface = surface def getSurface(self): """Return the surface""" return self.surface def initSurface(self, renderer): """Create the surface that we need to draw on""" raise NotImplementedError def getNiceName(self): """Return the nice name for this layer""" return '<Layer %d: %s - order %d>' % (id(self), self.name, self.order) def setStatic(self, static): """Determine whether this layer is static with respect to camera movements or not""" self.static = static ### Serializing ### def init(self): """Initialise from serialized state""" self.initEvents() ### Rendering ### def clearSurface(self): """Clear our surface""" raise NotImplementedError def preRender(self): """Called before the layer has anything rendered to""" self.processEvent((events.E_BEFORE_RENDER, self)) def render(self, surface): """Render to a surface""" raise NotImplementedError def postRender(self): """Called after the layer has has had everything rendered on it""" self.processEvent((events.E_AFTER_RENDER, self))
class Renderer(common.Loggable, serialize.Serializable, common.EventAware): """The main rendering component""" my_properties = ( serialize.L('layers', [], 'the layers we render to'), serialize.I('width', 640, 'the width of the screen'), serialize.I('height', 480, 'the height of the screen'), serialize.S('title', 'Serge', 'the title of the main window'), serialize.L('backcolour', (0,0,0), 'the background colour'), serialize.O('camera', None, 'the camera for this renderer'), serialize.O('icon', None, 'the icon for the main window'), serialize.B('fullscreen', False, 'whether to display in full screen or not'), ) def __init__(self, width=640, height=480, title='Serge', backcolour=(0,0,0), icon=None, fullscreen=False): """Initialise the Renderer""" self.addLogger() self.initEvents() self.width = width self.height = height self.title = title self.layers = [] self.backcolour = backcolour self.fullscreen = fullscreen self.camera = camera.Camera() self.camera.setSpatial(0, 0, self.width, self.height) self.icon = icon self.init() ### Serializing ### def init(self): """Initialise from serialized state""" self.addLogger() self.initEvents() self._sort_needed = False pygame.display.set_caption(self.title) # # Tried the following with flags but no impact pygame.FULLSCREEN|pygame.HWSURFACE|pygame.DOUBLEBUF flags = pygame.FULLSCREEN if self.fullscreen else 0 self.surface = pygame.display.set_mode((self.width, self.height), flags ) for layer in self.layers: layer.setSurface(pygame.Surface((self.width, self.height), pygame.SRCALPHA, 32)) layer.init() self.camera.init() self.camera.resizeTo(self.width, self.height) if self.icon: pygame.display.set_icon(visual.Register.getItem(self.icon).raw_image) ### Layers ### def addLayer(self, layer): """Add a layer to the rendering""" self.log.info('Adding layer "%s" at %d' % (layer.name, layer.order)) if layer in self.layers: raise DuplicateLayer('The layer %s is already in the renderer' % layer) else: self.layers.append(layer) self._sort_needed = True self.resetSurfaces() return layer def getLayer(self, name): """Return the named layer""" for layer in self.layers: if layer.name == name: return layer else: raise UnknownLayer('No layer with name "%s" was found' % (name,)) def getLayerBefore(self, layer): """Return the layer before the specified one in terms of rendering order""" for test_layer in reversed(self.getLayers()): if test_layer.order < layer.order: return test_layer else: raise NoLayer('There is no layer before %s' % layer.getNiceName()) def resetSurfaces(self): """Recreate the surfaces for our layers When layers are added we sometimes need to reset the layers, for instance, virtual layers need to be shifted around so that they have the right order. """ self._sortLayers() for layer in self.getLayers(): layer.initSurface(self) def getLayers(self): """Return all the layers""" return self.layers def removeLayer(self, layer): """Remove the layer from the rendering""" try: self.layers.remove(layer) except ValueError: raise UnknownLayer('The layer %s was not found' % layer.getNiceName()) def removeLayerNamed(self, name): """Remove the layer with the specific name""" layer = self.getLayer(name) self.removeLayer(layer) def clearLayers(self): """Clear all the layers""" self.layers = [] def _sortLayers(self): """Sort the layers into the right order""" self.layers.sort(lambda l1, l2 : cmp(l1.order, l2.order)) self._sort_needed = False def orderActors(self, actors): """Return the list of actors sorted by who should be processed first to correctly render The actors are checked to see which layer they reside on and then this is used to order the returned list. """ # # Make a lookup table to quickly find layers layers = dict([(layer.name, layer.order) for layer in self.getLayers()]) actor_list = [(layers.get(actor.getLayerName(), 0), actor) for actor in actors] actor_list.sort() # return [actor for _, actor in actor_list] ### Rendering ### def clearSurface(self): """Clear the surface""" self.surface.fill(self.backcolour) def preRender(self): """Prepare for new rendering""" self.clearSurface() for layer in self.getLayers(): if layer.active: layer.clearSurface() layer.preRender() def render(self): """Render all the layers""" # # Post rendering events for layer in self.layers: if layer.active: layer.postRender() # # Put layers in the right order if self._sort_needed: self._sortLayers() # # Render all layers for layer in self.layers: if layer.active: layer.render(self.surface) # self.processEvent((events.E_AFTER_RENDER, self)) def getSurface(self): """Return the overall surface""" return self.surface ### Camera stuff ### def setCamera(self, camera): """Set our camera""" self.camera = camera def getCamera(self): """Return our camera""" return self.camera def getScreenSize(self): """Returns the screen size""" return (self.width, self.height)
class Actor(common.Loggable, geometry.Rectangle, common.EventAware): """Represents an actor""" my_properties = ( serialize.S('tag', 'actor', 'the actor\'s tag'), serialize.S('name', '', 'the actor\'s name'), serialize.B('active', True, 'whether the actor is active'), serialize.B('visible', True, 'whether the actor is visible'), serialize.S('sprite', '', 'the name of our sprite'), serialize.S('layer', '', 'the name of the layer we render to'), serialize.I('rendering_order', 0, 'the order to use for rendering to the screen (lower is earlier)'), serialize.O('physical_conditions', '', 'the physical conditions for this object'), serialize.F('angle', 0.0, 'the angle for the actor'), serialize.O('lock', None, 'a lock object you can place to prevent an actor moving'), ) def __init__(self, tag, name=''): """Initialise the actor""" self.addLogger() self.initEvents() super(Actor, self).__init__() # Whether we respond to updates or not self.active = True self.visible = True # Class based tag to locate the actor by self.tag = tag # Unique name to locate by self.name = name # Our sprite self.sprite = '' self._visual = None # The layer we render to self.layer = '' # The order to render to the screen in (lower is earlier) self.rendering_order = 0 # Our zoom factor self.zoom = 1.0 # Physics parameters - None means no physics self.physical_conditions = None # Angle self.angle = 0.0 # Properties to lock an actor so it cannot be moved self.lock = None def init(self): """Initialize from serialized form""" self.addLogger() self.initEvents() self.log.info('Initializing actor %s:%s:%s' % (self, self.tag, self.name)) super(Actor, self).init() if self.sprite: self.setSpriteName(self.sprite) else: self._visual = None self.setLayerName(self.layer) self.zoom = 1.0 def getNiceName(self): """Return a nice name for this actor""" if self.name: name_part = '%s (%s)' % (self.name, self.tag) else: name_part = self.tag return '%s [%s] <%s>' % (self.__class__.__name__, name_part, hex(id(self))) def setSpriteName(self, name): """Set the sprite for this actor""" if name != self.sprite: self.visual = visual.Register.getItem(name).getCopy() # # Make sure to re-apply the zoom if self.zoom != 1.0: self.visual.scaleBy(self.zoom) self.sprite = name @property def visual(self): return self._visual @visual.setter def visual(self, value): """Set the visual item for this actor""" self._visual = value self._resetVisual() def _resetVisual(self): """Reset the visual item on the center point""" # # Adjust our location so that we are positioned and sized appropriately cx, cy, _, _ = self.getSpatialCentered() self.setSpatialCentered(cx, cy, self._visual.width, self._visual.height) # # Here is a hack - sometimes the visual width changes and we want to update our width # so we let the visual know about us so it can update our width. This is almost # certainly the wrong thing to do, but we have some tests in there so hopefully # the right thing becomes obvious later! self._visual._actor_parent = self def getSpriteName(self): """Return our sprite""" return self.sprite def setLayerName(self, name): """Set the layer that we render to""" self.layer = name def getLayerName(self): """Return our layer name""" return self.layer def setRenderingOrder(self, order): """Sets the order to render to the screen You can set this to adjust when objects are rendered even within a layer. A lower number means that an actor will be rendered earlier - which means it will be behind others. The default is 0, so you should set this to higher than 1000 if you want an actor to appear in front of other objects that have not been explicitly set. """ self.rendering_order = order def getRenderingOrder(self): """Return the rendering order""" return self.rendering_order def renderTo(self, renderer, interval): """Render this actor to the given renderer""" if self._visual and self.layer: layer = renderer.getLayer(self.layer) camera = renderer.camera if layer.static: coords = self.getOrigin() elif camera.canSee(self): coords = camera.getRelativeLocation(self) else: return # Cannot see me self._visual.renderTo(interval, layer.getSurface(), coords) def updateActor(self, interval, world): """Update the actor status""" def removedFromWorld(self, world): """Called when we are being removed from the world""" self.processEvent((events.E_REMOVED_FROM_WORLD, self)) def addedToWorld(self, world): """Called when we are being added to the world""" self.processEvent((events.E_ADDED_TO_WORLD, self)) def setZoom(self, zoom): """Zoom in on this actor""" if self._visual: self._visual.scaleBy(zoom/self.zoom) self.setSpatialCentered(self.x, self.y, self._visual.width, self._visual.height) self.zoom = zoom def setAngle(self, angle, sync_physical=False, override_lock=False): """Set the angle for the visual""" if self.lock and not override_lock: raise PositionLocked('Cannot rotate: %s' % self.lock.reason) if self._visual: self._visual.setAngle(angle) self._resetVisual() if sync_physical and self.physical_conditions: self.physical_conditions.body.angle = math.radians(-angle) self.angle = angle def getAngle(self): """Return the angle for the actor""" return self.angle ### Physics ### def setPhysical(self, physical_conditions): """Set the physical conditions""" # # Watch for if this object already has a shape if self.physical_conditions and self.physical_conditions.body: self.physical_conditions.updateFrom(physical_conditions) else: # # Check if we should be using the size of the visual element if physical_conditions.visual_size: if self.visual is None: raise physical.InvalidDimensions( 'No visual element set for actor %s but visual_size requested' % self.getNiceName()) else: if physical_conditions.visual_size == geometry.CIRCLE: # Circle physical_conditions.setGeometry(radius=self.visual.radius) elif physical_conditions.visual_size == geometry.RECTANGLE: # Rectangle physical_conditions.setGeometry(width=self.visual.width, height=self.visual.height) else: raise physical.InvalidDimensions('Visual size setting (%s) is not recognized' % physical_conditions.visual_size) # self.physical_conditions = physical_conditions def getPhysical(self): """Return the physical conditions""" return self.physical_conditions def syncPhysics(self, spatial_only=False): """Sync physics when the actors physical properties have been changed""" if self.physical_conditions: #self.log.debug('Syncing physics for %s to %s, %s' % (self.getNiceName(), self.x, self.y)) self.physical_conditions.body.position = self.x, self.y if not spatial_only: self.physical_conditions.body.velocity = self.physical_conditions.velocity # Remap x, y properties to allow syncing with the physics engine def move(self, x, y): """Move by a certain amount""" super(Actor, self).move(x, y) self.syncPhysics(spatial_only=True) def moveTo(self, x, y, no_sync=False, override_lock=False): """Move the center of this actor to the given location, unless it is locked You can override the lock by passing True to override lock. """ if self.lock and not override_lock: raise PositionLocked('The actor is locked in place: %s' % self.lock.reason) else: super(Actor, self).moveTo(x, y, override_lock=override_lock) if not no_sync: self.syncPhysics(spatial_only=True)
class Zone(geometry.Rectangle, common.Loggable): """A zone A zone is part of a world. It is a container for objects and it controls whether objects will take part in world updates. """ my_properties = ( serialize.B('active', False, 'whether the zone is active'), serialize.L('actors', set(), 'the actors in this zone'), serialize.F('physics_stepsize', 10.0, 'the size of physics steps in ms'), serialize.L('global_force', (0,0), 'the global force for physics'), serialize.F('_rtf', 1.0, 'debugging aid to slow down physics'), ) def __init__(self): """Initialise the zone""" super(Zone, self).__init__() self.addLogger() self.physics_stepsize = 10.0 self.global_force = (0,0) self.active = False self.setSpatial(-1000, -1000, 2000, 2000) self.clearActors() self._initPhysics() self._rtf = 1.0 # A debugging aid to slow down physics ### Serializing ### def init(self): """Initialise from serialized state""" self.addLogger() self.log.info('Initializing zone %s' % self) super(Zone, self).init() self._initPhysics() for actor in self.actors: actor.init() if actor.getPhysical(): actor.getPhysical().init() self._addPhysicalActor(actor) ### Zones ### def updateZone(self, interval, world): """Update the objects in the zone""" # # Iterate through actors - use a list of the actors # in case the actor wants to update the list of # actors during this iteration for actor in list(self.actors): if actor.active: profiler.PROFILER.start(actor, 'updateActor') actor.updateActor(interval, world) profiler.PROFILER.end() # # Do physics if we need to if self._physics_objects: self.updatePhysics(interval) def wouldContain(self, actor): """Return True if this zone would contain the actor as it is right now The base Zone implementation uses spatial overlapping as the criteria but you can create custom zones that use other criteria to decide which actors should be in the zone. """ return self.isOverlapping(actor) def addActor(self, actor): """Add an actor to the zone""" if actor in self.actors: raise DuplicateActor('The actor %s is already in the zone' % actor) else: self.actors.add(actor) if actor.getPhysical(): self._addPhysicalActor(actor) def hasActor(self, actor): """Return True if the actor is in this zone""" return actor in self.actors def removeActor(self, actor): """Remove an actor from the zone""" try: self.actors.remove(actor) except KeyError: raise ActorNotFound('The actor %s was not in the zone' % actor) else: if actor in self._physics_objects: self._physics_objects.remove(actor) p = actor.getPhysical() # # The try-catch here is probably not required but if the game # is playing around with the physics space then it might # remove something without alerting the zone so we catch it # here. try: self.space.remove(p.body) if p.shape: self.space.remove(p.shape) except KeyError, err: self.log.error('Actor %s already removed from physics space' % actor.getNiceName())
class Zone(common.Loggable, geometry.Rectangle): """A zone A zone is part of a world. It is a container for objects and it controls whether objects will take part in world updates. """ my_properties = ( serialize.B('active', False, 'whether the zone is active'), serialize.L('actors', set(), 'the actors in this zone'), serialize.F('physics_stepsize', 10.0, 'the size of physics steps in ms'), serialize.L('global_force', (0, 0), 'the global force for physics'), ) def __init__(self): """Initialise the zone""" self.addLogger() self.physics_stepsize = 10.0 self.global_force = (0, 0) self.active = False self.setSpatial(-1000, -1000, 2000, 2000) self.clearActors() self._initPhysics() ### Serializing ### def init(self): """Initialise from serialized state""" self.addLogger() self.log.info('Initializing zone %s' % self) super(Zone, self).init() self._initPhysics() for actor in self.actors: actor.init() if actor.getPhysical(): actor.getPhysical().init() self._addPhysicalActor(actor) ### Zones ### def updateZone(self, interval, world): """Update the objects in the zone""" # # Iterate through actors - use a list of the actors # in case the actor wants to update the list of # actors during this iteration for actor in list(self.actors): if actor.active: actor.updateActor(interval, world) # # Do physics if we need to if self._physics_objects: self._updatePhysics(interval) def addActor(self, actor): """Add an actor to the zone""" if actor in self.actors: raise DuplicateActor('The actor %s is already in the zone' % actor) else: self.actors.add(actor) if actor.getPhysical(): self._addPhysicalActor(actor) def hasActor(self, actor): """Return True if the actor is in this zone""" return actor in self.actors def removeActor(self, actor): """Remove an actor from the zone""" try: self.actors.remove(actor) except KeyError: raise ActorNotFound('The actor %s was not in the zone' % actor) else: if actor in self._physics_objects: self._physics_objects.remove(actor) p = actor.getPhysical() self.space.remove(p.body, p.shape) def clearActors(self): """Remove all actors""" self.actors = set() ### Finding ### def findActorByName(self, name): """Return the actor with the given name""" for actor in self.actors: if actor.name == name: return actor else: raise ActorNotFound('Could not find actor "%s"' % name) def findActorsByTag(self, tag): """Return all the actors with a certain tag""" return [actor for actor in self.actors if actor.tag == tag] def findFirstActorByTag(self, tag): """Return the first actor found with the given tag or raise an error""" for actor in self.actors: if actor.tag == tag: return actor else: raise ActorNotFound('Could not find actor with tag "%s"' % tag) def getActors(self): """Return all the actors""" return self.actors ### Physics ### def _initPhysics(self): """Initialize the physics engine""" # # Pymunk may not be installed - if so then we skip creating any physics context if not common.PYMUNK_OK: self.log.info('No pymunk - physics disabled') self._physics_objects = [] return # # Create a context for the physics self.log.info('Initializing physics engine') self.space = pymunk.Space() self.space.add_collision_handler(2, 2, self._checkCollision, None, None, None) # # List of physics objects that we need to update self._physics_objects = [] self._shape_dict = {} def _checkCollision(self, space, arbiter): """Return True if the collision should occur""" s1, s2 = arbiter.shapes[0], arbiter.shapes[1] self._collisions.append((s1, s2)) return True def _addPhysicalActor(self, actor): """Add an actor with physics to the zone""" p = actor.getPhysical() p.space = self.space self.space.add(p.body, p.shape) self._shape_dict[p.shape] = actor self._physics_objects.append(actor) actor.syncPhysics() def _updatePhysics(self, interval): """Perform a step of the physics engine""" # # Globally applied forces self.space.gravity = self.global_force # # Do calculations self._collisions = [] while interval > 0.0: togo = min(self.physics_stepsize, interval) self.space.step(togo / 1000.0) interval -= togo # # Apply all the collisions for shape1, shape2 in self._collisions: actor1, actor2 = self._shape_dict[shape1], self._shape_dict[shape2] actor1.processEvent(('collision', actor2)) actor2.processEvent(('collision', actor1)) # # Now update all the tracked objects in world space for actor in self._physics_objects: p = actor.getPhysical() actor.moveTo(*p.shape.body.position, no_sync=True) p.velocity = tuple(p.shape.body.velocity) def setPhysicsStepsize(self, interval): """Set the maximum step size for physics calculations""" self.physics_stepsize = interval def setGlobalForce(self, force): """Set the global force for physics""" self.global_force = force
class PhysicalConditions(serialize.Serializable): """Represents physical parameters of an object This includes the mass, velocity, force applied, acceleration and the physical dimensions. """ my_properties = ( serialize.F('mass', 0.0, 'the mass of the object'), serialize.L('velocity', (0.0,0.0), 'the velocity of the object'), serialize.L('force', (0.0,0.0), 'the force on the object'), serialize.F('radius', 0.0, 'the radius of the object'), serialize.F('width', 0.0, 'the width of the object'), serialize.F('height', 0.0, 'the height of the object'), serialize.F('friction', 0.1, 'the friction the object'), serialize.F('elasticity', 1.0, 'the elasticity of the object'), serialize.I('layers', 0, 'the collision layers that we are in'), serialize.I('group', 0, 'the collision group that we are in'), serialize.B('fixed', False, 'whether the object is fixed in place'), serialize.B('update_angle', False, 'whether the rotation of the body should propagate to the actors visual'), serialize.B('visual_size', False, 'whether to set the size based on the visual element of our parent actor'), ) def __init__(self, mass=0.0, radius=0.0, velocity=(0.0, 0.0), force=(0.0, 0.0), width=0.0, height=0.0, fixed=False, friction=0.1, elasticity=1.0, group=0, layers=-1, update_angle=False, visual_size=False): """Initialise the conditions""" self.body = None if not mass and not fixed: raise InvalidMass('Mass must be specified unless the object is fixed in place') self.mass = mass if not fixed else pymunk.inf self.velocity = velocity self.force = force self.fixed = fixed self.friction = friction self.elasticity = elasticity self.update_angle = update_angle self.visual_size = visual_size self.group = group self.layers = layers self.space = None if not visual_size: self.setGeometry(radius, width, height) def init(self): """Initialize from serialized form""" super(PhysicalConditions, self).init() self.setGeometry(self.radius, self.width, self.height) self._createPhysicsObject() def setGeometry(self, radius=None, width=None, height=None): """Set the geometry You must specify either the radius or the width and height """ # # Reality check if radius and (width or height): raise InvalidDimensions('Must specify radius or width & height, not both') elif not radius and not (width and height): raise InvalidDimensions('Must specify width & height') # if radius: self.geometry_type = 'circle' else: self.geometry_type = 'rectangle' self.radius = radius self.width = width self.height = height self._createPhysicsObject() def _createPhysicsObject(self): """Return a new physics object""" if self.geometry_type == 'circle': inertia = pymunk.moment_for_circle(self.mass, 0, self.radius, (0,0)) else: inertia = pymunk.moment_for_box(self.mass, self.width, self.height) # body = pymunk.Body(self.mass, inertia) body.velocity = self.velocity body.force = self.force # if self.geometry_type == 'circle': shape = pymunk.Circle(body, self.radius, (0,0)) else: #shape = pymunk.Poly(body, [(0, 0), (self.width, 0), # (self.width, self.height), (0, self.height)]) w2, h2 = self.width/2, self.height/2 shape = pymunk.Poly(body, [(-w2,-h2), (+w2, -h2), (+w2, +h2), (-w2, +h2)]) # shape.elasticity = self.elasticity shape.collision_type = 2 shape.group = self.group shape.layers = self.layers shape.friction = self.friction self.shape = shape self.body = body def updateFrom(self, physical_conditions): """Update the properties and our physics object""" self.velocity = physical_conditions.velocity self.force = physical_conditions.force self.body.velocity = self.velocity self.body.force = self.force
class Zone(geometry.Rectangle, common.Loggable): """A zone A zone is part of a world. It is a container for objects and it controls whether objects will take part in world updates. """ my_properties = ( serialize.B('active', False, 'whether the zone is active'), serialize.L('actors', set(), 'the actors in this zone'), serialize.F('physics_stepsize', 10.0, 'the size of physics steps in ms'), serialize.L('global_force', (0,0), 'the global force for physics'), serialize.F('_rtf', 1.0, 'debugging aid to slow down physics'), ) def __init__(self): """Initialise the zone""" super(Zone, self).__init__() self.addLogger() self.physics_stepsize = 10.0 self.global_force = (0,0) self.active = False self.setSpatial(-1000, -1000, 2000, 2000) self.clearActors() self._initPhysics() self._rtf = 1.0 # A debugging aid to slow down physics ### Serializing ### def init(self): """Initialise from serialized state""" self.addLogger() self.log.info('Initializing zone %s' % self) super(Zone, self).init() self._initPhysics() for actor in self.actors: actor.init() if actor.getPhysical(): actor.getPhysical().init() self._addPhysicalActor(actor) ### Zones ### def updateZone(self, interval, world): """Update the objects in the zone""" # # Iterate through actors - use a list of the actors # in case the actor wants to update the list of # actors during this iteration for actor in list(self.actors): if actor.active: actor.updateActor(interval, world) # # Do physics if we need to if self._physics_objects: self.updatePhysics(interval) def wouldContain(self, actor): """Return True if this zone would contain the actor as it is right now The base Zone implementation uses spatial overlapping as the criteria but you can create custom zones that use other criteria to decide which actors should be in the zone. """ return self.isOverlapping(actor) def addActor(self, actor): """Add an actor to the zone""" if actor in self.actors: raise DuplicateActor('The actor %s is already in the zone' % actor) else: self.actors.add(actor) if actor.getPhysical(): self._addPhysicalActor(actor) def hasActor(self, actor): """Return True if the actor is in this zone""" return actor in self.actors def removeActor(self, actor): """Remove an actor from the zone""" try: self.actors.remove(actor) except KeyError: raise ActorNotFound('The actor %s was not in the zone' % actor) else: if actor in self._physics_objects: self._physics_objects.remove(actor) p = actor.getPhysical() self.space.remove(p.body) if p.shape: self.space.remove(p.shape) def clearActors(self): """Remove all actors""" self.actors = set() ### Finding ### def findActorByName(self, name): """Return the actor with the given name""" for actor in self.actors: if actor.name == name: return actor else: raise ActorNotFound('Could not find actor "%s"' % name) def findActorsByTag(self, tag): """Return all the actors with a certain tag""" return [actor for actor in self.actors if actor.tag == tag] def findFirstActorByTag(self, tag): """Return the first actor found with the given tag or raise an error""" for actor in self.actors: if actor.tag == tag: return actor else: raise ActorNotFound('Could not find actor with tag "%s"' % tag) def getActors(self): """Return all the actors""" return self.actors ### Physics ### def _initPhysics(self): """Initialize the physics engine""" # # Pymunk may not be installed - if so then we skip creating any physics context if not common.PYMUNK_OK: self.log.debug('No pymunk - physics disabled') self._physics_objects = [] return # # Create a context for the physics self.log.debug('Initializing physics engine with %d iterations' % PHYSICS_ITERATIONS) self.space = pymunk.Space(PHYSICS_ITERATIONS) self.space.add_collision_handler(2, 2, self._checkCollision, None, None, None) # # List of physics objects that we need to update self._physics_objects = [] self._shape_dict = {} def _checkCollision(self, space, arbiter): """Return True if the collision should occur""" s1, s2 = arbiter.shapes[0], arbiter.shapes[1] self._collisions.append((s1, s2)) return True def _addPhysicalActor(self, actor): """Add an actor with physics to the zone""" p = actor.getPhysical() p.space = self.space if p.shape: self.space.add(p.body, p.shape) self._shape_dict[p.shape] = actor else: self.space.add(p.body) self._physics_objects.append(actor) actor.syncPhysics() def updatePhysics(self, interval): """Perform a step of the physics engine You do not normally need to call this method as it is called by the updateZone method. You may call this to advance the physics simulation along without affecting other game elements. """ # # Globally applied forces self.space.gravity = self.global_force # # Do calculations self._collisions = [] while interval > 0.0: togo = min(self.physics_stepsize, interval) self.space.step(togo/1000.0*self._rtf) # rtf is a debugging aid to go into slow motion mode interval -= togo # # Apply all the collisions for shape1, shape2 in self._collisions: actor1, actor2 = self._shape_dict[shape1], self._shape_dict[shape2] actor1.processEvent(('collision', actor2)) actor2.processEvent(('collision', actor1)) # # Now update all the tracked objects in world space for actor in self._physics_objects: p = actor.getPhysical() actor.moveTo(*p.body.position, no_sync=True, override_lock=True) p.velocity = tuple(p.body.velocity) if p.update_angle: actor.setAngle(-math.degrees(p.body.angle), override_lock=True) def setPhysicsStepsize(self, interval): """Set the maximum step size for physics calculations""" self.physics_stepsize = interval def setGlobalForce(self, force): """Set the global force for physics""" self.global_force = force def sleepActor(self, actor): """Tell the actor to go to sleep from a physics perspective The actor will still be visible and will still be updated but it will not update its physics. Useful for optimising when an actor does not need to interact with the physics simulation for a while. """ actor.getPhysical().body.sleep() def wakeActor(self, actor): """Tell the actor to go to wake up from a physics perspective An actor that was put to sleep (via sleepActor) will be woken up and take part in the physics simulation again. """ actor.getPhysical().body.activate()
class Actor(common.Loggable, geometry.Rectangle, common.EventAware): """Represents an actor""" my_properties = ( serialize.S('tag', 'actor', 'the actor\'s tag'), serialize.S('name', '', 'the actor\'s name'), serialize.B('active', True, 'whether the actor is active'), serialize.S('sprite', '', 'the name of our sprite'), serialize.S('layer', '', 'the name of the layer we render to'), serialize.O('physical_conditions', '', 'the physical conditions for this object'), serialize.F('angle', 0.0, 'the angle for the actor'), ) def __init__(self, tag, name=''): """Initialise the actor""" self.addLogger() self.initEvents() super(Actor, self).__init__() # Whether we respond to updates or not self.active = True # Class based tag to locate the actor by self.tag = tag # Unique name to locate by self.name = name # Our sprite self.sprite = '' self._visual = None # The layer we render to self.layer = '' # Our zoom factor self.zoom = 1.0 # Physics parameters - None means no physics self.physical_conditions = None # Angle self.angle = 0.0 def init(self): """Initialize from serialized form""" self.addLogger() self.initEvents() self.log.info('Initializing actor %s:%s:%s' % (self, self.tag, self.name)) super(Actor, self).init() if self.sprite: self.setSpriteName(self.sprite) else: self._visual = None self.setLayerName(self.layer) self.zoom = 1.0 def getNiceName(self): """Return a nice name for this actor""" if self.name: name_part = '%s (%s)' % (self.name, self.tag) else: name_part = self.tag return '%s [%s] <%s>' % (self.__class__.__name__, name_part, id(self)) def setSpriteName(self, name): """Set the sprite for this actor""" self.visual = visual.Register.getItem(name).getCopy() self.sprite = name @property def visual(self): return self._visual @visual.setter def visual(self, value): """Set the visual item for this actor""" self._visual = value self._resetVisual() def _resetVisual(self): """Reset the visual item on the center point""" # # Adjust our location so that we are positioned and sized appropriately cx, cy, _, _ = self.getSpatialCentered() self.setSpatialCentered(cx, cy, self._visual.width, self._visual.height) # # Here is a hack - sometimes the visual width changes and we want to update our width # so we let the visual know about us so it can update our width. This is almost # certainly the wrong thing to do, but we have some tests in there so hopefully # the right thing becomes obvious later! self._visual._actor_parent = self def getSpriteName(self): """Return our sprite""" return self.sprite def setAsText(self, text_object): """Set some text as our visual""" self.visual = text_object def setText(self, text): """Set the actual text""" self._visual.setText(text) def setLayerName(self, name): """Set the layer that we render to""" self.layer = name def getLayerName(self): """Return our layer name""" return self.layer def renderTo(self, renderer, interval): """Render ourself to the given renderer""" if self._visual: coords = renderer.camera.getRelativeLocation(self) if self.layer: self._visual.renderTo(interval, renderer.getLayer(self.layer).getSurface(), coords) def updateActor(self, interval, world): """Update the actor status""" def removedFromWorld(self, world): """Called when we are being removed from the world""" self.processEvent((events.E_REMOVED_FROM_WORLD, self)) def addedToWorld(self, world): """Called when we are being added to the world""" self.processEvent((events.E_ADDED_TO_WORLD, self)) def setZoom(self, zoom): """Zoom in on this actor""" if self._visual: self._visual.scaleBy(zoom/self.zoom) self.zoom = zoom def setAngle(self, angle, sync_physical=False): """Set the angle for the visual""" if self._visual: self._visual.setAngle(angle) self._resetVisual() if sync_physical and self.physical_conditions: self.physical_conditions.body.angle = math.radians(-angle) self.angle = angle def getAngle(self): """Return the angle for the actor""" return self.angle ### Physics ### def setPhysical(self, physical_conditions): """Set the physical conditions""" # # Watch for if this object already has a shape if self.physical_conditions and self.physical_conditions.body: self.physical_conditions.updateFrom(physical_conditions) else: self.physical_conditions = physical_conditions def getPhysical(self): """Return the physical conditions""" return self.physical_conditions def syncPhysics(self, spatial_only=False): """Sync physics when the actors physical properties have been changed""" if self.physical_conditions: #self.log.debug('Syncing physics for %s to %s, %s' % (self.getNiceName(), self.x, self.y)) self.physical_conditions.shape.body.position = self.x, self.y if not spatial_only: self.physical_conditions.shape.body.velocity = self.physical_conditions.velocity # Remap x, y properties to allow syncing with the physics engine def move(self, x, y): """Move by a certain amount""" super(Actor, self).move(x, y) self.syncPhysics(spatial_only=True) def moveTo(self, x, y, no_sync=False): """Move to a certain place""" super(Actor, self).moveTo(x, y) if not no_sync: self.syncPhysics(spatial_only=True)