← Terug naar homepagina

DOS-apps (Turbo Pascal & assembler) – speelbaar in je browser

In de jaren 90 bouwde ik samen met Marcel van der Lem en Eric Oostendorp diverse DOS-apps en DOS-games in Turbo Pascal en assembler — met Sound Blaster audio en VGA 256-kleuren. Toen een revolutie: de PC produceerde in eens natuurgetrouwe audio, in plaats van bliepjes uit een klein luidsprekertje. Meer dan 2 kleuren en later 16 kleuren EGA was ook revolutionair. Met dit alles werd gaming meteen veel leuker met realistische kleuren en geluid.

NB: Goed om te realiseren dat er in deze tijd nog geen Internet bestond. Ook geen kant-en-klare libraries waar je routines uit kon halen. Alles moesten we dus zelf uitzoeken en uitproberen. Vaak rechtstreeks op pixel- en soundbyte niveau in de registers van de processoren programmeren, hopen dat je niets stuk maakte. Bij fouten kreeg je geen of vage meldingen. Dan begon het debuggen. Op die manier leer je in ieder geval wel hoe de techniek echt werkt :-).

Hieronder vind je een selectie van mijn programmeer-avonturen. Klik op een tile om te starten. Tip: gebruik F11 voor fullscreen.

Zie ook: Jeroen Koomen (homepage) • Fotografie

Snackman – retro DOS-game van Jeroen Koomen

Snackman (game)

Mijn eerste DOS game: een Arcade-stijl PacMan-variant. Graphics gemaakt in Deluxe Paint. Geluiden gemaakt met onze zelf gebouwde sample-editor S-Edit. "Vies" gepeogrammeerd zonder transparante sprites. Pijltjestoetsen, F11/F12 voor CPU-speed.Pijltjestoetsen, F11/F12 voor CPU-speed.

Shortmo – DOS-demo met sprite-beweging en AdLib muziek

Shortmo (demo)

In de beginjaren van de SoundBlaster: mijn eerste demo die een sprite met een MEM-move beweegt, en muziek speelt over de AdLib processor. De mier heb ik gejat uit een andere game. Pijltjestoetsen, F11/F12 voor CPU-speed.

Checker – VGA 256-kleuren palette-rotate demo

Palette rotate

Een van mijn eerste experimenten met VGA 256 kleuren. Je kijkt naar een statisch plaatje, en ik laat het VGA Palette roteren waardoor de illusie van beweging ontstaat. F11/F12 voor CPU-speed.

Game DOS

Stonezone

Supercoole VGA mode 320x400 puzzle game ontwikkeld met Eric Oostendorp. Wissel stenen en speel het bord leeg.

Silicon – DOS-demo met sample-rate controle en VGA effecten

Silicon (demo)

In de beginjaren van de SoundBlaster: mijn eerste demo die een sample kon afspelen en waarmee je met de toetsen + en - de samplerate real-time kon beinvloeden. Gebruikt VGA palette rotate en de meegeleverde SoundBlaster 1.5 driver.

Art of Noise – DOS-demo met EMS en S-Edit samples

Art of Noise (demo)

Hier waren we al redelijk ver met verkennen van VGA en SoundBlaster capaciteit. Het running-geheugen op de gemiddelde PC was 256KB, veel te weinig voor goede samples. De samples van Art of Noise zijn opgeomen met onze eigen sample editor S-Edit, en de app maakt gebruik van EMS. Dit resulteerde in een simpele demo met soundtrack. Pijltjestoetsen, F11/F12 voor CPU-speed.

S-Edit – DOS sample-editor van Jeroen Koomen

Sample-editor S-Edit

Ons grootste project tijdens de studie: een audio sample editor met geavanceerde geluidsbewerkingsopties. 4 jaar ontwikkelwerk samen met goede vriend Marcel van der Lem. Klik HIER voor de webbrowser versie van S-edit.

Voorbeeldcode – Turbo Pascal/ASM

Sourcecode

Volledige code en toelichting voor een sampler. Vertelt stap voor stap wat er gedaan wordt om een input signaal via een scope-line weer te geven.

mastermind

Android game

Een jaar of 12 geleden heb ik in MIT APP Inventor gewerkt aan Color Code oftewel Mastermind, voor Android devices. Klik op de banner om de APK te downloaden. Installeer rechtstreeks op je Android device. Stuur me een bericht als je de MIT APP Inventor .AIA file wilt hebben.


{ 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 + $0A];
  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 .......                       }