I could tell George-stories all day long, but I’ll restrict myself to the one that brought back the memory – the job interview…

The scene, an office building in Leeds which by coincidence housed both the legendary Realtime Games Software and upstarts Vektor Grafix. Quite a large coincidence given that Realtime were well known for 3D Starstrike, an unofficial clone of the Star Wars arcade machine, while Vektor Grafix had just completed the official Atari-licensed conversion of the same.

It was at the door of Vektor Grafix that what can only be described as the third Blues Brother arrived, complete with dark suit and sunglasses. This was George and he played bass guitar, but rather than wanting to put the band back together he was selling out to the man and had come about the job. It quickly became apparent that he knew his stuff, and he also demonstrated some very complex circuit board design software he’d written, so he moved straight on to the coding test which had been hastily invented the day before. If I remember correctly, it was along the lines of “here’s some font data, here’s some text, render it to the screen.”

We sat George down in front of the development system of the day, which was an Amstrad PC1512 running an cross-assembler called PDS and hooked up via some custom hardware to the innards of a Spectrum.

“I just type it in here, do I?” asked George, somewhat bemused.

“Yes,” we answered, and off he went. Type turned out to be probably too strong a word, but nonetheless George set off typing – by which I mean alternately peering at the screen through the sunglasses and peering at the keyboard through the sunglasses while prodding a key with his index finger. This (or something like it) appeared on the PC screen…

17,0,64,33,...

“Whoa there,” I said, recognising Z80 opcodes (in decimal, of all things). “It’s an assembler, you can actually type the assembly language.”

“Wow, really? That’s amazing.” Off he went again…

LD DE,&4000
LD HL,...

The resulting program worked of course. It’s probably worth pointing out that knowing the opcodes (and associated instruction timings) was not all that unusual in those days, but when we realised that he’d developed the circuit board design software he’d demonstrated using nothing but a stream of decimal opcodes, we were blown away.

Anyway, it’s not a plaque on a park bench (or one of those ghastly football shirt and flowers tied to a lamppost things that seem to be all the rage these days) but for what it’s worth this is my memorial to George.

Since it was back in the days before internets, emails and bug databases, this list that included this particular bug report arrived, as was customary, by trans-Atlantic fax. What with timezone differences and costs of international calls in those days, the best course of action was to try and find the problem given the limited information.

After much testing and poring over the rendering code, the flight logic code, the cockpit code and anything else that could possibly be involved, we were no nearer a solution and finally had to give in and enter the dreaded ‘request more information’ cycle. How reproducible is this problem? “It happens every time.” Every time? We’ve done this hundreds of times, it never crashes here. Try it on a different machine? Cockpit view? External view? Try it in VGA mode? Turn the sound off? “Nope, no matter what, it always crashes.”

Eventually it turned out that the software wasn’t crashing at all. The plane was crashing, straight off the end of the carrier deck and into the sea. The resolution to the ‘bug’? Don’t attempt a short take-off with the air brake on.

I managed to catch up with a few requests for Hardwar technical information this evening. Various updates can be found in the usual place. I still have a few in the queue, so if I didn’t get round to yours, send it again. More than once if you’re in a hurry!

As the screenshot (click for full size) shows, I’ve also managed to compile a working version of RefMax, which was used to edit the 3D models, terrain, etc. Although progress has been made before editing and creating models without this by converting the game data to different formats, several people expressed an interest in getting hold of ‘the real thing’. It seems to work fine with the data you can extract from the game resource files. I’ll upload a copy when I’ve put together some basic instructions for setting it up and using it, but if anyone is keen to try it, let me know and it will encourage me to get round to it.

The first thing I was hit with was the ‘DRM‘, in the form of a “please enter 12 from page 47, paragraph 3 of the manual” question. A classic way to irritate your paying customers repeatedly, while the so-called pirates (arrrrr!) get off scot free. Of course, these days far more devious and dastardly schemes sail the high seas, but it did remind me of various other similar copy-protection fiascos I should be ashamed to have been involved in, so I’ll probably write more about them another day.

The next realisation was that it was really a PC game, shoehorned onto the Amiga, and really needing at least an A1200 rather than the comparitively sluggish A500. It did keep me amused for an hour or so, but all in all it wasn’t a very rewarding experience. Like most (but not all) old games, the memory is better than the reality, and probably best left that way. Suffice to say the game, and manual, have gone back in the box and will probably stay there for a long time.

In fact, until I get hold of some software, the Amiga is going back in the box as well, to sit in the loft with the countless other old computers.

There’s a lo-res version on YouTube here. I haven’t got a proper one yet.

I tried to get YouTube to find me more Hardwar-related videos but it got stuck on the idea of hardware and there doesn’t seem to be any way to tell it to find the exact word.

Digging around in some old archived data, I came across the source code for the PC (DOS) version of Star Wars, which consists of about 750K of ASM files -  quite a lot more than I’d have guessed at. A couple of the other files indicate that this is a copy of the source we brought back from California after working on the final testing over there, so it’s definitely the ‘latest’ version. There’s also a compiled EXE, but unsurprisingly it crashes when I try and run it under Windows XP.

The source makes for a very entertaining read, at least for me, bringing back a lot of memories. It’s definitely not what you’d call a fine example of software engineering, even for its time, but it did work very well. Following is a choice excerpt, featuring few comments, and a smattering of self-modifying code which appears to be more for the sake of it than for performance in this case.

DoTrenchWalls    PROC    NEAR
 
        mov    cx,TrenchWidth        ;Draw outer walls of trench.
        add    cx,TrenchX
        mov    Pxl,cx
        add    cx,CentreX
        mov    dx,TrenchBottom
        mov    Pyl,dx
        add    dx,CentreY
        mov    Sx,cx
        mov    Sy,dx
        mov    W cs:InnSy+4,dx
        mov    W cs:UseLaterX+4,cx
        sub    cx,CentreX
        sub    dx,CentreY
        mov    ax,ZDist
        mov    Pzl,ax
        call    View3d        ; Same point in Distance
        mov    Fx,cx
        mov    Fy,dx
        mov    bx,RecursePosition
        mov    ResX[bx],cx
        mov    ResY[bx],dx
        push    cx
        call    Msdraw
        mov    ax,01200h
        add    ax,TrenchY
        mov    Pyl,ax
        call    YView3d
        pop    cx
        mov    Fx,cx
        mov    Fy,dx
        mov    W cs:WasJustBufY+4,dx
        call    MsDraw            ; VertDraw.............!!!
        mov    dx,Pyl
        add    dx,CentreY
        mov    Fy,dx
        push    dx
UseLaterX:    mov    Fx,0FFFFh      ;self mod
        call    MsDraw
        mov    ax,0-TrenchWidth
        add    ax,TrenchX
        mov    Pxl,ax
        add    ax,CentreX
        mov    Sx,ax
        mov    W cs:WasBufX10+4,ax
        mov    dx,W [cs:InnSy+4]
        mov    Sy,dx
        mov    bx,RecursePosition
        mov    dx,W ResY[bx]
        mov    Fy,dx
        mov    ax,ZDist
        mov    Pzl,ax
        call    XView3d
        mov    Fx,cx
        mov    W cs:UseLater2+4,cx
        push    cx
        call    Msdraw
        pop    cx
        mov    Fx,cx
WasJustBufY:    mov    Fy,0FFFFh      ;self mod
        call    MsDraw            ;VertDraw............!!!
WasBufX10:    mov    Fx,0FFFFh      ;self mod
        pop    dx
        mov    Fy,dx
        call    MsDraw
        mov    bx,RecursePosition
        mov    cx,W ResX[bx]
        mov    Sx,cx
        mov    dx,W ResY[bx]
        mov    Sy,dx
        mov    Fy,dx
UseLater2:    mov    Fx,0FFFFh      ;self mod
        call    HorzDraw
        ret
 
DoTrenchWalls    ENDP

The question now is what to do with this blast from the past, which judging by the state of the CD it was on (a 1998 archive of 1988 code), it was about to disappear forever since much of the rest of the contents wouldn’t read at all. I could try and get it working as is, or port the data and logic to a more modern environment, or I could re-archive it and come back to it in another 20 years. Probably the latter is the sensible option.