Subversion Repositories RAND

Rev

Rev 1037 | Rev 1048 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

// team.cpp

#include "CvGameCoreDLL.h"
#include "CvPlayerAI.h"
#include "CvDefines.h"
#include "CvGameCoreUtils.h"
#include "cvGlobals.h"
#include "CvTeamAI.h"
#include "CvPlayerAI.h"
#include "CvGameAI.h"
#include "CvMap.h"
#include "CvPlot.h"
#include "CvTeam.h"
#include "CvDLLInterfaceIFaceBase.h"
#include "CvEventReporter.h"
#include "CvDLLEngineIFaceBase.h"
#include "CvArtFileMgr.h"
#include "CvDiploParameters.h"
#include "CvInfos.h"
#include "CvPopupInfo.h"
#include "CvDLLPythonIFaceBase.h"
#include "CyArgsList.h"
#include "FProfiler.h"
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      10/02/09                                jdog5000      */
/*                                                                                              */
/* AI logging                                                                                   */
/************************************************************************************************/
#include "BetterBTSAI.h"
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/
/************************************************************************************************/
/* REVOLUTION_MOD                         10/22/08                                jdog5000      */
/*                                                                                              */
/*                                                                                              */
/************************************************************************************************/
#include "CvInitCore.h"
/************************************************************************************************/
/* REVOLUTION_MOD                          END                                                  */
/************************************************************************************************/
int AGBuilt = 0; //code added by 45� for Ascension Gate & Mastery Victory
// Public Functions...
#pragma warning( disable : 4355 )
CvTeam::CvTeam() : m_GameObject(this),
m_Properties(this)
{
        m_aiStolenVisibilityTimer = new int[MAX_TEAMS];
        m_aiWarWearinessTimes100 = new int[MAX_TEAMS];
        m_aiTechShareCount = new int[MAX_TEAMS];
        m_aiCommerceFlexibleCount = new int[NUM_COMMERCE_TYPES];
        m_aiExtraMoves = new int[NUM_DOMAIN_TYPES];

        m_aiEspionagePointsAgainstTeam = new int[MAX_TEAMS];
        m_aiCounterespionageTurnsLeftAgainstTeam = new int[MAX_TEAMS];
        m_aiCounterespionageModAgainstTeam = new int[MAX_TEAMS];

        m_abAtWar = new bool[MAX_TEAMS];
        m_abHasMet = new bool[MAX_TEAMS];
        m_abHasSeen = new bool[MAX_TEAMS]; // K-Mod
        m_abPermanentWarPeace = new bool[MAX_TEAMS];
        m_abOpenBorders = new bool[MAX_TEAMS];
        m_abDefensivePact = new bool[MAX_TEAMS];
        m_abForcePeace = new bool[MAX_TEAMS];
        m_abVassal = new bool[MAX_TEAMS];
        m_abCanLaunch = NULL;

/************************************************************************************************/
/* REVOLUTION_MOD                         01/01/08                                jdog5000      */
/*                                                                                              */
/*                                                                                              */
/************************************************************************************************/
        m_abIsRebelAgainst = new bool[MAX_TEAMS];
/************************************************************************************************/
/* REVOLUTION_MOD                          END                                                  */
/************************************************************************************************/
        m_paiRouteChange = NULL;
        m_paiProjectCount = NULL;
        m_paiProjectDefaultArtTypes = NULL;
        m_pavProjectArtTypes = NULL;
        m_paiProjectMaking = NULL;
        m_paiUnitClassCount = NULL;
        m_paiBuildingClassCount = NULL;
        m_paiObsoleteBuildingCount = NULL;
        m_paiResearchProgress = NULL;
        m_paiTechCount = NULL;
        m_paiTerrainTradeCount = NULL;
        m_aiVictoryCountdown = NULL;
        m_aiForceTeamVoteEligibilityCount = NULL;

        m_pabHasTech = NULL;
        m_pabNoTradeTech = NULL;

        m_ppaaiImprovementYieldChange = NULL;
       
/************************************************************************************************/
/* Afforess                       Start          03/15/10                                               */
/*                                                                                              */
/*                                                                                              */
/************************************************************************************************/
        m_ppiBuildingCommerceChange = NULL;
        m_ppiBuildingYieldChange = NULL;
        m_ppiBuildingSpecialistChange = NULL;
        m_ppiBuildingCommerceModifier = NULL;
        m_ppiBuildingYieldModifier = NULL;
        m_paiTechExtraBuildingHappiness = NULL;
        m_paiTechExtraBuildingHealth = NULL;
        m_abEmbassy = new bool[MAX_TEAMS];
        m_abLimitedBorders = new bool[MAX_TEAMS];
        m_abFreeTrade = new bool[MAX_TEAMS];
        m_paiFreeSpecialistCount = NULL;
        m_paiUnitClassStrengthChange = NULL;
        m_abHasEverMet = new bool[MAX_TEAMS];
        m_aiFailedContactChecks = new int[MAX_TEAMS];
/************************************************************************************************/
/* Afforess                          END                                                            */
/************************************************************************************************/



        reset((TeamTypes)0, true);
}


CvTeam::~CvTeam()
{
        uninit();

        SAFE_DELETE_ARRAY(m_aiStolenVisibilityTimer);
        SAFE_DELETE_ARRAY(m_aiWarWearinessTimes100);
        SAFE_DELETE_ARRAY(m_aiTechShareCount);
        SAFE_DELETE_ARRAY(m_aiCommerceFlexibleCount);
        SAFE_DELETE_ARRAY(m_aiExtraMoves);
        SAFE_DELETE_ARRAY(m_aiEspionagePointsAgainstTeam);
        SAFE_DELETE_ARRAY(m_aiCounterespionageTurnsLeftAgainstTeam);
        SAFE_DELETE_ARRAY(m_aiCounterespionageModAgainstTeam);
        SAFE_DELETE_ARRAY(m_abAtWar);
        SAFE_DELETE_ARRAY(m_abHasMet);
        SAFE_DELETE_ARRAY(m_abHasSeen); // K-Mod
        SAFE_DELETE_ARRAY(m_abPermanentWarPeace);
        SAFE_DELETE_ARRAY(m_abOpenBorders);
        SAFE_DELETE_ARRAY(m_abDefensivePact);
        SAFE_DELETE_ARRAY(m_abForcePeace);
        SAFE_DELETE_ARRAY(m_abVassal);
/************************************************************************************************/
/* REVOLUTION_MOD                         01/01/08                                jdog5000      */
/*                                                                                              */
/*                                                                                              */
/************************************************************************************************/
        SAFE_DELETE_ARRAY(m_abIsRebelAgainst);
/************************************************************************************************/
/* REVOLUTION_MOD                          END                                                  */
/************************************************************************************************/
/************************************************************************************************/
/* Afforess                       Start          03/15/10                                               */
/*                                                                                              */
/*                                                                                              */
/************************************************************************************************/
        SAFE_DELETE_ARRAY(m_abEmbassy);
        SAFE_DELETE_ARRAY(m_abLimitedBorders);
        SAFE_DELETE_ARRAY(m_abFreeTrade);
        SAFE_DELETE_ARRAY(m_abHasEverMet); //Rhye      
        SAFE_DELETE_ARRAY(m_aiFailedContactChecks);
/************************************************************************************************/
/* Afforess                          END                                                            */
/************************************************************************************************/

}

void CvTeam::init(TeamTypes eID)
{
        init(eID, true);
}

void CvTeam::init(TeamTypes eID, bool bDeclareWar)
{
        //--------------------------------
        // Init saved data
        reset(eID);

        //--------------------------------
        // Init non-saved data

        //--------------------------------
        // Init other game data
        AI_init();

/************************************************************************************************/
/* REVOLUTION_MOD                         05/30/08                                jdog5000      */
/*                                                                                              */
/*                                                                                              */
/************************************************************************************************/
        if( GC.getGame().isFinalInitialized() && bDeclareWar)
        {
                //logMsg("   Checking for declarations of war against reset team %d", (int)getID() );
       
                for (int iI = 0; iI < MAX_TEAMS; iI++)
                {
                        if( iI != getID() )
                        {
                                if( GET_TEAM((TeamTypes)iI).isMinorCiv() )
                                {
                                        GET_TEAM((TeamTypes)iI).declareWar(getID(), false, WARPLAN_LIMITED);
                                        GET_TEAM((TeamTypes)iI).setHasMet(getID(),false);
                                        setHasMet((TeamTypes)iI,false);
                                        //logMsg("   Minor team %d declared war, using war plan %d", iI, (int)GET_TEAM((TeamTypes)iI).AI_getWarPlan(getID()) );
                                }
                                if( GET_TEAM((TeamTypes)iI).isBarbarian() )
                                {
                                        GET_TEAM((TeamTypes)iI).declareWar(getID(), false, WARPLAN_LIMITED);
                                        //logMsg("   Barb team %d declared war, using war plan %d", iI, (int)GET_TEAM((TeamTypes)iI).AI_getWarPlan(getID()) );
                                }
                        }
                }
        }
/************************************************************************************************/
/* REVOLUTION_MOD                          END                                                  */
/************************************************************************************************/
}


void CvTeam::uninit()
{
        int iI;

        SAFE_DELETE_ARRAY(m_abCanLaunch);

        SAFE_DELETE_ARRAY(m_paiRouteChange);
        SAFE_DELETE_ARRAY(m_paiProjectCount);
        SAFE_DELETE_ARRAY(m_paiProjectDefaultArtTypes);
        SAFE_DELETE_ARRAY(m_pavProjectArtTypes);
        SAFE_DELETE_ARRAY(m_paiProjectMaking);
        SAFE_DELETE_ARRAY(m_paiUnitClassCount);
        SAFE_DELETE_ARRAY(m_paiBuildingClassCount);
        SAFE_DELETE_ARRAY(m_paiObsoleteBuildingCount);
        SAFE_DELETE_ARRAY(m_paiResearchProgress);
        SAFE_DELETE_ARRAY(m_paiTechCount);
        SAFE_DELETE_ARRAY(m_paiTerrainTradeCount);
        SAFE_DELETE_ARRAY(m_aiVictoryCountdown);
        SAFE_DELETE_ARRAY(m_aiForceTeamVoteEligibilityCount);

        SAFE_DELETE_ARRAY(m_pabHasTech);
        SAFE_DELETE_ARRAY(m_pabNoTradeTech);

        if (m_ppaaiImprovementYieldChange != NULL)
        {
                for (iI = 0; iI < GC.getNumImprovementInfos(); iI++)
                {
                        SAFE_DELETE_ARRAY(m_ppaaiImprovementYieldChange[iI]);
                }
                SAFE_DELETE_ARRAY(m_ppaaiImprovementYieldChange);
        }
       
/************************************************************************************************/
/* Afforess                       Start          03/15/10                                               */
/*                                                                                              */
/*                                                                                              */
/************************************************************************************************/
        SAFE_DELETE_ARRAY(m_paiTechExtraBuildingHappiness);
        SAFE_DELETE_ARRAY(m_paiTechExtraBuildingHealth);
        SAFE_DELETE_ARRAY(m_paiFreeSpecialistCount);
        SAFE_DELETE_ARRAY(m_paiUnitClassStrengthChange);
        if (m_ppiBuildingCommerceChange != NULL)
        {
                for (iI = 0; iI < GC.getNumBuildingInfos(); iI++)
                {
                        SAFE_DELETE_ARRAY(m_ppiBuildingCommerceChange[iI]);
                }
                SAFE_DELETE_ARRAY(m_ppiBuildingCommerceChange);
        }

        if (m_ppiBuildingYieldChange != NULL)
        {
                for (iI = 0; iI < GC.getNumBuildingInfos(); iI++)
                {
                        SAFE_DELETE_ARRAY(m_ppiBuildingYieldChange[iI]);
                }
                SAFE_DELETE_ARRAY(m_ppiBuildingYieldChange);
        }

        if (m_ppiBuildingSpecialistChange != NULL)
        {
                for (iI = 0; iI < GC.getNumBuildingInfos(); iI++)
                {
                        SAFE_DELETE_ARRAY(m_ppiBuildingSpecialistChange[iI]);
                }
                SAFE_DELETE_ARRAY(m_ppiBuildingSpecialistChange);
        }

        if (m_ppiBuildingCommerceModifier != NULL)
        {
                for (iI = 0; iI < GC.getNumBuildingInfos(); iI++)
                {
                        SAFE_DELETE_ARRAY(m_ppiBuildingCommerceModifier[iI]);
                }
                SAFE_DELETE_ARRAY(m_ppiBuildingCommerceModifier);
        }

        if (m_ppiBuildingYieldModifier != NULL)
        {
                for (iI = 0; iI < GC.getNumBuildingInfos(); iI++)
                {
                        SAFE_DELETE_ARRAY(m_ppiBuildingYieldModifier[iI]);
                }
                SAFE_DELETE_ARRAY(m_ppiBuildingYieldModifier);
        }

/************************************************************************************************/
/* Afforess                          END                                                            */
/************************************************************************************************/

}


// FUNCTION: reset()
// Initializes data members that are serialized.
void CvTeam::reset(TeamTypes eID, bool bConstructorCall)
{
        int iI, iJ;

        //--------------------------------
        // Uninit class
        uninit();

        m_iNumMembers = 0;
        m_iAliveCount = 0;
        m_iEverAliveCount = 0;
        m_iNumCities = 0;
        m_iTotalPopulation = 0;
        m_iTotalLand = 0;
        m_iNukeInterception = 0;
        m_iExtraWaterSeeFromCount = 0;
        m_iMapTradingCount = 0;
        m_iTechTradingCount = 0;
        m_iGoldTradingCount = 0;
/************************************************************************************************/
/* Afforess                       Start          03/8/10                                                */
/*                                                                                              */
/*                                                                                              */
/************************************************************************************************/
        m_iCanPassPeaksCount = 0;
        m_iMoveFastPeaksCount = 0;
        m_iCanFoundOnPeaksCount = 0;
        m_iRebaseAnywhereCount = 0;
        m_iForeignTradeModifier = 0;
        m_iTradeModifier = 0;
        m_iTradeMissionModifier = 0;
        m_iCorporationRevenueModifier = 0;
        m_iCorporationMaintenanceModifier = 0;
        m_iEmbassyTradingCount = 0;
        m_iLimitedBordersTradingCount = 0;
        m_iCanFarmDesertCount = 0;
/************************************************************************************************/
/* Afforess                          END                                                            */
/************************************************************************************************/
        m_iOpenBordersTradingCount = 0;
        m_iDefensivePactTradingCount = 0;
        m_iPermanentAllianceTradingCount = 0;
        m_iVassalTradingCount = 0;
        m_iBridgeBuildingCount = 0;
        m_iIrrigationCount = 0;
        m_iIgnoreIrrigationCount = 0;
        m_iWaterWorkCount = 0;
        m_iVassalPower = 0;
        m_iMasterPower = 0;
        m_iEnemyWarWearinessModifier = 0;
        m_iRiverTradeCount = 0;
        m_iEspionagePointsEver = 0;

        m_bMapCentering = false;
        m_bCapitulated = false;

        m_eID = eID;

        for (iI = 0; iI < MAX_TEAMS; iI++)
        {
                m_aiStolenVisibilityTimer[iI] = 0;
                m_aiWarWearinessTimes100[iI] = 0;
                m_aiTechShareCount[iI] = 0;
                m_aiEspionagePointsAgainstTeam[iI] = 0;
                m_aiCounterespionageTurnsLeftAgainstTeam[iI] = 0;
                m_aiCounterespionageModAgainstTeam[iI] = 0;
                m_abHasMet[iI] = false;
                m_abHasSeen[iI] = false; // K-Mod
                m_abAtWar[iI] = false;
                m_abPermanentWarPeace[iI] = false;
                m_abOpenBorders[iI] = false;
/************************************************************************************************/
/* Afforess                       Start          03/8/10                                                */
/*                                                                                              */
/*                                                                                              */
/************************************************************************************************/
                m_abLimitedBorders[iI] = false;
                m_abFreeTrade[iI] = false;
                m_abEmbassy[iI] = false;
                m_abHasEverMet[iI] = false; //Rhye             
                m_aiFailedContactChecks[iI] = 0;
/************************************************************************************************/
/* Afforess                          END                                                            */
/************************************************************************************************/
                m_abDefensivePact[iI] = false;
                m_abForcePeace[iI] = false;
                m_abVassal[iI] = false;
/************************************************************************************************/
/* REVOLUTION_MOD                         01/01/08                                jdog5000      */
/*                                                                                              */
/*                                                                                              */
/************************************************************************************************/
                m_abIsRebelAgainst[iI] = false;
/************************************************************************************************/
/* REVOLUTION_MOD                          END                                                  */
/************************************************************************************************/

                if (!bConstructorCall && getID() != NO_TEAM)
                {
                        CvTeam& kLoopTeam = GET_TEAM((TeamTypes) iI);
                        kLoopTeam.m_aiStolenVisibilityTimer[getID()] = 0;
                        kLoopTeam.m_aiWarWearinessTimes100[getID()] = 0;
                        kLoopTeam.m_aiTechShareCount[getID()] = 0;
                        kLoopTeam.m_aiEspionagePointsAgainstTeam[getID()] = 0;
                        kLoopTeam.m_aiCounterespionageTurnsLeftAgainstTeam[getID()] = 0;
                        kLoopTeam.m_aiCounterespionageModAgainstTeam[getID()] = 0;
                        kLoopTeam.m_abHasMet[getID()] = false;
                        kLoopTeam.m_abHasSeen[getID()] = false; // K-Mod
                        kLoopTeam.m_abAtWar[getID()] = false;
                        kLoopTeam.m_abPermanentWarPeace[getID()] = false;
                        kLoopTeam.m_abOpenBorders[getID()] = false;
                       
/************************************************************************************************/
/* Afforess                       Start          03/8/10                                                */
/*                                                                                              */
/*                                                                                              */
/************************************************************************************************/
                        kLoopTeam.m_abEmbassy[getID()] = false;
                        kLoopTeam.m_abHasEverMet[getID()] = false; //Rhye              
                        kLoopTeam.m_aiFailedContactChecks[getID()] = 0;
                        kLoopTeam.m_abLimitedBorders[getID()] = false;
                        kLoopTeam.m_abFreeTrade[getID()] = false;
/************************************************************************************************/
/* Afforess                          END                                                            */
/************************************************************************************************/
                        kLoopTeam.m_abDefensivePact[getID()] = false;
                        kLoopTeam.m_abForcePeace[getID()] = false;
                        kLoopTeam.m_abVassal[getID()] = false;
                }
        }

        for (iI = 0; iI < NUM_COMMERCE_TYPES; iI++)
        {
                m_aiCommerceFlexibleCount[iI] = 0;
        }

        for (iI = 0; iI < NUM_DOMAIN_TYPES; iI++)
        {
                m_aiExtraMoves[iI] = 0;
        }

        if (!bConstructorCall)
        {
                FAssertMsg(m_abCanLaunch==NULL, "about to leak memory, CvTeam::m_abCanLaunch");
                m_abCanLaunch = new bool[GC.getNumVictoryInfos()];
                for (iI = 0; iI < GC.getNumVictoryInfos(); iI++)
                {
                        m_abCanLaunch[iI] = false;
                }

                FAssertMsg(m_paiRouteChange==NULL, "about to leak memory, CvTeam::m_paiRouteChange");
                m_paiRouteChange = new int[GC.getNumRouteInfos()];
                for (iI = 0; iI < GC.getNumRouteInfos(); iI++)
                {
                        m_paiRouteChange[iI] = 0;
                }

                FAssertMsg(m_paiProjectCount==NULL, "about to leak memory, CvPlayer::m_paiProjectCount");
                m_paiProjectCount = new int [GC.getNumProjectInfos()];
                FAssertMsg(m_paiProjectDefaultArtTypes==NULL, "about to leak memory, CvPlayer::m_paiProjectDefaultArtTypes");
                m_paiProjectDefaultArtTypes = new int [GC.getNumProjectInfos()];
                FAssertMsg(m_pavProjectArtTypes==NULL, "about to leak memory, CvPlayer::m_pavProjectArtTypes");
                m_pavProjectArtTypes = new std::vector<int> [GC.getNumProjectInfos()];
                FAssertMsg(m_paiProjectMaking==NULL, "about to leak memory, CvPlayer::m_paiProjectMaking");
                m_paiProjectMaking = new int [GC.getNumProjectInfos()];
                for (iI = 0; iI < GC.getNumProjectInfos(); iI++)
                {
                        m_paiProjectCount[iI] = 0;
                        m_paiProjectDefaultArtTypes[iI] = 0;
                        m_paiProjectMaking[iI] = 0;
                }

                FAssertMsg(m_paiUnitClassCount==NULL, "about to leak memory, CvTeam::m_paiUnitClassCount");
                m_paiUnitClassCount = new int [GC.getNumUnitClassInfos()];
                for (iI = 0; iI < GC.getNumUnitClassInfos(); iI++)
                {
                        m_paiUnitClassCount[iI] = 0;
                }

                FAssertMsg(m_paiBuildingClassCount==NULL, "about to leak memory, CvTeam::m_paiBuildingClassCount");
                m_paiBuildingClassCount = new int [GC.getNumBuildingClassInfos()];
                for (iI = 0; iI < GC.getNumBuildingClassInfos(); iI++)
                {
                        m_paiBuildingClassCount[iI] = 0;
                }

                FAssertMsg(m_paiObsoleteBuildingCount==NULL, "about to leak memory, CvTeam::m_paiObsoleteBuildingCount");
                m_paiObsoleteBuildingCount = new int[GC.getNumBuildingInfos()];
                for (iI = 0; iI < GC.getNumBuildingInfos(); iI++)
                {
                        m_paiObsoleteBuildingCount[iI] = 0;
                }

                FAssertMsg(m_paiResearchProgress==NULL, "about to leak memory, CvPlayer::m_paiResearchProgress");
                m_paiResearchProgress = new int [GC.getNumTechInfos()];
                FAssertMsg(m_paiTechCount==NULL, "about to leak memory, CvPlayer::m_paiTechCount");
                m_paiTechCount = new int [GC.getNumTechInfos()];
                for (iI = 0; iI < GC.getNumTechInfos(); iI++)
                {
                        m_paiResearchProgress[iI] = 0;
                        m_paiTechCount[iI] = 0;
                }

                FAssertMsg(m_paiTerrainTradeCount==NULL, "about to leak memory, CvTeam::m_paiTerrainTradeCount");
                m_paiTerrainTradeCount = new int[GC.getNumTerrainInfos()];
                for (iI = 0; iI < GC.getNumTerrainInfos(); iI++)
                {
                        m_paiTerrainTradeCount[iI] = 0;
                }

                FAssertMsg(m_aiVictoryCountdown==NULL, "about to leak memory, CvTeam::m_aiVictoryCountdown");
                m_aiVictoryCountdown = new int[GC.getNumVictoryInfos()];
                for (iI = 0; iI < GC.getNumVictoryInfos(); iI++)
                {
                        m_aiVictoryCountdown[iI] = -1;
                }
               
                FAssertMsg(m_paiTechExtraBuildingHappiness==NULL, "about to leak memory, m_paiTechExtraBuildingHappiness"); //Afforess
                m_paiTechExtraBuildingHappiness = new int[GC.getNumBuildingInfos()];
                for (iI = 0; iI < GC.getNumBuildingInfos(); iI++)
                {
                        m_paiTechExtraBuildingHappiness[iI] = 0;
                }
               
                FAssertMsg(m_paiTechExtraBuildingHealth==NULL, "about to leak memory, m_paiTechExtraBuildingHealth");
                m_paiTechExtraBuildingHealth = new int[GC.getNumBuildingInfos()];
                for (iI = 0; iI < GC.getNumBuildingInfos(); iI++)
                {
                        m_paiTechExtraBuildingHealth[iI] = 0;
                }
               

                FAssertMsg(m_pabHasTech==NULL, "about to leak memory, CvTeam::m_pabHasTech");
                m_pabHasTech = new bool[GC.getNumTechInfos()];
                FAssertMsg(m_pabNoTradeTech==NULL, "about to leak memory, CvTeam::m_pabNoTradeTech");
                m_pabNoTradeTech = new bool[GC.getNumTechInfos()];
                for (iI = 0; iI < GC.getNumTechInfos(); iI++)
                {
                        m_pabHasTech[iI] = false;
                        m_pabNoTradeTech[iI] = false;
                }

                FAssertMsg(m_ppaaiImprovementYieldChange==NULL, "about to leak memory, CvTeam::m_ppaaiImprovementYieldChange");
                m_ppaaiImprovementYieldChange = new int*[GC.getNumImprovementInfos()];
                for (iI = 0; iI < GC.getNumImprovementInfos(); iI++)
                {
                        m_ppaaiImprovementYieldChange[iI] = new int[NUM_YIELD_TYPES];
                        for (iJ = 0; iJ < NUM_YIELD_TYPES; iJ++)
                        {
                                m_ppaaiImprovementYieldChange[iI][iJ] = 0;
                        }
                }
               
                FAssertMsg(m_aiForceTeamVoteEligibilityCount==NULL, "about to leak memory, CvTeam::m_aiForceTeamVoteEligibilityCount");
                m_aiForceTeamVoteEligibilityCount = new int[GC.getNumVoteSourceInfos()];
                for (iI = 0; iI < GC.getNumVoteSourceInfos(); iI++)
                {
                        m_aiForceTeamVoteEligibilityCount[iI] = 0;
                }

                m_aeRevealedBonuses.clear();

/************************************************************************************************/
/* Afforess                       Start          03/8/10                                                */
/*                                                                                              */
/*                                                                                              */
/************************************************************************************************/

                FAssertMsg(m_ppiBuildingCommerceChange==NULL, "about to leak memory, CvTeam::m_ppiBuildingCommerceChange");
                m_ppiBuildingCommerceChange = new int*[GC.getNumBuildingInfos()];
                for (iI = 0; iI < GC.getNumBuildingInfos(); iI++)
                {
                        m_ppiBuildingCommerceChange[iI] = new int[NUM_COMMERCE_TYPES];
                        for (iJ = 0; iJ < NUM_COMMERCE_TYPES; iJ++)
                        {
                                m_ppiBuildingCommerceChange[iI][iJ] = 0;
                        }
                }

                FAssertMsg(m_ppiBuildingYieldChange==NULL, "about to leak memory, CvTeam::m_ppiBuildingYieldChange");
                m_ppiBuildingYieldChange = new int*[GC.getNumBuildingInfos()];
                for (iI = 0; iI < GC.getNumBuildingInfos(); iI++)
                {
                        m_ppiBuildingYieldChange[iI] = new int[NUM_YIELD_TYPES];
                        for (iJ = 0; iJ < NUM_YIELD_TYPES; iJ++)
                        {
                                m_ppiBuildingYieldChange[iI][iJ] = 0;
                        }
                }

                FAssertMsg(m_ppiBuildingSpecialistChange==NULL, "about to leak memory, CvTeam::m_ppiBuildingSpecialistChange");
                m_ppiBuildingSpecialistChange = new int*[GC.getNumBuildingInfos()];
                for (iI = 0; iI < GC.getNumBuildingInfos(); iI++)
                {
                        m_ppiBuildingSpecialistChange[iI] = new int[GC.getNumSpecialistInfos()];
                        for (iJ = 0; iJ < GC.getNumSpecialistInfos(); iJ++)
                        {
                                m_ppiBuildingSpecialistChange[iI][iJ] = 0;
                        }
                }
                FAssertMsg(m_paiFreeSpecialistCount==NULL, "about to leak memory, CvTeam::m_paiFreeSpecialistCount");
                m_paiFreeSpecialistCount = new int[GC.getNumSpecialistInfos()];
                for (iJ = 0; iJ < GC.getNumSpecialistInfos(); iJ++)
                {
                        m_paiFreeSpecialistCount[iJ] = 0;
                }

                FAssertMsg(m_ppiBuildingCommerceModifier==NULL, "about to leak memory, CvTeam::m_ppiBuildingCommerceModifier");
                m_ppiBuildingCommerceModifier = new int*[GC.getNumBuildingInfos()];
                for (iI = 0; iI < GC.getNumBuildingInfos(); iI++)
                {
                        m_ppiBuildingCommerceModifier[iI] = new int[NUM_COMMERCE_TYPES];
                        for (iJ = 0; iJ < NUM_COMMERCE_TYPES; iJ++)
                        {
                                m_ppiBuildingCommerceModifier[iI][iJ] = 0;
                        }
                }

                FAssertMsg(m_ppiBuildingYieldModifier==NULL, "about to leak memory, CvTeam::m_ppiBuildingYieldModifier");
                m_ppiBuildingYieldModifier = new int*[GC.getNumBuildingInfos()];
                for (iI = 0; iI < GC.getNumBuildingInfos(); iI++)
                {
                        m_ppiBuildingYieldModifier[iI] = new int[NUM_YIELD_TYPES];
                        for (iJ = 0; iJ < NUM_YIELD_TYPES; iJ++)
                        {
                                m_ppiBuildingYieldModifier[iI][iJ] = 0;
                        }
                }
                FAssertMsg(m_paiUnitClassStrengthChange==NULL, "about to leak memory, CvTeam::m_paiUnitClassStrengthChange");
                m_paiUnitClassStrengthChange = new int[GC.getNumUnitClassInfos()];
                for (iJ = 0; iJ < GC.getNumUnitClassInfos(); iJ++)
                {
                        m_paiUnitClassStrengthChange[iJ] = 0;
                }
               
/************************************************************************************************/
/* Afforess                          END                                                            */
/************************************************************************************************/
                AI_reset(false);
        }

        m_Properties.clear();
}

/************************************************************************************************/
/* REVOLUTION_MOD                         01/01/08                                jdog5000      */
/*                                                                                              */
/*                                                                                              */
/************************************************************************************************/
//
// for logging
//
void CvTeam::logMsg(char* format, ... )
{
        if (GC.isXMLLogging())
        {
                static char buf[2048];
                _vsnprintf( buf, 2048-4, format, (char*)(&format+1) );
                gDLL->logMsg("sdkDbg.log", buf);
        }
}

//
// for clearing data stored in plots and cities for this team
//
void CvTeam::resetPlotAndCityData( )
{
        int iI;
        CvPlot* pLoopPlot;
        CvCity* pLoopCity;
        for (iI = 0; iI < GC.getMapINLINE().numPlotsINLINE(); iI++)
        {
                pLoopPlot = GC.getMapINLINE().plotByIndexINLINE(iI);
               
                pLoopPlot->setRevealedOwner(getID(), NO_PLAYER);
                pLoopPlot->setRevealedImprovementType(getID(), NO_IMPROVEMENT);
                pLoopPlot->setRevealedRouteType(getID(), NO_ROUTE);
                pLoopPlot->setRevealed(getID(), false, false, getID(), true);

                pLoopCity = pLoopPlot->getPlotCity();
                if( pLoopCity != NULL )
                {
                        pLoopCity->setRevealed(getID(), false);
                        pLoopCity->setEspionageVisibility(getID(), false, true);
                }
        }
}

bool CvTeam::isRebel() const
{
        bool bValid;
        int iI;

        bValid = false;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID() && GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).isRebel())
                        {
                                bValid = true;
                        }
                        else
                        {
                                return false;
                        }
                }
        }
       
        return bValid;
}

bool CvTeam::isSingleCityTeam() const
{
        int iCities = 0;
        int iI;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                CvPlayer& kPlayer = GET_PLAYER((PlayerTypes)iI);
                if( (kPlayer.getTeam() == getID()) && kPlayer.isAlive() )
                {
                        iCities += GET_PLAYER((PlayerTypes)iI).getNumCities();
                }
                if(iCities > 1)
                {
                        return false;
                }
        }

        return true;
}

bool CvTeam::isRebelAgainst( TeamTypes eTeam ) const
{
        if( eTeam >= 0 && eTeam < MAX_TEAMS )
                return m_abIsRebelAgainst[(int)eTeam];

        return false;
}

void CvTeam::setRebelAgainst( TeamTypes eTeam, bool bNewValue )
{
        if( eTeam >= 0 && eTeam < MAX_TEAMS )
                m_abIsRebelAgainst[(int)eTeam] = bNewValue;
}

int CvTeam::countRebelAgainst( ) const
{
        int count = 0;
        for (int iI = 0; iI < MAX_CIV_TEAMS; iI++)
        {
                if( isRebelAgainst( (TeamTypes)iI ) )
                        count++;
        }
        return count;
}

int CvTeam::getNumMilitaryUnits( ) const
{
        int count = 0;
        for (int iI = 0; iI < MAX_CIV_PLAYERS; iI++)
        {
                if( GET_PLAYER((PlayerTypes)iI).getTeam() == getID() )
                        count += GET_PLAYER((PlayerTypes)iI).getNumMilitaryUnits();
        }
        return count;
}
/************************************************************************************************/
/* REVOLUTION_MOD                          END                                                  */
/************************************************************************************************/

void CvTeam::addTeam(TeamTypes eTeam)
{
        CLLNode<TradeData>* pNode;
        CvDeal* pLoopDeal;
        CvPlot* pLoopPlot;
        CvWString szBuffer;
        bool bValid;
        int iLoop = 0;
        int iI, iJ;

        FAssert(eTeam != NO_TEAM);
        FAssert(eTeam != getID());

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if ((GET_PLAYER((PlayerTypes)iI).getTeam() != getID()) && (GET_PLAYER((PlayerTypes)iI).getTeam() != eTeam))
                        {
                                if (GET_TEAM(GET_PLAYER((PlayerTypes)iI).getTeam()).isHasMet(getID()) && GET_TEAM(GET_PLAYER((PlayerTypes)iI).getTeam()).isHasMet(eTeam))
                                {
                                        MEMORY_TRACK_EXEMPT();

                                        szBuffer = gDLL->getText("TXT_KEY_MISC_PLAYER_PERMANENT_ALLIANCE", getName().GetCString(), GET_TEAM(eTeam).getName().GetCString());
                                        AddDLLMessage(((PlayerTypes)iI), false, GC.getEVENT_MESSAGE_TIME(), szBuffer, "AS2D_THEIRALLIANCE", MESSAGE_TYPE_MINOR_EVENT, NULL, (ColorTypes)GC.getInfoTypeForString("COLOR_HIGHLIGHT_TEXT"));
                                }
                        }
                }
        }

        szBuffer = gDLL->getText("TXT_KEY_MISC_PLAYER_PERMANENT_ALLIANCE", getName().GetCString(), GET_TEAM(eTeam).getName().GetCString());
        GC.getGameINLINE().addReplayMessage(REPLAY_MESSAGE_MAJOR_EVENT, getLeaderID(), szBuffer, -1, -1, (ColorTypes)GC.getInfoTypeForString("COLOR_HIGHLIGHT_TEXT"));


        for (pLoopDeal = GC.getGameINLINE().firstDeal(&iLoop); pLoopDeal != NULL; pLoopDeal = GC.getGameINLINE().nextDeal(&iLoop))
        {
                if (((GET_PLAYER(pLoopDeal->getFirstPlayer()).getTeam() == getID()) && (GET_PLAYER(pLoopDeal->getSecondPlayer()).getTeam() == eTeam)) ||
                          ((GET_PLAYER(pLoopDeal->getFirstPlayer()).getTeam() == eTeam) && (GET_PLAYER(pLoopDeal->getSecondPlayer()).getTeam() == getID())))
                {
                        bValid = true;

                        if (pLoopDeal->getFirstTrades() != NULL)
                        {
                                for (pNode = pLoopDeal->getFirstTrades()->head(); pNode; pNode = pLoopDeal->getFirstTrades()->next(pNode))
                                {
                                        if ((pNode->m_data.m_eItemType == TRADE_OPEN_BORDERS) ||
                                                  (pNode->m_data.m_eItemType == TRADE_DEFENSIVE_PACT) ||
                                                  (pNode->m_data.m_eItemType == TRADE_PEACE_TREATY) ||
                                                  (pNode->m_data.m_eItemType == TRADE_VASSAL) ||
/************************************************************************************************/
/* Afforess                       Start          06/16/10                                               */
/*                                                                                              */
/* Advanced Diplomacy                                                                           */
/************************************************************************************************/
                                                  (pNode->m_data.m_eItemType == TRADE_RITE_OF_PASSAGE) ||
                                                   (pNode->m_data.m_eItemType == TRADE_FREE_TRADE_ZONE) ||
/************************************************************************************************/
/* Afforess                          END                                                            */
/************************************************************************************************/
                                                  (pNode->m_data.m_eItemType == TRADE_SURRENDER))
                                        {
                                                bValid = false;
                                        }
                                }
                        }

                        if (pLoopDeal->getSecondTrades() != NULL)
                        {
                                for (pNode = pLoopDeal->getSecondTrades()->head(); pNode; pNode = pLoopDeal->getSecondTrades()->next(pNode))
                                {
                                        if ((pNode->m_data.m_eItemType == TRADE_OPEN_BORDERS) ||
                                                  (pNode->m_data.m_eItemType == TRADE_DEFENSIVE_PACT) ||
/************************************************************************************************/
/* Afforess                       Start          06/16/10                                               */
/*                                                                                              */
/* Advanced Diplomacy                                                                           */
/************************************************************************************************/
                                                  (pNode->m_data.m_eItemType == TRADE_RITE_OF_PASSAGE) ||
                                                   (pNode->m_data.m_eItemType == TRADE_FREE_TRADE_ZONE) ||
/************************************************************************************************/
/* Afforess                          END                                                            */
/************************************************************************************************/
                                                  (pNode->m_data.m_eItemType == TRADE_PEACE_TREATY) ||
                                                  (pNode->m_data.m_eItemType == TRADE_VASSAL) ||
                                                  (pNode->m_data.m_eItemType == TRADE_SURRENDER))
                                        {
                                                bValid = false;
                                        }
                                }
                        }

                        if (!bValid)
                        {
                                pLoopDeal->kill();
                        }
                }
        }

        shareItems(eTeam);
        GET_TEAM(eTeam).shareItems(getID());

        for (iI = 0; iI < MAX_TEAMS; iI++)
        {
                if ((iI != getID()) && (iI != eTeam))
                {
                        if (GET_TEAM((TeamTypes)iI).isAlive())
                        {
                                if (GET_TEAM(eTeam).isHasMet((TeamTypes)iI))
                                {
                                        meet(((TeamTypes)iI), false);
                                }
                                else if (isHasMet((TeamTypes)iI))
                                {
                                        GET_TEAM(eTeam).meet(((TeamTypes)iI), false);
                                }
                        }
                }
        }

        for (iI = 0; iI < MAX_TEAMS; iI++)
        {
                if ((iI != getID()) && (iI != eTeam))
                {
                        if (GET_TEAM((TeamTypes)iI).isAlive())
                        {
                                if (GET_TEAM(eTeam).isAtWar((TeamTypes)iI))
                                {
                                        declareWar(((TeamTypes)iI), false, GET_TEAM(eTeam).AI_getWarPlan((TeamTypes)iI));
                                }
                                else if (isAtWar((TeamTypes)iI))
                                {
                                        GET_TEAM(eTeam).declareWar(((TeamTypes)iI), false, AI_getWarPlan((TeamTypes)iI));
                                }
                        }
                }
        }

        for (iI = 0; iI < MAX_TEAMS; iI++)
        {
                if ((iI != getID()) && (iI != eTeam))
                {
                        if (GET_TEAM((TeamTypes)iI).isAlive())
                        {
                                if (GET_TEAM(eTeam).isPermanentWarPeace((TeamTypes)iI))
                                {
                                        setPermanentWarPeace(((TeamTypes)iI), true);
                                }
                                else if (isPermanentWarPeace((TeamTypes)iI))
                                {
                                        GET_TEAM(eTeam).setPermanentWarPeace(((TeamTypes)iI), true);
                                }
                        }
                }
        }

        for (iI = 0; iI < MAX_TEAMS; iI++)
        {
                if ((iI != getID()) && (iI != eTeam))
                {
                        if (GET_TEAM((TeamTypes)iI).isAlive())
                        {
                                if (GET_TEAM(eTeam).isOpenBorders((TeamTypes)iI))
                                {
                                        setOpenBorders(((TeamTypes)iI), true);
                                        GET_TEAM((TeamTypes)iI).setOpenBorders(getID(), true);
                                }
                                else if (isOpenBorders((TeamTypes)iI))
                                {
                                        GET_TEAM(eTeam).setOpenBorders(((TeamTypes)iI), true);
                                        GET_TEAM((TeamTypes)iI).setOpenBorders(eTeam, true);
                                }
                        }
                }
        }
/************************************************************************************************/
/* Afforess                       Start          03/8/10                                                */
/*                                                                                              */
/*                                                                                              */
/************************************************************************************************/
        for (iI = 0; iI < MAX_TEAMS; iI++)
        {
                if ((iI != getID()) && (iI != eTeam))
                {
                        if (GET_TEAM((TeamTypes)iI).isAlive())
                        {
                                if (GET_TEAM(eTeam).isLimitedBorders((TeamTypes)iI))
                                {
                                        setLimitedBorders(((TeamTypes)iI), true);
                                        GET_TEAM((TeamTypes)iI).setLimitedBorders(getID(), true);
                                }
                                else if (isLimitedBorders((TeamTypes)iI))
                                {
                                        GET_TEAM(eTeam).setLimitedBorders(((TeamTypes)iI), true);
                                        GET_TEAM((TeamTypes)iI).setLimitedBorders(eTeam, true);
                                }
                        }
                }
        }
        for (iI = 0; iI < MAX_TEAMS; iI++)
        {
                if ((iI != getID()) && (iI != eTeam))
                {
                        if (GET_TEAM((TeamTypes)iI).isAlive())
                        {
                                if (GET_TEAM(eTeam).isHasEmbassy((TeamTypes)iI))
                                {
                                        setHasEmbassy(((TeamTypes)iI), true);
                                        GET_TEAM((TeamTypes)iI).setHasEmbassy(getID(), true);
                                }
                                else if (isDefensivePact((TeamTypes)iI) || isOpenBorders((TeamTypes)iI))
                                {
                                        GET_TEAM(eTeam).setHasEmbassy(((TeamTypes)iI), true);
                                        GET_TEAM((TeamTypes)iI).setHasEmbassy(eTeam, true);
                                }
                        }
                }
        }
/************************************************************************************************/
/* Afforess                          END                                                            */
/************************************************************************************************/
        for (iI = 0; iI < MAX_TEAMS; iI++)
        {
                if ((iI != getID()) && (iI != eTeam))
                {
                        if (GET_TEAM((TeamTypes)iI).isAlive())
                        {
                                if (GET_TEAM(eTeam).isDefensivePact((TeamTypes)iI))
                                {
                                        setDefensivePact(((TeamTypes)iI), true);
                                        GET_TEAM((TeamTypes)iI).setDefensivePact(getID(), true);
                                }
                                else if (isDefensivePact((TeamTypes)iI))
                                {
                                        GET_TEAM(eTeam).setDefensivePact(((TeamTypes)iI), true);
                                        GET_TEAM((TeamTypes)iI).setDefensivePact(eTeam, true);
                                }
                        }
                }
        }

        for (iI = 0; iI < MAX_TEAMS; iI++)
        {
                if ((iI != getID()) && (iI != eTeam))
                {
                        if (GET_TEAM((TeamTypes)iI).isAlive())
                        {
                                if (GET_TEAM(eTeam).isForcePeace((TeamTypes)iI))
                                {
                                        setForcePeace(((TeamTypes)iI), true);
                                        GET_TEAM((TeamTypes)iI).setForcePeace(getID(), true);
                                }
                                else if (isForcePeace((TeamTypes)iI))
                                {
                                        GET_TEAM(eTeam).setForcePeace(((TeamTypes)iI), true);
                                        GET_TEAM((TeamTypes)iI).setForcePeace(eTeam, true);
                                }
                        }
                }
        }

        for (iI = 0; iI < MAX_TEAMS; iI++)
        {
                if ((iI != getID()) && (iI != eTeam))
                {
                        if (GET_TEAM((TeamTypes)iI).isAlive())
                        {
                                if (GET_TEAM(eTeam).isVassal((TeamTypes)iI))
                                {
                                        setVassal(((TeamTypes)iI), true, isCapitulated());
                                }
                                else if (isVassal((TeamTypes)iI))
                                {
                                        GET_TEAM(eTeam).setVassal(((TeamTypes)iI), true, isCapitulated());
                                }
                        }
                }
        }

        for (iI = 0; iI < MAX_TEAMS; iI++)
        {
                if ((iI != getID()) && (iI != eTeam))
                {
                        if (GET_TEAM((TeamTypes)iI).isAlive())
                        {
                                if (GET_TEAM((TeamTypes)iI).isVassal(eTeam))
                                {
                                        GET_TEAM((TeamTypes)iI).setVassal(getID(), true, GET_TEAM((TeamTypes)iI).isCapitulated());
                                }
                                else if (GET_TEAM((TeamTypes)iI).isVassal(getID()))
                                {
                                        GET_TEAM((TeamTypes)iI).setVassal(eTeam, true, GET_TEAM((TeamTypes)iI).isCapitulated());
                                }
                        }
                }
        }

        shareCounters(eTeam);
        GET_TEAM(eTeam).shareCounters(getID());

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam)
                {
                        GET_PLAYER((PlayerTypes)iI).setTeam(getID());
                }
        }

        for (iI = 0; iI < GC.getMapINLINE().numPlotsINLINE(); iI++)
        {
                pLoopPlot = GC.getMapINLINE().plotByIndexINLINE(iI);

                pLoopPlot->changeVisibilityCount(getID(), pLoopPlot->getVisibilityCount(eTeam), NO_INVISIBLE, false);

                for (iJ = 0; iJ < GC.getNumInvisibleInfos(); iJ++)
                {
                        pLoopPlot->changeInvisibleVisibilityCount(getID(), ((InvisibleTypes)iJ), pLoopPlot->getInvisibleVisibilityCount(eTeam, ((InvisibleTypes)iJ)));
                }

                if (pLoopPlot->isRevealed(eTeam, false))
                {
                        pLoopPlot->setRevealed(getID(), true, false, eTeam, false);
                }
        }

        GC.getGameINLINE().updatePlotGroups();

        for (iI = 0; iI < MAX_TEAMS; iI++)
        {
                if ((iI != getID()) && (iI != eTeam))
                {
                        GET_TEAM((TeamTypes)iI).setWarWeariness(getID(), ((GET_TEAM((TeamTypes)iI).getWarWeariness(getID()) + GET_TEAM((TeamTypes)iI).getWarWeariness(eTeam)) / 2));
                        GET_TEAM((TeamTypes)iI).setStolenVisibilityTimer(getID(), ((GET_TEAM((TeamTypes)iI).getStolenVisibilityTimer(getID()) + GET_TEAM((TeamTypes)iI).getStolenVisibilityTimer(eTeam)) / 2));
                        GET_TEAM((TeamTypes)iI).AI_setAtWarCounter(getID(), ((GET_TEAM((TeamTypes)iI).AI_getAtWarCounter(getID()) + GET_TEAM((TeamTypes)iI).AI_getAtWarCounter(eTeam)) / 2));
                        GET_TEAM((TeamTypes)iI).AI_setAtPeaceCounter(getID(), ((GET_TEAM((TeamTypes)iI).AI_getAtPeaceCounter(getID()) + GET_TEAM((TeamTypes)iI).AI_getAtPeaceCounter(eTeam)) / 2));
                        GET_TEAM((TeamTypes)iI).AI_setHasMetCounter(getID(), ((GET_TEAM((TeamTypes)iI).AI_getHasMetCounter(getID()) + GET_TEAM((TeamTypes)iI).AI_getHasMetCounter(eTeam)) / 2));
                        GET_TEAM((TeamTypes)iI).AI_setDefensivePactCounter(getID(), ((GET_TEAM((TeamTypes)iI).AI_getDefensivePactCounter(getID()) + GET_TEAM((TeamTypes)iI).AI_getDefensivePactCounter(eTeam)) / 2));
                        GET_TEAM((TeamTypes)iI).AI_setShareWarCounter(getID(), ((GET_TEAM((TeamTypes)iI).AI_getShareWarCounter(getID()) + GET_TEAM((TeamTypes)iI).AI_getShareWarCounter(eTeam)) / 2));
                        GET_TEAM((TeamTypes)iI).AI_setWarSuccess(getID(), ((GET_TEAM((TeamTypes)iI).AI_getWarSuccess(getID()) + GET_TEAM((TeamTypes)iI).AI_getWarSuccess(eTeam)) / 2));
                        GET_TEAM((TeamTypes)iI).AI_setEnemyPeacetimeTradeValue(getID(), ((GET_TEAM((TeamTypes)iI).AI_getEnemyPeacetimeTradeValue(getID()) + GET_TEAM((TeamTypes)iI).AI_getEnemyPeacetimeTradeValue(eTeam)) / 2));
                        GET_TEAM((TeamTypes)iI).AI_setEnemyPeacetimeGrantValue(getID(), ((GET_TEAM((TeamTypes)iI).AI_getEnemyPeacetimeGrantValue(getID()) + GET_TEAM((TeamTypes)iI).AI_getEnemyPeacetimeGrantValue(eTeam)) / 2));

/************************************************************************************************/
/* UNOFFICIAL_PATCH                       09/17/09                                jdog5000      */
/*                                                                                              */
/* Bugfix                                                                                                        */
/************************************************************************************************/
                        GET_TEAM((TeamTypes)iI).setEspionagePointsAgainstTeam( getID(), std::max(GET_TEAM((TeamTypes)iI).getEspionagePointsAgainstTeam(getID()), GET_TEAM((TeamTypes)iI).getEspionagePointsAgainstTeam(eTeam)));
/************************************************************************************************/
/* UNOFFICIAL_PATCH                        END                                                  */
/************************************************************************************************/

                        if (GET_TEAM((TeamTypes)iI).isAlive())
                        {
                                GET_TEAM((TeamTypes)iI).AI_setWarPlan(getID(), NO_WARPLAN, false);
                                GET_TEAM((TeamTypes)iI).AI_setWarPlan(eTeam, NO_WARPLAN, false);
                }
        }
        }

        AI_updateWorstEnemy();

        AI_updateAreaStragies();

        GC.getGameINLINE().updateScore(true);
}


void CvTeam::shareItems(TeamTypes eTeam)
{
        CvCity* pLoopCity;
        int iLoop = 0;
        int iI, iJ, iK;

        FAssert(eTeam != NO_TEAM);
        FAssert(eTeam != getID());

        for (iI = 0; iI < GC.getNumTechInfos(); iI++)
        {
                if (GET_TEAM(eTeam).isHasTech((TechTypes)iI))
                {
                        setHasTech(((TechTypes)iI), true, NO_PLAYER, true, false);
                }
        }

        for (iI = 0; iI < GC.getNumBonusInfos(); ++iI)
        {
                if (GET_TEAM(eTeam).isForceRevealedBonus((BonusTypes)iI))
                {
                        setForceRevealedBonus((BonusTypes)iI, true);
                }
        }

        for (int iTeam = 0; iTeam < MAX_TEAMS; ++iTeam)
        {
                setEspionagePointsAgainstTeam((TeamTypes)iTeam, std::max(GET_TEAM(eTeam).getEspionagePointsAgainstTeam((TeamTypes)iTeam), getEspionagePointsAgainstTeam((TeamTypes)iTeam)));
        }

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam)
                        {
                                for (pLoopCity = GET_PLAYER((PlayerTypes)iI).firstCity(&iLoop); pLoopCity != NULL; pLoopCity = GET_PLAYER((PlayerTypes)iI).nextCity(&iLoop))
                                {
                                        for (iJ = 0; iJ < GC.getNumBuildingInfos(); iJ++)
                                        {
                                                if (pLoopCity->getNumBuilding((BuildingTypes)iJ) > 0)
                                                {
                                                        if (!isObsoleteBuilding((BuildingTypes)iJ))
                                                        {
                                                                if (GC.getBuildingInfo((BuildingTypes)iJ).isTeamShare())
                                                                {
                                                                        for (iK = 0; iK < MAX_PLAYERS; iK++)
                                                                        {
                                                                                if (GET_PLAYER((PlayerTypes)iK).getTeam() == getID() && GET_PLAYER((PlayerTypes)iK).isAlive())
                                                                                {
                                                                                        GET_PLAYER((PlayerTypes)iK).processBuilding(((BuildingTypes)iJ), pLoopCity->getNumBuilding((BuildingTypes)iJ), pLoopCity->area());
                                                                                }
                                                                        }
                                                                }

                                                                processBuilding(((BuildingTypes)iJ), pLoopCity->getNumBuilding((BuildingTypes)iJ));
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam)
                        {
                                GET_PLAYER((PlayerTypes)iI).AI_updateBonusValue();
                        }
                }
        }
}


void CvTeam::shareCounters(TeamTypes eTeam)
{
        int iI;

        for (iI = 0; iI < MAX_TEAMS; iI++)
        {
                if ((iI != getID()) && (iI != eTeam))
                {
                        if (GET_TEAM(eTeam).getWarWeariness((TeamTypes)iI) > getWarWeariness((TeamTypes)iI))
                        {
                                setWarWeariness(((TeamTypes)iI), GET_TEAM(eTeam).getWarWeariness((TeamTypes)iI));
                        }

                        if (GET_TEAM(eTeam).getStolenVisibilityTimer((TeamTypes)iI) > getStolenVisibilityTimer((TeamTypes)iI))
                        {
                                setStolenVisibilityTimer(((TeamTypes)iI), GET_TEAM(eTeam).getStolenVisibilityTimer((TeamTypes)iI));
                        }

                        if (GET_TEAM(eTeam).AI_getAtWarCounter((TeamTypes)iI) > AI_getAtWarCounter((TeamTypes)iI))
                        {
                                AI_setAtWarCounter(((TeamTypes)iI), GET_TEAM(eTeam).AI_getAtWarCounter((TeamTypes)iI));
                        }

                        if (GET_TEAM(eTeam).AI_getAtPeaceCounter((TeamTypes)iI) > AI_getAtPeaceCounter((TeamTypes)iI))
                        {
                                AI_setAtPeaceCounter(((TeamTypes)iI), GET_TEAM(eTeam).AI_getAtPeaceCounter((TeamTypes)iI));
                        }

                        if (GET_TEAM(eTeam).AI_getHasMetCounter((TeamTypes)iI) > AI_getHasMetCounter((TeamTypes)iI))
                        {
                                AI_setHasMetCounter(((TeamTypes)iI), GET_TEAM(eTeam).AI_getHasMetCounter((TeamTypes)iI));
                        }

                        if (GET_TEAM(eTeam).AI_getOpenBordersCounter((TeamTypes)iI) > AI_getOpenBordersCounter((TeamTypes)iI))
                        {
                                AI_setOpenBordersCounter(((TeamTypes)iI), GET_TEAM(eTeam).AI_getOpenBordersCounter((TeamTypes)iI));
                        }

                        if (GET_TEAM(eTeam).AI_getDefensivePactCounter((TeamTypes)iI) > AI_getDefensivePactCounter((TeamTypes)iI))
                        {
                                AI_setDefensivePactCounter(((TeamTypes)iI), GET_TEAM(eTeam).AI_getDefensivePactCounter((TeamTypes)iI));
                        }

                        if (GET_TEAM(eTeam).AI_getShareWarCounter((TeamTypes)iI) > AI_getShareWarCounter((TeamTypes)iI))
                        {
                                AI_setShareWarCounter(((TeamTypes)iI), GET_TEAM(eTeam).AI_getShareWarCounter((TeamTypes)iI));
                        }

                        if (GET_TEAM(eTeam).AI_getWarSuccess((TeamTypes)iI) > AI_getWarSuccess((TeamTypes)iI))
                        {
                                AI_setWarSuccess(((TeamTypes)iI), GET_TEAM(eTeam).AI_getWarSuccess((TeamTypes)iI));
                        }

                        if (GET_TEAM(eTeam).AI_getEnemyPeacetimeTradeValue((TeamTypes)iI) > AI_getEnemyPeacetimeTradeValue((TeamTypes)iI))
                        {
                                AI_setEnemyPeacetimeTradeValue(((TeamTypes)iI), GET_TEAM(eTeam).AI_getEnemyPeacetimeTradeValue((TeamTypes)iI));
                        }

                        if (GET_TEAM(eTeam).AI_getEnemyPeacetimeGrantValue((TeamTypes)iI) > AI_getEnemyPeacetimeGrantValue((TeamTypes)iI))
                        {
                                AI_setEnemyPeacetimeGrantValue(((TeamTypes)iI), GET_TEAM(eTeam).AI_getEnemyPeacetimeGrantValue((TeamTypes)iI));
                        }

                        GET_TEAM(eTeam).AI_setWarPlan(((TeamTypes)iI), NO_WARPLAN, false);
                }
        }

        for (iI = 0; iI < GC.getNumProjectInfos(); iI++)
        {
                int iExtraProjects = GET_TEAM(eTeam).getProjectCount((ProjectTypes)iI) - getProjectCount((ProjectTypes)iI);
                if (iExtraProjects > 0)
                {
                        changeProjectCount((ProjectTypes)iI, iExtraProjects);
                        GC.getGameINLINE().incrementProjectCreatedCount((ProjectTypes)iI, -iExtraProjects);
                }

                changeProjectMaking(((ProjectTypes)iI), GET_TEAM(eTeam).getProjectMaking((ProjectTypes)iI));
        }

        for (iI = 0; iI < GC.getNumUnitClassInfos(); iI++)
        {
                changeUnitClassCount(((UnitClassTypes)iI), GET_TEAM(eTeam).getUnitClassCount((UnitClassTypes)iI));
        }

        for (iI = 0; iI < GC.getNumBuildingClassInfos(); iI++)
        {
                changeBuildingClassCount(((BuildingClassTypes)iI), GET_TEAM(eTeam).getBuildingClassCount((BuildingClassTypes)iI));
        }

        for (iI = 0; iI < GC.getNumTechInfos(); iI++)
        {
/************************************************************************************************/
/* UNOFFICIAL_PATCH                       04/29/10                                jdog5000      */
/*                                                                                              */
/* Bugfix                                                                                       */
/************************************************************************************************/
/* original bts code
                if (GET_TEAM(eTeam).getResearchProgress((TechTypes)iI) > getResearchProgress((TechTypes)iI))
                {
                        setResearchProgress(((TechTypes)iI), GET_TEAM(eTeam).getResearchProgress((TechTypes)iI), getLeaderID());
                }

                if (GET_TEAM(eTeam).isNoTradeTech((TechTypes)iI))
                {
                        setNoTradeTech(((TechTypes)iI), true);
                }
*/

                // Overflow from techs this team already has can cause bugged behavior
                if( !isHasTech((TechTypes)iI) )
                {
                        if (GET_TEAM(eTeam).getResearchProgress((TechTypes)iI) > getResearchProgress((TechTypes)iI))
                        {
                                setResearchProgress(((TechTypes)iI), GET_TEAM(eTeam).getResearchProgress((TechTypes)iI), getLeaderID());
                        }
                }

                // Clear no tech trade if it is false for other team
                // Fixes bug where if, with no tech brokering, team A trades a tech to team B, then later joins B in
                // a permanent alliance.  Previous code would block the AB alliance from "brokering" the tech, even
                // though A had researched it on their own.
                if ( GET_TEAM(eTeam).isHasTech((TechTypes)iI) && !(GET_TEAM(eTeam).isNoTradeTech((TechTypes)iI)) )
                {
                        setNoTradeTech(((TechTypes)iI), false);
                }
/************************************************************************************************/
/* UNOFFICIAL_PATCH                        END                                                  */
/************************************************************************************************/
        }
}


void CvTeam::processBuilding(BuildingTypes eBuilding, int iChange)
{
        PROFILE_FUNC();

        for (int i = 0; i < GC.getNumVoteSourceInfos(); ++i)
        {
                if (GC.getBuildingInfo(eBuilding).getVoteSourceType() == i)
                {
                        changeForceTeamVoteEligibilityCount((VoteSourceTypes)i, (GC.getBuildingInfo(eBuilding).isForceTeamVoteEligible()) ? iChange : 0);
                }
        }

        if (GC.getBuildingInfo(eBuilding).isMapCentering())
        {
                if (iChange > 0)
                {
                        setMapCentering(true);
                }
        }
        changeEnemyWarWearinessModifier(GC.getBuildingInfo(eBuilding).getEnemyWarWearinessModifier() * iChange);
}


void CvTeam::doTurn()
{
        MEMORY_TRACE_FUNCTION();
        PROFILE("CvTeam::doTurn()")

        int iCount;
        int iPossibleCount;
        int iI, iJ;

        FAssertMsg(isAlive(), "isAlive is expected to be true");

        AI_doTurnPre();

        if (isBarbarian())
        {
                for (iI = 0; iI < GC.getNumTechInfos(); iI++)
                {
                        if (!isHasTech((TechTypes)iI))
                        {
                                iCount = 0;
                                iPossibleCount = 0;

                                for (iJ = 0; iJ < MAX_CIV_TEAMS; iJ++)
                                {
/************************************************************************************************/
/* UNOFFICIAL_PATCH                       03/01/10                     Mongoose & jdog5000      */
/*                                                                                              */
/* Bugfix                                                                                       */
/************************************************************************************************/
/* original bts code
                                        if (GET_TEAM((TeamTypes)iJ).isAlive())
*/

                                        // From Mongoose SDK, BarbarianPassiveTechFix
                                        if (GET_TEAM((TeamTypes)iJ).isAlive() && !GET_TEAM((TeamTypes)iJ).isBarbarian())
/************************************************************************************************/
/* UNOFFICIAL_PATCH                        END                                                  */
/************************************************************************************************/
                                        {
                                                if (GET_TEAM((TeamTypes)iJ).isHasTech((TechTypes)iI))
                                                {
                                                        iCount++;
                                                }

                                                iPossibleCount++;
                                        }
                                }

                                if (iCount > 0)
                                {
                                        FAssertMsg(iPossibleCount > 0, "iPossibleCount is expected to be greater than 0");

/************************************************************************************************/
/* UNOFFICIAL_PATCH                       03/01/10                     Mongoose & jdog5000      */
/*                                                                                              */
/* Bugfix                                                                                       */
/************************************************************************************************/
/* original bts code
                                        changeResearchProgress(((TechTypes)iI), ((getResearchCost((TechTypes)iI) * ((GC.getDefineINT("BARBARIAN_FREE_TECH_PERCENT") * iCount) / iPossibleCount)) / 100), getLeaderID());
*/

                                        // From Mongoose SDK, BarbarianPassiveTechFix
                                        changeResearchProgress((TechTypes)iI, std::max((getResearchCost((TechTypes)iI) * GC.getDefineINT("BARBARIAN_FREE_TECH_PERCENT") * iCount) / (100 * iPossibleCount), 1), getLeaderID());
/************************************************************************************************/
/* UNOFFICIAL_PATCH                        END                                                  */
/************************************************************************************************/
                                }
                        }
                }
        } else if (isMinorCiv()) {
                //Afforess: fix bug where new civilizations that spawn after a minor civ will not be war with minor civs they meet
                //Every turn for new civs this minor civ has met, and declare war
                for (iI = 0; iI < MAX_CIV_TEAMS; iI++)
                {
                        if( iI != getID() && isHasMet((TeamTypes)iI) && !isAtWar((TeamTypes)iI) )
                        {
                                declareWar((TeamTypes)iI, false, WARPLAN_LIMITED);
                        }
                }
        }

        for (iI = 0; iI < MAX_TEAMS; iI++)
        {
                if (GET_TEAM((TeamTypes)iI).isAlive())
                {
                        if (getStolenVisibilityTimer((TeamTypes)iI) > 0)
                        {
                                changeStolenVisibilityTimer(((TeamTypes)iI), -1);
                        }

                        if (getCounterespionageTurnsLeftAgainstTeam((TeamTypes) iI) > 0)
                        {
                                changeCounterespionageTurnsLeftAgainstTeam((TeamTypes) iI, -1);
                        }

                        if (getCounterespionageTurnsLeftAgainstTeam((TeamTypes) iI) == 0)
                        {
                                setCounterespionageModAgainstTeam((TeamTypes) iI, 0);
                        }
                }
        }

        if (!GC.getGameINLINE().isOption(GAMEOPTION_NO_TECH_BROKERING))
        {
                for (iI = 0; iI < GC.getNumTechInfos(); iI++)
                {
                        setNoTradeTech(((TechTypes)iI), false);
                }

        }
        if (GC.getGameINLINE().isModderGameOption(MODDERGAMEOPTION_CONTACT_DECAY))
        {
                doEmbassyContactCheck();
        }
        doWarWeariness();

        testCircumnavigated();

        AI_doTurnPost();

}


void CvTeam::updateYield()
{
        int iI;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                        {
                                GET_PLAYER((PlayerTypes)iI).updateYield();
                        }
                }
        }
}


void CvTeam::updatePowerHealth()
{
        int iI;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                        {
                                GET_PLAYER((PlayerTypes)iI).updatePowerHealth();
                        }
                }
        }
}


void CvTeam::updateCommerce()
{
        int iI;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                        {
                                GET_PLAYER((PlayerTypes)iI).updateCommerce();
                        }
                }
        }
}


bool CvTeam::canChangeWarPeace(TeamTypes eTeam, bool bAllowVassal) const
{
        if (GC.getGameINLINE().isOption(GAMEOPTION_NO_CHANGING_WAR_PEACE))
        {
                return false;
        }

        if (eTeam == getID())
        {
                return false;
        }

        if (isPermanentWarPeace(eTeam) || GET_TEAM(eTeam).isPermanentWarPeace(getID()))
        {
                return false;
        }

/************************************************************************************************/
/* REVOLUTION_MOD                         02/08/08                                jdog5000      */
/*                                                                                              */
/* For minor civs                                                                               */
/************************************************************************************************/
        // No dealing with minor civs
        if( isMinorCiv() || GET_TEAM(eTeam).isMinorCiv() )
        {
                return false;
        }
/************************************************************************************************/
/* REVOLUTION_MOD                          END                                                  */
/************************************************************************************************/
        for (int iLoopTeam = 0; iLoopTeam < MAX_CIV_TEAMS; ++iLoopTeam)
        {
                CvTeam& kLoopTeam = GET_TEAM((TeamTypes)iLoopTeam);
                if (kLoopTeam.isAlive())
                {
                        if (kLoopTeam.isVassal(getID()) && kLoopTeam.isPermanentWarPeace(eTeam))
                        {
                                return false;
                        }

                        if (kLoopTeam.isVassal(eTeam) && kLoopTeam.isPermanentWarPeace(getID()))
                        {
                                return false;
                        }
                }
        }

        if (isAVassal())
        {
                return false;
        }

        if (bAllowVassal)
        {
                if (GET_TEAM(eTeam).isVassal(getID()))
                {
                        return false;
                }
        }
        else
        {
                if (GET_TEAM(eTeam).isAVassal())
                {
                        return false;
                }
        }

        return true;
}


bool CvTeam::canDeclareWar(TeamTypes eTeam) const
{
        if (eTeam == getID())
        {
                return false;
        }

        if (!(isAlive()) || !(GET_TEAM(eTeam).isAlive()))
        {
                return false;
        }

        if (isAtWar(eTeam))
        {
                return false;
        }

        if (!isHasMet(eTeam))
        {
                return false;
        }

        if (isForcePeace(eTeam))
        {
                return false;
        }

        for (int i = 0; i < MAX_TEAMS; ++i)
        {
                if (i != eTeam && i != getID() && ((GET_TEAM(eTeam).isVassal((TeamTypes)i)) || (GET_TEAM((TeamTypes)i).isVassal(eTeam))))
                {
                        if (isForcePeace((TeamTypes)i))
                        {
                                return false;
                        }
                }
        }

        if (!canChangeWarPeace(eTeam, true))
        {
                return false;
        }

        if (GC.getGameINLINE().isOption(GAMEOPTION_ALWAYS_PEACE))
        {
                return false;
        }

        if(GC.getUSE_CAN_DECLARE_WAR_CALLBACK())
        {
                PYTHON_ACCESS_LOCK_SCOPE

                CyArgsList argsList;
                argsList.add(getID());  // Team ID
                argsList.add(eTeam);    // pass in city class
                long lResult=0;
                PYTHON_CALL_FUNCTION4(__FUNCTION__, PYGameModule, "canDeclareWar", argsList.makeFunctionArgs(), &lResult);

                if (lResult == 0)
                {
                        return false;
                }
        }

        return true;
}

/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      01/16/10                                jdog5000      */
/*                                                                                              */
/* War Strategy AI                                                                              */
/************************************************************************************************/
/// \brief Version of canDeclareWar which ignores temporary peace treaties.
///
/// This function is for AIs considering who to start war preparations against, so they're future
/// plans aren't unnecessarily affected by current conditions.
///
/// Could not change definition of canDeclareWar, some sporadic crash-inducing compatibility issue
/// with the DLL it seems.  Lost a lot of time tracking down the source of the crash, it really is
/// just from adding bool bWhatever = false to canDeclareWar in CvTeam.h.  So, that's why there's
/// this overlapping second function.
bool CvTeam::canEventuallyDeclareWar(TeamTypes eTeam) const
{
        if (eTeam == getID())
        {
                return false;
        }

        if (!(isAlive()) || !(GET_TEAM(eTeam).isAlive()))
        {
                return false;
        }

        if (isAtWar(eTeam))
        {
                return false;
        }

        if (!isHasMet(eTeam))
        {
                return false;
        }

        if (!canChangeWarPeace(eTeam, true))
        {
                return false;
        }

        if (GC.getGameINLINE().isOption(GAMEOPTION_ALWAYS_PEACE))
        {
                return false;
        }

        if(GC.getUSE_CAN_DECLARE_WAR_CALLBACK())
        {
                PYTHON_ACCESS_LOCK_SCOPE

                CyArgsList argsList;
                argsList.add(getID());  // Team ID
                argsList.add(eTeam);    // pass in city class
                long lResult=0;
                PYTHON_CALL_FUNCTION4(__FUNCTION__, PYGameModule, "canDeclareWar", argsList.makeFunctionArgs(), &lResult);

                if (lResult == 0)
                {
                        return false;
                }
        }

        return true;
}


void CvTeam::declareWar(TeamTypes eTeam, bool bNewDiplo, WarPlanTypes eWarPlan, bool bCancelPacts)
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/
{
        PROFILE_FUNC();

        //CLLNode<TradeData>* pNode;
        CvDiploParameters* pDiplo;
        CvDeal* pLoopDeal;
        CvWString szBuffer;
        //bool bCancelDeal;
        int iLoop = 0;
        int iI, iJ;

        FAssertMsg(eTeam != NO_TEAM, "eTeam is not assigned a valid value");
        FAssertMsg(eTeam != getID(), "eTeam is not expected to be equal with getID()");

        if (!isAtWar(eTeam))
        {
                //FAssertMsg((isHuman() || isMinorCiv() || GET_TEAM(eTeam).isMinorCiv() || isBarbarian() || GET_TEAM(eTeam).isBarbarian() || AI_isSneakAttackReady(eTeam) || (GET_TEAM(eTeam).getAtWarCount(true) > 0) || !(GC.getGameINLINE().isFinalInitialized()) || gDLL->GetWorldBuilderMode() || getVassalCount() > 0  || isAVassal() || GET_TEAM(eTeam).getVassalCount() > 0  || GET_TEAM(eTeam).isAVassal() || getDefensivePactCount() > 0), "Possibly accidental AI war!!!");

/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      10/02/09                                jdog5000      */
/*                                                                                              */
/* AI logging                                                                                   */
/************************************************************************************************/
                if( gTeamLogLevel >= 1 )
                {
                        logBBAIForTeam(getID(), "  Team %d (%S) declares war on team %d", getID(), GET_PLAYER(getLeaderID()).getCivilizationDescription(0), eTeam);
                }
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/

                for (pLoopDeal = GC.getGameINLINE().firstDeal(&iLoop); pLoopDeal != NULL; pLoopDeal = GC.getGameINLINE().nextDeal(&iLoop))
                {
                        if (((GET_PLAYER(pLoopDeal->getFirstPlayer()).getTeam() == getID()) && (GET_PLAYER(pLoopDeal->getSecondPlayer()).getTeam() == eTeam)) ||
                                        ((GET_PLAYER(pLoopDeal->getFirstPlayer()).getTeam() == eTeam) && (GET_PLAYER(pLoopDeal->getSecondPlayer()).getTeam() == getID())))
                        {
                                pLoopDeal->kill();
                        }
                }

                for (iI = 0; iI < MAX_PLAYERS; iI++)
                {
                        if (((GET_PLAYER((PlayerTypes)iI).getTeam() == getID()) || (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam)) && GET_PLAYER((PlayerTypes)iI).isAlive())
                        {
                                GET_PLAYER((PlayerTypes)iI).updatePlunder(-1, false);
                        }
/************************************************************************************************/
/* Afforess                       Start          05/23/10                                               */
/*                                                                                              */
/*                                                                                              */
/************************************************************************************************/
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID() && GET_PLAYER((PlayerTypes)iI).isAlive())
                        {
                                if (GET_PLAYER((PlayerTypes)iI).getPledgedSecretaryGeneralVote() == eTeam)
                                {
                                        GET_PLAYER((PlayerTypes)iI).setPledgedSecretaryGeneralVote(NO_TEAM);
                                }
                        }

                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam && GET_PLAYER((PlayerTypes)iI).isAlive())
                        {
                                if (GET_PLAYER((PlayerTypes)iI).getPledgedSecretaryGeneralVote() == getID())
                                {
                                        GET_PLAYER((PlayerTypes)iI).setPledgedSecretaryGeneralVote(NO_TEAM);
                                }
                        }
/************************************************************************************************/
/* Afforess                          END                                                            */
/************************************************************************************************/
                }

                FAssertMsg(eTeam != getID(), "eTeam is not expected to be equal with getID()");
                setAtWar(eTeam, true);
                GET_TEAM(eTeam).setAtWar(getID(), true);

/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      08/21/09                                jdog5000      */
/*                                                                                              */
/* Efficiency                                                                                   */
/************************************************************************************************/
                // Plot danger cache
                GC.getMapINLINE().invalidateIsTeamBorderCache(eTeam);
                GC.getMapINLINE().invalidateIsTeamBorderCache(getID());
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/

                for (iI = 0; iI < MAX_PLAYERS; iI++)
                {
                        if (((GET_PLAYER((PlayerTypes)iI).getTeam() == getID()) || (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam)) && GET_PLAYER((PlayerTypes)iI).isAlive())
                        {
                                GET_PLAYER((PlayerTypes)iI).updatePlunder(1, false);
                        }
                }

                meet(eTeam, false);

                AI_setAtPeaceCounter(eTeam, 0);
                GET_TEAM(eTeam).AI_setAtPeaceCounter(getID(), 0);

                AI_setShareWarCounter(eTeam, 0);
                GET_TEAM(eTeam).AI_setShareWarCounter(getID(), 0);

                GET_TEAM(eTeam).AI_setWarPlan(getID(), ((isBarbarian() || isMinorCiv()) ? WARPLAN_ATTACKED : WARPLAN_ATTACKED_RECENT));

/************************************************************************************************/
/* REVOLUTION_MOD                         05/27/08                                jdog5000      */
/*                                                                                              */
/* For barbarian and minor civs                                                                 */
/************************************************************************************************/
                // Added check for barb, minor - jwd
                if (!isBarbarian() && !isMinorCiv() && !GET_TEAM(eTeam).isMinorCiv() && !GET_TEAM(eTeam).isBarbarian())
                {
                        for (iI = 0; iI < MAX_TEAMS; iI++)
                        {
                                if (GET_TEAM((TeamTypes)iI).isAlive())
                                {
                                        if (!GET_TEAM(eTeam).isAtWar((TeamTypes)iI) && GET_TEAM(eTeam).AI_isChosenWar((TeamTypes)iI))
                                        {
                                                GET_TEAM(eTeam).AI_setWarPlan(((TeamTypes)iI), NO_WARPLAN);
                                        }
                                }
                        }
                }
/************************************************************************************************/
/* REVOLUTION_MOD                          END                                                  */
/************************************************************************************************/

                if (NO_WARPLAN != eWarPlan)
                {
                        AI_setWarPlan(eTeam, eWarPlan);
                }

                FAssert(!(AI_isSneakAttackPreparing(eTeam)));
                if ((AI_getWarPlan(eTeam) == NO_WARPLAN) || AI_isSneakAttackPreparing(eTeam))
                {
                        if (isHuman())
                        {
                                AI_setWarPlan(eTeam, WARPLAN_TOTAL);
                        }
                        else if (isMinorCiv() || isBarbarian() || (GET_TEAM(eTeam).getAtWarCount(true) == 1))
                        {
                                AI_setWarPlan(eTeam, WARPLAN_LIMITED);
                        }
                        else
                        {
                                AI_setWarPlan(eTeam, WARPLAN_DOGPILE);
                        }
                }

                GC.getMapINLINE().verifyUnitValidPlot();

                for (iI = 0; iI < MAX_PLAYERS; iI++)
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID() && GET_PLAYER((PlayerTypes)iI).isAlive())
                        {
                                GET_PLAYER((PlayerTypes)iI).verifyUnitStacksValid();
                        }
                }

                GC.getGameINLINE().AI_makeAssignWorkDirty();

                if ((getID() == GC.getGameINLINE().getActiveTeam()) || (eTeam == GC.getGameINLINE().getActiveTeam()))
                {
                        gDLL->getInterfaceIFace()->setDirty(Score_DIRTY_BIT, true);
                        gDLL->getInterfaceIFace()->setDirty(CityInfo_DIRTY_BIT, true);
                }

/************************************************************************************************/
/* REVOLUTION_MOD                         03/06/08                                jdog5000      */
/*                                                                                              */
/* For barbarian and minor civs                                                                 */
/************************************************************************************************/
/* original code
                for (iI = 0; iI < MAX_PLAYERS; iI++)
                {
                        if (GET_PLAYER((PlayerTypes)iI).isAlive())
                        {
                                for (iJ = 0; iJ < MAX_PLAYERS; iJ++)
                                {
                                        if (GET_PLAYER((PlayerTypes)iJ).isAlive())
                                        {
                                                if ((GET_PLAYER((PlayerTypes)iI).getTeam() == getID()) && (GET_PLAYER((PlayerTypes)iJ).getTeam() == eTeam))
                                                {
                                                        GET_PLAYER((PlayerTypes)iI).AI_setFirstContact(((PlayerTypes)iJ), true);
                                                        GET_PLAYER((PlayerTypes)iJ).AI_setFirstContact(((PlayerTypes)iI), true);
                                                }
                                        }
                                }
                        }
                }

                for (iI = 0; iI < MAX_PLAYERS; iI++)
                {
                        if (GET_PLAYER((PlayerTypes)iI).isAlive())
                        {
                                for (iJ = 0; iJ < MAX_PLAYERS; iJ++)
                                {
                                        if (GET_PLAYER((PlayerTypes)iJ).isAlive())
                                        {
                                                if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                                                {
                                                        if (GET_PLAYER((PlayerTypes)iJ).getTeam() == eTeam)
                                                        {
                                                                GET_PLAYER((PlayerTypes)iJ).AI_changeMemoryCount(((PlayerTypes)iI), MEMORY_DECLARED_WAR, 1);
                                                        }
                                                        else if (GET_PLAYER((PlayerTypes)iJ).getTeam() != getID())
                                                        {
                                                                if (GET_TEAM(GET_PLAYER((PlayerTypes)iJ).getTeam()).isHasMet(eTeam))
                                                                {
                                                                        if ((GET_TEAM(GET_PLAYER((PlayerTypes)iJ).getTeam()).AI_getAttitude(eTeam) >= ATTITUDE_PLEASED) && !(GET_TEAM(GET_PLAYER((PlayerTypes)iJ).getTeam()).isAtWar(eTeam)))
                                                                        {
                                                                                GET_PLAYER((PlayerTypes)iJ).AI_changeMemoryCount(((PlayerTypes)iI), MEMORY_DECLARED_WAR_ON_FRIEND, 1);
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
*/

                // Added check for barb, minor - jwd
                if (!isBarbarian() && !(GET_TEAM(eTeam).isBarbarian()) &&
                                  !isMinorCiv() && !(GET_TEAM(eTeam).isMinorCiv()))
                {
                        for (iI = 0; iI < MAX_PLAYERS; iI++)
                        {
                                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                                {
                                        for (iJ = 0; iJ < MAX_PLAYERS; iJ++)
                                        {
                                                if (GET_PLAYER((PlayerTypes)iJ).isAlive())
                                                {
                                                        if ((GET_PLAYER((PlayerTypes)iI).getTeam() == getID()) && (GET_PLAYER((PlayerTypes)iJ).getTeam() == eTeam))
                                                        {
                                                                GET_PLAYER((PlayerTypes)iI).AI_setFirstContact(((PlayerTypes)iJ), true);
                                                                GET_PLAYER((PlayerTypes)iJ).AI_setFirstContact(((PlayerTypes)iI), true);
                                                        }
                                                }
                                        }
                                }
                        }
/************************************************************************************************/
/* Afforess                       Start          05/23/10                                               */
/*                                                                                              */
/*                                                                                              */
/************************************************************************************************/
                        if (GC.getGameINLINE().isOption(GAMEOPTION_RUTHLESS_AI))
                        {
                                for (iI = 0; iI < MAX_PLAYERS; iI++)
                                {
                                        if (GET_PLAYER((PlayerTypes)iI).isAlive())
                                        {
                                                //Player is on our team
                                                if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                                                {
                                                        //Calculate players we just backstabbed
                                                        for (iJ = 0; iJ < MAX_PLAYERS; iJ++)
                                                        {
                                                                if (GET_PLAYER((PlayerTypes)iJ).isAlive())
                                                                {
                                                                        //Player is on the team we are declaring war on
                                                                        if (GET_PLAYER((PlayerTypes)iJ).getTeam() == eTeam)
                                                                        {
                                                                                if (GET_PLAYER((PlayerTypes)iJ).AI_getAttitude((PlayerTypes)iI) >= ATTITUDE_PLEASED)
                                                                                {
                                                                                        GET_PLAYER((PlayerTypes)iJ).AI_changeMemoryCount(((PlayerTypes)iI), MEMORY_BACKSTAB, 1);
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                        //Calculate players whose friend we just backstabbed
                                                        for (iJ = 0; iJ < MAX_PLAYERS; iJ++)
                                                        {
                                                                if (GET_PLAYER((PlayerTypes)iJ).isAlive())
                                                                {
                                                                        //Player is not on the team we declared war on, and not on our team
                                                                        if (GET_PLAYER((PlayerTypes)iJ).getTeam() != eTeam && GET_PLAYER((PlayerTypes)iJ).getTeam() != getID())
                                                                        {
                                                                                //Friends with the leader of the team we declared war on
                                                                                if (GET_PLAYER((PlayerTypes)iJ).AI_getAttitude(GET_TEAM(eTeam).getLeaderID()) >= ATTITUDE_PLEASED)
                                                                                {
                                                                                        GET_PLAYER((PlayerTypes)iJ).AI_changeMemoryCount(((PlayerTypes)iI), MEMORY_BACKSTAB_FRIEND, 1);
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
/************************************************************************************************/
/* Afforess                          END                                                            */
/************************************************************************************************/

                        for (iI = 0; iI < MAX_PLAYERS; iI++)
                        {
                                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                                {
                                        for (iJ = 0; iJ < MAX_PLAYERS; iJ++)
                                        {
                                                if (GET_PLAYER((PlayerTypes)iJ).isAlive())
                                                {
                                                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                                                        {
                                                                if (GET_PLAYER((PlayerTypes)iJ).getTeam() == eTeam)
                                                                {
                                                                        GET_PLAYER((PlayerTypes)iJ).AI_changeMemoryCount(((PlayerTypes)iI), MEMORY_DECLARED_WAR, 1);

                                                                }
                                                                else if (GET_PLAYER((PlayerTypes)iJ).getTeam() != getID())
                                                                {
                                                                        if (GET_TEAM(GET_PLAYER((PlayerTypes)iJ).getTeam()).isHasMet(eTeam))
                                                                        {
                                                                                if ((GET_TEAM(GET_PLAYER((PlayerTypes)iJ).getTeam()).AI_getAttitude(eTeam) >= ATTITUDE_PLEASED) && !(GET_TEAM(GET_PLAYER((PlayerTypes)iJ).getTeam()).isAtWar(eTeam)))
                                                                                {
                                                                                        GET_PLAYER((PlayerTypes)iJ).AI_changeMemoryCount(((PlayerTypes)iI), MEMORY_DECLARED_WAR_ON_FRIEND, 1);
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
/************************************************************************************************/
/* REVOLUTION_MOD                          END                                                  */
/************************************************************************************************/

                for (iI = 0; iI < MAX_PLAYERS; iI++)
                {
                        if (GET_PLAYER((PlayerTypes)iI).isAlive())
                        {
                                if ((GET_PLAYER((PlayerTypes)iI).getTeam() == getID()) || (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam))
                                {
                                        GET_PLAYER((PlayerTypes)iI).updateWarWearinessPercentAnger();
                                }
                        }
                }

                for (iI = 0; iI < MAX_PLAYERS; iI++)
                {
                        if (GET_PLAYER((PlayerTypes)iI).isAlive())
                        {
                                if ((GET_PLAYER((PlayerTypes)iI).getTeam() == getID()) || (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam))
                                {
                                        GET_PLAYER((PlayerTypes)iI).updatePlotGroups();
                                }
                        }
                }

                for (iI = 0; iI < MAX_PLAYERS; iI++)
                {
                        if (GET_PLAYER((PlayerTypes)iI).isAlive())
                        {
                                if ((GET_PLAYER((PlayerTypes)iI).getTeam() == getID()) || (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam))
                                {
                                        GET_PLAYER((PlayerTypes)iI).updateTradeRoutes();
                                }
                        }
                }

/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      09/03/09                       poyuzhe & jdog5000     */
/*                                                                                              */
/* Efficiency                                                                                   */
/************************************************************************************************/
                // From Sanguo Mod Performance, ie the CAR Mod
                // Attitude cache
                if (GC.getGameINLINE().isFinalInitialized())
                {
                        for (int iI = 0; iI < MAX_PLAYERS; iI++)
                        {
                                if( GET_PLAYER((PlayerTypes)iI).isAlive() )
                                {
                                        if( GET_PLAYER((PlayerTypes)iI).getTeam() == getID() || GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam
                                                || GET_TEAM(GET_PLAYER((PlayerTypes)iI).getTeam()).isAtWar(getID()) || GET_TEAM(GET_PLAYER((PlayerTypes)iI).getTeam()).isAtWar(eTeam) )
                                        {
                                                for (int iJ = 0; iJ < MAX_PLAYERS; iJ++)
                                                {
                                                        if( GET_PLAYER((PlayerTypes)iJ).isAlive() && GET_PLAYER((PlayerTypes)iJ).getTeam() != GET_PLAYER((PlayerTypes)iI).getTeam() )
                                                        {
                                                                if( GET_PLAYER((PlayerTypes)iJ).getTeam() == getID() || GET_PLAYER((PlayerTypes)iJ).getTeam() == eTeam )
                                                                {
                                                                        GET_PLAYER((PlayerTypes)iJ).AI_invalidateAttitudeCache((PlayerTypes)iI);
                                                                        GET_PLAYER((PlayerTypes)iI).AI_invalidateAttitudeCache((PlayerTypes)iJ);
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/

                if (GC.getGameINLINE().isFinalInitialized() && !(gDLL->GetWorldBuilderMode()))
                {
                        if (bNewDiplo)
                        {
                                if (!isHuman())
                                {
                                        for (iI = 0; iI < MAX_PLAYERS; iI++)
                                        {
                                                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                                                {
                                                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam)
                                                        {
                                                                if (GET_PLAYER(getLeaderID()).canContact((PlayerTypes)iI))
                                                                {
                                                                        if (GET_PLAYER((PlayerTypes)iI).isHuman())
                                                                        {
                                                                                pDiplo = new CvDiploParameters(getLeaderID());
                                                                                FAssertMsg(pDiplo != NULL, "pDiplo must be valid");
                                                                                pDiplo->setDiploComment((DiploCommentTypes)GC.getInfoTypeForString("AI_DIPLOCOMMENT_DECLARE_WAR"));
                                                                                pDiplo->setAIContact(true);
                                                                                gDLL->beginDiplomacy(pDiplo, ((PlayerTypes)iI));
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }

                        if (!isBarbarian() && !(GET_TEAM(eTeam).isBarbarian()) &&
                                  !isMinorCiv() && !(GET_TEAM(eTeam).isMinorCiv()))
                        {
                                for (iI = 0; iI < MAX_PLAYERS; iI++)
                                {
                                        if (GET_PLAYER((PlayerTypes)iI).isAlive())
                                        {
                                                MEMORY_TRACK_EXEMPT();

                                                if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                                                {
                                                        szBuffer = gDLL->getText("TXT_KEY_MISC_YOU_DECLARED_WAR_ON", GET_TEAM(eTeam).getName().GetCString());
                                                        AddDLLMessage(((PlayerTypes)iI), true, GC.getEVENT_MESSAGE_TIME(), szBuffer, "AS2D_DECLAREWAR", MESSAGE_TYPE_MAJOR_EVENT, NULL, (ColorTypes)GC.getInfoTypeForString("COLOR_WARNING_TEXT"));
                                                }
                                                else if (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam)
                                                {
                                                        szBuffer = gDLL->getText("TXT_KEY_MISC_DECLARED_WAR_ON_YOU", getName().GetCString());
                                                        AddDLLMessage(((PlayerTypes)iI), true, GC.getEVENT_MESSAGE_TIME(), szBuffer, "AS2D_DECLAREWAR", MESSAGE_TYPE_MAJOR_EVENT, NULL, (ColorTypes)GC.getInfoTypeForString("COLOR_WARNING_TEXT"));
                                                }
                                                else if (GET_TEAM(GET_PLAYER((PlayerTypes)iI).getTeam()).isHasMet(getID()) && GET_TEAM(GET_PLAYER((PlayerTypes)iI).getTeam()).isHasMet(eTeam))
                                                {
                                                        szBuffer = gDLL->getText("TXT_KEY_MISC_SOMEONE_DECLARED_WAR", getName().GetCString(), GET_TEAM(eTeam).getName().GetCString());
                                                        AddDLLMessage(((PlayerTypes)iI), false, GC.getEVENT_MESSAGE_TIME(), szBuffer, "AS2D_THEIRDECLAREWAR", MESSAGE_TYPE_MAJOR_EVENT, NULL, (ColorTypes)GC.getInfoTypeForString("COLOR_WARNING_TEXT"));
                                                }
                                        }
                                }

                                szBuffer = gDLL->getText("TXT_KEY_MISC_SOMEONE_DECLARES_WAR", getName().GetCString(), GET_TEAM(eTeam).getName().GetCString());
                                GC.getGameINLINE().addReplayMessage(REPLAY_MESSAGE_MAJOR_EVENT, getLeaderID(), szBuffer, -1, -1, (ColorTypes)GC.getInfoTypeForString("COLOR_WARNING_TEXT"));
                        }
                }

/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      12/06/09                                jdog5000      */
/*                                                                                              */
/* Diplomacy, Customization                                                                     */
/************************************************************************************************/
                // This block is entirely redundant with the cancelDefensivePacts function, better implemented there
/*
                if (!(GET_TEAM(eTeam).isMinorCiv()))
                {
                        for (iI = 0; iI < MAX_PLAYERS; iI++)
                        {
                                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                                {
                                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                                        {
                                                for (pLoopDeal = GC.getGameINLINE().firstDeal(&iLoop); pLoopDeal != NULL; pLoopDeal = GC.getGameINLINE().nextDeal(&iLoop))
                                                {
                                                        bCancelDeal = false;

                                                        if ((pLoopDeal->getFirstPlayer() == ((PlayerTypes)iI)) || (pLoopDeal->getSecondPlayer() == ((PlayerTypes)iI)))
                                                        {
                                                                for (pNode = pLoopDeal->headFirstTradesNode(); (pNode != NULL); pNode = pLoopDeal->nextFirstTradesNode(pNode))
                                                                {
                                                                        if (pNode->m_data.m_eItemType == TRADE_DEFENSIVE_PACT)
                                                                        {
                                                                                bCancelDeal = true;
                                                                        }
                                                                }

                                                                for (pNode = pLoopDeal->headSecondTradesNode(); (pNode != NULL); pNode = pLoopDeal->nextSecondTradesNode(pNode))
                                                                {
                                                                        if (pNode->m_data.m_eItemType == TRADE_DEFENSIVE_PACT)
                                                                        {
                                                                                bCancelDeal = true;
                                                                        }
                                                                }
                                                        }

                                                        if (bCancelDeal)
                                                        {
                                                                pLoopDeal->kill();
                                                        }
                                                }
                                        }
                                }
                        }
                }
*/


                CvEventReporter::getInstance().changeWar(true, getID(), eTeam);

/************************************************************************************************/
/* REVOLUTION_MOD                         03/06/08                                jdog5000      */
/*                                                                                              */
/* For barbarian and minor civs                                                                 */
/************************************************************************************************/
                // Added check for barb, minor - jwd
                if (!isBarbarian() && !(GET_TEAM(eTeam).isBarbarian()) &&
                                  !isMinorCiv() && !(GET_TEAM(eTeam).isMinorCiv()))
                {
                        if( GC.getDefineINT("BBAI_ALLIANCE_OPTION") != 1 )
                        {
                                cancelDefensivePacts();
                        }

                        for (iI = 0; iI < MAX_TEAMS; iI++)
                        {
                                if (iI != getID() && iI != eTeam && GET_TEAM((TeamTypes)iI).isAlive())
                                {
                                        if (GET_TEAM((TeamTypes)iI).isDefensivePact(eTeam))
                                        {
                                                GET_TEAM((TeamTypes)iI).declareWar(getID(), bNewDiplo, WARPLAN_DOGPILE);
                                        }
                                        else if( GET_TEAM((TeamTypes)iI).isDefensivePact(getID()))
                                        {
                                                // For alliance option.  This teams pacts are canceled above if not using alliance option.
                                                GET_TEAM((TeamTypes)iI).declareWar(eTeam, bNewDiplo, WARPLAN_DOGPILE);
                                        }
                                }
                        }

                        if( GC.getDefineINT("BBAI_ALLIANCE_OPTION") != 1 )
                        {
                                GET_TEAM(eTeam).cancelDefensivePacts();
                        }
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/

                        for (iI = 0; iI < MAX_TEAMS; iI++)
                        {
                                if (iI != getID() && iI != eTeam)
                                {
                                        if (GET_TEAM((TeamTypes)iI).isAlive())
                                        {
                                                if (GET_TEAM((TeamTypes)iI).isVassal(eTeam) || GET_TEAM(eTeam).isVassal((TeamTypes)iI))
                                                {
                                                        declareWar((TeamTypes)iI, bNewDiplo, AI_getWarPlan(eTeam));
                                                }
                                                else if (GET_TEAM((TeamTypes)iI).isVassal(getID()) || isVassal((TeamTypes)iI))
                                                {
                                                        GET_TEAM((TeamTypes)iI).declareWar(eTeam, bNewDiplo, WARPLAN_DOGPILE);
                                                }
                                        }
                                }
                        }
                }
/************************************************************************************************/
/* REVOLUTION_MOD                          END                                                  */
/************************************************************************************************/
        }
}

void CvTeam::makePeace(TeamTypes eTeam, bool bBumpUnits)
{
        CvWString szBuffer;
        int iI;

        FAssertMsg(eTeam != NO_TEAM, "eTeam is not assigned a valid value");
        FAssertMsg(eTeam != getID(), "eTeam is not expected to be equal with getID()");

        if (isAtWar(eTeam))
        {
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      05/21/10                                jdog5000      */
/*                                                                                              */
/* AI logging                                                                                   */
/************************************************************************************************/
                if( gTeamLogLevel >= 1 && isAlive() && GET_TEAM(eTeam).isAlive())
                {
                        logBBAIForTeam(getID(), "Team %d (%S) and team %d (%S) make peace", getID(), GET_PLAYER(getLeaderID()).getCivilizationDescription(0), eTeam, GET_PLAYER(GET_TEAM(eTeam).getLeaderID()).getCivilizationDescription(0));
                }
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/

                for (iI = 0; iI < MAX_PLAYERS; iI++)
                {
                        //      Check isEverAlive() here rather than isAlive() since it's just an optimization (updatePlunder() will
                        //      do nothing for a truely dead player as they have no units), and this method is called by REV Python
                        //      in response to a plyer setAlive (false) event notification DURING the processing tof that player's
                        //      death.  If we do not treat THAT player as alive here their blockades will not be lifted
                        if (((GET_PLAYER((PlayerTypes)iI).getTeam() == getID()) || (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam)) && GET_PLAYER((PlayerTypes)iI).isEverAlive())
                        {
                                GET_PLAYER((PlayerTypes)iI).updatePlunder(-1, false);
                        }
                }

                FAssertMsg(eTeam != getID(), "eTeam is not expected to be equal with getID()");
                setAtWar(eTeam, false);
                GET_TEAM(eTeam).setAtWar(getID(), false);

/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      08/21/09                                jdog5000      */
/*                                                                                              */
/* Efficiency                                                                                   */
/************************************************************************************************/
                // Plot danger cache
                GC.getMapINLINE().invalidateIsTeamBorderCache(eTeam);
                GC.getMapINLINE().invalidateIsTeamBorderCache(getID());
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/

                for (iI = 0; iI < MAX_PLAYERS; iI++)
                {
                        if (((GET_PLAYER((PlayerTypes)iI).getTeam() == getID()) || (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam)) && GET_PLAYER((PlayerTypes)iI).isAlive())
                        {
                                GET_PLAYER((PlayerTypes)iI).updatePlunder(1, false);
                        }
                }

                AI_setAtWarCounter(eTeam, 0);
                GET_TEAM(eTeam).AI_setAtWarCounter(getID(), 0);

                AI_setWarSuccess(eTeam, 0);
                GET_TEAM(eTeam).AI_setWarSuccess(getID(), 0);

                AI_setWarPlan(eTeam, NO_WARPLAN);
                GET_TEAM(eTeam).AI_setWarPlan(getID(), NO_WARPLAN);

                if (bBumpUnits)
                {
                        GC.getMapINLINE().verifyUnitValidPlot();
                }

                GC.getGameINLINE().AI_makeAssignWorkDirty();

                if ((getID() == GC.getGameINLINE().getActiveTeam()) || (eTeam == GC.getGameINLINE().getActiveTeam()))
                {
                        gDLL->getInterfaceIFace()->setDirty(Score_DIRTY_BIT, true);
                        gDLL->getInterfaceIFace()->setDirty(CityInfo_DIRTY_BIT, true);
                }

                for (iI = 0; iI < MAX_PLAYERS; iI++)
                {
                        if (GET_PLAYER((PlayerTypes)iI).isAlive())
                        {
                                if ((GET_PLAYER((PlayerTypes)iI).getTeam() == getID()) || (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam))
                                {
                                        GET_PLAYER((PlayerTypes)iI).updateWarWearinessPercentAnger();
                                }
                        }
                }

                for (iI = 0; iI < MAX_PLAYERS; iI++)
                {
                        if (GET_PLAYER((PlayerTypes)iI).isAlive())
                        {
                                if ((GET_PLAYER((PlayerTypes)iI).getTeam() == getID()) || (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam))
                                {
                                        GET_PLAYER((PlayerTypes)iI).updatePlotGroups();
                                }
                        }
                }

                for (iI = 0; iI < MAX_PLAYERS; iI++)
                {
                        if (GET_PLAYER((PlayerTypes)iI).isAlive())
                        {
                                if ((GET_PLAYER((PlayerTypes)iI).getTeam() == getID()) || (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam))
                                {
                                        GET_PLAYER((PlayerTypes)iI).updateTradeRoutes();
                                }
                        }
                }

/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      09/03/09                       poyuzhe & jdog5000     */
/*                                                                                              */
/* Efficiency                                                                                   */
/************************************************************************************************/
                // From Sanguo Mod Performance, ie the CAR Mod
                // Attitude cache
                if (GC.getGameINLINE().isFinalInitialized())
                {
                        for (int iI = 0; iI < MAX_PLAYERS; iI++)
                        {
                                if( GET_PLAYER((PlayerTypes)iI).isAlive() )
                                {
                                        if( GET_PLAYER((PlayerTypes)iI).getTeam() == getID() || GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam
                                                || GET_TEAM(GET_PLAYER((PlayerTypes)iI).getTeam()).isAtWar(getID()) || GET_TEAM(GET_PLAYER((PlayerTypes)iI).getTeam()).isAtWar(eTeam) )
                                        {
                                                for (int iJ = 0; iJ < MAX_PLAYERS; iJ++)
                                                {
                                                        if( GET_PLAYER((PlayerTypes)iJ).isAlive() && GET_PLAYER((PlayerTypes)iJ).getTeam() != GET_PLAYER((PlayerTypes)iI).getTeam() )
                                                        {
                                                                if( GET_PLAYER((PlayerTypes)iJ).getTeam() == getID() || GET_PLAYER((PlayerTypes)iJ).getTeam() == eTeam )
                                                                {
                                                                        GET_PLAYER((PlayerTypes)iJ).AI_invalidateAttitudeCache((PlayerTypes)iI);
                                                                        GET_PLAYER((PlayerTypes)iI).AI_invalidateAttitudeCache((PlayerTypes)iJ);
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/

/************************************************************************************************/
/* REVOLUTION_MOD                         01/01/08                                jdog5000      */
/*                                                                                              */
/*                                                                                              */
/************************************************************************************************/
/* original code
                for (iI = 0; iI < MAX_PLAYERS; iI++)
                {
                        if (GET_PLAYER((PlayerTypes)iI).isAlive())
                        {
                                if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                                {
                                        szBuffer = gDLL->getText("TXT_KEY_MISC_YOU_MADE_PEACE_WITH", GET_TEAM(eTeam).getName().GetCString());
                                        AddDLLMessage(((PlayerTypes)iI), true, GC.getEVENT_MESSAGE_TIME(), szBuffer, "AS2D_MAKEPEACE", MESSAGE_TYPE_MAJOR_EVENT, NULL, (ColorTypes)GC.getInfoTypeForString("COLOR_HIGHLIGHT_TEXT"));
                                }
                                else if (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam)
                                {
                                        szBuffer = gDLL->getText("TXT_KEY_MISC_YOU_MADE_PEACE_WITH", getName().GetCString());
                                        AddDLLMessage(((PlayerTypes)iI), true, GC.getEVENT_MESSAGE_TIME(), szBuffer, "AS2D_MAKEPEACE", MESSAGE_TYPE_MAJOR_EVENT, NULL, (ColorTypes)GC.getInfoTypeForString("COLOR_HIGHLIGHT_TEXT"));
                                }
                                else if (GET_TEAM(GET_PLAYER((PlayerTypes)iI).getTeam()).isHasMet(getID()) && GET_TEAM(GET_PLAYER((PlayerTypes)iI).getTeam()).isHasMet(eTeam))
                                {
                                        szBuffer = gDLL->getText("TXT_KEY_MISC_SOMEONE_MADE_PEACE", getName().GetCString(), GET_TEAM(eTeam).getName().GetCString());
                                        AddDLLMessage(((PlayerTypes)iI), false, GC.getEVENT_MESSAGE_TIME(), szBuffer, "AS2D_THEIRMAKEPEACE", MESSAGE_TYPE_MAJOR_EVENT, NULL, (ColorTypes)GC.getInfoTypeForString("COLOR_HIGHLIGHT_TEXT"));
                                }
                        }
                }

                szBuffer = gDLL->getText("TXT_KEY_MISC_SOMEONE_MADE_PEACE", getName().GetCString(), GET_TEAM(eTeam).getName().GetCString());
                GC.getGameINLINE().addReplayMessage(REPLAY_MESSAGE_MAJOR_EVENT, getLeaderID(), szBuffer, -1, -1, (ColorTypes)GC.getInfoTypeForString("COLOR_HIGHLIGHT_TEXT"));
*/

                // Silence announcement when one team has no units or cities
                // Needed because civs are now set to peace with all when dieing since they keep at war state when being reborn
                bool bHasUnitsOrCities  = (getNumCities() > 0);
                bool bHasUnitsOrCities2 = (GET_TEAM(eTeam).getNumCities() > 0);

                // Could be homeless rebel, must check
                if( !bHasUnitsOrCities )
                {
                        for (iI = 0; iI < MAX_PLAYERS; iI++)
                        {
                                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                                {
                                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                                        {
                                                if( GET_PLAYER((PlayerTypes)iI).getNumUnits() > 0 )
                                                {
                                                        bHasUnitsOrCities = true;
                                                        break;
                                                }
                                        }
                                }
                        }
                }

                if( !bHasUnitsOrCities2 )
                {
                        for (iI = 0; iI < MAX_PLAYERS; iI++)
                        {
                                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                                {
                                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam)
                                        {
                                                if( GET_PLAYER((PlayerTypes)iI).getNumUnits() > 0 )
                                                {
                                                        bHasUnitsOrCities2 = true;
                                                        break;
                                                }
                                        }
                                }
                        }
                }
               

                // Anounce only if neither is minor
                if( !isMinorCiv() && !GET_TEAM(eTeam).isMinorCiv() )
                {
                        // Announce if both are really alive
                        if( bHasUnitsOrCities && bHasUnitsOrCities2 )
                        {
                                for (iI = 0; iI < MAX_PLAYERS; iI++)
                                {
                                        if (GET_PLAYER((PlayerTypes)iI).isAlive())
                                        {
                                                MEMORY_TRACK_EXEMPT();

                                                if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                                                {
                                                        szBuffer = gDLL->getText("TXT_KEY_MISC_YOU_MADE_PEACE_WITH", GET_TEAM(eTeam).getName().GetCString());
                                                        AddDLLMessage(((PlayerTypes)iI), true, GC.getEVENT_MESSAGE_TIME(), szBuffer, "AS2D_MAKEPEACE", MESSAGE_TYPE_MAJOR_EVENT, NULL, (ColorTypes)GC.getInfoTypeForString("COLOR_HIGHLIGHT_TEXT"));
                                                }
                                                else if (GET_PLAYER((PlayerTypes)iI).getTeam() == eTeam)
                                                {
                                                        szBuffer = gDLL->getText("TXT_KEY_MISC_YOU_MADE_PEACE_WITH", getName().GetCString());
                                                        AddDLLMessage(((PlayerTypes)iI), true, GC.getEVENT_MESSAGE_TIME(), szBuffer, "AS2D_MAKEPEACE", MESSAGE_TYPE_MAJOR_EVENT, NULL, (ColorTypes)GC.getInfoTypeForString("COLOR_HIGHLIGHT_TEXT"));
                                                }
                                                else if (GET_TEAM(GET_PLAYER((PlayerTypes)iI).getTeam()).isHasMet(getID()) && GET_TEAM(GET_PLAYER((PlayerTypes)iI).getTeam()).isHasMet(eTeam))
                                                {
                                                        szBuffer = gDLL->getText("TXT_KEY_MISC_SOMEONE_MADE_PEACE", getName().GetCString(), GET_TEAM(eTeam).getName().GetCString());
                                                        AddDLLMessage(((PlayerTypes)iI), false, GC.getEVENT_MESSAGE_TIME(), szBuffer, "AS2D_THEIRMAKEPEACE", MESSAGE_TYPE_MAJOR_EVENT, NULL, (ColorTypes)GC.getInfoTypeForString("COLOR_HIGHLIGHT_TEXT"));
                                                }
                                        }
                                }

                                szBuffer = gDLL->getText("TXT_KEY_MISC_SOMEONE_MADE_PEACE", getName().GetCString(), GET_TEAM(eTeam).getName().GetCString());
                                GC.getGameINLINE().addReplayMessage(REPLAY_MESSAGE_MAJOR_EVENT, getLeaderID(), szBuffer, -1, -1, (ColorTypes)GC.getInfoTypeForString("COLOR_HIGHLIGHT_TEXT"));
                        }
                }
/************************************************************************************************/
/* REVOLUTION_MOD                          END                                                  */
/************************************************************************************************/

                CvEventReporter::getInstance().changeWar(false, getID(), eTeam);

                for (iI = 0; iI < MAX_TEAMS; iI++)
                {
                        if (iI != getID() && iI != eTeam)
                        {
                                if (GET_TEAM((TeamTypes)iI).isAlive())
                                {
                                        if (GET_TEAM((TeamTypes)iI).isVassal(eTeam))
                                        {
                                                GET_TEAM((TeamTypes)iI).makePeace(getID(), bBumpUnits);
                                        }
                                        else if (GET_TEAM((TeamTypes)iI).isVassal(getID()))
                                        {
                                                GET_TEAM((TeamTypes)iI).makePeace(eTeam, bBumpUnits);
                                        }
                                }
                        }
                }

        }
}


bool CvTeam::canContact(TeamTypes eTeam) const
{
        int iI, iJ;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                        {
                                for (iJ = 0; iJ < MAX_PLAYERS; iJ++)
                                {
                                        if (GET_PLAYER((PlayerTypes)iJ).isAlive())
                                        {
                                                if (GET_PLAYER((PlayerTypes)iJ).getTeam() == eTeam)
                                                {
                                                        if (GET_PLAYER((PlayerTypes)iI).canContact((PlayerTypes)iJ))
                                                        {
                                                                return true;
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }

        return false;
}


void CvTeam::meet(TeamTypes eTeam, bool bNewDiplo)
{
        if (!isHasMet(eTeam))
        {
                makeHasMet(eTeam, bNewDiplo);
                GET_TEAM(eTeam).makeHasMet(getID(), bNewDiplo);

/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      02/20/10                                jdog5000      */
/*                                                                                              */
/* AI logging                                                                                   */
/************************************************************************************************/
                if( gTeamLogLevel >= 2 )
                {
                        if( GC.getGameINLINE().isFinalInitialized() )
                        {
                                if( eTeam != getID() && isAlive() && GET_TEAM(eTeam).isAlive() )
                                {
                                        logBBAIForTeam(getID(), "    Team %d (%S) meets team %d (%S)", getID(), GET_PLAYER(getLeaderID()).getCivilizationDescription(0), eTeam, GET_PLAYER(GET_TEAM(eTeam).getLeaderID()).getCivilizationDescription(0) );
                                }
                        }
                }
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/
        }
}


void CvTeam::signOpenBorders(TeamTypes eTeam)
{
        CLinkList<TradeData> ourList;
        CLinkList<TradeData> theirList;
        TradeData item;

        FAssert(eTeam != NO_TEAM);
        FAssert(eTeam != getID());

        if (!isAtWar(eTeam) && (getID() != eTeam))
        {
                setTradeItem(&item, TRADE_OPEN_BORDERS);

                if (GET_PLAYER(getLeaderID()).canTradeItem(GET_TEAM(eTeam).getLeaderID(), item) && GET_PLAYER(GET_TEAM(eTeam).getLeaderID()).canTradeItem(getLeaderID(), item))
                {
                        ourList.clear();
                        theirList.clear();

                        ourList.insertAtEnd(item);
                        theirList.insertAtEnd(item);

                        GC.getGameINLINE().implementDeal(getLeaderID(), (GET_TEAM(eTeam).getLeaderID()), &ourList, &theirList);
                }
        }
}

void CvTeam::signDefensivePact(TeamTypes eTeam)
{
        CLinkList<TradeData> ourList;
        CLinkList<TradeData> theirList;
        TradeData item;

        FAssert(eTeam != NO_TEAM);
        FAssert(eTeam != getID());

        if (!isAtWar(eTeam) && (getID() != eTeam))
        {
                setTradeItem(&item, TRADE_DEFENSIVE_PACT);

                if (GET_PLAYER(getLeaderID()).canTradeItem(GET_TEAM(eTeam).getLeaderID(), item) && GET_PLAYER(GET_TEAM(eTeam).getLeaderID()).canTradeItem(getLeaderID(), item))
                {
                        ourList.clear();
                        theirList.clear();

                        ourList.insertAtEnd(item);
                        theirList.insertAtEnd(item);

                        GC.getGameINLINE().implementDeal(getLeaderID(), (GET_TEAM(eTeam).getLeaderID()), &ourList, &theirList);
                }
        }
}

bool CvTeam::canSignDefensivePact(TeamTypes eTeam)
{
 /************************************************************************************************/
/* Afforess                       Start          03/15/10                                               */
/*                                                                                              */
/*                                                                                              */
/************************************************************************************************/
        if (GC.getGameINLINE().isOption(GAMEOPTION_ADVANCED_DIPLOMACY))
        {
            if (!isHasEmbassy(eTeam))
            {
                return false;
            }
        }
/************************************************************************************************/
/* Afforess                          END                                                            */
/************************************************************************************************/
        for (int iTeam = 0; iTeam < MAX_CIV_TEAMS; ++iTeam)
        {
                if (iTeam != getID() && iTeam != eTeam)
                {
                        CvTeam& kLoopTeam = GET_TEAM((TeamTypes)iTeam);
                        if (kLoopTeam.isPermanentWarPeace(eTeam) != kLoopTeam.isPermanentWarPeace(getID()))
                        {
                                return false;
                        }

                        if (isPermanentWarPeace((TeamTypes)iTeam) != GET_TEAM(eTeam).isPermanentWarPeace((TeamTypes)iTeam))
                        {
                                return false;
                        }
                }
        }

        return true;
}


int CvTeam::getAssets() const
{
        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                        {
                                iCount += GET_PLAYER((PlayerTypes)iI).getAssets();
                        }
                }
        }

        return iCount;
}


int CvTeam::getPower(bool bIncludeVassals) const
{
        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                CvPlayer& kLoopPlayer = GET_PLAYER((PlayerTypes)iI);
                if (kLoopPlayer.isAlive())
                {
                        if (kLoopPlayer.getTeam() == getID() || (bIncludeVassals && GET_TEAM(kLoopPlayer.getTeam()).isVassal(getID())))
                        {
                                iCount += kLoopPlayer.getPower();

                                if ( GET_TEAM(kLoopPlayer.getTeam()).isVassal(getID()) )
                                {
                                        iCount -= kLoopPlayer.getTechPower();
                                }
                        }
                }
        }

        return iCount;
}

int CvTeam::getDefensivePower(TeamTypes eExcludeTeam) const
{
        int iCount;
        int iI;

        iCount = 0;

        FAssert(eExcludeTeam != getID());

        for (iI = 0; iI < MAX_CIV_TEAMS; iI++)
        {
                CvTeam& kLoopTeam = GET_TEAM((TeamTypes)iI);
                if (kLoopTeam.isAlive() && !kLoopTeam.isAVassal())
                {
                        // K-Mod: added "eExcludeTeam" argument, so that defensive power can take into account the cancelation of pacts.
                        if (iI != eExcludeTeam && (getID() == iI || isVassal((TeamTypes)iI) || isDefensivePact((TeamTypes)iI)))
                        {
                                iCount += kLoopTeam.getPower(true);
                        }
                }
        }

        return iCount;
}

int CvTeam::getEnemyPower() const
{
        int iCount = 0;

        for (int iI = 0; iI < MAX_CIV_TEAMS; iI++)
        {
                CvTeam& kLoopTeam = GET_TEAM((TeamTypes)iI);
                if (kLoopTeam.isAlive())
                {
                        if (getID() != iI && isAtWar((TeamTypes)iI))
                        {
                                iCount += kLoopTeam.getPower(false);
                        }
                }
        }

        return iCount;
}


int CvTeam::getNumNukeUnits() const
{
        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                CvPlayer& kLoopPlayer = GET_PLAYER((PlayerTypes)iI);
                if (kLoopPlayer.isAlive())
                {
                        if (kLoopPlayer.getTeam() == getID() || GET_TEAM(kLoopPlayer.getTeam()).isVassal(getID()))
                        {
                                iCount += kLoopPlayer.getNumNukeUnits();
                        }
                }
        }

        return iCount;
}

int CvTeam::getVotes(VoteTypes eVote, VoteSourceTypes eVoteSource) const
{
        int iCount = 0;

        for (int iI = 0; iI < MAX_PLAYERS; iI++)
        {
                CvPlayer& kLoopPlayer = GET_PLAYER((PlayerTypes)iI);
                if (kLoopPlayer.getTeam() == getID() && kLoopPlayer.isAlive())
                {
                        iCount += kLoopPlayer.getVotes(eVote, eVoteSource);
                }
        }

        return iCount;
}

bool CvTeam::isVotingMember(VoteSourceTypes eVoteSource) const
{
        return (getVotes(NO_VOTE, eVoteSource) > 0);
}

bool CvTeam::isFullMember(VoteSourceTypes eVoteSource) const
{
        if (isForceTeamVoteEligible(eVoteSource))
        {
                return true;
        }

        for (int iI = 0; iI < MAX_PLAYERS; iI++)
        {
                CvPlayer& kLoopPlayer = GET_PLAYER((PlayerTypes)iI);
                if (kLoopPlayer.getTeam() == getID() && kLoopPlayer.isAlive())
                {
                        if (!kLoopPlayer.isFullMember(eVoteSource))
                        {
                                return false;
                        }
                }
        }

        return true;
}

/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      07/20/09                                jdog5000      */
/*                                                                                              */
/* General AI                                                                                   */
/************************************************************************************************/
int CvTeam::getAtWarCount(bool bIgnoreMinors, bool bIgnoreVassals) const
{
        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_CIV_TEAMS; iI++)
        {
                if (GET_TEAM((TeamTypes)iI).isAlive())
                {
                        if (!bIgnoreMinors || !(GET_TEAM((TeamTypes)iI).isMinorCiv()))
                        {
                                if( !bIgnoreVassals || !(GET_TEAM((TeamTypes)iI).isAVassal()))
                                {
                                        if (isAtWar((TeamTypes)iI))
                                        {
                                                FAssert(iI != getID());
                                                FAssert(!(AI_isSneakAttackPreparing((TeamTypes)iI)));
                                                iCount++;
                                        }
                                }
                        }
                }
        }

        return iCount;
}
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/

int CvTeam::getWarPlanCount(WarPlanTypes eWarPlan, bool bIgnoreMinors) const
{
        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_CIV_TEAMS; iI++)
        {
                if (GET_TEAM((TeamTypes)iI).isAlive())
                {
                        if (!bIgnoreMinors || !(GET_TEAM((TeamTypes)iI).isMinorCiv()))
                        {
                                if (AI_getWarPlan((TeamTypes)iI) == eWarPlan)
                                {
                                        FAssert(iI != getID());
                                        iCount++;
                                }
                        }
                }
        }

        return iCount;
}


int CvTeam::getAnyWarPlanCount(bool bIgnoreMinors) const
{
        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_CIV_TEAMS; iI++)
        {
                if (GET_TEAM((TeamTypes)iI).isAlive())
                {
                        if (!bIgnoreMinors || !(GET_TEAM((TeamTypes)iI).isMinorCiv()))
                        {
                                if (AI_getWarPlan((TeamTypes)iI) != NO_WARPLAN)
                                {
                                        FAssert(iI != getID());
                                        iCount++;
                                }
                        }
                }
        }

        FAssert(iCount >= getAtWarCount(bIgnoreMinors));

        return iCount;
}


int CvTeam::getChosenWarCount(bool bIgnoreMinors) const
{
        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_CIV_TEAMS; iI++)
        {
                if (GET_TEAM((TeamTypes)iI).isAlive())
                {
                        if (!bIgnoreMinors || !(GET_TEAM((TeamTypes)iI).isMinorCiv()))
                        {
                                if (AI_isChosenWar((TeamTypes)iI))
                                {
                                        FAssert(iI != getID());
                                        iCount++;
                                }
                        }
                }
        }

        return iCount;
}


int CvTeam::getHasMetCivCount(bool bIgnoreMinors) const
{
        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_CIV_TEAMS; iI++)
        {
                if (GET_TEAM((TeamTypes)iI).isAlive())
                {
                        if (iI != getID())
                        {
                                if (!bIgnoreMinors || !(GET_TEAM((TeamTypes)iI).isMinorCiv()))
                                {
                                        if (isHasMet((TeamTypes)iI))
                                        {
                                                FAssert(iI != getID());
                                                iCount++;
                                        }
                                }
                        }
                }
        }

        return iCount;
}


bool CvTeam::hasMetHuman() const
{
        int iI;

        for (iI = 0; iI < MAX_CIV_TEAMS; iI++)
        {
                if (GET_TEAM((TeamTypes)iI).isAlive())
                {
                        if (iI != getID())
                        {
                                if (GET_TEAM((TeamTypes)iI).isHuman())
                                {
                                        if (isHasMet((TeamTypes)iI))
                                        {
                                                FAssert(iI != getID());
                                                return true;
                                        }
                                }
                        }
                }
        }

        return false;
}


int CvTeam::getDefensivePactCount(TeamTypes eTeam) const
{
        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_CIV_TEAMS; iI++)
        {
                if (GET_TEAM((TeamTypes)iI).isAlive())
                {
                        if (iI != getID())
                        {
                                if (isDefensivePact((TeamTypes)iI))
                                {
                                        if (NO_TEAM == eTeam || GET_TEAM(eTeam).isHasMet((TeamTypes)iI))
                                        {
                                                iCount++;
                                        }
                                }
                        }
                }
        }

        return iCount;
}

int CvTeam::getVassalCount(TeamTypes eTeam) const
{
        int iCount = 0;

        for (int iI = 0; iI < MAX_CIV_TEAMS; iI++)
        {
                CvTeam& kLoopTeam = GET_TEAM((TeamTypes)iI);
                if (kLoopTeam.isAlive())
                {
                        if (iI != getID())
                        {
                                if (kLoopTeam.isVassal(getID()))
                                {
                                        if (NO_TEAM == eTeam || GET_TEAM(eTeam).isHasMet((TeamTypes)iI))
                                        {
                                                iCount++;
                                        }
                                }
                        }
                }
        }

        return iCount;
}

bool CvTeam::isAVassal() const
{
        int iI;

        for (iI = 0; iI < MAX_CIV_TEAMS; iI++)
        {
                if (GET_TEAM((TeamTypes)iI).isAlive())
                {
                        if (iI != getID())
                        {
                                if (isVassal((TeamTypes)iI))
                                {
                                        FAssert(iI != getID());
                                        return true;
                                }
                        }
                }
        }

        return false;
}

bool CvTeam::canVassalRevolt(TeamTypes eMaster) const
{
        FAssert(NO_TEAM != eMaster);

        CvTeam& kMaster = GET_TEAM(eMaster);

        if (isVassal(eMaster))
        {
                if (100 * getTotalLand(false) < GC.getDefineINT("VASSAL_REVOLT_OWN_LOSSES_FACTOR") * getVassalPower())
                {
                        return true;
                }

                if (100 * kMaster.getTotalLand() < GC.getDefineINT("VASSAL_REVOLT_MASTER_LOSSES_FACTOR") * getMasterPower() && (100 * GET_PLAYER(getLeaderID()).getUnitPower() > GET_PLAYER(kMaster.getLeaderID()).getUnitPower() * (10 + GC.getDefineINT("FREE_VASSAL_MILITARY_PERCENT"))))
                {
                        return true;
                }
        }

        if (GC.getDefineINT("FREE_VASSAL_MILITARY_PERCENT") < 0 ||
                100 * GET_PLAYER(getLeaderID()).getUnitPower() > GET_PLAYER(kMaster.getLeaderID()).getUnitPower() * GC.getDefineINT("FREE_VASSAL_MILITARY_PERCENT"))
        {
                return true;
        }
       
        if (GC.getDefineINT("FREE_VASSAL_LAND_PERCENT") < 0 ||
                100 * getTotalLand(false) < kMaster.getTotalLand(false) * GC.getDefineINT("FREE_VASSAL_LAND_PERCENT"))
        {
                return false;
        }

        if (GC.getDefineINT("FREE_VASSAL_POPULATION_PERCENT") < 0 ||
                100 * getTotalPopulation(false) < kMaster.getTotalPopulation(false) * GC.getDefineINT("FREE_VASSAL_POPULATION_PERCENT"))
        {
                return false;
        }

        return true;
}

/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      07/20/09                                jdog5000      */
/*                                                                                              */
/* General AI                                                                                   */
/************************************************************************************************/
int CvTeam::getCurrentMasterPower(bool bIncludeVassals) const
{
        if( isAVassal() )
        {
                for( int iI = 0; iI < MAX_CIV_TEAMS; iI++)
                {
                        if (GET_TEAM((TeamTypes)iI).isAlive())
                        {
                                if (iI != getID())
                                {
                                        if (isVassal((TeamTypes)iI))
                                        {
                                                return GET_TEAM((TeamTypes)iI).getPower(bIncludeVassals);
                                        }
                                }
                        }
                }
        }

        // Should never get here
        FAssert(false);
        return 0;
}

bool CvTeam::isMasterPlanningLandWar(CvArea* pArea)
{
        if( !isAVassal() )
        {
                return false;
        }

        if( (pArea->getAreaAIType(getID()) == AREAAI_OFFENSIVE) || (pArea->getAreaAIType(getID()) == AREAAI_DEFENSIVE) || (pArea->getAreaAIType(getID()) == AREAAI_MASSING) )
        {
                return true;
        }

        for( int iI = 0; iI < MAX_CIV_TEAMS; iI++ )
        {
                if( isVassal((TeamTypes)iI) )
                {
                        if( GET_TEAM((TeamTypes)iI).getAnyWarPlanCount(true) > 0 )
                        {
                                if( (pArea->getAreaAIType((TeamTypes)iI) == AREAAI_OFFENSIVE) || (pArea->getAreaAIType((TeamTypes)iI) == AREAAI_DEFENSIVE) || (pArea->getAreaAIType((TeamTypes)iI) == AREAAI_MASSING) )
                                {
                                        return true;
                                }
                                else if( pArea->getAreaAIType((TeamTypes)iI) == AREAAI_NEUTRAL )
                                {
                                        // Master has no presence here
                                        if( (pArea->getNumCities() - countNumCitiesByArea(pArea)) > 2 )
                                        {
                                                return (GC.getGameINLINE().getSorenRandNum((isCapitulated() ? 6 : 4),"Vassal land war") == 0);
                                        }
                                }
                        }
                        else if( GET_TEAM((TeamTypes)iI).isHuman() )
                        {
                                if( GC.getBBAI_HUMAN_VASSAL_WAR_BUILD() )
                                {
                                        if( (pArea->getNumCities() - countNumCitiesByArea(pArea) - GET_TEAM((TeamTypes)iI).countNumCitiesByArea(pArea)) > 2 )
                                        {
                                                return (GC.getGameINLINE().getSorenRandNum(4,"Vassal land war") == 0);
                                        }
                                }
                        }

                        break;
                }
        }

        return false;
}

bool CvTeam::isMasterPlanningSeaWar(CvArea* pArea)
{
        if( !isAVassal() )
        {
                return false;
        }

        if( (pArea->getAreaAIType(getID()) == AREAAI_ASSAULT) || (pArea->getAreaAIType(getID()) == AREAAI_ASSAULT_ASSIST) || (pArea->getAreaAIType(getID()) == AREAAI_ASSAULT_MASSING) )
        {
                return true;
        }

        for( int iI = 0; iI < MAX_CIV_TEAMS; iI++ )
        {
                if( isVassal((TeamTypes)iI) )
                {
                        if( GET_TEAM((TeamTypes)iI).getAnyWarPlanCount(true) > 0 )
                        {
                                if( (pArea->getAreaAIType((TeamTypes)iI) == AREAAI_ASSAULT) || (pArea->getAreaAIType((TeamTypes)iI) == AREAAI_ASSAULT_ASSIST) || (pArea->getAreaAIType((TeamTypes)iI) == AREAAI_ASSAULT_MASSING) )
                                {
                                        return (GC.getGameINLINE().getSorenRandNum((isCapitulated() ? 3 : 2),"Vassal sea war") == 0);
                                }
                                else if( pArea->getAreaAIType((TeamTypes)iI) == AREAAI_NEUTRAL )
                                {
                                        // Master has no presence here
                                        return false;
                                }

                        }
                        else if( GET_TEAM((TeamTypes)iI).isHuman() )
                        {
                                return false;
                        }

                        break;
                }
        }

        return false;
}
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/

int CvTeam::getUnitClassMaking(UnitClassTypes eUnitClass) const
{
        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                        {
                                iCount += GET_PLAYER((PlayerTypes)iI).getUnitClassMaking(eUnitClass);
                        }
                }
        }

        return iCount;
}


int CvTeam::getUnitClassCountPlusMaking(UnitClassTypes eIndex) const
{
        return (getUnitClassCount(eIndex) + getUnitClassMaking(eIndex));
}


int CvTeam::getBuildingClassMaking(BuildingClassTypes eBuildingClass) const
{
        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                        {
                                iCount += GET_PLAYER((PlayerTypes)iI).getBuildingClassMaking(eBuildingClass);
                        }
                }
        }

        return iCount;
}


int CvTeam::getBuildingClassCountPlusMaking(BuildingClassTypes eIndex) const
{
        return (getBuildingClassCount(eIndex) + getBuildingClassMaking(eIndex));
}


int CvTeam::getHasReligionCount(ReligionTypes eReligion) const
{
        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                        {
                                iCount += GET_PLAYER((PlayerTypes)iI).getHasReligionCount(eReligion);
                        }
                }
        }

        return iCount;
}


int CvTeam::getHasCorporationCount(CorporationTypes eCorporation) const
{
        int iCount = 0;

        for (int iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                        {
                                iCount += GET_PLAYER((PlayerTypes)iI).getHasCorporationCount(eCorporation);
                        }
                }
        }

        return iCount;
}

int CvTeam::processedTeamCulture()
{
        int iCulture;
        if (countTotalCulture() < MAX_INT)
        {
                iCulture = (int)countTotalCulture();
        }
        else
        {
                iCulture = MAX_INT;
        }
        return iCulture;
}


unsigned long long CvTeam::countTotalCulture()
{
        unsigned long long iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                        {
                                iCount += GET_PLAYER((PlayerTypes)iI).countTotalCulture();
                        }
                }
        }

        return iCount;
}


int CvTeam::countNumUnitsByArea(CvArea* pArea) const
{
        PROFILE_FUNC();

        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                        {
                                iCount += pArea->getUnitsPerPlayer((PlayerTypes)iI);
                        }
                }
        }

        return iCount;
}


int CvTeam::countNumCitiesByArea(CvArea* pArea) const
{
        PROFILE_FUNC();

        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                        {
                                iCount += pArea->getCitiesPerPlayer((PlayerTypes)iI);
                        }
                }
        }

        return iCount;
}


int CvTeam::countTotalPopulationByArea(CvArea* pArea) const
{
        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                        {
                                iCount += pArea->getPopulationPerPlayer((PlayerTypes)iI);
                        }
                }
        }

        return iCount;
}


int CvTeam::countPowerByArea(CvArea* pArea) const
{
        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                        {
                                iCount += pArea->getPower((PlayerTypes)iI);
                        }
                }
        }

        return iCount;
}


int CvTeam::countEnemyPowerByArea(CvArea* pArea) const
{
        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() != getID())
                        {
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      01/11/09                                jdog5000      */
/*                                                                                              */
/* General AI                                                                                   */
/************************************************************************************************/
/* original BTS code
                                if (isAtWar(GET_PLAYER((PlayerTypes)iI).getTeam()))
*/

                                // Count planned wars as well
                                if (AI_getWarPlan(GET_PLAYER((PlayerTypes)iI).getTeam()) != NO_WARPLAN)
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/
                                {
                                        iCount += pArea->getPower((PlayerTypes)iI);
                                }
                        }
                }
        }

        return iCount;
}

/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      04/01/10                                jdog5000      */
/*                                                                                              */
/* War strategy AI                                                                              */
/************************************************************************************************/
int CvTeam::countEnemyPopulationByArea(CvArea* pArea) const
{
        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() != getID())
                        {
                                WarPlanTypes eWarPlan = AI_getWarPlan(GET_PLAYER((PlayerTypes)iI).getTeam());
                                if( eWarPlan != NO_WARPLAN )
                                {
                                        int iContribution = pArea->getPopulationPerPlayer((PlayerTypes)iI);

                                        if ( eWarPlan == WARPLAN_LIMITED && (isMinorCiv() || GET_TEAM(GET_PLAYER((PlayerTypes)iI).getTeam()).isMinorCiv()) )
                                        {
                                                iContribution /= 2;
                                        }

                                        iCount += iContribution;
                                }
                        }
                }
        }

        return iCount;
}
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/


int CvTeam::countNumAIUnitsByArea(CvArea* pArea, UnitAITypes eUnitAI) const
{
        PROFILE_FUNC();

        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID())
                        {
                                iCount += pArea->getNumAIUnits(((PlayerTypes)iI), eUnitAI);
                        }
                }
        }

        return iCount;
}

/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      05/19/10                                jdog5000      */
/*                                                                                              */
/* War strategy AI                                                                              */
/************************************************************************************************/
int CvTeam::countEnemyDangerByArea(CvArea* pArea, TeamTypes eEnemyTeam ) const
{
        PROFILE_FUNC();

        CvPlot* pLoopPlot;
        int iCount;
        int iI;

        iCount = 0;

        for (iI = 0; iI < GC.getMapINLINE().numPlotsINLINE(); iI++)
        {
                pLoopPlot = GC.getMapINLINE().plotByIndexINLINE(iI);

                if (pLoopPlot != NULL)
                {
                        if (pLoopPlot->area() == pArea)
                        {
                                if (pLoopPlot->getTeam() == getID())
                                {
                                        //      Koshling - don't count animals - they are not actively attacking us so they shouldn't trigger
                                        //      things like a defensive stance
                                        iCount += pLoopPlot->plotCount(PUF_canDefendEnemyNoAnimal, getLeaderID(), 0, NO_PLAYER, eEnemyTeam, PUF_isVisible, getLeaderID());
                                }
                        }
                }
        }

        return iCount;
}
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/


int CvTeam::getResearchCost(TechTypes eTech) const
{
        int iCost;
        int iFinalMultiplier = 1;

        FAssertMsg(eTech != NO_TECH, "Tech is not assigned a valid value");

        iCost = GC.getTechInfo(eTech).getResearchCost();

        if ( iCost > MAX_INT/10000 )
        {
                iCost /= 10000;
                iFinalMultiplier = 10000;
        }

        //      Arkatakor
        if (!isHuman() && !isBarbarian())
        {
                //      The handicap type will be based on the average handicap of all human players
                iCost *= GC.getHandicapInfo(GC.getGameINLINE().getHandicapType()).getAIResearchPercent();
        }
        else
        {
                iCost *= GC.getHandicapInfo(getHandicapType()).getResearchPercent();
        }
       
        iCost /= 100;  

        if (!isHuman() && !isBarbarian())
        {              
        //Afforess AI Flexible Difficulty Start
                if (GC.getGameINLINE().isModderGameOption(MODDERGAMEOPTION_AI_USE_FLEXIBLE_DIFFICULTY))
                {
                        //45deg: Switched off AIResearch percent; now iAIResearchPercent will be the same for every handicap level, it will only be used as an offset and to
                        //tweak balance between human and AI research rate (see use of AIResearchPercent above)
                        //HandicapTypes eStandardDifficulty = (HandicapTypes)GC.getDefineINT("STANDARD_HANDICAP");
                        //iCost *= std::max(50, 100 - (GC.getHandicapInfo(getHandicapType()).getAIResearchPercent() - GC.getHandicapInfo(eStandardDifficulty).getAIResearchPercent()));
                        iCost *= GC.getHandicapInfo(getHandicapType()).getResearchPercent(); //45deg: now AI is using the same Research rate as human players
                        iCost /= 100;
                }
        //Afforess AI Flexible Difficulty End
        }

        iCost *= GC.getWorldInfo(GC.getMapINLINE().getWorldSize()).getResearchPercent();
        iCost /= 100;

        iCost *= GC.getGameSpeedInfo(GC.getGameINLINE().getGameSpeedType()).getResearchPercent();
        iCost /= 100;

        iCost *= GC.getEraInfo(GC.getGameINLINE().getStartEra()).getResearchPercent();
        iCost /= 100;

        iCost *= std::max(0, ((GC.getDefineINT("TECH_COST_EXTRA_TEAM_MEMBER_MODIFIER") * (getNumMembers() - 1)) + 100));
        iCost /= 100;
       
        if (!GC.getGameINLINE().isOption(GAMEOPTION_NO_REVOLUTION))
        {      
                iCost *= GC.getDefineINT("REVOLUTION_TECH_COST_RATIO");
                iCost /= 100;
        }
//45deg - START        
// Attempt to make tech runaway hard to achieve and to avoid civs falling behind in techs; if any civ is far away in terms of tech from where it's supposed to be
// it gets help or it's hindered by respectively decreasing or increasing tech cost; that is, compared to the "real" timeline of our world
        if (GC.getGameINLINE().isModderGameOption(MODDERGAMEOPTION_REALISTIC_TIMESCALE))
        {
                float fEstimateEndTurn = 0;
                for (int iI = 0; iI < GC.getGameSpeedInfo(GC.getGameINLINE().getGameSpeedType()).getNumTurnIncrements(); iI++)
                {
                        fEstimateEndTurn += GC.getGameSpeedInfo(GC.getGameINLINE().getGameSpeedType()).getGameTurnInfo(iI).iNumGameTurnsPerIncrement;
                }
               
                fEstimateEndTurn *= (100- (GC.getEraInfo(GC.getGameINLINE().getStartEra()).getStartPercent()));
                fEstimateEndTurn /= 100;               
                       
                //fEstimateEndTurn -= GC.getGameSpeedInfo(GC.getGameINLINE().getGameSpeedType()).getGoldenAgePercent() / 20; // leave 5 turns at the end of the game for Future Techs (blitz gamespeed), scaled for gamespeed
                EraTypes eStartEra = (EraTypes)GC.getGame().getStartEra();
                EraTypes eEndEra = (EraTypes)((GC.getGameINLINE().isOption(GAMEOPTION_NO_FUTURE)) ? GC.getInfoTypeForString("ERA_MODERN") : GC.getNumEraInfos() - 1);
                int iEraCount = (int)eEndEra - (int)eStartEra;

                //Count only the number of techs researchable by players in the game (starting from the start era, to the end era)
                int iTechCount = 0;
                for (int iI = 0; iI < GC.getNumTechInfos(); iI++)
                {
                        EraTypes eEra = (EraTypes)GC.getTechInfo((TechTypes)iI).getEra();
                        if (eEra >= eStartEra && eEra <= eEndEra)
                        {
                                iTechCount++;
                        }
                }
                //Assuming we divide turns evenly per era
                float fExpectedEra = (GC.getGameINLINE().getElapsedGameTurns() / (fEstimateEndTurn / iEraCount)) + eStartEra;
                float fPlayerEra = (float)GET_PLAYER(getLeaderID()).getCurrentEra();
                for (int iI = 0; iI < GC.getNumTechInfos(); iI++)       // 45deg: assuming we have the same number of techs per era; it's not true but it's a good approximation for our puroposes
                {
                        if (!(isHasTech((TechTypes)iI)))
                        {
                                if (GC.getTechInfo((TechTypes)iI).getEra() < GET_PLAYER(getLeaderID()).getCurrentEra())
                                {              
                                        fPlayerEra -= (float)(1.0/(iTechCount/iEraCount));      // 45deg: added this term to compensate techs left behind from previous eras; if I get Alphabet but I still miss half of Ancient Era techs, I'm not truly on Classical
                                }
                        }
                        else
                        {
                                if (GC.getTechInfo((TechTypes)iI).getEra() >= GET_PLAYER(getLeaderID()).getCurrentEra())        //45deg: on the other hand if I have more techs of current era (say Classical), I'm a bit closer to next era
                                {
                                        fPlayerEra += (float)(1.0/(iTechCount/iEraCount));     
                                }
                        }
                }

                int iModifier = (int)(100 * (pow((float)4, (fPlayerEra - fExpectedEra))));
                iModifier += 10;
                iModifier *= 10;
                iModifier /= 11;
               
                iCost *= iModifier;
                iCost /= 100;
        }
        if (isBarbarian())      //45deg: barbarians get too advanced otherwise
        {
                iCost *= 2;
                if ((GC.getGameINLINE().isOption(GAMEOPTION_RAGING_BARBARIANS)) || (GC.getGameINLINE().isOption(GAMEOPTION_BARBARIAN_WORLD)))
                {      
                        iCost *= 2;
                }
        }
//45deg - END          
        return std::max(1, iCost*iFinalMultiplier);
}


int CvTeam::getResearchLeft(TechTypes eTech) const
{
        return std::max(0, (getResearchCost(eTech) - getResearchProgress(eTech)));
}


bool CvTeam::hasHolyCity(ReligionTypes eReligion) const
{
        CvCity* pHolyCity;

        FAssertMsg(eReligion != NO_RELIGION, "Religion is not assigned a valid value");

        pHolyCity = GC.getGameINLINE().getHolyCity(eReligion);

        if (pHolyCity != NULL)
        {
                return (pHolyCity->getTeam() == getID());
        }

        return false;
}


bool CvTeam::hasHeadquarters(CorporationTypes eCorporation) const
{
        FAssertMsg(eCorporation != NO_CORPORATION, "Corporation is not assigned a valid value");

        CvCity* pHeadquarters = GC.getGameINLINE().getHeadquarters(eCorporation);

        if (pHeadquarters != NULL)
        {
                return (pHeadquarters->getTeam() == getID());
        }

        return false;
}

bool CvTeam::hasBonus(BonusTypes eBonus) const
{
        for (int iI = 0; iI < MAX_PLAYERS; ++iI)
        {
                if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID() && GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).hasBonus(eBonus))
                        {
                                return true;
                        }
                }
        }

        return false;
}

bool CvTeam::isBonusObsolete(BonusTypes eBonus) const
{
        TechTypes eObsoleteTech = (TechTypes) GC.getBonusInfo(eBonus).getTechObsolete();
        if (eObsoleteTech != NO_TECH && isHasTech(eObsoleteTech))
        {
                return true;
        }
        return false;
}


bool CvTeam::isHuman() const
{
        PROFILE_FUNC();

        int iI;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID() && GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).isHuman())
                        {
                                return true;
                        }
                }
        }

        return false;
}


bool CvTeam::isBarbarian() const
{
        return (getID() == BARBARIAN_TEAM);
}


bool CvTeam::isMinorCiv() const
{
        bool bValid;
        int iI;

        bValid = false;

        for (iI = 0; iI < MAX_PLAYERS; iI++)
        {
                if (GET_PLAYER((PlayerTypes)iI).getTeam() == getID() && GET_PLAYER((PlayerTypes)iI).isAlive())
                {
                        if (GET_PLAYER((PlayerTypes)iI).isMinorCiv())
                        {
                                bValid = true;
                        }
                        else
                        {
                                return false;
                        }
                }
        }

        return bValid;
}

/************************************************************************************************/
/* REVOLUTION_MOD                         10/22/08                                jdog5000      */
/*                                                                                              */
/* For Minor Civs                                                                               */
/************************************************************************************************/
void CvTeam::setIsMinorCiv( bool bNewValue, bool bDoBarbCivCheck )
{
        int iI;
        if( bNewValue != isMinorCiv() )
        {
                if( isAlive() )
                {
                        if( bNewValue )
                        {
                                logMsg( "Switching team %d to minor", getID() );
                        }
                        else
                        {
                                logMsg( "Switching minor team %d to full", getID() );
                        }
                }
                else
                {
                        if( bNewValue )
                        {
                                logMsg( "Setting non-alive team %d to minor", getID() );
                        }
                        else
                        {
                                logMsg( "Setting non-alive minor team %d to full", getID() );
                        }
                }

                bool abHasMet[MAX_TEAMS];
                TeamTypes eBarbCivVictim = NO_TEAM;

                // Have to check hasMet status first because of vassal states ... dow on master causes hasMet for vassal
                for (iI = 0; iI < MAX_TEAMS; iI++)
                {
                        abHasMet[iI] = isHasMet((TeamTypes)iI);
                }

                if ( isAlive() )
                {
                        if( bDoBarbCivCheck && !bNewValue )
                        {      
                                int iMaxVal = 0;
                                for (int iJ = 0; iJ < MAX_CIV_TEAMS; iJ++)
                                {
                                        if( iJ != getID() )
                                        {
                                                int iValue = GET_TEAM(getID()).AI_getBarbarianCivWarVal((TeamTypes)iJ, 12);
                                                if( iValue > iMaxVal )
                                                {
                                                        logMsg("    BarbCiv team %d is considering declaring war against victim Team %d", getID(), iJ);
                                                        CvCity* pCapital = GET_PLAYER(getLeaderID()).getCapitalCity();
                                                        if( pCapital == NULL || pCapital->plot()->isHasPathToPlayerCity(getID(),GET_TEAM((TeamTypes)iJ).getLeaderID()) )
                                                        {
                                                                iMaxVal = iValue;
                                                                eBarbCivVictim = (TeamTypes)iJ;
                                                        }
                                                }
                                        }
                                }

                                logMsg("    BarbCiv team %d will declare war against victim Team %d", getID(), eBarbCivVictim);
                        }
                }

/*              if( !(GC.getGameINLINE().isOption(GAMEOPTION_START_AS_MINORS)) )
                {
                        logMsg("    Making peace with other players");
                        // Declare peace in either case, remove contact causes "Nice to meet you" diplo screens
                        for (iI = 0; iI < MAX_CIV_TEAMS; iI++)
                        {
                                if( iI != getID() )
                                {
                                        if( isAtWar((TeamTypes)iI) && !GET_TEAM((TeamTypes)iI).isBarbarian() && !GET_TEAM((TeamTypes)iI).isMinorCiv() )
                                        {
                                                makePeace((TeamTypes)iI, false);
                                        }

                                        setHasMet( (TeamTypes)iI, false );
                                        setHasMet( getID(), false );
                                }
                        }
                }
*/


                if( bNewValue )
                {
                        // Convert all team members
                        for(iI = 0; iI < MAX_CIV_PLAYERS; iI++)
                        {
                                if( GET_PLAYER((PlayerTypes)iI).getTeam() == getID() )
                                {
                                        GC.getInitCore().setMinorNationCiv((PlayerTypes)iI, bNewValue);
                                }
                        }

                        // Declare war on all outside teams
                        declareWarAsMinor();
                }
                else
                {
                        // Keep war againt those this team has met
                        for (iI = 0; iI < MAX_CIV_TEAMS; iI++)
                        {
                                if( iI != getID() && GET_TEAM((TeamTypes)iI).isAlive() && !(GET_TEAM((TeamTypes)iI).isBarbarian()) && !(GET_TEAM((TeamTypes)iI).isMinorCiv()) )
                                {
                                        if( abHasMet[iI] )
                                        {
                                                if( GC.getGameINLINE().isOption(GAMEOPTION_START_AS_MINORS) )
                                                {
                                                        if( isAlive() && !isAtWar((TeamTypes)iI) )
                                                        {
                                                                declareWar((TeamTypes)iI, true, NO_WARPLAN);
                                                        }
                                                }
                                                else
                                                {
                                                        // Does other player want to keep war with us?
                                                        bool bPeace = true;
                                                        bool bPlanWar = false;

                                                        CvPlayer& kPlayer = GET_PLAYER(GET_TEAM((TeamTypes)iI).getLeaderID());
                                                        int iLoop = 0;
                                                        int iCount = 0;
                                                        for (CvUnit* pLoopUnit = kPlayer.firstUnit(&iLoop); pLoopUnit; pLoopUnit = kPlayer.nextUnit(&iLoop))
                                                        {
                                                                if( pLoopUnit->plot()->getTeam() == getID() )
                                                                {
                                                                        iCount++;
                                                                }
                                                        }
                                                       
                                                        if( GET_TEAM((TeamTypes)iI).isHuman() )
                                                        {
                                                                if( iCount > 2 )
                                                                {
                                                                        bPeace = false;
                                                                }
                                                        }
                                                        else
                                                        {
                                                                if( !isAtWar((TeamTypes)iI) )
                                                                {
                                                                        // Shouldn't happen
                                                                        bPeace = false;
                                                                }
                                                                else if( GET_TEAM((TeamTypes)iI).AI_minorKeepWarVal(getID()) > 0 )
                                                                {
                                                                        if( GET_TEAM((TeamTypes)iI).AI_endWarVal(getID()) < (GET_TEAM(getID()).AI_endWarVal((TeamTypes)iI))