---

HUD.cpp

Go to the documentation of this file.

/*
CS Senior Project 2003
Team : Leftfield
Project : ModernWarfare
Members :
- Russ Christensen              <rchriste@cs.utah.edu>
- Todd Smith                    <tcsmith@cs.utah.edu>
- Usit Duongsaa                 <duongsaa@cs.utah.edu>
Copyright 2003 Russ Christensen, Usit Duongsaa, and Todd Smith. All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 
THIS SOFTWARE IS PROVIDED BY RUSS CHRISTENSEN, USIT DUONGSAA, AND TODD SMITH ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RUSS, USIT, TODD OR OTHER CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include "HUD.h"
#include "GameState.h"
#include "Globals.h"
#include "EconData.h"
#include "Map.h"
#include "HelperFunctions.h"
#include "Sound.h"

using namespace NetworkMessages;
using namespace Globals;

const Vec3D HUD::COLOR_INACTIVE_BATTLE(0.792f, 0.741f, 0.768f);
const Vec3D HUD::COLOR_CITY_OUTLINE(0.83f, 0.88f, 0.69f);

void HUD::init(istream& in)
{
        HUD& h = HUD::getObj();

        in >> h.m_startX;
        in >> h.m_startY;
        in >> h.m_endX;
        in >> h.m_endY;

        float delta;

        in >> h.m_mapBorderX1;
        h.m_mapBorderX1 += h.m_startX;
        in >> h.m_mapBorderY1;
        h.m_mapBorderY1 += h.m_startY;
        in >> delta;
        h.m_mapBorderX2 = h.m_mapBorderX1+delta;
        in >> delta;
        h.m_mapBorderY2 = h.m_mapBorderY1+delta;
        // read inset and calculate map dims
        in >> delta;
        h.m_mapDims[0].x = h.m_mapBorderX1+delta;
        h.m_mapDims[0].y = h.m_mapBorderY1+delta;
        h.m_mapDims[1].x = h.m_mapBorderX2-delta;
        h.m_mapDims[1].y = h.m_mapBorderY2-delta;
        h.m_miniMapBounds.setBounds(h.m_mapDims[0], h.m_mapDims[1]);
        in >> h.m_mapCityOutlineSize >> h.m_mapCitySize;
        in >> h.m_mapUnitSize;

        // info box, contains build Q in overhead mode, ?? in battle mode
        in >> h.m_infoBorderX1;
        h.m_infoBorderX1 += h.m_startX;
        in >> h.m_infoBorderY1;
        h.m_infoBorderY1 += h.m_startY;
        in >> delta;
        h.m_infoBorderX2 = h.m_infoBorderX1+delta;
        in >> delta;
        h.m_infoBorderY2 = h.m_infoBorderY1+delta;

        // read in the portrait center and size
        in >> delta;
        h.m_infoPortraitCenter.x = h.m_infoBorderX1 + delta;
        in >> delta;
        h.m_infoPortraitCenter.y = h.m_infoBorderY1 + delta;
        in >> h.m_infoPortraitSize.x >> h.m_infoPortraitSize.y;

        // build Q
        in >> h.m_buildQIconSize.x >> h.m_buildQIconSize.y;
        float cX, cY, offset;
        // icon center X, icon center Y, offset (how much to shift each icon center
        in >> cX >> cY >> offset;
        cX += h.m_infoBorderX1;
        cY += h.m_infoBorderY1;
        for(int i=0; i < 3; ++i)
        {
                for(int j=0; j < 3; ++j)
                {
                        int index = i*3+j;
                        h.m_buildQIconCoords[index].x = cX + j*offset;
                        h.m_buildQIconCoords[index].y = cY + i*offset;
                }
        }

        in >> delta;
        h.m_buildQTimerCoords.x = h.m_infoBorderX1 + delta;
        in >> delta;
        h.m_buildQTimerCoords.y = h.m_infoBorderY1 + delta;
        //in >> h.m_buildQTimerCoords.x >> h.m_buildQTimerCoords.y;
        in >> h.m_buildQTimerTextSize;

        string color;
        in >> color;
        h.m_buildQTimerTextColor = Map::getColorVec3D(color);



        in >> h.m_moneyBorderX1;
        h.m_moneyBorderX1 += h.m_startX;
        in >> h.m_moneyBorderY1;
        h.m_moneyBorderY1 += h.m_startY;
        in >> delta;
        h.m_moneyBorderX2 = h.m_moneyBorderX1+delta;
        in >> delta;
        h.m_moneyBorderY2 = h.m_moneyBorderY1+delta;
        in >> h.m_moneyTextX;
        h.m_moneyTextX += h.m_startX;
        in >> h.m_moneyTextY;
        h.m_moneyTextY += h.m_startY;
        in >> h.m_moneyTextSize;
        in >> color;
        h.m_moneyTextColor = Map::getColorVec3D(color);

        // actions box
        in >> h.m_actionsBorderStart.x >> h.m_actionsBorderStart.y;
        h.m_actionsBorderStart.x += h.m_startX;
        h.m_actionsBorderStart.y += h.m_startY;
        in >> h.m_actionsBorderEnd.x >> h.m_actionsBorderEnd.y;
        h.m_actionsBorderEnd.x += h.m_startX;
        h.m_actionsBorderEnd.y += h.m_startY;

  // map box
  in >> h.m_mapBorderStart.x >> h.m_mapBorderStart.y;
  h.m_mapBorderStart.x += h.m_startX;
  h.m_mapBorderStart.y += h.m_startY;
  in >> h.m_mapBorderEnd.x >> h.m_mapBorderEnd.y;
  h.m_mapBorderEnd.x += h.m_startX;
  h.m_mapBorderEnd.y += h.m_startY;

  // info box
  in >> h.m_infoBorderStart.x >> h.m_infoBorderStart.y;
  h.m_infoBorderStart.x += h.m_startX;
  h.m_infoBorderStart.y += h.m_startY;
  in >> h.m_infoBorderEnd.x >> h.m_infoBorderEnd.y;
  h.m_infoBorderEnd.x += (h.m_infoBorderStart.x);
  h.m_infoBorderEnd.y += (h.m_infoBorderStart.y);

        // build menu icons
        h.m_buildIcons.reserve(ICON_COUNT);
        h.m_buildIcons[0] = &h.m_iconBuildLT;
        h.m_buildIcons[1] = &h.m_iconBuildHT;
        h.m_buildIcons[2] = &h.m_iconBuildRL;
        h.m_buildIcons[3] = &h.m_iconBuildAR;
        h.m_buildIcons[4] = &h.m_iconBuildJT;

        // all build menu icons have same size
        float width, height;
        in >> width >> height;

        in >> h.m_iconTextXOffset >> h.m_iconTextYOffset >> h.m_iconTextSize;

        in >> color;
        h.m_iconTextColor = Map::getColorVec3D(color);

        float x,y;
        in >> x >> y;
        h.m_iconBuildLT.setBounds( Vec2D(x - width/2,
                y - height/2),
                Vec2D(x + width/2,
                y + height/2));
        h.m_iconBuildLT.setImage(Globals::artWork->portraitLT);

        in >> x >> y;
        h.m_iconBuildHT.setBounds( Vec2D(x - width/2,
                y - height/2),
                Vec2D(x + width/2,
                y + height/2));
        h.m_iconBuildHT.setImage(Globals::artWork->portraitHT);

        in >> x >> y;
        h.m_iconBuildRL.setBounds( Vec2D(x - width/2,
                y - height/2),
                Vec2D(x + width/2,
                y + height/2));
        h.m_iconBuildRL.setImage(Globals::artWork->portraitLA);

        in >> x >> y;
        h.m_iconBuildAR.setBounds( Vec2D(x - width/2,
                y - height/2),
                Vec2D(x + width/2,
                y + height/2));
        h.m_iconBuildAR.setImage(Globals::artWork->portraitAR);

        in >> x >> y;
        h.m_iconBuildJT.setBounds( Vec2D(x - width/2, y - height/2), Vec2D(x + width/2, y + height/2));
        h.m_iconBuildJT.setImage(Globals::artWork->portraitJE);

        in >> x >> y;
        h.m_iconOverhead.setBounds(Vec2D(x - width/2, y - height/2), Vec2D(x + width/2, y + height/2));

        in >> x >> y;
        h.m_iconCallRFM.setBounds(Vec2D(x - width/2, y - height/2), Vec2D(x + width/2, y + height/2));  // call RFM icon

        in >> h.m_panelCallRFMCoord.x >> h.m_panelCallRFMCoord.y;                               // call RFM panel coord
        in >> h.m_panelCallRFMSize.x >> h.m_panelCallRFMSize.y;

        // 5-button callRFM panel
        FLOAT callW,callH;              // width,height of 5-but panel
        in >> x >> y >> callW >> callH;
        callW /= 5;
        for( int i=0; i<5; i++ )
        {
                Vec2D UL( x+callW*i, y);
                Vec2D LR( x+callW*i+callW, y+callH );           
                h.m_iconCallUnitType.push_back( Icon(UL,LR,NULL) );
        }       

        in >> h.cammRFMTextPos.x >> h.cammRFMTextPos.y;

        in >> x >> y;
        h.m_iconJetGuard.setBounds(Vec2D(x - width/2, y - height/2), Vec2D(x + width/2, y + height/2)); // jet guard
        in >> x >> y;
        h.m_iconJetBomb.setBounds(Vec2D(x - width/2, y - height/2), Vec2D(x + width/2, y + height/2));  // jet bomb
        in >> x >> y;
        h.m_iconStop.setBounds(Vec2D(x - width/2, y - height/2), Vec2D(x + width/2, y + height/2));             // stop


        in >> h.m_econInfoTextX;
        in >> h.m_econInfoTextY;

        in >> x >> y;
        const FLOAT econHeight = 0.07f;
        h.m_iconUpgradeEcon.setBounds(Vec2D(x - width/2, y - econHeight/2), Vec2D(x + width/2, y + econHeight/2));

        h.m_iconOverhead.setImage(Globals::artWork->switchToOverhead);
        h.m_iconCallRFM.setImage(Globals::artWork->callRFMIconTex);
        h.m_iconJetGuard.setImage(Globals::artWork->butJetGuard);
        h.m_iconJetBomb.setImage(Globals::artWork->butJetBomb);
        h.m_iconStop.setImage(Globals::artWork->butStop);

        h.m_pSelectedCity = 0;
        h.m_pSelectedUnit = 0;
        h.m_selectedGroupType = -1;

        h.m_iconUpgradeEcon.setImage( Globals::artWork->upgradeEconTex );
        h.m_portraits[UnitTypes::LIGHT_TANK] = Globals::artWork->portraitLT;
        h.m_portraits[UnitTypes::HEAVY_TANK] = Globals::artWork->portraitHT;
        h.m_portraits[UnitTypes::LAUNCHER] = Globals::artWork->portraitLA;
        h.m_portraits[UnitTypes::ARTILLERY] = Globals::artWork->portraitAR;
        h.m_portraits[UnitTypes::JET] = Globals::artWork->portraitJE;

        h.m_blinkOn = false;
        h.m_blinkCount = 0;

        h.m_showCallRFMPanel = false;

        // help text
        h.m_iconBuildLT.setHelpString("Build Light Tank Battalion\nFast and can shoot in any direction\nHot Key[L]");
        h.m_iconBuildHT.setHelpString("Build Heavy Tank Battalion\nSlow but very heavily armored\nHot Key[H]");
        h.m_iconBuildRL.setHelpString("Build Rocket Launcher Battalion\nLaunch medium-range rockets\nInflict massive damage to an area\nHot Key[R]");
        h.m_iconBuildAR.setHelpString("Build Artillery Battalion\nCan bombard from long range\nHot Key[A]");
        h.m_iconBuildJT.setHelpString("Build Jet Squadrom\nCan bomb ground targets or\nshoot down enemy jets\nHot Key[J]");
        h.m_iconUpgradeEcon.setHelpString("Upgrade City's Economic Level\nIncreased the city's income\n-rate in the long term");
        h.m_iconOverhead.setHelpString("Go back to the overhead map\nHot Key [Ctrl+Up]");
        h.m_iconCallRFM.setHelpString("Call in reinforcement (if any)");
        h.m_iconJetGuard.setHelpString("Right-Click on Empty Ground\nJets will guard the area\nand shoot down incoming enemy jets");
        h.m_iconJetBomb.setHelpString("Right-Click on Enemy Target\nJets will drop non-guided bombs");
        h.m_iconStop.setHelpString("Stop this battalion at current\nposition and direction\nHot Key [S]");
        h.m_iconCallUnitType[0].setHelpString("Call in more Light Tanks");
        h.m_iconCallUnitType[1].setHelpString("Call in more Heavy Tanks");
        h.m_iconCallUnitType[2].setHelpString("Call in more Rocket Launchers");
        h.m_iconCallUnitType[3].setHelpString("Call in more Artilleries");
        h.m_iconCallUnitType[4].setHelpString("Call in more Jets");
}

Vec2D HUD::translateMiniMapToWorld(const Vec2D& mmPos)
{
        Vec2D pos;
        pos.x = mmPos.x - m_miniMapBounds.bounds()[0].x;
        pos.y = mmPos.y - m_miniMapBounds.bounds()[0].y;
        // scale to world coords
        pos.x *= 1/m_miniMapScale.x;
        pos.y *= 1/m_miniMapScale.y;
        // translate to absolute coords
        pos.x += m_map.bounds.bounds()[0].x;
        pos.y += m_map.bounds.bounds()[0].y;
        return pos;

}

Vec3D HUD::translateMiniMapToWorld3D(const Vec2D& mmPos)
{
        Vec3D pos;
        Vec2D pos2D = translateMiniMapToWorld(mmPos);
        pos.x = pos2D.x;
        pos.y = pos2D.y;
        pos.z = 0.0f;
        return pos;
}

Vec2D HUD::translateWorldToMiniMap(const Vec2D& wPos)
{
        Vec2D pos;
        pos.x = wPos.x - m_map.bounds.bounds()[0].x;
        pos.y = wPos.y - m_map.bounds.bounds()[0].y;
        // scale
        pos.x *= m_miniMapScale.x;
        pos.y *= m_miniMapScale.y;
        // translate to minimap position in the HUD
        pos.x += m_mapDims[0].x;
        pos.y += m_mapDims[0].y;
        return pos;
}


Vec2D HUD::translateWorldToMiniMap(const Vec3D& wPos)
{
        return translateWorldToMiniMap(Vec2D(wPos.x, wPos.y));
}

bool HUD::processMiniMapInput(const Vec2D& mouse)
{
        if(m_miniMapBounds.contains(mouse) )
        {
                if( input_isMouseLBClicked() )
                {
                        // switch from battle mode to overhead mode
                        if( input_isKeyDown(KeyCodes::key_LCONTROL) || input_isKeyDown(KeyCodes::key_RCONTROL) )
                        {
                                switchToOverhead();
                                // translate mouse position to world position
                                Vec2D pos = translateMiniMapToWorld(mouse);
                                GameState::camTarget().x = pos.x;
                                GameState::camTarget().y = pos.y;
                                return true;
                        }
                        // if the user clicks on a battle entry icon, switch to it
                        for(BattleIter iter=GameState::battles().begin(); iter != GameState::battles().end(); ++iter)
                        {
                                // only allow player to switch between battles they are involved in.
                                if( (*iter)->isFoughtBy(m_pPlayer->color()) )
                                {
                                        Vec2D pos = translateWorldToMiniMap( (*iter)->getBattleLocation() );
                                        Rect r(Vec2D(pos.x-0.01f, pos.y-0.01f), Vec2D(pos.x+0.01f, pos.y+0.01f));

                                        if( r.contains(mouse) )
                                        {
                                                GameState::setActiveBattle( *iter );
                                                setSelectedCity(0);
                                                setSelectedUnit(0);
                                                setSelectedGroupType(-1);
                                                return true;
                                        }
                                }

                        }
                        // translate mouse position to world position
                        Vec2D pos = translateMiniMapToWorld(mouse);
                        GameState::camTarget().x = pos.x;
                        GameState::camTarget().y = pos.y;

                        return true;
                }
                else if( input_isMouseRBClicked() )
                {
                        // move units to point on minimap
                        Vec3D goalPos = translateMiniMapToWorld3D(mouse);
      // only move units within the map bounds
      if( GameState::worldMap().bounds.contains(Vec2D(goalPos.x, goalPos.y)) )
      {
        for(vector<MilitaryUnit*>::iterator iter = GameState::selectedUnits().begin(); iter != GameState::selectedUnits().end(); ++iter)
        {
          stringstream sstr;
          sstr << COMMAND_OVERHEAD << " " << COMMIT_TIME << " " << Globals::currGameTick + NETWORK_GAME_TICK_LAG << " " << COMMAND_GOAL << " "
            << (*iter)->uniqueID() << " " << Helper::serialize(goalPos);
          net_send(sstr.str());
          
        }
        if(GameState::selectedUnits().size() > 0) Sound::playRandomSound(Sound::CLASS_ACK);
        return true;
      }
                }
        }
        return false;
}

bool HUD::isButtonStopClicked()
{
        HUD& h = HUD::getObj();
        Vec2D mouse2D( input_getMouseX(), input_getMouseY() );
        return input_isMouseLBClicked() &&  h.m_iconStop.contains(mouse2D);
}

bool HUD::isButtonCallRFMUnitTypeClicked( int unitType )
{
        HUD& h = HUD::getObj();
        Vec2D mouse2D( input_getMouseX(), input_getMouseY() );
        if( !h.m_showCallRFMPanel ) return false;
        return input_isMouseLBClicked() &&  h.m_iconCallUnitType[unitType].contains(mouse2D);
}
//------------------------------------------------------------------------------------
namespace Overhead {
        void deleteMilitaryUnit(MilitaryUnit* unit);
}

void sendReinforcement( int unitType )
{
        HUD& h = HUD::getObj(); 
        if( !GameState::activeBattle() ) return;
        Vec2D battlePos( GameState::activeBattle()->getBattleLocation() );
        Vec3D playerCol( GameState::consolePlayer()->color() );
        for( UnitIter iter(GameState::units().begin()); iter!=GameState::units().end(); iter++ )
                if( (*iter)->color()==playerCol )
                        if( (*iter)->unitType()==unitType )
                        {
                                Vec2D unitPos( (*iter)->position().x, (*iter)->position().y );
                                if( math_dist2D(battlePos,unitPos) <= 100.0f )
                                {
                                        stringstream sstr;
                                        if( unitType==UnitTypes::JET )
                                        {
                                                sstr << COMMAND_SEND_JET_REINFORCEMENT << " " << COMMIT_TIME << " " << currGameTick + NETWORK_GAME_TICK_LAG
                                                        << " " << GameState::activeBattle()->uniqueID() << " " << (*iter)->uniqueID();
                                        } else
                                        {
                                                sstr << COMMAND_SEND_UNIT_REINFORCEMENT << " " << COMMIT_TIME << " " << currGameTick + NETWORK_GAME_TICK_LAG
                                                        << " " << GameState::activeBattle()->uniqueID() << " " << (*iter)->uniqueID();
                                        }
                                        net_send(sstr.str());
                                        return;
                                }
                        }
}
//------------------------------------------------------------------------------------
bool HUD::processOverheadInput()
{
        HUD& h = HUD::getObj();

  // adjust sound volume
  bool ctrl_down(input_isKeyDown(KeyCodes::key_LCONTROL) || input_isKeyDown(KeyCodes::key_RCONTROL));
  if(input_isKeyDown(KeyCodes::key_ADD) && !ctrl_down)
    Sound::increaseSongVol();
  if(input_isKeyDown(KeyCodes::key_SUBTRACT) && !ctrl_down) 
    Sound::decreaseSongVol();
  if(input_isKeyPressed(KeyCodes::key_ADD) && ctrl_down)
    Sound::increaseSFXVol();
  if(input_isKeyPressed(KeyCodes::key_SUBTRACT) && ctrl_down)
    Sound::decreaseSFXVol();


        Vec2D mouse2D( input_getMouseX(), input_getMouseY() );

        if( h.processMiniMapInput(mouse2D) ) return true;

        // process build menu
        if(h.m_pSelectedCity)
        {
                if(input_isMouseLBClicked() &&  h.m_iconBuildLT.contains(mouse2D)) 
                {
                        sendBuildMessage( COMMAND_BUILD_LIGHTTANK, h.m_pSelectedCity->uniqueID() );
                        return true;
                } 
                else if( input_isMouseLBClicked() && h.m_iconBuildHT.contains(mouse2D) ) 
                {
                        sendBuildMessage( COMMAND_BUILD_HEAVYTANK, h.m_pSelectedCity->uniqueID());
                        return true;
                } 
                else if( input_isMouseLBClicked() &&  h.m_iconBuildRL.contains(mouse2D) ) 
                {
                        sendBuildMessage( COMMAND_BUILD_ROCKET_LAUNCHER, h.m_pSelectedCity->uniqueID() );
                        return true;
                } 
                else if( input_isMouseLBClicked() && h.m_iconBuildAR.contains(mouse2D) ) 
                {
                        sendBuildMessage( COMMAND_BUILD_ARTILLERY, h.m_pSelectedCity->uniqueID() ); 
                        return true;
                } 
                else if(input_isMouseLBClicked() && h.m_iconBuildJT.contains(mouse2D)  ) 
                {
                        sendBuildMessage( COMMAND_BUILD_JET, h.m_pSelectedCity->uniqueID() );
                        return true;
                }
                else if(input_isMouseLBClicked() && h.m_iconUpgradeEcon.contains(mouse2D)  )            // upgrade econ
                {
                        sendBuildMessage( COMMAND_BUILD_ECON, h.m_pSelectedCity->uniqueID() );                  
                        return true;
                }               
        }
        else if( GameState::activeBattle() )
        {
                // switch to overhead mode
                if(input_isMouseLBClicked())
                {
                        if( h.m_iconOverhead.contains(mouse2D) )
                        {
                                h.switchToOverhead();
                                return true;
                        }

                        if( h.m_iconCallRFM.contains(mouse2D) )                                 // call Reinforcement
                        {
                                h.m_showCallRFMPanel = true;
                                h.setSelectedCity(NULL);
                                h.setSelectedGroupType(-1);
                                h.setSelectedUnit(NULL);
                                GameState::activeBattle()->clearUnitSelection();
                                return true;
                        }

                        // call Reinforcement
                        Vec3D &playerCol = (Vec3D) GameState::consolePlayer()->color();
                        bool mayGround = GameState::activeBattle()->maySendGroundReinforcement( playerCol );
                        bool mayAir    = GameState::activeBattle()->maySendAirReinforcement( playerCol );
                        bool allowed[5] = { mayGround, mayGround, mayGround, mayGround, mayAir };
                        for( int i=0; i<UnitTypes::COUNT; i++ )
                        if( isButtonCallRFMUnitTypeClicked(i) )
                        {
                                if( allowed[i] )  sendReinforcement(i);
                                return true;
                        }

                        if( h.m_selectedGroupType==UnitTypes::JET )                             // jet guard & bomb buttons
                        {
                                if( h.m_iconJetGuard.contains(mouse2D) ) return true;
                                if( h.m_iconJetBomb.contains(mouse2D) ) return true;
                        }
                }
        }

        // cycle through battles using CTRL+LEFT/RIGHT ARROW KEYS
        if( GameState::battles().size() > 0 )
        {
                if( (input_isKeyDown(KeyCodes::key_LCONTROL) || input_isKeyDown(KeyCodes::key_RCONTROL)) && input_isKeyPressed(KeyCodes::key_RIGHT) )
                {
                        h.switchToNextBattle();
                        return true;
                }
                else if ( (input_isKeyDown(KeyCodes::key_LCONTROL) || input_isKeyDown(KeyCodes::key_RCONTROL)) && input_isKeyPressed(KeyCodes::key_LEFT) )
                {
                        h.switchToPrevBattle();
                        return true;
                }
                else if( (input_isKeyDown(KeyCodes::key_LCONTROL) || input_isKeyDown(KeyCodes::key_RCONTROL)) &&  input_isKeyPressed(KeyCodes::key_UP) )
                {
                        h.switchToOverhead();
                        return true;
                }
        }
        return false;
}

void HUD::renderMiniMap()
{
        // draw minimap background
        overlay_rect(m_mapDims[0], m_mapDims[1], true, Colors::gray, BlendModes::NONE, 1.0f, ICON_RENDER_PRIORITY);

        // draw each city
        for(CityIter iter=GameState::cities().begin(); iter != GameState::cities().end(); ++iter)
        {
                Vec2D pos = translateWorldToMiniMap( (*iter)->position() );
                overlay_point(pos, m_mapCityOutlineSize, COLOR_CITY_OUTLINE, BlendModes::NONE, 1.0f, ICON_RENDER_PRIORITY);
                overlay_point(pos, m_mapCitySize, (*iter)->color(), BlendModes::NONE, 1.0f, 1+ICON_RENDER_PRIORITY);
        }
        // draw each unit
        for(UnitIter iter=GameState::units().begin(); iter != GameState::units().end(); ++iter)
        {
                // translate from absolute(world) to map coords
                Vec2D pos = translateWorldToMiniMap( (*iter)->position() );
                overlay_point(pos, m_mapUnitSize, (*iter)->color(), BlendModes::NONE, 1.0f, ICON_RENDER_PRIORITY);
        }
        // draw a symbol to show each battle
        for(BattleIter iter=GameState::battles().begin(); iter != GameState::battles().end(); ++iter)
        {
                //Vec2D pos = translateWorldToMiniMap(Vec2D((*iter)->getBattleLocation().x, (*iter)->getBattleLocation().y));
                Vec2D pos = translateWorldToMiniMap( (*iter)->getBattleLocation() );

                // only show battles that the player is fighting in
                if( (*iter)->isFoughtBy(m_pPlayer->color()) && m_blinkOn )
                {      
                        overlay_image(Globals::artWork->minimapBattleIcon, pos, Vec2D(0.03f,0.03f),
                                BlendModes::KEY, 1.0f, MOUSE_RENDER_PRIORITY);
                }
        }

}

void HUD::update()
{
        HUD& h = HUD::getObj();

        if(h.m_blinkCount++ > BLINK_RATE)
        {
                h.m_blinkOn = !h.m_blinkOn;
                h.m_blinkCount = 0;
        }
}


void HUD::render() 
{
        HUD& h = HUD::getObj();
        Vec2D mouse2D( input_getMouseX(), input_getMouseY() );

        // draw the background
        overlay_image(Globals::artWork->hud, Vec2D(0.5f,0.9f), Vec2D(1.0f, 0.2f), BlendModes::NONE, 1.0f, BG_RENDER_PRIORITY);

        // draw box to indicate player color
  overlay_rect(h.m_mapBorderStart, h.m_mapBorderEnd, false, h.m_pPlayer->color(), BlendModes::NONE, 1.0f, ICON_RENDER_PRIORITY);
        overlay_rect(h.m_actionsBorderStart, h.m_actionsBorderEnd, false, h.m_pPlayer->color(), BlendModes::NONE, 1.0f, ICON_RENDER_PRIORITY);
  overlay_rect(h.m_infoBorderStart, h.m_infoBorderEnd, false, h.m_pPlayer->color(), BlendModes::NONE, 1.0f, ICON_RENDER_PRIORITY);

        // draw the minimap
        h.renderMiniMap();

        // display amount of money in bank
        overlay_text() << "$" << h.m_pPlayer->bank().balance();
        overlay_textOut(Vec2D(h.m_moneyTextX, h.m_moneyTextY), h.m_moneyTextSize, h.m_moneyTextColor);

        if(h.m_pSelectedCity)
        {
                // econ data
                int econLevel = h.m_pSelectedCity->econLevel();
                int incomeRate = EconData::getObj().depositPerCity(econLevel) * 62 * 60 / EconData::getObj().depositInterval();
                overlay_text() << "Economics Level = " << econLevel << "\n";
                overlay_text() << "Generates $" << incomeRate << "/min";
                if( h.m_pSelectedCity->timeUntilFinishEconUpgrade()!=-1 )
                        overlay_text() << "\nUpgrading : " << h.m_pSelectedCity->timeUntilFinishEconUpgrade();
                
                overlay_textOut( Vec2D(h.m_econInfoTextX,h.m_econInfoTextY), 0.8f );

                // upgrading econ
                h.m_iconUpgradeEcon.render();
                h.m_iconUpgradeEcon.drawHelpString();
                if( h.m_iconUpgradeEcon.contains(mouse2D) )  h.m_iconUpgradeEcon.drawOutline(Colors::yellow);
                int cost = EconData::getObj().econUpgradeCost( h.m_pSelectedCity->econLevel() );
                if( cost <= 10000 )  overlay_text() << "$" << cost;
                else                             overlay_text() << "MAX";
                overlay_textOut( h.m_iconUpgradeEcon.bounds()[0]+Vec2D(0.002f,0.004f), h.m_iconTextSize, h.m_iconTextColor );

                // diplay build menu
                for(int i=0; i < ICON_COUNT; ++i)
                {
                        h.m_buildIcons[i]->render();
                        h.m_buildIcons[i]->drawHelpString();
                        // draw unit price
                        overlay_text() << "$" << EconData::getObj().unitAmount(i);
                        overlay_textOut(Vec2D(h.m_buildIcons[i]->bounds()[0].x + h.m_iconTextXOffset,
                                h.m_buildIcons[i]->bounds()[0].y + h.m_iconTextYOffset), 
                                h.m_iconTextSize, 
                                h.m_iconTextColor);
                        if( h.m_buildIcons[i]->contains(mouse2D) )  h.m_buildIcons[i]->drawOutline(Colors::yellow);                     
                }

                // display build queue 
                deque<int> q = h.m_pSelectedCity->trainees();
                int n=0;
                for(deque<int>::iterator it = q.begin(); it != q.end() && n < 9; ++it, ++n)
                        overlay_image(h.m_buildIcons[*it]->image(), 
                        h.m_buildQIconCoords[n], 
                        h.m_buildQIconSize, 
                        BlendModes::NONE, 
                        1.0f, 
                        ICON_RENDER_PRIORITY);

                // 62 == ticks per second
                if( !q.empty() )
                {
                        overlay_text() << static_cast<int>(h.m_pSelectedCity->trainingTimeLeft()/62);
                        overlay_textOut(h.m_buildQTimerCoords, h.m_buildQTimerTextSize, h.m_buildQTimerTextColor);
                }


        }
        else if(h.m_pSelectedUnit) 
        {
                overlay_image(h.m_portraits[h.m_pSelectedUnit->unitType()], 
                        h.m_infoPortraitCenter,
                        h.m_infoPortraitSize,
                        BlendModes::NONE,
                        1.0f,
                        ICON_RENDER_PRIORITY);
        }
        else if (h.m_selectedGroupType != -1) 
        {
                overlay_image(h.m_portraits[h.m_selectedGroupType], 
                        h.m_infoPortraitCenter,
                        h.m_infoPortraitSize,
                        BlendModes::NONE,
                        1.0f,
                        ICON_RENDER_PRIORITY);
        }

        // if we are in a battle show button to switch to overhead
        if( GameState::activeBattle() )
        {
                h.m_iconOverhead.render();
                h.m_iconCallRFM.render();
                h.m_iconOverhead.drawHelpString();
                h.m_iconCallRFM.drawHelpString();
                if( h.m_iconOverhead.contains(mouse2D) )  h.m_iconOverhead.drawOutline(Colors::yellow);
                if( h.m_iconCallRFM.contains(mouse2D) )   h.m_iconCallRFM.drawOutline(Colors::yellow );

                if( h.m_showCallRFMPanel )                                                              // Call Reinforcement Panel
                {
                        overlay_image( Globals::artWork->callRFMPanelTex, h.m_panelCallRFMCoord, h.m_panelCallRFMSize,
                                BlendModes::NONE, 1.0f, 6 );

                        int totalCallable = 0;
                        for( int i=0; i<5; i++ )                        // the 5 call unit type buttons
                        {
                                if( h.m_iconCallUnitType[i].contains(mouse2D) )  h.m_iconCallUnitType[i].drawOutline(Colors::yellow);
                                h.m_iconCallUnitType[i].drawHelpString();
                                totalCallable += GameState::availableRFM()[i];

                                // number of available RFM
                                Vec2D pos( h.m_iconCallUnitType[i].bounds()[0] + h.m_iconCallUnitType[i].bounds()[1] );
                                pos = pos * 0.5f + Vec2D( -0.002f, -0.001f );
                                overlay_text() << GameState::availableRFM()[i];
                                overlay_textOut( pos, 1.2f, Colors::yellow, NULL, 6 );
                        }

                        // callRFM description text                     
                        Vec3D &playerCol = (Vec3D)GameState::consolePlayer()->color();
                        bool mayGround = GameState::activeBattle()->maySendGroundReinforcement( playerCol );
                        bool mayAir    = GameState::activeBattle()->maySendAirReinforcement( playerCol );
                        if( totalCallable==0 )                  
                                overlay_text() << "No nearby friendly forces";                  
                        else if( !mayGround && !mayAir )
                                overlay_text() << "Too many units in battle already";
                        else if( !mayGround )
                                overlay_text() << "Too many tanks\n in battle already";
                        else if( !mayAir )
                                overlay_text() << "Too many jets\nin battle already";
                        else
                                overlay_text() << totalCallable << " Battalions Standing by";
                        overlay_textOut( h.cammRFMTextPos, 0.7f, Colors::red, NULL, 6 );


                        
                }

                // battle unit command
                if( h.m_selectedGroupType != -1 )                                       // stop button
                {
                        h.m_iconStop.render();
                        h.m_iconStop.drawHelpString();
                        if( h.m_iconStop.contains(mouse2D) )  h.m_iconStop.drawOutline(Colors::yellow);
                }
                if( h.m_selectedGroupType == UnitTypes::JET )                                   // jet guard, bomb buttons
                {
                        h.m_iconJetGuard.render();
                        h.m_iconJetGuard.drawHelpString();
                        if( h.m_iconJetGuard.contains(mouse2D) )  h.m_iconJetGuard.drawOutline(Colors::yellow);
                        h.m_iconJetBomb.render();
                        h.m_iconJetBomb.drawHelpString();
                        if( h.m_iconJetBomb.contains(mouse2D) )  h.m_iconJetBomb.drawOutline(Colors::yellow);
                }
        }
}


void HUD::setWorldMap(Map::WorldMap& map) 
{ 
        HUD& h = HUD::getObj();
        h.m_map = map; 
        h.m_miniMapScale.x = (h.m_mapDims[1].x - h.m_mapDims[0].x) / h.m_map.width;
        h.m_miniMapScale.y = (h.m_mapDims[1].y - h.m_mapDims[0].y) / h.m_map.height;
}

void HUD::clearSelections() 
{
        HUD::getObj().m_selectedGroupType = -1;
        HUD::getObj().m_pSelectedCity = 0;
        HUD::getObj().m_pSelectedUnit = 0;
}

void HUD::shutdown()
{
        HUD::getObj().releaseObj();
}


void HUD::switchToNextBattle()
{
        BattleIter currBattle;
        // find the active battle
        if( GameState::activeBattle() )
        {
                for(BattleIter iter = GameState::battles().begin(); iter != GameState::battles().end(); ++iter)
                {
                        if( (*iter) == GameState::activeBattle() )
                        {
                                currBattle = iter;
                                break;
                        }
                }
        }
        else
        {
                currBattle = GameState::battles().begin();
        }

        // treat the vector of battles as a circular queue
        // now get the next battle the player belongs to
        for(BattleIter iter=currBattle+1; iter != GameState::battles().end(); ++iter)
        {
                if( (*iter)->isFoughtBy(m_pPlayer->color()) )
                {
                        GameState::setActiveBattle(*iter);
                        return;
                }
        }
        // start from the beginning of the list and go up to current battle
        for(BattleIter iter=GameState::battles().begin(); iter != currBattle; ++iter)
        {
                if( (*iter)->isFoughtBy(m_pPlayer->color()) )
                {
                        GameState::setActiveBattle(*iter);
                        return;
                }
        }
        // current battle is the only battle this player is involved in
        if( (*currBattle)->isFoughtBy(m_pPlayer->color()) )
                GameState::setActiveBattle(*currBattle);
}

void HUD::switchToPrevBattle()
{
        BattleIter currBattle;
        // find the active battle
        if( GameState::activeBattle() )
        {
                for(BattleIter iter = GameState::battles().begin(); iter != GameState::battles().end(); ++iter)
                {
                        if( (*iter) == GameState::activeBattle() )
                        {
                                currBattle = iter;
                                break;
                        }
                }
        }
        else
        {
                currBattle = GameState::battles().end()-1;
        }

        // treat the vector of battles as a circular queue
        // now get the previous battle the player belongs to
        for(BattleIter iter=currBattle-1; iter >= GameState::battles().begin(); --iter)
        {
                if( (*iter)->isFoughtBy(m_pPlayer->color()) )
                {
                        GameState::setActiveBattle(*iter);
                        return;
                }
        }
        // start from the beginning of the list and go up to current battle
        for(BattleIter iter=GameState::battles().end()-1; iter != currBattle; --iter)
        {
                if( (*iter)->isFoughtBy(m_pPlayer->color()) )
                {
                        GameState::setActiveBattle(*iter);
                        return;
                }
        }
        // current battle is the only battle this player is involved in
        if( (*currBattle)->isFoughtBy(m_pPlayer->color()) )
                GameState::setActiveBattle(*currBattle);
}

void HUD::switchToOverhead()
{
        GameState::setActiveBattle(0);
        setSelectedCity(0);
        setSelectedUnit(0);
        setSelectedGroupType(-1);
}

---