Indie game storeFree gamesFun gamesHorror games
Game developmentAssetsComics


A member registered Jan 17, 2021 · View creator page →

Creator of

Recent community posts

Oh nevermind it works now.

By the way i meant that it was showing Firefox’s crash screen. I also tried running it on my secondary computer and it was showing a black screen.

I use Python 3.8.10 (on Linux Mint 20.3), and for some reason, the controls aren’t working.

Anyway, you can encode the tar archive into a QR code like a binary file.

Unfortunately, the web version of this game doesn’t work on my machine. I use the latest version of Firefox on Linux Mint 20.3.

Thanks! :)

By the way, at 2AM (Basically i did everything described in my last post from 11PM to 1:30AM) i came up with an idea that i also had earlier. I made a text file to describe how it works:

          /  \
         /    \
        /      \
       /        \
      /          \
     /            \
    /              \
   /                \
  /\    /\    /\    /\
 /  \  /  \  /  \  /  \
/ 1  \/  1 \/ 2  \/  2 \

Each player has to guess a word that has to do with the word on his left and right triangle.

          /  \
         /    \
        /      \
       /        \
      /          \
     /\          /\
    /  \        /  \
   /    \      /    \
  /  1   \    /   2  \
 /        \  /        \
/          \/          \

Now starts a cycle: Players 1 and 2 need to guess something that has to do with the words of both players. Whoever is the least accurate gets eliminated:

          /  \
         /    \
        /      \
       /        \
      /     1    \
     /            \
    /              \
   /                \
  /                  \
 /                    \
/                      \

Step 2 repeats for each group of 2 players, until there's only one player remaining in the triangle:

                      /  \
                     /    \
                    /      \
                   /        \
                  /          \
                 /            \
                /              \
               /                \
              /                  \
             /                    \
            /                      \
           /                        \
          /                          \
         /                            \
        /                              \
       /                                \
      /                                  \
     /\          /\          /\          /\
    /  \        /  \        /  \        /  \
   /    \      /    \      /    \      /    \
  /  1   \    /   2  \    /   3  \    /  4   \
 /        \  /        \  /        \  /        \
/          \/          \/          \/          \

                      /  \
                     /    \
                    /      \
                   /        \
                  /          \
                 /            \
                /              \
               /                \
              /                  \
             /                    \
            /                      \
           /\                      /\
          /  \                    /  \
         /    \                  /    \
        /      \                /      \
       /        \              /        \
      /          \            /          \
     /     1      \          /      4     \
    /              \        /              \
   /                \      /                \
  /                  \    /                  \
 /                    \  /                    \
/                      \/                      \

                      /  \
                     /    \
                    /      \
                   /        \
                  /          \
                 /            \
                /              \
               /                \
              /                  \
             /                    \
            /                      \
           /                        \
          /            4             \
         /                            \
        /                              \
       /                                \
      /                                  \
     /                                    \
    /                                      \
   /                                        \
  /                                          \
 /                                            \
/                                              \

I would use a simulated keyboard on the GBA to write words.

Every bottom triangle will contain a word randomly picked from an array of words; Actually, the array is a table that’s 3 words long; this is the dictionary. The first 2 entries are the entries that have to do with the 3rd word.

I’ll include every single noun in the English language, and sometimes the 3rd entries in the dictionary table will not be in the dictionary, like a “1-up” that has to do with “life” and “mushroom”.

(1 edit)

I’m sorry if you don’t like devlogs in your Community page, so please reply if i can continue to post here my game’s devlog or if i should do it somewhere else. By the way, once i post the game, i’ll put the devlog in the game’s page and (if you want to) remove it from here.

My first decision is to choose an engine; I’m a C programmer. I don’t want to deal with any low-level stuff, so a high-level C library with a lot of good documentation and examples (like some DS libraries I’ve used before and probably use again) would be awesome.

My first pick was gba-modern, but it had virtually zero basic examples or documentation so I can’t use it.

Then I looked at gba-plusplus, and (at least at first) it looked quite nice! OK tutorials to build my game from the ground up, and overall a pretty good library!

So I decided to select it.

Though, to use it, obviously, I’ll need to install it first.

So I immediately git cloned the repository and tried to build it with cmake

And my version of cmake was too low. So I got around that by editing the minimum required version of cmake

And I was missing SPHINX_EXECUTABLE, with the error “Cannot find Doxygen”.

I have no idea what it wanted to build, but I installed every single sphinx package I could find and tried again. And it complained about Doxygen. So I installed that and tried again. And it complained about a dot component of Doxygen. So I installed every single Doxygen package that exists and tried again. Now it complained about some error I didn’t understand:

CMake Error at CMakeLists.txt:8 (set_target_properties):
  INTERFACE_LIBRARY targets may only have whitelisted properties.  The
  property "LINKER_LANGUAGE" is not allowed.

-- Configuring incomplete, errors occurred!
See also "/home/<username>/Documents/Code/gbapp/gba-plusplus/CMakeFiles/CMakeOutput.log".

At this point, I just game up and uninstalled every unnecessary package I installed. The only thing it would have built anyways was the Doxygen wiki…

So I went and took a peek at the include/gba directory, and found the header files of the library. Turns out I could just use it right away!

But I still needed to create the project with a Makefile, and I realized a problem…

None of the examples were building. It turns out that the environment variables weren’t set in the root user, and because the examples were in a directory that I couldn’t write to without root privileges, I was forced to compile as root. So I copied one of the examples to another directory I had write access to, and I got Permission denied.

Turns out the directory itself was write-protected for me. I chowned the directory to me and it finally built.

And it worked like a charm.

Now I had to just copy the Makefile over to my game’s directory, copy gba-plusplus to it, change the game’s and directories’ names to my liking and I was good to go!

But then I had to decide on the name of my game, and none of the themes were particularly interesting or I couldn’t think of good ideas for them, but I really wanted to use one of the LOWREZJAM’s themes.

After a lot of thinking. I had these ideas:

  • A platformer where you go through wells to change gravity…

And that was it. So i setted up everything i needed while i thinked of some ideas.

But in the middle of setting up, i noticed one of gbaplusplus’s examples and went “oh no this is too complicated”. So i changed to Butano.

I git cloned Butano into a directory and compiled the text example. It took a pretty long time to compile, even with all my cores.

I copied the template to my game’s directory and set everything up to run and compile with Butano, but had to modify the Makefile a bit to point to the corrent location of Butano.

Here’s the setup i used:

  • OS: Linux Mint 20.3 Una
  • Butano directory: “./butano/butano”
  • Emulator used: mgba-qt
  • CMake version: 3.16.3
  • Make version: 4.2.1
  • Editor used: Vim & Gnome Builder
  • G++/GCC/C++/… version: 9.4.0

I wrote this post as i went through everything i did in this post, and i still haven’t comed up with a theme, so it took me hours to write.

EDIT: I put Butano’s directory inside of the source code, so that it can be directly downloaded and builded without needing to first build Butano.

I decided to use a resolution of 64x64, by rendering everything to 3 64x64 sprites (that I will call the “display sprites”) and scaling them 2x; there are 3 “display sprites” on top of each other, so there are 3 layers, and virtual sprites (like the player) have to be rendered directly to one of the three layers, like background elements.

I previously asked this question on the LOWREZJAM’s Community page, but…

I’d like to know if I can make a game that conforms to the 64x64 limitation and runs on the Game Boy Advance.

I’d like to know if I can post a game to both the GBA Jam and the LOWREZJAM (Making a GBA game confined to 64x64 pixels or about 11% of the screen).

In the case of block-based programming language, you should ensure that all the code in each sprite (not combined, so you can have as many sprites as you want) fits into one screen of the editor, at the most zoomed out.

Oh, and btw online games are an exception to Rule 3, therefore they are valid in this jam.

(3 edits)

I’ve considered 2 meanings of this theme:

  1. You connect “nodons” (circles) to perform math. (This isn’t a game idea so I wasted just 2 days)

  2. You control 2 entities at the same time, and one’s controls (and the world) mirror the other (eg. if one goes left, the other one goes right). There are only a few differences between the left half of the world and the right half, and you have to use these differences to complete the level by desyncing the 2 entities. Thus they are connected.

  3. You connect some wires so that electricity can reach the other wire.

(5 edits)

Thanks a lot for your help! Though I still have 1 problem:

I don’t know if Talonlang supports SDL (it would support it only if the interpreter would), so I think that for Talonlang I’ll have to make a text-based game, maybe with ncurses. I would like to know if I can directly import Python modules from Talonlang (since its interpreter is written in Python).

Update: I can’t.

I don’t think I’ll have enough time to make 3 completed games, so I’ll start with the Talonlang game, then (if I have time) I’ll make the Ruby and Go ones.

Also, the Ruby gems package manager gives me a lot of problems. Still, I just can’t get Raylib to work, and I doubt that SDL will; by the way I have the dev packages of SDL2 and Raylib installed (the latter as a static library), I use Linux (more specifically Mint) and use Windows only for C# stuff, basic C/C++ programming with CYGWIN, or GameMaker Studio stuff (that I can’t get to work, but I think I’m derailing too much).

Lastly, I couldn’t come up with any ideas for the games. I think I’ll just generate some ideas using a generator and select the ones I find interesting.

(1 edit)

Update: I wasn’t able to get Raylib working on Ruby or Rust. I don’t even wanna try with Go because I know that it would be a headache.

I’ll just write these games text-based with ncurses for now.

Also, I replaced Rust with Talonlang because… primarily ownership and borrowing. Plus, I think Talonlang is pretty nice for this.

(1 edit)

I chose Ruby, Go, and Rust.

  • Ruby because it has a nice syntax.
  • Go because it is pretty similar to C, a language that I regularly use.
  • Rust because it is very interesting to me, plus the same reason as Go.

All of these 3 games I’ll make (or less if I don’t have enough time) require a graphics library; normally I’d use Raylib, a very nice library that has bindings to all 3 programming languages I selected.

But are there any alternatives that aren’t in the “gray area” between frameworks and libraries? Or should I just make a text-based game?

(1 edit)

Thanks for the reply.

Can I use non-game-specific code that I’ve already written? While I was making one of my unreleased games, I made a non-game-specific file containing classes and functions for creating vectors and other useful things; just utilities that all the games I make share.

If you want to know the full list of utilities in this file (excluding ones I might add in the future), here’s a list:

  • A distance function that calculates the distance between two vectors
  • A function to create a vector from a list of numbers or an array of numbers
  • A class to store data about a shape (the vectors. the calculation operations, and the color)
  • A function to split a string by a delimiter
  • Functions to do math operations with vectors instead of single numbers

I can also show the code if you want.

I have two questions:

First, does the game have to be for a specific system?

I would want to know if my game needs to be able to run on machines that have floppy disk drives (for example, old DOS computers or Commodores) or my game can be able to run only on Linux (or only on Windows), and no other platform.

Second, I can’t understand the phrase “No third party media” in the rules;

If no third-party media at all can be used (including compilers, OSs, etc.), then I would have to write my game directly in machine language and would have to write everything from scratch, and it would take me over a month to get even a basic platformer.

There are a lot of different meanings to this phrase, and I would kindly ask you to rephrase it. Thanks.

When i ran it on Linux for the first time, it deadlocked my entire computer (I could only move the mouse on a black screen, nothing else worked, not even closing the screen of my laptop or pressing the power button). Then after hard-rebooting, the game will get to the Unity splash screen, fade, and then close.

I typically use a 14” laptop screen at 60hz (I think), with a resolution of 1920x1080 pixels. I also have a secondary monitor (that was my primary monitor until I bought a laptop), 24” big. Those measurements are just guesses; I don’t remember what the box of my monitor or laptop said about my screen size.

The mechanic of this game is excavating blocks with the mouse, creating a path to the green block while avoiding red blocks, and then pressing R to let the robot character follow the path. If the robot hits a red block, he gets teleported to a random level and you lose some points. If instead he hits the green block, you go to a random level and gain some points. I'm rapidly updating this game so this mechanic might change slightly in future updates, though i want to make sure that anyone can play any version of the game.

/n is only for javascript,

so you should use multiple commands for multi-line messages.

.BAT files are lists of instruction to be done by te command prompt,and all of the commands are just DOS commands.

I think yes.

I don't know anything of the 386 assembly, and also I'm too lazy to learn it. But BAT is a pretty Simple language.

I always use fantasy consoles (tic-80, pico-8, pv8, ect.) to make games, and the best games i make are for fastasy consoles.

why didn't you post it in your jam's page?

I'll make a second jam, and you'll upload it during the second jam

yes, you can do anything as long as the js code can be encoded into a qr code.

No. You have to make the music, the code and everything else fit into the size limitation.

I mean that you should use the normal 16-bit color, not more. Only 65536 colors

include a index.html file with the submission, that contains only a command that runs the js code

Nevermind. Do wheateader you want, as long as the entire js code fits and it's encoded into a qr code.

(1 edit)

Ok, good!... But when will Tony develop the free version?

If he doesn't, I buy the Steam version, decompile it and cut the features i mentioned, then I release it.

I'll include this free version into a collection i'll make

Well... BASIC8 isn't free, and probably i will be using it for just this jam.

I think that for me BASIC8 is just a waste of money, because i'll use it for this jam and then abandon it.

When it comes to fantasy cosnoles, i usually make JS games with the TIC-80 or the SCRIPT-8. So spending $13 on a fantasy console that i'll be using for only one time... Just isn't worth it. I'd consider to lower the price a bit, maybe to $10, where it is more affordable. Then, if you'd lower the price for me, i could sponsor it, or even make a commercial.

To make the user base more big, and not do the same "mistakes" the PICO-8 and other paid fantasy consoles did, i think you should make a free demo version of the BASIC-8 to be more competitive to the other paid fantasy cossoles. in the demo version, the user should be able to:

  • Make a game
  • Use the sprite/tile editor
  • Use the map editor

Howeaver, with the following limits:

  • The user can't save disks.
  •  The user can only use the game dev. tools for a limited amount of time (For example, 4 hours)
  • The user can't use any advanced tools.

I think that this demo version would bring more users to the fanbase.

This isn't even a game.

Ops... I'm lazy.

there's no discord server for this jam.

in this jam?

You need to do it step by step.

  1. Incorporate the CSS file into the HTML file
  2. Use javascript commands to build the HTML file, for example you should use "document.createElement("canvas");" to make a canvas element.

Yes, to use html, you need to build the html from the js file itself like you described.

My idea for a tool is a Fantasy Console, programmable in BASIC

I need a fantasy console that's programmable in BASIC and that has maps that function like the ones of the TIC-80, i mean that the camera scrolls throuth the map smoothly on the TIC-80 and other popular fantasy console, while in others (like the LowRes NX) the programmer has to load gradually the map from another source, beacuse there's a map buffer that's small, like old games on the Sega Genesis. I was able to make this comparisons emulating Sonic 3 for the Sega Genesis in BizHawk, and looking at the backgrounds in the Video RAM Scanner. I can see that the level isn't loaded all at once, but it's loaded in 32x32 backgrounds gradually, if i had made a platformer with powerful debug tools for both the TIC-80 and the Sega Genesis or the LowRes NX, you would see that if you teleport to a long distance away from the current camera position, you would see that in the TIC-80 version the camera centers at the player position immediately, because it has previously loaded the entire map at once, while in the LowRes NX version, it would take some time to move the camera to the player's position, because it need to gradually load the map to find the player's coordinates and go to them. This waiting would be hard to see with fast fantasy consoles, because the camera scolling routines are very fast.

Also, if the map buffer can't hold the whole map at once, the programmer has to make complex routines to load the map gradually, which would waste time and get the programmer frustrated. While in fantasy console where the map is loaded all at once, even a beginner programmer has to only use a few commands and he can scroll the map smoothly without any bugs or trickeries to worry about.