Hi all,

We've finished our next game, Crypt Sweeper, after ~2 months of development.

Links:

• Digital Release (Pay What You Want)
• Physical Release (cart only)
• Source Code

I thought this community might be interested in some of the development and history as well.

We have been working on a platformer for a while, but started to feel stuck. I'm always on the look out for interesting games, and stumbled on this article from ArsTechnica, where they clued me into DragonSweeper.

It took me a while to figure out the game, but once I did, it was really addicting! I kept discovering new mechanics and ideas, and fell in love with it. I thought it would be a great idea to port the game to the GBA, and reached out to the developer (@danielben). He didn't want me to use his assets, but suggested I clone the game instead.

This seemed like a project I could tackle in a reasonable amount of time so I got to work. I made a basic clone of how I understood the game, and then dove into the original DragonSweeper code to look at the level generation.

DragonSweeper's level generation is really interesting -- the basic idea is to place monsters on the board, then score how "happy" the monsters are, and wiggle them around until their "happiness" is maxed out.

I attempted to port this same basic logic to C, but when I ran it on the GBA, it took 40+ seconds to generate a level! This was not acceptable.

I ripped out the level generator, and rewrote it from scratch, based on my new understanding of how the game worked. There are a lot of constraints that need to be maintained, but in principle, it's still very easy. For example, the walls are always placed in pairs (horizontal or vertical). Most monsters have placement logic as well. Instead of encoding the preferred placement as "happiness", I just placed them directly in the structure I wanted, and gave up and started from scratch if I failed after 100 attempts.

The level generation still took a while though, 15-20 seconds (iirc).

My solution was to do all level generation at compile-time. This actually turned out to be a really good decision.

A side effect of doing level generation at compile-time meant that I could do additional analysis on the levels. In particular, I wanted to have 5 levels of difficulty, with harder monsters spawning on more advanced levels, but also the boards themselves needed to be analyzed for their difficulty in reasoning.

So I created an AI that could play the game, based on different amounts of understanding of the game. For example, the base level understanding is just math. But I could also add knowledge of how the monsters behaved into the AI. That meant I could run the AI against a board with different levels of understanding of the game.

At compile-time, I generate 1024 levels per difficulty, and in order to validate that a board conforms to a difficulty level, I let the AI play the board with a certain level of understanding. If it can beat the board at that level of understanding -- and not at a lower level of understanding -- then I can be certain that the board has a certain level of difficulty.

This does increase compile-time quite a lot, but it's a fixed cost.

This is a similar technique I've done for Sudoku boards, for example. It's hard to generate an easy board from scratch, but you can generate lots of boards, validate they have one unique solution, and categorize them after the fact. This is roughly what I do for Crypt Sweeper as well.

One last step, since the player only has 1024 unique levels per difficulty, that felt a little small. In order to increase variability, I also shuffle the two lowest level monsters randomly on the board, at run-time. These monsters are always placed randomly, so shuffling them around after the fact shouldn't alter the difficulty that much, and hopefully provides a tiny bit of variety at run-time.

Lastly, now that I had everything working, I got a little creative with the monsters. I did copy a lot of the monster behavior from DragonSweeper, but I added new monsters, variations of monsters, dropped some of the mechanics I didn't understand (gnome?), and reworked some mechanics specific to the GBA (Dracula's Ire).

After all that, I gave it to my wife, who did all the graphics and came up with the story. I wrote an 8-bit rendition of Moonlight Sonata for the soundtrack, and added final touches, like sound effects, and an in-game tutorial.

Anyways, we hope you enjoy the game! We decided to release it as Pay What You Want because we took so much from DragonSweeper, which is also a free game, so it didn't feel right to charge for the game. At the same time, if people want to give us money, that would be great, because it helps us make more games!

Thanks for reading!

Sean

Hello there ! :D

I'm Simon from Neofid Studios,
We create new games for retro consoles (Demons of Asteborg, Astebros, now working on DaemonClaw for the Sega Genesis)

After spending many years developing for the Sega Genesis, we saw the evolution of the Butano devkit and we had to give it a try !
So we decided to remake our first game "Demons of Asteborg" in a Deluxe version !
Here are some gifs showing the current state of the project !

You can try the demo of the game here

We are currently running an Indiegogo campaign to make this project a reality, we are also creating a NeoGeo version of the game for those interested !
You can support the project here
We only have a few days lefts, I really hope we'll be able to make it, I hope this project will speak to you and that you'll have as much fun playing it as I had developing it!

Thanks for your time and attention !

It feels surreal to finally be writing this but... Goodboy Galaxy for the GBA released earlier this week!

It's an exploration platformer about a dog in space, which myself, Rik and so many friends & collaborators have been working on for the last 2.5 years (or 5 years if you include the demo!). We've poured absolutely everything into this project and we really hope you enjoy it after all this time! <3

You can buy the game digitally on itch.io: https://goodboygalaxy.itch.io/goodboy-galaxy-gba

Physical carts are currently in production, and can be preordered from First Press Games.

The game was made in the Nim programming language and uses the following libraries:

• Natu (in development) - Nim GBA programming toolkit
• libtonc - text rendering and many other utilities
• maxmod - music / sound engine
• libugba - interrupt handler
• ACSL - heap allocator / C stdlib replacement
• posprintf - string formatting
• Cult-of-GBA BIOS - RLE Decompression for video cutscenes
• agbabi - memcpy/set + coroutines
• nimcoro - high-level coroutine wrapper
• gba-rumble - brrrrrrrrrrrrrrrrr
  Full game credits here.

We're currently working on the native PC and Switch ports, which will be out next year, but I figured I'd post about the GBA release here for posterity. Lemme know if you have any questions!

Hey all, we had some spam accounts joining recently, so I've added a simple captcha quiz to the registration form.

Hopefully this solves the problem! If not, we may have to explore other solutions.

160p Test Suite is a port of Artemio Urbina's 240p Test Suite to Game Boy Advance. It has two goals:

1. Evaluate TV sets and video processors for ability to handle retro console video signals.
2. Turn a game console into a test signal generator to help in calibrating the black, white, and color levels and geometry of a display.

The port to GBA was originally requested by Extrems for testing Game Boy Interface (GBI), a Game Boy Player Start-Up Disc replacement app for Nintendo GameCube. It has since been used inside Nintendo, as reported by Kyle Orland of Ars Technica. It's been a long time since version 0.22 in November 2020, and even that was after forum.gbadev.org began to run into serious problems with its PHP installation.

Highlights from the past two releases:

0.23 (2023-03-03)

• Help: fix blink sprite alignment
• Credits: Display version from Git commit tag and ID
• Credits: Pino has moved to the Fediverse
• Motion blur: add health warning
• Motion blur: increase duration cap to 60 frames (requested by zeta0134)
• Motion blur: do not edit parameters while running
• Shadow sprite: add Donna
• Rename Manual lag test to Timing and reflex test to reflect how it is used
• Hill zone scroll test: Switch from laggy libgba IRQs to HDMA to reduce split artifacts
• Backlight zones: add speed control for measuring afterglow time

0.22 (2020-11-04)

• Color bars: A to toggle NTSC 7.5% setup
• Color bleed: Rearrange to 10 rectangles
• Add a back story for mascot Gus

Download ROM and source zipfile or from the GitHub release

Recently, I've been reading the SFML Game Development book.
It covers a lot of topic about gamedev from scratch, including state stack based Scene class, GUI, command pattern, etc.

As a practice, I'm going to port Creepy Castle to the GBA, using Butano engine.

As it's an unauthorized port, I won't release it other than some video recordings...

Nothing much, only the GUI stuff for now;

The button implementation is a copycat of this menu implementation, but I'm not dynamically allocating it.

// buttons as member variables of the scene
ui::Container<4>           _uiContainer;
ui::SaveSlotButton         _btnSaveSlot[SAVE_SLOT_COUNT];
ui::IconTextButton<1, 4>   _btnBack;
ui::IconTextButton<2, 8>   _btnDeletion;

// initialize the buttons
_btnSaveSlot[0].setSaveFile(&_fakeTestSave1);
_btnSaveSlot[0].setPosition(SAVE_SLOT_BTN_START_POS);
_btnSaveSlot[0].setCallback([this]() {
    reqStackPop();
    reqStackPush(SceneId::GAME);
    getContext().saveFile = &_fakeTestSave1;
});
...

// add the buttons to the container
_uiContainer.addElement(&_btnSaveSlot[0]);
_uiContainer.addElement(&_btnSaveSlot[1]);
_uiContainer.addElement(&_btnBack);
_uiContainer.addElement(&_btnDeletion);

I'll work on loading 16x16 meta-tile based tilemap on this week.

Hi! Even though this isn't new, I'm going to leave a post here to get some exposure.

https://github.com/AntonioND/gbt-player

GBT Player is my music player for GBA (old versions supported GB/GBC). It uses the PSG channels (1 to 4, the ones that come from the GB). This means that the music you can make with them is fairly limited, but it doesn't need to use any CPU for mixing audio. Other players, like Maxmod or Apex Audio System, target the DMA channels, which means the music can be as complex as desired, but by using a lot of CPU to mix audio.

With GBT Player, you use a mod tracker like OpenMPT, create a S3M file with your song, and convert it with a python script. It generates files with the converted song. Then, you pass this data to the music player library (which is very small), and that's it!

PSG music players like GBT Player can be very useful for games that need a lot of CPU for other tasks (like for 3D software rendering), or for multiboot games.

Also, there is always the option of using both systems at once! This is an example that combines Maxmod and GBT Player. The music composer has to create a S3M file in which the first 4 channels are special (they correspond to the PSG channels of the GBA), and the rest are free to use as needed. GBT Player includes an utility that will split this S3M file into two, so that you can use the PSG part with GBT Player, and the rest of the S3M file with any player you like!

https://github.com/AntonioND/gbt-player/tree/efd8e754c9ae0ca444d48fced58ca99f0510faaf/gba/examples/combined_maxmod

And it isn't needed to use devkitARM to use this library, it's self-contained, all you need is a C compiler to use it!

Feel free to leave suggestions and bug reports in the repository, and I'm happy to help here if there are doubts about how to use it!

On desktop, I love using a library called Allegro, and they have their own game jam community called TINS; and along came the KrampusHack, which is a secret santa game jam thing. I thought it might be pretty interesting to join in...

Each participant submits a "wish list", and at the start of the jam, you are presented with one of the other participants wish-list. None of it is "required", but it is encouraged to try and fit the brief. The one I've got has some bits I think I'm capable of, and within the limits of the GBA too...

But wait... why am I annoying the GBA community with an Allegro jam... Well, Allegro is preferred, but not required, and whilst I am using Allegro, my game engine builds for both desktop and the GBA! So you'll all be getting a little Christmas game at the end of December, start of January.

Dev logs are encouraged on TINS, so I thought I'd kind of double-key and give you all the exciting news of my production too...

Apotris is an absolutely stellar block stacking game for the GBA by @akouzoukos, which supports guideline rules, several game modes, heavy customisability, a banging soundtrack, and link cable multiplayer. Last month it had a physical release by insideGadgets, which sold out pretty quick, but is now back in stock.

You can order a cart (with optional rumble!) from shop.insidegadgets.com/product/apotris

or read more and grab the ROM from akouzoukos.itch.io/apotris/devlog/452358/apotris-v34-physical-release

The GBA Jam 2022 has come to an end!

You can find the final results and download links for all 26 entries at gbadev.net/gbajam22.

Many thanks and congrats to everyone who took part. Hope to see you all next year! (whether it'll be a big jam or something more relaxed like last year's winter jam is undecided, but we'll keep you posted!)

Also, @avivace recently added a web build of mGBA to the Homebrew Hub, which means you can play all the entries in your browser too. So go and try them out if you haven't already!