D:/Zythum/DinoKod/Mod_Aeternis_Client/A_WinHUD.cpp

//---------------------------------------------------------------------------------------------
//      This file is a part of "DinoKod".
//      Copyright © 2003 Dino Productions. All Rights Reserved.
//      
//      File                    : A_WinHUD.cpp
//      Author                  : Sebastien LEIX        sebastien.leix@wanadoo.fr
//      Date                    : 16/06/2003
//      Modification    :
//
//---------------------------------------------------------------------------------------------
#include "Common/Assert.h"
#include "Common/Time.h"
#include "Render/Render.h"
#include "Render/Font.h"
#include "Render/Camera.h"
#include "Mod/Mod.h"

#include "Game/ClientWorld.h"
#include "Mod_Aeternis/A_Team.h"
#include "Mod_Aeternis_Client/A_Interface.h"
#include "Mod_Aeternis_Client/A_ClientCharacter.h"
#include "Mod_Aeternis_Client/A_ClientFlag.h"
#include "Mod_Aeternis_Client/A_ClientGameManager.h"
#include "Mod_Aeternis_Client/A_InputManager.h"
#include "Mod_Aeternis_Client/A_ClientWeapon.h"

#include "Mod_Aeternis_Client/A_WinHUD.h"
#include "Mod_Aeternis_Client/A_WinBuy.h"

#define KWINDOW_NUMBERS_SHADER_WIDTH    256
#define KWINDOW_NUMBERS_SHADER_HEIGHT   32
#define KWINDOW_HUD2_SHADER_WIDTH               512
#define KWINDOW_HUD2_SHADER_HEIGHT              512

#define RADARMOVESPEED 0.8f

#define KHUDSTATUS_WIDTH                                0.3f
#define KHUDSTATUS_HEIGHT                               0.59f

//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
KAWinHUD::KAWinHUD( KWin* pFather, KFPt& Pos, KFPt& Size, KInterface* pInterface )
: KWin( pFather, Pos, Size, pInterface )
{
        m_hBackGround                                   = KSHADER_NO;
        m_hHud                                                  = KSHADER_NO;
        m_hNumbers                                              = KSHADER_NO;
    m_bDisplayVoiceCommand                      = false ;
        m_bDisplayRadar                                 = true ;
        m_bDisplayFlagBloc                              = false ;
        m_bDisplayWeaponBloc                            = false ;
        m_bDisplayStatusBloc                    = true ;
        m_fRadarPercentOutOfScreen              = 1.0f ;
        m_fWeaponBlocPercentOutOfScreen = 1.0f ;
        m_fFlagBlocPercentOutOfScreen   = 1.0f ;
        m_fStatusBlocPercentOutOfScreen = 1.0f ;
        m_BloodTime                                             = 0;
        m_BloodDuration                                 = 0;
}

//------------------------------------------------------------------------------------------
KAWinHUD::~KAWinHUD()
{
}

//------------------------------------------------------------------------------------------
void KAWinHUD::Display()
{
        u8                              FadeAlpha               = (u8)(255.0f * GetFade());
        KHEALTH                 Health                  = 0;
        KAGAMEFLAGMODE  RedFlagMode             = KAGFM_STARTPOS;
        KAGAMEFLAGMODE  BlueFlagMode    = KAGFM_STARTPOS;
        s32                             RedScore                = 0;
        s32                             BlueScore               = 0;
        KMATEAM                 Team                    = KMAT_SPECTATOR;

        KAClientGameManager*    pGameManager = (KAClientGameManager*)g_pClientGameManager;

        if( pGameManager )
        {
                KAClientPlayer* pPlayer = (KAClientPlayer*)pGameManager->GetpMyPlayer();
                if( pPlayer )
                {
                        // Santé
                        Health = pPlayer->GetHealth();
                        if( pPlayer->GetpTeam() )
                                Team = pPlayer->GetpTeam()->GetTeam();
                }

                if( pGameManager->m_pRedFlag )
                        RedFlagMode  = pGameManager->m_pRedFlag->GetFlagMode() ;

                if( pGameManager->m_pBlueFlag )
                        BlueFlagMode = pGameManager->m_pBlueFlag->GetFlagMode() ;

                RedScore = pGameManager->GetpTeam( KMAT_RED )->GetScore();
                BlueScore = pGameManager->GetpTeam( KMAT_BLUE )->GetScore();
        }
        
        DisplayRadar( Team, 1.0f );
        DisplayStatusPanel( Team, RedFlagMode, RedScore, BlueFlagMode, BlueScore, Health );
//      DisplayWeaponPanel( Team );
//      DisplayFlagPanel( Team );
//      DisplayCrosshair();
        DisplayInventory(Team) ;
        DisplayTime() ;

    if(m_bDisplayVoiceCommand) DisplayVoiceCommand(true) ;

        DisplayBlood();
}

//------------------------------------------------------------------------------------------
void KAWinHUD::Manage()
{
        static KTIME lastTime = g_Time.GetTime() ;
        KTIME newTime = g_Time.GetTime() ;

        float fTimeElapsed = (float)(newTime - lastTime) ;
        lastTime = newTime ;
        float fStep = (fTimeElapsed * RADARMOVESPEED) / 1000.0f ;

        if(m_bDisplayRadar)                                             m_fRadarPercentOutOfScreen -= fStep ;
        if(!m_bDisplayRadar)                                    m_fRadarPercentOutOfScreen += fStep ;
        if(m_fRadarPercentOutOfScreen > 1.0f)   m_fRadarPercentOutOfScreen = 1.0f ;
        if(m_fRadarPercentOutOfScreen < 0.0f)   m_fRadarPercentOutOfScreen = 0.0f ;

        if(m_bDisplayWeaponBloc)                                                m_fWeaponBlocPercentOutOfScreen -= fStep ;
        if(!m_bDisplayWeaponBloc)                                               m_fWeaponBlocPercentOutOfScreen += fStep ;
        if(m_fWeaponBlocPercentOutOfScreen > 1.0f)              m_fWeaponBlocPercentOutOfScreen = 1.0f ;
        if(m_fWeaponBlocPercentOutOfScreen < 0.0f)              m_fWeaponBlocPercentOutOfScreen = 0.0f ;

        if(m_bDisplayFlagBloc)                                          m_fFlagBlocPercentOutOfScreen -= fStep ;
        if(!m_bDisplayFlagBloc)                                         m_fFlagBlocPercentOutOfScreen += fStep ;
        if(m_fFlagBlocPercentOutOfScreen > 1.0f)        m_fFlagBlocPercentOutOfScreen = 1.0f ;
        if(m_fFlagBlocPercentOutOfScreen < 0.0f)        m_fFlagBlocPercentOutOfScreen = 0.0f ;

        if(m_bDisplayStatusBloc)                                        m_fStatusBlocPercentOutOfScreen -= fStep ;
        if(!m_bDisplayStatusBloc)                                       m_fStatusBlocPercentOutOfScreen += fStep ;
        if(m_fStatusBlocPercentOutOfScreen > 1.0f)      m_fStatusBlocPercentOutOfScreen = 1.0f ;
        if(m_fStatusBlocPercentOutOfScreen < 0.0f)      m_fStatusBlocPercentOutOfScreen = 0.0f ;
}

//------------------------------------------------------------------------------------------
void KAWinHUD::DisplayNumbers( KFPt& Pos, KFPt& Size, s32 Numbers, KCOLOR Color, KCOLOR Specular )
{
        char    pNumbers[256];

        sprintf( pNumbers, "%.2i", Numbers );

        s32             Len = (s32)strlen( pNumbers );
        for( s32 i = 0; i < Len; i ++ )
        {
                DisplayNumber( Pos + KFPt( Size.x * (float)i, 0.0f ), KFPt( Size.x, Size.y ), (s32)(pNumbers[i] - '0'), Color, Specular );
        }
}

//------------------------------------------------------------------------------------------
void KAWinHUD::DisplayNumber( KFPt& Pos, KFPt& Size, s32 Number, KCOLOR Color, KCOLOR Specular )
{
        KASSERT( ( Number >= 0 ) && ( Number <= 9 ) );

        float   pTU[4], pTV[4];
        float   dtexelu = 0.5f / (float)KWINDOW_NUMBERS_SHADER_WIDTH;
        float   dtexelv = 0.5f / (float)KWINDOW_NUMBERS_SHADER_HEIGHT;

        pTU[0] = (float)Number / 10.0f + dtexelu;                               pTV[0] = dtexelv;
        pTU[1] = ((float)Number + 1.0f ) / 10.0f + dtexelu;             pTV[1] = dtexelv;
        pTU[2] = (float)Number / 10.0f + dtexelu;                               pTV[2] = 1.0f + dtexelv;
        pTU[3] = ((float)Number + 1.0f ) / 10.0f + dtexelu;             pTV[3] = 1.0f + dtexelv;

        DrawQuad( Pos.x, Pos.y, Size.x, Size.y, m_hNumbers, Color, Specular, KRM_NORMAL, pTU, pTV );
}

//------------------------------------------------------------------------------------------
void KAWinHUD::DisplayAmmo( s32 Ammo )
{
        DisplayNumbers( KFPt( 0.9f, 0.1f), KFPt( 0.03f, 0.03f ), ((g_Time.GetTime() / 100) % 100) );
}

//------------------------------------------------------------------------------------------
void KAWinHUD::DisplayLife( KHEALTH Health )
{
        u8              FadeAlpha = (u8)(255.0f * GetFade());
        u8              c = u8((float)Health * 2.55f);
        KCOLOR  Specular = KRGBA( 255 - c, 0, 0, FadeAlpha );
        KCOLOR  Color   = KRGBA( 255, c, c, FadeAlpha );

        KFPt    fSize = GetFloatPoint( KPt( 20, 20 ) );
        KFPt    fPos = GetFloatPoint( KPt( 8, GetIntPoint( GetSize() ).y - 30 ) );

        KFPt    StatusDelta;
        KFPt    fStatusSize = GetFloatPoint( KPt( (s32)((float)KWINDOW_HUD2_SHADER_WIDTH * KHUDSTATUS_WIDTH), (s32)((float)KWINDOW_HUD2_SHADER_HEIGHT * KHUDSTATUS_HEIGHT) ) );
        StatusDelta.x = -m_fStatusBlocPercentOutOfScreen * fStatusSize.x;
        StatusDelta.y = m_fStatusBlocPercentOutOfScreen * fStatusSize.y;
        
        DisplayNumbers( fPos + StatusDelta, fSize, Health, Color, Specular );
}

//------------------------------------------------------------------------------------------
void KAWinHUD::DisplayRadar( KMATEAM Team, float Zoom )
{
        u8              FadeAlpha = (u8)(255.0f * GetFade());
        KFPt    RadarDelta;
        float   pTU[4], pTV[4];
        float   dtexelu = 0.5f / (float)KWINDOW_HUD2_SHADER_WIDTH;
        float   dtexelv = 0.5f / (float)KWINDOW_HUD2_SHADER_HEIGHT;

        float   w = 0.50f;
        float   h = 0.375f;
        pTU[0] = (float)0.0f + dtexelu;         pTV[0] = 0.0f + dtexelv;
        pTU[1] = (float)w + dtexelu;            pTV[1] = 0.0f + dtexelv;
        pTU[2] = (float)0.0f + dtexelu;         pTV[2] = h + dtexelv;
        pTU[3] = (float)w + dtexelu;            pTV[3] = h + dtexelv;

        KFPt    fSize = GetFloatPoint( KPt( (s32)((float)KWINDOW_HUD2_SHADER_WIDTH * w), (s32)((float)KWINDOW_HUD2_SHADER_HEIGHT * h) ) );
        RadarDelta.x = -m_fRadarPercentOutOfScreen * fSize.x;
        RadarDelta.y = -m_fRadarPercentOutOfScreen * fSize.y;
        
        DrawQuad( m_Pos.x + RadarDelta.x, m_Pos.y + RadarDelta.y, fSize.x, fSize.y, m_hHud, GetTeamColor( Team ), KRGB_BLACK, KRM_NORMAL, pTU, pTV );

        // Affiche le Niveau de Zoom
        char    pZoomText[256];
        sprintf( pZoomText, "x%.0f", Zoom );
        m_pRender->DrawText( GetIntPoint( m_Pos ) + KPt( 25 , 170 ) + GetIntPoint( RadarDelta ), pZoomText, KRGB( 200, 200, 200 ), 0.75f );

        KFPt    fCenterPos = GetFloatPoint( KPt( 138, 106 ) );

        // Affiche les objets dans le radar
        KAClientGameManager*    pGameManager = (KAClientGameManager*)g_pClientGameManager;
        if( !pGameManager )
                return;

        KClientWorld*   pWorld = pGameManager->GetpClientWorld();
        if( !pWorld )
                return;

        KAClientPlayer*         pMyPlayer = (KAClientPlayer*)pGameManager->GetpMyPlayer();
        if( !pMyPlayer )
                return;

        KAClientCharacter*      pMyCharacter = pMyPlayer ? pMyPlayer->GetpCharacter() : NULL;
        if( !pMyCharacter )
                return;

        // Récupere la direction de la caméra
        KVector vUp, vRight, vView;
        m_pRender->GetCamera()->GetAxes( vRight, vUp, vView );

        KFPt    vDirX;
        KFPt    vDirY;
        vDirX.x = vRight.x;
        vDirX.y = vRight.y;
        vDirX.Normalize();
        vDirY.x = vView.x;
        vDirY.y = vView.y;
        vDirY.Normalize();

//      g_Console << "X : " << vDirX.x << " " << vDirX.y << KENDL;
//      g_Console << "Y : " << vDirY.x << " " << vDirY.y << KENDL;

        float   ZoomFactor = Zoom / 20.0f;

        for( K3DObject* pObject = pWorld->GetpFirstObject(); pObject; pObject = pWorld->GetpNextObject( pObject ) )
        {
                switch( pObject->GetType() )
                {
                case KAGOT_CHARACTER:
                        {
                                KFPt    fItemSize = GetFloatPoint( KPt( 8, 8 ) );

                                KAClientCharacter*      pCharacter      = (KAClientCharacter*)pObject;
                                KAClientPlayer*         pPlayer         = (KAClientPlayer*)pGameManager->GetpPlayer( pCharacter->GethPlayer() );

                                if( pCharacter != pMyCharacter && pPlayer && pPlayer->GetpTeam() && pPlayer->GetpTeam()->GetTeam() == Team )
                                {
                                        KFPt    WorldObjectPos;

                                        // Offset de l'objet par rapport au perso en coordonnées monde
                                        WorldObjectPos.x = ( pObject->GetPos().x - pMyCharacter->GetPos().x ) * ZoomFactor;
                                        WorldObjectPos.y = ( pObject->GetPos().y - pMyCharacter->GetPos().y ) * ZoomFactor;
                                        
                                        KFPt    TmpPos = WorldObjectPos;
                                        WorldObjectPos.x = vDirX.x * TmpPos.x + vDirX.y * TmpPos.y;
                                        WorldObjectPos.y = vDirY.x * TmpPos.x + vDirY.y * TmpPos.y;

                                        // Offset de l'objet par rapport au perso en coordonnées radar
                                        KFPt    ObjectPos;
                                        
                                        ObjectPos.x = m_Pos.x + fCenterPos.x - fItemSize.x / 2.0f;
                                        ObjectPos.y = m_Pos.y + fCenterPos.y - fItemSize.y / 2.0f;
                                                
                                        ObjectPos += GetFloatPoint( KPt( (s32)WorldObjectPos.x, (s32)-WorldObjectPos.y ) );

                                        DrawQuad(       ObjectPos.x + RadarDelta.x,
                                                                ObjectPos.y + RadarDelta.y,
                                                                fItemSize.x,
                                                                fItemSize.y,
                                                                KSHADER_NO,
                                                                KRGB( 200, 200, 20 ) );
                                }
                        }
                        break;
                case KAGOT_FLAG:
                        {
                                KFPt    fItemSize = GetFloatPoint( KPt( 16, 16 ) );

                                KAClientFlag*           pFlag   = (KAClientFlag*)pObject;

                                KFPt    WorldObjectPos;

                                // Offset de l'objet par rapport au perso en coordonnées monde
                                WorldObjectPos.x = ( pObject->GetPos().x - pMyCharacter->GetPos().x ) * ZoomFactor;
                                WorldObjectPos.y = ( pObject->GetPos().y - pMyCharacter->GetPos().y ) * ZoomFactor;

                                KFPt    TmpPos = WorldObjectPos;
                                WorldObjectPos.x = vDirX.x * TmpPos.x + vDirX.y * TmpPos.y;
                                WorldObjectPos.y = vDirY.x * TmpPos.x + vDirY.y * TmpPos.y;

                                // Offset de l'objet par rapport au perso en coordonnées radar
                                KFPt    ObjectPos;
                                
                                ObjectPos.x = m_Pos.x + fCenterPos.x - fItemSize.x / 2.0f;
                                ObjectPos.y = m_Pos.y + fCenterPos.y - fItemSize.y / 2.0f;
                                        
                                ObjectPos += GetFloatPoint( KPt( (s32)WorldObjectPos.x, (s32)-WorldObjectPos.y ) );

                                KCOLOR  FlagColor = GetTeamColor( pFlag->GetTeam() );
                                float   pTU[4], pTV[4];

                                GetFlagUV( pFlag->GetFlagMode(), pTU, pTV );

                                DrawQuad(       ObjectPos.x + RadarDelta.x,
                                                        ObjectPos.y + RadarDelta.y,
                                                        fItemSize.x,
                                                        fItemSize.y,
                                                        m_hHud,
                                                        FlagColor,
                                                        FlagColor,
                                                        KRM_NORMAL,
                                                        pTU,
                                                        pTV );
                        }
                        break;
                }
        }
}

//------------------------------------------------------------------------------------------
void KAWinHUD::DisplayStatusPanel( KMATEAM Team, KAGAMEFLAGMODE RedFlagMode, s32 RedScore, KAGAMEFLAGMODE BlueFlagMode, s32 BlueScore, KHEALTH Health )
{
        u8              FadeAlpha = (u8)(255.0f * GetFade());
        KFPt    StatusDelta;
        float   pTU[4], pTV[4];
        float   dtexelu = 0.5f / (float)KWINDOW_HUD2_SHADER_WIDTH;
        float   dtexelv = 0.5f / (float)KWINDOW_HUD2_SHADER_HEIGHT;

        float   w = KHUDSTATUS_WIDTH;
        float   h = KHUDSTATUS_HEIGHT;
        pTU[0] = (float)0.0f + dtexelu;         pTV[0] = 0.41f + dtexelv;
        pTU[1] = (float)w + dtexelu;            pTV[1] = 0.41f + dtexelv;
        pTU[2] = (float)0.0f + dtexelu;         pTV[2] = 1.0f + dtexelv;
        pTU[3] = (float)w + dtexelu;            pTV[3] = 1.0f + dtexelv;

        KFPt    fSize = GetFloatPoint( KPt( (s32)((float)KWINDOW_HUD2_SHADER_WIDTH * w), (s32)((float)KWINDOW_HUD2_SHADER_HEIGHT * h) ) );
        StatusDelta.x = -m_fStatusBlocPercentOutOfScreen * fSize.x;
        StatusDelta.y = -m_fStatusBlocPercentOutOfScreen * fSize.y;
        
        DrawQuad( m_Pos.x + StatusDelta.x, m_Pos.y + 1.0f - fSize.y - StatusDelta.y, fSize.x, fSize.y, m_hHud, GetTeamColor( Team ), KRGB_BLACK, KRM_NORMAL, pTU, pTV );

        DisplayFlag( RedFlagMode, KMAT_RED, RedScore );
        DisplayFlag( BlueFlagMode, KMAT_BLUE, BlueScore );
        DisplayLife( Health );
}

//------------------------------------------------------------------------------------------
void KAWinHUD::DisplayFlag( KAGAMEFLAGMODE FlagMode, KMATEAM Team, s32 Score )
{
        u8              FadeAlpha = (u8)(255.0f * GetFade());
        KFPt    StatusDelta;
        float   pTU[4], pTV[4];
        float   dtexelu = 0.5f / (float)KWINDOW_HUD2_SHADER_WIDTH;
        float   dtexelv = 0.5f / (float)KWINDOW_HUD2_SHADER_HEIGHT;

        GetFlagUV( FlagMode, pTU, pTV );

        s32             PosY = (Team == KMAT_BLUE) ? 155 : 235;
        KCOLOR  Color = GetTeamColor( Team );
        u8              i = s8(64.0f * fabs( cosf( (float)g_Time.GetTime() / 400.0f ) ) );
        KCOLOR  Specular = (FlagMode != KAGFM_STARTPOS) ? RGB( i, i, i ) : KRGB( 16, 16, 16 );

        KFPt    fSize = GetFloatPoint( KPt( (s32)((float)KWINDOW_HUD2_SHADER_WIDTH * 0.09f), (s32)((float)KWINDOW_HUD2_SHADER_HEIGHT * 0.09) ) );
        KFPt    fPos = GetFloatPoint( KPt( 70, GetIntPoint( GetSize() ).y - PosY ) );
        KFPt    fStatusSize = GetFloatPoint( KPt( (s32)((float)KWINDOW_HUD2_SHADER_WIDTH * KHUDSTATUS_WIDTH), (s32)((float)KWINDOW_HUD2_SHADER_HEIGHT * KHUDSTATUS_HEIGHT) ) );
        StatusDelta.x = -m_fStatusBlocPercentOutOfScreen * fStatusSize.x;
        StatusDelta.y = m_fStatusBlocPercentOutOfScreen * fStatusSize.y;
        
        DrawQuad( fPos.x + StatusDelta.x, fPos.y + StatusDelta.y, fSize.x, fSize.y, m_hHud, Color, Specular, KRM_NORMAL, pTU, pTV );

        char    pTextScore[16];
        sprintf( pTextScore, "%i", Score );
        m_pRender->DrawText( KPt( 110, GetIntPoint( GetSize() ).y - PosY + 48 ) + GetIntPoint( StatusDelta ), pTextScore, KRGB( 200, 200, 200 ), 0.75f );
}

//------------------------------------------------------------------------------------------
void KAWinHUD::DisplayWeaponPanel( KFPt& Pos, KMATEAM Team )
{
        u8              FadeAlpha = (u8)(255.0f * GetFade());
        float   pTU[4], pTV[4];
        float   dtexelu = 0.5f / (float)KWINDOW_HUD2_SHADER_WIDTH;
        float   dtexelv = 0.5f / (float)KWINDOW_HUD2_SHADER_HEIGHT;

        float   w = 0.5;
        float   h = 0.125f;

        pTU[0] = (float)0.3125f + dtexelu;              pTV[0] = 1.0f - h + dtexelv;
        pTU[1] = (float)0.3125f + w + dtexelu;  pTV[1] = 1.0f - h + dtexelv;
        pTU[2] = (float)0.3125f + dtexelu;              pTV[2] = 1.0f + dtexelv;
        pTU[3] = (float)0.3125f + w + dtexelu;  pTV[3] = 1.0f + dtexelv;

        KFPt    fSize = GetFloatPoint( KPt( (s32)((float)KWINDOW_HUD2_SHADER_WIDTH * w), (s32)((float)KWINDOW_HUD2_SHADER_HEIGHT * h) ) );
//      float   DeltaX = 0.165f * (1.0f - m_fStatusBlocPercentOutOfScreen);
        DrawQuad( m_Pos.x + Pos.x + (m_fWeaponBlocPercentOutOfScreen * 0.083984375f), m_Pos.y + 1.0f - fSize.y + (h * m_fWeaponBlocPercentOutOfScreen), fSize.x, fSize.y, m_hHud, GetTeamColor( Team ), KRGB_BLACK, KRM_NORMAL, pTU, pTV );
//      DrawQuad( Pos.x, Pos.y - fSize.y, fSize.x, fSize.y, m_hHud, GetTeamColor( Team ), KRGB_BLACK, KRM_NORMAL, pTU, pTV );
}

//------------------------------------------------------------------------------------------
void KAWinHUD::DisplayFlagPanel( KFPt& Pos, KMATEAM Team )
{
        u8              FadeAlpha = (u8)(255.0f * GetFade());
        float   pTU[4], pTV[4];
        float   dtexelu = 0.5f / (float)KWINDOW_HUD2_SHADER_WIDTH;
        float   dtexelv = 0.5f / (float)KWINDOW_HUD2_SHADER_HEIGHT;

        float   w = 0.3f;
        float   h = 0.1171875f;

        pTU[0] = (float)0.3125f + dtexelu;              pTV[0] = 0.7617f + dtexelv;
        pTU[1] = (float)0.3125f + w + dtexelu;  pTV[1] = 0.7617f + dtexelv;
        pTU[2] = (float)0.3125f + dtexelu;              pTV[2] = 0.7617f + h + dtexelv;
        pTU[3] = (float)0.3125f + w + dtexelu;  pTV[3] = 0.7617f + h + dtexelv;

        KFPt    fSize = GetFloatPoint( KPt( (s32)((float)KWINDOW_HUD2_SHADER_WIDTH * w), (s32)((float)KWINDOW_HUD2_SHADER_HEIGHT * h) ) );
        DrawQuad( m_Pos.x + Pos.x/*0.44f*/ + (m_fFlagBlocPercentOutOfScreen * 0.125f), m_Pos.y + 1.0f - fSize.y + (h * m_fFlagBlocPercentOutOfScreen), fSize.x, fSize.y, m_hHud, GetTeamColor( Team ), KRGB_BLACK, KRM_NORMAL, pTU, pTV );
//      DrawQuad( Pos.x, Pos.y - fSize.y, fSize.x, fSize.y, m_hHud, GetTeamColor( Team ), KRGB_BLACK, KRM_NORMAL, pTU, pTV );
}

//------------------------------------------------------------------------------------------
void KAWinHUD::GetFlagUV( KAGAMEFLAGMODE FlagMode, float* pTU, float* pTV )
{
        float   dtexelu = 0.5f / (float)KWINDOW_HUD2_SHADER_WIDTH;
        float   dtexelv = 0.5f / (float)KWINDOW_HUD2_SHADER_HEIGHT;

        switch( FlagMode )
        {
        case KAGFM_STARTPOS:
                pTU[0] = (float)0.875f + dtexelu;       pTV[0] = 0.125f + dtexelv;
                pTU[1] = (float)1.0f + dtexelu;         pTV[1] = 0.125f + dtexelv;
                pTU[2] = (float)0.875f + dtexelu;       pTV[2] = 0.250f + dtexelv;
                pTU[3] = (float)1.0f + dtexelu;         pTV[3] = 0.250f + dtexelv;
                break;
        case KAGFM_TAKEN:
                pTU[0] = (float)0.750f + dtexelu;       pTV[0] = 0.0f + dtexelv;
                pTU[1] = (float)0.875f + dtexelu;       pTV[1] = 0.0f + dtexelv;
                pTU[2] = (float)0.750f + dtexelu;       pTV[2] = 0.125f + dtexelv;
                pTU[3] = (float)0.875f + dtexelu;       pTV[3] = 0.125f + dtexelv;
                break;
        case KAGFM_DROPPED:
                pTU[0] = (float)0.750f + dtexelu;       pTV[0] = 0.125f + dtexelv;
                pTU[1] = (float)0.875f + dtexelu;       pTV[1] = 0.125f + dtexelv;
                pTU[2] = (float)0.750f + dtexelu;       pTV[2] = 0.250f + dtexelv;
                pTU[3] = (float)0.875f + dtexelu;       pTV[3] = 0.250f + dtexelv;
                break;
        }
}

//------------------------------------------------------------------------------------------
KCOLOR KAWinHUD::GetTeamColor( KMATEAM Team )
{
        u8              FadeAlpha = (u8)(255.0f * GetFade());

        switch( Team )
        {
        case KMAT_BLUE:
                return KRGBA( 147, 162, 255, FadeAlpha );
        case KMAT_RED:
                return KRGBA( 255, 147, 162, FadeAlpha );
        }

        return KRGBA( 255, 255, 255, FadeAlpha );
}

//------------------------------------------------------------------------------------------
void KAWinHUD::DisplayVoiceCommand(bool bDisplay)
{
    m_bDisplayVoiceCommand = bDisplay ;

    if(m_bDisplayVoiceCommand)
    {
        char* pTitle  = "Voice Command" ;

                m_pRender->DrawText( KPt( 20, 200 ), pTitle, KRGB( 255, 0, 0 ), 0.75f );
                for( s32 i = 0; i < KAGVC_COUNT; i ++ )
                        m_pRender->DrawText( KPt( 20, 220 + i * 16 ), m_psVoiceCommand[i], KRGB( 200, 200, 200 ), 0.75f );
    }    
}
/*
//------------------------------------------------------------------------------------------
void KAWinHUD::DisplayCrosshair()
{
        if(!m_bDisplayWeaponBloc)
                return ;
        u8              FadeAlpha = (u8)(255.0f * GetFade());
        float   pTU[4], pTV[4];
        float   dtexelu = 0.5f / (float)KWINDOW_HUD2_SHADER_WIDTH;
        float   dtexelv = 0.5f / (float)KWINDOW_HUD2_SHADER_HEIGHT;

        pTU[0] = (float)0.750f + dtexelu;       pTV[0] = 0.250f + dtexelv;
        pTU[1] = (float)0.875f + dtexelu;       pTV[1] = 0.250f + dtexelv;
        pTU[2] = (float)0.750f + dtexelu;       pTV[2] = 0.375f + dtexelv;
        pTU[3] = (float)0.875f + dtexelu;       pTV[3] = 0.375f + dtexelv;

        KFPt    fSize = GetFloatPoint( KPt( 64, 64 ) );
        KFPt    fWinSize = GetSize();
        DrawQuad( (fWinSize.x - fSize.x) / 2, (fWinSize.y - fSize.y) / 2, fSize.x, fSize.y, m_hHud, KRGB_WHITE, KRGB_BLACK, KRM_NORMAL, pTU, pTV );
}
*/
//------------------------------------------------------------------------------------------
void KAWinHUD::Load()
{
        KWin::Load();

        m_hBackGround   = m_pRender->GetpShaderBank()->LoadShader( "GUI/WinHUD" );
        m_hHud                  = m_pRender->GetpShaderBank()->LoadShader( "GUI/WinHUD3" );
        m_hNumbers              = m_pRender->GetpShaderBank()->LoadShader( "GUI/Numbers" );

        m_psVoiceCommand[KAGVC_AFFIRMATIVE]             = KStr( "%s - %s", g_AInputManager.GetpMappedKey(E_ACTIONS_VOICECMD1)->GetpKeyName(), GETLOCALSTRING(LS_VOICECMD_AFFIRMATIVE) );
        m_psVoiceCommand[KAGVC_NEGATIVE]                = KStr( "%s - %s", g_AInputManager.GetpMappedKey(E_ACTIONS_VOICECMD2)->GetpKeyName(), GETLOCALSTRING(LS_VOICECMD_NEGATIVE) );
        m_psVoiceCommand[KAGVC_LETSGO]                  = KStr( "%s - %s", g_AInputManager.GetpMappedKey(E_ACTIONS_VOICECMD3)->GetpKeyName(), GETLOCALSTRING(LS_VOICECMD_LETSGO) );
        m_psVoiceCommand[KAGVC_COVERME]                 = KStr( "%s - %s", g_AInputManager.GetpMappedKey(E_ACTIONS_VOICECMD4)->GetpKeyName(), GETLOCALSTRING(LS_VOICECMD_COVERME) );
        m_psVoiceCommand[KAGVC_ENEMYDOWN]               = KStr( "%s - %s", g_AInputManager.GetpMappedKey(E_ACTIONS_VOICECMD5)->GetpKeyName(), GETLOCALSTRING(LS_VOICECMD_ENEMYDOWN) );
        m_psVoiceCommand[KAGVC_IAMINPOSITION]   = KStr( "%s - %s", g_AInputManager.GetpMappedKey(E_ACTIONS_VOICECMD6)->GetpKeyName(), GETLOCALSTRING(LS_VOICECMD_IAMINPOSITION) );
}

//------------------------------------------------------------------------------------------
void KAWinHUD::Unload()
{
        KWin::Unload();

        m_pRender->GetpShaderBank()->UnloadShader( m_hBackGround );
        m_pRender->GetpShaderBank()->UnloadShader( m_hHud );
        m_pRender->GetpShaderBank()->UnloadShader( m_hNumbers );
}

//------------------------------------------------------------------------------------------
void KAWinHUD::DisplayRadar(bool bDisplay)
{
        if(bDisplay)
                m_fRadarPercentOutOfScreen = 0.0f ;
        else
                m_fRadarPercentOutOfScreen = 0.5f ;
}

//------------------------------------------------------------------------------------------
bool KAWinHUD::OnKeyDown( u32 VirtKey, u32 KeyData )
{
/*      if( ISVKMAPPED( E_ACTIONS_BUY ) )
        {
                if( ((KAInterface*)m_pInterface)->GetWin() == KAIW_BUY )
                        ((KAInterface*)m_pInterface)->SetWin( KAIW_NONE ) ;
                else if(!((KAInterface*)m_pInterface)->IsInGameMenu())
                        ((KAInterface*)m_pInterface)->SetWin( KAIW_BUY ) ;
        }
*/
        if(((KAInterface*)m_pInterface)->IsInGameMenu())
                return false ;
        KAClientGameManager* pGameManager = (KAClientGameManager*)g_pClientGameManager ;
        KAClientPlayer* pMyPlayer = (KAClientPlayer*)pGameManager->GetpMyPlayer() ;

        if( ISVKMAPPED( E_ACTIONS_RADAR ) )
                m_bDisplayRadar = !m_bDisplayRadar ;

        if( ISVKMAPPED( E_ACTIONS_HUDSTATUS ) )
                m_bDisplayStatusBloc = !m_bDisplayStatusBloc ;
        
        if( ISVKMAPPED( E_ACTIONS_PREVOBJECT ) )
                pMyPlayer->SelectPrevObject() ;
        
        if( ISVKMAPPED( E_ACTIONS_NEXTOBJECT ) )
                pMyPlayer->SelectNextObject() ;
        
        if( ISVKMAPPED( E_ACTIONS_DROP ) )
                pMyPlayer->Drop() ;
        
        if( ISVKMAPPED( E_ACTIONS_ZOOM ) )
                pMyPlayer->Zoom() ;

        // Voice Command
        if( ISVKMAPPED( E_ACTIONS_DISPLAYVOICECMD ) )
                m_bDisplayVoiceCommand = m_bDisplayVoiceCommand ? false : true;

        if( ISVKMAPPED( E_ACTIONS_VOICECMD1 ) && m_bDisplayVoiceCommand )
        {
                pGameManager->VoiceCommand( KAGVC_AFFIRMATIVE );
                m_bDisplayVoiceCommand = false;
        }

        if( ISVKMAPPED( E_ACTIONS_VOICECMD2 ) && m_bDisplayVoiceCommand )
        {
                pGameManager->VoiceCommand( KAGVC_NEGATIVE );
                m_bDisplayVoiceCommand = false;
        }

        if( ISVKMAPPED( E_ACTIONS_VOICECMD3 ) && m_bDisplayVoiceCommand )
        {
                pGameManager->VoiceCommand( KAGVC_LETSGO );
                m_bDisplayVoiceCommand = false;
        }

        if( ISVKMAPPED( E_ACTIONS_VOICECMD4 ) && m_bDisplayVoiceCommand )
        {
                pGameManager->VoiceCommand( KAGVC_COVERME );
                m_bDisplayVoiceCommand = false;
        }

        if( ISVKMAPPED( E_ACTIONS_VOICECMD5 ) && m_bDisplayVoiceCommand )
        {
                pGameManager->VoiceCommand( KAGVC_ENEMYDOWN );
                m_bDisplayVoiceCommand = false;
        }

        if( ISVKMAPPED( E_ACTIONS_VOICECMD6 ) && m_bDisplayVoiceCommand )
        {
                pGameManager->VoiceCommand( KAGVC_IAMINPOSITION );
                m_bDisplayVoiceCommand = false;
        }

        return true ;
}

//------------------------------------------------------------------------------------------
void KAWinHUD::DisplayInventory(KMATEAM Team)
{
        KAClientGameManager* pGameManager = (KAClientGameManager*)g_pClientGameManager ;
        KAClientPlayer* pMyPlayer = (KAClientPlayer*)pGameManager->GetpMyPlayer() ;
        
        if(pMyPlayer == NULL)
                return ;

        float   pTU[4], pTV[4];
        float   dtexelu = 0.5f / (float)KWINDOW_HUD2_SHADER_WIDTH;
        float   dtexelv = 0.5f / (float)KWINDOW_HUD2_SHADER_HEIGHT;

        if(pMyPlayer->GetCurrentWeapon())
                m_bDisplayWeaponBloc = true ;
        else
                m_bDisplayWeaponBloc = false ;

        float   OffsetX = 0.165f * (1.0f - m_fStatusBlocPercentOutOfScreen);

        //
        //      GUN PANEL
        //
        if(pMyPlayer->GetCurrentWeapon())
        {
                u32 WeaponType = pMyPlayer->GetCurrentWeapon()->GetWeaponType() ;

                float fWeaponIndexX = 0.5078125f ;
                float fWeaponSizeX = 0.25f ;
                float fWeaponSizeY = 0.125f ;

                switch( WeaponType )
                {
                        case KAGWT_KNIFE:
                                pTU[0] = fWeaponIndexX + dtexelu;                               pTV[0] = 0.0f + dtexelv;
                                pTU[1] = fWeaponIndexX + fWeaponSizeX + dtexelu;        pTV[1] = 0.0f + dtexelv;
                                pTU[2] = fWeaponIndexX + dtexelu;                               pTV[2] = 0.0f + fWeaponSizeY + dtexelv;
                                pTU[3] = fWeaponIndexX + fWeaponSizeX + dtexelu;        pTV[3] = 0.0f + fWeaponSizeY + dtexelv;
                        break;
                        case KAGWT_RIFLE:
                                pTU[0] = fWeaponIndexX + dtexelu;                               pTV[0] = 0.125f + dtexelv;
                                pTU[1] = fWeaponIndexX + fWeaponSizeX + dtexelu;        pTV[1] = 0.125f + dtexelv;
                                pTU[2] = fWeaponIndexX + dtexelu;                               pTV[2] = 0.125f + fWeaponSizeY + dtexelv;
                                pTU[3] = fWeaponIndexX + fWeaponSizeX + dtexelu;        pTV[3] = 0.125f + fWeaponSizeY + dtexelv;
                        break;
                        case KAGWT_SHOTGUN:
                                pTU[0] = fWeaponIndexX + dtexelu;                               pTV[0] = 0.25f + dtexelv;
                                pTU[1] = fWeaponIndexX + fWeaponSizeX + dtexelu;        pTV[1] = 0.25f + dtexelv;
                                pTU[2] = fWeaponIndexX + dtexelu;                               pTV[2] = 0.25f + fWeaponSizeY + dtexelv;
                                pTU[3] = fWeaponIndexX + fWeaponSizeX + dtexelu;        pTV[3] = 0.25f + fWeaponSizeY + dtexelv;
                        break;
                        case KAGWT_ROCKETLAUNCHER:
                                pTU[0] = fWeaponIndexX + dtexelu;                               pTV[0] = 0.375f + dtexelv;
                                pTU[1] = fWeaponIndexX + fWeaponSizeX + dtexelu;        pTV[1] = 0.375f + dtexelv;
                                pTU[2] = fWeaponIndexX + dtexelu;                               pTV[2] = 0.375f + fWeaponSizeY + dtexelv;
                                pTU[3] = fWeaponIndexX + fWeaponSizeX + dtexelu;        pTV[3] = 0.375f + fWeaponSizeY + dtexelv;
                        break;
                        case KAGWT_SNIPER:
                                pTU[0] = fWeaponIndexX + dtexelu;                               pTV[0] = 0.5f + dtexelv;
                                pTU[1] = fWeaponIndexX + fWeaponSizeX + dtexelu;        pTV[1] = 0.5f + dtexelv;
                                pTU[2] = fWeaponIndexX + dtexelu;                               pTV[2] = 0.5f + fWeaponSizeY + dtexelv;
                                pTU[3] = fWeaponIndexX + fWeaponSizeX + dtexelu;        pTV[3] = 0.5f + fWeaponSizeY + dtexelv;
                        break;
                }

                KFPt    fSize2 = GetFloatPoint( KPt( 128, 48 ) );
                KFPt    fSize3 = GetFloatPoint( KPt( 35, 0 ) );
                KCOLOR  color = GetTeamColor( Team ) ;
                if(pMyPlayer->GetCurrentWeapon() == pMyPlayer->GetSelectedObject())
                        color = KRGB_WHITE ;

                DrawQuad( m_Pos.x + OffsetX + fSize3.x + (m_fWeaponBlocPercentOutOfScreen * 0.083984375f), m_Pos.y + (1.0f - fSize2.y) + (0.125f * m_fWeaponBlocPercentOutOfScreen), fSize2.x, fSize2.y, m_hHud, color, KRGB_BLACK, KRM_NORMAL, pTU, pTV );

                DisplayWeaponPanel( KFPt( OffsetX, 0.0f ), Team );
                OffsetX += 0.275f;
        }

        m_bDisplayFlagBloc = false ;
        for(int iCpt = 0 ; iCpt <= pMyPlayer->GetNbObjectInInventory() ; iCpt ++)
        {
                K3DObject *pObject = pMyPlayer->GetpObjectInInventory(iCpt) ;

                if(pObject != NULL)
                {
                        u32 ObjectType = pObject->GetType() ;

                        if( ObjectType == KAGOT_FLAG )
                        {
                                m_bDisplayFlagBloc = true ;

                                pTU[0] = (float)0.869140625f + dtexelu; pTV[0] = 0.25390625f + dtexelv;
                                pTU[1] = (float)0.994140625f + dtexelu; pTV[1] = 0.25390625f + dtexelv;
                                pTU[2] = (float)0.869140625f + dtexelu; pTV[2] = 0.37890625f + dtexelv;
                                pTU[3] = (float)0.994140625f + dtexelu; pTV[3] = 0.37890625f + dtexelv;

                                KFPt    fSize2 = GetFloatPoint( KPt( 64, 64 ) );
                                KFPt    fSize3 = GetFloatPoint( KPt( 50, 0 ) );

                                KCOLOR color = GetTeamColor( Team ) ;
                                if(pObject == pMyPlayer->GetSelectedObject())
                                        color = KRGB_WHITE ;
                                DrawQuad( m_Pos.x + OffsetX + fSize3.x + (m_fFlagBlocPercentOutOfScreen * 0.125f), m_Pos.y + 1.0f - fSize2.y + (0.1171875f * m_fFlagBlocPercentOutOfScreen), fSize2.x, fSize2.y, m_hHud, color, KRGB_BLACK, KRM_NORMAL, pTU, pTV );
                                DisplayFlagPanel( KFPt( OffsetX, 0.0f ), Team );
                        }
                }
        }
}

//------------------------------------------------------------------------------------------
void KAWinHUD::ShowBlood( KDAMAGE Damage )
{
        m_BloodTime             = g_Time.GetTime();
        m_BloodDuration = Damage * 10;
}

//------------------------------------------------------------------------------------------
void KAWinHUD::DisplayBlood()
{
        KCOLOR  Color;
        
        KTIME   Time = g_Time.GetTime();

        if( m_BloodTime + m_BloodDuration > Time )
        {
                float   Intensity = ( ( m_BloodTime + m_BloodDuration - Time ) / (float)( m_BloodDuration ) );

                Color = KRGB( u8(255.0f * Intensity), 0, 0 );

                DrawQuad( m_Pos.x, m_Pos.y, m_Size.x, m_Size.y, KSHADER_NO, Color, KRGB_BLACK, KRM_ADD );
        }
}

//------------------------------------------------------------------------------------------
void KAWinHUD::DisplayTime()
{
        KAClientGameManager*    pGameManager = (KAClientGameManager*)g_pClientGameManager;
        if( !pGameManager )
                return;

        KAClientPlayer* pMyPlayer = (KAClientPlayer*)pGameManager->GetpMyPlayer() ;
        
        if(pMyPlayer == NULL)
                return ;
//      if(pMyPlayer->IsWaiting())
//              return ;

        KTIME gameTimeLeft = pGameManager->GetGameTimeLeft() ;
        KTIME roundTimeLeft = pGameManager->GetRoundTimeLeft() ;

        s32 uMinutesGameLeft    = gameTimeLeft / 60000 ;
        s32 uSecondesGameLeft   = (gameTimeLeft - uMinutesGameLeft * 60000) / 1000 ;

        s32 uMinutesRoundLeft   = roundTimeLeft / 60000 ;
        s32 uSecondesRoundLeft  = (roundTimeLeft - uMinutesRoundLeft * 60000) / 1000 ;

        char cTempGameTime[256] = "" ;
        char cTempRoundTime[256] = "" ;

        if(uMinutesGameLeft <= 0)       uMinutesGameLeft = 0 ;
        if(uSecondesGameLeft <= 0)      uSecondesGameLeft = 0 ;
        if(uMinutesRoundLeft <= 0)      uMinutesRoundLeft = 0 ;
        if(uSecondesRoundLeft <= 0)     uSecondesRoundLeft = 0 ;

        sprintf(cTempGameTime,"Game : %i : %i" ,uMinutesGameLeft,uSecondesGameLeft) ;
        sprintf(cTempRoundTime,"Round : %i : %i" ,uMinutesRoundLeft,uSecondesRoundLeft) ;

        m_pRender->DrawText( GetIntPoint(KFPt( 0.8f , 0.05f )) ,cTempGameTime, KRGB( 200, 200, 200 ), 1.0f );
        m_pRender->DrawText( GetIntPoint(KFPt( 0.8f , 0.09f )) , cTempRoundTime, KRGB( 200, 200, 200 ), 1.0f );

        /*
        DisplayNumbers( KFPt( 0.8f, 0.05f), KFPt( 0.03f, 0.03f ), uMinutesGameLeft );
        DisplayNumbers( KFPt( 0.88f, 0.05f), KFPt( 0.03f, 0.03f ), uSecondesGameLeft );

        DisplayNumbers( KFPt( 0.8f, 0.09f), KFPt( 0.03f, 0.03f ), uMinutesRoundLeft );
        DisplayNumbers( KFPt( 0.88f, 0.09f), KFPt( 0.03f, 0.03f ), uSecondesRoundLeft );
        */
}

---