---

AI.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 "AI.h"
#include "globals.h"
#include <utility>

namespace AI
{
  typedef vector<City*>::iterator CityIter;
  typedef vector<MilitaryUnit*>::iterator UnitIter;

  //-- PUBLIC 

  
  Player::Player(const Vec3D teamColor,
                 vector<MilitaryUnit*>  &units, 
                 vector<City*> &cities,
                 Map::WorldMap wm)      :        m_teamColor(teamColor),        
                                       m_units(units),
                                       m_cities(cities),
                                       m_threatMap(wm.gridWidth, vector<FLOAT>(wm.gridHeight)),
                                       m_worldMap(wm) 
  {
    //clearThreatMap();
  }
  

  
  void Player::update() 
  {
    buildThreatMap();

    // build list of units i own
    //                     access to each list of units.
    vector<MilitaryUnit*> myUnits;
    UnitIter unitIter;
    for(unitIter = m_units.begin(); unitIter != m_units.end(); ++unitIter)
    {
      if( (*unitIter)->color() == m_teamColor ) myUnits.push_back((*unitIter));
    }

    // find least threatened neutral city
    vector<City*> neutralCities;
    vector<City*> enemyCities;
    CityIter cityIter;
    for(cityIter = m_cities.begin(); cityIter != m_cities.end(); ++cityIter)
    {
      if( (*cityIter)->color() == Globals::NO_OWNER ) 
        neutralCities.push_back(*cityIter);
      else if( (*cityIter)->color() != m_teamColor )
        enemyCities.push_back(*cityIter);
    }

    if( !neutralCities.empty() )
    {
      // sort cities by their threatened valued. less threatened cities first
      sort(neutralCities.begin(), neutralCities.end(), CityLessThreatened(m_threatMap, m_worldMap) );
      // send units to the cities
      size_t numCities = neutralCities.size();
      size_t city;
      for(unitIter = myUnits.begin(), city=0; (unitIter != myUnits.end()) && city < numCities; ++unitIter, ++city)
      {
            if(!(*unitIter)->isIdle()) (*unitIter)->goal( neutralCities[city]->position() );
      }

    }
    // send the units to the enemy cites
    else
    {
      // sort cities by their threatened valued. less threatened cities first
      sort(enemyCities.begin(), enemyCities.end(), CityLessThreatened(m_threatMap, m_worldMap) );
      // send the two closest units to each of the cities
      //size_t numCities = enemyCities.size();
      //size_t city;
      //for(unitIter = myUnits.begin(), city=0; (unitIter != myUnits.end()) && city < numCities; ++unitIter, ++city)
      //{
      //  if( (*unitIter)->currState != MilitaryUnit::BUSY )
      //    (*unitIter)->goal( enemyCities[city]->position() );
      //}
      for(cityIter = enemyCities.begin(); cityIter != enemyCities.end(); ++cityIter)
      {
        sendUnitsToCity(myUnits, *cityIter);
      }
    }

  }
  

  
  Vec3D Player::color() const   {       return m_teamColor;     }
  
  const ThreatMap &Player::threatMap() { return m_threatMap; }
  


  //-- PRIVATE

  Player::CityLessThreatened::CityLessThreatened(ThreatMap &tm, Map::WorldMap &wm):
    m_threatMap(tm), m_worldMap(wm) { }

  // compare the grid cells of each city and see if c1 is in less threatened cell than c2
  BOOL Player::CityLessThreatened::operator ()(City *c1, City *c2) const
  {
    Int2Tuple c1Coords = m_worldMap.worldToGridCoord(c1->position());
    Int2Tuple c2Coords = m_worldMap.worldToGridCoord(c2->position());
    return m_threatMap[c1Coords.a][c1Coords.b] < m_threatMap[c2Coords.a][c2Coords.b];
  }

  
  void Player::clearThreatMap()
  {
    for(int     i=0; i < m_worldMap.gridHeight; ++i)
      for(int   j=0; j < m_worldMap.gridWidth;  ++j)
                          m_threatMap[i][j] = 0.0f;
  }
  
  
  
  // for now just find out which tile an enemy unit is in and increment the corresponding
  // cell in the threat map.
  void Player::buildThreatMap()
  {
    clearThreatMap();   
    for(UnitIter iter=m_units.begin(); iter != m_units.end(); ++iter)
    {
      
      // dont calculate my units
      if( (*iter)->color() != m_teamColor )
      {
        // a unit should have a great affect on the grid cell its in and 
        // a lesser affect to each neighbor cell. so increment the containing cell twice.
        Int2Tuple gridCoord = m_worldMap.worldToGridCoord((*iter)->position());
        m_threatMap[gridCoord.a][gridCoord.b] += AI::unitThreatIncr;
        // calculate value for surrounding cells
        int endRow = gridCoord.a+1 <= m_worldMap.gridHeight-1 ? gridCoord.a+1 : m_worldMap.gridHeight-1;
        int endCol = gridCoord.b+1 <= m_worldMap.gridWidth-1 ? gridCoord.b+1 : m_worldMap.gridWidth-1;
        for(int row=(gridCoord.a-1 >= 0 ? gridCoord.a-1 : 0); row <= endRow; ++row)
        {
          for(int col=(gridCoord.b-1 >= 0 ? gridCoord.b-1 : 0); col <= endCol; ++col)
            m_threatMap[row][col] += AI::unitThreatIncr;
        }
     
      }
    }
 
  }
  

  typedef pair<MilitaryUnit*, FLOAT> UnitDist;

  class SmallerDistToCity
  {
  public:
    BOOL operator()(UnitDist &ud1, UnitDist ud2) { return ud1.second < ud2.second; }
  };

  void Player::sendUnitsToCity(vector<MilitaryUnit*> &units, const City *city)
  {
    // list of units and and there distance to the target city
    vector<UnitDist> unitDists;
    for(UnitIter iter=units.begin(); iter != units.end(); ++iter)
    {
      unitDists.push_back(UnitDist((*iter), Helper::distXY((*iter)->position(), city->position())));
    }

    // sort the units by the distance to the target city
    sort(unitDists.begin(), unitDists.end(), SmallerDistToCity());

    if(unitDists.size() > 0 && (!unitDists[0].first->isIdle())) unitDists[0].first->goal(city->position());
    if(unitDists.size() >= 2 && !unitDists[1].first->isIdle()) 
    {
      unitDists[1].first->goal(city->position());
    }
      
  }


} // end namespace AI

---