//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseChangeWar(PlayerTypes ePlayer, TeamTypes eRivalTeam, bool bWar)
{
CvPlayerAI& kPlayer = GET_PLAYER(ePlayer);
CvTeam& kTeam = GET_TEAM(kPlayer.getTeam());
const TeamTypes eTeam = kPlayer.getTeam();
FAssert(eTeam != eRivalTeam);
if(bWar)
{
#if defined(MOD_EVENTS_WAR_AND_PEACE)
kTeam.declareWar(eRivalTeam, false, ePlayer);
#else
kTeam.declareWar(eRivalTeam);
#endif
}
else
{
#if defined(MOD_EVENTS_WAR_AND_PEACE)
kTeam.makePeace(eRivalTeam, true, false, ePlayer);
#else
kTeam.makePeace(eRivalTeam);
#endif
}
}
//------------------------------------------------------------------------------
void CvDllGameContext::InitializeSingleton()
{
if(s_pSingleton == NULL)
{
FAssert(s_hHeap == INVALID_HANDLE_VALUE);
s_hHeap = HeapCreate(0, 0, 0);
//
// Enable the low-fragmentation heap (LFH). Starting with Windows Vista,
// the LFH is enabled by default but this call does not cause an error.
//
ULONG HeapInformation = 2; //Low Fragmentation Heap
HeapSetInformation(s_hHeap,
HeapCompatibilityInformation,
&HeapInformation,
sizeof(HeapInformation));
}
s_pSingleton = FNEW(CvDllGameContext(), c_eCiv5GameplayDLL, 0);
#if defined(CUSTOM_MODS_H)
CUSTOMLOG("%s - Startup (Version %u%s - Build %s %s%s)", MOD_DLL_NAME, MOD_DLL_VERSION_NUMBER, MOD_DLL_VERSION_STATUS, __DATE__, __TIME__, MOD_DLL_CUSTOM_BUILD_NAME);
#if defined(MOD_GLOBAL_MAX_MAJOR_CIVS)
CUSTOMLOG(" - supporting %i major civilizations", MAX_MAJOR_CIVS);
#endif
#endif
}
void CvArea::setBestFoundValue(PlayerTypes eIndex, int iNewValue)
{
FAssertMsg(eIndex >= 0, "eIndex is expected to be >= 0");
FAssertMsg(eIndex < MAX_PLAYERS, "eIndex is expected to be < MAX_PLAYERS");
m_aiBestFoundValue[eIndex] = iNewValue;
FAssert(getBestFoundValue(eIndex) >= 0);
}
// ---------------------------------------------------------------------------
/// New Goody Hut Result from a Player
void CvGoodyHuts::DoPlayerReceivedGoody(PlayerTypes ePlayer, GoodyTypes eGoody)
{
FAssert(ePlayer >= 0);
FAssert(ePlayer < MAX_MAJOR_CIVS);
FAssert(eGoody >= 0);
// FAssert(eGoody < DB.count("GoodyHuts"));
// Push elements up in the array so that we free up element 0
for (int iGoodySlotLoop = 0; iGoodySlotLoop < NUM_GOODIES_REMEMBERED-1; iGoodySlotLoop++)
{
m_aaiPlayerGoodyHutResults[ePlayer][iGoodySlotLoop+1] = m_aaiPlayerGoodyHutResults[ePlayer][iGoodySlotLoop];
}
// Most recent Goody gets slot 0
m_aaiPlayerGoodyHutResults[ePlayer][0] = eGoody;
}
// Returns attack odds out of 100 (the higher, the better...)
int CvSelectionGroupAI::AI_attackOdds(const CvPlot* pPlot, bool bPotentialEnemy) const
{
PROFILE_FUNC();
CvUnit* pAttacker;
FAssert(getOwnerINLINE() != NO_PLAYER);
/************************************************************************************************/
/* BETTER_BTS_AI_MOD 02/21/10 jdog5000 */
/* */
/* Efficiency, Lead From Behind */
/************************************************************************************************/
// From Lead From Behind by UncutDragon
// original
//if (pPlot->getBestDefender(NO_PLAYER, getOwnerINLINE(), NULL, !bPotentialEnemy, bPotentialEnemy) == NULL)
// modified
if (!pPlot->hasDefender(false, NO_PLAYER, getOwnerINLINE(), NULL, !bPotentialEnemy, bPotentialEnemy))
/************************************************************************************************/
/* BETTER_BTS_AI_MOD END */
/************************************************************************************************/
{
return 100;
}
int iOdds = 0;
pAttacker = AI_getBestGroupAttacker(pPlot, bPotentialEnemy, iOdds);
if (pAttacker == NULL)
{
return 0;
}
return iOdds;
}
void CvArea::changeNumRevealedTiles(TeamTypes eIndex, int iChange)
{
FAssertMsg(eIndex >= 0, "eIndex is expected to be >= 0");
FAssertMsg(eIndex < MAX_PLAYERS, "eIndex is expected to be < MAX_PLAYERS");
m_aiNumRevealedTiles[eIndex] += iChange;
FAssert(getNumRevealedTiles(eIndex) >= 0);
}
void CvArea::changeNumImprovements(ImprovementTypes eImprovement, int iChange)
{
FAssertMsg(eImprovement >= 0, "eImprovement expected to be >= 0");
FAssertMsg(eImprovement < GC.getNumImprovementInfos(), "eImprovement expected to be < GC.getNumImprovementInfos");
m_paiNumImprovements[eImprovement] += iChange;
FAssert(getNumImprovements(eImprovement) >= 0);
}
void CvArea::changeNumBonuses(BonusTypes eBonus, int iChange)
{
FAssertMsg(eBonus >= 0, "eBonus expected to be >= 0");
FAssertMsg(eBonus < GC.getNumBonusInfos(), "eBonus expected to be < GC.getNumBonusInfos");
m_paiNumBonuses[eBonus] = (m_paiNumBonuses[eBonus] + iChange);
FAssert(getNumBonuses(eBonus) >= 0);
}
void CvArea::changePopulationPerPlayer(PlayerTypes eIndex, int iChange)
{
FAssertMsg(eIndex >= 0, "eIndex is expected to be >= 0");
FAssertMsg(eIndex < MAX_PLAYERS, "eIndex is expected to be < MAX_PLAYERS");
m_aiPopulationPerPlayer[eIndex] += iChange;
FAssert(getPopulationPerPlayer(eIndex) >= 0);
}
static void Visit(FObject key, FObject val, FObject ctx)
{
FAssert(GlobalP(val));
if (AsGlobal(val)->State == GlobalUndefined)
UndefinedList = MakePair(AsGlobal(val)->Name, UndefinedList);
}
int_t ListLength(FObject lst)
{
int_t ll = 0;
FObject fst = lst;
FObject slw = lst;
for (;;)
{
if (fst == EmptyListObject)
break;
if (PairP(fst) == 0)
return(-1);
fst = Rest(fst);
ll += 1;
if (fst == EmptyListObject)
break;
if (PairP(fst) == 0 || fst == slw)
return(-1);
fst = Rest(fst);
ll += 1;
FAssert(PairP(slw));
slw = Rest(slw);
if (fst == slw)
return(-1);
}
return(ll);
}
void CvMapGenerator::addFeatures()
{
PROFILE("CvMapGenerator::addFeatures");
if (gDLL->getPythonIFace()->callFunction(gDLL->getPythonIFace()->getMapScriptModule(), "addFeatures", NULL))
{
if (!gDLL->getPythonIFace()->pythonUsingDefaultImpl())
{
return;
}
}
for (int iI = 0; iI < GC.getMapINLINE().numPlotsINLINE(); iI++)
{
CvPlot* pPlot = GC.getMapINLINE().plotByIndexINLINE(iI);
FAssert(pPlot != NULL);
for (int iJ = 0; iJ < GC.getNumFeatureInfos(); iJ++)
{
if (pPlot->canHaveFeature((FeatureTypes)iJ))
{
if (GC.getGameINLINE().getMapRandNum(10000, "addFeaturesAtPlot") < GC.getFeatureInfo((FeatureTypes)iJ).getAppearanceProbability())
{
pPlot->setFeatureType((FeatureTypes)iJ);
}
}
}
}
}
static FObject ResolvedGet(FObject env, FObject symid)
{
FAssert(IdentifierP(symid) || SymbolP(symid));
if (IdentifierP(symid))
{
while (IdentifierP(AsIdentifier(symid)->Wrapped))
{
env = AsSyntacticEnv(AsIdentifier(symid)->SyntacticEnv)->GlobalBindings;
symid = AsIdentifier(symid)->Wrapped;
}
}
FAssert(EnvironmentP(env));
return(EnvironmentGet(env, symid));
}
void EnvironmentImportSet(FObject env, FObject is, FObject form)
{
FObject ilst = DoImportSet(env, is, form);
while (PairP(ilst))
{
FAssert(GlobalP(First(ilst)));
if (EnvironmentImportGlobal(env, First(ilst)))
RaiseExceptionC(R.Syntax, "import", "expected an undefined identifier",
List(AsGlobal(First(ilst))->Name, form));
ilst = Rest(ilst);
}
FAssert(ilst == EmptyListObject);
}
FObject EnvironmentGet(FObject env, FObject symid)
{
if (IdentifierP(symid))
symid = AsIdentifier(symid)->Symbol;
FAssert(SymbolP(symid));
FObject gl = EqHashMapRef(AsEnvironment(env)->HashMap, symid, FalseObject);
if (GlobalP(gl))
{
FAssert(BoxP(AsGlobal(gl)->Box));
return(Unbox(AsGlobal(gl)->Box));
}
return(NoValueObject);
}
//
// Player record accessor
//
CvPlayerRecord *CvStatistics::getPlayerRecord(int iIndex)
{
FAssert(iIndex >= 0);
FAssert(iIndex < MAX_PLAYERS);
if ( iIndex >= (int)m_PlayerRecords.size() || m_PlayerRecords[iIndex] == NULL )
{
CvPlayerRecord *pRecord = new CvPlayerRecord;
pRecord->init();
pRecord->setPlayerID( iIndex );
m_PlayerRecords.resize(iIndex + 1, NULL);
m_PlayerRecords[iIndex] = pRecord;
}
return m_PlayerRecords[iIndex];
}
void CvNetChangeVassal::Execute()
{
if (m_ePlayer != NO_PLAYER)
{
FAssert(GET_PLAYER(m_ePlayer).getTeam() != m_eMasterTeam);
GET_TEAM(GET_PLAYER(m_ePlayer).getTeam()).setVassal(m_eMasterTeam, m_bVassal, m_bCapitulated);
}
}
/// Get a specific entry
CvNotificationEntry *CvNotificationXMLEntries::GetEntry(int index)
{
FAssert(index < static_cast<int>(m_paNotificationEntries.size()));
if(index < static_cast<int>(m_paNotificationEntries.size()))
return m_paNotificationEntries[index];
return NULL;
}
static FObject CheckForRename(FObject nam, FObject rlst)
{
FAssert(SymbolP(nam));
while (PairP(rlst))
{
FObject rnm = First(rlst);
FAssert(PairP(rnm));
FAssert(PairP(Rest(rnm)));
if (SymbolP(First(rnm)))
{
FAssert(SymbolP(First(Rest(rnm))));
if (nam == First(rnm))
return(First(Rest(rnm)));
}
else
{
FAssert(IdentifierP(First(rnm)));
FAssert(IdentifierP(First(Rest(rnm))));
if (nam == AsIdentifier(First(rnm))->Symbol)
return(AsIdentifier(First(Rest(rnm)))->Symbol);
}
rlst = Rest(rlst);
}
FAssert(rlst == EmptyListObject);
return(NoValueObject);
}
// ---------------------------------------------------------------------------
/// Have we gotten this type of Goody lately? (in the last 3 Goodies, defined by NUM_GOODIES_REMEMBERED)
bool CvGoodyHuts::IsHasPlayerReceivedGoodyLately(PlayerTypes ePlayer, GoodyTypes eGoody)
{
FAssert(ePlayer >= 0);
FAssert(ePlayer < MAX_MAJOR_CIVS);
FAssert(eGoody >= 0);
// FAssert(eGoody < DB.count("GoodyHuts"));
// Look at all of our Goody slots and see if the requested Goody matches anything
for (int iGoodySlotLoop = 0; iGoodySlotLoop < NUM_GOODIES_REMEMBERED; iGoodySlotLoop++)
{
if (m_aaiPlayerGoodyHutResults[ePlayer][iGoodySlotLoop] == eGoody)
{
return true;
}
}
return false;
}
//------------------------------------------------------------------------------
void CvDllNetMessageHandler::ResponseIgnoreWarning(PlayerTypes ePlayer, TeamTypes eRivalTeam)
{
CvPlayerAI& kPlayer = GET_PLAYER(ePlayer);
CvTeam& kTeam = GET_TEAM(kPlayer.getTeam());
const TeamTypes eTeam = kPlayer.getTeam();
FAssert(eTeam != eRivalTeam);
kTeam.PushIgnoreWarning(eRivalTeam);
}
//------------------------------------------------------------------------------
bool CvDllUnit::CanSwapWithUnitHere(ICvPlot1* pPlot) const
{
CvPlot* pkPlot = (NULL != pPlot)? static_cast<CvDllPlot*>(pPlot)->GetInstance() : NULL;
FAssert(pkPlot != NULL);
if(pkPlot != NULL)
return m_pUnit->CanSwapWithUnitHere(*pkPlot);
else
return false;
}
/// Changes the Priority Level the player has for a particular Grand Strategy
void CvGrandStrategyAI::ChangeGrandStrategyPriority(AIGrandStrategyTypes eGrandStrategy, int iChange)
{
FAssert(eGrandStrategy != NO_AIGRANDSTRATEGY);
if(iChange != 0)
{
m_paiGrandStrategyPriority[eGrandStrategy] += iChange;
}
}
void CvArea::changeNumTrainAIUnits(PlayerTypes eIndex1, UnitAITypes eIndex2, int iChange)
{
FAssertMsg(eIndex1 >= 0, "eIndex1 is expected to be >= 0");
FAssertMsg(eIndex1 < MAX_PLAYERS, "eIndex1 is expected to be < MAX_PLAYERS");
FAssertMsg(eIndex2 >= 0, "eIndex2 is expected to be >= 0");
FAssertMsg(eIndex2 < NUM_UNITAI_TYPES, "eIndex2 is expected to be < NUM_UNITAI_TYPES");
m_aaiNumTrainAIUnits[eIndex1][eIndex2] += iChange;
FAssert(getNumTrainAIUnits(eIndex1, eIndex2) >= 0);
}
static FObject FindLibrary(FObject nam)
{
FObject ll = R.LoadedLibraries;
while (PairP(ll))
{
FAssert(LibraryP(First(ll)));
if (EqualP(AsLibrary(First(ll))->Name, nam))
return(First(ll));
ll = Rest(ll);
}
FAssert(ll == EmptyListObject);
return(NoValueObject);
}
static int_t EqualToSymbol(FObject obj, FObject sym)
{
FAssert(SymbolP(sym));
if (IdentifierP(obj))
return(AsIdentifier(obj)->Symbol == sym);
return(obj == sym);
}
/// Change the number of turns since the Active Strategy was last set
void CvGrandStrategyAI::ChangeNumTurnsSinceActiveSet(int iChange)
{
if(iChange != 0)
{
m_iNumTurnsSinceActiveSet += iChange;
}
FAssert(m_iNumTurnsSinceActiveSet >= 0);
}
// Returns ratio of strengths of stacks times 100
// (so 100 is even ratio, numbers over 100 mean this group is more powerful than the stack on a plot)
int CvSelectionGroupAI::AI_compareStacks(const CvPlot* pPlot, bool bPotentialEnemy, bool bCheckCanAttack, bool bCheckCanMove) const
{
FAssert(pPlot != NULL);
int compareRatio;
DomainTypes eDomainType = getDomainType();
// if not aircraft, then choose based on the plot, not the head unit (mainly for transport carried units)
if (eDomainType != DOMAIN_AIR)
{
if (pPlot->isWater())
eDomainType = DOMAIN_SEA;
else
eDomainType = DOMAIN_LAND;
}
compareRatio = AI_sumStrength(pPlot, eDomainType, bCheckCanAttack, bCheckCanMove);
compareRatio *= 100;
PlayerTypes eOwner = getOwnerINLINE();
if (eOwner == NO_PLAYER)
{
eOwner = getHeadOwner();
}
FAssert(eOwner != NO_PLAYER);
/************************************************************************************************/
/* UNOFFICIAL_PATCH 03/04/10 jdog5000 */
/* */
/* Bugfix */
/************************************************************************************************/
/* original bts code
int defenderSum = pPlot->AI_sumStrength(NO_PLAYER, getOwnerINLINE(), eDomainType, true, !bPotentialEnemy, bPotentialEnemy);
*/
// Clearly meant to use eOwner here ...
int defenderSum = pPlot->AI_sumStrength(NO_PLAYER, eOwner, eDomainType, true, !bPotentialEnemy, bPotentialEnemy);
/************************************************************************************************/
/* UNOFFICIAL_PATCH END */
/************************************************************************************************/
compareRatio /= std::max(1, defenderSum);
return compareRatio;
}
FObject VectorToList(FObject vec)
{
FAssert(VectorP(vec));
FObject lst = EmptyListObject;
for (int_t idx = (int_t) VectorLength(vec) - 1; idx >= 0; idx--)
lst = MakePair(AsVector(vec)->Vector[idx], lst);
return(lst);
}
void CvArea::changeNumAIUnits(PlayerTypes eIndex1, UnitAITypes eIndex2, int iChange)
{
FAssertMsg(eIndex1 >= 0, "eIndex1 is expected to be >= 0");
FAssertMsg(eIndex1 < MAX_PLAYERS, "eIndex1 is expected to be < MAX_PLAYERS");
if (eIndex2 != NO_UNITAI)
{
m_aaiNumAIUnits[eIndex1][eIndex2] += iChange;
FAssert(getNumAIUnits(eIndex1, eIndex2) >= 0);
}
}
