It's common to come across memes comparing two distinct ways of doing the same thing, one being the "nutella" way and the other the "root" way. In the first case, usually elaborate and technological resources are used to solve a problem, while in the second, things are done in a more straightforward and no-frills manner.


It's not uncommon for me to express my fascination for retro games, those that manage to engage players with minimal resources, keeping them immersed in gaming sessions for long periods, despite their often primitive aesthetic resources. As a game developer, I usually look at these games in a different, more technical and analytical way, so that I can use my findings and conclusions in the development of my own games. The issue I want to address is that despite this love for the old and all the analyses and conclusions I draw from my assessments, in the end, I turn on my modern notebook, load my modern development environment, choose my favorite modern programming language (Python), open my modern image editing and sound effects creation software, to ultimately create games with an old-school style!


There's nothing wrong with developing retro-style games using modern tools; on the contrary, I believe it's a great path. I'll call this path "nutella development" here. However, in my case, there was always that feeling that I was cheating. Deep down, I didn't feel like I was truly creating something retro because something very important was missing: subjecting myself to the technical limitations faced by developers at the time these games were created. That's when I decided to reminisce about my childhood days, with my incredible Amiga 1200, and try to create a game directly on that platform, subjecting myself to all sorts of technical restrictions inherent to the machines of the 1980s and 1990s. I'll call this path "root development."


The first challenge was trying to revive my old Amiga computer, and I was unsuccessful. I couldn't find the power supply or the mouse. I also realized that I couldn't easily connect it to a monitor with HDMI input, let alone to a current television. My old floppy disks with the software that would be used for game development probably wouldn't work anymore, and even if I had a solution to all these problems, there would be no guarantees that the computer itself would turn on and work without issues. Because of all these problems, using hardware from that era was out of the question.


Fortunately, there are emulators that can provide us with the entire software environment of the era on modern machines. I took advantage of a Raspberry Pi board that was lying around and installed an Amiga emulator on it with incredible results. After everything was installed and running perfectly, my feeling was as if my old Amiga 1200 was in front of me. The experience was identical to what I had in the past. After exploring the "new" operating system to remember how its basic operations worked, it was time to choose the programming language I would use for developing the new games.


I remember that at the end of the 1990s, I used to buy a magazine about Amiga computers at newsstands that came with floppy disks containing various public domain software. In one of these magazines, there was a demo version of a development environment for the Amiga called AMOS Pro. This environment is basically the Basic programming language enhanced for game development, with many routines and tools commonly used by developers. I was a child at the time, and the only thing I could do with it was to run the example programs that came with it to demonstrate the language's potential. Fortunately, today, with my hair graying, software development is no longer a mystery to me, and I decided to use the AMOS Pro programming language for my endeavor. It was time to eliminate that frustration of a boy who couldn't understand how all that code worked.


With my Amiga computer running on the emulator installed on Raspberry and the programming language defined, I needed to decide what type of game I would develop. I decided to fulfill a wish, which was to pay tribute to an old friend, my dog Marley, who in 2021, due to a medical error, passed away at eleven years old. Marley was an Italian Greyhound, a miniature version of those racing dogs. Because of his breed, he was quite thin and slim, earning him the nickname Skinny. Marley loved to hunt around the house for my personal items to take to his little house before going to sleep, so he could spend the night surrounded by my scent. It was common for me to find socks, letters, keys, clothes that he would sneakily grab from the clothesline inside his house. I decided to create a game called Skinny Marley, with the premise that the game would be based on Skinny's characteristic of taking my things to his little house.

My old friend Skinny Marley.

With the game's name and premise defined, it was necessary to determine its mechanics. After researching a bit, I realized that the mechanics of the Sokoban game would fit well for my game. In Sokoban, the player needs to push blocks to specific positions within the game map, taking care not to block their movements. Since it's only possible to push the blocks, great care must be taken not to push them into a position where they can no longer be moved. I thought about adapting this mechanic a bit for my new game, Skinny Marley. My idea was to place Marley's little house in a position on the screen with marked areas around it. Scattered throughout the map would be some objects, such as letters, slippers, socks, etc., that Marley would need to push into the marked areas next to his house. When all the objects in the level were positioned in the marked areas, the player would finish the level, being directed to the next one. Obviously, the challenge is the same as Sokoban, namely, being careful not to move the objects into positions that would block them, forcing the player to restart the level from scratch.

With the type of game to be developed defined, the real challenge began. First, I needed to learn how the AMOS Pro language works, with its limitations and potentials. The big problem here is that because it's such an old technology, there simply isn't an abundance of materials on the internet. The availability of content is extremely scarce, limited to a few videos on YouTube and some language manuals in PDF format. Fortunately, I found some source codes for programs made in AMOS Pro in the past, as well as some code examples created by the language developers themselves. I also found the language manual in PDF format, containing descriptions of its main routines and technical characteristics. With this material in hand, I could already do something.

Start Screen of Skinny Marley game.

I started with the basics, such as how the language's variable types work, how to create conditional structures, how to create repetition structures, how to create routines, read user input, write on the screen, etc. Despite its peculiarities, the AMOS Pro language didn't show much difference from current languages in these points. The next step was to understand how I would draw graphic elements on the screen. Here things started to get a bit more serious because I began to worry about more restricted color palettes, also more restricted screen resolutions, and the amount of memory used by my graphic elements. Every pixel started to be important to avoid excessive memory consumption. I also had to worry about the size of my source code, because there came a point where the development environment simply didn't accept more than 32 KBytes of source code. Until I found where I could change this setting, I had to struggle to optimize my algorithms more and more.


One thing that almost drove me crazy was the great shortage of data structures. I couldn't create Classes, Hash Maps, Structs, etc.. For a developer accustomed to the Object-Oriented paradigm, these things are sorely missed. I had to settle for working with Arrays containing a maximum of three dimensions at most. I was also very limited regarding String manipulation because the language doesn't offer ready-made routines for that, and I had to create all my routines from scratch.


Despite the limitations I faced, it was very rewarding to work with the AMOS Pro language because I was forced to put into practice many principles of Computer Science that often get "lost" due to the great facilities that current technologies offer us. Developing with such limited resources forces us to truly understand what we're doing and not to waste a single byte of system memory. Not to mention the optimization challenge because any "fat" in the code starts to make the system lose performance, becoming practically unusable.


This experience served to show me that the pioneers of game development deserve all our respect because they created an entire industry with extremely scarce resources. Furthermore, I leave here my tip for those who really want to become good game developers; if you truly want to understand what you're doing and move to the next level, develop a game from scratch in a truly retro environment. You will evolve a lot technically and also in game design, needing to always think in an optimized way, so that when you go back to more modern tools, everything will seem much easier.


Oh, and before I forget, the game was published on itch.io and can be found at the address https://tooizzi.itch.io/skinny-marley

Want to know how to play? Start right now by embarking on the adventure of installing an Amiga emulator on your modern computer (I recommend the WinUAE emulator) to get a taste of everything I wrote.