DOS apps (Turbo Pascal & assembler) – playable in your browser

In the 1990s I built various DOS apps in Turbo Pascal and assembler together with Marcel van der Lem and Eric Oostendorp — featuring Sound Blaster audio and VGA 256-color. A revolution at that time: real audio could be played from your PC, instead of bleeps from a small speaker. Having more than 2 colors or 16 colors EGA was a revolution. With all this, gaming instantly became much more attractive with realistic colors and sound.

Note: It’s good to realize that the Internet didn’t exist yet back then. There were no off-the-shelf libraries you could pull routines from either. So we had to figure everything out and experiment ourselves. Often programming directly at the pixel and sound-byte level in the processors’ registers, hoping you didn’t break anything. On errors you’d get no message or only a vague one. Then the debugging began. That way, at least, you really learn how the tech works :-).

Below you’ll find a selection of my programming adventures. Click a tile to start. Tip: use F11 for fullscreen.

Snackman (game)

My first DOS game: an arcade-style Pac-Man variant. Graphics made in Deluxe Paint. Sounds made with our self-built sample editor S-Edit. “Dirty” programmed without transparent sprites. Arrow keys, F11/F12 for CPU speed. Arrow keys, F11/F12 for CPU speed.

Shortmo (demo)

From the early days of the Sound Blaster: my first demo that moves a sprite with a MEM-move, and plays music via the AdLib processor. I “borrowed” the ant from another game. Arrow keys, F11/F12 for CPU speed.

Palette rotate

One of my first experiments with VGA 256 colors. You’re looking at a static image and I rotate the VGA palette, creating the illusion of movement,m>. F11/F12 for CPU speed.

Stonezone

Supercool VGA mode 320x400 puzzle game developed with Eric Oostendorp. Match identical stones until the board is empty.

Silicon (demo)

From the early days of the Sound Blaster: my first demo that could play a sample and let you influence the sample rate in real time with the + and − keys. Uses VGA palette rotate and the included Sound Blaster 1.5 driver.

Art of Noise (demo)

By now we were quite far along exploring VGA and Sound Blaster capabilities. The average PC had 256 KB of RAM, far too little for good samples. The Art of Noise samples were recorded with our own sample editor S-Edit, and the app uses EMS. This resulted in a simple demo with soundtrack. Arrow keys, F11/F12 for CPU speed.

Sample editor S-Edit

Our biggest project during our studies: an audio sample editor with advanced sound-editing options. 4 years of development together with my good friend Marcel van der Lem. Click HERE for the webbrowser version of S-edit.

Sourcecode

Complete code and explanation for a sampler. Explains step by step how an input signal is visualized via a scope line.

Android game

About 12 years ago I developed a game called Color Code e.g. Mastermind, for Android devices. Click on the banner to directly download the APK and install on your device. Send me a message if you want to receive the MIT APP Inventor .AIA file.


{ Project : Scope in mode 12h                                           }
{ Version : 1.1                                                         }
{ Author  : Jeroen Koomen                                               }
{ Date    : Released 24 april 1993                                      }
{ Specs   : Shows a scope which responds to input signal from           }
{           LINE-IN, MIC OR CD                                          }
{ Bugs    : Uh..... Well I.....  But..... I...   None.                  }
{                                                                       }
{ (C) Copyright 1993 Jeroen Koomen                                      }
{ (C) Copyright 1993 SONIX                                              }


{ I have tried to keep the explanation as easy as possible, so anyone   }
{ who is familiar with the AND, XOR, OR and SHR/SHL commands should be  }
{ able to understand what's happening ...............                   }
{ As you can see, no TPU's are linked - such as GRAPH.TPU and CRT.TPU   }
{ and that's the beauty of this program - with most compiler options    }
{ disabled, the EXE will be 2800 bytes                                  }

{ MOST OF THE CODE IS PURE TURBOPASCAL, I mention this because there are}
{ still lots of people who think you need assembler for these kind of   }
{ tricks - after all we wrote S-EDIT our sample editor, AND PROMIXER    }
{ our replacement for Creative Lab's SBP-MIX, entirely in Turbo Pascal! }
{ Due to the vertical retrace this program runs the same speed on all   }
{ possible system configurations -                                      }

{ I made this source-code public, and I'm sure it contains some         }
{ valuable information for you. That is why I expect you to leave THIS  }
{ sourcecode intact, and use your own imagination to do something with  }
{ it in your programs. If you do, I do NOT expect you to mention either }
{ my name or the name of SONIX - as long as you do not modify this code }
{ and spread this as much as you can ......... thanks in advance .....  }



{ IF YOU HAVE ANY QUESTIONS ABOUT PROGRAMMING THE SB, E-MAIL ME :       }
{                                                                       }
{ v882136@si.hhs.nl   (Haagse Hogeschool sector Informatica )           }
{                                                                       }
{ I'm sure I can help you out ...........                               }


{$G,$X}


var io_port : word;       { Is going to contain the base I/O adress     }
    t       : byte;       { Will be used to assign the input device     }


{***********************************************************************}
{ HEY !!! you can use this in all EGA/VGA color modes ........          }

Procedure SetColor ( Color, Red, Green, Blue : Byte ); assembler;
asm
  mov dx,3c8h
  mov al, color
  out dx, al
  mov dx,3c9h
  mov al, red
  out dx,al
  mov al, green
  out dx,al
  mov al, blue
  out dx,al
End;

{************************************************************************}
{ This function returns TRUE if a soundblaster PRO is found. The hi-byte }
{ and the low-byte will contain the DSP version number. I do not use the }
{ low-byte because I'm not interested in that, I just want to know if    }
{ the DSP version number is 2.x or 3.x (for soundblaster PRO)            }

function sbpro : boolean;

var hi_byte : byte;

begin
  sbpro:=false;
  while ((port[io_port + $0C] AND 128) <> 0) do; { wait for DSP ready }
  port[io_port + $0C] := $E1;
  while ((port[io_port + $0E] AND 128) = 0) do;  { wait for DSP ready }
  hi_byte := port[io_port + $A];
  if (hi_byte=2) OR (hi_byte=3) then sbpro:=true;  {sb1.5 and sb2.0 < 2}
end;                                               {sbpro = 2 or 3     }

{************************************************************************}
{ Reset the soundblaster (if present) and get the correct I/O-port       }
{ This routine works with all soundblaster card versions                 }

function reset_blaster : boolean;

CONST RESETS         = 10;
      RESETTIMES     = 50;

var resetok                : boolean;
    nr_resets, times_reset : word;

begin
  io_port    := $210;
  resetok    := false;
  nr_resets  := RESETS;
  while (io_port <= $260) AND (not resetok) do
  begin
    port[io_port+$6] := 1;
    port[io_port+$6] := 0;
    times_reset      := RESETTIMES;
    while (times_reset>0) AND (port[io_port+$E]<128) do
      dec(times_reset);
    if (times_reset=0) OR (port[io_port+$A]<>$AA) then
    begin
      dec(nr_resets);
      if nr_resets=0 then
      begin
        nr_resets := RESETS;
        inc(io_port, $10);
      end;
    end
    else
      resetok:=true;
  end;
  reset_blaster:=resetok;
end;

{*************************************************************************}
{ Not even a DIV or a MOD - they only slow things down - and we couldn't  }
{ use that now do we ?                                                    }

procedure scan_input;

var samplebyte,
    xorbytes   : array[0..320] of byte;
    wipearray  : array[8..320] of word;
    counter    : integer;

begin
  { disable keyboard interrupt }
  asm
    mov al,01011010b
    out 21h,al
  end;

  { By pre-calculating the sequence 128-64-32-16-8-4-2-1-0 you can     }
  { speed up the scope a little bit .... See below for the use of this }
  for counter:=0 to 320 do
    xorbytes[counter]:=(128 SHR (counter AND 7));

  repeat
    { first record the array ...........        }
    for counter:=6 to 320 do
    begin
      { Tell the DSP you want to read input ...}
      port[io_port+$C]:=$20;
      { Wait for the DSP to have the next byte available .... }
      repeat until port[io_port + $E]>=128;
      { and fetch it ...... }
      samplebyte[counter]:=port[io_port+$A];
    end;

    {wait for the vertical retrace.....}
{    repeat until (port[$3da] and 8)<>0;
    repeat until (port[$3da] and 8)=0;}

    { XOR the values on the screen......       }
    for counter:=8 to 320 do
      begin
        { fill an array so that you won't have to calculate the offsets }
        { of the pixels again when you wipe them ...........            }
        wipearray[counter]:=(counter SHR 3)-(samplebyte[counter]*80)+30820;
        mem[$A000:wipearray[counter]]:=mem[$A000:wipearray[counter]]
                                             XOR xorbytes[counter];
      end;

    {wait for the vertical retrace.....}
    repeat until (port[$3da] and 8)<>0;
    repeat until (port[$3da] and 8)=0;

    { XOR the pixels back to black ....}
    for counter:=8 to 320 do
        mem[$A000:wipearray[counter]]:=mem[$A000:wipearray[counter]]
                                             XOR xorbytes[counter];

  until port[$60]=1 { Only respond to the  key };
  { give back keyboard interrupt }
  asm
   .mov al,0
    out 21h,al
  end;
end;


{ When sampling, do not use the first byte, because this is an ADC
  reset-byte. Because each x-coordinate is 8 bits, we start to plot
  pixels at value 8.

  The scope-line offset on 30820 : y-coordinate = 385 (385*80 = 30800  )
                                   x-coordinate = 160 (            20*8)
                                                                -----
                                                                30820

  Suppose : counter             = 19  X-coordinate AND index for the array
            samplebyte[counter] = 52  The sampled value in the array which
                                      will be the Y-coordinate-therefore it
                                      has to be multiplied by 80 for the
                                      correct offset in memory

  Determine the x-coordinate :

  counter shr 3 gives 2; this is the second byte on the screen (=8 pixels)
  then determine which pixel (bit) has to be turned on :

  counter AND with 7 (this is equivalent to MOD 8),  this gives 3. <-------+
                                                                           |
  Because I draw the scope line from the left to the right, not the 3rd    |
  bit from the right, but the 3rd bit from the left has to be turned on.          |
                                                                           |
  If the most left bit is on and the rest is off, the byte has value 128.  |
  This left bit has to be shifted to the right 3 positions ----------------+
  and has to be put in video memory (See below : this is value 16d).

  This shows the 'caclulation' above : ---------------------+
                                                            |

           128 SHR 0      128 SHR 1      128 SHR 2      128 SHR 3

             byte 2         byte 2         byte 2         byte 2
            /      \       /      \       /      \       /      \    etc.
            10000000  XOR  01000000  XOR  00100000  XOR  00010000

              128d            64d            32d            16d


  So each byte has to be sent 8 times to the same offset in video-memory.

}

{************************************************************************}



begin
  { Check if there is a SoundBlaster present ....... }
  if not reset_blaster then
  begin
    writeln ('You need a SoundBlaster to run this program .......');
    halt;
  end;

  { Select videomode 12h ; 640*480 pixels VGA 16 color (with 4 bitplanes)}
  { I do not use all 4 to keep things simple, I just use one bitplane    }
  asm
    mov  ah,00
    mov  al,12h
    int  10h
  end;

  { Give the default pixelcolor (63)     }
  { new RGB values - Yellow in this case }
  setcolor(63,63,63,0);

  { Just to be sure - turn off the speaker else you cannot record ... }
  { SPEAKER ON = $D1  SPEAKER OFF = $D3                               }
  port[io_port + $0C]:=$D3;

  { Check if there is a SoundBlaster PRO present }
  { and enable the use of multiple input devices }
  { If a normal SoundBlaster is installed, MIC   }
  { will be used as input automatically          }
  if sbpro then
  begin
    { First select the input device :       }

    { Tell the DSP you want to write to it  }
    port[io_port + $4]:=$0C;
    { Then assign the current settings to t }
    t:=port[io_port + $5];
    { Clear all settings                    }
    t:=t AND $F9;
    { Assign the input device to t          }
    { 0=MIC, 1=CD, 3=LINE-IN                }
    t:=t OR (3 shl 1);
    { And pass it to the DSP                }
    port[io_port + $5]:=t;
  end;

  scan_input;

  { And back to textmode .......    }
  asm
    mov  ah,00
    mov  al,3
    int  10h
  end;
end.


{ WELL, I THINK EVEN A CHILD  COULD UNDERSTAND THIS CODE ..... AFTER SOME  }
{ ADVICE FROM A FRIEND OF MINE WHO DIDN'T UNDERSTAND THE CODE WITHOUT THIS }
{ DOCUMENTATION : PRACTICE PRACTICE PRACTICE .......                       }