---

BattleEntry.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 "BattleEntry.h"
#include "Globals.h"
#include "HUD.h"
#include "GameState.h"
#include "Sound.h"
#include "Icon.h"

using namespace Globals;
using namespace NetworkMessages;

const int SELECT_JETS   =       100;    // if m_selected >= this number, it means we're actually
                                                                        // select jet group # m_selected - thisNumber
                                                                        // i.e. 103 = Jet group #3

//------------------------------------------------------------------------------------
BattleEntry::BattleEntry( const Vec3D teamAColor, const Vec3D teamBColor, const Vec2D location )
{
        m_teamAColor = teamAColor;
        m_teamBColor = teamBColor;
        m_location = location;

        m_camTarget = Vec3D(0.0f,0.0f,0.0f);
        m_camHeight = 100.0f;

        m_firstTime = true;
        m_selected = -1;
        m_winner = '?';

        BS = new BattleState();

        for( int i=0; i<9; i++ )  m_ctrlGroup[i] = -1;          // clear group assignment

        BS->m_cvLastContact     = 0;
        BS->m_cvLastStress      = 0;
        BS->m_cvLastPanick      = 0;

        m_rfmCalledA = m_rfmCalledB = 0;
        m_showBigMiniMap = true;
}
//------------------------------------------------------------------------------------
void BattleEntry::inputSelectGroups()
{
        Vec2D mousePos( input_getMouseX(), input_getMouseY() );
        Vec3D playerColor( GameState::consolePlayer()->color() );
        ControlMode mode = GameState::controlMode();

        if( input_isMouseLBClicked() && mousePos.y < 0.8f ) 
        {
                int groupAtCursor = getGroupAtPos2D(mousePos);
                if( groupAtCursor!=-1 )
                {                       
                        if( BS->groups[groupAtCursor].m_color==playerColor || mode==GOD )       // can only select your own units
                                m_selected = groupAtCursor;
                }
                else m_selected = -1;

                if( m_selected==-1 )
                        HUD::clearSelections();
                else
                {
                        if(m_selected < SELECT_JETS )  HUD::setSelectedGroupType( BS->groups[m_selected].m_unitType );
                        else                                               HUD::setSelectedGroupType(UnitTypes::JET);
                        Sound::playRandomSound( Sound::CLASS_SELECT );
                }
                        
        }
}
//------------------------------------------------------------------------------------
void BattleEntry::inputSelectJets()
{
        Vec3D playerColor( GameState::consolePlayer()->color() );
        Vec2D mousePos( input_getMouseX(), input_getMouseY() );

        if( input_isMouseLBClicked() && mousePos.x > 0.940f )
        {
                FLOAT yOffset = 0.2f;
                for( UINT i=0; i<BS->jets.size(); i++ )
                {
                        if( BS->jets[i].m_color!=playerColor ) continue;                                        // can only select your own jets

                        if( mousePos.y >= yOffset && mousePos.y <= yOffset+0.07f )
                        {
                                m_selected = i + SELECT_JETS;
                                break;
                        }
                        yOffset += 0.08f;
                }

                if(m_selected>=SELECT_JETS)  Sound::playRandomSound( Sound::CLASS_SELECT );
        }

        if(m_selected==-1 )                                     HUD::setSelectedGroupType(-1);
        else if(m_selected < SELECT_JETS )  HUD::setSelectedGroupType( BS->groups[m_selected].m_unitType );
        else                                                            HUD::setSelectedGroupType(UnitTypes::JET);
}
//------------------------------------------------------------------------------------
void BattleEntry::inputIssueGroupCommand()
{
        Vec2D mousePos( input_getMouseX(),input_getMouseY() );

        if( m_selected!=-1 && m_selected < SELECT_JETS)                                 // stop command 
                if( input_isKeyPressed(KeyCodes::key_S) || HUD::isButtonStopClicked() )
                {
                        ostringstream cmd;
                        cmd << COMMAND_BATTLEMODE << " " << COMMIT_TIME << " " << (currGameTick+NETWORK_GAME_TICK_LAG)
                                << " " << COMMAND_BATTLE_ID << " " << this->uniqueID();
                        if( net_amIServer() ) cmd << " A "; else cmd << " B ";
                        cmd << "Stop " << m_selected;
                        net_send(cmd.str());
                        return;
                }
        

        if( input_isMouseRBClicked() && m_selected!=-1 && m_selected < SELECT_JETS)
        {
                BattleGroup &G = BS->groups[m_selected];
                int targetGrp = getGroupAtPos2D(mousePos);
                Sound::playRandomSound( Sound::CLASS_ACK );

                ostringstream cmd;
                cmd << COMMAND_BATTLEMODE << " " << COMMIT_TIME << " " << (currGameTick+NETWORK_GAME_TICK_LAG)
                        << " " << COMMAND_BATTLE_ID << " " << this->uniqueID();
                if( net_amIServer() ) cmd << " A "; else cmd << " B ";

                if( targetGrp!=-1 && getTeamCode(targetGrp)!=getTeamCode(m_selected) )
                {
                        if( input_isKeyDown(KeyCodes::key_LCONTROL) || input_isKeyDown(KeyCodes::key_RCONTROL) )
                        {                                                                                                                                               // assign primary target command
                                cmd << "AssignTarget " << m_selected << ' ' << targetGrp;
                        }
                        else                                                                                                                                    // intercept command
                        {
                                cmd << "Intercept " << m_selected << ' ' << targetGrp;
                        }
                }
                else                                                                                                                                            // move command
                {
                        Vec3D pt = math_translateScreenToWorldPlane( mousePos, 0.0f );
                        
                        if( !input_isKeyDown(KeyCodes::key_LSHIFT) && !input_isKeyDown(KeyCodes::key_RSHIFT) )
                                cmd << "SetWaypoint "; else cmd << "AddWaypoint ";
                        cmd << m_selected << " ";
                        cmd << pt.x << " " << pt.y << " " << pt.z;                      
                }

                net_send(cmd.str());
        }
}
//------------------------------------------------------------------------------------
void BattleEntry::inputIssueJetsCommand()
{       
        Vec2D mousePos( input_getMouseX(),input_getMouseY() );
        int jSelected = m_selected - SELECT_JETS;
        if( jSelected<0 ) return;                                                       // the selected unit is not a jet

        ostringstream cmd;
        cmd << COMMAND_BATTLEMODE << " " << COMMIT_TIME << " " << (currGameTick+NETWORK_GAME_TICK_LAG)
                << " " << COMMAND_BATTLE_ID << " " << this->uniqueID();
        if( net_amIServer() ) cmd << " A "; else cmd << " B ";

        // stop & return home
        if( input_isKeyPressed(KeyCodes::key_S) || HUD::isButtonStopClicked() )
        {
                BattleJets &J = BS->jets[ jSelected ];
                if( J.getCurrentCommand()!=JetCommands::IDLE )
                {
                        Sound::playRandomSound( Sound::CLASS_ACK );
                        cmd << "JReturn " << jSelected;
                        net_send(cmd.str());
                        return;
                }
        }

        if( input_isMouseRBClicked() )
        {
                BattleJets &J = BS->jets[ jSelected ];
                int targetGrp = getGroupAtPos2D(mousePos);
                if( targetGrp!=-1 && getTeamCode(targetGrp)!=getTeamCode(m_selected) )          // bomb target
                {
                        if( J.isReadyForOrder() )
                        {
                                Sound::playRandomSound( Sound::CLASS_ACK );
                                cmd << "JBomb " << jSelected << ' ' << targetGrp;
                                net_send(cmd.str());                            
                        }
                        else if( J.getCurrentCommand()==JetCommands::BOMB )
                        {
                                Sound::playRandomSound( Sound::CLASS_ACK );
                                cmd << "JAssignNewBomb " << jSelected << ' ' << targetGrp;
                                net_send(cmd.str());                            
                        }
                }
                else                                                                                                                                            // guard area
                {
                        Vec3D pt = math_translateScreenToWorldPlane( mousePos, 0.0f );
                        pt.z += terrain_getHeight( BS->terrain, pt.x, pt.y ) + 5.0f;

                        if( J.isReadyForOrder() )
                        {
                                Sound::playRandomSound( Sound::CLASS_ACK );
                                cmd << "JGuard " << jSelected << ' ' << pt.x << ' ' << pt.y << ' ' << pt.z;
                                net_send(cmd.str());                            
                        }
                        else if( J.getCurrentCommand()==JetCommands::GUARD )
                        {
                                Sound::playRandomSound( Sound::CLASS_ACK );
                                cmd << "JAssignNewGuard " << jSelected << ' ' << pt.x << ' ' << pt.y << ' ' << pt.z;
                                net_send(cmd.str());                            
                        }
                }               
        }
}
//------------------------------------------------------------------------------------
void BattleEntry::inputCtrlGroup()
{
        if( input_isKeyDown(KeyCodes::key_LCONTROL) || input_isKeyDown(KeyCodes::key_RCONTROL) )
        {                                                               // assign group
                if( input_isKeyPressed(KeyCodes::key_0) ) m_ctrlGroup[0] = m_selected;
                if( input_isKeyPressed(KeyCodes::key_1) ) m_ctrlGroup[1] = m_selected;
                if( input_isKeyPressed(KeyCodes::key_2) ) m_ctrlGroup[2] = m_selected;
                if( input_isKeyPressed(KeyCodes::key_3) ) m_ctrlGroup[3] = m_selected;
                if( input_isKeyPressed(KeyCodes::key_4) ) m_ctrlGroup[4] = m_selected;
                if( input_isKeyPressed(KeyCodes::key_5) ) m_ctrlGroup[5] = m_selected;
                if( input_isKeyPressed(KeyCodes::key_6) ) m_ctrlGroup[6] = m_selected;
                if( input_isKeyPressed(KeyCodes::key_7) ) m_ctrlGroup[7] = m_selected;
                if( input_isKeyPressed(KeyCodes::key_8) ) m_ctrlGroup[8] = m_selected;
                if( input_isKeyPressed(KeyCodes::key_9) ) m_ctrlGroup[9] = m_selected;
        }
        else                                                    // select group
        {
                if( input_isKeyPressed(KeyCodes::key_0) ) m_selected = m_ctrlGroup[0];
                if( input_isKeyPressed(KeyCodes::key_1) ) m_selected = m_ctrlGroup[1];
                if( input_isKeyPressed(KeyCodes::key_2) ) m_selected = m_ctrlGroup[2];
                if( input_isKeyPressed(KeyCodes::key_3) ) m_selected = m_ctrlGroup[3];
                if( input_isKeyPressed(KeyCodes::key_4) ) m_selected = m_ctrlGroup[4];
                if( input_isKeyPressed(KeyCodes::key_5) ) m_selected = m_ctrlGroup[5];
                if( input_isKeyPressed(KeyCodes::key_6) ) m_selected = m_ctrlGroup[6];
                if( input_isKeyPressed(KeyCodes::key_7) ) m_selected = m_ctrlGroup[7];
                if( input_isKeyPressed(KeyCodes::key_8) ) m_selected = m_ctrlGroup[8];
                if( input_isKeyPressed(KeyCodes::key_9) ) m_selected = m_ctrlGroup[9];
        }
}
//------------------------------------------------------------------------------------
void BattleEntry::inputSelectByHotKey()
{
        if( input_isKeyPressed(KeyCodes::key_N) )               // next ground group
        {
                int N = (int) BS->groups.size();
                m_selected = (m_selected+1) % N;
                Vec3D playerCol( GameState::consolePlayer()->color() );
                while( BS->groups[m_selected].m_color!=playerCol || BS->groups[m_selected].m_numUnits<=0 )
                        m_selected = (m_selected+1) % N;
        }

        if( input_isKeyPressed(KeyCodes::key_J) )               // next jet group
        {
                m_selected = -1;
                Vec3D playerCol( GameState::consolePlayer()->color() );
                for( int i=0; i<(int)BS->jets.size(); i++ )
                {
                        BattleJets &J = BS->jets[i];
                        if( J.m_color==playerCol && J.getNumJets()>0 && J.isReadyForOrder() )
                        {
                                m_selected = SELECT_JETS + i;
                                return;
                        }
                }
        }
}
//------------------------------------------------------------------------------------
void BattleEntry::input()
{
  if(HUD::processOverheadInput()) return;

        Vec2D mousePos( input_getMouseX(), input_getMouseY() );

        // camera control
        m_camHeight = 10.0f + 130.0f * (1 - input_getMouseWheel());
        if( input_getMouseX()<0.02f ) m_camTarget.y += 2.5f;
        if( input_getMouseX()>0.98f ) m_camTarget.y -= 2.5f;
        if( input_getMouseY()<0.02f ) m_camTarget.x -= 2.5f;
        if( input_getMouseY()>0.98f ) m_camTarget.x += 2.5f;
        if( input_isKeyDown(KeyCodes::key_LEFT  ) ) m_camTarget.y += 5.5f;
        if( input_isKeyDown(KeyCodes::key_RIGHT ) ) m_camTarget.y -= 5.5f;
        if( input_isKeyDown(KeyCodes::key_UP    ) ) m_camTarget.x -= 5.5f;
        if( input_isKeyDown(KeyCodes::key_DOWN  ) ) m_camTarget.x += 5.5f;      

        // keep camera in battlefield area
        while( math_distPlanar3D(m_camTarget,Vec3D(0,45,0)) > 290.0f )
                m_camTarget = m_camTarget * 0.99f;
        Vec3D camPos( m_camTarget+Vec3D(60.0f+m_camHeight*0.4f,0.0f,30.0f+m_camHeight) );
        while( math_dist3D(camPos,Vec3D(0,45,0)) > 380.0f )
        {
                m_camHeight *= 0.99f;
                m_camTarget = m_camTarget * 0.991f;
                camPos = m_camTarget+Vec3D(60.0f+m_camHeight*0.4f,0.0f,30.0f+m_camHeight);
        }       

        camera_set( camPos, m_camTarget, 0 );

        if( input_isKeyPressed(KeyCodes::key_TAB) )  m_showBigMiniMap = !m_showBigMiniMap;  // battle minimap toggle    
        Box toggleButton;
        if( m_showBigMiniMap )  toggleButton = Box( 0.835f, 0.05f, 0.85f, 0.065f );
        else                                    toggleButton = Box( 0.135f, 0.65f, 0.15f, 0.665f );     
        if( input_isMouseLBClicked() && toggleButton.isContain(mousePos) ) m_showBigMiniMap = !m_showBigMiniMap;
        
        inputSelectGroups();                    // select group/jets
        inputSelectJets();
        inputCtrlGroup();
        inputSelectByHotKey();

        if( m_selected >= 0 && m_selected<SELECT_JETS )                                                         // de-select if selected group dies
                if( BS->groups[m_selected].m_numUnits<=0 ) m_selected = -1;
        if( m_selected >= SELECT_JETS )
                if( BS->jets[m_selected-SELECT_JETS].getNumJets() <= 0 ) m_selected = -1;
        
        inputIssueGroupCommand();
        inputIssueJetsCommand();
}
//------------------------------------------------------------------------------------
void BattleEntry::enQueueInput( string cmd )
{
        m_cmdQueue.push_back(cmd);
}
//------------------------------------------------------------------------------------
void BattleEntry::processQueuedInput()          // process commands in the queue
{       
        list<string>::iterator iter;
        for( iter=m_cmdQueue.begin(); iter!=m_cmdQueue.end();  )
        {
                string cmd = *iter;
                sys_console() << "BattleEntry::processQueuedInput:" << cmd << endl;
                istringstream strm(cmd.c_str());
                string msgType;
                string cmdType;
                char player;
                int tick;
                int groupNum, targetNum, jetNum;
                FLOAT x, y, z;

                strm >> msgType;
                assert(msgType==COMMAND_BATTLEMODE);
                string strBattleID;
                string commitTime;
                int battleID;
                strm >> commitTime >> tick >> strBattleID >> battleID >> player;

                if( tick > currGameTick ) { iter++; continue; }         
                
                assert(battleID == this->uniqueID() && "Invalid message");
                strm >> cmdType;

                if(cmdType=="SetWaypoint")
                {
                        strm >> groupNum >> x >> y >> z;                        
                        BS->groups[groupNum].m_waypoints.resize(0);
                        BS->groups[groupNum].addWaypoint(Vec3D(x,y,z));
                        BS->groups[groupNum].m_primaryTarget = -1;
                }
                else if( cmdType=="AddWaypoint")
                {
                        strm >> groupNum >> x >> y >> z;
                        BS->groups[groupNum].addWaypoint(Vec3D(x,y,z));
                        BS->groups[groupNum].m_primaryTarget = -1;
                }
                else if( cmdType=="AssignTarget" )
                {
                        strm >> groupNum >> targetNum;
                        BS->groups[groupNum].m_primaryTarget = targetNum;
                        BS->groups[groupNum].m_isChasePrimaryTarget = false;
                        BS->groups[groupNum].m_isStrictPrimaryTarget = true;
                }
                else if( cmdType=="Intercept" )
                {
                        strm >> groupNum >> targetNum;
                        BS->groups[groupNum].m_primaryTarget = targetNum;
                        BS->groups[groupNum].m_isChasePrimaryTarget = true;
                        BS->groups[groupNum].m_isStrictPrimaryTarget = true;
                }
                else if( cmdType=="JReturn" )
                {
                        strm >> jetNum;
                        BattleJets &J = BS->jets[jetNum];
                        if( J.getCurrentCommand()!=JetCommands::IDLE )
                                J.orderToReturn();
                }
                else if( cmdType=="JBomb" )
                {
                        strm >> jetNum >> targetNum;
                        BattleJets &J = BS->jets[jetNum];
                        if( J.isReadyForOrder() )                       
                                J.orderToBomb(targetNum);
                }
                else if( cmdType=="JAssignNewBomb" )
                {
                        strm >> jetNum >> targetNum;
                        BattleJets &J = BS->jets[jetNum];
                        if( J.getCurrentCommand()==JetCommands::BOMB )                  
                                J.assignNewBombingTarget(targetNum);                    
                }
                else if( cmdType=="JGuard" )
                {
                        strm >> jetNum >> x >> y >> z;
                        BattleJets &J = BS->jets[jetNum];
                        if( J.isReadyForOrder() )
                                J.orderToGuard(Vec3D(x,y,z));
                }
                else if( cmdType=="JAssignNewGuard" )
                {
                        strm >> jetNum >> x >> y >> z;
                        BattleJets &J = BS->jets[jetNum];
                        if( J.getCurrentCommand()==JetCommands::GUARD )                 
                                J.assignNewGuardTarget(Vec3D(x,y,z));
                }
                else if( cmdType=="Stop" )
                {
                        strm >> groupNum;
                        BattleGroup &G = BS->groups[groupNum];
                        G.m_waypoints.resize(0);
                        G.m_primaryTarget = -1;
                        G.m_isChasePrimaryTarget = false;
                        G.m_isStrictPrimaryTarget = false;
                }
                else
                {
                        sys_console() << WARNING << "Invalid command" << endl;
                        sys_flushConsole();
                }

                iter++;
                m_cmdQueue.pop_front();         
        }
}
//------------------------------------------------------------------------------------
void BattleEntry::initBattle()
{
        int offsetA = (int)teamAGroups.size()/2;
        int offsetB = (int)teamBGroups.size()/2;
        Vec3D offsetVecA = Vec3D( 100.0f, 100.0f, 0.0f );       // deploy forces in line formation
        Vec3D offsetVecB = Vec3D(-100.0f,-100.0f, 0.0f );
        Vec3D scaleVecA  = Vec3D( -35.0f,  35.0f, 0.0f );
        Vec3D scaleVecB  = Vec3D(  35.0f, -35.0f, 0.0f );
        Vec3D dirA = Vec3D( 225.0f, 90.0f, 0.0f );
        Vec3D dirB = Vec3D(  45.0f, 90.0f, 0.0f );
        
        for( int i=0; i<(int)teamAGroups.size(); i++ )
        {
                Vec3D pos = offsetVecA + (FLOAT)(i-offsetA)*scaleVecA;
                Int3Tuple &t = teamAGroups[i];
                if( t.a==UnitTypes::JET )
                        BS->jets.push_back( BattleJets( t.b, m_teamAColor, 'A', t.c) );
                else
                        BS->groups.push_back( BattleGroup( pos, dirA, 'A', m_teamAColor, t.a, t.b, t.c ) );
        }

        for( int i=0; i<(int)teamBGroups.size(); i++ )
        {
                Vec3D pos = offsetVecB + (FLOAT)(i-offsetB)*scaleVecB;
                Int3Tuple &t = teamBGroups[i];
                if( t.a==UnitTypes::JET )
                        BS->jets.push_back( BattleJets( t.b, m_teamBColor, 'B', t.c) );
                else
                        BS->groups.push_back( BattleGroup( pos, dirB, 'B', m_teamBColor, t.a, t.b, t.c ) );
        }

        BS->teamAColor = m_teamAColor;
        BS->teamBColor = m_teamBColor;
        BS->terrain = artWork->battleTerrains.at(0);
        sys_console() << "Battle Starts at tick = " << Globals::currGameTick << endl;

        // set BS pointer for all
        for( UINT i=0; i<BS->groups.size(); i++ )  BS->groups[i].BS = BS;
        for( UINT i=0; i<BS->jets.size(); i++ )    BS->jets[i].BS = BS;

        BS->synch_firstShotTick = -1;
        BS->synch_firstKillTick = -1;

        // start with camera on top of your own units
        if( GameState::consolePlayer()->color()==m_teamAColor )  m_camTarget = offsetVecA;
        else                                                                                                     m_camTarget = offsetVecB;
}
//------------------------------------------------------------------------------------
void BattleEntry::updateGroups()
{
        // move&rotate battle groups
        for( UINT i=0; i<BS->groups.size(); i++ )
        {
                BS->groups[i].moveBattleGroup();
                BS->groups[i].moveUnits();
                BS->groups[i].acquireGroupTargets();
                BS->groups[i].fire();
        }
}
//------------------------------------------------------------------------------------
void BattleEntry::updateJets()
{
        for( UINT i=0; i<BS->jets.size(); i++ )
                BS->jets[i].update();
}
//------------------------------------------------------------------------------------
void BattleEntry::updateBullets()
{
        // move bullets
        FLOAT bulletSpeed[4] = { 1.2f, 2.1f, 1.6f, 2.9f };
        FLOAT bulletHeight[4] = { 22.0f, 10.0f, 30.0f, 8.0f };
        for( int i=0; i<BS->bulletCount; i++ )
        {
                BattleBullet &b = BS->bullets[i];
                b.m_time++;             
                b.m_pos.x += bulletSpeed[b.m_type] * cosf( D3DXToRadian( b.m_dir[0] ));
                b.m_pos.y += bulletSpeed[b.m_type] * sinf( D3DXToRadian( b.m_dir[0] ));

                Vec3D delta = b.m_target - b.m_pos;                     // calc smooth-curve Z
                FLOAT dist = sqrtf( delta.x*delta.x + delta.y*delta.y);
                FLOAT zFactor = 0.5f-(dist/b.m_totalDist);
                if(zFactor<0) zFactor = -zFactor;
                b.m_pos.z =  b.m_firingZ + sqrtf(0.5f-zFactor) * bulletHeight[b.m_type];
                
                FLOAT deltaZ = b.m_target.z - b.m_firingZ;      // adjust for deltaZ between firing and target height
                b.m_pos.z += deltaZ * (1.0f - dist/b.m_totalDist);

                if( b.m_type==BulletTypes::ROCKET )                     // create rocket trails
                        BS->sprites.push_back( BattleSprite( b.m_pos, 15, BattleSpriteTypes::ROCKET_TRAIL ));

                if( b.m_type==BulletTypes::ANTIAIR)                     // create antiair rocket trails
                        BS->sprites.push_back( BattleSprite( b.m_pos, 15, BattleSpriteTypes::ROCKET_TRAIL ));

                // destroy bullet upon impact           
                if( dist < 3.0f )
                {
                        if( b.m_targetGroup==-1 )                                                               // bullet not directed at any particular group
                        {
                                if( b.m_type==BulletTypes::ANTIAIR )
                                {
                                        for( UINT i=0; i<BS->jets.size(); i++ )
                                                if( BS->jets[i].m_team!=b.m_team )
                                                        BS->jets[i].takeHit(b);
                                }
                                else
                                {
                                        for( UINT i=0; i<BS->groups.size(); i++ ) BS->groups[i].takeHit(b);     
                                }
                        }
                        else if( b.m_type!=BulletTypes::ANTIAIR )
                                BS->groups[ b.m_targetGroup ].takeHit(b);                       // directed at a single group

                        BS->bulletCount--;
                        BS->bullets[i] = BS->bullets[BS->bulletCount];
                        i--;                    // redo this same spot
                }
        }
}
//------------------------------------------------------------------------------------
void BattleEntry::updateParticles()
{
        updateParticleList(BS->sprites);
}
//------------------------------------------------------------------------------------
void BattleEntry::updateDebris()
{
        for( list<BattleDebris>::iterator iter = BS->debris.begin(); iter!=BS->debris.end(); )
        {
                BattleDebris &d = (*iter);
                d.pos += d.speed;
                d.speed.z -= 0.003f;
                d.dir += d.dirSpeed;

                if( sys_randInt()%5==0 )  BS->sprites.push_back( BattleSprite( d.pos, 20, BattleSpriteTypes::EXPLO_SMALL ));
                if( sys_randInt()%12==0 )  BS->sprites.push_back( BattleSprite( d.pos, 60, BattleSpriteTypes::SMOKE_SMALL ));

                if( d.pos.z < terrain_getHeight(BS->terrain, d.pos.x, d.pos.y) )
                {
                         list<BattleDebris>::iterator toDel(iter);
                         iter++;
                         BS->debris.erase(toDel);
                }
                else
                        iter++;
        }
}
//------------------------------------------------------------------------------------
void BattleEntry::update()
{
        if(m_firstTime)                                 // first time init
        {
                m_firstTime = false;
                initBattle();
        }

        processQueuedInput();

        updateGroups();
        updateJets();
        updateBullets();
        updateParticles();
        updateDebris();

        BS->m_cvLastContact++;
        BS->m_cvLastStress++;
        BS->m_cvLastPanick++;
}
//------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------
char BattleEntry::getTeamCode(int selected)
{
        if( selected==-1 ) return '-';
        if( selected < SELECT_JETS )    return BS->groups[selected].m_team;     
        else                                                    return BS->jets[selected-SELECT_JETS].m_team;
}
//------------------------------------------------------------------------------------
int BattleEntry::getGroupAtPos2D( Vec2D pos )
{
        int s = -1;
        for( UINT i=0; i<BS->groups.size(); i++ )
                if( BS->groups[i].m_numUnits > 0 )
                {
                        if( BS->groups[i].isContain2DPoint(pos) )
                        {
                                s = i;
                                break;
                        }
                }
        return s;
}
//------------------------------------------------------------------------------------
void BattleEntry::renderEnvironment()
{
        // terrain
        terrain_render( BS->terrain, artWork->terrainTexLow, artWork->terrainTexHigh,           //terrain
                                        artWork->terrainTexNormal );

        // sky
        mesh_render( artWork->skyMesh, Vec3D(0.0f,0.0f,0.0f), Vec3D(750.0f,750.0f,650.0f),      // sky
                                                           Vec3D(0.0f,0.0f,0.0f), artWork->skyTexture );

        // trees & rock
        const Vec3D dir(0,0,0);
        const Vec3D treeSize(1.9f,1.9f,5.0f);
        const Vec3D rockSize(2.4f,2.4f,1.1f);
        const Vec4D shadowMult(1,1,1,0.25f);
        Vec3D shadowVec(0.0f,0.0f,1.1f);

        for( int i=0; i<MAX_TREE; i++ )
        {
                mesh_render( artWork->envTreeMesh, artWork->trees[i], treeSize, dir, artWork->envTreeTex );
                sprite_add(artWork->shadow, BlendModes::MIX, artWork->trees[i]+shadowVec, shadowMult, 4.5f );
        }
        for( int i=0; i<MAX_ROCK; i++ )
                mesh_render( artWork->envRockMesh, artWork->rocks[i], rockSize, dir, artWork->envRockTex );
}
//------------------------------------------------------------------------------------
void BattleEntry::renderGroups()
{       
        for( UINT i=0; i<BS->groups.size(); i++ ) BS->groups[i].render();

        if( m_selected >= 0 && m_selected < SELECT_JETS )                                                                       // selected group
        {
                BattleGroup &G = BS->groups[m_selected];
                Vec3D pt3D( G.m_pos );
                pt3D.z += terrain_getHeight(BS->terrain, pt3D.x, pt3D.y );
                Vec2D pt2D = math_translateWorldToScreen( pt3D );               
                G.drawOutlineBox( G.m_color );
        }
}
//------------------------------------------------------------------------------------
void BattleEntry::renderJets()
{
        Vec3D playerColor( GameState::consolePlayer()->color() );
        FLOAT yOffset = 0.2f;
        for( UINT i=0; i<BS->jets.size(); i++ )         // jets
        {
                BS->jets[i].render();

                if( BS->jets[i].m_color!=playerColor ) continue;                                        // can only select your own jets

                BS->jets[i].renderIcon(yOffset);
                if( i == m_selected - SELECT_JETS )
                {
                        Vec2D pt1( 0.940f, yOffset );
                        Vec2D pt2( 0.999f, yOffset+0.07f );
                        overlay_rect( pt1, pt2, false, Colors::yellow );
                }
                yOffset += 0.08f;
        }
}
//------------------------------------------------------------------------------------
void BattleEntry::renderBullets()
{
        AMesh bulletMesh[4] = { artWork->battleShellMesh,  artWork->battleRocketMesh,
                                                        artWork->battleICBMMesh,   artWork->battleRocketMesh   };
        Vec3D bulletSize[4] = { Vec3D(2.0f,1.0f,1.0f), Vec3D(3.5f,1.5f,1.5f),
                                                        Vec3D(6.0f,2.0f,2.0f), Vec3D(3.0f,1.2f,1.2f)  };
        for( int i=0; i<BS->bulletCount; i++ )
        {               
                BattleBullet &b = BS->bullets[i];
                mesh_render( bulletMesh[b.m_type], b.m_pos, bulletSize[b.m_type], b.m_dir, artWork->battleBulletTexture );
        }
}
//------------------------------------------------------------------------------------
void BattleEntry::renderParticles()
{
        renderParticleList(BS->sprites);        
}
//------------------------------------------------------------------------------------
void BattleEntry::renderDebris()
{
        AMesh debrisMesh[2] = { artWork->debris1, artWork->debris2 };
        Vec3D debrisSize[2] = { Vec3D(2.5f,2.5f,2.5f), Vec3D(0.7f,1.9f,1.9f) };
        for( list<BattleDebris>::iterator iter = BS->debris.begin(); iter!=BS->debris.end(); iter++ )
        {
                mesh_render( debrisMesh[iter->type], iter->pos, debrisSize[iter->type],
                                         Vec3D(iter->dir,0,0), artWork->debrisTex );
        }
}
//------------------------------------------------------------------------------------
void BattleEntry::renderInterface()
{
        FLOAT mx = input_getMouseX(), my = input_getMouseY();                                           // mouse cursor
        Vec2D mousePos(mx,my);
        overlay_image( Globals::artWork->mouse, Vec2D(mx+0.025f,my+0.025f), Vec2D(0.05f,0.05f), BlendModes::ADD, 0.5f );
        overlay_image( Globals::artWork->mouse, Vec2D(mx+0.025f,my+0.025f), Vec2D(0.05f,0.05f), BlendModes::KEY, 1.0f, MOUSE_RENDER_PRIORITY );

        if( m_selected != -1 )                          // if you have your own unit selected and hover the cursor on the enemy
        {                                                                       // i.e. about to order an attack command, highlight the enemy
                int target = getGroupAtPos2D(mousePos);
                if( target!=-1 && getTeamCode(m_selected) != getTeamCode(target) )
                {
                        BattleGroup &G = BS->groups[target];
                        G.drawOutlineBox( G.m_color );
                }
        }

        // range indicator
        if( m_selected != -1 && m_selected < SELECT_JETS )
        {
                Vec3D grpPos3D( BS->groups[m_selected].m_pos );
                Vec2D grpPos2D( math_translateWorldToScreen( grpPos3D ) );
                Vec3D targetPos3D( math_translateScreenToWorldPlane( mousePos, 0.0f ) );
                overlay_line( mousePos, grpPos2D, Colors::white, BlendModes::ADD, 0.25f );              
                FLOAT dist = math_distPlanar3D( grpPos3D, targetPos3D ) * 0.04f;                
                dist = ((int)(dist*100.0f)) / 100.0f;
                overlay_text() << dist << " miles";
                overlay_textOut( mousePos+Vec2D(0,0.05f) );
        }       
}
//------------------------------------------------------------------------------------
void BattleEntry::renderMiniMap()
{
        Vec2D mousePos( input_getMouseX(), input_getMouseY() ); 
        FLOAT ptSize, lineLen;
        Vec2D UL, LR;           // up-left, low-right corner
        if( m_showBigMiniMap )
        {
                UL = Vec2D( 0.15f, 0.05f );
                LR = Vec2D( 0.85f, 0.75f );
                ptSize = 4.0f;
                lineLen = 0.060f;
        }
        else
        {
                UL = Vec2D( 0.0f, 0.65f );
                LR = Vec2D( 0.15f, 0.8f );
                ptSize = 1.0f;
                lineLen = 0.015f;
        }
        Vec2D UR( LR.x, UL.y ); 

        overlay_rect(  UL, LR, true, Colors::gray, BlendModes::MIX, 0.3f, 2 );                                  // background
        overlay_rect(  UR, UR+Vec2D(-0.015f,0.015f), true, Colors::gray, BlendModes::MIX, 0.4f, 3 );
        overlay_rect(  UR, UR+Vec2D(-0.015f,0.015f), false, Colors::gray, BlendModes::MIX, 0.6f, 3 );

        // if mouse over the map toggle button
        Icon toggleIcon;        
        if( m_showBigMiniMap )  toggleIcon = Icon( Vec2D(0.835f,0.05f), Vec2D(0.85f,0.065f), NULL );
        else                                    toggleIcon = Icon( Vec2D(0.135f,0.65f), Vec2D(0.15f,0.665f), NULL );
        toggleIcon.setHelpString("Toggle Battle MiniMap\nHotKey[Tab]");
        if( toggleIcon.contains(mousePos) ) toggleIcon.drawOutline(Colors::yellow);
        toggleIcon.drawHelpString();
        
        for( int i=0; i<(int)BS->groups.size(); i++ )                                   // ground forces
        {
                BattleGroup &G = BS->groups[i];
                if( G.m_numUnits<=0 ) continue;
                Vec2D pos2D( G.m_pos.x, G.m_pos.y );
                Vec2D pt( pos2D*(1.0f/800.0f) + Vec2D(0.5f,0.5f) );
                swap( pt.x, pt.y );
                pt.x = 1.0f - pt.x;
                pt.x = pt.x * ( LR.x - UL.x );
                pt.y = pt.y * ( LR.y - UL.y );          
                pt += UL;
                overlay_point( pt, ptSize, G.m_color, BlendModes::MIX, 0.7f, 4 );
                
                FLOAT theta = D3DXToRadian( G.m_dir.x );
                Vec2D dirVec( lineLen*(-sinf(theta)), lineLen*cosf(theta) );
                overlay_line( pt, pt+dirVec, G.m_color, BlendModes::MIX, 0.7f, 5 );

                if( m_showBigMiniMap )          // type letter only shows in big map
                {
                        char letters[4] = { 'L','H','R','A' };
                        overlay_text() << G.m_numUnits << letters[G.m_unitType];
                        overlay_textOut( pt+Vec2D(-0.001f,-0.001f), 0.6f, Colors::white, NULL, 5 );
                }
        }

        for( int i=0; i<(int)BS->jets.size(); i++ )                                             // jets
        {
                BattleJets &G = BS->jets[i];
                if( G.getNumJets()<=0 ) continue;
                Vec2D pos2D( G.m_pos.x, G.m_pos.y );
                if( !Box(-400.0f,-400.0f,400.0f,400.0f).isContain(pos2D) )  continue;           
                Vec2D pt( pos2D*(1.0f/800.0f) + Vec2D(0.5f,0.5f) );
                swap( pt.x, pt.y );
                pt.x = 1.0f - pt.x;
                pt.x = pt.x * ( LR.x - UL.x );
                pt.y = pt.y * ( LR.y - UL.y );          
                pt += UL;
                overlay_point( pt, ptSize, G.m_color, BlendModes::MIX, 0.7f, 4 );
                
                FLOAT theta = D3DXToRadian( G.m_dir.x );
                Vec2D dirVec( lineLen*(-sinf(theta)), lineLen*cosf(theta) );
                overlay_line( pt, pt+dirVec, G.m_color, BlendModes::MIX, 0.7f, 5 );

                if( m_showBigMiniMap )          // type letter only shows in big map
                {                       
                        overlay_text() << G.getNumJets() << 'J';
                        overlay_textOut( pt+Vec2D(-0.001f,-0.001f), 0.6f, Colors::white, NULL, 5 );
                }
        }
}
//------------------------------------------------------------------------------------
void BattleEntry::render()
{
        if(m_firstTime) return;

        flare_begin( artWork->flareTexture, 512 );

        renderEnvironment();
        renderGroups();
        renderJets();
        renderBullets();
        renderParticles();
        renderDebris();
        renderInterface();
        renderMiniMap();

        overlay_text() << "Battle Mode";
        overlay_textOut( Vec2D(0.3f,0.01f), 3.0f, Colors::red );

        flare_end();
}
//------------------------------------------------------------------------------------
bool BattleEntry::isBattleFinished()
{       
        if(m_winner!='?') return true;

        // count the number of units each side has remaining.  If one side has 0 units, he loses
        int countA, countB;
        countA = countB = 0;
        for( UINT i=0; i<BS->groups.size(); i++ )
        {
                BattleGroup &g = BS->groups[i];
                if( g.m_team=='A' ) countA += g.m_numUnits;
                else                            countB += g.m_numUnits;
        }

        if( countA>0 && countB>0 ) return false;

        HUD::clearSelections();
        if( countA==0 )  m_winner = 'B';
        else                     m_winner = 'A';

        teamAGroups.resize(0);          // get rid of all the input groups
        teamBGroups.resize(0);          // we'll calculate the survivors and put in the right values
        for( UINT i=0; i<BS->groups.size(); i++ )
        {
                BattleGroup &g = BS->groups[i];
                if( g.m_numUnits > 0 )
                        if( g.m_team=='A' )  teamAGroups.push_back( Int3Tuple( g.m_unitType, g.m_numUnits, g.m_overheadForceNumber ) );
                        else                             teamBGroups.push_back( Int3Tuple( g.m_unitType, g.m_numUnits, g.m_overheadForceNumber ) );
        }

        // put the surviving jets back in
        for( UINT i=0; i<BS->jets.size(); i++ )
        {
                BattleJets &J = BS->jets[i];
                if( J.getNumJets()>0 )
                        if( J.m_team=='A' ) teamAGroups.push_back( Int3Tuple( UnitTypes::JET, J.getNumJets(), J.m_cityID ) );
                        else                            teamBGroups.push_back( Int3Tuple( UnitTypes::JET, J.getNumJets(), J.m_cityID ) );
        }

        sys_console() << "Battle Finishes at tick = " << Globals::currGameTick << endl;

        return true;
}
//------------------------------------------------------------------------------------
vector<Int3Tuple> BattleEntry::getSurvivors()
{
        if( teamAGroups.size()==0 ) return teamBGroups;
        else return teamAGroups;
}
//------------------------------------------------------------------------------------
Vec3D BattleEntry::getWinningTeamColor()
{
        if(m_winner=='B')
                return m_teamBColor;
        else
                return m_teamAColor;
}
//------------------------------------------------------------------------------------
Vec2D BattleEntry::getBattleLocation()
{
        return m_location;
}
//------------------------------------------------------------------------------------
bool BattleEntry::isFoughtBy(const Vec3D& teamColor) const
{
  return teamColor == m_teamAColor || teamColor == m_teamBColor;
}
//------------------------------------------------------------------------------------
int BattleEntry::countGroupsBelongingToPlayer( Vec3D playerColor )
{
        int count = 0;
        for( UINT i=0; i<BS->groups.size(); i++ )                                               // ground
        {
                BattleGroup &G = BS->groups[i];
                if( G.m_color == playerColor && G.m_numUnits > 0 )
                        count++;
        }
        for( UINT i=0; i<BS->jets.size(); i++ )                                                 // air
        {
                BattleJets &G = BS->jets[i];
                if( G.m_color == playerColor && G.getNumJets() > 0 )
                        count++;
        }
        return count;
}
//------------------------------------------------------------------------------------
bool BattleEntry::maySendGroundReinforcement( Vec3D playerColor )
{
        //if( playerColor==m_teamAColor && m_rfmCalledA >= 8 ) return false;    // no more than 8 reinforcement calling
        //if( playerColor==m_teamBColor && m_rfmCalledB >= 8 ) return false;

        int count = 0;
        for( UINT i=0; i<BS->groups.size(); i++ )
        {
                BattleGroup &G = BS->groups[i];
                if( G.m_color == playerColor && G.m_numUnits > 0 )
                        count++;
        }

        if( count >= 8 ) return false;          // no more than 8 ground groups at once
        return true;
}
//------------------------------------------------------------------------------------
bool BattleEntry::maySendAirReinforcement( Vec3D playerColor )
{
        //if( playerColor==m_teamAColor && m_rfmCalledA >= 8 ) return false;    // no more than 8 reinforcement calling
        //if( playerColor==m_teamBColor && m_rfmCalledB >= 8 ) return false;

        int count = 0;
        for( UINT i=0; i<BS->jets.size(); i++ )
        {
                BattleJets &G = BS->jets[i];
                if( G.m_color == playerColor && G.getNumJets() > 0 )
                        count++;
        }

        if( count >= 4 ) return false;          // no more than 4 jets at once
        return true;
}
//------------------------------------------------------------------------------------
void BattleEntry::sendGroundReinforcement( Vec3D playerColor, int unitType, int numUnits, int forceNum )
{
        char team;      
        Vec3D pos, dir;

        int offsetA = 4;                                // data required to calc reinforcement deploying position
        int offsetB = 4;
        Vec3D offsetVecA = Vec3D( 130.0f, 130.0f, 0.0f );       // deploy forces in line formation
        Vec3D offsetVecB = Vec3D(-130.0f,-130.0f, 0.0f );
        Vec3D scaleVecA  = Vec3D( -32.0f,  32.0f, 0.0f );
        Vec3D scaleVecB  = Vec3D(  32.0f, -32.0f, 0.0f );
        Vec3D dirA = Vec3D( 225.0f, 90.0f, 0.0f );
        Vec3D dirB = Vec3D(  45.0f, 90.0f, 0.0f );

        if( playerColor==m_teamAColor )
        {
                team = 'A';
                pos = offsetVecA + (FLOAT)(m_rfmCalledA-offsetA)*scaleVecA;
                dir = dirA;
                m_rfmCalledA = (m_rfmCalledA + 1) % 8;
        }
        else
        {
                team = 'B';
                pos = offsetVecB + (FLOAT)(m_rfmCalledB-offsetB)*scaleVecB;
                dir = dirB;
                m_rfmCalledB = (m_rfmCalledB + 1) % 8;
        }

        BS->groups.push_back( BattleGroup( pos, dir, team, playerColor, unitType, numUnits, forceNum ) );
        BS->groups[ BS->groups.size()-1 ].BS = BS;
}
//------------------------------------------------------------------------------------
void BattleEntry::sendAirReinforcement( Vec3D playerColor, int numJets, int homeTown )
{
        char team;
        if( playerColor==m_teamAColor )
        {
                m_rfmCalledA++;
                team = 'A';
        }
        else
        {
                m_rfmCalledB++;
                team = 'B';
        }
        BS->jets.push_back( BattleJets( numJets, playerColor, team, homeTown) );
        BS->jets[ BS->jets.size()-1 ].BS = BS;  
}
//------------------------------------------------------------------------------------
bool BattleEntry::contains(Vec3D pt)
{
        Vec3D myLocation(this->getBattleLocation().x, this->getBattleLocation().y, BATTLE_CIRCLE_HEIGHT);
        if (math_dist3D(pt, myLocation) < BATTLE_RADIUS / 2.0f) return true;
        else return false;
}
//------------------------------------------------------------------------------------
void BattleEntry::clearUnitSelection()
{
        m_selected = -1;
}
//------------------------------------------------------------------------------------

---