bascenev1 package

class bascenev1.Activity(settings: dict)

Bases: Generic

Units of execution wrangled by a bascenev1.Session.

Examples of activities include games, score-screens, cutscenes, etc. A bascenev1.Session has one ‘current’ activity at any time, though their existence can overlap during transitions.

add_actor_weak_ref(actor: bascenev1.Actor) → None

Add a weak-ref to a bascenev1.Actor to the activity.

(called by the bascenev1.Actor base class)

allow_kick_idle_players = True

Whether idle players can potentially be kicked (should not happen in menus/etc).

allow_mid_activity_joins: bool = True

Whether players should be allowed to join in the middle of this activity. Note that a bascenev1.Session may not allow mid-activity-joins even if the activity says it is ok.

allow_pausing = False

Whether scene-time should still progress when in menus/etc.

announce_player_deaths = False

Whether to print every time a player dies. This can be pertinent in games such as Death-Match but can be annoying in games where it doesn’t matter.

can_show_ad_on_death = False

Is it ok to show an ad after this activity ends before showing the next activity?

property context: bascenev1.ContextRef

A context-ref pointing at this activity.

create_player(sessionplayer: bascenev1.SessionPlayer) → PlayerT

Create a bascenev1.Player instance for this activity.

Note that the player object should not be used at this point as it is not yet fully wired up; wait for bascenev1.Activity.on_player_join() for that.

create_team(sessionteam: bascenev1.SessionTeam) → TeamT

Create a bascenev1.Team instance for this activity.

Subclasses can override this if the activity’s team class requires a custom constructor; otherwise it will be called with no args. Note that the team object should not be used at this point as it is not yet fully wired up; wait for bascenev1.Activity.on_team_join() for that.

property customdata: dict

Entities needing to store simple data with an activity can put it here. This dict will be deleted when the activity expires, so contained objects generally do not need to worry about handling expired activities.

end(results: Any = None, delay: float = 0.0, force: bool = False) → None

Commence activity shutdown and delivers results to the session.

‘delay’ is the time delay before the Activity actually ends (in seconds). Further end calls will be ignored up until this time, unless ‘force’ is True, in which case the new results will replace the old.

property expired: bool

Whether the activity is expired.

An activity is set as expired when shutting down. At this point no new nodes, timers, etc should be made, run, etc, and the activity should be considered a ‘zombie’.

property globalsnode: bascenev1.Node

The ‘globals’ Node for the activity.

This contains various global controls and values.

handlemessage(msg: Any) → Any

General message handling; can be passed any message object.

has_begun() → bool

Whether on_begin() has run.

has_ended() → bool

Return whether the activity has commenced ending.

has_transitioned_in() → bool

Whether on_transition_in() has run.

inherits_music = False

Set this to True to keep playing the music from the previous activity (without even restarting it).

inherits_slow_motion = False

Set this to True to inherit slow motion setting from previous activity (useful for transitions to avoid hitches).

inherits_tint = False

Set this to true to inherit screen tint/vignette colors from the previous activity (useful to prevent sudden color changes during transitions).

inherits_vr_camera_offset = False

Set this to true to inherit VR camera offsets from the previous activity (useful for preventing sporadic camera movement during transitions).

inherits_vr_overlay_center = False

Set this to true to inherit (non-fixed) VR overlay positioning from the previous activity (useful for prevent sporadic overlay jostling during transitions).

is_joining_activity = False

Joining activities are for waiting for initial player joins. They are treated slightly differently than regular activities, mainly in that all players are passed to the activity at once instead of as each joins.

is_transitioning_out() → bool

Whether on_transition_out() has run.

on_begin() → None

Called once the previous activity has finished transitioning out.

At this point the activity’s initial players and teams are filled in and it should begin its actual game logic.

on_expire() → None

Called when your activity is being expired.

If your activity has created anything explicitly that may be retaining a strong reference to the activity and preventing it from dying, you should clear that out here. From this point on your activity’s sole purpose in life is to hit zero references and die so the next activity can begin.

on_player_join(player: PlayerT) → None

Called when a player joins the activity.

(including the initial set of players)

on_player_leave(player: PlayerT) → None

Called when a player is leaving the Activity.

on_team_join(team: TeamT) → None

Called when a new team joins the activity.

(including the initial set of teams)

on_team_leave(team: TeamT) → None

Called when a team leaves the activity.

on_transition_in() → None

Called when the activity is first becoming visible.

Upon this call, the activity should fade in backgrounds, start playing music, etc. It does not yet have access to players or teams, however. They remain owned by the previous activity up until on_begin() is called.

on_transition_out() → None

Called when your activity begins transitioning out.

Note that this may happen at any time even if bascenev1.Activity.end() has not been called.

players: list[PlayerT]

The list of players in the activity. This gets populated just before on_begin() is called and is updated automatically as players join or leave the game.

property playertype: type[PlayerT]

The Player subclass this activity uses.

preloads: dict[type, Any]

Preloaded data for actors, maps, etc; indexed by type.

remove_player(sessionplayer: bascenev1.SessionPlayer) → None

Remove a player from the activity while it is running.

(internal)

retain_actor(actor: bascenev1.Actor) → None

Add a strong-ref to a bascenev1.Actor to this activity.

The reference will be lazily released once bascenev1.Actor.exists() returns False for the actor. The bascenev1.Actor.autoretain() method is a convenient way to access this same functionality.

property session: bascenev1.Session

The session this activity belongs to.

Raises a SessionNotFoundError if the session no longer exists.

settings_raw: dict[str, Any]

The settings dict passed in when the activity was made. This attribute is deprecated and should be avoided when possible; activities should pull all values they need from the settings arg passed to the activity’s __init__ call.

slow_motion = False

If True, runs in slow motion and turns down sound pitch.

property stats: bascenev1.Stats

The stats instance accessible while the activity is running.

If access is attempted before or after, raises a NotFoundError.

teams: list[TeamT]

The list of teams in the activity. This gets populated just before on_begin() is called and is updated automatically as players join or leave the game. (at least in free-for-all mode where every player gets their own team; in teams mode there are always 2 teams regardless of the player count).

property teamtype: type[TeamT]

The Team subclass this activity uses.

transition_time = 0.0

If the activity fades or transitions in, it should set the length of time here so that previous activities will be kept alive for that long (avoiding ‘holes’ in the screen) This value is given in real-time seconds.

use_fixed_vr_overlay = False

In vr mode, this determines whether overlay nodes (text, images, etc) are created at a fixed position in space or one that moves based on the current map. Generally this should be on for games and off for transitions/score-screens/etc. that persist between maps.

exception bascenev1.ActivityNotFoundError

Bases: NotFoundError

Raised when an expected activity does not exist.

class bascenev1.Actor

Bases: object

High level logical entities in an Activity.

Actors act as controllers, combining some number of Node, Texture, Sound, and other type objects into a high-level cohesive unit.

Some example actors include the Bomb, Flag, and Spaz, classes that live in the bascenev1lib.actor package.

One key feature of actors is that they generally ‘die’ (killing off or transitioning out their nodes) when the last Python reference to them disappears, so you can use logic such as:

# Create a flag actor in our game activity (self):
from bascenev1lib.actor.flag import Flag

self.flag = Flag(position=(0, 10, 0))

# Later, destroy the flag (provided nothing else is holding a
# reference to it). We could also just assign a new flag to this
# value. Either way, the old flag should disappear.
self.flag = None

This is in contrast to the behavior of the more low level Node class, which is always explicitly created and destroyed and doesn’t care how many Python references to it exist.

Note, however, that you can use the autoretain() method if you want an actor to stick around until explicitly killed regardless of references.

Another key feature of actors is their handlemessage() method, which takes a single arbitrary object as an argument. This provides a safe way to communicate between Actor, Activity, Session, and any other class providing a handlemessage() method. The most universally handled message type for actors is the DieMessage.

Another way to kill the flag from the example above: We can safely call this on any type with a handlemessage method (though its not guaranteed to always have a meaningful effect). In this case the actor instance will still be around, but its exists() and is_alive() methods will both return False:

self.flag.handlemessage(bascenev1.DieMessage())

property activity: bascenev1.Activity

The activity this actor was created in.

Raises a ActivityNotFoundError if the activity no longer exists.

autoretain() → Self

Keep this actor alive without needing to hold a reference to it.

This keeps the actor in existence by storing a reference to it with the Activity it was created in. The reference is lazily released once exists() returns False for the actor or when the Activity is set as expired. This can be a convenient alternative to storing references explicitly just to keep an actor from dying. For convenience, this method returns the actor it is called with, enabling chained statements such as: myflag = bascenev1.Flag().autoretain()

exists() → bool

Returns whether the actor is still present in a meaningful way.

Note that a dying character should still return True here as long as their corpse is visible; this is about presence, not being ‘alive’ (see is_alive() for that).

If this returns False, it is assumed the actor can be completely deleted without affecting the game; this call is often used when pruning lists of actors, such as with bascenev1.Actor.autoretain()

The default implementation of this method always return True.

Note that the boolean operator for the actor class calls this method, so a simple if myactor test will conveniently do the right thing even if myactor is set to None.

property expired: bool

Whether the actor is expired.

(see on_expire())

getactivity(doraise: Literal[True] = True) → bascenev1.Activity

getactivity(doraise: Literal[False]) → bascenev1.Activity | None

Return the activity this actor is associated with.

If the activity no longer exists, raises a ActivityNotFoundError or returns None depending on whether doraise is True.

handlemessage(msg: Any) → Any

General message handling; can be passed any message object.

is_alive() → bool

Returns whether the actor is ‘alive’.

What this means is up to the actor. It is not a requirement for actors to be able to die; just that they report whether they consider themselves to be alive or not. In cases where dead/alive is irrelevant, True should be returned.

on_expire() → None

Called for remaining actors when their activity dies.

Actors can use this opportunity to clear callbacks or other references which have the potential of keeping the Activity alive inadvertently (activities can not exit cleanly while any Python references to them remain.)

Once an actor is expired (see expired) it should no longer perform any game-affecting operations (creating, modifying, or deleting nodes, media, timers, etc.) Attempts to do so will likely result in errors.

class bascenev1.App

Bases: object

High level Ballistica app functionality and state.

Access the single shared instance of this class via the app attr available on various high level modules such as babase, bauiv1, and bascenev1.

SHUTDOWN_FAULTHANDLER_RUNWAY_SECONDS: float = 2.0

Extra time added to the suicide timer on faulthandler-capable platforms so the dump has room to complete before we die.

SHUTDOWN_SUICIDE_TIMEOUT_SECONDS: float = 15.0

Hard deadline for shutdown. The C++ side arms a suicide timer at this many seconds from the start of shutdown; if shutdown hasn’t completed by then we’re considered officially hung. On platforms where the Python faulthandler can write to fd 2, a traceback dump is also armed to fire at this same deadline (so we get a dump of every thread before we die) and the suicide timer is extended by SHUTDOWN_FAULTHANDLER_RUNWAY_SECONDS to give the dump time to finish writing.

SHUTDOWN_TASK_TIMEOUT_SECONDS = 12

How long we allow shutdown tasks to run before killing them. Currently the entire app hard-exits if shutdown takes 15 seconds, so we need to keep it under that. Staying above 10 should allow 10 second network timeouts to happen though.

property active: bool

Whether the app is currently front and center.

This will be False when the app is hidden, other activities are covering it, etc. (depending on the platform).

add_shutdown_task(coro: Coroutine[None, None, None]) → None

Add a task to be run on app shutdown.

All shutdown tasks will be run concurrently alongside a fade-out, so it is ok for them to take a moment or two to do their thing.

If a shutdown task is still running after SHUTDOWN_TASK_TIMEOUT_SECONDS, however, it will be canceled.

Code needing more exact control over its place in app shutdown can look into babase.atexit(), (though this comes with some limitations as well).

analytics: AnalyticsSubsystem

Subsystem for wrangling analytics.

assets: AssetSubsystem

Subsystem for acquiring + tracking downloadable asset packages.

property asyncio_loop: AbstractEventLoop

The logic thread’s asyncio event-loop.

This allows asyncio tasks to be run in the logic thread.

Generally you should call create_async_task() to schedule async code to run instead of using this directly. That will handle retaining the task and logging errors automatically. Only schedule tasks onto asyncio_loop yourself when you intend to hold on to the returned task and await its results. Releasing the task reference can lead to subtle bugs such as unreported errors and garbage-collected tasks disappearing before their work is done.

This loop is integrated directly into the logic thread’s event loop, so asyncio.get_running_loop() returns it from anywhere on the logic thread, and work posted from other threads (such as run_in_executor completions) wakes the logic thread immediately.

property classic: ClassicAppSubsystem | None

Our classic subsystem (if available).

config: AppConfig

Config values for the app.

create_async_task(coro: Coroutine[Any, Any, T], *, name: str | None = None) → None

Create a fully managed asyncio task.

This will automatically retain and release a reference to the task and log any exceptions that occur in it. If you need to await a task or otherwise need more control, schedule a task directly using asyncio_loop.

devconsole: DevConsoleSubsystem

Subsystem for wrangling the dev-console UI.

env: babase.Env

Static environment values for the app.

fg_state: int

Incremented each time the app leaves the SUSPENDED state. This can be a simple way to determine if network data should be refreshed/etc.

gc: GarbageCollectionSubsystem

Garbage collection related functionality.

get_convenience_imports() → dict[str, str | None]

Return active convenience imports.

This consists of a dict mapping module names to optional aliases. These are the modules that will be auto-imported into the REPL environment.

This can be set in the config as ‘Convenience Imports’. If it is not present there, defaults for the app are given.

handle_deep_link(url: str) → None

Handle a deep link URL.

health: AppHealthSubsystem

Subsystem for keeping tabs on app health.

lang: LanguageSubsystem

Language related functionality.

locale: LocaleSubsystem

Locale related functionality.

meta: MetadataSubsystem

Subsystem for wrangling metadata.

property mode: AppMode

The app’s current mode.

Raises ValueError if no mode is set.

property mode_selector: babase.AppModeSelector

Controls which app-modes are used for handling given intents.

Plugins can override this to change high level app behavior and spinoff projects can change the default implementation for the same effect.

net: NetworkSubsystem

Subsystem for network functionality.

plugins: PluginSubsystem

Subsystem for wrangling plugins.

property plus: PlusAppSubsystem | None

Our plus subsystem (if available).

register_subsystem(subsystem: T) → T

Register an AppSubsystem instance with the app.

Facilitates the subsystem receiving state callbacks, etc.

Note that subsystems can only be registered before the app completes its transition to the RUNNING state.

Returns the passed object for convenience in assigning it to an attr/etc.

run() → None

Run the app to completion.

Note that this only works on builds/runs where Ballistica is managing its own event loop.

set_intent(intent: AppIntent) → None

Set the intent for the app.

Intent defines what the app is trying to do at a given time. This call is asynchronous; the intent switch will happen in the logic thread in the near future. If this is called repeatedly before the change takes place, the final intent to be set will be used.

shutdown_fault_handler_arm() → float

Arm a Python traceback dump for shutdown diagnostics.

Called from the C++ shutdown path, colocated with the suicide-timer arm. Returns the number of seconds C++ should use for its suicide timer: SHUTDOWN_SUICIDE_TIMEOUT_SECONDS if the faulthandler dump can’t be armed (e.g. fd 2 is not available), or that value plus SHUTDOWN_FAULTHANDLER_RUNWAY_SECONDS if it was armed successfully — the extra time gives the dump room to finish writing before the process is killed.

Pairs with shutdown_fault_handler_disarm(), which is called at the end of _pre_interpreter_shutdown.

shutdown_fault_handler_disarm() → None

Cancel the shutdown faulthandler dump armed earlier.

Safe to call even if shutdown_fault_handler_arm() was never called or didn’t arm anything — in that case it’s a no-op.

property shutting_down: bool

Whether the app has begun (or completed) shutting down.

Becomes True once the app reaches SHUTTING_DOWN and remains True through SHUTDOWN_COMPLETE. Useful for long-running async work that should bow out quietly instead of erroring when app-level facilities (the threadpool, network, etc.) start getting torn down out from under it.

state: AppState

Current app state.

stringedit: StringEditSubsystem

Subsystem for wrangling text input from various sources.

threadpool: ThreadPoolExecutorEx

Default executor which can be used for misc background processing. It should also be passed to any additional asyncio loops we create so that everything shares the same single set of worker threads.

property ui_v1: UIV1AppSubsystem

Our ui_v1 subsystem (always available).

workspaces: WorkspaceSubsystem

Subsystem for wrangling workspaces.

class bascenev1.AppIntent

Bases: object

Base class for high level directives given to the app.

class bascenev1.AppIntentDefault

Bases: AppIntent

Tells the app to simply run in its default mode.

class bascenev1.AppIntentExec(code: str)

Bases: AppIntent

Tells the app to exec some Python code.

class bascenev1.AppMode

Bases: object

A low level mode the app can be in.

App-modes fundamentally change app behavior related to input handling, networking, graphics, and more. In a way, different app-modes can almost be considered different apps.

classmethod can_handle_intent(intent: AppIntent) → bool

Override this to define indent handling for an app-mode.

get_dev_console_ui_tab_buttons() → list[DevConsoleButtonDef]

Define buttons to show up in the UI dev console.

This can be useful for exposing UI code examples or debugging functionality.

handle_intent(intent: AppIntent) → None

Handle an intent.

on_activate() → None

Called when the mode is becoming the active one fro the app.

on_app_active_changed() → None

Called when the app’s active state changes while in this app-mode.

This corresponds to the app’s active attr. App-active state becomes false when the app is hidden, minimized, backgrounded, etc. The app-mode may want to take action such as pausing a running game or saving state when this occurs.

On platforms such as mobile where apps get suspended and later silently terminated by the OS, this is likely to be the last reliable place to save state/etc.

To best cover both mobile and desktop style platforms, actions such as saving state should generally happen in response to both on_deactivate() and on_app_active_changed() (when active is False).

on_deactivate() → None

Called when the mode stops being the active one for the app.

On platforms where the app is explicitly exited (such as desktop PC) this will also be called at app shutdown.

To best cover both mobile and desktop style platforms, actions such as saving state should generally happen in response to both on_deactivate() and on_app_active_changed() (when active is False).

class bascenev1.AppState(*values)

Bases: Enum

High level state the app can be in.

INITING = 2

Python app subsystems are being inited but should not yet interact or do any work.

LOADING = 3

Python app subsystems are inited and interacting, but the app has not yet embarked on a high level course of action. It is doing initial account logins, workspace & asset downloads, etc.

NATIVE_BOOTSTRAPPING = 1

The native layer is spinning up its machinery (screens, renderers, etc.). Nothing should happen in the Python layer until this completes.

NOT_STARTED = 0

The app has not yet begun starting and should not be used in any way.

RUNNING = 4

All pieces are in place and the app is now doing its thing.

SHUTDOWN_COMPLETE = 7

The app has completed shutdown. Any code running here should be basically immediate.

SHUTTING_DOWN = 6

The app is shutting down. This process may involve sending network messages or other things that can take up to a few seconds, so ideally graphics and audio should remain functional (with fades or spinners or whatever to show something is happening).

SUSPENDED = 5

Used on platforms such as mobile where the app basically needs to shut down while backgrounded. In this state, all event loops are suspended and all graphics and audio must cease completely. Be aware that the suspended state can be entered from any other state including NATIVE_BOOTSTRAPPING and SHUTTING_DOWN.

class bascenev1.AppTime

Monotonic time measurement that starts at 0 when the app launches and pauses while the app is suspended.

alias of float

class bascenev1.AppTimer(time: float, call: Callable[[], Any], repeat: bool = False)

Bases: object

Timers are used to run code at later points in time.

This class encapsulates a timer based on app-time. The underlying timer will be destroyed when this object is no longer referenced. If you do not want to worry about keeping a reference to your timer around, use the apptimer() function instead to get a one-off timer.

Parameters:

• time – Length of time in seconds that the timer will wait before firing.

• call – A callable Python object. Remember that the timer will retain a strong reference to the callable for as long as it exists, so you may want to look into concepts such as WeakCall if that is not desired.

• repeat – If True, the timer will fire repeatedly, with each successive firing having the same delay as the first.

Example: Use a timer object to print repeatedly for a few seconds:

def say_it():
    babase.screenmessage('BADGER!')

def stop_saying_it():
    global g_timer
    g_timer = None
    babase.screenmessage('MUSHROOM MUSHROOM!')

# Create our timer; it will run as long as we keep its ref alive.
g_timer = babase.AppTimer(0.3, say_it, repeat=True)

# Now fire off a one-shot timer to kill the ref.
babase.apptimer(3.89, stop_saying_it)

class bascenev1.BaseTime

Like Time but tied to the underlying scene’s clock rather than an activity — keeps advancing across activity transitions within the same session.

alias of float

class bascenev1.BaseTimer(time: float, call: Callable[[], Any], repeat: bool = False)

Bases: object

Timers are used to run code at later points in time.

This class encapsulates a base-time timer in the current scene context. The underlying timer will be destroyed when either this object is no longer referenced or when its context (activity, etc.) dies. If you do not want to worry about keeping a reference to your timer around, you should use the bascenev1.basetimer() function instead.

Parameters:

• time – Length of time in seconds that the timer will wait before firing.

• call – A callable Python object. Remember that the timer will retain a strong reference to the callable for as long as it exists, so you may want to look into concepts such as WeakCall if that is not desired.

• repeat – If True, the timer will fire repeatedly, with each successive firing having the same delay as the first.

Example

Use a base-timer object to print repeatedly for a few seconds:

import bascenev1 as bs

def say_it():
    bs.screenmessage('BADGER!')

def stop_saying_it():
    global g_timer
    g_timer = None
    bs.screenmessage('MUSHROOM MUSHROOM!')

# Create our timer; it will run as long as we keep its ref alive.
g_timer = bs.BaseTimer(0.3, say_it, repeat=True)

# Now fire off a one-shot timer to kill the ref.
bs.basetimer(3.89, stop_saying_it)

class bascenev1.BoolSetting(name: str, default: bool)

Bases: Setting

A boolean game setting.

default: bool

class bascenev1.Call(**kwargs)

Bases: object

Transitional alias of CallPartial.

Deprecated — pick CallPartial or CallStrict explicitly. The @deprecated decorator emits the runtime warning and is picked up by type-checkers/IDEs so call sites are flagged statically. The Call name will return after API 9 support ends but will then alias CallStrict, so migrating away now avoids a silent behavior change later.

class bascenev1.CallPartial(call: Any, /, *args: Any, **keywds: Any)

Bases: object

Wraps a callable and args into a single callable object.

The callable is strong-referenced so it won’t die until this object does.

Note that a bound method (ex: myobj.dosomething) contains a reference to self (myobj in that case), so you will be keeping that object alive too. Use babase.WeakCall if you want to pass a method to a callback without keeping its object alive.

Example: Wrap a method call with 1 positional and 1 keyword arg:

mycall = babase.Call(myobj.dostuff, argval, namedarg=argval2)

# Now we have a single callable to run that whole mess.
# ..the same as calling myobj.dostuff(argval, namedarg=argval2)
mycall()

class bascenev1.CallStrict(call: Callable[P, T], /, *args: P.args, **kwargs: P.kwargs)

Bases: Generic[P, T]

Like CallPartial() but disallows extra args at call time.

This allows more complete type checking to occur, so this is recommended if you do not need extra args at call time.

args

call

kwargs

class bascenev1.Campaign(name: str, sequential: bool = True, levels: list[bascenev1.Level] | None = None)

Bases: object

Represents a unique set of Level instances.

addlevel(level: bascenev1.Level, index: int | None = None) → None

Add a level to the campaign.

property configdict: dict[str, Any]

Return the live config dict for this campaign.

get_selected_level() → str

Return the name of the Level currently selected in the UI.

getlevel(name: str) → bascenev1.Level

Return a contained level by name.

property levels: list[bascenev1.Level]

The list of levels in the campaign.

property name: str

The name of the campaign.

reset() → None

Reset state for the campaign.

property sequential: bool

Whether this campaign’s levels must be played in sequence.

set_selected_level(levelname: str) → None

Set the Level currently selected in the UI (by name).

class bascenev1.CelebrateMessage(duration: float = 10.0)

Bases: object

Tells an object to celebrate.

duration: float = 10.0

Amount of time to celebrate in seconds.

class bascenev1.ChoiceSetting(name: str, default: Any, choices: list[tuple[str, Any]])

Bases: Setting

A setting with multiple choices.

choices: list[tuple[str, Any]]

class bascenev1.Chooser(vpos: float, sessionplayer: bascenev1.SessionPlayer, lobby: Lobby)

Bases: object

A character/team selector for a player.

get_character_name() → str

Return the selected character name.

get_color() → Sequence[float]

Return the currently selected color.

get_highlight() → Sequence[float]

Return the currently selected highlight.

get_lobby() → bascenev1.Lobby | None

Return this chooser’s lobby if it still exists; otherwise None.

getplayer() → bascenev1.SessionPlayer

Return the player associated with this chooser.

handlemessage(msg: Any) → Any

Standard generic message handler.

property lobby: bascenev1.Lobby

The chooser’s lobby.

property ready: bool

Whether this chooser is checked in as ready.

reload_profiles() → None

Reload all player profiles.

property sessionplayer: bascenev1.SessionPlayer

The session-player associated with this chooser.

property sessionteam: bascenev1.SessionTeam

Return this chooser’s currently selected bascenev1.SessionTeam.

update_from_profile() → None

Set character/colors based on the current profile.

update_position() → None

Update this chooser’s position.

class bascenev1.Collision

Bases: object

A class providing info about occurring collisions.

property opposingbody: int

The body index on the opposing node in the current collision.

property opposingnode: bascenev1.Node

The node the current callback material node is hitting.

Throws a NodeNotFoundError if the node does not exist. This can be expected in some cases such as in ‘disconnect’ callbacks triggered by deleting a currently-colliding node.

property position: bascenev1.Vec3

The position of the current collision.

property sourcenode: bascenev1.Node

The node containing the material triggering the current callback.

Throws a NodeNotFoundError if the node does not exist, though the node should always exist (at least at the start of the collision callback).

class bascenev1.CollisionMesh

Bases: object

A reference to a collision-mesh.

Use bascenev1.getcollisionmesh() to instantiate one.

class bascenev1.CollisionMeshVerifiedSpec(apverid: str, name: str)

Bases: CollisionMeshSpec

A collision-mesh reference that can also load the live one.

get() → bascenev1.CollisionMesh

Resolve and return the live collision-mesh for this reference.

exception bascenev1.ContextError

Bases: Exception

Raised when a call is made in an invalid context.

Examples of this include calling UI functions within an activity context or calling scene manipulation functions outside of a scene context.

class bascenev1.ContextRef

Bases: object

Store or use a Ballistica context.

Many operations such as bascenev1.newnode() or bascenev1.gettexture() operate implicitly on a current ‘context’. A context is some sort of state that functionality can implicitly use. Context determines, for example, which scene new nodes or textures get added to without having to specify that explicitly in the newnode()/gettexture() call. Contexts can also affect object lifecycles; for example a ContextCall will instantly become a no-op and release any references it is holding when the context it belongs to is destroyed.

In general, if you are a modder, you should not need to worry about contexts; mod code should mostly be getting run in the correct context and timers and other callbacks will take care of saving and restoring contexts automatically. There may be rare cases, however, where you need to deal directly with contexts, and that is where this class comes in.

Creating a context-ref will capture a reference to the current context. Other modules may provide ways to access their contexts; for example a bascenev1.Activity instance has a context attribute. You can also use the empty() classmethod to create a reference to no context. Some code such as UI calls may expect to be run with no context set and may complain if you try to use them within a context.

Usage

Context-refs are generally used with the Python with statement, which sets the context they point to as current on entry and resets it to the previous value on exit.

Example: Explicitly clear context while working with UI code from gameplay (UI stuff may complain if called within a context):

import bauiv1 as bui

def _callback_called_from_gameplay():

    # We are probably called with a game context as current, but
    # this makes UI stuff unhappy. So we clear the context while
    # doing our thing.
    with bui.ContextRef.empty():
        my_container = bui.containerwidget()

classmethod empty() → ContextRef

Return a context-ref pointing to no context.

This is useful when code should be run free of a context. For example, UI code generally insists on being run this way. Otherwise, callbacks set on the UI could inadvertently stop working due to a game activity ending, which would be unintuitive behavior.

is_empty() → bool

Whether the context was created as empty.

is_expired() → bool

Whether the context has expired.

Returns False for refs created as empty.

class bascenev1.CoopGameActivity(settings: dict)

Bases: GameActivity, Generic

Base class for cooperative-mode games.

celebrate(duration: float) → None

Tells all existing player-controlled characters to celebrate.

Can be useful in co-op games when the good guys score or complete a wave. duration is given in seconds.

fade_to_red() → None

Fade the screen to red; (such as when the good guys have lost).

get_score_type() → str

Return the score unit this co-op game uses (‘point’, ‘seconds’, etc.)

on_begin() → None

Called once the previous activity has finished transitioning out.

At this point the activity’s initial players and teams are filled in and it should begin its actual game logic.

setup_low_life_warning_sound() → None

Set up a beeping noise to play when any players are near death.

spawn_player_spaz(player: PlayerT, position: Sequence[float] = (0.0, 0.0, 0.0), angle: float | None = None) → PlayerSpaz

Spawn and wire up a standard player spaz.

classmethod supports_session_type(sessiontype: type[bascenev1.Session]) → bool

Return whether this game supports the provided session type.

class bascenev1.CoopSession

Bases: Session

A session which runs cooperative-mode games.

These generally consist of 1-4 players against the computer and include functionality such as high score lists.

allow_mid_activity_joins = False

campaign: bascenev1.Campaign | None

The baclassic.Campaign instance this Session represents, or None if there is no associated Campaign.

get_current_game_instance() → bascenev1.GameActivity

Get the game instance currently being played.

get_custom_menu_entries() → list[dict[str, Any]]

Subclasses can override this to provide custom menu entries.

The returned value should be a list of dicts, each containing a ‘label’ and ‘call’ entry, with ‘label’ being the text for the entry and ‘call’ being the callable to trigger if the entry is pressed.

on_activity_end(activity: bascenev1.Activity, results: Any) → None

Method override for co-op sessions.

Jumps between co-op games and score screens.

on_player_leave(sessionplayer: bascenev1.SessionPlayer) → None

Called when a previously-accepted bascenev1.SessionPlayer leaves.

restart() → None

Restart the current game activity.

should_allow_mid_activity_joins(activity: bascenev1.Activity) → bool

Ask ourself if we should allow joins during an Activity.

Note that for a join to be allowed, both the session and activity have to be ok with it (via this function and the bascenev1.Activity.allow_mid_activity_joins property.

use_team_colors = False

Whether players on a team should all adopt the colors of that team instead of their own profile colors. This only applies if use_teams is enabled.

use_teams = True

Whether this session groups players into an explicit set of teams. If this is off, a unique team is generated for each player that joins.

bascenev1.DEFAULT_TEAM_COLORS: tuple = ((0.1, 0.25, 1.0), (1.0, 0.25, 0.2))

Default RGB colors for the two teams in a MultiTeamSession, used when a session doesn’t specify its own.

bascenev1.DEFAULT_TEAM_NAMES: tuple = ('Blue', 'Red')

Default display names for the two teams in a MultiTeamSession.

class bascenev1.Data

Bases: object

A reference to a data object.

Use bascenev1.getdata() to instantiate one.

getvalue() → Any

Return the data object’s value.

This can consist of anything representable by json (dicts, lists, numbers, bools, None, etc). Note that this call will block if the data has not yet been loaded, so it can be beneficial to plan a short bit of time between when the data object is requested and when it’s value is accessed.

class bascenev1.DeathType(*values)

Bases: Enum

A reason for a death.

FALL = 'fall'

GENERIC = 'generic'

IMPACT = 'impact'

LEFT_GAME = 'left_game'

OUT_OF_BOUNDS = 'out_of_bounds'

REACHED_GOAL = 'reached_goal'

class bascenev1.DieMessage(immediate: bool = False, how: DeathType = DeathType.GENERIC)

Bases: object

A message telling an object to die.

Most bascenev1.Actor-s respond to this.

how: DeathType = 'generic'

The particular reason for death.

immediate: bool = False

If this is set to True, the actor should disappear immediately. This is for ‘removing’ stuff from the game more so than ‘killing’ it. If False, the actor should die a ‘normal’ death and can take its time with lingering corpses, sound effects, etc.

class bascenev1.DisplayTime

Like AppTime but incremented at frame draw time and in a smooth consistent manner; useful to keep animations smooth and jitter-free.

alias of float

class bascenev1.DisplayTimer(time: float, call: Callable[[], Any], repeat: bool = False)

Bases: object

Timers are used to run code at later points in time.

This class encapsulates a timer based on display-time. The underlying timer will be destroyed when this object is no longer referenced. If you do not want to worry about keeping a reference to your timer around, use the displaytimer() function instead to get a one-off timer.

Display-time is a time value intended to be used for animation and other visual purposes. It will generally increment by a consistent amount each frame. It will pass at an overall similar rate to AppTime, but trades accuracy for smoothness.

Parameters:

• time – Length of time in seconds that the timer will wait before firing.

• call – A callable Python object. Remember that the timer will retain a strong reference to the callable for as long as it exists, so you may want to look into concepts such as WeakCall if that is not desired.

• repeat – If True, the timer will fire repeatedly, with each successive firing having the same delay as the first.

Example: Use a Timer object to print repeatedly for a few seconds:

def say_it():
    babase.screenmessage('BADGER!')

def stop_saying_it():
    global g_timer
    g_timer = None
    babase.screenmessage('MUSHROOM MUSHROOM!')

# Create our timer; it will run as long as we keep its ref alive.
g_timer = babase.DisplayTimer(0.3, say_it, repeat=True)

# Now fire off a one-shot timer to kill the ref.
babase.displaytimer(3.89, stop_saying_it)

class bascenev1.DropMessage

Bases: object

Tells an object that it has dropped what it was holding.

class bascenev1.DroppedMessage(node: bascenev1.Node)

Bases: object

Tells an object that it has been dropped.

node: bascenev1.Node

The bascenev1.Node doing the dropping.

class bascenev1.DualTeamSession

Bases: MultiTeamSession

bascenev1.Session type for teams mode games.

use_team_colors = True

Whether players on a team should all adopt the colors of that team instead of their own profile colors. This only applies if use_teams is enabled.

use_teams = True

Whether this session groups players into an explicit set of teams. If this is off, a unique team is generated for each player that joins.

class bascenev1.EmptyPlayer

Bases: Player[bascenev1.EmptyTeam]

An empty player for use by Activities that don’t need to define one.

bascenev1.Player and bascenev1.Team are ‘Generic’ types, and so passing those top level classes as type arguments when defining a bascenev1.Activity reduces type safety. For example, activity.teams[0].player will have type ‘Any’ in that case. For that reason, it is better to pass EmptyPlayer and EmptyTeam when defining a bascenev1.Activity that does not need custom types of its own.

Note that EmptyPlayer defines its team type as EmptyTeam and vice versa, so if you want to define your own class for one of them you should do so for both.

class bascenev1.EmptyTeam

Bases: Team[bascenev1.EmptyPlayer]

An empty player for use by Activities that don’t define one.

bascenev1.Player and bascenev1.Team are ‘Generic’ types, and so passing those top level classes as type arguments when defining a bascenev1.Activity reduces type safety. For example, activity.teams[0].player will have type ‘Any’ in that case. For that reason, it is better to pass EmptyPlayer and EmptyTeam when defining a bascenev1.Activity that does not need custom types of its own.

Note that EmptyPlayer defines its team type as EmptyTeam and vice versa, so if you want to define your own class for one of them you should do so for both.

type bascenev1.FeedbackEvent = Literal['join', 'collect', 'grab', 'impact_dealt', 'impact_received', 'death']

class bascenev1.FloatChoiceSetting(name: str, default: float, choices: list[tuple[str, float]])

Bases: ChoiceSetting

A float setting with multiple choices.

choices: list[tuple[str, float]]

default: float

class bascenev1.FloatSetting(name: str, default: float, min_value: float = 0.0, max_value: float = 9999.0, increment: float = 1.0)

Bases: Setting

A floating point game setting.

default: float

increment: float = 1.0

max_value: float = 9999.0

min_value: float = 0.0

class bascenev1.FreeForAllSession

Bases: MultiTeamSession

bascenev1.Session type for free-for-all mode games.

get_ffa_point_awards() → dict[int, int]

Return the number of points awarded for different rankings.

This is based on the current number of players.

use_team_colors = False

Whether players on a team should all adopt the colors of that team instead of their own profile colors. This only applies if use_teams is enabled.

use_teams = False

Whether this session groups players into an explicit set of teams. If this is off, a unique team is generated for each player that joins.

class bascenev1.FreezeMessage(time: float = 5.0)

Bases: object

Tells an object to become frozen.

As seen in the effects of an ice bascenev1.Bomb.

time: float = 5.0

The amount of time the object will be frozen.

class bascenev1.GameActivity(settings: dict)

Bases: Activity, Generic

Common base class for all game activities.

allow_kick_idle_players = True

Whether idle players can potentially be kicked (should not happen in menus/etc).

allow_pausing = True

Whether scene-time should still progress when in menus/etc.

available_settings: list[bascenev1.Setting] | None = None

default_music: bascenev1.MusicType | None = None

description: str | None = None

end(results: Any = None, delay: float = 0.0, force: bool = False) → None

Commence activity shutdown and delivers results to the session.

‘delay’ is the time delay before the Activity actually ends (in seconds). Further end calls will be ignored up until this time, unless ‘force’ is True, in which case the new results will replace the old.

end_game() → None

Tell the game to wrap up and call bascenev1.Activity.end().

This method should be overridden by subclasses. A game should always be prepared to end and deliver results, even if there is no ‘winner’ yet; this way things like the standard time-limit (bascenev1.GameActivity.setup_standard_time_limit()) will work with the game.

classmethod get_available_settings(sessiontype: type[bascenev1.Session]) → list[bascenev1.Setting]

Return a list of settings relevant to this game type when running under the provided session type.

classmethod get_description(sessiontype: type[bascenev1.Session]) → str

Get a str description of this game type.

The default implementation simply returns the ‘description’ class var. Classes which want to change their description depending on the session can override this method.

classmethod get_description_display_string(sessiontype: type[bascenev1.Session], *, langstr: Literal[False] = False) → Lstr

classmethod get_description_display_string(sessiontype: type[bascenev1.Session], *, langstr: Literal[True]) → LangStr

Return a translated version of get_description().

Sub-classes should override get_description(); not this.

Pass langstr=True to receive a LangStr. The legacy Lstr form goes away when api 9 support ends.

classmethod get_display_string(settings: dict | None = None, *, langstr: Literal[False] = False) → Lstr

classmethod get_display_string(settings: dict | None = None, *, langstr: Literal[True]) → LangStr

Return a descriptive name for this game/settings combo.

Subclasses should override getname(); not this.

Pass langstr=True to receive a LangStr (or a plain str for a game we have no entry for, such as a mod’s). The legacy Lstr form goes away when api 9 support ends.

get_instance_description() → str | Sequence

Return a description for this game instance, in English.

This is shown in the center of the screen below the game name at the start of a game. It should start with a capital letter and end with a period, and can be a bit more verbose than the version returned by get_instance_description_short().

Note that translation is applied by looking up the specific returned value as a key, so the number of returned variations should be limited; ideally just one or two. To include arbitrary values in the description, you can return a sequence of values in the following form instead of just a string:

# This will give us something like ‘Score 3 goals.’ in English # and can properly translate to ‘Anota 3 goles.’ in Spanish. # If we just returned the string ‘Score 3 Goals’ here, there would # have to be a translation entry for each specific number. ew. return [‘Score ${ARG1} goals.’, self.settings_raw[‘Score to Win’]]

This way the first string can be consistently translated, with any arg values then substituted into the result. ${ARG1} will be replaced with the first value, ${ARG2} with the second, etc.

get_instance_description_short() → str | Sequence

Return a short description for this game instance in English.

This description is used above the game scoreboard in the corner of the screen, so it should be as concise as possible. It should be lowercase and should not contain periods or other punctuation.

Note that translation is applied by looking up the specific returned value as a key, so the number of returned variations should be limited; ideally just one or two. To include arbitrary values in the description, you can return a sequence of values in the following form instead of just a string:

# This will give us something like ‘score 3 goals’ in English # and can properly translate to ‘anota 3 goles’ in Spanish. # If we just returned the string ‘score 3 goals’ here, there would # have to be a translation entry for each specific number. ew. return [‘score ${ARG1} goals’, self.settings_raw[‘Score to Win’]]

This way the first string can be consistently translated, with any arg values then substituted into the result. ${ARG1} will be replaced with the first value, ${ARG2} with the second, etc.

get_instance_display_string(*, langstr: Literal[False] = False) → Lstr

get_instance_display_string(*, langstr: Literal[True]) → LangStr

Return a name for this particular game instance.

Pass langstr=True to receive a LangStr. The legacy Lstr form goes away when api 9 support ends.

get_instance_scoreboard_display_string(*, langstr: Literal[False] = False) → Lstr

get_instance_scoreboard_display_string(*, langstr: Literal[True]) → LangStr

Return a name for this particular game instance.

This name is used above the game scoreboard in the corner of the screen, so it should be as concise as possible.

Pass langstr=True to receive a LangStr. The legacy Lstr form goes away when api 9 support ends.

classmethod get_settings_display_string(config: dict[str, Any], *, langstr: Literal[False] = False) → Lstr

classmethod get_settings_display_string(config: dict[str, Any], *, langstr: Literal[True]) → LangStr

Given a game config dict, return a short description for it.

This is used when viewing game-lists or showing what game is up next in a series.

Pass langstr=True to receive a LangStr. The legacy Lstr form goes away when api 9 support ends.

classmethod get_supported_maps(sessiontype: type[bascenev1.Session]) → list[str]

Called by the default bascenev1.GameActivity.create_settings_ui() implementation; should return a list of map names valid for this game-type for the given bascenev1.Session type.

classmethod get_team_display_string(name: str, *, langstr: Literal[False] = False) → Lstr

classmethod get_team_display_string(name: str, *, langstr: Literal[True]) → str | LangStr

Given a team name, returns a localized version of it.

Pass langstr=True to receive a LangStr (or a plain str for a custom team name the player typed). The legacy Lstr form goes away when api 9 support ends.

classmethod getname() → str

Return a str name for this game type.

This default implementation simply returns the ‘name’ class attr.

classmethod getscoreconfig() → bascenev1.ScoreConfig

Return info about game scoring setup; can be overridden by games.

handlemessage(msg: Any) → Any

General message handling; can be passed any message object.

initialplayerinfos: list[bascenev1.PlayerInfo] | None

Holds some flattened info about the player set at the point when on_begin() is called.

property map: Map

The map being used for this game.

Raises a bascenev1.MapNotFoundError if the map does not currently exist.

name: str | None = None

on_begin() → None

Called once the previous activity has finished transitioning out.

At this point the activity’s initial players and teams are filled in and it should begin its actual game logic.

on_player_join(player: PlayerT) → None

Called when a player joins the activity.

(including the initial set of players)

on_transition_in() → None

Called when the activity is first becoming visible.

Upon this call, the activity should fade in backgrounds, start playing music, etc. It does not yet have access to players or teams, however. They remain owned by the previous activity up until on_begin() is called.

respawn_player(player: PlayerT, respawn_time: float | None = None) → None

Given a bascenev1.Player, sets up a standard respawn timer, along with the standard counter display, etc. At the end of the respawn period spawn_player() will be called if the Player still exists. An explicit ‘respawn_time’ can optionally be provided (in seconds).

scoreconfig: bascenev1.ScoreConfig | None = None

setup_standard_powerup_drops(enable_tnt: bool = True) → None

Create standard powerup drops for the current map.

setup_standard_time_limit(duration: float) → None

Create a standard game time-limit given the provided duration in seconds. This will be displayed at the top of the screen. If the time-limit expires, end_game() will be called.

show_kill_points = True

show_zoom_message(message: Lstr | LangStr, *, color: Sequence[float] = (0.9, 0.4, 0.0), scale: float = 0.8, duration: float = 2.0, trail: bool = False) → None

Zooming text used to announce game names and winners.

spawn_player(player: PlayerT) → bascenev1.Actor

Spawn something for the provided player.

The default implementation simply calls spawn_player_spaz().

spawn_player_if_exists(player: PlayerT) → None

A utility method which calls self.spawn_player() only if the bascenev1.Player provided still exists; handy for use in timers and whatnot.

There is no need to override this; just override spawn_player().

spawn_player_spaz(player: PlayerT, position: Sequence[float] = (0, 0, 0), angle: float | None = None) → PlayerSpaz

Create and wire up a player-spaz for the provided player.

classmethod supports_session_type(sessiontype: type[bascenev1.Session]) → bool

Return whether this game supports the provided session type.

tips: list[str | bascenev1.GameTip] = []

class bascenev1.GameResults

Bases: object

Results for a completed game.

Upon completion, a game should fill one of these out and pass it to its end() call.

get_sessionteam_score(sessionteam: bascenev1.SessionTeam) → int | None

Return the score for a given team.

get_sessionteam_score_str(sessionteam: bascenev1.SessionTeam, *, langstr: Literal[False] = False) → Lstr

get_sessionteam_score_str(sessionteam: bascenev1.SessionTeam, *, langstr: Literal[True]) → LangStr

Return the score for the given team as a displayable string.

(properly formatted for the score type.)

Pass langstr=True to receive a LangStr. The legacy Lstr form goes away when api 9 support ends.

has_score_for_sessionteam(sessionteam: bascenev1.SessionTeam) → bool

Return whether there is a score for a given team.

property lower_is_better: bool

Whether lower scores are better.

property playerinfos: list[bascenev1.PlayerInfo]

Get info about the players represented by the results.

property score_label: str

The label associated with scores (‘points’, etc).

property scoretype: bascenev1.ScoreType

The type of score.

property sessionteams: list[bascenev1.SessionTeam]

Return all teams in the results.

set_game(game: bascenev1.GameActivity) → None

Set the game instance these results are applying to.

set_team_score(team: bascenev1.Team, score: int | None) → None

Set the score for a given team.

This can be a number or None (see the none_is_winner arg in the constructor).

property winnergroups: list[WinnerGroup]

The ordered list of winner-groups.

property winning_sessionteam: bascenev1.SessionTeam | None

The winning team if there is exactly one, or else None.

class bascenev1.GameTip(text: str, icon: bascenev1.Texture | None = None, sound: bascenev1.Sound | None = None)

Bases: object

Defines a tip presentable to the user at the start of a game.

icon: bascenev1.Texture | None = None

sound: bascenev1.Sound | None = None

text: str

class bascenev1.HitMessage(*, srcnode: bascenev1.Node | None = None, pos: Sequence[float] | None = None, velocity: Sequence[float] | None = None, magnitude: float = 1.0, velocity_magnitude: float = 0.0, radius: float = 1.0, source_player: bascenev1.Player | None = None, kick_back: float = 1.0, flat_damage: float | None = None, hit_type: str = 'generic', force_direction: Sequence[float] | None = None, hit_subtype: str = 'default')

Bases: object

Tells an object it has been hit in some way.

This is used by punches, explosions, etc to convey their effect to a target.

get_source_player(playertype: type[PlayerT]) → PlayerT | None

Return the source-player if one exists and is the provided type.

class bascenev1.HostInfo(name: str, build_number: int, address: str | None, port: int | None)

Bases: object

Info about a host.

address: str | None

build_number: int

name: str

port: int | None

class bascenev1.HostProbeOutcome(*values)

Bases: Enum

No-requirements outcomes of fetch_host_requirements().

LEGACY = 'legacy'

The host answered the legacy discovery query reporting a pre-lang-str protocol: a confirmed old host with no requirements to fetch. Connect immediately.

SILENT = 'silent'

Nothing answered anything – the address is unreachable, bogus, or down. The plain connect attempt surfaces the error the user actually cares about.

UNRESPONSIVE = 'unresponsive'

The host proved alive AND lang-str-era (or began the exchange) but never completed the requirements listing despite an extended retry budget. Joining it unprepped could only strand; fail the join like a standard connection failure.

class bascenev1.HostRequirements(asset_packages: list[str] = <factory>, password_required: bool = False)

Bases: object

Everything a host requires of clients joining it.

Fetched from prospective hosts by the pre-join requirements query (see connect_to_party()).

asset_packages: list[str]

password_required: bool = False

class bascenev1.ImpactDamageMessage(intensity: float)

Bases: object

Tells an object that it has been jarred violently.

intensity: float

The intensity of the impact.

class bascenev1.InputDevice

Bases: object

An input-device such as a gamepad, touchscreen, or keyboard.

allows_configuring: bool

Whether the input-device can be configured in the app.

allows_configuring_in_system_settings: bool

Whether the input-device can be configured in the system. setings app. This can be used to redirect the user to go there if they attempt to configure the device.

client_id: int

The numeric client-id this device is associated with. This is only meaningful for remote client inputs; for all local devices this will be -1.

detach_from_player() → None

Detach the device from any player it is controlling.

This applies both to local players and remote players.

exists() → bool

Return whether the underlying device for this object is still present.

get_axis_name(axis_id: int) → str

Given an axis ID, return the name of the axis on this device.

Can return an empty string if the value is not meaningful to humans.

get_button_name(button_id: int) → babase.Lstr

Given a button ID, return a human-readable name for that key/button.

Can return an empty string if the value is not meaningful to humans.

get_classic_purchases() → list[str] | None

Return classic-inventory purchase legacy-ids owned by this device’s account, as provided by the master server.

Returns None when the master server isn’t providing this data — e.g. when this device isn’t connected via a v2-auth handshake, when an older master-server version didn’t send it, or when the account has no classic-inventory record. Callers should treat None as ‘unknown’, not as ‘owns nothing’; an empty list is the correct way to represent ‘owns nothing’.

(internal)

get_default_player_name() → str

(internal)

Returns the default player name for this device. (used for the ‘random’ profile)

get_player_profiles() → dict

(internal)

get_v1_account_name(full: bool) → str

Returns the account name associated with this device.

(can be used to get account names for remote players)

has_meaningful_button_names: bool

Whether button names returned by this instance match labels on the actual device. (Can be used to determine whether to show them in controls-overlays, etc.).

id: int

The unique numeric id of this device.

instance_number: int

The number of this device among devices of the same type.

is_attached_to_player() → bool

Return whether this device is controlling a player of some sort.

This can mean either a local player or a remote player.

is_controller_app: bool

Whether this input-device represents a locally-connected controller-app.

is_remote_client: bool

Whether this input-device represents a remotely-connected client.

is_test_input: bool

Whether this input-device is a dummy device for testing.

name: str

The name of the device.

player: bascenev1.SessionPlayer | None

The player associated with this input device.

unique_identifier: str

A string that can be used to persistently identify the device, even among other devices of the same type. Used for saving prefs, etc.

class bascenev1.InputType(*values)

Bases: Enum

Types of input a controller can send to the game.

BOMB_PRESS = 8

BOMB_RELEASE = 9

DOWN_PRESS = 25

DOWN_RELEASE = 26

FLY_PRESS = 13

FLY_RELEASE = 14

HOLD_POSITION_PRESS = 17

HOLD_POSITION_RELEASE = 18

JUMP_PRESS = 4

JUMP_RELEASE = 5

LEFT_PRESS = 19

LEFT_RELEASE = 20

LEFT_RIGHT = 3

PICK_UP_PRESS = 10

PICK_UP_RELEASE = 11

PUNCH_PRESS = 6

PUNCH_RELEASE = 7

RIGHT_PRESS = 21

RIGHT_RELEASE = 22

RUN = 12

START_PRESS = 15

START_RELEASE = 16

UP_DOWN = 2

UP_PRESS = 23

UP_RELEASE = 24

class bascenev1.IntChoiceSetting(name: str, default: int, choices: list[tuple[str, int]])

Bases: ChoiceSetting

An int setting with multiple choices.

choices: list[tuple[str, int]]

default: int

class bascenev1.IntSetting(name: str, default: int, min_value: int = 0, max_value: int = 9999, increment: int = 1)

Bases: Setting

An integer game setting.

default: int

increment: int = 1

max_value: int = 9999

min_value: int = 0

class bascenev1.JoinActivity(settings: dict)

Bases: Activity[EmptyPlayer, EmptyTeam]

Standard activity for waiting for players to join.

It shows tips and other info and waits for all players to check ready.

on_transition_in() → None

Called when the activity is first becoming visible.

Upon this call, the activity should fade in backgrounds, start playing music, etc. It does not yet have access to players or teams, however. They remain owned by the previous activity up until on_begin() is called.

class bascenev1.JoinInfo(lobby: bascenev1.Lobby)

Bases: object

Display useful info for joiners.

class bascenev1.LangStr(json: str, packages: Sequence[str] | None = None, wrap: tuple[int, int | None, int | None] | None = None)

Bases: object

A deferred, language-agnostic complex string (native).

The verified-local counterpart of bacommon.langstr.LangStrSpec (see the D28 semantic split – holding one of these implies displayability here): holds tokens, not text, and evaluates to a flat string in the client’s locale at display time. Construct from the canonical wire JSON of any language-string form; pass the payload’s packages manifest to bind integer-indexed values at parse, and optionally a wrap triple (min-lines, max-lines, max-chars-per-line; None = unlimited) as a usage-site override of the string’s definition-time line-wrapping. Immutable, with content equality and hashing. Accepted anywhere str | babase.Lstr is accepted for display.

evaluate() → str

Evaluate to flat display text in the client’s locale.

Fail-visible: structural problems yield a LANGSTR_ERROR:... sentinel string (with a logged warning) rather than raising.

classmethod from_text(text: str) → babase.LangStr

Wrap a plain string as a literal language-string.

The text is shown exactly as given in every locale – any { or } displays literally, with no substitution. Use this to pass a piece of already-final text (a name a mod supplied, a value with no translation entry) through an API that wants a LangStr. Anything that needs substitutions or translation should be an authored asset-package entry instead, so its arguments are type-checked.

property spec: bacommon.langstr.LangStrSpec

The authoring-spec projection of this verified-local string.

Projecting verified -> spec is always valid (the reverse is deliberately not offered; see the D28 semantic split). Use this when feeding a wrapper string into spec-typed surfaces such as doc-ui models or client-effects. Content-only: any usage-site line-wrap override does not carry into the spec.

to_json() → str

Return the canonical wire JSON for this language-string.

to_resource_json() → str

Return wire JSON for the self-describing resource-form projection of this language-string (bound indexed nodes convert via the native language tables). For persisting values beyond their payload’s package-index context. Raises ValueError for unbound/unknown indexed nodes.

class bascenev1.Level(name: str, gametype: type[bascenev1.GameActivity], settings: dict, preview_texture_name: str | None = None, *, displayname: str | None = None, preview_texture: bauiv1.TextureVerifiedSpec | None = None)

Bases: object

An entry in a Campaign.

property campaign: bascenev1.Campaign | None

The campaign this level is associated with, or None.

property complete: bool

Whether this level has been completed.

property displayname: bascenev1.Lstr

The localized name for this level.

Deprecated since version 1.8.0: Use displayname_langstr. This property’s type changes to LangStr when api 9 support ends.

property displayname_langstr: LangStr

The localized name for this level.

This is the LangStr flavor of displayname. It exists only for the transition; once api 9 support ends, displayname returns this and this property goes away with the removal of api 10.

property gametype: type[bascenev1.GameActivity]

The type of game used for this level.

get_high_scores() → dict

Return the current high scores for this level.

get_score_version_string() → str

Return the score version string for this level.

If a level’s gameplay changes significantly, its version string can be changed to separate its new high score lists/etc. from the old.

get_settings() → dict[str, Any]

Returns the settings for this Level.

property index: int

The zero-based index of this level in its campaign.

Access results in a RuntimeError if the level is not assigned to a campaign.

property name: str

The unique name for this level.

property preview_texture: bauiv1.Texture

The preview texture for this level.

Level previews are drawn by ui code, so this is a loaded Texture.

Levels are built during app-loading, which is before construct-mode has resolved asset-packages, so the constructor takes the wrapper reference (someassets.textures.my_level_preview, no .get()) and the texture is loaded here on first access – by which time the ui that wants to draw it exists and the package is registered.

property preview_texture_name: str | None

The preview texture name for this level.

Deprecated since version 1.8.0: Use preview_texture, and pass preview_texture to the constructor rather than preview_texture_name. This returns None for a level constructed the new way, so built-in levels now report None here. Removed when api 9 support ends.

property rating: float

The current rating for this level.

set_complete(val: bool) → None

Set whether or not this level is complete.

set_high_scores(high_scores: dict) → None

Set high scores for this level.

set_rating(rating: float) → None

Set a rating for this level, replacing the old ONLY IF higher.

class bascenev1.Lobby

Bases: object

Environment where players can selecting characters, etc.

add_chooser(sessionplayer: bascenev1.SessionPlayer) → None

Add a chooser to the lobby for the provided player.

check_all_ready() → bool

Return whether all choosers are marked ready.

create_join_info() → JoinInfo

Create a display of on-screen information for joiners.

(how to switch teams, players, etc.) Intended for use in initial joining-screens.

get_choosers() → list[Chooser]

The current choosers present.

property next_add_team: int

(internal)

reload_profiles() → None

Reload available player profiles.

remove_all_choosers() → None

Remove all choosers without kicking players.

This is called after all players check in and enter a game.

remove_all_choosers_and_kick_players() → None

Remove all player choosers and kick attached players.

remove_chooser(player: bascenev1.SessionPlayer) → None

Remove a single player’s chooser; does not kick them.

This is used when a player enters the game and no longer needs a chooser.

property sessionteams: list[bascenev1.SessionTeam]

The teams available in this lobby.

update_positions() → None

Update positions for all choosers.

property use_team_colors: bool

Whether this lobby is using team colors.

If False, inidividual player colors are used instead.

class bascenev1.Lstr(*, resource: str, fallback_resource: str = '', fallback_value: str = '', subs: Sequence[tuple[str, str | Lstr]] | None = None)

class bascenev1.Lstr(*, translate: tuple[str, str], subs: Sequence[tuple[str, str | Lstr]] | None = None)

class bascenev1.Lstr(*, value: str, subs: Sequence[tuple[str, str | Lstr]] | None = None)

Bases: object

Used to define strings in a language-independent way.

These should be used whenever possible in place of hard-coded strings so that in-game or UI elements show up correctly on all clients in their currently active language.

To see available resource keys, see the translation pages at legacy.ballistica.net/translate.

Parameters:

• resource – Pass a string to look up a translation by resource key.

• translate – Pass a tuple consisting of a translation category and untranslated value. Any matching translation found in that category will be used. Otherwise the untranslated value will be.

• value – Pass a regular string value to be used as-is.

• subs – A sequence of 2-member tuples consisting of values and replacements. Replacements can be regular strings or other Lstr values.

• fallback_resource – A resource key that will be used if the main one is not present for the current language instead of falling back to the english value (‘resource’ mode only).

• fallback_value – A regular string that will be used if neither the resource nor the fallback resource is found (‘resource’ mode only).

Example 1: Resource path

mynode.text = babase.Lstr(resource='audioSettingsWindow.titleText')

Example 2: Translation

If a translated value is available, it will be used; otherwise the English value will be. To see available translation categories, look under the translations resource section.

mynode.text = babase.Lstr(translate=('gameDescriptions',
                                     'Defeat all enemies'))

Example 3: Substitutions

Substitutions can be used with resource and translate modes as well as the value shown here.

mynode.text = babase.Lstr(value='${A} / ${B}',
                          subs=[('${A}', str(score)),
                                ('${B}', str(total))])

Example 4: Nesting

Lstr instances can be nested. This example would display the translated resource at 'res_a' but replace any instances of '${NAME}' it contains with the translated resource at 'res_b'.

mytextnode.text = babase.Lstr(
    resource='res_a',
    subs=[('${NAME}', babase.Lstr(resource='res_b'))])

args

Basically just stores the exact args passed. However if Lstr values were passed for subs, they are replaced with that Lstr’s dict.

as_json() → str

Return the json dict representation of the Lstr.

evaluate() → str

Evaluate to a flat string in the current language.

You should avoid doing this as much as possible and instead pass and store Lstr values.

static from_json(json_string: str) → babase.Lstr

Given a json string, returns a Lstr.

Does no validation.

is_flat_value() → bool

Return whether this instance represents a ‘flat’ value.

This is defined as a simple string value incorporating no translations, resources, or substitutions. In this case it may be reasonable to replace it with a raw string value, perform string manipulation on it, etc.

class bascenev1.Map(vr_overlay_offset: Sequence[float] | None = None)

Bases: Actor

A game map.

Consists of a collection of terrain nodes, metadata, and other functionality comprising a game map.

defs: Any = None

exists() → bool

Returns whether the actor is still present in a meaningful way.

Note that a dying character should still return True here as long as their corpse is visible; this is about presence, not being ‘alive’ (see is_alive() for that).

If this returns False, it is assumed the actor can be completely deleted without affecting the game; this call is often used when pruning lists of actors, such as with bascenev1.Actor.autoretain()

The default implementation of this method always return True.

Note that the boolean operator for the actor class calls this method, so a simple if myactor test will conveniently do the right thing even if myactor is set to None.

get_def_bound_box(name: str) → tuple[float, float, float, float, float, float] | None

Return a 6 member bounds tuple or None if it is not defined.

get_def_point(name: str) → Sequence[float] | None

Return a single defined point or a default value in its absence.

get_def_points(name: str) → list[Sequence[float]]

Return a list of named points.

Return as many sequential ones are defined (flag1, flag2, flag3), etc. If none are defined, returns an empty list.

get_ffa_start_position(players: Sequence[bascenev1.Player]) → Sequence[float]

Return a random starting position in one of the FFA spawn areas.

If a list of bascenev1.Player-s is provided; the returned points will be as far from these players as possible.

get_flag_position(team_index: int | None = None) → Sequence[float]

Return a flag position on the map for the given team index.

Pass None to get the default flag point. (used for things such as king-of-the-hill)

classmethod get_music_type() → bascenev1.MusicType | None

Return a music-type string that should be played on this map.

If None is returned, default music will be used.

classmethod get_play_types() → list[str]

Return valid play types for this map.

classmethod get_preview_texture() → bauiv1.Texture | None

Return this map’s preview texture, or None if it has none.

Map previews are drawn by ui code, so this hands back a loaded Texture – typically straight off an asset-package wrapper (someassets.textures.my_map_preview.get()). Headless builds can call this too; textures there load as null data rather than being unavailable.

classmethod get_preview_texture_name() → str | None

Return the name of the preview texture for this map.

Deprecated since version 1.8.0: Override get_preview_texture() instead, which hands back the loaded texture rather than a name to look up. Overriding this still works – get_preview_texture() falls back to it – but built-in maps no longer implement it, so calling it on one returns None. Removed when api 9 support ends.

get_start_position(team_index: int) → Sequence[float]

Return a random starting position for the given team index.

classmethod getname() → str

Return the unique name of this map, in English.

handlemessage(msg: Any) → Any

General message handling; can be passed any message object.

is_point_near_edge(point: Vec3, running: bool = False) → bool

Return whether the provided point is near an edge of the map.

Simple bot logic uses this call to determine if they are approaching a cliff or wall. If this returns True they will generally not walk/run any farther away from the origin. If ‘running’ is True, the buffer should be a bit larger.

name = 'Map'

classmethod on_preload() → Any

Called when the map is being preloaded.

It should return any media/data it requires to operate

classmethod preload() → None

Preload map media.

This runs the class’s on_preload() method as needed to prep it to run. Preloading should generally be done in a bascenev1.Activity’s __init__ method. Note that this is a classmethod since it is not operate on map instances but rather on the class itself before instances are made

class bascenev1.Material(label: str | None = None)

Bases: object

An entity applied to game objects to modify collision behavior.

A material can affect physical characteristics, generate sounds, or trigger callback functions when collisions occur.

Materials are applied to ‘parts’, which are groups of one or more rigid bodies created as part of a bascenev1.Node. Nodes can have any number of parts, each with its own set of materials. Generally materials are specified as array attributes on the Node. The spaz node, for example, has various attributes such as materials, roller_materials, and punch_materials, which correspond to the various parts it creates.

Use bascenev1.Material to instantiate a blank material, and then use its bascenev1.Material.add_actions() method to define what the material does.

add_actions(actions: tuple, conditions: tuple | None = None) → None

Add one or more actions to the material, optionally with conditions.

Conditions

Conditions are provided as tuples which can be combined to form boolean logic. A single condition might look like:

('condition_name', cond_arg)

Or a more complex nested one might look like:

(('condition1', cond_arg), 'or', ('condition2', cond2_arg))

The strings 'and', 'or', and 'xor' can chain together two conditions, as seen above.

Available Conditions

('they_have_material', material)

Does the part we’re hitting have a given bascenev1.Material?

('they_dont_have_material', material)

Does the part we’re hitting not have a given bascenev1.Material?

('eval_colliding')

Is 'collide' true at this point in material evaluation? (see the modify_part_collision action)

('eval_not_colliding')

Is collide false at this point in material evaluation? (see the modify_part_collision action)

('we_are_younger_than', age)

Is our part younger than age (in milliseconds)?

('we_are_older_than', age)

Is our part older than age (in milliseconds)?

('they_are_younger_than', age)

Is the part we’re hitting younger than age (in milliseconds)?

('they_are_older_than', age)

Is the part we’re hitting older than age (in milliseconds)?

('they_are_same_node_as_us')

Does the part we’re hitting belong to the same bascenev1.Node as us?

('they_are_different_node_than_us')

Does the part we’re hitting belong to a different bascenev1.Node?

Actions

In a similar manner, actions are specified as tuples. Multiple actions can be specified by providing a tuple of tuples.

Available Actions

('call', when, callable)

Calls the provided callable; when can be either 'at_connect' or 'at_disconnect'. 'at_connect' means to fire when the two parts first come in contact; 'at_disconnect' means to fire once they cease being in contact.

('message', who, when, message_obj)

Sends a message object; who can be either 'our_node' or 'their_node', when can be 'at_connect' or 'at_disconnect', and message_obj is the message object to send. This has the same effect as calling the node’s bascenev1.Node.handlemessage() method.

('modify_part_collision', attr, value)

Changes some characteristic of the physical collision that will occur between our part and their part. This change will remain in effect as long as the two parts remain overlapping. This means if you have a part with a material that turns 'collide' off against parts younger than 100ms, and it touches another part that is 50ms old, it will continue to not collide with that part until they separate, even if the 100ms threshold is passed. Options for attr/value are: 'physical' (boolean value; whether a physical response will occur at all), 'friction' (float value; how friction-y the physical response will be), 'collide' (boolean value; whether any collision will occur at all, including non-physical stuff like callbacks), 'use_node_collide' (boolean value; whether to honor modify_node_collision overrides for this collision), 'stiffness' (float value, how springy the physical response is), 'damping' (float value, how damped the physical response is), 'bounce' (float value; how bouncy the physical response is).

('modify_node_collision', attr, value)

Similar to modify_part_collision, but operates at a node-level. Collision attributes set here will remain in effect as long as anything from our part’s node and their part’s node overlap. A key use of this functionality is to prevent new nodes from colliding with each other if they appear overlapped; if modify_part_collision is used, only the individual parts that were overlapping would avoid contact, but other parts could still contact leaving the two nodes ‘tangled up’. Using modify_node_collision ensures that the nodes must completely separate before they can start colliding. Currently the only attr available here is 'collide' (a boolean value).

('sound', sound, volume)

Plays a bascenev1.Sound when a collision occurs, at a given volume, regardless of the collision speed/etc.

('impact_sound', sound, target_impulse, volume)

Plays a sound when a collision occurs, based on the speed of impact. Provide a bascenev1.Sound, a target-impulse, and a volume.

('skid_sound', sound, target_impulse, volume)

Plays a sound during a collision when parts are ‘scraping’ against each other. Provide a bascenev1.Sound, a target-impulse, and a volume.

('roll_sound', sound, targetImpulse, volume)

Plays a sound during a collision when parts are ‘rolling’ against each other. Provide a bascenev1.Sound, a target-impulse, and a volume.

Examples

Example 1: Create a material that lets us ignore collisions against any nodes we touch in the first 100 ms of our existence; handy for preventing us from exploding outward if we spawn on top of another object:

m = bascenev1.Material()
m.add_actions(
     conditions=(('we_are_younger_than', 100),
                 'or', ('they_are_younger_than', 100)),
     actions=('modify_node_collision', 'collide', False))

Example 2: Send a bascenev1.DieMessage to anything we touch, but cause no physical response. This should cause any bascenev1.Actor to drop dead:

m = bascenev1.Material()
m.add_actions(
 actions=(
   ('modify_part_collision', 'physical', False),
   ('message', 'their_node', 'at_connect', bascenev1.DieMessage())
 )
)

Example 3: Play some sounds when we’re contacting the ground:

m = bascenev1.Material()
m.add_actions(
  conditions=('they_have_material' shared.footing_material),
  actions=(
    ('impact_sound', bascenev1.getsound('metalHit'), 2, 5),
    ('skid_sound', bascenev1.getsound('metalSkid'), 2, 5)
  )
)

label: str

A label for the material; only used for debugging.

class bascenev1.Mesh

Bases: object

A reference to a mesh.

Meshes are used for drawing. Use bascenev1.getmesh() to instantiate one.

class bascenev1.MeshVerifiedSpec(apverid: str, name: str)

Bases: MeshSpec

A mesh reference that can also load the live scene mesh.

get() → bascenev1.Mesh

Resolve and return the live scene mesh for this reference.

ui() → bauiv1.MeshVerifiedSpec

This same verified reference, in ui form.

Both featuresets’ verified specs assert the same thing – the package was construct-mode-resolved – so converting between them preserves that guarantee; only what get() loads differs (a ui mesh vs a scene-bound one). Use at a ui boundary consuming scene-authored config, such as a spaz appearance’s icon.

There is deliberately no reverse scene() on the ui types: scene_v1 always pulls in ui_v1 (via classic), but a spinoff may include ui_v1 with no scene_v1 at all.

class bascenev1.MultiTeamSession

Bases: Session

Common base for DualTeamSession and FreeForAllSession.

Free-for-all-mode is essentially just teams-mode with each bascenev1.Player having their own bascenev1.Team, so there is much overlap in functionality.

announce_game_results(activity: bascenev1.GameActivity, results: bascenev1.GameResults, delay: float, announce_winning_team: bool = True) → None

Show basic game result at the end of a game.

(before transitioning to a score screen). This will include a zoom-text of ‘BLUE WINS’ or whatnot, along with a possible audio announcement of the same.

get_ffa_series_length() → int

Return free-for-all series length.

get_game_number() → int

Returns which game in the series is currently being played.

get_max_players() → int

Return max number of Players allowed to join the game at once.

get_next_game_description(*, langstr: Literal[False] = False) → Lstr

get_next_game_description(*, langstr: Literal[True]) → LangStr

Returns a description of the next game on deck.

Pass langstr=True to receive a LangStr. The legacy Lstr form goes away when api 9 support ends.

get_series_length() → int

Return teams series length.

on_activity_end(activity: bascenev1.Activity, results: Any) → None

Called when the current activity has ended.

The session should look at the results and start another activity.

on_team_join(team: bascenev1.SessionTeam) → None

Called when a new team joins the session.

class bascenev1.MusicType(*values)

Bases: Enum

Types of music available to play in-game.

These do not correspond to specific pieces of music, but rather to ‘situations’. The actual music played for each type can be overridden by the game or by the user.

CHAR_SELECT = 'CharSelect'

CHOSEN_ONE = 'Chosen One'

EPIC = 'Epic'

EPIC_RACE = 'Epic Race'

FLAG_CATCHER = 'FlagCatcher'

FLYING = 'Flying'

FOOTBALL = 'Football'

FORWARD_MARCH = 'ForwardMarch'

GRAND_ROMP = 'GrandRomp'

HOCKEY = 'Hockey'

KEEP_AWAY = 'Keep Away'

MARCHING = 'Marching'

MENU = 'Menu'

ONSLAUGHT = 'Onslaught'

RACE = 'Race'

RUN_AWAY = 'RunAway'

SCARY = 'Scary'

SCORES = 'Scores'

SPORTS = 'Sports'

SURVIVAL = 'Survival'

TO_THE_DEATH = 'ToTheDeath'

VICTORY = 'Victory'

class bascenev1.Node

Bases: object

Reference to a Node; the low level building block of a game.

At its core, a game is nothing more than a scene of Nodes with attributes getting interconnected or set over time.

A bascenev1.Node instance should be thought of as a weak-reference to a game node; not the node itself. This means a Node’s lifecycle is completely independent of how many Python references to it exist. To explicitly add a new node to the game, use bascenev1.newnode(), and to explicitly delete one, use bascenev1.Node.delete(). bascenev1.Node.exists() can be used to determine if a Node still points to a live node in the game.

You can use bascenev1.Node(None) to instantiate an invalid Node reference (sometimes used as attr values/etc).

add_death_action(action: Callable[[], None]) → None

Add a callable object to be called upon this node’s death. Note that these actions are run just after the node dies, not before.

allow_kick_idle_players: bool = False

Available on globals node.

always_show_health_bar: bool = False

On shield node.

ambient_color: Sequence[float] = (1.0, 1.0, 1.0)

area_of_interest_bounds: Sequence[float] = (-1, -1, -1, 1, 1, 1)

behavior_version: int = 0

billboard_cross_out: bool = False

Available on spaz node.

billboard_opacity: float = 0.0

Available on spaz node.

billboard_texture: bascenev1.Texture | None = None

Available on spaz node.

bomb_pressed: bool = False

boxing_gloves: bool = False

boxing_gloves_flashing: bool = False

Available on spaz node.

camera_mode: str = 'rotate'

client_only: bool = False

color: Sequence[float] = (0.0, 0.0, 0.0)

connectattr(srcattr: str, dstnode: Node, dstattr: str) → None

Connect one of this node’s attributes to an attribute on another node. This will immediately set the target attribute’s value to that of the source attribute, and will continue to do so once per step as long as the two nodes exist. The connection can be severed by setting the target attribute to any value or connecting another node attribute to it.

Example: Create a locator and attach a light to it:

light = bascenev1.newnode('light')
loc = bascenev1.newnode('locator', attrs={'position': (0, 10, 0)})
loc.connectattr('position', light, 'position')

counter_text: str = ''

counter_texture: bascenev1.Texture | None = None

curse_death_time: int = 0

damage: int = 0

damage_smoothed: float = 0.0

dead: bool = False

Available on spaz node.

debris_friction: float = 0.0

debris_kill_height: float = 0.0

delete(ignore_missing: bool = True) → None

Delete the node. Ignores already-deleted nodes if ignore_missing is True; otherwise a babase.NodeNotFoundError is thrown.

exists() → bool

Returns whether the Node still exists. Most functionality will fail on a nonexistent Node, so it’s never a bad idea to check this.

Note that you can also use the boolean operator for this same functionality, so a statement such as “if mynode” will do the right thing both for Node objects and values of None.

extras_material: Sequence[bascenev1.Material] = ()

flashing: bool = False

floor_reflection: bool = False

fly_pressed: bool = False

frozen: bool = False

getdelegate(type: type[T], doraise: Literal[False] = False) → T | None

getdelegate(type: type[T], doraise: Literal[True]) → T

Return the node’s current delegate object if it matches a certain type.

If the node has no delegate or it is not an instance of the passed type, then None will be returned. If ‘doraise’ is True, then an bascenev1.DelegateNotFoundError will be raised instead.

getname() → str

Return the name assigned to a Node; used mainly for debugging

getnodetype() → str

Return the internal type of node referenced by this object as a string. (Note this is different from the Python type which is always bascenev1.Node)

gravity_scale: float = 1.0

handlemessage(*args: Any) → None

General message handling; can be passed any message object.

All standard message objects are forwarded along to the node’s delegate for handling (generally the bascenev1.Actor that made the node).

Nodes also support a second form of message; ‘node-messages’. These consist of a string type-name as a first argument along with the args specific to that type name as additional arguments. Node-messages communicate directly with the low-level node layer and are delivered simultaneously on all game clients, acting as an alternative to setting node attributes.

happy_thoughts_mode: bool = False

hockey: bool = False

hold_body: int = 0

hold_node: bascenev1.Node | None = None

hold_position_pressed: bool = False

host_only: bool = False

hurt: float = 0.0

Available on spaz node.

input0: float = 0.0

input1: float = 0.0

input2: float = 0.0

input3: float = 0.0

invincible: bool = False

is_area_of_interest: bool = False

jump_pressed: bool = False

knockout: float = 0.0

Available on spaz node.

loop: bool = False

materials: Sequence[bascenev1.Material] = ()

mesh_opaque: bascenev1.Mesh | None = None

mesh_transparent: bascenev1.Mesh | None = None

mini_billboard_1_end_time: int = 0

Available on spaz node.

mini_billboard_1_start_time: int = 0

Available on spaz node.

mini_billboard_1_texture: bascenev1.Texture | None = None

Available on spaz node.

mini_billboard_2_end_time: int = 0

Available on spaz node.

mini_billboard_2_start_time: int = 0

Available on spaz node.

mini_billboard_2_texture: bascenev1.Texture | None = None

Available on spaz node.

mini_billboard_3_end_time: int = 0

Available on spaz node.

mini_billboard_3_start_time: int = 0

Available on spaz node.

mini_billboard_3_texture: bascenev1.Texture | None = None

Available on spaz node.

move_left_right: float = 0.0

Available on spaz node.

move_up_down: float = 0.0

Available on spaz node.

music: str = ''

music_continuous: bool = False

music_count: int = 0

name: str = ''

name_color: Sequence[float] = (0.0, 0.0, 0.0)

offset: float = 0.0

opacity: float = 0.0

paused: bool = False

pickup_before_hitbox: bool = False

pickup_materials: Sequence[bascenev1.Material] = ()

pickup_pressed: bool = False

position: Sequence[float] = (0.0, 0.0, 0.0)

position_center: Sequence[float] = (0.0, 0.0, 0.0)

position_forward: Sequence[float] = (0.0, 0.0, 0.0)

premultiplied: bool = False

punch_materials: Sequence[bascenev1.Material] = ()

punch_momentum_angular: float = 0.0

punch_momentum_linear: Sequence[float] = (0.0, 0.0, 0.0)

punch_position: Sequence[float] = (0.0, 0.0, 0.0)

punch_power: float = 0.0

punch_pressed: bool = False

punch_velocity: Sequence[float] = (0.0, 0.0, 0.0)

rate: int = 0

roller_materials: Sequence[bascenev1.Material] = ()

rotate: float = 0.0

run: float = 0.0

Available on spaz node.

scale: float | Sequence[float] = 0.0

shadow_offset: Sequence[float] = (0.0, 0.0)

shadow_ortho: bool = False

shadow_range: Sequence[float] = (0, 0, 0, 0)

shattered: int = 0

Available on spaz node.

size: Sequence[float] = (0.0, 0.0, 0.0)

slow_motion: bool = False

source_player: bascenev1.Player | None = None

stick_to_owner: bool = False

text: babase.Lstr | babase.LangStr | str = ''

texture: bascenev1.Texture | None = None

time: int = 0

time1: int = 0

time2: int = 0

timemax: int = 0

times: Sequence[int] = (1, 2, 3, 4, 5)

tint: Sequence[float] = (1.0, 1.0, 1.0)

tint2_color: Sequence[float] = (0.0, 0.0, 0.0)

tint_color: Sequence[float] = (0.0, 0.0, 0.0)

tint_texture: bascenev1.Texture | None = None

use_fixed_vr_overlay: bool = False

values: Sequence[float] = (1.0, 2.0, 3.0, 4.0)

velocity: Sequence[float] = (0.0, 0.0, 0.0)

vignette_inner: Sequence[float] = (0.0, 0.0)

vignette_outer: Sequence[float] = (0.0, 0.0)

vr_camera_offset: Sequence[float] = (0.0, 0.0, 0.0)

vr_depth: float = 0.0

vr_near_clip: float = 0.0

vr_overlay_center: Sequence[float] = (0.0, 0.0, 0.0)

vr_overlay_center_enabled: bool = False

class bascenev1.NodeActor(node: bascenev1.Node)

Bases: Actor

A simple bascenev1.Actor type that wraps a single bascenev1.Node.

This Actor will delete its Node when told to die, and it’s exists() call will return whether the Node still exists or not.

exists() → bool

Returns whether the actor is still present in a meaningful way.

Note that a dying character should still return True here as long as their corpse is visible; this is about presence, not being ‘alive’ (see is_alive() for that).

If this returns False, it is assumed the actor can be completely deleted without affecting the game; this call is often used when pruning lists of actors, such as with bascenev1.Actor.autoretain()

The default implementation of this method always return True.

Note that the boolean operator for the actor class calls this method, so a simple if myactor test will conveniently do the right thing even if myactor is set to None.

handlemessage(msg: Any) → Any

General message handling; can be passed any message object.

exception bascenev1.NodeNotFoundError

Bases: NotFoundError

Raised when an expected node does not exist.

exception bascenev1.NotFoundError

Bases: Exception

Raised when a referenced object does not exist.

class bascenev1.OutOfBoundsMessage

Bases: object

A message telling an object that it is out of bounds.

class bascenev1.PickUpMessage(node: bascenev1.Node)

Bases: object

Tells an object that it has picked something up.

node: bascenev1.Node

The bascenev1.Node that is getting picked up.

class bascenev1.PickedUpMessage(node: bascenev1.Node)

Bases: object

Tells an object that it has been picked up by something.

node: bascenev1.Node

The bascenev1.Node doing the picking up.

class bascenev1.Player

Bases: Generic

A player in a specific bascenev1.Activity.

These correspond to bascenev1.SessionPlayer objects, but are associated with a single bascenev1.Activity instance. This allows activities to specify their own custom bascenev1.Player types.

actor: bascenev1.Actor | None

The bascenev1.Actor associated with the player.

assigninput(inputtype: InputType | tuple[InputType, ...], call: Callable) → None

Set the python callable to be run for one or more types of input.

character: str

color: Sequence[float]

property customdata: dict

Arbitrary values associated with the player. Though it is encouraged that most player values be properly defined on the bascenev1.Player subclass, it may be useful for player-agnostic objects to store values here. This dict is cleared when the player leaves or expires so objects stored here will be disposed of at the expected time, unlike the Player instance itself which may continue to be referenced after it is no longer part of the game.

exists() → bool

Whether the underlying player still exists.

This will return False if the underlying bascenev1.SessionPlayer has left the game or if the bascenev1.Activity this player was associated with has ended. Most functionality will fail on a nonexistent player. Note that you can also use the boolean operator for this same functionality, so a statement such as “if player” will do the right thing both for Player objects and values of None.

expire() → None

Called when the Player is expiring (when its Activity does so).

(internal)

get_icon() → dict[str, Any]

Returns the character’s icon (images, colors, etc contained in a dict)

getname(full: bool = False, icon: bool = True) → str

Returns the player’s name. If icon is True, the long version of the name may include an icon.

highlight: Sequence[float]

is_alive() → bool

Returns True if the player has a bascenev1.Actor assigned and its is_alive() method return True. False is returned otherwise.

leave() → None

Called when the Player leaves a running game.

(internal)

property node: bascenev1.Node

A bascenev1.Node of type ‘player’ associated with this Player.

This node can be used to get a generic player position/etc.

on_expire() → None

Can be overridden to handle player expiration.

The player expires when the Activity it is a part of expires. Expired players should no longer run any game logic (which will likely error). They should, however, remove any references to players/teams/games/etc. which could prevent them from being freed.

property position: Vec3

The position of the player, as defined by its bascenev1.Actor.

If the player currently has no actor, raises a babase.ActorNotFoundError.

postinit(sessionplayer: bascenev1.SessionPlayer) → None

Wire up a newly created player.

(internal)

resetinput() → None

Clears out the player’s assigned input actions.

send_feedback(*, event: FeedbackEvent = 'impact_received') → None

Request physical feedback (controller rumble, device vibration) for whoever is controlling this player.

event says what happened; each platform decides how strong and how long that should feel, so there is deliberately nothing else to pass. Note a device may render nothing at all for an event its hardware cannot represent well, so don’t rely on any particular one always being felt.

property sessionplayer: bascenev1.SessionPlayer

Return the bascenev1.SessionPlayer corresponding to this Player.

Throws a bascenev1.SessionPlayerNotFoundError if it does not exist.

property team: TeamT

The bascenev1.Team for this player.

class bascenev1.PlayerDiedMessage(player: bascenev1.Player, was_killed: bool, killerplayer: bascenev1.Player | None, how: DeathType)

Bases: object

A message saying a bascenev1.Player has died.

getkillerplayer(playertype: type[PlayerT]) → PlayerT | None

Return the bascenev1.Player responsible for the killing, if any.

Pass the Player type being used by the current game.

getplayer(playertype: type[PlayerT]) → PlayerT

Return the bascenev1.Player that died.

The type of player for the current activity should be passed so that the type-checker properly identifies the returned value as one.

how: DeathType

The particular type of death.

killed: bool

If True, the player was killed; If False, they left the game or the round ended.

class bascenev1.PlayerInfo(name: str, character: str)

Bases: object

Holds basic info about a player.

character: str

name: str

exception bascenev1.PlayerNotFoundError

Bases: NotFoundError

Raised when an expected player does not exist.

class bascenev1.PlayerProfilesChangedMessage

Bases: object

Signals player profiles may have changed and should be reloaded.

class bascenev1.PlayerRecord(name: str, name_full: str, sessionplayer: bascenev1.SessionPlayer, stats: bascenev1.Stats)

Bases: object

Stats for an individual player in a bascenev1.Stats object.

This does not necessarily correspond to a bascenev1.Player that is still present (stats may be retained for players that leave mid-game)

associate_with_sessionplayer(sessionplayer: bascenev1.SessionPlayer) → None

Associate this entry with a bascenev1.SessionPlayer.

cancel_multi_kill_timer() → None

Cancel any multi-kill timer for this player entry.

character: str

get_icon() → dict[str, Any]

Get the icon for this instance’s player.

get_last_sessionplayer() → bascenev1.SessionPlayer

Return the last bascenev1.Player we were associated with.

getactivity() → bascenev1.Activity | None

Return the bascenev1.Activity this instance is associated with.

Returns None if the activity no longer exists.

getname(full: bool = False) → str

Return the player entry’s name.

property player: bascenev1.SessionPlayer

Return the instance’s associated bascenev1.SessionPlayer.

Raises a bascenev1.SessionPlayerNotFoundError if the player no longer exists.

submit_kill(showpoints: bool = True) → None

Submit a kill for this player entry.

property team: bascenev1.SessionTeam

The bascenev1.SessionTeam the last associated player was last on.

This can still return a valid result even if the player is gone. Raises a bascenev1.SessionTeamNotFoundError if the team no longer exists.

class bascenev1.PlayerScoredMessage(score: int)

Bases: object

Informs something that a bascenev1.Player scored.

score: int

The score value.

class bascenev1.Plugin

Bases: object

A plugin to alter app behavior in some way.

Plugins are discoverable by the MetadataSubsystem system and the user can select which ones they want to enable. Enabled plugins are then called at specific times as the app is running in order to modify its behavior in some way.

has_settings_ui() → bool

Called to ask if we have settings UI we can show.

on_app_running() → None

Called when the app reaches the running state.

on_app_shutdown() → None

Called when the app is beginning the shutdown process.

on_app_shutdown_complete() → None

Called when the app has completed the shutdown process.

on_app_suspend() → None

Called when the app enters the suspended state.

on_app_unsuspend() → None

Called when the app exits the suspended state.

show_settings_ui(source_widget: Any | None) → None

Called to show our settings UI.

class bascenev1.PowerupAcceptMessage

Bases: object

A message informing a bascenev1.Powerup that it was accepted.

This is generally sent in response to a bascenev1.PowerupMessage to inform the box (or whoever granted it) that it can go away.

class bascenev1.PowerupMessage(poweruptype: str, sourcenode: bascenev1.Node | None = None)

Bases: object

A message telling an object to accept a powerup.

This message is normally received by touching a bascenev1.PowerupBox.

poweruptype: str

The type of powerup to be granted (a string). See bascenev1.Powerup.poweruptype for available type values.

sourcenode: bascenev1.Node | None = None

The node the powerup game from, or None otherwise. If a powerup is accepted, a bascenev1.PowerupAcceptMessage should be sent back to the sourcenode to inform it of the fact. This will generally cause the powerup box to make a sound and disappear or whatnot.

class bascenev1.ScoreConfig(label: str = 'Score', scoretype: bascenev1.ScoreType = ScoreType.POINTS, lower_is_better: bool = False, none_is_winner: bool = False, version: str = '')

Bases: object

Settings for how a game handles scores.

label: str = 'Score'

A label show to the user for scores; ‘Score’, ‘Time Survived’, etc.

lower_is_better: bool = False

Whether lower scores are preferable. Higher scores are by default.

none_is_winner: bool = False

Whether a value of None is considered better than other scores. By default it is not.

scoretype: bascenev1.ScoreType = 'p'

How the score value should be displayed.

version: str = ''

To change high-score lists used by a game without renaming the game, change this. Defaults to an empty string.

class bascenev1.ScoreScreenActivity(settings: dict)

Bases: Activity[EmptyPlayer, EmptyTeam]

A standard score screen that fades in and shows stuff for a while.

After a specified delay, player input is assigned to end the activity.

default_music: MusicType | None = 'Scores'

inherits_tint = True

Set this to true to inherit screen tint/vignette colors from the previous activity (useful to prevent sudden color changes during transitions).

inherits_vr_camera_offset = True

Set this to true to inherit VR camera offsets from the previous activity (useful for preventing sporadic camera movement during transitions).

on_begin() → None

Called once the previous activity has finished transitioning out.

At this point the activity’s initial players and teams are filled in and it should begin its actual game logic.

on_player_join(player: EmptyPlayer) → None

Called when a player joins the activity.

(including the initial set of players)

on_transition_in() → None

Called when the activity is first becoming visible.

Upon this call, the activity should fade in backgrounds, start playing music, etc. It does not yet have access to players or teams, however. They remain owned by the previous activity up until on_begin() is called.

transition_time = 0.5

If the activity fades or transitions in, it should set the length of time here so that previous activities will be kept alive for that long (avoiding ‘holes’ in the screen) This value is given in real-time seconds.

use_fixed_vr_overlay = True

In vr mode, this determines whether overlay nodes (text, images, etc) are created at a fixed position in space or one that moves based on the current map. Generally this should be on for games and off for transitions/score-screens/etc. that persist between maps.

class bascenev1.ScoreType(*values)

Bases: Enum

Type of scores.

MILLISECONDS = 'ms'

POINTS = 'p'

SECONDS = 's'

class bascenev1.Session(*, team_names: Sequence[str] | None = None, team_colors: Sequence[Sequence[float]] | None = None, min_players: int = 1, max_players: int = 8, submit_score: bool = True)

Bases: object

Wrangles a series of Activity instances.

Examples of sessions are bascenev1.FreeForAllSession, bascenev1.DualTeamSession, and bascenev1.CoopSession.

A session is responsible for wrangling and transitioning between various activity instances such as mini-games and score-screens, and for maintaining state between them (players, teams, score tallies, etc).

begin_next_activity() → None

Called once the previous activity has been totally torn down.

This means we’re ready to begin the next one.

property context: bascenev1.ContextRef

A context-ref pointing at this activity.

customdata: dict

A shared dictionary for objects to use as storage on this session. Ensure that keys here are unique to avoid collisions.

end() → None

Initiate an end to the session and a return to the main menu.

Note that this happens asynchronously, allowing the session and its activities to shut down gracefully.

end_activity(activity: bascenev1.Activity, results: Any, delay: float, force: bool) → None

Commence shutdown of an activity (if not already occurring).

‘delay’ is the time delay before the activity actually ends (in seconds). Further calls to end the activity will be ignored up until this time, unless ‘force’ is True, in which case the new results will replace the old.

get_custom_menu_entries() → list[dict[str, Any]]

Subclasses can override this to provide custom menu entries.

The returned value should be a list of dicts, each containing a ‘label’ and ‘call’ entry, with ‘label’ being the text for the entry and ‘call’ being the callable to trigger if the entry is pressed.

getactivity() → bascenev1.Activity | None

Return the current foreground activity for this session.

handlemessage(msg: Any) → Any

General message handling; can be passed any message object.

lobby: bascenev1.Lobby

The lobby instance where new players go to select a profile/team/etc. before being added to games. Be aware this value may be None if a session does not allow any such selection.

max_players: int

The maximum number of players allowed in the Session.

min_players: int

The minimum number of players who must be present for the Session to proceed past the initial joining screen

on_activity_end(activity: bascenev1.Activity, results: Any) → None

Called when the current activity has ended.

The session should look at the results and start another activity.

on_player_leave(sessionplayer: bascenev1.SessionPlayer) → None

Called when a previously-accepted bascenev1.SessionPlayer leaves.

on_player_request(player: bascenev1.SessionPlayer) → bool

Called when a new player wants to join the session.

This should return True or False to accept/reject.

on_team_join(team: bascenev1.SessionTeam) → None

Called when a new team joins the session.

on_team_leave(team: bascenev1.SessionTeam) → None

Called when a team is leaving the session.

property sessionglobalsnode: bascenev1.Node

The sessionglobals node for the session.

sessionplayers: list[bascenev1.SessionPlayer]

All players in the session. Note that most things should use the list of Player instances found in the Activity; not this. Some players, such as those who have not yet selected a character, will only be found on this list.

sessionteams: list[bascenev1.SessionTeam]

All the teams in the session. Most things will operate on the list of Team instances found in an Activity; not this.

setactivity(activity: bascenev1.Activity) → None

Assign a new current activity for the session.

Note that this will not change the current context to the new activity’s. Code must be run in the new activity’s methods (on_transition_in(), etc) to get it. (so you can’t do session.setactivity(foo) and then bascenev1.newnode() to add a node to foo).

should_allow_mid_activity_joins(activity: bascenev1.Activity) → bool

Ask ourself if we should allow joins during an Activity.

Note that for a join to be allowed, both the session and activity have to be ok with it (via this function and the bascenev1.Activity.allow_mid_activity_joins property.

tournament_id: str | None

use_team_colors: bool = True

Whether players on a team should all adopt the colors of that team instead of their own profile colors. This only applies if use_teams is enabled.

use_teams: bool = False

Whether this session groups players into an explicit set of teams. If this is off, a unique team is generated for each player that joins.

exception bascenev1.SessionNotFoundError

Bases: NotFoundError

Raised when an expected session does not exist.

class bascenev1.SessionPlayer

Bases: object

A reference to a player in a Session.

These are created and managed internally and provided to your Session/Activity instances. Be aware that, like Node objects, SessionPlayer objects are effectively ‘weak’ references under-the-hood; a player can leave the game at any point. For this reason, you should make judicious use of the bascenev1.SessionPlayer.exists() method (or boolean operator) to ensure that a SessionPlayer is still present if retaining references to one for any length of time.

activityplayer: bascenev1.Player | None

The current game-specific instance for this player.

assigninput(type: bascenev1.InputType | tuple[bascenev1.InputType, ...], call: Callable) → None

Set the python callable to be run for one or more types of input.

character: str

The character this player has selected in their profile.

color: Sequence[float]

The base color for this player. In team games this will match the team’s color.

exists() → bool

Return whether the underlying player is still in the game.

get_account_id() → str | None

Return the account id this player is signed in under, or None if not available. For players connected via protocol < 36 this will be a V1 account id; for protocol >= 36 it will be a V2 account id. Note that this may require an active internet connection (especially for network-connected players) and may return None for a short while after a player initially joins (while verification occurs).

get_icon() → dict[str, Any]

Return the character’s icon (images, colors, etc contained in a dict.

get_v1_account_id() → str | None

Deprecated since version Use: get_account_id() instead. This method will be removed when api 9 support ends.

Return the account id this player is signed in under, if it can be determined with relative certainty. Returns None otherwise.

getname(full: bool = False, icon: bool = True) → str

Returns the player’s name. If icon is True, the long version of the name may include an icon.

highlight: Sequence[float]

A secondary color for this player. This is used for minor highlights and accents to allow a player to stand apart from his teammates who may all share the same team (primary) color.

id: int

The unique numeric id of the player.

Note that you can also use the boolean operator for this same functionality, so a statement such as if player: will do the right thing both for SessionPlayer objects as well as values of None.

in_game: bool

This bool value will be True once the player has completed any lobby character/team selection.

inputdevice: bascenev1.InputDevice

The input device associated with the player.

remove_from_game() → None

Removes the player from the game.

resetinput() → None

Clears out the player’s assigned input actions.

send_feedback(*, event: str = 'impact_received') → None

Request physical feedback (controller rumble, device vibration) for whoever is controlling this player.

event says what happened, not what it should feel like; each platform renders it however it does that best. Valid values are ‘join’, ‘collect’, ‘grab’, ‘impact_dealt’, ‘impact_received’ and ‘death’. Note a device may render nothing at all for an event its hardware cannot represent well, so don’t rely on any particular one always being felt.

Does nothing if the player has already left the game.

sessionteam: bascenev1.SessionTeam

The session-team this session-player is on. If the player is still in its lobby selecting a team/etc. then a SessionTeamNotFoundError will be raised.

setdata(team: bascenev1.SessionTeam, character: str, color: Sequence[float], highlight: Sequence[float]) → None

(internal)

setname(name: str, full_name: str | None = None, real: bool = True) → None

Set the player’s name to the provided string. A number will automatically be appended if the name is not unique from other players.

class bascenev1.SessionTeam(team_id: int = 0, name: str | Lstr | LangStr = '', color: Sequence[float] = (1.0, 1.0, 1.0))

Bases: object

A team of one or more SessionPlayer.

Note that a player will always have a team. in some cases, such as free-for-all Session, each team consists of just one player.

color: tuple[float, ...]

The team’s color.

customdata: dict

A dict for use by the current Session for storing data associated with this team. Unlike customdata, this persists for the duration of the session.

id: int

The unique numeric id of the team.

name: str | babase.LangStr

The team’s name.

Built-in default names are LangStr values; names the player typed themselves are plain strings, shown as-is.

players: list[bascenev1.SessionPlayer]

The list of players on the team.

exception bascenev1.SessionTeamNotFoundError

Bases: NotFoundError

Raised when an expected session-team does not exist.

class bascenev1.Setting(name: str, default: Any)

Bases: object

Defines a user-controllable setting for a game or other entity.

default: Any

name: str

class bascenev1.ShouldShatterMessage

Bases: object

Tells an object that it should shatter.

class bascenev1.Sound

Bases: object

A reference to a sound.

Use bascenev1.getsound() to instantiate one.

play(volume: float = 1.0, position: Sequence[float] | None = None, host_only: bool = False) → None

Play the sound a single time.

If position is not provided, the sound will be at a constant volume everywhere. Position should be a float tuple of size 3.

class bascenev1.SoundVerifiedSpec(apverid: str, name: str)

Bases: SoundSpec

A sound reference that can also load the live scene sound.

get() → bascenev1.Sound

Resolve and return the live scene sound for this reference.

ui() → bauiv1.SoundVerifiedSpec

This same verified reference, in ui form.

Both featuresets’ verified specs assert the same thing – the package was construct-mode-resolved – so converting between them preserves that guarantee; only what get() loads differs (a ui sound vs a scene-bound one). Use at a ui boundary consuming scene-authored config, such as a spaz appearance’s icon.

There is deliberately no reverse scene() on the ui types: scene_v1 always pulls in ui_v1 (via classic), but a spinoff may include ui_v1 with no scene_v1 at all.

class bascenev1.StandLocation(position: Vec3, angle: float | None = None)

Bases: object

Describes a point in space and an angle to face.

angle: float | None = None

position: Vec3

class bascenev1.StandMessage(position: Sequence[float] = (0.0, 0.0, 0.0), angle: float = 0.0)

Bases: object

A message telling an object to move to a position in space.

Used when teleporting players to home base, etc.

angle: float = 0.0

The angle to face (in degrees)

position: Sequence[float] = (0.0, 0.0, 0.0)

Where to move to.

class bascenev1.Stats

Bases: object

Manages scores and statistics for a bascenev1.Session.

get_records() → dict[str, bascenev1.PlayerRecord]

Get PlayerRecord corresponding to still-existing players.

getactivity() → bascenev1.Activity | None

Get the activity associated with this instance.

May return None.

orchestrahitsound1: bascenev1.Sound | None

orchestrahitsound2: bascenev1.Sound | None

orchestrahitsound3: bascenev1.Sound | None

orchestrahitsound4: bascenev1.Sound | None

player_scored(player: bascenev1.Player, base_points: int = 1, *, target: Sequence[float] | None = None, kill: bool = False, victim_player: bascenev1.Player | None = None, scale: float = 1.0, color: Sequence[float] | None = None, title: str | babase.Lstr | babase.LangStr | None = None, screenmessage: bool = True, display: bool = True, importance: int = 1, showpoints: bool = True, big_message: bool = False) → int

Register a score for the player.

Return value is actual score with multipliers and such factored in.

player_was_killed(player: bascenev1.Player, killed: bool = False, killer: bascenev1.Player | None = None) → None

Should be called when a player is killed.

register_sessionplayer(player: bascenev1.SessionPlayer) → None

Register a bascenev1.SessionPlayer with this score-set.

reset() → None

Reset the stats instance completely.

reset_accum() → None

Reset per-sound sub-scores.

setactivity(activity: bascenev1.Activity | None) → None

Set the current activity for this instance.

class bascenev1.Team

Bases: Generic

A team in a specific Activity.

These correspond to SessionTeam objects, but are created per activity so that the activity can use its own custom team subclass.

color: tuple[float, ...]

property customdata: dict

Arbitrary values associated with the team. Though it is encouraged that most player values be properly defined on the Team subclass, it may be useful for player-agnostic objects to store values here. This dict is cleared when the team leaves or expires so objects stored here will be disposed of at the expected time, unlike the Team instance itself which may continue to be referenced after it is no longer part of the game.

id: int

manual_init(team_id: int, name: str | Lstr | LangStr, color: tuple[float, ...]) → None

Manually init a team for uses such as bots.

name: str | LangStr

on_expire() → None

Can be overridden to handle team expiration.

players: list[PlayerT]

property sessionteam: SessionTeam

The SessionTeam corresponding to this team.

Throws a SessionTeamNotFoundError if there is none.

class bascenev1.TeamGameActivity(settings: dict)

Bases: GameActivity, Generic

Base class for teams and free-for-all mode games.

(Free-for-all is essentially just a special case where every player has their own team)

end(results: Any = None, announce_winning_team: bool = True, announce_delay: float = 0.1, force: bool = False) → None

End the game and announce the single winning team unless ‘announce_winning_team’ is False. (for results without a single most-important winner).

on_begin() → None

Called once the previous activity has finished transitioning out.

At this point the activity’s initial players and teams are filled in and it should begin its actual game logic.

on_transition_in() → None

Called when the activity is first becoming visible.

Upon this call, the activity should fade in backgrounds, start playing music, etc. It does not yet have access to players or teams, however. They remain owned by the previous activity up until on_begin() is called.

spawn_player_spaz(player: PlayerT, position: Sequence[float] | None = None, angle: float | None = None) → PlayerSpaz

Override to spawn and wire up a standard PlayerSpaz for a Player.

If position or angle is not supplied, a default will be chosen based on the Player and their Team.

classmethod supports_session_type(sessiontype: type[bascenev1.Session]) → bool

Return whether this game supports the provided session type.

class bascenev1.Texture

Bases: object

A reference to a texture.

Use bascenev1.gettexture() to instantiate one.

class bascenev1.TextureVerifiedSpec(apverid: str, name: str)

Bases: TextureSpec

A texture reference that can also load the live scene texture.

get() → bascenev1.Texture

Resolve and return the live scene texture for this reference.

Loads into the current scene context (see module docs).

ui() → bauiv1.TextureVerifiedSpec

This same verified reference, in ui form.

Both featuresets’ verified specs assert the same thing – the package was construct-mode-resolved – so converting between them preserves that guarantee; only what get() loads differs (a ui texture vs a scene-bound one). Use at a ui boundary consuming scene-authored config, such as a spaz appearance’s icon.

There is deliberately no reverse scene() on the ui types: scene_v1 always pulls in ui_v1 (via classic), but a spinoff may include ui_v1 with no scene_v1 at all.

class bascenev1.ThawMessage

Bases: object

Tells an object to stop being frozen.

class bascenev1.Time

Monotonic time measurement local to a scene activity — pauses when the activity pauses, resets when the activity ends.

alias of float

class bascenev1.Timer(time: float, call: Callable[[], Any], repeat: bool = False)

Bases: object

Timers are used to run code at later points in time.

This class encapsulates a scene-time timer in the current bascenev1.Context. The underlying timer will be destroyed when either this object is no longer referenced or when its Context (Activity, etc.) dies. If you do not want to worry about keeping a reference to your timer around, you should use the bs.timer() function instead.

Scene time maps to local simulation time in bascenev1.Activity or bascenev1.Session Contexts. This means that it may progress slower in slow-motion play modes, stop when the game is paused, etc.

Parameters:

• time – Length of time (in seconds by default) that the timer will wait before firing. Note that the actual delay experienced may vary depending on the timetype. (see below)

• call – A callable Python object. Note that the timer will retain a strong reference to the callable for as long as it exists, so you may want to look into concepts such as WeakCall if that is not desired.

• repeat – If True, the timer will fire repeatedly, with each successive firing having the same delay as the first.

Example: Use a Timer object to print repeatedly for a few seconds:

import bascenev1 as bs

def say_it():
    bs.screenmessage('BADGER!')

def stop_saying_it():
    global g_timer
    g_timer = None
    bs.screenmessage('MUSHROOM MUSHROOM!')

# Create our timer; it will run as long as we hold its ref.
g_timer = bs.Timer(0.3, say_it, repeat=True)

# Now fire off a one-shot timer to kill the ref.
bs.timer(3.89, stop_saying_it)

class bascenev1.UIScale(*values)

Bases: Enum

The overall scale the UI is being rendered for. Note that this is independent of pixel resolution. For example, a phone and a desktop PC might render the game at similar pixel resolutions but the size they display content at will vary significantly.

‘large’ is used for devices such as desktop PCs where fine details can

be clearly seen. UI elements are generally smaller on the screen and more content can be seen at once.

‘medium’ is used for devices such as tablets, TVs, or VR headsets.

This mode strikes a balance between clean readability and amount of content visible.

‘small’ is used primarily for phones or other small devices where

content needs to be presented as large and clear in order to remain readable from an average distance.

LARGE = 2

MEDIUM = 1

SMALL = 0

bascenev1.UNHANDLED: bascenev1._messages._UnhandledType = <bascenev1._messages._UnhandledType object>

Gameplay-centric api for classic BombSquad.

class bascenev1.Vec3

class bascenev1.Vec3(value: float)

class bascenev1.Vec3(values: Sequence[float])

class bascenev1.Vec3(x: float, y: float, z: float)

Bases: Sequence[float]

A vector of 3 floats.

These can be created the following ways (checked in this order):

• With no args, all values are set to 0.

• With a single numeric arg, all values are set to that value.

• With a three-member sequence arg, sequence values are copied.

• Otherwise assumes individual x/y/z args (positional or keywords).

cross(other: Vec3) → Vec3

Returns the cross product of this vector and another.

dot(other: Vec3) → float

Returns the dot product of this vector and another.

length() → float

Returns the length of the vector.

normalized() → Vec3

Returns a normalized version of the vector.

x: float

The vector’s X component.

y: float

The vector’s Y component.

z: float

The vector’s Z component.

class bascenev1.WeakCall(**kwargs)

Bases: object

Transitional alias of WeakCallPartial.

Deprecated — pick WeakCallPartial or WeakCallStrict explicitly. The @deprecated decorator emits the runtime warning and is picked up by type-checkers/IDEs so call sites are flagged statically. The WeakCall name will return after API 9 support ends but will then alias WeakCallStrict, so migrating away now avoids a silent behavior change later.

class bascenev1.WeakCallPartial(call: Any, /, *args: Any, **keywds: Any)

Bases: object

Wrap a callable and arguments into a single callable object.

When passed a bound method as the callable, the instance portion of it is weak-referenced, meaning the underlying instance is free to die if all other references to it go away. Should this occur, calling the weak-call is simply a no-op.

Think of this as a handy way to tell an object to do something at some point in the future if it happens to still exist.

EXAMPLE A: This code will create a FooClass instance and call its bar() method 5 seconds later; it will be kept alive even though we overwrite its variable with None because the bound method we pass as a timer callback (foo.bar) strong-references it:

foo = FooClass()
babase.apptimer(5.0, foo.bar)
foo = None

EXAMPLE B: This code will not keep our object alive; it will die when we overwrite it with None and the timer will be a no-op when it fires:

foo = FooClass()
babase.apptimer(5.0, ba.WeakCall(foo.bar))
foo = None

EXAMPLE C: Wrap a method call with some positional and keyword args:

myweakcall = babase.WeakCall(self.dostuff, argval1,
                             namedarg=argval2)

# Now we have a single callable to run that whole mess.
# The same as calling myobj.dostuff(argval1, namedarg=argval2)
# (provided my_obj still exists; this will do nothing otherwise).
myweakcall()

Note: additional args and keywords you provide to the weak-call constructor are stored as regular strong-references; you’ll need to wrap them in weakrefs manually if desired.

class bascenev1.WeakCallStrict(call: Callable[P, T], /, *args: P.args, **kwargs: P.kwargs)

Bases: Generic[P, T]

Like WeakCallPartial() but disallows extra args at call time.

This allows more complete type checking to occur, so this is recommended if you do not need extra args at call time.

args

call: Any

kwargs

class bascenev1.WinnerGroup(score: int | None, teams: list[bascenev1.SessionTeam])

Bases: object

Winning team or teams as calculated by a GameResults.

score: int | None

teams: list[bascenev1.SessionTeam]

bascenev1.animate(node: bascenev1.Node, attr: str, keys: dict[float, float], loop: bool = False, offset: float = 0) → bascenev1.Node

Animate values on a target bascenev1.Node.

Creates an ‘animcurve’ node with the provided values and time as an input, connect it to the provided attribute, and set it to die with the target. Key values are provided as time:value dictionary pairs. Time values are relative to the current time. By default, times are specified in seconds, but timeformat can also be set to MILLISECONDS to recreate the old behavior (prior to ba 1.5) of taking milliseconds. Returns the animcurve node.

bascenev1.animate_array(node: bascenev1.Node, attr: str, size: int, keys: dict[float, Sequence[float]], *, loop: bool = False, offset: float = 0) → None

Animate an array of values on a target bascenev1.Node.

Like bs.animate, but operates on array attributes.

bascenev1.app: babase._app.App = <babase._app.App object>

The App singleton for the current process. Also exposed at bauiv1.app, bascenev1.app, etc. — they all refer to this same object.

bascenev1.apptime() → babase.AppTime

Return the current app-time in seconds.

App-time is a monotonic time value; it starts at 0.0 when the app launches and will never jump by large amounts or go backwards, even if the system time changes. Its progression will pause when the app is in a suspended state.

Note that the AppTime returned here is simply float; it just has a unique type in the type-checker’s eyes to help prevent it from being accidentally used with time functionality expecting other time types.

bascenev1.apptimer(time: float, call: Callable[[], Any]) → None

Schedule a callable object to run based on app-time.

This function creates a one-off timer which cannot be canceled or modified once created. If you require the ability to do so, or need a repeating timer, use the babase.AppTimer class instead.

Parameters:

• time – Length of time in seconds that the timer will wait before firing.

• call – A callable Python object. Note that the timer will retain a strong reference to the callable for as long as the timer exists, so you may want to look into concepts such as WeakCall if that is not desired.

Example: Print some stuff through time:

import babase

babase.screenmessage('hello from now!')
babase.apptimer(1.0, babase.Call(babase.screenmessage,
                'hello from the future!'))
babase.apptimer(2.0, babase.Call(babase.screenmessage,
                'hello from the future 2!'))

bascenev1.basetime() → bascenev1.BaseTime

Return the base-time in seconds for the current scene-v1 context.

Base-time is a time value that progresses at a constant rate for a scene, even when the scene is sped up, slowed down, or paused. It may, however, speed up or slow down due to replay speed adjustments or may slow down if the cpu is overloaded. Note that the value returned here is simply a float; it just has a unique type in the type-checker’s eyes to help prevent it from being accidentally used with time functionality expecting other time types.

bascenev1.basetimer(time: float, call: Callable[[], Any], repeat: bool = False) → None

Schedule a call to run at a later point in scene base-time. Base-time is a value that progresses at a constant rate for a scene, even when the scene is sped up, slowed down, or paused. It may, however, speed up or slow down due to replay speed adjustments or may slow down if the cpu is overloaded.

This function adds a timer to the current scene context. This timer cannot be canceled or modified once created. If you require the ability to do so, use the bascenev1.BaseTimer class instead.

Parameters:

• time – Length of time in seconds that the timer will wait before firing.

• call – A callable Python object. Remember that the timer will retain a strong reference to the callable for the duration of the timer, so you may want to look into concepts such as WeakCall if that is not desired.

• repeat – If True, the timer will fire repeatedly, with each successive firing having the same delay as the first.

Example: Print some stuff through time:

import bascenev1 as bs

bs.screenmessage('hello from now!')
bs.basetimer(1.0, bs.Call(bs.screenmessage,
             'hello from the future!'))
bs.basetimer(2.0, bs.Call(bs.screenmessage,
             'hello from the future 2!'))

bascenev1.broadcastmessage(message: str | babase.Lstr | babase.LangStr, color: Sequence[float] | None = None, top: bool = False, image: dict[str, Any] | None = None, log: bool = False, clients: Sequence[int] | None = None, transient: bool = False) → None

Broadcast a screen-message to clients in the current session.

If ‘top’ is True, the message will go to the top message area. For ‘top’ messages, ‘image’ must be a dict containing ‘texture’ and ‘tint_texture’ textures and ‘tint_color’ and ‘tint2_color’ colors. This defines an icon to display alongside the message. If ‘log’ is True, the message will also be submitted to the log. ‘clients’ can be a list of client-ids the message should be sent to, or None to specify that everyone should receive it. If ‘transient’ is True, the message will not be included in the game-stream and thus will not show up when viewing replays. Currently the ‘clients’ option only works for transient messages.

bascenev1.cameraflash(duration: float = 999.0) → None

Create a strobing camera flash effect.

(as seen when a team wins a game) Duration is in seconds.

bascenev1.camerashake(intensity: float = 1.0) → None

Shake the camera.

Note that some cameras and/or platforms (such as VR) may not display camera-shake, so do not rely on this always being visible to the player as a gameplay cue.

bascenev1.chatmessage(message: str | babase.Lstr | babase.LangStr, clients: Sequence[int] | None = None, sender_override: str | None = None) → None

(internal)

bascenev1.client_info_query_response(token: str, response: Any) → None

(internal)

bascenev1.connect_to_party(address: str, port: int = 43210, print_progress: bool = True) → None

Attempt to connect to a party at a given address.

Runs the pre-join requirements exchange first: the prospective host is asked what it requires of joiners (its asset-package listing, etc.) and anything not yet locally available is downloaded – with a cancelable progress dialog – before the actual connection attempt happens. Hosts confirmed (via the legacy discovery query) to predate the requirements protocol get a plain immediate connect; hosts new enough to require the exchange never get an unprepped connect (a failed exchange fails the join).

(internal)

bascenev1.disconnect_client(client_id: int, ban_time: int = 300) → bool

(internal)

bascenev1.disconnect_from_host() → None

(internal)

bascenev1.displaytime() → babase.DisplayTime

Return the current display-time in seconds.

Display-time is a time value intended to be used for animation and other visual purposes. It will generally increment by a consistent amount each frame. It will pass at an overall similar rate to app-time, but trades accuracy for smoothness.

Note that the value returned here is simply a float; it just has a unique type in the type-checker’s eyes to help prevent it from being accidentally used with time functionality expecting other time types.

bascenev1.displaytimer(time: float, call: Callable[[], Any]) → None

Schedule a callable object to run based on display-time.

This function creates a one-off timer which cannot be canceled or modified once created. If you require the ability to do so, or need a repeating timer, use the DisplayTimer class instead.

Display-time is a time value intended to be used for animation and other visual purposes. It will generally increment by a consistent amount each frame. It will pass at an overall similar rate to app-time, but trades accuracy for smoothness.

Parameters:

• time – Length of time in seconds that the timer will wait before firing.

• call – A callable Python object. Note that the timer will retain a strong reference to the callable for as long as the timer exists, so you may want to look into concepts such as WeakCall if that is not desired.

Example: Print some stuff through time:

babase.screenmessage('hello from now!')
babase.displaytimer(1.0, babase.Call(babase.screenmessage,
                    'hello from the future!'))
babase.displaytimer(2.0, babase.Call(babase.screenmessage,
                    'hello from the future 2!'))

bascenev1.emitfx(position: Sequence[float], velocity: Sequence[float] | None = None, count: int = 10, scale: float = 1.0, spread: float = 1.0, chunk_type: str = 'rock', emit_type: str = 'chunks', tendril_type: str = 'smoke') → None

Emit particles, smoke, etc. into the fx sim layer.

The fx sim layer is a secondary dynamics simulation that runs in the background and just looks pretty; it does not affect gameplay. Note that the actual amount emitted may vary depending on graphics settings, exiting element counts, or other factors.

bascenev1.end_host_scanning() → None

(internal)

bascenev1.existing(obj: ExistableT | None) → ExistableT | None

Convert invalid refs to None for an Existable.

To best support type checking, it is important that invalid references not be passed around and instead get converted to values of None. That way the type checker can properly flag attempts to pass possibly-dead objects (FooType | None) into functions expecting only live ones (FooType), etc. This call can be used on any ‘existable’ object (one with an exists() method) to convert it to None if it does not exist.

For more info about the concept of ‘existables’: https://ballistica.net/wiki/Coding-Style-Guide

bascenev1.fetch_host_requirements(address: str, port: int) → HostRequirements | HostProbeOutcome

Probe a prospective host for its join requirements.

Fires the paged UDP requirements query and the legacy discovery query together (fragments merge across pages: lists concatenate, scalars are first-seen; the discovery response’s protocol version disambiguates old hosts from packet loss without waiting out timeouts). Blocking (network waits up to a few seconds); call from a background thread.

Returns the host’s HostRequirements, or a HostProbeOutcome describing why there are none.

bascenev1.filter_playlist(playlist: PlaylistType, sessiontype: type[Session], *, add_resolved_type: bool = False, remove_unowned: bool = True, mark_unowned: bool = False, name: str = '?') → PlaylistType

Return a filtered version of a playlist.

Strips out or replaces invalid or unowned game types, makes sure all settings are present, and adds in a ‘resolved_type’ which is the actual type.

bascenev1.get_chat_messages() → list[str]

(internal)

bascenev1.get_client_ping(client_id: int) → float

Return the current ping (RTT in ms) for a connected client. Returns -1.0 if client_id is invalid.

bascenev1.get_connection_to_host_info() → dict

(internal)

bascenev1.get_connection_to_host_info_2() → bascenev1.HostInfo | None

Return info about the host we are currently connected to.

bascenev1.get_default_free_for_all_playlist() → list[dict[str, Any]]

Return a default playlist for free-for-all mode.

bascenev1.get_default_powerup_distribution() → Sequence[tuple[str, int]]

Standard set of powerups.

bascenev1.get_default_teams_playlist() → list[dict[str, Any]]

Return a default playlist for teams mode.

bascenev1.get_filtered_map_name(name: str) → str

Filter a map name to account for name changes, etc.

This can be used to support old playlists, etc.

bascenev1.get_game_port() → int

(internal)

Return the port ballistica is hosting on.

bascenev1.get_main_ui_input_device() → bascenev1.InputDevice | None

Return the input-device currently controlling the main ui, or None if there is none.

bascenev1.get_map_class(name: str) → type[Map]

Return a map type given a name.

bascenev1.get_map_display_string(name: str, *, langstr: Literal[False] = False) → Lstr

bascenev1.get_map_display_string(name: str, *, langstr: Literal[True]) → LangStr

Return a displayable name for a given map.

Pass langstr=True to receive a LangStr (or a plain str for a map we have no entry for, such as a mod’s). The legacy Lstr form goes away when api 9 support ends.

bascenev1.get_player_colors() → list[tuple[float, float, float]]

Return user-selectable player colors.

bascenev1.get_player_profile_colors(profilename: str | None, profiles: dict[str, dict[str, Any]] | None = None) → tuple[tuple[float, float, float], tuple[float, float, float]]

Given a profile, return colors for them.

bascenev1.get_player_profile_icon(profilename: str) → str

Given a profile name, returns an icon string for it.

(non-account profiles only)

bascenev1.get_public_party_enabled() → bool

(internal)

bascenev1.get_public_party_max_size() → int

(internal)

bascenev1.get_trophy_string(trophy_id: str) → str

Given a trophy id, returns a string to visualize it.

bascenev1.getactivity(doraise: Literal[True] = True) → bascenev1.Activity

bascenev1.getactivity(doraise: Literal[False]) → bascenev1.Activity | None

Return the current bascenev1.Activity instance.

Note that this is based on context_ref; thus code run in a timer generated in Activity ‘foo’ will properly return ‘foo’ here, even if another Activity has since been created or is transitioning in. If there is no current Activity, raises a babase.ActivityNotFoundError. If doraise is False, None will be returned instead in that case.

bascenev1.getcollision() → Collision

Return the in-progress collision.

bascenev1.getcollisionmesh(name: str) → bascenev1.CollisionMesh

Return a collision-mesh, loading it if necessary.

Collision-meshes are used in physics calculations for such things as terrain.

Note that this function returns immediately even if the asset has yet to be loaded. Loading will happen in the background or on-demand. To avoid hitches, try to instantiate asset objects a bit earlier than they are actually needed, giving them time to load gracefully in the background.

bascenev1.getdata(name: str) → bascenev1.Data

Return a data, loading it if necessary.

Note that this function returns immediately even if the asset has yet to be loaded. Loading will happen in the background or on-demand. To avoid hitches, try to instantiate asset objects a bit earlier than they are actually needed, giving them time to load gracefully in the background.

bascenev1.getmesh(name: str) → bascenev1.Mesh

Return a mesh, loading it if necessary.

Note that this function returns immediately even if the asset has yet to be loaded. Loading will happen in the background or on-demand. To avoid hitches, try to instantiate asset objects a bit earlier than they are actually needed, giving them time to load gracefully in the background.

bascenev1.getnodes() → list

Return all nodes in the current scene context.

bascenev1.getsession(doraise: Literal[True] = True) → bascenev1.Session

bascenev1.getsession(doraise: Literal[False]) → bascenev1.Session | None

Return the session associated with the current context. If there is none, a SessionNotFoundError is raised (unless doraise is False, in which case None is returned instead).

bascenev1.getsound(name: str) → bascenev1.Sound

Return a sound, loading it if necessary.

Note that this function returns immediately even if the asset has yet to be loaded. Loading will happen in the background or on-demand. To avoid hitches, try to instantiate asset objects a bit earlier than they are actually needed, giving them time to load gracefully in the background.

bascenev1.gettexture(name: str) → bascenev1.Texture

Return a texture, loading it if necessary.

Note that this function returns immediately even if the asset has yet to be loaded. Loading will happen in the background or on-demand. To avoid hitches, try to instantiate asset objects a bit earlier than they are actually needed, giving them time to load gracefully in the background.

bascenev1.init_campaigns() → None

Fill out initial default Campaigns.

bascenev1.launch_replay(file_name: str) → None

Immediately start a session playing back a replay file.

Assumes the replay’s required asset-packages are already present locally; use new_replay_session() (or prepare_replay()) to resolve/download them first. This is the raw launch that the prep path hands off to.

(internal)

bascenev1.ls_input_devices() → None

Log debugging info about input devices.

bascenev1.ls_objects() → None

Log debugging info about C++ level objects.

This call only functions in debug builds of the game. It prints various info about the current object count, etc.

bascenev1.new_replay_session(file_name: str) → None

Prepare and play a replay: resolve content, then start playback.

A one-call convenience combining prepare_replay() and launch_replay() – content not present locally is downloaded (with a cancelable dialog) before playback begins, mirroring connect_to_party()’s pre-join content prep. A replay whose content is already local (the common case) or which predates asset-package tables starts immediately.

(internal)

bascenev1.newactivity(activity_type: type[bascenev1.Activity], settings: dict | None = None) → bascenev1.Activity

Instantiates a bascenev1.Activity given a type object.

Activities require special setup and thus cannot be directly instantiated; you must go through this function.

bascenev1.newnode(type: str, owner: bascenev1.Node | None = None, attrs: dict | None = None, name: str | None = None, delegate: Any = None) → bascenev1.Node

Add a node of the given type to the game.

If a dict is provided for ‘attributes’, the node’s initial attributes will be set based on them.

‘name’, if provided, will be stored with the node purely for debugging purposes. If no name is provided, an automatic one will be generated such as ‘terrain@foo.py:30’.

If ‘delegate’ is provided, Python messages sent to the node will go to that object’s handlemessage() method. Note that the delegate is stored as a weak-ref, so the node itself will not keep the object alive.

if ‘owner’ is provided, the node will be automatically killed when that object dies. ‘owner’ can be another node or a bascenev1.Actor

bascenev1.normalized_color(color: Sequence[float]) → tuple[float, ...]

Scale a color so its largest value is 1.0; useful for coloring lights.

async bascenev1.prepare_replay(file_name: str) → bool

Resolve a replay’s required asset-packages before playback.

The requirements are read from the replay file’s header (no stream decompression) and anything not present locally is downloaded, with a cancelable progress dialog. Returns True when the replay is ready to play, or False if the user cancelled or a download failed.

Safe to call with the launching UI still visible: on a False result the caller should leave that UI in place (a cancel then just closes the dialog and returns the user to where they were).

(internal)

bascenev1.print_live_object_warnings(when: Any, ignore_session: bascenev1.Session | None = None, ignore_activity: bascenev1.Activity | None = None) → None

Print warnings for remaining objects in the current context.

IMPORTANT - don’t call this in production; usage of gc.get_objects() can bork Python. See notes at top of efro.debug module.

bascenev1.printnodes() → None

Print various info about existing nodes; useful for debugging.

bascenev1.pushcall(call: Callable, from_other_thread: bool = False, suppress_other_thread_warning: bool = False, other_thread_use_fg_context: bool = False, raw: bool = False) → None

Push a call to the logic-thread’s event loop.

This function expects to be called from the logic thread, and will automatically save and restore the context to behave seamlessly.

To push a call from outside of the logic thread, pass from_other_thread=True. In that case the call will run with no context set. To instead run in whichever context is currently active on the logic thread, pass other_thread_use_fg_context=True. Passing raw=True will skip thread checks and context saves/restores altogether.

bascenev1.register_map(maptype: type[Map]) → None

Register a map class with the game.

bascenev1.reload_hooks() → None

Reload functions and other objects held by the native layer. Call this if you replace things in a hooks module to get the native layer to see your changes.

bascenev1.safecolor(color: Sequence[float], target_intensity: float = 0.6) → tuple[float, ...]

Given a color tuple, return a color safe to display as text.

Accepts tuples of length 3 or 4. This will slightly brighten very dark colors, etc.

bascenev1.screenmessage(message: str | babase.Lstr | babase.LangStr | bacommon.langstr.LangStrSpec, color: Sequence[float] | None = None, log: bool = False, literal: bool = False) → None

Print a message to the local client’s screen in a given color.

Note that this function is purely for local display. To broadcast screen-messages during gameplay, look for methods such as bascenev1.broadcastmessage().

bascenev1.set_admins(admins: list[str]) → None

(internal)

bascenev1.set_authenticate_clients(enable: bool) → None

(internal)

bascenev1.set_enable_default_kick_voting(enable: bool) → None

(internal)

bascenev1.set_internal_music(music: babase.SimpleSound | None, volume: float = 1.0, loop: bool = True) → None

:meta private:.

bascenev1.set_master_server_source(source: int) → None

(internal)

bascenev1.set_max_players_override(max_players: int | None) → None

Set the override for how many players can join a session

bascenev1.set_player_rejoin_cooldown(cooldown: float) → None

Set the cooldown for individual players rejoining after leaving.

bascenev1.set_public_party_enabled(enabled: bool) → None

(internal)

bascenev1.set_public_party_max_size(max_size: int) → None

(internal)

bascenev1.set_public_party_name(name: str) → None

(internal)

bascenev1.set_public_party_public_address_ipv4(address: str | None) → None

(internal)

bascenev1.set_public_party_public_address_ipv6(address: str | None) → None

(internal)

bascenev1.set_public_party_queue_enabled(max_size: bool) → None

(internal)

bascenev1.set_public_party_stats_url(url: str | None) → None

(internal)

bascenev1.setmusic(musictype: MusicType | None, continuous: bool = False) → None

Set the app to play (or stop playing) a certain type of music.

This function will handle loading and playing sound assets as necessary, and also supports custom user soundtracks on specific platforms so the user can override particular game music with their own.

Pass None to stop music.

if continuous is True and musictype is the same as what is already playing, the playing track will not be restarted.

bascenev1.show_damage_count(damage: str, position: Sequence[float], direction: Sequence[float], dead: bool = False) → None

Pop up a damage count at a position in space.

bascenev1.storagename(suffix: str | None = None) → str

Generate a unique name for storing class data in shared places.

This consists of a leading underscore, the module path at the call site with dots replaced by underscores, the containing class’s qualified name, and the provided suffix. When storing data in public places such as ‘customdata’ dicts, this minimizes the chance of collisions with other similarly named classes.

Note that this will function even if called in the class definition.

Example: Generate a unique name for storage purposes:

class MyThingie:

    # This will give something like
    # '_mymodule_submodule_mythingie_data'.
    _STORENAME = babase.storagename('data')

    # Use that name to store some data in the Activity we were
    # passed.
    def __init__(self, activity):
        activity.customdata[self._STORENAME] = {}

bascenev1.time() → bascenev1.Time

Return the current scene time in seconds.

Scene time maps to local simulation time in bascenev1.Activity or bascenev1.Session Contexts. This means that it may progress slower in slow-motion play modes, stop when the game is paused, etc.

Note that the value returned here is simply a float; it just has a unique type in the type-checker’s eyes to help prevent it from being accidentally used with time functionality expecting other time types.

bascenev1.timer(time: float, call: Callable[[], Any], repeat: bool = False) → None

Schedule a call to run at a later point in time.

This function adds a scene-time timer to the current bascenev1.ContextRef. This timer cannot be canceled or modified once created. If you require the ability to do so, use the bascenev1.Timer class instead.

Scene time maps to local simulation time in bascenev1.Activity or bascenev1.Session Contexts. This means that it may progress slower in slow-motion play modes, stop when the game is paused, etc.

Parameters:

• time – Length of scene time in seconds that the timer will wait before firing.

• call – A callable Python object. Note that the timer will retain a strong reference to the callable for as long as it exists, so you may want to look into concepts such as bascenev1.WeakCall if that is not desired.

• repeat – If True, the timer will fire repeatedly, with each successive firing having the same delay as the first.

Examples

Print some stuff through time:

import bascenev1 as bs
bs.screenmessage('hello from now!')
bs.timer(1.0, bs.Call(bs.screenmessage, 'hello from the future!'))
bs.timer(2.0, bs.Call(bs.screenmessage, 'hello from the future 2!'))

bascenev1.timestring(timeval: float | int, centi: bool = True, *, langstr: Literal[False] = False) → babase.Lstr

bascenev1.timestring(timeval: float | int, centi: bool = True, *, langstr: Literal[True]) → babase.LangStr

Generate a localized string for displaying a time value.

Given a time value, returns a localized string with: (hours if > 0 ) : minutes : seconds : (centiseconds if centi=True).

Pass langstr=True to receive a LangStr. The legacy Lstr form goes away when api 9 support ends.

Warning

the underlying localized-string value is somewhat large, so don’t use this to rapidly update text values for an in-game timer or you may consume significant network bandwidth. For that sort of thing you should use things like ‘timedisplay’ nodes and attribute connections.

Submodules

bascenev1.builtinassets module

Asset-package wrapper for a-0.babuiltinassets.260730a (bascenev1).

Bare minimum assets always bundled with the engine.

These are loaded at launch and always available in the C++ layer.

class bascenev1.builtinassets.AudioGroup

Bases: object

Sounds needed during engine bootstrap and early UI (clicks, errors,
and other always-available effects).

See source for the full asset list.

class bascenev1.builtinassets.MeshesGroup

Bases: object

Meshes needed during engine bootstrap and early UI.

See source for the full asset list.

class bascenev1.builtinassets.StringsAccountGroup

Bases: object

Account and sign-in vocabulary: status, error, and requirement
messages about the player account.

See source for the full asset list.

must_sign_in: LangStr

Error screen-message shown to a player who attempts to join a
party or server that requires account authentication while they
are not signed in to an account.

English: "You must sign in to do this."

not_using_account(*, service: str | LangStr) → LangStr

Notice that a platform account is being ignored.

English: "Note: Ignoring your {service} account. Go to Account >
Sign in to use it."

sign_in_error: LangStr

Error message shown when signing in fails.

English: "Error signing in."

updating_account: LangStr

Notice that the account is being updated.

English: "Updating your account..."

class bascenev1.builtinassets.StringsAssetsGroup

Bases: object

Asset-system progress and error strings: boot-time (construct-mode)
bring-up, package download/build progress dialogs, and the
pre-main-menu sign-in gate.

See source for the full asset list.

access_denied_guidance(*, detail: str | LangStr) → LangStr

Wraps a server-supplied asset access-denial explanation with
guidance for the user; shown on the boot-time asset dialog.

English: "{detail} Remove these mods/changes and try again."

all_assets_requested_quality: LangStr

Screen message shown when a resolve finally lands the requested
asset quality after previously showing lower-quality fallbacks.
Paired with requested_quality_assets_building.

English: "All assets are now requested quality."

authenticating: LangStr

Status line in the boot-time asset dialog while waiting for
account sign-in so restricted assets can load.

English: "Authenticating…"

building_assets(*, count: int) → LangStr

Progress-dialog line shown while the server builds assets;
updates live as the remaining count drops. Spans every package
being built, so it names no package.

English: (one) "Building assets (# remaining)…" / (other)
"Building assets (# remaining)…"

building_assets_no_count: LangStr

Progress-dialog line shown once asset builds have started but
before the total step count is known (some packages have not
reported yet). Replaced by the counted line once it is.

English: "Building assets…"

client_too_old: LangStr

Error on the boot-time asset dialog when this app build is too
old to load current assets (fallback wording when the server
didn't supply its own).

English: "This app version is too old to load current assets.
Please update to continue."

content_error_guidance(*, detail: str | LangStr) → LangStr

Wraps a server-supplied asset build-failure explanation with
guidance for the package author; shown on the boot-time asset
dialog (this state is nearly always seen by the author, since
dev/test versions only resolve for them).

English: "{detail} Fix the file in the source workspace and try
again."

downloading_assets(*, count: int) → LangStr

Progress-dialog line shown while asset files download; updates
live as the remaining count drops.

English: (one) "Downloading assets (# remaining)…" / (other)
"Downloading assets (# remaining)…"

load_error: LangStr

Generic error on the boot-time asset dialog when asset loading
fails unexpectedly.

English: "An error occurred loading assets; see log for details."

preparing_build: LangStr

Progress-dialog line shown while server-side asset builds are
being prepared, before per-step progress is known.

English: "Preparing to build assets…"

requested_quality_assets_building: LangStr

Screen message shown after a resolve that had to serve
lower-quality textures because the requested quality was still
being built. Paired with all_assets_requested_quality, which
announces the recovery.

English: "Requested quality assets are still building; showing
lower quality fallbacks."

sign_in_failed: LangStr

Error on the boot-time asset dialog when a required sign-in was
not completed (attempted and failed, or timed out); a Retry
button sits below it.

English: "You must sign in to an account with access to these
assets to continue. Retry to sign in, or remove these
mods/changes."

sign_in_needed_browser(*, address: str | LangStr) → LangStr

Message on the boot-time sign-in dialog when required assets
need a signed-in account and a web browser is available; a Sign
In button sits below it.

English: "Sign-in is required to load these assets. Press the
button below, or visit {address}"

sign_in_needed_other_device(*, address: str | LangStr) → LangStr

Message on the boot-time sign-in dialog when required assets
need a signed-in account and this device has no web browser.

English: "Sign-in is required to load these assets. On another
device, visit {address}"

signing_in: LangStr

Status line in the boot-time asset dialog after a browser sign-in
completes, while the account finishes validating.

English: "Signing in…"

class bascenev1.builtinassets.StringsAudioGroup

Bases: object

Audio-related messages: music/custom-soundtrack playback errors.

See source for the full asset list.

music_play_error(*, music: str | LangStr) → LangStr

Error screen-message shown when a custom-soundtrack music file
fails to play; the placeholder is the quoted filename.

English: "Error playing music: {music}"

class bascenev1.builtinassets.StringsGroup

Bases: object

New-format engine strings needed early or accessed from the C++
layer via the builtin-strings API (see ballistica-internal
strings-asset-migration decision D22).

See source for the full asset list.

class bascenev1.builtinassets.StringsInputGroup

Bases: object

Input-device strings: device display names and connect/disconnect
notices.

See source for the full asset list.

axis(*, number: str | LangStr) → LangStr

Short lowercase label identifying a numbered joystick axis by
index; used inline in axis-name displays such as the
controls-configuration UI. The {number} placeholder is the axis
index.

English: "axis {number}"

button(*, number: str | LangStr) → LangStr

Short lowercase label identifying a numbered controller button
by index; used inline in button-name displays such as the
controls-configuration UI. The {number} placeholder is the
button index.

English: "button {number}"

controller_connected(*, controller: str | LangStr) → LangStr

Transient screen-message shown when a single game controller
connects, naming the device (several connecting at once use a
separate counted message).

English: "{controller} connected."

controller_detected: LangStr

Transient screen-message shown at app startup when exactly one
game controller is detected (multiple controllers at startup use
a separate counted message).

English: "1 controller detected."

controller_disconnected(*, controller: str | LangStr) → LangStr

Transient screen-message shown when a single game controller
disconnects, naming the device (several disconnecting at once
use a separate counted message).

English: "{controller} disconnected."

controller_menus_only: LangStr

Notice that a controller works only in menus.

English: "This controller can not be used to play; only to
navigate menus."

controller_reconnected(*, controller: str | LangStr) → LangStr

Transient screen-message shown when a previously-connected game
controller (e.g. a BombSquad Remote phone client) reconnects,
naming the device.

English: "{controller} reconnected."

controllers_connected(*, count: int) → LangStr

Transient screen-message shown when multiple game controllers
connect at the same time (a single controller connecting shows a
different message naming that controller).

English: (one) "# controller connected." / (other) "#
controllers connected."

controllers_detected(*, count: int) → LangStr

Transient screen-message shown at app startup when more than one
game controller is detected at once (a single controller at
startup uses a separate message).

English: (one) "# controller detected." / (other) "# controllers
detected."

controllers_disconnected(*, count: int) → LangStr

Transient screen-message shown when multiple game controllers
disconnect at the same time (a single controller disconnecting
shows a different message naming that controller).

English: (one) "# controller disconnected." / (other) "#
controllers disconnected."

keyboard: LangStr

Display name for the keyboard input device; shown in input-device
lists, controls-configuration UI, and messages naming the device.

English: "Keyboard"

touch_screen: LangStr

Display name for the touch-screen input device; shown in
input-device lists, controls-configuration UI, and messages
naming the device.

English: "TouchScreen"

touch_screen_join_warning: LangStr

Warning screen-message shown when the touchscreen joins the game
while physical controllers are already active (touch joins are
often accidental then); tells the player how to back out. 'Menu'
and 'Leave Game' refer to in-game menu items.

English: "You have joined with the touchscreen. If this was a
mistake, tap Menu -> Leave Game with it to back out."

unsupported_controller(*, name: str | LangStr) → LangStr

Notice that a controller is not supported.

English: "Sorry, the {name} controller is not supported."

vr_orientation_reset: LangStr

Confirmation screen-message shown in VR mode when the player
resets the headset's forward orientation via their controller.

English: "VR orientation reset."

vr_orientation_reset_cardboard: LangStr

Explanation of the VR orientation reset on Cardboard.

English: "Use this to reset the VR orientation. To play, you'll
need an external controller."

class bascenev1.builtinassets.StringsNetGroup

Bases: object

Networking error messages shown to the player.

See source for the full asset list.

account_rejected: LangStr

Error screen-message shown to a player whose attempt to join a
party or server was rejected because the host could not validate
their account.

English: "Your account was rejected. Are you signed in?"

auth_error: LangStr

Generic error screen-message shown to a player whose attempt to
join a party or server failed due to an authentication or server
error (with no more-specific cause available).

English: "An error has occurred."

connection_failed: LangStr

Notice that connecting to a server failed.

English: "Connection failed."

incorrect_password: LangStr

Error screen-message shown to a player whose attempt to join a
password-protected party or server was rejected for entering the
wrong party password.

English: "Incorrect password."

invalid_address: LangStr

Error screen-message shown when the player enters a malformed
network address trying to connect to a game party.

English: "Error: invalid address."

unavailable_no_connection: LangStr

Error shown when something cannot be reached, most likely because
there is no internet connection (dialog messages and
screen-messages).

English: "This is currently unavailable (no internet
connection?)"

class bascenev1.builtinassets.StringsPluginsGroup

Bases: object

Messages about user-installed plugins being detected, removed, or
failing to load.

See source for the full asset list.

class_load_error(*, plugin: str | LangStr, error: str | LangStr) → LangStr

Error message for a plugin class that failed to load.

English: "Error loading plugin class '{plugin}': {error}"

detected: LangStr

Notice that new plugins were found.

English: "New plugin(s) detected. Restart to activate them, or
configure them in settings."

init_error(*, plugin: str | LangStr, error: str | LangStr) → LangStr

Error message for a plugin that failed to initialize.

English: "Error initializing plugin {plugin}: {error}"

removed(*, count: int) → LangStr

Notice that previously-present plugins are gone.

English: (one) "# plugin no longer found." / (other) "# plugins
no longer found."

class bascenev1.builtinassets.StringsReplayGroup

Bases: object

Game-replay playback error messages.

See source for the full asset list.

read_error: LangStr

Error screen-message shown when a game replay file can't be read
(corrupt or truncated).

English: "Error reading replay file."

version_error: LangStr

Error screen-message shown when a saved game replay was recorded
by an incompatible game version and can't be played back.

English: "Sorry, this replay was made in a different version of
the game and can't be used."

class bascenev1.builtinassets.StringsScriptsGroup

Bases: object

Messages about scanning user script modules and reporting ones that
need updating for the current script API.

See source for the full asset list.

module_needs_update(*, path: str | LangStr, api: str | LangStr) → LangStr

Notice that one script module is out of date.

English: "The module at {path} must be updated for API version
{api}."

modules_need_update(*, path: str | LangStr, count: int, api: str | LangStr) → LangStr

Notice that several script modules are out of date.

English: (one) "{path} and # other module must be updated for
API {api}" / (other) "{path} and # other modules must be updated
for API {api}"

scan_error: LangStr

Notice that errors occurred scanning scripts.

English: "Error(s) scanning scripts. See log for details."

class bascenev1.builtinassets.StringsSessionGroup

Bases: object

Gameplay-session messages shown by the host: idle-player kick
notices and similar.

See source for the full asset list.

kick_idle_kicked(*, name: str | LangStr) → LangStr

Screen-message shown on the host when a player is removed from
the game for being idle too long (the kick-idle-players option).

English: "Kicking {name} for being idle."

kick_idle_warning(*, seconds: int, name: str | LangStr) → LangStr

Screen-message warning shown on the host shortly before an idle
player gets kicked (the kick-idle-players option); followed by
the kick_idle_warning_settings note.

English: (one) "{name} will be kicked in # second if still
idle." / (other) "{name} will be kicked in # seconds if still
idle."

kick_idle_warning_settings: LangStr

Parenthesized note shown right after the kick_idle_warning
message, pointing at where the kick-idle-players behavior can be
disabled. 'Settings' and 'Advanced' refer to the in-game settings
menu sections.

English: "(you can turn this off in Settings -> Advanced)"

class bascenev1.builtinassets.StringsStoreGroup

Bases: object

In-app-purchase and store transaction messages: purchase failures,
restores, and availability notices.

See source for the full asset list.

google_play_purchases_unavailable: LangStr

Notice that Google Play purchases are unavailable.

English: "Google Play purchases are not available. You may need
to update your store app."

google_play_services_unavailable: LangStr

Notice that Google Play Services is unavailable.

English: "Google Play Services is not available. Some app
functionality may be disabled."

purchase_already_in_progress: LangStr

Notice that this item is already being purchased.

English: "A purchase of this item is already in progress."

purchase_not_valid(*, email: str | LangStr) → LangStr

Error message that a purchase was not valid.

English: "Purchase not valid. Contact {email} if this is an
error."

purchases_restored: LangStr

Confirmation that past purchases were restored.

English: "Purchases restored."

remove_ads_token_offer: LangStr

Limited-time offer to remove ads via a token pack.

English: "LIMITED TIME OFFER: PURCHASE ANY TOKEN PACK TO REMOVE
IN-GAME ADS."

transaction_in_progress: LangStr

Notice that a transaction is already underway.

English: "A transaction is in progress; please try again in a
moment."

unavailable: LangStr

Notice that a store item is not available.

English: "Sorry, this is not available."

unavailable_temporarily: LangStr

Notice that something is unavailable for now.

English: "This is currently unavailable; please try again later."

class bascenev1.builtinassets.StringsTimeGroup

Bases: object

Compact unit suffixes and glue for formatted time values (the
hours/minutes/seconds pieces babase.timestring assembles).

See source for the full asset list.

suffix_hours(*, count: str | LangStr) → LangStr

Compact hours suffix used in formatted time values.

English: "{count}h"

suffix_minutes(*, count: str | LangStr) → LangStr

Compact minutes suffix used in formatted time values.

English: "{count}m"

suffix_seconds(*, count: str | LangStr) → LangStr

Compact seconds suffix used in formatted time values.

English: "{count}s"

class bascenev1.builtinassets.StringsUiGroup

Bases: object

General UI strings: menu-control ownership messages and
list-navigation hints.

See source for the full asset list.

arrows_to_exit_list(*, left: str | LangStr, right: str | LangStr) → LangStr

Lowercase hint shown (with an error sound) when the player hits
the edge of a UI list; tells them how to move focus out of it.
The two placeholders are substituted with left/right arrow glyph
characters.

English: "press {left} or {right} to exit list"

cancel: LangStr

Generic Cancel button label (used by e.g. asset-download progress
dialogs).

English: "Cancel"

clipboard_not_supported: LangStr

Notice that the clipboard is unavailable in this build.

English: "Clipboard not supported on this build."

copied_to_clipboard: LangStr

Confirmation that text was copied to the clipboard.

English: "Copied to clipboard."

error: LangStr

Generic Error title used on error dialogs (e.g. the boot-time
asset-update dialog when a load fails).

English: "Error"

game_center: LangStr

Name label for the Apple Game Center service.

English: "Game Center"

google_play: LangStr

Name label for the Google Play service.

English: "Google Play"

has_menu_control(*, name: str | LangStr) → LangStr

Screen-message shown when an input device tries to use a menu
another device currently controls; names the controlling device.
A timeout suffix (menu_control_time_out or
menu_control_will_time_out) is appended after it.

English: "{name} has menu control."

menu_control_time_out(*, seconds: int) → LangStr

Parenthesized suffix appended after the has_menu_control message
once the controlling device's ownership is close to expiring;
gives the remaining seconds.

English: (one) "(times out in # second)" / (other) "(times out
in # seconds)"

menu_control_will_time_out: LangStr

Parenthesized suffix appended after the has_menu_control message
while the controlling device's ownership is not yet close to
expiring.

English: "(will time out if idle)"

ok: LangStr

Generic label for a button acknowledging/dismissing a message
(used by e.g. asset-update error dialogs).

English: "OK"

remote_app_name: LangStr

Name label for the remote-control companion app.

English: "BombSquad Remote"

retry: LangStr

Generic label for a button that retries a failed operation (used
by e.g. the boot-time asset-update dialog).

English: "Retry"

sign_in: LangStr

Generic Sign In label used for dialog titles and buttons (e.g.
the boot-time asset gate's browser sign-in dialog).

English: "Sign In"

spaced_pair(*, first: str | LangStr, second: str | LangStr) → LangStr

Pure-formatting template joining two labels with a space;
substitution-only.

English: "{first} {second}"

storage_permission_needed: LangStr

Notice that storage access permission is required.

English: "This requires storage access"

success: LangStr

Confirmation label that an operation succeeded.

English: "Success!"

updating: LangStr

Generic title for progress dialogs applying updates: asset
downloads/builds at boot, locale switches, pre-game package
fetches.

English: "Updating…"

class bascenev1.builtinassets.StringsWorkspaceGroup

Bases: object

Messages about syncing and activating account workspaces.

See source for the full asset list.

activated(*, thing: str | LangStr) → LangStr

Confirmation that a workspace was activated.

English: "{thing} activated."

sync_error(*, workspace: str | LangStr) → LangStr

Error message that a workspace failed to sync.

English: "Error syncing workspace {workspace}. See log for
details."

sync_reuse(*, workspace: str | LangStr) → LangStr

Notice that a previously synced workspace is being reused.

English: "Unable to sync {workspace}. Reusing the last synced
version."

class bascenev1.builtinassets.TexturesGroup

Bases: object

Textures needed during engine bootstrap and early UI, including the
reflection cube-maps.

See source for the full asset list.

bascenev1.builtinassets.audio: AudioGroup = <bascenev1._assetref.AssetGroup object>

The audio group - 20 assets (blank, blip, cash_register, click01, cork_pop, and 15 more). Full list in source.

bascenev1.builtinassets.meshes: MeshesGroup = <bascenev1._assetref.AssetGroup object>

The meshes group - 72 assets (action_button_bottom, action_button_left, action_button_right, action_button_top, arrow_back, and 67 more). Full list in source.

bascenev1.builtinassets.strings: StringsGroup = <babase._language.LangStrDir object>

The strings group - 87 strings (account, assets, audio, input, net, and 82 more). Full list in source.

bascenev1.builtinassets.textures: TexturesGroup = <bascenev1._assetref.AssetGroup object>

The textures group - 82 assets (action_buttons, arrow, back_icon, black, bomb_button, and 77 more). Full list in source.

bascenev1.classicassets module

Asset-package wrapper for a-0.baclassicassets.260730b (bascenev1).

All assets for classic bombsquad.

class bascenev1.classicassets.AudioGroup

Bases: object

All standard game sounds (everything non-bootstrap).

See source for the full asset list.

class bascenev1.classicassets.MeshesGroup

Bases: object

All standard game meshes (everything non-bootstrap).

See source for the full asset list.

class bascenev1.classicassets.StringsAccountGroup

Bases: object

Account-management UI: sign-in/out, account creation/linking,
progress display, and the player-info viewer.

See source for the full asset list.

accounts: LangStr

Heading for a list of linked accounts.

English: "Accounts"

achievement_progress(*, complete: str | LangStr, total: str | LangStr) → LangStr

Display of achievement completion (N out of M).

English: "Achievements: {complete} of {total}"

ban_this_player: LangStr

Button to ban the viewed player (admin/host action).

English: "Ban This Player"

campaign_progress(*, progress: str | LangStr) → LangStr

Display of hard-mode campaign completion percentage.

English: "Campaign (Hard): {progress}"

create_an_account: LangStr

Button to create a new account.

English: "Create an Account"

delete_account: LangStr

Button to delete the account.

English: "Delete Account"

google_play_games_account_switch: LangStr

Instructions for switching Google accounts.

English: "If you want to use a different Google account, use the
Google Play Games app to switch."

manage_account: LangStr

Button to manage account settings on the web.

English: "Manage Account"

not_signed_in: LangStr

Error shown when an action requires sign-in.

English: "You must sign in to do this."

player_info: LangStr

Title of the player-info viewer popup.

English: "Player Info"

report_this_player: LangStr

Button to report the viewed player.

English: "Report This Player"

sign_in: LangStr

Sign-in button label.

English: "Sign In"

sign_in_for_codes: LangStr

Notice that codes require being signed in.

English: "You must sign in to an account for codes to take
effect."

sign_in_info: LangStr

Blurb explaining the benefits of signing in.

English: "Sign in to collect Tickets, compete online, and share
progress across devices."

sign_in_no_connection: LangStr

Error when sign-in fails, likely due to no internet.

English: "Unable to sign in. (no internet connection?)"

sign_in_with(*, service: str | LangStr) → LangStr

Sign-in button label naming a specific service.

English: "Sign In with {service}"

sign_in_with_device: LangStr

Button to sign in with the automatic device-local account.

English: "Sign In with Device Account"

sign_in_with_device_info: LangStr

Explanation under the device-account sign-in button.

English: "(an automatic account only available from this device)"

sign_in_with_email: LangStr

Button to sign in via an email address.

English: "Sign In with an Email Address"

sign_out: LangStr

Sign-out button label.

English: "Sign Out"

signing_in: LangStr

Status shown while signing in.

English: "Signing in..."

signing_out: LangStr

Status shown while signing out.

English: "Signing out..."

submitting_code: LangStr

Status message while a code is being submitted.

English: "Submitting Code..."

tickets(*, count: str | LangStr) → LangStr

Display of the ticket balance.

English: "Tickets: {count}"

title: LangStr

Title of the account section/window; also labels account buttons.

English: "Account"

trophies_this_season: LangStr

Heading for trophies earned this season.

English: "Trophies This Season"

v2_link_instructions: LangStr

Instruction shown with a web link for creating or signing in to
an account.

English: "Use this link to create an account or sign in."

you_are_signed_in_as: LangStr

Label above the signed-in account name.

English: "You are signed in as:"

class bascenev1.classicassets.StringsAchievementsBoomGoesTheDynamiteGroup

Bases: object

Strings for the "Boom Goes the Dynamite" achievement: its name and
its descriptions (short/full, unearned/earned). It is earned on the
campaign level "Pro Onslaught".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Kill 3 bad guys with TNT"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Killed 3 bad guys with TNT"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete all objectives on {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}"

name: LangStr

Name of an achievement the player can earn.

English: "Boom Goes the Dynamite"

class bascenev1.classicassets.StringsAchievementsBoxerGroup

Bases: object

Strings for the "Boxer" achievement: its name and its descriptions
(short/full, unearned/earned). It is earned on the campaign level
"Onslaught Training".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Win without using any bombs"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Won without using any bombs"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete {level} without using any bombs."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level} without using any bombs"

name: LangStr

Name of an achievement the player can earn.

English: "Boxer"

class bascenev1.classicassets.StringsAchievementsDualWieldingGroup

Bases: object

Strings for the "Dual Wielding" achievement: its name and its
descriptions (short/full, unearned/earned).

See source for the full asset list.

description_full: LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Connect 2 controllers (hardware or app)"

description_full_complete: LangStr

Full description of an achievement the player has already earned,
naming the campaign level (past tense).

English: "Connected 2 controllers (hardware or app)"

name: LangStr

Name of an achievement the player can earn.

English: "Dual Wielding"

class bascenev1.classicassets.StringsAchievementsFlawlessVictoryGroup

Bases: object

Strings for the "Flawless Victory" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Rookie Onslaught".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Win without getting hit"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Won without getting hit"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Win {level} without getting hit."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Won {level} without getting hit."

name: LangStr

Name of an achievement the player can earn.

English: "Flawless Victory"

class bascenev1.classicassets.StringsAchievementsFreeLoaderGroup

Bases: object

Strings for the "Free Loader" achievement: its name and its
descriptions (short/full, unearned/earned).

See source for the full asset list.

description_full: LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Start a Free-For-All game with 2+ players"

description_full_complete: LangStr

Full description of an achievement the player has already earned,
naming the campaign level (past tense).

English: "Started a Free-For-All game with 2+ players"

name: LangStr

Name of an achievement the player can earn.

English: "Free Loader"

class bascenev1.classicassets.StringsAchievementsGoldMinerGroup

Bases: object

Strings for the "Gold Miner" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Uber Onslaught".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Kill 6 bad guys with land-mines"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Killed 6 bad guys with land-mines"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Kill 6 enemies with landmines on {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Killed 6 bad guys with land-mines on {level}"

name: LangStr

Name of an achievement the player can earn.

English: "Gold Miner"

class bascenev1.classicassets.StringsAchievementsGotTheMovesGroup

Bases: object

Strings for the "Got the Moves" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Uber Football".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Win without using punches or bombs"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Won without using punches or bombs"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Win {level} without any punches or bombs."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Won {level} without any punches or bombs"

name: LangStr

Name of an achievement the player can earn.

English: "Got the Moves"

class bascenev1.classicassets.StringsAchievementsGroup

Bases: object

Achievement strings: the name of each co-op campaign achievement
plus its short and full descriptions, in both unearned and earned
(past-tense) forms.

See source for the full asset list.

class bascenev1.classicassets.StringsAchievementsInControlGroup

Bases: object

Strings for the "In Control" achievement: its name and its
descriptions (short/full, unearned/earned).

See source for the full asset list.

description_full: LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Connect a controller (hardware or app)"

description_full_complete: LangStr

Full description of an achievement the player has already earned,
naming the campaign level (past tense).

English: "Connected a controller. (hardware or app)"

name: LangStr

Name of an achievement the player can earn.

English: "In Control"

class bascenev1.classicassets.StringsAchievementsLastStandGodGroup

Bases: object

Strings for the "Last Stand God" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "The Last Stand".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Score 1000 points"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Scored 1000 points"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete the mission on {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}."

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} God"

class bascenev1.classicassets.StringsAchievementsLastStandMasterGroup

Bases: object

Strings for the "Last Stand Master" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "The Last Stand".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Score 250 points"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Scored 250 points"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete all objectives on {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}."

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} Master"

class bascenev1.classicassets.StringsAchievementsLastStandWizardGroup

Bases: object

Strings for the "Last Stand Wizard" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "The Last Stand".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Score 500 points"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Scored 500 points"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete {level} to unlock this achievement."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}."

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} Champion"

class bascenev1.classicassets.StringsAchievementsMineGamesGroup

Bases: object

Strings for the "Mine Games" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Rookie Onslaught".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Kill 3 bad guys with land-mines"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Killed 3 bad guys with land-mines"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Kill 3 bad guys with land-mines on {level}"

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed all objectives on {level}."

name: LangStr

Name of an achievement the player can earn.

English: "Mine Games"

class bascenev1.classicassets.StringsAchievementsOffYouGoThenGroup

Bases: object

Strings for the "Off You Go Then" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Onslaught Training".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Toss 3 bad guys off the map"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Tossed 3 bad guys off the map"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete all objectives in {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Tossed 3 bad guys off the map in {level}"

name: LangStr

Name of an achievement the player can earn.

English: "Off You Go Then"

class bascenev1.classicassets.StringsAchievementsOnslaughtGodGroup

Bases: object

Strings for the "Onslaught God" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Infinite Onslaught".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Score 5000 points"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Scored 5000 points"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete all objectives on {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}"

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} God"

class bascenev1.classicassets.StringsAchievementsOnslaughtMasterGroup

Bases: object

Strings for the "Onslaught Master" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Infinite Onslaught".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Score 500 points"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Scored 500 points"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete all objectives on {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}"

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} Master"

class bascenev1.classicassets.StringsAchievementsOnslaughtTrainingVictoryGroup

Bases: object

Strings for the "Onslaught Training Victory" achievement: its name
and its descriptions (short/full, unearned/earned). It is earned on
the campaign level "Onslaught Training".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Defeat all waves"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Defeated all waves"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Defeat all waves in {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Defeated all waves in {level}."

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} Victory"

class bascenev1.classicassets.StringsAchievementsOnslaughtWizardGroup

Bases: object

Strings for the "Onslaught Wizard" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Infinite Onslaught".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Score 1000 points"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Scored 1000 points"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete all objectives in {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}."

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} Master"

class bascenev1.classicassets.StringsAchievementsPrecisionBombingGroup

Bases: object

Strings for the "Precision Bombing" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Pro Runaround".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Win without any powerups"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Won without any powerups"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Win {level} without using any power-ups."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Won {level} without any power-ups."

name: LangStr

Name of an achievement the player can earn.

English: "Precision Bombing"

class bascenev1.classicassets.StringsAchievementsProBoxerGroup

Bases: object

Strings for the "Pro Boxer" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Pro Onslaught".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Win without using any bombs"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Won without using any bombs"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete {level} without using any bombs."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level} without using any bombs"

name: LangStr

Name of an achievement the player can earn.

English: "Pro Boxer"

class bascenev1.classicassets.StringsAchievementsProFootballShutoutGroup

Bases: object

Strings for the "Pro Football Shutout" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Pro Football".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Win without letting the bad guys score"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Won without letting the bad guys score"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete {level} without taking any damage."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level} without letting the opponent score."

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} Shutout"

class bascenev1.classicassets.StringsAchievementsProFootballVictoryGroup

Bases: object

Strings for the "Pro Football Victory" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Pro Football".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Win the game"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Won the game"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Win the game in {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}."

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} Victory"

class bascenev1.classicassets.StringsAchievementsProOnslaughtVictoryGroup

Bases: object

Strings for the "Pro Onslaught Victory" achievement: its name and
its descriptions (short/full, unearned/earned). It is earned on the
campaign level "Pro Onslaught".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Defeat all waves"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Defeated all waves"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Defeat all waves of {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Defeated all waves of {level}"

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} Victory"

class bascenev1.classicassets.StringsAchievementsProRunaroundVictoryGroup

Bases: object

Strings for the "Pro Runaround Victory" achievement: its name and
its descriptions (short/full, unearned/earned). It is earned on the
campaign level "Pro Runaround".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Complete all waves"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Completed all waves"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete all waves on {level}"

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed all waves on {level}"

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} Victory"

class bascenev1.classicassets.StringsAchievementsRookieFootballShutoutGroup

Bases: object

Strings for the "Rookie Football Shutout" achievement: its name and
its descriptions (short/full, unearned/earned). It is earned on the
campaign level "Rookie Football".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Win without letting the bad guys score"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Won without letting the bad guys score"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Win {level} without letting the opponent score."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}."

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} Shutout"

class bascenev1.classicassets.StringsAchievementsRookieFootballVictoryGroup

Bases: object

Strings for the "Rookie Football Victory" achievement: its name and
its descriptions (short/full, unearned/earned). It is earned on the
campaign level "Rookie Football".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Win the game"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Won the game"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Win the game in {level}"

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed the campaign on {level}."

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} Victory"

class bascenev1.classicassets.StringsAchievementsRookieOnslaughtVictoryGroup

Bases: object

Strings for the "Rookie Onslaught Victory" achievement: its name and
its descriptions (short/full, unearned/earned). It is earned on the
campaign level "Rookie Onslaught".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Defeat all waves"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Defeated all waves"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Defeat all waves in {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Defeated all waves in {level}."

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} Victory"

class bascenev1.classicassets.StringsAchievementsRunaroundGodGroup

Bases: object

Strings for the "Runaround God" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Infinite Runaround".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Score 2000 points"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Scored 2000 points"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete all objectives on {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}"

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} God"

class bascenev1.classicassets.StringsAchievementsRunaroundMasterGroup

Bases: object

Strings for the "Runaround Master" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Infinite Runaround".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Score 500 points"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Scored 500 points"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete all objectives in {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}"

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} Master"

class bascenev1.classicassets.StringsAchievementsRunaroundWizardGroup

Bases: object

Strings for the "Runaround Wizard" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Infinite Runaround".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Score 1000 points"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Scored 1000 points"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete the objective on {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Scored 1000 points on {level}"

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "Champion of {level}"

class bascenev1.classicassets.StringsAchievementsSharingIsCaringGroup

Bases: object

Strings for the "Sharing is Caring" achievement: its name and its
descriptions (short/full, unearned/earned).

See source for the full asset list.

description_full: LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Successfully share the game with a friend"

description_full_complete: LangStr

Full description of an achievement the player has already earned,
naming the campaign level (past tense).

English: "Successfully shared the game with a friend"

name: LangStr

Name of an achievement the player can earn.

English: "Sharing is Caring"

class bascenev1.classicassets.StringsAchievementsStayinAliveGroup

Bases: object

Strings for the "Stayin' Alive" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Uber Runaround".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Win without dying"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Won without dying"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Win {level} without dying."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Won {level} without dying"

name: LangStr

Name of an achievement the player can earn.

English: "Stayin' Alive"

class bascenev1.classicassets.StringsAchievementsSuperMegaPunchGroup

Bases: object

Strings for the "Super Mega Punch" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Pro Football".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Inflict 100% damage with one punch"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Inflicted 100% damage with one punch"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Inflict 100% damage with one punch in {level}"

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}"

name: LangStr

Name of an achievement the player can earn.

English: "Super Mega Punch"

class bascenev1.classicassets.StringsAchievementsSuperPunchGroup

Bases: object

Strings for the "Super Punch" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Rookie Football".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Inflict 50% damage with one punch"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Inflicted 50% damage with one punch"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete {level} without taking any damage."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Inflicted 50% damage with one punch on {level}"

name: LangStr

Name of an achievement the player can earn.

English: "Super Punch"

class bascenev1.classicassets.StringsAchievementsTeamPlayerGroup

Bases: object

Strings for the "Team Player" achievement: its name and its
descriptions (short/full, unearned/earned).

See source for the full asset list.

description_full: LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Start a Teams game with 4+ players"

description_full_complete: LangStr

Full description of an achievement the player has already earned,
naming the campaign level (past tense).

English: "Started a Teams game with 4+ players"

name: LangStr

Name of an achievement the player can earn.

English: "Team Player"

class bascenev1.classicassets.StringsAchievementsTheGreatWallGroup

Bases: object

Strings for the "The Great Wall" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Uber Runaround".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Stop every single bad guy"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Stopped every single bad guy"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete all objectives in {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Stopped every single bad guy on {level}."

name: LangStr

Name of an achievement the player can earn.

English: "The Great Wall"

class bascenev1.classicassets.StringsAchievementsTheWallGroup

Bases: object

Strings for the "The Wall" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Pro Runaround".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Stop every single bad guy"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Stopped every single bad guy"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Stop every single bad guy on {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Stopped every single bad guy on {level}"

name: LangStr

Name of an achievement the player can earn.

English: "The Wall"

class bascenev1.classicassets.StringsAchievementsTntTerrorGroup

Bases: object

Strings for the "TNT Terror" achievement: its name and its
descriptions (short/full, unearned/earned). It is earned on the
campaign level "Uber Onslaught".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Kill 6 bad guys with TNT"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Killed 6 bad guys with TNT"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Kill 6 enemies with TNT on {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Killed 6 bad guys with TNT on {level}"

name: LangStr

Name of an achievement the player can earn.

English: "TNT Terror"

class bascenev1.classicassets.StringsAchievementsUberFootballShutoutGroup

Bases: object

Strings for the "Uber Football Shutout" achievement: its name and
its descriptions (short/full, unearned/earned). It is earned on the
campaign level "Uber Football".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Win without letting the bad guys score"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Won without letting the bad guys score"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete {level} without taking any damage."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}."

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} Shutout"

class bascenev1.classicassets.StringsAchievementsUberFootballVictoryGroup

Bases: object

Strings for the "Uber Football Victory" achievement: its name and
its descriptions (short/full, unearned/earned). It is earned on the
campaign level "Uber Football".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Win the game"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Won the game"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Win the game in {level}."

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Won the game in {level}"

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} Victory"

class bascenev1.classicassets.StringsAchievementsUberOnslaughtVictoryGroup

Bases: object

Strings for the "Uber Onslaught Victory" achievement: its name and
its descriptions (short/full, unearned/earned). It is earned on the
campaign level "Uber Onslaught".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Defeat all waves"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Defeated all waves"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Defeat all waves in {level}"

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Defeated all waves in {level}"

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} Victory"

class bascenev1.classicassets.StringsAchievementsUberRunaroundVictoryGroup

Bases: object

Strings for the "Uber Runaround Victory" achievement: its name and
its descriptions (short/full, unearned/earned). It is earned on the
campaign level "Uber Runaround".

See source for the full asset list.

description: LangStr

Short description of what an achievement requires, shown before
it is earned.

English: "Complete all waves"

description_complete: LangStr

Short description of an achievement the player has already earned
(past tense).

English: "Completed all waves"

description_full(*, level: str | LangStr) → LangStr

Full description of what an achievement requires, naming the
campaign level it applies to.

English: "Complete all waves on {level}"

description_full_complete(*, level: str | LangStr) → LangStr

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed all waves on {level}"

name(*, level: str | LangStr) → LangStr

Name of an achievement the player can earn.

English: "{level} Victory"

class bascenev1.classicassets.StringsAppInviteGroup

Bases: object

Friend-invite / promo-code sharing flow.

See source for the full asset list.

email_it: LangStr

Button to email an invite code.

English: "Email It"

enjoy: LangStr

Cheerful "Enjoy!" message.

English: "ENJOY!"

friend_has_sent_promo(*, count: int, app_name: str | LangStr, name: str | LangStr) → LangStr

Header naming a ticket gift from a friend.

English: (one) "# {app_name} Ticket from {name}" / (other) "#
{app_name} Tickets from {name}"

friend_promo_award(*, count: int) → LangStr

Explanation of the ticket reward per redemption.

English: (one) "You will receive # Ticket each time it is used."
/ (other) "You will receive # Tickets each time it is used."

friend_promo_expire(*, expire_hours: int) → LangStr

Notice of code expiry for new players only.

English: (one) "The code will expire in # hour and only works
for new players." / (other) "The code will expire in # hours and
only works for new players."

friend_promo_instructions(*, app_name: str | LangStr) → LangStr

How to redeem the promo code.

English: "To use it, open {app_name} and go to
"Settings->Advanced->Send Info". See bombsquadgame.com for
download links for all supported platforms."

friend_promo_redeem_long(*, count: int, max_uses: str | LangStr) → LangStr

How many free tickets a promo code grants and to how many
people.

English: (one) "It can be redeemed for # free ticket by up to
{max_uses} people." / (other) "It can be redeemed for # free
tickets by up to {max_uses} people."

friend_promo_redeem_short(*, count: int) → LangStr

Short note of ticket value for a code.

English: (one) "It can be redeemed for # Ticket in the game." /
(other) "It can be redeemed for # Tickets in the game."

requesting_code: LangStr

Status while requesting a promo code.

English: "Requesting a code..."

share_code: LangStr

Instruction to share a promo code.

English: "Share this code with friends:"

where_to_enter: LangStr

Parenthetical pointer to where a promo code is entered.

English: "(in "Settings->Advanced->Send Info")"

you_have_been_sent_promo(*, app_name: str | LangStr) → LangStr

Notice that the player got a promo code.

English: "You have been sent a {app_name} promo code:"

class bascenev1.classicassets.StringsCharactersGroup

Bases: object

Playable character display names. Mods can register their own
characters; those names are shown untranslated.

See source for the full asset list.

agent_johnson: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. Translate the "Agent" title;
keep/transliterate "Johnson".

English: "Agent Johnson"

b9000: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. Robot designation: keep as "B-9000"
(transliterate letters/digits only where the script requires).

English: "B-9000"

bernard: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. Invented proper name: keep verbatim in
Latin-script locales; transliterate phonetically in non-Latin
scripts. Established legacy renames in some locales are
intentional and were seeded.

English: "Bernard"

betty: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. A warm, familiar granny-ish given name:
keep/adapt "Betty" or use an equivalent common local name.

English: "Betty"

bones: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. Meaningful nickname: playful
diminutive/pet-name forms for "bones/skeleton" work well.

English: "Bones"

butch: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. playful given name; transliterate
phonetically in non-Latin scripts, or keep an established
cowboy-flavored rename.

English: "Butch"

easter_bunny: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. Use each culture's standard
Easter-bunny term.

English: "Easter Bunny"

frosty: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. Meaningful name: a frosty/snowy
name-like form (playful beats a generic "snowman" where a natural
option exists).

English: "Frosty"

gretel: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. invented proper name; transliterate
phonetically in non-Latin scripts.

English: "Gretel"

grumbledorf: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. Invented wizardly pun name: "grumble" +
a Gandalf/Dumbledore-style suffix. A local grumble-pun in the
same shape is ideal; otherwise transliterate. Never a generic
"wizard" word alone, and never an actual name from other fiction.

English: "Grumbledorf"

jack_morgan: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. Invented proper name: keep verbatim in
Latin-script locales; transliterate phonetically in non-Latin
scripts. Established legacy renames in some locales are
intentional and were seeded. Use local name order conventions.

English: "Jack Morgan"

kronk: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. Invented proper name: keep verbatim in
Latin-script locales; transliterate phonetically in non-Latin
scripts. Established legacy renames in some locales are
intentional and were seeded.

English: "Kronk"

lee: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. short proper name; transliterate
phonetically in non-Latin scripts.

English: "Lee"

lucky: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. Meaningful name ("fortunate"):
translate the meaning as a name-like form.

English: "Lucky"

mel: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. Invented proper name: keep verbatim in
Latin-script locales; transliterate phonetically in non-Latin
scripts. Established legacy renames in some locales are
intentional and were seeded.

English: "Mel"

middle_man: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. a compound nickname meaning a neutral
intermediary; a fitting localized equivalent works well.

English: "Middle-Man"

pascal: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. Invented proper name: keep verbatim in
Latin-script locales; transliterate phonetically in non-Latin
scripts. Established legacy renames in some locales are
intentional and were seeded.

English: "Pascal"

pixel: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. English puns pixel/pixie. Either keep
"Pixel" (transliterated as needed) or use a fairy/sprite word
that lands a similar double meaning.

English: "Pixel"

santa_claus: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. Use each culture's traditional
gift-bringer name.

English: "Santa Claus"

snake_shadow: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. Descriptive name: translate the meaning
(snake + shadow, ninja-flavored).

English: "Snake Shadow"

spaz: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. the default character and series
mascot; transliterate phonetically, or keep an established
playful rename.

English: "Spaz"

taobao_mascot: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. Chinese locales use the official mascot
name 淘公仔; others translate "Taobao Mascot" ("Taobao" stays as the
brand).

English: "Taobao Mascot"

todd_mcburton: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. invented proper name; transliterate
phonetically in non-Latin scripts.

English: "Todd McBurton"

zoe: LangStr

Character display name shown in the store, inventory, character
picker, and gameplay UIs. Invented proper name: keep verbatim in
Latin-script locales; transliterate phonetically in non-Latin
scripts. Established legacy renames in some locales are
intentional and were seeded.

English: "Zoe"

class bascenev1.classicassets.StringsChestGroup

Bases: object

Chest window: open/reduce-wait controls, slot descriptions, and
prize odds.

See source for the full asset list.

open: LangStr

Button to open a chest.

English: "Open"

open_me: LangStr

Playful prompt on an openable chest.

English: "OPEN ME!"

open_now: LangStr

Button to open a chest immediately.

English: "Open Now"

open_now_description: LangStr

Note that the player can open a chest early.

English: "You have enough Tokens to open this now - you don't
need to wait."

prize_odds: LangStr

Heading for the prize-odds view.

English: "Prize Odds"

reduce_wait: LangStr

Button to reduce the wait time.

English: "Reduce Wait"

slot_description: LangStr

Explanation of what a chest slot holds.

English: "This slot can hold a chest. Earn chests by playing
campaign levels, placing in tournaments, and completing
achievements."

slot_number(*, num: str | LangStr) → LangStr

Label naming a numbered chest slot.

English: "Chest Slot {num}"

stop_reminding_me: LangStr

Button to stop open-chest reminders.

English: "Stop Reminding Me"

unlocks_in: LangStr

Label for the time until a chest unlocks.

English: "Unlocks In"

class bascenev1.classicassets.StringsControlsGroup

Bases: object

On-screen control guidance shown during play: button hints and
input-hardware suggestions.

See source for the full asset list.

fire_tv_remote_warning(*, remote_app_name: str | LangStr) → LangStr

Suggestion to use a controller or the remote app.

English: "For a better experience, use a controller or install
{remote_app_name} on your phone or tablet."

move: LangStr

Label for the movement control in the controls guide.

English: "Move"

run: LangStr

Label for the run control in the controls guide.

English: "Run"

class bascenev1.classicassets.StringsCoopGroup

Bases: object

Co-op play UI: campaign/custom/tournament tabs, difficulty markers,
tournament info/status, and level-lock notices.

See source for the full asset list.

achievement_label: LangStr

Heading label shown before an achievement name.

English: "Achievement:"

achievements_remaining: LangStr

Heading over the list of achievements left to earn.

English: "Achievements Remaining:"

campaign: LangStr

Label for the campaign tab/section.

English: "Campaign"

chest_slots_full_warning: LangStr

Warning that all chest slots are full so earned chests will be
lost.

English: "WARNING: All your chest slots are full. Any chests you
earn this game will be lost."

current_best: LangStr

Label for the player's best score.

English: "Current Best"

custom: LangStr

Label for the custom-games tab.

English: "Custom"

difficulty_hard_only: LangStr

Marker that a level is available only in hard mode.

English: "Hard Mode Only"

difficulty_hard_unlock_only: LangStr

Confirmation prompt that a level unlocks only in hard mode.

English: "This level can only be unlocked in hard mode. Do you
think you have what it takes!?!?!"

entry_fee: LangStr

Label for a tournament entry fee.

English: "Entry"

level_is_locked(*, level: str | LangStr) → LangStr

Notice that a named level is locked.

English: "{level} is locked."

level_must_be_completed_first(*, level: str | LangStr) → LangStr

Notice that a named level must be completed first.

English: "{level} must be completed first."

no_achievements_remaining: LangStr

Placeholder when no achievements remain.

English: "- none"

no_tournaments_in_test_build: LangStr

Warning that tournament scores are ignored on test builds.

English: "WARNING: Tournament scores from this test build will be
ignored."

of_total(*, total: str | LangStr) → LangStr

Suffix showing a value out of a total time.

English: "of {total}"

player_count_abbreviated(*, count: str | LangStr) → LangStr

Abbreviated player-count badge (number + "p" for players).

English: "{count}p"

power_ranking_points(*, number: str | LangStr) → LangStr

Compact points label for power-ranking scores.

English: "{number} pts"

prizes: LangStr

Label for tournament prizes.

English: "Prizes"

time_remaining: LangStr

Label for tournament time remaining.

English: "Time Remaining"

tournament: LangStr

Singular "Tournament" label.

English: "Tournament"

tournament_checking_state: LangStr

Status while loading tournament state.

English: "Checking tournament state; please wait..."

tournament_ended: LangStr

Notice that the current tournament has ended.

English: "This tournament has ended. A new one will start soon."

tournament_info: LangStr

Explanation of how tournaments work.

English: "Compete for high scores with other players in your
league. Prizes are awarded to the top scoring players when
tournament time expires."

tournaments: LangStr

Plural "Tournaments" tab label.

English: "Tournaments"

tournaments_disabled_workspace: LangStr

Notice that tournaments are off while a workspace is active.

English: "Tournaments are disabled when workspaces are active. To
re-enable tournaments, disable your workspace and restart."

class bascenev1.classicassets.StringsCoopLevelsGroup

Bases: object

Names of the single-player and co-op campaign levels, including the
parameterized difficulty variants.

See source for the full asset list.

infinite_onslaught: LangStr

Name of the Infinite Onslaught co-op level.

English: "Infinite Onslaught"

infinite_runaround: LangStr

Name of the Infinite Runaround co-op level.

English: "Infinite Runaround"

onslaught_training: LangStr

Name of the Onslaught Training co-op level.

English: "Onslaught Training"

pro_football: LangStr

Name of the Pro Football co-op level.

English: "Pro Football"

pro_onslaught: LangStr

Name of the Pro Onslaught co-op level.

English: "Pro Onslaught"

pro_runaround: LangStr

Name of the Pro Runaround co-op level.

English: "Pro Runaround"

pro_variant(*, game: str | LangStr) → LangStr

Name of the Pro difficulty variant of a level.

English: "Pro {game}"

rookie_football: LangStr

Name of the Rookie Football co-op level.

English: "Rookie Football"

rookie_onslaught: LangStr

Name of the Rookie Onslaught co-op level.

English: "Rookie Onslaught"

the_last_stand: LangStr

Name of the The Last Stand co-op level.

English: "The Last Stand"

uber_football: LangStr

Name of the Uber Football co-op level.

English: "Uber Football"

uber_onslaught: LangStr

Name of the Uber Onslaught co-op level.

English: "Uber Onslaught"

uber_runaround: LangStr

Name of the Uber Runaround co-op level.

English: "Uber Runaround"

uber_variant(*, game: str | LangStr) → LangStr

Name of the Uber difficulty variant of a level.

English: "Uber {game}"

class bascenev1.classicassets.StringsCoopScoreGroup

Bases: object

Co-op score/results screen: unavailable-scores notices, the
best-scores/best-times section headings, and level/tournament
proceed messages.

See source for the full asset list.

best_rating(*, rating: str | LangStr) → LangStr

The player's best rating on this co-op level.

English: "Your best rating is {rating}"

complete_level_to_proceed: LangStr

Notice that the level must be completed to proceed.

English: "You must complete this level to proceed!"

current_standing(*, rank: str | LangStr) → LangStr

The player's current rank on this co-op level.

English: "Your current standing is #{rank}"

final_time: LangStr

Label for the finishing time on the co-op results screen.

English: "Final Time"

friend_scores_unavailable: LangStr

Notice that friend scores could not be loaded.

English: "Friend scores unavailable."

last_games(*, count: str | LangStr) → LangStr

Note that a rating covers only recent games.

English: "(last {count} games)"

level_unlocked: LangStr

Announcement that a new co-op level became available.

English: "Level Unlocked!"

multi_player_count(*, count: str | LangStr) → LangStr

Player count for a multi-player co-op score entry.

English: "{count} players"

new_personal_best: LangStr

Celebration for beating your own previous best.

English: "New personal best!"

next_level: LangStr

Label for the level that follows this one.

English: "Next Level"

not_enough_players_remaining: LangStr

Notice that too few players remain to continue.

English: "Not enough players remaining; exit and start a new
game."

out_of(*, rank: str | LangStr, all: str | LangStr) → LangStr

The player's rank among all ranked players.

English: "(#{rank} out of {all})"

rating: LangStr

Label for the score rating on the co-op results screen.

English: "Rating"

score_list_unavailable: LangStr

Notice that the score list could not be loaded.

English: "Score list unavailable."

score_was(*, count: str | LangStr) → LangStr

The previous best score, shown when it is beaten.

English: "(was {count})"

single_player_count: LangStr

Player count for a single-player co-op score entry.

English: "1 player"

tournament_standings: LangStr

Heading/button label for the tournament standings.

English: "Tournament Standings"

world_scores_unavailable: LangStr

Notice that world scores could not be loaded.

English: "World scores unavailable."

worlds_best_scores: LangStr

Heading for the world-best scores list.

English: "World's Best Scores"

worlds_best_times: LangStr

Heading for the world-best times list.

English: "World's Best Times"

your_best_scores: LangStr

Heading for the player's own best scores.

English: "Your Best Scores"

your_best_times: LangStr

Heading for the player's own best times.

English: "Your Best Times"

class bascenev1.classicassets.StringsCreditsGroup

Bases: object

Credits-window text: section headings and contributor credit lines.

See source for the full asset list.

additional_audio_art_ideas(*, name: str | LangStr) → LangStr

Credit line for additional contributors.

English: "Additional Audio, Early Artwork, and Ideas by {name}"

additional_music_from(*, name: str | LangStr) → LangStr

Credit line for additional music.

English: "Additional music from {name}"

all_my_family: LangStr

Credit line thanking friends and family playtesters.

English: "All of my friends and family who helped play test"

coding_graphics_audio(*, name: str | LangStr) → LangStr

Credit line for the main developer.

English: "Coding, Graphics, and Audio by {name}"

language_translations: LangStr

Section heading for translation credits.

English: "Language Translations:"

legal: LangStr

Section heading for legal text.

English: "Legal:"

public_domain_music_via(*, name: str | LangStr) → LangStr

Credit line for public-domain music.

English: "Public-domain music via {name}"

software_based_on(*, name: str | LangStr) → LangStr

Credit line for third-party software.

English: "This software is based in part on the work of {name}."

sound_and_music: LangStr

Section heading for sound/music credits.

English: "Sound & Music:"

sounds_source(*, source: str | LangStr) → LangStr

Credit heading naming a sound source.

English: "Sounds ({source}):"

special_thanks: LangStr

Section heading for special thanks.

English: "Special Thanks:"

thanks_especially_to(*, name: str | LangStr) → LangStr

Special-thanks credit line.

English: "Special thanks to {name}"

title(*, app_name: str | LangStr) → LangStr

Title of the credits window.

English: "{app_name} Credits"

whoever_invented_coffee: LangStr

Humorous credit line thanking coffee.

English: "Whoever invented coffee"

class bascenev1.classicassets.StringsEconomyGroup

Bases: object

Screen-messages about currency: grants and related notices.

See source for the full asset list.

received_tickets(*, count: int) → LangStr

Confirmation of how many tickets were received.

English: (one) "Received # Ticket!" / (other) "Received #
Tickets!"

you_got_tokens(*, tokens: int) → LangStr

Confirmation effect sent to game clients when tokens are
credited (store purchases, promo codes, and other grant flows).

English: (one) "You got # Token!" / (other) "You got # Tokens!"

class bascenev1.classicassets.StringsFileSelectorGroup

Bases: object

File/folder selector window titles and buttons.

See source for the full asset list.

select_file: LangStr

Title when selecting a file.

English: "Select a File"

select_file_or_folder: LangStr

Title when selecting a file or folder.

English: "Select a File or Folder"

select_folder: LangStr

Title when selecting a folder.

English: "Select a Folder"

use_this_folder: LangStr

Button to confirm the current folder.

English: "Use This Folder"

class bascenev1.classicassets.StringsGameDescriptionsGroup

Bases: object

Minigame objective descriptions shown at match start and on game
lists. Mods define their own; those show untranslated.

See source for the full asset list.

be_the_chosen_one_for_a: LangStr

Minigame objective description (start-of-match / game lists).

English: "Be the chosen one for a length of time to win. Kill the
chosen one to become it."

bomb_as_many_targets_as_you: LangStr

Minigame objective description (start-of-match / game lists).

English: "Bomb as many targets as you can."

carry_the_flag_for_a_set: LangStr

Minigame objective description (start-of-match / game lists).

English: "Carry the flag for a set length of time."

carry_the_flag_for_seconds(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "Carry the flag for {arg1} seconds."

carry_the_flag_for_seconds_2(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "Carry the flag for {arg1} seconds"

crush_of_your_enemies(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "Crush {arg1} of your enemies."

defeat_all_enemies: LangStr

Minigame objective description (start-of-match / game lists).

English: "Defeat all enemies."

dodge_the_falling_bombs: LangStr

Minigame objective description (start-of-match / game lists).

English: "Dodge the falling bombs."

final_glorious_epic_slow_motion_battle: LangStr

Minigame objective description (start-of-match / game lists).

English: "Final glorious epic slow motion battle to the death."

gather_eggs: LangStr

Minigame objective description (start-of-match / game lists).

English: "Gather eggs!"

get_the_flag_to_the_enemy: LangStr

Minigame objective description (start-of-match / game lists).

English: "Get the flag to the enemy end zone."

how_fast_can_you_defeat_the: LangStr

Minigame objective description (start-of-match / game lists).

English: "How fast can you defeat the ninjas?"

kill_a_set_number_of_enemies: LangStr

Minigame objective description (start-of-match / game lists).

English: "Kill a set number of enemies to win."

kill_enemies(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "Defeat {arg1} enemies"

last_one_standing_wins: LangStr

Minigame objective description (start-of-match / game lists).

English: "Last one standing wins."

last_one_standing_wins_2: LangStr

Minigame objective description (start-of-match / game lists).

English: "last one standing wins"

last_remaining_alive_wins: LangStr

Minigame objective description (start-of-match / game lists).

English: "Last remaining alive wins."

last_team_standing_wins: LangStr

Minigame objective description (start-of-match / game lists).

English: "Last team standing wins."

last_team_standing_wins_2: LangStr

Minigame objective description (start-of-match / game lists).

English: "last team standing wins"

prevent_enemies_from_reaching_the_exit: LangStr

Minigame objective description (start-of-match / game lists).

English: "Prevent enemies from reaching the exit."

reach_the_enemy_flag_to_score: LangStr

Minigame objective description (start-of-match / game lists).

English: "Reach the enemy flag to score."

return_1_flag: LangStr

Minigame objective description (start-of-match / game lists).

English: "return 1 flag"

return_flags(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "Return {arg1} flags"

return_the_enemy_flag_to_score: LangStr

Minigame objective description (start-of-match / game lists).

English: "Return the enemy flag to score."

run_1_lap: LangStr

Minigame objective description (start-of-match / game lists).

English: "Run 1 lap."

run_1_lap_2: LangStr

Minigame objective description (start-of-match / game lists).

English: "run 1 lap"

run_1_lap_your_entire_team: LangStr

Minigame objective description (start-of-match / game lists).

English: "Run 1 lap. Your entire team has to finish."

run_laps(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "Run {arg1} laps."

run_laps_2(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "Run {arg1} laps"

run_laps_your_entire_team_has(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "Run {arg1} laps. Your entire team has to finish."

run_real_fast: LangStr

Minigame objective description (start-of-match / game lists).

English: "Run real fast!"

score_a_goal: LangStr

Minigame objective description (start-of-match / game lists).

English: "Score a goal."

score_a_goal_2: LangStr

Minigame objective description (start-of-match / game lists).

English: "score a goal"

score_a_touchdown: LangStr

Minigame objective description (start-of-match / game lists).

English: "Score a touchdown."

score_a_touchdown_2: LangStr

Minigame objective description (start-of-match / game lists).

English: "score a touchdown"

score_goals(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "Score {arg1} goals."

score_goals_2(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "Score {arg1} goals"

score_some_goals: LangStr

Minigame objective description (start-of-match / game lists).

English: "Score some goals."

score_touchdowns(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "Score {arg1} touchdowns."

score_touchdowns_2(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "score {arg1} touchdowns"

secure_all_flags(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "Secure all {arg1} flags."

secure_all_flags_2(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "Secure all {arg1} flags"

secure_all_flags_on_the_map: LangStr

Minigame objective description (start-of-match / game lists).

English: "Secure all flags on the map to win."

secure_the_flag_for_a_set: LangStr

Minigame objective description (start-of-match / game lists).

English: "Secure the flag for a set length of time."

secure_the_flag_for_seconds(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "Secure the flag for {arg1} seconds."

secure_the_flag_for_seconds_2(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "Secure the flag for {arg1} seconds"

steal_the_enemy_flag: LangStr

Minigame objective description (start-of-match / game lists).

English: "Steal the enemy flag."

steal_the_enemy_flag_times(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "Steal the enemy flag {arg1} times."

there_can_be_only_one: LangStr

Minigame objective description (start-of-match / game lists).

English: "There can be only one."

touch_1_flag: LangStr

Minigame objective description (start-of-match / game lists).

English: "touch 1 flag"

touch_flags(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "Touch {arg1} flags"

touch_the_enemy_flag: LangStr

Minigame objective description (start-of-match / game lists).

English: "Touch the enemy flag."

touch_the_enemy_flag_times(*, arg1: str | LangStr) → LangStr

Minigame objective description (start-of-match / game lists).

English: "Touch the enemy flag {arg1} times."

class bascenev1.classicassets.StringsGameGroup

Bases: object

Generic in-game scoreboard and result vocabulary shared across the
various gameplay activities (scores, victory/draw banners, wave
progress, bonus labels).

See source for the full asset list.

completion_bonus: LangStr

Label for a level-completion score bonus.

English: "Completion Bonus"

disqualified_player_left(*, team: str | LangStr, player: str | LangStr) → LangStr

Notice that a team was disqualified when a player left.

English: "Team {team} has been disqualified because {player}
left the game."

double_kill: LangStr

Celebratory banner for two kills in quick succession.

English: "DOUBLE KILL!"

draw: LangStr

Banner shown when a game ends in a tie.

English: "Draw"

epic_description_filter(*, description: str | LangStr) → LangStr

Epic-mode wrapper appended to a game description.

English: "{description} In epic slow motion."

epic_name_filter(*, name: str | LangStr) → LangStr

Name of the slow-motion variant of a minigame.

English: "Epic {name}"

fail: LangStr

Banner shown when the player fails a level.

English: "Fail"

final_scores: LangStr

Heading over the final score table.

English: "Final Scores"

five_kill: LangStr

Celebratory banner for five kills in quick succession.

English: "FIVE KILL!!!"

flawless_wave: LangStr

Celebratory banner for clearing a wave flawlessly.

English: "Flawless Wave!"

game_on_map(*, name: str | LangStr, mapname: str | LangStr) → LangStr

Pure-formatting template pairing a game with its map;
substitution-only.

English: "{name} @ {mapname}"

killing_track_skipper(*, name: str | LangStr) → LangStr

Notice that a racer is killed for cutting the course.

English: "Killing {name} for skipping part of the track!"

lap_number(*, current: str | LangStr, total: str | LangStr) → LangStr

Progress label for the current lap of a race.

English: "Lap {current}/{total}"

lives_bonus: LangStr

Label for the remaining-lives bonus in a co-op score tally.

English: "Lives Bonus"

multi_kill(*, count: int) → LangStr

Celebratory banner for a kill streak of a given count (six or
more).

English: (one) "#-KILL!!!" / (other) "#-KILLS!!!"

name_betrayed(*, name: str | LangStr, victim: str | LangStr) → LangStr

Death announcement: a player killed a teammate.

English: "{name} betrayed {victim}."

name_died(*, name: str | LangStr) → LangStr

Death announcement: a player died.

English: "{name} died."

name_killed(*, name: str | LangStr, victim: str | LangStr) → LangStr

Death announcement: a player killed an opponent.

English: "{name} killed {victim}."

name_scores(*, name: str | LangStr) → LangStr

Announcement that a named player scores.

English: "{name} Scores!"

name_suicide(*, name: str | LangStr) → LangStr

Death announcement: a player killed themselves.

English: "{name} committed suicide."

no_valid_maps_error: LangStr

Error message when no valid maps exist for a game type.

English: "No valid maps found for this game type."

onslaught_respawn(*, player: str | LangStr, wave: str | LangStr) → LangStr

Notice of which wave a defeated player returns on.

English: "{player} will respawn in wave {wave}"

own_flag_at_base_warning: LangStr

Warning that your own flag must be at your base to score.

English: "Your own flag must be at your base to score!"

paused_by_host: LangStr

Notice that the host has paused the game.

English: "(paused by host)"

perfect_wave: LangStr

Celebration shown for completing a wave without damage.

English: "Perfect Wave!"

points_gained(*, points: str | LangStr) → LangStr

Pure-formatting popup showing points just gained;
substitution-only.

English: "+{points}"

points_gained_titled(*, points: str | LangStr, title: str | LangStr) → LangStr

Pure-formatting popup pairing gained points with an award title;
substitution-only.

English: "+{points} {title}"

press_any_button_continue: LangStr

Prompt to press any button to continue.

English: "Press any button to continue..."

press_any_button_play_again: LangStr

Prompt to press a button to play again.

English: "Press any button to play again..."

press_any_key_button_continue: LangStr

Prompt to press any key or button to continue.

English: "Press any key/button to continue..."

press_any_key_button_play_again: LangStr

Prompt to press a key or button to play again.

English: "Press any key/button to play again..."

press_jump_to_fly: LangStr

Flying-map tip: press jump repeatedly to fly.

English: "** Press jump repeatedly to fly **"

quad_kill: LangStr

Celebratory banner for four kills in quick succession.

English: "QUAD KILL!!!"

reach_wave_2: LangStr

Notice that you must reach wave 2 to rank.

English: "Reach wave 2 to rank."

score: LangStr

Label for a score value on the in-game scoreboard.

English: "Score"

solo_name_filter(*, name: str | LangStr) → LangStr

Name of the solo variant of a minigame.

English: "Solo {name}"

time_bonus: LangStr

Label for the time-based bonus in a co-op score tally.

English: "Time Bonus"

time_bonus_amount(*, amount: str | LangStr) → LangStr

Time-bonus label with its current amount, shown on the co-op
HUD.

English: "Time Bonus: {amount}"

time_expired: LangStr

Banner shown when the game time limit runs out.

English: "Time Expired"

tip_title: LangStr

Heading label shown before a gameplay tip.

English: "Tip:"

tournament_time_expired: LangStr

Banner shown when the tournament time limit runs out.

English: "Tournament Time Expired"

triple_kill: LangStr

Celebratory banner for three kills in quick succession.

English: "TRIPLE KILL!!"

turbo_warning(*, name: str | LangStr) → LangStr

Warning that button-spamming will knock a player out.

English: "Warning {name}: Button-spamming (turbo) will knock you
out!"

victory: LangStr

Celebratory banner shown when a game is won.

English: "Victory!"

vs: LangStr

Small "versus" label shown between two opponents.

English: "vs."

waiting_for_host(*, host: str | LangStr) → LangStr

Notice that the host must continue the game.

English: "(Waiting for {host} to continue)"

wave: LangStr

Label for the current wave number in wave-based games.

English: "Wave"

wave_number(*, number: str | LangStr) → LangStr

Label for the current wave with its number, shown on the co-op
HUD.

English: "Wave {number}"

class bascenev1.classicassets.StringsGameNamesGroup

Bases: object

Names of the competitive multiplayer minigames. Mods can add their
own games; those names are shown untranslated.

See source for the full asset list.

assault: LangStr

Name of the Assault minigame.

English: "Assault"

capture_the_flag: LangStr

Name of the Capture the Flag minigame.

English: "Capture the Flag"

chosen_one: LangStr

Name of the Chosen One minigame.

English: "Chosen One"

conquest: LangStr

Name of the Conquest minigame.

English: "Conquest"

death_match: LangStr

Name of the Death Match minigame.

English: "Death Match"

easter_egg_hunt: LangStr

Name of the Easter Egg Hunt minigame.

English: "Easter Egg Hunt"

elimination: LangStr

Name of the Elimination minigame.

English: "Elimination"

football: LangStr

Name of the Football minigame.

English: "Football"

hockey: LangStr

Name of the Hockey minigame.

English: "Hockey"

keep_away: LangStr

Name of the Keep Away minigame.

English: "Keep Away"

king_of_the_hill: LangStr

Name of the King of the Hill minigame.

English: "King of the Hill"

meteor_shower: LangStr

Name of the Meteor Shower minigame.

English: "Meteor Shower"

ninja_fight: LangStr

Name of the Ninja Fight minigame.

English: "Ninja Fight"

onslaught: LangStr

Name of the Onslaught minigame.

English: "Onslaught"

race: LangStr

Name of the Race minigame.

English: "Race"

runaround: LangStr

Name of the Runaround minigame.

English: "Runaround"

target_practice: LangStr

Name of the Target Practice minigame.

English: "Target Practice"

the_last_stand: LangStr

Name of the The Last Stand minigame.

English: "The Last Stand"

class bascenev1.classicassets.StringsGatherGroup

Bases: object

Party/gather UI strings: hosting-form labels, pre-join prompts, and
related networking-flow messages.

See source for the full asset list.

about: LangStr

Label for the About tab of the gather window.

English: "About"

added_to_favorites(*, name: str | LangStr) → LangStr

Confirmation after saving a favorite party.

English: "Added '{name}' to Favorites."

address_fetch_error: LangStr

Placeholder shown when addresses cannot be fetched.

English: "<error fetching addresses>"

checking: LangStr

Status shown while checking something.

English: "checking..."

connect: LangStr

Button to connect to a party.

English: "Connect"

copy_code: LangStr

Button to copy the party code.

English: "Copy Code"

copy_code_confirm: LangStr

Confirmation after copying a party code.

English: "Code copied to clipboard."

dedicated_server_info: LangStr

Tip about setting up a dedicated server.

English: "For best results, set up a dedicated server. See
bombsquadgame.com/server to learn how."

delete_confirm_list(*, list: str | LangStr) → LangStr

Confirmation before deleting a named list.

English: "Delete "{list}"?"

description_short: LangStr

Short hint pointing to the gather window.

English: "Use the gather window to assemble a party."

disconnect_clients(*, count: int) → LangStr

Confirmation before an action disconnects party players.

English: (one) "This will disconnect the # player in your party.
Are you sure?" / (other) "This will disconnect the # players in
your party. Are you sure?"

discord_friends: LangStr

Blurb inviting players to the Discord.

English: "Want to look for new people to play with? Join our
Discord and find new friends!"

discord_join: LangStr

Button to open the Discord invite.

English: "Join the Discord"

favorites: LangStr

Label for the favorites list of saved parties.

English: "Favorites"

favorites_save: LangStr

Button to save a party as a favorite.

English: "Save As Favorite"

free_cloud_server_available: LangStr

Notice that a free cloud server is available.

English: "FREE CLOUD SERVER AVAILABLE!"

free_cloud_server_available_minutes(*, minutes: str | LangStr) → LangStr

Countdown to the next free cloud server.

English: "Next free cloud server available in {minutes}
minutes."

free_cloud_server_not_available: LangStr

Notice that no free cloud servers are free right now.

English: "No free cloud servers available."

get_friend_invite_code: LangStr

Button to get a friend invite code.

English: "Get Friend Invite Code"

host_public_party: LangStr

Heading for the host-public-party view.

English: "Host a Public Party"

hosting_unavailable: LangStr

Notice that hosting is unavailable.

English: "Hosting Unavailable"

invalid_address_error: LangStr

Error for an invalid server address.

English: "Error: invalid address."

invalid_name_error: LangStr

Error for an invalid party name.

English: "Error: invalid name."

invalid_port_error: LangStr

Error for an invalid server port.

English: "Error: invalid port."

invite_a_friend(*, count: str | LangStr) → LangStr

Blurb about inviting friends for a ticket reward.

English: "Friends don't have the game? Invite them to try it and
they'll receive {count} free Tickets."

invite_friends: LangStr

Button to invite friends.

English: "Invite Friends"

join_public_party: LangStr

Heading for the join-public-party view.

English: "Join a Public Party"

joinable_from_internet: LangStr

Question label about internet joinability.

English: "Are you joinable from the internet?:"

joinable_no: LangStr

Negative joinability status with a caveat marker.

English: "NO*"

joinable_yes: LangStr

Affirmative joinability status.

English: "YES"

local_network_description: LangStr

Subtitle for the nearby-party tab.

English: "Join a Nearby Party (LAN, Bluetooth, etc.)"

make_party_private: LangStr

Button to make the party private.

English: "Make My Party Private"

make_party_public: LangStr

Button to make the party public.

English: "Make My Party Public"

manual: LangStr

Label for the Manual (join-by-address) tab.

English: "Manual"

manual_address: LangStr

Label for the server address input field.

English: "Address"

manual_description: LangStr

Subtitle for the manual-connect tab.

English: "Join a party by address:"

manual_join_section: LangStr

Heading for the join-by-address section.

English: "Join By Address"

max_connections: LangStr

Label for the max-connections setting.

English: "Max Connections"

max_party_size: LangStr

Label for the max-party-size setting.

English: "Max Party Size"

nearby: LangStr

Label for the Nearby (local network) tab.

English: "Nearby"

no_connection: LangStr

Placeholder shown when there is no connection.

English: "<no connection>"

no_parties_added: LangStr

Placeholder when no favorite parties are saved.

English: "No Parties Added"

no_servers_found: LangStr

Placeholder when no public servers are found.

English: "No servers found."

party_code: LangStr

Label for the party join code.

English: "Party Code"

party_name: LangStr

Label for the party name field.

English: "Party Name"

party_requires_password: LangStr

Description line in the pre-join password prompt dialog, shown
above the password entry field when joining a password-protected
party.

English: "This party requires a password."

party_server_running: LangStr

Status that the party server is running.

English: "Your party server is running."

party_size: LangStr

Lowercase column label for party size.

English: "party size"

party_status_checking: LangStr

Status shown while checking party status.

English: "checking status..."

party_status_joinable: LangStr

Status that the party is joinable.

English: "your party is now joinable from the internet"

party_status_no_connection: LangStr

Status that the server is unreachable.

English: "unable to connect to server"

party_status_not_public: LangStr

Status that the hosted party is not public.

English: "your party is not public"

password_optional: LangStr

Label for the optional party-password entry field in the gather
window's public-hosting form.

English: "Password (optional)"

ping: LangStr

Lowercase column label for network ping.

English: "ping"

port: LangStr

Label for the server port input field.

English: "Port"

private: LangStr

Label for the Private (cloud) party tab.

English: "Private"

private_party_cloud_description: LangStr

Explanation of private cloud parties.

English: "Private parties run on dedicated cloud servers; no
router configuration required."

private_party_host: LangStr

Button to host a private party.

English: "Host a Private Party"

private_party_join: LangStr

Button to join a private party.

English: "Join a Private Party"

public: LangStr

Label for the Public party tab.

English: "Public"

public_host_router_config: LangStr

Warning about router config for public hosting.

English: "This may require configuring port-forwarding on your
router. For an easier option, host a private party."

router_forwarding(*, port: str | LangStr) → LangStr

Tip to forward a UDP port on the router.

English: "*To fix this, forward UDP port {port} to your local
address on your router."

show_my_address: LangStr

Button to show the local machine address.

English: "Show My Address"

start_hosting: LangStr

Button to start hosting.

English: "Host"

start_hosting_paid(*, cost: str | LangStr) → LangStr

Button to start paid hosting for a cost.

English: "Host Now For {cost}"

start_stop_hosting_minutes(*, minutes: int) → LangStr

Notice of the free start/stop-hosting window in minutes.

English: (one) "You can start and stop hosting for free for the
next # minute." / (other) "You can start and stop hosting for
free for the next # minutes."

stop_hosting: LangStr

Button to stop hosting.

English: "Stop Hosting"

title: LangStr

Title of the Gather section, where players meet up and play with
others; also labels the main-menu button leading there and
gather-related join-screen hints.

English: "Gather"

unable_to_resolve_host: LangStr

Error when the host address cannot resolve.

English: "Error: unable to resolve host."

v2_account_required: LangStr

Notice that a V2 account is required.

English: "This requires a V2 account. Upgrade your account and
try again."

your_address_from_internet: LangStr

Label for the internet-facing address.

English: "Your address from the internet:"

your_local_address: LangStr

Label for the local network address.

English: "Your local address:"

class bascenev1.classicassets.StringsGetRemoteGroup

Bases: object

Get-remote-app window: controller/remote-app info blurb.

See source for the full asset list.

info_short(*, app_name: str | LangStr, remote_app_name: str | LangStr) → LangStr

Blurb about using controllers or the remote app.

English: "{app_name} is most fun when played with family &
friends. Connect one or more hardware controllers or install the
{remote_app_name} app on phones or tablets to use them as
controllers."

class bascenev1.classicassets.StringsGetTokensGroup

Bases: object

Get-tokens / Gold Pass store window strings.

See source for the full asset list.

gold_pass: LangStr

The "Gold Pass" product name.

English: "Gold Pass"

gold_pass_desc1: LangStr

Gold Pass benefit: infinite tokens.

English: "Infinite Tokens."

gold_pass_desc2: LangStr

Gold Pass benefit: no ads.

English: "No ads."

gold_pass_desc3: LangStr

Gold Pass benefit: forever.

English: "Forever."

not_enough_tokens: LangStr

Error when the player lacks enough tokens.

English: "Not enough tokens!"

num_tokens(*, count: int) → LangStr

A number of tokens.

English: (one) "# Token" / (other) "# Tokens"

purchase_never_available: LangStr

Notice that purchases are unavailable here.

English: "Sorry, purchases are not available on this build. Try
signing into your account on another platform and making
purchases from there."

purchase_not_available: LangStr

Notice that a purchase is unavailable.

English: "This purchase is not available."

remove_ads_offer: LangStr

Limited-time offer to remove ads via a token pack.

English: "LIMITED TIME OFFER: PURCHASE ANY TOKEN PACK TO REMOVE
IN-GAME ADS."

shiny_new_currency: LangStr

Tagline describing tokens as the new currency.

English: "BombSquad's shiny new currency."

you_have_gold_pass: LangStr

Notice that the player owns a Gold Pass.

English: "You have a Gold Pass. All token purchases are free.
Enjoy!"

class bascenev1.classicassets.StringsGroup

Bases: object

All standard game strings (everything non-bootstrap).

See source for the full asset list.

class bascenev1.classicassets.StringsHelpGroup

Bases: object

Help window: section headings and how-to-play text for controls,
controllers, devices, friends, and powerups.

See source for the full asset list.

bomb_info: LangStr

How-to text for the Bomb action.

English: "- Bomb - Stronger than punches, but can result in grave
self-injury. For best results, throw towards enemy before fuse
runs out."

can_help(*, app_name: str | LangStr) → LangStr

Reassurance that the app can help.

English: "{app_name} can help."

controllers: LangStr

Heading for the controllers section.

English: "Controllers"

controllers_info(*, app_name: str | LangStr, remote_app_name: str | LangStr) → LangStr

Body text for the controllers section.

English: "You can play {app_name} with friends over a network,
or play together on the same device if you have enough
controllers. It supports a variety of controllers, and you can
even use phones as controllers via the free '{remote_app_name}'
app. See Settings > Controllers for more info."

controls: LangStr

Heading for the controls section.

English: "Controls"

controls_subtitle(*, app_name: str | LangStr) → LangStr

Subtitle introducing the basic actions.

English: "Your friendly {app_name} character has a few basic
actions:"

devices: LangStr

Heading for the devices section.

English: "Devices"

devices_info(*, app_name: str | LangStr) → LangStr

Body text for the devices section.

English: "The VR version of {app_name} can be played over the
network with the regular version, so whip out your extra phones,
tablets, and computers and get your game on. It can even be
useful to connect a regular version of the game to the VR
version just to allow people outside to watch the action."

friends: LangStr

Heading for the friends section.

English: "Friends"

friends_good(*, app_name: str | LangStr) → LangStr

Two-line message about playing with friends.

English: "These are good to have. {app_name} is most fun with
several players and can support up to 8 at a time, which leads
us to:"

jump_info: LangStr

How-to text for the Jump action.

English: "- Jump - Jump to cross small gaps, to throw things
higher, and to express feelings of joy."

or_punching_something: LangStr

Continued humorous line about punching.

English: "Or punching something, throwing it off a cliff, and
blowing it up on the way down with a sticky bomb."

pick_up_info: LangStr

How-to text for the Pick Up action.

English: "- Pick Up - Grab flags, enemies, or anything else not
bolted to the ground. Press again to throw."

powerups: LangStr

Heading for the powerups section.

English: "Powerups"

powerups_subtitle: LangStr

Subtitle introducing powerups.

English: "Of course, no game is complete without powerups:"

punch_info: LangStr

How-to text for the Punch action.

English: "- Punch - Punches do more damage the faster your fists
are moving, so run and spin like a madman."

run_info: LangStr

How-to text for the Run action.

English: "- Run - Hold ANY button to run. Triggers or shoulder
buttons work well if you have them. Running gets you places
faster but makes it hard to turn, so watch out for cliffs."

some_days: LangStr

Opening humorous line in the help window.

English: "Some days you just feel like punching something. Or
blowing something up."

title(*, app_name: str | LangStr) → LangStr

Title of the help window.

English: "{app_name} Help"

to_get_the_most: LangStr

Lead-in before the list of what you need.

English: "To get the most out of this game, you'll need:"

welcome(*, app_name: str | LangStr) → LangStr

Welcome heading in the help window.

English: "Welcome to {app_name}!"

class bascenev1.classicassets.StringsInGameMenuGroup

Bases: object

In-game pause-menu strings: resume/end/leave buttons and their
confirmation prompts.

See source for the full asset list.

end_game: LangStr

Label for the in-game pause menu button that ends the current
game and returns to the menu.

English: "End Game"

end_replay: LangStr

Label for the in-game pause menu button that stops the replay
currently being viewed.

English: "End Replay"

end_test: LangStr

Label for the in-game pause menu button that ends the current
benchmark/test run (shown in place of the end-game button).

English: "End Test"

exit_to_menu_confirm: LangStr

Confirmation question shown before ending the current game and
returning to the main menu.

English: "Exit to menu?"

just_player(*, name: str | LangStr) → LangStr

Small annotation under the leave-game button clarifying which
player would leave (their name substituted in).

English: "(Just {name})"

leave_game: LangStr

Label for the in-game pause menu button that removes the pressing
player's character from the game (in local multiplayer with
several players).

English: "Leave Game"

leave_party: LangStr

Label for the in-game pause menu button that disconnects from the
party (shown when connected to someone else's game).

English: "Leave Party"

leave_party_confirm: LangStr

Confirmation question shown before disconnecting from a party via
the in-game menu.

English: "Really leave the party?"

resume: LangStr

Label for the in-game pause menu button that closes the menu and
resumes playing.

English: "Resume"

class bascenev1.classicassets.StringsInboxGroup

Bases: object

Message-inbox window: messages, prizes, expiry labels.

See source for the full asset list.

expired_ago(*, t: str | LangStr) → LangStr

Label showing how long ago something expired.

English: "Expired {t} ago"

expires_in(*, t: str | LangStr) → LangStr

Label showing time until a message expires.

English: "Expires in {t}"

final_standings: LangStr

Heading for final tournament standings.

English: "Final Standings"

must_update: LangStr

Notice that the app must be updated to view content.

English: "You must update the app to view this."

no_messages: LangStr

Placeholder when the inbox is empty.

English: "No messages."

your_prize: LangStr

Label above a prize the player won.

English: "Your prize:"

class bascenev1.classicassets.StringsInventoryGroup

Bases: object

Client-side inventory window bits: offline/signed-out placeholder
variants (the online inventory content itself is server-composed).

See source for the full asset list.

only_available_online: LangStr

Inventory placeholder message.

English: "Full inventory is only available when online."

only_available_signed_in: LangStr

Inventory placeholder message.

English: "Full inventory is only available when signed in."

title: LangStr

Window title (client-side offline/profiles-only variants; the
online inventory title comes from the server).

English: "Inventory"

class bascenev1.classicassets.StringsKeyboardGroup

Bases: object

Labels and instructions for the on-screen keyboard used for text
entry on touch and controller devices.

See source for the full asset list.

change_instructions: LangStr

Instructions for switching on-screen keyboards.

English: "Double press space to change keyboards."

no_others_available: LangStr

Notice that no other on-screen keyboards exist.

English: "No other keyboards available."

space_key: LangStr

Label on the on-screen keyboard space bar.

English: "space"

switched(*, name: str | LangStr) → LangStr

Confirmation that the on-screen keyboard changed.

English: "Keyboard switched to {name}"

class bascenev1.classicassets.StringsKioskGroup

Bases: object

Kiosk/demo-mode menu strings.

See source for the full asset list.

demo_menu: LangStr

Title of the demo/kiosk menu.

English: "Demo Menu"

full_menu: LangStr

Button to open the full menu (kiosk).

English: "Full Menu"

single_player_examples: LangStr

Kiosk section: single-player / co-op examples.

English: "Single Player / Co-op Examples"

versus_examples: LangStr

Kiosk section: versus examples.

English: "Versus Examples"

class bascenev1.classicassets.StringsLeagueGroup

Bases: object

League/season UI: ranking labels, season timing notices, bonuses,
and the league-president title.

See source for the full asset list.

achievements_unavailable_old_seasons: LangStr

Notice that achievement details are unavailable for past seasons.

English: "Sorry, achievement specifics are not available for old
seasons."

all_time: LangStr

Label for all-time (non-seasonal) stats.

English: "All Time"

bronze: LangStr

Name of the Bronze league tier.

English: "Bronze"

current_season(*, number: str | LangStr) → LangStr

Label for the current season, with its number.

English: "Current Season ({number})"

diamond: LangStr

Name of the Diamond league tier.

English: "Diamond"

gold: LangStr

Name of the Gold league tier.

English: "Gold"

league: LangStr

The "League" label/heading.

English: "League"

league_president: LangStr

Title for the top-ranked player in a league.

English: "League President"

league_rank: LangStr

Label for the player's league rank.

English: "League Rank"

multipliers: LangStr

Label for score multipliers.

English: "Multipliers"

number_badge(*, number: str | LangStr) → LangStr

Rank-number badge (hash + number); substitution-only.

English: "#{number}"

power_ranking: LangStr

Label for the power-ranking metric.

English: "Power Ranking"

power_ranking_points_equals(*, number: str | LangStr) → LangStr

Badge showing a points equivalence in power ranking.

English: "= {number} pts"

power_ranking_points_mult(*, number: str | LangStr) → LangStr

Badge showing a points multiplier in power ranking.

English: "(x{number} pts)"

season(*, number: str | LangStr) → LangStr

Label naming a season by number.

English: "Season {number}"

season_ended_days_ago(*, days: int) → LangStr

Notice that a season ended a number of days ago.

English: (one) "Season ended # day ago." / (other) "Season ended
# days ago."

season_ends_days(*, days: int) → LangStr

Notice that the season ends in a number of days.

English: (one) "Season ends in # day." / (other) "Season ends in
# days."

season_ends_hours(*, hours: int) → LangStr

Notice that the season ends in a number of hours.

English: (one) "Season ends in # hour." / (other) "Season ends
in # hours."

season_ends_minutes(*, minutes: int) → LangStr

Notice that the season ends in a number of minutes.

English: (one) "Season ends in # minute." / (other) "Season ends
in # minutes."

silver: LangStr

Name of the Silver league tier.

English: "Silver"

to_ranked: LangStr

Label for points needed to become ranked.

English: "To Ranked"

tournament_required(*, name: str | LangStr) → LangStr

Notice that a higher league is required to enter.

English: "You must reach {name} to enter this tournament."

trophy_counts_reset: LangStr

Notice that trophy counts reset each season.

English: "Trophy counts will reset next season."

up_to_date_bonus: LangStr

Label for the up-to-date-version score bonus.

English: "Up-To-Date Bonus"

up_to_date_bonus_description(*, percent: str | LangStr) → LangStr

Explanation of the up-to-date bonus, with the percentage.

English: "Players running a recent version of the game receive a
{percent}% bonus here."

your_power_ranking: LangStr

Label above the player's own power ranking.

English: "Your Power Ranking:"

class bascenev1.classicassets.StringsLobbyGroup

Bases: object

Join-screen (lobby) prompts and labels shown while players are
joining, picking profiles, and readying up.

See source for the full asset list.

bomb: LangStr

The bomb action word, shown emphasized in join prompts.

English: "BOMB"

choosing_player: LangStr

Placeholder name while a player is still joining.

English: "<choosing player>"

create_edit_player: LangStr

Lobby profile-list entry for creating or editing a profile.

English: "<Create/Edit Player>"

press_any_button_to_join: LangStr

Prompt inviting anyone to join by pressing a button.

English: "press any button to join..."

press_punch_to_join: LangStr

Prompt to join by pressing the punch button.

English: "press PUNCH to join..."

press_to_override_character(*, buttons: str | LangStr) → LangStr

Prompt for overriding the profile character in the lobby.

English: "press {buttons} to override your character"

press_to_select_profile(*, buttons: str | LangStr) → LangStr

Prompt for selecting a player profile in the lobby.

English: "press {buttons} to select a player"

press_to_select_team(*, buttons: str | LangStr) → LangStr

Prompt for choosing a team in the lobby.

English: "press {buttons} to select a team"

ready: LangStr

Status note that a joining player is ready.

English: "ready"

class bascenev1.classicassets.StringsMainMenuGroup

Bases: object

Main-menu strings: menu buttons, build watermarks, and menu-scene
status text.

See source for the full asset list.

credits: LangStr

Label for the main-menu button showing the game's credits.

English: "Credits"

exit_game: LangStr

Label for the main-menu button that exits the app (general
wording; the Mac variant uses the 'Quit' string).

English: "Exit Game"

host_navigating_menus(*, host: str | LangStr) → LangStr

Shown to connected clients while the party host is navigating
menus (so they know why they are looking at an idle screen).

English: "- {host} is navigating menus like a boss -"

how_to_play: LangStr

Label for the main-menu button opening the
how-to-play/instructions section.

English: "How to Play"

mode_arcade: LangStr

Label for the main-menu button switching the game into Arcade
mode (a simplified mode designed for stand-up arcade cabinets).

English: "Arcade Mode"

mode_demo: LangStr

Label for the main-menu button switching the game into Demo mode
(a simple mode providing a few gameplay examples instead of the
full experience).

English: "Demo Mode"

next_achievements: LangStr

Heading shown in the main-menu ticker above the player's next
unearned achievements.

English: "Next Achievements:"

quit: LangStr

Label for the main-menu button that exits the app (wording used
on Mac, where apps are 'quit'; other platforms use the 'Exit
Game' string).

English: "Quit"

test_build: LangStr

Watermark label shown in the main menu on special test builds of
the game.

English: "Test Build"

class bascenev1.classicassets.StringsMapNamesGroup

Bases: object

Names of the play areas (maps) that matches are held in. Mods can
add their own maps; those names are shown untranslated.

See source for the full asset list.

big_g: LangStr

Name of the Big G play area.

English: "Big G"

bridgit: LangStr

Name of the Bridgit play area.

English: "Bridgit"

courtyard: LangStr

Name of the Courtyard play area.

English: "Courtyard"

crag_castle: LangStr

Name of the Crag Castle play area.

English: "Crag Castle"

doom_shroom: LangStr

Name of the Doom Shroom play area.

English: "Doom Shroom"

football_stadium: LangStr

Name of the Football Stadium play area.

English: "Football Stadium"

happy_thoughts: LangStr

Name of the Happy Thoughts play area.

English: "Happy Thoughts"

hockey_stadium: LangStr

Name of the Hockey Stadium play area.

English: "Hockey Stadium"

lake_frigid: LangStr

Name of the Lake Frigid play area.

English: "Lake Frigid"

monkey_face: LangStr

Name of the Monkey Face play area.

English: "Monkey Face"

rampage: LangStr

Name of the Rampage play area.

English: "Rampage"

roundabout: LangStr

Name of the Roundabout play area.

English: "Roundabout"

step_right_up: LangStr

Name of the Step Right Up play area.

English: "Step Right Up"

the_pad: LangStr

Name of the The Pad play area.

English: "The Pad"

tip_top: LangStr

Name of the Tip Top play area.

English: "Tip Top"

tower_d: LangStr

Name of the Tower D play area.

English: "Tower D"

zigzag: LangStr

Name of the Zigzag play area.

English: "Zigzag"

class bascenev1.classicassets.StringsMultiTeamGroup

Bases: object

Multi-team series victory and score screens: player-award headings
(most valuable/violent/destroyed), the "SERIES!" banner, and the
score-table column labels.

See source for the full asset list.

best_of_final(*, count: str | LangStr) → LangStr

Title for a best-of-N final series.

English: "Best-of-{count} Final"

best_of_series(*, count: int) → LangStr

Title for a best-of-N series.

English: (one) "Best Of # Series:" / (other) "Best Of # Series:"

deaths: LangStr

Column label for the death count in the score table.

English: "Deaths"

deaths_tally(*, count: str | LangStr) → LangStr

A player's death count in the end-of-series tally.

English: "{count} deaths"

first_to_final(*, count: str | LangStr) → LangStr

Title for a first-to-N-wins final series.

English: "First-to-{count} Final"

first_to_series(*, count: int) → LangStr

Title for a first-to-N-wins series.

English: (one) "First-To-# Series" / (other) "First-To-# Series"

game_leaders(*, count: int) → LangStr

Heading over the leaders of the current game.

English: (one) "Game # Leaders" / (other) "Game # Leaders"

games_to(*, wincount: str | LangStr, losecount: str | LangStr) → LangStr

Series score line reading as wins-to-losses.

English: "{wincount} games to {losecount}"

kills: LangStr

Column label for the kill count in the score table.

English: "Kills"

kills_tally(*, count: str | LangStr) → LangStr

A player's kill count in the end-of-series tally.

English: "{count} kills"

most_destroyed_player: LangStr

Heading for the most-destroyed-player award.

English: "Most Destroyed Player"

most_valuable_player: LangStr

Heading for the most-valuable-player award.

English: "Most Valuable Player"

most_violent_player: LangStr

Heading for the most-violent-player award.

English: "Most Violent Player"

must_invite_friends(*, gather: str | LangStr) → LangStr

Notice explaining how to get more players in.

English: "Invite friends via {gather} or connect controllers to
play."

player: LangStr

Column label for the player name in the score table.

English: "Player"

series: LangStr

All-caps "SERIES!" celebration banner.

English: "SERIES!"

team_label(*, name: str | LangStr) → LangStr

Score-banner label naming a team.

English: "{name}:"

up_first: LangStr

Label introducing the first game of a series.

English: "Up first:"

up_next(*, count: str | LangStr) → LangStr

Label introducing the next game of a series.

English: "Up next in game {count}:"

wins(*, name: str | LangStr) → LangStr

Banner announcing the winner of a series.

English: "{name} Wins!"

wins_the_series_intro: LangStr

Opening words of the series-victory banner.

English: "WINS THE"

class bascenev1.classicassets.StringsPartyGroup

Bases: object

Party window: member list, chat, kick/mute controls.

See source for the full asset list.

add_to_favorites: LangStr

Button to save a party to favorites.

English: "Add to Favorites"

cant_kick_host: LangStr

Error when trying to kick the host.

English: "You can't kick the host."

chat_message: LangStr

Label for the chat message input.

English: "Chat Message"

chat_muted: LangStr

Status that chat is muted.

English: "Chat Muted"

empty: LangStr

Placeholder when the party has no members.

English: "Your party is empty"

host: LangStr

Parenthetical marker for the party host.

English: "(host)"

kick_vote: LangStr

Button to start a vote to kick a player.

English: "Vote to Kick"

mute_chat: LangStr

Menu choice to mute party chat.

English: "Mute Chat"

title: LangStr

Title of the party window.

English: "Your Party"

unmute_chat: LangStr

Button to unmute chat.

English: "Unmute Chat"

class bascenev1.classicassets.StringsPartyQueueGroup

Bases: object

Party-join queue status messages.

See source for the full asset list.

waiting_in_line: LangStr

Status while waiting in a full-party queue.

English: "Waiting in line (party is full)..."

class bascenev1.classicassets.StringsPlayGroup

Bases: object

Play window: player-count range labels.

See source for the full asset list.

one_to_four_players: LangStr

Player-count label 1-4.

English: "1-4 players"

two_to_eight_players: LangStr

Player-count label 2-8.

English: "2-8 players"

class bascenev1.classicassets.StringsPlayModesGroup

Bases: object

Play-mode names (Teams, Free-for-All, ...) shared across playlist
UIs, session descriptions, and settings.

See source for the full asset list.

coop: LangStr

The "Co-op" (cooperative) play-mode name.

English: "Co-op"

free_for_all: LangStr

The 'Free-for-All' play mode name (every player for themselves).

English: "Free-for-All"

single_player_coop: LangStr

The "Single Player / Co-op" play-mode name.

English: "Single Player / Co-op"

teams: LangStr

The 'Teams' play mode name (used in playlist types, session
descriptions, etc.).

English: "Teams"

class bascenev1.classicassets.StringsPlayOptionsGroup

Bases: object

Playlist play-options: tutorial/shuffle toggles, team names/colors,
unlock notices.

See source for the full asset list.

no_valid_games: LangStr

Error when a playlist has no playable games.

English: "This playlist contains no valid unlocked games."

points_to_win: LangStr

Setting label for the points needed to win.

English: "Points To Win"

series_length: LangStr

Setting label for how many games a series runs.

English: "Series Length"

show_tutorial: LangStr

Checkbox to show the tutorial.

English: "Show Tutorial"

shuffle_game_order: LangStr

Checkbox to shuffle the game order.

English: "Shuffle Game Order"

team_names_colors: LangStr

Button to edit team names and colors.

English: "Team Names/Colors..."

unlock_in_store: LangStr

Note that an item must be unlocked in the store.

English: "This must be unlocked in the store."

class bascenev1.classicassets.StringsPlaylistGroup

Bases: object

Playlist browser/editor UI:
create/edit/delete/duplicate/share/import playlists and add/remove
games.

See source for the full asset list.

add_game_button: LangStr

Two-line button to add a game in the editor.

English: "Add Game"

add_game_title: LangStr

Title of the add-game window.

English: "Add Game"

cant_delete_default: LangStr

Error deleting the default playlist.

English: "You can't delete the default playlist."

cant_edit_default: LangStr

Error editing the default playlist.

English: "Can't edit the default playlist! Duplicate it or create
a new one."

cant_overwrite_default: LangStr

Error overwriting the default playlist.

English: "Can't overwrite the default playlist!"

cant_save_already_exists: LangStr

Error when playlist name is taken.

English: "A playlist with that name already exists!"

cant_save_empty: LangStr

Error saving an empty playlist.

English: "Can't save an empty playlist!"

cant_share_default: LangStr

Error sharing the default playlist.

English: "You can't share the default playlist."

customize_title(*, type: str | LangStr) → LangStr

Title for the customize-playlists window.

English: "Customize {type} Playlists"

default_list_name(*, playmode: str | LangStr) → LangStr

Name of the built-in default playlist for a play mode.

English: "Default {playmode} Playlist"

default_new_list_name(*, playmode: str | LangStr) → LangStr

Default name offered for a newly created playlist.

English: "My {playmode} Playlist"

delete_playlist: LangStr

Two-line button to delete a playlist.

English: "Delete Playlist"

duplicate_playlist: LangStr

Two-line button to duplicate a playlist.

English: "Duplicate Playlist"

edit_game_button: LangStr

Two-line button to edit a game in the editor.

English: "Edit Game"

edit_playlist: LangStr

Two-line button to edit a playlist.

English: "Edit Playlist"

editor_title: LangStr

Title of the playlist editor window.

English: "Playlist Editor"

export_success(*, name: str | LangStr) → LangStr

Confirmation after exporting a named playlist.

English: "'{name}' exported."

get_more_games: LangStr

Button to get more game types.

English: "Get More Games..."

get_more_maps: LangStr

Button to get more maps.

English: "Get More Maps..."

import_instructions: LangStr

Instructions for importing a playlist by code.

English: "Use the following code to import this playlist
elsewhere:"

just_epic: LangStr

Name of the built-in slow-motion playlist.

English: "Just Epic"

just_sports: LangStr

Name of the built-in sports-only playlist.

English: "Just Sports"

list_name: LangStr

Label for the playlist name field.

English: "Playlist Name"

map_select_title(*, game: str | LangStr) → LangStr

Title of the map-selection window.

English: "{game}: Select a Map"

new_playlist: LangStr

Two-line button to create a new playlist.

English: "New Playlist"

no_valid_maps: LangStr

Error when no maps suit the game type.

English: "No valid maps found for this game type."

playlists: LangStr

Title for the playlists list.

English: "Playlists"

remove_game_button: LangStr

Two-line button to remove a game in the editor.

English: "Remove Game"

class bascenev1.classicassets.StringsProfileGroup

Bases: object

Player-profile editor strings: create/edit/delete profiles, the
local/global/account profile explanations, and global-name upgrade
flow.

See source for the full asset list.

account_profile: LangStr

Parenthetical marker labeling the account-based profile.

English: "(account profile)"

account_profile_info(*, icons: str | LangStr) → LangStr

Explanation of what an account profile is.

English: "Uses account details {icons}. Create custom profiles
to change."

available(*, name: str | LangStr) → LangStr

Status shown when a chosen global name is available.

English: "The name {name} is available."

cant_delete_account_profile: LangStr

Error when trying to delete the account profile.

English: "You can't delete your account profile."

character: LangStr

Lowercase field label for the profile character.

English: "character"

checking_availability(*, name: str | LangStr) → LangStr

Status shown while checking global-name availability.

English: "Checking availability for "{name}"..."

color: LangStr

Lowercase field label for profile color.

English: "color"

delete_confirm(*, profile: str | LangStr) → LangStr

Confirmation before deleting a named profile.

English: "Delete '{profile}'?"

get_more_characters: LangStr

Button to get more player characters.

English: "Get More Characters..."

get_more_icons: LangStr

Button to get more profile icons.

English: "Get More Icons..."

global_profile: LangStr

Parenthetical marker labeling a global profile.

English: "(global profile)"

global_profile_info: LangStr

Explanation of global profiles in the edit window.

English: "Global player profiles are guaranteed to have unique
names worldwide. They also include custom icons."

highlight: LangStr

Lowercase field label for profile highlight color.

English: "highlight"

icon: LangStr

Lowercase field label for profile icon.

English: "icon"

in_game_clipped_name(*, name: str | LangStr) → LangStr

Preview of how a profile name appears in-game (possibly
clipped).

English: "In-game: {name}"

local_profile: LangStr

Parenthetical marker labeling a local profile.

English: "(local profile)"

local_profile_info: LangStr

Explanation of local profiles in the edit window.

English: "Local player profiles have no icons and their names are
not guaranteed to be unique. Upgrade to a global profile to
reserve a unique name and add a custom icon."

name_description: LangStr

Label for the profile name input field.

English: "Player Name"

name_not_empty: LangStr

Error when the profile name field is empty.

English: "Name cannot be empty!"

not_enough_tickets: LangStr

Error when the player lacks enough tickets for an upgrade.

English: "Not enough Tickets!"

nothing_selected: LangStr

Error when no item is selected.

English: "Nothing is selected!"

profile_already_exists: LangStr

Error when a profile name is already taken.

English: "A profile with that name already exists."

purchasing: LangStr

Status shown while a purchase is processing.

English: "Purchasing..."

title_edit: LangStr

Title of the edit-profile window.

English: "Edit Profile"

title_new: LangStr

Title of the new-profile window.

English: "New Profile"

unavailable(*, name: str | LangStr) → LangStr

Status shown when a chosen global name is taken.

English: ""{name}" is unavailable. Try another name."

upgrade_profile_info: LangStr

Explanation shown in the upgrade-to-global window.

English: "This will reserve your player name worldwide and allow
you to assign a custom icon to it."

upgrade_to_global: LangStr

Button/title to upgrade a profile to global.

English: "Upgrade to Global Profile"

class bascenev1.classicassets.StringsProfilesGroup

Bases: object

Player-profile management UI: profile lists, creation, and related
hints.

See source for the full asset list.

explanation: LangStr

Single-line parenthetical hint; keep the parentheses.

English: "(custom player names and appearances for this account)"

new_profile: LangStr

Button label.

English: "New Profile"

title: LangStr

Section heading / window title for player-profile management.

English: "Player Profiles"

class bascenev1.classicassets.StringsReportGroup

Bases: object

Player-report dialog: report reasons and explanation.

See source for the full asset list.

cheating: LangStr

Report reason: cheating.

English: "Cheating"

explanation: LangStr

Explanation atop the report dialog.

English: "Use this email to report cheating, inappropriate
language, or other bad behavior. Please describe below:"

inappropriate_language: LangStr

Report reason: inappropriate language.

English: "Inappropriate Language"

reason: LangStr

Prompt asking what to report.

English: "What would you like to report?"

class bascenev1.classicassets.StringsResourceTypeInfoGroup

Bases: object

Currency info popups (tickets/tokens descriptions).

See source for the full asset list.

get_tokens: LangStr

Button to acquire tokens.

English: "Get Tokens"

tickets_description: LangStr

Explanation of what tickets are and how to get them.

English: "Tickets can be used to unlock characters, maps,
minigames, and more in the store. Tickets can be found in chests
won through campaigns, tournaments, and achievements."

tokens_description: LangStr

Explanation of what tokens are and how to get them.

English: "Tokens are used to speed up Chest unlocks and for other
game and account features. You can win Tokens in the game or buy
them in packs. Or buy a Gold Pass for infinite Tokens and never
hear about them again."

class bascenev1.classicassets.StringsScoreTypesGroup

Bases: object

Column labels naming what a game's score measures (goals, flags,
time survived, and so on) on score tables.

See source for the full asset list.

flags: LangStr

Score-column label for flags captured.

English: "Flags"

goals: LangStr

Score-column label for goals scored.

English: "Goals"

survived: LangStr

Score-column label for time survived.

English: "Survived"

time: LangStr

Score-column label for elapsed time.

English: "Time"

time_held: LangStr

Score-column label for time spent holding something.

English: "Time Held"

class bascenev1.classicassets.StringsSendInfoGroup

Bases: object

Send-info / promo-code dialog strings.

See source for the full asset list.

send_info_description: LangStr

Explanation in the send-info dialog.

English: "Sends account and app state info to the developer.
Please include your name or reason for sending."

class bascenev1.classicassets.StringsServerGroup

Bases: object

Broadcast messages sent to connected players about the hosting
server's lifecycle.

See source for the full asset list.

restarting: LangStr

Broadcast that the server is restarting.

English: "Server is restarting. Please rejoin in a moment..."

shutting_down: LangStr

Broadcast that the server is shutting down.

English: "Server is shutting down..."

class bascenev1.classicassets.StringsSessionGroup

Bases: object

Session-level player-flow broadcast messages: joins, departures, and
player-limit notices.

See source for the full asset list.

not_enough_players(*, count: int) → LangStr

Warning that more players are needed to start.

English: (one) "You need at least # player to start this game!"
/ (other) "You need at least # players to start this game!"

player_delayed_join(*, player: str | LangStr) → LangStr

Notice that a joining player enters next round.

English: "{player} will enter at the start of the next round."

player_left(*, player: str | LangStr) → LangStr

Broadcast that a named player left the game.

English: "{player} left the game."

player_limit_reached(*, count: int) → LangStr

Notice that the session player limit blocks joining.

English: (one) "Player limit of # reached; no more players can
join." / (other) "Player limit of # reached; no more players can
join."

class bascenev1.classicassets.StringsSettingsAdvancedGroup

Bases: object

Advanced-settings strings: language/translation section and misc
toggles.

See source for the full asset list.

always_use_internal_keyboard: LangStr

Checkbox forcing the in-game on-screen keyboard for text entry.

English: "Always Use Internal Keyboard"

always_use_internal_keyboard_description: LangStr

Explanation under the always-use-internal-keyboard checkbox.

English: "(a simple, controller-friendly on-screen keyboard for
text editing)"

disable_camera_gyro: LangStr

Checkbox disabling gyroscope-driven camera motion (mobile).

English: "Disable Camera Gyroscope Motion"

disable_camera_shake: LangStr

Checkbox disabling camera-shake effects.

English: "Disable Camera Shake"

help_translate(*, app_name: str | LangStr) → LangStr

Blurb asking for community translation help, above the
translation-site link.

English: "{app_name}'s non-English translations are a community
supported effort. If you'd like to contribute or correct a
translation, follow the link below. Thanks in advance!"

insecure_connections: LangStr

Checkbox allowing non-TLS server connections (a
network-workaround option).

English: "Use Insecure Connections"

insecure_connections_description: LangStr

Explanation under the insecure-connections checkbox.

English: "not recommended, but may allow online play from
restricted countries or networks"

kick_idle_players: LangStr

Checkbox auto-kicking idle players.

English: "Kick Idle Players"

language: LangStr

Selector for the display language.

English: "Language"

modding_guide: LangStr

Button linking to the online modding guide.

English: "Modding Guide"

send_info: LangStr

Button for submitting info/logs to the developer (also used for
entering promo codes).

English: "Send Info"

show_demos_when_idle: LangStr

Checkbox playing demo games when idle.

English: "Show Demos When Idle"

show_deprecated_login_types: LangStr

Checkbox revealing deprecated login options.

English: "Show Deprecated Login Types"

show_in_game_ping: LangStr

Checkbox showing network ping during games.

English: "Show In-Game Ping"

show_mods_folder: LangStr

Button revealing the user mods folder.

English: "Show Mods Folder"

title: LangStr

Label for the advanced-settings category: language, promo codes,
developer options, and other misc settings.

English: "Advanced"

translation_checking: LangStr

Status line while the translation status loads.

English: "checking translation status..."

translation_editor(*, app_name: str | LangStr) → LangStr

Button linking to the web translation editor.

English: "{app_name} Translation Editor"

translation_fetch_error: LangStr

Status line when the translation-status query fails.

English: "translation status unavailable"

translation_inform_me: LangStr

Checkbox subscribing to translation-update notifications for the
user's language.

English: "Inform me when my language needs updates"

translation_needs_updates: LangStr

Status line when the current language has missing/outdated
translations.

English: "** The current language needs updates!! **"

translation_up_to_date: LangStr

Status line when the current language needs no translation
updates.

English: "The current language is up to date; woohoo!"

class bascenev1.classicassets.StringsSettingsAudioGroup

Bases: object

Audio-settings strings.

See source for the full asset list.

music_volume: LangStr

Slider for music volume.

English: "Music Volume"

sound_volume: LangStr

Slider for sound-effects volume.

English: "Sound Volume"

soundtrack_description: LangStr

Explanation under the soundtracks button.

English: "(assign your own music to play during games)"

soundtracks: LangStr

Button opening the custom-soundtracks feature.

English: "Soundtracks"

title: LangStr

Label for the audio-settings category: volume levels and related
sound options.

English: "Audio"

class bascenev1.classicassets.StringsSettingsBenchmarksGroup

Bases: object

Benchmark & stress-test window strings.

See source for the full asset list.

already_running_in_activity: LangStr

Error when starting a benchmark while another activity is running
one.

English: "Already present in another activity."

player_count: LangStr

Selector for stress-test bot count.

English: "Player Count"

playlist_description: LangStr

Description heading for the stress-test playlist.

English: "Stress Test Playlist"

playlist_name: LangStr

Field for stress-test playlist name.

English: "Playlist Name"

playlist_type: LangStr

Selector for stress-test playlist type.

English: "Playlist Type"

round_duration: LangStr

Selector for stress-test round length.

English: "Round Duration"

run_cpu_benchmark: LangStr

Button running the CPU benchmark.

English: "Run CPU Benchmark"

run_media_reload_benchmark: LangStr

Button running the media-reload benchmark.

English: "Run Media-Reload Benchmark"

run_stress_test: LangStr

Button starting a stress test.

English: "Run Stress Test"

stress_test: LangStr

Section heading for the stress-test options.

English: "Stress Test"

title: LangStr

Title of the benchmarks window; also labels the button leading
there.

English: "Benchmarks & Stress Tests"

class bascenev1.classicassets.StringsSettingsControllersGamepadGroup

Bases: object

Game-controller (gamepad) config-window strings: button assignment
prompts and advanced options.

See source for the full asset list.

advanced_title: LangStr

Title of the advanced controller-setup window.

English: "Advanced Controller Setup"

analog_stick_dead_zone: LangStr

Slider for the analog-stick dead zone.

English: "Analog Stick Dead Zone"

analog_stick_dead_zone_description: LangStr

Explanation under the dead-zone slider.

English: "(turn this up if your character 'drifts' when you
release the stick)"

applies_to_all: LangStr

Note that controller-setup changes apply to every controller of
the same type.

English: "(applies to all controllers of this type)"

auto_recalibrate: LangStr

Checkbox enabling analog-stick auto-recalibration.

English: "Auto-Recalibrate Analog Stick"

auto_recalibrate_description: LangStr

Explanation under the auto-recalibrate checkbox.

English: "(enable this if your character does not move at full
speed)"

clear: LangStr

Tiny action label clearing one button assignment.

English: "clear"

dpad: LangStr

Tiny label for a controller's directional pad in the button
diagram.

English: "D-Pad"

dpad_numbered(*, num: int) → LangStr

Label for a numbered directional pad in the controller-setup
diagram (2-in-1 devices have two).

English: (one) "dpad #" / (other) "dpad #"

enable: LangStr

Checkbox enabling the secondary-controller feature.

English: "Enable"

extra_start_button: LangStr

Assignment slot for an additional start button.

English: "Extra Start Button"

if_nothing_try_analog: LangStr

Hint shown when a dpad capture gets no input.

English: "If nothing happens, try assigning to the analog stick
instead."

if_nothing_try_dpad: LangStr

Hint shown when an analog-stick capture gets no input.

English: "If nothing happens, try assigning to the d-pad
instead."

ignore_completely: LangStr

Checkbox making the game ignore this controller entirely.

English: "Ignore Completely"

ignore_completely_description: LangStr

Explanation under the ignore-completely checkbox.

English: "(prevent this controller from affecting either the game
or menus)"

ignored_button(*, num: int) → LangStr

Assignment slot for a numbered button the game should ignore
(slots 1-4).

English: (one) "Ignored Button #" / (other) "Ignored Button #"

ignored_button_description: LangStr

Explanation under the ignored-button assignments.

English: "(use this to prevent 'home' or 'sync' buttons from
affecting the UI)"

press_any_analog_trigger: LangStr

Prompt while capturing an analog trigger assignment.

English: "Press any analog trigger..."

press_any_button: LangStr

Prompt while capturing which physical button to assign.

English: "Press any button..."

press_any_button_or_dpad: LangStr

Prompt while capturing a button or dpad press.

English: "Press any button or dpad..."

press_left_right: LangStr

Prompt while capturing a horizontal axis assignment.

English: "Press left or right..."

press_up_down: LangStr

Prompt while capturing a vertical axis assignment.

English: "Press up or down..."

run_button(*, num: int) → LangStr

Assignment slot for a numbered run button (1 or 2).

English: (one) "Run Button #" / (other) "Run Button #"

run_trigger(*, num: int) → LangStr

Assignment slot for a numbered analog run trigger (1 or 2).

English: (one) "Run Trigger #" / (other) "Run Trigger #"

run_trigger_description: LangStr

Explanation under the run-trigger assignments.

English: "(analog triggers let you run at variable speeds)"

second_half: LangStr

Explanation of the secondary-controller feature for
2-controllers-in-1 devices.

English: "Use this to configure the second half of a
2-controllers-in-1 device that shows up as a single controller."

secondary: LangStr

Section title for the secondary-controller settings.

English: "Secondary Controller"

start_button_activates_default: LangStr

Checkbox making the start button activate the default widget.

English: "Start Button Activates Default Widget"

start_button_activates_default_description: LangStr

Explanation under the start-button checkbox.

English: "(turn this off if your start button is more of a 'menu'
button)"

title: LangStr

Title of the controller-setup window (assigning buttons for one
controller type).

English: "Controller Setup"

two_in_one_setup: LangStr

Button opening the 2-controllers-in-1 setup section.

English: "2-in-1 Controller Setup"

ui_only: LangStr

Checkbox limiting this controller to menu navigation.

English: "Limit to Menu Use"

ui_only_description: LangStr

Explanation under the menu-use-only checkbox.

English: "(prevent this controller from actually joining a game)"

unassigned_buttons_run: LangStr

Checkbox making all unassigned buttons act as run.

English: "All Unassigned Buttons Run"

unset: LangStr

Placeholder shown for a button assignment with no value.

English: "<unset>"

vr_reorient_button: LangStr

Assignment slot for the VR view-reset button.

English: "VR Reorient Button"

class bascenev1.classicassets.StringsSettingsControllersGroup

Bases: object

Controller-settings strings: the category title, hub buttons, and
device-config notes; per-device-type config windows live in subdirs.

See source for the full asset list.

android_note: LangStr

Note about controller-support variability on Android.

English: "Note: controller support varies by device and Android
version."

cant_configure_device(*, device: str | LangStr) → LangStr

Note shown for input devices that have no configurable options.

English: "Sorry, {device} is not configurable."

configure_controllers: LangStr

Button/title for configuring game controllers (controllers
settings window and the controller-select window title).

English: "Configure Controllers"

configure_in_system_settings(*, device: str | LangStr) → LangStr

Note for devices configured via the OS settings app instead of
in-game.

English: "{device} can be configured in the System Settings
app."

configure_keyboard: LangStr

Button leading to keyboard player-1 key configuration.

English: "Configure Keyboard"

configure_keyboard_p2: LangStr

Button leading to keyboard player-2 key configuration.

English: "Configure Keyboard P2"

configure_mobile: LangStr

Button leading to info about using phones/tablets as controllers.

English: "Mobile Devices as Controllers"

disable_remote_app: LangStr

Checkbox disabling incoming remote-app controller connections.

English: "Disable Remote-App Connections"

disable_xinput: LangStr

Windows-only checkbox disabling the XInput controller API.

English: "Disable XInput"

disable_xinput_description: LangStr

Explanation under the disable-XInput checkbox.

English: "Allows more than 4 controllers but may not work as
well."

press_any_button_to_configure: LangStr

Prompt in the controller-select window; displays until a button
is pressed on the controller to be configured.

English: "Press any button on the controller you want to
configure..."

remote_best_results: LangStr

Wifi-quality advice in the mobile-devices-as-controllers info
window.

English: "For best results you'll need a lag-free wifi network.
You can reduce wifi lag by turning off other wireless devices, by
playing close to your wifi router, and by connecting the game
host directly to the network via ethernet."

remote_configured_in_app(*, remote_app_name: str | LangStr) → LangStr

Note shown when trying to configure the remote-control phone app
as a controller; its settings live in that app.

English: "{remote_app_name} is configured in the app itself."

remote_explanation(*, remote_app_name: str | LangStr, app_name: str | LangStr) → LangStr

Explanation in the mobile-devices-as-controllers info window;
names the remote app and the game.

English: "To use a smart-phone or tablet as a wireless
controller, install the "{remote_app_name}" app on it. Any
number of devices can connect to a {app_name} game over Wi-Fi,
and it's free!"

title: LangStr

Label for the controller-settings category: game controllers,
keyboards, touch screens, and remote-control setup.

English: "Controllers"

class bascenev1.classicassets.StringsSettingsControllersKeyboardGroup

Bases: object

Keyboard config-window strings.

See source for the full asset list.

configuring(*, device: str | LangStr) → LangStr

Title of the keyboard-config window, naming the device being
configured.

English: "Configuring {device}"

keyboard2_note: LangStr

Note in the second-keyboard-player config about hardware keypress
limits.

English: "Note: most keyboards can only register a few keypresses
at once, so having a second keyboard player may work better if
there is a separate keyboard attached for them to use. Note that
you'll still need to assign unique keys to the two players even
in that case."

press_any_key: LangStr

Prompt while capturing which key to assign.

English: "Press any key..."

class bascenev1.classicassets.StringsSettingsControllersTouchscreenGroup

Bases: object

Touchscreen config-window strings.

See source for the full asset list.

action_control_scale: LangStr

Slider for action-control size.

English: "Action Control Scale"

actions: LangStr

Section heading for action-control options.

English: "Actions"

buttons: LangStr

Option value: actions via on-screen buttons.

English: "buttons"

drag_controls: LangStr

Hint that the on-screen controls can be dragged to reposition.

English: "< drag controls to reposition them >"

joystick: LangStr

Option value: movement via an on-screen joystick.

English: "Joystick"

movement: LangStr

Section heading for movement-control options.

English: "Movement"

movement_control_scale: LangStr

Slider for movement-control size.

English: "Movement Control Scale"

swipe: LangStr

Option value: controls via swiping.

English: "swipe"

swipe_controls_hidden: LangStr

Checkbox hiding the swipe-control icons.

English: "Hide Swipe Icons"

swipe_info: LangStr

Explanation of swipe-style controls.

English: "'Swipe' style controls take a little getting used to
but make it easier to play without looking at the controls."

title: LangStr

Title of the touchscreen-controls config window; also labels the
button leading there.

English: "Configure Touchscreen"

class bascenev1.classicassets.StringsSettingsDevToolsGroup

Bases: object

Dev-tools window strings.

See source for the full asset list.

create_user_system_scripts: LangStr

Button copying system scripts into the user scripts dir for
modding.

English: "Create User System Scripts"

delete_user_system_scripts: LangStr

Button deleting the user copy of system scripts.

English: "Delete User System Scripts"

show_dev_console_button: LangStr

Checkbox showing the on-screen dev-console button.

English: "Show Dev Console Button"

title: LangStr

Title of the dev-tools window; also labels the button leading
there.

English: "Dev Tools"

class bascenev1.classicassets.StringsSettingsGraphicsGroup

Bases: object

Graphics-settings strings: the category title and option labels
(shared quality words like Low/High live in strings/ui).

See source for the full asset list.

fullscreen: LangStr

Checkbox toggling fullscreen display.

English: "Fullscreen"

fullscreen_shortcut_format(*, name: str | LangStr, shortcut: str | LangStr) → LangStr

Format joining the fullscreen checkbox label with its keyboard
shortcut; pure substitution.

English: "{name} [{shortcut}]"

max_fps: LangStr

Selector for the frame-rate cap.

English: "Max FPS"

native: LangStr

Resolution option meaning the display's native resolution.

English: "Native"

resolution: LangStr

Selector for render resolution.

English: "Resolution"

show_fps: LangStr

Checkbox showing the FPS counter.

English: "Show FPS"

textures: LangStr

Selector for texture quality.

English: "Textures"

title: LangStr

Label for the graphics-settings category: resolution, quality,
fullscreen, and similar visual options.

English: "Graphics"

tv_border: LangStr

Checkbox adding a safe-area border for TVs.

English: "TV Border"

vertical_sync: LangStr

Selector for vertical sync.

English: "Vertical Sync"

visuals: LangStr

Selector for overall visual quality.

English: "Visuals"

class bascenev1.classicassets.StringsSettingsGroup

Bases: object

Settings-section strings: the hub window title and category names
(each category name also titles its own sub-window).

See source for the full asset list.

title: LangStr

Title of the settings section (the hub window listing the
settings categories); also labels buttons leading there.

English: "Settings"

class bascenev1.classicassets.StringsSettingsNetTestingGroup

Bases: object

Network-testing window strings.

See source for the full asset list.

title: LangStr

Title of the network-testing window; also labels the button
leading there.

English: "Network Testing"

class bascenev1.classicassets.StringsSettingsPluginsGroup

Bases: object

Plugin-management strings.

See source for the full asset list.

auto_enable_new: LangStr

Checkbox auto-enabling newly-found plugins.

English: "Auto Enable New Plugins"

disable_all: LangStr

Button disabling every installed plugin.

English: "Disable All Plugins"

enable_all: LangStr

Button enabling every installed plugin.

English: "Enable All Plugins"

none_installed: LangStr

Placeholder when the plugins list is empty.

English: "No Plugins Installed"

settings_title: LangStr

Title of the plugin-settings window.

English: "Plugin Settings"

title: LangStr

Title of the plugins window; also labels buttons leading there.

English: "Plugins"

class bascenev1.classicassets.StringsSettingsTestingGroup

Bases: object

Shared strings for the value-testing windows (net/VR testing
subclasses).

See source for the full asset list.

for_testing_note: LangStr

Note atop value-testing windows that tweaks are session-only.

English: "Note: these values are only for testing and will be
lost when the app exits."

class bascenev1.classicassets.StringsSettingsVrTestingGroup

Bases: object

VR-testing window strings.

See source for the full asset list.

title: LangStr

Title of the VR-testing window; also labels the button leading
there.

English: "VR Testing"

class bascenev1.classicassets.StringsSoundtrackGroup

Bases: object

Custom-soundtrack editor strings: soundtrack list/edit/delete, music
source picker, and playlist selection.

See source for the full asset list.

cant_delete_default: LangStr

Error when trying to delete the default soundtrack.

English: "You can't delete the default soundtrack."

cant_edit_default: LangStr

Error when trying to edit the default soundtrack.

English: "Can't edit default soundtrack. Duplicate it or create a
new one."

cant_overwrite_default: LangStr

Error when trying to overwrite the default soundtrack.

English: "Can't overwrite default soundtrack"

cant_save_already_exists: LangStr

Error when saving a soundtrack whose name is already taken.

English: "A soundtrack with that name already exists!"

copy_of(*, name: str | LangStr) → LangStr

Auto-generated name for a duplicated soundtrack.

English: "{name} Copy"

default_game_music: LangStr

Placeholder label for an entry that plays the game's default
music.

English: "<default game music>"

default_soundtrack_name: LangStr

Name of the built-in default soundtrack.

English: "Default Soundtrack"

delete_confirm(*, name: str | LangStr) → LangStr

Confirmation prompt before deleting a named soundtrack.

English: "Delete soundtrack '{name}'?"

delete_soundtrack: LangStr

Two-line button label to delete a soundtrack.

English: "Delete Soundtrack"

duplicate_soundtrack: LangStr

Two-line button label to duplicate a soundtrack.

English: "Duplicate Soundtrack"

edit_soundtrack: LangStr

Two-line button label to edit a soundtrack.

English: "Edit Soundtrack"

error_playing_music(*, music: str | LangStr) → LangStr

Error message that a music file would not play.

English: "Error playing music: {music}"

fetching_itunes: LangStr

Status while loading Music-app playlists.

English: "fetching Music App playlists..."

music_source: LangStr

Title of the music-source picker.

English: "Music Source"

music_volume_zero_warning: LangStr

Warning shown in the editor when music volume is muted.

English: "Warning: music volume is set to 0"

new_soundtrack: LangStr

Two-line button label to create a new soundtrack.

English: "New Soundtrack"

new_soundtrack_name(*, count: str | LangStr) → LangStr

Auto-generated default name for a newly-created soundtrack.

English: "My Soundtrack {count}"

no_music_files_in_folder: LangStr

Notice that a chosen folder holds no music.

English: "Folder contains no music files."

select_a_playlist: LangStr

Title of the Music-app playlist picker.

English: "Select A Playlist"

test: LangStr

Tiny lowercase "test" button to preview a music entry.

English: "test"

title: LangStr

Title of the soundtracks section; also labels the button leading
there.

English: "Soundtracks"

use_default_game_music: LangStr

Music-source option: the built-in game music.

English: "Default Game Music"

use_itunes_playlist: LangStr

Music-source option: a playlist from the system Music app.

English: "Music App Playlist"

use_music_file: LangStr

Music-source option: a single music file.

English: "Music File (mp3, etc)"

use_music_folder: LangStr

Music-source option: a folder of music files.

English: "Folder of Music Files"

using_music_app: LangStr

Notice that the OS music app supplies the soundtrack.

English: "Using Music App for soundtrack..."

class bascenev1.classicassets.StringsStoreGroup

Bases: object

Store item name labels and shop entry points.

See source for the full asset list.

merch: LangStr

Store label for physical merchandise.

English: "Merch!"

pro_name(*, app_name: str | LangStr) → LangStr

Product name label for the Pro upgrade.

English: "{app_name} Pro"

class bascenev1.classicassets.StringsTeamsGroup

Bases: object

Default team names. Players can rename their teams, so these are the
built-in defaults only; custom names are shown as-is and
untranslated.

See source for the full asset list.

bad_guys: LangStr

Default name of the enemy team.

English: "Bad Guys"

blue: LangStr

Default name of the blue team.

English: "Blue"

good_guys: LangStr

Default name of the friendly team.

English: "Good Guys"

red: LangStr

Default name of the red team.

English: "Red"

class bascenev1.classicassets.StringsTournamentEntryGroup

Bases: object

Tournament-entry dialog: entry cost and watch-ad options.

See source for the full asset list.

tickets_count(*, count: int) → LangStr

Cost shown as a number of tickets.

English: (one) "# Ticket" / (other) "# Tickets"

title: LangStr

Title of the tournament-entry dialog.

English: "Tournament Entry"

watch_an_ad: LangStr

Button to watch an ad for tournament entry.

English: "Watch an Ad"

class bascenev1.classicassets.StringsTournamentScoresGroup

Bases: object

Tournament standings window strings.

See source for the full asset list.

no_scores_yet: LangStr

Placeholder when a tournament has no scores.

English: "No scores yet."

tournament_standings: LangStr

Title for the tournament standings window.

English: "Tournament Standings"

class bascenev1.classicassets.StringsTutorialGroup

Bases: object

Tutorial narration lines (the coach's spoken tips as you learn the
controls) plus the skip-tutorial UI strings.

See source for the full asset list.

cpu_benchmark: LangStr

Notice shown while running the CPU-benchmark tutorial.

English: "Running tutorial at ludicrous-speed (primarily tests
CPU speed)"

phrase01: LangStr

Tutorial greeting.

English: "Hi there!"

phrase02(*, app_name: str | LangStr) → LangStr

Tutorial: welcome line.

English: "Welcome to {app_name}!"

phrase03: LangStr

Tutorial: intro to control tips.

English: "Here's a few tips for controlling your character:"

phrase04(*, app_name: str | LangStr) → LangStr

Tutorial: physics intro.

English: "Many things in {app_name} are PHYSICS based."

phrase05: LangStr

Tutorial: punch example lead-in.

English: "For example, when you punch,.."

phrase06: LangStr

Tutorial: punch damage explanation.

English: "..damage is based on the speed of your fists."

phrase07(*, name: str | LangStr) → LangStr

Tutorial: weak-punch explanation.

English: "See? We weren't moving, so that barely hurt {name}."

phrase08: LangStr

Tutorial: jump-and-spin tip.

English: "Now let's jump and spin to get more speed."

phrase09: LangStr

Tutorial: approval after a good move.

English: "Ah, that's better."

phrase10: LangStr

Tutorial: running tip.

English: "Running helps too."

phrase11: LangStr

Tutorial: how to run.

English: "Hold down ANY button to run."

phrase12: LangStr

Tutorial: combined-move tip.

English: "For extra-awesome punches, try running AND spinning."

phrase13(*, name: str | LangStr) → LangStr

Tutorial: apology after a hard hit.

English: "Whoops; sorry 'bout that {name}."

phrase14(*, name: str | LangStr) → LangStr

Tutorial: pick-up-and-throw tip.

English: "You can pick up and throw things such as flags.. or
{name}."

phrase15: LangStr

Tutorial: intro to bombs.

English: "Lastly, there's bombs."

phrase16: LangStr

Tutorial: bomb-throwing practice note.

English: "Throwing bombs takes practice."

phrase17: LangStr

Tutorial: bad-throw reaction.

English: "Ouch! Not a very good throw."

phrase18: LangStr

Tutorial: moving-throw tip.

English: "Moving helps you throw farther."

phrase19: LangStr

Tutorial: jumping-throw tip.

English: "Jumping helps you throw higher."

phrase20: LangStr

Tutorial: whiplash-throw tip.

English: ""Whiplash" your bombs for even longer throws."

phrase21: LangStr

Tutorial: bomb-timing note.

English: "Timing your bombs can be tricky."

phrase22: LangStr

Tutorial: mild dismay exclamation.

English: "Dang."

phrase23: LangStr

Tutorial: cook-off-the-fuse tip.

English: "Try "cooking off" the fuse for a second or two."

phrase24: LangStr

Tutorial: praise after a cooked bomb.

English: "Hooray! Nicely cooked."

phrase25: LangStr

Tutorial: wrap-up line.

English: "Well, that's just about it."

phrase26: LangStr

Tutorial: send-off encouragement.

English: "Now go get 'em, tiger!"

phrase27: LangStr

Tutorial: parting motivational line.

English: "Remember your training, and you WILL come back alive!"

phrase28: LangStr

Tutorial: wry qualifier after the pep talk.

English: "...well, maybe..."

phrase29: LangStr

Tutorial: final good-luck wish.

English: "Good luck!"

random_name1: LangStr

Tutorial: stand-in practice-character name.

English: "Fred"

random_name2: LangStr

Tutorial: stand-in practice-character name.

English: "Harry"

random_name3: LangStr

Tutorial: stand-in practice-character name.

English: "Bill"

random_name4: LangStr

Tutorial: stand-in practice-character name.

English: "Chuck"

random_name5: LangStr

Tutorial: stand-in practice-character name.

English: "Phil"

skip_confirm: LangStr

Confirmation prompt before skipping the tutorial.

English: "Really skip the tutorial? Tap or press to confirm."

skip_vote_count(*, count: str | LangStr, total: str | LangStr) → LangStr

Tutorial: skip-vote tally.

English: "{count}/{total} skip votes"

skipping: LangStr

Status shown while the tutorial is being skipped.

English: "skipping tutorial..."

tip: LangStr

Label preceding a gameplay tip.

English: "Tip"

to_skip_press_anything: LangStr

Hint on how to skip the tutorial.

English: "(tap or press anything to skip tutorial)"

class bascenev1.classicassets.StringsUiGroup

Bases: object

Generic UI vocabulary: short labels (buttons, dialog titles,
joiners) shared across many UIs. Purpose-specific wording belongs
elsewhere - see each entry's docs for what it is and is not.

See source for the full asset list.

achievements: LangStr

Generic "Achievements" label/heading.

English: "Achievements"

activity: LangStr

Generic "Activity" label.

English: "Activity"

app_name: LangStr

The app's name; byte-identical in every language.

English: "BombSquad"

boost: LangStr

Generic "Boost" button label.

English: "Boost"

claim: LangStr

Button label to claim a reward.

English: "Claim"

demo: LangStr

Generic "Demo" label.

English: "Demo"

easy: LangStr

Generic "Easy" difficulty label.

English: "Easy"

epic_mode: LangStr

Generic "Epic Mode" label.

English: "Epic Mode"

exit_app_confirm(*, app_name: str | LangStr) → LangStr

Confirmation question for exiting the app.

English: "Exit {app_name}?"

final_score: LangStr

Generic "Final Score" label.

English: "Final Score"

free: LangStr

Emphatic "FREE!" label.

English: "FREE!"

game_center: LangStr

The Apple "Game Center" service name; byte-identical in every
language.

English: "Game Center"

google_play: LangStr

The "Google Play" service name; byte-identical in every language.

English: "Google Play"

hard: LangStr

Generic "Hard" difficulty label.

English: "Hard"

inbox: LangStr

Generic "Inbox" label.

English: "Inbox"

kick: LangStr

Generic "Kick" button label.

English: "Kick"

leaderboards: LangStr

Generic "Leaderboards" label.

English: "Leaderboards"

map: LangStr

Generic "Map" label.

English: "Map"

not_signed_in_status: LangStr

Lowercase "not signed in" status indicator.

English: "not signed in"

play: LangStr

General 'Play' action label; used for the main-menu Play button
and the tournament-entry play button.

English: "Play"

playlist: LangStr

Generic "Playlist" label.

English: "Playlist"

points: LangStr

Generic "Points" label.

English: "Points"

practice: LangStr

Generic "Practice" label.

English: "Practice"

quit_app_confirm(*, app_name: str | LangStr) → LangStr

Confirmation question for quitting the app (Mac wording).

English: "Quit {app_name}?"

rank: LangStr

Generic "Rank" label.

English: "Rank"

remote_app_name: LangStr

The remote-control companion app's name; byte-identical in every
language.

English: "BombSquad Remote"

stats: LangStr

Generic "Stats" label.

English: "Stats"

trophies: LangStr

Generic "Trophies" label.

English: "Trophies"

class bascenev1.classicassets.StringsV2UpgradeGroup

Bases: object

Device-account -> V2-account upgrade prompt.

See source for the full asset list.

device_account_upgrade(*, name: str | LangStr) → LangStr

Warning to upgrade a device account to a V2 account.

English: "Warning: You are signed in with a device account
({name}). Device accounts will be removed in a future update.
Upgrade to a V2 account to keep your progress."

class bascenev1.classicassets.StringsWatchGroup

Bases: object

Watch-section strings: replay browsing and playback UI.

See source for the full asset list.

delete_confirm(*, replay: str | LangStr) → LangStr

Confirmation before deleting a named replay.

English: "Delete "{replay}"?"

delete_replay_button: LangStr

Two-line button to delete a replay.

English: "Delete Replay"

my_replays: LangStr

Heading for the list of the player's replays.

English: "My Replays"

no_replay_selected: LangStr

Error when no replay is selected.

English: "No Replay Selected"

playback_speed(*, speed: str | LangStr) → LangStr

Label showing the current replay playback-speed multiplier
(in-game replay controls and the watch section).

English: "Playback Speed: {speed}"

rename_replay(*, replay: str | LangStr) → LangStr

Prompt to rename a named replay.

English: "Rename "{replay}" to:"

rename_replay_button: LangStr

Two-line button to rename a replay.

English: "Rename Replay"

rename_warning(*, replay: str | LangStr) → LangStr

Warning to rename a replay so it is not overwritten.

English: "Rename "{replay}" after a game to keep it; otherwise
it will be overwritten."

replay_delete_error: LangStr

Error when deleting a replay fails.

English: "Error deleting replay."

replay_name: LangStr

Label for the replay name field.

English: "Replay Name"

replay_name_default: LangStr

Default name for the most recent replay.

English: "Last Game Replay"

replay_rename_error: LangStr

Error when renaming a replay fails.

English: "Error renaming replay."

replay_rename_error_already_exists: LangStr

Error message that a replay name is taken.

English: "A replay with that name already exists."

replay_rename_error_invalid: LangStr

Error when a replay rename name is bad.

English: "Can't rename replay; invalid name."

title: LangStr

Title of the Watch section, where players view replays of
previous games; also labels the main-menu button leading there.

English: "Watch"

watch_replay_button: LangStr

Two-line button to watch a replay.

English: "Watch Replay"

class bascenev1.classicassets.TexturesGroup

Bases: object

All standard game textures (everything non-bootstrap).

See source for the full asset list.

bascenev1.classicassets.audio: AudioGroup = <bascenev1._assetref.AssetGroup object>

The audio group - 412 assets (achievement, action_hero1, action_hero2, action_hero3, action_hero4, and 407 more). Full list in source.

bascenev1.classicassets.meshes: MeshesGroup = <bascenev1._assetref.AssetGroup object>

The meshes group - 390 assets (achievement_outline, action_hero_fore_arm, action_hero_hand, action_hero_head, action_hero_lower_leg, and 385 more). Full list in source.

bascenev1.classicassets.strings: StringsGroup = <babase._language.LangStrDir object>

The strings group - 1036 strings (account, achievements, app_invite, characters, chest, and 1031 more). Full list in source.

bascenev1.classicassets.textures: TexturesGroup = <bascenev1._assetref.AssetGroup object>

The textures group - 313 assets (achievement_boxer, achievement_cross_hair, achievement_dual_wielding, achievement_empty, achievement_flawless_victory, and 308 more). Full list in source.