CPCMiniPac (Amstrad CPC) by Stefan Hasenhütl

CPC MiniPac

-----------

-----------

CPCMiniPac is a game based on Pac-Man. The aim is to eat all the points without

getting caught by a ghost. Is controlled with the arrow keys.

There are 2 big dots that cannot be eaten.

However, the ghosts can pass these points. So be careful!

It runs on an Amstrad CPC-6128 and is written in Locomotive Basic 1.1.

Technical explanation

---------------------

---------------------

The game uses control characters instead of the following basic commands:

PAPER

BORDER

INK

MODE

SYMBOL

This technique is e.g. in the book https://archive.org/details/schneider-cpc-grafik-programmierung

described in chapter 2.4 (from page 84).

Special mode 0

--------------

This game uses CALL &BD1C to switch to MODE 0 but without clearing the screen.

In this way, 4 colors can be used per character instead of one color.

http://www.cantrell.org.uk/david/tech/cpc/cpc-firmware/firmware.pdf -> page 71

I calculated the individual characters with an Excel: calc_symbol_xls.png

I defined some characters that do not contain so many 0s directly via control characters in lines 10 and 20.

I defined the characters for the playing area (contains many 0s) in line 100 and read them in line 20

and set via PRINT command. (DATA lines 80 and 90)

Playing area

------------

It is 20 elements wide and 11 high:

Each field consists of 2x1 characters. Each entry in the table above represents a special character.

This table is stored in row 100 as HEX values. Lines 20 to 40 are read in and displayed on the screen.

Explanation of the individual basic lines

------------------------------------

10 -> SYMBOL AFTER for user-defined characters, control characters for colors and symbols, chr$(0) must be used for 0s

20 -> Remaining control characters output via PRINT, reading in and outputting the next control characters from DATA lines 80 and 90,

      Special mode 0 call, definition of ghost array e(4,4) and field array g(20,11)

      Start of the output of the playing field

30 -> Definition of other variables, e.g. setting the ghost positions on the playing field, due to lack of space at this point

      Convert HEX values to integers

40 -> Output of the playing field, chr$(210 + table entry) e.g. 210+4=214 characters at the top left of the playing field

      Beginning of the main loop WHILE w>0, start of the ghost loop, collision test with game end

50 -> Ghost movement algorithm, overwriting the current ghost position with characters from the playing field array

60 -> Output ghost in new position, keyboard query, output score, calculation of Pac-Man's position

      Memorizing the character at the possible next position from Pac-Man

70 -> Check if the next character is an invalid one on the playing field, if not then perform movement

      Show Pac-Man on the screen with animation, if Pac-Man was moved then show the playing field element at the old position

      If target position was a point (c=14) then count point and emit sound

80 -> end of game loop, control character data for characters

90 -> control character data for characters

100 -> playing field data in HEX, End of game message

Important Variables

------------------

e(A,B) A->ghost 1-4, B=1-> X coordinate, B=2 -> Y coordinate, B=3-> direction X, B=4-> direction Y

g(20,11) playing field -> values from 1-16

x -> X coordinate Pac-Man

y -> Y coordinate Pac-Man

a -> old X coordinate Pac-Man

b -> old Y coordinate Pac-Man

w -> number of points (starting value 97)

c -> character from the playing field e.g. 14 -> point

h -> variable for left and right arrow keys

v -> Variable for up and down arrow keys

CPCMiniPac

----------

----------

CPCMiniPac ist ein an Pac-Man angelehntes Spiel. Ziel ist es alle Punkte zu fressen ohne von einem Geist erwischt zu werden. Gesteuert wird mit den Pfeiltasten. 

Es gibt 2 große Punkte, die nicht gefressen werden können.

Die Geister können an diesen Punkten aber vorbei. Also vorsicht!

Es läuft auf einem Amstrad CPC-6128 und ist in Locomotive Basic 1.1 geschrieben.

Technische Erklärung

--------------------

--------------------

Das Spiel verwendet Steuerzeichen anstatt folgender Basic Befehle:

PAPER

BORDER

INK

MODE

SYMBOL

Diese Technik ist z.B. im Buch https://archive.org/details/schneider-cpc-grafik-programmierung 

im Kapitel 2.4 (ab Seite 84) beschrieben.

Spezial Mode 0

--------------

Dieses Spiel nützt CALL &BD1C um in den MODE 0 zu schalten, aber ohne den Bildschirm zu löschen. 

So können statt einer Farbe gleich 4 Farben pro Zeichen genützt werden.

http://www.cantrell.org.uk/david/tech/cpc/cpc-firmware/firmware.pdf -> Seite 71

Die Berechnung der einelnen Zeichen habe ich mit einem Excel gemacht: calc_symbol_xls.png

Einige Zeichen, die nicht so viele 0en enthalten habe ich direkt via Steuerzeichen in Zeile 10 und 20 definiert. 

Die Zeichen für die Spielfläche (enthält viele 0en) habe ich in Zeile 100 definiert und in Zeile 20 eingelesen

und via PRINT Befehl gesetzt. (DATA Zeilen 80 und 90)

Spielfeld

---------

Es ist 20 Elemente breit und 11 hoch:

Jedes Feld besteht aus 2x1 Zeichen. Jeder Eintrag in der obigen Tabelle steht für ein spezielles Zeichen.

Diese Tabelle ist in Zeile 100 als HEX Werte gespeichert. Das Einlesen und Darstellen am Bildschirm wird von Zeile 20 bis 40 gemacht.

Erklärung der einzelnen Basic Zeilen

------------------------------------

10 -> SYMBOL AFTER für selbstdefinierte Zeichen, Steuerzeichen für Farben und Symbole, für 0en muss chr$(0) verwendet werden

20 -> Restliche Steuerzeichenausgabe via PRINT, Einlesen und ausgeben der nächsten Steuerzeichen aus den DATA Zeilen 80 und 90, 

      Spezial Mode 0 Call, Definition vom Geister Array e(4,4) und Spielfeld Array g(20,11)

      Start der Ausgabe des Spielfeldes

30 -> Definition weiterer Variablen, z.B. setzen der Geisterpositionen am Spielfeld, aus Platzmangel an dieser Stelle

      Umwandeln der HEX Werte zu Integer

40 -> Ausgabe der Spielfläche, chr$(210 + Tabelleneintrag) z.B. 210+4=214 Zeichen ganz oben links vom Spielfeld

      Beginn der Hauptschleife WHILE w>0, Start der Geisterschleife, Kollisionstest mit Spielende

50 -> Geister Bewegungs Algorithmus, Überschreiben der aktuellen Geisterposition mit Zeichen aus dem Spielfeld Array

60 -> Ausgabe Geist an neuer Position, Tastaturabfrage, Ausgabe Score, Berechnung der Position vom Pac-Man

      Merken des Zeichens an der möglichen nächsten Position vom Pac-Man

70 -> Prüfen ob nächstes Zeichen ein ungültiges am Spielfeld ist, wenn nicht dann Bewegung durchführen

      Pac-Man am Bildschirm mit Animation ausgeben, wenn Pac-Man bewegt wurde dann an alter Position das Spielfeldzeichen darstellen

      Wenn Zielposition ein Punkt war (c=14) dann Punkt zählen und Sound ausgeben

80 -> Ende Spielschleife, Steuerzeichendaten für Zeichen

90 -> Steuerzeichendaten für Zeichen

100 -> Spielfeld Daten in HEX, WIN Meldung zum Spielende

Wichtige Variablen

------------------

e(A,B) A->Geist 1-4, B=1-> X Koordinate, B=2 -> Y Koordinate, B=3-> Bewegunsrichtung X, B=4-> Bewegunsrichtun Y  

g(20,11) Spielfeld -> Werte von 1-16

x -> X Koordinate Pac-Man

y -> Y Koordinate Pac-Man

a -> alte X Koordinate Pac-Man

b -> alte Y Koordinate Pac-Man

w -> Anzahl der Punkte (Startwert 97)

c -> Zeichen vom Spielfeld z.B. 14-> Punkt

h -> Variable für Pfeiltasten links und rechts

v -> Variable für Pfeiltasten oben und unten