spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

// __________________________________________________________________
// Klasse für das Spiel
class CGame
{
public:

    // Variablen

// Terrain Vertex: Nur Position und Farbe
struct terrvertex {
   float x,y,z;
   DWORD color;
};
#define D3DFVF_TERRAIN (D3DFVF_XYZ|D3DFVF_DIFFUSE)

// 2D -> 1D Indexing
#define ind(x, z) ((x) + ((z) * 128))

   terrvertex   *aterr;
   short        *aheightmap;

    BOOL        m_bPaused;              // Ist das Spiel pausiert?
    BOOL        m_bGameOver;            // Ist das Spiel vorbei?
    char*       m_strCity;              // In welchem Level wir sind
    float       m_fLevelTime;           // Zeit, die für den Level gebraucht wird

    // Konstruktor
    inline CGame() {ZeroMemory(this, sizeof(CGame));}

    // Methoden
    tbResult    Init();                                         // Initialisierung
    tbResult    Exit();                                         // Herunterfahren
    tbResult    Load();                                         // Laden
    tbResult    Unload();                                       // Entladen
    tbResult    Move(float fTime);                              // Bewegen
    tbResult    Render(float fTime);                            // Rendern
    tbResult    InitLevel(int iLevel);                          // Initialisiert einen Level
};

// __________________________________________________________________

Quellcode

#include "kgames.h"
#include <fstream.h>

tbVector3               g_vCameraPos = tbVector3(0.0f, 10.0f, 0.0f);                // Kameraposition
float                   g_fCameraRot;               // Rotation der Kamera
float                   g_fCameraUpDown;            // Schaut die Kamera hoch oder runter?

// __________________________________________________________________
// Initialisiert den Spielzustand
tbResult CGame::Init()
{
    
    // Laden...
    if(Load()) TB_ERROR("Fehler beim Laden des Spielzustands!", TB_ERROR);

    
    return TB_OK;
}

// __________________________________________________________________
// Fährt den Spielzustand herunter
tbResult CGame::Exit()
{
    // Entladen...
    Unload();
g_pkgames->Exit();
        TB_SAFE_DELETE(g_pkgames);
    return TB_OK;
}

// __________________________________________________________________
// Lädt den Spielzustand
tbResult CGame::Load()
{
   ifstream file;
   unsigned char c;
   int num=0;

   aheightmap = (short*) malloc(128*128*sizeof(short));
   aterr = (terrvertex*) malloc(127*127*6*sizeof(terrvertex));

   file.open("heightmap.raw",ios::binary);
   for (int z=0; z < 128; z++) {
      for (int x=0; x < 128; x++) {
         file.get(c);
         aheightmap[ind(x,z)] = (short)c;
      }
   }
   file.close();

   for (z=0; z < 127; z++) {
      for (int x=0; x < 127; x++) {
         aterr[num].x = (float) x;
         aterr[num].z = (float) z;
         aterr[num].y = (float)aheightmap[ind(x,z)] / 25.6f;
         aterr[num].color = tbColor(0.0f, 0.5f, 1.0f);
         
         aterr[num+1].x = (float) x+1;
         aterr[num+1].z = (float) z;
         aterr[num+1].y = (float)aheightmap[ind(x+1,z)] / 25.6f;
         aterr[num].color = tbColor(1.0f, 0.5f, 0.0f);

         aterr[num+2].x = (float) x+1;
         aterr[num+2].z = (float) z+1;
         aterr[num+2].y = (float)aheightmap[ind(x+1,z+1)] / 25.6f;
         aterr[num].color = tbColor(0.5f, 0.0f, 1.0f);
/*
         aterr[num+3].x = (float) x;
         aterr[num+3].z = (float) z;
         aterr[num+3].y = (float)aheightmap[ind(x,z)] / 25.6f;
         aterr[num].color = tbColor(1.0f, (float) x, (float) z);

         aterr[num+4].x = (float) x+1;
         aterr[num+4].z = (float) z+1;
         aterr[num+4].y = (float)aheightmap[ind(x+1,z+1)] / 25.6f;
         aterr[num].color = tbColor(1.0f, (float) x, (float) z);

         aterr[num+5].x = (float) x;
         aterr[num+5].z = (float) z+1;
         aterr[num+5].y = (float)aheightmap[ind(x,z+1)] / 25.6f;
         aterr[num].color = tbColor(1.0f, (float) x, (float) z);*/
      
         num += 3;
      }
   }
    return TB_OK;
}

// __________________________________________________________________
// Entlädt den Spielzustand
tbResult CGame::Unload()
{

   free(aterr);
   free(aheightmap);
   
    return TB_OK;
}

// __________________________________________________________________
// Bewegt den Spielzustand
tbResult CGame::Move(float fTime)
{

    tbVector3 vCameraDir;

    // Tastatursteuerung...
    vCameraDir = tbVector3(sinf(g_fCameraRot) * cosf(g_fCameraUpDown),
                           sinf(g_fCameraUpDown),
                           cosf(g_fCameraRot) * cosf(g_fCameraUpDown));

    if(g_pbButtons[TB_KEY_LEFT])            g_fCameraRot -= 1.0f * fTime;
    if(g_pbButtons[TB_KEY_RIGHT])           g_fCameraRot += 1.0f * fTime;
    if(g_pbButtons[TB_KEY_UP])              g_fCameraUpDown -= 1.0f * fTime;
    if(g_pbButtons[TB_KEY_DOWN])            g_fCameraUpDown += 1.0f * fTime;
    if(g_pbButtons[TB_KEY_W])               g_vCameraPos += vCameraDir * 15.0f * fTime;
    if(g_pbButtons[TB_KEY_S])               g_vCameraPos -= vCameraDir * 15.0f * fTime;

    if(g_pbButtons[TB_KEY_X]) tbDirect3D::SetRS(D3DRS_FILLMODE, D3DFILL_WIREFRAME );
    if(g_pbButtons[TB_KEY_Y]) tbDirect3D::SetRS(D3DRS_FILLMODE, D3DFILL_SOLID );

    // P oder Pause hält das Spiel an oder setzt es fort.
    if(g_pbButtons[TB_KEY_P] || g_pbButtons[TB_KEY_PAUSE])
    {
        m_bPaused = !m_bPaused;
        tbDelay(100);
    }

    // Wenn das Spiel pausiert, gibt es nichts mehr zu tun.
    if(m_bPaused) return TB_OK;

    // ------------------------------------------------------------------

    //Spielfunktionen implementieren!!!

    // ------------------------------------------------------------------

    // Levelzeit erhöhen
    m_fLevelTime += fTime;

    // ------------------------------------------------------------------

    // Wenn die Escape-Taste gedrückt wird, geht's zurück ins Hauptmenü.
    if(g_pbButtons[TB_KEY_ESCAPE]) PostQuitMessage(0);

    return TB_OK;
}

// __________________________________________________________________
// Rendert den Spielzustand
tbResult CGame::Render(float fTime)
{
    tbMatrix            mProjection;
    tbMatrix            mCamera;
    tbMatrix            mWorld;
    tbVector3           vCameraDir;
    D3DLIGHT9   Light;


    //Puffer Leeren
    tbDirect3D::Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, tbColor(1.0f, 1.0f, 1.0f), 1.0f, 0);
    tbDirect3D::BeginScene();

    mProjection = tbMatrixProjection(TB_DEG_TO_RAD(60.0f), tbDirect3D::GetAspect(), 0.1f, 300.0f);
    tbDirect3D::SetTransform(D3DTS_PROJECTION, mProjection);


    // Kameramatrix erstellen und einsetzen
    vCameraDir = tbVector3(sinf(g_fCameraRot) * cosf(g_fCameraUpDown),
                           sinf(g_fCameraUpDown),
                           cosf(g_fCameraRot) * cosf(g_fCameraUpDown));
    mCamera = tbMatrixCamera(g_vCameraPos, g_vCameraPos + vCameraDir);
    tbDirect3D::GetDevice()->SetTransform(D3DTS_VIEW, (D3DMATRIX*)(&mCamera));
    //RENDERANWEISUNGEN

    //END-RENDERANWEISUNGEN
    //Welt
    
    mWorld = tbMatrixTranslation(g_vCameraPos);
    tbDirect3D::SetTransform(D3DTS_WORLD, mWorld);


    // Ein Richtungslicht erstellen mit der Richtung der Kamera
    ZeroMemory(&Light, sizeof(D3DLIGHT9));
    Light.Type = D3DLIGHT_DIRECTIONAL;
    Light.Diffuse = tbColor(0.5f, 0.5f, 0.5f);
    Light.Ambient = tbColor(0.5f, 0.5f, 0.5f);
    Light.Specular = tbColor(0.5f, 0.5f, -5.5f);
    Light.Direction = vCameraDir;
    tbDirect3D::GetDevice()->SetLight(0, &Light);
    tbDirect3D::GetDevice()->LightEnable(0, TRUE);


    // Linearer schwarzer Nebel!
    tbDirect3D::SetRS(D3DRS_FOGENABLE,      TRUE);
    tbDirect3D::SetRS(D3DRS_FOGVERTEXMODE,  D3DFOG_LINEAR);
    tbDirect3D::SetRS(D3DRS_RANGEFOGENABLE, TRUE);
    tbDirect3D::SetRS(D3DRS_FOGCOLOR,       tbColor(0.0f, 0.0f, 0.2f));
    tbDirect3D::SetRSF(D3DRS_FOGSTART,      300.0f);
    tbDirect3D::SetRSF(D3DRS_FOGEND,        500.0f);
    //tbDirect3D::SetRS(D3DRS_FILLMODE, D3DFILL_WIREFRAME );

    // Weltmatrix zurücksetzen
    tbDirect3D::GetDevice()->SetTransform(D3DTS_WORLD, (D3DMATRIX*)(&tbMatrixIdentity()));
//RENDERN TERRAIN
    tbDirect3D::SetFVF(D3DFVF_TERRAIN);
    tbDirect3D::GetDevice()->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 127*127*2, aterr, sizeof(terrvertex));
    tbDirect3D::EndScene();
    return TB_OK;
}

// __________________________________________________________________
// Initialisiert einen Level
tbResult CGame::InitLevel(int iLevel)
{

    m_bPaused = FALSE;
    m_bGameOver = FALSE;

    // Zeit zurücksetzen
    m_fLevelTime = 0.0f;

    return TB_OK;
}