Arcade Package API

This page documents the Application Programming Interface (API) for the Python Arcade library.

For example code, see Example Code.

Color and Keyboard Constants

• arcade.key package
• arcade.csscolor package
• arcade.color package

Main API

The Arcade Library

A Python simple, easy to use module for creating 2D games.

class arcade.AStarBarrierList(moving_sprite: arcade.Sprite, blocking_sprites: arcade.SpriteList, grid_size: int, left: int, right: int, bottom: int, top: int)

Bases: object

Class that manages a list of barriers that can be encountered during A* path finding.

recalculate()

Recalculate blocking sprites.

class arcade.AnimatedTimeBasedSprite(filename: str = None, scale: float = 1, image_x: float = 0, image_y: float = 0, image_width: float = 0, image_height: float = 0, center_x: float = 0, center_y: float = 0, _repeat_count_x=1, _repeat_count_y=1)

Bases: arcade.Sprite

Sprite for platformer games that supports animations. These can be automatically created by the Tiled Map Editor.

update_animation(delta_time: float = 0.016666666666666666)

Logic for selecting the proper texture to use.

class arcade.AnimatedTimeSprite(scale: float = 1, image_x: float = 0, image_y: float = 0, center_x: float = 0, center_y: float = 0)

Bases: arcade.Sprite

Deprecated class for periodically updating sprite animations. Use AnimatedTimeBasedSprite instead.

update_animation(delta_time: float = 0.016666666666666666)

Logic for selecting the proper texture to use.

class arcade.AnimatedWalkingSprite(scale: float = 1, image_x: float = 0, image_y: float = 0, center_x: float = 0, center_y: float = 0)

Bases: arcade.Sprite

Sprite for platformer games that supports walking animations. Make sure to call update_animation after loading the animations so the initial texture can be set. Or manually set it. For a better example, see: http://arcade.academy/examples/platformer.html#animate-character

update_animation(delta_time: float = 0.016666666666666666)

Logic for selecting the proper texture to use.

class arcade.AnimationKeyframe(tile_id: int, duration: int, texture: arcade.texture.Texture)

Bases: object

Used in animated sprites.

duration: int = None

texture: Texture = None

tile_id: int = None

class arcade.CreateText(text: str, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], font_size: float = 12, width: int = 20, align='left', font_name='Calibri', 'Arial', bold: bool = False, italic: bool = False, anchor_x='left', anchor_y='baseline', rotation=0)

Bases: object

Class used for managing text

class arcade.DialogueBox(x, y, width, height, color=None, theme=None)

Bases: object

on_draw()

on_mouse_press(x, y, _button, _modifiers)

on_mouse_release(x, y, _button, _modifiers)

class arcade.EmitBurst(count: int)

Bases: arcade.emitter.EmitController

Used to configure an Emitter to emit particles in one burst

how_many(delta_time: float, current_particle_count: int) → int

is_complete() → bool

class arcade.EmitController

Bases: object

Base class for how a client configure the rate at which an Emitter emits Particles

Subclasses allow the client to control the rate and duration of emitting

how_many(delta_time: float, current_particle_count: int) → int

is_complete() → bool

class arcade.EmitInterval(emit_interval: float)

Bases: arcade.emitter.EmitController

Base class used to configure an Emitter to have a constant rate of emitting. Will emit indefinitely.

how_many(delta_time: float, current_particle_count: int) → int

is_complete() → bool

class arcade.EmitMaintainCount(particle_count: int)

Bases: arcade.emitter.EmitController

Used to configure an Emitter so it emits particles so that the given count is always maintained

how_many(delta_time: float, current_particle_count: int) → int

is_complete() → bool

class arcade.Emitter(center_xy: Union[Tuple[float, float], List[float]], emit_controller: arcade.emitter.EmitController, particle_factory: Callable[[Emitter], arcade.particle.Particle], change_xy: Union[Tuple[float, float], List[float]] = 0.0, 0.0, emit_done_cb: Callable[[Emitter], None] = None, reap_cb: Callable[[], None] = None)

Bases: object

Emits and manages Particles over their lifetime. The foundational class in a particle system.

can_reap()

Determine if Emitter can be deleted

draw()

get_count()

get_pos() → Union[Tuple[float, float], List[float]]

Get position of emitter

update()

class arcade.EmitterIntervalWithCount(emit_interval: float, particle_count: int)

Bases: arcade.emitter.EmitInterval

Configure an Emitter to emit particles with given interval, ending after emitting given number of particles

how_many(delta_time: float, current_particle_count: int) → int

is_complete() → bool

class arcade.EmitterIntervalWithTime(emit_interval: float, lifetime: float)

Bases: arcade.emitter.EmitInterval

Configure an Emitter to emit particles with given interval, ending after given number of seconds

how_many(delta_time: float, current_particle_count: int) → int

is_complete() → bool

class arcade.EternalParticle(filename_or_texture: Union[str, arcade.texture.Texture], change_xy: Union[Tuple[float, float], List[float]], center_xy: Union[Tuple[float, float], List[float]] = 0.0, 0.0, angle: float = 0, change_angle: float = 0, scale: float = 1.0, alpha: int = 255, mutation_callback=None)

Bases: arcade.particle.Particle

Particle that has no end to its life

can_reap()

Determine if Particle can be deleted

class arcade.FadeParticle(filename_or_texture: Union[str, arcade.texture.Texture], change_xy: Union[Tuple[float, float], List[float]], lifetime: float, center_xy: Union[Tuple[float, float], List[float]] = 0.0, 0.0, angle: float = 0, change_angle: float = 0, scale: float = 1.0, start_alpha: int = 255, end_alpha: int = 0, mutation_callback=None)

Bases: arcade.particle.LifetimeParticle

Particle that animates its alpha between two values during its lifetime

update()

Advance the Particle’s simulation

class arcade.GridLocation

Bases: object

This represents a location on the grid. Contains the x/y of the grid location, and the tile that is on it.

class arcade.LifetimeParticle(filename_or_texture: Union[str, arcade.texture.Texture], change_xy: Union[Tuple[float, float], List[float]], lifetime: float, center_xy: Union[Tuple[float, float], List[float]] = 0.0, 0.0, angle: float = 0, change_angle: float = 0, scale: float = 1.0, alpha: int = 255, mutation_callback=None)

Bases: arcade.particle.Particle

Particle that lives for a given amount of time and is then deleted

can_reap()

Determine if Particle can be deleted

update()

Advance the Particle’s simulation

class arcade.Matrix3x3

Bases: object

multiply(o: List[float])

reset()

rotate(phi: float)

scale(sx: float, sy: float)

shear(sx: float, sy: float)

translate(tx: float, ty: float)

arcade.NamedPoint

alias of arcade.arcade_types.Point

exception arcade.NoOpenGLException

Bases: Exception

Exception when we can’t get an OpenGL 3.3+ context

class arcade.Particle(filename_or_texture: Union[str, arcade.texture.Texture], change_xy: Union[Tuple[float, float], List[float]], center_xy: Union[Tuple[float, float], List[float]] = 0.0, 0.0, angle: float = 0.0, change_angle: float = 0.0, scale: float = 1.0, alpha: int = 255, mutation_callback=None)

Bases: arcade.Sprite

Sprite that is emitted from an Emitter

can_reap()

Determine if Particle can be deleted

update()

Advance the Particle’s simulation

class arcade.PhysicsEnginePlatformer(player_sprite: arcade.Sprite, platforms: arcade.SpriteList, gravity_constant: float = 0.5, ladders: arcade.SpriteList = None)

Bases: object

Simplistic physics engine for use in a platformer. It is easier to get started with this engine than more sophisticated engines like PyMunk. Note, it does not currently handle rotation.

can_jump(y_distance=5) → bool

Method that looks to see if there is a floor under the player_sprite. If there is a floor, the player can jump and we return a True.

Returns

True if there is a platform below us

Return type

bool

disable_multi_jump()

Disables multi-jump.

Calling this function also removes the requirement to call increment_jump_counter() every time the player jumps.

enable_multi_jump(allowed_jumps: int)

Enables multi-jump. allowed_jumps should include the initial jump. (1 allows only a single jump, 2 enables double-jump, etc)

If you enable multi-jump, you MUST call increment_jump_counter() every time the player jumps. Otherwise they can jump infinitely.

Parameters

allowed_jumps (int) –

increment_jump_counter()

Updates the jump counter for multi-jump tracking

is_on_ladder()

Return ‘true’ if the player is in contact with a sprite in the ladder list.

jump(velocity: int)

Have the character jump.

update()

Move everything and resolve collisions.

Returns

SpriteList with all sprites contacted. Empty list if no sprites.

class arcade.PhysicsEngineSimple(player_sprite: arcade.Sprite, walls: arcade.SpriteList)

Bases: object

Simplistic physics engine for use in games without gravity, such as top-down games. It is easier to get started with this engine than more sophisticated engines like PyMunk. Note, it does not currently handle rotation.

update()

Move everything and resolve collisions.

Returns

SpriteList with all sprites contacted. Empty list if no sprites.

class arcade.PymunkPhysicsEngine(gravity=0, 0, damping: float = 1.0)

Bases: object

Pymunk Physics Engine

DYNAMIC = 0

KINEMATIC = 1

MOMENT_INF = inf

STATIC = 2

add_collision_handler(first_type: str, second_type: str, begin_handler: Callable = None, pre_handler: Callable = None, post_handler: Callable = None, separate_handler: Callable = None)

Add code to handle collisions between objects.

add_sprite(sprite: arcade.Sprite, mass: float = 1, friction: float = 0.2, elasticity: Optional[float] = None, moment=None, body_type=0, damping=None, gravity=None, max_velocity=None, max_horizontal_velocity=None, max_vertical_velocity=None, radius: float = 0, collision_type: str = 'default')

Add a sprite to the physics engine.

add_sprite_list(sprite_list, mass: float = 1, friction: float = 0.2, elasticity: Optional[float] = None, moment=None, body_type=0, collision_type=None)

Add all sprites in a sprite list to the physics engine.

apply_force(sprite, force)

Apply force to a Sprite.

apply_impulse(sprite, impulse)

Apply an impulse force on a sprite

apply_opposite_running_force(sprite: arcade.Sprite)

If a sprite goes left while on top of a dynamic sprite, that sprite should get pushed to the right.

check_grounding(sprite: arcade.Sprite)

See if the player is on the ground. Used to see if we can jump.

get_physics_object(sprite: arcade.Sprite) → arcade.pymunk_physics_engine.PymunkPhysicsObject

Get the shape/body for a sprite.

get_sprite_for_shape(shape) → Optional[arcade.Sprite]

Given a shape, what sprite is associated with it?

get_sprites_from_arbiter(arbiter)

Given a collision arbiter, return the sprites associated with the collision.

is_on_ground(sprite)

Return true of sprite is on top of something.

remove_sprite(sprite: arcade.Sprite)

Remove a sprite from the physics engine.

resync_sprites()

Set visual sprites to be the same location as physics engine sprites.

set_friction(sprite, friction)

Apply force to a Sprite.

set_horizontal_velocity(sprite, velocity)

Set a sprite’s velocity

set_position(sprite, position)

Apply an impulse force on a sprite

set_velocity(sprite, velocity)

Apply an impulse force on a sprite

step(delta_time: float = 0.016666666666666666, resync_sprites: bool = True)

Tell the physics engine to perform calculations.

Parameters

• delta_time (float) – Time to move the simulation forward. Keep this value constant, do not use varying values for each step.

• resync_sprites (bool) – Resynchronize Arcade graphical sprites to be at the same location as their Pymunk counterparts. If running multiple steps per frame, set this to false for the first steps, and true for the last step that’s part of the update.

class arcade.PymunkPhysicsObject(body: pymunk.body.Body = None, shape: pymunk.shapes.Shape = None)

Bases: object

Object that holds pymunk body/shape for a sprite.

class arcade.Shape

Bases: object

Primitive drawing shape. This can be part of a ShapeElementList so shapes can be drawn faster in batch.

draw()

Draw this shape. Drawing this way isn’t as fast as drawing multiple shapes batched together in a ShapeElementList.

class arcade.ShapeElementList

Bases: typing.Generic

A program can put multiple drawing primitives in a ShapeElementList, and then move and draw them as one. Do this when you want to create a more complex object out of simpler primitives. This also speeds rendering as all objects are drawn in one operation.

property angle

Get the angle of the ShapeElementList in degrees.

append(item: TShape)

Add a new shape to the list.

property center_x

Get the center x coordinate of the ShapeElementList.

property center_y

Get the center y coordinate of the ShapeElementList.

draw()

Draw everything in the list.

move(change_x: float, change_y: float)

Move all the shapes ion the list :param change_x: Amount to move on the x axis :param change_y: Amount to move on the y axis

remove(item: TShape)

Remove a specific shape from the list.

class arcade.Sound(file_name: Union[str, pathlib.Path], streaming: bool = False)

Bases: object

This class represents a sound you can play.

get_length()

Get length of audio in seconds

get_stream_position()

Return where we are in the stream. This will reset back to zero when it is done playing.

get_volume()

Get the current volume

play(volume=1.0, pan=0.0)

Play the sound.

Parameters

• volume (float) – Volume, from 0=quiet to 1=loud

• pan (float) – Pan, from -1=left to 0=centered to 1=right

set_left_right_volume(left_volume, right_volume)

Set absolute left/right volume

This can only be done after the sound has started playing. Setting the sound volume when there is no sound playing generates a TypeError. If you want to set the volume before playing, use the volume parameter in the play method.

set_volume(volume)

Set the current volume.

This can only be done after the sound has started playing. Setting the sound volume when there is no sound playing generates a TypeError. If you want to set the volume before playing, use the volume parameter in the play method.

stop()

Stop a currently playing sound.

class arcade.Sprite(filename: str = None, scale: float = 1, image_x: float = 0, image_y: float = 0, image_width: float = 0, image_height: float = 0, center_x: float = 0, center_y: float = 0, repeat_count_x: int = 1, repeat_count_y: int = 1, flipped_horizontally: bool = False, flipped_vertically: bool = False, flipped_diagonally: bool = False, mirrored: bool = None, calculate_hit_box: bool = True)

Bases: object

Class that represents a ‘sprite’ on-screen. Most games center around sprites. For examples on how to use this class, see: http://arcade.academy/examples/index.html#sprites

Attributes:

alpha

Transparency of sprite. 0 is invisible, 255 is opaque.

angle

Rotation angle in degrees.

radians

Rotation angle in radians.

bottom

Set/query the sprite location by using the bottom coordinate. This will be the ‘y’ of the bottom of the sprite.

boundary_left

Used in movement. Left boundary of moving sprite.

boundary_right

Used in movement. Right boundary of moving sprite.

boundary_top

Used in movement. Top boundary of moving sprite.

boundary_bottom

Used in movement. Bottom boundary of moving sprite.

center_x

X location of the center of the sprite

center_y

Y location of the center of the sprite

change_x

Movement vector, in the x direction.

change_y

Movement vector, in the y direction.

change_angle

Change in rotation.

color

Color tint the sprite

collision_radius

Used as a fast-check to see if this item is close enough to another item. If this check works, we do a slower more accurate check. You probably don’t want to use this field. Instead, set points in the hit box.

cur_texture_index

Index of current texture being used.

guid

Unique identifier for the sprite. Useful when debugging.

height

Height of the sprite.

force

Force being applied to the sprite. Useful when used with Pymunk for physics.

left

Set/query the sprite location by using the left coordinate. This will be the ‘x’ of the left of the sprite.

points

Points, in relation to the center of the sprite, that are used for collision detection. Arcade defaults to creating points for a rectangle that encompass the image. If you are creating a ramp or making better hit-boxes, you can custom-set these.

position

A list with the (x, y) of where the sprite is.

repeat_count_x

Unused

repeat_count_y

Unused

right

Set/query the sprite location by using the right coordinate. This will be the ‘y=x’ of the right of the sprite.

sprite_lists

List of all the sprite lists this sprite is part of.

texture

Texture class with the current texture.

textures

List of textures associated with this sprite.

top

Set/query the sprite location by using the top coordinate. This will be the ‘y’ of the top of the sprite.

scale

Scale the image up or down. Scale of 1.0 is original size, 0.5 is 1/2 height and width.

velocity

Change in x, y expressed as a list. (0, 0) would be not moving.

width

Width of the sprite

It is common to over-ride the update method and provide mechanics on movement or other sprite updates.

add_spatial_hashes()

Add spatial hashes for this sprite in all the sprite lists it is part of.

property alpha

Return the alpha associated with the sprite.

property angle

Get the angle of the sprite’s rotation.

append_texture(texture: arcade.texture.Texture)

Appends a new texture to the list of textures that can be applied to this sprite.

Parameters

texture (Texture) – Texture to add ot the list of available textures

property bottom

Return the y coordinate of the bottom of the sprite.

property center_x

Get the center x coordinate of the sprite.

property center_y

Get the center y coordinate of the sprite.

property change_x

Get the velocity in the x plane of the sprite.

property change_y

Get the velocity in the y plane of the sprite.

clear_spatial_hashes()

Search the sprite lists this sprite is a part of, and remove it from any spatial hashes it is a part of.

collides_with_list(sprite_list: SpriteList) → list

Check if current sprite is overlapping with any other sprite in a list

Args:

self: current Sprite sprite_list: SpriteList to check against

Returns:

SpriteList of all overlapping Sprites from the original SpriteList

collides_with_point(point: Union[Tuple[float, float], List[float]]) → bool

Check if point is within the current sprite.

Args:

self: Current sprite point: Point to check.

Returns:

True if the point is contained within the sprite’s boundary.

collides_with_sprite(other: arcade.Sprite) → bool

Will check if a sprite is overlapping (colliding) another Sprite.

Args:

self: Current Sprite. other: The other sprite to check against.

Returns:

True or False, whether or not they are overlapping.

property collision_radius

Get the collision radius.

Note

Final collision checking is done via geometry that was set in get_points/set_points. These points are used in the check_for_collision function. This collision_radius variable is used as a “pre-check.” We do a super-fast check with collision_radius and see if the sprites are close. If they are, then we look at the geometry and figure if they really are colliding.

property color

Return the RGB color associated with the sprite.

draw()

Draw the sprite.

draw_hit_box(color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]] = 0, 0, 0, line_thickness: float = 1)

Draw a sprite’s hit-box. This is slow, but useful for debugging. :param color: Color of box :param line_thickness: How thick the box should be

forward(speed: float = 1.0)

Set a Sprite’s position to speed by its angle :param speed: speed factor

get_adjusted_hit_box() → Sequence[Union[Tuple[float, float], List[float]]]

Get the points that make up the hit box for the rect that makes up the sprite, including rotation and scaling.

get_hit_box() → Sequence[Union[Tuple[float, float], List[float]]]

Get a sprite’s hit box, unadjusted for translation, rotation, or scale.

get_points() → Sequence[Union[Tuple[float, float], List[float]]]

Get the points that make up the hit box for the rect that makes up the sprite, including rotation and scaling.

property height

Get the height in pixels of the sprite.

property hit_box

Get a sprite’s hit box, unadjusted for translation, rotation, or scale.

kill()

Alias of remove_from_sprite_lists

property left

Return the x coordinate of the left-side of the sprite’s hit box.

on_update(delta_time: float = 0.016666666666666666)

Update the sprite. Similar to update, but also takes a delta-time.

property points

Get the points that make up the hit box for the rect that makes up the sprite, including rotation and scaling.

property position

Get the center x and y coordinates of the sprite.

Returns:

(center_x, center_y)

pymunk_moved(physics_engine, dx, dy, d_angle)

Called by the pymunk physics engine if this sprite moves.

property radians

Converts the degrees representation of self.angle into radians. :return: float

register_physics_engine(physics_engine)

Called by the Pymunk physics engine when this sprite is added to that physics engine. Lets the sprite know about the engine and remove itself if it gets deleted.

register_sprite_list(new_list)

Register this sprite as belonging to a list. We will automatically remove ourselves from the the list when kill() is called.

remove_from_sprite_lists()

Remove the sprite from all sprite lists.

rescale_relative_to_point(point: Union[Tuple[float, float], List[float]], factor: float) → None

Rescale the sprite relative to a different point than its center.

reverse(speed: float = 1.0)

Set a new speed, but in reverse. :param speed: speed factor

property right

Return the x coordinate of the right-side of the sprite’s hit box.

property scale

Get the scale of the sprite.

set_hit_box(points: Sequence[Union[Tuple[float, float], List[float]]])

Set a sprite’s hit box. Hit box should be relative to a sprite’s center, and with a scale of 1.0. Points will be scaled with get_adjusted_hit_box.

set_points(points: Sequence[Union[Tuple[float, float], List[float]]])

Set a sprite’s hitbox

set_position(center_x: float, center_y: float)

Set a sprite’s position

Parameters

• center_x (float) – New x position of sprite

• center_y (float) – New y position of sprite

set_texture(texture_no: int)

Sets texture by texture id. Should be renamed because it takes a number rather than a texture, but keeping this for backwards compatibility.

stop()

Stop the Sprite’s motion

strafe(speed: float = 1.0)

Set a sprites position perpendicular to its angle by speed :param speed: speed factor

property texture

property texture_transform

property top

Return the y coordinate of the top of the sprite.

turn_left(theta: float = 90)

Rotate the sprite left a certain number of degrees. :param theta: change in angle

turn_right(theta: float = 90)

Rotate the sprite right a certain number of degrees. :param theta: change in angle

update()

Update the sprite.

update_animation(delta_time: float = 0.016666666666666666)

Override this to add code that will change what image is shown, so the sprite can be animated.

property width

Get the width of the sprite.

class arcade.SpriteList(use_spatial_hash=None, spatial_hash_cell_size=128, is_static=False)

Bases: object

Keep a list of sprites. Contains many optimizations around batch-drawing sprites and doing collision detection. For optimization reasons, use_spatial_hash and is_static are very important.

append(item: _SpriteType)

Add a new sprite to the list.

Parameters

item (Sprite) – Sprite to add to the list.

array_of_images: Optional[List[Any]] = None

property center

Get the mean center coordinates of all sprites in the list.

disable_spatial_hashing()

Turn off spatial hashing.

draw(**kwargs)

Draw this list of sprites.

Parameters

filter – Optional parameter to set OpenGL filter, such as gl.GL_NEAREST to avoid smoothing.

enable_spatial_hashing(spatial_hash_cell_size=128)

Turn on spatial hashing.

extend(items: list)

Extends the current list with the given list

Parameters

items (list) – list of Sprites to add to the list

index(key)

insert(index: int, item: _SpriteType)

Inserts a sprite at a given index

Parameters

• index (int) – The index at which to insert

• item (Sprite) – The sprite to insert

move(change_x: float, change_y: float)

Moves all Sprites in the list by the same amount.

Parameters

• change_x (float) – Amount to change all x values by

• change_y (float) – Amount to change all y values by

next_texture_id = 0

on_update(delta_time: float = 0.016666666666666666)

Update the sprite. Similar to update, but also takes a delta-time.

property percent_sprites_moved

What percent of the sprites moved?

pop(index: int = - 1) → arcade.Sprite

Pop off the last sprite, or the given index, from the list

preload_textures(texture_names: List)

Preload a set of textures that will be used for sprites in this sprite list.

Parameters

texture_names (array) – List of file names to load in as textures.

remove(item: _SpriteType)

Remove a specific sprite from the list. :param Sprite item: Item to remove from the list

rescale(factor: float) → None

Rescale all sprites in the list relative to the spritelists center.

reverse()

Reverses the current list inplace

update()

Call the update() method on each sprite in the list.

update_angle(sprite: arcade.Sprite)

Called by the Sprite class to update the angle in this sprite. Necessary for batch drawing of items.

Parameters

sprite (Sprite) – Sprite to update.

update_animation(delta_time: float = 0.016666666666666666)

Call the update_animation in every sprite in the sprite list.

update_color(sprite: arcade.Sprite)

Called by the Sprite class to update position, angle, size and color of the specified sprite. Necessary for batch drawing of items.

Parameters

sprite (Sprite) – Sprite to update.

update_height(sprite: arcade.Sprite)

Called by the Sprite class to update the size/scale in this sprite. Necessary for batch drawing of items.

Parameters

sprite (Sprite) – Sprite to update.

update_location(sprite: arcade.Sprite)

Called by the Sprite class to update the location in this sprite. Necessary for batch drawing of items.

Parameters

sprite (Sprite) – Sprite to update.

update_position(sprite: arcade.Sprite)

Called by the Sprite class to update position, angle, size and color of the specified sprite. Necessary for batch drawing of items.

Parameters

sprite (Sprite) – Sprite to update.

update_size(sprite: arcade.Sprite)

Called by the Sprite class to update the size/scale in this sprite. Necessary for batch drawing of items.

Parameters

sprite (Sprite) – Sprite to update.

update_texture(sprite)

Make sure we update the texture for this sprite for the next batch drawing

update_width(sprite: arcade.Sprite)

Called by the Sprite class to update the size/scale in this sprite. Necessary for batch drawing of items.

Parameters

sprite (Sprite) – Sprite to update.

property use_spatial_hash

Are we using a spatial hash?

class arcade.SpriteSolidColor(width, height, color)

Bases: arcade.Sprite

This sprite is just a rectangular sprite of one solid color. No need to use an image file.

class arcade.SubmitButton(textbox, on_submit, x, y, width=100, height=40, text='submit', theme=None)

Bases: arcade.gui.TextButton

on_press()

on_release()

class arcade.Text

Bases: object

Class used for managing text.

class arcade.TextBox(x, y, width=300, height=40, theme=None, outline_color=0, 0, 0, font_size=24, shadow_color=245, 245, 245, highlight_color=255, 255, 255)

Bases: object

check_mouse_press(x, y)

check_mouse_release(x, y)

draw()

update(delta_time, key)

class arcade.TextButton(center_x, center_y, width, height, text, font_size=18, font_face: Union[str, Tuple[str, …]] = 'Arial', font_color=None, face_color=211, 211, 211, highlight_color=255, 255, 255, shadow_color=128, 128, 128, button_height=2, theme=None)

Bases: object

Text-based button

check_mouse_press(x, y)

check_mouse_release(_x, _y)

draw()

Draw the button

draw_color_theme()

draw_texture_theme()

on_press()

on_release()

class arcade.TextDisplay(x, y, width=300, height=40, outline_color=0, 0, 0, shadow_color=245, 245, 245, highlight_color=255, 255, 255, theme=None)

Bases: object

check_mouse_press(x, y)

check_mouse_release(_x, _y)

color_theme_draw()

draw()

draw_text()

on_press()

on_release()

texture_theme_draw()

update(_delta_time, text, symbol, cursor_index)

class arcade.TextLabel(text, x, y, color=0, 0, 0, font_size=22, anchor_x='center', anchor_y='center', width: int = 0, align='center', font_name='Calibri', 'Arial', bold: bool = False, italic: bool = False, rotation=0)

Bases: object

draw()

class arcade.TextStorage(box_width, font_size=24, theme=None)

Bases: object

blink_cursor()

update(delta_time, key)

class arcade.Texture(name: str, image: PIL.Image.Image = None)

Bases: object

Class that represents a texture. Usually created by the load_texture or load_textures commands.

Attributes:

name

Unique name of the texture. Used by load_textures for caching. If you are manually creating a texture, you can just set this to whatever.

image

A PIL.Image.Image object.

width

Width of the texture in pixels.

height

Height of the texture in pixels.

draw_scaled(center_x: float, center_y: float, scale: float = 1.0, angle: float = 0, alpha: int = 255)

Draw the texture.

Parameters

• center_x (float) – X location of where to draw the texture.

• center_y (float) – Y location of where to draw the texture.

• scale (float) – Scale to draw rectangle. Defaults to 1.

• angle (float) – Angle to rotate the texture by.

• alpha (int) – The transparency of the texture (0-255).

draw_sized(center_x: float, center_y: float, width: float, height: float, angle: float = 0, alpha: int = 255)

draw_transformed(left: float, bottom: float, width: float, height: float, angle: float = 0, alpha: int = 255, texture_transform: arcade.texture.Matrix3x3 = <arcade.texture.Matrix3x3 object>)

property height

Height of the texture in pixels.

property hit_box_points

property width

Width of the texture in pixels.

class arcade.Theme

Bases: object

DEFAULT_FONT_COLOR = (0, 0, 0)

DEFAULT_FONT_NAME = ('Calibri', 'Arial')

DEFAULT_FONT_SIZE = 24

add_button_textures(normal, hover=None, clicked=None, locked=None)

add_dialogue_box_texture(dialogue_box_texture)

add_menu_texture(menu_texture)

add_text_box_texture(text_box_texture)

add_window_texture(window_texture)

set_font(font_size, font_color, font_name=None)

class arcade.Tile

Bases: object

This class represents an individual tile from a tileset.

class arcade.TiledMap

Bases: object

This class holds a tiled map, and tile set from the map.

class arcade.View(window: arcade.Window = None)

Bases: object

Support different views/screens in a window.

on_draw()

Called when this view should draw

on_key_press(symbol: int, modifiers: int)

Override this function to add key press functionality.

Parameters

• symbol (int) – Key that was hit

• modifiers (int) – If it was shift/ctrl/alt

on_key_release(_symbol: int, _modifiers: int)

Override this function to add key release functionality.

Parameters

• _symbol (int) – Key that was hit

• _modifiers (int) – If it was shift/ctrl/alt

on_mouse_drag(x: float, y: float, dx: float, dy: float, _buttons: int, _modifiers: int)

Override this function to add mouse button functionality.

Parameters

• x (float) – x position of mouse

• y (float) – y position of mouse

• dx (float) – Change in x since the last time this method was called

• dy (float) – Change in y since the last time this method was called

• _buttons (int) – Which button is pressed

• _modifiers (int) – Ctrl, shift, etc.

on_mouse_motion(x: float, y: float, dx: float, dy: float)

Override this function to add mouse functionality.

Parameters

• x (float) – x position of mouse

• y (float) – y position of mouse

• dx (float) – Change in x since the last time this method was called

• dy (float) – Change in y since the last time this method was called

on_mouse_press(x: float, y: float, button: int, modifiers: int)

Override this function to add mouse button functionality.

Parameters

• x (float) – x position of the mouse

• y (float) – y position of the mouse

• button (int) – What button was hit. One of: arcade.MOUSE_BUTTON_LEFT, arcade.MOUSE_BUTTON_RIGHT, arcade.MOUSE_BUTTON_MIDDLE

• modifiers (int) – Shift/click, ctrl/click, etc.

on_mouse_release(x: float, y: float, button: int, modifiers: int)

Override this function to add mouse button functionality.

Parameters

• x (float) –

• y (float) –

• button (int) –

• modifiers (int) –

on_mouse_scroll(x: int, y: int, scroll_x: int, scroll_y: int)

User moves the scroll wheel.

Parameters

• x (int) –

• y (int) –

• scroll_x (int) –

• scroll_y (int) –

on_show()

Called when this view is shown

on_update(delta_time: float)

To be overridden

update(delta_time: float)

To be overridden

class arcade.Window(width: int = 800, height: int = 600, title: str = 'Arcade Window', fullscreen: bool = False, resizable: bool = False, update_rate: Optional[float] = 0.016666666666666666, antialiasing: bool = True, screen: pyglet.canvas.base.Screen = None)

Bases: pyglet.window.BaseWindow

The Window class forms the basis of most advanced games that use Arcade. It represents a window on the screen, and manages events.

activate()

Activate this window.

center_window()

Center the window on the screen.

close()

Close the Window.

property current_view

This property returns the current view being shown. To set a different view, call the arcade.Window.show_view() method.

dispatch_events()

Dispatch events

flip()

Swap OpenGL and backing buffers for double-buffered windows.

get_location() → Tuple[int, int]

Return the X/Y coordinates of the window

Returns

x, y of window location

get_size() → Tuple[int, int]

Get the size of the window.

Returns

(width, height)

get_system_mouse_cursor(name)

Get the system mouse cursor

get_viewport() → Tuple[float, float, float, float]

Get the viewport. (What coordinates we can see.)

maximize()

Maximize the window.

minimize()

Minimize the window.

on_draw()

Override this function to add your custom drawing code.

on_key_press(symbol: int, modifiers: int)

Override this function to add key press functionality.

Parameters

• symbol (int) – Key that was hit

• modifiers (int) – If it was shift/ctrl/alt

on_key_release(symbol: int, modifiers: int)

Override this function to add key release functionality.

Parameters

• symbol (int) – Key that was hit

• modifiers (int) – If it was shift/ctrl/alt

on_mouse_drag(x: float, y: float, dx: float, dy: float, buttons: int, modifiers: int)

Override this function to add mouse button functionality.

Parameters

• x (float) – x position of mouse

• y (float) – y position of mouse

• dx (float) – Change in x since the last time this method was called

• dy (float) – Change in y since the last time this method was called

• buttons (int) – Which button is pressed

• modifiers (int) – Ctrl, shift, etc.

on_mouse_motion(x: float, y: float, dx: float, dy: float)

Override this function to add mouse functionality.

Parameters

• x (float) – x position of mouse

• y (float) – y position of mouse

• dx (float) – Change in x since the last time this method was called

• dy (float) – Change in y since the last time this method was called

on_mouse_press(x: float, y: float, button: int, modifiers: int)

Override this function to add mouse button functionality.

Parameters

• x (float) – x position of the mouse

• y (float) – y position of the mouse

• button (int) – What button was hit. One of: arcade.MOUSE_BUTTON_LEFT, arcade.MOUSE_BUTTON_RIGHT, arcade.MOUSE_BUTTON_MIDDLE

• modifiers (int) – Shift/click, ctrl/click, etc.

on_mouse_release(x: float, y: float, button: int, modifiers: int)

Override this function to add mouse button functionality.

Parameters

• x (float) –

• y (float) –

• button (int) –

• modifiers (int) –

on_mouse_scroll(x: int, y: int, scroll_x: int, scroll_y: int)

User moves the scroll wheel.

Parameters

• x (int) –

• y (int) –

• scroll_x (int) –

• scroll_y (int) –

on_resize(width: float, height: float)

Override this function to add custom code to be called any time the window is resized. The only responsibility here is to update the viewport.

Parameters

• width (float) – New width

• height (float) – New height

on_update(delta_time: float)

Move everything. Perform collision checks. Do all the game logic here.

Parameters

delta_time (float) – Time interval since the last time the function was called.

set_caption(caption)

Set the caption for the window.

set_exclusive_keyboard(exclusive=True)

Capture all keyboard input.

set_exclusive_mouse(exclusive=True)

Capture the mouse.

set_fullscreen(fullscreen=True, screen=None, mode=None, width=None, height=None)

Set if we are full screen or not.

Parameters

• fullscreen (bool) –

• screen –

• mode –

• width (int) –

• height (int) –

set_location(x, y)

Set location of the window.

set_max_size(width: float, height: float)

Wrap the Pyglet window call to set maximum size

Parameters

• width (float) – width in pixels.

• height (float) – height in pixels.

Raises ValueError

set_maximum_size(width, height)

Set largest window size.

set_min_size(width: float, height: float)

Wrap the Pyglet window call to set minimum size

Parameters

• width (float) – width in pixels.

• height (float) – height in pixels.

set_minimum_size(width: int, height: int)

Set smallest window size.

set_mouse_platform_visible(platform_visible=None)

This does something.

set_mouse_visible(visible: bool = True)

If true, user can see the mouse cursor while it is over the window. Set false, the mouse is not visible. Default is true.

Parameters

visible (bool) –

set_size(width: float, height: float)

Ignore the resizable flag and set the size

Parameters

• width (float) –

• height (float) –

set_update_rate(rate: float)

Set how often the screen should be updated. For example, self.set_update_rate(1 / 60) will set the update rate to 60 fps

Parameters

rate (float) – Update frequency in seconds

set_viewport(left: float, right: float, bottom: float, top: float)

Set the viewport. (What coordinates we can see. Used to scale and/or scroll the screen.)

Parameters

• left (Number) –

• right (Number) –

• bottom (Number) –

• top (Number) –

set_visible(visible=True)

Set if the window is visible or not. Normally, a program’s window is visible.

Parameters

visible (bool) –

set_vsync(vsync: bool)

Set if we sync our draws to the monitors vertical sync rate.

show_view(new_view: arcade.View)

Select the view to show. Calling this function is the same as setting the arcade.Window.current_view() attribute.

Parameters

new_view (View) – View to show

switch_to()

Switch the this window.

test(frames: int = 10)

Used by unit test cases. Runs the event loop a few times and stops.

Parameters

frames (int) –

update(delta_time: float)

Move everything. For better consistency in naming, use on_update instead.

Parameters

delta_time (float) – Time interval since the last time the function was called in seconds.

use()

Bind the window’s framebuffer for rendering commands

arcade.are_polygons_intersecting(poly_a: Sequence[Union[Tuple[float, float], List[float]]], poly_b: Sequence[Union[Tuple[float, float], List[float]]]) → bool

Return True if two polygons intersect.

Parameters

• poly_a (PointList) – List of points that define the first polygon.

• poly_b (PointList) – List of points that define the second polygon.

Returns

True or false depending if polygons intersect

Rtype bool

arcade.astar_calculate_path(start_point: Union[Tuple[float, float], List[float]], end_point: Union[Tuple[float, float], List[float]], astar_barrier_list: arcade.paths.AStarBarrierList, diagonal_movement=True)

Parameters

• start_point (Point) –

• end_point (Point) –

• barrier_list (AStarBarrierList) –

• diagonal_movement (bool) –

Returns: List

arcade.calculate_points(image)

Given an image, this returns points that make up a hit box around it. Attempts to trim out transparent pixels.

Parameters

image (Image) –

Returns

List of points

arcade.check_for_collision(sprite1: arcade.Sprite, sprite2: arcade.Sprite) → bool

Check for a collision between two sprites.

Parameters

• sprite1 – First sprite

• sprite2 – Second sprite

Returns

True or False depending if the sprites intersect.

arcade.check_for_collision_with_list(sprite: arcade.Sprite, sprite_list: arcade.SpriteList) → List[arcade.Sprite]

Check for a collision between a sprite, and a list of sprites.

Parameters

• sprite (Sprite) – Sprite to check

• sprite_list (SpriteList) – SpriteList to check against

Returns

List of sprites colliding, or an empty list.

arcade.clamp(a, low, high)

arcade.cleanup_texture_cache()

This cleans up the cache of textures. Useful when running unit tests so that the next test starts clean.

arcade.close_window()

Closes the current window, and then runs garbage collection. The garbage collection is necessary to prevent crashing when opening/closing windows rapidly (usually during unit tests).

arcade.create_ellipse(center_x: float, center_y: float, width: float, height: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], border_width: float = 1, tilt_angle: float = 0, num_segments: int = 32, filled=True) → arcade.Shape

This creates an ellipse vertex buffer object (VBO).

The function returns a Shape object that can be drawn with my_shape.draw(). Don’t create the shape in the draw method, create it in the setup method and then draw it in on_draw.

For even faster performance, add multiple shapes into a ShapeElementList and draw that list. This allows nearly unlimited shapes to be drawn just as fast as one.

arcade.create_ellipse_filled(center_x: float, center_y: float, width: float, height: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], tilt_angle: float = 0, num_segments: int = 128) → arcade.Shape

Create a filled ellipse. Or circle if you use the same width and height.

The function returns a Shape object that can be drawn with my_shape.draw(). Don’t create the shape in the draw method, create it in the setup method and then draw it in on_draw.

For even faster performance, add multiple shapes into a ShapeElementList and draw that list. This allows nearly unlimited shapes to be drawn just as fast as one.

arcade.create_ellipse_filled_with_colors(center_x: float, center_y: float, width: float, height: float, outside_color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], inside_color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], tilt_angle: float = 0, num_segments: int = 32) → arcade.Shape

Draw an ellipse, and specify inside/outside color. Used for doing gradients.

The function returns a Shape object that can be drawn with my_shape.draw(). Don’t create the shape in the draw method, create it in the setup method and then draw it in on_draw.

For even faster performance, add multiple shapes into a ShapeElementList and draw that list. This allows nearly unlimited shapes to be drawn just as fast as one.

Parameters

• center_x (float) –

• center_y (float) –

• width (float) –

• height (float) –

• outside_color (Color) –

• inside_color (float) –

• tilt_angle (float) –

• num_segments (int) –

Returns Shape

arcade.create_ellipse_outline(center_x: float, center_y: float, width: float, height: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], border_width: float = 1, tilt_angle: float = 0, num_segments: int = 128) → arcade.Shape

Create an outline of an ellipse.

The function returns a Shape object that can be drawn with my_shape.draw(). Don’t create the shape in the draw method, create it in the setup method and then draw it in on_draw.

For even faster performance, add multiple shapes into a ShapeElementList and draw that list. This allows nearly unlimited shapes to be drawn just as fast as one.

arcade.create_isometric_grid_lines(width, height, tile_width, tile_height, color, line_width)

arcade.create_line(start_x: float, start_y: float, end_x: float, end_y: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], line_width: float = 1) → arcade.Shape

Create a line to be rendered later. This works faster than draw_line because the vertexes are only loaded to the graphics card once, rather than each frame.

Parameters

• start_x (float) –

• start_y (float) –

• end_x (float) –

• end_y (float) –

• color (Color) –

• line_width (float) –

Returns Shape

arcade.create_line_generic(point_list: Sequence[Union[Tuple[float, float], List[float]]], color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], shape_mode: int, line_width: float = 1) → arcade.Shape

This function is used by create_line_strip and create_line_loop, just changing the OpenGL type for the line drawing.

arcade.create_line_generic_with_colors(point_list: Sequence[Union[Tuple[float, float], List[float]]], color_list: Iterable[Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]]], shape_mode: int, line_width: float = 1) → arcade.Shape

This function is used by create_line_strip and create_line_loop, just changing the OpenGL type for the line drawing.

Parameters

• point_list (PointList) –

• color_list (Iterable[Color]) –

• shape_mode (float) –

• line_width (float) –

Returns Shape

arcade.create_line_loop(point_list: Sequence[Union[Tuple[float, float], List[float]]], color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], line_width: float = 1)

Create a multi-point line loop to be rendered later. This works faster than draw_line because the vertexes are only loaded to the graphics card once, rather than each frame.

Parameters

• point_list (PointList) –

• color (Color) –

• line_width (float) –

Returns Shape

arcade.create_line_strip(point_list: Sequence[Union[Tuple[float, float], List[float]]], color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], line_width: float = 1)

Create a multi-point line to be rendered later. This works faster than draw_line because the vertexes are only loaded to the graphics card once, rather than each frame.

Internally, thick lines are created by two triangles.

Parameters

• point_list (PointList) –

• color (Color) –

• line_width (PointList) –

Returns Shape

arcade.create_lines(point_list: Sequence[Union[Tuple[float, float], List[float]]], color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], line_width: float = 1)

Create a multi-point line loop to be rendered later. This works faster than draw_line because the vertexes are only loaded to the graphics card once, rather than each frame.

Parameters

• point_list (PointList) –

• color (Color) –

• line_width (float) –

Returns Shape

arcade.create_lines_with_colors(point_list: Sequence[Union[Tuple[float, float], List[float]]], color_list: Sequence[Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]]], line_width: float = 1)

arcade.create_orthogonal_projection(left, right, bottom, top, near, far, dtype=None)

Creates an orthogonal projection matrix. Used internally with the OpenGL shaders.

Parameters

• left (float) – The left of the near plane relative to the plane’s center.

• right (float) – The right of the near plane relative to the plane’s center.

• top (float) – The top of the near plane relative to the plane’s center.

• bottom (float) – The bottom of the near plane relative to the plane’s center.

• near (float) – The distance of the near plane from the camera’s origin. It is recommended that the near plane is set to 1.0 or above to avoid rendering issues at close range.

• far (float) – The distance of the far plane from the camera’s origin.

• dtype –

Returns

A projection matrix representing the specified orthogonal perspective.

Return type

numpy.array

See also

http://msdn.microsoft.com/en-us/library/dd373965(v=vs.85).aspx

arcade.create_polygon(point_list: Sequence[Union[Tuple[float, float], List[float]]], color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]])

Draw a convex polygon. This will NOT draw a concave polygon. Because of this, you might not want to use this function.

The function returns a Shape object that can be drawn with my_shape.draw(). Don’t create the shape in the draw method, create it in the setup method and then draw it in on_draw.

For even faster performance, add multiple shapes into a ShapeElementList and draw that list. This allows nearly unlimited shapes to be drawn just as fast as one.

Parameters

• point_list (PointList) –

• color –

Returns Shape

arcade.create_rectangle(center_x: float, center_y: float, width: float, height: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], border_width: float = 1, tilt_angle: float = 0, filled=True) → arcade.Shape

This function creates a rectangle using a vertex buffer object.

The function returns a Shape object that can be drawn with my_shape.draw(). Don’t create the shape in the draw method, create it in the setup method and then draw it in on_draw.

For even faster performance, add multiple shapes into a ShapeElementList and draw that list. This allows nearly unlimited shapes to be drawn just as fast as one.

Parameters

• center_x (float) –

• center_y (float) –

• width (float) –

• height (float) –

• color (Color) –

• border_width (float) –

• tilt_angle (float) –

• filled (bool) –

arcade.create_rectangle_filled(center_x: float, center_y: float, width: float, height: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], tilt_angle: float = 0) → arcade.Shape

Create a filled rectangle.

The function returns a Shape object that can be drawn with my_shape.draw(). Don’t create the shape in the draw method, create it in the setup method and then draw it in on_draw.

For even faster performance, add multiple shapes into a ShapeElementList and draw that list. This allows nearly unlimited shapes to be drawn just as fast as one.

Parameters

• center_x (float) –

• center_y (float) –

• width (float) –

• height (float) –

• color (Color) –

• tilt_angle (float) –

Returns Shape

arcade.create_rectangle_filled_with_colors(point_list, color_list) → arcade.Shape

This function creates one rectangle/quad using a vertex buffer object.

The function returns a Shape object that can be drawn with my_shape.draw(). Don’t create the shape in the draw method, create it in the setup method and then draw it in on_draw.

For even faster performance, add multiple shapes into a ShapeElementList and draw that list. This allows nearly unlimited shapes to be drawn just as fast as one.

arcade.create_rectangle_outline(center_x: float, center_y: float, width: float, height: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], border_width: float = 1, tilt_angle: float = 0) → arcade.Shape

Create a rectangle outline.

The function returns a Shape object that can be drawn with my_shape.draw(). Don’t create the shape in the draw method, create it in the setup method and then draw it in on_draw.

For even faster performance, add multiple shapes into a ShapeElementList and draw that list. This allows nearly unlimited shapes to be drawn just as fast as one.

Args:

center_x: center_y: width: height: color: border_width: tilt_angle:

Returns:

arcade.create_rectangles_filled_with_colors(point_list, color_list) → arcade.Shape

This function creates multiple rectangle/quads using a vertex buffer object.

The function returns a Shape object that can be drawn with my_shape.draw(). Don’t create the shape in the draw method, create it in the setup method and then draw it in on_draw.

For even faster performance, add multiple shapes into a ShapeElementList and draw that list. This allows nearly unlimited shapes to be drawn just as fast as one.

arcade.create_text(text: str, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], font_size: float = 12, width: int = 0, align='left', font_name='Calibri', 'Arial', bold: bool = False, italic: bool = False, anchor_x: str = 'left', anchor_y: str = 'baseline', rotation=0)

Deprecated. Two step text drawing for backwards compatibility.

arcade.create_triangles_filled_with_colors(point_list, color_list) → arcade.Shape

This function creates multiple rectangle/quads using a vertex buffer object.

The function returns a Shape object that can be drawn with my_shape.draw(). Don’t create the shape in the draw method, create it in the setup method and then draw it in on_draw.

For even faster performance, add multiple shapes into a ShapeElementList and draw that list. This allows nearly unlimited shapes to be drawn just as fast as one.

arcade.draw_arc_filled(center_x: float, center_y: float, width: float, height: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], start_angle: float, end_angle: float, tilt_angle: float = 0, num_segments: int = 128)

Draw a filled in arc. Useful for drawing pie-wedges, or Pac-Man.

Parameters

• center_x (float) – x position that is the center of the arc.

• center_y (float) – y position that is the center of the arc.

• width (float) – width of the arc.

• height (float) – height of the arc.

• color (Color) – color, specified in a list of 3 or 4 bytes in RGB or RGBA format.

• start_angle (float) – start angle of the arc in degrees.

• end_angle (float) – end angle of the arc in degrees.

• tilt_angle (float) – angle the arc is tilted.

• num_segments (float) – Number of line segments used to draw arc.

arcade.draw_arc_outline(center_x: float, center_y: float, width: float, height: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], start_angle: float, end_angle: float, border_width: float = 1, tilt_angle: float = 0, num_segments: int = 128)

Draw the outside edge of an arc. Useful for drawing curved lines.

Parameters

• center_x (float) – x position that is the center of the arc.

• center_y (float) – y position that is the center of the arc.

• width (float) – width of the arc.

• height (float) – height of the arc.

• color (Color) – color, specified in a list of 3 or 4 bytes in RGB or RGBA format.

• start_angle (float) – start angle of the arc in degrees.

• end_angle (float) – end angle of the arc in degrees.

• border_width (float) – width of line in pixels.

• tilt_angle (float) – angle the arc is tilted.

• num_segments (int) – float of triangle segments that make up this circle. Higher is better quality, but slower render time.

arcade.draw_circle_filled(center_x: float, center_y: float, radius: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], num_segments: int = - 1)

Draw a filled-in circle.

Parameters

• center_x (float) – x position that is the center of the circle.

• center_y (float) – y position that is the center of the circle.

• radius (float) – width of the circle.

• color (Color) – color, specified in a list of 3 or 4 bytes in RGB or RGBA format.

• num_segments (int) – Number of triangle segments that make up this circle. Higher is better quality, but slower render time. The default value of -1 means arcade will try to calulate a reasonable amount of segments based on the size of the circle.

arcade.draw_circle_outline(center_x: float, center_y: float, radius: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], border_width: float = 1, num_segments: int = - 1)

Draw the outline of a circle.

Parameters

• center_x (float) – x position that is the center of the circle.

• center_y (float) – y position that is the center of the circle.

• radius (float) – width of the circle.

• color (Color) – color, specified in a list of 3 or 4 bytes in RGB or RGBA format.

• border_width (float) – Width of the circle outline in pixels.

• num_segments (int) – Number of triangle segments that make up this circle. Higher is better quality, but slower render time. The default value of -1 means arcade will try to calulate a reasonable amount of segments based on the size of the circle.

arcade.draw_ellipse_filled(center_x: float, center_y: float, width: float, height: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], tilt_angle: float = 0, num_segments: int = - 1)

Draw a filled in ellipse.

Parameters

• center_x (float) – x position that is the center of the circle.

• center_y (float) – y position that is the center of the circle.

• width (float) – width of the ellipse.

• height (float) – height of the ellipse.

• color (Color) – color, specified in a list of 3 or 4 bytes in RGB or RGBA format.

• tilt_angle (float) – Angle in degrees to tilt the ellipse.

• num_segments (int) – Number of triangle segments that make up this circle. Higher is better quality, but slower render time. The default value of -1 means arcade will try to calulate a reasonable amount of segments based on the size of the circle.

arcade.draw_ellipse_outline(center_x: float, center_y: float, width: float, height: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], border_width: float = 1, tilt_angle: float = 0, num_segments: int = - 1)

Draw the outline of an ellipse.

Parameters

• center_x (float) – x position that is the center of the circle.

• center_y (float) – y position that is the center of the circle.

• width (float) – width of the ellipse.

• height (float) – height of the ellipse.

• color (Color) – color, specified in a list of 3 or 4 bytes in RGB or RGBA format.

• border_width (float) – Width of the circle outline in pixels.

• tilt_angle (float) – Angle in degrees to tilt the ellipse.

• num_segments (int) – Number of triangle segments that make up this circle. Higher is better quality, but slower render time. The default value of -1 means arcade will try to calulate a reasonable amount of segments based on the size of the circle.

arcade.draw_line(start_x: float, start_y: float, end_x: float, end_y: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], line_width: float = 1)

Draw a line.

Parameters

• start_x (float) – x position of line starting point.

• start_y (float) – y position of line starting point.

• end_x (float) – x position of line ending point.

• end_y (float) – y position of line ending point.

• color (Color) – color, specified in a list of 3 or 4 bytes in RGB or RGBA format.

• line_width (float) – Width of the line in pixels.

arcade.draw_line_strip(point_list: Sequence[Union[Tuple[float, float], List[float]]], color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], line_width: float = 1)

Draw a multi-point line.

Parameters

• point_list (PointList) – List of x, y points that make up this strip

• color (Color) – Color of line strip

• line_width (float) – Width of the line

arcade.draw_lines(point_list: Sequence[Union[Tuple[float, float], List[float]]], color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], line_width: float = 1)

Draw a set of lines.

Draw a line between each pair of points specified.

Parameters

• point_list (PointList) – List of points making up the lines. Each point is in a list. So it is a list of lists.

• color (Color) – color, specified in a list of 3 or 4 bytes in RGB or RGBA format.

• line_width (float) – Width of the line in pixels.

arcade.draw_lrtb_rectangle_filled(left: float, right: float, top: float, bottom: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]])

Draw a rectangle by specifying left, right, top, and bottom edges.

Parameters

• left (float) – The x coordinate of the left edge of the rectangle.

• right (float) – The x coordinate of the right edge of the rectangle.

• top (float) – The y coordinate of the top of the rectangle.

• bottom (float) – The y coordinate of the rectangle bottom.

• color (Color) – The color of the rectangle.

Raises AttributeError

Raised if left > right or top < bottom.

arcade.draw_lrtb_rectangle_outline(left: float, right: float, top: float, bottom: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], border_width: float = 1)

Draw a rectangle by specifying left, right, top, and bottom edges.

Parameters

• left (float) – The x coordinate of the left edge of the rectangle.

• right (float) – The x coordinate of the right edge of the rectangle.

• top (float) – The y coordinate of the top of the rectangle.

• bottom (float) – The y coordinate of the rectangle bottom.

• color (Color) – The color of the rectangle.

• border_width (float) – The width of the border in pixels. Defaults to one.

Raises AttributeError

Raised if left > right or top < bottom.

arcade.draw_lrwh_rectangle_textured(bottom_left_x: float, bottom_left_y: float, width: float, height: float, texture: arcade.texture.Texture, angle: float = 0, alpha: int = 255)

Draw a texture extending from bottom left to top right.

Parameters

• bottom_left_x (float) – The x coordinate of the left edge of the rectangle.

• bottom_left_y (float) – The y coordinate of the bottom of the rectangle.

• width (float) – The width of the rectangle.

• height (float) – The height of the rectangle.

• texture (int) – identifier of texture returned from load_texture() call

• angle (float) – rotation of the rectangle. Defaults to zero.

• alpha (int) – Transparency of image. 0 is fully transparent, 255 (default) is visible

arcade.draw_parabola_filled(start_x: float, start_y: float, end_x: float, height: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], tilt_angle: float = 0)

Draws a filled in parabola.

Parameters

• start_x (float) – The starting x position of the parabola

• start_y (float) – The starting y position of the parabola

• end_x (float) – The ending x position of the parabola

• height (float) – The height of the parabola

• color (Color) – The color of the parabola

• tilt_angle (float) – The angle of the tilt of the parabola

arcade.draw_parabola_outline(start_x: float, start_y: float, end_x: float, height: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], border_width: float = 1, tilt_angle: float = 0)

Draws the outline of a parabola.

Parameters

• start_x (float) – The starting x position of the parabola

• start_y (float) – The starting y position of the parabola

• end_x (float) – The ending x position of the parabola

• height (float) – The height of the parabola

• color (Color) – The color of the parabola

• border_width (float) – The width of the parabola

• tilt_angle (float) – The angle of the tilt of the parabola

arcade.draw_point(x: float, y: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], size: float)

Draw a point.

Parameters

• x (float) – x position of point.

• y (float) – y position of point.

• color (Color) – color, specified in a list of 3 or 4 bytes in RGB or RGBA format.

• size (float) – Size of the point in pixels.

arcade.draw_points(point_list: Sequence[Union[Tuple[float, float], List[float]]], color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], size: float = 1)

Draw a set of points.

Parameters

• point_list (PointList) – List of points Each point is in a list. So it is a list of lists.

• color (Color) – color, specified in a list of 3 or 4 bytes in RGB or RGBA format.

• size (float) – Size of the point in pixels.

arcade.draw_polygon_filled(point_list: Sequence[Union[Tuple[float, float], List[float]]], color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]])

Draw a polygon that is filled in.

Parameters

• point_list (PointList) – List of points making up the lines. Each point is in a list. So it is a list of lists.

• color (Color) – The color, specified in RGB or RGBA format.

arcade.draw_polygon_outline(point_list: Sequence[Union[Tuple[float, float], List[float]]], color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], line_width: float = 1)

Draw a polygon outline. Also known as a “line loop.”

Parameters

• point_list (PointList) – List of points making up the lines. Each point is in a list. So it is a list of lists.

• color (Color) – color, specified in a list of 3 or 4 bytes in RGB or RGBA format.

• line_width (int) – Width of the line in pixels.

arcade.draw_rectangle_filled(center_x: float, center_y: float, width: float, height: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], tilt_angle: float = 0)

Draw a filled-in rectangle.

Parameters

• center_x (float) – x coordinate of rectangle center.

• center_y (float) – y coordinate of rectangle center.

• width (float) – width of the rectangle.

• height (float) – height of the rectangle.

• color (Color) – color, specified in a list of 3 or 4 bytes in RGB or RGBA format.

• tilt_angle (float) – rotation of the rectangle. Defaults to zero.

arcade.draw_rectangle_outline(center_x: float, center_y: float, width: float, height: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], border_width: float = 1, tilt_angle: float = 0)

Draw a rectangle outline.

Parameters

• center_x (float) – x coordinate of top left rectangle point.

• center_y (float) – y coordinate of top left rectangle point.

• width (float) – width of the rectangle.

• height (float) – height of the rectangle.

• color (Color) – color, specified in a list of 3 or 4 bytes in RGB or RGBA format.

• border_width (float) – width of the lines, in pixels.

• tilt_angle (float) – rotation of the rectangle. Defaults to zero.

arcade.draw_scaled_texture_rectangle(center_x: float, center_y: float, texture: arcade.texture.Texture, scale: float = 1.0, angle: float = 0, alpha: int = 255)

Draw a textured rectangle on-screen.

Parameters

• center_x (float) – x coordinate of rectangle center.

• center_y (float) – y coordinate of rectangle center.

• texture (int) – identifier of texture returned from load_texture() call

• scale (float) – scale of texture

• angle (float) – rotation of the rectangle. Defaults to zero.

• alpha (float) – Transparency of image. 0 is fully transparent, 255 (default) is visible

arcade.draw_text(text: str, start_x: float, start_y: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], font_size: float = 12, width: int = 0, align: str = 'left', font_name: Union[str, Tuple[str, …]] = 'calibri', 'arial', bold: bool = False, italic: bool = False, anchor_x: str = 'left', anchor_y: str = 'baseline', rotation: float = 0) → arcade.Sprite

Draws text to the screen.

Internally this works by creating an image, and using the Pillow library to draw the text to it. Then use that image to create a sprite. We cache the sprite (so we don’t have to recreate over and over, which is slow) and use it to draw text to the screen.

This implementation does not support bold/italic like the older Pyglet-based implementation of draw_text. However if you specify the ‘italic’ or ‘bold’ version of the font via the font name, you will get that font. Just the booleans do not work.

Parameters

• text (str) – Text to draw

• start_x (float) – x coordinate of the lower-left point to start drawing text

• start_y (float) – y coordinate of the lower-left point to start drawing text

• color (Color) – Color of the text

• font_size (float) – Size of the text

• width (float) – Width of the text-box for the text to go into. Used with alignment.

• align (str) – Align left, right, center

• Tuple[str, ..]] font_name (Union[str,) – Font name, or list of font names in order of preference

• bold (bool) – Bold the font (currently unsupported)

• italic (bool) – Italicize the font (currently unsupported)

• anchor_x (str) – Anchor the font location, defaults to ‘left’

• anchor_y (str) – Anchor the font location, defaults to ‘baseline’

• rotation (float) – Rotate the text

arcade.draw_text_2(text: str, start_x: float, start_y: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], font_size: float = 12, width: int = 0, align: str = 'left', font_name: Union[str, Tuple[str, …]] = 'calibri', 'arial', bold: bool = False, italic: bool = False, anchor_x: str = 'left', anchor_y: str = 'baseline', rotation: float = 0)

Draws text to the screen using pyglet’s label instead. Doesn’t work.

Parameters

• text (str) – Text to draw

• start_x (float) –

• start_y (float) –

• color (Color) – Color of the text

• font_size (float) – Size of the text

• width (float) –

• align (str) –

• Tuple[str, ..]] font_name (Union[str,) –

• bold (bool) –

• italic (bool) –

• anchor_x (str) –

• anchor_y (str) –

• rotation (float) –

arcade.draw_texture_rectangle(center_x: float, center_y: float, width: float, height: float, texture: arcade.texture.Texture, angle: float = 0, alpha: int = 255)

Draw a textured rectangle on-screen.

Parameters

• center_x (float) – x coordinate of rectangle center.

• center_y (float) – y coordinate of rectangle center.

• width (float) – width of texture

• height (float) – height of texture

• texture (int) – identifier of texture returned from load_texture() call

• angle (float) – rotation of the rectangle. Defaults to zero.

• alpha (float) – Transparency of image. 0 is fully transparent, 255 (default) is visible

arcade.draw_triangle_filled(x1: float, y1: float, x2: float, y2: float, x3: float, y3: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]])

Draw a filled in triangle.

Parameters

• x1 (float) – x value of first coordinate.

• y1 (float) – y value of first coordinate.

• x2 (float) – x value of second coordinate.

• y2 (float) – y value of second coordinate.

• x3 (float) – x value of third coordinate.

• y3 (float) – y value of third coordinate.

• color (Color) – Color of triangle.

arcade.draw_triangle_outline(x1: float, y1: float, x2: float, y2: float, x3: float, y3: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], border_width: float = 1)

Draw a the outline of a triangle.

Parameters

• x1 (float) – x value of first coordinate.

• y1 (float) – y value of first coordinate.

• x2 (float) – x value of second coordinate.

• y2 (float) – y value of second coordinate.

• x3 (float) – x value of third coordinate.

• y3 (float) – y value of third coordinate.

• color (Color) – Color of triangle.

• border_width (float) – Width of the border in pixels. Defaults to 1.

arcade.draw_xywh_rectangle_filled(bottom_left_x: float, bottom_left_y: float, width: float, height: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]])

Draw a filled rectangle extending from bottom left to top right

Parameters

• bottom_left_x (float) – The x coordinate of the left edge of the rectangle.

• bottom_left_y (float) – The y coordinate of the bottom of the rectangle.

• width (float) – The width of the rectangle.

• height (float) – The height of the rectangle.

• color (Color) – The color of the rectangle.

arcade.draw_xywh_rectangle_outline(bottom_left_x: float, bottom_left_y: float, width: float, height: float, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], border_width: float = 1)

Draw a rectangle extending from bottom left to top right

Parameters

• bottom_left_x (float) – The x coordinate of the left edge of the rectangle.

• bottom_left_y (float) – The y coordinate of the bottom of the rectangle.

• width (float) – The width of the rectangle.

• height (float) – The height of the rectangle.

• color (Color) – The color of the rectangle.

• border_width (float) – The width of the border in pixels. Defaults to one.

arcade.earclip(polygon)

Simple earclipping algorithm for a given polygon p. polygon is expected to be an array of 2-tuples of the cartesian points of the polygon For a polygon with n points it will return n-2 triangles. The triangles are returned as an array of 3-tuples where each item in the tuple is a 2-tuple of the cartesian point.

Implementation Reference:

• https://www.geometrictools.com/Documentation/TriangulationByEarClipping.pdf

arcade.finish_render()

Swap buffers and displays what has been drawn. If programs use derive from the Window class, this function is automatically called.

arcade.generate_sprites(map_object: arcade.read_tiled_map.TiledMap, layer_name: str, scaling: float, base_directory='') → arcade.SpriteList

generate_sprites has been deprecated. Use arcade.tilemap.process_layer instead. Generate the sprites for a layer in a map.

Parameters

• map_object (TiledMap) – Map previously read in from read_tiled_map function

• layer_name – Name of the layer we want to generate sprites from. Case sensitive.

• scaling – Scaling factor.

• base_directory – Directory to read images from. Defaults to current directory.

Returns

List of sprites

Return type

SpriteList

arcade.get_closest_sprite(sprite: arcade.Sprite, sprite_list: arcade.SpriteList) → Optional[Tuple[arcade.Sprite, float]]

Given a Sprite and SpriteList, returns the closest sprite, and its distance.

Parameters

• sprite (Sprite) – Target sprite

• sprite_list (SpriteList) – List to search for closest sprite.

Returns

Closest sprite.

Return type

Sprite

arcade.get_display_size()

Return the resolution of the monitor

arcade.get_distance(x1: float, y1: float, x2: float, y2: float)

Get the distance between two points.

arcade.get_distance_between_sprites(sprite1: arcade.Sprite, sprite2: arcade.Sprite) → float

Returns the distance between the center of two given sprites :param Sprite sprite1: Sprite one :param Sprite sprite2: Sprite two :return: Distance :rtype: float

arcade.get_four_byte_color(color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]]) → Union[Tuple[int, int, int, int], List[int]]

Given a RGB list, it will return RGBA. Given a RGBA list, it will return the same RGBA.

Parameters

color (Color) – Three or four byte tuple

Returns

return: Four byte RGBA tuple

arcade.get_four_float_color(color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]]) → Tuple[float, float, float, float]

Given a 3 or 4 RGB/RGBA color where each color goes 0-255, this returns a RGBA tuple where each item is a scaled float from 0 to 1.

Parameters

color (Color) – Three or four byte tuple

Returns

Four floats as a RGBA tuple

arcade.get_game_controllers()

Get a list of all the game controllers

Returns

List of game controllers

arcade.get_image(x: int = 0, y: int = 0, width: int = None, height: int = None)

Get an image from the screen.

Parameters

• x (int) – Start (left) x location

• y (int) – Start (top) y location

• width (int) – Width of image. Leave blank for grabbing the ‘rest’ of the image

• height (int) – Height of image. Leave blank for grabbing the ‘rest’ of the image

You can save the image like:

image = get_image()
image.save('screenshot.png', 'PNG')

arcade.get_joysticks()

Get a list of all the game controllers

This is an alias of get_game_controllers, which is better worded.

Returns

List of game controllers

arcade.get_pixel(x: int, y: int) → Tuple[int, int, int]

Given an x, y, will return RGB color value of that point.

Parameters

• x (int) – x location

• y (int) – y location

Returns

Color

arcade.get_points_for_thick_line(start_x: float, start_y: float, end_x: float, end_y: float, line_width: float)

Function used internally for Arcade. OpenGL draws triangles only, so a think line must be two triangles that make up a rectangle. This calculates those points.

arcade.get_projection()

Returns the current projection.

Returns

Numpy array with projection.

arcade.get_rectangle_points(center_x: float, center_y: float, width: float, height: float, tilt_angle: float = 0) → Sequence[Union[Tuple[float, float], List[float]]]

Utility function that will return all four coordinate points of a rectangle given the x, y center, width, height, and rotation.

Args:

center_x: center_y: width: height: tilt_angle:

Returns:

arcade.get_scaling_factor(window)

Tries to get the scaling factor of the given Window. Currently works on MacOS only. Useful in figuring out what’s going on with Retina and high-res displays.

Parameters

window (Window) – Handle to window we want to get scaling factor of.

Returns

Scaling factor. E.g., 2 would indicate scaled up twice.

Return type

int

arcade.get_sprites_at_exact_point(point: Union[Tuple[float, float], List[float]], sprite_list: arcade.SpriteList) → List[arcade.Sprite]

Get a list of sprites at a particular point

Parameters

• point (Point) – Point to check

• sprite_list (SpriteList) – SpriteList to check against

Returns

List of sprites colliding, or an empty list.

arcade.get_sprites_at_point(point: Union[Tuple[float, float], List[float]], sprite_list: arcade.SpriteList) → List[arcade.Sprite]

Get a list of sprites at a particular point

Parameters

• point (Point) – Point to check

• sprite_list (SpriteList) – SpriteList to check against

Returns

List of sprites colliding, or an empty list.

arcade.get_text_image(text: str, text_color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], font_size: float = 12, width: int = 0, align: str = 'left', valign: str = 'top', font_name: Union[str, Tuple[str, …]] = 'calibri', 'arial', background_color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]] = None, height: int = 0)

arcade.get_tilemap_layer(map_object: pytiled_parser.objects.TileMap, layer_path: str) → Optional[pytiled_parser.objects.Layer]

Given a TileMap and a layer path, this returns the TileLayer.

Parameters

• map_object (pytiled_parser.objects.TileMap) – The map read in by the read_tmx function.

• layer_path (str) – A string to match the layer name. Case sensitive.

Returns

A TileLayer, or None if no layer was found.

arcade.get_viewport() → Tuple[float, float, float, float]

Get the current viewport settings.

Returns

Tuple of floats, with left, right, bottom, top

arcade.get_window() → Optional[pyglet.window.BaseWindow]

Return a handle to the current window.

Returns

Handle to the current window.

arcade.has_line_of_sight(point_1: Union[Tuple[float, float], List[float]], point_2: Union[Tuple[float, float], List[float]], walls: arcade.SpriteList, max_distance: int = - 1, check_resolution: int = 2)

Determine if we have line of sight between two points. Try to make sure that spatial hashing is enabled on the wall SpriteList or this will be very slow.

Parameters

• point_1 (Point) – Start position

• point_2 (Point) – End position position

• walls (SpriteList) – List of all blocking sprites

• max_distance (int) – Max distance point 1 can see

• check_resolution (int) – Check every x pixels for a sprite. Trade-off between accuracy and speed.

arcade.is_point_in_polygon(x, y, polygon_point_list)

Use ray-tracing to see if point is inside a polygon

Args:

x: y: polygon_point_list:

Returns: bool

arcade.isometric_grid_to_screen(tile_x, tile_y, width, height, tile_width, tile_height)

arcade.lerp(v1: float, v2: float, u: float) → float

linearly interpolate between two values

arcade.lerp_vec(v1: Union[Tuple[float, float], List[float]], v2: Union[Tuple[float, float], List[float]], u: float) → Union[Tuple[float, float], List[float]]

arcade.load_sound(path: Union[str, pathlib.Path])

Load a sound.

Parameters

file_name (str) – Name of the sound file to load.

Returns

Sound object

Return type

Sound

arcade.load_spritesheet(file_name: Union[str, pathlib.Path], sprite_width: int, sprite_height: int, columns: int, count: int, margin: int = 0) → List[arcade.texture.Texture]

Parameters

• file_name (str) – Name of the file to that holds the texture.

• sprite_width (int) – Width of the sprites in pixels

• sprite_height (int) – Height of the sprites in pixels

• columns (int) – Number of tiles wide the image is.

• count (int) – Number of tiles in the image.

Returns List

List of Texture objects.

arcade.load_texture(file_name: Union[str, pathlib.Path], x: float = 0, y: float = 0, width: float = 0, height: float = 0, flipped_horizontally: bool = False, flipped_vertically: bool = False, flipped_diagonally: bool = False, can_cache: bool = True, mirrored=None) → arcade.texture.Texture

Load an image from disk and create a texture.

Note: If the code is to load only part of the image, the given x, y coordinates will start with the origin (0, 0) in the upper left of the image. When drawing, Arcade uses (0, 0) in the lower left corner. Be careful with this reversal.

For a longer explanation of why computers sometimes start in the upper left, see: http://programarcadegames.com/index.php?chapter=introduction_to_graphics&lang=en#section_5

Parameters

• file_name (str) – Name of the file to that holds the texture.

• x (float) – X position of the crop area of the texture.

• y (float) – Y position of the crop area of the texture.

• width (float) – Width of the crop area of the texture.

• height (float) – Height of the crop area of the texture.

• flipped_horizontally (bool) – Mirror the sprite image. Flip left/right across vertical axis.

• flipped_vertically (bool) – Flip the image up/down across the horizontal axis.

• flipped_diagonally (bool) – Transpose the image, flip it across the diagonal.

• mirrored (bool) – Deprecated.

• can_cache (bool) – If a texture has already been loaded, load_texture will return the same texture in order to save time. Sometimes this is not desirable, as resizing a cached texture will cause all other textures to resize with it. Setting can_cache to false will prevent this issue at the experience of additional resources.

Returns

New Texture object.

Raises

ValueError

arcade.load_texture_pair(filename)

Load a texture pair, with the second being a mirror image of the first. Useful when doing animations and the character can face left/right.

arcade.load_textures(file_name: Union[str, pathlib.Path], image_location_list: Union[Tuple[Union[Tuple[float, float, float, float], List[float]], …], List[Union[Tuple[float, float, float, float], List[float]]]], mirrored: bool = False, flipped: bool = False) → List[arcade.texture.Texture]

Load a set of textures from a single image file.

Note: If the code is to load only part of the image, the given x, y coordinates will start with the origin (0, 0) in the upper left of the image. When drawing, Arcade uses (0, 0) in the lower left corner. Be careful with this reversal.

For a longer explanation of why computers sometimes start in the upper left, see: http://programarcadegames.com/index.php?chapter=introduction_to_graphics&lang=en#section_5

Parameters

• file_name (str) – Name of the file.

• image_location_list (List) – List of image sub-locations. Each rectangle should be a List of four floats: [x, y, width, height].

• mirrored (bool) – If set to True, the image is mirrored left to right.

• flipped (bool) – If set to True, the image is flipped upside down.

Returns

List of Texture’s.

Raises

ValueError

arcade.make_burst_emitter(center_xy: Union[Tuple[float, float], List[float]], filenames_and_textures: Sequence[Union[str, arcade.texture.Texture]], particle_count: int, particle_speed: float, particle_lifetime_min: float, particle_lifetime_max: float, particle_scale: float = 1.0, fade_particles: bool = True)

Returns an emitter that emits all of its particles at once

arcade.make_circle_texture(diameter: int, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]]) → arcade.texture.Texture

Return a Texture of a circle with the given diameter and color.

Parameters

• diameter (int) – Diameter of the circle and dimensions of the square Texture returned.

• color (Color) – Color of the circle.

Returns

New Texture object.

arcade.make_interval_emitter(center_xy: Union[Tuple[float, float], List[float]], filenames_and_textures: Sequence[Union[str, arcade.texture.Texture]], emit_interval: float, emit_duration: float, particle_speed: float, particle_lifetime_min: float, particle_lifetime_max: float, particle_scale: float = 1.0, fade_particles: bool = True)

Returns an emitter that emits its particles at a constant rate for a given amount of time

arcade.make_soft_circle_texture(diameter: int, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], center_alpha: int = 255, outer_alpha: int = 0) → arcade.texture.Texture

Return a Texture of a circle with the given diameter and color, fading out at its edges.

Parameters

• diameter (int) – Diameter of the circle and dimensions of the square Texture returned.

• color (Color) – Color of the circle.

• center_alpha (int) – Alpha value of the circle at its center.

• outer_alpha (int) – Alpha value of the circle at its edges.

Returns

New Texture object.

arcade.make_soft_square_texture(size: int, color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], center_alpha: int = 255, outer_alpha: int = 0) → arcade.texture.Texture

Return a Texture of a square with the given diameter and color, fading out at its edges.

Parameters

• size (int) – Diameter of the square and dimensions of the square Texture returned.

• color (Color) – Color of the square.

• center_alpha (int) – Alpha value of the square at its center.

• outer_alpha (int) – Alpha value of the square at its edges.

Returns

New Texture object.

arcade.make_transparent_color(color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]], transparency: float)

Given a RGB color, along with an alpha, returns a RGBA color tuple.

Parameters

• color (Color) – Three or four byte RGBA color

• transparency (float) – Transparency

arcade.open_window(width: int, height: int, window_title: str, resizable: bool = False, antialiasing: bool = True) → arcade.Window

This function opens a window. For ease-of-use we assume there will only be one window, and the programmer does not need to keep a handle to the window. This isn’t the best architecture, because the window handle is stored in a global, but it makes things easier for programmers if they don’t have to track a window pointer.

Parameters

• width (Number) – Width of the window.

• height (Number) – Height of the window.

• window_title (str) – Title of the window.

• resizable (bool) – Whether the window can be user-resizable.

• antialiasing (bool) – Smooth the graphics?

Returns

Handle to window

Rtype arcade.Window

arcade.pause(seconds: numbers.Number)

Pause for the specified number of seconds. This is a convenience function that just calls time.sleep()

Parameters

seconds (float) – Time interval to pause in seconds.

arcade.play_sound(sound: arcade.Sound, volume: float = 1.0, pan: float = 0.0)

Play a sound.

Parameters

• sound (Sound) – Sound loaded by load_sound. Do NOT use a string here for the filename.

• volume (float) – Volume, from 0=quiet to 1=loud

• pan (float) – Pan, from -1=left to 0=centered to 1=right

arcade.process_layer(map_object: pytiled_parser.objects.TileMap, layer_name: str, scaling: float = 1, base_directory: str = '', use_spatial_hash: bool = False) → arcade.SpriteList

This takes a map layer returned by the read_tmx function, and creates Sprites for it.

Parameters

• map_object – The TileMap read in by read_tmx.

• layer_name – The name of the layer that we are creating sprites for.

• scaling – Scaling the layer up or down. (Note, any number besides 1 can create a tearing effect, if numbers don’t evenly divide.)

• base_directory – Base directory of the file, that we start from to load images.

• use_spatial_hash – If all, or at least 75%, of the loaded tiles will not move between frames and you are using either the simple physics engine or platformer physics engine, set this to True to speed collision calculation. Leave False if using PyMunk, if all sprites are moving, or if no collision will be checked.

Returns

A SpriteList.

arcade.quick_run(time_to_pause: numbers.Number)

Only run the application for the specified time in seconds. Useful for unit testing or continuous integration (CI) testing where there is no user interaction.

Parameters

time_to_pause (Number) – Number of seconds to pause before automatically closing.

arcade.rand_angle_360_deg()

arcade.rand_angle_spread_deg(angle: float, half_angle_spread: float) → float

arcade.rand_in_circle(center: Union[Tuple[float, float], List[float]], radius: float)

Generate a point in a circle, or can think of it as a vector pointing a random direction with a random magnitude <= radius Reference: http://stackoverflow.com/a/30564123 Note: This algorithm returns a higher concentration of points around the center of the circle

arcade.rand_in_rect(bottom_left: Union[Tuple[float, float], List[float]], width: float, height: float) → Union[Tuple[float, float], List[float]]

arcade.rand_on_circle(center: Union[Tuple[float, float], List[float]], radius: float) → Union[Tuple[float, float], List[float]]

Note: by passing a random value in for float, you can achieve what rand_in_circle() does

arcade.rand_on_line(pos1: Union[Tuple[float, float], List[float]], pos2: Union[Tuple[float, float], List[float]]) → Union[Tuple[float, float], List[float]]

arcade.rand_vec_magnitude(angle: float, lo_magnitude: float, hi_magnitude: float) → Union[Tuple[float, float], List[float]]

arcade.rand_vec_spread_deg(angle: float, half_angle_spread: float, length: float) → Union[Tuple[float, float], List[float]]

arcade.read_tiled_map(tmx_file: str, scaling: float = 1, tsx_file: str = None) → arcade.read_tiled_map.TiledMap

read_tiled_map has been deprecated. Use arcade.tilemap.read_tmx instead.

Given a tmx_file, this will read in a tiled map, and return a TiledMap object.

Given a tsx_file, the map will use it as the tileset. If tsx_file is not specified, it will use the tileset specified within the tmx_file.

Important: Tiles must be a “collection” of images.

Hitboxes can be drawn around tiles in the tileset editor, but only polygons are supported. (This is a great area for PR’s to improve things.)

Parameters

• tmx_file (str) – String with name of our TMX file

• scaling (float) – Scaling factor. 0.5 will half all widths and heights

• tsx_file (str) – Tileset to use (can be specified in TMX file)

Returns

Map

Return type

TiledMap

arcade.read_tmx(tmx_file: Union[str, pathlib.Path]) → pytiled_parser.objects.TileMap

Given a .tmx, this will read in a tiled map, and return a TiledMap object.

Given a tsx_file, the map will use it as the tileset. If tsx_file is not specified, it will use the tileset specified within the tmx_file.

Important: Tiles must be a “collection” of images.

Hitboxes can be drawn around tiles in the tileset editor, but only polygons are supported. (This is a great area for PR’s to improve things.)

Parameters

tmx_file (str) – String with name of our TMX file

Returns

Map

Return type

TiledMap

arcade.render_text(text: arcade.CreateText, start_x: float, start_y: float)

Deprecated. Two step text drawing for backwards compatibility.

arcade.rotate_point(x: float, y: float, cx: float, cy: float, angle_degrees: float) → List[float]

Rotate a point around a center.

Parameters

• x – x value of the point you want to rotate

• y – y value of the point you want to rotate

• cx – x value of the center point you want to rotate around

• cy – y value of the center point you want to rotate around

• angle_degrees – Angle, in degrees, to rotate

Returns

Return rotated (x, y) pair

Return type

(float, float)

arcade.run()

Run the main loop. After the window has been set up, and the event hooks are in place, this is usually one of the last commands on the main program.

arcade.schedule(function_pointer: Callable, interval: numbers.Number)

Schedule a function to be automatically called every interval seconds.

Parameters

• function_pointer (Callable) – Pointer to the function to be called.

• interval (Number) – Interval to call the function.

arcade.screen_to_isometric_grid(screen_x, screen_y, width, height, tile_width, tile_height)

arcade.set_background_color(color: Union[Tuple[int, int, int], List[int], Tuple[int, int, int, int]])

This specifies the background color of the window.

Parameters

color (Color) – List of 3 or 4 bytes in RGB/RGBA format.

arcade.set_viewport(left: float, right: float, bottom: float, top: float)

This sets what coordinates the window will cover.

By default, the lower left coordinate will be (0, 0) and the top y coordinate will be the height of the window in pixels, and the right x coordinate will be the width of the window in pixels.

If a program is making a game where the user scrolls around a larger world, this command can help out.

Note: It is recommended to only set the view port to integer values that line up with the pixels on the screen. Otherwise if making a tiled game the blocks may not line up well, creating rectangle artifacts.

Parameters

• left (Number) – Left-most (smallest) x value.

• right (Number) – Right-most (largest) x value.

• bottom (Number) – Bottom (smallest) y value.

• top (Number) – Top (largest) y value.

arcade.set_window(window: pyglet.window.BaseWindow)

Set a handle to the current window.

Parameters

window (Window) – Handle to the current window.

arcade.start_render()

Get set up to render. Required to be called before drawing anything to the screen.

arcade.stop_sound(sound: arcade.Sound)

Stop a sound that is currently playing.

Parameters

sound –

arcade.trim_image(image: PIL.Image.Image) → PIL.Image.Image

Crops the extra whitespace out of an image.

Returns

New PIL.Image.Image object.

arcade.unschedule(function_pointer: Callable)

Unschedule a function being automatically called.

Parameters

function_pointer (Callable) – Pointer to the function to be unscheduled.