// Call to Conquest Script

//////////////////  INITIALISATION

HandleEvent(BeginTurn)'CTC_NumofPlayers' pre {

int_t i;
int_t j;
int_t livePlayers;
city_t tmpCity;

    if (g.year==0){ //else done at endturn when SLIC reloaded

          SetPreference("AlienEndGame",0);// turn bloodlust on ?
     
		if (preference("MaxPlayers") < preference("NumPlayers")){
		    CTC_PLAYER_COUNT= preference("NumPlayers");
		}
		else{
		    CTC_PLAYER_COUNT= preference("MaxPlayers");
		} 
		for (i=0;i<CTC_PLAYER_COUNT ;i=i+1 ){
		    for (j=0;j<CTC_PLAYER_COUNT;j=j+1){
			    CTC_HOME_CIV[(i*CTC_PLAYER_COUNT )+j]=i; 
			    CTC_FOREIGN_CIV[(i*CTC_PLAYER_COUNT )+j]=j;
			    CTC_CLOSENESS[(i*CTC_PLAYER_COUNT )+j]=999999;//just a big number
			    CTC_LAUNCH_CITY[(i*CTC_PLAYER_COUNT )+j]=tmpCity; //the invalid one
			    CTC_TARGET_CITY[(i*CTC_PLAYER_COUNT )+j]=tmpCity;
			    CTC_GEOG_THREAT[(i*CTC_PLAYER_COUNT )+j]=999999;
		    }
		}
		DisableTrigger('CTC_Bombard_PillboxSpec');
    }
    livePlayers=0;
    for (i=0;i<CTC_PLAYER_COUNT ;i=i+1){
         if (IsPlayerAlive(i)){
	         livePlayers=livePlayers+1;
         }         
    }
    CTC_AI_FEAR_RADIUS=1 + preference("NumPlayers")-livePlayers; 

///////////////////   START OPTIONS 

	DisableTrigger('CTC_QuickStartSettle');
	DisableTrigger('CTC_QuickStartMove');

	DisableTrigger('CTC_PreSurrender');
	DisableTrigger('CTC_SurrenderTrigger');

	DisableTrigger('CTC_DestroyBuildsOnCapture');
	DisableTrigger('CTC_PlagueChance');
	DisableTrigger('CTC_EpidemicChance');

    // unit building system:
    

	// leader units:
	
	HAM_ON=0;
     DisableTrigger('CTC_Start_Hammurabi');
	DisableTrigger('CTC_HammurabiLives');
	DisableTrigger('CTC_HammurabiDies');

	DisableTrigger('CTC_Ramses');
	DisableTrigger('CTC_Start_Ramses');
	DisableTrigger('CTC_RamsesLives');
	DisableTrigger('CTC_RamsesDies');

	DisableTrigger('CTC_Cyrus');
	DisableTrigger('CTC_Start_Cyrus');
	DisableTrigger('CTC_CyrusLives');
	DisableTrigger('CTC_CyrusDies');

	DisableTrigger('CTC_AlexandertheGreat');
	DisableTrigger('CTC_Start_Alexander');
	DisableTrigger('CTC_AlexanderLives');
	DisableTrigger('CTC_AlexanderDies');

	DisableTrigger('CTC_Caesar');
	DisableTrigger('CTC_Start_Caesar');
	DisableTrigger('CTC_CaesarLives');
	DisableTrigger('CTC_CaesarDies');

//	DisableTrigger('Muhammad');

	DisableTrigger('CTC_Charlemagne');
	DisableTrigger('CTC_Start_Charlemagne');
	DisableTrigger('CTC_CharlemagneLives');
	DisableTrigger('CTC_CharlemagneDies');

//	DisableTrigger('HernanCortes');

	DisableTrigger('CTC_StonewallJackson');
     DisableTrigger('CTC_Start_StonewallJackson');
	DisableTrigger('CTC_StonewallJacksonLives');
	DisableTrigger('CTC_StonewallJacksonDies');

	DisableTrigger('CTC_DwightEisenhower');
	DisableTrigger('CTC_Start_DwightEisenhower');
	DisableTrigger('CTC_DwightEisenhowerLives');
	DisableTrigger('CTC_DwightEisenhowerDies');

	DisableTrigger('CTC_NormanSchwarzkopf');
	DisableTrigger('CTC_Start_NormanSchwarzkopf');
	DisableTrigger('CTC_NormanSchwarzkopfLives');
	DisableTrigger('CTC_NormanSchwarzkopfDies');

     DisableTrigger('CTC_Zhukov');
	DisableTrigger('CTC_Start_Zhukov');
	DisableTrigger('CTC_ZhukovLives');
	DisableTrigger('CTC_ZhukovDies');

     DisableTrigger('CTC_Rommel');
	DisableTrigger('CTC_Start_Rommel');
	DisableTrigger('CTC_RommelLives');
	DisableTrigger('CTC_RommelDies');

// misc

    DisableTrigger('CTC_MergecivCheck');
    DisableTrigger('CTC_MergecivExec');

    DisableTrigger('AutoUpdateUnit');
    DisableTrigger('CTC_BombardEffect');

    

    DisableTrigger('CTC_FireAfterEffect');
    DisableTrigger('CTC_MergeAfterCaptureCity'); // TBD

    // add DisableTrigger('AI_to_AI_Establish_Embassy');

    DisableTrigger('CTC_AI_to_AI_Two_Players');

    

    if (IsHumanplayer(player[0])){
         
         if (g.year == 0){
              message(player[0],'CTC_IntroductionA');
		    DisableTrigger('CTC_ReloadSlic');
         }
    }
    DisableTrigger('CTC_NumofPlayers');
}

HandleEvent(BeginTurn) 'CTC_ReloadSlic' pre {

    if (IsHumanplayer(player[0])){
         if (g.year > 0){            
	         message(player[0],'CTC_ReStartOptions');//just for DESTROY_BUILDINGS_PERCENT, etc
	         DisableTrigger('CTC_ReloadSlic');
	    }
    }
}

HandleEvent(BeginTurn) 'CTC_InitGeogThreatSystem' pre {

// on turn 0:

    DisableTrigger('CTC_ReinitializeAfterReloadingSLIC');
    DisableTrigger('CTC_ReInstateCheckGeogArraysOnCapture');
    
    DisableTrigger('CTC_AI_GeogThreatStates');
         DisableTrigger('CTC_MakeContact');
         DisableTrigger('CTC_MakeContactWithHuman');

    DisableTrigger('CTC_LoadDipStateCycles');
    DisableTrigger('CTC_CheckGeogArraysOnCapture');
    DisableTrigger('CTC_CheckGeogArraysOnCreate');
    DisableTrigger('CTC_CheckGeogArraysOnKill');
    DisableTrigger('CTC_CheckGeogArraysAfterSurrender');


    DisableTrigger('CTC_Pre_Trigger_AI_Tactics');// hence: 

	    DisableTrigger('CTC_Trigger_AI_Land_Tactics');
	    DisableTrigger('CTC_TacticsPrep');//make field army arrays 
	    DisableTrigger('CTC_AI_Land_Tactics');

    DisableTrigger('CTC_InitGeogThreatSystem');
}

// if someone reloads SLIC:

HandleEvent(EndTurn) 'CTC_ReinitializeAfterReloadingSLIC' pre {

    int_t i;
    int_t j;
    city_t tmpCity;
    int_t CitiesDoneFlg;
    int_t HasSteelFlg;
    int_t HasFlightFlg;
    int_t livePlayers;

    SetPreference("AlienEndGame",0);// turn bloodlust on

    DisableTrigger('CTC_CheckForCities');
    DisableTrigger('CTC_InitGeogThreatSystem');

    DisableTrigger('CTC_AI_GeogThreatStates');
         DisableTrigger('CTC_MakeContact');
	    DisableTrigger('CTC_MakeContactWithHuman');

    DisableTrigger('CTC_LoadDipStateCycles');
    DisableTrigger('CTC_CheckGeogArraysOnCapture');
    DisableTrigger('CTC_CheckGeogArraysOnCreate');
    DisableTrigger('CTC_CheckGeogArraysOnKill');
    DisableTrigger('CTC_CheckGeogArraysAfterSurrender');


    DisableTrigger('CTC_Pre_Trigger_AI_Tactics');// hence: 

	    DisableTrigger('CTC_Trigger_AI_Land_Tactics');
	    DisableTrigger('CTC_TacticsPrep');//make field army arrays 
	    DisableTrigger('CTC_AI_Land_Tactics');

    DisableTrigger('CTC_Bombard_PillboxSpec');

    DisableTrigger('StartBuildingAirBases');
    DisableTrigger('BuildNearbyAirBase');
    DisableTrigger('LookForAirBase');
    DisableTrigger('BuildNearbyAirBaseAfterSwap');
    DisableTrigger('SaveTheAirBases');
    DisableTrigger('TrackAirBases');
    DisableTrigger('DeleteAirBase');
    DisableTrigger('GroupAirUnits');
    
    DisableTrigger('SaveThePlanes');
    DisableTrigger('BackToLandingPlaceAfterBombarding'); 

    // unit building system:
    

    if (preference("MaxPlayers") < preference("NumPlayers")){
	    CTC_PLAYER_COUNT= preference("NumPlayers");
    }
    else{
	    CTC_PLAYER_COUNT= preference("MaxPlayers");
    }
    livePlayers=0;
    for (i=0;i<CTC_PLAYER_COUNT ;i=i+1){
         if (IsPlayerAlive(i)){
	         livePlayers=livePlayers+1;
         }         
    }
    CTC_AI_FEAR_RADIUS=1 + preference("NumPlayers")-livePlayers; 
    HasSteelFlg=0;
    for (i=0;i<CTC_PLAYER_COUNT;i=i+1 ){
         if (IsPlayerAlive(i)){
	         if (HasAdvance(i,ID_ADVANCE_STEEL)){
		         HasSteelFlg=1;
			    i=CTC_PLAYER_COUNT;
	         }
         }
    }
    if (HasSteelFlg){
         EnableTrigger('CTC_Bombard_PillboxSpec');
    }
    HasFlightFlg=0;
    for (i=0;i<CTC_PLAYER_COUNT;i=i+1 ){
         if (IsPlayerAlive(i)){
	         if (HasAdvance(i,ID_ADVANCE_FLIGHT)){
		         HasFlightFlg=1;	
			    i=CTC_PLAYER_COUNT;
	         }
         }
    }
    if (HasFlightFlg){

         EnableTrigger('StartBuildingAirBases');
         EnableTrigger('BuildNearbyAirBase');
         EnableTrigger('LookForAirBase');
	    EnableTrigger('BuildNearbyAirBaseAfterSwap');
         EnableTrigger('SaveTheAirBases');
         EnableTrigger('TrackAirBases');
         EnableTrigger('GroupAirUnits');
         
	    EnableTrigger('SaveThePlanes');
	    EnableTrigger('BackToLandingPlaceAfterBombarding');

	    DisableTrigger('InitAirSystem');
    }
    for (i=0;i<CTC_PLAYER_COUNT;i=i+1 ){
	    for (j=0;j<CTC_PLAYER_COUNT;j=j+1){
		    CTC_HOME_CIV[(i*CTC_PLAYER_COUNT )+j]=i; 
		    CTC_FOREIGN_CIV[(i*CTC_PLAYER_COUNT )+j]=j;
		    CTC_CLOSENESS[(i*CTC_PLAYER_COUNT )+j]=999999;//just a big number
		    CTC_LAUNCH_CITY[(i*CTC_PLAYER_COUNT )+j]=tmpCity; //the invalid one
		    CTC_TARGET_CITY[(i*CTC_PLAYER_COUNT )+j]=tmpCity;
		    CTC_GEOG_THREAT[(i*CTC_PLAYER_COUNT )+j]=999999;
	    }
    }
    
    CitiesDoneFlg=1;
    for (i=1; i< CTC_PLAYER_COUNT ; i=i+1){
    //make sure everyone in the game has cities
	    if (IsPlayerAlive(i)){
		    if (PlayerCityCount(i)==0) {
			    CitiesDoneFlg=0; // someone doesn't have any citys,
			    i=CTC_PLAYER_COUNT;
		    }
	    }
    }
    if(CitiesDoneFlg==1){ 
	    for (i=1;i<CTC_PLAYER_COUNT;i=i+1){ 
		    if (IsPlayerAlive(i)){ 
			    CTC_ComputeGeogThreats(i);
		    }
	    }
	    EnableTrigger('CTC_LoadDipStateCycles');
	    EnableTrigger('CTC_AI_GeogThreatStates');
	         EnableTrigger('CTC_MakeContact');
	    EnableTrigger('CTC_Pre_Trigger_AI_Tactics');

	    EnableTrigger('CTC_CheckGeogArraysOnCapture');
	    EnableTrigger('CTC_CheckGeogArraysOnCreate');
	    EnableTrigger('CTC_CheckGeogArraysOnKill');

	    DisableTrigger('CTC_InitGeogThreatSystem');
    }
    else{ //it starts back at checking for cities

         EnableTrigger('CTC_CheckForCities');  
    }
    DisableTrigger('CTC_ReinitializeAfterReloadingSLIC');
}


// Options:

alertbox 'CTC_IntroductionA' {
	Title(ID_WELCOME);
	Text(ID_START);
	Button(ID_INTRO) {
		Kill();
		Message(player[0], 'CTC_IntroductionB');
	}
	Button(ID_OPTIONS ){
	    Kill();
	    message(player[0],'CTC_StartOptions');
     }
}

messagebox 'CTC_IntroductionB' {
    show();
	Title(ID_WELCOME);
	Text(ID_START_B);
	Button(ID_INTRO) {
		Kill();
          LibraryConcept(80);
	}
     OnClose {
		Message(player[0], 'CTC_StartOptions');
	}
}

alertbox 'CTC_ReStartOptions' {
    Text(ID_ReStartOptionsM);
    // After reloading SLIC, you must reset some of your playing options.
    Button(ID_Proceed) {
         message(player[0],'CTC_SecondOption');
	    Kill(); 
	}
     Button(ID_NoOptions) {
	    Kill();  
	}
}

alertbox 'CTC_StartOptions' {
    DisableMessageClass(71002);

    Text(ID_StartOptionsM);
    // There are several playing options that you can include at this point. 
    // Do you want to review them?
    Button(ID_YES) {
         message(player[0],'CTC_FirstOption');
	    Kill(); 
	}
     Button(ID_NoOptions) {
	    Kill();  
	}
}

messagebox 'CTC_FirstOption' {
    show();
    Title(ID_QuickStart);
    Text(ID_FirstOptionM);
    // Do you want to include the QuickStart option?
    // \n\n It will allow you (and each AI player) to start with 2 warriors and 4 or 5 settlers (depends on difficulty setting)?
    Button(ID_YES) {
         EnableTrigger('CTC_QuickStartSettle');
	    EnableTrigger('CTC_QuickStartMove');
         Kill(); 
	    message(player[0],'CTC_SecondOption');   
	}
     Button(ID_NO) {
	    Kill(); 
	    message(player[0],'CTC_SecondOption');   
	}
}

messagebox 'CTC_SecondOption' {
    show();
    Title(ID_Surrender);
    Text(ID_SecondOptionM);
    // Do you want to include the Surrender option? 
    // \n\n An AI player will surrender rather than fighting down to it's last defender in it's last city.
    Button(ID_YES) {
         EnableTrigger('CTC_PreSurrender');
	    EnableTrigger('CTC_SurrenderTrigger');
         Kill(); 
	    message(player[0],'CTC_SecondOptionA');   
	}
     Button(ID_NO) {
	    Kill(); 
	    message(player[0],'CTC_ThirdOption');   
	}
}

messagebox 'CTC_SecondOptionA' {
    show();
    Text(ID_SecondOptionAM);
    // The default conditions are that the AI player will surrender when you have 3 times as many military units AND cities as they have.
    // \n\n You can either use the default conditions or define your own
    Button(ID_Default){
          CITY_SURRENDER_RATIO=3;
          UNIT_SURRENDER_RATIO=3;
          Kill(); 
	     message(player[0],'CTC_ThirdOption'); 
    }
    Button(ID_MyOwn){
         Kill(); 
	    message(player[0],'CTC_SecondOptionB');
    }
}

messagebox 'CTC_SecondOptionB' {
    show();
    Text(ID_SecondOptionBM);
    // First chose the ratio of your cities to their cities that will force them to surrender: 
    Button(ID_TWO) {
	    CITY_SURRENDER_RATIO=2;
         Kill(); 
	    message(player[0],'CTC_SecondOptionC');   
	}
	Button(ID_THREE) {
	    CITY_SURRENDER_RATIO=3;
         Kill(); 
	    message(player[0],'CTC_SecondOptionC');  
	}
     Button(ID_FOUR) {
	    CITY_SURRENDER_RATIO=4;
         Kill(); 
	    message(player[0],'CTC_SecondOptionC');    
	}
	Button(ID_FIVE) {
	    CITY_SURRENDER_RATIO=5;
         Kill(); 
	    message(player[0],'CTC_SecondOptionC');   
	}
}

messagebox 'CTC_SecondOptionC' {
    show();
    Text(ID_SecondOptionCM);
    // Now chose the ratio of your military units to their military units that you must also attain in order to force them to surrender: 
    Button(ID_TWO) {
	    UNIT_SURRENDER_RATIO=2;
         Kill(); 
	    message(player[0],'CTC_ThirdOption');   
	}
	Button(ID_THREE) {
	    UNIT_SURRENDER_RATIO=3;
         Kill(); 
	    message(player[0],'CTC_ThirdOption');  
	}
     Button(ID_FOUR) {
	    UNIT_SURRENDER_RATIO=4;
         Kill(); 
	    message(player[0],'CTC_ThirdOption');    
	}
	Button(ID_FIVE) {
	    UNIT_SURRENDER_RATIO=5;
         Kill(); 
	    message(player[0],'CTC_ThirdOption');   
	}
}

messagebox 'CTC_ThirdOption' {
    show();
    Title(ID_DestroyOnCapture);
    Text(ID_ThirdOptionM);
    // Whenever a city is captured, a percentage of it's buildings will be destroyed. 
    //\n\n You can choose from the following percentages: 
    Button(ID_ZERO) {
         Kill(); 
	    message(player[0],'CTC_FourthOption');   
	}
	Button(ID_TEN) {
	    DESTROY_BUILDINGS_PERCENT=10;
         EnableTrigger('CTC_DestroyBuildsOnCapture');
         Kill(); 
	    message(player[0],'CTC_FourthOption');   
	}
	Button(ID_TWENTYFIVE) {
	    DESTROY_BUILDINGS_PERCENT=25;
         EnableTrigger('CTC_DestroyBuildsOnCapture');
         Kill(); 
	    message(player[0],'CTC_FourthOption');   
	}
     Button(ID_FIFTY) {
	    DESTROY_BUILDINGS_PERCENT=50;
	    EnableTrigger('CTC_DestroyBuildsOnCapture');
	    Kill(); 
	    message(player[0],'CTC_FourthOption');   
	}
}

messagebox 'CTC_FourthOption' {
    show();
    Title(ID_PlaguesandEpidemics);
    Text(ID_FourthOptionM);
    // Do you want to include the Plague/epidemic option? 
    // \n\n It will randomly generate plagues unless your cities have medical and hygenic countermeasures.
    Button(ID_HIGHF) {
         PLAGUE_FREQ=15;
	    if (HasAdvance(player[0],ID_ADVANCE_RAILROAD)){
              EnableTrigger('CTC_EpidemicChance');
	    }
	    else{
              EnableTrigger('CTC_PlagueChance');
	    }  
         Kill(); 
	    message(player[0],'CTC_FifthOption');   
	}
	Button(ID_MEDIUMF) {
         PLAGUE_FREQ=10;
	    if (HasAdvance(player[0],ID_ADVANCE_RAILROAD)){
              EnableTrigger('CTC_EpidemicChance');
	    }
	    else{
              EnableTrigger('CTC_PlagueChance');
	    }
         Kill(); 
	    message(player[0],'CTC_FifthOption');   
	}
	Button(ID_LOWF) {
         PLAGUE_FREQ=5;
	    if (HasAdvance(player[0],ID_ADVANCE_RAILROAD)){
              EnableTrigger('CTC_EpidemicChance');
	    }
	    else{
              EnableTrigger('CTC_PlagueChance');
	    }
         Kill(); 
	    message(player[0],'CTC_FifthOption');   
	}
     Button(ID_DontInclude) {
	    Kill(); 
	    message(player[0],'CTC_FifthOption');   
	}
}

messagebox 'CTC_FifthOption' {
    show();
    Title(ID_GreatLeaders);
    Text(ID_FifthOptionM);

    Button(ID_YES) {

              HAM_ON=1;
		    EnableTrigger('CTC_Ramses');
		    EnableTrigger('CTC_Cyrus');
		    EnableTrigger('CTC_AlexandertheGreat');
		    EnableTrigger('CTC_Caesar');
//		    EnableTrigger('Muhammad');
		    EnableTrigger('CTC_Charlemagne');
//		    EnableTrigger('HernanCortes');
		    EnableTrigger('CTC_StonewallJackson');
		    EnableTrigger('CTC_DwightEisenhower');
		    EnableTrigger('CTC_NormanSchwarzkopf');
		    EnableTrigger('CTC_Zhukov');
		    EnableTrigger('CTC_Rommel');
        
         if (g.year > 0){//for reloadslic
              HAM_ON=1;
	         EnableTrigger('CTC_Start_Hammurabi'); 
	         EnableTrigger('CTC_Start_Ramses');
	         EnableTrigger('CTC_Start_Cyrus');
	         EnableTrigger('CTC_Start_Alexander');
	         EnableTrigger('CTC_Start_Caesar');
//	         EnableTrigger('Restart_Muhammad');       <= TBD, doesn't exist
	         EnableTrigger('CTC_Start_Charlemagne');
//		    EnableTrigger('Restart_HernanCortes');   <= TBD, doesn't exist
		    EnableTrigger('CTC_Start_StonewallJackson');
		    EnableTrigger('CTC_Start_DwightEisenhower');
		    EnableTrigger('CTC_Start_NormanSchwarzkopf');
		    EnableTrigger('CTC_Start_Zhukov');
		    EnableTrigger('CTC_Start_Rommel');
         }

         Kill(); 
	    message(player[0],'CTC_SixthOption');   
	}
     Button(ID_NO) {
	    Kill(); 
	    message(player[0],'CTC_SixthOption');   
	}
}

messagebox 'CTC_SixthOption' {
    show();
    Title(ID_CollateralDamage);
    Text(ID_SixthOptionM);

    Button(ID_HIGHF) {

         PILLAGE_PERCENT=9;
         Kill(); 
	    message(player[0],'CTC_SeventhOption');  
	}
	Button(ID_MEDIUMF) {
	    PILLAGE_PERCENT=6;
         Kill(); 
	    message(player[0],'CTC_SeventhOption');   
	}
	Button(ID_LOWF) {
	    PILLAGE_PERCENT=3;
         Kill(); 
	    message(player[0],'CTC_SeventhOption');   
	}
     Button(ID_DontInclude) {
	    PILLAGE_PERCENT=0;
	    Kill(); 
	    message(player[0],'CTC_SeventhOption');   
	}
}

messagebox 'CTC_SeventhOption' {
    show();
    Title(ID_AutoPilot);
    Text(ID_SeventhOptionM);

    Button(ID_YES) {
	    CTC_AUTOPILOT=1;
	    Kill(); 
	    message(player[0],'CTC_EndOptions');   
	}

    Button(ID_NO) {
	    Kill(); 
	    message(player[0],'CTC_EndOptions');   
	}
}

messagebox 'CTC_EndOptions' {
    show();
    Text(ID_EndOptionsM);
    // That's all for now. Have fun!
    Button(ID_STARTGAME){
         Kill();
    }
}


////////////////////////////////
//
// ENABLED/DISABLED HANDLERS
//
////////////////////////////////

HandleEvent(MoveUnits)'CTC_QuickStartMove' pre { //Run Quickstart Once at Game Start
int_t i;
int_t j;
int_t numSettlers;
unit_t tmpUnit;

     if (g.year==0) { 
	    for(j=1; j < CTC_PLAYER_COUNT; j=j+1){
              if (IsPlayerAlive(j)){
			    GetUnitByIndex(j,0,tmpUnit);
			    if (GetUnitsAtLocation(tmpUnit.location)==1){
			         numSettlers=4; 
			    }
			    else{
                        numSettlers=3;
			    }
			    for(i=0; i<numSettlers; i=i+1){ 
				 CreateUnit(j, UnitDB(UNIT_SETTLER), tmpUnit.location, 0);
			    }
			    CreateUnit(j, UnitDB(UNIT_WARRIOR), tmpUnit.location, 0);
			    CreateUnit(j, UnitDB(UNIT_WARRIOR), tmpUnit.location, 0);

			    GrantAdvance(j,AdvanceDB(ADVANCE_STONE_WORKING));
			    GrantAdvance(j,AdvanceDB(ADVANCE_TOOLMAKING));
			    GrantAdvance(j,AdvanceDB(ADVANCE_WRITING));
			    GrantAdvance(j,AdvanceDB(ADVANCE_AGRICULTURE));
			    GrantAdvance(j,AdvanceDB(ADVANCE_SLAVE_LABOR));
			    GrantAdvance(j,AdvanceDB(ADVANCE_RELIGION));
		    }
	    }
    }
    DisableTrigger('CTC_QuickStartSettle');
    DisableTrigger('CTC_QuickStartMove');
}

HandleEvent(SettleOrder)'CTC_QuickStartSettle' post { //Run Quickstart Once at Game Start
int_t i;
int_t j;
int_t num_players;
int_t numSettlers;
unit_t tmpUnit;

     if (g.year==0) { 
	    for(j=1; j < CTC_PLAYER_COUNT; j=j+1){
              if (IsPlayerAlive(j)){
			    GetUnitByIndex(j,0,tmpUnit);
			    if (GetUnitsAtLocation(tmpUnit.location)==1){
			         numSettlers=5; 
			    }
			    else{
                        numSettlers=4;
			    }
			    for(i=0; i<numSettlers; i=i+1){ 
				 CreateUnit(j, UnitDB(UNIT_SETTLER), tmpUnit.location, 0);
			    }
			    CreateUnit(j, UnitDB(UNIT_WARRIOR), tmpUnit.location, 0);
			    CreateUnit(j, UnitDB(UNIT_WARRIOR), tmpUnit.location, 0);

			    GrantAdvance(j,AdvanceDB(ADVANCE_STONE_WORKING));
			    GrantAdvance(j,AdvanceDB(ADVANCE_TOOLMAKING));
			    GrantAdvance(j,AdvanceDB(ADVANCE_WRITING));
			    GrantAdvance(j,AdvanceDB(ADVANCE_AGRICULTURE));
			    GrantAdvance(j,AdvanceDB(ADVANCE_SLAVE_LABOR));
			    GrantAdvance(j,AdvanceDB(ADVANCE_RELIGION));
		    }
	    }
    }
    DisableTrigger('CTC_QuickStartSettle');
    DisableTrigger('CTC_QuickStartMove');
}


////////////////////////////////////////////////////////////////////////////
//
// Destroy buildings script to allow for destruction of buildings due to conquest.
//
// By Dale
//
// Version 1.1 5-May-2001
//
////////////////////////////////////////////////////////////////////////////

///////////////////////////////////
// Capture City event
///////////////////////////////////

HandleEvent(CaptureCity) 'CTC_DestroyBuildsOnCapture' pre {
	city_t tmpcity;
	int_t i;
	
    tmpcity = city[0];
    if(CityIsValid(tmpcity)) {
	    for(i = 0; i < 50; i = i + 1) { 
		    if(random(100) < DESTROY_BUILDINGS_PERCENT) {
			    DestroyBuilding(tmpcity, i);
		    }
	    }
    }
}

///////////////////////////////////
// Nuke City event (included as default)
///////////////////////////////////

HandleEvent(NukeCity) 'CTC_DestroyBuildsOnNuke' pre {
	city_t tmpcity;
	int_t i;
	int_t randnum;

	tmpcity = city[0];
	if(CityIsValid(tmpcity)) {
		for(i = 0; i < 50; i = i + 1) {
			randnum = random(100);
			if(randnum < 50) {
				DestroyBuilding(tmpcity, i);
			}
		}
	}
}

	    //-------------------------------------
        //--------------------------------------
       //
      //  Plague disaster coding for CTP2
     //       by the Immortal Wombat
    //         originally written for Cradle
   //          modified and adapted for CTC by Peter Triggs
  //
 //--------------------------------------------
//---------------------------------------------

// Global variables for use in messages

int_t	PLAGUED_CITY_COUNTER; //how many cities were plagued
int_t     DEATH_COUNT; //total deaths

    /////////////////////////////////
   //
  //   Plague / Epidemic Function
 //
///////////////////////////////////


void_f	CTC_Plague (int_t thePlayer){
    int_t	tmpPlayer;
    int_t	CityCount;
    int_t properCityCount; //city pop>3
    int_t	i;
    int_t	tmpDead;
    int_t	PPChance;
    int_t	j;  
    int_t hospitalCount;
    int_t drugstoreCount;
    int_t foodsiloCount;
    int_t aqueductCount;
    city_t PlaguedCity;
    city_t tmpCity;

    tmpPlayer = thePlayer;		    
    CityCount = PlayerCityCount(tmpPlayer);
    PLAGUED_CITY_COUNTER = 0;
    DEATH_COUNT=0;
    aqueductCount=0;
    properCityCount=0;

// what about AI?:

    if (IsHumanPlayer(tmpPlayer)){//ancient plagues

	    for(i = 0; i < CityCount; i = i + 1){		    		    
		    GetCityByIndex(tmpPlayer, i, PlaguedCity);
		    if (PlaguedCity.population>3){
			    properCityCount=properCityCount+1;
			    if(CityHasBuilding(PlaguedCity, "IMPROVE_AQUEDUCT")){
				    aqueductCount=aqueductCount+1;
			    }
		    }
	    }
	    if(properCityCount){
		    if ((aqueductCount*100)/properCityCount< 85){//must have 85% aqueducts in proper Cities to prevent plagues
			    for(i = 0; i < CityCount; i = i + 1){		    		    
				    GetCityByIndex(tmpPlayer, i, PlaguedCity);
				    if(PlaguedCity.population > 3){
						//
						// Buildings that reduce plague chance are:
						// aqueduct 
						//
						//  Start = 100% chance of plague in PlaguedCity
					    PPChance = 100;
						//  + aqueduct --> 40/60 chance
						//
					    if(CityHasBuilding(PlaguedCity, "IMPROVE_AQUEDUCT")){
						    PPChance = PPChance - 60;
					    }
					    if(random(100) <= PPChance){
						    Event:AddHappyTimer(PlaguedCity, 3, -2, 14);	// 3 turns of -2 happiness
						    PLAGUED_CITY_COUNTER = PLAGUED_CITY_COUNTER + 1;
						    if (random(100) <= PPChance/2){//serious plague, people die
							    city[0] = PlaguedCity;				
							    tmpDead = city[0].population/8;  //from 5
							    DEATH_COUNT=DEATH_COUNT+tmpDead;
							    for(j = 0; j < tmpDead; j = j + 1){
								    Event:KillPop(PlaguedCity);
							    }
						    }
					    }
				    }
			    }
	    }
	    // cities and deaths done, now messages
	    else{// no more plagues
		    message(tmpPlayer,'CTC_ForesightPreventedPlague');
		    for (j=0;j<CityCount;j=j+1){
			    GetCityByIndex(tmpPlayer,j,tmpCity);
			    Event:AddHappyTimer(tmpCity,3,1,14);//3 turns of +1 happiness	         
		    }
         }			   		    	  
	    if(PLAGUED_CITY_COUNTER){
		    if (DEATH_COUNT){
			    DEATH_COUNT=DEATH_COUNT*10;
			    if(HasAdvance(tmpPlayer, ID_ADVANCE_MASONRY)){
				    message(tmpPlayer,'CTC_NeedMoreAqueducts');			        
			    }
			    else{
				    message(tmpPlayer,'CTC_NeedMoreResearch');
			    }
		    }
		    else{
			    if(HasAdvance(tmpPlayer, ID_ADVANCE_MASONRY)){
				    message(tmpPlayer,'CTC_NeedMoreAqueducts1');			        
			    }
			    else{
				    message(tmpPlayer,'CTC_NeedCleanWater');
			    }
		    }
	    }
	    else{// ?? lucky escape
		    
	    }
    }
}

void_f	CTC_Epidemic (int_t thePlayer){
    int_t	tmpPlayer;
    int_t	CityCount;
    int_t properCityCount; //city pop>20 ?
    int_t	i;
    int_t	tmpDead;
    int_t	PPChance;
    int_t	j;  
    int_t hospitalCount;
    int_t drugstoreCount;
    int_t foodsiloCount;
    int_t successFlg;

    city_t PlaguedCity;
    city_t tmpCity;

    tmpPlayer = thePlayer;
    CityCount = PlayerCityCount(tmpPlayer);
    PLAGUED_CITY_COUNTER = 0;
    DEATH_COUNT=0;
   
    hospitalCount=0;
    drugstoreCount=0;
    foodsiloCount=0;
    properCityCount=0;
    successFlg=0;

// what about AI?:

    if (IsHumanPlayer(tmpPlayer)){

	    if (HasAdvance(tmpPlayer, ID_ADVANCE_RAILROAD) ){//modern epidemics
		    for(i = 0; i < CityCount; i = i + 1){		    		    
			    GetCityByIndex(tmpPlayer, i, PlaguedCity);
			    if(PlaguedCity.population >= 20){// only proper cities suffer
				    //
				    // Building that reduce epidemic chance are:
				    // food silo, drug store, hospital 
				    //
				    //  Start = 100% chance of epidemic in PlaguedCity
				    PPChance = 100;
				    //  + food silo --> 50/50 chance
				    //  + hospital  --> 25/75 chance
				    //  + drug store --> 0/100 chance
				    //
				    if(CityHasBuilding(PlaguedCity, "IMPROVE_FOOD_SILO")){
					    foodsiloCount=foodsiloCount+1;
					    PPChance = PPChance - 50;
				    }
				    if(CityHasBuilding(PlaguedCity, "IMPROVE_HOSPITAL")){
					    hospitalCount=hospitalCount+1;
					    PPChance = PPChance - 25;
				    }
				    if(CityHasBuilding(PlaguedCity, "IMPROVE_DRUG_STORE")){
					    drugstoreCount=drugstoreCount+1;
					    PPChance = PPChance - 25;
				    }  
				    if(random(99)<=PPChance-1){
					    city[0] = PlaguedCity;				
					    tmpDead = city[0].population/20;//from 5 
					    DEATH_COUNT=DEATH_COUNT+tmpDead;
					    for(j = 0; j < tmpDead; j = j + 1){
						    Event:KillPop(PlaguedCity);
					    }
					    Event:AddHappyTimer(PlaguedCity, 3, -3, 14);	// 3 turns of -3 happiness
					    PLAGUED_CITY_COUNTER = PLAGUED_CITY_COUNTER + 1;
				    }
			    }
			}
			// cities and deaths done, now messages
			if(HasAdvance(tmpPlayer, ID_ADVANCE_PHARMACEUTICALS)){
			    if (drugstoreCount==CityCount){ // total success
				    message(tmpPlayer,'CTC_NoMoreEpidemics');
				    for (j=0;j<CityCount;j=j+1){
					    GetCityByIndex(tmpPlayer,j,tmpCity);
					    Event:AddHappyTimer(tmpCity,3,2,14);//3 turns of +2 happiness	         
				    }
			    }
              }
		    if(PLAGUED_CITY_COUNTER){
			    if (DEATH_COUNT){
				    DEATH_COUNT=DEATH_COUNT*10;
				    if(HasAdvance(tmpPlayer, ID_ADVANCE_PHARMACEUTICALS)){   
					    message(tmpPlayer,'CTC_NeedMoreDrugstores'); 
				    }
				    elseif(HasAdvance(tmpPlayer, ID_ADVANCE_MEDICINE)){
                             if (hospitalCount<CityCount){
					         message(tmpPlayer,'CTC_NeedMoreHospitals');
					    }
					    
					    else{
						    message(tmpPlayer,'CTC_NeedMoreResearch1'); 
					    }                          
				    }
				    elseif(HasAdvance(tmpPlayer, ID_ADVANCE_RAILROAD)){
					    if (foodsiloCount<CityCount){
						    message(tmpPlayer,'CTC_NeedMoreFoodSilos');
					    }
					    else{
						    message(tmpPlayer,'CTC_NeedMoreResearch2');  
					    }    
				    }
			    }
			    else{

//no deaths, lucky escape
				   
			    }
		    }
		    else{// epidemic successfully contained (nobody died or unhappy): encouraging messages
			    				    
			    if (HasAdvance(tmpPlayer, ID_ADVANCE_PHARMACEUTICALS)) {
				    SetString(0,ID_Drugstores);
				    successFlg=1;
			    }
			    elseif (HasAdvance(tmpPlayer, ID_ADVANCE_MEDICINE)){ //but less than total hospital coverage
				    SetString(0,ID_Hospitals);
				    successFlg=1;
			    }
			    elseif (HasAdvance(tmpPlayer, ID_ADVANCE_RAILROAD)) {
				    SetString(0,ID_FoodSilos);
				    successFlg=1;
			    }
			    if (successFlg==1){
                        message(tmpPlayer,'CTC_ForesightPreventedEpidemic');
				    for (j=0;j<CityCount;j=j+1){
					    GetCityByIndex(tmpPlayer,j,tmpCity);
					    Event:AddHappyTimer(tmpCity,3,2,14);//3 turns of +2 happiness	         
				    }
			    }
		    }
	    }
    }
}

HandleEvent(BeginTurn) 'CTC_PlagueChance' post {

int_t	PlagueChance;
int_t     i;
int_t     endplaguesFlg;

   
	endplaguesFlg=0;
	if(g.year >= 3 && IsHumanPlayer(player[0].owner)){
		PlagueChance = random(100);	
		if(PlagueChance <PLAGUE_FREQ){			
		    CTC_Plague(player[0].owner);		
		}
		for (i=0;i<CTC_PLAYER_COUNT;i=i+1){// end ancient plagues when all human players have Feudalism
		    if (IsPlayerAlive(i)){
		         if (IsHumanPlayer(i)){
			         if (!HasAdvance(i,ID_ADVANCE_FEUDALISM)){
				         endplaguesFlg=1;
			         } 
		         }
		    }
		}
		if (endplaguesFlg==0){
		    DisableTrigger('CTC_PlagueChance');
		    EnableTrigger('CTC_EpidemicChance');
		}
	}	
}

HandleEvent(BeginTurn) 'CTC_EpidemicChance' post {

int_t	PlagueChance;
int_t	tmpPlayer;

	tmpPlayer = player[0];
	PlagueChance = random(100);
	if (IsHumanPlayer(tmpPlayer) && HasAdvance(tmpPlayer, ID_ADVANCE_RAILROAD)){
	//modern epidemics
	    if(PlagueChance <PLAGUE_FREQ+5){		
		    CTC_Epidemic(tmpPlayer);
	    }
	}	
}


messagebox 'CTC_NoMoreEpidemics' {
    MessageClass(41102);
    show();
    Title(ID_EPIDEMIC);
    Text (ID_NoMoreEpidemicsM );
    Button(ID_BUTTON_DONT_SHOW_AGAIN){
         DisableMessageClass(41102);
	    Kill();
    }
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

messagebox 'CTC_NeedMoreHospitals' {
    show();
    Title(ID_EPIDEMIC);
    Text (ID_NeedMoreHospitalsM);
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

messagebox 'CTC_NeedMoreDrugstores' {
    show();
    Title(ID_EPIDEMIC);
    Text (ID_NeedMoreDrugstoresM);
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

messagebox 'CTC_NeedMoreResearch1' {
    show();
    Title(ID_EPIDEMIC);
    Text (ID_NeedMoreResearch1M) ;
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

messagebox 'CTC_NeedMoreResearch2' {
    show();
    Title(ID_EPIDEMIC);
    Text (ID_NeedMoreResearch2M) ;
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

messagebox 'CTC_NeedMoreFoodSilos' {
    show();
    Title(ID_EPIDEMIC);
    Text (ID_NeedMoreFoodSilosM);
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

messagebox 'CTC_ContinuePolicy' {
    show();
    Title(ID_EPIDEMIC);
    Text (ID_ContinuePolicyM) ;
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

messagebox 'CTC_ForesightPreventedEpidemic' {
    MessageClass(21102);
    show();
    Title(ID_EPIDEMIC);
    Text (ID_ForesightPreventedEpidemicM);
    Button(ID_BUTTON_DONT_SHOW_AGAIN){
         DisableMessageClass(21102);
	    Kill();
    }
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

messagebox 'CTC_NeedMoreAqueducts' {
    show();
    Title(ID_PLAGUE);
    Text (ID_NeedMoreAqueductsM) ;
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

messagebox 'CTC_NeedMoreResearch' {
    show();
    Title(ID_PLAGUE);
    Text (ID_NeedMoreResearchM) ;
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

messagebox 'CTC_NeedMoreAqueducts1' {
    show();
    Title(ID_PLAGUE);
    Text (ID_NeedMoreAqueducts1M) ;
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

messagebox 'CTC_NeedCleanWater' {
    show();
    Title(ID_PLAGUE);
    Text (ID_NeedCleanWaterM) ;
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

messagebox 'CTC_ForesightPreventedPlague' {
    MessageClass(31102);
    show();
    Title(ID_PLAGUE);
    Text (ID_ForesightPreventedPlagueM) ;
    Button(ID_BUTTON_DONT_SHOW_AGAIN){
         DisableMessageClass(31102);
	    Kill();
    }
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}


  /////////////////////////////////////////////////////
 //  Wonder-Units - SLIC by The Immortal Wombat :D  //
/////////////////////////////////////////////////////
// fixed by Wouter Snijders (aka Locutus)	2001-5-7
// originally written for Cradle, adapted for CTC by PT


    //------------------------------------------------------------------//
   // Alexander's veteran effect (stolen from the Alex scenario)       //
  // Makes units on the same square as a Wonder Unit                  //
 // Veteran                                                          //
//------------------------------------------------------------------//

void_f CTC_VeteranEffect (location_t theLoc){
int_t	i;
unit_t	tmpUnit;
int_t	tmpNum;
location_t tmpLoc;
	
    tmpLoc=theLoc;
    // Make all Units veterans who share the location with a Great Leader
    tmpNum = GetUnitsAtLocation(tmpLoc);
    for (i = 0; i < tmpNum; i = i + 1) {
	    GetUnitFromCell(tmpLoc, i, tmpUnit);
	    ToggleVeteran(tmpUnit, 1);
    }
}

// Hammurabi: now comes with Recapture City feat

HandleEvent(BeginTurnUnit) 'CTC_Start_Hammurabi' pre {

    if (Unit[0].type == UnitDB(UNIT_HAMMURABI)){//if HAMMURABI exists
		HammurabiCount=50;
		EnableTrigger('CTC_HammurabiLives');
		EnableTrigger('CTC_HammurabiDies');
		DisableTrigger('CTC_Start_Hammurabi'); 
    } 
}

HandleEvent(BeginTurnUnit) 'CTC_HammurabiLives' post {

    int_t	j;
    int_t  tmpPlayer;
    int_t  numCities;
    city_t tmpCity;

    if(Unit[0].type == UnitDB(UNIT_HAMMURABI) ) {
	    CTC_VeteranEffect(Unit[0].location);
	    HammurabiCount=HammurabiCount-1;
	    if (HammurabiCount<=0){//dies of old age
              tmpPlayer=Unit[0].owner;
		    numCities=PlayerCityCount(tmpPlayer);
		    for(j = 0; j < numCities; j = j + 1) {
			    GetCityByIndex(tmpPlayer, j, tmpCity);
			    Event:AddHappyTimer(tmpCity, 3, -1, 12);
		    }
		    SetString(0,ID_UNIT_HAMMURABI);
              message(tmpPlayer,'CTC_LeaderDeadOfOldAge');
		    event:DisbandUnit(unit[0]);
              DisableTrigger('CTC_HammurabiLives');
              DisableTrigger('CTC_HammurabiDies'); 
	    }
    }
}

HandleEvent(KillUnit) 'CTC_HammurabiDies' pre {

    int_t	j;
    int_t  tmpPlayer;
    city_t tmpCity;

    if (Unit[0].type == UnitDB(UNIT_HAMMURABI)){
         tmpPlayer=Unit[0].owner;
	    SetString(0,ID_UNIT_HAMMURABI);
	    message(tmpPlayer,'CTC_LeaderKilled');
         DisableTrigger('CTC_HammurabiLives');
	    DisableTrigger('CTC_HammurabiDies');
	    for(j = 0; j < PlayerCityCount(tmpPlayer); j = j + 1) {
		    GetCityByIndex(tmpPlayer, j, tmpCity);
		    Event:AddHappyTimer(tmpCity, 3, -2, 12);
	    }
    }
}

// Ramses

HandleEvent(CreateWonder) 'CTC_Ramses' post {

	if(value[0] == WonderDB(WONDER_PYRAMIDS)) {
	    if (GetUnitsAtLocation(city[0].location)<12){
	         CreateUnit(city[0].owner, UnitDB(UNIT_RAMSES), city[0].location, 0);
         }
         else{
	         CreateUnit(city[0].owner, UnitDB(UNIT_RAMSES), city[0].location, 1);
         }
		EnableTrigger('CTC_Start_Ramses');
		DisableTrigger('CTC_Ramses');
	}
}

HandleEvent(BeginTurnUnit) 'CTC_Start_Ramses' pre {

    if(Unit[0].type == UnitDB(UNIT_RAMSES)) {
	    RamsesCount=50;
	    EnableTrigger('CTC_RamsesLives');
	    EnableTrigger('CTC_RamsesDies');
	    DisableTrigger('CTC_Start_Ramses'); 
    }  
}

HandleEvent(BeginTurnUnit) 'CTC_RamsesLives' post {

    int_t	j;
    int_t  tmpPlayer;
    int_t  numCities;
    city_t tmpCity;
	
    if(Unit[0].type == UnitDB(UNIT_RAMSES)) {
	    CTC_VeteranEffect(Unit[0].location);
	    RamsesCount=RamsesCount-1;
	    if (RamsesCount<=0){//dies of old age
	         tmpPlayer=Unit[0].owner;
		    numCities=PlayerCityCount(tmpPlayer);
		    for(j = 0; j < numCities; j = j + 1) {
			    GetCityByIndex(tmpPlayer, j, tmpCity);
			    Event:AddHappyTimer(tmpCity, 3, -1, 12);
		    }
		    SetString(0,ID_UNIT_RAMSES);
              message(tmpPlayer,'CTC_LeaderDeadOfOldAge');
		    event:DisbandUnit(unit[0]);
              DisableTrigger('CTC_RamsesLives');
              DisableTrigger('CTC_RamsesDies');
	    }
    }
}

HandleEvent(KillUnit) 'CTC_RamsesDies' pre {

    int_t	j;
    int_t  tmpPlayer;
    city_t tmpCity;

    if (Unit[0].type == UnitDB(UNIT_RAMSES)){
         tmpPlayer=Unit[0].owner;
	    SetString(0,ID_UNIT_RAMSES);
	    message(tmpPlayer,'CTC_LeaderKilled');
         DisableTrigger('CTC_RamsesLives');
	    DisableTrigger('CTC_RamsesDies');
	    for(j = 0; j < PlayerCityCount(tmpPlayer); j = j + 1) {
		    GetCityByIndex(tmpPlayer, j, tmpCity);
		    Event:AddHappyTimer(tmpCity, 3, -2, 12);
	    }
    }
}

// Cyrus 

HandleEvent(VictoryMoveOrder) 'CTC_Cyrus' post {

	if(HasAdvance(Army[0].owner,ID_ADVANCE_HORSE_RIDING) && army[0].size>8 ) {
	    if (TerrainType(location[0])<10 || (TerrainType(location[0])>17 && TerrainType(location[0])<22) ){//not at sea  
		    CyrusLoc=location[0].location;
		    event:AccomplishFeat(featDB(FEAT_GOT_CYRUS), army[0].owner); 
		    DisableTrigger('CTC_Cyrus');
	    }
	}
}

HandleEvent(BeginTurnUnit) 'CTC_Start_Cyrus' pre {

    if(Unit[0].type == UnitDB(UNIT_CYRUS)) {
	    CyrusCount=50;
	    EnableTrigger('CTC_CyrusLives');
	    EnableTrigger('CTC_CyrusDies');
         DisableTrigger('CTC_Start_Cyrus'); 
    } 
}

HandleEvent(BeginTurnUnit) 'CTC_CyrusLives' post {

    int_t	j;
    int_t  numCities;
    int_t tmpPlayer;
    city_t tmpCity;
	
    if(Unit[0].type == UnitDB(UNIT_CYRUS)) {
	    CTC_VeteranEffect(Unit[0].location);
	    CyrusCount=CyrusCount-1;
	    if (CyrusCount<=0){//dies of old age
              tmpPlayer=Unit[0].owner;
		    SetString(0,ID_UNIT_CYRUS);
              message(tmpPlayer,'CTC_LeaderDeadOfOldAge');
		    for(j = 0; j < PlayerCityCount(tmpPlayer); j = j + 1) {
			    GetCityByIndex(tmpPlayer, j, tmpCity);
			    Event:AddHappyTimer(tmpCity, 3, -1, 12);
		    }
		    event:DisbandUnit(unit[0]);
              DisableTrigger('CTC_CyrusLives');
              DisableTrigger('CTC_CyrusDies');      
		}
	}
}

HandleEvent(KillUnit) 'CTC_CyrusDies' pre {

    int_t	j;
    int_t  tmpPlayer;
    city_t tmpCity;

    if (Unit[0].type == UnitDB(UNIT_CYRUS)){
         tmpPlayer=Unit[0].owner;
	    SetString(0,ID_UNIT_CYRUS);
	    message(tmpPlayer,'CTC_LeaderKilled');
         DisableTrigger('CTC_CyrusLives');
	    DisableTrigger('CTC_CyrusDies');
	    for(j = 0; j < PlayerCityCount(tmpPlayer); j = j + 1) {
		    GetCityByIndex(tmpPlayer, j, tmpCity);
		    Event:AddHappyTimer(tmpCity, 3, -2, 12);
	    }
    }
}

// Alexander the Great

HandleEvent(CreateWonder) 'CTC_AlexandertheGreat' post {

	if(value[0] == WonderDB(WONDER_ARISTOTLES_LYCEUM)) {
	    if (GetUnitsAtLocation(city[0].location)<12){
	         CreateUnit(city[0].owner, UnitDB(UNIT_ALEXANDER_THE_GREAT), city[0].location, 0);
         }
         else{
	         CreateUnit(city[0].owner, UnitDB(UNIT_ALEXANDER_THE_GREAT), city[0].location, 1);
         }
         EnableTrigger('CTC_Start_Alexander');
	    DisableTrigger('CTC_AlexandertheGreat');
	}
}

HandleEvent(BeginTurnUnit) 'CTC_Start_Alexander' pre {

    if(Unit[0].type == UnitDB(UNIT_ALEXANDER_THE_GREAT)) {
	    AlexanderCount=50;
	    EnableTrigger('CTC_AlexanderLives');
	    EnableTrigger('CTC_AlexanderDies');
         DisableTrigger('CTC_Start_Alexander');
    }    
}

HandleEvent(BeginTurnUnit) 'CTC_AlexanderLives' post {

    int_t	j;
    int_t  tmpPlayer;
    int_t  numCities;
    city_t tmpCity;
	
    if(Unit[0].type == UnitDB(UNIT_ALEXANDER_THE_GREAT)) {
	    CTC_VeteranEffect(Unit[0].location);
	    AlexanderCount=AlexanderCount-1;
	    if (AlexanderCount<=0){//dies of old age
	         tmpPlayer=Unit[0].owner;
		    numCities=PlayerCityCount(tmpPlayer);
		    for(j = 0; j < numCities; j = j + 1) {
			    GetCityByIndex(tmpPlayer, j, tmpCity);
			    Event:AddHappyTimer(tmpCity, 3, -1, 12);
		    }
		    SetString(0,ID_UNIT_ALEXANDER_THE_GREAT);
		    message(tmpPlayer,'CTC_LeaderDeadOfOldAge');
		    event:DisbandUnit(unit[0]);
              DisableTrigger('CTC_AlexanderLives');
              DisableTrigger('CTC_AlexanderDies');
              
		}
	}
}

HandleEvent(KillUnit) 'CTC_AlexanderDies' pre {

    int_t	j;
    int_t  tmpPlayer;
    city_t tmpCity;

    if (Unit[0].type == UnitDB(UNIT_ALEXANDER_THE_GREAT)){
         tmpPlayer=Unit[0].owner;
	    SetString(0,ID_UNIT_ALEXANDER_THE_GREAT);
	    message(tmpPlayer,'CTC_LeaderKilled');
         DisableTrigger('CTC_AlexanderLives');
	    DisableTrigger('CTC_AlexanderDies');
	    for(j = 0; j < PlayerCityCount(tmpPlayer); j = j + 1) {
		    GetCityByIndex(tmpPlayer, j, tmpCity);
		    Event:AddHappyTimer(tmpCity, 3, -2, 12);
	    }
    }
}

// Caesar

HandleEvent(CreateWonder) 'CTC_Caesar' post {

	if(value[0] == WonderDB(WONDER_THE_APPIAN_WAY)) {
	    if (GetUnitsAtLocation(city[0].location)<12){
	         CreateUnit(city[0].owner, UnitDB(UNIT_CAESAR), city[0].location, 0);
         }
         else{
	         CreateUnit(city[0].owner, UnitDB(UNIT_CAESAR), city[0].location, 1);
         }
	    DisableTrigger('CTC_Caesar');
	    EnableTrigger('CTC_Start_Caesar');
	}
}

HandleEvent(BeginTurnUnit) 'CTC_Start_Caesar' pre {// if SLIC is reloaded

    if(Unit[0].type == UnitDB(UNIT_CAESAR)) {
	    CaesarCount=50;
	    EnableTrigger('CTC_CaesarLives');
	    EnableTrigger('CTC_CaesarDies');
	    DisableTrigger('CTC_Start_Caesar'); 
    }
}

HandleEvent(BeginTurnUnit) 'CTC_CaesarLives' post {

    int_t	j;
    int_t  tmpPlayer;
    int_t  numCities;
    city_t tmpCity;
	
    if(Unit[0].type == UnitDB(UNIT_CAESAR)) {
	    CTC_VeteranEffect(Unit[0].location);
	    CaesarCount=CaesarCount-1;
	    if (CaesarCount==0){//dies of old age
	         tmpPlayer=Unit[0].owner;
		    numCities=PlayerCityCount(tmpPlayer);
	         SetString(0,ID_UNIT_CAESAR);
	         message(tmpPlayer,'CTC_LeaderDeadOfOldAge');
		     for(j = 0; j < numCities; j = j + 1) {
			    GetCityByIndex(tmpPlayer, j, tmpCity);
			    Event:AddHappyTimer(tmpCity, 3, -1, 12);
		    }
		    event:DisbandUnit(unit[0]);
              DisableTrigger('CTC_CaesarLives');
              DisableTrigger('CTC_CaesarDies');             
		}
	}
}

HandleEvent(KillUnit) 'CTC_CaesarDies' pre {

    int_t	j;
    int_t  tmpPlayer;
    city_t tmpCity;

    if (Unit[0].type == UnitDB(UNIT_CAESAR)){
         tmpPlayer=Unit[0].owner;
	    SetString(0,ID_UNIT_CAESAR);
	    message(tmpPlayer,'CTC_LeaderKilled');
         DisableTrigger('CTC_CaesarLives');
	    DisableTrigger('CTC_CaesarDies');
	    for(j = 0; j < PlayerCityCount(tmpPlayer); j = j + 1) {
		    GetCityByIndex(tmpPlayer, j, tmpCity);
		    Event:AddHappyTimer(tmpCity, 3, -2, 12);
	    }
    }
}

// Muhammad

//HandleEvent(CreateWonder) 'Muhammad' post {

//	if(value[0] == WonderDB(WONDER_CHICHEN_ITZA)) {
//		CreateUnit(city[0].owner, UnitDB(UNIT_MUHAMMAD), city[0].location, 0);
//		DisableTrigger('Muhammad');
//	}
//}

// Charlemagne

HandleEvent(VictoryMoveOrder) 'CTC_Charlemagne' post {

    if(HasAdvance(Army[0].owner,ID_ADVANCE_CHIVALRY) && army[0].size>9) { 
	    if (TerrainType(location[0])<10 || (TerrainType(location[0])>17 && TerrainType(location[0])<22)){//not at sea 
		    CharlemagneLoc=location[0].location; 
		    player[0]=army[0].owner;
		    event:AccomplishFeat(featDB(FEAT_GOT_CHARLEMANGE), player[0]); 
		    DisableTrigger('CTC_Charlemagne');
	    }
    }
}

HandleEvent(BeginTurnUnit) 'CTC_Start_Charlemagne' pre {

    if(Unit[0].type == UnitDB(UNIT_CHARLEMANGE)) {
	    CharlemagneCount=50;
	    EnableTrigger('CTC_CharlemagneLives');
	    EnableTrigger('CTC_CharlemagneDies');
	    DisableTrigger('CTC_Start_Charlemagne'); 
    }
}

HandleEvent(BeginTurnUnit) 'CTC_CharlemagneLives' post {

    int_t	j;
    int_t  numCities;
    int_t  tmpPlayer;
    city_t tmpCity;
	
    if(Unit[0].type == UnitDB(UNIT_CHARLEMANGE)) {
	    CTC_VeteranEffect(Unit[0].location);
	    CharlemagneCount=CharlemagneCount-1;
	    if (CharlemagneCount==0){//dies of old age
	         tmpPlayer=Unit[0].owner;
		    numCities=PlayerCityCount(tmpPlayer);
		    SetString(0,ID_UNIT_CHARLEMANGE);
		    message(tmpPlayer,'CTC_LeaderDeadOfOldAge');
		     for(j = 0; j < numCities; j = j + 1) {
			    GetCityByIndex(tmpPlayer, j, tmpCity);
			    Event:AddHappyTimer(tmpCity, 3, -1, 12);
		    }
		    event:DisbandUnit(unit[0]);
              DisableTrigger('CTC_CharlemagneLives');
              DisableTrigger('CTC_CharlemagneDies');
		}
	}
}

HandleEvent(KillUnit) 'CTC_CharlemagneDies' pre {

    int_t	j;
    int_t  tmpPlayer;
    city_t tmpCity;

    if (Unit[0].type == UnitDB(UNIT_CHARLEMANGE)){
         tmpPlayer=Unit[0].owner;
	    SetString(0,ID_UNIT_CHARLEMANGE);
	    message(tmpPlayer,'CTC_LeaderKilled');
         DisableTrigger('CTC_CharlemagneLives');
	    DisableTrigger('CTC_CharlemagneDies');
	    for(j = 0; j < PlayerCityCount(tmpPlayer); j = j + 1) {
		    GetCityByIndex(tmpPlayer, j, tmpCity);
		    Event:AddHappyTimer(tmpCity, 3, -2, 12);
	    }
    }
}

// Hernan Cortes

//HandleEvent(CreateWonder) 'HernanCortes' post {

//	if(value[0] == WonderDB(WONDER_EAST_INDIA_COMPANY)) {
//		CreateUnit(city[0].owner, UnitDB(UNIT_HERNAN_CORTES), city[0].location, 0);
//		DisableTrigger('HernanCortes'); 
//	}
//}

// StonewallJackson

HandleEvent(VictoryMoveOrder) 'CTC_StonewallJackson' post {

    if(HasAdvance(Army[0].owner,ID_ADVANCE_CAVALRY_TACTICS) && army[0].size>10) {  
	    if (TerrainType(location[0])<10 || (TerrainType(location[0])>17 && TerrainType(location[0])<22)){//not at sea 
		    StonewallJacksonLoc=location[0].location; 
		    player[0]=army[0].owner;
		    event:AccomplishFeat(featDB(FEAT_GOT_STONEWALL_JACKSON), player[0]); 
		    DisableTrigger('CTC_StonewallJackson');
	    }
    }
}

HandleEvent(BeginTurnUnit) 'CTC_Start_StonewallJackson' pre {

    if(Unit[0].type == UnitDB(UNIT_STONEWALL_JACKSON)) {
         StonewallJacksonCount=50;
         EnableTrigger('CTC_StonewallJacksonLives');
         EnableTrigger('CTC_StonewallJacksonDies');
	    DisableTrigger('CTC_Start_StonewallJackson');
    }
}

HandleEvent(BeginTurnUnit) 'CTC_StonewallJacksonLives' post {

    int_t	j;
    int_t  tmpPlayer;
    int_t  numCities;
    city_t tmpCity;
	
    if(Unit[0].type == UnitDB(UNIT_STONEWALL_JACKSON)) {
	    CTC_VeteranEffect(Unit[0].location);
	    StonewallJacksonCount=StonewallJacksonCount-1;
	    if (StonewallJacksonCount==0){//dies of old age
	         tmpPlayer=Unit[0].owner;
		    numCities=PlayerCityCount(tmpPlayer);
		    SetString(0,ID_UNIT_STONEWALL_JACKSON);
		    message(tmpPlayer,'CTC_LeaderDeadOfOldAge');
		     for(j = 0; j < numCities; j = j + 1) {
			    GetCityByIndex(tmpPlayer, j, tmpCity);
			    Event:AddHappyTimer(tmpCity, 3, -1, 12);
		    }
		    event:DisbandUnit(unit[0]);
              DisableTrigger('CTC_StonewallJacksonLives');
              DisableTrigger('CTC_StonewallJacksonDies');
		}
	}
}

HandleEvent(KillUnit) 'CTC_StonewallJacksonDies' pre {

    int_t	j;
    int_t  tmpPlayer;
    city_t tmpCity;

    if (Unit[0].type == UnitDB(UNIT_STONEWALL_JACKSON)){
         tmpPlayer=Unit[0].owner;
	    SetString(0,ID_UNIT_STONEWALL_JACKSON);
	    message(tmpPlayer,'CTC_LeaderKilled');
         DisableTrigger('CTC_StonewallJacksonLives');
	    DisableTrigger('CTC_StonewallJacksonDies');
	    for(j = 0; j < PlayerCityCount(tmpPlayer); j = j + 1) {
		    GetCityByIndex(tmpPlayer, j, tmpCity);
		    Event:AddHappyTimer(tmpCity, 3, -2, 12);
	    }
    }
}

HandleEvent(VictoryMoveOrder) 'CTC_Rommel' post {

	if(HasAdvance(Army[0].owner,ID_ADVANCE_INTERNAL_COMBUSTION) && army[0].size>9 ) {
	    if (TerrainType(location[0])<10 || (TerrainType(location[0])>17 && TerrainType(location[0])<22) ){//not at sea  
		    RommelLoc=location[0].location;
		    event:AccomplishFeat(featDB(FEAT_GOT_ROMMEL), army[0].owner); 
		    DisableTrigger('CTC_Rommel');
	    }
	}
}

HandleEvent(BeginTurnUnit) 'CTC_Start_Rommel' pre {

    if(Unit[0].type == UnitDB(UNIT_ERWIN_ROMMEL)) {
	    RommelCount=50;
	    EnableTrigger('CTC_RommelLives');
	    EnableTrigger('CTC_RommelDies');
         DisableTrigger('CTC_Start_Rommel'); 
    } 
}

HandleEvent(BeginTurnUnit) 'CTC_RommelLives' post {

    int_t	j;
    int_t  numCities;
    int_t tmpPlayer;
    city_t tmpCity;
	
    if(Unit[0].type == UnitDB(UNIT_ERWIN_ROMMEL)) {
	    CTC_VeteranEffect(Unit[0].location);
	    CyrusCount=RommelCount-1;
	    if (RommelCount<=0){//dies of old age
              tmpPlayer=Unit[0].owner;
		    SetString(0,ID_UNIT_ERWIN_ROMMEL);
              message(tmpPlayer,'CTC_LeaderDeadOfOldAge');
		    for(j = 0; j < PlayerCityCount(tmpPlayer); j = j + 1) {
			    GetCityByIndex(tmpPlayer, j, tmpCity);
			    Event:AddHappyTimer(tmpCity, 3, -1, 12);
		    }
		    event:DisbandUnit(unit[0]);
              DisableTrigger('CTC_RommelLives');
              DisableTrigger('CTC_RommelDies');      
		}
	}
}

HandleEvent(KillUnit) 'CTC_RommelDies' pre {

    int_t	j;
    int_t  tmpPlayer;
    city_t tmpCity;

    if (Unit[0].type == UnitDB(UNIT_ERWIN_ROMMEL)){
         tmpPlayer=Unit[0].owner;
	    SetString(0,ID_UNIT_ERWIN_ROMMEL);
	    message(tmpPlayer,'CTC_LeaderKilled');
         DisableTrigger('CTC_RommelLives');
	    DisableTrigger('CTC_RommelDies');
	    for(j = 0; j < PlayerCityCount(tmpPlayer); j = j + 1) {
		    GetCityByIndex(tmpPlayer, j, tmpCity);
		    Event:AddHappyTimer(tmpCity, 3, -2, 12);
	    }
    }
}

HandleEvent(VictoryMoveOrder) 'CTC_Zhukov' post {

	if(HasAdvance(Army[0].owner,ID_ADVANCE_ROCKETRY) && army[0].size>10 ) {
	    if (TerrainType(location[0])<10 || (TerrainType(location[0])>17 && TerrainType(location[0])<22) ){//not at sea  
		    ZhukovLoc=location[0].location;
		    event:AccomplishFeat(featDB(FEAT_GOT_ZHUKOV), army[0].owner); 
		    DisableTrigger('CTC_Zhukov');
	    }
	}
}

HandleEvent(BeginTurnUnit) 'CTC_Start_Zhukov' pre {

    if(Unit[0].type == UnitDB(UNIT_GEORGI_ZHUKOV)) {
	    ZhukovCount=50;
	    EnableTrigger('CTC_ZhukovLives');
	    EnableTrigger('CTC_ZhukovDies');
         DisableTrigger('CTC_Start_Zhukov'); 
    } 
}

HandleEvent(BeginTurnUnit) 'CTC_ZhukovLives' post {

    int_t	j;
    int_t  numCities;
    int_t tmpPlayer;
    city_t tmpCity;
	
    if(Unit[0].type == UnitDB(UNIT_GEORGI_ZHUKOV)) {
	    CTC_VeteranEffect(Unit[0].location);
	    CyrusCount=ZhukovCount-1;
	    if (ZhukovCount<=0){//dies of old age
              tmpPlayer=Unit[0].owner;
		    SetString(0,ID_UNIT_GEORGI_ZHUKOV);
              message(tmpPlayer,'CTC_LeaderDeadOfOldAge');
		    for(j = 0; j < PlayerCityCount(tmpPlayer); j = j + 1) {
			    GetCityByIndex(tmpPlayer, j, tmpCity);
			    Event:AddHappyTimer(tmpCity, 3, -1, 12);
		    }
		    event:DisbandUnit(unit[0]);
              DisableTrigger('CTC_ZhukovLives');
              DisableTrigger('CTC_ZhukovDies');      
		}
	}
}

HandleEvent(KillUnit) 'CTC_ZhukovDies' pre {

    int_t	j;
    int_t  tmpPlayer;
    city_t tmpCity;

    if (Unit[0].type == UnitDB(UNIT_GEORGI_ZHUKOV)){
         tmpPlayer=Unit[0].owner;
	    SetString(0,ID_UNIT_GEORGI_ZHUKOV);
	    message(tmpPlayer,'CTC_LeaderKilled');
         DisableTrigger('CTC_ZhukovLives');
	    DisableTrigger('CTC_ZhukovDies');
	    for(j = 0; j < PlayerCityCount(tmpPlayer); j = j + 1) {
		    GetCityByIndex(tmpPlayer, j, tmpCity);
		    Event:AddHappyTimer(tmpCity, 3, -2, 12);
	    }
    }
}

// Dwight Eisenhower

HandleEvent(VictoryMoveOrder) 'CTC_DwightEisenhower' post {

    if(HasAdvance(Army[0].owner,ID_ADVANCE_TANK_WARFARE) && army[0].size>10) { 
	    if (TerrainType(location[0])<10 || (TerrainType(location[0])>17 && TerrainType(location[0])<22)){//not at sea 
		    DwightEisenhowerLoc=location[0].location; 
		    player[0]=army[0].owner;
		    event:AccomplishFeat(featDB(FEAT_GOT_DWIGHT_EISENHOWER), player[0]); 
		    DisableTrigger('CTC_DwightEisenhower');
	    }
    }
}

HandleEvent(BeginTurnUnit) 'CTC_Start_DwightEisenhower' pre {

    if(Unit[0].type == UnitDB(UNIT_DWIGHT_EISENHOWER)) {
         DwightEisenhowerCount=50;
         EnableTrigger('CTC_DwightEisenhowerLives');
         EnableTrigger('CTC_DwightEisenhowerDies');
	    DisableTrigger('CTC_Start_DwightEisenhower'); 
    }
}

HandleEvent(BeginTurnUnit) 'CTC_DwightEisenhowerLives' post {

    int_t	j;
    int_t  tmpPlayer;
    int_t  numCities;
    city_t tmpCity;
	
    if(Unit[0].type == UnitDB(UNIT_DWIGHT_EISENHOWER)) {
	    CTC_VeteranEffect(Unit[0].location);
	    DwightEisenhowerCount=DwightEisenhowerCount-1;
	    if (DwightEisenhowerCount==0){//dies of old age
	         tmpPlayer=Unit[0].owner;
		    numCities=PlayerCityCount(tmpPlayer);
		    SetString(0,ID_UNIT_DWIGHT_EISENHOWER);
		    message(tmpPlayer,'CTC_LeaderDeadOfOldAge');
		     for(j = 0; j < numCities; j = j + 1) {
			    GetCityByIndex(tmpPlayer, j, tmpCity);
			    Event:AddHappyTimer(tmpCity, 3, -1, 12);
		    }
		    event:DisbandUnit(unit[0]);
              DisableTrigger('CTC_DwightEisenhowerLives');
              DisableTrigger('CTC_DwightEisenhowerDies');
		}
	}
}

HandleEvent(KillUnit) 'CTC_DwightEisenhowerDies' pre {

    int_t	j;
    int_t  tmpPlayer;
    city_t tmpCity;

    if (Unit[0].type == UnitDB(UNIT_DWIGHT_EISENHOWER)){
         tmpPlayer=Unit[0].owner;
	    SetString(0,ID_UNIT_DWIGHT_EISENHOWER);
	    message(tmpPlayer,'CTC_LeaderKilled');
         DisableTrigger('CTC_DwightEisenhowerLives');
	    DisableTrigger('CTC_DwightEisenhowerDies');
	    for(j = 0; j < PlayerCityCount(tmpPlayer); j = j + 1) {
		    GetCityByIndex(tmpPlayer, j, tmpCity);
		    Event:AddHappyTimer(tmpCity, 3, -2, 12);
	    }
    }
}


// Norman Schwarzkopf

HandleEvent(VictoryMoveOrder) 'CTC_NormanSchwarzkopf' post {

    if(HasAdvance(Army[0].owner,ID_ADVANCE_SUPERSONIC_FLIGHT) && army[0].size>10) {  
    

// army[0] should have interceptors

	    NormanSchwarzkopfLoc=location[0].location; 
	    player[0]=army[0].owner;
	    event:AccomplishFeat(featDB(FEAT_GOT_NORMAN_SCHWARZKOPF), player[0]); 
	    DisableTrigger('CTC_NormanSchwarzkopf');
    }
}

HandleEvent(BeginTurnUnit) 'CTC_Start_NormanSchwarzkopf' pre {// if SLIC is reloaded

    if(Unit[0].type == UnitDB(UNIT_NORMAN_SCHWARZKOPF)) {
         NormanSchwarzkopfCount=50;
         EnableTrigger('CTC_NormanSchwarzkopfLives');
         EnableTrigger('CTC_NormanSchwarzkopfDies');
	    DisableTrigger('CTC_Start_NormanSchwarzkopf'); 
    }
}

HandleEvent(BeginTurnUnit) 'CTC_NormanSchwarzkopfLives' post {

    int_t	j;
    int_t  tmpPlayer;
    int_t  numCities;
    city_t tmpCity;
	
    if(Unit[0].type == UnitDB(UNIT_NORMAN_SCHWARZKOPF)) {
	    CTC_VeteranEffect(Unit[0].location);
	    NormanSchwarzkopfCount=NormanSchwarzkopfCount-1;
	    if (NormanSchwarzkopfCount==0){//dies of old age
	         tmpPlayer=Unit[0].owner;
		    numCities=PlayerCityCount(tmpPlayer);
		    SetString(0,ID_UNIT_NORMAN_SCHWARZKOPF);
		    message(tmpPlayer,'CTC_LeaderDeadOfOldAge');
		     for(j = 0; j < numCities; j = j + 1) {
			    GetCityByIndex(tmpPlayer, j, tmpCity);
			    Event:AddHappyTimer(tmpCity, 3, -1, 12);
		    }
		    event:DisbandUnit(unit[0]);
              DisableTrigger('CTC_NormanSchwarzkopfLives');
              DisableTrigger('CTC_NormanSchwarzkopfDies');
		    
		}
	}
}

HandleEvent(KillUnit) 'CTC_NormanSchwarzkopfDies' pre {

    int_t	j;
    int_t  tmpPlayer;
    city_t tmpCity;

    if (Unit[0].type == UnitDB(UNIT_NORMAN_SCHWARZKOPF)){
         tmpPlayer=Unit[0].owner;
	    SetString(0,ID_UNIT_NORMAN_SCHWARZKOPF);
	    message(tmpPlayer,'CTC_LeaderKilled');
         DisableTrigger('CTC_NormanSchwarzkopfLives');
	    DisableTrigger('CTC_NormanSchwarzkopfDies');
	    for(j = 0; j < PlayerCityCount(tmpPlayer); j = j + 1) {
		    GetCityByIndex(tmpPlayer, j, tmpCity);
		    Event:AddHappyTimer(tmpCity, 3, -2, 12);
	    }
    }
}

messagebox 'CTC_LeaderDeadOfOldAge' {
    show();
    Text (ID_LeaderHasDiedM) ;
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

messagebox 'CTC_LeaderKilled' {
    show();
    Text (ID_LeaderKilledM) ;
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

////////////////////////
// Surrender Handlers
////////////////////////

int_t CTC_THE_LOSER;
int_t CTC_THE_WINNER;

HandleEvent(CaptureCity) 'CTC_PreSurrender' pre {

    CTC_THE_LOSER=city[0].owner;
}


HandleEvent(CaptureCity) 'CTC_SurrenderTrigger' post {

int_t	i;
int_t     AI_surrender_coefficient;
int_t     numCities;
city_t	tmpCity;
city_t    tmpCityArray[];
int_t     numUnits;
unit_t    tmpUnit;
unit_t    tmpUnitArray[];

    if (CITY_SURRENDER_RATIO && UNIT_SURRENDER_RATIO){
         if ( !IsHumanPlayer(CTC_THE_LOSER) && CTC_THE_LOSER>0 && GetCurrentRound()>80 ){//Humans and Barbs don't surrender
		    player[1]=CTC_THE_LOSER; 
              CTC_THE_WINNER=player[0];
              if (IsHumanPlayer(CTC_THE_WINNER) && PlayerCityCount(CTC_THE_LOSER)){
		         if (CITY_SURRENDER_RATIO*player[1].cities <= player[0].cities
		         &&  UNIT_SURRENDER_RATIO*player[1].militaryunits <= player[0].militaryunits){ 
		         //the surrender condition 
                        Message(CTC_THE_WINNER, 'CTC_SurrenderMessage');// fix message
                   }
			    elseif (PlayerCityCount(CTC_THE_LOSER) && IsHumanPlayer(player[0])) {//only send messages when he has something left to surrender
				    if (CITY_SURRENDER_RATIO*PlayerCityCount(CTC_THE_LOSER)<=PlayerCityCount(player[0])){//city criterion satisfied
					    if (80*UNIT_SURRENDER_RATIO*player[1].militaryunits <= 100*player[0].militaryunits){
						    Message(player[0].owner, 'CTC_OverwhelmingSuperiority');
					    }
					    elseif (60*UNIT_SURRENDER_RATIO*player[1].militaryunits <= 100*player[0].militaryunits) {
						    Message(player[0].owner, 'CTC_MajorSuperiority');
					    }    
				    }
                        elseif (UNIT_SURRENDER_RATIO*player[1].militaryunits <= player[0].militaryunits){//unit criterion satisfied
					    if (80*CITY_SURRENDER_RATIO*PlayerCityCount(CTC_THE_LOSER)<= 100*PlayerCityCount(player[0])){
						    Message(player[0].owner, 'CTC_OverwhelmingSuperiority1');
					    }
					    elseif (60*CITY_SURRENDER_RATIO*PlayerCityCount(CTC_THE_LOSER)<= 100*PlayerCityCount(player[0])) {
						    Message(player[0].owner, 'CTC_MajorSuperiority1');
					    }    
				    }
				    elseif (75*CITY_SURRENDER_RATIO*PlayerCityCount(CTC_THE_LOSER) <= 100*PlayerCityCount(player[0])
				    && (75*UNIT_SURRENDER_RATIO*player[1].militaryunits) <= 100*player[0].militaryunits){
					    Message(player[0].owner, 'CTC_MilitarySuperiority');
				    }
			    }
		    }
		    else{//for AI simulate mergeciv
		         if (CTC_AI_FEAR_RADIUS<4){
                        AI_surrender_coefficient=100-15*CTC_AI_FEAR_RADIUS;
			    }
			    else{
				    AI_surrender_coefficient=50;
			    }
		  
		         if (AI_surrender_coefficient*CITY_SURRENDER_RATIO*player[1].cities <= 100*player[0].cities
		         &&  AI_surrender_coefficient*UNIT_SURRENDER_RATIO*player[1].militaryunits <= 100*player[0].militaryunits){ 
                        DisableTrigger('CTC_CheckGeogArraysOnCapture');
			         GodMode(1);
				    numUnits=player[1].units;
                        if (numUnits){
					    for (i=0; i<numUnits; i=i+1){//put all LOSER units into an array
						    GetUnitByIndex(CTC_THE_LOSER,i,tmpUnit);
                                  if (tmpUnit.valid){
                                       tmpUnitArray[i]=tmpUnit;
                                  }
					    }
					    for (i=0; i<tmpUnitArray.#; i=i+1){//then kill them
						    Event: DisbandUnit(tmpUnitArray[i]);
					    }
				    }
				    numCities=PlayerCityCount(CTC_THE_LOSER);
				    if (numCities){
				         for (i=0; i<numCities; i=i+1) {//put all LOSER cities into an array
                                  GetCityByIndex(CTC_THE_LOSER, i, tmpCity);
						    if (CityIsValid(tmpCity)) {
						         tmpCityArray[i]=tmpCity;
                                  }
					    }
					    for (i=0; i<tmpCityArray.#; i=i+1) {//then give them to the WINNER
						    
						    Event:GiveCity(tmpCityArray[i], CTC_THE_WINNER);
                                  Event:AddHappyTimer(tmpCityArray[i],5,3,14);//5 turns of +3 happiness
					    }
				    }      
	                   GodMode(0);
	                   CTC_THE_LOSER=0; 
	                   CTC_THE_WINNER=0;
				    EnableTrigger('CTC_ReInstateCheckGeogArraysOnCapture');
				    EnableTrigger('CTC_CheckGeogArraysAfterSurrender');
                   }
              }
	    }
    }
}

HandleEvent(EndTurn) 'CTC_ReInstateCheckGeogArraysOnCapture' pre {
    EnableTrigger('CTC_CheckGeogArraysOnCapture');
    DisableTrigger('CTC_ReInstateCheckGeogArraysOnCapture');
}

int_t CTC_THE_CONQUERER;

alertbox 'CTC_SurrenderMessage' {

    int_t i;
    int_t numAI;

    numAI=0;
    for (i=1;i<CTC_PLAYER_COUNT;i=i+1){
         if (IsPlayerAlive(i)){
	         if (!IsHumanPlayer(i)){
		         NumAI=numAI+1;
	         }
         }
    }
    if (numAI == 1){
         Text (ID_TheVictoryMessage) ; 
         Button(ID_BUTTON_END_GAME ){
		    message(CTC_THE_WINNER,'CTC_SurrenderMessage1');
		    kill();
	    }
         Button(ID_BUTTON_CONTINUE_GAME ){

// Do you want to disable the surrender mechanism?

		    kill();
	    }
    }
    else{
         Text (ID_TheSurrenderMessage) ; 
	    Button(ID_BUTTON_CONTINUE ){
		    message(CTC_THE_WINNER,'CTC_SurrenderMessage1');
		    kill();
	    }
    }
    
}

alertbox 'CTC_SurrenderMessage1' {
    show();

    Text (ID_TheSurrenderMessage1) ;
    Button(ID_BUTTON_CONTINUE ){
         int_t	    i;
         int_t     numAI;
         int_t     numCities;
         city_t    tmpCity;
         city_t    CityArray[];

         int_t     numUnits;
         unit_t    tmpUnit;
         unit_t    UnitArray[];

         location_t tmpLoc;
         GodMode(1);
         DisableTrigger('CTC_CheckGeogArraysOnCapture');
         player[1]=CTC_THE_LOSER; 
	    numUnits=player[1].units;
	    numCities=PlayerCityCount(CTC_THE_LOSER);

	    for (i=0; i<numUnits; i=i+1){//put all LOSER units into an array
		    GetUnitByIndex(CTC_THE_LOSER,i,tmpUnit);
		    if (tmpUnit.valid){
			    UnitArray[i]=tmpUnit;
		    }
	    }
	    for (i=0; i<UnitArray.#; i=i+1){//then kill them
		    Event: DisbandUnit(UnitArray[i]);
	    }

	    for (i=0; i<numCities; i=i+1) {//put all LOSER cities into an array
		    GetCityByIndex(CTC_THE_LOSER, i, tmpCity);
		    if (CityIsValid(tmpCity)) {
			    CityArray[i]=tmpCity;
		    }
	    }
	    GodMode(0);
	    for (i=0; i<CityArray.#; i=i+1) {//then give them to the WINNER
		    
		    Event:GiveCity(CityArray[i], CTC_THE_WINNER);
		    Event:AddHappyTimer(CityArray[i],5,3,14);//5 turns of +3 happiness
		    tmpLoc=CityArray[i].location;
	    }
         GetCityByIndex(CTC_THE_WINNER, 0, tmpCity);   
	    AddCenter(tmpCity.location); 
         PlaySound("SOUND_ID_CHEER_ENTERTAINMENT");

         if (MilitaryRank(CTC_THE_WINNER)==100 
	    ||  KnowledgeRank(CTC_THE_WINNER)== 100
	    ||  PopulationRank(CTC_THE_WINNER)== 100
	    ||  CitiesRank(CTC_THE_WINNER)== 100){
        
	// find the smallest AI civ

		    int_t tmpRank;
		    int_t weakRank;
		    int_t weakAIciv;
		    int_t distRank;
		    int_t closeAIciv;

		    weakRank=99999;
		    weakAIciv=0;
		    for (i=1;i<CTC_PLAYER_COUNT;i=i+1){
			    if (IsPlayerAlive(i)) {
				    if (!IsHumanPlayer(i) && i != CTC_THE_LOSER){
					    tmpRank=GeographicRank(i)+PopulationRank(i)+CitiesRank(i);
					    if (tmpRank<weakRank){
						    weakRank=tmpRank;
						    weakAIciv=i;
					    }
				    }   
			    }
		    }
		    if (weakAIciv){// find the closest AIciv to it
			    distRank=99999;
			    closeAIciv=0;
			    for (i=1;i<CTC_PLAYER_COUNT;i=i+1){
				    if (IsPlayerAlive(i)) {
					    if (!IsHumanPlayer(i) && weakAIciv != i && i != CTC_THE_LOSER){
						    tmpRank=CTC_GetCloseness(weakAIciv,i);
						    if (tmpRank<distRank){
							    distRank=tmpRank;
							    closeAIciv=i;
						    }
					    }
				    }
			    }
			    if (closeAIciv){
				    MERGE_SOURCE =weakAIciv;
				    MERGE_TARGET =closeAIciv;
				    MERGE_COUNTDOWN=10; //should really depend on number of human players?
				    EnableTrigger('CTC_MergecivCheck');
				    CTC_THE_CONQUERER = CTC_THE_WINNER;
			    }
		    }
	    }
	    CTC_THE_LOSER=0; 
	    CTC_THE_WINNER=0;    

	    EnableTrigger('CTC_ReInstateCheckGeogArraysOnCapture');
	    EnableTrigger('CTC_CheckGeogArraysAfterSurrender');
	    
	    kill();
    }
}

alertbox 'CTC_OverwhelmingSuperiority' {
	Text (ID_OverwhelmingSuperiorityM) ;
	//show();
	Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

alertbox 'CTC_MajorSuperiority' {
	//show();
	Text (ID_MajorSuperiorityM) ;
	Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

alertbox 'CTC_OverwhelmingSuperiority1' {
	Text (ID_OverwhelmingSuperiority1M) ;
	//show();
	Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

alertbox 'CTC_MajorSuperiority1' {
	//show();
	Text (ID_MajorSuperiority1M) ;
	Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

alertbox 'CTC_MilitarySuperiority' {
	//show();
	Text (ID_MilitarySuperiorityM) ;
	Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

/////////////////
//
//  Merge Civ 
//
//  original idea: Lou Wigman	
//
//  original scripting: The Immortal Wombat (aka Ben Weaver)
//
//  adapted for CTC by PT
//
/////////////////

void_f CTC_MergeCivs(int_t CivOne, int_t CivTwo, int_t CivOneUnitCount,  int_t PWtotal){ 
// give civ one assets to civ two

	int_t    i;
     int_t    RiotLevel;
     int_t    HapBoost;
     int_t    CivOneCityCount;
	int_t    CivOneUnitType[];

	city_t   tmpCity;
     city_t   CivOneCity[];

	unit_t   tmpUnit;

	location_t    tmpLoc;
	location_t    CivOneUnitLoc[];
	
    // re-init CivOneUnit	arrays?
    for (i=0;i<CivOneUnitType.#;i=i+1){
         CivOneUnitType[i]=0;
	    CivOneUnitLoc[i]=0;
    }

    //first, do gold and pw
    Event:AddGold(CivTwo, PlayerGold(CivOne));   
    SetPW(CivTwo, PWtotal);

    //save CivOne's unit data
    for(i = 0; i < CivOneUnitCount; i = i + 1){
	    GetUnitByIndex(CivOne, i, tmpUnit);
	    if (tmpUnit.valid){
		    CivOneUnitType[i]=tmpUnit.type;
		    CivOneUnitLoc[i]=tmpUnit.location;
	    }
    }

    // kill CivOne's units
    for(i = 0; i < CivOneUnitType.#; i = i + 1){
	    GetUnitByIndex(CivOne, i, tmpUnit);
	    Event:DisbandUnit(tmpUnit);
    }

	//now give his cities to CivTwo
 
    GodMode(1); //nec?
	CivOneCityCount=PlayerCityCount(CivOne);   
     for(i = 0; i < CivOneCityCount; i = i + 1){
         GetCityByIndex(CivOne, i, tmpCity);
	    if (CityIsValid(tmpCity)) {
	         CivOneCity[i]=tmpCity;
	    }
	}
     
	for(i = 0; i < CivOneCity.#; i = i + 1){
		Event:GiveCity(CivOneCity[i], CivTwo);
	}
     GodMode(0);

	//and, replace the units
	
	for(i = 0; i < CivOneUnitType.#; i = i + 1){
		Event:CreateUnit(CivTwo, CivOneUnitLoc[i], 0, CivOneUnitType[i], 0);
	}

	// "make sure nobody's rioting or starting cults or sodomizing goats"

    RiotLevel = GetRiotLevel();
    for(i = 0; i < PlayerCityCount(CivTwo); i = i + 1) {
	    GetCityByIndex(CivTwo, i, tmpCity);
	    if(tmpCity.happiness < RiotLevel + 1) { //Winnie had "&& CityIsValid(tmpCity)", can't see why
	         hapBoost=RiotLevel + 3 - tmpCity.happiness;
              Event:AddhappyTimer(tmpCity, 1000, hapBoost, 0); //1000?
         }
	    else{
	         Event:AddhappyTimer(tmpCity, 1000, 2, 0);
	    }
    }
}



HandleEvent(BeginTurn) 'CTC_MergecivCheck' post {

    int_t i;
    int_t DoMerge;
    int_t CivOneUnitCount;
    int_t PWtotal;

    DoMerge=0;
    if (MERGE_COUNTDOWN == 0){
         DoMerge=1;
    }
    elseif (MERGE_COUNTDOWN > 0){
         if(Random(9)<1) {//include random chance of quicker merge
            DoMerge=1;
         }
    }
    if (DoMerge){
	    if (player[0].owner == MERGE_SOURCE){ //so MERGE_SOURCE must still be alive
              if (IsPlayerAlive(MERGE_TARGET)){ 
			    DisableMessageClass(180103);//disable conquered by message
		         player[1]=MERGE_TARGET;    
                   message(CTC_THE_CONQUERER,'CTC_ImportantNewsComingIn');
			    EnableTrigger('CTC_MergecivExec');
	         }
         }
    }
    if (player[0].owner == CTC_THE_CONQUERER){//decrease count every time CTC_THE_CONQUERER has a turn
         MERGE_COUNTDOWN=MERGE_COUNTDOWN-1;
    }
    if (MERGE_COUNTDOWN <0){ //shut down
         CTC_THE_CONQUERER=0;
	    MERGE_SOURCE=0;
	    MERGE_TARGET=0;
	    EnableMessageClass(180103);
         DisableTrigger('CTC_MergecivCheck');

// here's the place to check to see if we want to do another one

    }
}

alertbox 'CTC_ImportantNewsComingIn' {
    Title(ID_BREAKING_NEWS);
    Text (ID_ImportantNewsComingInTxt );
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

HandleEvent(EndTurn) 'CTC_MergecivExec' pre {
    
    int_t CivOneUnitCount;
    int_t PWtotal;
    int_t numAI;
    int_t i;

    if (!IsHumanPlayer(player[0].owner) ){//aborted if SLIC reloaded
   
		player[1]=MERGE_TARGET;  
		PWtotal = player[1].publicworkslevel;
		PWtotal = PWtotal + player[0].publicworkslevel; 

	    CivOneUnitCount=player[0].units;
	    numAI=0;
	    for (i=1;i<CTC_PLAYER_COUNT;i=i+1){
              if (IsPlayerAlive(i)){
		         if (!IsHumanPlayer(i)){
			         numAI=numAI+1; 
		         }
              }
         }
	    if (numAI==2){
	         message(CTC_THE_CONQUERER, 'CTC_LastMerge');
	         CITY_SURRENDER_RATIO=5;
              UNIT_SURRENDER_RATIO=5;  
	    }
	    else{
              message(CTC_THE_CONQUERER, 'CTC_Coup_dEtat');
	    }
	    
	    CTC_MergeCivs(player[0].owner, MERGE_TARGET, CivOneUnitCount, PWtotal);
	    DisableTrigger('CTC_MergecivExec');
    }
}

messagebox 'CTC_Coup_dEtat' {
    show();
    Title(ID_COUP);
    player[1]=MERGE_TARGET;
    Text (ID_Coup_dEtatTxt );
}

messagebox 'CTC_LastMerge' {
    show();
    Title(ID_MOAB);
    player[1]=MERGE_TARGET;
    Text (ID_LastMergeTxt );
}
////////////////////////////////////////////////
//
//  LOCUTUS'S MILITIA CODE (adapted for CTC by PT)
//
////////////////////////////////////////////////

// return 1 if army contains an ImmobileUnit
int_f CTC_ArmyHasImmobileUnit(army_t theArmy) {

int_t	i;
army_t tmpArmy;
unit_t tmpUnit;

    tmpArmy=theArmy;                       
    for (i = 0; i < tmpArmy.size; i = i + 1) {
	    GetUnitFromArmy(tmpArmy, i, tmpUnit);
	    if (UnitDB(tmpUnit.type).powerpoints == 82
	        || UnitDB(tmpUnit.type).powerpoints == 80) {//militia or pillbox\leviathon	
		    return 1;
	    }
    }
    return 0;
}

// return 1 if army contains a Settler
int_f CTC_ArmyHasSettler(army_t theArmy) {

int_t	i;
army_t tmpArmy;
unit_t tmpUnit;

    tmpArmy=theArmy;                       
    for (i = 0; i < tmpArmy.size; i = i + 1) {		// cycle through all units in this army
	    GetUnitFromArmy(tmpArmy, i, tmpUnit);
	    if (UnitDB(tmpUnit.type).powerpoints == 1 || UnitDB(tmpUnit.type).powerpoints == 2) {	
	    // if any of the units in this army is a Settler
		    return 1;
	    }
    }
    return 0;
}

// return 1 if army contains an AirUnit
int_f CTC_ArmyHasAirUnit(army_t theArmy) {

int_t	i;
army_t tmpArmy;
unit_t tmpUnit;

    tmpArmy=theArmy;                       
    for (i = 0; i < tmpArmy.size; i = i + 1) {
	    GetUnitFromArmy(tmpArmy, i, tmpUnit);
	    if (UnitDB(tmpUnit.type).powerpoints == 31) {	// proper air unit
		    return 1;
	    }
    }
    return 0;
}
//  CITY HANDLERS

// when a city is built, no matter how (settler, sea engineer, ruin), create one Militia unit
HandleEvent(CreateCity) 'CTC_MilitiaCityCreated' post {	// triggers when a city is founded
    
    unit_t tmpUnit;
    int_t milType;
   
    milType=0;
	if (HasAdvance(player[0], ID_ADVANCE_GLOBAL_DEFENSE)) {		
		milType= UnitDB(UNIT_HEAVY_MACHINE_GUNNER_MILITIA);
	} 
	elseif (HasAdvance(player[0], ID_ADVANCE_MASS_PRODUCTION)) {
		milType= UnitDB(UNIT_MACHINE_GUNNER_MILITIA);
	} 
	elseif (HasAdvance(player[0], ID_ADVANCE_MODERN_METALLURGY)) {
		milType= UnitDB(UNIT_MUSKETEER_MILITIA);
	} 
	elseif (HasAdvance(player[0], ID_ADVANCE_FEUDALISM)) {
		milType= UnitDB(UNIT_PIKEMEN_MILITIA);
	} 
	elseif (HasAdvance(player[0], ID_ADVANCE_TOOLMAKING)) {
		milType= UnitDB(UNIT_HOPLITE_MILITIA); 
	}
	if (milType){
		CreateUnit(player[0], milType, city[0].location, 0, tmpUnit);// create one unit of proper type
		Event:EntrenchUnit(tmpUnit);					           // and fortify them
	}
}

// when a city grows to MILITIA_CITY_SIZE,size, kill it's militia
HandleEvent(MakePop) 'CTC_MilitiaCityGrew' post {		    // triggers if city grew in size
    unit_t    tmpUnit;
    int_t     i;

    if (city[0].population > 60) {
	    for (i = 0; i < GetUnitsAtLocation(city[0].location); i = i + 1) {
		    GetUnitFromCell(city[0].location, i, tmpUnit);  // cycle through all units at current location
		    if (UnitDB(tmpUnit.type).powerpoints == 82) {	  // if unit is Militia	
			    KillUnit(tmpUnit);				       // kill this unit
		    }
	    }
    }
}

// if city is disbanded, kill it's immobile units
HandleEvent(DisbandCity) 'CTC_MilitiaCityDisbanded' pre {  // triggers if city is disbanded
    unit_t	tmpUnit;
    int_t     tmpNum;
    int_t      i;

    if (CityIsValid(city[0])){
         tmpNum=GetUnitsAtLocation(city[0].location);
	    for (i = 0; i < tmpNum; i = i + 1) {
			GetUnitFromCell(city[0].location, i, tmpUnit);  // cycle through all units at current location
			if (UnitDB(tmpUnit.type).powerpoints == 82
			    || UnitDB(tmpUnit.type).powerpoints == 80) {   // if unit is immobile	
				KillUnit(tmpUnit);				        // kill this unit
			}
	    }
    }
}

// MOVE HANDLERS 

// prevent immobile units from moving through numpad commands
HandleEvent(MoveToOrder) 'CTC_MilitiaMoveNumpad' pre {	
	if (ArmyIsValid(army[0])){
		if (CTC_ArmyHasImmobileUnit(army[0])) {
		    // don't let other units get trapped with immobile units
              event:UngroupOrder(army[0]); 
		    return STOP; // don't allow army to move
		}
	}
}

// prevent immobile units from moving
HandleEvent(MoveOrder) 'CTC_MilitiaMove' pre {
    city_t tmpCity;
    if (ArmyIsValid(army[0])){
		if (CTC_ArmyHasImmobileUnit(army[0])) {
		    // don't let other units get trapped with immobile units
              event:UngroupOrder(army[0]);
              return STOP; // don't allow army to move 		  			    
		}
    }
}

// prevent Militia units from boarding a transport
HandleEvent(MoveIntoTransport) 'CTC_MilitiaBoard' pre {// triggers right before an army boards a transport
    if (ArmyIsValid(army[0])){
		if (CTC_ArmyHasImmobileUnit(army[0])) {
		    return STOP;
		}
    }
}

HandleEvent(BoardTransportOrder) 'CTC_MilitiaBoardTransportOrder' pre {
    if (ArmyIsValid(army[0])){
	    if (CTC_ArmyHasImmobileUnit(army[0])) {
		    return STOP;
	    }
    }
}

// MISC HANDLERS

HandleEvent( DetrenchOrder) 'CTC_MilitiaDetrenchOrder' pre {// don't let them detrench

    if (ArmyIsValid(army[0])){
	    if (CTC_ArmyHasImmobileUnit(army[0])) {
		    return STOP;
	    }
    }
}

///////////////////
//
// Bombard Special Effects
//
///////////////////

location_t BOMB_LOC;

Void_f Do_Bombard_Effect(army_t theArmy, location_t theLocation, int_t pillageFlg){

    army_t tmpArmy;
    location_t tmpLoc;
    city_t tmpCity;
    unit_t tmpUnit;

    int_t i;
    int_t cityFlg;
    int_t landFlg;
    int_t impFlg;
    int_t EffectResult;
    int_t doArmyFlg;
    int_t enemyFlg;

    tmpArmy=theArmy;
    tmpLoc=theLocation;

    EffectResult=0;
    cityFlg=0;
    impFlg=0;
    landFlg=0;
    doArmyFlg=1;
    enemyFlg=0;

    if (GetUnitsAtLocation(tmpLoc)){
	    enemyFlg=1;
    }
    if (GetCityByLocation(tmpLoc,tmpCity)){
         cityFlg=1;
    }
    for (i=0;i<24;i=i+1){// standard tileimp.txt
	    if (TileHasImprovement(tmpLoc, i) ){ 
              impFlg=1;
		    i=24;
	    }
    }
    if (pillageFlg && impFlg){
	    event:CutImprovements(tmpLoc); 
    }
    if (TerrainType(tmpLoc)<10 || (TerrainType(tmpLoc)>17 && TerrainType(tmpLoc)<22) ){//land target   
	    landFlg=1;       
    }
    for (i=0;i<tmpArmy.size;i=i+1){//first pass: look for planes (they take priority)
	    GetUnitFromArmy(tmpArmy,i,tmpUnit);
         if (tmpUnit.type == UnitDB(UNIT_BIPLANE)){//Biplanes have lesser effects
	         AddCenter(tmpLoc);
	         AddEffect(tmpLoc, "SPECEFFECT_EXPLOSION_SPACE_1", "SOUND_DEATH_TANK");
		    // "SPECEFFECT_FIRES", "SOUND_ID_EXPLOSION_LAND_2"
			//	   StartTimer(7, 2); follow with fires?
         }
	    elseif (UnitDB(tmpUnit.type).PowerPoints == 31){ //plane effects take priority
		    if (cityFlg || landFlg){//city or land loc
		         AddCenter(tmpLoc);
			    AddEffect(tmpLoc, "SPECEFFECT_EXPLOSION_LAND_1", "SOUND_DEATH_TANK");
			    // follow with  "SPECEFFECT_FIRES", "SOUND_ID_EXPLOSION_LAND_2"
			    StartTimer(7, 2);
		    }
		    elseif(!landFlg && (impFlg || enemyFlg)){//sea loc with improvement or enemy units
			    AddCenter(tmpLoc);
			    AddEffect(tmpLoc, "SPECEFFECT_EXPLOSION_WATER", "SOUND_ID_EXPLOSION_LAND_1");
			    // follow with "SPECEFFECT_UNHAPPINESS_SEA", "SOUND_ID_EXPLOSION_LAND_1" <= should be sinking sound
			    StartTimer(6, 2);
		    }
		    i=tmpArmy.size;
		    doArmyFlg=0;
	    }
    }
    if (doArmyFlg){	    
	    for (i=0;i<tmpArmy.size;i=i+1){//second pass: look for naval or ranged that can bombard water
		    GetUnitFromArmy(tmpArmy,i,tmpUnit);
		    if (UnitDB(tmpUnit.type).PowerPoints == 12 || UnitDB(tmpUnit.type).PowerPoints == 52) {// naval or ranged that can bombard water
			    if(cityFlg || (landFlg && impFlg)) {
				    AddCenter(tmpLoc);
				    AddEffect(tmpLoc, "SPECEFFECT_EXPLOSION_SPACE_1", "SOUND_DEATH_TANK");
				   // "SPECEFFECT_FIRES", "SOUND_ID_EXPLOSION_LAND_2"
				   StartTimer(7, 2);
			    } 
			    elseif(!landFlg && (impFlg || enemyFlg)){//sea loc with improvement or enemy units
				    AddCenter(tmpLoc);
				    AddEffect(tmpLoc, "SPECEFFECT_EXPLOSION_WATER", "SOUND_ID_EXPLOSION_LAND_1");
				    // follow with "SPECEFFECT_UNHAPPINESS_SEA", "SOUND_ID_EXPLOSION_LAND_1" <= should be sinking sound
				    StartTimer(6, 2);
			    }
			    elseif(landFlg){ //land loc without improvement
				    AddCenter(tmpLoc);
				    StartTimer(5, 2);//after timer  SPECEFFECT_EXPLOSION_LAND_1 
			    }
			    i=tmpArmy.size; 
			    doArmyFlg=0;
		    }
	    }
    }
    if (doArmyFlg){
	    for (i=0;i<tmpArmy.size;i=i+1){//third pass: look for Ranged can bombard Land and Mountain
		    GetUnitFromArmy(tmpArmy,i,tmpUnit);
		    if (UnitDB(tmpUnit.type).PowerPoints == 51) {
			    if (landFlg){ //land loc
				    if (cityFlg){
					    AddCenter(tmpLoc);
					    StartTimer(7, 2); //after timer: fires
				    }
				    else{
					    AddCenter(tmpLoc);
					    StartTimer(2, 2);//after timer: SPECEFFECT_EXPLOSION_LAND_2, small orange cloud
				    } 
				    i=tmpArmy.size;
				    doArmyFlg=0;
			    }
		    }
	    }
    }
    if (doArmyFlg && !landFlg){// last pass: target is sea location
	    for (i=0;i<tmpArmy.size;i=i+1){
		    GetUnitFromArmy(tmpArmy,i,tmpUnit);
		    if (UnitDB(tmpUnit.type).PowerPoints == 11 || UnitDB(tmpUnit.type).PowerPoints == 21) {// naval or undersea can bombard water
		         AddCenter(tmpLoc);
			    AddEffect(tmpLoc, "SPECEFFECT_EXPLOSION_WATER", "SOUND_ID_EXPLOSION_LAND_1");		    
			    i=tmpArmy.size;
		    }
	    }  
    }  
}



HandleEvent(BombardOrder) 'CTC_Bombard_SpecEffects' post {

    int_t  pillageFlg;

    if (ArmyIsValid(army[0])){//in case this kicks in because of counter-bombarding

         if (IsHumanPlayer(army[0].owner) && Distance(army[0].location,location[0])==1){
              if (random(100)<PILLAGE_PERCENT){
	              pillageFlg=1;
              }
              Do_Bombard_Effect(army[0], location[0].location, pillageFlg);
		    BOMB_LOC=location[0]; 
		    EnableTrigger('CTC_BombardEffect');  
	    }
    }
}

HandleEvent(TimerExpired) 'CTC_BombardEffect' post {

    if(value[0]==1){
	    AddEffect(BOMB_LOC, "SPECEFFECT_FIRES", "SOUND_ID_EXPLOSION_LAND_2"); 
    }
    elseif(value[0]==2){  
	    AddEffect(BOMB_LOC, "SPECEFFECT_EXPLOSION_LAND_2", "SOUND_ID_EXPLOSION_LAND_1"); 
    }
    elseif(value[0]==3){ //same as 1 
	    AddEffect(BOMB_LOC, "SPECEFFECT_FIRES", "SOUND_ID_EXPLOSION_LAND_2"); 
    }
    elseif(value[0]==4){//same as 1
         AddEffect(BOMB_LOC, "SPECEFFECT_FIRES", "SOUND_ID_EXPLOSION_LAND_2"); 
	   // AddEffect(BOMB_LOC, "SPECEFFECT_EXPLOSION_WATER", "SOUND_ID_EXPLOSION_LAND_1"); 
    }
    elseif(value[0]==5){  
	    AddEffect(BOMB_LOC, "SPECEFFECT_EXPLOSION_LAND_1", "SOUND_ID_EXPLOSION_LAND_1"); 
    }
    elseif(value[0]==6){  
	    AddEffect(BOMB_LOC, "SPECEFFECT_UNHAPPINESS_SEA", "SOUND_ID_EXPLOSION_LAND_1"); //sinking sound
    }
    elseif(value[0]==7){ //same as 1 
	    AddEffect(BOMB_LOC, "SPECEFFECT_FIRES", "SOUND_ID_EXPLOSION_LAND_2"); 
    }

    BOMB_LOC=0;
    DisableTrigger('CTC_BombardEffect');
}

////////
//
// Bells and Whistles
//
////////

//add settlers to cities

HandleEvent(BeginTurnUnit) 'CTC_AddPopToCity' pre {
int_t i;
city_t tmpcity;

//NOMAD for Cradle

    if (unit[0].valid) {
	    if( IsHumanPlayer(unit[0].owner)&& unit[0].type==UnitDB(UNIT_SETTLER) && 0<PlayerCityCount(unit[0].owner) ){
		    // human player is about to move a settler, and has cities
		    if (GetCityByLocation(unit[0].location,tmpCity)) {//is he in a city?
			    if (tmpcity.population>2) {
				    SelectUnit(unit[0]);
				    city[0]=tmpcity;
				    player[0]=unit[0].owner;
				    Message(player[0], 'CTC_AddPopToCityQ');
				    //ask if we want him to settle there
			    }	         
		    }
	    }
    }
}
     
messagebox 'CTC_AddPopToCityQ'{ 
    Show(); 
    Text(ID_CTC_AddPopToCityM);
    //M_AddPopToCity  "{player[0].leader_name#SIR_CAP}, shall I settle in this city?"
    Button(ID_NO){ 
	 Kill(); 
    } 
    Button(ID_YES){
         Event:DisbandUnit(unit[0]);
         AddPops(city[0],1);
         Kill();
    }
}

/////////// //  Disband Cities and Create Refugees

int_t THE_CITY_OWNER;

HandleEvent(CaptureCity) 'CTC_DisbandCities' pre {
    THE_CITY_OWNER=city[0].owner;
}

//these will be part of the mergeciv system:
HandleEvent(CaptureCity) 'CTC_EnableMergeAfterCaptureCity' pre {
    if (g.year>300){
         EnableTrigger('CTC_MergeAfterCaptureCity');
         DisableTrigger('CTC_EnableMergeAfterCaptureCity');
    }
}

HandleEvent(CaptureCity) 'CTC_MergeAfterCaptureCity' post {

    
// TBD

}


HandleEvent(CaptureCity) 'CTC_DisbandCities' post {

// This is in large part Martin Guehmann's KillCityOption. I had a handler that did something quite similar but 
// Martin's was much better. So I've incorporated quite a lot of his code into mine.

int_t refugees; //pop to send to the winner's cities
int_t escapees; //pop to send to the loser's cities
int_t casualties; //pop that died in the attack
int_t Pw;
int_t i;
int_t j;
city_t tmpCity; 
int_t tmpDist;
int_t theDist;
location_t tmpLoc; //the disbanded city's location

    if (CityIsValid(city[0])){
  
		if (IsHumanPlayer(player[0]) && 2<city[0].population ){
		  //&& city[0].population<20

		    Message(player[0],'CTC_DisbandCitiesQ'); 
		}
		elseif (!IsHumanPlayer(player[0])) {
		    tmpDist=CTC_FindTheNearestCity(player[0].owner,city[0].location,1);
		    if (city[0].population<7 && (tmpDist<6 || tmpDist>11)){
		    // the AI always disbands small cities that are too close or too far away

                   FinishBuilding(city[0]);// Winnie did this (why?)
                   refugees=(50*city[0].population)/100;// send them randomly around the winner's empire
                   casualties=(30*city[0].population)/100;
			    escapees= city[0].population-(refugees+casualties);
                   tmpDist=999999;         
			    if (IsPlayerAlive(THE_CITY_OWNER)){// what about if not?
			         if (PlayerCityCount(THE_CITY_OWNER)){        
					    For (i=0; i<escapees; i=i+1){// scatter the escapees around the loser's empire
						    j = random(PlayerCityCount(THE_CITY_OWNER));
						    GetCityByIndex(THE_CITY_OWNER, j, tmpCity);
						    AddPops(tmpCity, 1);
					    }
					    value[0]=escapees;
				    }
                   }
			    tmpLoc=city[0].location;
			    Event:AddGold(player[0],city[0].population*100);
			    Pw = player[0].publicworkslevel + (city[0].population*75);
			    setPW(player[0], Pw); 
			    for (i=0; i<refugees; i=i+1){
				    j = random(PlayerCityCount(player[0])-1);
				    GetCityByIndex(player[0], j, tmpCity);
				    AddPops(tmpCity, 1);
			    }
			    if (escapees >0){
				    if (PlayerCityCount(THE_CITY_OWNER)){        
					    For (i=0; i<escapees; i=i+1){// scatter the escapees around the loser's empire
						    j = random(PlayerCityCount(THE_CITY_OWNER));
						    GetCityByIndex(THE_CITY_OWNER, j, tmpCity);
						    AddPops(tmpCity, 1);
					    }
				    }
			    }
			    if (IsHumanPlayer(THE_CITY_OWNER)){
				    AddCenter(tmpLoc); 
				    AddEffect(tmpLoc, "SPECEFFECT_FIRES", "SOUND_ID_EXPLOSION_LAND_1");
				    StartTimer(1,2);
                        if (escapees >0){
				         message(THE_CITY_OWNER,'CTC_OurEscapeeMessage');
	                   }
				    else{
				         message(THE_CITY_OWNER,'CTC_DemandRetaliationMessage');
				    }
			    }
			    else{
			         for (i=0; i<CTC_PLAYER_COUNT; i=i+1){
				         if (IsPlayerAlive(i)){  
						    if (IsHumanPlayer(i)){
							    message(i,'CTC_SavageMessage');
						    }
					    }
				    }
			    }
			    event:KillCity(city[0],0,player[0]); 
		    }
		    else {
		         for (i=0; i<CTC_PLAYER_COUNT; i=i+1){
			         if (IsPlayerAlive(i)){  
					    if (IsHumanPlayer(i)){
							message(i,'CTC_CityCapturedMessage');
					    }
				    } 
			    }   
		    }
	    }
    }
}

messagebox 'CTC_OurEscapeeMessage' {
    show();
    Text (ID_CTC_OurEscapeeMessageM) ;
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

messagebox 'CTC_DemandRetaliationMessage' {
    show();
    Text (ID_CTC_DemandRetaliationMessageM) ;
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

messagebox 'CTC_SavageMessage' {
    show();
    Text (ID_CTC_SavageMessageM) ;
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}
// "Sir, the savage {player[0].civ_name_plural} have captured the city of {city[0].name} and razed it to the ground."

messagebox 'CTC_CityCapturedMessage' {
    show();
    Text (ID_CTC_CityCapturedMessageM) ;
    Button(ID_BUTTON_CLOSE){
         Kill();
    }
}

MessageBox 'CTC_DisbandCitiesQ'{ 
    Show();     
    Text(ID_CTC_DisbandCitiesM);

    Button(ID_NO){
    
	    Kill(); 
    } 
    Button(ID_YES){

         int_t i;
	    int_t j;
         int_t refugees ; 
	    int_t escapees;
         int_t Pw;
	    int_t tmpDist;
	    int_t theDist;
	    int_t tmpPop;
         location_t tmpLoc;
         city_t tmpCity;


         FinishBuilding(city[0]);
         refugees=(50*city[0].population)/100; //compute our refugees 50%
         escapees= city[0].population-(refugees+2);//+2 for casualties
         tmpDist=999999;
	    if (PlayerCityCount(THE_CITY_OWNER)){        
		    For (i=0; i<escapees; i=i+1){// scatter the escapees around the loser's empire
			    j = random(PlayerCityCount(THE_CITY_OWNER));
			    GetCityByIndex(THE_CITY_OWNER, j, tmpCity);
			    AddPops(tmpCity, 1);
		    }
	    }
	    For (i=0; i<refugees; i=i+1){// scatter the refugees around our empire
		    j = random(PlayerCityCount(player[0])-1);
		    GetCityByIndex(player[0], j, tmpCity);
		    AddPops(tmpCity, 1);
	    }
	    AddGold(player[0], (city[0].population*100));
	    Pw = player[0].publicworkslevel + (city[0].population*75);
	    SetPW(player[0], Pw);
	    ChangeGlobalRegard(player[0], -20, ID_ABHORRENT, 3);		 
	    tmpLoc=city[0].location; 
	    AddEffect(tmpLoc, "SPECEFFECT_FIRES", "SOUND_ID_PILLAGE"); 
	    CTC_FIRE_LOC=tmpLoc;
	    StartTimer(1, 2); 
         EnableTrigger('CTC_FireAfterEffect');
	    tmpPop=city[0].population;
	    for (i=0; i<tmpPop; i=i+1){
		    Event: KillPop(city[0]);
	    }
	    Kill(); 
    } 
}


HandleEvent(TimerExpired) 'CTC_FireAfterEffect' post {

    if(value[0]==1){
         AddEffect(CTC_FIRE_LOC, "SPECEFFECT_EXPLOSION_LAND_1", "SOUND_ID_EXPLOSION_LAND_2");
    }
    DisableTrigger('CTC_FireAfterEffect');
}

 // INFRASTRUCTURE STUFF

HandleEvent(CityBeginTurn)'CTC_InfrastructureWorkaround' pre {
int_t cityPW;
int_t playerPW;

    if (IsBuildingAtHead(city[0])== BuildingDB(IMPROVE_QUEUE_INFRASTRUCTURE)) {      
	    cityPW=100000/city[0].buildingtime;	
	    player[0]=city[0].owner;
	    if (IsHumanPlayer(player[0])){
	         cityPW=(500*cityPW)/1000;
	    }   
         playerPW=player[0].publicworkslevel;
	    SetPW(player[0], playerPW+cityPW);
         Event:ZeroProduction(city[0]);
	    if(AtWarCount(player[0]) && !IsHumanPlayer(player[0]) ){ // if at war, stop AI queueing	       	     
	         ClearBuildQueue(city[0]);
         }
    }
}


HandleEvent(GrantAdvance)'CTC_InfrastructureKiller' post {
// whenever the player gets an advance, kill all infrastructure queueing

int_t i;
city_t tmpCity;

    if (value[0]!=AdvanceDB(ADVANCE_SUBNEURAL_ADS) && !IsHumanPlayer(player[0]) ){ //to prevent clash with GoodMod
	    For(i=0; i<player[0].cities; i=i+1){
		    GetCityByIndex(player[0],i,tmpCity);
		    if (IsBuildingAtHead(tmpCity)== BuildingDB(IMPROVE_QUEUE_INFRASTRUCTURE)){
			    ClearBuildQueue(tmpCity);
		    }
	    }
    }
}


//////////   Clear Those Forests and Make Farms on River Tiles
// Remember: for terraforming, the Event:CreateImprovement(...) presuposses that 
// the player has the required advance as defined in terrain.txt and the PW to pay
// for it
/////////////////

HandleEvent(MakePop)'CTC_ExpandingCityTileImprovement' post {

location_t theLoc;
location_t firstLoc;

int_t j;

    if (city[0].population >5 && !IsHumanPlayer(city[0].owner) ) {                      
         player[0]=city[0].owner;
         GetNeighbor(city[0].location, 0, firstLoc);//go north of the City
         for (j=0; j<=7 ; j=j+1) { //directions
              GetNeighbor(firstLoc, j, theLoc);//look around        
              if ( CellOwner(theLoc)==city[0].owner && HasGood(theLoc)==-1) {
	              if (TerrainType(theLoc)==TerrainDB(TERRAIN_FOREST) || TerrainType(theLoc)==TerrainDB(TERRAIN_JUNGLE) ) {
		         // 0=forest, 7=jungle
		              Event:CreateImprovement(city[0].owner,theLoc, TerrainImprovementDB(TILEIMP_TERRAFORM_PLAINS),0);
                        //change to plains 		       
                   }
			    if (TerrainType(theLoc)==TerrainDB(TERRAIN_GRASSLAND) || TerrainType(theLoc)==TerrainDB(TERRAIN_PLAINS) ) {
		              if (HasRiver(theLoc)){
				         if (TileHasImprovement(theLoc,TerrainImprovementDB(TILEIMP_ADVANCED_FARMS))){
                                  Event:CreateImprovement(city[0].owner,theLoc,TerrainImprovementDB(TILEIMP_HYDROPONIC_FARMS),0); 
				         }
					    elseif (TileHasImprovement(theLoc,TerrainImprovementDB(TILEIMP_FARMS))) {
					         Event:CreateImprovement(city[0].owner,theLoc,TerrainImprovementDB(TILEIMP_ADVANCED_FARMS),0);
					    }
					    else{
					         Event:CreateImprovement(city[0].owner,theLoc,TerrainImprovementDB(TILEIMP_FARMS),0);
					    }
				    }
			    }
              }
         }
	    GetNeighbor(city[0].location, 2, firstLoc);//go east of the City
         for (j=0; j<=7 ; j=j+1) { //directions
		    GetNeighbor(firstLoc, j, theLoc);//look around                    
		    if ( CellOwner(theLoc)==city[0].owner && HasGood(theLoc)==-1) {
			    if (TerrainType(theLoc)==TerrainDB(TERRAIN_FOREST) || TerrainType(theLoc)==TerrainDB(TERRAIN_JUNGLE) ) {
			    // 0=forest, 7=jungle
				    Event:CreateImprovement(city[0].owner,theLoc, TerrainImprovementDB(TILEIMP_TERRAFORM_PLAINS),0);
				    //change to plains 		       
			    }
			    if (TerrainType(theLoc)==TerrainDB(TERRAIN_GRASSLAND) || TerrainType(theLoc)==TerrainDB(TERRAIN_PLAINS) ) {
		              if (HasRiver(theLoc)){
				         if (TileHasImprovement(theLoc,TerrainImprovementDB(TILEIMP_ADVANCED_FARMS))){
                                  Event:CreateImprovement(city[0].owner,theLoc,TerrainImprovementDB(TILEIMP_HYDROPONIC_FARMS),0); 
				         }
					    elseif (TileHasImprovement(theLoc,TerrainImprovementDB(TILEIMP_FARMS))) {
					         Event:CreateImprovement(city[0].owner,theLoc,TerrainImprovementDB(TILEIMP_ADVANCED_FARMS),0);
					    }
					    else{
					         Event:CreateImprovement(city[0].owner,theLoc,TerrainImprovementDB(TILEIMP_FARMS),0);
					    }
				    }
			    }
		    }
	    }
	    GetNeighbor(city[0].location, 5, firstLoc);//go west of the City
	    for (j=0; j<=7 ; j=j+1) { //directions
		    GetNeighbor(firstLoc, j, theLoc);//look around                 
		    if ( CellOwner(theLoc)==city[0].owner && HasGood(theLoc)==-1) {
			    if (TerrainType(theLoc)==TerrainDB(TERRAIN_FOREST) || TerrainType(theLoc)==TerrainDB(TERRAIN_JUNGLE) ) {
			    // 0=forest, 7=jungle
				    Event:CreateImprovement(city[0].owner,theLoc, TerrainImprovementDB(TILEIMP_TERRAFORM_PLAINS),0);
				    //change to plains 
                   }
			    if (TerrainType(theLoc)==TerrainDB(TERRAIN_GRASSLAND) || TerrainType(theLoc)==TerrainDB(TERRAIN_PLAINS) ) {
		              if (HasRiver(theLoc)){
				         if (TileHasImprovement(theLoc,TerrainImprovementDB(TILEIMP_ADVANCED_FARMS))){
                                  Event:CreateImprovement(city[0].owner,theLoc,TerrainImprovementDB(TILEIMP_HYDROPONIC_FARMS),0); 
				         }
					    elseif (TileHasImprovement(theLoc,TerrainImprovementDB(TILEIMP_FARMS))) {
					         Event:CreateImprovement(city[0].owner,theLoc,TerrainImprovementDB(TILEIMP_ADVANCED_FARMS),0);
					    }
					    else{
					         Event:CreateImprovement(city[0].owner,theLoc,TerrainImprovementDB(TILEIMP_FARMS),0);
					    }
		              }
			    }
              }
         }
	    GetNeighbor(city[0].location, 7, firstLoc);//go south of the City
         for (j=0; j<=7 ; j=j+1) { //directions
              GetNeighbor(firstLoc, j, theLoc);//look around
              if ( CellOwner(theLoc)==city[0].owner && HasGood(theLoc)==-1) {
	              if (TerrainType(theLoc)==TerrainDB(TERRAIN_FOREST) || TerrainType(theLoc)==TerrainDB(TERRAIN_JUNGLE) ) {
		         // 0=forest, 7=jungle
		              Event:CreateImprovement(city[0].owner,theLoc, TerrainImprovementDB(TILEIMP_TERRAFORM_PLAINS),0);
                        //change to plains
                   }
			    if (TerrainType(theLoc)==TerrainDB(TERRAIN_GRASSLAND) || TerrainType(theLoc)==TerrainDB(TERRAIN_PLAINS) ) {
		              if (HasRiver(theLoc)){
				         if (TileHasImprovement(theLoc,TerrainImprovementDB(TILEIMP_ADVANCED_FARMS))){
                                  Event:CreateImprovement(city[0].owner,theLoc,TerrainImprovementDB(TILEIMP_HYDROPONIC_FARMS),0); 
				         }
					    elseif (TileHasImprovement(theLoc,TerrainImprovementDB(TILEIMP_FARMS))) {
					         Event:CreateImprovement(city[0].owner,theLoc,TerrainImprovementDB(TILEIMP_ADVANCED_FARMS),0);
					    }
					    else{
					         Event:CreateImprovement(city[0].owner,theLoc,TerrainImprovementDB(TILEIMP_FARMS),0);
					    }
		              }
			    }
              }     
         }
    }
}

HandleEvent(CreateCity)'CTC_New_City_Location_Fix' post { 
//for when the AI founds a city, possibly in a lousy location

// rem june 2003: this is old and not really necessary for CTC
location_t theLoc;
city_t tmpCity;
int_t i;
int_t CityOK;

//this preliminary stuff is for where the AI discovers a city in a goody hut that's
//too close to one of its existing cities.

    if (!IsHumanPlayer(player[0])) {
	    CityOK=0;
	    if (value[1]==-1) {// if it came from a goody hut
		    if (PlayerCityCount(player[0])==1) {// it was the first city
			    CityOK=1;
		    }
		    elseif (PlayerCityCount(player[0])>0) {
			    for(i=0; i<PlayerCityCount(player[0]); i=i+1){
				    GetCityByIndex(player[0], i, tmpCity);
				    if (tmpCity.location==location[0]) {// it's still here, it was legal		        
					    if (CTC_FindTheNearestCity(player[0].owner, location[0], 1) ){
						    if (Distance(location[0], CTC_THE_NEAREST_CITY.location)<7) {
						    //but it's in a lousy location, so
							    event:DisbandCity(tmpCity);    
						    }
						    else{
							    CityOK=1;
						    }
					    }
				    }
			    }
		    }
	    } 
	    elseif (CityIsValid(city[0])) {        
		    CityOK=1;
	    }   
	    if (CityOK==1) { 
		    for (i=0; i<=7 ; i=i+1) { //directions
			    GetNeighbor(city[0].location, i, theLoc);//look around
			    if ( CellOwner(theLoc)==city[0].owner) {
			         if (TerrainType(theLoc)==2 || TerrainType(theLoc)==3 )  { 
				    // 2=tundra, 3=glacier
				         Terraform(theLoc, 4);//change to grassland
				    }
				    if (HasGood(theLoc)==-1) {
					    if (TerrainType(theLoc)==0 || TerrainType(theLoc)==7 || TerrainType(theLoc)==5)  { 
					    // 0=forest, 7=jungle, 5=desert
						    Terraform(theLoc, 1);//change to plains 
					    }
					    if (TerrainType(theLoc)==18) { //brown (desert) hills
						    Terraform(theLoc, 9);//change to hills 
					    }				   
                        }
			    }
		    }
	    }
    }
}




///////////////////////////////////////////////
//
//    GEOGRAPHIC THREAT STATES (THREAT ARRAYS)
//
///////////////////////////////////////////////



HandleEvent(BeginTurn) 'CTC_CheckForCities' pre {

    int_t i;
    int_t CitiesDoneFlg;

    if (g.year>0){ 
	    CitiesDoneFlg=1;
	    for (i=1; i< CTC_PLAYER_COUNT ; i=i+1){
	    //make sure everyone in the game has cities
		    if (IsPlayerAlive(i)){
			    if (PlayerCityCount(i)==0) {
				    CitiesDoneFlg=0; // someone doesn't have any citys,
				    i=CTC_PLAYER_COUNT;
			    }
		    }
	    }
	    if(CitiesDoneFlg==1){
	         for (i=1;i<CTC_PLAYER_COUNT;i=i+1){ 
			    if (IsPlayerAlive(i)){ 
				    CTC_ComputeGeogThreats(i);
			    }
		    }
		    EnableTrigger('CTC_LoadDipStateCycles');
		    EnableTrigger('CTC_AI_GeogThreatStates');

		    EnableTrigger('CTC_Pre_Trigger_AI_Tactics');

		    EnableTrigger('CTC_CheckGeogArraysOnCapture');
		    EnableTrigger('CTC_CheckGeogArraysOnCreate');
		    EnableTrigger('CTC_CheckGeogArraysOnKill');

		    DisableTrigger('CTC_CheckForCities');
	    }
    }
}

HandleEvent(CaptureCity) 'CTC_CheckGeogArraysOnCapture' post {

    int_t i;

    for (i=0;i<CTC_PLAYER_COUNT;i=i+1){
         if (IsPlayerAlive(i)) {
	         if (PlayerCityCount(i) ){
			    CTC_ComputeGeogThreats(i);
		    }
         }
    }
}

HandleEvent(CreateCity) 'CTC_CheckGeogArraysOnCreate' post {

    int_t i;
    int_t tmpDist;

    for (i=0;i<CTC_PLAYER_COUNT;i=i+1){
         if (IsPlayerAlive(i)) {   
		    if (i != city[0].owner && PlayerCityCount(i)){
			    tmpDist=CTC_GetCloseness(i,city[0].owner);
			    CTC_GetLaunchCity(city[0].owner,i);
			    CTC_GetTargetCity(city[0].owner,i);
			    if (distance(CTC_THE_LAUNCH_CITY.location,CTC_THE_TARGET_CITY.location)<tmpDist){
				    CTC_ComputeGeogThreats(i);
			    }
		    }
         }
    }
}

HandleEvent(KillCity) 'CTC_CheckGeogArraysOnKill' post {

    int_t i;

    for (i=0;i<CTC_PLAYER_COUNT;i=i+1){
         if (IsPlayerAlive(i)) {         
		    if (PlayerCityCount(i) ){
		         if (PlayerCityCount(i) ){
				    CTC_ComputeGeogThreats(i);
			    }
		    }
         }
    }
}

HandleEvent(BeginTurn) 'CTC_CheckGeogArraysAfterSurrender' post {

    int_t i;

    for (i=1;i<CTC_PLAYER_COUNT;i=i+1){
         if (IsPlayerAlive(i)) {  
		    if (PlayerCityCount(i) ){
			    CTC_ComputeGeogThreats(i);
		    }
         }
    }
    DisableTrigger('CTC_CheckGeogArraysAfterSurrender');
}

////////////////////////////////////////////////////////////////
///
///     GEOG THREATS and STRATEGIES
///
////////////////////////////////////////////////////////////////

void_f ClearSpecialsFromBuildLists (int_t thePlayer){

    int_t  i;
    int_t  indexChk;
    city_t tmpCity;
    unit_t tmpUnit;


    for (i=0;i<PlayerCityCount(thePlayer);i=i+1){
         GetCityByIndex(thePlayer,i,tmpCity);
	    value[0]=IsUnitAtHead(tmpCity);        
	    if (-1<value[0]){
	         if (unitDB(value[0].value).powerpoints==0){                 
		         indexChk=value[0];
			    KillUnitFromBuildList(tmpCity,indexChk);
	         }
	    }     
    }
}

HandleEvent(NextStrategicState) 'CTC_Human_War_States' pre {//for mayors

    if (IsHumanPlayer(player[0])){
         if (AtWarCount(player[0]) ){// when at war with anybody always default to military plus more OFFENSE and DEFENSE
	         ConsiderStrategicState(player[0],2550,StrategyDB(STRATEGY_WAR_BUILDLISTS_MED),-1,-1,-1);
		    if (AtWarCount(player[0])>1){//if in trouble, no more specials and really prioritize units
		        ConsiderStrategicState(player[0],2650,StrategyDB(STRATEGY_WAR_BUILDLISTS_HIGH),-1,-1,-1); 
		    }
         }
    }
}


// note: remember that the unit building strats have priority 3500

HandleEvent(NextStrategicState) 'CTC_AI_GeogThreatStates' pre {
    int_t i;
    int_t j;
    int_t triggerAttack;
    int_t HumanTarget;
    int_t GeogThreat;

    int_t numArmies;
    int_t minCity;
    city_t tmpCity;

    if ( !IsHumanPlayer(player[0]) && player[0].owner>0){
         if (player[0].publicworkslevel >20000){
              ConsiderStrategicState(player[0],2500,StrategyDB(STRATEGY_LOTS_MORE_TILE_IMPROVEMENTS),-1,-1,-1);
	    }
	    elseif (player[0].publicworkslevel >10000) {
	         ConsiderStrategicState(player[0],2500,StrategyDB(STRATEGY_MORE_TILE_IMPROVEMENTS),-1,-1,-1);
	    }
	    // default BuildSettlerProductionLevel 0.50
         if (80<g.year && g.year<225){
	         minCity=999;
		    for (i=0;i<player[0].cities;i=i+1){
		         GetCityByIndex(player[0].owner,i,tmpCity);
			    if (tmpCity.population < minCity){
			         minCity=tmpCity.population;
			    } 
		    }
		    if (minCity > 6){ // here BuildSettlerProductionLevel 0.20
                    ConsiderStrategicState(player[0],2600,StrategyDB(STRATEGY_KEEP_SETTLING),-1,-1,-1);
		    }
	    }


// WAR GOALS & BUILDLISTS:

         if (AtWarCount(player[0]) ){// when at war with anybody always default to military plus more OFFENSE and DEFENSE

// only prioritizing SEIGE goals, what about the others?

              ConsiderStrategicState(player[0],2600,StrategyDB(STRATEGY_SEIGE),-1,-1,-1);
              ConsiderStrategicState(player[0],2550,StrategyDB(STRATEGY_WAR_BUILDLISTS_MED),-1,-1,-1);	
	         
// should only need to do this once: so it could be a handler, not a function ?

		    ClearSpecialsFromBuildLists(player[0]);      
		    if (AtWarCount(player[0])>1){
		        //if in trouble, no more specials or settlers, and really prioritize units
		        ConsiderStrategicState(player[0],2650,StrategyDB(STRATEGY_WAR_BUILDLISTS_HIGH),-1,-1,-1); 
		    }
		    else{//when at war with one opponant

//maybe sooner: start with catapults and increase frequency with bombard effectiveness?

			    if (HasAdvance(player[0],ID_ADVANCE_AERODYNAMICS)){
			         if (random(2)<1){
				         ConsiderStrategicState(player[0],2650,StrategyDB(STRATEGY_BOMBARD),-1,-1,-1);  
			         }
			    } 
			    for (i=1;i<CTC_PLAYER_COUNT;i=i+1){
			         if (IsPLayerAlive(i)){
				         if (AtWarWith(player[0],i)){
					         player[1]=i;
						    i=CTC_PLAYER_COUNT;
					    }
				    }
			    }
			    if (IsHumanPlayer(player[1])){
                        ConsiderStrategicState(player[0],2650,StrategyDB(STRATEGY_FEW_SETTLERS),-1,-1,-1);  
			         ConsiderStrategicState(player[0],2650,StrategyDB(STRATEGY_WAR_DISPOSITIONS),-1,-1,-1);     
				    if (player[0].militaryunits < player[1].militaryunits){
			        
			              //if he's human and stronger, no more specials, few settlers, and really prioritize units
					         
				         ConsiderStrategicState(player[0],2650,StrategyDB(STRATEGY_WAR_BUILDLISTS_HIGH),-1,-1,-1);  
			         }
			    }
			    if ( 15*player[1].militaryunits < 10*player[0].militaryunits ) {
			    // if we're winning, don't forget development
				    ConsiderStrategicState(player[0],2700,StrategyDB(STRATEGY_WAR_BUILDLISTS_LOW),-1,-1,-1); 
			    }
			    if (player[1].cities > 2*player[0].cities){
			    // if he's strong, build more units
			         ConsiderStrategicState(player[0],2700,StrategyDB(STRATEGY_MORE_UNITS),-1,-1,-1); 
			    }
		    }
	    } 

// GET THE FIRST THREATENING HUMAN:
	    
	    HumanTarget=CTC_IsThreatenedByAHuman(player[0].owner,0,CTC_AI_FEAR_RADIUS+1);
	    //is there a Human who poses 1<= Geog Threat level <=CTC_AI_FEAR_RADIUS? (=initially 1)

         if (HumanTarget){
              if (!AtWarWith(player[0],HumanTarget)){

			    GeogThreat=CTC_GetGeogThreat(player[0].owner, HumanTarget);

			    // high threat stuff
			    if (GeogThreat <= CTC_AI_FEAR_RADIUS){

				    //use BUILD_LIST_SEQUENCE_DEFAULT_MIL plus more OFFENSE and DEFENSE
				    ConsiderStrategicState(player[0],2500,StrategyDB(STRATEGY_PREPARE_FOR_WAR),-1,-1,-1);
			    }

			    //=> this will eventually put all AI civs who don't like their Human neighbour 
			    //on BUILD_LIST_SEQUENCE_DEFAULT_MIL plus more OFFENSE and DEFENSE
			    // diplomatically, they're open to negotiations
			    elseif ( GeogThreat == CTC_AI_FEAR_RADIUS+1 
			    && GetEffectiveRegard(player[0],HumanTarget)<275){
				    ConsiderStrategicState(player[0],2500,StrategyDB(STRATEGY_PREPARE_FOR_WAR),-1,-1,-1);
			    }
			    // else default personality strategy
	 
			    if (GeogThreat < CTC_AI_FEAR_RADIUS+2){
				    if (g.year<150){// exploration stuff (find the enemy)
					    if (AtWarCount(player[0])==0){
						    ConsiderStrategicState(player[0],2500,StrategyDB(STRATEGY_EXPLORE_WIDE),-1,-1,-1);    
					    }
					    else{// at war but not with human target
						    ConsiderStrategicState(player[0],2500,StrategyDB(STRATEGY_EXPLORE_FAR),-1,-1,-1);
					    }
				    }

				    // preemptive attack stuff

// on higher difficulty levels give the human a bit more time to get established

                        int_t startYearforPreAtt;
                        if (preference("Difficulty")>2){
				         startYearforPreAtt=80 + (preference("Difficulty")*preference("Difficulty")); 
                        }
				    else{
				         startYearforPreAtt=80;
				    }
				    if (g.year>startYearforPreAtt){
				   
					    triggerAttack=0;
					    if (AtWarCount(HumanTarget)==0){
						    triggerAttack=1;
					    }
					    elseif (AtWarCount(HumanTarget)<=CTC_AI_FEAR_RADIUS) {
						    if (MilitaryRank(HumanTarget)==100 
						    || CitiesRank(HumanTarget)==100
						    || PopulationRank(HumanTarget)==100){
							    triggerAttack=1;
						    }
						    // science rank ?
						    if (AtWarCount(HumanTarget)==1){//in case of stagnation
							    for (i=1;i<CTC_PLAYER_COUNT;i=i+1){
								    if (IsPlayerAlive(i)){
									    if (AtWarWith(HumanTarget,i)){
										    player[1]=i;
										    i=CTC_PLAYER_COUNT;
									    }
								    }
							    }
							    if (GetLastHotWarAttack(player[1],HumanTarget)>15 || GetLastHotWarAttack(HumanTarget,player[1])>15){
								    LogRegardEvent(player[0],HumanTarget,-25,2,ID_RICH_PICKINGS,0);  
								    triggerAttack=1;
							    }
						    }
						    
					    }
					    if (triggerAttack){   
					    //if he's not at war or he's  strong or there's no fighting

						    if (g.year>150){
							    player[1]=HumanTarget;
							    if (player[0].militaryunits<player[1].militaryunits){
								    LogRegardEvent(player[0],player[1],-15,3,ID_FEEL_THREATENED,0);
							    }
							    else{
								    LogRegardEvent(player[0],player[1],-15,2,ID_RICH_PICKINGS,0); 
							    }
						    }
						    if (GetEffectiveRegard(player[0],HumanTarget)<150){// trigger preemptive attack			    
							    if (HasAgreement(HumanTarget,player[0],4)){//AI agreed not to tresspass on Human
								    CancelAgreement(HumanTarget,player[0],4); 
								    LogRegardEvent(player[0],HumanTarget,-20,2,ID_SOFT_TARGET,0);
							    }
							    if (HasAgreement(player[0],HumanTarget,32)){
								    CancelAgreement(player[0],HumanTarget,32); 
								    LogRegardEvent(player[0],HumanTarget,-20,2,ID_SOFT_TARGET,0);
							    }
							    if (HasAgreement(player[0],HumanTarget,33)){
								    CancelAgreement(player[0],HumanTarget,33);
								    LogRegardEvent(player[0],HumanTarget,-20,2,ID_SOFT_TARGET,0);
							    }
							    if (GeogThreat == CTC_AI_FEAR_RADIUS && 1<CTC_AI_FEAR_RADIUS && AtWarCount(HumanTarget)> CTC_AI_FEAR_RADIUS-1){
								    //do nothing more, give him a break
							    }
							    else{// so GeogThreat < CTC_AI_FEAR_RADIUS
							         LogRegardEvent(player[0],HumanTarget,-15,2,ID_SOFT_TARGET,0);
								    ConsiderStrategicState(player[0],2700,StrategyDB(STRATEGY_PREEMPTIVE_ATTACK),-1,-1,-1);   
								    for (j=1;j<CTC_PLAYER_COUNT;j=j+1){//focus on the above human (nec when at war?)
									    if (IsPlayerAlive(j)){
										    if (j != HumanTarget && !IsHumanPlayer(j)){
											    LogRegardEvent(player[0],j,50,0,ID_NONE,0);
										    }
									    }
								    }
							    }
						    }
					    }
				    }
			    }
		    }
         }
         if (g.year==50){
		    EnableMessageClass(71002);//start warning about wonders
         }
	    if (g.year>160 && AtWarCount(player[0])==0 ){ //in any case
	         ConsiderStrategicState(player[0],2500,StrategyDB(STRATEGY_PRIORITIZE_WONDERS),-1,-1,-1);
         }
    }
}

HandleEvent(NextDiplomaticState) 'CTC_LoadDipStateCycles' pre {

    int_t GeogThreatVal_01;
    int_t GeogThreatVal_10;

    if ( !IsHumanPlayer(player[0]) ){       
         GeogThreatVal_01=CTC_GetGeogThreat(player[0].owner,player[1].owner);
	    GeogThreatVal_10=CTC_GetGeogThreat(player[1].owner,player[0].owner);
         if (IsHumanPlayer(player[1])) {  //AI to Human stuff          
              if ( AtWarWith(player[0],player[1])) {//if at war with a human
		         if (GeogThreatVal_01 <= CTC_AI_FEAR_RADIUS){
				    if (GeogThreatVal_01 == CTC_AI_FEAR_RADIUS){ 
				         if (AtWarCount(player[1]) > CTC_AI_FEAR_RADIUS+1) {//give him a break
					         ConsiderDiplomaticState(player[0],player[1],3000,diplomacyDB(DIPLOMACY_DEFAULT),-1,-1,-1); 
// maybe adjust regard and trust here 
					    }
					    else{
					         ConsiderDiplomaticState(player[0],player[1],3000,diplomacyDB(DIPLOMACY_STAY_AT_WAR),-1,-1,-1); 
					    }
				    }
				    else{//otherwise it's a vendetta
					    ConsiderDiplomaticState(player[0],player[1],3000,diplomacyDB(DIPLOMACY_STAY_AT_WAR),-1,-1,-1); 
				    }
			    }
			    else{//usually out of range: try to counter the game system
                        if (( GeogThreatVal_01 > CTC_AI_FEAR_RADIUS+1 && GetLastHotWarAttack(player[0],player[1])>10) 
				    || (GetLastHotWarAttack(player[0],player[1])>20 && GetLastHotWarAttack(player[1],player[0])>20)){
	                        LogRegardEvent(player[0],player[1], 200, 0, ID_TOO_FAR_WAY, 0);
				         SetTrust(player[0],player[1], 500);
				         ConsiderDiplomaticState(player[0],player[1],9999,diplomacyDB(DIPLOMACY_DEFAULT),-1,-1,-1); 
				    }
			    }
		    }
		    if (GeogThreatVal_01 <= CTC_AI_FEAR_RADIUS) {// high threat

// give more time here ?

			    if (g.year<50){
				    ConsiderDiplomaticState(player[0],player[1],2000,diplomacyDB(DIPLOMACY_DEFAULT),-1,-1,-1); 
			    }
			    elseif(AtWarCount(player[1])<CTC_AI_FEAR_RADIUS){
			         if (player[1]==CTC_GetScienceLeader()){  //6=knowledge event
		                   LogRegardEvent(player[0],player[1], -2, 6, ID_SCIENCE_LEAD, 0);
				    }
				    if (player[1]==CTC_GetMilitaryLeader()){ //2=military power event   
					    LogRegardEvent(player[0],player[1], -5, 2, ID_MILITARY_LEAD, 0);
				    }
				    if (player[1]==CTC_GetPopulationLeader()){//3=military safety event?
					    LogRegardEvent(player[0],player[1], -3, 3, ID_POP_LEAD, 0);
				    }
				    if (player[1]==CTC_GetGeographicLeader()){
					    LogRegardEvent(player[0],player[1], -3, 3, ID_GEOG_LEAD, 0);
				    }
				    if (player[1]==CTC_GetCitiesLeader()){        
					    LogRegardEvent(player[0],player[1], -3, 3, ID_CITY_LEAD, 0);
				    }
			         if (!AtWarWith(player[0],player[1])){
					    if (GeogThreatVal_10==1){//if mutual threat put in additional regard hit
						    LogRegardEvent(player[0],player[1],-5,0,ID_RICH_PICKINGS,0); 
					    }
					    if (HasAgreement(player[0],player[1],32)){// nullify ceasefire
						    LogRegardEvent(player[0],player[1],-20,0,ID_NO_CEASEFIRE,0); 
					    }
					    if (HasAgreement(player[0],player[1],33)){// nullify peace treaty
						    LogRegardEvent(player[0],player[1],-40,0,ID_NO_PEACE,0); 
					    }
					    if (player[0].militaryunits<player[1].militaryunits){
						    LogRegardEvent(player[0],player[1],-15,3,ID_FEEL_THREATENED,0);
					    }
					    else{
						    LogRegardEvent(player[0],player[1],-15,0,ID_RICH_PICKINGS,0); 
					    }
					    ConsiderDiplomaticState(player[0],player[1],2000,diplomacyDB(DIPLOMACY_PROVOKE_WAR),-1,-1,-1);
			         }
				    // else the game looks after the dip state
			    }
			    // give the Human a chance to prevent a pre-emptive attack but don't be too friendly
			    elseif (AtWarCount(player[1])> CTC_AI_FEAR_RADIUS){
				    if (GetEffectiveRegard(player[0],player[1])<275){
					    LogRegardEvent(player[0],player[1],20,4,ID_BRIBERY,0); // 4=diplomacy event?
				    }
				    elseif (GetEffectiveRegard(player[0],player[1])>375){
					    LogRegardEvent(player[0],player[1],-20,4,ID_BRIBERY,0); // 4=diplomacy event?  
				    }
				    ConsiderDiplomaticState(player[0],player[1],2100,diplomacyDB(DIPLOMACY_OPEN_TO_NEGOTIATION),-1,-1,-1);  
			    }
			    else{
                        ConsiderDiplomaticState(player[0],player[1],2000,diplomacyDB(DIPLOMACY_DEFAULT),-1,-1,-1);
			    }
		    }
		    elseif (GeogThreatVal_01 == CTC_AI_FEAR_RADIUS+1) {// medium threat
			    if (g.year<100){
				    ConsiderDiplomaticState(player[0],player[1],2000,diplomacyDB(DIPLOMACY_DEFAULT),-1,-1,-1);
			    }
			    else{// get ready for pre-emptive attack
				    if ( AtWarCount(player[1])<CTC_AI_FEAR_RADIUS && !AtWarWith(player[0],player[1]) ){
				         if (player[0].militaryunits<player[1].militaryunits){
						    LogRegardEvent(player[0],player[1],-15,3,ID_FEEL_THREATENED,0);
					    }
					    else{
						    LogRegardEvent(player[0],player[1],-15,0,ID_RICH_PICKINGS,0); 
					    }
					    if (HasAgreement(player[0],player[1],32)){// nullify ceasefire
						    LogRegardEvent(player[0],player[1],-20,3,ID_NO_CEASEFIRE,0); 
					    }
					    if (HasAgreement(player[0],player[1],33)){// nullify peace treaty
						    LogRegardEvent(player[0],player[1],-40,3,ID_NO_PEACE,0); 
					    }
                             ConsiderDiplomaticState(player[0],player[1],2100,diplomacyDB(DIPLOMACY_PROVOKE_WAR),-1,-1,-1);	
				    }			    
				    if (player[1]==CTC_GetScienceLeader()) {
					    LogRegardEvent(player[0],player[1], -2, 6, ID_SCIENCE_LEAD, 0);		    
				    }
				    if (player[1]==CTC_GetMilitaryLeader()) {
					    LogRegardEvent(player[0],player[1], -5, 2, ID_MILITARY_LEAD, 0);
				    }
				    if (player[1]==CTC_GetPopulationLeader()) {
					    LogRegardEvent(player[0],player[1], -4, 3, ID_POP_LEAD, 0);
				    }
				    if (player[1]==CTC_GetGeographicLeader()) {
					    LogRegardEvent(player[0],player[1], -3, 3, ID_GEOG_LEAD, 0);
				    }
				    if (player[1]==CTC_GetCitiesLeader()) {
					    LogRegardEvent(player[0],player[1], -2, 3, ID_CITY_LEAD, 0);
				    }	    
				    ConsiderDiplomaticState(player[0],player[1],2000,diplomacyDB(DIPLOMACY_OPEN_TO_NEGOTIATION),-1,-1,-1);
			    }
		    }
		    else{//low threat
			    ConsiderDiplomaticState(player[0],player[1],2000,diplomacyDB(DIPLOMACY_MAKE_FRIEND),-1,-1,-1);         
		    }
         } 

         else{  //if (!IsHumanPlayer(player[1])) {
  
	    //=> base states

              if (GeogThreatVal_01==1 && GeogThreatVal_10<=2) {               
	              ConsiderDiplomaticState(player[0],player[1],2000,diplomacyDB(DIPLOMACY_PROVOKE_WAR),-1,-1,-1);
	         }
		    elseif (GeogThreatVal_01<=4) {
	              ConsiderDiplomaticState(player[0],player[1],2000,diplomacyDB(DIPLOMACY_DEFAULT),-1,-1,-1);
	         }
	         else{
		         ConsiderDiplomaticState(player[0],player[1],2000,diplomacyDB(DIPLOMACY_MAKE_FRIEND),-1,-1,-1);
		    }
         
	    //=> special states
              
		    
		    if (player[1].cities>3){
                   
			    // if either player is at war with or threatened by a human, make friends
			    if (CTC_IsThreatenedByAHuman(player[1],0,3) 
			    || CTC_IsAtWarWithHuman(player[1]) ){
			         if (AtWarWith(player[0],player[1])){
                             EnableTrigger('CTC_StopAttackingThreatenedPlayer');  
			         }                     
				    ConsiderDiplomaticState(player[0],player[1],3000,diplomacyDB(DIPLOMACY_MAKE_FRIEND),-1,-1,-1);
				    LogRegardEvent(player[0],player[1],60,0,ID_NONE,0);
			    }
			    elseif (CTC_IsThreatenedByAHuman(player[0],0,3)
			    || CTC_IsAtWarWithHuman(player[0]) ){
                        if (AtWarWith(player[0],player[1])){
                             EnableTrigger('CTC_StopThreatenedPlayerFromAttacking');   
			         }                     
				    ConsiderDiplomaticState(player[0],player[1],3000,diplomacyDB(DIPLOMACY_MAKE_FRIEND),-1,-1,-1);
				    LogRegardEvent(player[0],player[1],60,0,ID_NONE,0);
			    }
		    }
		    else{//crush the weaklings: induce war
		         if (g.year > 120){
                        LogRegardEvent(player[0],player[1],-60,0,ID_NONE,0); 
		         }
		    }
	    }
    }
}

HandleEvent(NextDiplomaticState) 'CTC_AtWarWithHumanIntell' post {// regard hits too excessive?

int_t perType;

    if ( !IsHumanPlayer(player[0]) && IsHumanPlayer(player[1]) && AtWarWith(player[0],player[1])){
         perType=GetPersonalityType(player[0]);
	    if (random(99)<2){
	         LogRegardEvent(player[0],player[1],-55,1,ID_AT_WAR_BANANAS,0);
	    }
	    elseif (perType==PersonalityDB(PERSONALITY_GHANDI)){
	         LogRegardEvent(player[0],player[1],-50,1,ID_AT_WAR_DIPLOMAT,0);    
	    }
         elseif (perType==PersonalityDB(PERSONALITY_STALIN) || perType==PersonalityDB(PERSONALITY_CEASAR) || perType==PersonalityDB(PERSONALITY_DEGAULLE)){
              LogRegardEvent(player[0],player[1],-50,1,ID_AT_WAR_MILITARIST,0);
	    }
         elseif (perType==PersonalityDB(PERSONALITY_MEDICI) ){
              LogRegardEvent(player[0],player[1],-50,1,ID_AT_WAR_ECONOMIST,0);
	    }
	    elseif (perType==PersonalityDB(PERSONALITY_TELLER) || perType==PersonalityDB(PERSONALITY_STRANGELOVE)){
              LogRegardEvent(player[0],player[1],-50,1,ID_AT_WAR_ECOTOPIAN,0);
	    }
	    elseif (perType==PersonalityDB(PERSONALITY_CALLENBACH) || perType==PersonalityDB(PERSONALITY_NADER) ){
              LogRegardEvent(player[0],player[1],-50,1,ID_AT_WAR_SCIENTIST,0);
	    }
    }
}

HandleEvent(NextDiplomaticState)'CTC_AI_to_AI_Proposal_Generator' pre {

int_t GeogThreatVal_01;
int_t GeogThreatVal_10;
int_t regardBoost;

    GeogThreatVal_01=CTC_GetGeogThreat(player[0].owner,player[1].owner);
    GeogThreatVal_10=CTC_GetGeogThreat(player[1].owner,player[0].owner);
    if (!IsHumanPlayer(player[0]) && 0<player[0].owner && !IsHumanPlayer(player[1])) {

         // offer cease fire (localize AI-AI wars)
         if (AtWarWith(player[0],player[1]) ){
	         if (GeogThreatVal_01 >2 
		    || GeogThreatVal_10 >2 
		    || AtWarCount(player[0])>1
		    || CTC_IsThreatenedByAHuman(player[0],0,3)  //special case: focus AI aggression
		    || CTC_IsAtWarWithHuman(player[0])          //special case: focus AI aggression
		       ) {
		         regardBoost=60;
			    if (GetEffectiveRegard(player[1],player[0]) < 600){
				    regardBoost=600-GetEffectiveRegard(player[1],player[0]);
			    }
			    LogRegardEvent(player[1],player[0], regardBoost, 0, ID_NONE, 0);
			    SetTrust(player[1],player[0], 500);
	              ConsiderNewProposal(player[0],player[1], 2500,32,0,ID_NONE,ID_NONE,ID_NONE); 			    
	              Event:NewProposal(player[0],player[1]);
              }
	    }

         //exchange maps 
         if (!AtWarWith(player[0],player[1]) 
	       && g.year >80
	       && (GetAgreementDuration(player[0],player[1],23)>20 || GetAgreementDuration(player[0],player[1],23)==-1) ){
  
		    ConsiderNewProposal(player[0],player[1], 2550,23,0,ID_NONE,ID_NONE,ID_NONE); 
		    Event:NewProposal(player[0],player[1]);
	    }
    }
}

HandleEvent(NextDiplomaticState) 'CTC_AI_to_AI_Establish_Embassy' pre {
//start this when there's only two AI players left  

    int_t AI_playercount;
    int_t i;

    AI_playercount=0;
    if (!IsHumanPlayer(player[0]) && 0<player[0].owner && !IsHumanPlayer(player[1])){
         for (i=1;i<CTC_PLAYER_COUNT;i=i+1){
	         if (IsPlayerAlive(i)){
		         if (!IsHumanPlayer(i)){
			         AI_playercount=AI_playercount+1;
		         }
	         }
         }
         if (AI_playercount == 2){
		    Event:EstablishEmbassy(player[0],player[1]);
		    Event:EstablishEmbassy(player[1],player[0]);
		    DisableTrigger('CTC_AI_to_AI_Establish_Embassy');
              EnableTrigger('CTC_AI_to_AI_Two_Players');
	    }
	    else{
              DisableTrigger('CTC_AI_to_AI_Establish_Embassy');
	    }
    }
}

HandleEvent(NextDiplomaticState) 'CTC_AI_to_AI_Two_Players' pre {
    
    if (!IsHumanPlayer(player[0]) && 0<player[0].owner && !IsHumanPlayer(player[1])) {

         if (!HasAgreement(player[0], player[1],33) ) {//peace treaty
              
		    LogRegardEvent(player[0],player[1], 400, 0, ID_NONE, 0);
	         SetTrust(player[0],player[1], 900);
		    
		    ConsiderNewProposal(player[0],player[1], 2750,33,0,ID_NONE,ID_NONE,ID_NONE); 
              Event:NewProposal(player[0],player[1]);
	    }
         if (!HasAgreement(player[0], player[1],35) ) {//research pact
              ConsiderNewProposal(player[0],player[1], 2700,35,0,ID_NONE,ID_NONE,ID_NONE); 
              Event:NewProposal(player[0],player[1]);
	    }
    }
}

HandleEvent(NewProposal) 'CTC_AI_Responses_to_AI_Proposals' pre {
// player[0] is sender
// player[1] is receiver

int_t first_type; //initial proposal

    first_type = GetLastNewProposalType(player[0], player[1], 0);

 //player[0] and player[1] reversed in ConsiderResponse
    if(!IsHumanPlayer(player[0]) && !IsHumanPlayer(player[1]) ) {
         
         if (first_type==23) {//WHENEVER an AI civ requests a map
              ConsiderResponse(player[1], player[0], 3250, 2);//2=accept
		    event:Accept(player[1], player[0]);
	    }
	    if (first_type==32) {//WHENEVER an AI civ offers a cease fire to another
	         ConsiderResponse(player[1], player[0], 3500, 2);//2=accept
		    event:Accept(player[1], player[0]);
	    }
         if (first_type==33) {//WHENEVER an AI civ offers a peace treaty to another
	         ConsiderResponse(player[1], player[0], 3500, 2);//2=accept
		    event:Accept(player[1], player[0]);
	    }
         if (first_type==35) {//WHENEVER an AI civ offers a research pact
              ConsiderResponse(player[1], player[0], 3250, 2);//2=accept
		    event:Accept(player[1], player[0]);
	    }
    }
}

HandleEvent(NewProposal) 'CTC_AI_Response_to_HumanCeasefire' pre {
// player[0] is sender
// player[1] is receiver

int_t first_type; //initial proposal

    first_type = GetLastNewProposalType(player[0], player[1], 0);

    if(IsHumanPlayer(player[0]) && !IsHumanPlayer(player[1]) ) {  
	    if (first_type==32) {// cease fire: if they're out of range or there's been no fighting
              if (CTC_GetGeogThreat(player[1].owner,player[0].owner)>CTC_AI_FEAR_RADIUS+1
		    || (GetLastHotWarAttack(player[0],player[1])>20 && GetLastHotWarAttack(player[1],player[0])>20)){		
				ConsiderResponse(player[0], player[1], 3500, 2);//2=accept
      	    }
	    }
    }
}

HandleEvent(KillPlayer) 'CTC_IncrementFearRadius' pre {

    if (IsHumanPlayer(player[1])){
         CTC_AI_FEAR_RADIUS=CTC_AI_FEAR_RADIUS+1;
         EnableTrigger('CTC_AI_to_AI_Establish_Embassy');//not the best place for this
    }
}


HandleEvent(GrantAdvance)'CTC_ShowAdvance'post{
    if(IsHumanPlayer(player[0])){
         if (value[0]==AdvanceDB(ADVANCE_FEUDALISM) || value[0]==AdvanceDB(ADVANCE_INDUSTRIAL_REVOLUTION) ){
              LibraryAdvance(value[0]);
	    }
    }
}

HandleEvent(GrantAdvance) 'CTC_PlayerGetsGovtAdvance' pre {

    if (IsHumanPlayer(player[0])){
         if (value[0]==AdvanceDB(ADVANCE_PHILOSOPHY)){
	         DisableMessageClass(90203);
		    message(player[0],'PlayerGotPhilosophy');
         }
	    elseif(value[0]==AdvanceDB(ADVANCE_BUREAUCRACY)) {
		    EnableMessageClass(90203);
	    }
	    elseif (value[0]==AdvanceDB(ADVANCE_THEOLOGY)) {
	         DisableMessageClass(90203);
		    message(player[0],'PlayerGotTheology');
	    }
	    elseif(value[0]==AdvanceDB(ADVANCE_NATIONALISM) || value[0]==AdvanceDB(ADVANCE_INDUSTRIAL_REVOLUTION)) {
		    EnableMessageClass(90203);
	    }
         elseif (value[0]==AdvanceDB(ADVANCE_GLOBAL_COMMUNICATIONS)) {
	         DisableMessageClass(90203);
		    message(player[0],'PlayerGotGlobComm');
	    }
    }    
}

messagebox 'PlayerGotPhilosophy' {
    
	Show();
	Text(ID_PLAYER_DISCOVERS_PHILOSOPHY);
	MessageType("CIVILIZATION");

	Button(ID_BUTTON_NOT_NOW) {
		Kill();
	}
	Button(ID_BUTTON_C_DEM) {
		SetGovernment(GovernmentDB(GOVERNMENT_CLASSICAL_DEMOCRACY));
		Kill();
	}
	Button(ID_BUTTON_OLIGARCHY) {
		SetGovernment(GovernmentDB(GOVERNMENT_OLIGARCHY));
		Kill();
	}
	Button(ID_BUTTON_MONARCHY) {
		SetGovernment(GovernmentDB(GOVERNMENT_MONARCHY));
		Kill();
	}
     // out of button space
}

messagebox 'PlayerGotTheology' {
    
	Show();
	Text(ID_PLAYER_DISCOVERS_THEOLOGY);
	MessageType("CIVILIZATION");

	Button(ID_BUTTON_NOT_NOW) {
		Kill();
	}
	Button(ID_BUTTON_THEOCRACY) {
		SetGovernment(GovernmentDB(GOVERNMENT_THEOCRACY));
		Kill();
	}
	Button(ID_BUTTON_THEO_EMP) {
		SetGovernment(GovernmentDB(GOVERNMENT_THEOCRATIC_EMPIRE));
		Kill();
	}
	Button(ID_BUTTON_DONT_SHOW_AGAIN){
	    DisableMessageClass(90203);
	    Kill();
    }
}

messagebox 'PlayerGotGlobComm' {
    
	Show();
	Text(ID_PLAYER_DISCOVERS_GLOBAL_COMMUNICATIONS);
	MessageType("CIVILIZATION");

	Button(ID_BUTTON_NOT_NOW) {
		Kill();
	}
	Button(ID_BUTTON_ECO_FUNDAMENTALISM) {
		SetGovernment(GovernmentDB(GOVERNMENT_ECO_FUNDAMENTALISM));
		Kill();
	}
	Button(ID_BUTTON_GLOBAL_CORPORATISM) {
		SetGovernment(GovernmentDB(GOVERNMENT_GLOBAL_CORPORATISM));
		Kill();
	}
	Button(ID_BUTTON_TECHNOCRACY) {
		SetGovernment(GovernmentDB(GOVERNMENT_TECHNOCRACY));
		Kill();
	}
}

// try to prevent the AI from settling on owned land (no contact) at start
// and for rest of game

HandleEvent(SettleOrder) 'CTC_PreventCrowding' pre {

    int_t locOwner;
    int_t locBad;
   
    if (!IsHumanPlayer(army[0].owner)){
	    locOwner=CellOwner(army[0].location);
	    locBad=1;
	    if (locOwner == -1 || locOwner == army[0].owner){
		    locBad=0;
	    }
	    if (locBad){
		    return Stop;
	    }
    }
}

//////////////////////////////////////////////////
// MAKE CONTACT WITH THE FIRST THREATENING HUMAN:
//////////////////////////////////////////////////

HandleEvent(BeginTurn) 'CTC_MakeContact' pre { 

    int_t HumanTarget;
    int_t GeogThreat;
   
    int_t i;
    int_t numArmies;
    army_t tmpArmy;
    city_t tmpCity;

    if (g.year<250){//should be sufficient
   
	    HumanTarget=CTC_IsThreatenedByAHuman(player[0].owner,0,CTC_AI_FEAR_RADIUS+1);
	    //is there a Human who poses 1<= Geog Threat level <=CTC_AI_FEAR_RADIUS? (=initially 1)

	    if (HumanTarget){
		    GeogThreat=CTC_GetGeogThreat(player[0].owner, HumanTarget);
		    if (GeogThreat < CTC_AI_FEAR_RADIUS+2){ 

			    if (GetEffectiveRegard(HumanTarget,player[0]) == 300 
			    ||  GetEffectiveRegard(HumanTarget,player[0]) == 500){ // no contact
	    
				    CTC_THE_TARGET_PLAYER=HumanTarget;
				    EnableTrigger('CTC_MakeContactWithHuman');

				    numArmies=player[0].armies;
				    for (i=0;i<numArmies;i=i+1){
					    GetArmyByIndex(player[0].owner,i,tmpArmy);
					    if (!GetCityByLocation(tmpArmy.location,tmpCity)){
						    event:BeginTurnArmy(tmpArmy);
					    }
				    }
			    }
		    }
	    }
    }
    else{
        DisableTrigger('CTC_MakeContact');
	   DisableTrigger('CTC_MakeContactWithHuman');
	   DisableTrigger('CTC_StopSearching');
    }
}

HandleEvent(BeginTurnArmy) 'CTC_MakeContactWithHuman' pre {

    city_t     tmpCity;
    int_t      tmpCloseness;
    int_t      tmpDist;
    location_t tmpLoc;

    if (ArmyIsValid(army[0])){
         if (!GetCityByLocation(army[0].location, tmpCity)){
	         CTC_GetTargetCity(army[0].owner,CTC_THE_TARGET_PLAYER);
		    tmpCloseness=CTC_GetCloseness(army[0].owner,CTC_THE_TARGET_PLAYER);
		    tmpDist=SquaredDistance(army[0].location,CTC_THE_TARGET_CITY.location);
              if (tmpDist < 10*(tmpCloseness*tmpCloseness)){
		         GetRandomNeighbor(CTC_THE_TARGET_CITY.location,tmpLoc);
			    event:ClearOrders(army[0]);
	              event:MovePathOrder(army[0],tmpLoc);
              }
         }
    }
}

HandleEvent(EndTurn) 'CTC_StopSearching' pre {
    DisableTrigger('CTC_MakeContactWithHuman');
}



// STOP FIGHTING DAMMIT

int_t CTC_THREATENED_PLAYER;

HandleEvent(BeginTurn) 'CTC_StopAttackingThreatenedPlayer' post {

    int_t i;

    if (!IsHumanPlayer(player[0])){
         if (AtWarCount(player[0])){
	         for (i=1;i<CTC_PLAYER_COUNT;i=i+1){
		         if (IsPlayerAlive(i)){
			         if (AtWarWith(player[0],i) && !IsHumanPlayer(i)){
                             if (CTC_IsThreatenedByAHuman(i,0,3) 
					    || CTC_IsAtWarWithHuman(i)){
					         CTC_THREATENED_PLAYER=i;
                                  EnableTrigger('CTC_StopFighting');
						    EnableTrigger('CTC_TurnOffStopFighting');
						    i=CTC_PLAYER_COUNT;
					    } 
			         }
		         }
	         } 
         }
    }
}

HandleEvent(FinishAttack) 'CTC_StopFighting' pre {

    unit_t tmpUnit;
    if (GetUnitsAtLocation(location[0])){
         GetUnitFromCell(location[0],0,tmpUnit);
	    if (tmpUnit.owner==CTC_THREATENED_PLAYER){
		    return Stop;
	    }
    }
}

HandleEvent(EndTurn) 'CTC_TurnOffStopFighting' pre {
    
    DisableTrigger('CTC_StopAttackingThreatenedPlayer');
    DisableTrigger('CTC_StopFighting');
    DisableTrigger('CTC_TurnOffStopFighting');
}

HandleEvent(BeginTurn) 'CTC_StopThreatenedPlayerFromAttacking' post {

    int_t i;

    if (!IsHumanPlayer(player[0])){
         if (AtWarCount(player[0])){
	         if (CTC_IsThreatenedByAHuman(player[0],0,3) 
		    || CTC_IsAtWarWithHuman(player[0])){
	         for (i=1;i<CTC_PLAYER_COUNT;i=i+1){
		         if (IsPlayerAlive(i)){
			         if (AtWarWith(player[0],i) && !IsHumanPlayer(i)){
					         CTC_THREATENED_PLAYER=player[0];
                                  EnableTrigger('CTC_StopFighting_1');
						    EnableTrigger('CTC_TurnOffStopFighting_1');
						    i=CTC_PLAYER_COUNT;
					    } 
			         }
		         }
	         } 
         }
    }
}

HandleEvent(FinishAttack) 'CTC_StopFighting_1' pre {

    unit_t tmpUnit;

    if (army[0].owner==CTC_THREATENED_PLAYER){
         if (GetUnitsAtLocation(location[0])){
              GetUnitFromCell(location[0],0,tmpUnit);
	         if (!IsHumanPlayer(tmpUnit.owner)){
                   return Stop;
	         }   
	    }
    }
}

HandleEvent(EndTurn) 'CTC_TurnOffStopFighting_1' pre {    
    DisableTrigger('CTC_StopThreatenedPlayerFromAttacking');
    DisableTrigger('CTC_StopFighting_1');
    DisableTrigger('CTC_TurnOffStopFighting_1');
}