bauiv1 package¶

class bauiv1.AccountV2Handle[source]¶

Bases: object

Handle for interacting with a V2 account.

This class supports the with statement, which is how it is used with some operations such as cloud messaging.

Do not instantiate this class directly. Always access account handles through the accounts subsystem; for example via babase.AccountV2Subsystem.primary.

accountid: str¶: The id of this account.

logins: dict[LoginType, LoginInfo]¶: Info about last known logins associated with this account.

request_transient_api_key(on_response: Callable[[str | Exception], None]) → None[source]¶

Request a transient API key for this account.

Calls on_response with the key string on success, or an Exception on failure. Always called in the logic thread.

Note that keys may be rotated in some cases, so it is best to re-request a key at least once per hour rather than caching it indefinitely.

tag: str¶: The last known tag for this account.

workspaceid: str | None¶: The id of the workspace being synced to this client, if any.

workspacename: str | None¶: The name of the workspace being synced to this client.

class bauiv1.App[source]¶

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[source]¶

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[source]¶

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][source]¶

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[source]¶: 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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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 bauiv1.AppIntent[source]¶

Bases: object

Base class for high level directives given to the app.

class bauiv1.AppIntentDefault[source]¶

Bases: AppIntent

Tells the app to simply run in its default mode.

class bauiv1.AppIntentExec(code: str)[source]¶

Bases: AppIntent

Tells the app to exec some Python code.

class bauiv1.AppMode[source]¶

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[source]¶: Override this to define indent handling for an app-mode.

get_dev_console_ui_tab_buttons() → list[DevConsoleButtonDef][source]¶

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[source]¶: Handle an intent.

on_activate() → None[source]¶: Called when the mode is becoming the active one fro the app.

on_app_active_changed() → None[source]¶

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[source]¶

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 bauiv1.AppState(*values)[source]¶

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 bauiv1.AppTime¶

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

alias of float

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

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 bauiv1.BasicMainWindowState(create_call: Callable[[Literal['in_right', 'in_left', 'in_scale'] | None, bauiv1.Widget | None], bauiv1.MainWindow], uiopenstate: bauiv1.UIOpenState | None = None)[source]¶

Bases: MainWindowState

A basic MainWindowState.

Holds some call to recreate a window and optionally a selection to restore.

create_window(transition: Literal['in_right', 'in_left', 'in_scale'] | None = None, origin_widget: bauiv1.Widget | None = None) → bauiv1.MainWindow[source]¶

Create a window based on this state.

WindowState child classes should override this to recreate their particular type of window.

class bauiv1.Call(**kwargs)[source]¶

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 bauiv1.CallPartial(call: Any, /, *args: Any, **keywds: Any)[source]¶

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 bauiv1.CallStrict(call: Callable[P, T], /, *args: P.args, **kwargs: P.kwargs)[source]¶

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 bauiv1.CloudSubscription(subscription_id: int)[source]¶

Bases: object

User handle to a subscription to some cloud data.

Do not instantiate these directly; use the subscribe methods in CloudSubsystem to create them.

class bauiv1.ContextRef[source]¶

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[source]¶

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[source]¶: Whether the context was created as empty.

is_expired() → bool[source]¶

Whether the context has expired.

Returns False for refs created as empty.

class bauiv1.DevConsoleButtonDef(name: str, call: Callable[[], Any])[source]¶

Bases: object

A barebones way to define a custom button for the dev console.

Note that a DevConsoleTab should use its DevConsoleTab.button() method to create buttons; this is instead for allowing basic customization.

class bauiv1.DevConsoleSubsystem[source]¶

Bases: object

Subsystem for wrangling the dev-console.

Access the single shared instance of this class via the devconsole attr on the App class.

The dev-console is a simple always-available UI intended for use by developers; not end users. Traditionally it is available by typing a backtick (`) key on a keyboard, but can also be accessed via an on-screen button (see settings/advanced/dev-tools to enable said button).

save_tab(tabname: str) → None[source]¶: Called by the C++ layer when we should store tab to config.

tabs: list[DevConsoleTabEntry]¶: All tabs in the dev-console. Add your own stuff here via plugins or whatnot to customize the console.

class bauiv1.DevConsoleTab[source]¶

Bases: object

Base class for a DevConsoleSubsystem tab.

property base_scale: float¶

A scale value based on the app’s current UIScale.

Dev-console tabs can manually incorporate this into their UI sizes and positions if they desire. By default, dev-console tabs are uniform across all ui-scales.

button(label: str, pos: tuple[float, float], size: tuple[float, float], call: Callable[[], Any] | None = None, *, h_anchor: Literal['left', 'center', 'right'] = 'center', label_scale: float = 1.0, corner_radius: float = 8.0, style: Literal['normal', 'bright', 'red', 'red_bright', 'purple', 'purple_bright', 'yellow', 'yellow_bright', 'blue', 'blue_bright', 'white', 'white_bright', 'black', 'black_bright'] = 'normal', disabled: bool = False) → None[source]¶: Add a button to the tab being refreshed.

property height: float¶: The current tab height. Only valid during refreshes.

python_terminal() → None[source]¶: Add a Python Terminal to the tab being refreshed.

refresh() → None[source]¶

Called when the tab should refresh itself.

Overridden by subclasses to implement tab behavior.

request_refresh() → None[source]¶: The tab can call this to request that it be refreshed.

text(text: str, pos: tuple[float, float], *, h_anchor: Literal['left', 'center', 'right'] = 'center', h_align: Literal['left', 'center', 'right'] = 'center', v_align: Literal['top', 'center', 'bottom', 'none'] = 'center', scale: float = 1.0, style: Literal['normal', 'faded'] = 'normal') → None[source]¶: Add a button to the tab being refreshed.

property width: float¶: The current tab width. Only valid during refreshes.

class bauiv1.DevConsoleTabEntry(name: str, factory: Callable[[], DevConsoleTab])[source]¶

Bases: object

Represents a distinct tab in the DevConsoleSubsystem.

factory: Callable[[], DevConsoleTab]¶

name: str¶

class bauiv1.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 bauiv1.DisplayTimer(time: float, call: Callable[[], Any], repeat: bool = False)[source]¶

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 bauiv1.Keyboard[source]¶

Bases: object

Chars definitions for on-screen keyboard.

Keyboards are discoverable by the meta-tag system and the user can select which one they want to use. On-screen keyboard uses chars from active babase.Keyboard.

chars: list[tuple[str, ...]]¶: Used for row/column lengths.

name: str¶: Displays when user selecting this keyboard.

nums: tuple[str, ...]¶: The ‘num’ page.

pages: dict[str, tuple[str, ...]]¶: Extra chars like emojis.

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

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[source]¶

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[source]¶

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[source]¶: Return the canonical wire JSON for this language-string.

to_resource_json() → str[source]¶: 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 bauiv1.LoginAdapter(login_type: LoginType)[source]¶

Bases: object

Adapts a platform-implicit login so it can be used explicitly.

For login types like Google Play Game Services and Game Center, the user is silently/implicitly signed in at the platform level and typically has no in-app way to sign out. This adapter tracks the current implicit state, lets the app ‘attach to’ or ‘detach from’ it, and exposes an explicit sign_in() call that produces V2 credentials.

Login types with no implicit platform state (e.g. Discord, email) don’t use this class — they run their own explicit flows.

class ImplicitLoginState(login_id: str, display_name: str)[source]¶

Bases: object

Describes the current state of an implicit login.

display_name: str¶

login_id: str¶

class SignInResult(credentials: str)[source]¶

Bases: object

Describes the final result of a sign-in attempt.

credentials: str¶

get_sign_in_token(completion_cb: Callable[[str | None], None]) → None[source]¶

Get a sign-in token from the adapter back end.

This token is then passed to the cloud to complete the sign-in process. The adapter can use this opportunity to bring up account creation UI, call its internal sign-in function, etc. as needed. The provided completion_cb should then be called with either a token or with None if sign in failed or was cancelled.

is_back_end_active() → bool[source]¶: Is this adapter’s back-end currently active?

on_back_end_active_change(active: bool) → None[source]¶

Called when active state for the back-end is (possibly) changing.

Meant to be overridden by subclasses. Being active means that the implicit login provided by the back-end is actually being used by the app. It should therefore register unlocked achievements, leaderboard scores, allow viewing native UIs, etc. When not active it should ignore everything and behave as if signed out, even if it technically is still signed in.

set_implicit_login_state(state: ImplicitLoginState | None) → None[source]¶

Keep the adapter informed of implicit login states.

This should be called by the adapter back-end when an account of their associated type gets logged in or out.

final sign_in(result_cb: Callable[[LoginAdapter, SignInResult | Exception], None], description: str) → None[source]¶

Attempt to sign in via this adapter.

This can be called even if the back-end is not implicitly signed in; the adapter will attempt to sign in if possible. An exception will be passed to the callback if the sign-in attempt fails.

class bauiv1.LoginInfo(name: str)[source]¶

Bases: object

Info for a login used by AccountV2Handle.

name: str¶

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

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

class bauiv1.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[source]¶: Return the json dict representation of the Lstr.

evaluate() → str[source]¶

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[source]¶

Given a json string, returns a Lstr.

Does no validation.

is_flat_value() → bool[source]¶

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 bauiv1.MainWindow(root_widget: bauiv1.Widget, *, transition: str | None, origin_widget: bauiv1.Widget | None, cleanupcheck: bool = True, refresh_on_screen_size_changes: bool = False)[source]¶

Bases: Window

A special type of window that can be set as ‘main’.

The UI system has at most one main window at any given time. MainWindows support high level functionality such as saving and restoring states, allowing them to be automatically recreated when navigating back from other locations or when something like ui-scale changes.

get_main_window_shared_state_id() → str | None[source]¶

Provide a custom id for window shared state.

Unlike MainWindowState, which is used to save and restore a single main-window instance, shared-state is intended to hold values that can apply to multiple instances of a window.

By default, shared state uses the window class as an index (so is shared by all windows of the same class), but this method can be overridden to provide more distinct states. For example, a store-page main-window class might want to keep distinct states for different sub-pages it can display instead of having a single state for the whole class.

Note that shared state only persists for the current run of the app.

get_main_window_state() → MainWindowState[source]¶

Return a WindowState to recreate this specific window.

Used to gracefully return to a window from another window or ui system.

main_window_back() → None[source]¶

Move back in the main window stack.

Is a no-op if the main window does not have control; no need to check main_window_has_control() first.

main_window_close(transition: str | None = None) → None[source]¶: Get window transitioning out if still alive.

main_window_do_restore_shared_state(state: dict) → None[source]¶

Restore state from the provided shared state dict.

Can be overridden by subclasses to restore custom data.

main_window_do_save_shared_state(state: dict) → None[source]¶

Save state into the provided shared state dict.

Can be overridden by subclasses to save custom data.

main_window_has_control() → bool[source]¶

Is this MainWindow allowed to change the global main window?

This is called internally by methods such as main_window_replace() and main_window_back() so generally you do not need to call it directly when using those. However you may still opt to check this if doing other actions besides main-window navigation (such as displaying pop-ups).

main_window_replace(new_window: MainWindow | Callable[[], MainWindow], back_state: MainWindowState | None = None, is_auxiliary: bool = False, extra_type_id: str = '') → MainWindow | None[source]¶

Replace ourself with a new MainWindow.

Returns the new MainWindow. Will no-op and return None if we are not allowed to replace the MainWindow.

main_window_restore_shared_state() → None[source]¶

Restore shared state (such as widget selection), if any.

This is automatically called just after main-windows are created, but the user may opt to call it at other times such as after explicitly refreshing some UI.

State contained here is intended to operate on already-constructed UI; state that influences which UI is contructed should go through other mechanisms.

main_window_save_shared_state() → None[source]¶

Save shared state (such as widget selection).

This is automatically called just before main-windows are destroyed, but the user may opt to call it at other times such as before refreshing a UI (so that selection can be restored after the refresh, etc.)

State contained here is intended to operate on already-constructed UI; state that influences which UI is contructed should go through other mechanisms.

main_window_should_preserve_selection() → bool | None[source]¶

Whether this window should auto-save/restore selection.

If enabled, selection will be stored in the window’s shared state. See get_main_window_shared_state_id() for more info about main-window shared-state.

The default value of None results in a warning to explicitly override this (as the implicit default will change from False to True after api 9 support ends).

on_main_window_close() → None[source]¶

Called before transitioning out a main window.

A good opportunity to save window state/etc.

class bauiv1.MainWindowAutoRecreateSuppress[source]¶

Bases: object

Suppresses main-window auto-recreate while in existence.

Can be instantiated and held by windows or processes within windows for the purpose of preventing the main-window auto-recreate mechanism from firing. This mechanism normally fires when the screen is resized or the ui-scale is changed, allowing main-windows to be recreated to adapt to the new configuration.

class bauiv1.MainWindowState[source]¶

Bases: object

Persistent state for a specific MainWindow.

This allows MainWindows to be automatically recreated for back-button purposes, when switching app-modes, etc.

create_window(transition: Literal['in_right', 'in_left', 'in_scale'] | None = None, origin_widget: bauiv1.Widget | None = None) → MainWindow[source]¶

Create a window based on this state.

WindowState child classes should override this to recreate their particular type of window.

class bauiv1.Mesh[source]¶

Bases: object

Mesh asset for local user interface purposes.

class bauiv1.MeshVerifiedSpec(apverid: str, name: str)[source]¶

Bases: MeshSpec

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

get() → bauiv1.Mesh[source]¶: Resolve and return the live engine mesh for this reference.

exception bauiv1.NotFoundError[source]¶

Bases: Exception

Raised when a referenced object does not exist.

class bauiv1.Permission(*values)[source]¶

Bases: Enum

Permissions that can be requested from the OS.

STORAGE = 0¶

class bauiv1.Plugin[source]¶

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[source]¶: Called to ask if we have settings UI we can show.

on_app_running() → None[source]¶: Called when the app reaches the running state.

on_app_shutdown() → None[source]¶: Called when the app is beginning the shutdown process.

on_app_shutdown_complete() → None[source]¶: Called when the app has completed the shutdown process.

on_app_suspend() → None[source]¶: Called when the app enters the suspended state.

on_app_unsuspend() → None[source]¶: Called when the app exits the suspended state.

show_settings_ui(source_widget: Any | None) → None[source]¶: Called to show our settings UI.

class bauiv1.PluginSpec(class_path: str, loadable: bool)[source]¶

Bases: object

Represents a plugin the engine knows about.

attempt_load_if_enabled() → Plugin | None[source]¶: Possibly load the plugin and log any errors.

attempted_load¶: Whether the engine has attempted to load the plugin. If this is True but the value of plugin is None, it means there was an error loading the plugin. If a plugin’s api-version does not match the running app, if a new plugin is detected with auto-enable-plugins disabled, or if the user has explicitly disabled a plugin, the engine will not even attempt to load it.

class_path¶: Fully qualified class path for the plugin.

property enabled: bool¶

Whether this plugin is set to load.

Getting or setting this attr affects the corresponding app-config key. Remember to commit the app-config after making any changes.

loadable¶: Can we attempt to load the plugin?

plugin: Plugin | None¶: The associated Plugin, if any.

class bauiv1.QuitType(*values)[source]¶

Bases: Enum

Types of quit behavior that can be requested from the app.

‘soft’ may hide/reset the app but keep the process running, depending: on the platform (generally a thing on mobile).
‘back’ is a variant of ‘soft’ which may give ‘back-button-pressed’: behavior depending on the platform. (returning to some previous activity instead of dumping to the home screen, etc.)
‘hard’ leads to the process exiting. This generally should be avoided: on platforms such as mobile where apps are expected to keep running until killed by the OS.

BACK = 1¶

HARD = 2¶

SOFT = 0¶

class bauiv1.RootUIUpdatePause[source]¶

Bases: object

Pauses updates to the root-ui while in existence.

class bauiv1.Sound[source]¶

Bases: object

Sound asset for local user interface purposes.

play(volume: float = 1.0) → None[source]¶: Play the sound locally.

stop() → None[source]¶: Stop the sound if it is playing.

class bauiv1.SoundVerifiedSpec(apverid: str, name: str)[source]¶

Bases: SoundSpec

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

get() → bauiv1.Sound[source]¶: Resolve and return the live engine sound for this reference.

class bauiv1.SpecialChar(*values)[source]¶

Bases: Enum

Special characters the engine can diplay. Note that this currently needs to be manually kept in sync with bacommon.text.SpecialChar.

BACK = 10¶

BOTTOM_BUTTON = 7¶

BOXING_GLOVE = 101¶

CLOSE = 97¶

CROWN = 64¶

DELETE = 8¶

DICE_BUTTON1 = 31¶

DICE_BUTTON2 = 32¶

DICE_BUTTON3 = 33¶

DICE_BUTTON4 = 34¶

DISCORD_LOGO = 35¶

DOWN_ARROW = 0¶

DPAD_CENTER_BUTTON = 15¶

DRAGON = 69¶

EXPLODINARY_LOGO = 46¶

EYE_BALL = 66¶

FAST_FORWARD_BUTTON = 14¶

FEDORA = 62¶

FIREBALL = 76¶

FLAG_ALGERIA = 81¶

FLAG_ARGENTINA = 92¶

FLAG_AUSTRALIA = 85¶

FLAG_BRAZIL = 50¶

FLAG_CANADA = 54¶

FLAG_CHILE = 94¶

FLAG_CHINA = 52¶

FLAG_CZECH_REPUBLIC = 84¶

FLAG_EGYPT = 79¶

FLAG_FRANCE = 57¶

FLAG_GERMANY = 49¶

FLAG_INDIA = 55¶

FLAG_INDONESIA = 58¶

FLAG_IRAN = 90¶

FLAG_ITALY = 59¶

FLAG_JAPAN = 56¶

FLAG_KUWAIT = 80¶

FLAG_MALAYSIA = 83¶

FLAG_MEXICO = 48¶

FLAG_NETHERLANDS = 61¶

FLAG_PHILIPPINES = 93¶

FLAG_POLAND = 91¶

FLAG_QATAR = 78¶

FLAG_RUSSIA = 51¶

FLAG_SAUDI_ARABIA = 82¶

FLAG_SINGAPORE = 86¶

FLAG_SOUTH_KOREA = 60¶

FLAG_UNITED_ARAB_EMIRATES = 77¶

FLAG_UNITED_KINGDOM = 53¶

FLAG_UNITED_STATES = 47¶

GAME_CENTER_LOGO = 30¶

GOOGLE_PLAY_GAMES_LOGO = 29¶

HAL = 63¶

HEART = 68¶

HELMET = 70¶

LEFT_ARROW = 2¶

LEFT_BUTTON = 5¶

LOCAL_ACCOUNT = 45¶

LOGO = 27¶

LOGO_FLAT = 11¶

MIKIROG = 95¶

MOON = 74¶

MUSHROOM = 71¶

NINJA_STAR = 72¶

NVIDIA_LOGO = 89¶

OCULUS_LOGO = 87¶

OUYA_BUTTON_A = 25¶

OUYA_BUTTON_O = 22¶

OUYA_BUTTON_U = 23¶

OUYA_BUTTON_Y = 24¶

PALM_TREE = 100¶

PARTY_ICON = 36¶

PAUSE_BUTTON = 21¶

PLAY_BUTTON = 20¶

PLAY_PAUSE_BUTTON = 13¶

PLAY_STATION_CIRCLE_BUTTON = 17¶

PLAY_STATION_CROSS_BUTTON = 16¶

PLAY_STATION_SQUARE_BUTTON = 19¶

PLAY_STATION_TRIANGLE_BUTTON = 18¶

POTATO = 99¶

REWIND_BUTTON = 12¶

RIGHT_ARROW = 3¶

RIGHT_BUTTON = 6¶

SANTA_HAT = 98¶

SHIFT = 9¶

SKULL = 67¶

SPIDER = 75¶

STEAM_LOGO = 88¶

TEST_ACCOUNT = 37¶

TICKET = 28¶

TICKET_BACKING = 38¶

TOKEN = 26¶

TOP_BUTTON = 4¶

TROPHY0A = 42¶

TROPHY0B = 43¶

TROPHY1 = 39¶

TROPHY2 = 40¶

TROPHY3 = 41¶

TROPHY4 = 44¶

UP_ARROW = 1¶

V2_LOGO = 96¶

VIKING_HELMET = 73¶

YIN_YANG = 65¶

class bauiv1.Texture[source]¶

Bases: object

Texture asset for local user interface purposes.

class bauiv1.TextureVerifiedSpec(apverid: str, name: str)[source]¶

Bases: TextureSpec

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

get() → bauiv1.Texture[source]¶: Resolve and return the live engine texture for this reference.

class bauiv1.UIOpenState(stateid: str)[source]¶

Bases: object

Keeps ui informed that something is open.

Generally instances of this are assigned as a class member of some UI class, which will then keep the UI informed upon its death.

It is valid to have multiple states for one tag; the UI will keep a tally.

stateid¶

class bauiv1.UIScale(*values)[source]¶

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¶

class bauiv1.UIV1AppSubsystem[source]¶

Bases: AppSubsystem

Consolidated UI functionality for the app.

To use this class, access the single instance of it at ‘ba.app.ui’.

class RootUIElement(*values)[source]¶

Bases: Enum

Stuff provided by the root ui.

ACCOUNT_BUTTON = 'account_button'¶

ACHIEVEMENTS_BUTTON = 'achievements_button'¶

CHEST_SLOT_0 = 'chest_slot_0'¶

CHEST_SLOT_1 = 'chest_slot_1'¶

CHEST_SLOT_2 = 'chest_slot_2'¶

CHEST_SLOT_3 = 'chest_slot_3'¶

GET_TOKENS_BUTTON = 'get_tokens_button'¶

INBOX_BUTTON = 'inbox_button'¶

INVENTORY_BUTTON = 'inventory_button'¶

LEVEL_METER = 'level_meter'¶

MENU_BUTTON = 'menu_button'¶

SETTINGS_BUTTON = 'settings_button'¶

SQUAD_BUTTON = 'squad_button'¶

STORE_BUTTON = 'store_button'¶

TICKETS_METER = 'tickets_meter'¶

TOKENS_METER = 'tokens_meter'¶

TROPHY_METER = 'trophy_meter'¶

add_ui_cleanup_check(obj: Any, widget: bauiv1.Widget) → None[source]¶

Checks to ensure a widget-owning object gets cleaned up properly.

This adds a check which will print an error message if the provided object still exists ~5 seconds after the provided bauiv1.Widget dies.

This is a good sanity check for any sort of object that wraps or controls a bauiv1.Widget. For instance, a ‘Window’ class instance has no reason to still exist once its root container bauiv1.Widget has fully transitioned out and been destroyed. Circular references or careless strong referencing can lead to such objects never getting destroyed, however, and this helps detect such cases to avoid memory leaks.

auxiliary_window_activate(win_type: type[bauiv1.MainWindow], win_create_call: Callable[[], bauiv1.MainWindow], win_extra_type_id: str = '') → None[source]¶

Navigate to or away from an Auxiliary window.

Auxiliary windows can be thought of as ‘side quests’ in the window hierarchy; places such as settings windows or league ranking windows that the user might want to visit without losing their place in the regular hierarchy.

If an auxiliary window matching the provided type and extra-type-id exists in the stack, this call will back out past it (think of it as toggling the side-quest back off).

If a non-matching auxiliary window exists in the stack, this call will back out past that and replace it with this (effectively ending the old side-quest and starting a new one).

property available: bool¶

Can uiv1 currently be used?

Code that may run in headless mode, before the UI has been spun up, while other ui systems are active, etc. can check this to avoid likely erroring.

clear_main_window(transition: str | None = None) → None[source]¶: Clear any existing main window.

get_main_window() → bauiv1.MainWindow | None[source]¶: Return main window, if any.

async get_password(*, description: str | Lstr | LangStr | None = None) → str | None[source]¶

Ask the user for a password.

Returns the entered password, or None if the user cancels or no interactive UI is available (headless, etc.). Overridable (‘virtual’) so alternate UI layers can substitute their own prompt; this default implementation shows a small PasswordPromptWindow.

Must be awaited on the logic thread. If the awaiting task is cancelled, the prompt window is dismissed.

has_main_window() → bool[source]¶: Return whether a main menu window is present.

new_id_prefix(name: str) → str[source]¶

Generate a unique id given a base name.

Useful to ensure widgets have globally unique ids even if a particular window type is instantiated multiple times.

on_app_loading() → None[source]¶

Called when the app reaches the LOADING state.

Note that subsystems created after the app switches to the loading state will not receive this callback. Subsystems created by plugins are an example of this.

on_screen_size_change() → None[source]¶

Called when the screen size changes.

Will not be called for the initial screen size.

on_ui_scale_change() → None[source]¶

Called when screen ui-scale changes.

Will not be called for the initial ui scale.

reset() → None[source]¶

Reset the subsystem to a default state.

This is called when switching app modes, but may be called at other times too.

restore_main_window_state(state: MainWindowState) → None[source]¶: Restore UI to a saved state.

save_current_main_window_state() → MainWindowState | None[source]¶: Save state for the current window, if any.

save_main_window_state(window: MainWindow) → MainWindowState[source]¶

Fully initialize a window-state from a window.

Use this to get a complete state for later restoration purposes. Calling the window’s get_main_window_state() directly is insufficient.

set_main_window(window: bauiv1.MainWindow, *, back_state: MainWindowState | None, extra_type_id: str = '', from_window: bauiv1.MainWindow | None | bool = True, is_back: bool = False, is_top_level: bool = False, is_auxiliary: bool = False, suppress_warning: bool = False, restore_shared_state: bool = True) → None[source]¶

Set the current ‘main’ window.

Generally this should not be called directly; The high level MainWindow methods main_window_replace() and main_window_back() should be used whenever possible to implement navigation.

The caller is responsible for cleaning up any previous main window.

should_suppress_window_recreates() → bool[source]¶: Should we avoid auto-recreating windows at the current time?

property uiscale: UIScale¶: Current ui scale for the app.

class bauiv1.WeakCall(**kwargs)[source]¶

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 bauiv1.WeakCallPartial(call: Any, /, *args: Any, **keywds: Any)[source]¶

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 bauiv1.WeakCallStrict(call: Callable[P, T], /, *args: P.args, **kwargs: P.kwargs)[source]¶

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 bauiv1.Widget[source]¶

Bases: object

Internal type for low level UI elements; buttons, windows, etc.

This class represents a weak reference to a widget object in the internal C++ layer. Currently, functions such as bauiv1.buttonwidget() must be used to instantiate or edit these.

activate() → None[source]¶: Activates a widget; the same as if it had been clicked.

add_delete_callback(call: Callable) → None[source]¶: Add a call to be run immediately after this widget is destroyed.

allow_preserve_selection: bool¶: Whether this widget should participate in auto selection save/restore.

center: tuple[float, float]¶: The center of this widget in its parent widget’s space.

delete(ignore_missing: bool = True) → None[source]¶: Delete the Widget. Ignores already-deleted Widgets if ignore_missing is True; otherwise an Exception is thrown.

draw_controller: bauiv1.Widget | None¶: The widget that visually ‘owns’ this one — typically set when an overlay textwidget represents the label of an underlying buttonwidget; activating the draw controller is the right way to act on the visual widget. None for widgets with no draw controller set.

exists() → bool[source]¶

Returns whether the Widget still exists. Most functionality will fail on a nonexistent widget.

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

get_children() → list[bauiv1.Widget][source]¶: Returns any child Widgets of this Widget.

get_screen_space_center() → tuple[float, float][source]¶: Returns the coords of the bauiv1.Widget center relative to the center of the screen. This can be useful for placing pop-up windows and other special cases.

get_selected_child() → bauiv1.Widget | None[source]¶: Returns the selected child Widget or None if nothing is selected.

get_widget_type() → str[source]¶: Return the internal type of the Widget as a string. Note that this is different from the Python bauiv1.Widget type, which is the same for all widgets.

id: str | None¶: ID for this widget (if any).

parent: bauiv1.Widget | None¶: The parent widget (if any).

scroll_into_view() → None[source]¶: Scroll to show this widget if possible.

selectable: bool¶: Whether this widget can be selected.

transitioning_out: bool¶

Whether this widget is in the process of dying (read only).

It can be useful to check this on a window’s root widget to prevent multiple window actions from firing simultaneously, potentially leaving the UI in a broken state.

class bauiv1.Window(root_widget: bauiv1.Widget, cleanupcheck: bool = True, prevent_main_window_auto_recreate: bool = True)[source]¶

Bases: object

A basic window.

Essentially wraps a ContainerWidget with some higher level functionality.

get_root_widget() → bauiv1.Widget[source]¶: Return the root widget.

bauiv1.accountlog: logging.Logger = <Logger ba.account (INFO)>¶: Logger for account functionality.

bauiv1.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.

bauiv1.applog: logging.Logger = <Logger ba.app (INFO)>¶: Logger for general app operation; INFO is visible by default.

bauiv1.appname() → str[source]¶: Return current app name (all lowercase).

bauiv1.appnameupper() → str[source]¶: Return current app name with capitalized characters.

bauiv1.apptime() → babase.AppTime[source]¶

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.

bauiv1.apptimer(time: float, call: Callable[[], Any]) → None[source]¶

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!'))

bauiv1.balog: logging.Logger = <Logger ba (INFO)>¶: Top-level Ballistica Logger — use this to adjust verbosity across everything Ballistica logs.

Create or edit a button widget.

Pass a valid existing bauiv1.Widget as ‘edit’ to modify it; otherwise a new one is created and returned. Arguments that are not set to None are applied to the Widget.

bauiv1.charstr(char_id: babase.SpecialChar) → str[source]¶

Return a unicode string representing a special character.

Note that these utilize the private-use block of unicode characters (U+E000-U+F8FF) and are specific to the game; exporting or rendering them elsewhere will be meaningless.

See SpecialChar for the list of available characters.

Create or edit a check-box widget.

Pass a valid existing bauiv1.Widget as ‘edit’ to modify it; otherwise a new one is created and returned. Arguments that are not set to None are applied to the Widget.

bauiv1.clipboard_is_supported() → bool[source]¶

Return whether this platform supports clipboard operations at all.

If this returns False, UIs should not show ‘copy to clipboard’ buttons, etc.

bauiv1.clipboard_set_text(value: str) → None[source]¶

Copy a string to the system clipboard.

Ensure that clipboard_is_supported() returns True before adding buttons/etc. that make use of this functionality.

Create or edit a column widget.

Pass a valid existing bauiv1.Widget as ‘edit’ to modify it; otherwise a new one is created and returned. Arguments that are not set to None are applied to the Widget.

bauiv1.containerwidget(*, edit: bauiv1.Widget | None = None, parent: bauiv1.Widget | None = None, id: str | None = None, size: Sequence[float] | None = None, position: Sequence[float] | None = None, background: bool | None = None, selected_child: bauiv1.Widget | None = None, transition: str | None = None, cancel_button: bauiv1.Widget | None = None, start_button: bauiv1.Widget | None = None, root_selectable: bool | None = None, on_activate_call: Callable[[], None] | None = None, claims_left_right: bool | None = None, selection_loops: bool | None = None, selection_loops_to_parent: bool | None = None, scale: float | None = None, on_outside_click_call: Callable[[], None] | None = None, single_depth: bool | None = None, visible_child: bauiv1.Widget | None = None, stack_offset: Sequence[float] | None = None, color: Sequence[float] | None = None, on_cancel_call: Callable[[], None] | None = None, print_list_exit_instructions: bool | None = None, click_activate: bool | None = None, always_highlight: bool | None = None, selectable: bool | None = None, scale_origin_stack_offset: Sequence[float] | None = None, toolbar_visibility: Literal['menu_minimal', 'menu_minimal_no_back', 'menu_full', 'menu_full_no_back', 'menu_store', 'menu_store_no_back', 'menu_in_game', 'menu_tokens', 'no_menu_minimal', 'inherit'] | None = None, toolbar_cancel_button_style: Literal['back', 'close'] | None = None, on_select_call: Callable[[], None] | None = None, claim_outside_clicks: bool | None = None, claims_up_down: bool | None = None, darken_behind: bool | None = None, darken_behind_is_permanent: bool | None = None) → bauiv1.Widget[source]¶

Create or edit a container widget.

Pass a valid existing bauiv1.Widget as ‘edit’ to modify it; otherwise a new one is created and returned. Arguments that are not set to None are applied to the Widget.

bauiv1.discord_sign_in(result_cb: Callable[[str | Exception], None], description: str) → None[source]¶

Run the Discord OAuth sign-in flow and return V2 credentials.

Kicks off the native OAuth flow (browser-based), exchanges the resulting token with the cloud for V2 credentials, and invokes result_cb on the logic thread with a credentials string on success or with an Exception on any failure.

Discord has no implicit/background sign-in on any platform, so it doesn’t use LoginAdapter. This mirrors the email/V2-proxy flow in structure: an explicit credential-producing flow that drops directly into set_primary_credentials.

bauiv1.displaytime() → babase.DisplayTime[source]¶

Return the current display-time in seconds.

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.

bauiv1.displaytimer(time: float, call: Callable[[], Any]) → None[source]¶

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.

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!'))

bauiv1.do_once() → bool[source]¶

Return whether this is the first time running a line of code.

This is used by print_once() type calls to keep from overflowing logs. The call functions by registering the filename and line where The call is made from. Returns True if this location has not been registered already, and False if it has.

Example: This print will only fire for the first loop iteration:

for i in range(10):
    if babase.do_once():
        print('HelloWorld once from loop!')

bauiv1.existing(obj: ExistableT | None) → ExistableT | None[source]¶

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

bauiv1.get_ip_address_type(addr: str) → AddressFamily[source]¶

Return an address-type given an address.

Can be socket.AF_INET or socket.AF_INET6.

bauiv1.get_legacy_langdata() → dict[str, Any][source]¶

Return the parsed legacy language-data blob (cached process-wide).

This is the legacy langdata.json payload (translated language names + translation contributors), now sourced from the builtin asset-package’s flavor-invariant constant bucket (logical path legacylangdata) rather than a bundled data file.

Returns {} when the blob is unavailable (headless / no bundled asset-package manifest / not yet resolved) or on any read error, so callers can .get(...) safely.

bauiv1.get_qrcode_texture(url: str) → bauiv1.Texture[source]¶

Return a QR code texture.

The provided url must be 64 bytes or less.

bauiv1.get_selected_widget() → bauiv1.Widget | None[source]¶: Return the current globally selected widget, if any.

bauiv1.get_special_widget(name: Literal['squad_button', 'back_button', 'menu_button', 'account_button', 'achievements_button', 'settings_button', 'inbox_button', 'store_button', 'get_tokens_button', 'inventory_button', 'tickets_meter', 'tokens_meter', 'trophy_meter', 'level_meter', 'overlay_stack', 'chest_0_button', 'chest_1_button', 'chest_2_button', 'chest_3_button']) → bauiv1.Widget[source]¶: Return special widgets located in system toolbars.

bauiv1.get_type_name(cls: type) → str[source]¶: Return a fully qualified type name for a class.

bauiv1.get_virtual_safe_area_size() → tuple[float, float][source]¶: Return the size of the area on screen that will always be visible.

bauiv1.get_virtual_screen_size() → tuple[float, float][source]¶: Return the current virtual size of the display.

bauiv1.getclass(name: str, subclassof: type[T], check_sdlib_modulename_clash: bool = False) → type[T][source]¶

Given a full class name such as foo.bar.MyClass, return the class.

The class will be checked to make sure it is a subclass of the provided ‘subclassof’ class, and a TypeError will be raised if not.

bauiv1.getmesh(name: str) → bauiv1.Mesh[source]¶: Load a mesh for use solely in the local user interface.

bauiv1.getsound(name: str) → bauiv1.Sound[source]¶: Load a sound for use in the ui.

bauiv1.gettexture(name: str) → bauiv1.Texture[source]¶: Load a texture for use in the ui.

Create or edit a horizontal scroll widget.

Pass a valid existing bauiv1.Widget as ‘edit’ to modify it; otherwise a new one is created and returned. Arguments that are not set to None are applied to the Widget.

bauiv1.imagewidget(*, edit: bauiv1.Widget | None = None, parent: bauiv1.Widget | None = None, size: Sequence[float] | None = None, position: Sequence[float] | None = None, color: Sequence[float] | None = None, texture: bauiv1.Texture | None = None, opacity: float | None = None, rotate: float | None = None, mesh_transparent: bauiv1.Mesh | None = None, mesh_opaque: bauiv1.Mesh | None = None, has_alpha_channel: bool = True, tint_texture: bauiv1.Texture | None = None, tint_color: Sequence[float] | None = None, transition_delay: float | None = None, draw_controller: bauiv1.Widget | None = None, tint2_color: Sequence[float] | None = None, tilt_scale: float | None = None, mask_texture: bauiv1.Texture | None = None, radial_amount: float | None = None, draw_controller_mult: float | None = None, depth_range: tuple[float, float] | None = None, transition_type: Literal['in_left', 'scale'] | None = None) → bauiv1.Widget[source]¶

Create or edit an image widget.

Pass a valid existing bauiv1.Widget as ‘edit’ to modify it; otherwise a new one is created and returned. Arguments that are not set to None are applied to the Widget.

bauiv1.in_logic_thread() → bool[source]¶

Return whether the current thread is the logic thread.

The logic thread is where a large amount of app code runs, and various functionality expects to only be used from there.

bauiv1.is_browser_likely_available() → bool[source]¶

Return whether a browser likely exists on the current device.

If this returns False, you may want to avoid calling open_url() with any lengthy addresses. (open_url() will display an address as a string/qr-code in a window if unable to bring up a browser, but that is only reasonable for small-ish URLs.)

bauiv1.netlog: logging.Logger = <Logger ba.net (INFO)>¶: Logger for general networking activity.

bauiv1.open_url(address: str, force_fallback: bool = False) → None[source]¶

Open the provided URL.

Attempts to open the provided url in a web-browser. If that is not possible (or force_fallback is True), instead displays the url as a string and/or qrcode.

bauiv1.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[source]¶

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.

bauiv1.quit(confirm: bool = False, quit_type: babase.QuitType | None = None) → None[source]¶

Quit the app.

If confirm is True, a confirm dialog will be presented if conditions allow; otherwise the quit will still be immediate. See docs for QuitType for explanations of the optional quit_type arg.

bauiv1.reload_hooks() → None[source]¶: 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.

bauiv1.request_main_ui() → None[source]¶

High level call to request a main ui if it is not already open.

Can be called from any thread.

bauiv1.root_ui_pause_updates() → None[source]¶: Temporarily pause updates to the root ui for animation purposes. Make sure that each call to this is matched by a call to root_ui_resume_updates().

bauiv1.root_ui_resume_updates() → None[source]¶: Resume paused updates to the root ui for animation purposes.

Create or edit a row widget.

Pass a valid existing bauiv1.Widget as ‘edit’ to modify it; otherwise a new one is created and returned. Arguments that are not set to None are applied to the Widget.

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

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.

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

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

Create or edit a scroll widget.

Pass a valid existing bauiv1.Widget as ‘edit’ to modify it; otherwise a new one is created and returned. Arguments that are not set to None are applied to the Widget.

Create or edit a spinner widget.

Pass a valid existing bauiv1.Widget as ‘edit’ to modify it; otherwise a new one is created and returned. Arguments that are not set to None are applied to the Widget.

bauiv1.supports_unicode_display() → bool[source]¶: Return whether we can display all unicode characters in the gui.

Create or edit a text widget.

Pass a valid existing bauiv1.Widget as ‘edit’ to modify it; otherwise a new one is created and returned. Arguments that are not set to None are applied to the Widget.

bauiv1.timestring(timeval: float | int, centi: bool = True, *, langstr: Literal[False] = False) → babase.Lstr[source]¶

bauiv1.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.

bauiv1.uibounds() → tuple[float, float, float, float][source]¶

Returns ui-bounds values: (x-min, x-max, y-min, y-max).

This is the range of values that can be plugged into ‘stack_offset’ for a bauiv1.containerwidget() call while guaranteeing that its center remains onscreen.

bauiv1.uicleanupcheck(obj: Any, widget: bauiv1.Widget) → None[source]¶: Deprecated since version 1.7.51: Use UIV1AppSubsystem.add_ui_cleanup_check(). Will be removed when api 9 support ends.

bauiv1.uilog: logging.Logger = <Logger ba.ui (INFO)>¶: Ballistica user interface api version 1

bauiv1.utc_now_cloud() → datetime.datetime[source]¶

Returns estimated utc time regardless of local clock settings.

Applies offsets pulled from server communication/etc.

bauiv1.widget(*, edit: bauiv1.Widget, up_widget: bauiv1.Widget | None = None, down_widget: bauiv1.Widget | None = None, left_widget: bauiv1.Widget | None = None, right_widget: bauiv1.Widget | None = None, show_buffer_top: float | None = None, show_buffer_bottom: float | None = None, show_buffer_left: float | None = None, show_buffer_right: float | None = None, depth_range: tuple[float, float] | None = None, autoselect: bool | None = None, allow_preserve_selection: bool | None = None, auto_select_toolbars_only: bool | None = None) → None[source]¶

Edit common attributes of any widget.

Unlike other UI calls, this can only be used to edit, not to create.

bauiv1.widget_by_id(id: str) → bauiv1.Widget | None[source]¶: Return a widget with the given ID, or None if there is none.

Submodules¶

bauiv1.builtinassets module¶

Asset-package wrapper for a-0.babuiltinassets.260730a (bauiv1).

Bare minimum assets always bundled with the engine.

These are loaded at launch and always available in the C++ layer.

class bauiv1.builtinassets.AudioGroup[source]¶

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 bauiv1.builtinassets.MeshesGroup[source]¶

Bases: object

Meshes needed during engine bootstrap and early UI.

See source for the full asset list.

class bauiv1.builtinassets.StringsAccountGroup[source]¶

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[source]¶

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 bauiv1.builtinassets.StringsAssetsGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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 bauiv1.builtinassets.StringsAudioGroup[source]¶

Bases: object

Audio-related messages: music/custom-soundtrack playback errors.

See source for the full asset list.

music_play_error(*, music: str | LangStr) → LangStr[source]¶

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 bauiv1.builtinassets.StringsGroup[source]¶

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 bauiv1.builtinassets.StringsInputGroup[source]¶

Bases: object

Input-device strings: device display names and connect/disconnect
notices.

See source for the full asset list.

axis(*, number: str | LangStr) → LangStr[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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 bauiv1.builtinassets.StringsNetGroup[source]¶

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 bauiv1.builtinassets.StringsPluginsGroup[source]¶

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[source]¶

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[source]¶

Error message for a plugin that failed to initialize.

English: "Error initializing plugin {plugin}: {error}"

removed(*, count: int) → LangStr[source]¶

Notice that previously-present plugins are gone.

English: (one) "# plugin no longer found." / (other) "# plugins
no longer found."

class bauiv1.builtinassets.StringsReplayGroup[source]¶

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 bauiv1.builtinassets.StringsScriptsGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.builtinassets.StringsSessionGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.builtinassets.StringsStoreGroup[source]¶

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[source]¶

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 bauiv1.builtinassets.StringsTimeGroup[source]¶

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[source]¶

Compact hours suffix used in formatted time values.

English: "{count}h"

suffix_minutes(*, count: str | LangStr) → LangStr[source]¶

Compact minutes suffix used in formatted time values.

English: "{count}m"

suffix_seconds(*, count: str | LangStr) → LangStr[source]¶

Compact seconds suffix used in formatted time values.

English: "{count}s"

class bauiv1.builtinassets.StringsUiGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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 bauiv1.builtinassets.StringsWorkspaceGroup[source]¶

Bases: object

Messages about syncing and activating account workspaces.

See source for the full asset list.

activated(*, thing: str | LangStr) → LangStr[source]¶

Confirmation that a workspace was activated.

English: "{thing} activated."

sync_error(*, workspace: str | LangStr) → LangStr[source]¶

Error message that a workspace failed to sync.

English: "Error syncing workspace {workspace}. See log for
details."

sync_reuse(*, workspace: str | LangStr) → LangStr[source]¶

Notice that a previously synced workspace is being reused.

English: "Unable to sync {workspace}. Reusing the last synced
version."

class bauiv1.builtinassets.TexturesGroup[source]¶

Bases: object

Textures needed during engine bootstrap and early UI, including the
reflection cube-maps.

See source for the full asset list.

bauiv1.builtinassets.audio: AudioGroup = <bauiv1._assetref.AssetGroup object>¶: The audio group - 20 assets (blank, blip, cash_register, click01, cork_pop, and 15 more). Full list in source.

bauiv1.builtinassets.meshes: MeshesGroup = <bauiv1._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.

bauiv1.builtinassets.strings: StringsGroup = <babase._language.LangStrDir object>¶: The strings group - 87 strings (account, assets, audio, input, net, and 82 more). Full list in source.

bauiv1.builtinassets.textures: TexturesGroup = <bauiv1._assetref.AssetGroup object>¶: The textures group - 82 assets (action_buttons, arrow, back_icon, black, bomb_button, and 77 more). Full list in source.

bauiv1.classicassets module¶

Asset-package wrapper for a-0.baclassicassets.260730b (bauiv1).

All assets for classic bombsquad.

class bauiv1.classicassets.AudioGroup[source]¶

Bases: object

All standard game sounds (everything non-bootstrap).

See source for the full asset list.

class bauiv1.classicassets.MeshesGroup[source]¶

Bases: object

All standard game meshes (everything non-bootstrap).

See source for the full asset list.

class bauiv1.classicassets.StringsAccountGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsAchievementsBoomGoesTheDynamiteGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsAchievementsBoxerGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsAchievementsDualWieldingGroup[source]¶

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 bauiv1.classicassets.StringsAchievementsFlawlessVictoryGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsAchievementsFreeLoaderGroup[source]¶

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 bauiv1.classicassets.StringsAchievementsGoldMinerGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsAchievementsGotTheMovesGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsAchievementsGroup[source]¶

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 bauiv1.classicassets.StringsAchievementsInControlGroup[source]¶

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 bauiv1.classicassets.StringsAchievementsLastStandGodGroup[source]¶

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[source]¶

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[source]¶

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}."

name(*, level: str | LangStr) → LangStr[source]¶

Name of an achievement the player can earn.

English: "{level} God"

class bauiv1.classicassets.StringsAchievementsLastStandMasterGroup[source]¶

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[source]¶

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[source]¶

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}."

name(*, level: str | LangStr) → LangStr[source]¶

Name of an achievement the player can earn.

English: "{level} Master"

class bauiv1.classicassets.StringsAchievementsLastStandWizardGroup[source]¶

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[source]¶

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[source]¶

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}."

name(*, level: str | LangStr) → LangStr[source]¶

Name of an achievement the player can earn.

English: "{level} Champion"

class bauiv1.classicassets.StringsAchievementsMineGamesGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsAchievementsOffYouGoThenGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsAchievementsOnslaughtGodGroup[source]¶

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[source]¶

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[source]¶

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}"

name(*, level: str | LangStr) → LangStr[source]¶

Name of an achievement the player can earn.

English: "{level} God"

class bauiv1.classicassets.StringsAchievementsOnslaughtMasterGroup[source]¶

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[source]¶

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[source]¶

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}"

name(*, level: str | LangStr) → LangStr[source]¶

Name of an achievement the player can earn.

English: "{level} Master"

class bauiv1.classicassets.StringsAchievementsOnslaughtTrainingVictoryGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

Name of an achievement the player can earn.

English: "{level} Victory"

class bauiv1.classicassets.StringsAchievementsOnslaughtWizardGroup[source]¶

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[source]¶

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[source]¶

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}."

name(*, level: str | LangStr) → LangStr[source]¶

Name of an achievement the player can earn.

English: "{level} Master"

class bauiv1.classicassets.StringsAchievementsPrecisionBombingGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsAchievementsProBoxerGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsAchievementsProFootballShutoutGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

Name of an achievement the player can earn.

English: "{level} Shutout"

class bauiv1.classicassets.StringsAchievementsProFootballVictoryGroup[source]¶

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[source]¶

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[source]¶

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}."

name(*, level: str | LangStr) → LangStr[source]¶

Name of an achievement the player can earn.

English: "{level} Victory"

class bauiv1.classicassets.StringsAchievementsProOnslaughtVictoryGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

Name of an achievement the player can earn.

English: "{level} Victory"

class bauiv1.classicassets.StringsAchievementsProRunaroundVictoryGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

Name of an achievement the player can earn.

English: "{level} Victory"

class bauiv1.classicassets.StringsAchievementsRookieFootballShutoutGroup[source]¶

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[source]¶

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[source]¶

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}."

name(*, level: str | LangStr) → LangStr[source]¶

Name of an achievement the player can earn.

English: "{level} Shutout"

class bauiv1.classicassets.StringsAchievementsRookieFootballVictoryGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

Name of an achievement the player can earn.

English: "{level} Victory"

class bauiv1.classicassets.StringsAchievementsRookieOnslaughtVictoryGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

Name of an achievement the player can earn.

English: "{level} Victory"

class bauiv1.classicassets.StringsAchievementsRunaroundGodGroup[source]¶

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[source]¶

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[source]¶

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}"

name(*, level: str | LangStr) → LangStr[source]¶

Name of an achievement the player can earn.

English: "{level} God"

class bauiv1.classicassets.StringsAchievementsRunaroundMasterGroup[source]¶

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[source]¶

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[source]¶

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}"

name(*, level: str | LangStr) → LangStr[source]¶

Name of an achievement the player can earn.

English: "{level} Master"

class bauiv1.classicassets.StringsAchievementsRunaroundWizardGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

Name of an achievement the player can earn.

English: "Champion of {level}"

class bauiv1.classicassets.StringsAchievementsSharingIsCaringGroup[source]¶

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 bauiv1.classicassets.StringsAchievementsStayinAliveGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsAchievementsSuperMegaPunchGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsAchievementsSuperPunchGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsAchievementsTeamPlayerGroup[source]¶

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 bauiv1.classicassets.StringsAchievementsTheGreatWallGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsAchievementsTheWallGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsAchievementsTntTerrorGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsAchievementsUberFootballShutoutGroup[source]¶

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[source]¶

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[source]¶

Full description of an achievement the player has already
earned, naming the campaign level (past tense).

English: "Completed {level}."

name(*, level: str | LangStr) → LangStr[source]¶

Name of an achievement the player can earn.

English: "{level} Shutout"

class bauiv1.classicassets.StringsAchievementsUberFootballVictoryGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

Name of an achievement the player can earn.

English: "{level} Victory"

class bauiv1.classicassets.StringsAchievementsUberOnslaughtVictoryGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

Name of an achievement the player can earn.

English: "{level} Victory"

class bauiv1.classicassets.StringsAchievementsUberRunaroundVictoryGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

Name of an achievement the player can earn.

English: "{level} Victory"

class bauiv1.classicassets.StringsAppInviteGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

Notice that the player got a promo code.

English: "You have been sent a {app_name} promo code:"

class bauiv1.classicassets.StringsCharactersGroup[source]¶

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 bauiv1.classicassets.StringsChestGroup[source]¶

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[source]¶

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 bauiv1.classicassets.StringsControlsGroup[source]¶

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[source]¶

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 bauiv1.classicassets.StringsCoopGroup[source]¶

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[source]¶

Notice that a named level is locked.

English: "{level} is locked."

level_must_be_completed_first(*, level: str | LangStr) → LangStr[source]¶

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[source]¶

Suffix showing a value out of a total time.

English: "of {total}"

player_count_abbreviated(*, count: str | LangStr) → LangStr[source]¶

Abbreviated player-count badge (number + "p" for players).

English: "{count}p"

power_ranking_points(*, number: str | LangStr) → LangStr[source]¶

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 bauiv1.classicassets.StringsCoopLevelsGroup[source]¶

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[source]¶

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[source]¶

Name of the Uber difficulty variant of a level.

English: "Uber {game}"

class bauiv1.classicassets.StringsCoopScoreGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsCreditsGroup[source]¶

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[source]¶

Credit line for additional contributors.

English: "Additional Audio, Early Artwork, and Ideas by {name}"

additional_music_from(*, name: str | LangStr) → LangStr[source]¶

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[source]¶

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[source]¶

Credit line for public-domain music.

English: "Public-domain music via {name}"

software_based_on(*, name: str | LangStr) → LangStr[source]¶

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[source]¶

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[source]¶

Special-thanks credit line.

English: "Special thanks to {name}"

title(*, app_name: str | LangStr) → LangStr[source]¶

Title of the credits window.

English: "{app_name} Credits"

whoever_invented_coffee: LangStr¶

Humorous credit line thanking coffee.

English: "Whoever invented coffee"

class bauiv1.classicassets.StringsEconomyGroup[source]¶

Bases: object

Screen-messages about currency: grants and related notices.

See source for the full asset list.

received_tickets(*, count: int) → LangStr[source]¶

Confirmation of how many tickets were received.

English: (one) "Received # Ticket!" / (other) "Received #
Tickets!"

you_got_tokens(*, tokens: int) → LangStr[source]¶

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 bauiv1.classicassets.StringsFileSelectorGroup[source]¶

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 bauiv1.classicassets.StringsGameDescriptionsGroup[source]¶

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[source]¶

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[source]¶

Minigame objective description (start-of-match / game lists).

English: "Carry the flag for {arg1} seconds"

crush_of_your_enemies(*, arg1: str | LangStr) → LangStr[source]¶

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[source]¶

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[source]¶

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[source]¶

Minigame objective description (start-of-match / game lists).

English: "Run {arg1} laps."

run_laps_2(*, arg1: str | LangStr) → LangStr[source]¶

Minigame objective description (start-of-match / game lists).

English: "Run {arg1} laps"

run_laps_your_entire_team_has(*, arg1: str | LangStr) → LangStr[source]¶

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[source]¶

Minigame objective description (start-of-match / game lists).

English: "Score {arg1} goals."

score_goals_2(*, arg1: str | LangStr) → LangStr[source]¶

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[source]¶

Minigame objective description (start-of-match / game lists).

English: "Score {arg1} touchdowns."

score_touchdowns_2(*, arg1: str | LangStr) → LangStr[source]¶

Minigame objective description (start-of-match / game lists).

English: "score {arg1} touchdowns"

secure_all_flags(*, arg1: str | LangStr) → LangStr[source]¶

Minigame objective description (start-of-match / game lists).

English: "Secure all {arg1} flags."

secure_all_flags_2(*, arg1: str | LangStr) → LangStr[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

Minigame objective description (start-of-match / game lists).

English: "Touch the enemy flag {arg1} times."

class bauiv1.classicassets.StringsGameGroup[source]¶

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[source]¶

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[source]¶

Epic-mode wrapper appended to a game description.

English: "{description} In epic slow motion."

epic_name_filter(*, name: str | LangStr) → LangStr[source]¶

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[source]¶

Pure-formatting template pairing a game with its map;
substitution-only.

English: "{name} @ {mapname}"

killing_track_skipper(*, name: str | LangStr) → LangStr[source]¶

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[source]¶

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[source]¶

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[source]¶

Death announcement: a player killed a teammate.

English: "{name} betrayed {victim}."

name_died(*, name: str | LangStr) → LangStr[source]¶

Death announcement: a player died.

English: "{name} died."

name_killed(*, name: str | LangStr, victim: str | LangStr) → LangStr[source]¶

Death announcement: a player killed an opponent.

English: "{name} killed {victim}."

name_scores(*, name: str | LangStr) → LangStr[source]¶

Announcement that a named player scores.

English: "{name} Scores!"

name_suicide(*, name: str | LangStr) → LangStr[source]¶

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[source]¶

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[source]¶

Pure-formatting popup showing points just gained;
substitution-only.

English: "+{points}"

points_gained_titled(*, points: str | LangStr, title: str | LangStr) → LangStr[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

Label for the current wave with its number, shown on the co-op
HUD.

English: "Wave {number}"

class bauiv1.classicassets.StringsGameNamesGroup[source]¶

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 bauiv1.classicassets.StringsGatherGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

Button to start paid hosting for a cost.

English: "Host Now For {cost}"

start_stop_hosting_minutes(*, minutes: int) → LangStr[source]¶

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 bauiv1.classicassets.StringsGetRemoteGroup[source]¶

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[source]¶

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 bauiv1.classicassets.StringsGetTokensGroup[source]¶

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[source]¶

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 bauiv1.classicassets.StringsGroup[source]¶

Bases: object

All standard game strings (everything non-bootstrap).

See source for the full asset list.

class bauiv1.classicassets.StringsHelpGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

Welcome heading in the help window.

English: "Welcome to {app_name}!"

class bauiv1.classicassets.StringsInGameMenuGroup[source]¶

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[source]¶

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 bauiv1.classicassets.StringsInboxGroup[source]¶

Bases: object

Message-inbox window: messages, prizes, expiry labels.

See source for the full asset list.

expired_ago(*, t: str | LangStr) → LangStr[source]¶

Label showing how long ago something expired.

English: "Expired {t} ago"

expires_in(*, t: str | LangStr) → LangStr[source]¶

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 bauiv1.classicassets.StringsInventoryGroup[source]¶

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 bauiv1.classicassets.StringsKeyboardGroup[source]¶

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[source]¶

Confirmation that the on-screen keyboard changed.

English: "Keyboard switched to {name}"

class bauiv1.classicassets.StringsKioskGroup[source]¶

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 bauiv1.classicassets.StringsLeagueGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

Badge showing a points equivalence in power ranking.

English: "= {number} pts"

power_ranking_points_mult(*, number: str | LangStr) → LangStr[source]¶

Badge showing a points multiplier in power ranking.

English: "(x{number} pts)"

season(*, number: str | LangStr) → LangStr[source]¶

Label naming a season by number.

English: "Season {number}"

season_ended_days_ago(*, days: int) → LangStr[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsLobbyGroup[source]¶

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[source]¶

Prompt for overriding the profile character in the lobby.

English: "press {buttons} to override your character"

press_to_select_profile(*, buttons: str | LangStr) → LangStr[source]¶

Prompt for selecting a player profile in the lobby.

English: "press {buttons} to select a player"

press_to_select_team(*, buttons: str | LangStr) → LangStr[source]¶

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 bauiv1.classicassets.StringsMainMenuGroup[source]¶

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[source]¶

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 bauiv1.classicassets.StringsMapNamesGroup[source]¶

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 bauiv1.classicassets.StringsMultiTeamGroup[source]¶

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[source]¶

Title for a best-of-N final series.

English: "Best-of-{count} Final"

best_of_series(*, count: int) → LangStr[source]¶

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[source]¶

A player's death count in the end-of-series tally.

English: "{count} deaths"

first_to_final(*, count: str | LangStr) → LangStr[source]¶

Title for a first-to-N-wins final series.

English: "First-to-{count} Final"

first_to_series(*, count: int) → LangStr[source]¶

Title for a first-to-N-wins series.

English: (one) "First-To-# Series" / (other) "First-To-# Series"

game_leaders(*, count: int) → LangStr[source]¶

Heading over the leaders of the current game.

English: (one) "Game # Leaders" / (other) "Game # Leaders"

games_to(*, wincount: str | LangStr, losecount: str | LangStr) → LangStr[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

Label introducing the next game of a series.

English: "Up next in game {count}:"

wins(*, name: str | LangStr) → LangStr[source]¶

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 bauiv1.classicassets.StringsPartyGroup[source]¶

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 bauiv1.classicassets.StringsPartyQueueGroup[source]¶

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 bauiv1.classicassets.StringsPlayGroup[source]¶

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 bauiv1.classicassets.StringsPlayModesGroup[source]¶

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 bauiv1.classicassets.StringsPlayOptionsGroup[source]¶

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 bauiv1.classicassets.StringsPlaylistGroup[source]¶

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[source]¶

Title for the customize-playlists window.

English: "Customize {type} Playlists"

default_list_name(*, playmode: str | LangStr) → LangStr[source]¶

Name of the built-in default playlist for a play mode.

English: "Default {playmode} Playlist"

default_new_list_name(*, playmode: str | LangStr) → LangStr[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsProfileGroup[source]¶

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[source]¶

Explanation of what an account profile is.

English: "Uses account details {icons}. Create custom profiles
to change."

available(*, name: str | LangStr) → LangStr[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsProfilesGroup[source]¶

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 bauiv1.classicassets.StringsReportGroup[source]¶

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 bauiv1.classicassets.StringsResourceTypeInfoGroup[source]¶

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 bauiv1.classicassets.StringsScoreTypesGroup[source]¶

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 bauiv1.classicassets.StringsSendInfoGroup[source]¶

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 bauiv1.classicassets.StringsServerGroup[source]¶

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 bauiv1.classicassets.StringsSessionGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

Broadcast that a named player left the game.

English: "{player} left the game."

player_limit_reached(*, count: int) → LangStr[source]¶

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 bauiv1.classicassets.StringsSettingsAdvancedGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsSettingsAudioGroup[source]¶

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 bauiv1.classicassets.StringsSettingsBenchmarksGroup[source]¶

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 bauiv1.classicassets.StringsSettingsControllersGamepadGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

Assignment slot for a numbered run button (1 or 2).

English: (one) "Run Button #" / (other) "Run Button #"

run_trigger(*, num: int) → LangStr[source]¶

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 bauiv1.classicassets.StringsSettingsControllersGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsSettingsControllersKeyboardGroup[source]¶

Bases: object

Keyboard config-window strings.

See source for the full asset list.

configuring(*, device: str | LangStr) → LangStr[source]¶

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 bauiv1.classicassets.StringsSettingsControllersTouchscreenGroup[source]¶

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 bauiv1.classicassets.StringsSettingsDevToolsGroup[source]¶

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 bauiv1.classicassets.StringsSettingsGraphicsGroup[source]¶

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[source]¶

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 bauiv1.classicassets.StringsSettingsGroup[source]¶

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 bauiv1.classicassets.StringsSettingsNetTestingGroup[source]¶

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 bauiv1.classicassets.StringsSettingsPluginsGroup[source]¶

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 bauiv1.classicassets.StringsSettingsTestingGroup[source]¶

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 bauiv1.classicassets.StringsSettingsVrTestingGroup[source]¶

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 bauiv1.classicassets.StringsSoundtrackGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsStoreGroup[source]¶

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[source]¶

Product name label for the Pro upgrade.

English: "{app_name} Pro"

class bauiv1.classicassets.StringsTeamsGroup[source]¶

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 bauiv1.classicassets.StringsTournamentEntryGroup[source]¶

Bases: object

Tournament-entry dialog: entry cost and watch-ad options.

See source for the full asset list.

tickets_count(*, count: int) → LangStr[source]¶

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 bauiv1.classicassets.StringsTournamentScoresGroup[source]¶

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 bauiv1.classicassets.StringsTutorialGroup[source]¶

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[source]¶

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[source]¶

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[source]¶

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[source]¶

Tutorial: apology after a hard hit.

English: "Whoops; sorry 'bout that {name}."

phrase14(*, name: str | LangStr) → LangStr[source]¶

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[source]¶

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 bauiv1.classicassets.StringsUiGroup[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.StringsV2UpgradeGroup[source]¶

Bases: object

Device-account -> V2-account upgrade prompt.

See source for the full asset list.

device_account_upgrade(*, name: str | LangStr) → LangStr[source]¶

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 bauiv1.classicassets.StringsWatchGroup[source]¶

Bases: object

Watch-section strings: replay browsing and playback UI.

See source for the full asset list.

delete_confirm(*, replay: str | LangStr) → LangStr[source]¶

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[source]¶

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[source]¶

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[source]¶

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 bauiv1.classicassets.TexturesGroup[source]¶

Bases: object

All standard game textures (everything non-bootstrap).

See source for the full asset list.

bauiv1.classicassets.audio: AudioGroup = <bauiv1._assetref.AssetGroup object>¶: The audio group - 412 assets (achievement, action_hero1, action_hero2, action_hero3, action_hero4, and 407 more). Full list in source.

bauiv1.classicassets.meshes: MeshesGroup = <bauiv1._assetref.AssetGroup object>¶: The meshes group - 360 assets (achievement_outline, action_hero_fore_arm, action_hero_hand, action_hero_head, action_hero_lower_leg, and 355 more). Full list in source.

bauiv1.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.

bauiv1.classicassets.textures: TexturesGroup = <bauiv1._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.

bauiv1.onscreenkeyboard module¶

Provides the built-in on screen keyboard UI.

class bauiv1.onscreenkeyboard.OnScreenKeyboardWindow(adapter: StringEditAdapter)[source]¶

Bases: Window

Simple built-in on-screen keyboard.