si78c is a memory simply reimplementation of the 1978 arcade sport Dwelling Invaders in C.

It requires the novel arcade ROM to characteristic to load a bunch of sprites and
other data, but does no longer expend the novel sport code.

It’s a long way no longer an emulation, but reasonably a restoration.

It’s a long way on the opposite hand, barely ample that it will also be oldschool to designate the internal
workings of the novel machine, in a extra accessible system.

Many thanks to Christopher Cantrell at computerarcheology.com. Without his
painstaking work and very perfect notes, this mission would have taken plenty
longer.

This was as soon as a sexy clear project, requiring many iterations over several
months, and I could well presumably conservatively estimate that round 200 hours of labor have
been put into the mission so a long way.

The normal ROM is round 2000 lines of 8080 assembler, all of it sport code.
The final printed version of si78c is round 1500 lines of sport code, 500
lines of help code, and round 800 lines of feedback.

There are about twenty thousand extra lines of unpublished code within the
background consisting of the old iterations and other help scripts
and tools that essential to be written to procure the job completed.

When running, si78c produces an identical memory states (apart from the stack) to
the novel version. As a natural side pause, it produces pixel simply
frames when put next with the novel.

Cycle timing is no longer namely simply, however the sport code is no longer
namely tranquil to this, as it makes expend of interrupts for timing most
issues, as a replacement of clock cycles.

The intended viewers is hackers, followers, scholars, students, historians,
and someone else engaged in digital archaeology.

The code is supposed to be oldschool as a extra accessible handbook to discovering out the
normal sport, and discovering out about its internal workings.

Where perfect, I in fact have oldschool the an identical or an identical characteristic and variable names as
Cantrell, to extra without problems abet of us discovering out both versions. The code is furthermore
specified by a an identical inform to the novel.

Every characteristic with a matching analog within the novel machine is signposted
with a commentary like xref 028e, which affords the deal with of the matching routine
within the novel ROM.

A pair of alternative places within the code like loops and branches are annotated equally.

To search out extra detail on code shut to an xref, chances are you’ll presumably expend Cantrell’s
very perfect notes right here.

The normal code is interrupt pushed, and in part co-operatively
multitasked. The sport spends about a third of the time running the vital
thread, which will get pre-empted by the midscreen and vblank interrupts. The replacement
two thirds of the time is break up between these interrupt contexts, which may well presumably be no longer
pre-empted, but mediate when to system to predominant.

It furthermore contains some attention-grabbing ingredients like this:

02D0: 31 00 24        LD      SP,$2400         // wipe the stack
02D3: FB              EI                       // drop isr context
02D4: CD D7 19        CALL    DsableGameTasks  // tackle going from this point

That code (running in an interrupt context) after detecting the player’s death,
in fact wipes out all thread contexts (including itself), and then becomes
the brand new predominant context.

To deal with issues like this within the this in si78c, I clear to expend ucontext
(user level threading) to give me extra stunning grained tackle a watch on over thread
switching, introduction and destruction.

The an identical portion of code in C to the above is a piece of messier, and involves
the usage of swapcontext to swap to a scheduler context, which then resets all of the
contexts, and then swaps abet and re-enters at the desired point.

There just isn’t the sort of thing as a sound, because the sound hardware is no longer emulated.

Cycle timing is no longer namely simply, as mentioned, but its no longer very
essential on this case.

The code will currently finest work on little endian methods, because the novel
machine (8080) was as soon as little endian, and we expend the ROM data as is.

The sport is identified to diagram and speed on Ubuntu 18.04 and MacOSX El Capitan, and
will likely speed on other x86 Unix methods, as lengthy as they help ucontext and
SDL2. Unfortunately, ucontext is deprecated on MacOSX, so it could perhaps presumably no longer speed on
later versions.

The sport is written within the subset of C99 that is appropriate with C++, and makes expend of
no compiler extensions apart from attribute packed. This can diagram stunning on GCC 3
and above, and in all likelihood any Unix C or C++ compiler more moderen than that.

Porting to a non unix machine like Dwelling windows would require altering out ucontext
to expend threads or fibers. Porting to a simpler machine like DOS, or something
bare steel will require writing some code to blit to the framebuffer, and
adapting to no subject native interrupt facilities come in.

In the case of CPU direct required, the code just isn’t always namely optimized, and
currently requires a 32-bit processor tremendous of as a minimum 10 Mips. It can presumably be
made to compare on a smaller machine with a piece of of labor.

The code assumes little endian. To port to a huge endian machine would require
extra dissection of the ROM, to call and swizzle any little endian data
when it is a long way loaded.

Porting the code to 1 more language would no longer be a shrimp job, and would most
likely require switching out the threading machine, and changing the code to
no longer expend pointers.

SDL2 is required as a dependency, to set up on Ubuntu, attain this:

$ sudo simply-procure set up libsdl2-dev

To capture the code and diagram the binary, attain this:

$ git clone https://github.com/loadzero/si78c.git && cd si78c
$ diagram

As mentioned, the novel arcade ROM is required, invaders.zip from the
MAME_078 dwelling is identified to work.

The constituent ingredients wants to be positioned in a folder known as inv1, and have
these checksums:

$ md5sum inv1/7d3b201f3e84af3b4fcb8ce8619ec9c6  inv1/invaders.e
7709a2576adb6fedcdfe175759e5c17a  inv1/invaders.f
9ec2dc89315a0d50c5e166f664f64a48  inv1/invaders.g
e87815985f5208bfa25d567c3fb52418  inv1/invaders.h

To speed it:

The keyboard controls are:

a   LEFT
d   RIGHT
1   1P
2   2P
j   FIRE
5   COIN
t   TILT