---

City.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 "City.h"
#include "BattleUnitStat.h"
#include "EconData.h"
#include "Overhead.h"
#include "GameState.h"
#include "Sound.h"

namespace Overhead {
        void deleteMilitaryUnit(MilitaryUnit* unit);
        extern list<BattleSprite> battleCircleAnimation;
}

namespace {
        Vec3D citySize(8.0f, 8.0f, 8.0f);
        uint pointsNeededForaNewUnit(62*10);
}

City::City(const Vec3D & location, Player* theOwner ) : 
m_size(Vec3D(15.0f, 15.0f, 15.0)),
m_position(location),
m_color( (theOwner ? theOwner->color() : Globals::NO_OWNER) ),
m_rallyPoint(location),
m_trainees(),
m_timer(-1),
m_currUnitType(-1),
m_pOwner(theOwner),
m_timeOfLastDeposit(-5000),     // so that at the 1st game tick, everyone get exactly 1 deposit
// regardless of how long the game has been spinning before host starts
m_econLevel(1),
m_econRemainingTime(-1),
m_jetGaurdSize(0)
{
}

City::~City(void)
{
}

void City::draw(void) const
{
        using namespace Globals;
        mesh_render( artWork->city_mesh, this->m_position, citySize, Vec3D(0.0f,90.0f,0.0f), artWork->city_texture, 0, this->color() );
}

void City::drawSelectBox(void) const
{
        Vec3D pos = m_position;
        pos.z += 1.2f;
        FLOAT angle = (FLOAT)( (Globals::currGameTick*5) % 360 );
        mesh_render( artWork->circle, pos, Vec3D(13.0f,13.0f,0.001f), Vec3D(angle,0,0), artWork->colorGreen );

        // also draw the rally point
        Vec2D screenPoint = math_translateWorldToScreen(this->m_position + Vec3D(0.0f,0.0f,0.0f));
        Vec2D rp = math_translateWorldToScreen(m_rallyPoint);
        overlay_line(screenPoint, rp, Colors::red);
        overlay_text() << "Rally Point";
        overlay_textOut(rp, 1.0f, Colors::red);
}


void City::startEconUpgrade( int secToComplete )
{
        m_econRemainingTime = 62*secToComplete;
}

int City::timeUntilFinishEconUpgrade()
{
        if( m_econRemainingTime==-1 ) return -1;
        return m_econRemainingTime / 62;
}

int City::econLevel()
{
        return m_econLevel;
}

void City::upgradeEcon()
{
        if( !m_pOwner ) return;                                 // can't train unit from a neutral city
        if( m_econRemainingTime!=-1 ) return;   // already upgrading
        if( m_pOwner->bank().withdraw(EconData::getObj().econUpgradeCost(m_econLevel)) )
        {
                startEconUpgrade( EconData::getObj().econUpgradeTime(m_econLevel) );
        }
}

void City::update(void)
{
        m_position.z = terrain_getHeight( artWork->worldMap, m_position.x, m_position.y );

        DWORD currTime = Globals::currGameTick;
        if( m_pOwner && (currTime - m_timeOfLastDeposit  >= EconData::getObj().depositInterval()) )
        {
                m_pOwner->bank().deposit(Helper::maintenanceMultiplier(this->color(), EconData::getObj().depositPerCity(m_econLevel)));
                m_timeOfLastDeposit = currTime;
        }

        // check econ upgrades
        if(m_econRemainingTime>-1) m_econRemainingTime--;
        if( m_econRemainingTime==0 )
        {
                m_econRemainingTime = -1;
                if( m_econLevel<5 ) m_econLevel++;
        }

        // check timers for unit building
        if(m_timer > 0) --m_timer;
        else if (m_timer == 0)
        {
                // only play sounds if the unit being created is on the console players team
                switch(m_currUnitType)
                {
                case UnitTypes::LIGHT_TANK:
                        {
                                MilitaryUnit* mu = new LightTank(m_position, m_pOwner, DEFAULT_LIGHT_TANK_SIZE);
                                mu->goal(m_rallyPoint);
                                GameState::addMilitaryUnit(mu);
                                if(m_color == GameState::consolePlayer()->color())
                                        Sound::playRandomSound(Sound::CLASS_CREATE_LT);
                                break;
                        }
                case UnitTypes::HEAVY_TANK:
                        {
                                MilitaryUnit* mu = new HeavyTank(m_position, m_pOwner, DEFAULT_HEAVY_TANK_SIZE);
                                mu->goal(m_rallyPoint);
                                GameState::addMilitaryUnit(mu);
                                if(m_color == GameState::consolePlayer()->color())
                                        Sound::playRandomSound(Sound::CLASS_CREATE_HT);
                                break;
                        }
                case UnitTypes::LAUNCHER:
                        {
                                MilitaryUnit* mu = new RocketLauncher(m_position, m_pOwner, DEFAULT_ROCKET_LAUNCHER_SIZE);
                                mu->goal(m_rallyPoint);
                                GameState::addMilitaryUnit(mu);
                                if(m_color == GameState::consolePlayer()->color())
                                        Sound::playRandomSound(Sound::CLASS_CREATE_RT);
                        }
                        break;
                case UnitTypes::ARTILLERY:
                        {
                                MilitaryUnit* mu = new Artillery(m_position, m_pOwner, DEFAULT_ARTILLERY_SIZE);
                                mu->goal(m_rallyPoint);
                                GameState::addMilitaryUnit(mu);
                                if(m_color == GameState::consolePlayer()->color())
                                        Sound::playRandomSound(Sound::CLASS_CREATE_AR);
                                break;
                        }
                case UnitTypes::JET:
                        {                       
                                MilitaryUnit* mu = new Jet(m_position, m_pOwner, 12, (int)uniqueID() );
                                GameState::addMilitaryUnit(mu);
                                if(m_color == GameState::consolePlayer()->color())
                                        Sound::playRandomSound(Sound::CLASS_CREATE_JT);
                                break;
                        }
                default:
                        sys_console() << "Warning! Invalid unit given as UnitType when trying to have a city build a new unit.  Type:" 
                                << m_currUnitType << endl;
                }
                // so that we train the next unit
                m_trainees.pop_front();
                --m_timer;
        }
        else if( !m_trainees.empty() )
        {
                m_currUnitType = m_trainees.front();
                m_timer = EconData::getObj().unitTrainingTime(m_currUnitType);
        }

}

bool City::contains(Vec2D that) const
{
        Vec2D city2Dpos( math_translateWorldToScreen(m_position) );
        return math_dist2D( city2Dpos,that ) < 0.07f;
}

Vec3D City::position(void) const
{
        return m_position;
}

Player* City::owner(void) const
{
        return this->m_pOwner;
}

Vec3D City::color(void) const
{
        return m_color;
}

void City::changeOwner(Player* newOwner, bool taunting)
{
        Player* preOwner = m_pOwner;
        m_pOwner = newOwner;
        m_color = m_pOwner->color();
        //m_jetGaurdSize = 0;
        vector<MilitaryUnit*> toDelete;
        for(UnitIter unitIter(GameState::units().begin()); unitIter != GameState::units().end(); ++unitIter)
        {
                if ((*unitIter)->unitType() == UnitTypes::JET)  
                {
                        if ((*unitIter)->color() != this->color() && dynamic_cast<Jet*>((*unitIter))->getCityID() == this->uniqueID())
                        {
                                toDelete.push_back(*unitIter);
                        }
                }
        }
        for(UnitIter unitIter(toDelete.begin()); unitIter != toDelete.end(); ++unitIter)
        {
                Overhead::deleteMilitaryUnit(*unitIter);
        }
        if (taunting && preOwner)
        {
                Overhead::battleCircleAnimation.push_back( BattleSprite(this->position(), 60, BattleSpriteTypes::EXPLO_LARGE));
                Overhead::battleCircleAnimation.push_back( BattleSprite(this->position(), 100, BattleSpriteTypes::SMOKE_LARGE));
                stringstream sstr;
                if (preOwner->color() == Colors::white)
                {
                        sstr << Helper::playerColorToPlayerName(newOwner->color()) << " took over a neutral city";
                } else
                {
                        sstr << Helper::playerColorToPlayerName(newOwner->color()) << " says: ";
                        switch (sys_randInt() % 4)
                        {
                        case 0:
                                sstr << "I took over " << Helper::playerColorToPlayerName(preOwner->color()) << "'s city!";
                                break;
                        case 1:
                                sstr << "Another city mine! " << Helper::playerColorToPlayerName(preOwner->color()) << " is taking a woopin";
                                break;
                        case 2:
                                sstr << "Another city mine! " << Helper::playerColorToPlayerName(preOwner->color()) << " is getting a butt woopin";
                                break;
                        case 3:
                                sstr << "Some people are destined to loose! City's mine";
                                break;
                        default:
                                break;
                        }
                }
                GameState::messagesReceived().addMessage(sstr.str());
        }
}

bool City::collision(const MilitaryUnit* unit) const
{
        return ((this->m_position.x + citySize.x > unit->position().x) &&
                (this->m_position.x - citySize.x < unit->position().x) &&
                (this->m_position.y + citySize.y > unit->position().y) &&
                (this->m_position.y - citySize.y < unit->position().y));
}

void City::setRallyPoint(Vec3D rp) { m_rallyPoint = rp; }

Vec3D& City::rallyPoint() { return m_rallyPoint; }

void City::trainUnit(int type)
{
        if( !m_pOwner ) return;         // can't train unit from a neutral city
        if( m_pOwner->bank().withdraw(EconData::getObj().unitAmount(type)) )
        {
                if ((Helper::totalUnitsForPlayer(this->color()) + Helper::totalUnitsBeingBuiltForPlayer(this->color())) < MAX_UNITS_FOR_EACH_PLAYER)
                {
                        m_trainees.push_back(type);
                } else
                {
                        GameState::messagesReceived().addMessage("Cannot Build: Max unit limit reached");
                }
        } else if (this->color() == GameState::consolePlayer()->color())
        {
                GameState::messagesReceived().addMessage("Cannot Build: Not enough funds");
        }

}

const deque<int>& City::trainees() const { return m_trainees; }

int City::trainingTimeLeft() const { return m_timer; }

void City::addJetGaurd() { ++m_jetGaurdSize; }

void City::deleteJetGuard() 
{ 
        if (!(--m_jetGaurdSize >= 0))
        {
                sys_console() << WARNING << "!(--m_jetGaurdSize >= 0)" << endl;
                sys_flushConsole();
        }
}

int City::jetGaurdSize() { return m_jetGaurdSize; }

---