@@ -5221,6 +6460,50 @@ them elsewhere will be meaningless.
a new one is created and returned. Arguments that are not set to None
are applied to the Widget.
+
+clipboard_get_text() -> str
+
+Return text currently on the system clipboard.
+
+Category: General Utility Functions
+
+Ensure that ba.clipboard_has_text() returns True before calling
+ this function.
+
+
+clipboard_has_text() -> bool
+
+Return whether there is currently text on the clipboard.
+
+Category: General Utility Functions
+
+This will return False if no system clipboard is available; no need
+ to call ba.clipboard_available() separately.
+
+
+clipboard_is_supported() -> bool
+
+Return whether this platform supports clipboard operations at all.
+
+Category: General Utility Functions
+
+If this returns False, UIs should not show 'copy to clipboard'
+buttons, etc.
+
+
+clipboard_set_text(value: str) -> None
+
+Copy a string to the system clipboard.
+
+Category: General Utility Functions
+
+Ensure that ba.clipboard_available() returns True before adding
+ buttons/etc. that make use of this functionality.
+
columnwidget(edit: ba.Widget = None,
@@ -5234,7 +6517,12 @@ are applied to the Widget.
print_list_exit_instructions: bool = None,
left_border: float = None,
top_border: float = None,
- bottom_border: float = None) -> ba.Widget
+ bottom_border: float = None,
+ selection_loops_to_parent: bool = None,
+ border: float = None,
+ margin: float = None,
+ claims_left_right: bool = None,
+ claims_tab: bool = None) -> ba.Widget
Create or edit a column widget.
@@ -5260,7 +6548,7 @@ are applied to the Widget.
claims_left_right: bool = None,
claims_tab: bool = None,
selection_loops: bool = None,
- selection_loop_to_parent: bool = None,
+ selection_loops_to_parent: bool = None,
scale: float = None,
on_outside_click_call: Callable[[], None] = None,
single_depth: bool = None,
@@ -5290,7 +6578,7 @@ are applied to the Widget.
do_once() -> bool
-Register a call at a location and return whether one already happened.
+Return whether this is the first time running a line of code.
Category: General Utility Functions
@@ -5322,41 +6610,60 @@ Note that the actual amount emitted may vary depending on graphics
settings, exiting element counts, or other factors.
-get_collision_info(*args: Any) -> Any
+existing(obj: Optional[ExistableType]) -> Optional[ExistableType]
-Return collision related values
+Convert invalid references to None for any ba.Existable object.
Category: Gameplay Functions
-Returns a single collision value or tuple of values such as location,
-depth, nodes involved, etc. Only call this in the handler of a
-collision-triggered callback or message
+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 dead
+objects (Optional[FooType]) into functions expecting only live ones
+(FooType), etc. This call can be used on any 'existable' object
+(one with an exists() method) and will convert it to a None value
+if it does not exist.
+
+For more info, see notes on 'existables' here:
+https://ballistica.net/wiki/Coding-Style-Guide
-get_valid_languages() -> List[str]
+garbage_collect() -> None
-Return a list containing names of all available languages.
+Run an explicit pass of garbage collection.
Category: General Utility Functions
-Languages that may be present but are not displayable on the running
-version of the game are ignored.
+May also print warnings/etc. if collection takes too long or if
+uncollectible objects are found (so use this instead of simply
+gc.collect().
getactivity(doraise: bool = True) -> ba.Activity
+getactivity(doraise: bool = True) -> <varies>
-Returns the current ba.Activity instance.
+Return the current ba.Activity instance.
Category: Gameplay Functions
Note that this is based on context; thus code run in a timer generated
in Activity 'foo' will properly return 'foo' here, even if another
Activity has since been created or is transitioning in.
-If there is no current Activity an Exception is raised, or if doraise is
-False then None is returned instead.
+If there is no current Activity, raises a ba.ActivityNotFoundError.
+If doraise is False, None will be returned instead in that case.
+
+
+getclass(name: str, subclassof: Type[T]) -> Type[T]
+
+Given a full class name such as foo.bar.MyClass, return the class.
+
+Category: General Utility Functions
+
+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.
ba.getcollidemodel()
@@ -5374,6 +6681,14 @@ to be loaded. To avoid hitches, instantiate your media objects in
advance of when you will be using them, allowing time for them to load
in the background if necessary.
+
+
getcollision() -> Collision
+
+Return the in-progress collision.
+
+Category: Gameplay Functions
+
getmaps(playtype: str) -> List[str]
@@ -5444,7 +6759,7 @@ Category: Gameplay Functions
getsession(doraise: bool = True) -> ba.Session
+getsession(doraise: bool = True) -> <varies>
Category: Gameplay Functions
@@ -5489,7 +6804,10 @@ in the background if necessary.
on_select_call: Callable[[], None] = None,
center_small_content: bool = None, color: Sequence[float] = None,
highlight: bool = None, border_opacity: float = None,
- simple_culling_h: float = None) -> ba.Widget
+ simple_culling_h: float = None,
+ claims_left_right: bool = None,
+ claims_up_down: bool = None,
+ claims_tab: bool = None) -> ba.Widget
Create or edit a horizontal scroll widget.
@@ -5545,8 +6863,8 @@ is only useful for simple URLs.)
log(message: str, to_console: bool = True, newline: bool = True,
- to_server: bool = True) -> None
+log(message: str, to_stdout: bool = True,
+ to_server: bool = True) -> None
Category: General Utility Functions
@@ -5561,8 +6879,8 @@ issues unless to_server is False.
so in most cases you can just use that.
-new_activity(activity_type: Type[ba.Activity],
+newactivity(activity_type: Type[ba.Activity],
settings: dict = None) -> ba.Activity
Instantiates a ba.Activity given a type object.
@@ -5570,11 +6888,11 @@ so in most cases you can just use that.
Category: General Utility Functions
Activities require special setup and thus cannot be directly
-instantiated; You must go through this function.
+instantiated; you must go through this function.
newnode(type: str, owner: Union[Node, ba.Actor] = None,
+newnode(type: str, owner: ba.Node = None,
attrs: dict = None, name: str = None, delegate: Any = None)
-> Node
@@ -5674,7 +6992,8 @@ It prints various info about the current object count, etc.
pushcall(call: Callable, from_other_thread: bool = False) -> None
+pushcall(call: Callable, from_other_thread: bool = False,
+ suppress_other_thread_warning: bool = False ) -> None
Pushes a call onto the event loop to be run during the next cycle.
@@ -5703,11 +7022,14 @@ app running.
rowwidget(edit: Widget =None, parent: Widget =None,
+rowwidget(edit: ba.Widget = None, parent: ba.Widget = None,
size: Sequence[float] = None,
position: Sequence[float] = None,
- background: bool = None, selected_child: Widget = None,
- visible_child: Widget = None) -> Widget
+ background: bool = None, selected_child: ba.Widget = None,
+ visible_child: ba.Widget = None,
+ claims_left_right: bool = None,
+ claims_tab: bool = None,
+ selection_loops_to_parent: bool = None) -> ba.Widget
Create or edit a row widget.
@@ -5758,7 +7080,12 @@ Currently the 'clients' option only works for transient messages.
capture_arrows: bool = False, on_select_call: Callable = None,
center_small_content: bool = None, color: Sequence[float] = None,
highlight: bool = None, border_opacity: float = None,
- simple_culling_v: float = None) -> ba.Widget
+ simple_culling_v: float = None,
+ selection_loops_to_parent: bool = None,
+ claims_left_right: bool = None,
+ claims_up_down: bool = None,
+ claims_tab: bool = None,
+ autoselect: bool = None) -> ba.Widget
Create or edit a scroll widget.
@@ -5780,21 +7107,11 @@ are applied to the Widget.
'screen' should be a string description of an app location
('Main Menu', etc.)
-
-setlanguage(language: Optional[str], print_change: bool = True, store_to_config: bool = True) -> None
-
-Set the active language used for the game.
-
-Category: General Utility Functions
-
-Pass None to use OS default language.
-
setmusic(musictype: Optional[MusicType], continuous: bool = False) -> None
+setmusic(musictype: Optional[ba.MusicType], continuous: bool = False) -> None
-Tell the game to play (or stop playing) a certain type of music.
+Set the app to play (or stop playing) a certain type of music.
Category: Gameplay Functions
@@ -5807,54 +7124,6 @@ user can override particular game music with their own.
if 'continuous' is True and musictype is the same as what is already
playing, the playing track will not be restarted.
-
-sharedobj(name: str) -> Any
-
-Return a predefined object for the current Activity, creating if needed.
-
-Category: Gameplay Functions
-
-Available values for 'name':
-
-'globals': returns the 'globals' ba.Node, containing various global
- controls & values.
-
-'object_material': a ba.Material that should be applied to any small,
- normal, physical objects such as bombs, boxes, players, etc. Other
- materials often check for the presence of this material as a
- prerequisite for performing certain actions (such as disabling collisions
- between initially-overlapping objects)
-
-'player_material': a ba.Material to be applied to player parts. Generally,
- materials related to the process of scoring when reaching a goal, etc
- will look for the presence of this material on things that hit them.
-
-'pickup_material': a ba.Material; collision shapes used for picking things
- up will have this material applied. To prevent an object from being
- picked up, you can add a material that disables collisions against things
- containing this material.
-
-'footing_material': anything that can be 'walked on' should have this
- ba.Material applied; generally just terrain and whatnot. A character will
- snap upright whenever touching something with this material so it should
- not be applied to props, etc.
-
-'attack_material': a ba.Material applied to explosion shapes, punch
- shapes, etc. An object not wanting to receive impulse/etc messages can
- disable collisions against this material.
-
-'death_material': a ba.Material that sends a ba.DieMessage() to anything
- that touches it; handy for terrain below a cliff, etc.
-
-'region_material': a ba.Material used for non-physical collision shapes
- (regions); collisions can generally be allowed with this material even
- when initially overlapping since it is not physical.
-
-'railing_material': a ba.Material with a very low friction/stiffness/etc
- that can be applied to invisible 'railings' useful for gently keeping
- characters from falling off of cliffs.
-
show_damage_count(damage: str, position: Sequence[float], direction: Sequence[float]) -> None
@@ -5863,18 +7132,44 @@ playing, the playing track will not be restarted.
Category: Gameplay Functions
+
+storagename(suffix: str = None) -> str
+
+Generate a unique name for storing class data in shared places.
+
+Category: General Utility Functions
+
+This consists of a leading underscore, the module path at the
+call site with dots replaced by underscores, the containing class's
+qualified name, and the provided suffix. When storing data in public
+places such as 'customdata' dicts, this minimizes the chance of
+collisions with other similarly named classes.
+
+Note that this will function even if called in the class definition.
+
+# Example: generate a unique name for storage purposes:
+class MyThingie:
+
+ # This will give something like '_mymodule_submodule_mythingie_data'.
+ _STORENAME = ba.storagename('data')
+
+ # Use that name to store some data in the Activity we were passed.
+ def __init__(self, activity):
+ activity.customdata[self._STORENAME] = {}
+
textwidget(edit: Widget = None, parent: Widget = None,
+textwidget(edit: ba.Widget = None, parent: ba.Widget = None,
size: Sequence[float] = None, position: Sequence[float] = None,
text: Union[str, ba.Lstr] = None, v_align: str = None,
h_align: str = None, editable: bool = None, padding: float = None,
on_return_press_call: Callable[[], None] = None,
on_activate_call: Callable[[], None] = None,
- selectable: bool = None, query: Widget = None, max_chars: int = None,
+ selectable: bool = None, query: ba.Widget = None, max_chars: int = None,
color: Sequence[float] = None, click_activate: bool = None,
on_select_call: Callable[[], None] = None,
- always_highlight: bool = None, draw_controller: Widget = None,
+ always_highlight: bool = None, draw_controller: ba.Widget = None,
scale: float = None, corner_scale: float = None,
description: Union[str, ba.Lstr] = None,
transition_delay: float = None, maxwidth: float = None,
@@ -5897,7 +7192,7 @@ are applied to the Widget.
time(timetype: ba.TimeType = TimeType.SIM,
timeformat: ba.TimeFormat = TimeFormat.SECONDS)
- -> Union[float, int]
+ -> <varies>
Return the current time.
@@ -6037,6 +7332,16 @@ so this can be used to disambiguate 'Any' types).
Generally this should be used in 'if __debug__' or assert clauses
to keep runtime overhead minimal.
+
+verify_object_death(obj: object) -> None
+
+Warn if an object does not get freed within a short period.
+
+Category: General Utility Functions
+
+This can be handy to detect and prevent memory/resource leaks.
+
widget(edit: ba.Widget = None, up_widget: ba.Widget = None,
diff --git a/resources/Makefile b/resources/Makefile
new file mode 100644
index 00000000..46a99a6e
--- /dev/null
+++ b/resources/Makefile
@@ -0,0 +1,8 @@
+# Released under the MIT License. See LICENSE for details.
+
+# Dummy resources makefile; nothing here for now.
+all: resources
+
+resources:
+
+clean:
diff --git a/resources/README.md b/resources/README.md
new file mode 100644
index 00000000..2d7fafc6
--- /dev/null
+++ b/resources/README.md
@@ -0,0 +1,4 @@
+# BallisticaCore Resources
+
+This directory should contain sources for a common set of resources such as icons, launch screens, etc.
+Run 'make' to compile and push them to their platform-specific locations.
diff --git a/src/ballistica/app/app.cc b/src/ballistica/app/app.cc
new file mode 100644
index 00000000..6bd078a5
--- /dev/null
+++ b/src/ballistica/app/app.cc
@@ -0,0 +1,398 @@
+// Released under the MIT License. See LICENSE for details.
+
+#include "ballistica/app/app.h"
+
+#include "ballistica/app/stress_test.h"
+#include "ballistica/core/thread.h"
+#include "ballistica/game/game.h"
+#include "ballistica/graphics/graphics_server.h"
+#include "ballistica/graphics/renderer.h"
+#include "ballistica/input/device/touch_input.h"
+#include "ballistica/input/input.h"
+#include "ballistica/networking/network_reader.h"
+#include "ballistica/networking/networking.h"
+#include "ballistica/networking/telnet_server.h"
+#include "ballistica/python/python.h"
+
+namespace ballistica {
+
+App::App(Thread* thread)
+ : Module("app", thread), stress_test_(std::make_unique()) {
+ assert(g_app == nullptr);
+ g_app = this;
+
+ // So anyone who needs to use the 'main' thread id can get at it...
+ Thread::UpdateMainThreadID();
+
+ // We modify some app behavior when run under the server manager.
+ auto* envval = getenv("BA_SERVER_WRAPPER_MANAGED");
+ server_wrapper_managed_ = (envval && strcmp(envval, "1") == 0);
+}
+
+void App::PostInit() {
+ // If we've got a nice themed hardware cursor, show it.
+ // Otherwise hide the hardware cursor; we'll draw it in software.
+ // (need to run this in postinit because SDL/etc may not be inited yet
+ // as of App::App().
+ g_platform->SetHardwareCursorVisible(g_buildconfig.hardware_cursor());
+}
+
+App::~App() = default;
+
+auto App::UsesEventLoop() const -> bool {
+ // We have 2 redundant values for essentially the same thing;
+ // should get rid of IsEventPushMode() once we've created
+ // App subclasses for our various platforms.
+ return !g_platform->IsEventPushMode();
+}
+
+void App::RunRenderUpkeepCycle() {
+ // This should only be used in cases where the OS is handling the event loop.
+ assert(!UsesEventLoop());
+ if (UsesEventLoop()) {
+ return;
+ }
+
+ // Pump thread messages (we're being driven by frame-draw callbacks
+ // so this is the only place that it gets done at).
+ thread()->RunEventLoop(true); // Single pass only.
+
+ // Now do the general app event cycle for whoever needs to process things.
+ RunEvents();
+}
+
+void App::RebuildLostGLContext() {
+ assert(InMainThread());
+ assert(g_graphics_server);
+ if (g_graphics_server) {
+ g_graphics_server->RebuildLostContext();
+ }
+}
+
+void App::DrawFrame(bool during_resize) {
+ assert(InMainThread());
+
+ // Its possible to receive frames before we're ready to draw.
+ if (!g_graphics_server || !g_graphics_server->renderer()) {
+ return;
+ }
+
+ millisecs_t starttime = GetRealTime();
+
+ // A resize-draw event means that we're drawing due to a window resize.
+ // In this case we ignore regular draw events for a short while
+ // afterwards which makes resizing smoother.
+ // FIXME: should figure out the *correct* way to handle this;
+ // I believe the underlying cause here is some sort of context contention
+ // across threads.
+ if (during_resize) {
+ last_resize_draw_event_time_ = starttime;
+ } else {
+ if (starttime - last_resize_draw_event_time_ < (1000 / 30)) {
+ return;
+ }
+ }
+ g_graphics_server->TryRender();
+ RunRenderUpkeepCycle();
+}
+
+void App::SetScreenResolution(float width, float height) {
+ assert(InMainThread());
+ if (!HeadlessMode()) {
+ g_graphics_server->VideoResize(width, height);
+ }
+}
+
+void App::PushShutdownCompleteCall() {
+ PushCall([this] { ShutdownComplete(); });
+}
+
+void App::ShutdownComplete() {
+ assert(InMainThread());
+ assert(g_platform);
+
+ // Need to call our cleanup stuff that would otherwise get called in main.
+ g_platform->FinalCleanup();
+
+ done_ = true;
+
+ // Kill our own event loop (or tell the OS to kill its).
+ if (UsesEventLoop()) {
+ thread()->Quit();
+ } else {
+ g_platform->QuitApp();
+ }
+}
+
+void App::RunEvents() {
+ // there's probably a better place for this...
+ stress_test_->Update();
+
+ // Give platforms a chance to pump/handle their own events.
+ // FIXME: now that we have app class overrides, platform should really
+ // not be doing event handling. (need to fix rift build).
+ g_platform->RunEvents();
+}
+
+void App::UpdatePauseResume() {
+ if (actually_paused_) {
+ // Unpause if no one wants pause.
+ if (!sys_paused_app_) {
+ OnResume();
+ actually_paused_ = false;
+ }
+ } else {
+ // Pause if anyone wants.
+ if (sys_paused_app_) {
+ OnPause();
+ actually_paused_ = true;
+ }
+ }
+}
+
+void App::OnPause() {
+ assert(InMainThread());
+
+ // Avoid reading gyro values for a short time to avoid hitches when restored.
+ g_graphics->SetGyroEnabled(false);
+
+ // IMPORTANT: Any on-pause related stuff that threads need to do must
+ // must be done from their HandleThreadPause(). If we push runnables to them
+ // they may or may not be called before the thread is actually paused.
+
+ Thread::SetThreadsPaused(true);
+
+ assert(g_networking);
+ g_networking->Pause();
+
+ assert(g_network_reader);
+ if (g_network_reader) {
+ g_network_reader->Pause();
+ }
+
+ if (g_app_globals->telnet_server) {
+ g_app_globals->telnet_server->Pause();
+ }
+
+ g_platform->OnAppPause();
+}
+
+void App::OnResume() {
+ assert(InMainThread());
+ last_app_resume_time_ = GetRealTime();
+ Thread::SetThreadsPaused(false);
+
+ g_platform->OnAppResume();
+ g_networking->Resume();
+ g_network_reader->Resume();
+
+ if (g_app_globals->telnet_server) {
+ g_app_globals->telnet_server->Resume();
+ }
+
+ // Also let the Python layer do what it needs to
+ // (starting/stopping music, etc).
+ g_python->PushObjCall(Python::ObjID::kHandleAppResumeCall);
+ g_game->PushOnAppResumeCall();
+
+ g_graphics->SetGyroEnabled(true);
+
+ // When resuming from a paused state, we may want to
+ // pause whatever game was running when we last were active.
+ // TODO(efro): we should make this smarter so it doesn't happen if
+ // we're in a network game or something that we can't pause;
+ // bringing up the menu doesn't really accomplish anything there.
+ if (g_app_globals->should_pause) {
+ g_app_globals->should_pause = false;
+
+ // If we've been completely backgrounded,
+ // send a menu-press command to the game; this will
+ // bring up a pause menu if we're in the game/etc.
+ g_game->PushMainMenuPressCall(nullptr);
+ }
+}
+
+auto App::GetProductPrice(const std::string& product) -> std::string {
+ std::lock_guard lock(product_prices_mutex_);
+ auto i = product_prices_.find(product);
+ if (i == product_prices_.end()) {
+ return "";
+ } else {
+ return i->second;
+ }
+}
+
+void App::SetProductPrice(const std::string& product,
+ const std::string& price) {
+ std::lock_guard lock(product_prices_mutex_);
+ product_prices_[product] = price;
+}
+
+void App::PauseApp() {
+ assert(InMainThread());
+ Platform::DebugLog("PauseApp@"
+ + std::to_string(Platform::GetCurrentMilliseconds()));
+ assert(!sys_paused_app_);
+ sys_paused_app_ = true;
+ UpdatePauseResume();
+}
+
+void App::ResumeApp() {
+ assert(InMainThread());
+ Platform::DebugLog("ResumeApp@"
+ + std::to_string(Platform::GetCurrentMilliseconds()));
+ assert(sys_paused_app_);
+ sys_paused_app_ = false;
+ UpdatePauseResume();
+}
+
+void App::DidFinishRenderingFrame(FrameDef* frame) {}
+
+void App::PrimeEventPump() {
+ assert(!UsesEventLoop());
+
+ // Pump events manually until a screen gets created.
+ // At that point we use frame-draws to drive our event loop.
+ while (!g_graphics_server->initial_screen_created()) {
+ g_main_thread->RunEventLoop(true);
+ Platform::SleepMS(1);
+ }
+}
+
+#pragma mark Push-Calls
+
+void App::PushShowOnlineScoreUICall(const std::string& show,
+ const std::string& game,
+ const std::string& game_version) {
+ PushCall([show, game, game_version] {
+ assert(InMainThread());
+ g_platform->ShowOnlineScoreUI(show, game, game_version);
+ });
+}
+
+void App::PushNetworkSetupCall(int port, int telnet_port, bool enable_telnet,
+ const std::string& telnet_password) {
+ PushCall([port, telnet_port, enable_telnet, telnet_password] {
+ assert(InMainThread());
+ // Kick these off if they don't exist.
+ // (do we want to support changing ports on existing ones?)
+ if (g_network_reader == nullptr) {
+ new NetworkReader(port);
+ }
+ if (g_app_globals->telnet_server == nullptr && enable_telnet) {
+ new TelnetServer(telnet_port);
+ assert(g_app_globals->telnet_server);
+ if (telnet_password.empty()) {
+ g_app_globals->telnet_server->SetPassword(nullptr);
+ } else {
+ g_app_globals->telnet_server->SetPassword(telnet_password.c_str());
+ }
+ }
+ });
+}
+
+void App::PushPurchaseAckCall(const std::string& purchase,
+ const std::string& order_id) {
+ PushCall(
+ [purchase, order_id] { g_platform->PurchaseAck(purchase, order_id); });
+}
+
+void App::PushGetScoresToBeatCall(const std::string& level,
+ const std::string& config,
+ void* py_callback) {
+ PushCall([level, config, py_callback] {
+ assert(InMainThread());
+ g_platform->GetScoresToBeat(level, config, py_callback);
+ });
+}
+
+void App::PushPurchaseCall(const std::string& item) {
+ PushCall([item] {
+ assert(InMainThread());
+ g_platform->Purchase(item);
+ });
+}
+
+void App::PushRestorePurchasesCall() {
+ PushCall([] {
+ assert(InMainThread());
+ g_platform->RestorePurchases();
+ });
+}
+
+void App::PushOpenURLCall(const std::string& url) {
+ PushCall([url] { g_platform->OpenURL(url); });
+}
+
+void App::PushGetFriendScoresCall(const std::string& game,
+ const std::string& game_version, void* data) {
+ PushCall([game, game_version, data] {
+ g_platform->GetFriendScores(game, game_version, data);
+ });
+}
+
+void App::PushSubmitScoreCall(const std::string& game,
+ const std::string& game_version, int64_t score) {
+ PushCall([game, game_version, score] {
+ g_platform->SubmitScore(game, game_version, score);
+ });
+}
+
+void App::PushAchievementReportCall(const std::string& achievement) {
+ PushCall([achievement] { g_platform->ReportAchievement(achievement); });
+}
+
+void App::PushStringEditCall(const std::string& name, const std::string& value,
+ int max_chars) {
+ PushCall([name, value, max_chars] {
+ static millisecs_t last_edit_time = 0;
+ millisecs_t t = GetRealTime();
+
+ // Ignore if too close together.
+ // (in case second request comes in before first takes effect).
+ if (t - last_edit_time < 1000) {
+ return;
+ }
+ last_edit_time = t;
+ assert(InMainThread());
+ g_platform->EditText(name, value, max_chars);
+ });
+}
+
+void App::PushSetStressTestingCall(bool enable, int player_count) {
+ PushCall([this, enable, player_count] {
+ stress_test_->SetStressTesting(enable, player_count);
+ });
+}
+
+void App::PushResetAchievementsCall() {
+ PushCall([] { g_platform->ResetAchievements(); });
+}
+
+void App::OnBootstrapComplete() {
+ assert(InMainThread());
+ assert(g_input);
+
+ if (!HeadlessMode()) {
+ // On desktop systems we just assume keyboard input exists and add it
+ // immediately.
+ if (g_platform->IsRunningOnDesktop()) {
+ g_input->PushCreateKeyboardInputDevices();
+ }
+
+ // On non-tv, non-desktop, non-vr systems, create a touchscreen input.
+ if (!g_platform->IsRunningOnTV() && !IsVRMode()
+ && !g_platform->IsRunningOnDesktop()) {
+ g_input->CreateTouchInput();
+ }
+ }
+}
+
+void App::PushCursorUpdate(bool vis) {
+ PushCall([vis] {
+ assert(InMainThread());
+ g_platform->SetHardwareCursorVisible(vis);
+ });
+}
+
+} // namespace ballistica
diff --git a/src/ballistica/app/app.h b/src/ballistica/app/app.h
new file mode 100644
index 00000000..30576afc
--- /dev/null
+++ b/src/ballistica/app/app.h
@@ -0,0 +1,146 @@
+// Released under the MIT License. See LICENSE for details.
+
+#ifndef BALLISTICA_APP_APP_H_
+#define BALLISTICA_APP_APP_H_
+
+#include
+#include
+#include
+#include
+
+#include "ballistica/core/module.h"
+
+namespace ballistica {
+
+/// Our high level app interface module.
+/// It runs in the main thread and is what platform wrappers
+/// should primarily interact with.
+class App : public Module {
+ public:
+ explicit App(Thread* thread);
+ ~App() override;
+
+ /// This gets run after the constructor completes.
+ /// Any setup that may trigger a virtual method/etc. should go here.
+ auto PostInit() -> void;
+
+ /// Return whether this class runs its own event loop.
+ /// If true, BallisticaMain() will continuously ask the app for events
+ /// until the app is quit, at which point BallisticaMain() returns.
+ /// If false, BallisticaMain returns immediately and it is assumed
+ /// that the OS handles the app lifecycle and pushes events to the app
+ /// via callbacks/etc.
+ auto UsesEventLoop() const -> bool;
+
+ /// Called for non-event-loop apps to give them an opportunity to
+ /// ensure they are self-sustaining. For instance, an app relying on
+ /// frame-draws for its main thread event processing may need to
+ /// manually pump events until frame rendering begins.
+ virtual auto PrimeEventPump() -> void;
+
+ /// Handle any pending OS events.
+ /// On normal graphical builds this is triggered by RunRenderUpkeepCycle();
+ /// timer intervals for headless builds, etc.
+ /// Should process any pending OS events, etc.
+ virtual auto RunEvents() -> void;
+
+ // These should be called by the window, view-controller, sdl,
+ // or whatever is driving the app. They must be called from the main thread.
+
+ /// Should be called on mobile when the app is backgrounded.
+ /// Pauses threads, closes network sockets, etc.
+ auto PauseApp() -> void;
+
+ auto paused() const -> bool { return actually_paused_; }
+
+ /// Should be called on mobile when the app is foregrounded.
+ /// Spins threads back up, re-opens network sockets, etc.
+ auto ResumeApp() -> void;
+
+ /// The last time the app was resumed (uses GetRealTime() value).
+ auto last_app_resume_time() const -> millisecs_t {
+ return last_app_resume_time_;
+ }
+
+ /// Should be called when the window/screen resolution changes.
+ auto SetScreenResolution(float width, float height) -> void;
+
+ /// Should be called if the platform detects the GL context was lost.
+ auto RebuildLostGLContext() -> void;
+
+ /// Attempt to draw a frame.
+ auto DrawFrame(bool during_resize = false) -> void;
+
+ /// Used on platforms where our main thread event processing is driven by
+ /// frame-draw commands given to us. This should be called after drawing
+ /// a frame in order to bring game state up to date and process OS events.
+ auto RunRenderUpkeepCycle() -> void;
+
+ /// Called by the graphics-server when drawing completes for a frame.
+ virtual auto DidFinishRenderingFrame(FrameDef* frame) -> void;
+
+ /// Return the price of an IAP product as a human-readable string,
+ /// or an empty string if not found.
+ /// FIXME: move this to platform.
+ auto GetProductPrice(const std::string& product) -> std::string;
+ auto SetProductPrice(const std::string& product, const std::string& price)
+ -> void;
+
+ auto done() const -> bool { return done_; }
+
+ /// Whether we're running under ballisticacore_server.py
+ /// (affects some app behavior).
+ auto server_wrapper_managed() const -> bool {
+ return server_wrapper_managed_;
+ }
+
+ virtual auto OnBootstrapComplete() -> void;
+
+ // Deferred calls that can be made from other threads.
+
+ auto PushCursorUpdate(bool vis) -> void;
+ auto PushShowOnlineScoreUICall(const std::string& show,
+ const std::string& game,
+ const std::string& game_version) -> void;
+ auto PushGetFriendScoresCall(const std::string& game,
+ const std::string& game_version, void* data)
+ -> void;
+ auto PushSubmitScoreCall(const std::string& game,
+ const std::string& game_version, int64_t score)
+ -> void;
+ auto PushAchievementReportCall(const std::string& achievement) -> void;
+ auto PushGetScoresToBeatCall(const std::string& level,
+ const std::string& config, void* py_callback)
+ -> void;
+ auto PushOpenURLCall(const std::string& url) -> void;
+ auto PushStringEditCall(const std::string& name, const std::string& value,
+ int max_chars) -> void;
+ auto PushSetStressTestingCall(bool enable, int player_count) -> void;
+ auto PushPurchaseCall(const std::string& item) -> void;
+ auto PushRestorePurchasesCall() -> void;
+ auto PushResetAchievementsCall() -> void;
+ auto PushPurchaseAckCall(const std::string& purchase,
+ const std::string& order_id) -> void;
+ auto PushNetworkSetupCall(int port, int telnet_port, bool enable_telnet,
+ const std::string& telnet_password) -> void;
+ auto PushShutdownCompleteCall() -> void;
+
+ private:
+ auto UpdatePauseResume() -> void;
+ auto OnPause() -> void;
+ auto OnResume() -> void;
+ auto ShutdownComplete() -> void;
+ bool done_{};
+ bool server_wrapper_managed_{};
+ bool sys_paused_app_{};
+ bool actually_paused_{};
+ std::unique_ptr stress_test_;
+ millisecs_t last_resize_draw_event_time_{};
+ millisecs_t last_app_resume_time_{};
+ std::unordered_map product_prices_;
+ std::mutex product_prices_mutex_;
+};
+
+} // namespace ballistica
+
+#endif // BALLISTICA_APP_APP_H_
diff --git a/src/ballistica/app/app_config.cc b/src/ballistica/app/app_config.cc
new file mode 100644
index 00000000..98ac6baf
--- /dev/null
+++ b/src/ballistica/app/app_config.cc
@@ -0,0 +1,285 @@
+// Released under the MIT License. See LICENSE for details.
+
+#include "ballistica/app/app_config.h"
+
+#include "ballistica/ballistica.h"
+#include "ballistica/platform/platform.h"
+#include "ballistica/python/python.h"
+
+namespace ballistica {
+
+void AppConfig::Init() { new AppConfig(); }
+
+auto AppConfig::Entry::FloatValue() const -> float {
+ throw Exception("not a float entry");
+}
+
+auto AppConfig::Entry::OptionalFloatValue() const -> std::optional {
+ throw Exception("not an optional float entry");
+}
+
+auto AppConfig::Entry::StringValue() const -> std::string {
+ throw Exception("not a string entry");
+}
+
+auto AppConfig::Entry::IntValue() const -> int {
+ throw Exception("not an int entry");
+}
+
+auto AppConfig::Entry::BoolValue() const -> bool {
+ throw Exception("not a bool entry");
+}
+
+auto AppConfig::Entry::DefaultFloatValue() const -> float {
+ throw Exception("not a float entry");
+}
+
+auto AppConfig::Entry::DefaultOptionalFloatValue() const
+ -> std::optional {
+ throw Exception("not an optional float entry");
+}
+
+auto AppConfig::Entry::DefaultStringValue() const -> std::string {
+ throw Exception("not a string entry");
+}
+
+auto AppConfig::Entry::DefaultIntValue() const -> int {
+ throw Exception("not an int entry");
+}
+
+auto AppConfig::Entry::DefaultBoolValue() const -> bool {
+ throw Exception("not a bool entry");
+}
+
+class AppConfig::StringEntry : public AppConfig::Entry {
+ public:
+ StringEntry() = default;
+ StringEntry(const char* name, std::string default_value)
+ : Entry(name), default_value_(std::move(default_value)) {}
+ auto GetType() const -> Type override { return Type::kString; }
+ auto Resolve() const -> std::string {
+ return g_python->GetRawConfigValue(name().c_str(), default_value_.c_str());
+ }
+ auto StringValue() const -> std::string override { return Resolve(); }
+ auto DefaultStringValue() const -> std::string override {
+ return default_value_;
+ }
+
+ private:
+ std::string default_value_;
+};
+
+class AppConfig::FloatEntry : public AppConfig::Entry {
+ public:
+ FloatEntry() = default;
+ FloatEntry(const char* name, float default_value)
+ : Entry(name), default_value_(default_value) {}
+ auto GetType() const -> Type override { return Type::kFloat; }
+ auto Resolve() const -> float {
+ return g_python->GetRawConfigValue(name().c_str(), default_value_);
+ }
+ auto FloatValue() const -> float override { return Resolve(); }
+ auto DefaultFloatValue() const -> float override { return default_value_; }
+
+ private:
+ float default_value_{};
+};
+
+class AppConfig::OptionalFloatEntry : public AppConfig::Entry {
+ public:
+ OptionalFloatEntry() = default;
+ OptionalFloatEntry(const char* name, std::optional default_value)
+ : Entry(name), default_value_(default_value) {}
+ auto GetType() const -> Type override { return Type::kOptionalFloat; }
+ auto Resolve() const -> std::optional {
+ return g_python->GetRawConfigValue(name().c_str(), default_value_);
+ }
+ auto OptionalFloatValue() const -> std::optional override {
+ return Resolve();
+ }
+ auto DefaultOptionalFloatValue() const -> std::optional override {
+ return default_value_;
+ }
+
+ private:
+ std::optional default_value_{};
+};
+
+class AppConfig::IntEntry : public AppConfig::Entry {
+ public:
+ IntEntry() = default;
+ IntEntry(const char* name, int default_value)
+ : Entry(name), default_value_(default_value) {}
+ auto GetType() const -> Type override { return Type::kInt; }
+ auto Resolve() const -> int {
+ return g_python->GetRawConfigValue(name().c_str(), default_value_);
+ }
+ auto IntValue() const -> int override { return Resolve(); }
+ auto DefaultIntValue() const -> int override { return default_value_; }
+
+ private:
+ int default_value_{};
+};
+
+class AppConfig::BoolEntry : public AppConfig::Entry {
+ public:
+ BoolEntry() = default;
+ BoolEntry(const char* name, bool default_value)
+ : Entry(name), default_value_(default_value) {}
+ auto GetType() const -> Type override { return Type::kBool; }
+ auto Resolve() const -> bool {
+ return g_python->GetRawConfigValue(name().c_str(), default_value_);
+ }
+ auto BoolValue() const -> bool override { return Resolve(); }
+ auto DefaultBoolValue() const -> bool override { return default_value_; }
+
+ private:
+ bool default_value_{};
+};
+
+AppConfig::AppConfig() {
+ // (We're a singleton).
+ assert(g_app_config == nullptr);
+ g_app_config = this;
+ SetupEntries();
+}
+
+template
+void AppConfig::CompleteMap(const T& entry_map) {
+ for (auto&& i : entry_map) {
+ assert(entries_by_name_.find(i.second.name()) == entries_by_name_.end());
+ assert(i.first < decltype(i.first)::kLast);
+ entries_by_name_[i.second.name()] = &i.second;
+ }
+
+ // Make sure all values have entries.
+#if BA_DEBUG_BUILD
+ int last = static_cast(decltype(entry_map.begin()->first)::kLast); // ew
+ for (int j = 0; j < last; ++j) {
+ auto i2 =
+ entry_map.find(static_castfirst)>(j));
+ if (i2 == entry_map.end()) {
+ throw Exception("Missing appconfig entry " + std::to_string(j));
+ }
+ }
+#endif
+}
+
+void AppConfig::SetupEntries() {
+ // Register all our typed entries.
+ float_entries_[FloatID::kScreenGamma] = FloatEntry("Screen Gamma", 1.0F);
+ float_entries_[FloatID::kScreenPixelScale] =
+ FloatEntry("Screen Pixel Scale", 1.0F);
+ float_entries_[FloatID::kTouchControlsScale] =
+ FloatEntry("Touch Controls Scale", 1.0F);
+ float_entries_[FloatID::kTouchControlsScaleMovement] =
+ FloatEntry("Touch Controls Scale Movement", 1.0F);
+ float_entries_[FloatID::kTouchControlsScaleActions] =
+ FloatEntry("Touch Controls Scale Actions", 1.0F);
+ float_entries_[FloatID::kSoundVolume] = FloatEntry("Sound Volume", 1.0F);
+ float_entries_[FloatID::kMusicVolume] = FloatEntry("Music Volume", 1.0F);
+
+ // Note: keep this synced with the defaults in MainActivity.java.
+ float gvrrts_default = g_platform->IsRunningOnDaydream() ? 1.0F : 0.5F;
+ float_entries_[FloatID::kGoogleVRRenderTargetScale] =
+ FloatEntry("GVR Render Target Scale", gvrrts_default);
+
+ optional_float_entries_[OptionalFloatID::kIdleExitMinutes] =
+ OptionalFloatEntry("Idle Exit Minutes", std::optional());
+
+ string_entries_[StringID::kResolutionAndroid] =
+ StringEntry("Resolution (Android)", "Auto");
+ string_entries_[StringID::kTouchActionControlType] =
+ StringEntry("Touch Action Control Type", "buttons");
+ string_entries_[StringID::kTouchMovementControlType] =
+ StringEntry("Touch Movement Control Type", "swipe");
+ string_entries_[StringID::kGraphicsQuality] =
+ StringEntry("Graphics Quality", "Auto");
+ string_entries_[StringID::kTextureQuality] =
+ StringEntry("Texture Quality", "Auto");
+ string_entries_[StringID::kVerticalSync] =
+ StringEntry("Vertical Sync", "Auto");
+ string_entries_[StringID::kVRHeadRelativeAudio] =
+ StringEntry("VR Head Relative Audio", "Auto");
+ string_entries_[StringID::kMacControllerSubsystem] =
+ StringEntry("Mac Controller Subsystem", "Classic");
+ string_entries_[StringID::kTelnetPassword] =
+ StringEntry("Telnet Password", "changeme");
+
+ int_entries_[IntID::kPort] = IntEntry("Port", kDefaultPort);
+ int_entries_[IntID::kTelnetPort] =
+ IntEntry("Telnet Port", kDefaultTelnetPort);
+
+ bool_entries_[BoolID::kTouchControlsSwipeHidden] =
+ BoolEntry("Touch Controls Swipe Hidden", false);
+ bool_entries_[BoolID::kFullscreen] = BoolEntry("Fullscreen", false);
+ bool_entries_[BoolID::kKickIdlePlayers] =
+ BoolEntry("Kick Idle Players", false);
+
+ // (default to internal keyboard on iircade; not elsewhere)
+ bool_entries_[BoolID::kAlwaysUseInternalKeyboard] =
+ BoolEntry("Always Use Internal Keyboard", g_buildconfig.iircade_build());
+ bool_entries_[BoolID::kShowFPS] = BoolEntry("Show FPS", false);
+ bool_entries_[BoolID::kTVBorder] =
+ BoolEntry("TV Border", g_platform->IsRunningOnTV());
+ bool_entries_[BoolID::kKeyboardP2Enabled] =
+ BoolEntry("Keyboard P2 Enabled", false);
+ bool_entries_[BoolID::kEnablePackageMods] =
+ BoolEntry("Enable Package Mods", false);
+ bool_entries_[BoolID::kChatMuted] = BoolEntry("Chat Muted", false);
+ bool_entries_[BoolID::kEnableRemoteApp] =
+ BoolEntry("Enable Remote App", true);
+ bool_entries_[BoolID::kEnableTelnet] = BoolEntry("Enable Telnet", true);
+ bool_entries_[BoolID::kDisableCameraShake] =
+ BoolEntry("Disable Camera Shake", false);
+ bool_entries_[BoolID::kDisableCameraGyro] =
+ BoolEntry("Disable Camera Gyro", false);
+
+ // Now add everything to our name map and make sure all is kosher.
+ CompleteMap(float_entries_);
+ CompleteMap(int_entries_);
+ CompleteMap(string_entries_);
+ CompleteMap(bool_entries_);
+}
+
+auto AppConfig::Resolve(FloatID id) -> float {
+ auto i = float_entries_.find(id);
+ if (i == float_entries_.end()) {
+ throw Exception("Invalid config entry");
+ }
+ return i->second.Resolve();
+}
+
+auto AppConfig::Resolve(OptionalFloatID id) -> std::optional {
+ auto i = optional_float_entries_.find(id);
+ if (i == optional_float_entries_.end()) {
+ throw Exception("Invalid config entry");
+ }
+ return i->second.Resolve();
+}
+
+auto AppConfig::Resolve(StringID id) -> std::string {
+ auto i = string_entries_.find(id);
+ if (i == string_entries_.end()) {
+ throw Exception("Invalid config entry");
+ }
+ return i->second.Resolve();
+}
+
+auto AppConfig::Resolve(BoolID id) -> bool {
+ auto i = bool_entries_.find(id);
+ if (i == bool_entries_.end()) {
+ throw Exception("Invalid config entry");
+ }
+ return i->second.Resolve();
+}
+
+auto AppConfig::Resolve(IntID id) -> int {
+ auto i = int_entries_.find(id);
+ if (i == int_entries_.end()) {
+ throw Exception("Invalid config entry");
+ }
+ return i->second.Resolve();
+}
+
+} // namespace ballistica
diff --git a/src/ballistica/app/app_config.h b/src/ballistica/app/app_config.h
new file mode 100644
index 00000000..6e3303e7
--- /dev/null
+++ b/src/ballistica/app/app_config.h
@@ -0,0 +1,141 @@
+// Released under the MIT License. See LICENSE for details.
+
+#ifndef BALLISTICA_APP_APP_CONFIG_H_
+#define BALLISTICA_APP_APP_CONFIG_H_
+
+#include