Starcraft Shareware CD

I might have mentioned this somewhere before, but despite being an avid fan of the RTS genre, I never really had a taste for the Starcraft franchise. What makes all this even weirder is that I also love sci-fi a great deal, but yeah, the whole thing, it just never seemed to resonate with me. You know? It’s one of those, “It’s not you, it’s me!” type of situations. Or that’s what I like to tell myself at least.

Anyway, given that the recent cinematic announcement trailer about the upcoming entry in the franchise seemed to have raised some eyebrows in some circles, I have decided to yap a little about the Starcraft Shareware CD, which I have stumbled upon earlier in the year, while casually browsing around on the interwebz archive.

CD

The CD has been ripped in the BIN/CUE format, which meant that I had to convert it to ISO, with the bchunk utility.

$ bchunk input.cue input.bin output.iso

The resulting ISO that has been spit out by running the ancient incantation above is exactly 230686720 bytes or 220 mega-bytes in size, and happens to have an MD5 checksum of ad5d17e3d665d16c105ff9b7694ff4b6.

Next, I generated a listing of the CD itself, which you can peruse at your leisure by checking out the table below.

I felt like providing only the CRC-32 checksum of each file, was to be more than sufficient in case someone looking for a specific version of any of the included files might happen to stumble upon this very post at some point.

AUTORUN.INF

The first thing that caught my eye while browsing through the CD was the AUTORUN.INF.

[autorun]
OPEN=SETUP.EXE
ICON=SC.ICO

I asked myself, why doesn’t this simply point to INSTALL.EXE, for both OPEN= and ICON=? Rather curious, isn’t it?

Examining the entrypoint of SETUP.EXE in Ghidra has revealed the following sequence of function calls.

int nRes;

res = FUN_00401000();

FUN_00401370(res);

Nothing too interesting at first glance, which led me to take a look at FUN_00401000:

int FUN_00401000(void)
{
  int nRes;
  
  nRes = FUN_00401020();
  if(nRes == 0)
  {
    FUN_00401080();
  }
    
  return 0;
}

Well, that’s underwhelming, isn’t it? But, I soldiered on like the true champ that I really am, and struck nothing less than liquid gold in the FUN_00401020 function:

int FUN_00401020(void)
{
  HANDLE hEvent;
  CHAR szBuffer[256];
  int nRes;

  nRes = LoadStringA(GetModuleHandleA(NULL), 0x64, szBuffer, sizeof(szBuffer));
  if(nRes != 0)
  {
	hEvent = OpenEventA(EVENT_ALL_ACCESS, FALSE, szBuffer);
    if(hEvent != 0)
    {
      CloseHandle(hEvent);
      return 1;
    }
  }
       
  return 0;
}

The resource string with id 0x64 is: "Starcraft Check For Other Instances", which I have double checked by dumping the resources via winedump:

$ winedump -j resource SETUP.EXE | tail -n 11 | head -n 3
  STRING Name=0007 Language=0000:
    0064 "Starcraft Check For Other Instances"
    0065 "SWarClass"

I feel like this doesn’t need a whole lot of explaining, and it should be pretty much self explanatory that this is a standard way to ensure that only a single instance is running at given any time.

At this point it was rather obvious that if FUN_00401020 returned 0, which meant that no other instances were found to be running, then FUN_00401080 would simply proceed to launch INSTALL.EXE via ShellExecuteA.

This is exactly the case, however, one thing that is worth calling out is the fact that it extracts the current path of itself by calling GetModuleFileNameA using the handle returned by GetModuleHandle(NULL) first, rather than fiddle around with the CD-ROM drive letter, which used to be a rather annoying thing that many studios around this time did more often than not, simply out of sheer ignorance or incompetence, I could never determine which.

DirectX 5.0

In the DIRECTX5 directory that is present on the CD, one can find an off-line copy of the DirectX 5.0 runtime (rather unsurprising, right?), which Microsoft ended up shipping on Aug 4, 1997 as per the official press release.

Some consider version 5.0 to be the very first stable version (whatever that means!?), but I have to respectfully disagree with that assessment, and state that in my personal opinion, the very first version worthy of the stable label is none other than version 7.0.

An interesting little tidbit that I have only discovered when writing all this up, was the very fact that Microsoft was still shipping more than handful of virtual device (mini-)drivers (VXD) as part of the runtime at this point.

This DRIVERS/USA/ATI_M64.VXD bad-boy for example is a mini-driver for the ATI Mach64 family of cards.

$ grep -m 3 'ATI_M64' DXATI.INF 
%PCI\VEN_1002&DEV_5654.DeviceDesc%=ATI_M64, PCI\VEN_1002&DEV_5654 ; Mach64 VT
%PCI\VEN_1002&DEV_4754.DeviceDesc%=ATI_M64, PCI\VEN_1002&DEV_4754 ; Mach64 GT
%PCI\VEN_1002&DEV_4755.DeviceDesc%=ATI_M64, PCI\VEN_1002&DEV_4755 ; Rage II (U3)

How very demure, how very mindful of them, right?

ISP

The ISP directory houses an assortment of software from some of the major dial-up Internet Service Providers from the 1990s, some of which come with semi-branded IE4 and Netscape installers.

Nothing too terribly exciting, unless one is researching this particular subject matter of course.

Help

I was surprised to find that the HELP directory is more or less an off-line copy of the support section of what used to be the actual Starcraft mini-site on-line, or it has been crafted to look the part the very least.

It makes sense I suppose, the year was 1998, when all of this was being cobbled together after all.

INSTALL.EXE

Once I was done with my cursory browse-through session of the CD, the details of which I’ve outlined above, it was time to stare at the elephant in the room that is INSTALL.EXE with a size of 163820728 bytes or 157 mega-bytes.

This is nothing more than an installer stub with an MPQ package (archive) appended to the very end of it, which is pretty much how Blizzard was creating all their installers all the way up to the early 2000s.

Think of it as a customized Winzip Self Extractor on steroids, but with an MPQ rather than a ZIP archive in it.

Just because I like to back up my clams with evidence, I had no choice but to dig deeper just a wee bit.

To verify that the 3EE00h offset is the correct one, I checked out the very last section of the executable image itself.

$ winedump -f INSTALL.EXE | tail
      INITIALIZED_DATA  MEM_READ  MEM_WRITE

  .rsrc      VirtSize: 0x000044e8  VirtAddr:  0x00047000
    raw data offs:   0x0003a800  raw data size: 0x00004600
    relocation offs: 0x00000000  relocations:   0x00000000
    line # offs:     0         line #'s:      0       
    characteristics: 0x40000040
      INITIALIZED_DATA  MEM_READ

Done dumping INSTALL.EXE

Adding 0x0003A800 + 0x00004600 yields exactly 0x0003EE00, so it all checks out.

This also means that the actual size of the stub is a mere 257536 bytes, that amounts to something like 257 kilo-bytes. It’s way bigger than the stub powering the pre-release-demo version of Diablo from a few years back.

Cinematic Previews (trailers)

Even if you didn’t pay too much attention to the screenshot(s) of the installer above, you might have still noticed the View Previews button, clicking on which will end up playing two cinematic previews in fullscreen at a glorious resolution of 640x308.

The first trailer is for the then upcoming StarCraft: Bood-War expansion pack, and the second is a teaser for the much awaited Diablo 2. This is sometimes also being referred to as the so called “Diablo 2: E3 cinematic trailer”.

Both videos are in the Smacker video format developed by none other than RAD Game Tools, as evidenced by several occurrences of the SMK2 signature inside the MPQ archive, as well as the presence of the SMACKW32.DLL library in the same directory as the INSTALL.EXE.

I don’t want to go into much more technical details here, because I intend to do it justice in the form of a dedicated post sometime in the near future, in which I’ll illustrate how to go about extracting and upscaling these trailers for the purposes of digital preservation of course.

IPX

I do not miss the good old dial-up days, believe you me, but it does bother me to some extent that I never had the chance to experience playing any games over IPX at the time.

I am also well aware of that fact that there have been a couple of drop-in replacements that happen to implement it over UDP and such, but I’d still like to roll my very own implementation at some point, just for the fun of it all.

Precursor Campaign

The least surprising thing to me was that this version of the game came with a separate self-contained campaign, often referred to as the precursor or prequel campaign.

It consists of a total of 5 missions, and is still available as a separate download to be played with the full version of the original game as yet other regular custom campaign.

This wasn’t something unusual in this transitional-era, where shareware slowly started turning into so called trial-ware at first (remember the Age of Empires: Trial?), before taking the final steps and morphing into the concept of the demo that is still alive and well today.

What makes most of the games from this era to be less than enjoyable today in their original form is primarily the fact that they all happen to have their resolutions locked down to a meager 640x480 or 800x600 respectively.

Just like in the case of the IPX support, there are existing solutions that can help one remedy this, like replacing the ddraw.dll with a custom built shim of sorts, but as per usual, I’d like to spend some time and write my own at some point or another in the future, which naturally would also be usable with other games from this time frame.

In closing

I sincerely hope that you enjoyed this little totally serendipitous tour in the land of digital archeology as much, as I enjoyed spending my time digging around and then writing it all up in the form of this semi-lengthy post.

A seemingly random encounter with a shareware CD has managed to spawn no less than 3 different additional mini-side-projects; all of which now have to compete against all the others left in the drawer to be picked up later.

It’s not easy at all, you know? Oh well.