Quote:Original post by MarminQuote:
The arcade games made 20 years ago were not extremely complex. They were extremely simple compared to games made now or even compared to other kinds of software written back then.
Those arcade games had not been programmed before, the programmers had to find solutions to comletely new problems with minimal tools and low freq. CPU's .. Rygar for example must have been be very hard, almost imposible to program with a simple assembler tool. How did they keep track of all the data? Paperwork hm.. and . the debugging and testing?
I didn't own a C64 but a MSX, and I did some Z80 - assembler programming. What I found difficult was to keep track of all the labels etc. (what is now easier with OOP.)
Would those software houses still have their source code?
I wrote a turn-based wargame for the Atari STFM way back in 1991. It was my first substantial game project and I learned everything from scratch. The source code fitted inside a single text file of approximately half a megabyte in size. I was using HiSoft's GenST development software -- basically an assembler and debugger -- and OCP Art Studio for the graphics. (I have an arts background; the programming stuff is something I sort of fell into by accident.) Oh: and two floppy disk drives. (The game was called "Mythical Warriors" and completed up to the Beta stage, but never saw a release as the publisher went belly-up.)
Unlike most developers, even during my day, I tended to work from home and developed directly on the target platform. Most software houses of the day had already moved to using cross-assemblers such as SNASM and PDS, which ran the IDE and assembler software on a PC and squirted the finished game code over a cable to the target computer. The only reason I didn't do this myself was because those kits cost a small fortune and I never missed them. During my days learning to code in assembly language on the ZX Spectrum, I was using a cassette tape for storage. As you can imagine, a lot of my time and effort went into avoiding the coding of bugs in the first place as a crash meant about 5 minutes of reloading the IDE and source code.
As for the wargame itself: I wrote all my tools first, then worked on the game itself. One of the hardest parts to get right was the pathfinding algorithm. Since my maps, rather naively, included streams, this made the task even harder. In the end, I effectively ended up reinventing the A* algorithm since the World Wide Web didn't exist back then and books on the subject were hard to find. It wasn't all _that_ hard: once you hit upon the idea of 'scoring' each tile on the map, A* follows naturally.
Another trick games often use is to only create the _illusion_ of complexity. For instance, the 8-bit classic "Elite" claimed to have an insane number of galaxies for you to visit. In reality, planets were simply created by rolling a virtual die, grabbing a planet name from a set list and 'rolling' the planet's stats as if creating a character in an RPG. This was easily done using the pseudo-random number generators popular even today: give the generator a specific 'seed' number and you can guarantee you'll get the same sequence of random numbers generated each time. To create a new galaxy, you simply changed the seed and used it to 'roll' new planets.
This kind of 'fake' depth and complexity is quite common in games, even today.