The most exciting computer that I ever owned, and certainly one of the most significant in the history of personal computing, is the Amiga 1000, the first Amiga model released by Commodore in 1985. It was so far ahead of its time that almost nobody – including Commodore’s marketing department – could fully articulate what it was all about.
The Amiga was a revolution in every aspect. It could display 4096 colors and had custom chips for accelerated video. It had built-in video outputs for TVs and VCRs. It had four-voice, sampled stereo sound and was the first computer with built-in speech synthesis and text-to-speech conversion. And it’s still the only system that can display multiple screens at different resolutions at the same time on a single monitor. Moreover, the operating system was a true UNIX-like preemptive multitasking 32bit one, coupled with an advanced graphical user interface to tie it all together.
Programming it was a real challenge! The Amiga required me to learn brand new concepts such as multitasking and concurrent programming, resource arbitration through microkernel I/O interfaces, interprocessing messaging, GUI design and programming, multimedia (animation, digital audio processing) and 3d programming… It was really hard to learn and master all that stuff! I programmed far fewer games for the Amiga, but they were far more advanced than those for the C64.
I Tesori (Treasures)
Oh well, the very first game I designed for the Amiga was not so good; in my defense it must be said that it was written in the (horrible) AmigaBASIC from MicroSoft, the only development tool shipped in bundle with the Amiga. AmigaBASIC was limited, slow and there weren’t decent compilers for it, so it wouldn’t be possible to develop very good things with it (Commodore would replace it with better tools in the years coming).
Apart from the obvious limitations, “i Tesori” is a platform game featuring two Beobi, Pippero and Tucchero, searching for underground treasures. They need to eventually creep into some strange dungeons (provided you are good enough to find the keys to open doors) and face the dreadful Burubulli, terrible beings that can suck your very soul if you’re not skilled enough to avoid them.
The interesting part of the game was that you had to control both Beobi at once, usually with the second one following the first one. Should one of the two Beobi die, you had the possibility to return to the base camp with the other and “revive” the dead one, so that the game featured virtually “infinite lives” (but you must survive while travelling back)! Also, by returning to the base camp you could cash in the loot found so far and buy equipment useful to further advance in the game.
This was my first serious project written in C (using the Lattice development system): it was colorful, it was throwing big animated objects around the screen, it featured a dual-viewports, smooth scrolled playfield and a four-voices in-game soundtrack – it was, in fact, a “real Amiga game”!
“Cosmo Defender” has a very simple gameplay: enter an evil alien base equipped with a powerful laser-gun and blast off all those nasty things/beings/whatever!
The only limitation of “Cosmo Defender” was the game speed: it used the AmigaOS multimedia libraries and it didn’t bang the hardware directly (as many other games of the time used to do), so it didn’t achieve a very high framerate. It wasn’t super-smooth, because such big objects were quite a burden for the Blitter chip and more optimized routines (than the AmigaOS ones) would be required, however the speed was adequate and the game was still quite playable.
In the game you control one or two Beobi (depending on whether you play the game alone or with a friend), who need to safely return home. Unfortunately, they are trapped in a part of the city that is not only far away from their house, but also “controlled” by two rival gangs, Blesche and Coni, that will fight the Beobi and try to stop them.
“Beobi Teppisti” used smaller and fewer graphics objects than Cosmo Defender did, so, even if the game engine was the same, it didn’t suffer from any framerate problem. In fact, it’s a funny game, as it features quite an original fighting system: there isn’t anywhere an “energy” or “hp” bar; instead, to defeat an enemy you have to “push” it, by kicking/punching it, offscreen, either to the left or the right, while at the same time avoiding being throwed offscreen yourself. This leads to a very interesting (and funny) gameplay, especially when playing in dual mode!
I Tesori (remake – unfinished)
After becoming a competent C programmer I had the idea of a remake of my first Amiga game. “I Tesori” was quite an interesting product, from the gameplay point of view, unfortunately bogged down, performance wise, by the infamous AmigaBASIC interpreter; thus, a remake written in C would really make sense.
For that project I developed from scratch a brand new game engine that, using in a clever way the Copper custom chip, would feature not simply a double or triple buffer display, but a multi-buffered one able to animate at a very high framerate just every single “cell” of the maze (and not only the “sprites”); that would allow every object laying around in the underworld to be “alive”: treasures will shine, torches will burn, doors will open-close and so on!
Unfortunately, the project was never completed. Lack of interest in a game that, apart from the underlying technology, was nothing more than a clone/remake, led eventually the development to a halt. The only things remaining of this project are a very early prototype that just shows the game logic and some (unfinished) artwork…
This game was my first attempt to develop a racing car simulator. Despite being very rudimental, it laid the foundations for the following AVC car simulation library and the Virtual Grand Prix series.
In 1989 Atari released Hard Drivin’, a real game-changer in the “car racing game” genre, as it was a realistic, detailed simulation of a sports car, coupled with one of the first 3D polygon environments. I was simply fascinated by the realism of the simulated dynamics and, of course, I immediately started to think how could a similar result be achieved on the allmighty Amiga.
Programming such a game/simulator was a real challenge. First of all, in order to develop a 3D polygon rendering engine, I had to learn how to use the bit-blitter in the line drawing/filling mode, a thing that was not very well documented in the programming manuals and that required a lot of trial and error. Second, I had to develop a fast fixed point 3D math library (sorry, no FP coprocessor on the Amiga) for all the roto-translations and perspective transforms involved in the process of drawing the virtual 3d world. And, last but not least, I began to study the complex equations – and how to solve them in an efficient, real-time way – representing the dynamics of a sports car; that one was the most challenging part of the project (and, I must tell, the more intriguing), as the more I studied the problem, the more it became clear that some parts of the problem were still not 100% clear even to the insiders and that there was still a lot of research in the car dynamics simulation field; as a matter of facts, I had to resort to custom-crafting some algorithms by myself, a thing that started to ignite passion, in me, for the simulation field.
Impossible Drivin’, at the end, is a very simple (from the gameplay point of view) game: you drive an open-wheeled car around a 3d polygonal track as fast as you can without going off-track or loosing control of the car. Nothing more, nothing less (no race, no opponents, no time-attack mode). Yet, knowing what was going on (literally) under the hood, at the time it was the product of mine I was more proud of!
ThunderHell was born out of a bet: would it be possible to develop a shoot’em up that could stand on par with games such as “Xenon 2 Megablast” or “the Killing Game Show” entirely in C and without a single line of assembly?
Developed by crafting an highly optimized game engine that banged the hardware directly, ThunderHell is an horizontal scrolling (with three levels of parallax), fast paced shoot’em up full of enemies, bullets, explosions and all the bells and whistles that one could expect from a game of that genre. In fact, the game moves so many (sometimes very big) objects and enemies on screen that it’s quite hard to finish; so, for the first time, I added a cheat mode so that even friends not so skilled could complete it and see the game end!
In 1994 Commodore declared bankruptcy. However, many plans to buyout and salvage the Amiga platform were announced by different companies and the userbase was big (and very loyal), so development of very high-quality games for the Amiga continued at least until the end of the 90s; as an example, the Amiga version of Myst was released in 1997.
I wanted to give my contribute, too, so I started the development of Virtual Grand Prix (codename AlienF1). VGP would have to accomplish two missions: on the one hand, it would implement a fast 3d engine aimed at hi-spec’d Amigas (AGA and 68030 required) featuring gouraud shading, texture mapping, billboarding, curved surfaces and all the things that were “hot” those times; on the other hand, it had to be the most realistic simulation of a Formula One car available on the Amiga.
The 3d engine was the most difficult part of the game, as the Amiga bitplane graphics architecture makes it difficult to develop texture mapping or gouraud shading algorithms (many 3d engines on the Amiga would still use simple 3d solid polygons or were slow conversions of engines developed for the PC architecture and not really suitable for the custom graphics chipset). However, using in a clever way the bit-blitter and the bitfield instructions of the 68020/30 CPUs I was able to craft a very fast engine; I still remember how many emails of compliments I received by Amiga users from all over the world when I uploaded on Aminet the very first demo of the game!
For the car physics I started from where I left off in Impossible Drivin’; having more CPU power available I refined the algorithms (improving especially the tyre and the aerodynamics models) and added the possibility (mandatory in a real F1 simulator) for the user to change quite everything in the car setup (wings, shocks, tyres and so on)! The result was a very realistic open-wheeled car simulation, so realistic that some users complained that it was a bit difficult to push the car to its limits (but hey! We’re speaking F1 cars, here, it DOES require some skill and a lot of practice to master how to drive those monsters)!
The final game features the full 1998 F1 championship season with all the 16 tracks and the 11 teams (22 cars) of that year; the player can race against 21 opponents controlled by a competent AI on the full race weekend (free practice, qualify, race) and can choose between a single race mode or the full championship season (saving the partial results after each Grand Prix). Many Amiga magazines gave Virtual Grand Prix very high scores, and this game can be considered arguably my masterpiece for the Amiga.