Version bump to 0.89.0-alpha!

* Update todo, changelog and contributors.

* Document basics of touch.nvgt.

* Update website features list to mention Android!

* Properly call java TTS finalizer.

* Remove duplicate form control announcement on window focus in virtual_dialogs.nvgt.

* Add a new speak_to_file test, function is broken right now.

* Astyle a couple of interact tests.

Author: samtupy

doc/src/appendix/!To do.md

@@ -50,6 +50,12 @@ NVGT does have a library object similar to BGT which allows one to call into mos
 ### force_key methods
 A rare request is that we add bgt's force_key_down/force_key_up methods and friends to the engine, this is a good idea and we will do so. We are very close now with the new simulate_key_down and simulate_key_up functions, the only difference between these and the force methods is that the player still controls the keyboard E. simulate arrow down then real arrow down followed by real arrow up means arrow released, where as with bgt force methods the arrow key would stay forced down until manually reset.
 
+### IOS
+NVGT now has Android support, leaving one more target platform which is IOS!
+
+### Android touchups
+Android support is getting pretty stable, but there are a couple of areas that still need improvement. We still need to finish asset management, and so until that is done you must embed a pack file into your app for sounds to be played. More improvements to tts_voice will follow as well, you can only use the default voice at this time and parameter ranges may need adjustment. The gesture support though functional is still very young, and needs more testing and expansion.
+
 
 ## Code improvements
 This section specifically lists tasks we wish to perform related to NVGT's c++ code, repository, or other backend. Other than performance, items here should rarely effect application functionality but are instead designed to allow developers to engage in a bit less painful wincing when reading or contributing to NVGT's code.

doc/src/appendix/Changelog.md

@@ -1,7 +1,9 @@
 # Changelog
 This document lists all major changes that have taken place in NVGT since we started keeping track.
 
-## New in 0.89.0-alpha (unreleased):
+## New in 0.89.0-alpha (10/09/2024):
+* NVGT has now switched to using InnoSetup for it's installer, adding several new options such as adding to path, start menu icons etc.
+* Added the script_function::get_namespace() method as well as script_function::retrieve() which takes a native function handle derived from a funcdef.
 * Including pack files via the `#include` directive has been removed in favor of being able to include scripts of any extension, you should use the `#pragma embed` directive to do this instead.
 * NVGT games now run on intel as well as arm mac computers!
 * The calendar object is now registered as a reference type with Angelscript meaning it now supports handles, for BGT backwards compatibility. The other datetime classes are still value types.
@@ -12,7 +14,7 @@ This document lists all major changes that have taken place in NVGT since we sta
 * ini.nvgt include is now free of bgt_compat! Added quick test for it.
 * Fixed a bug in instance.nvgt include regarding automatic mutex name generation.
 * The compiler now includes a status window that continues getting updated with messages reporting what is currently happening during compilation.
-* Adds refresh_window() function.
+* Adds refresh_window() function, allowing manual pulling for windows events encase you want to use your own sleeping methods.
 * Adds input_forms.nvgt include with functions to quickly retrieve information using an audio form, test/example in test/interact/test_input_forms.nvgt.
 * Introduce new menu system based on audio form, in menu.nvgt. As a result, the old dynamic menu has been renamed to bgt_dynamic_menu.nvgt to make it clear what one is legacy.
 * Registered some new vector functions such as cross, length2, distance and distance2 etc.
@@ -29,7 +31,7 @@ This document lists all major changes that have taken place in NVGT since we sta
 * Add virtual_dialogs.nvgt include.
 * Add datastream.sync_rw_cursors property (true by default).
 * tts_dump_config and tts_load_config in speech.nvgt include can now save screen reader usage setting.
-* ADDED ANDROID PLATFORM SUPPORT, NVGT RUNS ON MOBILE! This includes gesture detection (touch.nvgt include or query_touch_device function), screen reader speech through Android's accessibility event API, and android TextToSpeech engine support through  the tts_voice class! The support is still young and there are many improvements still to be made (only the default tts voice can be used right now for example), but even running small nvgt scripts from source is possible at this point with NVGT's Android runner application, and one-click APK bundling is possible!
+* ADDED ANDROID PLATFORM SUPPORT, NVGT RUNS ON MOBILE! This includes gesture detection (touch.nvgt include or query_touch_device function), screen reader speech through Android's accessibility event API, and android TextToSpeech engine support through  the tts_voice class! The support is still young and there are many improvements still to be made (only the default tts voice can be used right now and the only way to embed sounds is by using the `#pragma embed pack.dat` feature for example), but even running small nvgt scripts from source is possible at this point with NVGT's Android runner application, and one-click APK bundling is possible!
 * NVGT now has a bundling facility! It can create .apk packages for android (assuming the needed android tools are available), it can create MacOS app bundles on all platforms though only a .dmg on Mac (.app.zip on other platforms), and it can copy Windows/Linux libraries into place as well as bundle your asset files like sounds, readme and changelog all to create a fully distributable package in one click! It can even run custom prebuild and postbuild shell commands in case the bundling facility isn't quite doing enough for your needs. More information is in the compiling for distribution document. This means as an aside that NVGT's compiler application is significantly larger, as it must include the MacOS and Linux libraries on windows, the Windows and Linux libraries on Mac etc for the purposes of creating a fully functional app bundle no matter what platform it is compiled on.
 * The compile script submenu has changed, it now contains options to compile for all platforms you have stubs for!
 * Trying to embed a pack that doesn't exist no longer makes NVGTW.exe silently exit.

doc/src/appendix/Contributors.md

@@ -6,9 +6,11 @@ This file contains the names of anyone who has helped contribute to the NVGT eng
 * [Rory Michie](https://github.com/RoryMichie): Has done much work on the NVGT user manual.
 * [Tyler Spivey](https://github.com/tspivey): rewrote the executable loader on Windows to work with packers such as UPX, helped make documentation look more presentable.
 * [Harry Min Khant](https://github.com/harrymkt): Wrote several documentation articles particularly in the references section, improvements to nvgt includes.
-* [Ethin Probst](https://github.com/ethindp): major optimizations to parts of the code, rewrote sound effect parsing, libspeechd and Android TTS engine integration, atomics, docs.
+* [Ethin Probst](https://github.com/ethindp): major optimizations to parts of the code, rewrote sound effect parsing, libspeechd and Android TTS engine integration, atomics, innosetup installer, docs.
+* [Ivan Soto](https://github.com/ivansoto0): Several major includes such as input_forms.nvgt, settings.nvgt, touch.nvgt etc as well as various improvements to smaller ones such as bgt_compat, input_forms and others.
 * [Valiant8086](https://github.com/valiant8086): Documentation on game distribution.
 * [Gruia Chiscop](https://github.com/GruiaChiscop): AVSpeech implementation.
+* [Hamza Ahmad](https://github.com/literary-programmer): Contributed virtual_dialogs.nvgt include, Improvements to form.nvgt.
 * [Abdullah Tepeli](https://github.com/colonel-official): Delete-by-word support for the audio_form include.
 * Beta testers including but not limited to Patrick Wilson, Quin G, Steven D, Lucas Brown, Liam Erven, DJWolfy, Lukáš Hosnedl, Heaven Games, Pragma and Day Garwood, without the valuable feedback and suggestions provided by these people NVGT would have never gotten this far.
 * Last but not least, nothing is worth maintaining or developing without users, and so thank you to everyone who uses this engine and gives it their feedback, time and attention!

doc/src/references/include/touch gesture management (touch.nvgt)/.MDRoot

@@ -0,0 +1 @@
+This file indicates that this subdirectory should be considered as a root page in the markdown version of the documentation, see the docgen notes for more details.

doc/src/references/include/touch gesture management (touch.nvgt)/Classes/touch_gesture_manager/!touch_gesture_manager.nvgt

@@ -0,0 +1,41 @@
+/**
+	Detects and then converts raw touch screen finger data into gesture events which can be detected by your application or even converted to keyboard input.
+	touch_gesture_manager();
+	## Remarks:
+		This is the highest level interface NVGT offers to accessing touch screens. It looks at what fingers are touching the screen and where, and by monitoring that data over time, derives gestures such as swipes and taps from that data before passing them along to whatever interface you register to receive them.
+		An interface is included by default (see the touch_keyboard_interface class), which convertes these events into simulated keyboard input for you so that adding touch support to your game becomes as simple as mapping gesture names to keycode lists.
+		The basic usage of this class is to create an instatnce of it somewhere, before attaching any number of touch_interface instances to the manager and finally calling manager.monitor() within the loops of your programs to receive gesture events.
+*/
+
+// Example:
+#include"touch.nvgt"
+#include"speech.nvgt"
+touch_jesture_manager touch;
+void main() {
+	show_window("touch screen test");
+	//attach multiple keys to a single jesture.
+	int[] t = {KEY_TAB, KEY_LSHIFT};
+	touch_keyboard_interface testsim(touch, {{"swipe_left1f", KEY_LEFT}, {"swipe_right1f", KEY_RIGHT}, {"swipe_up1f", KEY_UP}, {"swipe_down1f", KEY_DOWN}, {"double_tap1f", KEY_RETURN}, {"tripple_tap1f", t}, {"swipe_left2f", KEY_ESCAPE}, {"swipe_right2f", KEY_Q}, {"double_tap2f", KEY_SPACE}});
+	touch.add_touch_interface(testsim);
+	dictionary@d = {{"double_tap1f", KEY_X}, {"double_tap2f", KEY_Z}};
+	// Demonstrate registering an interface for only a portion of the screen.
+	touch.add_touch_interface(touch_keyboard_interface(touch, d, 0.5, 1.0, 0.5, 1.0));
+	while (!key_pressed(KEY_ESCAPE) and !key_pressed(KEY_AC_BACK)) {
+		wait(5);
+		touch.monitor();
+		if (key_pressed(KEY_LEFT)) speak("left");
+		if (key_pressed(KEY_RIGHT)) speak("right");
+		if (key_pressed(KEY_DOWN)) speak("down");
+		if (key_pressed(KEY_UP)) speak("up");
+		if (key_pressed(KEY_TAB)) {
+			speak("tripple tap");
+			if (key_down(KEY_LSHIFT) or key_down(KEY_RSHIFT)) speak("you are holding down shift", false);
+		}
+		if (key_pressed(KEY_SPACE)) speak("double tap 2 fingers");
+		if (key_pressed(KEY_ESCAPE)) exit();
+		if (key_pressed(KEY_Q)) speak("swipe right 2 fingers");
+		if (key_pressed(KEY_RETURN)) speak("you just double tapped the screen!", false);
+		if (key_pressed(KEY_X)) speak("You just double tapped another part of the screen!");
+		if (key_pressed(KEY_Z)) speak("You just double tapped with 2 fingers on another part of the screen!");
+	}
+}

doc/src/references/include/touch gesture management (touch.nvgt)/Classes/touch_gesture_manager/Methods/is_available.nvgt

@@ -0,0 +1,15 @@
+/**
+	Determine whether any touch devices are available to receive events from.
+	bool is_available();
+	## Returns:
+		bool: true if at least one touch device is available on the system, false otherwise.
+	## Remarks:
+		It is worth noting that due to circumstances outside our control, sometimes touch devices don't appear in the list until after you have touched them at least once. Therefor you should not use this method at program startup to determine with finality that no touch device is available, but could instead use it during program lifetime to monitor for whether touch support appears or disappears.
+*/
+
+// Example:
+touch_jesture_manager touch;
+void main() {
+	wait(1000); // Give the user some time to touch the screen to make sure it appears.
+	if (!touch.is_available()) alert("warning", "This system does not appear to support touch screen devices");
+}

doc/src/references/include/touch gesture management (touch.nvgt)/Classes/touch_gesture_manager/Methods/monitor.md

@@ -0,0 +1,7 @@
+# monitor
+Check for the latest touch events.
+
+`void monitor();`
+
+## Remarks:
+This function must be called in all of your game's loops in order for the system to work properly. Not doing this will lead to undefined behavior.

doc/src/references/include/touch gesture management (touch.nvgt)/Classes/touch_gesture_manager/Methods/set_interfaces.md

@@ -0,0 +1,15 @@
+# set_interfaces
+Sets the list of interfaces that will receive touch events.
+
+`bool set_touch_interfaces(touch_interface@[]@ interfaces, bool append = false);`
+
+## Arguments:
+* `touch_interface@[]@ interfaces`: A list of interfaces that will receive touch events.
+* `bool append = false`: Determines whether to append to the list of existing interfaces Vs. replacing it.
+
+## Returns:
+
+bool: True if a change was made to the interface list, false otherwise.
+
+## Remarks:
+You can pass multiple interfaces to a gesture manager because different interfaces can receive different events for various parts of the screen. An interface can simply return false in it's `is_bounds` method at any time to pass the gesture event to the next handler in the chain. Gesture interfaces are evaluated from newest to oldest.

doc/src/references/include/touch gesture management (touch.nvgt)/Classes/touch_keyboard_interface/!touch_keyboard_interface.md

@@ -0,0 +1,20 @@
+# touch_keyboard_interface
+Convert gesture events to simulated keyboard input.
+
+`touch_keyboard_interface(touch_jesture_manager@parent, dictionary@map, float minx = TOUCH_UNCOORDINATED, float maxx = TOUCH_UNCOORDINATED, float miny = TOUCH_UNCOORDINATED, float maxy = TOUCH_UNCOORDINATED);`
+
+## Arguments:
+* touch_gesture_manager@ parent: A handle to the manager you intend to add this interface to, parameter subject for removal in future.
+* dictionary@ map: A mapping of gestures to keycode lists (see remarks).
+* float minx, maxx, miny, maxy = TOUCH_UNCOORDINATED: The bounds of this interface, default for entire screen or custom.
+
+## Remarks:
+This interface works by receiving a mapping of gesture names or IDs to lists of keycodes that should be simulated.
+
+The basic format of gesture IDs consists of a gesture name followed by a number of fingers and the letter f. For example, to detect a 2 finger swipe right gesture, you would use the key "swipe_right2f" in the mapping dictionary. The available gesture names are as follows:
+* swipe_left
+* swipe_right
+* swipe_up
+* swipe_down
+* double_tap
+* tripple_tap

jni/src/main/java/com/samtupy/nvgt/TTS.java

@@ -159,9 +159,10 @@ public void setVolume(float volume) {
 	}
 
 	@Override
-	public void finalize() {
+	protected void finalize() throws Throwable {
 		if (isActive())
 			tts.shutdown();
+		super.finalize();
 	}
 
 	public List<String> getVoices() {

release/include/virtual_dialogs.nvgt

@@ -91,8 +91,8 @@ class virtual_dialogs {
 		if (window_status == this.was_window_active)
 			return;
 
-		if (window_status)
-			this.form.focus(this.form.get_current_focus());
+		// if (window_status)
+		//	 this.form.focus(this.form.get_current_focus());
 
 		this.was_window_active = window_status;
 	}

test/interact/keys_pressed.nvgt

@@ -18,9 +18,8 @@ void main() {
 
 		if (keys.length() > 0) {
 			for (uint k = 0; k < keys.length(); k++) {
-				if (keys.find(KEY_ESCAPE) > -1) {
+				if (keys.find(KEY_ESCAPE) > -1)
 					escape_was_pressed = true;
-				}
 				speak(keys[k], false);
 			}
 		}

test/interact/test_input_forms.nvgt

@@ -1,3 +1,7 @@
+// NonVisual Gaming Toolkit (NVGT)
+// Copyright (C) 2022-2024 Sam Tupy
+// License: zlib (see license.md in the root of the NVGT distribution)
+
 #include"dget.nvgt"
 #include"input_forms.nvgt"
 void main() {
@@ -12,9 +16,9 @@ void main() {
 	input.add_checkbox_field("agreement", "I agree to the rules", false, true, true);
 	input.description = "You will be asked the following questions to guide you in your profile setup";
 	dictionary@result = input.run();
-	if(input.user_canceled) {
+	if (input.user_canceled) {
 		alert("error", "The user canceled profile setup");
 		exit();
 	}
-	alert("profile", "The user is named "+dgets(result, "first_name")+" "+dgets(result, "last_name")+". They are from "+dgets(result, "location", "unknown")+" and are "+dgetn(result, "age", 1)+" years old. Their favorite operating system is "+dgets(result, "platform", "system7"));
+	alert("profile", "The user is named " + dgets(result, "first_name") + " " + dgets(result, "last_name") + ". They are from " + dgets(result, "location", "unknown") + " and are " + dgetn(result, "age", 1) + " years old. Their favorite operating system is " + dgets(result, "platform", "system7"));
 }

test/quick/speak_to_file2.nvgt

@@ -0,0 +1,9 @@
+// NonVisual Gaming Toolkit (NVGT)
+// Copyright (C) 2022-2024 Sam Tupy
+// License: zlib (see license.md in the root of the NVGT distribution)
+
+void main() {
+	tts_voice v;
+	v.speak_to_file(cwdir() + "/speak_to_file2_1.wav", "this is test1");
+	v.speak_to_file("speak_to_file2_2.wav", "this is test2");
+}

version

@@ -1 +1 @@
-0.88.0-beta
+0.89.0-alpha

web/src/index.md

@@ -44,7 +44,8 @@ The NVGT engine advertises the following qualities and features:
 * script debugger; Find issues in your code like never before with standard debugging techniques like breakpoints, single instruction stepping, realtime expression evaluation and more.
 * ever expanding plugin system; Be free of the Angelscript sandbox and code whatever extensions to your game you want in c++ or another language.
 * subscripting; Add downloadable levels to your games or make them more dynamic with NVGT's ability to execute Angelscript code from within Angelscript code like the javascript or python eval function.
-* cross platform; Release your games for windows, as well as macOS and Linux!
+* cross platform; Distribute your games to a wide audience by easily compiling it for Windows, Mac OS, Linux and more.
+* games on the go; Let your players take your games with them on their Android devices, with IOS planned for the future. Mobile support still young.
 * 64-bit; Your old BGT projects can now utilize all system resources.
 * 3d pathfinder; Find intelligent paths in 3 dimensions with possibly more in the future.
 * builtin JSON support; Connect your projects to online services using one of the most widely recognized API data exchange languages.