July-August Progress Report

Hello everyone! It's been two months since the last progress report, so let's hop right in and see what progress has been made! Note that the updates listed here have not been released yet.

Progress from July 2 - August 31

• Updated Devil's Emergence to use the new "item collection hitbox" collider type introduced in last month's progress report.
• Added a fullscreen toggle key, mapped to F4 by default.
• Fixed a glaring continuity error in hard mode's description ("spell card" → "barrage").
• Replaced the image loading library (the old one had stopped compiling).

That's almost nothing!! Granted, I have a good excuse. Okay, a mediocre excuse. I spent most of July frantically trying to polish my entry for the fourth Touhou Pride Game Jam, which I eventually had to give up on. Fortunately, this meant that I could finally start working on Devil's Emergence once more!

... but for having a whole month to work, that seems like a rather paltry changelog. Did I give in to laziness? Of course not. ... Erm, not entirely... okay, maybe a little, but in my defense, sleep schedules are another one of my myriad nemeses. But I have been hard at work on this game! Just not directly. Specifically, I've been tackling something that's been preventing me from creating the game's stages.

In the spirit of overengineering everything  trying to make the game's executable unreasonably small learning and having fun, I'm using a scripting language to direct enemy movement in each of stages. I wanted to make writing stages as easy on myself as possible, so I set off to crates.io in search of a comfortable language using the following criteria:

• Must be embeddable (if I can't actually use it from the engine, what's the point?)
• Must be usable as a general purpose language (I wanted to bundle whatever language I chose with Devil's Emergence's engine, Triplicata)
• Must have support for coroutines/async functions (allows code to run concurrently, so I can have multiple enemies act at the same time)
• Curly brace languages are preferred (I'm just more comfortable with them)
• No JavaScript allowed
• Would ideally have sum types (ie. tagged unions, so that I can say things like "a Result is either Ok, which has a number, or an Error, which has a message")
• Must be statically typed (A given variable has a type describing what it is, such as "number" or "text". Dynamic typing is a scam perpetuated by Big Error™ to sell more runtime errors)
  

Unfortunately, I didn't come across any languages that met these requirements. To this day, the only language I know of that comes close (aside from the one I chose) is Mun, but I don't think they have any sort of coroutines yet. I tried using Lua, but I really couldn't shake the discomfort I felt about its dynamic type system. So instead of giving up and writing the stages in-engine as a sane person might do, I rolled up my sleeves and started writing my own scripting language, Laria.

Laria is heavily based on the design of the Rust programming language, but it aims to be a bit simpler to read and write. It's still a very early work in progress, but as of March 2022, I was able to use it to implement Meiling's stage for the one-stage demo. However, due to its early state, I had to work around several limitations, such as the lack of structs and the lack of coroutines, leading to an abundance of messy code. Because of this, I resolved to try and get Laria into a more usable state before returning to work on Devil's Emergence. Here's what I've managed to do so far:

• Renamed a fundamental type to make code easier to read (! became never; this is the empty type, which has no values. I might end up renaming it again later)
• Made it easier to add new keywords to the language
• Polished several corners of the languages
• Added references, which allows you to pass around a reference-counted pointer to an object instead of the object itself. This allows functions to modify their inputs and might enable performance improvements for large objects.
• Fixed a bug where signed and unsigned numbers were considered the same type
• Allowed more types to be checked for equality (including strings of text)
• Removed the ability to turn off the static type system
• Fixed an infinite loop when reading a number
• Added compound assignment operators (for example, x += y, which sets x to the result of x + y)
• Implemented structs (groups of values), including:
  • The ability to access individual values in the struct
  • The ability to implement associated (static) functions on them, which don't require an instance of the struct
    • These are essentially normal functions that are grouped with the struct
  • The ability to implement methods, which do require an instance of the struct
    • These have a special syntax, foo.do_something() (where foo is an instance of a struct and do_something is the method)
• Simplified some code using a new feature in Rust
• Changed how bytecode generation works, which opens the door to simplify the codebase in the near future
• Changed how some bytecode instructions work, resulting in a moderate performance improvement
• Significantly improved the output of the decompiler (a debugging tool used to check the generated bytecode)

With all this done, I'm more or less ready to resume work on Devil's Emergence! There's one more feature I'd like to implement at some point before the game goes gold (separating code into different files), but I think I can live with the current situation for now. It's definitely an improvement over what I had to work with in March!

Before:

// Very long, very repetitive. Just in case you missed it, this acts on a `bullet_handle`.
// This is fairly tame, but can get much worse for more complex attacks.
bullet_handle_with_aim_angle(bullet_handle, -left_angle);
bullet_handle_fire(bullet_handle);
bullet_handle_with_aim_angle(bullet_handle, -right_angle);
bullet_handle_fire(bullet_handle);

After:

// Short!
bullet_handle.with_aim_angle(-left_angle).fire();
bullet_handle.with_aim_angle(-right_angle).fire();

Given that and the fact that I'm back at university now, I'm hoping that work on the game will ramp up shortly! Please watch warmly until it is ready~

Until then, thank you for reading! See you next time!