I've spent the past three weeks implementing the new GtsScript syntax, and the performance gains are pretty substantial over the old system! I'm finishing up the syntax, which is just a custom permutation of C#'s own syntax.

Here's an incomplete set of features so far:

Everything is case-insensitive - String comparisons, keywords, function names, etc.

Basic arithmetic, bitwise operations & comparisons (order of operations is currently broken)

Array accessing (Only one dimensional arrays are supported for now)

Switch statement (planned)

For statement

Foreach statement (Works on enumerable classes & arrays)

While statement

If else statement (with an unknown limit of else if's)

Object allocation statement (new Object() { var = value }, new Object(constructorArgs), arrays, etc.)

Local function + Global functions + Export functions

Function overloading

Extensions of classes (e.g. void GiantessAI::MyExtension() { echo("Hello World!"); })

Event functions

Including other script files (#include preprocessor directive)

Variable declarations

Lambda functions

Ternary operators

ScriptObjectReferences (!player, !ai, @"NamedObject" etc.)

$globalVariables

Yield keyword (Used as a stand-in for '[Halt]')

Return keyword

Break & continue keywords

Nested variable declaration & assignment

Includes lefthand AND righthand increment / decrement operators (--/++)

Includes Implicit typename support (e.g. var myVariable = 100f; instead of float myVariable = 100f;)

Accessing & writing to static variables hidden within nested static / non-static types

Function pointers (e.g. var myFunction = echo; myFunction("Hello world");)

Value assignment to scriptrefs (such as !ai and !target)

Here's syntax that I don't believe will be useful for GtsScript (Feel free to express your support for them though):

Null forgiving operator (!ai.m_Stomach?.someVariable)

Null coalescing operator (!target ?? !player) (I'm on the fence about this one)

Custom data structures such as classes and structs

Generic parameters for function calls & declarations

Goto label statement (myLabel: ... goto myLabel;)

C++ #define macros (Would be cool, but would require a bit of an overhaul to the tokenizer)

Some major changes over the old syntax include:

This new scripting syntax will NOT be finnicky about whitespace / newlines - You can have all your code on one line if you really want to.

Block syntax (for, foreach, while & if) do not require curly brackets -- If you do not provide curly brackets, they'll just execute the next statement given. Also, you can just replace the curly brackets with a ';' if you don't want to run any code while looping.

Local variables are no longer prefixed with '%', and are instead just plain names.

The '->' and '::' symbols are being phased out (except for type extensions) - You can still use them if you wish, but it's encouraged that you use a period instead when accessing class variables, static stuff, etc.

Here's a text file with a lot of the syntax listed above if you're curious (Password is 'tJ7NRBdij4' without the apostrophes): https://pastebin.com/BXEPdjwc

If you have any opinions on the current syntax as it's lain out above, please tell me!

The reason I'm spending so much time on the new scripting language is because I believe the future of this project depends on extendibility! Nobody will play if there's nothing new to do or see, and I'm really hoping there's people out there with at least some Unity experience that want to tinker around with the project. That's really what this whole thing is dependent on, heh

Speaking of extendibility, I'm still finishing up the model importer! I still don't think Giantess support is in the cards for the next update unfortunately. Still though - player models & food models are a good start!

Thank you for your support, and I'll see you all next week!!! ❤️