6. Spygame API Reference Documentation

6.1. Core API

class spygame.AABBCollision

Bases: spygame.CollisionAlgorithm

A simple axis-aligned bounding-box collision mechanism which only works on Pygame rects.

static collide(sprite1, sprite2, collision_objects=None, direction=’x’, direction_veloc=0.0, original_pos=None)

static try_collide(o1, o2, collision_obj, direction, direction_veloc)

does the actual AABB collision test

Parameters:

• o1 (Sprite) – object 1
• o2 (Sprite) – object 2
• collision_obj (Collision) – the collision object to be populated
• direction (str) – the direction in which we have to measure a collision (x or y)
• direction_veloc (float) – the velocity value in the given x- or y-direction

Returns:

the populated Collision object

Return type:

Collision

class spygame.AIBrain(name=’brain’, commands=None)

Bases: spygame.AnimationLinkedBrain

An AnimationLinkedBrain that can handle simple left/right logic for 2D platformer monsters. The brain will take care of avoiding cliffs, but other than that always just walk from left to right and back. Overwrite this to implement more complex behaviors in the tick method.

added()

bumped(col)

check_cliff_ahead()

Checks whether there is a cliff ahead (returns true if yes).

check_enemy_ahead()

tick(game_loop)

Needs to be called by the GameObject at some point during the GameObject’s tick method.

Parameters:game_loop (GameLoop) – the currently playing GameLoop object

toggle_direction()

Changes the current direction (left to right or vice-versa)

class spygame.AnimatedSprite(x, y, sprite_sheet, animation_setup, **kwargs)

Bases: spygame.Sprite

Adds an Animation component to each Sprite instance. AnimatedSprites need a SpriteSheet (no static images or no-render allowed).

Parameters:

• x (int) – the initial x position of the Sprite
• y (int) – the initial y position of the Sprite
• spritesheet (SpriteSheet) – the SpriteSheet object to use for this Sprite
• animation_setup (dict) – the dictionary with the animation setup data to be sent to Animation.register_settings (the name of the registry record will be kwargs[“anim_settings_name”] OR spritesheet.name)

class spygame.Animation(name)

Bases: spygame.Component

A Component that takes care of setting the image property of its owning Sprite object based on so-called “animation settings”. Animation settings are stored in a global registry under the name of the SpriteSheet object that holds the images that belong to the animation setting. The tick method has to be called by the Sprite’s tick method in order for the Sprite’s image to be changed on each tick.

added()

animation_flags = {‘none’: 0, ‘manual’: 1, ‘all’: 65535}

animation_settings = {}

blink_animation(game_object, rate=3.0, duration=3.0)

Blinks the GameObject with the given parameters.

Parameters:

• game_object (GameObject) – our GameObject to which blinking is applied
• rate (float) – the rate with which to blink (in 1/s)
• duration (float) – the duration of the blinking (in s); after the duration, the blinking stops

static get_flag(flags)

Returns the bitmap code for an already existing Animation flag or for a new flag (the code will be created then). Flags are usually used to tell a Brain Component or the character directly what effects the animation has.

Parameters:flags (str) – the flag(s) (comma-separated), whose code(s) should be returned Returns:the flag as an int; if many flags are given, returns a bitmask with all those bits set that represent the given flags Return type:int

static get_settings(spritesheet_name, anim_setting)

next_flag = 2

play_animation(game_object, name, priority=0)

Plays an animation on our GameObject.

Parameters:

• game_object (GameObject) – the GameObject on which to play the animation; the animation has to be setup via register_settings with the name of the SpriteSheet of the GameObject
• name (str) – the name of the animation to play
• priority (int) – the priority with which to play this animation (if this method is called multiple times, it will pick the higher one)

static register_settings(settings_name, settings, register_events_on=None)

tick(game_loop)

Needs to be called by the GameObject at some point during the GameObject’s tick method.

Parameters:game_loop (GameLoop) – the GameLoop that’s currently playing

class spygame.AnimationLinkedBrain(name=’brain’, commands=None)

Bases: spygame.Brain

A Brain that is linked to an Animation component and can thus subscribe to events triggered by that Component.

added()

class spygame.Autobuild(x, y, w, h, tile_w, tile_h)

Bases: object

Mix-in class to force x, y, width, height structure of ctors. All autobuild objects (objects that are built automatically by a TiledTileLayer with the property autobuild_objects=true) will have to abode to this ctor parameter structure.

class spygame.Brain(name=’brain’, commands=None)

Bases: spygame.Component

A generic Brain class that has a command dict for other classes to be able to look up what the brain currently wants. Also has a main-switch to activate/deactivate the Brain. Should implement tick method and set self.commands each tick.

activate()

Makes this Brain active: we will react to the GameLoop’s keyboard events.

deactivate()

Makes this Brain inactive: we will not(!) react to the GameLoop’s keyboard events (no exceptions).

reset()

Sets all commands to False.

tick(game_loop)

Needs to be called by the GameObject at some point during the GameObject’s tick method.

Parameters:game_loop (GameLoop) – the currently playing GameLoop object

class spygame.Collision

Bases: object

A simple feature object that stores collision properties for collisions between two objects or between an object and a TiledTileLayer.

invert()

Inverts this Collision in place to yield the Collision for the case that the two Sprites are switched.

class spygame.CollisionAlgorithm

Bases: object

A static class that is used to store a collision algorithm.

static collide(sprite1, sprite2, collision_objects=None, original_pos=None)

solves a simple spatial collision problem for two Sprites (that have a rect property) - defaults to SAT collision between two objects - thanks to doc’s at: http://www.sevenson.com.au/actionscript/sat/ - TODO: handle angles on objects - TODO: handle velocities of sprites prior to collision to calculate correct normals

Parameters:

• sprite1 (Sprite) – sprite 1
• sprite2 (Sprite) – sprite 2 (the other sprite)
• collision_objects (Union[None,Tuple[Collision]]) – the two always-recycled returnable Collision instances (aside from None); if None, use our default ones
• original_pos (Union[Tuple[int],None]) – the position of sprite1 before doing the move that lead to this collision-detection call

Returns:

a Collision object with all details of the collision between the two Sprites (None if there is no collision)

Return type:

Union[None,Collision]

default_collision_objects = (<spygame.Collision object>, <spygame.Collision object>)

class spygame.Component(name)

Bases: spygame.GameObject

A Component can be added to and removed from other GameObjects. Use “extend” to make a Component’s method be callable directly from the owning GameObject.

Parameters:name (str) – the name of the component (the name can be used to retrieve any GameObject’s components via the [GameObject].components dict)

added()

Gets called when the component is added to a GameObject.

extend(method)

Extends the given method (has to take self as 1st param) onto the GameObject, so that this method can be called directly from the GameObject. The extended method will take two self’s (0=Component, 1=GameObject), thus selfs should be called ‘comp’ and ‘game_object’ OR ‘self’ and ‘game_object’

Parameters:method (callable) – method, which to make callable from within the owning GameObject

removed()

Gets called when the component is removed from a GameObject.

class spygame.ControlledPhysicsComponent(name=’physics’)

Bases: spygame.PhysicsComponent

When added to a GameObject, checks for an existing Brain Component and creates a property (self.game_obj_cmp_brain) for easy access.

added()

class spygame.Display(width=600, height=400, title=’Spygame Rocks!’)

Bases: object

A simple wrapper class for a pygame.display/pygame.Surface object representing the pygame display. Also stores offset information for Viewport focusing (if Viewport is smaller that the Level, which is usually the case).

change_dims(width, height)

Changes the Display’s size dynamically (during the game).

Parameters:

• width (int) – the new width to use
• height (int) – the new height to use

debug_refresh()

Force-refreshes the display (used only for debug purposes).

instantiated = False

class spygame.Dockable(name=’dockable’)

Bases: spygame.Component

A dockable component allows 1) for Sprites to dock to a so-called “mother_ship” and b) for Sprites to become “mother_ships” themselves (other Sprites can dock to this Sprite). Sprites that are docked to our mother_ship (this Component’s Sprite) will be moved along with it when they stand on top.

DEFINITELY_DOCKED = 1

DEFINITELY_NOT_DOCKED = 2

PREVIOUSLY_DOCKED = 8

TO_BE_DETERMINED = 4

added()

dock_to(mother_ship)

A sprite lands on an elevator -> couple the elevator to the sprite so that when the elevator moves, the sprite moves along with it. Only possible to dock to dockable-type objects.

Parameters:mother_ship (Sprite) – the Sprite to dock to (Sprite needs to have a dockable component)

is_docked()

Returns:True if the current state is definitely docked OR (to-be-determined AND previous state was docked) Return type:bool

move(sprite, x, y, absolute=False)

This will ‘overwrite’ the normal Sprite’s move method by Component’s extend.

Parameters:

• sprite (Sprite) – the GameObject that this Component belongs to (the Sprite to move around)
• x (Union[int,None]) – the amount in pixels to move in x-direction
• y (Union[int,None]) – the amount in pixels to move in y-direction
• absolute (bool) – whether x and y are given as absolute coordinates (default: False): in this case x/y=None means do not move in this dimension

state_unsure()

Returns:True if our current docking state is not 100% sure (TO_BE_DETERMINED) Return type:bool

to_determine()

Changes our docking state to be undetermined (saves the current state as PREVIOUS flag).

undock()

Undocks itself from the mothership.

undock_all_docked_objects()

undocks all objects currently docked to this object

class spygame.Elevator(x, y, direction=’y’, initial_veloc=50, max_pos=500, min_pos=0)

Bases: spygame.Sprite

A simple elevator/moving platform class. Can either go in x or in y direction, with a configurable speed and in between settable coordinate values. Has a Dockable Component to be able to carry characters standing on top of it. Is of type one_way_platform so one can jump on the Elevator also from below it.

tick(game_loop)

Moving elevator up and down OR left and right.

class spygame.EventObject

Bases: object

An EventObject introduces event handling and most objects that occur in spygame games will inherit from this class. NOTE: spygame events are not(!) pygame events. EventObject can ‘have’ some events, which are simple strings (the names of the events, e.g. ‘hit’, ‘jump’, ‘collided’, etc..). EventObject can trigger any event by their name. If an EventObject wants to trigger an event, this event must have been registered with the EventObject beforehand (will raise exception otherwise).

check_event(event: str)

Checks whether the given event is in this EventObject’s registry (raises exception if not).

Parameters:event (str) – the event to be checked

debind_events()

Called to remove any listeners from this object. E.g. when this object is destroyed you’ll want all the event listeners to be removed from this object.

off_event(event, target=None, callback=None, unregister=False)

Unbinds an event from a target/callback. Can be called with 1, 2, or 3 parameters, each of which unbinds a more specific listener.

Parameters:

• event (str) – the name of the event to unbind from the callback
• target (EventObject) – the target EventObject to unbind this event from (callback would be a member of this target)
• callback (callable) – the callback to unbind the event from
• unregister (bool) – whether we should unregister this event as well

on_event(event, target=None, callback=None, register=False)

Binds a callback to an event on this EventObject. If you provide a target object, that object will add this event to it’s list of binds, allowing it to automatically remove it when it is destroyed. From here on, if the event gets triggered, the callback will be called on the target object. Note: Only previously registered events may be triggered (we can register the event here by setting register=True).

Parameters:

• event (Union[str,List[str]]) – the name of the event to be bound to the callback (e.g. tick, got_hit, etc..)
• (EventObject) (target) – The target object on which to call the callback (defaults to self if not given)
• callback (callable) – the bound method to call on target if the event gets triggered
• register (bool) – whether we should register this event right now (only registered events are allowed to be triggered later)

register_event(*events)

registers a possible event (str) with this object; only registered events are allowed to be triggered later

Parameters:events (str) – the event (or events) that should be registered

trigger_event(event, *params)

Triggers an event and specifies the parameters to be passed to the bound event handlers (callbacks) as *params.

Parameters:

• event (str) – the name of the event that should be triggered; note: this event name will have to be registered with the EventObject in order for the trigger to succeed
• params (any) – the parameters to be passed to the handler methods as *args

unregister_event(*events)

Removes one or more events from this EventObject’s event registry; unregistered events are no longer allowed to be triggered.

Parameters:events (str) – the event(s) that should be removed from the registry

unregister_events()

Unregisters all events from this GameObject (see ‘unregister_event’).

class spygame.Game(screens_and_levels, width=0, height=0, title=’spygame Demo!’, max_fps=60, debug_flags=0)

Bases: object

An object that serves as a container for Screen and Level objects. Manages displaying the screens (start screen, menus, etc..) and playable levels of the game. Also keeps a Display object (and determines its size), which is used for rendering and displaying the game.

get_next_level(level)

returns the next level (if exists) as object; None if no next level

Parameters:level (Level) – the Level, whose next Level we would like to get Returns:the next Level after level; None if no next Level exists Return type:Union[Level,None]

instantiated = False

level_aborted(level)

aborts the level and tries to play the “start” screen

Parameters:level (Level) – the Level object that has been aborted

level_lost(level)

a level has been lost

Parameters:level (Level) – the Level object in which the loss happened

level_mastered(level)

a level has been successfully finished -> play next one

Parameters:level (Level) – the Level object that has been mastered

class spygame.GameLoop(callback, display, keyboard_inputs=None, max_fps=60)

Bases: object

Class that represents the GameLoop. Has play and pause functions: play starts the tick/callback loop. Has clock for ticking (keeps track of self.dt each tick), handles and abides to max-fps rate setting. Handles keyboard input registrations via its KeyboardInputs object. Needs a callback to know what to do each tick. Tick method does keyboard_inputs.tick, then calls the given callback with self as only argument.

active_loop = None

pause()

Pauses this GameLoop.

play(max_fps=None)

Plays this GameLoop (after pausing the currently running GameLoop, if any).

static play_a_loop(**kwargs)

Factory: plays a given GameLoop object or creates a new one using the given **kwargs options.

Parameters:kwargs (any) –

• force_loop (bool): whether to play regardless of whether we still have some active loop running
• callback (callable): the GameLoop’s callback loop function
• keyboard_inputs (KeyboardInputs): the GameLoop’s KeyboardInputs object
• display (Display): the Display object to render everything on
• max_fps (int): the max frames per second to loop through
• screen_obj (Screen): alternatively, a Screen can be given, from which we will extract display, max_fps and keyboard_inputs
• game_loop (Union[str,GameLoop]): the GameLoop to use (instead of creating a new one); “new” or [empty] for new one
• dont_play (bool): whether - after creating the GameLoop - it should be played. Can be used for openAI gym purposes, where we just step, not tick

Returns:the created/played GameLoop object or None Return type:Union[GameLoop,None]

step(action)

(!)for reinforcement learning only(!) WIP: Executes one action on the game. The action gets translated into a keyboard sequence first, then is played.

Parameters:action (str) – the action to execute on the MDP

tick(max_fps=None)

Called each frame of the GameLoop. Collects keyboard events. Calls the GameLoop’s callback. Keeps a frame counter.

Parameters:max_fps (int) – the maximum allowed number of frames per second (usually 60)

class spygame.GameObject

Bases: spygame.EventObject

A GameObject adds the capability to add one or more Component objects to the GameObject (e.g. animation, physics, etc..). Component objects are stored by their name in the GameObject.components dict.

add_component(component)

Adds a component object to this GameObject -> calls the component’s added method.

Parameters:component (Component) – component to be added to GameObject under game_obj.components[component.name] Returns:the same Component for chaining Return type:Component

destroy()

Destroys the GameObject by calling debind and removing the object from it’s parent. Will trigger a destroyed event (callback).

id_to_obj = {0: <Sprite sprite(in 0 groups)>}

next_id = 1

remove_component(component)

Removes the given component from this GameObject.

Parameters:component (Component) – the Component object to be removed

tick(game_loop)

A tick (coming from the GameObject containing Stage). Override this if you want your GameObject to do something each frame.

Parameters:game_loop (GameLoop) – the GameLoop that’s currently playing

class spygame.HumanPlayerBrain(name=’brain’, key_brain_translations=None)

Bases: spygame.AnimationLinkedBrain

An AnimationLinkedBrain that handles agent control (via the GameLoop´s keyboard registry). Supports special keyboard->command translations (e.g. key down -> command A for one tick; key up -> command B for one tick).

add_translations(key_brain_translations)

Adds a single or more KeyboardBrainTranslation object to our dict.

Parameters:key_brain_translations (Union[KeyboardBrainTranslation,str,dict,tuple]) – the keyboard-to-command translation to be added to this Brain (can be represented in different ways; see code)

added()

anim_ends(anim, anim_new)

remove_translation(key)

Adds a single KeyboardBrainTranslation object to our dict.

Parameters:key (str) – the key (str) to be removed from our key-to-command translation dict

tick(game_loop: spygame.GameLoop)

Needs to be called by the GameObject at some point during the GameObject’s tick method. Translates all keys from the GameLoops’s KeyboardInputs object into our command dict.

Parameters:game_loop (GameLoop) – the currently playing GameLoop object

class spygame.KeyboardBrainTranslation(key, command, flags=0, other_command=None, animation_to_complete=None)

Bases: object

A class to represent a relationship between a pressed key and a command (or two commands) The normal relationship is: [some key]: when pressed -> [command] is True; when not pressed -> [command] is False But other, more complex relationships are supported as well.

BLOCK_OTHER_CMD_UNTIL_ANIM_COMPLETE = 8

BLOCK_REPEAT_UNTIL_ANIM_COMPLETE = 4

DOWN_ONE_TICK = 1

NORMAL = 0

STATE_CHARGING = 1

STATE_CMD_RECEIVED = 4

STATE_FULLY_CHARGED = 2

STATE_NONE = 0

UP_ONE_TICK = 2

class spygame.KeyboardInputs(key_list=None)

Bases: spygame.EventObject

A class to handle keyboard inputs by the user playing the spygame game. A KeyboardInput object is passed to the GameLoop c’tor, so that the GameLoop can tick the KeyboardInput object each frame. Single keys to watch out for can be registered via the update_keys method (not registered keys will be ignored). The tick method collects all keydown/keyup pygame events and stores the currently registered keys in the keyboard_registry as True (currently pressed) or False (currently not pressed). All keys are described by their pygame names (without the leading K_), e.g. pygame.K_UP=`up`, pygame.K_ESCAPE=`escape`, etc..

tick()

Pulls all keyboard events from the event queue and processes them according to our keyboard_registry/descriptions. Triggers events for all registered keys like: ‘key_down.[desc]’ (when pressed) and ‘key_up.[desc]’ (when released), where desc is the lowercase string after pygame.K_… (e.g. ‘down’, ‘up’, etc..).

update_keys(new_key_list=None)

Populates our registry and other dicts with the new key-list given (may be an empty list).

Parameters:new_key_list (Union[List,None]) – the new key list, where each item is the lower-case pygame keycode without the leading K_ e.g. up for pygame.K_UP; use None for clearing out the registry (no keys assigned)

class spygame.Ladder(x, y, w, h, tile_w, tile_h)

Bases: spygame.Sprite, spygame.Autobuild

A Ladder object that actors can climb on. One-way-platform type: one cannot fall through the top of the ladder but does not collide with the rest (e.g. from below) of the ladder. A Ladder object does not have an image and is thus not(!) being rendered; the image of the ladder has to be integrated into a rendered TiledTileLayer. TiledTileLayers have the possibility to generate Ladder objects automatically from those tiles that are flagged with the type=’ladder’ property. In that case, the TiledTileLayer property ‘build_ladders’ (bool) has to be set to true.

class spygame.Level(name: str = ‘test’, **kwargs)

Bases: spygame.Screen

A Level class adds tmx file support to the Screen. TiledTileLayers (background, collision, foreground, etc..) as well as single Sprite objects can be defined in the tmx file.

done()

play()

Start level (stage the scene; will overwrite the old 0-stage (=main-stage)). The options-object below will be also stored in [Stage object].options. Child Level classes only need to do these three things: a) stage a screen, b) register some possible events, c) play a new game loop.

static screen_func(stage)

Sets up the Stage by adding all layers (one-by-one) from the tmx file to the Stage.

Parameters:stage (Stage) –

class spygame.LiquidBody(x, y, w, h, tile_w, tile_h, description=’quicksand’)

Bases: spygame.Sprite, spygame.Autobuild

A LiquidBody object (quicksand, water, etc..) that an actor will sink into and die. The AIBrain of enemies will avoid stepping into such an object.

class spygame.MovableRock(x, y, **kwargs)

Bases: spygame.Sprite

land(*args)

tick(game_loop)

class spygame.PhysicsComponent(name)

Bases: spygame.Component

Defines an abstract generic physics component that can be added to agents (or enemies) to behave in the world. GameObject’s that own this Comonent may have a Brain component as well in order to steer behavior of the agent in tick. Needs to override tick and collision.

added()

collision(col)

This is the resolver for a Collision that happened between two Sprites under this PhysicsComponent.

Parameters:col (Collision) – the Collision object describing the collision that already happened between two sprites

tick(game_loop: spygame.GameLoop)

Needs to be called by the GameObject at some point during the GameObject’s tick method.

Parameters:game_loop (GameLoop) – the currently playing GameLoop object

static tile_sprite_handler(tile_sprite_class, layer)

Populates the tile_sprites dict of a TiledTileLayer with tile_sprite_class (e.g. TileSprite or SlopedTileSprite) objects.

Parameters:

• layer (TiledTileLayer) – the TiledTileLayer, whose tiles we would like to process and store (each one) in the returned np.ndarray
• tile_sprite_class (type) – the TiledSprite subclass to use for generating TileSprite objects

Returns:

a 2D np.ndarray (x,y) with the created TileSprite objects for each x/y coordinate (None if there is no tile at a position)

Return type:

np.ndarray (2D)

class spygame.PlatformerPhysics(name=’physics’)

Bases: spygame.ControlledPhysicsComponent

Defines “The Lost Vikings”-like game physics. Supports: Running over sloped tiles, jumping, ladders, moving platforms and elevators, pushable heavy rocks, one-way-platforms To be addable to any character (player or enemy) or thing (e.g. a pushable rock)

added()

collide_in_one_direction(sprite, direction, direction_veloc, original_pos)

Detects and solves all possible collisions between our GameObject and all Stage’s objects (layers and Sprites) in one direction (x or y).

Parameters:

• sprite (Sprite) – the GameObject of this Component (the moving/colliding Sprite)
• direction (str) – either “x” or “y”
• direction_veloc (float) – the velocity in the given direction (x/y-component of the velocity vector)
• original_pos (Tuple[int,int]) – the position of the game_object before this collision detection execution

collide_with_collision_layer(sprite, layer, direction, direction_veloc, original_pos)

Collides a Sprite with a collision TiledTileLayer (type==default) and solves all detected collisions. Supports slopes of all shapes (given y = mx + b parameterized). Certain restrictions apply for the tiled landscape for this algorithm to work: - no upside-down slopes allowed (slopes on the ceiling) - TODO: what other restrictions?

Parameters:

• sprite (Sprite) – the Sprite to test for collisions against a TiledTileLayer
• layer (TiledTileLayer) – the TiledTileLayer object in which to look for collision tiles (full of sloped)
• direction (str) – x or y direction in which the sprite is currently moving before this test
• direction_veloc (float) – the velocity in the given direction (could be negative or positive)
• original_pos (Tuple[int,int]) – the position of the sprite before the move that caused this collision test to be executed

collision(col)

Gets called (via event trigger ‘collision’ (setup when this component is added to our GameObject)) when a collision is detected (e.g. by a layer).

Parameters:col (Collision) – the collision object of the detected collision (the first sprite in that Collision object must be our GameObject)

static get_highest_tile(tiles, direction, start_abs, end_abs)

Returns the highest tile in a list (row or column) of sloped, full-collision or empty tiles.

Parameters:

• tiles (list) – the list of tiles to check
• direction (str) – the direction in which the list of tiles is arranged (x=row of tiles or y=column of tiles)
• start_abs (int) – the absolute leftmost x-value from where to check
• end_abs (int) – the absolute rightmost x-value from where to check

Returns:

a tuple consisting of a) the highest SlopedTileSprite found in the list and b) the height value measured on a cartesian y-axis (positive=up)

Return type:

Tuple[SlopedTileSprite,int]

lock_ladder()

Locks the GameObject into a ladder. Makes sure that there is nothing in the x-way (to move to the center of the ladder if standing a little bit aside). Otherwise, will not lock.

push_an_object(pusher, col)

Pushes a pushable other GameObject (assuming that this other object also has a PlatformerPhysics Component).

Parameters:

• pusher – the Sprite that’s actively pushing against the other GameObject
• col – the Collision object (that caused the push) returned by the collision detector method

push_back(sequence)

Pushes the GameObject in x direction for some number of frames (e.g. when being hit by an arrow). The force of the push is given as x-acceleration value being added to the already calculated normal physics acceleration values. E.g. the character’s brain wants to go left: ax is then the running acceleration plus the value of the first item in the sequence. The sequence’s first item is then removed.

Parameters:sequence (list) – a list of additive x-accelerations that will be applied (on top of the regular physics) to the GameObject frame by frame until the list is empty

tick(game_loop)

Needs to be called by the GameObject at some point during the GameObject’s tick method. Determines x/y-speeds and moves the GameObject.

Parameters:game_loop (GameLoop) – the currently playing GameLoop object

unlock_ladder()

Frees the GameObject from a ladder - if it is currently on a ladder.

class spygame.Repeater(x, y, image_file, **kwargs)

Bases: spygame.Sprite

A background 2D image that scrolls slower than the Viewport (to create a pseudo 3D effect).

render(display)

class spygame.SATCollision

Bases: spygame.CollisionAlgorithm

static calculate_normal(points, idx)

static collide(sprite1, sprite2, collision_objects=None, original_pos=None)

static dot_product_against_normal(point)

normal = [0.0, 0.0]

static try_collide(o1, o2, collision_obj, flip)

class spygame.Screen(name: str = ‘start’, **kwargs)

Bases: spygame.EventObject

A Screen object has a play and a done method that need to be implemented. The play method stages the Screen on a Stage. The done method can do some cleanup.

done()

play()

class spygame.SimpleHumanBrain(name=’brain’, commands=None)

Bases: spygame.Brain

looks for keys that match our stored commands and sets these commands to True if the key is pressed, False otherwise

added()

tick(game_loop)

Needs to be called by the GameObject at some point during the GameObject’s tick method. Translates all keys from the GameLoops’s KeyboardInputs object into our command dict.

Parameters:game_loop (GameLoop) – the currently playing GameLoop object

class spygame.SimpleScreen(name, **kwargs)

Bases: spygame.Screen

A simple Screen that has support for labels and sprites (static images) shown on the screen.

done()

play()

Plays the Screen.

static screen_func(stage: spygame.Stage)

Defines this screen’s Stage setup. Stage functions are used to setup a Stage (before playing it).

Parameters:stage (Stage) – the Stage to be setup

class spygame.SlopedTileSprite(layer, pytmx_tiled_map, id_, tile_props, rect)

Bases: spygame.TileSprite

a TileSprite that supports storing some temporary calculations about a slope in the tile and its relation to a Sprite that’s currently colliding with the TileSprite - used by the PlatformerPhysics Component when detecting and handling slope collisions

get_y(x)

Calculates the y value (in normal cartesian y-direction (positive values on up axis)) for a given x-value.

Parameters:x (int) – the x-value (x=0 for left edge of tile x=tilewidth for right edge of tile) Returns:the calculated y-value Return type:int

sloped_xy_pull(sprite)

Applies a so-called xy-pull on a Sprite object moving in x-direction in this sloped tile. An xy-pull is a change in the y-coordinate because of the x-movement (sliding up/down a slope while moving left/right).

Parameters:sprite (Sprite) – the Sprite object that’s moving on the slope

class spygame.Sprite(x, y, **kwargs)

Bases: spygame.GameObject, pygame.sprite.Sprite

A Sprite can be added to a Stage; has a type and a collision mask for collision detection with other Sprites or TiledTileLayers also on the Stage. Sprite objects inherit from pygame.sprite.Sprite, so a Sprite has an image and a position/collision rect via rect property (pygame.rect). Each Sprite can have either a static image or hold a SpriteSheet object from which it can pull images for animation purposes; either way, the image property holds the current image. The image rect (property image_rect) can be different from the collision rect (property rect); usually one would want the collision rect to be a little smaller than the actual image.

added_to_stage(stage)

adjusts our max positions based on the stage’s level’s dimensions - only if it’s a Level (not a simple Screen)

Parameters:stage (Stage) – the Stage we were added to

destroy()

static get_type(types_)

Returns the bitmap code for an already existing Sprite type or for a new type (the code will be created then). Types are usually used for collision masks.

Parameters:types (str) – the type(s) (comma-separated), whose code(s) should be returned Returns:the type as an int; if many types are given, returns a bitmask with all those bits set that represent the given types Return type:int

move(x, y, absolute=False)

Moves us by x/y pixels (or to x,y if absolute=True).

Parameters:

• x (Union[int,None]) – the amount in pixels to move in x-direction
• y (Union[int,None]) – the amount in pixels to move in y-direction
• absolute (bool) – whether x and y are given as absolute coordinates (default: False): in this case x/y=None means do not move in this dimension

next_type = 512

render(display)

Paints the Sprite with its current image onto the given Display object.

Parameters:display (Display) – the Display object to render on (Display has a pygame.Surface, on which we blit our image)

types = {‘none’: 0, ‘dockable’: 1, ‘default’: 2, ‘one_way_platform’: 4, ‘particle’: 8, ‘friendly’: 16, ‘enemy’: 32, ‘all’: 65535}

class spygame.SpriteSheet(file, store_flips=None)

Bases: object

Represents a spritesheet loaded from a tsx file. Stores each single image (as pygame.Surface) in the sheet by its position. Allows for already doing flip transformations (x/y and/or both axes) so we save time during the game. Stores single tile properties in tile_props_by_id dict (only for those tiles that actually have custom properties defined in the tsx file).

class spygame.Stage(screen, options=None)

Bases: spygame.GameObject

A Stage is a container class for Sprites sorted by pygame.sprite.Groups and TiledTileLayers. Sprites within a Stage can collide with each other or with the TiledTileLayers in the Stage. Sprites and TiledTileLayers that are to be rendered are stored sorted by their render_order property (lowest renders first).

active_stage = 0

add_sprite(sprite, group_name)

Adds a new single Sprite to an existing or a new pygame.sprite.Group.

Parameters:

• sprite (Sprite) – the Sprite to be added to this Stage (the Sprite’s position is defined in its rect.x/y properties)
• group_name (str) – the name of the group to which the GameObject should be added (group will not be created if it doesn’t exist yet)

Returns:

the Sprite that was added

Return type:

Sprite

add_tiled_layer(pytmx_layer, pytmx_tiled_map)

Adds a pytmx.TiledElement to the Stage with all its tiles or objects. The TiledElement could either be converted into a TiledTileLayer or a TiledObjectGroup (these objects are generated in this function based on the pytmx equivalent being passed in).

Parameters:

• pytmx_layer (pytmx.pytmx.TiledElement) – the original pytmx object to derive our TiledTileLayer or TileObjectGroup from
• pytmx_tiled_map (pytmx.pytmx.TiledMap) – the original pytmx TiledMap object (the tmx file) to which this layer belongs

add_tiled_object_group(tiled_object_group)

Adds a TiledObjectGroup (all it’s objects as single Sprites) to this Stage.

Parameters:tiled_object_group (TiledObjectGroup) –

add_tiled_tile_layer(tiled_tile_layer)

Adds a TiledTileLayer to this Stage. Puts it in the ordered to_render list, in the tiled_layers list.

Parameters:tiled_tile_layer (TiledTileLayer) – the TiledTileLayer to add to this Stage

static clear_stage(idx)

Clears one of the Stage objects by index.

Parameters:idx (int) – the index of the Stage to clear (index==slot in static Stage.stages list)

static clear_stages()

Clears all our Stage objects.

destroyed()

detect(detector, params=None)

Returns the first GameObject in this Stage that - when passed to the detector function with params - returns True.

Parameters:

• detector (callable) – a function that returns a bool
• params (list) – the list of positional args that are passed to the detector

Returns:

the first GameObject in this Stage that - when passed to the detector function with params - returns True

Return type:

Union[Sprite,None]

static estimate_sprite_direction(sprite)

tries to return an accurate tuple of direction (x/y) and direction_veloc - if sprite directly has vx and vy, use these - if sprite has a physics component: use vx and vy from that Component - else: pretend vx and vy are 0.0 then return the direction whose veloc component is highest plus that highest veloc

Parameters:sprite (Sprite) – the Sprite to estimate Returns:tuple of direction (x/y) and direction_veloc Return type:Tuple[str,float]

for_each(callback, params=None)

Calls the given callback function for each sprite, each time passing it the sprite itself and *params.

Parameters:

• callback (callable) – the callback to call for each sprite in the Stage
• params (any) – the params to pass as second/third/etc.. parameter to the callback

force_remove_sprite(sprite: spygame.Sprite)

Force-removes the given Sprite immediately (without putting it in the remove_list first).

Parameters:sprite (Sprite) – the Sprite to be removed from the Stage

static get_stage(idx=0)

Returns the Stage at the given index (returns None if none found).

Parameters:idx (Union[int,None]) – the index of the Stage to return (0=default Stage) Returns:the Stage object at the given index or None if there is no Stage at that index Return type:Union[Stage,None]

hide()

Hides the Stage.

invoke(func_name, params=None)

Calls a function on all of the GameObjects on this Stage.

Parameters:

• func_name (str) – the function name to call on all our GameObjects using getattr
• params (Union[list,None]) – the *args passed to that function

locate(x, y, w=1, h=1, type_=2, collision_mask=2)

Returns the first Collision found by colliding the given measurements (Rect) against this Stage’s objects. Starts with all TiledTileLayer objects, then all other Sprites.

Parameters:

• x (int) – the x-coordinate of the Rect to check
• y (int) – the y-coordinate of the Rect to check
• w (int) – the width of the Rect to check
• h (int) – the height of the Rect to check
• type (int) – the type of the Rect (has to match collision_mask of Stage’s objects)
• collision_mask (int) – the collision mask of the Rect (only layers and Sprites that match this mask are checked)

Returns:

the first Collision encountered

Return type:

Union[Collision,None]

locate_obj = <Sprite sprite(in 0 groups)>

max_stages = 10

pause()

Pauses playing the Stage.

remove_sprite(sprite: spygame.Sprite)

Removes a Sprite from this Stage by putting it in the remove_list for later removal.

Parameters:sprite (Sprite) – the Sprite to be removed from the Stage

render(display)

Gets called each frame by the GameLoop (after ‘tick’ is called on all Stages). Renders all its layers (ordered by ‘render_order’ property of the TiledTileLayer in the tmx file). TODO: renders Sprites that are not part of any layer.

Parameters:display (Display) – the Display object to render on

static render_stages(display, refresh_after_render=False)

Loops through all Stages and renders all of them.

Parameters:

• display (Display) – Display object on which to render
• refresh_after_render (bool) – do we refresh the pygame.display after all Stages have been called with render?

show()

Unhides the Stage.

solve_collisions()

Look for the objects layer and do each object against the main collision layer. Some objects in the objects layer do their own collision -> skip those here (e.g. ladder climbing objects). After the main collision layer, do each object against each other.

static stage_default_game_loop_callback(game_loop: spygame.GameLoop)

The default game loop callback to use if none is given when staging a Scene. Order: Clamps dt (to avoid extreme values), ticks all stages, renders all stages, updates the pygame.display

Parameters:game_loop (GameLoop) – the currently playing (active) GameLoop

static stage_screen(screen, screen_func=None, stage_idx=None, options=None)

Supported options are (if not given, we take some of them from given Screen object, instead): - stage_idx (int): sets the stage index to use (0-9) - stage_class (class): sets the class (must be a Stage class) to be used when creating the new Stage - force_loop (bool): if set to True and we currently have a GameLoop running, stop the current GameLoop and replace it with a new one, which has to be given via the “game_loop” option (as GameLoop object, or as string “new” for a default GameLoop) - keyboard_inputs (KeyboardInputs): the KeyboardInputs object to use for the new GameLoop - display (Display): the Display to use for the new GameLoop - components (List[Component]): a list of Component objects to add to the new Stage (e.g. a Viewport)

Parameters:

• screen (Screen) – the Screen object to set up on a certain stage
• screen_func (callable) – the function to use to set up the Stage (before playing it)
• stage_idx (int) – the Stage index to use (0=default Stage)
• options (dict) – options to be used when instantiating the Stage

Returns:

the new Stage object

Return type:

Stage

stages = [None, None, None, None, None, None, None, None, None, None]

start()

Starts running the Stage (and calling all GameObject’s tick method).

stop()

Stops playing the Stage (stops calling tick on all GameObjects).

tick(game_loop)

Gets called each frame by the GameLoop. Calls the tick method on all its Sprites (but only if the sprite is within the viewport).

Parameters:game_loop (GameLoop) – the GameLoop object that’s currently running (and ticking all Stages)

static tick_sprite(sprite, game_loop)

ticks one single sprite :param Sprite sprite: the Sprite object to tick :param GameLoop game_loop: the GameLoop object that’s currently playing

unpause()

Unpauses playing the Stage.

class spygame.State

Bases: spygame.EventObject

A simple state class that serves as a dict with settable and gettable key/value pairs. Setting a new value will trigger “changed”+key events.

dec(key, amount: int = 1)

get(key)

inc(key, amount: int = 1)

set(key, value, trigger_event=False)

class spygame.TileSprite(layer, pytmx_tiled_map, id_, tile_props, rect)

Bases: spygame.Sprite

Class used by TiledTileLayer objects to have a means of representing single tiles in terms of Sprite objects (used for collision detector function).

class spygame.TiledObjectGroup(pytmx_layer: pytmx.pytmx.TiledObjectGroup, pytmx_tiled_map: pytmx.pytmx.TiledMap)

Bases: spygame.TmxLayer

A wrapper class for the pytmx.TiledObjectGroup class, which represents an object layer in a tmx file. Generates all GameObjects specified in the layer (a.g. the agent, enemies, etc..). Implements render by looping through all GameObjects and rendering their Sprites one by one.

class spygame.TiledTileLayer(pytmx_layer, pytmx_tiled_map, tile_sprite_handler)

Bases: spygame.TmxLayer

A wrapper class for pytmx.pytmx.TiledTileLayer, which represents a ‘normal’ tile layer in a tmx file. Reads in all tiles’ images into one Surface object so we can render the entire layer at once. Implements render.

build_sprite_surface()

Builds the image (pygame.Surface) for this tile layer based on all found tiles in the layer.

capture_autobuilds()

Captures all autobuild objects in this layer and returns them in a list of objects. Once an autobuild tile is found: searches neighboring tiles (starting to move right and down) for the same property and thus measures the object’s width and height (in tiles).

Returns:list of generated autobuild objects Return type:List[object]

collide_simple_with_sprite(sprite, collision_detector)

Collides a Sprite (that only obeys simple physics rules) with a TiledTileLayer and solves all detected collisions. The Sprite needs to have the properties vx and vy, which are interpreted as the Sprite’s velocity. Ignores slopes.

Parameters:

• sprite (Sprite) – the Sprite to test for collisions against a TiledTileLayer
• collision_detector (callable) – the collision detector method to use (this is set in the Sprite’s Stage’s options)

get_overlapping_tiles(sprite)

Returns the tile boundaries (which tiles does the sprite overlap with?).

Parameters:sprite (Sprite) – the sprite to test against Returns:a tuple of (start-x. end-x, start-y, end-y) tile-coordinates to consider as overlapping with the given Sprite Return type:tuple

render(display)

Blits a part of our Sprite’s image onto the Display’s Surface using the Display’s offset attributes.

Parameters:display (Display) – the Display object to render on

class spygame.TmxLayer(tmx_layer_obj, tmx_tiled_map)

Bases: object

A wrapper class for the pytmx TiledObject class that can either represent a TiledTileLayer or a TiledObjectGroup. Needs to implement render and stores some spygame specific properties such as collision, render, etc.

Parameters:

• tmx_layer_obj (pytmx.pytmx.TiledElement) – the underlying pytmx TiledTileLayer
• tmx_tiled_map (pytmx.pytmx.TiledMap) – the underlying pytmx TiledMap object (representing the tmx file)

class spygame.TopDownPhysics(name=’physics’)

Bases: spygame.ControlledPhysicsComponent

Defines “top-down-2D”-step physics (agent can move in any of the 4 directions using any step-size (smooth walking)). To be addable to any character (player or enemy).

added()

collide_in_one_direction(sprite, direction, direction_veloc, original_pos)

Detects and solves all possible collisions between our GameObject and all Stage’s objects (layers and Sprites) in one direction (x or y).

Parameters:

• sprite (Sprite) – the GameObject of this Component (the moving/colliding Sprite)
• direction (str) – either “x” or “y”
• direction_veloc (float) – the velocity in the given direction (x/y-component of the velocity vector)
• original_pos (Tuple[int,int]) – the position of the game_object before this collision detection execution

collide_with_collision_layer(sprite, layer, direction, direction_veloc, original_pos)

Collides a Sprite with a collision TiledTileLayer (type==default) and solves all detected collisions.

Parameters:

• sprite (Sprite) – the Sprite to test for collisions against a TiledTileLayer
• layer (TiledTileLayer) – the TiledTileLayer object in which to look for collision tiles (full of sloped)
• direction (str) – x or y direction in which the sprite is currently moving before this test
• direction_veloc (float) – the velocity in the given direction (could be negative or positive)
• original_pos (Tuple[int,int]) – the position of the sprite before the move that caused this collision test to be executed

collision(col)

tick(game_loop)

Needs to be called by the GameObject at some point during the GameObject’s tick method.

Parameters:game_loop (GameLoop) – the currently playing GameLoop object

class spygame.Viewport(display)

Bases: spygame.Component

A viewport is a component that can be added to a Stage to help that Stage render the scene depending on scrolling/obj_to_follow certain GameObjects - any GameObject with offset_x/y fields is supported, the Viewport will set these offsets to the Viewports x/y values before each render call

added()

center_on(x=None, y=None)

Centers on a given x/y position without(!) respecting the Viewport’s max_speed property (unlike soft_center_on).

Parameters:

• x (Union[int,None]) – the x position to center on (None if we should ignore the x position)
• y (Union[int,None]) – the y position to center on (None if we should ignore the y position)

center_on_xy_with_viewport(stage, x, y)

Centers the Viewport on a given x/y position (so that the x/y position is in the center of the screen afterwards).

Parameters:

• stage (GameObject) – our game_object (the Stage) that has self as component
• x (int) – the x position to center on
• y (int) – the y position to center on

follow(game_loop=None, first=False)

Helper method to follow our self.obj_to_follow (should not be called by the API user). Called when the Stage triggers Event ‘post_tick’ (passes GameLoop into it which is not used).

Parameters:

• game_loop (GameLoop) – the GameLoop that’s currently playing
• first (bool) – whether this is the very first call to this function (if so, do a hard center on, otherwise a soft-center-on)

follow_object_with_viewport(stage, obj_to_follow, directions=None, bounding_box=None, max_speed=inf)

Makes the viewport follow a GameObject (obj_to_follow).

Parameters:

• stage (GameObject) – our game_object (the Stage) that has self as component
• obj_to_follow (GameObject) – the GameObject that we should follow
• directions (dict) – dict with ‘x’ and ‘y’ set to either True or False depending on whether we follow only in x direction or y or both
• bounding_box (dict) – should contain min_x, max_x, min_y, max_y so we know the boundaries of the camera
• max_speed (float) – the max speed of the camera

move_to(x=None, y=None)

Moves the Viewport to a given x/y position (top-left corner, not centering) without(!) respecting the Viewport’s max_speed property.

Parameters:

• x (Union[int,None]) – the x position to move to (None if we should ignore the x position)
• y (Union[int,None]) – the y position to move to (None if we should ignore the y position)

move_to_xy_with_viewport(stage, x, y)

Moves the Viewport to the given x/y position (top-left corner, not center(!)).

Parameters:

• stage (GameObject) – our game_object (the Stage) that has self as Component
• x (int) – the x position to move to
• y (int) – the y position to move to

pre_render(display)

Sets the offset property of the given Display so that it matches our (previously) calculated x/y values.

Parameters:display (Display) – the Display, whose offset we will change here

shake_viewport(stage, time=3, frequency=5)

Shakes the Viewport object for the given time and with the given frequency.

Parameters:

• stage (GameObject) – our game_object (the Stage) that has self as Component
• time (float) – the amount of time (in sec) for which the Viewport should shake
• frequency (floar) – the frequency (in up/down shakes per second) with which we should shake; higher numbers mean more rapid shaking

soft_center_on(x=None, y=None)

Soft-centers on a given x/y position respecting the Viewport’s max_speed property (unlike center_on).

Parameters:

• x (Union[int,None]) – the x position to center on (None if we should ignore the x position)
• y (Union[int,None]) – the y position to center on (None if we should ignore the y position)

tick(game_loop)

unfollow_object_with_viewport(stage)

Stops following.

Parameters:stage (GameObject) – our game_object (the Stage) that has self as component

spygame.convert_type(value, force_class=False)

Converts the given value from a string (or other) type into the most likely type. E.g. ‘some text’ -> ‘some text’ (str) ‘1’ -> 1 (int) ‘-51’ -> -51 (int) ‘0.1’ -> 0.1 (float) ‘true’ -> True (bool) ‘False’ -> False (bool) [1, 2, 3] -> [1, 2, 3] (list) spygame.Ladder -> <type spygame.Ladder> (a python class object; can be used as a ctor to construct objects of that class)

Parameters:

• value (any) – the given value to be converted to the most-likely python type
• force_class (bool) – if True, we will interpret even simple strings (starting with upper case but without any dots) as class names (e.g. Ladder)

Returns:

the converted value

Return type:

any

spygame.defaults(dictionary, defaults_dict)

Adds all key/value pairs from defaults_dict into dictionary, but only if dictionary doesn’t have the key defined yet.

Parameters:

• dictionary (dict) – the target dictionary
• defaults_dict (dict) – the source (default) dictionary to take the keys from (only if they are not defined in dictionary

spygame.extend(dictionary, extend_dict)

Extends the dictionary with extend_dict, thereby overwriting existing keys.

Parameters:

• dictionary (dict) – the target dictionary
• extend_dict (dict) – the source (extension) dictionary to take the keys from (even if they are not defined in dictionary)

spygame.get_kwargs_from_obj_props(obj_props)

returns a kwargs dict retrieved from a single object’s properties in a level-tmx TiledObjectGroup

6.2. Example Classes:

6.2.1. The Lost Vikings

class spygame.examples.vikings.Arrow(shooter)

Bases: spygame.examples.vikings.Shot

arrow class

sprite_sheet = None

class spygame.examples.vikings.Baleog(x, y)

Bases: spygame.examples.vikings.Viking

check_actions()

check_hit_with_sword()

Returns:True if player is currently hitting with sword Return type:bool

check_shoot_with_arrow()

Returns:True if player is doing something with arrow right now Return type:bool

class spygame.examples.vikings.Coconut(x, y, **kwargs)

Bases: spygame.AnimatedSprite

collision(col)

our collision resolver (triggered by the Stage) :param Collision col: the Collision object describing the collision

shake()

shakes the coconut for a while back and forth (after being hit by arrow)

tick(game_loop)

class spygame.examples.vikings.Dinosaur(x, y, color=’blue’)

Bases: spygame.AnimatedSprite

check_running()

die()

hit_particle(col)

Called when hit by a particle type object.

Parameters:col (Collision) – the Collision object describing the collision

sprite_sheet = None

tick(game_loop)

class spygame.examples.vikings.DinosaurBrain

Bases: spygame.AIBrain

bumped(col)

class spygame.examples.vikings.Erik(x, y)

Bases: spygame.examples.vikings.Viking

check_actions()

check_bored_timer()

check_in_air() → bool

check_out_of_breath()

check_running()

class spygame.examples.vikings.FireSpitter(x, y, w, h, tile_w, tile_h, **kwargs)

Bases: spygame.Sprite, spygame.Autobuild

a FireSpitter can spit fireballs that kill the Vikings

fire()

tick(game_loop)

class spygame.examples.vikings.Fireball(shooter, direction=’right’)

Bases: spygame.examples.vikings.Shot

fireball class

sprite_sheet = None

class spygame.examples.vikings.KeyLock(x, y, color=’yellow’)

Bases: spygame.Sprite

unlocked()

will execute once a Viking is touching this KeyLock and using the matching Key Item

class spygame.examples.vikings.Olaf(x, y)

Bases: spygame.examples.vikings.Viking

check_actions()

check_bored_timer()

check_in_air()

check_running()

check_switch_shield(game_loop)

which_stand()

class spygame.examples.vikings.Scorpion(x, y)

Bases: spygame.AnimatedSprite

calm_down()

check_running()

get_mad()

hit_particle(col)

sprite_sheet = None

tick(game_loop)

class spygame.examples.vikings.Shot(offset_x, offset_y, spritesheet, animation_setup, shooter, **kwargs)

Bases: spygame.AnimatedSprite

a shot (like the one a scorpion shoots) - can be extended to do more complicated stuff

collision(col)

we hit something -> solves a collision with another object

Parameters:col (spyg.Collision) – the spyg.Collision object to solve

collision_done()

we are done hitting something -> destroys this object (e.g. shot hits the wall -> disappears)

tick(game_loop)

simple tick function with ax and ay, speed- and pos-recalc, and collision detection

Parameters:game_loop (spyg.GameLoop) – the spyg.GameLoop object currently playing

class spygame.examples.vikings.Viking(x, y, spritesheet, animation_setup)

Bases: spygame.AnimatedSprite

a generic Viking class

activate()

allow_play_stand()

check_actions()

check_bored_timer()

check_in_air()

check_on_ladder(dt)

returns True if we are currently locked into a ladder, False otherwise - if we are locked into a ladder also set the current SpriteSheet frame manually (via animation.frame and animation.animation=None)

Parameters:dt (float) – the time passed since the last tick Returns:whether we are locked into a ladder or not Return type:bool

check_running()

deactivate()

die()

get_squeezed(squeezer)

hit_liquid(description)

hit_particle(col)

land(col)

tick(game_loop)

class spygame.examples.vikings.VikingLevel(name: str = ‘test’, **kwargs)

Bases: spygame.Level

active_viking_changed(new_viking_idx)

done()

escape_menu()

next_active_viking()

play()

viking_died(dead_viking)

viking_reached_exit(viking)