I've expanded the editor with additional tools, introduced layer support for sprites, and added localization. For the first time in one of my SDL applications, I also implemented a menu bar. Here's a screenshot of the current version:

For now, I've decided not to release it publicly. It will remain an internal tool, at least until I've added more features and refined it further.

I've also worked a little on the website, which now displays the estimated reading time for news entries next to the date.

While implementing this, it became clear that havPreviewHandler's existing loading pipeline didn't hold up under rapid file switching. Under certain conditions, previews stalled.

To address this properly, the loading system was reworked into an asynchronous pipeline. The result is faster preview updates and a responsive File Explorer experience, even when switching files mid-load.

The changelog for v0.3.0 is short, but the changes behind it are not.

• Added MP4 file support for representative still-frame preview and thumbnail (no video playback)

The update is available in the Downloads section.

So here it is: Asphalt Strike - a hybrid between a vertical scrolling shooter and an endless runner. The game is inspired by Solar Striker and Tachikoma - A Go Go!, a bonus game from Ghost in the Shell: Stand Alone Complex on the PlayStation Portable (PSP).

Asphalt Strike also includes an improved version of my dynamic music system, which I first used in my roguelike game Escape Made Easy (E.M.E.). I also spent some time learning the SDL Storage API introduced in version 3.2.0.

Inspired by Shadow Knights and Hovertank, I implemented a small sound effect generator based on sine waves - meaning there are no external sound effect files this time. That was a fun challenge.

The font used in the game is baked directly into the source code, and the game supports localization in both English and German.

In addition, I created a pixel editor built directly into the debug build of the game, called Asphalt Strike - Atlas Editor. I used it to create all the game's graphics.

Honestly, I probably took the editor further than intended in terms of features, and I'm considering turning it into a standalone tool - we'll see.

For now, here's a screenshot of the Atlas Editor:

The game can be downloaded in the Downloads section. I've also released a video on YouTube showcasing the game.

While working on the game, I discovered a few bugs and made some behavioral changes to havSeriLite, which led to the release of version 0.2:

• Fixed reader buffer validation / copy bounds
• Made size == 0 checks a valid no-op for empty fields

• Added Preview Pane right-click actions:
• Save current frame as... (PNG, JPEG, or BMP)
• Copy current frame (clipboard)

The update is available in the Downloads section.

About ~5k lines of code later, I've got a pseudo-3D engine running that feels pretty close to the old Sega Genesis games, mixed with some of the building rendering style from the 3DO version.

The working title is RR, built with C++23, SDL 3.0, and OpenGL 3.3.

First video is up on YouTube. Not sure yet if this turns into a real project, so I haven't put up a project page for it, but it's been a fun side experiment so far.

• Improved timeline dragging so frame selection better matches the cursor position
• Added a loading indicator so the preview pane no longer appears blank while content is loading (especially noticeable with larger files)

The update is available in the Downloads section.

I've also continued working on havIDE, which now includes:

• Expanded debugging capabilities (call stack and watches)
• Enhanced syntax highlighting and configurable editor formatting (indentation style and size, line endings, encoding)
• Support for saving project and session settings per project folder

I recently came across a personal website that had a "Pronounce my name" button next to the author's name. I thought it was a cool feature and wanted to know how it works.

A quick search showed that this can be implemented using the Web Speech API, specifically the Speech Synthesis part (text-to-speech, or TTS). Browser and voice availability can vary depending on the operating system, but I added it to my website regardless - because why not. If you don't see the speaker button next to my name on the homepage, your browser or system probably doesn't support it.

I remembered that Windows allows custom shell extensions, although I had never built one myself. So I took the opportunity to dive in, researched the necessary APIs, and began developing a preview handler that enables animated image previews directly in the File Explorer Preview Pane.

During this process, I came across two particularly helpful resources: "Preview Handlers and Shell Preview Host" and "Thumbnail Handlers." These guided me in implementing both a preview handler and a custom thumbnail provider.

Beyond animated previews, I also wanted to improve how thumbnails are generated. By default, Windows uses only the first frame of an animation as a static thumbnail, which is often not representative. To address this, I implemented logic to generate more meaningful static thumbnails for GIF, WebP, and APNG images.

The result is havPreviewHandler - a shell extension DLL for Windows 11 File Explorer that provides animated previews and representative static thumbnails for GIF, WebP, and PNG files (including APNG content in PNG containers).

The shell extension is released as freeware and is available on the havPreviewHandler project page.

The screenshot below shows havPreviewHandler displaying an animated GIF directly in the File Explorer Preview Pane:

• Added blink attribute support (ANSI_BLINK, ANSI_NO_BLINK)
• Added VT processing support for stderr on Windows
• Added console restore helper (havTermKit_RestoreConsole)
• Added terminal input helpers
  • havTermKit_EnableInputVT
  • havTermKit_DisableInputVT
  • havTermKit_EnableRawInputNonBlocking
  • havTermKit_DisableRawInputNonBlocking
  • havTermKit_ReadByte
  • havTermKit_TryReadByte
• Added VT mouse helpers (tracking toggles and SGR parser)
• Added terminal mode helpers
  • havTermKit_AlternateScreenEnter
  • havTermKit_AlternateScreenLeave
  • havTermKit_WrapEnable
  • havTermKit_WrapDisable
• Added terminal size helper (havTermKit_GetTerminalSize)
• Cleaned up Windows Unicode / config macros

In addition, I've released havTermViper, a terminal-based game built using havTermKit.

The full source code for the game is available on GitHub under the MIT License.

As development continued and I introduced more advanced features such as slopes, room over room support, and a particle system, the renderer became increasingly complex. Rendering artifacts appeared in edge cases and performance degraded significantly, especially when the camera moved close to particle effects.

I initially tried to fix the issues within the software renderer. I spent time optimizing and correcting edge cases, but the complexity kept increasing and some problems proved difficult to resolve cleanly.

Today I made the decision to rewrite the renderer in OpenGL 3.3.

I'm not a graphics programmer and maintaining a feature-rich software rasterizer while continuing engine development was no longer the most effective use of my time.

The rewrite took the entire day.

The result: significantly improved and stable performance, resolved graphical issues, and a noticeably smaller and cleaner codebase.

I also removed SDL_image 3.0 from the project. With native PNG loading and saving now part of SDL 3.0, the extra dependency is no longer required.

Even the screen-melting effect survived the transition to OpenGL.

Visually, the engine remains nearly identical. If you compare the screenshots below, the difference is minimal.

(Left: Software Renderer / Right: OpenGL Renderer)

The working project title is GCR, developed in C++23, SDL 3.0, and OpenGL 3.3. This milestone consists of roughly 5700 lines of code and establishes the technical foundation for the project moving forward.

Although GCR is now officially underway, my primary focus remains on finishing Hovertank and Shadow Knights, followed by continued development of my Doom-style engine, Portals, and the game that will be built on it.

To solve this, I created havTermKit, a lightweight terminal utility library for modern C and C++, available on GitHub under the MIT license.

It provides ANSI escape macros for:

• Text styling
• Foreground and background colors
• Cursor control
• Screen clearing
• Hyperlinks

Additionally, it includes a small initialization function to enable VT processing and UTF-8 support on Windows.

Below are screenshots showcasing the virtual keyboard in the Mod Manager search when using a controller, as well as in Hovertank's in-game dialogs.

Note: Hovertank's virtual keyboard is context-aware and only shows valid keys for the current input dialog.

Here's a screenshot of the new multi-select tags dropdown:

I used the Shadow Knights Editor (SKE) as a starting point, since both games share the same map format. However, unlike SKE, HVE uses uniform 16x16 pixel tiles for each layer, as it doesn't display the original game sprites.

Here's a screenshot of the first version of the editor:

Additionally, havINI version 0.6 has been released with the following fix:

• Fixed quoted-value parsing for bracket characters: [ and ] are now treated as normal value content when inside a quoted string (e.g., Key = "[") instead of being misinterpreted as section delimiters.

I found a few third-party closed-source tools that could do this, so I decided to write my own. Over the course of a few days, I built a WinForms-based C# app called havTransparentWnd that allows you to make windows transparent.

The app lets you adjust the opacity of transparent windows, block specific applications from being made transparent, and provides system tray integration for easy access. It also supports a global hotkey to toggle transparency on and off, as well as multiple languages (currently English and German).

You can download havTransparentWnd from the Downloads section. It requires Windows 10 or later and the .NET 10 Desktop Runtime. The source code is available on GitHub under the MIT license. As usual, there's also a screenshot on the Projects page.

Mods live in their own dedicated folders, and the game allows players to use multiple mods simultaneously. Mods can override graphics and sounds from the base game, with override behavior controlled through an INI file. Level names, descriptions, and times are managed through a separate INI file. Hovertank uses havINI for INI file parsing.

havINI version 0.5 includes the following changes and fixes:

• Updated value parsing: quoted values now respect escape sequences (\" and \\) and track the opening quote type so inner apostrophes / quotes don't terminate the string.
• Added comment escape mode control for literal comment output when needed.
• Parsing now only trims leading whitespace to preserve spaces inside values.
• Fixed array key parsing to ignore surrounding whitespace, matching formatted output (e.g., "Key[] = value").
• Array operations now validate empty / out-of-range conditions and throw consistent runtime errors.

With that, here is version 0.4 of Escape Made Easy (E.M.E.). You can download the update in the Downloads section.

This update includes the following changes and fixes:

• Migrated to SDL 3.0 and SDL_mixer 3.0.
• Replaced JSON files with CSON files.
• Replaced BMP file with PNG file.
• Minor improvements to the dynamic music system.
• Fixed a bug where the oldest game messages were saved instead of the latest ones.
• Clamp initial mouse position to window bounds on startup (prevents cursor from starting out of range).
• Added a language selector feature (English & German).
• Added an icon to the game executable.
• Game is now 64-bit only.

I've also released version 0.2 of havCSON, which improves number formatting and error handling.

In other news, I've rewritten the particle system of Portals to be pixel-based instead of bitmap-based. The bitmap-based approach was causing performance issues when you got too close to the particles. Below is a screenshot showcasing the new pixel-based particle system:

Today, just one day later, the map renderer is running on OpenGL instead of GDI. I'm using OpenGL 3.3 with shaders as the default, with a fallback to OpenGL 2.1 for older hardware. I also fixed the clipping issue when copying map segments. There's still a small quirk where objects shift slightly when you rotate or flip them, but it's a minor issue that isn't worth fixing - rotating and flipping are more of a gimmick anyway.

If you compare the enlarged versions of the screenshots, they basically look the same, except the rectangles in the OpenGL version (screenshot #2) are "pixel-perfect", whereas the GDI ones (screenshot #1) aren't.

I'm really satisfied with the new rendering speed. Going forward, I'll be using OpenGL directly for map rendering in wxWidgets instead of trying to squeeze more performance out of GDI.

After finishing the recording, I thought: "Why isn't there a single hotkey to switch directly to the most recently used window? The built-in Windows shortcuts just aren't efficient or ergonomic enough for my workflow." So I wrote a WinForms-based background app in C# that registers global hotkeys to switch windows. I called it havWndSwitcher, and I ended up taking the original idea much further than planned. The app offers a lot of options (you'll see what I mean when you try it), and I even added language selection support; it currently includes English and German.

You can download havWndSwitcher from the downloads section. It requires Windows 10 or later and the .NET 8 Desktop Runtime. The source code is available on GitHub under the MIT license. As usual, there are also screenshots on the projects page.

I've learned a lot since then. The new source port stays much closer to the original codebase, and this time the fixed-point math uses 32-bit integers - although the game itself will still only run on 64-bit operating systems.

After five days of development, the new port is already playable from start to finish. There's still work ahead, but I've uploaded a short preview video on YouTube showcasing the current state of the game.

Unfortunately, CSON remains effectively confined to the CoffeeScript ecosystem, leaving C++ developers without a usable implementation.

To address that gap, I created havCSON, a lightweight CSON reader / writer library for C++23, available on GitHub under the MIT license.

As mentioned in the previous update, the editor wasn't built from scratch - I used The Pushing Point Editor as the starting point. However, I had to heavily modify the map renderer. The original editor used uniform 16x16 pixel tiles for each layer. For SKE, I wanted to display the actual sprites instead of 16x16 placeholders. This required rewriting large parts of the renderer because it relies on the dirty rectangle rendering technique to update maps efficiently.

Since the sprites vary in size, applying the same dirty-rectangle-based approach to the objects layer became significantly more complex. I did manage to update only the necessary map regions in the end, but doing so with the Graphics Device Interface (GDI) was challenging, especially because I had to handle transparency manually. There are still a few edge cases where it doesn't behave perfectly (for example, rotating a copied map segment containing sprites can clip them), but overall I got it working. The effort paid off: map rendering is still "fast" given the limitations of GDI.

Here's a screenshot showing the first release version of the editor:

In other news, I've expanded my Python GitHub profile automation script. I added a section that displays my top used languages across my public repositories (excluding forks), as well as a section showing my latest YouTube videos.

The top languages section includes a legend and an automatically generated SVG file that shows a stacked bar chart of used languages - similar to GitHub's own language bar. The data is retrieved via the GitHub REST API, and the latest YouTube videos are fetched using the YouTube Data API v3.

This was a fun challenge, though my first attempt at generating the top languages section didn't work on GitHub. I initially tried using HTML with inline CSS, but GitHub sanitizes it, presumably for security reasons, so the styling was removed. I ended up generating an SVG instead. I could have saved myself some time by checking beforehand whether GitHub supports inline CSS in README.md files - but oh well.

With that out of the way: I've started work on a map editor for Shadow Knights called SKE (Shadow Knights Editor), which will be released as freeware. The editor is being developed in C++23 using wxWidgets. SKE is based on The Pushing Point Editor, mainly because I know how long it takes to build a map editor completely from scratch, and I'd rather focus my time on finishing the game's source port.

Anyway, here's a screenshot showing the editor in its current state:

However, there's still one missing piece: even if you enable that option and add Thunderbird to your Windows startup apps, so it launches automatically when you log in, it still can't start minimized.

I started wondering today whether an extension could handle this. I'm sure there are already extensions that can do that, but it seemed like a good opportunity to learn how difficult it is to build an extension myself. The result is Havoc Startup Minimizer - a lightweight, efficient, and permission-free extension for Mozilla Thunderbird that minimizes the main Thunderbird window immediately after startup.

You can find it on the official Thunderbird Add-ons site: https://addons.thunderbird.net/en-US/thunderbird/addon/havoc-startup-minimizer

And the source code is available on GitHub: https://github.com/Havoc7891/havoc-startup-minimizer

I've also added a basic save game feature that automatically saves your progress after each completed level. To showcase these updates, I've put together a short YouTube video demonstrating the new features in action.

In other news, over the weekend I updated and completed the German translation of WinMerge, an open-source differencing and merging tool I use frequently. The translation hadn't been maintained for over two years and contained 288 untranslated strings, so I brought it up to date using Poedit. My translation work will be included in the next release version (v2.16.52.2), which is expected to be released at the end of November.

The Shadow Knights source port is now fully playable from start to finish. While there's still work to be done, it's far enough along that I'm ready to show it off.

You can check out the first preview video of the game on YouTube - a small glimpse of what's to come.

Fortunately, I had already solved this problem back in April 2022 using the Microsoft Keyboard Layout Creator (MSKLC) 1.4, when I first switched to QWERTY at home. I created a custom Windows keyboard layout called "IntAltGr", which lets you type umlauts, the sharp S, and various other international characters using the Alt Gr modifier in combination with letter keys. If your keyboard doesn't have an Alt Gr modifier, you can use Ctrl + Alt instead.

Here are the key combinations for umlauts and the sharp S:

• Alt Gr + Q -> ä
• Alt Gr + P -> ö
• Alt Gr + Y -> ü
• Alt Gr + S -> ß

You might wonder why I didn't just use the built-in US-International layout in Windows. The reason is simple: I dislike having to press the ` and ' keys twice to type them literally. In my layout, those keys produce their characters immediately with a single press.

Since I needed this layout again for my work laptop, I decided to rebuild the setup and release it on my website. It probably won't be useful for most people, but it's a convenient way for me to install it quickly on any of my Windows machines.

Simply double-click the setup.exe file to install the keyboard layout. Once installed, you can switch to it by pressing Win + Spacebar.

You can download "IntAltGr" from the Downloads page.

Until now, it wasn't possible to change a sector's winding, which meant you had to completely remove and recreate the sector. I've added the ability to toggle the winding now, along with winding markers in the editor so you can easily see if a sector has the correct winding. There's also a new screenshot on the projects page showcasing this feature.

On the engine side, I've been improving the renderer. I also worked on collision detection: it's now possible to walk on slopes.

This new version includes:

• Modern Dialog API: Uses native HTML <dialog> element for better accessibility
• Responsive Design: Automatically adapts to different screen sizes and orientations
• Touch Support: Swipe gestures for navigation on mobile devices
• Keyboard Navigation: Arrow keys for previous / next navigation
• Image Counter: Shows current position in gallery (e.g., "1 / 3")
• Optional Captions: Display custom captions for each image
• Smooth Animations: CSS-based animations for opening / closing
• Theme Support: Automatic light / dark theme detection
• Zero Dependencies: Pure vanilla JavaScript, no external libraries required

You can see the plugin in action on the projects page.

I found a small single-player map for Command & Conquer: Tiberian Dawn called Dark Tide, which I created on September 4, 2005 but never released. Yesterday, I updated it to work with the Remastered edition and uploaded it to the Steam Workshop. However, since the map still isn't showing up in the game's User Maps browser, I've also put together a ZIP release as an alternative download. That way, you can install it manually if you'd like to spend a few minutes playing it. You can download the map here.

I also tracked down an old Counter-Strike aim map I made on September 7, 2004 for my old clan, called Wild Aim. The map is pretty simple, but it served its purpose back in the day. I've updated the accompanying readme, but the map itself is unchanged from the original release. You can download it here.

I've plenty of other projects I could potentially release, but I'd need to track them down first and some would require extra work to run on newer operating systems. I'm not really willing to spend that time right now since I've new projects to focus on... but never say never, right?

I've also created a walkthrough video for Time of Darkness and uploaded it to YouTube. It's for people who don't own Half-Life, don't want to play the mod, or got stuck in one of the maps, since some of the puzzles aren't completely obvious.

Honestly, I might have gone a little overboard with the projects page. It now includes not just a search function, but also filters for projects, types, genres, platforms, and technologies used. That's what happens when I dive into something: I just can't stop until I'm completely satisfied.

I also revamped the image gallery, which is now much more mobile-friendly. For now, it's still tied to the site, but I'm planning to separate it and release it as a new version of havLightbox.

Back then, I packaged the mod using an installer tool from Clickteam. Honestly, I didn't expect the installer to work on Windows 11 anymore - but to my surprise, it did! Of course, that only meant I could install the files; I still wasn't sure if the mod itself would actually run.

So, I fired up Steam, downloaded the original version of Half-Life, installed the mod in its proper location, and gave it a try. And... it still works! At that point I thought: "Well, why not release it again?"

You can download the mod here. Details about the story, installation instructions, and screenshots are available on the projects page.

After rediscovering Times of Darkness, I was curious to see if I could also track down the work-in-progress build of its canceled sequel, Times of Darkness 2. And I did. The mod itself will never be released, but I've decided to at least release the intro track I composed for it. You'll find the song along with details on its creation on the projects page under Times of Darkness, or you can download it directly from here.

So, I sat down for about two hours and programmed a WinForms-based background app in C# that registers a global hotkey to center the mouse cursor on the primary monitor. I called the app havCurCtr. You can download it from here. You need Windows 10 or later and the .NET 8 Desktop Runtime to run this app. The source code is available on GitHub under the MIT license. As usual, there's also a screenshot on the projects page.

I've also added havGSD to the projects and downloads page now. I didn't do it when I first released it, because I didn't want to include GitHub projects there, but I changed my mind - if it's an app or plugin (and not just a library), I'll include it.

I received an email from Duolingo today letting me know that it's my first Duoversary, and I figured this was a good opportunity to reflect on my experience with the app - and maybe brag a little about my achievements.

Let's get the bragging out of the way first: I've maintained my daily streak so far, even if I don't always complete all the daily quests. I've reached the highest league (Diamond League), remained there for 26 consecutive weeks so far, and even secured first place in the Diamond Tournament back in June. While I'm not particularly driven by competition, achievements do tend to spark a bit of that competitive edge in me.

I've unlocked almost all the achievements - except for the friend-related ones. I've chosen the lone wolf route, which, in my opinion, makes the accomplishments all the more rewarding. I'll probably go for the friend-related ones eventually, just to have them, though I haven't really cared so far. That said, Duolingo has occasionally forced friend streaks and friend quests on me with randomly selected users, without giving me the option to opt out. I don't mind the concept in general, but I do question why it has to be mandatory. Anyway, that's enough about the gamification side of things.

So, the big question: Do you actually learn something with this app? In my experience - yes, you do. It depends heavily on the subject, though. When it comes to languages, it's definitely effective. For example, I was already fluent in English before I started using Duolingo, but I've still picked up new vocabulary, useful phrases, and subtle grammar improvements. I'd say it's a solid tool for language learning - great for daily practice and vocabulary, though not enough to develop strong speaking and listening skills on its own.

Beyond languages, I also tried the music lessons. They're useful for building a basic understanding of how to read sheet music, but not much more. Don't expect to walk away able to play an instrument (aside from maybe a few simple melodies on a keyboard).

All in all, if you're consistent and know what to expect, Duolingo can really help build foundational skills - especially in languages.

This will be the last video focusing on the editor for now - the next one will highlight the current state of the 'Portals' game engine. Stay tuned!

I've also updated the projects page - it now includes an additional older project, and the version descriptions have been streamlined for clarity.

Work on the 'Portals' editor is progressing steadily and is now close to supporting the engine's core features.

I found the idea intriguing, so I built something similar - also using a GitHub Action and Python, just like the author of the article. Now, my README updates automatically with the latest news entries from my RSS feed. You can check out the code here.

It wasn't what I originally had in mind when I thought about creating a profile README, but it turned out to be a fun little side project - especially since I haven't done much automation with GitHub before - and a great way to keep my profile dynamic and current.

Now, I'm back to working on the 'Portals' editor.

My main focus remains on the 'Portals' editor. I've refined the immediate mode GUI framework to streamline the creation of dialogs. In hindsight, I should have invested more time into building the editor early on instead of focusing primarily on the engine. Creating simple test maps by hand was manageable, since I use the JSON format for the maps (which I plan to replace with a binary format later on). But when it comes to building real maps, manual creation just doesn't cut it - so I'm implementing editor-side support for all existing engine features.

In addition to work on the 'Portals' editor, I've also made progress on havIDE (my C++ IDE). It now features a full dark mode, and I've started implementing debugging support via GDB. You can check out a new development screenshot on the projects page.

In addition to 'Portals', I've also started working on my own C++ IDE called havIDE, using C++23 and wxWidgets. What began as a curiosity project to see how challenging it would be is now becoming a serious project. I'll likely use it for future C++ work. For now, I've shared a few development screenshots on the projects page, if you're interested in seeing the progress.

While CodeLite allows searching for keywords in code comments via the Find in Files dialog, I wanted a more integrated solution that doesn't rely on search. This plugin provides a built-in task list directly within CodeLite, making it easier to track TODOs and other notes in C++ projects.

You can find it here: https://github.com/Havoc7891/havGSD

Surprisingly, the migration to SDL3 was straightforward! It took just two hours, and everything transitioned without any major issues. With the code successfully updated, I thought, "Why let this engine go to waste? Why not use it to create a simple game?"

I've always wanted to make a Sokoban clone, so I gave it a shot and built a 3D version using this engine. The result is The Pushing Point. You can find more details and screenshots on the projects page and download it from the downloads page.

I've also released a YouTube video where I complete the first level - feel free to check it out!

On another note, I started using the Duolingo app in July this year and received my Duolingo Year-in-Review a while ago. Apparently, I'm in the top 2% of all learners, which, honestly, just confirms what I've always known: I'm a linguistic (and musical) genius in the making. Who am I to argue?

To address this, I created a smaller serialization library called havSeriLite. Loosely based on the JSON and BSON formats, this library is much easier to use. While it doesn't use a standardized format and isn't as feature-rich as havJSON, it provides all the functionality I need for the 'Portals' editor and game engine. I've released havSeriLite on GitHub under the MIT license.

This update includes the following changes and fixes:

• The game no longer requires the ABGR8888 pixel format.
• Fixed flickering dialogs in the main menu.
• Fixed an in-game rendering issue where the game map was corrupted by the level up dialog.
• Fixed floor numbers in the "You are now on floor #x of the prison complex." messages.
• Added the ability to return to the previous floor. Note: both the previous and next floors are regenerated with new items and enemies. You will not receive a health bonus when returning to the previous floor, but you will receive a health bonus when returning to the next floor from a previous one.

This update includes the following changes and fixes:

• Increased the number of mixing channels from 8 to 16.
• Added a slight key delay to intermission screens.
• Added missing ceiling and floor textures in map 2.
• Improved the wording in the help section of the map editor.
• Added an additional "--windowsize " argument (e.g., "--windowsize 640 480") to change the window size in windowed mode.