tile.cpp

/***************************************************************************
                           tile.cpp
                           -------------------
    begin                : 2004-04-18
    copyright            : (C) 2004-2005 by Michael Menne
    email                : menne@users.sourceforge.net
 ***************************************************************************/

/***************************************************************************
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 ***************************************************************************/

#include "tile.h"
#include "app.h"
#include "frame.h"
#include "glcanvas.h"
#include "texture.h"

#include <wx/file.h>

extern ofstream logFile;

namespace WDS
{

extern int g_DirTable[8][3];


DECLARE_APP(CApp)

// Bewegungskosten für Terrain
// ID   Terrain     Kosten
// 0    Wasser      100
// 1    Grasland      6
// 2    Steppe        7
// 3    Wald         10
// 4    Hochebene    13
// 5    Hügel        14
// 6    Bergwald     16
// 7    Felsen       19
// 8    Gebirge      28
static int g_aCosts[] = { 100, 6, 7, 10, 13, 14, 16, 19, 28};

bool CTile::m_bLoaded = false;
CTexture* CTile::m_pTerrains[9][241];
CTexture* CTile::m_pFrames[8];
CTexture* CTile::m_pBuildings[500];
CTexture* CTile::m_pStreets[15];
CTexture* CTile::m_pBorders[15];
CTexture* CTile::m_pUnits[RACE_NUMOF] = { NULL, NULL, NULL, NULL };

/*----------------------------------------------------------------------------/
    Constructor / Destructor
-----------------------------------------------------------------------------*/

CTile::CTile()
{
    m_State   = PATH_NONE;
    m_Parent  = -1;
    m_CostF   =  0;
    m_CostG   =  0;

    m_nTerrain1 = -1;   // -1, da Terrain1 auch 0 werden kann ( = Wasser )
    m_nTerrain2 =  0;   // sonst bedeutet 0 leer
    m_nBuilding =  0;

    m_nFrame  = 0;
    m_nBorder = 0;
    m_nStreet = 0;
    m_nUnit   = 0;
    m_nFOW    = 1;
}

CTile::~CTile()
{
}

/*
 *  Init( )
 *  Läd alle benötigten Graphiken für Terrain, Gebäude, Strassen, Grenzen, Rahmen
 *  sowie Einheiten
 */
void CTile::Init( )
{
    if( m_bLoaded )
        return;

    wxStopWatch sw;
    logFile << "Loading graphics..." << endl;

    CGLCanvas *pCanvas = GetGLCanvas();
    char buf[64];
    int  i, j;

    int n = sizeof( CTile );

    // Terrain
    for( i=0; i<9; i++ )
    {
        for( j=0; j<241; j++ )
        {
            sprintf( buf, "data/terrain/%d-%d.png", i, j );

            if( wxFile::Exists( buf ) )
                m_pTerrains[i][j] = pCanvas->LoadTexture( buf, true );
            else
                m_pTerrains[i][j] = NULL;
        }
    }

    // Frames
    for( i=0; i<8; i++ )
    {
        sprintf( buf, "data/frame/frame%d.png", i+1 );
        m_pFrames[i] = pCanvas->LoadTexture( buf, true );
    }

    // Buildings
    for( i=0; i<500; i++ )
    {
        sprintf( buf, "data/buildings/%d.png", i+1 );

        if( wxFile::Exists( buf ) )
            m_pBuildings[i] = pCanvas->LoadTexture( buf, true );
        else
            m_pBuildings[i] = NULL;
    }

    // Grenzen
    for( i=0; i<15; i++ )
    {
        sprintf( buf, "data/overlay/bo-%d.png", i+1 );
        m_pBorders[i] = pCanvas->LoadTexture( buf, true );
    }

    // Strassen
    for( i=0; i<15; i++ )
    {
        sprintf( buf, "data/overlay/s-%d.png", i+1 );
        m_pStreets[i] = pCanvas->LoadTexture( buf, true );
    }

    // Einheiten Graphiken
    for( i=0; i<4; i++ )
    {
        sprintf( buf, "data/units/%d.png", i+1 );
        m_pUnits[i] = pCanvas->LoadTexture( buf, true );
    }

    logFile << "-> Graphics loaded in " << sw.Time() << " ms." <<  endl;

    m_bLoaded = true;
}

/*
 *  Shut( )
 *  Löscht alle in Init() geladenen Graphiken
 */
void CTile::Shut( )
{
    if( !m_bLoaded )
        return;

    CGLCanvas *pCanvas = GetGLCanvas();
    int i, j;

    // Terrain Graphiken löschen
    for( i=0; i<9; i++ )
    {
        for( j=0; j<241; j++ )
        {
            if( m_pTerrains[i][j] )
            {
                pCanvas->DeleteTexture( m_pTerrains[i][j] );
                m_pTerrains[i][j] = NULL;
            }
        }
    }

    // Frame Graphiken löschen
    for( i=0; i<8; i++ )
    {
        if( m_pFrames[i] )
        {
            pCanvas->DeleteTexture( m_pFrames[i] );
            m_pFrames[i] = NULL;
        }
    }

    // Building Graphiken löschen
    for( i=0; i<500; i++ )
    {
        if( m_pBuildings[i] )
        {
            pCanvas->DeleteTexture( m_pBuildings[i] );
            m_pBuildings[i] = NULL;
        }
    }

    // Grenzen Graphiken löschen
    for( i=0; i<15; i++ )
    {
        if( m_pBorders[i] )
        {
            pCanvas->DeleteTexture( m_pBorders[i] );
            m_pBorders[i] = NULL;
        }
    }

    // Strassen Graphiken löschen
    for( i=0; i<15; i++ )
    {
        if( m_pStreets[i] )
        {
            pCanvas->DeleteTexture( m_pStreets[i] );
            m_pStreets[i] = NULL;
        }
    }

    // Einheiten Graphiken löschen
    for( i=0; i<4; i++ )
    {
        if( m_pUnits[i] )
        {
            pCanvas->DeleteTexture( m_pUnits[i] );
            m_pUnits[i] = NULL;
        }
    }

    m_bLoaded = false;
}

/*----------------------------------------------------------------------------/
    Member Funktionen
-----------------------------------------------------------------------------*/

void CTile::SetFogOfWar( int nFOW )
{
    m_nFOW = nFOW;
}

void CTile::SetFrame( int nID )
{
    if( nID < 1 || nID > 8 )
        return;

    m_nFrame = nID;
}

void CTile::SetTerrain ( int nID, int nBorder )
{
    if( nID < 0 || nID > 8 ||           // [0,   9]
        nBorder < 0 || nBorder> 240 )   // [0, 240]
        return;

    m_nTerrain1 = nID;
    m_nTerrain2 = nBorder;
}

void CTile::SetBuilding( int nID )
{
    if( nID < 0 || nID > 500 )
        return;

    m_nBuilding = nID;
}

void CTile::SetBorder( int nID )
{
    if( nID < 0 || nID > 15 )   // [0, 15]
        return;

    m_nBorder = nID;
}

void CTile::SetStreet( int nID )
{
    if( nID < 0 || nID > 15 )   // [0, 15]
        return;

    m_nStreet = nID;
}

void CTile::SetUnit( int nID )
{
    // UNITS & 1 ist mensch, UNITS & 2 ist Elfen, UNITS & 4 ist Zwerge und UNITS & 8 ist Orks
    switch( nID )
    {
    case 0: m_nUnit  = 0; break;
    case 1: m_nUnit |= 1; break;
    case 2: m_nUnit |= 2; break;
    case 3: m_nUnit |= 4; break;
    case 4: m_nUnit |= 8; break;
    }
}

void CTile::Reset( )
{
    SetFogOfWar( 1 );
    SetBuilding( 0 );
    SetBorder  ( 0 );
    SetUnit    ( 0 );
    SetStreet  ( 0 );
}

/*
 *  Draw( )
 *  @param bFOW Gibt an, ob Fog Of War gezeichnet werden soll.
 *  Zeichnet Terrain, Gebäude, Strasse, usw.
 */
void CTile::Draw( Rect &rcTile, bool bFOW )
{
    // Frame
    if( m_nFrame > 0 )
        DrawTile( rcTile, m_pFrames[m_nFrame-1] );

    // Bei Fog Of War nur Terrain malen
    if( m_nFOW && bFOW )
    {
        glColor3f( 0.5f, 0.5f, 0.5f );  // Dadurch wird dunkler gezeichnet

        // Terrain
        if( m_nTerrain1 != -1 )
            DrawTile( rcTile, m_pTerrains[(int)m_nTerrain1][(int)m_nTerrain2] );

        glColor3f( 1.0f, 1.0f, 1.0f );
    }
    else
    {
        // Terrain
        if( m_nTerrain1 != -1 )
            DrawTile( rcTile, m_pTerrains[(int)m_nTerrain1][(int)m_nTerrain2] );


        // Grenze
        if( m_nBorder > 0 )
            DrawTile( rcTile, m_pBorders[m_nBorder-1] );

        // Strasse
        if( m_nStreet > 0 )
            DrawTile( rcTile, m_pStreets[m_nStreet-1] );

        // Gebäude
        if( m_nBuilding > 0 )
            DrawTile( rcTile, m_pBuildings[m_nBuilding-1] );

        // Units
        if( m_nUnit & 1 )
            DrawTile( rcTile, m_pUnits[0] );
        if( m_nUnit & 2 )
            DrawTile( rcTile, m_pUnits[1] );
        if( m_nUnit & 4 )
            DrawTile( rcTile, m_pUnits[2] );
        if( m_nUnit & 8 )
            DrawTile( rcTile, m_pUnits[3] );
    }
}

/*
 *  DrawOverlay( )
 *  Zeichnet alles was über der Karte angezeigt werden soll
 */
void CTile::DrawOverlay( Rect &rcTile )
{
    // Pfadplanung
    if( m_State == PATH_ACTIVE )
    {
        // Mittelpunkt des Tiles ermitteln
        wxPoint ptCenter( rcTile.x+63, rcTile.y+70 );

        // Roten Kreis zeichnen
        GetGLCanvas()->DrawCircle( ptCenter, 32, 16.0f, 1.0f, 0.0f, 0.0f );

        // Linie zeichnen
        if( m_Parent != -1 )
        {
            wxPoint ptDest;
            int xm = g_DirTable[(int)m_Parent][0];
            int ym = g_DirTable[(int)m_Parent][1];
            ptDest.x = ptCenter.x - ( (xm-ym) * 63 );
            ptDest.y = ptCenter.y - ( (xm+ym) * 35 );

            GetGLCanvas()->DrawLine( ptCenter, ptDest, 1.0f, 1.0f, 0.0f, 0.0f );
        }
    }
}

/*
 *  DrawTile( )
 *  Zeichnet die Textur in das gegebene Rechteck ( ~ BitBlt )
 */
void CTile::DrawTile( Rect &rcTile, CTexture *pTex )
{
    if( pTex == NULL )
        return;

    float fw = 126.0f/128.0f;
    float fh = 105.0f/128.0f;

    pTex->Bind();           // Select Image Texture
    glBegin(GL_QUADS);
        glTexCoord2f(0.0f, 0.0f); glVertex2i( rcTile.x,       rcTile.y );           // links oben
        glTexCoord2f(0.0f, fh  ); glVertex2i( rcTile.x,       rcTile.Bottom() );    // links unten
        glTexCoord2f(fw,   fh  ); glVertex2i( rcTile.Right(), rcTile.Bottom() );    // rechts unten
        glTexCoord2f(fw,   0.0f); glVertex2i( rcTile.Right(), rcTile.y );           // rechts oben
    glEnd();
}

/*
 *  GetWeigth( )
 *  Gibt die Bewegungspunkte zurück, die benötigt werden um auf das Feld zu ziehen
 *  Dabei werden Strassen berücksichtigt. Wird für die Pfadplanung gebraucht
 */
float CTile::GetWeigth( )
{
    // Bewegungskosten neu berechnen
    int m_nWeigth = g_aCosts[(int)m_nTerrain1];

    if( !IsStreet() )
        return m_nWeigth;
    else
        return m_nWeigth * 0.7f;
}

/*
 *  GetGLCanvas( )
 *  Gibt einen Zeiger auf die OpenGL Canvas zurück
 */
CGLCanvas* CTile::GetGLCanvas( )
{
    CGLCanvas *pCanvas = wxGetApp().GetFrame()->GetGLCanvas();
    return pCanvas;
}

}
// kate: space-indent off; tab-width 4; replace-tabs off;

---