Klassen
mail: andy@unitedbytes.de
www : http://www.unitedbytes.de
Release Date: 10/02/99
2.1 Jetzt gehts los!
====================
Hiieeyaa! Hier bin ich wieder mit meinem 2. Tutorial! Ich hoffe, das das hier
genausogut ankommt, wie das erste Tut!! Heute werden wir ein paar grundlegende
Dinge besprechen wie: Strukturen für den Player, Programmieren der Haupt-Engine,
Kollisions-Abfrage usw ...
2.2 Mit was fangen wir an?
==========================
Hmm ... *gruebel* ...mit was fangen wir am Besten an? Da ihr schon grundlegende
Kenntnisse in C/C++ habt, würde ich sagen, wir erschaffen uns erstmal eine
einfache
Player-Struktur. Nun werden einige sich wahrscheinlich fragen: "Player-Struktur???"
Wir wollen für den Anfang ein kleines Spiel zusammen programmieren, das
eine Art
Jump´n Run + Adventure werden soll. Gut. Und jetzt schauen wir uns einmal
so eine
"Player Struktur" an:
Struktur:
Name: ..........Eddy Mustermann (mir ist nix besseres eingefallen!)
Position x .....20 (X-Position der Figur)
Position y .....20 (Y-Position der Figur)
Feld x .........3 (auf welchem X-Feld? )
Feld y .........3 ( " Y-Feld? )
Energie ........100 (Lebens-Energie der Figur)
CanFly .........0/1 (kann der Typ fliegen?)
AttackPower ....5 (Angriffskraft)
CurrentWeapon ..1 (Welche Waffe?)
Speed ..........10 (Schnelligkeit der Figur)
Update .........0/1 (hat sich irgendetwas verändert?)
Sodele. In C/C++ sähe das dann so aus:
/* Code-Anfang */
class ThePlayer{
public:
char *name;
int xpos;
int ypos;
int xfeld;
int yfeld;
int energie;
short canfly;
int attackpower;
int currentweapon;
int speed;
int update;
};
/* Code-Ende */
Sehr gut. Jetzt haben wir eine Klasse names "ThePlayer" erstellt.
Klassen bringen uns sehr
viele Vorteile in der Spieleprogrammierung, weil man sehr einfach neue Player
ins Spiel bringen
kann, ohne das was ändern muss ... na gut, fast nichts! :)
2.3 Einstieg in die Grafikwelt !?
=================================
Nun, mit den Kenntnissen, die wir jetzt schon haben, können wir (leider)
noch kein Spiel
schreiben! Ich werde euch jetzt nicht (noch nicht!) mit Grafik-Knowhow versorgen,
weil
die Grafik vorerst noch Nebensache ist. Daher möchte ich mich auf den stinknormalen
25x80 Textmodus konzentrieren ... but don´t worry! Mode13 is coming soon!!
;)
Jetzt brauchen wir noch eine Struktur die ich in meinen Spielen IMMER verwende.
Ihr Name
ist "Global". Global deswegen, weil sich alle anderen Funktionen,
Klassen usw. auf diese
Struktur stützen.
Hier ist meine "Global-Struktur" für den Textmodus.
/* Code-Anfang */
int Map [25][80]; // Landkarte des Spiels
struct MyGlobals {
int tilesize; // Feldergröße (für Jump´n Runs etc.)
int screensizex; // Größe des Bilschirms X
int screensizey; // " " " Y
int status; // Status-Variable (ist manchmal ganz nützlich)
}
2.4 Here is it!! Der komplette Quellcode
========================================
Hehe ...dachtet ihr wohl!! Ich packe den Quellcode doch net in eine Textdatei!
Alle Sources, die bei meinen Tutorials mitgeliefert werden, sind gleich komplette
C/C++ Dateien.
Jetzt haben wir zwar eine wunderbare Struktur für den Player und die
virtuelle Welt, aber
wir können nichts damit anfangen! Ok, das wird sich jetzt ändern!
Hier der Code für eine
einfache Anzeige-Routine im Textmodus. Sie ist zwar nicht die schnellste, aber
dafür leicht
zu verstehen:
void ThePlayer::Draw ()
{
if (update==1) // Ist Update nötig?
{
textcolor (0); // Schwarze Farbe
gotoxy (oldxpos, oldypos); // Zeichne an OldX u. OldY
cprintf (" "); // Lösche Player
textcolor (14); // Gelbe Farbe
gotoxy (xpos, ypos); // Zeichne an X u. Y
cprintf ("O"); // Das 'O' kann auch gegen ein anderes Zeichen
// eurer Wahl ausgetauscht werden!
update=0; // Update wieder auf 0 setzen
}
}
Gut. Jetzt brauchen wir noch 4 Funktionen, um den Player bewegen zu lassen.
4 Stück deshalb: Auf, Ab, Rechts, Links! Achtung: Diese Codes haben noch
keine
Kollisionsabfrage! Wir werden sie erst später einbauen.
void ThePlayer::MoveUp ()
{
oldxpos=xpos;
oldypos=ypos;
ypos--;
update=1;
}
void ThePlayer::MoveDown ()
{
oldxpos=xpos;
oldypos=ypos;
ypos++;
update=1;
}
void ThePlayer::MoveRight ()
{
oldxpos=xpos;
oldypos=ypos;
xpos++;
update=1;
}
void ThePlayer::MoveLeft ()
{
oldxpos=xpos;
oldypos=ypos;
xpos--;
update=1;
}
Wow! Jetzt haben wir alles, um den Player bewegen zu können! Nur wie
machen wir das?
Da ich jetzt (noch) nicht in die Interrupt-Programmierung einsteigen möchte,
nehmen
wir die ganz normalen Tastaturabfragen in C/C++. Die sind zwar nicht die schnellsten,
aber dafür einfach zu erlernen.
void ThePlayer::EventManager ()
{
char ch;
if (kbhit()) ch=getch (); // Auf Tastendruck warten
if (ch==27) exit (0); // Wenn ESC gedrückt wurde, dann abbrechen
if (ch==0) // Wenn Sondertaste gedrückt wurde (Scancode 0)
{
ch=getch ();
if (ch==72) MoveUp (); // Wenn Cursor NACH OBEN gedrückt wurde
if (ch==80) MoveDown (); // " " NACH UNTEN " "
if (ch==77) MoveRight (); // " " NACH RECHTS " "
if (ch==75) MoveLeft (); // " " NACH LINKS " "
}
}
Taattaaa!! Unser erstes kleines (Test-) Spiel ist fertig!! Man kann jetzt
den Player auf
dem Bildschirm herumbewegen.
2.5 Ende von Kapitel 2
======================
Yep, das war Kapitel 2! Ich hoffe, es hat euch gefallen! :)
Mein nächstes Tutorial wird in den nächsten Tagen verfügbar sein.
Es kann aber auch sein, das das ganze noch n paar Tage warten muss,
weil ich z.Zt in der Schule ziemlich viel zu tun habe ;)
Cya in the next tutorial,
Andreas Löffler aka GD^CRAZY
Kontakt:
mail: andy@unitedbytes.de
www : http://www.unitedbytes.de
-=[EOF]=-
