Actors

Contents

• Actors
  • Actor
  • CompositeActor
  • AbstractMountableActor
  • MountableActor
  • PhysicallyMountableActor
  • ActorCollection

Actor

class serge.actor.Actor(tag, name='')

Bases: serge.common.Loggable, serge.geometry.Rectangle, serge.common.EventAware

Represents an actor

addedToWorld(world)

Called when we are being added to the world

getAngle()

Return the angle for the actor

getLayerName()

Return our layer name

getNiceName()

Return a nice name for this actor

getPhysical()

Return the physical conditions

getRenderingOrder()

Return the rendering order

getSpriteName()

Return our sprite

init()

Initialize from serialized form

move(x, y)

Move by a certain amount

moveTo(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.

removedFromWorld(world)

Called when we are being removed from the world

renderTo(renderer, interval)

Render this actor to the given renderer

setAngle(angle, sync_physical=False, override_lock=False)

Set the angle for the visual

setLayerName(name)

Set the layer that we render to

setPhysical(physical_conditions)

Set the physical conditions

setRenderingOrder(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.

setSpriteName(name)

Set the sprite for this actor

setZoom(zoom)

Zoom in on this actor

syncPhysics(spatial_only=False)

Sync physics when the actors physical properties have been changed

updateActor(interval, world)

Update the actor status

CompositeActor

class serge.actor.CompositeActor(*args, **kw)

Bases: serge.actor.Actor

An actor that can have children, which are also actors

World operations on the parent, like adding and removing, will also apply to the children.

If the children are removed from the parent then they are also removed from the world.

addChild(actor)

Add a child actor

addedToWorld(world)

Called when we are being added to the world

getChildren()

Return the list of children

getChildrenWithTag(tag)

Return all the children with a certain tag

hasChild(actor)

Return True if this actor already has this actor as a child

hasChildren()

Return True if this actor has children

removeChild(actor, leave_in_world=False)

Remove a child actor

removeChildren()

Remove all the children

removedFromWorld(world)

Called when we are being removed from the world

AbstractMountableActor

class serge.actor.AbstractMountableActor(*args, **kw)

Bases: serge.actor.CompositeActor

An base class for actors that you can mount other actors to

The other actors are located at a certain position relative to the position of this actor. You can use this actor to create clusters either visually or functionally.

mountActor()

Mount the actor with the given offset

If original_rotation is True then the mount offset is taken as working against the original rotation (ie angle = 0) of the actor.

If rotate_with_actor is set to False then this actor will not rotate with the parent actor, it will just move.

unmountActor(actor)

Unmount the actor

MountableActor

class serge.actor.MountableActor(*args, **kw)

Bases: serge.actor.AbstractMountableActor

An actor that you can mount other actors to

The other actors are located at a certain position relative to the position of this actor. You can use this actor to create clusters either visually or functionally.

moveTo(x, y, no_sync=False, override_lock=False)

Move this actor

setAngle(angle, sync_physical=False, override_lock=False)

Set the angle for the visual

PhysicallyMountableActor

class serge.actor.PhysicallyMountableActor(tag, name='', mass=0.0, **kw)

Bases: serge.actor.AbstractMountableActor

An physical actor that you can mount other physical actors to

The other actors are located at a certain position relative to the position of this actor. You can use this actor to create clusters either visually or functionally.

All actors must be under the control of the physics engine.

addedToWorld(world)

The actor was added to the world

init()

Initialise from serialized form

mountActor()

Mount the actor with the given offset

moveTo(x, y, no_sync=False, override_lock=False)

Move this actor

setAngle(angle, sync_physical=False, override_lock=False)

Set the angle for the visual

unmountActor(actor)

Unmount the actor

ActorCollection

class serge.actor.ActorCollection

Bases: list

A list of actors

This class implements some useful methods which help to handle collections of actors.

findActorByName(name)

Return then actor with the given name

findActorsByTag(tag)

Return a collection of actors with the given tag

findActorsByTags(tags)

Return a collection of actors with at least one of the tags

forEach()

Returns an object suitable for mapping method calls to all the actors in the collection

Use this like,

collection.forEach().setAngle(12)

hasActor(actor)

Return True if we have that actor

hasActorWithName(name)

Return True if the collection contains an actor with the given name

hasActorWithTag(tag)

Return True if the collection contains an actor with the given tag

numberOfActorsWithName(name)

Return the number of actors with the given name

numberOfActorsWithTag(tag)

Return the number of actors with the given tag