You can see the code here, too: https://gist.github.com/axelei/dafd305213ed1b2655545f06edfbc905

# Programa para clonar prestashop
# Copyright Krusher 2015 - Licenciado bajo GPL3

paramfile="httpdocs/app/config/parameters.php"
extractDatabaseName="s/.*'database_name' => '\(.*\)'.*/\1/p"
extractDatabaseUser="s/.*'database_user' => '\(.*\)'.*/\1/p"
extractDatabasePassword="s/.*'database_password' => '\(.*\)'.*/\1/p"

if [ "$#" -lt 4 ]; then
  echo "Error: Se requieren 3 argumentos."
  echo "Uso: $0 dir_web_original dir_web_destino url_original url_destino"
  exit 1
fi

echo Traspasando de $1 a $2 \(urls: $3 -- $4 \)

databaseName=$(sed -n "$extractDatabaseName" $1/app/config/parameters.php)
databaseUser=$(sed -n "$extractDatabaseUser" $1/app/config/parameters.php)
databasePassword=$(sed -n "$extractDatabasePassword" $1/app/config/parameters.php)

echo Datos de la base de datos de origen: $databaseName / $databaseUser / $databasePassword

targetName=$(sed -n "$extractDatabaseName" $2/app/config/parameters.php)
targetUser=$(sed -n "$extractDatabaseUser" $2/app/config/parameters.php)
targetPassword=$(sed -n "$extractDatabasePassword" $2/app/config/parameters.php)

echo Datos de la base de datos de destino: $targetName / $targetUser / $targetPassword

if [[ -z "$databaseName" ]] || [[ -z "$databaseUser" ]] || [[ -z "$databasePassword" ]] || [[ -z "$targetName" ]] || [[ -z "$targetUser" ]] || [[ -z "$targetPassword" ]]; then
  echo "Error: Algunas de las variables no han sido extraídas, comprueba los errores y los directorios."
  exit 1
fi

echo URL de la instancia origen: $3
echo URL de la instancia destino: $4

read -p "Pulsa enter para continuar o CTRL+C para cancelar"
echo  "Procediendo con el traspaso."

echo Extrayendo base de datos
rm -f temp.sql
mysqldump -u $databaseUser $databaseName -p$databasePassword > temp.sql
echo Borrando base de datos objetivo
mysql -u $targetUser $targetName -p$targetPassword -e "drop database $targetName; create database $targetName"
echo Insertando la base de datos origen en la objetivo
mysql -u $targetUser -D $targetName -p$targetPassword < temp.sql
rm -f temp.sql

echo borra ficheros contenido antiguo
rm -Rf $2/*
echo copia ficheros
cp -r $1/* $2/

echo Configurando base de datos objetivo con los datos originales

sed -i "s/'database_name' => '\(.*\)'/'database_name' => '$targetName'/g" $2/app/config/parameters.php
sed -i "s/'database_user' => '\(.*\)'/'database_user' => '$targetUser'/g" $2/app/config/parameters.php
sed -i "s/'database_password' => '\(.*\)'/'database_password' => '$targetPassword'/g" $2/app/config/parameters.php

echo Configurando la nueva URL en la instancia destino

mysql -u $targetUser $targetName -p$targetPassword -e "update prstshp_configuration set value = '$4' where NAME IN ('PS_SHOP_DOMAIN', 'PS_SHOP_DOMAIN_SSL')"
mysql -u $targetUser $targetName -p$targetPassword -e "UPDATE prstshp_shop_url SET domain = '$4', domain_ssl = '$4' WHERE id_shop_url = 1;"
sed -i s/\\^$3\\$/^$4$/g $2/.htaccess

echo Terminado.

The implementation could undoubtedly be improved—using a more suitable language or more advanced tools—but this is the solution I came up with given the constraints of an environment lacking many essential utilities and commands. If you found it helpful, feel free to share your experience in the comments.

La entrada About how to clone a Prestashop instance se publicó primero en Nobody comes after the last.

However, over time, these computers swept everything aside. During their peak, Macintosh computers were a minority, and both the Amiga and Atari ST faded away. How did they fare in terms of sound to compete with them? It was the era of sound cards for PCs and compatibles.

The first PC was a modest computer. Its features were no better than, for instance, a Commodore 64, but it was correctly oriented towards business: a high-quality keyboard and monitor, a relatively open architecture, a decent microprocessor, and extensive documentation about its BIOS, which was replicated by third parties to the chagrin of the blue giant. These and many other debated details greatly contributed to its popularization, but that’s another story.

In this article, I will try to provide an overview of how sound evolved in PCs, what hardware was behind it, and of course, how it impacted the world of video games through the golden age of the PC and its omnipresent MS-DOS. For now, I am not familiar enough with the MSX world, for example, to expand to other platforms, but I hope that in the future I will hit the jackpot and have plenty of time to do so. However, I will attempt to explain the jargon and terms used to make the text intelligible. I promise to be brief.

The Beep, or PC Speaker

All we had in the standard PC regarding sound is what accompanied the first model, simply called the PC Speaker. It is a small two-and-a-quarter-inch speaker mounted on the machine chassis. An element that has remained in PC motherboards even today, being replaced by a less cumbersome piezoelectric buzzer.

The operation of a magnetic membrane speaker is well known: analog sound, transmitted via an electrical current, acts on an electromagnet that moves a magnetic membrane. The vibrations of this membrane, transmitted as pressure waves in the air, constitute the sounds we can hear.

Piezoelectric speakers are somewhat more interesting: they utilize the ability of certain crystals to vibrate in response to the electric current passing through them to directly generate pressure waves in the air. This allows them to be miniaturized to the maximum and made very cheap, though, of course, at the expense of having very poor sound quality. In any case, it is adequate for the characteristics of the PC Speaker.

But enough of Beakman’s World. Returning to our topic, the technical characteristics of the PC Speaker sound are really poor: it can only emit a 1-bit square wave signal with an arbitrary frequency. That is, just beeps at full volume with the frequency we want, which leaves us bare compared to almost any other system.

The PC Speaker operation is also simple. The controller is an Intel 8253, a programmable timer that controls the speaker voltage. The computer simply tells it when to beep and when to stop, communicating with it at ¹⁰⁵⁄₈₈ MHz. This strange figure was because it corresponds to one-third of the NTSC color burst frequency, and divided by the largest integer of 16 bits corresponds to the frequency of MS-DOS software interrupts. How wonderful! Right?

In the early 90s, a technique called Pulse Width Modulation (PWM) was used to obtain digital sound. This technique involves utilizing the physical characteristics of a speaker with high-frequency TTL pulses. Essentially, the physical parts of a speaker have inertia, so if a pulse is short enough, this inertia can dampen the movement and achieve intermediate states. Since all this has to be done via software, it requires frequent communication with the controller, meaning it needs a lot of CPU power to do it properly. The result was not spectacular and it has been calculated (by smarter people than me, mind you) to be equivalent to a 6-bit DAC with a response frequency of about 11 kHz.

Despite this, since all PCs had this device, it was widely supported throughout its history, and often well into the 90s, there were games that fundamentally used other cards that provided some support for the PC Speaker. A notable example was Digital Illusions CE (now DICE) games like Pinball Fantasies (1992). Trackers, popular amateur music production programs, also provided support, such as Impulse Tracker (1995) or Fast Tracker II (1994), among others.

Audio Peripherals in PCs

The operating system of choice for these machines was MS-DOS and its variants, and it wasn’t until the latter half of the 1990s that things began to change. Even then, and at least until 1997, it remained very popular for PC games. Since this system only supported the PC Speaker, how were sound cards used?

As the saying goes, with care. Since the operating system did not provide support, each piece of software had to be built to handle each specific sound card it wanted to use. Additionally, as each card used its own unique technology, it likely employed different sources (PCM digital audio, MIDI sequences, sound generator programs, etc.). Therefore, not all games supported all hardware, as not all were popular.

A popular way for a program to support various sound cards was through middleware, and by far the most common was the Miles Sound System, from 1991. Through these libraries, it was possible to program audio systems for games that took advantage of all consumer sound cards, often helping by unifying the game’s musical resources to work with all of them. It also made configuring hardware settings much easier through the wizards that were often included. (Who remembers SETSOUND.EXE?)

Configuring a sound card was not always a simple task. On operating systems like Microsoft Windows, everything was handled by the OS, and with the right driver, any program sounded as it should. In MS-DOS, the program had to access the hardware directly, and system resources were not always in the same location. Which port should be used? Which interrupt controls the card? Would there be a conflict with the printer port?

The most popular way to do this was, of course, through programs that could configure our hardware, assigning them free resources. We could then indicate to our game which resources we had assigned, or maybe the game could figure it out through environment variables. However, especially in the beginning, resources could only be modified by physically manipulating the card. This was done with jumpers that closed circuits on various contacts on the board, but in the early 80s, users often had to use a soldering iron or cutter to modify the card tracks. Fortunately, this was usually not the case in later PC times.

Which cards were the most sold or the most used in PC games? How did they work? Let’s look at the most common and interesting ones.

PCjr and Tandy 1000: SN76489

I’ve already written about this audio chip. Created by Texas Instruments in the early 80s, it was used in numerous systems throughout the decade and reached the PC through the PCjr in mid-1984, a (partially) IBM PC-compatible computer. More oriented towards the home market, it included an improved video mode, a chiclet keyboard, and a sound system featuring the SN76489. A few months later, the Tandy 1000 emerged, a clone of the PCjr with partial compatibility that tried to address both the original PC’s and the PCjr’s issues, while simultaneously introducing new incompatibilities with both.

This hardware had fairly modest capabilities: three square wave voices and one noise channel, resulting in mono output. Of course, compared to the PC Speaker sound, it was a significant improvement. The success of this sound addon was limited, as although the Tandy 1000 sold reasonably well, no other compatible PC included this chip, and no sound cards with it were sold.

In both cases, this sound chip could be programmed by writing to address C0h, modifying its registers. This further contributed to its limited success, as from the IBM AT (1984, the third PC model after the PC and XT), that memory address was reserved for other purposes. Additionally, proper sound cards would soon appear, but it still received support for some interesting games, like King Quest (1984, Sierra On-Line) on the PCjr. As we will see, Roberta Williams’ games were always at the forefront of PC technologies.

In the early 90s, with the launch of IBM PS/1 line, a sound card with suspiciously similar capabilities to the PCjr and Tandy 1000 was introduced to the market. It was simply called PS1-Audio, and it also had three voices and a noise generator, with sound identical to that heard on the two aforementioned computers. Besides the unique SN sound, it seemed to have a DAC for digital sound and included a joystick/MIDI port. I am unaware of the quality of this digital audio, but by the time it took off, there were much more interesting alternatives.

This humble writer only knows of a handful of games that supported it, such as a special edition of Silpheed made by Sierra in 1990. Another was King Quest 4 by the same company and the same year. Both supported the three musical voices and the DAC for sound effects.

Roland MPU-401

Probably the first professional audio peripheral for PCs was the Midi Processing Unit 401, manufactured by Roland starting in 1984. It did not provide audio capabilities to the PC at all, “just” communications in the MIDI standard. Variants were made for almost all systems, such as the Commodore 64 or the MSX.

The MIDI (Musical Instrument Digital Interface) standard establishes a protocol for communicating with musical instruments, as well as a standard for connectors. It was created in 1983 by a committee at the proposal of the Japanese company Roland, and from then on, all instruments adhering to it could communicate and cooperate with each other. One device could serve as a sequencer, another as a synthesizer, a third as a drum machine, and so on. The fact that a computer complied with this standard allowed it to be used as a workstation, and it is often cited as the reason the Atari ST succeeded in the professional music production world for many years.

Returning to the MPU-401 and the PC, there were several variants, each with slightly different capabilities, and some even had additional hardware with popular MIDI synthesizers. It basically consisted of an expansion card with a large connector to which one had to plug in an external box with most of the hardware. In this box, you could find MIDI IN, OUT, and THRU connectors, allowing you to plug in any instrument or device that complied with the MIDI standard. It also had a metronome connector and a tape sync connector.

There were two operating modes for this device: normal and UART (serial connection). The normal mode (also called intelligent mode) provided eight MIDI tracks, a metronome, and tape synchronization. The UART mode was just a MIDI connection, and it was supported by most clones and similar hardware. Intelligent mode fell out of use within a few years as it was easier to implement its functions with the PC itself.

This hardware alone was not very useful, as it only controlled other devices. If you had a synthesizer module or similar, however, you could achieve sound as good as your device could provide. The UART mode was widely supported by games as it was relatively simple. Just writing to port 330h (300h in some cases) with the notes was enough, and it would handle receiving them from whatever you had connected. As we will see, there were some truly remarkable gadgets that could use this interface.

Covox Speech Thing and Variants

In 1986, a very simple device appeared that allowed the PC to play 8-bit digital audio, and it was as easy to install as plugging it into the printer port.

The operation of this device was really simple, consisting merely of a ladder of resistors of increasing value for the eight digital outputs of the printer port. To achieve cleaner sound, some variants used electrolytic capacitors. Needless to say, although it wasn’t expensive hardware (about $80), almost immediately very cheap clones appeared, and one could even build it with a bit of soldering and skill.

Its greatest virtue was also its greatest flaw. Being a completely passive device, everything was under the control of the CPU. The 8-bit sound output could have any frequency you wanted, although the architecture of the printer ports made it difficult to achieve CD quality at 44.1 kHz. Additionally, the technique required to operate it consumed a lot of CPU time, as this device had no access to memory or any kind of buffer. It was necessary to constantly write values to the printer port, and both this and the control of intervals had to be done “manually” by your program.

One of the most popular variants was the Disney Sound Source, released by the ubiquitous Mickey Mouse company in the early ’90s. Externally, it was distinguished by having its own speaker, powered by batteries, but inside it had a fundamental difference: a small buffer memory that made it much easier to program and required much less control from the CPU. In exchange, the sound had to have a fixed sample rate that could not be adjusted.

The Covox did not gain much acceptance, although again, games from Digital Illusions CE offered quite good support, as did the trackers discussed in the PC-Speaker section. The Disney Sound Source had better luck, receiving more support from game developers, starting with Roberta Williams‘ productions. There was also a software emulator of the SN76489, which, if you had a decent CPU, provided PCjr (or Tandy 1000) audio to some games. However, it had poor compatibility, and not many games could use it easily.

AdLib

Everything seen so far didn’t resemble a sound card as we know it, but the Canadian AdLib Inc. launched a successful sound card in 1987, the AdLib Music Synthesizer Card, simply known as AdLib. With it, the concept of a sound card for home use was born.

This card provided FM audio synthesis through Yamaha OPL2 chip, but no digital sound. It offered nine voices, each with its ADSR envelope with various waveforms and operators. FM audio synthesis is a bit more complex than a simple programmable sound generator because it involves several waves whose frequencies modulate the sound of the main wave, which can take various forms: square, sine, triangle, sawtooth, and more. Indeed, it is as complicated as it sounds, and crafting a nice sound is quite a challenge.

And diving into technicalities, ADSR may seem like a complicated acronym but it just stands for “attack-decay-sustain-release.” These are four parameters that define the volume of an instrument in its fundamental phases, also known as the envelope: the attack (the start of the note), both before and after it is played, the volume while holding it, and how long it takes to fade out. It’s abstract to explain it in words; a graph explains it much better.

The card was well received and was widely supported in most PC games, establishing itself as the first major standard for most home applications. It was supported throughout the life of MS-DOS, and even some Windows games (mainly 3.X) made use of it. However, sales did not keep up in the ’90s, as almost all subsequent cards and clones used the same Yamaha chip and were either cheaper or added more features.

Certainly, the audio synthesis capabilities of this AdLib, which was little more than a wrapper for the OPL2, were much richer and more than notable for 1987. PC games could feature music similar to famous Yamaha synthesizers at a very competitive price, around $130. However, with the popularization of middlewares, the quality of music for AdLib games declined, as most of the times, the card was simply used to play General MIDI instruments with a sound bank provided by the middleware programmer. Since it didn’t have digital sound, this technique was quick but produced poor results.

What was that General MIDI about? Essentially, it’s an additional standard to the MIDI protocol that requires up to 24 simultaneous voices and 128 defined instruments. It emerged from 1991 onwards, and since then, most MIDI-capable audio synthesizers and sound cards complied with this specification.

In 1992, the company marketed a second model, the AdLib Gold 1000. Instead of the OPL2 chip, it featured the improved OPL3, which allowed for more simultaneous voices and more ways to create different sounds, in addition to including a 12-bit DAC. Unfortunately, it fell victim to the success of its smaller sibling and didn’t sell well. It received support from some notable games like Dune (Cryo, 1991), but it ultimately led to the manufacturer’s bankruptcy.

Roland MT-32

One of my absolute favorites, and of many video game enthusiasts. The Roland MT-32 Multi-Timbre Sound Module, simply known as the MT-32, was launched as an affordable MIDI synthesizer for amateur musicians but quickly gained great popularity among PC gamers. It could only be used via MIDI connections, so an MPU-401 interface or hardware with that functionality was required.

The MT-32 operated on a principle called LA, or linear arithmetic. It combined digital samples of instruments (recorded instruments) with subtractive audio synthesis, achieving high-quality voices without spending thousands of dollars on ROM cartridges and expensive sound samplers. Its memory contained many partial samples of instruments which, combined with synthetic sound, filters, and DSP, created a bank of 128 instruments and 30 sound and drum sounds. This device was not exclusive to the PC; it could be used with any system with a MIDI connection, such as Sharp X68000 computer.

This device was not compatible with the General MIDI standard, which did not appear until four years later, so Roland provided partial compatibility by selling an add-on. However, its use in games was mostly limited to its base equipment, which cost around $700, to which the MIDI interface, typically an MPU-401 starting at $550, had to be added. As a musical instrument, it was very competitive, but as an audio solution for games, it was very expensive.

Its price was the reason why, when cheaper wavetable-based systems (essentially banks of digital instrument samples) appeared, it fell out of use, though not before leaving us with some of the highest-quality PC soundtracks. Again, Sierra On-Line was a pioneer in its use, with games like King Quest IV in 1988. In the early ’90s, the best soundtracks were composed for this device: Monkey Island 2 (LucasArts, 1991), Dune II (Westwood Studios, 1992), and many others.

This audio system lacked digitized sound, but most games allowed the simultaneous use of a sound card with this capability, so a player with a plump wallet could enjoy both digital sound and the best music at the same time.

Over the years, this device took different forms, such as the 1989 LAPC-I. Instead of a MIDI module, it was an expansion card that combined the features of an MPU-401 interface and the MT-32, making very similar sound but being much more convenient.

Other varied stuff

By the late 80s, there was a wide range of sound cards with different features, prices, and lifespans. I’ve tried to detail the most notable ones, but it’s worth mentioning that there were others that didn’t sell much.

One of these cards was the first created by IBM. The only one, if we don’t count the PS/1 card, which was more of an expansion for that system. This is the IBM Music Feature Card, produced in 1987 with a design similar to the LAPC-I: a MIDI interface with a synthesizer, this time the Yamaha YM2164, used in some synthesizers of the time. It cost $500 and wasn’t much better than an AdLib. It was aimed at the semi-professional market but didn’t fit into any specific sector and was overshadowed by the competition.

That same year, Creative Technology Limited (known as Creative Labs in the U.S.) began marketing its first sound card: the Creative Music System. It essentially consisted of two Philips SAA1099 chips, with features similar to but superior to the SN76489: these programmable sound generators provided the PC with 12 stereo voices, four of which could be used as noise generators. The popular chain RadioShack sold it as Game Blaster a year later, and although its audio chip was supported by a number of games, the card was quickly overshadowed by the company’s subsequent creations.

In 1989, a company called Innovation Computer Corporation developed something that seemed like a good idea on paper. The SSI 2001 was a sound card that included the already established SID chip from the Commodore 64. The demoscene for this computer was popular, but there were much better products available for the PC, and it only received support from a handful of games. At least it included a game port to connect a joystick.

Finally, Sound Blaster

The most successful creation of Creative, and by far the most popular line of home sound cards of the time, is undoubtedly the Sound Blaster. Almost all games included support for this card, whose first version dates back to 1989. The reasons for its success were a timely release and features completely focused on computer games. Furthermore, since compatibility with the AdLib was perfect, there was no reason not to choose the Sound Blaster.

The Sound Blaster, later known as 1.0, was capable of reproducing 8-bit sampled mono digital sound (PCM and ADPCM) up to 22 kHz. Additionally, it could record 8-bit mono sound up to 11 kHz. It was also backward compatible with the Game Blaster, allowing it to use its SAA1099 chips to play music, but this feature was little used since it was also compatible with the AdLib, having an OPL2 chip as well. This all-in-one card became the best-selling expansion card for PCs within a year. It also included a game port and MIDI.

A year later, to cut costs, the card began to be sold without the SAA1099 chips, although it retained the sockets if you wanted to add them later. This version later became known as 1.5.

Soon after, the third revision appeared: Sound Blaster 2.0, in 1991. The sound quality increased to 44 kHz, the MIDI port was now full-duplex (could transmit and receive simultaneously), and the DMA now supported the “auto-init” extension, allowing it to be fully compatible with Windows 3.X.

Why did Sound Blaster succeed in the gaming sound card market? One reason is the use of DMA, Direct Memory Access. In most home hardware devices, it was necessary to use the CPU synchronously with the audio device, sending the information at the precise moment, wasting valuable CPU time. Thanks to DMA, we can tell the audio card where in memory the sound to be played is, and it will handle fetching it as needed. Naturally, under the CPU’s watchful eye, but now it can focus on other than sending data to the audio card.

In 1991, a different model from the previous ones was launched: the Sound Blaster Pro. The maximum audio output sampling rate was increased to 44 kHz in mono (22 kHz in stereo), and a second OPL2 chip was added, doubling the voices and providing stereo sound. Additionally, this card came with a very welcome addition: a Matsushita CD-ROM controller.

It wasn’t long before a second revision replaced the it, changing the pair of OPL2 chips for an improved OPL3. Moreover, it was now possible to buy the card with a CD-ROM controller for other standards, such as Sony or Mitsumi. This card was one of the most cloned of the time, and some semi-professional sound cards included a software emulator to use them in games.

What is the fuss about this CD-ROM controller thing? Before the ATAPI standard became popular in PCs, there were different standards for CD-ROM drives. Even then, this standard coexisted with SCSI, which was more professional, so an extra controller card was often needed if you wanted to have a CD-ROM drive. The fact that this controller was integrated into our sound card was a very important factor, but it had to be the right one for our CD-ROM drive. Any of these drives could read any disc, though.

In June 1992 it came what many considered the ultimate sound card for gaming: the Sound Blaster 16. With all the features of the Sound Blaster Pro 2.0, but additionally its MIDI interface was now fully compatible with the MPU-401 UART. It was possible to purchase a daughter card to provide wavetable capabilities, but this was not a very common feature in games. Nonetheless, the standout feature of this product was something else: CD-quality (44.1 kHz at 16 bit) playback and recording! This was a different world.

The revisions of the Sound Blaster 16 didn’t add or remove anything, given the immense popularity of this sound card. Only its form factor was redesigned to integrate it into a motherboard or for the OEM market, taking the name ViBRA 16. It was never fully backward compatible with the Sound Blaster Pro in terms of digital sound, but it was in its FM synthesizer. Nevertheless, almost all programs from 1992 onwards supported both.

Sound Blaster 16, with just its name it sold Creative’s ad and its Sound Blaster line

Windows Sound System

It was practically impossible to compete with the Sound Blaster, as they had become the de facto standard. There was barely any room for innovation, and developing a different standard was suicidal because no one would support it. Microsoft created a specification with this name in 1992, so anyone could build a sound card compatible with Windows 3.X and with any program that used the standard.

There were several levels of this specification, and the first and most used required a sound quality of 48 kHz at 16 bit, and an OPL3 for musical synthesis. The Sound Blaster Pro met this specification, but curiously the Sound Blaster 16 did not. Any card that adhered to the WSS standard, no matter how basic, could be used in Windows and also emulate a Sound Blaster Pro. Although many games supported this standard in MS-DOS, some major developers, such as Apogee, did not include it in their games. It was also not supported by id Software, so it missed out on the essential Doom (1993).

This standard became completely obsolete in 1997 with the introduction of Intel AC97, primarily designed for Windows. It never had support for MS-DOS, although by then almost all developers had already focused on Windows 95.

Gravis Ultrasound

The case of the GUS is interesting. When in 1992 everyone was buying the Sound Blaster, this Canadian company began selling this card along with the Gravis Gamepad, a PC game controller inspired by the Super Nintendo’s. The reason was to offer a card with a more professional design at a bargain price.

This card didn’t have a simple DAC like the Sound Blaster, nor did it include any FM audio synthesis chip. Instead, its hardware was a digital sample synthesis engine, very similar if not identical to the wavetable concept. It had dedicated RAM where sounds and instruments were loaded, and with its mixer it could play up to 32 sounds (up to 14 in CD quality). The playback quality was the same as the Sound Blaster 16, 44 kHz and 16 bit in stereo. However, for recording, an additional daughter board was required.

Different revisions of this card provided more or less RAM, usually upgradeable with 30-pin SIMM modules. Others added a CD-ROM controller or hardware mixing and CD-quality recording without needing a daughter board. One revision, the Gravis Ultrasound ACE, removed all the extras and was marketed as a card to be used alongside the Sound Blaster.

Its operation made Amiga software relatively easy to port to the PC, as the handling was similar, with the advantage of dedicated RAM. The aforementioned trackers and the demoscene also enthusiastically embraced the benefits of the GUS, as it allowed real-time music production without having to invest in a powerful CPU.

The case of games was complicated. Some of the major releases, like Doom (id Software, 1993), provided native support from the start, but not all developers jumped on board. It didn’t help that it didn’t even have an OPL chip, and even less that it didn’t come with a factory MIDI interface. Additionally, as expected, no game released before autumn 1992 supported this card. None of this was a problem for music production, but how was its gaming use maximized?

The answer lay in the Gravis Ultrasound ability to imitate or emulate other sound cards. More or less directly, it could emulate a General MIDI device using a preset sound bank, as well as mimic the instruments of an MT-32. This itself provided musical support for most games of the time, but the digital sound question remained unresolved. Some patches appeared for existing games or those released without Gravis support, but we depended on magazines including them with their CDs or having internet access, which was very rare before 1994. The answer came (more or less) with the use of emulators.

IWSBOS and MegaEM were the two programs most used by Gravis users. These allowed emulation of a Sound Blaster 2.0 and an AdLib, significantly increasing the number of games that could use it. This was by no means a complete solution, and it depended on whether a game used a protected mode, required EMS memory, needed a lot of conventional memory… all of this was also a lottery as compatibility was hit or miss. Only the Gravis Ultrasound Extreme, from 1996, provided hardware support for Sound Blaster Pro emulation, albeit a bit late.

In any case, Gravis Ultrasound provided excellent hardware for amateur musicians, costing only slightly more than a Sound Blaster. Although support for games was irregular, it was a way to stand out from the common path. Its onboard memory allowed for much more sound variety than MIDI modules, and being able to use it as a General MIDI device with sounds loaded by us gave games a musical quality that the Sound Blaster could only dream of without its Wave Blaster daughterboard.

Sound Blaster AWE32, and we are just getting started

The Sound Blaster 16 was undeniably the flagship sound card for 1994, but its features beyond digital stereo sound were quite stagnant. Creative Labs took the step with the AWE32, introducing many improvements in musical capability, such as dedicated RAM, a 32-voice wavetable processor, a hardware mixer with an integrated equalizer, and a digital effects processor. The price, however, was in line with all that was offered.

It goes without saying that it was perfectly compatible with the digital sound of the Sound Blaster 16, and as it also included the OPL3 chip, it was compatible with FM audio synthesis of both the Sound Blaster and the AdLib. In some cheaper models, however, they decided to integrate it into their processor or simply not include it and provide support through emulation. The sound in this case wasn’t 100% the same, but it maintained compatibility. For all these reasons, from its release, these cards reestablished themselves as the standard for home use, especially gaming. For old games, their retro-compatible features could be used, and new ones began to support it right away.

For a PC gamer, this card combined all the desirable features: it worked with all games, and the music sounded much better than a Sound Blaster 16, with full MPU-401 UART support. Additionally, it was a direct challenge to the Gravis Ultrasound, as it entered their territory thanks to the EMU8000 chip. It provided 32-voice wavetable synthesis using its dedicated RAM, which could be expanded in some models to an incredible (and expensive) 32 megabytes. Curiously enough, popular trackers did not provide direct support for this amazing hardware (but they did through Sound Blaster compatibility, of course), only some specialized players did.

Games that supported the AWE32 directly offered great sound. Not only for its CD-quality digital sound or its General MIDI-compatible music, but also for its digital effects like reverb or flange. Additionally, since we could load instruments into memory using the SoundFont format, not all games had to sound the same. There weren’t many games that took advantage of this card however, and most were limited to using the digital sound inherited from the Sound Blaster 16 and playing General MIDI music from its preset sound bank.

Although most revisions of the AWE32 involved changing or removing things (like the factory-installed memory, as in the Sound Blaster 32), in 1996 another model was released that went beyond a simple revision: the Sound Blaster AWE64. The improvements included cleaner sound due to a higher signal-to-noise ratio, and a significant increase in polyphony (to 64 voices). The hardware was an extension of what was seen before, so compatibility was more than assured.

The AWE64 revisions were interesting. The Gold version brought us closer to the professional realm by including a 20-bit professional DAC, as well as RCA connectors plated in gold and a digital S/PDIF output. The Value revision, on the other hand, was limited to domestic and gaming use at a very competitive price, and although there was practically no support for AWE64 in games, it was a more than affordable way to play games that supported AWE32 and compatible cards, though without the possibility of expanding RAM. In any case, this became more difficult with the AWE64 as it moved from standard 30-pin SIMM support to Creative’s proprietary memory, which was more expensive and harder to find. Money talks.

Professional cards: Turtle Beach

The PC audio card market was not limited to games and home applications. Although by the late 80s and well into the 90s, the old Atari ST remained the king of music studios (with the Macintosh trailing behind), PCs also became a viable platform for professional audio production. One of the most well-known companies was Turtle Beach, with a line of professional cards that started selling in 1991.

Turtle Beach’s flagship product in the MS-DOS era was the Multisound. The sound quality of this card was on another level, aimed squarely at professional use. Its heart was a professional E-MU synthesizer with up to 4 MB of ROM, with studio-quality 24-bit recording capability and digital sound inputs and outputs, all in 1991, when the Sound Blaster struggled to achieve 22 kHz mono sound at 8-bit. Even with the advent of the AWE32 in 1994, they remained competitive, costing not much more than these at that time (around $400).

Naturally, the applications for this card were very specialized, working only with specific software. They were not at all compatible with the de facto standard, which was Sound Blaster, not even with MPU-401. The only way to use them with MS-DOS era games was through Windows NT, and only with an emulator like VDMsound, something completely inadvisable and beyond the scope of this article. (Moreover, this happened much later)

Other General MIDI modules and cards

While everyone was very pleased with the Sound Blaster, their musical quality in games left much to be desired for the 1990s. The solution was to have an MT-32, of course, but that required a significant investment. Moreover, since it did not comply with the General MIDI standard, not all games could use it properly or at all.

The first notable device in this field arrived in 1991 and was the Roland SC-55 (Sound Canvas), a MIDI synthesizer module that adhered to General MIDI and Roland’s new proprietary standard, General Standard, a name that apparently involved quite a bit of brainstorming. The merits of this device were notable: it was not only compatible with General MIDI, making many games of the time work, but it also emulated the MT-32 with its basic sound bank. It didn’t sound exactly the same, but it maintained high quality in its instruments and was perceived as a fairly good substitute. A popular form factor for PCs was the Roland SCC-1, which was an internal card rather than a MIDI module and already included MPU-401 functionality.

Not many games supported it directly, although its compatibility with the musical standards of the time made it work reasonably well with programs that were not specifically designed for it. However, in 1993, the very game Doom by id Software not only provided specific support but also had its brilliant metal soundtrack designed to be played on this device.

Where was Yamaha? Possibly working on its XG standard, eXtended General MIDI. In 1994, the first module conforming to this standard was released, the MU80 Tone Generator. Superior to the Sound Canvas and allowing much more modulation variety for instruments, it was sold over the years as either a MIDI module or included in audio cards with digital sound capability. However, we entered the murky territory of the PCI bus, which was more modern but practically incompatible with all previous cards that used the ISA bus. For many years, various versions of Windows used an emulator of this standard to provide MIDI sound to their operating system without the need for musical synthesis hardware.

MS-DOS games did not bother to provide direct support for XG cards and modules, so they had to be used simply as a General MIDI module controlled by an MPU-401 or compatible. The result was a fairly good sound but completely underutilized the ingenious capabilities of this hardware.

One more thing (other interesting cards)

Competing in the era of the Sound Blaster was more difficult than gargling with talcum powder. However, with the rise of middlewares and Windows 3.X software, it was somewhat possible to offer alternative cards.

Pro Audio Spectrum

This family of cards made by Mediavision started in 1991 with the original PAS. They offered AdLib compatibility by including a pair of OPL2 chips in their configuration, as well as audio that was completely incompatible with the Sound Blaster “standard.” It also included a CD-ROM controller, with models available for different standards. Its sound was 8-bit, and it didn’t catch on, lasting only a year before being replaced by its successor.

Today, it is a hard-to-find card with little literature available, though it had moderate support in games as the driver used it similarly. There was a revision that used a 16-bit ISA port, replacing the FM synthesis part with an OPL3 chip, and was able to play 16-bit sound. It was known as the Pro Audio Spectrum Plus. Both cards could also emulate the MPU-401 module in their joystick connector.

The following year saw the release of the Pro Audio Spectrum 16, which is more common today and has interesting features: 16-bit stereo digital sound in CD quality, similar to what the Sound Blaster 16 offered that same year. For game enthusiasts who didn’t want to miss anything, it included full hardware compatibility with the Sound Blaster 1.5, so it could now be used with virtually all games on the market, albeit with inferior sound quality if PAS16 support was not included. These features allowed it to sell moderately well and gain support for most games that used a major middleware.

Thunder Board

In addition to the Pro Audio Spectrum, Mediavision marketed another card unrelated to the PAS. What reason could there be to risk it twice in this market? Well, not entirely: Thunder Board is a clone of the Sound Blaster 1.5 but at a student price.

With it, you could do the same as with Creative’s product for much less money, and although better cards existed in 1992, the Thunder Board stood out as an alternative for those short on cash. In fact, in the midst of the saving frenzy, they came up with a very unique product: the Thunder and Lightning, which did not include improvements in its sound circuits. Instead, it included… a SuperVGA graphics card!

It’s true that building a PC was cheaper thanks to these devices, but one wonders if it’s a good idea to bring audio and video circuits so close together. More information could not be found.

Soundman Wave

In the amateur production market, we already had the Gravis Ultrasound, and a year later, this creation by Logitech appeared. A product straddling game-oriented hardware and sound aimed at small home studios. Its features were quite good for 1993: CD-quality sound both in playback and recording, CD-ROM controller, and something very interesting: an OPL4 chip instead of the common OPL3. Besides the FM synthesis features present in almost all cards, it had wavetable capabilities, with its bank located in a 2-megabyte ROM.

This card had, however, two problems. First, although it was compatible with the Sound Blaster Pro, it was very unreliable. Either it sounded too sharp, or one of the channels didn’t work, or it didn’t sound at all. In the end, despite the manufacturer’s claims, it had to rely on Sound Blaster 1.5 compatibility, and native game support was very limited. The second problem is even more painful: without onboard RAM, the wavetable sound was limited to the banks provided by its otherwise “huge” ROM.

The End of the MS-DOS Golden Age

MS-DOS and its derivatives (PC-DOS, DR-DOS, 4DOS, etc.) began as a sui generis interpretation of CP/M and remained terribly outdated for most of their active time. Only the omnipresence of the PC architecture, the amount of available software and hardware, and the ease of commercializing clone PCs allowed it to last so long. But the second half of the 1990s saw its reign fall, and with it, the way we understood sound cards.

With the arrival of Windows 95, developers finally began to abandon MS-DOS, and thanks to its driver model, it was possible to use practically any sound card in all programs. With no need for a program to provide specific support, the tables turned. Additionally, the ISA bus was gradually replaced by PCI, and the fact that games could only handle the former created a significant schism in audio card technology.

The ISA bus was present from the first wave of PCs, and with it, it was possible to write to memory or use the computer’s resources via software interrupts or discrete channels. With PCI, the model shifted to a bus arbitrator, more advanced technologically but completely different, and support was practically limited to Windows systems or, at most and for a while, a driver that provided ISA compatibility for MS-DOS-designed games. Since Windows 98 eventually included software compatibility with Sound Blaster, it was possible to use almost any sound card, thus delivering the final blow to Creative’s hegemony.

After the Long Read

Given the (very) relative success of my article on the most important sound chips in video games, I decided to create one focused on the MS-DOS era. It evokes less easy nostalgia, among other things because there are no Nintendo games or similar, and sometimes handling and configuring these machines was a real pain in the back.

The claim of brevity was naturally a joke. Books could be written just about the AdLib, and I could have extended the history of the PC until I was exhausted. I have tried, however, to condense the most important aspects of the world of sound cards without leaving techniques and technicalities unexplained. I limited myself to the MS-DOS era, both because it interests me the most and because it was a time with a unique idiosyncrasy that, fortunately or unfortunately, I lived through.

La entrada The golden age of sound cards se publicó primero en Nobody comes after the last.

It’s also true that a commercial success can lead to significant advancements, dragging others along, or simply have the merit of bringing them to the masses. Let’s take a look.

ENIAC

We start at the beginning, almost literally. Completed in 1945, the Electronic Numerical Integrator and Computer, as it was formally known, is often cited as the first electronic, digital, programmable, and general-purpose computer in history. ¹ Perhaps the most interesting feature is that it was a Turing Complete machine, meaning it could behave like a theoretical Turing machine. Although this is a rather abstract concept, it serves as a “certificate” that the machine could perform any calculation if it had the appropriate resources.

Some authors reference the Colossus machine as the first with these characteristics, built from 1943 to 1945. However, it was not a true general-purpose machine, as its purpose was focused on deciphering Lorenz cipher machines, similar to the famous Enigma. Another point against it is that this computer was a state secret until the 1960s.

It should be noted that, although we classify ENIAC as programmable, it was not programmable in the conventional sense. Author David Alan Grier (Editor-in-Chief of IEEE) describes it as a collection of adders and other arithmetic units controlled by a tangled mess of wires. ² Nonetheless, this nearly seven-million-dollar (2024 value) machine (almost half a million in 1946) was thousands of times faster than its predecessors made with electromechanical devices and served the U.S. Army until 1955, primarily for calculating artillery ballistic tables.

Apollo Guidance Computer

The highlight of this computer was that it took us to the Moon, obviously. But it also represented a significant technical challenge: miniaturizing a computer enough to be carried on the mission. Remember that devices from the 1940s and 1950s were so large they filled a room of cabinets and consumed large amounts of electricity.

Notably, it was one of the first computers to use integrated circuits, a milestone it shares with the IBM 360 ³ and the SDS 92 ⁴. Another reason for the reduction in size was its wired core memory, which was hand-woven in a tedious process that took eight weeks. It had 2,048 words of RAM and 36,864 of ROM. ⁵

Manchester Ferranti

The UNIVAC is often referenced as the first commercial computer, but it was the Manchester Ferranti, also known as the Mark I, that beat it by a month, in February 1951. There were two earlier machines, BINAC and Z4, that could be considered predecessors, but BINAC was electromechanical and not general-purpose, and the Z4 never worked well after installation. ⁶

The Ferranti was also the first computer in the world with sound, as it included an instruction to alert the operator with variable time and frequency. In 1951, the BBC even recorded several melodies played by this computer. ⁷ Another very interesting achievement was being one of the first computers to have a chess game, albeit a very limited one. It was also programmed with a checkers game in 1952. This unique achievement is shared with machines like the NIMROD, about a year earlier. However, this machine only ran the nim game.

PDP

The PDP machines from Digital Equipment Corporation were pioneers in many ways. The first model, the PDP-1, was launched in 1959 and became one of the most iconic symbols of hacker culture. It was also the hardware used for one of the great milestones in video games, Spacewar!, in 1962. It was the first time a video game ran on a minicomputer.

Indeed, the term minicomputer sounds like a joke, as these were devices that occupied several cabinets. However, the name comes not from their size but from their minimal nature. They were also smaller and cheaper than mainframes, not competing with large systems like IBM. They emerged after the transistor and magnetic core memory revolution, and the honor of being the first of their kind is debated among other minis like the LINC, from the same company, or the TXs from Lincoln Laboratory.

The PDP-8 model, released in 1965, was the first computer to cost less than $20,000, was the size of a refrigerator, and sold around 50,000 units—a huge number for that time. Among the many operating systems developed, the 8OS is cited as pioneering the use of the command line as input. It inspired the CP/M operating system in the 1970s, which in turn directly inspired MS-DOS and similar systems, which made a splash in IBM PC architecture. ⁸

Talking about the PDPs means talking about UNIX, as this operating system was initially designed for the PDP-7 by Ken Thompson and Dennis Ritchie in 1969. Not happy with just that, after writing it in assembly language, Dennis Ritchie invented the ubiquitous C language a couple of years later. Virtually all modern computers derive from the technologies developed for these minis, whether UNIX, C, or the command line, among others.

Another significant step forward came with the PDP-11, which was the first to be built with UniBus in 1969. This allowed all the computer’s devices to communicate with each other, including memory, enabling Direct Memory Access (DMA) and freeing the central processor for other tasks during operations. It also facilitated data exchange and the development of device drivers.

Xerox Alto

The milestones of this Xerox PARC computer from 1973 were many. Although it was not the first personal computer in history (that honor goes to the Kenbak-1), it was much closer to modern computers than any other gadget created at that time. Certainly, if we need to find a direct predecessor to the philosophy of personal computer interfaces today, we find it in this computer.

Its innovations were substantial: it was the first computer with a graphical interface, the first to have a mouse, the first to use the WYSIWYG philosophy⁹, the ability to run multiple applications simultaneously, and the first to use the desktop metaphor. It was also the first computer with Ethernet. Hats off.

Steve Jobs‘ famous visit to Xerox PARC in 1979 ignited the spark for graphical user interfaces in personal computers. Apple Computers’ Lisa and Microsoft Windows were the fruits of this “inspiration.” They might not have gotten it right the first time, but it eventually became the main interface for modern user computing.

It cost $32,000 and was not a commercial success, so it is not as well-known as other Apple or IBM computers; however, it is probably the greatest influence on today’s personal computers. Its size, being that of a small filing cabinet, didn’t help either.

Altair 8800

Sometimes being the first isn’t everything. While the Kenbak-1 was first, and the Xerox Alto was a reference, it was the MITS Altair 8800 that sparked the home computing era in 1977 with the revolution of the Intel 8080 processor. This was the first microprocessor cited as having real commercial usefulness for general-purpose computers, beyond embedded applications like calculators. Bear in mind that this processor was the “inspiration” for others like the Zilog Z80.

Much of its success is due to being featured on the cover of Popular Electronics in January 1975 and being sold as a kit to assemble. Also, the first available programming language was Altair BASIC, developed by two individuals named Bill Gates and Paul Allen, who after this event founded a little company known as Microsoft. This computer was the first de facto standard in personal computers, with its bus later known as the S-100. Since a single motherboard would have been too large, a backplane design was chosen, where cards were inserted in parallel into the bus, a design that became an IEEE standard.

A clone of this computer, the IMSAI 8080, included a keyboard and monitor, which were optional with the Altair. It was the computer used by the protagonist in the film WarGames (John Badham, 1983).

Others

The reader would not forgive me for not mentioning the following devices.

• IBM 5150 – Not the first personal computer, but the first IBM PC in history, in 1981. The vast majority of personal computers still use this old architecture. Not bad, right?
• IBM S/360 – The true commercial mainframe from 1964. Its architecture still echoes in IBM’s current Z series and was among the first computers to use integrated circuits. A major market success. It was also one of the first machines to be emulated in later mainframes of the brand.
• TRS-80, Apple II, Commodore PET – The 1977 triad. These three computers were responsible for popularizing computing, at least in the United States, where the economy allowed it. They were introduced into schools, home computers began to emerge, and true competition in personal computing started.
• Commodore 64 – Although this title is contested, since 1982 it has been the best-selling computer model of all time. None of its successors matched the overwhelming success of the C64, not even the Amiga line with its outstanding multimedia capabilities.
• NeXT Cube – Steve Jobs’ parallel project to Apple, launched in 1988. It was where the WWW was invented, as well as the PostScript standard. Packed with features and with a rather high price, it is now a highly sought-after item. Its operating system was the basis for modern Mac OS (then OS X).
• IBM 5100 – Considered the precursor to the IBM PC, in 1975. Personal, portable, and considered a pocket mainframe due to its emulation capabilities. It is also sought after by time travelers.
• Cray I – The original supercomputer concept from 1976. Its vector central processing unit earned it many accolades from the industry and was one of the first computers with a very attractive design. At a price of $5 to $8 million, it was not for everyone.

Final Words

What do you think of the list? I tried to keep it brief and focus more on innovation than mere commercial success, but in the end, the first to sell often gets (or tends to get) the credit. Do you miss any computers or interesting facts? Let me know in the comments.

Referencias

La entrada The most important computers in history se publicó primero en Nobody comes after the last.

Unlike contemporary home computers, PC architecture didn’t use an integrated graphics chipset, it would use expansion cards to undertake graphical tasks. This –along with its philosophy of a more-or-less open architecture– would result in many solutions coming into existence along its lifetime. I’ve devoured quite a lot of old computer magazine pages and thus my impressions.

When the first PC was released in 1981 it was offered with two different graphics controllers: Monochrome Display Adapter (MDA) and Color Graphics Adapter (CGA). Both based upon Motorola 6845, a chip managed and generated video signals, that would end up in computers like BBC Micro and Amstrad CPC. In fact it was used for other PC video adapters that we will see soon.

Monochrome Display Adapter

The mother of all PC graphics cards is no other than the MDA, and it’s often quoted as one of the reasons of his success in business applications. It is, as its very name indicates, monochromatic display adapter, with an ISA 8-bit connection, and allows to output a character matrix of 80 by 24.

Well, truth be said “graphics card” is quite over its head, but “texts card” doesn’t fit either. Although its real resolution was 720×350 pixels (80×25 characters of 9×14 pixels) its small memory of 4K wouldn’t allow to address each pixel individually, although it would allow attributes like underlined or blinking. Thus its only display mode was text. Even then it was more than enough for a professional usage like a spreadsheet or a text processor, in fact its great picture quality made it even more popular than her sister in arms.

The display monitor and the card had a digital TTL connection, with two pins for the video signal (to transmit the intensity attribute) and two for vertical and horizontal synchrony. Screen refresh was fixed at 50 Hz and had two knobs for bright and contrast. Green phosphor screen, image of the computers since 60s until the 80s, gave a note of sobriety.

A known and curious fact is that the Monochrome Display and Printer Adapter, as it was officially named, included a parallel port for the printer.

Color Graphics Adapter

The CGA was released to market at the same time to IBM PC and MDA. It didn’t include its high resolution text mode of his suited up sister, but its 16 KB memory would allow it to use a resolution of 640×200 in black and white or 320×200 at four colours of three fixed palettes. It included text modes with 16 colours, although not as nice as MDA‘s.

Needless to say that it was the most logical approach to playful applications, and except some text mode games almost every PC game supported it to display graphics. In fact it had support in games for at least 10 years after, like Son of the Empire (Action Sixteen) in the anno domini of 1992. Even Windows 3.0 (Microsoft, 1990) could work with the CGA.

The CGA card could use the same DE9 connector that MDA used, except that instead of using two TTL pins it had four (RGBi), which gave us a digital connection with synchrony and 16 colours. Everything at a fixed frequency of 60 Hz. Curiously enough one of the pins was used as a 12V output to the monitor, which mostly didn’t use.

Along with the RGBi TTL connection one of the most interesting features of CGA cards was its NTSC video analogue output, as a composite video RCA connection. Frankly its colours were not marvelous, and they tend to blend and mix with each other. It was after all “Never Twice Same Color” composite video, no less. This could nevertheless be used as an advantage, allowing way more apparent colours when adjacent pixels blended to its adjacents generate “new”. Our friend 8-Bit guy explains it way better on his channel.

Over the years many new complex techniques were released to use more and more colours than initially designed, up to 1024 in the 8088 MPH (Hornet & CRTC & Desire, 2015) demo. Apparently when manipulating very carefully video synchronisms, accessing not documented video modes and programming at a very low level, we could made amazing tricks with this hardware. It was naturally not very practical, but there came nothing.

Due to MDA and CGA using different computer resources it was technically possible to use both simultaneously. The spreadsheet par excellence, Lotus 1-2-3 (Lotus Software, 1993) wrote directly into memory and made it possible to use both monochrome monitor to display text and colour monitor for graphics, at the same time. Although this feature wasn’t throughoutly used this software was one the PC success at mid term, and an important benchmark to determine whether a computer can be considered “compatible”.

Hercules Graphics Card

This card was, if not the first made by a third party, first doing so with a considerably commercial success. Basically it’s a card compatible with the IBM Monochrome Display Adapter that could address pixel by pixel a 720×350 resolution, thanks to its 64 KB memory, and could display high quality monochrome graphics, everything with the PC supplied monitor. Technically last two lines were not addressable, so the resolution in the end was a more-than-decent 720×348 pixels.

It wasn’t a broadly supported card as the “officials”, but there was a cohort of games that could make use of it, like many from LucasArts or Sierra On-Line, famous for working even in microwave ovens. This card launch retail price of 500 american dollars, equivalent to around 1.300 in 2018.

It was possible, nevertheless, to emulate a CGA card to have better software compatibility not directly supporting this card. Some late models would include hardware emulation but the usual at the time was to use emulators as SIMCGA, which was basically bruteforce: it copied as fast as it could memory from CGA area (wrote by programs through the BIOS) to Hercules‘ in real time. It didn’t work fantastically, especially with programs that would write directly on the memory, but was better than nothing. Software that worked did so displaying dither instead of colours, of course. Despite its advantages I really could have used that SIMCGA when this was the first graphics card that I had…

In parallel to Hercules some other with similar features were released, as Orchid Graphics Adapter or Plantronics Colorplus. In the case of Colorplus there were hardware CGA compatibility, but neither were quite a commercial success or had important software support.

IBM PCJr y Tandy 1000

PCJr was very anticipated, and many professionals and amateurs were interested in a home oriented PC as opposed to the business oriented main line. The result was the PCJr, released in 1984 and was mostly compatible with the PC and PC XT, its older brothers. Its differences began with a chiclet keyboard, its sound chip and ended with having 128 KB of RAM, so the most demanding PC programs couldn’t be run. In the graphics aspect it possesed the new Video Gate Array (not to be confused with the later VGA), better known as CGA Plus.

Differences with Color Graphics Adapter were mostly being able to use more colours at the same resolution: 16 colours at 320×200 and 4 at 640×200 pixels, although it didn’t had to be fixed palettes. Another not so desirable feature was having its 128 KB of RAM shared with the system memory, making this computer slower than others with the same processor. None of its features saved it from being one of the most important flops in modern commercial computing.

Few games were released for this platform. Most interesting were, of course, Sierra On-Line adventures. The chief example being King Quest (1984) which was released in disks, even though the expected main memory was ROM cartridges.

This computer natural relay was taken by the Tandy Corporation, with its Tandy 1000. Its graphics card was named, of course, Tandy Graphics Adapter. Even though it offered same features that CGA Plus (including the fact of sharing its memory with the system) they were not directly compatible, and software running in the other usually yielded not the best results: blank lines, some displaced ones, etc. But it wasn’t that bad, since almost nobody missed the PCJr and the software was usually written for the TGA.

Professional Graphics Controller

Even when PC was a very capable machine in enterprise applications its graphical features weren’t otherworldly. Since 1984, however, IBM began making and selling this card, also known as Professional Graphics Adapter, Professional Graphics Array or simply PGC. Its graphic arts oriented features could easily cloud almost every other home computer of the era. Its characteristics were heartshaking: 640×480 pixels of resolution at 256 colours from a palette of 4096, also being compatible with CGA graphic modes.

Its looks were terrific: it consisted of a three full sized cards (one of them just to hardware emulate CGA) that took two slots in the IBM PC XT. It couldn’t be otherwise since it had 320 KB of RAM (more than most computers!) and its own Intel 8088 processor, so writing the graphics memory was way faster that competing cards. Its price was superlative too: 3.000 dollars in 1984 (equivalent to around 7.800 in 2018) and could only be used in the IBM 5175 monitor, which was 1.300 dollars (3.400 in 2018). Wikipedia mentions, however, that a dedicated computer aided design workstation costed around 50.000 dollars (around 130.000 in 2018), so in perspective it wasn’t that wild.

Its graphical modes were not directly addressable by the BIOS, and there aren’t any games known that would use them. No big surprise there, since this was a CAD oriented product and its chief usage was Autocad 2.5 (Autodesk, 1986). It didn’t really have any competition, but in two years there were a couple of decent clones released, like the Everex EPGA, compatible with Hercules and CGA, taking just one expansion slot. In place of the 8088 it included no less than a Intel 80286, which was more powerful, and 512KB of RAM memory. It costed 999 dollars (around 2.400 in 2018).

Enhanced Graphics Adapter

The new IBM standard came with this card, which wasn’t 100% compatible but included video modes for every taste. It was launched in 1984 and had up to 640×350 pixels of resolutions at 16 colours, to be chosen of a palette of 64.

This product used a new monitor type, very conveniently named EGA. It used the DE9 TTL connector again, with 6 pins this times for the image. Its usage wasn’t restricted to the brand new AT, the new PC model that IBM presented that year, but undoubtedly it was it ideal addition to it. It gave much better graphics than competing computers like the Commodore 64 (1982) for a very competitive price, which in 1986 was 624 dollars. (about 1.350 in 2018). It was of course the card that every game wanted, and even in 1994 there were games that used it, like BlackThorne (Blizzard). High resolution modes, however, were not usually supported…

The EGA card was compatible with RGBi CGA modes, and it could change its vertical frequency from 15.7 to 21.8 kHz by the use of some small switches in the backplate of the card. This was a bit inconvenient since until autoswitching cards appeared one had to be fiddling the computers behinds, and also switching modes in the monitor, but it was OK since it provided almost complete compatibility with legacy modes. NTSC composite video was however lost, so the software (games!) using this mode weren’t exactly good looking on EGA.

Something very well received was the linear modes, as opposed as interlaced modes in Hercules and CGA. What does that exactly mean? In previous graphics adapter memory had two blocks: one with odd lines and the other with even lines. Programs were walking the memory and suddenly it advanced two lines instead of one. With EGA we could at last write from the beginning to the end without strange leaps. Other very welcomed feature was having BIOS extension on its ROM, unlike PGC for an example.  One of the most impressive ways to exploiting this card was the soft scroll in Commander Keen (1990) programmed by John Carmack, in which he used pixels not directly visible (and hardware scrolling techniques) in the planar modes, making it possible to achieve visuals in the like of the contemporary video game consoles without artifacts or flickering. What was this planar thing exactly we will discussing it soon.

Soon after this standard materialized clones began appearing. Some included video modes in the likes of the MDA, others had more resolution. These modes almost didn’t had any software support so they weren’t a very interesting perk. Other cards however did include auto switching capabilities, so you didn’t had to bother to switch minuscule controls in your card when you needed to change modes. It was the case of the Paradise EGA, in 1986. For 500 USD (1.300 in 2018) it did everything that EGA, CGA, Hercules or MDA standard could, with auto switching capabilities and light pen support. It also had two RCA connectors that the heck if I know what were they for.

Multi-Color Graphics Array

Actually this card never existing on its own. It was simply the name gave to the chipset video in IBM PS/2 Model 30, an interesting computer released in 1987 which spawned the mouse and keyboard connector used until a short while ago. The computer line introduced the MCA bus (Micro Channel Arquitecture), which was an attempt by IBM of retaking the wheel of PC architecture. It was a hard and expensive reversal for IBM.

MCGA however came to stay, or better said its graphical modes did. Specially the brand new 320×200 resolution at 256 colours, chosen from a palette of 262.144, extensively used in games. It supported a 640×480 monochrome mode. Its huge disadvantage was not being compatible with EGA modes, so games not supporting MCGA had to resort to use CGA modes, which were much more ugly. Solution was simply using the 256 colour mode with the 16 that most fitted EGA‘s, but software has to be coded for that and naturally that would exclude everything written before. All in all it was then when PCs began having graphical capabilities over almost any other computer back then.

Monitor and connector used by this technology were analogic, as opposed to previous standards (salve the Professional Graphics Adapter) which was based on digital TTL signals. The conector is/was a DE15 which carried RGB signals, along with vertical and horizontal synchrony. In this case it could have screen frequencies ranging 50 to 70 Hz depending on the graphic mode. Eventually this connector was simply called VGA, and even in 2018 still has its uses despite being obsolete. Its name is very evident to all computer amateurs, as we will see soon.

MCGA died with the first IBM PS/2 line modes, which ended manufacturing in 1992. Of course MCA bus disappeared too, although keyboard and mouse connector sticked with us until well passed the first decade of the XXI century.

An alternative to MCGA in the PS/2 line was the less known IBM 8514 standard, remsembling the Professional Graphics Adapter from two years earlier as supporting similar resolutions of 640×480 pixels at 256 colours. It wasn’t just a graphics card but a whole modern GPU, supporting graphics acceleration (in 2D obviously) allowing instructions like drawing primitives or block transfer memory. Being compatible with Windows 3.X (later with Windows 2.X, too) it was IBM‘s pennant on graphics quality, showing Microsoft Excel like no other. The card costed 1.290 dollars, plus 270 if we wanted the memory expansion to 1 MB (necessary for the 640×480 at 256 colours mode) it was 270 more, and the monitor was sold by IBM at a retail price of 3.110, about 6.600 in 2018. Totalling 3.110 mother whooping dollars, around 6.600 in 2018. This card wasn’t as cloned as others by IBM, and thus the limited support and not having any games known writen for it.

Video Graphics Array

If the quintessential graphics adapter for the PC had to be chosen, look no further. It appeared in 1987 and its graphic modes are supported even today, and used when everything else fails. It was the lower common denominator in practically every PC models and compatibles, and it’s easily the most cloned graphic standard ever. Yo could write a thick book about VGA (and there are not few of them) but at this time we will consider the most important aspects.

Its standard spects included practically all the EGA, CGA and MCGA video modes, along with a 640×480 pixels mode with any 16 colours. Most however would support high resolution modes up to 800×600 pixels, although depending on the spent money in the display and or video card these could be not supported, and also the memory had to be taken in consideration, since some early cheaper models would include less than 256 KB of memory, which was the defined standard. Given its flexible and programmable nature it could use practically any arbitrary resolution with wacky combinations, along with new text modes very popular in software developers.

Since then obiquitous VGA had very interesting technical features. Its screen frame rate varied between 50 Hz for the high resolution modes to 70, and its vertical synchrony as fixed at 31.46875 kHz. This isn’t a random number: it was exactly double the NTSC signal frequency, so it was relatively easy to design and build an adapter to display image on a common television set. Thanks to its RAM memory up to 4 planes could be defined, which could be modified at any time even when they weren’t being displayed, and flip (switch which was displayed) at any time we desired. The icing of the cake was that almost every mode were reachable via BIOS thanks to the extensions it included for the said.

This adapter had however some small inconveniences. It wasn’t compatible with PCJr or Hercules special modes, and compatibility while near wasn’t 100% with EGA. It didn’t include the CGA composite video output either. Neither were really big deal since almost every mode could be easily emulated by the VGA. Finally, programing most complex graphical modes (multiple planes, complex operations) wasn’t easy and it couldn’t be achieved by the BIOS, so the bare hardware had to be managed instead. In the days to come that was an advantage too, since the flexibility of this standard allowed to develop a string of exotic graphics modes and specific algorithms.

VGA wasn’t a true GPU itself, since it didn’t have video acceleration capabilities. It had however some operations which one could take advantage of to have better graphic performance, like setting 4 pixels in a sitting or copying video RAM regions without using the CPU. This along multiplanar modes got considerable better results than EGA, achieving not only soft scroll but using sprites in a similar way to dedicated videogame system. (Note: some people suggest sprites were effectively limited to mouse sprite and not much more)

PC in Japan

Since the PC standard was meant for the latin alphabet (or cyrilic or greek if we changed the text glyphs in text mode) and din’t support Janapense characters (more complex and numerous) it was never popular in Japan. IN 1986 an EGA variation was introduced, named JEGA (Japanese EGA) which used an special BIOS along with double-width character support, but it wasn’t enough to compete with NEC PC-98 standard. AX-VGA wasn’t enough either, it’s equivalent on the VGA standard.

Solution was far simpler than it looked: Microsoft just released specific MS-DOS version since 1990, which called DOS/V and made them to work in Japanese machines with a standard VGA card, and would allow japanese double-width characters.

Mode X

While most of the tricks on the hardware were known before, in 1991 Michael Abrash publised an article about a graphic mode undocumented by IBM, coming up with the name of mode X. It wasn’t unheard of and was used before in a handful of games, but it was since then when it adquired entity in the videogame programming world as it had all the desireable features of graphic modes. Except for one thing: it was quite complex to program for.

This mode provided a resolution of 320×240 pixels with 256 arbitrary colours. In the aspect relation of the PC monitors (4:3) that meant square pixels, as opposed as most of the other video modes. That simplified a lot calculating “real” distances in the screen having pixel differences. Having 256 colours meant having an exact byte-per-pixel in the memory map, so you didn’t had to read the memory in advance to do bit masks in order to draw a pixel. But most important, being a planar mode (called “unchained” in its article) would allow to write in several planes and switch them at will. From its best merit it came its best defect: writing in memory was a comples tax, since each adjacent byte was in different planes. With four planes, for instance, each 4 bytes would represent four pixels but one in each plane.

Makes

First computers including a VGA graphics card were the IBM PS/2 line, first integrated on the mother board and later as an standalone card. In fact one of the main features appealed by IBM was not being a chipset anymore, disregarding the MC6845 controller which other cards had and embedding everything into a single processor, except for memory and auxiliary electronics (crystal oscillators, passive electronics, etc.) IBM could afford including it on the mainboard precisely because this high level of integration.

It didn’t take a long time for high compatibility to be released, which went around 500 dollars in 1987 (1.100 dollars in 2018). VGA is probably, in fact, the most cloned video PC video card, and wikipedia cites S3, Ati, Matrox, Tseng, Trident, NEC and more as the main makes. Almost every card had in common the standard video modes and many others in high resolution, along with various features by each. This would allow two important things, first being industry progressing while adding new features and capabilities and second was IBM progressively losing control of the standards. This made video cards very different each other, leading to the next chapter of our soap opera.

XGA and everything else

After VGA‘s overwhelming success, next proposed standar by IBM was the Extended Graphics Array, abbreviated to XGA. Its features weren’t so impressive for 1990 in the blueprints, but it added a very interesting video mode which had a resolution of 640×480 pixels and 65.536 colours (high-colour), something close to professionals solutions. It added partial compatibility with the IBM 8514 standard, particulary with the 640×480 at 256 colours mode, and had an all-pixels-addressable 1024×768 pixels at 256 colour mode, as opposed to the 8514 which would allow only text at that resolution

The great highlight of this card was, however, an alleged performance improvement up to 50% in Windows versus the old VGA. It the end it wasn’t such a big deal since software wasn’t usually programmed to use all the resources of this card, so making an expense of 1.095 dollars (more than 2.100 in 2018) hardly justified this expensive boost. It was, nonetheless, a good choice against the costly 8514 in IBM OS/2 operating system or in the same Microsoft Windows.

This new graphics card had two crucial issues: first it was presented for PS/2 computer lines fitting a MCA bus, and since it was proprietary and expensive to implement by third parties it failed. Moreover, at that time third party makers just extended VGA specifications to achieve better features in arbitrary aspects, being this XGA specification not very attractive for them. Games and other graphic media programmers, specially for MS-DOS, had a hard time since they had to support a plethora of diverse standards, so many get stalled in the lower common denominator that VGA modes were.

Super VGA

Just after first VGA cards came into retail stores the first bits of this specification began to establish. It never materialized in no particular card, in fact technically it wasn’t a format specification at all, since there was no authority which published an standard outside the path that IBM or main makers walked. In this context, even IBM XGA ended up being considered as part of the blend which Super VGA was.

This changed around 1990 with VESA (Video Electronics Standards Association) publishing VBE: VESA BIOS extensions. It was since then when it began to exist a common interface to access high resolution modes, which ended up being named Super VGA or VESA modes, everything through these BIOS extensions. First specifications defined video modes which cards implemented, specially high resolution modes. In 1994 it was published the 2.0 specification which included paging support, planar modes, 16 and 24 bits of colour, linear models and everything under the protected mode of the CPU, thus finally allowing MS-DOS games with high resolution games to materialize without having to worry about every card in the market.

Other of the VESA specifications was VLB, the VESA local bus, in 1992. This interface, alternative to PC bus (which came to be called ISA bus, Industry Standard Architecture) made the CPU closer to the graphics card, allowing a better performance. Actually it was an upgrade to ISA, and allowed the graphics card for example to access main memory through DMA channels, or graphics memory mapped in the virtual memory in protected mode. It wasn’t exempt of problems however: First it was designed essentially around Intel 80486 processor, which ended up being a not very scalable solution and not very predictable. Its usage, except for very concrete exceptions, was chiefly graphic cards, and motherboards used to include at most two slots supporting VLB. Lastly its form factor made cards difficult to install, due its huge connector which applied a non trivial stress to the components when installing. The last straw was the PCI bus which appeared later that year, and compatible graphics card the following year.

Finale

Super VGA, or what it came to be through consortiums and standards was (wasn’t) the last great PC era graphics standard, now outside IBM company intent. In 1990 a decent Super VGA graphics card cost around 400 dollars (about 770 in 2018), against more than 1.000 (around 1.900 in 2018) which IBM solutions cost, so outside professional applications it was the big winner.

Since then it’s another story. With the downfall of MS-DOS, the beginning of Windows 95 era and the drivers model it happened something similar to sound cards, and the tussle were about specific ears like 3D or video decoding. This is different topic which I won’t be covering today, though.

My acknowledgements to my graphics friends which gave me support and joined me in this lecture:

• The Crazy Pixel
• The Human Card
• Mrs. Horizontal Resolution and Mrs. Vertical Resolution
• The Low Resolution Dwarf
• The Voyeur Display
• The Glutton Slot
• Mr. Standard
• And finally Mr. I Can’t See Shit

As always I’d love to receive comments and remarks about the above, along with personal experiences by whom expended more than they should to have 10 or 12 more colours in the screen.

La entrada Graphics cards of the IBM era se publicó primero en Nobody comes after the last.

MicroProse (at a later stage, good old pal Sid Meier founded Firaxis) and Maxis had a fundamentally opposed nature: the first offered reflexive, long, deep and slow paced products, while Will Wright‘s company designed kind of humorous games of a certain fantasy fashion. I am excited to imagine what could come out of this joint venture.

It was 2002 when Sid Meier’s SimGolf came out, produced by Electronic Arts in a time in which the company was engulfing other myth-enshrouded companies. The result is a surprising mix of company management with the loaded people’s sport. Again surprisingly, despite bearing the name of the Civilization saga creator, it is a game not of an excessive complexity, straightforward enough for everyone to play with the funny touches of a Sims game. Everything in a very visual interface, with a golf playability part in the style of role playing games. (you aim and I’ll shoot)

The player has inherited a sum of money which would use to buy a plot of land to make his dream come true: design and build a golf course worthy of the SGA (Sim Golf Association) and winning the million-dollar prize. Everything while juggling budgets so posh people will continue burninig  simolleons in the 18 course. The way to do this is rather simple: we decie the distance between the tee and the green, we add the fairway and decide the difficulty of the hole with hazards and break. Everything while managing club facilities to make our guests stay more enjoyable, as well as the club staff of gardeners and “refreshment” sellers who will walk our paths.

Technology used is not a wonder, even considering it is more than 15 years old at the moment of writing. Its 2D graphics are pleasant and music is very appropriate for the game, but there are very few settings and you can’t even change the 800×600 pixel resolution. You can’t barely change the difficulty, which is not explained at all throughout the game, so it’s unknown to me how does it work or what does it do. It is not possible to expand or mod anything, and does not have any multiplayer capabilities. Its interface is also a nuisance (suddenly it’s your turn to hit the ball, but you are clicking elsewhere to edit a green, so you hit a homerun with the darn ball). It would be acceptable for an early 90s game, but for it sure downplay a 21st century product in an absurd way.

It is true that it has many negative technical points, but the playability is so fun it makes you forget (partially at least) these aspects. It’s not only joyful to build the holes, it’s very gratifying to watch these old fogies trying to carry the blessed-be ball to the hole. That and watching them dropping the simoleons when finishing, whose quantity depends on how fun was the hole itself. We can see them chatting, having “histories” like “my goldfish is ill” or “I saw an UFO” (literally). We have to manage the beverage distribution so they don’t get dry, give them electric carts and deterring them to slack so they play fluidly.

A very fun aspect of the game is the sound. Fitting in a CD is no problem for having many funny sound effects, with multiple details (as playing classical notes in each click building the fairway) or playing Hanna Barbera effects. Musical effects, even when they aren’t a hit, give some colour and contribute to the general ambient of the 90s rich celebrities. Part of its charm is actually the imagenierie of this subculture like the sims-like cartoons.

The sporty part of the game complements perfectly the management end, and it’s all the unenforced we like. Of course the vital objective of the main character is to win the course tournament, but we can ignore it completely and just concentrate being a mogul. If we like to play the sport there’s no hurry either, and doesn’t need any special dexterity. In fact it is more in the like of japanese role playing games: the character has some statistics (dive, irons, hook/slice etc.) and we’ll just indicate him the hits to be done. Depending on our abilities the shot would be more or less successful. In the long run we will be able to get better on every aspect of the sports and win the tournament. Well, or get utterly thrashed.

The reception of this launch was colder than a mother-in-law hug. It wasn’t big on news, and people was more worried praising (or giving criticisms) the Sims games, or shooting in some Grand Theft Auto. In any case critics gave mostly positive scores to the game… and player critic was mostly non-existant. As a curious note there was another launch titled SimGolf programmed by Maxis in 1996, which received even less attention. Was this game a second attempt? Beats me.

Playing nowadays Sim Meier’s SimGolf is still a fun experience. Graphics are not severely outdated and the only real downsides are the technical problems or the out of date interface, which can be ignored with not a lot of effort thanks to the fun factor. Well, unless you use Windows 10: the damn DRM exploited an operating system flaw that was corrected in Windows 10 and it’s no longer possible to play it “legally” in this operating system. (Hint: it will work if updated to 1.02 version and properly cracked thanks to the MyTH crack scene group)

This is yet another game to add to my “deserves and remake and won’t have” list. Too bad it ran mostly unnoticed, since Electronic Arts will never do something similar again. In golf games we recently had Golf Story (Sidebar Games, 2017) in Nintendo Switch, and in the business management gameplay it could be compared to Theme Hospital (Bullfrog, 1997). There’s no big deal after even after all these years.

La entrada Sid Meier’s SimGolf – Retroview se publicó primero en Nobody comes after the last.

Unfortunately it wasn’t playing in Real Betis, given my abilities with the a football is the same as Kayne West with a violin: I don’t even know what to do with it. I could, however, get myself a NeoGeo MVS, the SNK arcade board. Very famous among anyone young in the 90s for it very high quality games and being the base of NeoGeo AES console, which shared hardware and games.

Well, having an arcade at home is a bit inaccurate, mostly because my flat has the size of an average service room. Instead, I’ve managed to get an apparatus to use these boards in a normal TV set, along with the cables and gadgets needed to play. These devices are generically known as Supergun, and I’m about to explain how to use one.

To begin with, arcade circuiot boards doesn’t have a connector to plug them to your mother’s TV, nor they have one to plug them to the mains power. How do they work, then? Most boards after mid ’80s use the JAMMA (Japanese Amusement Machine and Marketing Association) standard, which is supplied energy and controls and outputs analog video in RGBS format. Most european TV sets from mid 80s will admit this signal one way or another, via SCART or a VGA connector if it’s modern enough. Power supply is another thing, requiring both 12V and 5V, and sometimes even a -5V line.

In a real arcade cabinet a multifrequency monitor is needed along with a power supply with all these voltages, an awful lot of cables, coin slot device and switches an joysticks for the controls. With an appropriate cabinet, of course, everything covered in grime and fluff if possible. Needless to say that if you touch something you shouldn’t (the display, in particular) it can shock the heck out of you, so better leave it to professionals. (i.e. not like me)

Here is where Supergun comes into play. Instead of having a plethora of stripped filthy wires we can use more common appliances: a TV, a console controller and a ATX power supply, in the likes of a PC. They provide a nice button to “insert coin” and many other useful features. Some models would adapt to standar extensions, like the one NeoGeo uses (providing two additional buttons and stereo sound) or CPS2‘s. (that has a lot of buttons and stereo QSound)

This Supergun in particular has some interesting features. First, it’s able to provide approximately one watt of a -5V line, needed for some old boards (apparently, NeoGeo doesn’t need it). It allows to adjust the video sync, along with the red, green and blue lines individually. It includes a voltmeter, to check in beforehand if the supplied voltages are appropriate. It comes with autofire too, but either it doesn’t properly work of I’m too silly to understand it. For the controller it uses two male DB15 in the likes of the NeoGeo and a female DB9 for the extra buttons, also known as “kick harness”.

Good thing we can use, through an adapter, a six-button Mega Drive controller, or other controllers for more common systems. The NeoGeo controllers are expensive as hell, so it’s a good alternative. It has also jack and RCA stereo connectors, so we can use some high speakers if we want.

Most NeoGeo MVS models would allow to connect NeoGeo controllers directly. They look like standard DB15, but unfortunately they are “deeper”, so a common DB15 plug won’t work. Other SuperGun models will directly allow Mega Drive controllers, but sometimes supporting two buttons per player, three at most.

This Supergun model, along with controller adapters, can be found on eBay for example. Doing the appropriate query you can find many models and other similar devices. Some will come with some assembly required, others will come in a case… there are models to fulfill any desire. As usual, keep an eye on the seller’s reputation and read the advertisement correctly. The price is usually between 40 euros for a basic model to 70 for most complex. Sometimes you can find one in a case for around 100 euros, and some even with controllers and power supply for an arm and a leg.

Other possibility is, of course, to build your own Supergun. It’s usually not worth the time, but of course hobbyist would like to try anyway, and connectors are not expensive. None of the signals are multiplexed, and no encoding is needed. Controls are registered (i.e. switch signals) when the precise pin is connected to ground, and they stop doing so when in high impedance. The RGBS signal can go directly to a TV set or a display via SCART, BNC or RCA connectors. Some will provide VGA, 31KHz output, so will be displayed nicely on a computer monitor.

Some old boards, in particular old Konami boards and most from early 80s would need an adapter because the connection is not an standard JAMMA. This would introduce a further layer to the setup, but it’s not the usual for non-antediluvian games.

One more thing: in my setup I use a SCART switch, but I don’t recommend doing so unless really necessary (for example when the cables won’t reach the back of the TV) as these switches usually add noise to the image. With this SCART connection we won’t usually get stereo sound, as the JAMMA standard is only in mono. Some boards, however, (like the NeoGeo) uses the negative audio signal for a second audio channel, something the Supergun must manage. Otherwise, the boards usually have a direct audio connection.

NeoGeo games come in two formats: MVS and AES. MVS are the arcade games, somewhat bigger, and AES are for the the home version, and are region locked. They don’t share the connection and it’s necessary an adapter to use it in a system they weren’t designed for, but technically are the same gadget and hold the same date. Ok, time to test everything.

Once everything is connected we can play already. This Supergun model has more lights than Las Vegas (Nevada, not Sevilla), noting that there’s voltage on lines 12V and 5V. There’s an “insert button”, since it’s something the controllers won’t have. Otherwise it would be a run for the arcade owner, doesn’t it?

Now we can finally enjoy our games. An advantage that NeoGeo MVS offers against the home model is that, in spite that home model was cheaper back then, the MVS sold more and it’s easier and cheaper to find nowadays. It takes such a mess to set everything up, but we can use any arcade board we want with it. We can find a NeoGeo board for like 40 or 50 euros, and games ranges from 30 for the most common to a few hundred for the hardest to find.

I hope this article, describing my experience, can help somebody. In any case it must be noted that I don’t have any relation with the eBay sellers I make reference of, and I cannot be responsible of anything you buy or try to set up. Some links are sponsored, meaning they would give me a misery if somebody buys anything. If you are going to try anything described here at least follow your common sense: don’t touch with your filthy hands the connections, don’t play with electricity and take caution of not short-circuiting anything, as you can find yourself without your game. Or carpet.

Edit: It seems eBay doesn’t like my links so they have been removed.

La entrada About using arcade games at home se publicó primero en Nobody comes after the last.

Among the electronic circuits that have made possible the sound aspect of the digital world there are really notable ones. Because the melodies they have been written for, the impact in the gaming (or general) culture, its capacities or simply because the leap they meant. As the dumb lists enthusiast I am, here is a list of some which, in my judgement, are the most interesting and deserve to be remembered.

The dawn of sound

First computers were huge machines devoted to military calculus and research, and were basically mute. Some could beep a little, but in 1961 a giant leap came and we could hear the IBM 7094 not just playing music, but singing too. It wasn’t until 1971 that, at last, commercial video games appeared as such with Spacewar! (Steve Rusel), which included among its circuits some noise generators to liven up the program.

Following this it should be noted that first video gaming began to be sold (staring with Magnavox Odyssey in 1972) were either mute or with a little buzzer as audio. In 1977 Atari presented its VCS, later known as the Atari 2600. Among its cuts we could fin the TIA, created by uncle Jay Miner, and later enhanced in the computers Atari 400 and 800.

Anyone who had one would remember its crude, off-key sound. It had mono output, with two oscillators with several modes, each one with 32 tone and 16 volume levels. It was a programmable sound generator (PSG) rather poor, but was one of the first recognisable ones, manufactured in huge quantities and with several versions. In the ’80s it derived in the POKEY chip, used in famous arcades like Tetris (Atari, 1988) or included in some console cartridges to expand its sound capabilities.

TIA, POKEY and many others weren’t really dedicated hardware. These chips usually had many purposes. POKEY for example worked as sampling hardware for potentiometers and other analogue signals, and TIA served also as video generator.

Texas Instruments SN

One of the first audio dedicated chips that we could hear in a plethora of console systems were the Texas Instruments SN family. Born in the early 80s, these chips had some modest capabilities: tree square wave generators and a white noise channel, at least with a more easily modulated tone and volume this time.

The list of system which used these SN is very big: Game Gear, Master System, Mega Drive, Sega SG-1000, Tandy 1000, IBM PCjr, Coleco Adam, BBC Micro, NeoGeo Pocket, a lot of arcade machines… and many others. SEGA consoles, apart from SG-1000, integrated this chip in their audio/video processors. They were used in so many places that became some of the most ubiquitous and recognisable 80’s sound. However it was easy to mix up with its direct competitor: the General Instrument AY.

General Instrument AY

This audio chip was born a couple years before SN, its sworn competitor. Its characteristics seem taken from them: three square wave oscillators and a noise channel. However, even when it wasn’t a intended feature, it was possible to play PCM digital sound through software techniques, at a high CPU cost. Its registers were bigger, too, so it was possible to tune frequencies and other characteristics in a finer way, and thus the audio output.

The main platforms that used the AY chips to play sounds were the Amstrad CPC, Intellivision, Vectrex and the Atari ST. Case of which was a deep sorrow among its user when compared to Amiga audio capabilities. 

Yamaha YM (OP)

The Yamaha YM family is varied and prolific, and has been used in an awful lot of computers and consoles, and some of the most common PC sound cards in the 90s. They are in general chips with frequency modulated synthesis and several PCM or ADPCM channels.

OP series was used in expansion cartridges in computers as the Commodore 64 and the MSX, but specially in PC sound cards. Starting with the AdLib and then on almost every Creative Labs Sound Blaster at the end of the 80s through mid 90s. In this case it was accompanied with one or several DAC, while retaining the particular Yamaha FM synthetic sound. In fact, a great majority of PC game of this era supported these chip to play music.

OPN family, on the contrary, was mainly used in video game consoles, although it was used in NEC Japanese computer line, known as PC-88. It was used in some keyboards too, with partial compatibility with Yamaha DX series. The main usage, however, was in video game consoles as Mega Drive and Neo Geo. In the SEGA console case with a single PCM channel, and in the SNK‘s with several ADPCM capable channels.

Other systems were backed by digital audio, but the Mega Drive, as well as SEGA 16 bit arcades, bid  for the FM synthesis in its Yamaha YM2612. This made its sound effect a lot less convincing, but in the other hand the music sounds like a proper synthesizer. In the adequate hands it could made some amazing tricks.

The rest of their chips, with various denominations (OPN, OPP, OPZ, RYP4, PCMD8, SCSP…) were used in consoles like Sega Saturn, but mostly they were heart for Yamaha famous keyboards and drum machines.

SPC700

Super Nintendo was a very capable system in its sound capabilities. This was due to a particular well designed and powerful sound subsystem, the S-SMP. This system included a DAC, a 64 KB SRAM, a 64 bytes ROM, a DSP and the SPC700 chip, brain for the audio system. It was designed by Ken Kutaragi, later known as the father of PlayStation.

Contrary to many contemporary audio chips it wasn’t a programmable sound generator, nor a FM synthesizer: it was a true wavetable engine with 8 digital channels rated at 32KHz, 16 bit. It was also a whole programmable system, executing these programs from its static memory. The SPC couldn’t read the SNES main RAM, but it was possible however to use the CPU to transfer between them, and some games took advantage of this to swap samples on the fly and overcome the 64K barrier.

In the midst of the four generation console war (link in Spanish only) it became a strong argument in favour for the SNES. With only one digital channel the Mega Drive couldn’t offer the same convincing sound effects and drums at the same time, something the Super Nintendo would excel in. At the cost, of course, of not having any audio synthesis capability, so the 64KB SRAM would frequently fall short for longer, modulated or dynamic sounds.

APU

1983 was a convulse time for the video game industry. Nintendo made a strong bid with its NES, including tasking Ricoh with a programmable audio chip at a very competitive cost, with superior capabilities compared to AY and SN. Five oscillators with triangular, sinusoidal and square waves, a noise generator and a channel in which it was possible to play PCM audio. Having no proper DMA capabilities, an intensive CPU use was needed, and the console couldn’t do much more when doing so.

In the beginning Ricoh was reluctant to comply. Nintendo asked for a very competitive price, and it was perceived as a dangerous move. But after Nintendo promising millionaire purchases they accepted. A great success, for it sold in many millions. Thus the 2A03 was born, the commercial designation for the Audio Processing Unit. (Just in case the intrepid reader has not realised, this APU doesn’t have anything to do with the Simpsons)

Even when Master System was a more powerful console, Nintendo took the prize and many people identify its particular APU sound as the 8 bit aesthetic. It is evident too that audio capabilities of the APU were superior, as it was more recent and had many desirable characteristics.

Paula

In the mid 80s it was the Amiga era. They were unrivalled  when it came to multimedia capabilities. In 1985 they competed even with professional musical machinery, because to their amazing audio features. Thanks to a multimedia oriented architecture and, of course, to a chip named Paula.

This chip was in charge of controlling the floppy disk drive, the parallel port communications and of course the sound system. Its capabilities were amazing for the era: four digital audio channels rated at 8 bit or two at 14 bit controlled by DMA. Thanks to this hardware the mod files became popular, which took advantage of all audio system characteristics.

Their principle of operation was more similar to modern sound cards than its earlier counterparts. Instead of the CPU polling and sending data in real time to the audio processor, it could just tell the Paula chip where in the RAM was the sound stored, how did we want to play it, at which volume, when to stop… and Paula would do its job on its own. I the meanwhile we would have the whole CPU for our games while digital, multi-channel music was playing, defeating anything heard before.

Other feature this chip had, even though seldom used, was using a channel as modulator for another, allowing rudimentary frequency modulated audio synthesis or using them as a filter. It wasn’t used very often as the results weren’t impressive. Something that was, however, was the software channel mixing, popularising 8 channel digital audio players. But this consumed too many CPU, so it was impractical for games and other programs.

SID

Finally, as usual, my superfavourite. The Sound Interface Device, better known as SID, is the audio chip for the best selling compute system ever: the Commodore 64. It isn’t a sophisticated audio digital player, or anything near it, just a humble programmable audio synthesizer, with mono output and three voices that sounded like hells. It’s considered one of the reasons the demoscene was born on this computer.

Each of the three voices had its own programmable oscillators, each one with a independant ADSR (attack-decay-sustain-release) curve, CPU controllable if necessary. It included external analogue parts as low-pass, notch filters or ring modulation, channel independant. This would make it a true modern audio synthetiser; everything in a 1982, mid priced computer.

This chip had also more traps than rodents for trapping. For example, modifying some of the registers at the adequate frequency could seemingly play digital sound, albeit at low resolution. Unfortunately this was “fixed” on later revisions, making this audio almost inaudible. Fortunately another trick was discovered for both versions, although it required a dedicated channel, sensibly reducing the available audio channels.

This chip doesn’t seem a big deal on paper, in fact in early years is wasn’t as exploited as deserved. Along the years, authors as Jeroen Tel or Ron Hubbard squeezed the SID potential in games, providing some of the most memorable soundtracks of the era. The demoscene did the rest, pulling a sound that would have rivalled with professional synthesizers. All this would contribute to consider a cult sounding machine, and very valued among musicians and collectors. It also helps to its collectible status that it was one of most delicate parts of the system, requiring a dedicated 12V AC (9 in the second version) and getting screwed beyond repair at a drop of a hat if the power source wouldn’t supply very regular values.

Author for this chip founded Ensoniq company, devoted to synthesising keyboard. The second was the ESQ-1, built to be what its authors wanted the SID to be back in his day.

Some other here and that

It was very interesting that PC-Engine, a modest 8 bit console, had such a great graphic and sound capabilities back in 1987. Thanks to its CPU (which served as audio chip too) it had near wavetable audio capabilities, mixing PSG capabilities and digital audio. Having its size, pricing and scope is well worth tipping our hat.

In PlayStation we could hear the might of the CD digital audio, but we mus not forget the PSU, Playstation Sound Unit. This chip allowed an incredible 24 ADPCM digital audio channels at CD quality, sequenced by MIDI streams. Well yes, CD audio was great, but you suely remember musics in Final Fantasy and the like… Nintendo and its powerful 64 bit CPU were not in position to compete. PlayStation 2 had a enhanced version of this chip with more channels, more quality, more effects and… well, more of everything.

There was a worthy contender however in the Sega Saturn‘s YMF295 chip, that would allow this and more: FM synthesis, DSP filtering and a dedicated RAM. Everything controlled by a Motorola 68EC000 dedicated CPU. Unfortunately this complex piece of technology didn’t had audio uncompressing capabilities.

Endnotes

Something odd happens in the world of audio synthesis. I love the warm sound of analogue synthesiser as the Minimoog, and the might of the modern digital synthesizers. In the 80s and 90s however there is a void of uncool pop music. Even then, one of my greatest hobbies is video game music of this era, using precisely this kind of technology.

Well, this could have helped to video game music stereotypes (classics at least) being outdated and childish melodies. Us veteran players however mostly agree that they are an essential part of the digital culture.

I didn’t want to brought the topic of sound cards (Sound Blaster, Covox Speech Thing, etc) or general purpose system dedicated to audio generation and processing (MT-32) as they didn’t were dedicated audio chips, but they deserve however an own article at length. I’ll leave it for other some time.

I tried to gather and discover some of the best examples (and those which I like the most) of chips that shaped videogame sounds at its best moment, although I must recognize that it’s strange doing so in this acronym jargon and uncomprehensible technologies. Oh and, of course, we lack a lot of chips here in lots of forms, colours and flavours, but that is left as an exercise for the reader.

La entrada Sound chips that shaped video games se publicó primero en Nobody comes after the last.

There is something in Kero Blaster (2014) that dispels all my doubts at first glance: it’s signed as the second completa game by Daisuke “Pixel” Amaya, the mastermind after the legendary Cave Story (2004).

Kero Blaster premises are obvious: a run’n’gun game that mimics classics from the 20th century in playability and multimedia aspects. Its resemblance is even beyond Cave Story‘s as this time there’s almost any dialogues or exploration, being all the levels all linear. This isn’t a bad thing per se, just a design option, a well used choice and justified by a good level design.

This is a game initially released on iOS, but released not much later on more accessible platforms as Steam. Even then, controls don’t resent at all (I’ve played only the PC version with a controller) and allows to be played without problems. Moreover, it introduces a concept I loved: when the fire button is pressed, the character will continue facing its direction until released, making boss fights much easier and enjoyable.

Back to the playability, it will undoubtedly satisfy you. It might add a bit of difficulty comparing to Cave Story kind of games, as it introduces a bit of inertia, but not as much as Super Mario Bros. (Nintendo, 1985). The game offers a classic experience, which however allows modern elements as game saving and many different enemies on screen. I believe limiting video memory to 64K won’t have done much for a more credible experience anyway. 

There’s not a lot to say about graphics, but almost everything is good. It is true that they are simple, not very colourful and in low resolution. But that’s part of their charm: Daisuke Amaya is precisely known for expressing a quite lot with just a fistful of pixels. It’s to be said that the main character is a bit so-so, but for the rest they are perfectly created, and even with a simple bunch of pixel they are create with, they even appear to have their own expressions and everything.

The game sound is on par with other aspects, and helps the general aspect of the game to be genuinely retro. Well, it’s no better compared to Cave Story, but even then they are fidel to Pixel‘s style. So melodies are so authentic and it achieves a warming charisma for the game. Not having the exploration component in this game, is it possible to compose music with less restrictions.

The game keeps a great quality throughout the game, with a good enemy, level and enemy design. The story is quite simple, just a worker of a teleport company doing some works, some of the which gets complicated. Even when the dialogues aren’t passionately deep they are perfectly translated to a lot of languages (Spanish included) for our own comfort. The worst point of the game is its length, which is about a hour and a half for a not-so-good player (me), but it’s warranted that all that time we’ll be well hooked. Also it has something I love: a shop to spend all our moneis and getting our weapons and vitality better.

Well, we don’t really have to settle with the hour and a half the game offers, because completing the game will unlock the “overwork” game mode. This is, additional levels remixed from the first run, which aren’t as surprising as the first but still good if we want more the same. Two spin-offs were made, too: Pink Hour (2014) and Pink Heaven (2014), short but free.

Whether you liked Cave Story or you just like run’n’gun games this is a great choice to spend the afternoon, as it’s usually at a competitive price. I’m personally looking forward to Pixel Studios next production.

La entrada Kero Blaster – Impressions se publicó primero en Nobody comes after the last.

In 1996 they created a game strongly inspired in the great Sim City 2000 (1993, Maxis), this is, a city simulator. However its subject is so unique and different: instead of cities we must create and take care of Heaven and Hell, so Planet’s souls can have their eternal rest. With the advice of our two assistants, we should make their journey to the Great Beyond profitable for us.

As previously stated, the view and the game planning are awfully similar to Sim City 2000‘s, so much that at first glance it seems a blatant clone. Isometric view, roads, zones, buildings… but of course, there’s no one city, but two; which correspond to Heaven and Hell. Neither there are police or fire departments, but some unique structures to make the rewards and punishments work as intended.

The souls coming to our Afterlife, depending if they have done good or bad deeds, will inhabit our Heaven or Hell. Depending on how have they lived their lives, they will be assigned a punishment or a reward based on the seven capital sins and virtues of the catechism: humility/pride, charity/avarice, chastity/lust, peacefulness/wrath, temperance/gluttony, satisfaction/envy, diligence/laziness. Well, literature in this theological subject varies a bit between authors, but these are the ones used in the game.

Those responsible of executing this punishment (or satisfying these awards) are of course angels and demons. At first they will come from other realms, thus costing a quantity of pennies (in game currency), but after a while we should train some, too. We shall take other parameters into account, as the capacity of our entrances and exits provided by our gates and karma trains. These trains by the way will allow the souls finally leave our realm when their journey is finished, thus leaving space for new ones. All of this must be planned to be as stable as possible, so punishments and prizes are as efficient as possible, and so our economy wouldn’t suffer by a bad planning.

One of the strong subjects in the game is its trademark humour, sometimes pop culture referred and religion in others. For an example, some disasters in the game (this is shamelessly taken from Sim City 2000, too) are Disco Inferno, or The Hell Freezes. This humour is also brought by our assistants, Aria Goodhalo and Jasper Wormsworth (Jasper Turbator in Spanish release), impeccably dubbed in the Shakespeare’s language by the way. (And so they are in Spanish)

Dub is also other of the great virtues of the game. Either in Spanish or English this is a remarkably well done job, even with some jokes lost in translation in Spanish the quality and professionalism is very high. The rest of the sound aspect is not left behind, being on par with the rest of the production. In the Spanish version, however, sometimes it’s a mess of yells and cries and it’s a bit annoying.

Graphical aspects of the game also holds firmly. Buildings are very original, and each reward and punishment have a multitude of them. Our assistants, too, are very well animated and the graphical art as a whole is coherent with the overall quality of a George Lucas company. Game introductory video, even when it’s original, it’s not unheard of, but it’s another of the odd pleasures of this game. (and dark humour)

In general it could be said that the game production is very looked after and worth of a great company as Lucas Arts. What is the playability like, then? Well, again it’s blatantly taken from Sim City 2000, and it’s a playable game from the beginning. It also come with very comprehensive tutorials narrated by our assistants that will let us know how to get started. From building roads, entrances, exits, buildings or rewards to balancing our delicate, celestial and infernal budget.

Wow, what a great game is this! How is it possible to be so obscure? Well, this could easily have been one of the genre’s references because its variety, originality and its great craft. Unfortunately it suffers from some problems that made it pass through history without trouble or fanfare. In the first place, even with the entertaining and complete tutorials, it’s impossible to get how the game economy works, and we will lose pennies a lot while we ask ourselves what the hell (heh, heh) are we doing wrong. This brings the second matter: it’s absurdly difficult and not intuitive at all, and even when we have dozens of graphs, maps and hints it’s terribly easy to make the budgets fly off and lose our temper to our creation.

The game has a rather complex simulation, and we will have to keep an eye in Planet’s inhabitants beliefs to accordingly plan punishments and rewards that will accommodate them. We could even not to need a Heaven or a Hell depending on that beliefs, as they could not believe in Heaven, Hell or nothing at all. We would need to look after their technology too, because they can go all idiot blowing themselves up with an atomic bomb. All of this while prancing and dancing around with the most delicate budget in the world, if we can even figure out the damn thing.

With so many virtues the game has it’s a real pity that the game has such an unforgiving difficulty, and such an unworthy arbitrariness when it comes to balance its difficulty. Have these points been more polished we could be talking about a very different game, in the likes of Will Wright did in the past.

If we want to get the game ee will have to settle with a budget “games for Windows 95” CDs. It can be however bought from stores like GoG for a mere five euros, but again we will have to settle with the MS-DOS version, as the Windows version misfires more often than Kayne West at Jeopardy. Also as usual in this hallowed store they completely ignore the Spanish speaking community and it’s only available in English.

Even with all these problem the game has it’s worthwhile having a look and giving a try to it. Even today the game holds still, and the original themes it has makes it interesting nowadays. It’s good enough to remember it, although it is true that this is a game that really could use a remake, rather than the plethora of “classics” in the like of Carlos Duty and endless Mariozeldas. Not because it appearance might be outdated, but in order to fix its compelling health issues. I’m afraid however that its low popularity won’t help.

La entrada Afterlife – Retroview se publicó primero en Nobody comes after the last.

There were ports in a great number of platforms, from the Macintosh (the original) to GameBoy Advance, but my favourite is MS-DOS, and it’s what this article is about. There are two interesting files: the executable (SC2000.EXE) and the data file (SC2000.DAT). Unfortunately, Windows version didn’t came out in Spanish (my mother language), and Network Edition version works awfully bad (and it is available only in English).

SC2000.EXE

The game executable does not seem to have many resources, but it does have some interface texts. In the hexadecimal editor we can see some fixed-width labels.

There are some texts representing variable-width labels, too. There are also some embedded files, in which for example game scenarios are described.

At the moment disassembling an executable from the early 90s is not one of my specialities, and thus I have not find out much. Pointers are not evident in the executable, so I left it alone. But the most interesting is the data files we are describing down below.

SC2000.DAT

This is the main data file. It does not have a header, but a short look in the hexadecimal editor throw some hints about its structure.

It turns out that from byte 0 the first we can find is 16-byte blocks that describe files contained in the pack. The first field is evident: 12 bytes with the file name (8 + 3 characters of the MS-DOS file with the period). If there is leftover space, the rest of the bytes are 00h.

The other two bytes are not so evident, but it turns out that the game is originary from Macintosh, which at that time used Motorola processors. These processors, unlike Intel‘s, are Little-Endian (being Intel Big-Indian). This means that numbers with more than one byte are stored ordered from the least significant byte to the most significant, instead of the “natural” ordering. This is thus a 32 bit unsigned integer in little-endian format, which codifies the offset of the file just before.

I owe the happy idea about the offset to Brett Lajzer, an Albany software engineer that began researching this file before me. I wrote him to swap information and advised me about this point, which he didn’t finally describe in his article.

Unpacking and packing, knowing this, is relatively simple. I’ve written a small Java program that makes this operation easy:

package sce2000;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import org.apache.commons.io.FileUtils;

public class Sce2000 {
	
	public static final String SC2000DAT = "G:\\dos\\sce2000\\sc2000.dat";
	public static final int NUMFILES = 399;
	
	public static class Filestrut implements Serializable {
		private static final long serialVersionUID = 1L;
		public String filename;
		public int offset;
		public int targetOffset;
	}

	public static void main(String[] args) throws IOException, ClassNotFoundException {
		
		if (args.length == 0) {
			info();
		} else if ("x".equals(args[0])) {
			extract();
		} else if ("c".equals(args[0])) {
			create();
		} else {
			info();
		}

	}
	
	public static void info() {
		System.out.println("Usage: x to eXtract or c to Create (after eXtract) + sc2000.dat file");
	}

	public static void create() throws IOException, ClassNotFoundException {
		
		File sc2000dat = new File(SC2000DAT);
		File metafile = new File(SC2000DAT + "!/meta");
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(metafile));
		List<Filestrut> files = (List<Filestrut>) ois.readObject();
		
		List<Byte> targetFile = new ArrayList<Byte>();

		for (Filestrut file : files) {
			byte[] fileNameBytes = file.filename.getBytes(StandardCharsets.US_ASCII);
			for (Byte myByte : fileNameBytes) {
				targetFile.add(myByte);
			}
			for (int i = 0; i < 16 - fileNameBytes.length; i++) {
				targetFile.add((byte) 0);
			}
			//sourceFile.length();
		}
		
		int i = 0;
		for (Filestrut file : files) {
			byte[] binary = Files.readAllBytes(Paths.get(SC2000DAT + "!/" + file.filename));
			int fileOffset = targetFile.size();
			for (Byte myByte : binary) {
				targetFile.add(myByte);
			}
			int filePointer = 12 + (16 * i);
			
			byte[] offsetBytes = fromInt(fileOffset);
			targetFile.set(filePointer, offsetBytes[0]);
			targetFile.set(filePointer + 1, offsetBytes[1]);
			targetFile.set(filePointer + 2, offsetBytes[2]);
			targetFile.set(filePointer + 3, offsetBytes[3]);
			
			i++;
		}
		
		byte[] binaryFile = new byte[targetFile.size()];
		for (i = 0; i < targetFile.size(); i++) {
			binaryFile[i] = targetFile.get(i);
		}
		
		FileUtils.writeByteArrayToFile(sc2000dat, binaryFile);

		
		System.out.println();
		
	}
		

	public static void extract() throws IOException {
		
		Path sc2000dat = Paths.get(SC2000DAT);
		byte[] data = Files.readAllBytes(sc2000dat);
		
		int vector = 0;
		List<Filestrut> files = new ArrayList<Filestrut>();
		for (int i = 0; i < NUMFILES; i++) {
			
			Filestrut currfile = new Filestrut();
			
			currfile.filename =  convertFilename(Arrays.copyOfRange(data, vector, vector + 12));
			vector += 12;
			
			currfile.offset = fromByteArray(Arrays.copyOfRange(data, vector, vector + 4));
			vector += 4;
			
			System.out.println("Found file " + currfile.filename + " at " + currfile.offset);
			
			files.add(currfile);
			
		}
		
		File dir = new File(SC2000DAT + "!");
		if (dir.exists()) {
			FileUtils.deleteDirectory(dir);
		}
		
		dir.mkdir();
		
		Iterator<Filestrut> fileIt = files.iterator();
		
		Filestrut file = fileIt.next();
		Filestrut fileNext = null;
		
		boolean stop = false;
		while (!stop) {
			
			File extracted = new File(SC2000DAT + "!/" + file.filename);
			
			int init = file.offset;
			int end = -1;
			if (fileIt.hasNext()) {
				fileNext = fileIt.next();
				end = fileNext.offset;
			} else {
				end = data.length;
				stop = true;
			}

			System.out.println("Writing: " + extracted.getAbsolutePath());
			FileUtils.writeByteArrayToFile(extracted, Arrays.copyOfRange(data, init, end));
			
			file = fileNext;
			
		}
		
		File metafile = new File(SC2000DAT + "!/meta");
		
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(metafile));
		oos.writeObject(files);
		oos.close();
		
		System.out.println("OK!");
	}
	
	public static byte[] fromInt(int number) {
		byte[] bytes = ByteBuffer.allocate(4).putInt(number).array();
		swapEndianess(bytes);
		return bytes;
	}
	
	public static void swapEndianess(byte [] bytes) {
		byte temp1 = bytes[0];
		byte temp2 = bytes[1];
		bytes[0] = bytes[3];
		bytes[1] = bytes[2];
		bytes[2] = temp2;
		bytes[3] = temp1;
	}
	
	public static int fromByteArray(byte[] bytes) {
		// Change endianness
		swapEndianess(bytes);
		return ByteBuffer.wrap(bytes).getInt();
	}
	
	public static String convertFilename(byte[] data) {
	    StringBuilder sb = new StringBuilder(data.length);
	    for (int i = 0; i < data.length; ++ i) {
	        if (data[i] < 0) { 
	        	throw new IllegalArgumentException();
	        }
	        if (data[i] == 0) {
	        	break;
	        }
	        sb.append((char) data[i]);
	    }
	    return sb.toString();
	}


}

This program has been done quick and dirty and it’s not what we would say optimized. I indulged myself loading the whole files in memory as the complete DAT file is few megabytes big. Also it has the file count and DAT path hardcoded in the code. Making it better and more efficient is left as an exercise to the reader.

Why in Java? It’s not the most appropriate for handling binaries, and not having unsigned types support doesn’t precisely help. I simply did it in Java and not in C because it’s the language I use for a living, and the one I’m the most fluent with. Also I’ve not programmed anything in C for 10 years. 🙂

Using the above code (or any other the intrepid reader can code) we can see the following file types:

• RAW, as the header-less image files.
• PAL, as the colour palette used in the game.
• Text files, some as TXT* without an extension and others with RAW extension.
• XMI, with the music.
• VOC, with the sound effect files.
• FNT, with the typography files.
• Etc, etc…

Let’s talk about them a bit one by one.

VOC files

The game sound files are stored in VOC files. Well, that’s one is easy, as it’s not a common file format but broadly supported on many sound edition programs. It’s a format by Creative Labs that chiefly stores PCM and ADPCM coded audio, although sometimes has been used for other encodings.

It can be perfectly open and saved with Adobe Audition. The sampling frequency varies from one file to another, but is recognized without many problems.

Text files

There are three kinds of text file types. The most simple are TXT* files without an extension, being * a number. They can be directly opened with Notepad++ and be edited without problems.

Well, not quite. Encoding is not ASCII, nor UNICODE because it wasn’t common at the time. Which one, then? Well, being the game was programmed for Macintosh, encoding is Macintosh Roman. This is a problem because Notepad++ does not support it. It’s been asked for, but seems not the priority, so you might want to convert it somehow to edit it more comfortably.

Addendum: It supports it after all! The option was buried in the menus: Encoding > Character Sets > Cyrillic > Macintosh.

Other text files are STR*.RAW and *.RAW, being * a number. Their format is not so nice.

So the first byte is always 00h, and the second seems to store the string count in the text. Strings, unlike in C, aren’t coded terminated in 00h. They are stored preceeded by its length, coded in 1 byte. Ideally we could use an utility software for this, which could easily be coded. (but I don’t feel like to)

The third text file kind correspond only to PPDT1003.RAW file, which has one of the funniest characteristics in all SimCity 2000: the newspapers.

Unfortunately this format is a nightmare. It begins with a term dictionary separated by 00h, and then a clump of texts used to generate the articles. This custom encoding is variable-width (for an example, 5C96h represent the ñ character) and uses the previously defined terms, and of course placeholders for article subjects. These articles are procedurally generated, and an article denouncing the disappearance of an animal had as the main protagonist a cat or a rhinoceros, owned by mrs. Dwight or mr. Martínez.

Back in the day we had editors like Thingy, which supported TBL files. You could specify a term dictionary there and easily edit files like this. Anyway, it would only be of use if we could keep the string length, and even then we would need to decipher the preceding number (and its encoding) so we could properly edit it.

Addendum: It seems the pointers for the newspaper texts are in the PPDT1004.RAW file. They consist in blocks of 4 bytes in big-endian. What a mess.

Image files

Excluding some text files (described in above), RAW files store the images used in the game interface. Buildings and other elements are in some DAT files that would be out of the scope of this article, because they can be edited much more easily with the SimCity Urban Renewal Kit (SCURK), a tool included in some later versions which could edit cities “by hand” and modify the graphical aspect of the buildings.

Now about the files in question, these RAW files are 8 bit (256 colours) bitmaps with a 4 byte header. It doesn’t seem to be relevant information about resolution or colours, but for that matter we have another file, MINE.PAL, which specifies the colour palette used throughout the game. It’s not a Microsoft Palette file as the extension suggest, but a raw palette ACT type. Interestingly, it’s the preferred format used in Adobe Photoshop.

So for the resolution, there seems not to be an easy way to find it out simply looking at the file. The most easy method is factorizing the number (minus 4 bytes) in two factors, something Photoshop could help us with when opening the file, at least in the most modern version. By the file name we can more or less tell what’s the file for, and in case we have played (you really should!) the game, you could more or less recognize its width/height ratio. Some are easy: the title screen (TITLE.RAW) is a 640×480 image. All the images use the same palette, as the game only uses the same 256 colours all of the time.

I always use the same technique editing 8 bit indexed colour images: I convert them to 24 bit colour (plus 8 bit alpha channel) and I edit them comfortably. After that, before saving them, I change them to indexed color loading again the game palette. Surprisingly enough, saving the files in Adobe RAW format, the game loads it right, because Photoshop would allow us to preserve the 4 byte header. What a relief!

Please note: needless to say this RAW format has anything to do with raw image formats the nowadays digital cameras uses.

XMI files

Game music tracks are stored in the XMI files. Tis format supports many tracks per file, but this seems not the case. The structure is very different from MIDI files, but they do about the same: store musical notes and events. It can be played in Windows easily with Foobar2000, and it is possible to convert MIDI to XML (and vice versa). MIDIPLEX seems to be able to do it from Windows, but no compiled binaries are offered so I did it with older tools with MS-DOS, using DOSBox. Anyway, the very SimCity 2000 will need DOSBox to work in modern systems.

FNT files

They are presumed to be the game typographies, to judge from the numbers and the extension they come with. It seems not the same format that Windows uses (bitmap FNT), so I’ve been unable to open the files with any editor.

Others

Other files present in the package are General MIDI sources for OPL chipsets, some indexes and headers for the building graphic sets… anything very interesting when modifying the game. Everything else seems to be embedded in the executable file, something it’s out of my reach at the moment.

In Windows

On a point of information, the Windows version can be modified much more easily. The image and sound resources are present in WAV and BMP format, which are much less obscure as the previously described. The rest of the resources are embedded in the game executable, but with a resource editor they can be extracted and modified with ease, and in more accessible format than their MS-DOS counterparts. (I use Resource Hacker, which is free and works quite well)

Newspapers, however, seems to have the same calamitous format than the MS-DOS version. It’s a pity, because it would be very interesting to translate this version to Spanish.

So this is where I leave it. I hope it’s been educative, although after all this time there seems to be little interest modifying this game. I’ve always wanted to meddle with this game and create my own mod, Sim City 2000 effect, a bit mischievous, but maybe that’ll be in another time.

La entrada Taking Sim City 2000 into pieces se publicó primero en Nobody comes after the last.