AI::Player class Reference

00037                                         :        m_teamColor(teamColor),        
00038                                        m_units(units),
00039                                        m_cities(cities),
00040                                        m_threatMap(wm.gridWidth, vector<FLOAT>(wm.gridHeight)),
00041                                        m_worldMap(wm) 
00042   {
00043     //clearThreatMap();
00044   }

00142   {
00143     clearThreatMap();   
00144     for(UnitIter iter=m_units.begin(); iter != m_units.end(); ++iter)
00145     {
00146       
00147       // dont calculate my units
00148       if( (*iter)->color() != m_teamColor )
00149       {
00150         // a unit should have a great affect on the grid cell its in and 
00151         // a lesser affect to each neighbor cell. so increment the containing cell twice.
00152         Int2Tuple gridCoord = m_worldMap.worldToGridCoord((*iter)->position());
00153         m_threatMap[gridCoord.a][gridCoord.b] += AI::unitThreatIncr;
00154         // calculate value for surrounding cells
00155         int endRow = gridCoord.a+1 <= m_worldMap.gridHeight-1 ? gridCoord.a+1 : m_worldMap.gridHeight-1;
00156         int endCol = gridCoord.b+1 <= m_worldMap.gridWidth-1 ? gridCoord.b+1 : m_worldMap.gridWidth-1;
00157         for(int row=(gridCoord.a-1 >= 0 ? gridCoord.a-1 : 0); row <= endRow; ++row)
00158         {
00159           for(int col=(gridCoord.b-1 >= 0 ? gridCoord.b-1 : 0); col <= endCol; ++col)
00160             m_threatMap[row][col] += AI::unitThreatIncr;
00161         }
00162      
00163       }
00164     }
00165  
00166   }

00131   {
00132     for(int     i=0; i < m_worldMap.gridHeight; ++i)
00133       for(int   j=0; j < m_worldMap.gridWidth;  ++j)
00134                           m_threatMap[i][j] = 0.0f;
00135   }

00110 {       return m_teamColor;     }

00181   {
00182     // list of units and and there distance to the target city
00183     vector<UnitDist> unitDists;
00184     for(UnitIter iter=units.begin(); iter != units.end(); ++iter)
00185     {
00186       unitDists.push_back(UnitDist((*iter), Helper::distXY((*iter)->position(), city->position())));
00187     }
00188 
00189     // sort the units by the distance to the target city
00190     sort(unitDists.begin(), unitDists.end(), SmallerDistToCity());
00191 
00192     if(unitDists.size() > 0 && (!unitDists[0].first->isIdle())) unitDists[0].first->goal(city->position());
00193     if(unitDists.size() >= 2 && !unitDists[1].first->isIdle()) 
00194     {
00195       unitDists[1].first->goal(city->position());
00196     }
00197       
00198   }

00112 { return m_threatMap; }

00049   {
00050     buildThreatMap();
00051 
00052     // build list of units i own
00054     //                     access to each list of units.
00055     vector<MilitaryUnit*> myUnits;
00056     UnitIter unitIter;
00057     for(unitIter = m_units.begin(); unitIter != m_units.end(); ++unitIter)
00058     {
00059       if( (*unitIter)->color() == m_teamColor ) myUnits.push_back((*unitIter));
00060     }
00061 
00062     // find least threatened neutral city
00063     vector<City*> neutralCities;
00064     vector<City*> enemyCities;
00065     CityIter cityIter;
00066     for(cityIter = m_cities.begin(); cityIter != m_cities.end(); ++cityIter)
00067     {
00068       if( (*cityIter)->color() == Globals::NO_OWNER ) 
00069         neutralCities.push_back(*cityIter);
00070       else if( (*cityIter)->color() != m_teamColor )
00071         enemyCities.push_back(*cityIter);
00072     }
00073 
00074     if( !neutralCities.empty() )
00075     {
00076       // sort cities by their threatened valued. less threatened cities first
00077       sort(neutralCities.begin(), neutralCities.end(), CityLessThreatened(m_threatMap, m_worldMap) );
00078       // send units to the cities
00079       size_t numCities = neutralCities.size();
00080       size_t city;
00081       for(unitIter = myUnits.begin(), city=0; (unitIter != myUnits.end()) && city < numCities; ++unitIter, ++city)
00082       {
00083             if(!(*unitIter)->isIdle()) (*unitIter)->goal( neutralCities[city]->position() );
00084       }
00085 
00086     }
00087     // send the units to the enemy cites
00088     else
00089     {
00090       // sort cities by their threatened valued. less threatened cities first
00091       sort(enemyCities.begin(), enemyCities.end(), CityLessThreatened(m_threatMap, m_worldMap) );
00092       // send the two closest units to each of the cities
00093       //size_t numCities = enemyCities.size();
00094       //size_t city;
00095       //for(unitIter = myUnits.begin(), city=0; (unitIter != myUnits.end()) && city < numCities; ++unitIter, ++city)
00096       //{
00097       //  if( (*unitIter)->currState != MilitaryUnit::BUSY )
00098       //    (*unitIter)->goal( enemyCities[city]->position() );
00099       //}
00100       for(cityIter = enemyCities.begin(); cityIter != enemyCities.end(); ++cityIter)
00101       {
00102         sendUnitsToCity(myUnits, *cityIter);
00103       }
00104     }
00105 
00106   }


Public Methods
	Player (const Vec3D teamColor, vector< MilitaryUnit * > &units, vector< City * > &cities, Map::WorldMap worldMap)
	Creates a player and assigns it to the specified team.
void	update ()
	Updates the AI player. Calculating threats, building units, etc...
Vec3D	color () const
	Tells which team the player is on.
const ThreatMap &	threatMap ()
	gets the threat map, usefull for debugging.
Private Methods
void	clearThreatMap ()
void	buildThreatMap ()
void	sendUnitsToCity (vector< MilitaryUnit * > &units, const City *city)
	send units to a city to capture it. PRE: The vector of military units is not empty. POST: Some number of units(for now, at most 2) is sent to attack the target city.
Private Attributes
Vec3D	m_teamColor
vector< MilitaryUnit * > &	m_units
vector< City * > &	m_cities
ThreatMap	m_threatMap
Map::WorldMap	m_worldMap

AI::Player Class Reference

Detailed Description

Public Methods

Private Methods

Private Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation