Fireball Rain

The big addition is the Fireball Rain, which is a more classic bullet hell platformer move, inspired by Marisa’s Energy Bombardment in Touhou Luna Nights. Except instead of spawn a pillar of light, each fireball spawns a fire AOE that stays on the ground/wall it hit for a while.

The move is more regular that the previous homing fireballs, so it encourages the player to learn the pattern and safe spots to get there quickly rather than adapting to each shot very fast. That said, I find it a bit too regular now, maybe I’ll add some randomized offset to force the player to adjust their position a little.

New moves and animations

Player character can now Air dodge, and existing moves all got a dedicated animation. The boss is also animated when casting a spell and getting hurt.

Here is a video to recap new animations, all while trying to dodge the new Fireball Rain.

And the player character death animation:

Simpler level

I removed all the platforms and re-added two so the player character can still jump high enough to reach the boss who is shooting Fireball Rain from very high above.

First BGM

I was tired of testing in a silent room so I added the first BGM, some free asset Last Boss 01 (ラストボス01), by MaouDamashii under CC BY 4.0.

Changelog

Gameplay

• Player character: shorter ground Slide, add Air Slide
• Player character: Melee attack: allow changing direction when chaining attacks
• Boss: skill: replaced single fireball shot with new Fireball rain (projectile accelerates)
• Projectile: Fireball damages player character but moves through it
• Projectile: Fireball generates fire AOE for a short time after hitting ground or wall

Level

• Simplify level with only 2 platforms

Visual

• Player character: Slide, Hurt, Death, Jump, Fall, Crouch, DashAttack, AirSlide + transitions
• Boss: new Idle, Hurt, SpellForward, SpellUpward animations and transitions between them (using AnimationTree)
• Projectile: Fireball warm up FX, Fireball Rain round fireball sprite, Fireball explosion on hit

Audio

• BGM: Boss theme phase 1 extracted from free BGM “Last Boss ラストボス01” by MaouDamashii

Godot threads opened

Issues

• Animation SpriteFrames panel: FPS field is too small, long numbers (e.g. using decimal fraction) are cropped
• Animation Tree: State machine nodes view does not refresh on Undo/Redo creating new node (until next click)
• Code editor: hover debug empty String / StringName variable shows nothing

Proposals

• Animation SpriteFrames: add keyboard shortcut to rename animation (default F2)

Visual revamp

Big revamp! I finally switched the whole game to full custom graphics. I first worked with a resolution similar to the proto character asset (see previous post 3 months ago), then tried smaller sizes to draw faster. Below, some character scale research:

From left to right:

1. Tiny: fast to draw, but hard to show details like scars, sword erosion or body limb animations. Instead, it relies a lot on translations and FX.
2. Chibi: I don’t like how this one turned out, it was supposed to look like Momodora I-III but got ugly and now it reminds me of the horned idol statue in Indiana Jones and the Fate of Atlantis.
3. Small: It’s a nice compromise, I’d go with this one if I had more time.
4. Normal: The original sprite I’ve drawn, would take more time to animate, but I’d go with this one if I hired a pixel artist.
5. Tall: A funny experiment with the “thin body - long legs” pixel art style found in indie games like Superbrothers: Sword & Sworcery EP.

In the end I went for the Tiny art style, using references such as Time for Lunch (PICO-8 game) and Necrosphere.

Then I converted the other elements (boss, projectiles and FX) and added new elements (background, HUD) to fit in this style. The ice spike FX is very big so it was quite easy to convert (although the warm up animation needed some tuning), while I had to redo the fireball animation from scratch (and also recolored them).

Rebuilt boss level

I also rebuilt the whole level to something symmetrical with a few platforms. Kudos to the Lospec Pixel School which helped me tune the color palette! Using Aseprite, it’s quite fast with the Indexed Color Mode + Edit Color button.

First SFX

Finally, I added fireball spawn SFX. Instead of the usual sfxr (via jsfxr), I tried to use audio synthesizer Vital. I had already tested its free little brother Helm but was limited by the lack of wave modulation and wanted more features… Well, I got them, there are too many for me to understand now, so I just used a little bit of Vital’s features.

The biggest issue was Reaper + Vital plugin crashing on Linux which forced me to manually record the SFX from Vital standalone. I may eventually switch back to jsfxr or Helm because of this.

Since I was busy working on new graphics and plugging the HUD behavior, there is no new gameplay features in this update. I will work on improved boss patterns and main character moves next time.

Changelog

Level

• Rebuilt full level as a small, one-screen room with 5 platforms

UI

• HUD: plug main character & boss life gauges to their remaining HP

Visual

• Main character sprites: Idle (1 frame), Run cycle (4 frames), Attack (7 frames)
• Boss sprites (Tiny art style): Idle (1 frame)
• Fireball sprites (Tiny art style): Move (4 frames)
• Ice spikes (Tiny art style): Warm up (13 frames), Appear (6 frames), Active (4 frames), Disappear (3 frames)
• HUD: Main character life gauge (discrete cells), Boss life gauge (continuous gauge)

Audio

• SFX: Fireball spawn

Godot threads opened

For the first time, I’ll also post the list of Godot issues and proposals I opened since the last devlog. It’s pretty long because they span over 3 months, hopefully next list will be shorter.

I realised I spent a considerable amount of time debugging, isolating MWE (Minimum Working Examples) and posting them on GitHub, so tracking issues I have opened is a good way to motivate me: I’ve not been doing nothing that day!

For now it’s my main way to contribute to Godot, but I hope I’ll be able to send pull requests to contribute to engine code in the near future.

Issues

• #87254 Sometimes after saving scene, both instantiated scene and original scene node numerical properties become null, shown as 0 in inspector
• #88067 Erratic behavior when CharacterBody2D is inside tilemap (or group of small colliders) with collision shapes, is_on_floor returns false
• #88115 AnimatedSprite2D: Empty Animation name error on ready/instantiation propagates to inherited scenes
• #88303 Scene editor: Mouse middle click doesn’t always close scene tab
• #88400 Export: Save a File: Godot doesn’t update Quick Access folders if changed after opening editor, causing offset display or even out-of-bounds error
• #88408 Linux: Scene editor: Control: Releasing mouse primary button after Alt+drag for centered Control resize will not end resize operation
• #89543 Linux X11 OpenGL/Vulkan - After changing window size, window content doesn’t immediately refresh to match new size
• #89621 Linux - Portable installation of Blender not recognized for Blender import with error: Blender Path does not contain a Blender installation
• #89785 Autocomplete Input.get_axis StringName parameter suddenly switches from action name to symbols while typing
• #89910 When Import ETC2 ASTC option is disabled, Remote Debug on Android is still allowed but fails Export with empty error message in Project Run popup
• #89923 TileSet: Leftover patterns after TileSet atlas source removal causes output error spam “No TileSet atlas source with id N”
• #90021 Instances of inherited scenes are not updated when changing exported var value on base scene if scene containing them was already open, until editor restart
• #90264 Literal String as int (or float) cast causes Parser Error “Cannot cast a value of type “String” as “int”.” although it works with variable String
• #90537 Repeated toggle fullscreen increases window size by the window decorations size each time we leave fullscreen

Discussions

• #8948 Add a button/option to build and run directly on plugged Android device
• #8958 Confused by CanvasLayer property follow_viewport_enable / follow_viewport_enabled, sounded like follow_camera_enabled but it’s the opposite
• #9096 Ctrl+Click to go to definition of method name defined as StringName &”my_method”
• #9396 Add Control child class/node that fits own size to children (maximum bounding box) to be used as intermediate parent under HBoxContainer/VBoxContainer
• #9400 Tilemap tile full rect collision shapes are considered independent, causing Raycast to hit individual tiles inside tilemap
• #9461 Add exception methods to CharacterBody2D to ignore specific collision objects during move_and_slide

Proposals

• #8854 Hover long editor bell notification text (cut with ellipsis) to see full message and/or allow copying full text with right-click
• #8947 Export to Android: improve Invalid package name error message by showing Project name converted to $genname explicitly
• #9095 F1 Search Help reused to navigate code: show custom symbols without doc + go to source code of custom class/method (from F1 popup or documentation)
• #9102 Debug: Code editor: command to debug content of Object variable under cursor/caret in remote Inspector
• #9105 Allow setting Mouse Default Cursor Shape differently when Button is disabled
• #9107 Add contextual menu to convert binary resource .res to serialized text .tres (and vice-versa)
• #9129 Windows export: Indicate reason for “Invalid file version” and “Invalid product version”
• #9146 Project settings: add Debug > GDScript > Warnings parameter to include/exclude specific add-ons
• #9307 Add an option to make Wide / Full Rect control anchor presets take Window Stretch Scale project setting into account
• #9387 Animation SpriteFrames: do not lose focus when deleting frame

Gameplay

• Level: added 1 boss: the sorcerer
• Enemy AI: the sorcerer continuously shoots fireballs in the same direction

Visual

• Character sprite: Sorcerer 2-frame Idle, 2-frame Hurt, 2-frame Die, 4-frame SpellForward (not used yet)
• Projectile sprite: Fireball 4-frame Move

Assets used:

• Warrior-Free Animation set V1.3 by Clembod
• Free Pixel Art Grasslands Tileset by Will Tice / unTied Games

My latest addition is moving enemies. They currently move at half the speed of the player snake, but they still make the game significantly harder: new enemies regularly spawn and keep coming at you, and touching them causes instant game over. You can trick them by repeatedly warping to the other side of the arena, but I may eventually fix this by making enemies aware of edge warping to find the real shortest distance to player snake.

One problem is inherent to snake: you cannot control the tail, so it is very vulnerable, even more as your snake gets longer. I may mitigate this by reducing penalty when a body part other than the head hits an enemy.

Dev status

Total work time: 27h

Gameplay

• Player character: move like a classic snake (hold diagonal for laddering)
• Pick-up: eat to extend snake length by 1 and increase Score

Visual

• Dark background
• All sprites are colored squares

HUD

• Display score in top-left corner

Known issues

• Pick-up and enemies can spawn anywhere, including near and inside the player snake without warning!

Gameplay

• Actions: Slide, airborne Attack
• Flow: better action constraints (cannot move while attacking on ground, but can move when attacking airborne, with locked direction)
• Enemy AI: Behaviour Trees with Yet Another Behavior Tree

Visual

• Feedback: red hurt color, blue invincible color during Slide
• More robust animation system with base (continuous) animations like Run + override (one-time) animations like Attack

Debug

• Restart all entities immediately when pressing R
• Debug overlay: FPS, current frame, currently pressed input

Assets used:

• Warrior-Free Animation set V1.3 by Clembod
• Animated pixel art skeleton by AstroBob
• Free Pixel Art Grasslands Tileset by Will Tice / unTied Games

I managed to port most of my code for character control/animation from an older project. But it was top-view, so I still had to work more to get running and jumping to work.

The biggest issue I had with physics was a regression on move_and_slide (see this issue). Otherwise, I’d say Godot’s built-in classes made it pretty simple. I don’t have any custom raycasts in my code so far.

So far I implemented the following features for the player character:

• move and jump
• melee attack: can chain up to two slashes
• health system: get hurt and die

I’d like to make this open source, but as it contains some copyrighted third-party assets (although free). I may extract the scripts into some public submodule (as with my Unity projects) though, so stay tuned!

Assets used:

• Warrior-Free Animation set V1.3 by Clembod
• Pixel Slime by rvros (CC0 1.0)
• Free Pixel Art Grasslands Tileset by Will Tice / unTied Games

I am sometimes working on an AI sandbox game with Unity. I implement various AI techniques I found in books, using Unity as a basic game framework and without using its advanced features.

I implement AI features in C# from AI Game Engine Programming (code samples in C++) and Artificial Intelligence for Games (pseudocode). Because of the specific features of C# and Unity, I adapt the code as needed while trying to keep the same behavior as described in the books. Sometimes, I am not satisfied with a specific behavior so I have to change the code further.

My project is uses a Git submodule to gather AI scripts that are reusable between games. The submodule repository is available publicly on Bitbucket as Unity Commons – AI (branch feature/movement). Note that it is a work in progress, but you can read the code to compare your implementation of the AI techniques with mine.

Features

Finite-State Machine

Source: AI Game Engine Programming

Unity implemented Finite-State Machines (FSM) for its Animator, but I recreated my own system for training purpose. It heavily uses generic and is entirely code-based. Currently, it doesn’t support data-driven state programming. For an FSM system that supports transition injection, check out libraries like solid-state (made by another developer).

[add video of guard changing state]

Movement

Source: Artificial Intelligence for Games

I have implemented pseudo-code from the book until Chapter 3.4.2. I have implemented a variety of Steering Movements, which you can see in action below.

[add videos of various guard movements]

I have also implemented some basic ballistic from Chapter 3.5: Predicting Physics.

I rarely have time to make a nice options screen during game jams, not to mention accessibility features. But for NaNoRenO 2020, I worked on them more than usual. In this post, I’ll explain how I customized the Preferences and Accessibility panel of Sidetracked! in Ren’Py.

Preferences

In this game, the Preferences button is always present in the bottom-right corner (gear icon), so it’s not visible in the left side bar to avoid redundancy. I’m not sure if it was the right idea as the Preferences and Accessibility buttons are now far apart from each other, but at least the Preferences button stays at the same place.

Default Menu

When opening the menu in-game (by pressing Escape or right-clicking), Ren’Py shows the Save screen by default. Some players prefer accessing the Preferences screen first, then click on Save/Load when needed. Considering that the Save and Load screen are very similar, requiring the player to click on Save or Load to access the respective menus may remove some ambiguity.

I still wanted to preserve the original behavior, so I added a Default Menu option that can be set to either Preferences or Save. Unfortunately, it’s not easy to change the way Ren’Py opens the game menu natively, so I had to rebind the game menu key to a custom Action.

Initialization code

1
2
3
4
5
6
7
# options.rpy, or any script where you initialize variables and set preferences
# default screen shown when opening in-game menu
default preferences.game_menu_screen = "preferences_screen"
init -110 python:
    def show_pref_game_menu():
        ShowMenu(preferences.game_menu_screen)()
define config.game_menu_action = show_pref_game_menu

Source: options.rpy

Setting

1
2
3
4
5
6
7
8
9
10
# screens.rpy (add the vbox where it seems fit)
screen preferences():
    use game_menu(_("Preferences"), scroll="viewport"):
        # ...
        vbox:
            style_prefix "radio"
            label _("Default menu")
            null height 5
            textbutton _("Preferences") action SetField(preferences, "game_menu_screen", "preferences_screen")
            textbutton _("Save") action SetField(preferences, "game_menu_screen", "save_screen")

Source: screens.rpy

Result

Safe Mode

Safe Mode is a joke particular to this game, so I won’t tackle it here. If you’re interested in how it’s done, check the menu item and Captcha screen, but you should play the game first to understand what it’s about.

Slider Reset button

I noticed that the built-in Accessibility panel (toggled with the A key) had convenient reset buttons for the Text Size Scaling and Line Spacing Scaling settings.

I decided to put the same buttons for the Text Speed and Auto-Forward Time sliders:

Setting

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# screens.rpy
screen preferences():
    # ...
    hbox:
        style_prefix "slider"
        box_wrap True
        vbox:
            label _("Text Speed")
            hbox:
                bar value Preference("text speed")
                # reset to default value of preferences.text_cps in options.rpy
                textbutton _("Reset"):
                    action Preference("text speed", 0)
            null height gui.pref_spacing
            label _("Auto-Forward Time")
            hbox:
                bar value Preference("auto-forward time")
                # reset to default value of preferences.afm_time in options.rpy
                textbutton _("Reset"):
                    action Preference("auto-forward time", 15)

Source: screens.rpy

Result

If you don’t like hard-coded values, define some config.default_text_cps and config.default_afm_time values in options.rpy, then replace 0 and 15 with those respective values in both screens.rpy above, and in options.rpy:

1
2
3
# options.rpy
default preferences.text_cps = config.default_text_cps
default preferences.afm_time = config.default_afm_time

Note that the Preference action, like SetField, detects if the current value is the target value (see SetField.get_selected source). This means that the Reset button is stylized differently when the current value is not default. To tweak this, check your style_prefix and define the properties you want for default, selected, and hover states.

Ex:

1
2
3
4
5
6
7
8
9
# screens.rpy
style slider_button_text:
    properties gui.button_text_properties("slider_button")
    outlines [ (absolute(1), "#ffffff00", absolute(0), absolute(0)) ]
    selected_outlines [ (absolute(1), "#744675", absolute(0), absolute(0)) ]
    selected_hover_outlines [ (absolute(1), "#f4cfe5", absolute(0), absolute(0)) ]
    selected_hover_color "#ffffff"
    hover_color "#f4cfe5"
    hover_outlines [ (absolute(1), "#744675", absolute(0), absolute(0)) ]

Source: screens.rpy

Accessibility

Most of the accessibility features in Sidetracked! are based on the Renpy built-in Accessibility Panel (toggled by pressing A) and the Ren’Py Accessibility Add-On.

To reuse options from the built-in Accessibility Panel, I had a look at 00accessibility.rpy and copied them, adapting the format to my own menu.

The Accessibility menu is available directly from the main menu and in-game menu. In this game, the Preferences button is always present in the bottom-right corner so it’s not visible in the side bar, but otherwise I would have placed Accessibility just below Preferences. Alternatively, Accessibility may be a sub-menu of Preferences/Options, as in TOMATO CLINIC by npckc.

UPDATE 2026-08 about the accessibily options listed in the last screenshot

TOMATO CLINIC’s developer has created another plugin, Caption Tool for Ren’Py, which supports Image Captions (extra lines to describe what’s happening visually on the scene). I used it for another game, Points Against Authority. For the other accessibility options you see in the above panel:

• Sound Captions can be used with both the Ren’Py Accessibility Add-On (as “Audio cues”) and Caption Tool.
• Textbox Transparency can be tuned with the Ren’Py Accessibility Add-On.
• Text-based mini-games must be implemented on a per-game basis. I haven’t done it in Sidetracked! but it may be worth it to make the Captcha mini-game accessible for blind, keyboard play.

Font Override (font family)

Font Override replaces all font families with the target font. It comes from the built-in Accessibility Panel and is based on FontGroups. FontGroup has a nice fallback system: if some characters are missing from your override font (e.g. Japanese characters), it will fallback to the default font just for those characters.

Because Font Override is applied to all the fonts used in the game, when using it, you cannot differentiate font styles (text, name, button, etc.) when using it. This shows in Sidetracked!, where the menu font is The Bold Font (uppercase bold font), while the font for normal text is DejaVu Sans.

In Sidetracked!, you can apply the font override directly the from Accessibility menu, and it will apply to all kinds of text.

If you want to allow the user to still distinguish font families between different styles (e.g. menu, character name, dialogue text), I have found 3 (!) methods to let you customize each font individually on a per-usage basis (I only tested the first one).

Text font attribute

Similar to Ren’Py Accessibility Add-On’s approach. Define your own variable for a certain type of text, e.g. preferences.pref_font_dialogue. In screens.rpy, add the font attribute in front of every text instance that should use this font, e.g. in screen say, use text what ... font preferences.pref_font_dialogue. Repeat for every instance of text that should use this font family (e.g. text who for the character name).

Repeat the process for every type of text that needs a different font family: define preferences.pref_font_menu, preferences.pref_font_character_name, etc.

Limitation: it doesn’t scale well with many text instances. It’s fine for character name (text who) and dialogue (text what), but as soon as you deal with menus, there will be many more text statements to change.

Style preference setting

From this thread (not tested myself)

1
2
3
4
# Style definition
renpy.register_style_preference("text", "Open Dyslexic", style.say_dialogue, "font", "gui/OpenDyslexic-Regular.otf")
# Setting
textbutton "Open Dyslexic" action StylePreference("text", "Open Dyslexic")

However this uses default styles, so you may end up defining your own styles and putting them in various textoptions as in the first method, if you don’t just differentiate interface, character name and dialogue text.

GUI preference access

From this thread (not tested myself)

1
2
3
4
5
6
# Definition
define gui.text_font = gui.preference("font_1", "DejaVuSans.ttf")
define gui.name_text_font = gui.preference("font_2", "DejaVuSans.ttf")
define gui.interface_text_font = gui.preference("font_3", "DejaVuSans.ttf")
# Setting
textbutton _("Custom") action [ gui.SetPreference("font_1", "Custom1.otf"), gui.SetPreference("font_2", "Custom2.otf"), gui.SetPreference("font_3", "Custom3.otf")]

It also uses default styles, so same remark as above.

Font color

It is very similar to Font family, although not an override option. Again, there are different ways to set it. I was only interested in changing the font color in dialogue boxes, so I set the color property on text what directly. This technique comes directly from the Ren’Py Accessibility Add-On.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# accessibility_setup.rpy
init python:
    preferences.pref_text_color = gui.text_color
# screens.rpy
screen accessibility():
    # ...
    vbox:
        style_prefix "check"
        label _("Font Color")
        null height 5
        textbutton _("Default (Purple)"):
            action changeColor(gui.text_color)
            style_suffix "radio_button"
        # I wanted to make that text black, but when selected, it adds a purple
        # outline and it's ugly. Better use a style to mimic default radio text becoming
        # white instead when selected, but didn't manage to inject specific style here
        textbutton _("Black"):
            action changeColor("#000000")
            style_suffix "radio_button"
screen say(who, what):
   # ...
        text what id "what" color preferences.pref_text_color

Source: screens.rpy

Self-voicing

This comes directly from the built-in Accessibility panel. I dropped the Clipboard and Debug options so there are only Off and Text-to-speech. This can also be toggled at any time with the V key.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# screens.rpy
screen accessibility():
    # ...
    vbox:
        style_prefix "check"
        # Copied from renpy SDK: 00accessibility.rpy
        label _("Self-Voicing")
        null height 5
        textbutton _("Off"):
            action Preference("self voicing", "disable")
            style_suffix "radio_button"
        textbutton _("Text-to-speech"):
            action Preference("self voicing", "enable")
            style_suffix "radio_button"

Unfortunately, the game is not fully playable with self-voicing only, due to other issues. In particular, some options are not voiced correctly (Window Alpha is voiced “Baa-baa”), and the Preferences/Task-Tree button at the bottom-right is not intuitive to reach with the keyboard. This means that it’s very hard to find the Safe Mode option, and furthermore, the captcha at the beginning is simply impossible to solve for blind players as pictures are not commented. There are certainly ways to make it work in my game (e.g. audio captcha). But if your game has a more straightforward UI, it may just work out of the box for you.

Audio cues

This technique comes directly from the Ren’Py Accessibility Add-On, I just adapted it to my needs. It allows to add notifications when an SFX is played.

First, we define resources with paths to our assets.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# resources.rpy
# Audio
# -1 so it's done just before music_dictionary definition in accessibility_setup.rpy
init -1:
    ## BGM assets
    define audio.title_theme = "<to 19.2>audio/bgm/title_theme.ogg"
    ## BGM mapping (so accessibility feature can get BGM notification text from core name
    ## instead of filepath, which contains the <loop> pattern and is not very convenient)
    define music_to_assets = dict(
        title_theme = audio.title_theme, ...)
    ## SFX assets
    define audio.coins_drop = "audio/sfx/coins_drop.ogg"
    ## SFX mapping (to allow to reuse audio assets for actions with different meanings,
    ## and also so accessibility feature can use short name as dict key rather than filepath)
    define sfx_to_assets = dict(
        coins_drop = audio.coins_drop, ...)

Source: resources.rpy

Second, we define a preference to enable audio cues, as well as the textual descriptions of sounds.

1
2
3
4
5
6
7
8
9
# accessibility_setup.rpy
# Audio cues
default preferences.audio_cues = True
    # alias : "Song Title",
    music_dictionary = dict(
        title_theme = "Title Theme - Upbeat Music", ...)
    # alias : "Sound description."
    sfx_dictionary = dict(
        coins_drop = "Coins dropped", ...)

Source: accessibility_setup.rpy

Third, we define functions to play sounds together with the description, if audio cues are enabled.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# accessibility_functions.rpy
    def play_sfx(sound_name, **kwargs):
        # slightly modified to allow passing a string, so you can reuse the same SFX
        # with different meanings, hence different notification texts (currently not used,
        # since only queued sounds with custom notification reuse sounds; but more flexible anyway)
        # also removed "{i}{/i}" which for some reason shows at "[i][/i]"
        renpy.sound.play(sfx_to_assets[sound_name], **kwargs)
        notify_sfx(sound_name)
    def notify_sfx(sound_name):
        if preferences.audio_cues:
            renpy.notify("SFX: " + sfx_dictionary[sound_name])
    def play_music(music_name, **kwargs):
        # same modification as in SFX
        renpy.music.play(music_to_assets[music_name], **kwargs)
        if preferences.audio_cues:
            renpy.notify("Now Playing: " + music_dictionary[music_name])

Source: accessibility_functions.rpy

I modified the code slightly above:

• for some reason, “{i}{/i}” shows at “[i][/i]” in the notification message in recent versions of Ren’Py, so I removed them
• I prefer using an audio asset representative name than a full path as dict key. One reason is that filepaths, esp. with music info, can be very long and harder to debug, the other is that it allows me to reuse the same sound with different audio cues, by mapping different sound aliases to different descriptions but to the same audio asset.

Finally, we add a checkbox in the Accessibility panel to toggle Audio Cues.

1
2
3
4
5
6
7
8
9
10
# screens.rpy
screen accessibility():
    # ...
    vbox:
        style_prefix "check"
        # Copied from Ren'Py Accessibility Add-On: screens replacements.rpy
        label _("Audio")
        null height 5
        # Toggle Audio Cues
        textbutton _("Audio Cues") action ToggleField(preferences, "audio_cues")

Source: screens.rpy

Quick menu keys

I created this option just for this game, which shows the key shortcuts that can be used to open the Preferences and Task Tree menus (P and T resp.).

I noticed that Self-Voicing ALWAYS pronounced “T” and “P” at the end of every dialogue line. This was very annoying so I added an option to hide those hints. I wish Ren’Py allowed to customize how buttons and labels are read (e.g. “Task Tree” instead of T), including disabling self-voicing completely.

1
2
3
4
5
6
7
8
9
10
11
# screens.rpy
screen accessibility():
    # ...
    vbox:
        style_prefix "check"
        xsize 950
        # Copied from Ren'Py Accessibility Add-On: screens replacements.rpy
        label _("HUD")
        null height 5
        # Toggle Quick Menu Key Hints
        textbutton _("Quick Menu Keys (unselect when using self-voicing)") action ToggleField(preferences, "show_quick_menu_keyboard_hints")

Source: screens.rpy

Window Alpha

This technique comes directly from the Ren’Py Accessibility Add-On. It allows the user to change the text box transparency.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# screens.rpy
screen accessibility():
    # ...
    vbox:
        style_prefix "slider"
        # Set Textbox Opacity
        label _("Window Alpha")
        null height 5
        hbox:
            bar value FieldValue(preferences, 'say_window_alpha', 1.0, max_is_zero=False, offset=0, step=.2)
            textbutton _("Reset"):
                action SetField(preferences, "say_window_alpha", 1.0)
# ...
screen say(who, what):
    style_prefix "say"
    window:
        id "window"
        background Transform(style.window.background, alpha=preferences.say_window_alpha)

Source: screens.rpy

Windows fullscreen mode and resolution

I added the resolution setting much later than the rest (v3.5.3). It’s working fine on 1080p and allows the user to toggle fullscreen while preserving the last resolution, or force resolution to 720p. However, on 4K screens it will capture at 3200×1800. I considered fixing that bug and making a separate post for this feature, but as I won’t have time to, I prefer dropping the code for the setting right now:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# screens.rpy
screen preferences():
    # ...
    vbox:
        style_prefix "radio"
        label _("Display")
        null height 5
        textbutton _("Fullscreen") action Preference("display", "toggle")
    vbox:
        style_prefix "radio"
        label _("Resolution")
        null height 5
        # pass ratio of native resolution, which is 1080p
        python:
            # for monitors of 1080p and less (actually checking width of 1920),
            # the default size is clamped to max_window_size, so we label "Default" slightly differently
            if renpy.get_renderer_info().get("max_window_size", (9999, 9999))[0] > 1920:
                # e.g. on hi-dpi
                default_res_text = _("Default (1080p)")
            else:
                # e.g. on 1080p
                default_res_text = _("Default")
        textbutton default_res_text action Preference("display", 1.0) # or "window", it also uses __DisplayAction(1.0)
        textbutton _("720p") action Preference("display", 2. / 3.)    # 0.666... because 2/3*1080 = 720

Source: screens.rpy

The main features I am aiming at are:

• Entity-component system
• Fixed update and input/render update loops
• Game window with OpenGL with GLEW + GLFW
• Keyboard/mouse input
• Primitive 2D shapes rendering
• Basic shaders
• 2D physics (Box2D)
• Scene-Entity system
• Scene editor and basic scene serialization
• AI helpers
• Unit tests (Catch2)
• Sample game

At first I used SDL2 for window management and rendering, before switching to OpenGL with GLFW for more flexibility (e.g. zooming in and out with the camera). Now, I know that SDL2 supports OpenGL rendering too, so looking back at it, SDL2 wasn’t a bad choice at all (plus I’m still only rendering simple shapes like squares right now).

That said, I like GLFW’s window API better and I need some OpenGL training anyway, so why not start with simple shapes. Next time, I’ll also have a look at SFML, but for now I want to focus on the engine systems (modules).

Progress

I have implemented the game application window, basic keyboard input and basic rendering systems, as well as a simple entity-component system with a base Actor class for game objects, a base Component class for components and their respective factories. Input and rendering is done via Components, but the developer can also add custom behavior by subclassing the Actor class for all game, as in Unreal Engine (and Godot with Nodes).

Advantage: you can implement behavior specific to one entity directly inside the Actor subclass, without using components

Disadvantage: all game objects don’t have the same exact type and have different sizes, so you cannot put them in an array/vector of GameObjects (Unity-style) combined with handles for maximum cache efficiency (see Data Locality). If you still want data contiguity, you’ll need a custom container that supports variable object size.

For now, I have something like this:

The last thing I have done is refactoring the engine structure with a lot of interfaces to allow unit testing.

You can check the code on my GitHub repos:

• Engine
• Sample “game” (it uses the engine as submodule)

Next step

I’m not working on this project right now, but I’ll have to go back to it at some point, especially if I want to make an engine in a different language (e.g. Rust). This would be an opportunity to learn from my past mistakes and clean things up before I step onto a cleaner architecture.

Quite often, gameplay programmers need to hand over the task of creating scripted events to level designers. In Unreal, a common workflow is to define shared features in C++ and level-specific behaviors with Blueprints.

While it is possible to implement C++ Actor methods via Blueprints using either BlueprintImplementableEvent or BlueprintNativeEvent, in this post, I’ll talk about dynamic multicast delegates.

Concept

Delegates allow you to handle functions as objects, pass them around and execute them later with the appropriate context. There are various ways to implement them in C++ (see this discussion on stack overflow and this proposition of Generic C++ delegates), and Unreal provides its own implementation (see Delegates in UE documentation). I won’t try to explain how they work in UE (getting myself lost among all the macros in the source code) but I’ll show you how to use them in a very specific case.

Imagine we have several Actors that share the same behaviors via Actor Components. Both Actors and Actor Components are initially defined in C++, but only Actors are extended via Blueprints (to reduce the number of Blueprints). Behaviors are defined as C++ methods in the Actor Components’ classes, but since those are not derived into Blueprints, we cannot use BlueprintImplementableEvent nor BlueprintNativeEvent UFUNCTIONs to move the implementation to a Blueprint event graph.

Instead, we declare a dynamic multicast delegate member in the Actor Component (called SwitchableComponent) and bind a function (actually a Blueprint graph) to that delegate in the Actor’s Blueprint.

Code

Actor Component

Below is an example on how to do that with a switch and a delegate for functions that takes 1 boolean parameter (true to switch on).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
// SwitchableComponent.h

#pragma once

#include "Item/InteractableComponent.h"
#include "SwitchableComponent.generated.h"

// This macro will generate a declaration for a delegate that supports functions receiving
// one boolean parameter. Check the documentation for parameter variants.
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FSwitchableComponentSwitchSignature, bool, bOn);

// In my game, UInteractableComponent allows interaction from the player character,
// but you can derive directly from UActorComponent instead
UCLASS(BlueprintType, ClassGroup = (Interaction), meta = (BlueprintSpawnableComponent))
class MYGAME_API USwitchableComponent : public UInteractableComponent
{
    GENERATED_BODY()

public:

    USwitchableComponent();

    UPROPERTY(Transient, Category = "State")
    bool bIsOn;

    /** Toggle switch */
    void Switch();

protected:

    // Here is the delegate we'll bind the behavior to in the Actor Blueprint
    /** Callback on switch on / off (passed boolean argument is true if switching on) */
    UPROPERTY(BlueprintAssignable, Category = "Interaction")
    FSwitchableComponentSwitchSignature OnSwitch;

};

// SwitchableComponent.cpp

#include "StairlessTower.h"
#include "SwitchableComponent.h"

USwitchableComponent::USwitchableComponent() : UInteractableComponent()
{
    bIsOn = false;
}

void USwitchableComponent::Switch()
{
    // Toggle
    bIsOn = !bIsOn;

    // The IsBound() check is optional for multi-cast delegates, but let you know if
    // at least one function is bound to the delegate
    if (OnSwitch.IsBound())
    {
        OnSwitch.Broadcast(bIsOn);
    }
}

Note that we need a dynamic delegate because dynamic delegates are serializable, which allows them to be saved in the Blueprints. I’m not sure why multicasts delegates are required, maybe it’s because they support multiple function bindings or because they don’t have return values. Anyway, if you try to use DECLARE_DYNAMIC_DELEGATE_OneParam you’ll get the following error: ‘BlueprintAssignable’ is only allowed on multicast delegate properties.

Actor

Now, we create a WallSwitch Actor that uses SwitchableComponent:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// WallSwitch.h

#pragma once

#include "GameFramework/Actor.h"
#include "WallSwitch.generated.h"

// We'll need to derive a Blueprint from this Actor, so we make it Blueprintable
UCLASS(Blueprintable)
class MYGAME_API AWallSwitch : public AActor
{
    GENERATED_BODY()

    // Make the switchable component accessible in the Blueprint editor for later
    /** Switchable component */
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Interaction", meta = (AllowPrivateAccess = "true"))
    class USwitchableComponent* SwitchableComponent;

public:
    // Sets default values for this component's properties
    AWallSwitch();

    // Called when the game starts
    virtual void BeginPlay() override;

    // Called every frame
    // virtual void Tick( float DeltaSeconds ) override;

};


// WallSwitch.cpp

#include "StairlessTower.h"
#include "WallSwitch.h"

#include "Item/SwitchableComponent.h"

// Sets default values for this component's properties
AWallSwitch::AWallSwitch()
{
    PrimaryActorTick.bCanEverTick = false;

    // Create and attach a SwitchableComponent
    SwitchableComponent = CreateDefaultSubobject<USwitchableComponent>(TEXT("SwitchableComponent"));
}

Blueprint

Actor Blueprint

We create an Actor Blueprint BP_WallSwitch derived from WallSwitch. The Components panel shows:

When we select the Switchable Component, the Details panel shows:

Binding

At first, the buttons in the Events section should all show a “+”. We click on the button next to On Switch to create the event node below (from then on, the button will show “View” as on the screenshot above):

Alternatively, you may right-click in the Event Graph area and type “Add On Switch” in the search field (ensuring SwitchableComponent is still selected and Context Sensitive is checked).

From here, we can bind a Blueprint graph to the OnSwitch delegate (represented by an event node) defined earlier in C++. In this example, we play a Sequence from a Sequence Actor reference we added directly as a Variable in the Actor Blueprint.

Result

When the player character tries to interact with the Wall Switch, the level sequence plays:

The red/green box you see is a Box Trace with visual debug that the Player Character uses to detect interactables. It’s quite easy to do with Blueprints but may be tricky in C++, I’ll explain how this works in another post.

Notes

The OnSwitch event node that appeared seems to be a convenience node provided by the Event Graph when handling a delegate on an Actor Component (BlueprintImplementableEvents also show such nodes). But in general, you can bind events to delegates by creating a Custom Event with its own subgraph and assigning it to the Event input pin of the Bind Event to … node (type “Assign” in the Blueprint search box and you’ll find an action that generates both the Custom Event and the Bind Event node for the delegate you want, provided it is accessible from the current Blueprint or you have selected it in the World Viewport).

For instance, I selected a Wall Switch instance in the Viewport, then in the Level Blueprint editor I right-clicked > Assign to OnSwitch. This allowed me to add an extra logging event when the Wall Switch was pressed (the multi-cast delegates will trigger all bounds functions/events on Broadcast).

For examples on how to bind functions from raw C++, check out Rama’s article on Delegates.