October 2022 update

Hey folks,
Lacewing Blue HTML5 update and new extension to report!

Before I get further, the roles of the Patreon have been revamped. Folks wanting a single extension can now sign onto the smallest role.

Bluewing HTML5

So, the Lacewing Blue HTML5 project is 95% done, and currently on hold. I was buying a code signing certificate from Sectigo, and they're having difficulty due to my type of company. Normally, you'd verify with the government website, but as my company is not limited liability, it doesn't get registered with Companies House.

The UK allows you to start a single employee, unlimited business, with just changing your personal tax filing. But there's no public listing, because it's personal taxes, and Sectigo's policy isn't suited for validating a company like that.

So I'm still going back and forth with them – have been emailing for months now, now I'm phoning – and once it's sorted I can sign my new bluewing-cpp-server programs, which means I can put out the new version.

Right now, the Bluewing HTML5 works pretty well. The Linux server is a bit rude with disconnecting clients, and on the client side, interaction with files and memory access (allowing other exts to read the memory) is inconsistent, but outside of that, all the messages work, channels work, welcome messages, etc.

Note the workarounds for UDP and the like I mentioned in my previous post. Minimal recoding needed for Windows code!

Once the code signing is sorted, I'll release the standalone bluewing-cpp-servers, then I'll sort out the C++ interface so Bluewing Server can load SSL certificates on the fly. Hopefully, it should be sorted by end of this month, and I can resume work.

Function object, now a script engine

This object was in plans all the way back in 2018, but at the time I wasn't familiar with object selection, so I paused it and switched my focus to Bluewing.
Then Uppernate started coming out with Scope Control object, so I waited for him to finish so I could pilfer his code and understand how qualifiers and selection works. He sent the code for it a while ago.

The function object, which had some working names of Intense Functions object and Expression-Function object, has slowly evolved to be a whole script engine, where the main content of the code is Fusion events. I published the general ideas for it for public feedback here.

The extension, now called DarkScript, is extensive, and gives enough functionality to Fusion engine that anyone coming from C#, C++, PHP and other languages will find things easy to implement. It's super powerful.

DarkScript can do:

• Functions called from expressions – including functions called inside those.
  Pass 0-6 parameters of any type.
  Functions are invoked by a very obvious pattern; you can add a parameter by adding a letter to the expression, or change the return type with a single character. CF2.5+ users can use Find All (Ctrl-Shift-F) to find all usages of their function.
• Functions that inherit the calling event's object selection
• Delayed functions – including running by ticks or by timer, cancelling, and keeping them across frame transitions
• Repeating functions (fastloop) – although, unlike Fusion's fastloops, they don't break object selection in calling event
• Foreach functions – they run in-line, not at end of event like Fusion's built-in foreach
  And you can nest foreach, unlike Fusion's built-in foreach, which will deselect the outer loop's foreach object.
  You can run foreachs on qualifiers, and have events respond only if qualifier, or for any object that's in the qualifier as well. Fusion only supports one way.
• Functions implemented in a subapp (or parent app)
• Functions called by reading a text expression (scripting)
• Templated functions, with your specific parameter types, which allow you to check for parameters being correct types, or you can enable template-less functions (to use, just write the code that uses them, no pre-planning)
• Variable-parameter functions (variadic functions)
• Scoped variables (local variables), inherited by sub-functions and deleted when function ends
• Strict types, and weak types; it has a conversion strictness property, which you can look at as automatic conversion between float, int, string
• It has support for recursion (functions calling themselves), and it checks for accidental recursion – you can disable recursion globally
• Throwing "exceptions" during error scenarios, which aborts the function and as many layers as you want, etc.
• Call stack reading – you can find what Fusion event line called this function, and what line called that, etc. It also works well with foreach and delayed functions.You can also get all the passed parameters and their types in one text expression.
• Function redirection – you can have a "SetNameDebug" function with a lot of debug stuff and "SetName" without; and when you want to debug it, redirect SetName to SetNameDebug, in one action. Once debug is done, you can deactivate the SetNameDebug events when you're done, and Fusion's build engine won't include them in built apps.
• Function disabling – disabled functions won't trigger any events and will instantly return their default return value to the caller. When some functionality in your app is not needed, this will let you turn it off without rewiring most of your code. Anything you need more complicated turning off for, there's function redirection!
• Stopping functions midway. This is fairly strong by itself. You can:
• > interrupt foreach loops (not possible in Fusion)
• > interrupt fastloops and keep running On Loop for the current loop index (Fusion's fastloop behaviour)
• > interrupt fastloops and stop running On Loop for the current loop index (not possible in Fusion)
• > interrupt On Function events for a non-loop function (effectively a Break)

I should also have a help file done for it as well. The issue with a super powerful object like this is that I'll need to hash out the finer details like operator precedence for people familiar with modular programming, and hash it out more for Fusion beginners.
Honestly, beginners will gain a lot from using this object; it's halfway to using non-Fusion programming languages, but still plenty simple.

Later, I may evolve the run-function-from-text to a whole script parser; Turing-complete, so multiple lines allowing multiple functions, if/else, loops, etc. The functions in it will still run with Fusion events, of course.

I've designed DarkScript to be compatible with Fusion 2.0, and I'll port it to all platforms I can; which won't be simple, because it interacts with a lot of Fusion internal code, but fortunately, all the Fusion runtimes are based on the Windows code for consistency, so while variables are moved around, they all operate the same way.

If anyone wants to be involved in the testing, let me know!
And as always, thanks for your ongoing support!
~Phi