Das erste SpielTeil 3 (Scherfgen 531 - 552)

Softwaretechnologie II (Teil 1): Simulation und 3D Programmierung

Medienwiss./Medieninformatik AM3

Visuelle Programmierung I 

Referent: Janek Rudolf

Inhalt

Schritt 5: Bälle hinzufügen

Schritt 6: Die Blöcke

Schritt 7: Versuche

Schritt8: Punkte

Schritt 9: Sound für das Spiel

Schritt10: Hier spielt die Musik

Schritt 5: Bälle hinzufügen

Erstellung von Klasse CBall

CGame werden 16 CBall-Variablen in einem Array hinzugefügt

U.a. BOOL m_bExists, BOOL m_bGrabbed, tbVector3 m_vPosition, tbVector3 m_vVelocity

Fortbewegung und Kollisionen des Balls

Bewegung durch Methode CBall:Move

Fortbewegung des Balls: m_vVelocity x vergangene Zeit seit letztem Frame(CBall:Move) +

m_vPosition

Ball kann mit Wand und Schläger kollidieren

Radius des Ballmodells = 0.25

Kollision mit der Wand tritt ein wenn:

x-Koordinate des Positionsvektor +/- 0.25 in oder hinter der Wand liegt. Rechts: x=9.25, Links: x=-9.25, z=4.25

Kollision mit dem Schläger tritt ein wenn:xBall >xSchläger-1.25 ^xBall<xSchläger +1.25^zBall>zSchläger -0.25^zBall<zSchläger+0.25

Indem die z-Komponente des Geschwindigkeitsvektors umgekehrt wird, prallt der Ball ab

Verlieren des Balls

Ist m_vPosition <= -12, geht der Ball verloren

Die Variable m_bExists wird auf FALSE gesetzt

Im günstigsten Fall „klebt“ danach ein neuer Ball auf dem Schläger

Ist das der Fall, wird m_bGrabbed == TRUE und die move-Methode verlassen

// Bewegt einen BalltbResult CBall::Move(float fTime){// Wenn der Ball klebt: abbrechen!if(m_bGrabbed) return TB_OK;

// Position verändernm_vPosition += m_vVelocity * fTime;

// Wenn der Ball eine Wand berührt, prallt er ab.if(m_vPosition.x - 0.25f <= -9.25f) {bWall = TRUE; m_vVelocity.x *= -1.0f; m_vPosition.x = -9.0f;} // Linke

Wandif(m_vPosition.x + 0.25f >= 9.25f) {bWall = TRUE; m_vVelocity.x *= -1.0f; m_vPosition.x = 9.0f;} // Rechte

Wandif(m_vPosition.z + 0.25f >= 4.25f) {bWall = TRUE; m_vVelocity.z *= -1.0f; m_vPosition.z = 4.0f;} // Obere

Wand

// Auch am Schläger prallt er ab (Natürlich!).if(m_vPosition.x >= m_pGame->m_vPaddlePos.x - 1.25f && m_vPosition.x <= m_pGame->m_vPaddlePos.x + 1.25f && m_vPosition.z <= m_pGame->m_vPaddlePos.z + 0.25f && m_vPosition.z - m_vVelocity.z * fTime >= m_pGame->m_vPaddlePos.z + 0.25f)

// Es gibt eine Kollision! Wir kehren die z-Komponente des Bewegungsvektors um.m_vVelocity.z *= -1.0f;

if(m_vPosition.z < -12.0f){ m_bExists = FALSE; }}

Rendern

Implementieren der Methode Cball::Render

tbMatrixTranslation(GetAbsPosition()) verschiebt Ballmodell an richtige Stelle

Absolute Position des Balls wird gebraucht in Translationsmatrix, sonst ist sie relativ zum Schläger

CGame::m_pBallModel->Render rendert danach den Ball

Die Bälle

Erster Ball bei Eintritt ins Level, Zero Memory leert Array m_aBall

Erstellung eines Balls durch Methode CGame::CreateBall mit Parametern der Position, des Geschwindigkeitsvektors und dem Zustand, ob angeklebt oder nicht

Erster Ball: Relative Position zum Schläger(0,0, 0,25), Geschwindigkeitsvektor (0,0,0) und Zustand = Angeklebt

Erstellung einer Liste in Form des Arrays CGame::m_aBall mit 16 Elementen

Mit m_bExists prüfen ob/wie viele Bälle existieren

CGame::Move geht die 16 Elemente durch, wenn die Elemente existieren, Aufruf seiner Move-Funktion und Aufruf von CBall::Render

// Erstellt einen neuen Ballint CGame::CreateBall(tbVector3 vPosition, tbVector3 vVelocity,BOOL bGrabbed){// Freien Ball suchenfor(int iBall = 0; iBall < 16; iBall++){if(!m_aBall[iBall].m_bExists){// Freier Ball gefunden! Ausfüllen!m_aBall[iBall].m_bExists = TRUE;m_aBall[iBall].m_pGame = this;m_aBall[iBall].m_bGrabbed = bGrabbed;m_aBall[iBall].m_vPosition = vPosition;m_aBall[iBall].m_vVelocity = vVelocity;

// Index des neuen Balls liefernreturn iBall;}}

// Kein Platz mehr!return -1;}

Abfeuern mit der Leertaste// Wenn die Leertaste gedrückt wurde, wird der klebende Ball// abgeworfen.if(g_pbButtons[TB_KEY_SPACE] && m_aBall[0].m_bExists && m_aBall[0].m_bGrabbed){// Sound abspieleng_pBreakanoid->m_apSound[3]->PlayNextBuffer();

// Ball abfeuern!m_aBall[0].m_bGrabbed = FALSE;

// Die Position eines klebenden Balls ist immer relativ// zum Schläger. Wir wandeln sie nun in eine absolute Position um.m_aBall[0].m_vPosition += m_vPaddlePos;

// Den Bewegungsvektor des Balls berechnen wir zufällig.

m_aBall[0].m_vVelocity.x = tbFloatRandom(-4.0f, 4.0f);m_aBall[0].m_vVelocity.y = 0.0f;m_aBall[0].m_vVelocity.z = tbFloatRandom(8.0f, 10.0f);

// Den Bewegungsvektor des Schlägers addierenm_aBall[0].m_vVelocity += m_vPaddleVel;

// Dem Ball einen kleinen "Schubs" nach vorne gebenm_aBall[0].m_vPosition.z += 0.1f;}

Schritt 6: Die Blöcke

Erstellen der Klasse CBlock mit der einzigen Methode Render

Variablen : m_iEnergy: Anzahl Energiepunkte

M_itype: Typ des Blocks (1 blau, 2 orange, 3 grün, 4 gelb) type= Anzahl Energiepunkte

tbVector3 m_vPosition: Position des Blocks auf dem Spielfeld

CGame* m_pGame: Kopie des CGame-Zeigers

Blockreihen

Erstellen eines Arrays mit 64 CBlock-Elementen (wie bei den Bällen)

ZeroMemory setzt bei betreten des Levels alle Blöcke zurück

Level wird in Zeilen bzw. Strings unterteilt – Jedes Zeichen im String = ein Block

1 Zeile = 9 Zeichen/Blöcke - Mehrere Zeilen = Level

Funktion CGame::CreateBlockRow um die Blockreihe zu erstellen

// Erstellt eine Reihe von BlöckentbResult CGame::CreateBlockRow(char* pcBlocks, tbVector3 vStartPos){int iType;// Alle Zeichen im String durchgehenfor(DWORD dwChar = 0; dwChar < strlen(pcBlocks); dwChar++){// Wenn das Zeichen kein Leerzeichen ist...if(pcBlocks[dwChar] != ' '){// Freien Block suchenfor(DWORD dwBlock = 0; dwBlock < 64; dwBlock++){if(m_aBlock[dwBlock].m_iEnergy <= 0){// Freier Block gefunden - ausfüllen!// Zeichen im String in einen Blocktyp umwandeln.iType = 0;if(pcBlocks[dwChar] == '1') iType = 1;else if(pcBlocks[dwChar] == '2') iType = 2;else if(pcBlocks[dwChar] == '3') iType = 3;else if(pcBlocks[dwChar] == '4') iType = 4;

Levels von Breakanoid

// Je nach Level die Blöcke erstellenswitch(iLevel){case 1:CreateBlockRow(" 1 1 1 ", tbVector3(-8.0f, 0.0f, 2.0f));CreateBlockRow("12 111 21", tbVector3(-8.0f, 0.0f, 1.0f));CreateBlockRow("12 21", tbVector3(-8.0f, 0.0f, 0.0f));CreateBlockRow(" 112 211 ", tbVector3(-8.0f, 0.0f, -1.0f));break;

case 2:CreateBlockRow(" 222 ", tbVector3(-8.0f, 0.0f, 1.0f));CreateBlockRow(" 2 3 2 ", tbVector3(-8.0f, 0.0f, 0.0f));CreateBlockRow(" 2 333 2 ", tbVector3(-8.0f, 0.0f, -1.0f));CreateBlockRow("111111111", tbVector3(-8.0f, 0.0f, -2.0f));break;

Kollision zwischen Ball und Block

Prüfung in CBall::Move, ob Ball und Block kollidieren

Ist das der Fall, wird dem Block ein EP abgezogen, der Ball prallt ab

Problem: Welcher Block und welche Seite des Blocks wird getroffen

x-oder z-Komponente des Geschwindigkeitsvektors umkehren

Zuerst Bedingung setzen, ob der Ball überhaupt mit dem Block kollidieren kann

Danach berechnen, wo der Ball den Block trifft, dazu die Minimalste Distanz von den 4 Blöcken zum Ball berechnen

Bei links oder rechts vom Block, Vorzeichenveränderung der x-Komponente,

Bei oben oder unten vom Block, Vorzeichenveränderung der z-Komponente

nach Kollision, dem Ball einen Schub in die richtige Richtung geben

// Kollision mit den Blöcken berechnenfor(DWORD dwBlock = 0; dwBlock < 64; dwBlock++){if(m_pGame->m_aBlock[dwBlock].m_iEnergy > 0){vBlock = m_pGame->m_aBlock[dwBlock].m_vPosition;

// Befindet sich der Ball im Kollisionsbereich?if(m_vPosition.x + 0.25f >= vBlock.x - 1.0f && m_vPosition.x - 0.25f <= vBlock.x + 1.0f && m_vPosition.z + 0.25f >= vBlock.z - 0.5f && m_vPosition.z - 0.25f <= vBlock.z + 0.5f)

// Entfernung des Balls von allen Blockseiten berechnenfDistLeft = fabsf(m_vPosition.x + 0.25f - (vBlock.x - 1.0f));fDistRight = fabsf(m_vPosition.x - 0.25f - (vBlock.x + 1.0f));fDistTop = fabsf(m_vPosition.z - 0.25f - (vBlock.z + 0.5f));fDistBottom = fabsf(m_vPosition.z + 0.25f - (vBlock.z - 0.5f));

// Minimale Distanz berechnenfMinDist = TB_MIN(fDistLeft, TB_MIN(fDistRight, TB_MIN(fDistTop, fDistBottom)));

// Wenn die Distanz zur linken oder rechten Seite am kleinsten ist...if(fMinDist == fDistLeft || fMinDist == fDistRight){// Ball an der z-Achse abprallen lassenm_vVelocity.x *= -1.0f;

// Dem Ball einen kleinen "Schubs" gebenif(fMinDist == fDistLeft) m_vPosition.x -= 0.1f;else m_vPosition.x += 0.1f;}else{// Ball an der x-Achse abprallen lassenm_vVelocity.z *= -1.0f;

// Dem Ball einen kleinen "Schubs" gebenif(fMinDist == fDistTop) m_vPosition.z += 0.1f;else m_vPosition.z -= 0.1f;}// Dem Block einen Energiepunkt abziehen und Punkte addierenm_pGame->m_aBlock[dwBlock].m_iEnergy--;// Kollision ist immer nur mit einem einzigen Block möglich!break;

Multiball

Wird ein Block zerstört (Energie =0), ermittelt tbIntRandom eine Zahl zwischen 1 und 14

Ist es eine 7, wird ein neuer Ball mit zufälliger Flugrichtung nach unten erstellt

Ende des Levels/Spiels:

Das Level ist geschafft, wenn alle Blöcke zerstört sind

Dazu wird im m_aBlock-Array die Anzahl der Blöcke mit vorhandener Energie gezählt

Sind alle Level geschafft, fängt der Spieler wieder bei Level 1 an

Schritt 7: Versuche

Variable CGame::m_iNumTries wird zu Beginn des Spiels auf 5 gesetzt

In der Methode CGame:Move werden mit Hilfe einer for-Schleife die Bälle gezählt

Ist die Anzahl der Bälle 0, so wird dem Spieler mit m_iTriesLeft- - ein Versuch abgezogen und ein neuer Ball auf den Schläger „geklebt“

Game Over !

Um das Spiel bei m_iTries == 0 zu beenden, hinzufügen der Variable BOOL m_bGameOver

Bei TRUE wird in CGame::Render mit grüner und roter Schrift „Game Over!“ ausgegeben

Schritt8: Punkte

Um eine Punktzahl zu speichern, wurde bereits die Variable CGame::m_iScore erstellt

Die vergangene Zeit eine Levels wird in der Variable CGame::m_fLevelTime gespeichert

Umso weniger Zeit, desto mehr Punkte und pro Level 10000 Punkte extra

Zudem 100 Punkte bei Treffen eines Blocks, 1000-4000 bei Zerstörung

// Level 1 bringt 10000 Punkte, Level 2 20000 Punkte usw..m_iScore += m_iLevel * 10000;

// Je weniger Zeit man gebraucht hat, desto mehr Extrapunkte gibt's.// Bei x benötigten Sekunden gibt es den x-ten Teil von 1000000

Punkten.m_iScore += (DWORD)(1000000.0f * (1.0f / m_fLevelTime));

// Dem Block einen Energiepunkt abziehen und Punkte addierenm_pGame->m_aBlock[dwBlock].m_iEnergy--;m_pGame->m_iScore += 100;

// Wenn der Block zerstört wurde, gibt es Extrapunkteif(m_pGame->m_aBlock[dwBlock].m_iEnergy <= 0){m_pGame->m_iScore += m_pGame->m_aBlock[dwBlock].m_iType

* 1000;

Schritt 9: Sound für das Spiel

Da alle Sounds schon geladen wurden, geht es nur noch um das abspielen

Die Sounds, die im Array CBreakanoid::m_apSound[11] gespeichert sind, werden gebraucht für:

CBreakanoid::m_apSound[2]: neuen Level betreten CBreakanoid::m_apSound[3]: Ball abfeuern CBreakanoid::m_apSound[4]: Ball geht verloren CBreakanoid::m_apSound[5]: Ball trifft Schläger CBreakanoid::m_apSound[6]: Extraball-Sound CBreakanoid::m_apSound[7]: Ball prallt an Wand ab CBreakanoid::m_apSound[8-11]: Ball trifft Block, 4 verschiedene

Sounds

Das Abspielen des Sounds funktioniert, indem man PlayNextBuffer auf der tbSound_klasse aufruft

Wenn der Ball einen Block berührt, wird durch Zufallsgenerator einer von 4 Tönen abgespielt:

// Zufälligen "Pling"-Sound abspielen iSound = tbIntRandom(8, 11);iBuffer = g_pBreakanoid->m_apSound[iSound]->PlayNextBuffer();if(iBuffer != -1)

Schritt10: Hier spielt die Musik

Die Musik ist als MP3(MUSIC.MP3) gespeichert

Musik wird die komplette Zeit unverändert abgespielt

Dafür muss die Variable tbMusic* m_pMusic in der CBreakanoid –Klasse abgelegt werden

Geladen und abgespielt wird sie in CBreakanoid::Load

// Musik laden und gleich abspielenm_pMusic = new tbMusic;if(m_pMusic->Init("Data\\Music.mp3")){// Fehler!TB_ERROR("Fehler beim Laden der Musik!", TB_ERROR);}m_pMusic->Play();return TB_OK;

Danke für eure Aufmerksamkeit!!!