GreatPeopleDirectiveTypes CvPlayerAI::GetDirectiveGeneral (CvUnit*)
{
GreatPeopleDirectiveTypes eDirective = NO_GREAT_PEOPLE_DIRECTIVE_TYPE;
SpecialUnitTypes eSpecialUnitGreatPerson = (SpecialUnitTypes) GC.getInfoTypeForString("SPECIALUNIT_PEOPLE");
int iGreatGeneralCount = 0;
int iLoop;
for (CvUnit* pLoopUnit = firstUnit(&iLoop); pLoopUnit; pLoopUnit = nextUnit(&iLoop))
{
if (pLoopUnit->getSpecialUnitType() != eSpecialUnitGreatPerson)
{
continue;
}
if (pLoopUnit->AI_getUnitAIType() == UNITAI_GENERAL && pLoopUnit->GetGreatPeopleDirective() != GREAT_PEOPLE_DIRECTIVE_GOLDEN_AGE)
{
iGreatGeneralCount++;
}
}
if (iGreatGeneralCount > 2)
{
eDirective = GREAT_PEOPLE_DIRECTIVE_GOLDEN_AGE;
}
return eDirective;
}
GreatPeopleDirectiveTypes CvPlayerAI::GetDirectiveGeneral(CvUnit* pGreatGeneral)
{
GreatPeopleDirectiveTypes eDirective = NO_GREAT_PEOPLE_DIRECTIVE_TYPE;
SpecialUnitTypes eSpecialUnitGreatPerson = (SpecialUnitTypes) GC.getInfoTypeForString("SPECIALUNIT_PEOPLE");
int iGreatGeneralCount = 0;
int iLoop;
for(CvUnit* pLoopUnit = firstUnit(&iLoop); pLoopUnit; pLoopUnit = nextUnit(&iLoop))
{
if(pLoopUnit->getSpecialUnitType() != eSpecialUnitGreatPerson)
{
continue;
}
if(pLoopUnit->AI_getUnitAIType() == UNITAI_GENERAL && pLoopUnit->GetGreatPeopleDirective() != GREAT_PEOPLE_DIRECTIVE_GOLDEN_AGE)
{
iGreatGeneralCount++;
}
}
if(iGreatGeneralCount > 2 && pGreatGeneral->plot()->getOwner() == pGreatGeneral->getOwner())
{
// we're using a power at this point because constructing the improvement goes through different code
eDirective = GREAT_PEOPLE_DIRECTIVE_USE_POWER;
}
return eDirective;
}
void CvSelectionGroupAI::AI_seperateAI(UnitAITypes eUnitAI)
{
CLLNode<IDInfo>* pEntityNode;
CvUnit* pLoopUnit;
pEntityNode = headUnitNode();
while (pEntityNode != NULL)
{
pLoopUnit = ::getUnit(pEntityNode->m_data);
pEntityNode = nextUnitNode(pEntityNode);
if (pLoopUnit->AI_getUnitAIType() == eUnitAI)
{
pLoopUnit->joinGroup(NULL);
// TAC - AI Assault Sea - koma13, jdog5000(BBAI)
// Was potential crash in use of plot() if group emptied
//if (plot()->getTeam() == getTeam())
if (pLoopUnit->plot()->getTeam() == getTeam())
// TAC - AI Assault Sea - koma13, jdog5000(BBAI)
{
pLoopUnit->getGroup()->pushMission(MISSION_SKIP);
}
}
}
}
void CvPlayerAI::ProcessGreatPeople(void)
{
SpecialUnitTypes eSpecialUnitGreatPerson = (SpecialUnitTypes) GC.getInfoTypeForString("SPECIALUNIT_PEOPLE");
CvAssert(isAlive());
if(!isAlive())
return;
int iLoop;
for(CvUnit* pLoopUnit = firstUnit(&iLoop); pLoopUnit; pLoopUnit = nextUnit(&iLoop))
{
if(pLoopUnit->getSpecialUnitType() != eSpecialUnitGreatPerson)
{
continue;
}
GreatPeopleDirectiveTypes eDirective = NO_GREAT_PEOPLE_DIRECTIVE_TYPE;
switch(pLoopUnit->AI_getUnitAIType())
{
case UNITAI_WRITER:
eDirective = GetDirectiveWriter(pLoopUnit);
break;
case UNITAI_ARTIST:
eDirective = GetDirectiveArtist(pLoopUnit);
break;
case UNITAI_MUSICIAN:
eDirective = GetDirectiveMusician(pLoopUnit);
break;
case UNITAI_ENGINEER:
eDirective = GetDirectiveEngineer(pLoopUnit);
break;
case UNITAI_MERCHANT:
eDirective = GetDirectiveMerchant(pLoopUnit);
break;
case UNITAI_SCIENTIST:
eDirective = GetDirectiveScientist(pLoopUnit);
break;
case UNITAI_GENERAL:
eDirective = GetDirectiveGeneral(pLoopUnit);
break;
case UNITAI_PROPHET:
eDirective = GetDirectiveProphet(pLoopUnit);
break;
case UNITAI_ADMIRAL:
eDirective = GetDirectiveAdmiral(pLoopUnit);
break;
}
pLoopUnit->SetGreatPeopleDirective(eDirective);
}
}
void CvSelectionGroupAI::AI_separateAI(UnitAITypes eUnitAI)
{
CLLNode<IDInfo>* pEntityNode;
CvUnit* pLoopUnit;
pEntityNode = headUnitNode();
while (pEntityNode != NULL)
{
pLoopUnit = ::getUnit(pEntityNode->m_data);
pEntityNode = nextUnitNode(pEntityNode);
if (pLoopUnit->AI_getUnitAIType() == eUnitAI)
{
pLoopUnit->joinGroup(NULL);
}
}
}
bool CvSelectionGroupAI::AI_separateEmptyTransports()
{
bool bSeparated = false;
CLLNode<IDInfo>* pEntityNode = headUnitNode();
while (pEntityNode != NULL)
{
CvUnit* pLoopUnit = ::getUnit(pEntityNode->m_data);
pEntityNode = nextUnitNode(pEntityNode);
if ((pLoopUnit->AI_getUnitAIType() == UNITAI_ASSAULT_SEA) && (pLoopUnit->getCargo() == 0))
{
pLoopUnit->joinGroup(NULL);
bSeparated = true;
}
}
return bSeparated;
}
void CvSelectionGroupAI::AI_seperateNonAI(UnitAITypes eUnitAI)
{
CLLNode<IDInfo>* pEntityNode;
CvUnit* pLoopUnit;
pEntityNode = headUnitNode();
while (pEntityNode != NULL)
{
pLoopUnit = ::getUnit(pEntityNode->m_data);
pEntityNode = nextUnitNode(pEntityNode);
if (pLoopUnit->AI_getUnitAIType() != eUnitAI)
{
pLoopUnit->joinGroup(NULL);
if (pLoopUnit->plot()->getTeam() == getTeam())
{
pLoopUnit->getGroup()->pushMission(MISSION_SKIP);
}
}
}
}
void CvSelectionGroupAI::AI_separateEmptyTransports()
{
CLLNode<IDInfo>* pEntityNode;
CvUnit* pLoopUnit;
pEntityNode = headUnitNode();
while (pEntityNode != NULL)
{
pLoopUnit = ::getUnit(pEntityNode->m_data);
pEntityNode = nextUnitNode(pEntityNode);
if ((pLoopUnit->AI_getUnitAIType() == UNITAI_ASSAULT_SEA) && (pLoopUnit->getCargo() == 0))
{
pLoopUnit->joinGroup(NULL);
if (pLoopUnit->plot()->getTeam() == getTeam())
{
pLoopUnit->getGroup()->pushMission(MISSION_SKIP);
}
}
}
}
void CvSelectionGroupAI::AI_seperateAI(UnitAITypes eUnitAI)
{
CLLNode<IDInfo>* pEntityNode;
CvUnit* pLoopUnit;
pEntityNode = headUnitNode();
int iCounter = 0; //Rhye (possible loop fix)
while (pEntityNode != NULL)
{
iCounter++; //Rhye (fix)
if (iCounter > 20) break; //Rhye (fix)
pLoopUnit = ::getUnit(pEntityNode->m_data);
pEntityNode = nextUnitNode(pEntityNode);
if (pLoopUnit->AI_getUnitAIType() == eUnitAI)
{
pLoopUnit->joinGroup(NULL);
if (plot()->getTeam() == getTeam())
{
pLoopUnit->getGroup()->pushMission(MISSION_SKIP);
}
}
}
}
// Returns true if the group has become busy...
bool CvSelectionGroupAI::AI_update()
{
CLLNode<IDInfo>* pEntityNode;
CvUnit* pLoopUnit;
bool bDead;
bool bFollow;
PROFILE("CvSelectionGroupAI::AI_update");
FAssert(getOwnerINLINE() != NO_PLAYER);
if (!AI_isControlled())
{
return false;
}
if (getNumUnits() == 0)
{
return false;
}
// K-Mod / BBAI
if (getActivityType() == ACTIVITY_SLEEP && !isHuman() && !getHeadUnit()->isCargo())
{
setForceUpdate(true);
}
// end
if (isForceUpdate())
{
doForceUpdate(); // K-Mod (based on old code)
}
//FAssert(!(GET_PLAYER(getOwnerINLINE()).isAutoMoves())); // (no longer true in K-Mod)
int iTempHack = 0; // XXX
bDead = false;
bool bFailedAlreadyFighting = false;
//while ((m_bGroupAttack && !bFailedAlreadyFighting) || readyToMove())
while ((AI_isGroupAttack() && !isBusy()) || readyToMove()) // K-Mod
{
iTempHack++;
if (iTempHack > 100)
{
FAssertMsg(false, "unit stuck in a loop");
CvUnit* pHeadUnit = getHeadUnit();
if (NULL != pHeadUnit)
{
if (GC.getLogging())
{
TCHAR szOut[1024];
CvWString szTempString;
getUnitAIString(szTempString, pHeadUnit->AI_getUnitAIType());
sprintf(szOut, "Unit stuck in loop: %S(%S)[%d, %d] (%S)\n", pHeadUnit->getName().GetCString(), GET_PLAYER(pHeadUnit->getOwnerINLINE()).getName(),
pHeadUnit->getX_INLINE(), pHeadUnit->getY_INLINE(), szTempString.GetCString());
gDLL->messageControlLog(szOut);
}
pHeadUnit->finishMoves();
}
break;
}
// if we want to force the group to attack, force another attack
if (AI_isGroupAttack())
{
AI_cancelGroupAttack();
groupAttack(m_iGroupAttackX, m_iGroupAttackY, MOVE_DIRECT_ATTACK, bFailedAlreadyFighting);
}
// else pick AI action
else
{
CvUnit* pHeadUnit = getHeadUnit();
//if (pHeadUnit == NULL || pHeadUnit->isDelayedDeath())
if (pHeadUnit == NULL || pHeadUnit->doDelayedDeath()) // K-Mod
{
break;
}
//resetPath();
if (pHeadUnit->AI_update())
{
// AI_update returns true when we should abort the loop and wait until next slice
FAssert(!pHeadUnit->isDelayedDeath());
break;
}
}
if (doDelayedDeath())
{
bDead = true;
break;
}
// if no longer group attacking, and force separate is true, then bail, decide what to do after group is split up
// (UnitAI of head unit may have changed)
if (!AI_isGroupAttack() && AI_isForceSeparate())
{
AI_separate(); // pointers could become invalid...
//return true;
return false; // K-Mod
}
}
if (!bDead)
{
if (!isHuman())
{
bFollow = false;
// if we not group attacking, then check for follow action
if (!AI_isGroupAttack())
{
pEntityNode = headUnitNode();
// K-Mod note: I've rearranged a few things below, and added 'bFirst'.
bool bFirst = true;
while ((pEntityNode != NULL) && readyToMove(true))
{
pLoopUnit = ::getUnit(pEntityNode->m_data);
pEntityNode = nextUnitNode(pEntityNode);
if (bFirst)
resetPath();
if (pLoopUnit->canMove())
{
if (pLoopUnit->AI_follow(bFirst))
{
bFollow = true;
bFirst = true; // let the next unit start fresh.
}
else
bFirst = false;
}
}
// K-Mod end
}
if (doDelayedDeath())
{
bDead = true;
}
if (!bDead)
{
if (!bFollow && readyToMove(true))
{
pushMission(MISSION_SKIP);
}
}
/************************************************************************************************/
/* BETTER_BTS_AI_MOD 04/28/10 jdog5000 */
/* */
/* Unit AI */
/************************************************************************************************/
// AI should never put units to sleep, how does this ever happen?
//FAssert( getHeadUnit()->isCargo() || getActivityType() != ACTIVITY_SLEEP );
/************************************************************************************************/
/* BETTER_BTS_AI_MOD END */
/************************************************************************************************/
}
}
if (bDead)
{
//return true;
return false; // K-Mod
}
return (isBusy() || isCargoBusy());
}
CvUnit* CvSelectionGroupAI::AI_getBestGroupAttacker(const CvPlot* pPlot, bool bPotentialEnemy, int& iUnitOdds, bool bForce, bool bNoBlitz) const
{
CLLNode<IDInfo>* pUnitNode;
CvUnit* pLoopUnit;
CvUnit* pBestUnit;
int iPossibleTargets;
int iValue;
int iBestValue;
int iOdds;
int iBestOdds;
iBestValue = 0;
iBestOdds = 0;
pBestUnit = NULL;
pUnitNode = headUnitNode();
bool bIsHuman = (pUnitNode != NULL) ? GET_PLAYER(::getUnit(pUnitNode->m_data)->getOwnerINLINE()).isHuman() : true;
while (pUnitNode != NULL)
{
pLoopUnit = ::getUnit(pUnitNode->m_data);
pUnitNode = nextUnitNode(pUnitNode);
if (!pLoopUnit->isDead())
{
bool bCanAttack = false;
if (pLoopUnit->getDomainType() == DOMAIN_AIR)
{
bCanAttack = pLoopUnit->canAirAttack();
}
else
{
bCanAttack = pLoopUnit->canAttack();
if (bCanAttack && bNoBlitz && pLoopUnit->isBlitz() && pLoopUnit->isMadeAttack())
{
bCanAttack = false;
}
}
if (bCanAttack)
{
if (bForce || pLoopUnit->canMove())
{
if (bForce || pLoopUnit->canMoveInto(pPlot, /*bAttack*/ true, /*bDeclareWar*/ bPotentialEnemy))
{
iOdds = pLoopUnit->AI_attackOdds(pPlot, bPotentialEnemy);
iValue = iOdds;
/*************************************************************************************************/
/** BETTER AI (Block some Units from attacking at low odds) Sephi **/
/** **/
/** **/
/*************************************************************************************************/
if (!GET_PLAYER(pLoopUnit->getOwnerINLINE()).isHuman())
{
if (pLoopUnit->AI_getUnitAIType()==UNITAI_WARWIZARD)
{
if (iOdds<95)
{
iValue=0; //Need to put the min to 1 to prevent WoC
}
}
if (pLoopUnit->AI_getUnitAIType()==UNITAI_HERO)
{
if (iOdds<85)
{
iValue=0;
}
}
if (pLoopUnit->getLevel()>4 && iOdds<95)
{
iValue/=2;
}
}
iValue=std::max(1,iValue);
/*************************************************************************************************/
/** END **/
/*************************************************************************************************/
FAssertMsg(iValue > 0, "iValue is expected to be greater than 0");
if (pLoopUnit->collateralDamage() > 0)
{
iPossibleTargets = std::min((pPlot->getNumVisibleEnemyDefenders(pLoopUnit) - 1), pLoopUnit->collateralDamageMaxUnits());
if (iPossibleTargets > 0)
{
iValue *= (100 + ((pLoopUnit->collateralDamage() * iPossibleTargets) / 5));
iValue /= 100;
}
}
// if non-human, prefer the last unit that has the best value (so as to avoid splitting the group)
if (iValue > iBestValue || (!bIsHuman && iValue > 0 && iValue == iBestValue))
{
iBestValue = iValue;
iBestOdds = iOdds;
pBestUnit = pLoopUnit;
}
}
}
}
}
}
iUnitOdds = iBestOdds;
return pBestUnit;
}
bool CvSelectionGroupAI::AI_isFull()
{
CLLNode<IDInfo>* pUnitNode;
CvUnit* pLoopUnit;
if (getNumUnits() > 0)
{
UnitAITypes eUnitAI = getHeadUnitAI();
// do two passes, the first pass, we ignore units with speical cargo
int iSpecialCargoCount = 0;
int iCargoCount = 0;
// first pass, count but ignore special cargo units
pUnitNode = headUnitNode();
while (pUnitNode != NULL)
{
pLoopUnit = ::getUnit(pUnitNode->m_data);
pUnitNode = nextUnitNode(pUnitNode);
if (pLoopUnit->AI_getUnitAIType() == eUnitAI)
{
if (pLoopUnit->cargoSpace() > 0)
{
iCargoCount++;
}
if (pLoopUnit->specialCargo() != NO_SPECIALUNIT)
{
iSpecialCargoCount++;
}
else if (!(pLoopUnit->isFull()))
{
return false;
}
}
}
// if every unit in the group has special cargo, then check those, otherwise, consider ourselves full
if (iSpecialCargoCount >= iCargoCount)
{
pUnitNode = headUnitNode();
while (pUnitNode != NULL)
{
pLoopUnit = ::getUnit(pUnitNode->m_data);
pUnitNode = nextUnitNode(pUnitNode);
if (pLoopUnit->AI_getUnitAIType() == eUnitAI)
{
if (!(pLoopUnit->isFull()))
{
return false;
}
}
}
}
return true;
}
return false;
}
bool CvSelectionGroupAI::AI_isDeclareWar(const CvPlot* pPlot)
{
FAssert(getHeadUnit() != NULL);
if (isHuman())
{
return false;
}
else
{
bool bLimitedWar = false;
if (pPlot != NULL)
{
TeamTypes ePlotTeam = pPlot->getTeam();
if (ePlotTeam != NO_TEAM)
{
WarPlanTypes eWarplan = GET_TEAM(getTeam()).AI_getWarPlan(ePlotTeam);
if (eWarplan == WARPLAN_LIMITED)
{
bLimitedWar = true;
}
}
}
CvUnit* pHeadUnit = getHeadUnit();
if (pHeadUnit != NULL)
{
switch (pHeadUnit->AI_getUnitAIType())
{
case UNITAI_UNKNOWN:
case UNITAI_ANIMAL:
case UNITAI_SETTLE:
case UNITAI_WORKER:
break;
case UNITAI_ATTACK_CITY:
case UNITAI_ATTACK_CITY_LEMMING:
return true;
break;
case UNITAI_ATTACK:
case UNITAI_COLLATERAL:
case UNITAI_PILLAGE:
if (bLimitedWar)
{
return true;
}
break;
case UNITAI_PARADROP:
case UNITAI_RESERVE:
case UNITAI_COUNTER:
case UNITAI_CITY_DEFENSE:
case UNITAI_CITY_COUNTER:
case UNITAI_CITY_SPECIAL:
case UNITAI_EXPLORE:
case UNITAI_MISSIONARY:
case UNITAI_PROPHET:
case UNITAI_ARTIST:
case UNITAI_SCIENTIST:
case UNITAI_GENERAL:
case UNITAI_MERCHANT:
case UNITAI_ENGINEER:
case UNITAI_SPY:
case UNITAI_ICBM:
case UNITAI_WORKER_SEA:
break;
case UNITAI_ATTACK_SEA:
case UNITAI_RESERVE_SEA:
case UNITAI_ESCORT_SEA:
if (bLimitedWar)
{
return true;
}
break;
case UNITAI_EXPLORE_SEA:
break;
case UNITAI_ASSAULT_SEA:
if (hasCargo())
{
return true;
}
break;
case UNITAI_SETTLER_SEA:
case UNITAI_MISSIONARY_SEA:
case UNITAI_SPY_SEA:
case UNITAI_CARRIER_SEA:
case UNITAI_MISSILE_CARRIER_SEA:
case UNITAI_PIRATE_SEA:
case UNITAI_ATTACK_AIR:
case UNITAI_DEFENSE_AIR:
case UNITAI_CARRIER_AIR:
case UNITAI_MISSILE_AIR:
break;
default:
FAssert(false);
break;
}
}
}
return false;
}
// Returns true if the group has become busy...
bool CvSelectionGroupAI::AI_update()
{
CLLNode<IDInfo>* pEntityNode;
CvUnit* pLoopUnit;
bool bDead;
bool bFollow;
PROFILE("CvSelectionGroupAI::AI_update");
FAssert(getOwnerINLINE() != NO_PLAYER);
if (!AI_isControlled())
{
return false;
}
if (getNumUnits() == 0)
{
return false;
}
if (isForceUpdate())
{
clearMissionQueue(); // XXX ???
setActivityType(ACTIVITY_AWAKE);
setForceUpdate(false);
// if we are in the middle of attacking with a stack, cancel it
AI_cancelGroupAttack();
}
FAssert(!(GET_PLAYER(getOwnerINLINE()).isAutoMoves()));
int iTempHack = 0; // XXX
bDead = false;
bool bFailedAlreadyFighting = false;
while ((m_bGroupAttack && !bFailedAlreadyFighting) || readyToMove())
{
iTempHack++;
if (iTempHack > 100)
{
FAssert(false);
CvUnit* pHeadUnit = getHeadUnit();
if (NULL != pHeadUnit)
{
if (GC.getLogging())
{
TCHAR szOut[1024];
CvWString szTempString;
getUnitAIString(szTempString, pHeadUnit->AI_getUnitAIType());
sprintf(szOut, "Unit stuck in loop: %S(%S)[%d, %d] (%S)\n", pHeadUnit->getName().GetCString(), GET_PLAYER(pHeadUnit->getOwnerINLINE()).getName(),
pHeadUnit->getX_INLINE(), pHeadUnit->getY_INLINE(), szTempString.GetCString());
gDLL->messageControlLog(szOut);
}
pHeadUnit->finishMoves();
}
break;
}
// if we want to force the group to attack, force another attack
if (m_bGroupAttack)
{
m_bGroupAttack = false;
groupAttack(m_iGroupAttackX, m_iGroupAttackY, MOVE_DIRECT_ATTACK, bFailedAlreadyFighting);
}
// else pick AI action
else
{
CvUnit* pHeadUnit = getHeadUnit();
if (pHeadUnit == NULL || pHeadUnit->isDelayedDeath())
{
break;
}
resetPath();
if (pHeadUnit->AI_update())
{
// AI_update returns true when we should abort the loop and wait until next slice
break;
}
}
if (doDelayedDeath())
{
bDead = true;
break;
}
// if no longer group attacking, and force separate is true, then bail, decide what to do after group is split up
// (UnitAI of head unit may have changed)
if (!m_bGroupAttack && AI_isForceSeparate())
{
AI_separate(); // pointers could become invalid...
return true;
}
}
if (!bDead)
{
if (!isHuman())
{
bFollow = false;
// if we not group attacking, then check for follow action
if (!m_bGroupAttack)
{
pEntityNode = headUnitNode();
while ((pEntityNode != NULL) && readyToMove(true))
{
pLoopUnit = ::getUnit(pEntityNode->m_data);
pEntityNode = nextUnitNode(pEntityNode);
if (pLoopUnit->canMove())
{
resetPath();
if (pLoopUnit->AI_follow())
{
bFollow = true;
break;
}
}
}
}
if (doDelayedDeath())
{
bDead = true;
}
if (!bDead)
{
if (!bFollow && readyToMove(true))
{
pushMission(MISSION_SKIP);
}
}
}
}
if (bDead)
{
return true;
}
return (isBusy() || isCargoBusy());
}
CvUnit* CvSelectionGroupAI::AI_getBestGroupSacrifice(const CvPlot* pPlot, bool bPotentialEnemy, bool bForce, bool bNoBlitz) const
{
int iBestValue = 0;
CvUnit* pBestUnit = NULL;
CLLNode<IDInfo>* pUnitNode = headUnitNode();
while (pUnitNode != NULL)
{
CvUnit* pLoopUnit = ::getUnit(pUnitNode->m_data);
pUnitNode = nextUnitNode(pUnitNode);
if (!pLoopUnit->isDead())
{
bool bCanAttack = false;
if (pLoopUnit->getDomainType() == DOMAIN_AIR)
{
bCanAttack = pLoopUnit->canAirAttack();
}
else
{
bCanAttack = pLoopUnit->canAttack();
if (bCanAttack && bNoBlitz && pLoopUnit->isBlitz() && pLoopUnit->isMadeAttack())
{
bCanAttack = false;
}
}
if (bCanAttack)
{
if (bForce || pLoopUnit->canMove())
{
if (bForce || pLoopUnit->canMoveInto(pPlot, true))
{
int iValue = pLoopUnit->AI_sacrificeValue(pPlot);
FAssertMsg(iValue > 0, "iValue is expected to be greater than 0");
/*************************************************************************************************/
/** BETTER AI (Summons make good groupattack sacrifice units) Sephi **/
/** **/
/** **/
/*************************************************************************************************/
if (pLoopUnit->getDuration()>0)
{
iValue+=10000;
}
/*************************************************************************************************/
/** END **/
/*************************************************************************************************/
/*************************************************************************************************/
/** BETTER AI (Block some Units from attacking at low odds) Sephi **/
/** **/
/** **/
/*************************************************************************************************/
if (!GET_PLAYER(pLoopUnit->getOwnerINLINE()).isHuman())
{
if (pLoopUnit->AI_getUnitAIType()==UNITAI_WARWIZARD)
{
iValue=1;
}
if (pLoopUnit->AI_getUnitAIType()==UNITAI_HERO)
{
iValue=1;
}
if (pLoopUnit->getLevel()>4)
{
iValue=1;
}
}
/*************************************************************************************************/
/** END **/
/*************************************************************************************************/
// we want to pick the last unit of highest value, so pick the last unit with a good value
if (iValue >= iBestValue)
{
iBestValue = iValue;
pBestUnit = pLoopUnit;
}
}
}
}
}
}
return pBestUnit;
}
bool CvSelectionGroupAI::AI_isDeclareWar(const CvPlot* pPlot)
{
FAssert(getHeadUnit() != NULL);
if (isHuman())
{
return false;
}
else
{
bool bLimitedWar = false;
if (pPlot != NULL)
{
TeamTypes ePlotTeam = pPlot->getTeam();
if (ePlotTeam != NO_TEAM)
{
WarPlanTypes eWarplan = GET_TEAM(getTeam()).AI_getWarPlan(ePlotTeam);
if (eWarplan == WARPLAN_LIMITED)
{
bLimitedWar = true;
}
}
}
CvUnit* pHeadUnit = getHeadUnit();
if (pHeadUnit != NULL)
{
switch (pHeadUnit->AI_getUnitAIType())
{
case UNITAI_UNKNOWN:
case UNITAI_ANIMAL: // R&R, ray, Wild Animals
case UNITAI_ANIMAL_SEA: // R&R, ray, Wild Animals
case UNITAI_FLEEING: // R&R, ray, Fleeing Units
case UNITAI_COLONIST:
case UNITAI_SETTLER:
case UNITAI_WORKER:
case UNITAI_MISSIONARY:
case UNITAI_SCOUT:
case UNITAI_WAGON:
case UNITAI_TREASURE:
case UNITAI_YIELD:
case UNITAI_GENERAL:
return false;
break;
case UNITAI_DEFENSIVE:
case UNITAI_OFFENSIVE:
case UNITAI_COUNTER:
return true;
break;
//TAC Whaling, ray
case UNITAI_WORKER_SEA:
//End TAC Whaling, ray
case UNITAI_TRANSPORT_SEA:
return false;
break;
case UNITAI_ASSAULT_SEA:
case UNITAI_COMBAT_SEA:
case UNITAI_PIRATE_SEA:
case UNITAI_ESCORT_SEA: // TAC - AI Escort Sea - koma13
return true;
break;
default:
FAssert(false);
break;
}
}
}
return false;
}
bool CvSelectionGroupAI::AI_isDeclareWar(const CvPlot* pPlot)
{
FAssert(getHeadUnit() != NULL);
if (isHuman())
{
return false;
}
else
{
bool bLimitedWar = false;
if (pPlot != NULL)
{
TeamTypes ePlotTeam = pPlot->getTeam();
if (ePlotTeam != NO_TEAM)
{
WarPlanTypes eWarplan = GET_TEAM(getTeam()).AI_getWarPlan(ePlotTeam);
if (eWarplan == WARPLAN_LIMITED)
{
bLimitedWar = true;
}
}
}
CvUnit* pHeadUnit = getHeadUnit();
if (pHeadUnit != NULL)
{
switch (pHeadUnit->AI_getUnitAIType())
{
case UNITAI_UNKNOWN:
case UNITAI_COLONIST:
case UNITAI_SETTLER:
case UNITAI_WORKER:
case UNITAI_MISSIONARY:
case UNITAI_SCOUT:
case UNITAI_WAGON:
case UNITAI_TREASURE:
case UNITAI_YIELD:
case UNITAI_GENERAL:
///TKs Med Animal
case UNITAI_ANIMAL:
case UNITAI_HUNTSMAN:
case UNITAI_MARAUDER:
case UNITAI_TRADER:
///TKe
return false;
break;
case UNITAI_DEFENSIVE:
case UNITAI_OFFENSIVE:
case UNITAI_COUNTER:
return true;
break;
case UNITAI_TRANSPORT_SEA:
return false;
break;
case UNITAI_ASSAULT_SEA:
case UNITAI_COMBAT_SEA:
case UNITAI_PIRATE_SEA:
return true;
break;
default:
FAssert(false);
break;
}
}
}
return false;
}