package enemyAI;

import core.baseInfo;

import core.gameData;

import core.mainThread;

import core.vector;

import entity.goldMine;

import entity.solidObject;

import entity.techCenter;

//this agent makes all the high level combat decisions

public class combatManagerAI {

public baseInfo theBaseInfo;

public int frameAI;

public int currentState;

public final int booming = 0;

public final int aggressing = 1;

public final int defending = 2;

public goldMine[] goldMines;

float distanceToTarget;

public vector gatherPoint, attackDirection, attackPosition;

public solidObject unNeutralizedEntity;

public solidObject[] team;

public int numberOfUnitInCombatRadius;

public int numberOfUnitOutsideCombatRadius;

public float unitInCombactRadiusPercentage;

public solidObject[] unitInCombatRadius;

public solidObject[] unitOutsideCombatRadius;

public solidObject[] troopsControlledByCombatAI;

public solidObject[] playerUnitInMinimap;

public vector playerForceCenter;

public vector adjustedAttackDirection;

public int withdrawUnitOutsideCombatRadiusCooldown;

public float maxPlayerForceStrengthRoundAttacker;

public float combatCenterX, combatCenterZ;

public float myRallyPointX, myRallyPointZ;

public boolean rallyPointChanged;

public float unrevealedPlayerForceStrength;

public int noPlayerActivityCountdown;

public boolean staticDefenseAhead;

public boolean staticDefenseNearAttackPosition;

public boolean dealWithMajorThreat;

public boolean unitCountLow;

public int attackTime, standardAttackTime, rushAttackTime;

public int stateSwitchingCooldown;

public combatManagerAI(){

this.theBaseInfo = mainThread.ec.theBaseInfo;

standardAttackTime = 500;

if(mainThread.ec.difficulty == 2)

standardAttackTime = 630;

rushAttackTime = 250 + gameData.getRandom()/5;

goldMines = mainThread.theAssetManager.goldMines;

gatherPoint = new vector(-1,-1,-1);

attackDirection = new vector(0,0,0);

attackPosition = new vector(0,0,0);

playerForceCenter = new vector(0,0,0);

adjustedAttackDirection = new vector(0,0,0);

}

//check if player has expansions

//if player has expansion(s) then find the one that is least defended

//compare player force with its own force

//if AI thinks its has a comparable or greater force than the player, attack player's expansion and switch to aggressing mode

//if AI is under significant threat, switch to defending mode

public void processAI(){

frameAI = mainThread.ec.frameAI;

if(mainThread.ec.theMapAwarenessAI.numberOfPlayerUnitsOnMinimap != 0)

noPlayerActivityCountdown=150;

else if(noPlayerActivityCountdown > 0)

noPlayerActivityCountdown--;

//assume player force gets stronger as time goes by

if(unrevealedPlayerForceStrength < 0)

unrevealedPlayerForceStrength = 0;

if(noPlayerActivityCountdown > 0 && mainThread.ec.theMapAwarenessAI.totalNumberOfPlayerUnits > 0) {

if(frameAI < 360)

unrevealedPlayerForceStrength+=0.075f;

else

unrevealedPlayerForceStrength+=0.1f;

}

if(withdrawUnitOutsideCombatRadiusCooldown > 0){

withdrawUnitOutsideCombatRadiusCooldown --;

}else{

maxPlayerForceStrengthRoundAttacker = 0;

}

if(stateSwitchingCooldown > 0)

stateSwitchingCooldown--;

team = mainThread.ec.theUnitProductionAI.troopsControlledByCombatAI;

numberOfUnitInCombatRadius = mainThread.ec.theUnitProductionAI.numberOfUnitInCombatRadius;

numberOfUnitOutsideCombatRadius = mainThread.ec.theUnitProductionAI.numberOfUnitOutsideCombatRadius;

unitInCombatRadius = mainThread.ec.theUnitProductionAI.unitInCombatRadius;

unitOutsideCombatRadius = mainThread.ec.theUnitProductionAI.unitOutsideCombatRadius;

troopsControlledByCombatAI = mainThread.ec.theUnitProductionAI.troopsControlledByCombatAI;

playerUnitInMinimap = mainThread.ec.theMapAwarenessAI.playerUnitInMinimap;

combatCenterX = mainThread.ec.theUnitProductionAI.combatAICenterX;

combatCenterZ = mainThread.ec.theUnitProductionAI.combatAICenterZ;

boolean frontalTroopIverwhelmed = false;

boolean shouldAttack = false;

boolean playerHasBecomeStrongerThanAIDuringMarching = false;

rallyPointChanged = false;

if(myRallyPointX != mainThread.ec.theUnitProductionAI.rallyPoint.x){

myRallyPointX = mainThread.ec.theUnitProductionAI.rallyPoint.x;

myRallyPointZ = mainThread.ec.theUnitProductionAI.rallyPoint.z;

rallyPointChanged = true;

}

int numberOfLightTanks_AI = mainThread.ec.theUnitProductionAI.numberOfLightTanksControlledByCombatAI;

int numberOfRocketTanks_AI = mainThread.ec.theUnitProductionAI.numberOfRocketTanksControlledByCombatAI;

int numberOfStealthTanks_AI = mainThread.ec.theUnitProductionAI.numberOfStealthTanksControlledByCombatAI;

int numberOfHeavyTanks_AI = mainThread.ec.theUnitProductionAI.numberOfHeavyTanksControlledByCombatAI;

unitCountLow = (numberOfLightTanks_AI + numberOfRocketTanks_AI + numberOfStealthTanks_AI + numberOfHeavyTanks_AI * 2 < 9) && frameAI > 480;

if(currentState == booming){

//enemy AI compares its own force with player's force, then make a decision whether it should attack or not

attackTime = standardAttackTime;

if(mainThread.ec.theMapAwarenessAI.canRushPlayer && mainThread.ec.difficulty > 0)

attackTime = rushAttackTime;

int targetPlayerExpension = mainThread.ec.theMapAwarenessAI.targetPlayerExpension;

if(frameAI > attackTime) {

if(targetPlayerExpension == 0 || targetPlayerExpension == 1 || targetPlayerExpension == 6 || targetPlayerExpension == 7)

if(frameAI < 700)

shouldAttack = checkIfAIHasBiggerForce(0.5f);

else

shouldAttack = checkIfAIHasBiggerForce(0.75f);

else

shouldAttack = checkIfAIHasBiggerForce(1.2f);

if(mainThread.ec.theUnitProductionAI.numberOfCombatUnit > 75)

shouldAttack = true;

}

if(shouldAttack){

if(targetPlayerExpension != -1){

currentState = aggressing;

attackDirection.set(goldMines[targetPlayerExpension].centre.x - combatCenterX, 0, goldMines[targetPlayerExpension].centre.z - combatCenterZ);

attackDirection.unit();

attackPosition.set(goldMines[targetPlayerExpension].centre);

attackPosition.add(attackDirection);

return;

}else{

//if no enemy structure found around gold mines, set attack position to a revealed enemy building or unit

solidObject[] playerStructures = mainThread.ec.theMapAwarenessAI.playerStructures;

solidObject[] playerUnitInMinimap = mainThread.ec.theMapAwarenessAI.playerUnitInMinimap;

attackDirection.set(0,0,0);

for(int i = 0; i < playerStructures.length; i++){

if(playerStructures[i] != null && playerStructures[i].currentHP > 0){

currentState = aggressing;

attackDirection.set(playerStructures[i].centre.x - combatCenterX, 0, playerStructures[i].centre.z - combatCenterZ);

attackDirection.unit();

attackPosition.set(playerStructures[i].centre);

attackPosition.add(attackDirection);

return;

}

}

if(attackDirection.x == 0 && attackDirection.z ==0){

for(int i = 0; i < playerUnitInMinimap.length; i++){

if(playerUnitInMinimap[i] != null && playerUnitInMinimap[i].currentHP > 0){

currentState = aggressing;

attackDirection.set(playerUnitInMinimap[i].centre.x - combatCenterX, 0, playerUnitInMinimap[i].centre.z - combatCenterZ);

attackDirection.unit();

attackPosition.set(playerUnitInMinimap[i].centre);

attackPosition.add(attackDirection);

return;

}

}

}

//if AI couldn't find a player base nor player's unit then set the attack position to the player spawning point

currentState = aggressing;

attackDirection.set(goldMines[0].centre.x - combatCenterX, 0, goldMines[0].centre.z - combatCenterZ);

attackDirection.unit();

attackPosition.set(goldMines[0].centre);

attackPosition.add(attackDirection);

}

}else {

//check if defenceManager found a major threat

if(mainThread.ec.theDefenseManagerAI.majorThreatLocation.x != 0) {

if(unitCountLow)

return;

currentState = aggressing;

attackDirection.set(mainThread.ec.theDefenseManagerAI.majorThreatLocation.x - combatCenterX, 0, mainThread.ec.theDefenseManagerAI.majorThreatLocation.z - combatCenterZ);

attackDirection.unit();

attackPosition.set(mainThread.ec.theDefenseManagerAI.majorThreatLocation);

return;

}

//check if there are any player units/structures near the combat center

solidObject[] playerUnitInMinimap = mainThread.ec.theMapAwarenessAI.playerUnitInMinimap;

solidObject[] playerStructures = mainThread.ec.theMapAwarenessAI.playerStructures;

for(int i = 0; i < playerUnitInMinimap.length; i++) {

if(playerUnitInMinimap[i] != null && playerUnitInMinimap[i].currentHP > 0) {

double d = Math.sqrt((combatCenterX - playerUnitInMinimap[i].centre.x)*(combatCenterX - playerUnitInMinimap[i].centre.x) + (combatCenterZ - playerUnitInMinimap[i].centre.z)*(combatCenterZ - playerUnitInMinimap[i].centre.z));

if(d < 7){

currentState = aggressing;

attackDirection.set(playerUnitInMinimap[i].centre.x - combatCenterX, 0, playerUnitInMinimap[i].centre.z - combatCenterZ);

attackDirection.unit();

attackPosition.set(playerUnitInMinimap[i].centre);

return;

}

}

}

for(int i = 0; i < playerStructures.length; i++) {

if(playerStructures[i] != null && playerStructures[i].currentHP > 0) {

double d = Math.sqrt((combatCenterX - playerStructures[i].centre.x)*(combatCenterX - playerStructures[i].centre.x) + (combatCenterZ - playerStructures[i].centre.z)*(combatCenterZ - playerStructures[i].centre.z));

if(d < 7){

currentState = aggressing;

attackDirection.set(playerStructures[i].centre.x - combatCenterX, 0, playerStructures[i].centre.z - combatCenterZ);

attackDirection.unit();

attackPosition.set(playerStructures[i].centre);

return;

}

}

}

}

if(currentState != aggressing) {

if(rallyPointChanged || Math.abs(myRallyPointX - combatCenterX) > 1 || Math.abs(myRallyPointZ - combatCenterZ) > 1){

for(int i =0 ; i < troopsControlledByCombatAI.length; i++){

if(troopsControlledByCombatAI[i] != null && troopsControlledByCombatAI[i].currentHP > 0){

if(Math.abs(troopsControlledByCombatAI[i].destinationX - myRallyPointX) > 0.25 || Math.abs(troopsControlledByCombatAI[i].destinationY - myRallyPointZ) > 0.25) {

if(troopsControlledByCombatAI[i].secondaryDestinationX != myRallyPointX || troopsControlledByCombatAI[i].secondaryDestinationY != myRallyPointZ) {

troopsControlledByCombatAI[i].attackMoveTo(myRallyPointX, myRallyPointZ);

troopsControlledByCombatAI[i].currentCommand = solidObject.attackMove;

troopsControlledByCombatAI[i].secondaryCommand = solidObject.attackMove;

}

}

}

}

}

}

}else if(currentState == aggressing && stateSwitchingCooldown == 0){

//check if a major threat is found other than the current attack position

if(mainThread.ec.theDefenseManagerAI.majorThreatLocation.x != 0){

float xPos = mainThread.ec.theDefenseManagerAI.majorThreatLocation.x;

float zPos = mainThread.ec.theDefenseManagerAI.majorThreatLocation.z;

float d1 = (attackPosition.x - combatCenterX)*(attackPosition.x - combatCenterX) + (attackPosition.z - combatCenterZ)*(attackPosition.z - combatCenterZ);

float d2 = (xPos - combatCenterX)*(xPos - combatCenterX) + (zPos - combatCenterZ)*(zPos - combatCenterZ);

if(d2 -2 <= d1) {

attackPosition.set(xPos, 0, zPos);

}

dealWithMajorThreat = true;

}else {

if(dealWithMajorThreat == true) {

currentState = booming;

dealWithMajorThreat = false;

return;

}

}

attackDirection.set(attackPosition.x - combatCenterX, 0, attackPosition.z - combatCenterZ);

distanceToTarget = attackDirection.getLength();

attackDirection.unit();

//check if the target position has been neutralized

solidObject[] playerUnitInMinimap = mainThread.ec.theMapAwarenessAI.playerUnitInMinimap;

solidObject[] playerStructures = mainThread.ec.theMapAwarenessAI.playerStructures;

unNeutralizedEntity = null;

//look for revealed player building structures

for(int i = 0; i < playerStructures.length; i++){

if(playerStructures[i] != null){

if((playerStructures[i].centre.x - attackPosition.x)*(playerStructures[i].centre.x - attackPosition.x) + (playerStructures[i].centre.z - attackPosition.z)*(playerStructures[i].centre.z - attackPosition.z) < 16){

unNeutralizedEntity = playerStructures[i];

attackPosition.set(playerStructures[i].centre);

break;

}

}

}

//if there is no player structure found, then look for player units

boolean needResetAttackPosition = false;

if(unNeutralizedEntity == null){

for(int i = 0; i < playerUnitInMinimap.length; i++){

if(playerUnitInMinimap[i] != null){

unNeutralizedEntity = playerUnitInMinimap[i];

needResetAttackPosition = true;

if((playerUnitInMinimap[i].centre.x - attackPosition.x)*(playerUnitInMinimap[i].centre.x - attackPosition.x) + (playerUnitInMinimap[i].centre.z - attackPosition.z)*(playerUnitInMinimap[i].centre.z - attackPosition.z) < 16){

needResetAttackPosition = false;

break;

}

}

}

}

if(needResetAttackPosition) {

attackPosition.set(unNeutralizedEntity.centre);

}

//if front portion of the troops are under attack, set the attack position to the attacker

for(int i = 0; i < numberOfUnitInCombatRadius; i++){

if(unitInCombatRadius[i].underAttackCountDown > 0){

attackPosition.set(unitInCombatRadius[i].attacker.centre);

unNeutralizedEntity = unitInCombatRadius[i].attacker;

break;

}

}

//check if the front portion of the troops are overwhelmed by player force

float playerForceStrengthNearCombatCenter = checkPlayerForceStrengthAroundOnePoint(playerUnitInMinimap, combatCenterX + attackDirection.x, combatCenterZ + attackDirection.z, 4);

if((playerForceStrengthNearCombatCenter+1)/(getAIForceStrength(unitInCombatRadius)+1) > 2f){

frontalTroopIverwhelmed = true;

}

//check if the player force has become stronger than the AI during the marching towards attack position

//System.out.println("distanceToTarget: " + distanceToTarget);

if(checkIfAIHasBiggerForce(1.5f) == false && distanceToTarget > 8 && !(mainThread.ec.theMapAwarenessAI.playerForceNearBase && dealWithMajorThreat)){

playerHasBecomeStrongerThanAIDuringMarching = true;

}

//check if the troops is near a concentration of player's static defense.

//If true, then check if AI has enough troops to deal with the static defense.

staticDefenseAhead = false;

int staticDefenseThreshold = 0;

if(frameAI > 600 && mainThread.ec.theUnitProductionAI.numberOfUnitInCombatRadius > 15)

staticDefenseThreshold = 4;

double distanceToTower = 999;

for(int i = 0; i < mainThread.ec.theMapAwarenessAI.playerStaticDefenseLocations.length; i++) {

if(mainThread.ec.theMapAwarenessAI.playerStaticDefenseSize[i] > staticDefenseThreshold) {

float xPos = mainThread.ec.theMapAwarenessAI.playerStaticDefenseLocations[i].x;

float zPos = mainThread.ec.theMapAwarenessAI.playerStaticDefenseLocations[i].z;

distanceToTower = Math.sqrt((xPos - combatCenterX)*(xPos - combatCenterX) + (zPos - combatCenterZ)*(zPos - combatCenterZ));

if(distanceToTower < 4.5) {

staticDefenseAhead = true;

break;

}

}

}

if(mainThread.ec.difficulty < 1)

staticDefenseAhead = false;

//if a rush tactics is denied by the player (e.g player builds static defenses around natural), then briefly suspend the attacking force (wait for rocket tanks to take out the static defenses)

if(frameAI < standardAttackTime && mainThread.ec.theMapAwarenessAI.canRushPlayer && distanceToTower < 2 && mainThread.ec.difficulty > 0){

if(Math.abs(attackPosition.x - myRallyPointX) > 12 || Math.abs(attackPosition.z - myRallyPointZ) > 12) {

for(int i = 0; i < troopsControlledByCombatAI.length; i++) {

if(troopsControlledByCombatAI[i] != null && troopsControlledByCombatAI[i].currentHP > 0 && troopsControlledByCombatAI[i].type != 1) {

troopsControlledByCombatAI[i].moveTo(myRallyPointX, myRallyPointZ);

troopsControlledByCombatAI[i].currentCommand = solidObject.move;

troopsControlledByCombatAI[i].secondaryCommand = solidObject.StandBy;

}

}

currentState = booming;

stateSwitchingCooldown = 8;

return;

}

}

staticDefenseNearAttackPosition = false;

for(int i = 0; i < mainThread.ec.theMapAwarenessAI.playerStaticDefenseLocations.length; i++) {

if(mainThread.ec.theMapAwarenessAI.playerStaticDefenseSize[i] > 0) {

if(mainThread.ec.theMapAwarenessAI.playerStaticDefenseStrength[i] > 6) {

float xPos = mainThread.ec.theMapAwarenessAI.playerStaticDefenseLocations[i].x;

float zPos = mainThread.ec.theMapAwarenessAI.playerStaticDefenseLocations[i].z;

float d = (xPos - attackPosition.x)*(xPos - attackPosition.x) + (zPos - attackPosition.z)*(zPos - attackPosition.z);

if(d < 16) {

staticDefenseNearAttackPosition = true;

break;

}

}

}

}

//send units to attack-move to target position

if(!playerHasBecomeStrongerThanAIDuringMarching && !frontalTroopIverwhelmed && (unNeutralizedEntity != null || distanceToTarget > 2)){

//if the tail portion of the troops are under attack, send them back to base instead of throwing them into player's trap

float AIForceStrengthOutsideCombatRadius = getAIForceStrength(unitOutsideCombatRadius);

maxPlayerForceStrengthRoundAttacker = 0;

for(int i = 0; i < numberOfUnitOutsideCombatRadius; i++){

if(unitOutsideCombatRadius[i].underAttackCountDown > 0 && unitOutsideCombatRadius[i].attacker != null){

//check the number of hostile units around the attacker

playerForceStrengthNearCombatCenter = checkPlayerForceStrengthAroundOnePoint(playerUnitInMinimap, unitOutsideCombatRadius[i].attacker.centre.x, unitOutsideCombatRadius[i].attacker.centre.z, 4);

if(playerForceStrengthNearCombatCenter > maxPlayerForceStrengthRoundAttacker)

maxPlayerForceStrengthRoundAttacker = playerForceStrengthNearCombatCenter;

}

//check if there are too many hostile units

if(maxPlayerForceStrengthRoundAttacker > AIForceStrengthOutsideCombatRadius){

if(withdrawUnitOutsideCombatRadiusCooldown == 0)

withdrawUnitOutsideCombatRadiusCooldown = 30;

break;

}

}

if(withdrawUnitOutsideCombatRadiusCooldown > 0){

team = unitInCombatRadius; //exclude the tail portion of the troops from the attack force

//retreat tail portion of the troops to rally point

//but if the player's force is near the rally point, send tail portion of the troops to defend the rally point

float x = mainThread.ec.theMapAwarenessAI.mainPlayerForceLocation.x;

float z = mainThread.ec.theMapAwarenessAI.mainPlayerForceLocation.z;

double d = Math.sqrt((x-myRallyPointX)*(x-myRallyPointX) + (z-myRallyPointZ)*(z-myRallyPointZ));

for(int i = 0; i < unitOutsideCombatRadius.length; i++){

if(unitOutsideCombatRadius[i] != null && unitOutsideCombatRadius[i].currentHP > 0){

if(d > 3.5) {

unitOutsideCombatRadius[i].attackMoveTo(mainThread.ec.theUnitProductionAI.rallyPoint.x, mainThread.ec.theUnitProductionAI.rallyPoint.z);

}else {

unitOutsideCombatRadius[i].attackMoveTo(x, z);

}

unitOutsideCombatRadius[i].currentCommand = solidObject.attackMove;

unitOutsideCombatRadius[i].secondaryCommand = solidObject.attackMove;

}

}

}

if(unNeutralizedEntity != null){

attackDirection.set(unNeutralizedEntity.centre.x - combatCenterX, 0, unNeutralizedEntity.centre.z - combatCenterZ);

distanceToTarget = attackDirection.getLength();

attackDirection.unit();

}

//make sure the attack position is a valid point on the map

if(attackPosition.x < 1.5)

attackPosition.x = 1.5f;

if(attackPosition.x > 30.5)

attackPosition.x = 30.5f;

if(attackPosition.y < 1.5)

attackPosition.y = 1.5f;

if(attackPosition.y > 30.5)

attackPosition.y = 30.5f;

everyoneAttackTargetPosition();

}else{

//if target position has been neutralized, change status to booming

currentState = booming;

float gatherPointX, gatherPointZ;

//if the change of state is caused by heavy causality of the AI player then move move every unit back to rally point

if(frontalTroopIverwhelmed || playerHasBecomeStrongerThanAIDuringMarching){

gatherPointX = mainThread.ec.theUnitProductionAI.rallyPoint.x;

gatherPointZ = mainThread.ec.theUnitProductionAI.rallyPoint.z;

}else {

//if the AI really couldn't find any targets then gather every units at the current combat center

gatherPointX = combatCenterX;

gatherPointZ = combatCenterZ;

}

for(int i = 0; i < numberOfUnitOutsideCombatRadius; i++){

//send the tail portion of the troops to rally point

unitOutsideCombatRadius[i].attackMoveTo(gatherPointX, gatherPointZ);

unitOutsideCombatRadius[i].currentCommand = solidObject.attackMove;

unitOutsideCombatRadius[i].secondaryCommand = solidObject.attackMove;

}

for(int i = 0; i < numberOfUnitInCombatRadius; i++){

//send the tail portion of the troops to rally point

if(unitInCombatRadius[i].attackStatus != solidObject.isAttacking){

unitInCombatRadius[i].attackMoveTo(gatherPointX, gatherPointZ);

unitInCombatRadius[i].currentCommand = solidObject.attackMove;

unitInCombatRadius[i].secondaryCommand = solidObject.attackMove;

}

}

}

}

}

//attack a target location with all the forces

public void everyoneAttackTargetPosition(){

//Find a gather location for an attack. The attacking units will first try to gather around a location that in between the target location and the attack force's center point.

//When the majority attacking units arrive around the gather point, the attack will proceed towards the target location.

//The purpose of doing this is to keep the attack units together when across long distance,

float teamRadius = (float)Math.sqrt(mainThread.ec.theUnitProductionAI.numberOfCombatUnit)/2.5f;

if(distanceToTarget < 3 + teamRadius && unNeutralizedEntity != null && !staticDefenseAhead){

//adjust the attack location for better engagement

playerForceCenter.set(0,0,0);

int numOfPlayerUnitsInMinimap = 0;

for(int i = 0; i < playerUnitInMinimap.length; i++){

if(playerUnitInMinimap[i] != null && playerUnitInMinimap[i].currentHP > 0){

float playerCenterX = playerUnitInMinimap[i].centre.x;

float playerCenterZ = playerUnitInMinimap[i].centre.z;

if((playerCenterX - combatCenterX)*(playerCenterX - combatCenterX) + (playerCenterZ - combatCenterZ)*(playerCenterZ - combatCenterZ) < 9){

playerForceCenter.x+=playerCenterX;

playerForceCenter.z+=playerCenterZ;

numOfPlayerUnitsInMinimap++;

}

}

}

if(numOfPlayerUnitsInMinimap >0){

playerForceCenter.x/=numOfPlayerUnitsInMinimap;

playerForceCenter.z/=numOfPlayerUnitsInMinimap;

}else{

playerForceCenter.x= attackPosition.x;

playerForceCenter.z= attackPosition.z;

}

adjustedAttackDirection.set(playerForceCenter.x - combatCenterX, 0, playerForceCenter.z - combatCenterZ);

adjustedAttackDirection.unit();

adjustedAttackDirection.scale(20);

for(int i = 0; i < mainThread.ec.theUnitProductionAI.numberOfCombatUnit; i++){

if(team[i] != null && team[i].currentHP > 0){

if(!((team[i].secondaryDestinationX == attackPosition.x && team[i].secondaryDestinationY == attackPosition.z)

|| (team[i].secondaryDestinationX == unNeutralizedEntity.centre.x && team[i].secondaryDestinationY == unNeutralizedEntity.centre.z))){

if(team[i].attackStatus != solidObject.isAttacking){

float x = team[i].centre.x;

float z = team[i].centre.z;

boolean farFromAttackPosition = Math.abs(x - attackPosition.x) > 2.5 || Math.abs(z - attackPosition.z) > 2.5;

if(!farFromAttackPosition)

team[i].attackMoveTo(playerForceCenter.x + adjustedAttackDirection.x, playerForceCenter.z + adjustedAttackDirection.z);

else

team[i].attackMoveTo(attackPosition.x, attackPosition.z);

team[i].currentCommand = solidObject.attackMove;

team[i].secondaryCommand = solidObject.attackMove;

}

team[i].secondaryDestinationX = attackPosition.x;

team[i].secondaryDestinationY = attackPosition.z;

}

}

}

}else{

for(int i = 0; i < 3; i++){

gatherPoint.set(combatCenterX + attackDirection.x*(teamRadius+1*i), 0, combatCenterZ + attackDirection.z*(teamRadius+ 1*i));

//if the gather point is inside a water body them move the gather point forward

int tileIndex = (int)(gatherPoint.x*64)/16 + (127 - ((int)(gatherPoint.z*64))/16)*128;

if(tileIndex >= mainThread.gridMap.tiles.length || tileIndex < 0)

break;

if(mainThread.gridMap.tiles[tileIndex][0] != null && mainThread.gridMap.tiles[tileIndex][0].type == 4)

continue;

else

break;

}

boolean playerForceIsMuchWeakerThanAI = checkIfAIHasBiggerForce(0.5f);

for(int i = 0; i < mainThread.ec.theUnitProductionAI.numberOfCombatUnit; i++){

if(team[i] != null && team[i].currentHP > 0){

if(mainThread.ec.difficulty > 0) {

//stop chasing player unit if it has got out of sight

if(team[i].targetObject != null && team[i].targetObject.currentHP >0) {

int targetPositionIndex = (int)(team[i].targetObject.centre.x*64)/16 + (127 - (int)(team[i].targetObject.centre.z*64)/16)*128;

if(team[i].attackStatus != solidObject.isAttacking && team[i].underAttackCountDown == 0 && (!mainThread.ec.visionMap[targetPositionIndex] || team[i].targetObject.isCloaked))

team[i].targetObject = null;

}

//marching forward

if(team[i].targetObject == null || team[i].targetObject.currentHP <=0){

if(staticDefenseAhead) {

if(team[i].type == 1) {

team[i].attackMoveTo(team[i].centre.x + attackDirection.x*teamRadius, team[i].centre.z + attackDirection.z*teamRadius);

}else {

team[i].attackMoveTo(combatCenterX, combatCenterZ);

}

}else if(!(team[i].currentMovementStatus == solidObject.hugRight || team[i].currentMovementStatus == solidObject.hugLeft)){

double d = Math.sqrt((team[i].centre.x - combatCenterX)*(team[i].centre.x - combatCenterX) + (team[i].centre.z - combatCenterZ)*(team[i].centre.z - combatCenterZ))*3;

if(d > teamRadius){

if(staticDefenseNearAttackPosition || !playerForceIsMuchWeakerThanAI || mainThread.ec.theMapAwarenessAI.playerAssetDestoryedCountDown == 0)

team[i].attackMoveTo(gatherPoint.x, gatherPoint.z);

else

team[i].attackMoveTo(attackPosition.x, attackPosition.z);

}else{

team[i].attackMoveTo(team[i].centre.x + attackDirection.x*teamRadius, team[i].centre.z + attackDirection.z*teamRadius);

}

}

team[i].currentCommand = solidObject.attackMove;

team[i].secondaryCommand = solidObject.attackMove;

}

}else {

team[i].attackMoveTo(attackPosition.x, attackPosition.z);

team[i].currentCommand = solidObject.attackMove;

team[i].secondaryCommand = solidObject.attackMove;

}

}

}

}

//make sure idle units are send to attack unNeutralized target

if(unNeutralizedEntity != null){

for(int i = 0; i < mainThread.ec.theUnitProductionAI.numberOfCombatUnit; i++){

if(team[i] != null && team[i].currentHP > 0 && !(team[i].type!= 1 && staticDefenseAhead)){

if(team[i].currentCommand == solidObject.StandBy || (team[i].targetObject == null && (team[i].secondaryDestinationX != unNeutralizedEntity.centre.x || team[i].secondaryDestinationY != unNeutralizedEntity.centre.z))){

float d = (team[i].centre.x - attackPosition.x)*(team[i].centre.x - attackPosition.x) + (team[i].centre.z - attackPosition.z)*(team[i].centre.z - attackPosition.z);

if(d < 9){

team[i].attackMoveTo(unNeutralizedEntity.centre.x, unNeutralizedEntity.centre.z);

team[i].currentCommand = solidObject.attackMove;

team[i].secondaryCommand = solidObject.attackMove;

}

}

}

}

}

}

public float checkPlayerForceStrengthAroundOnePoint(solidObject[] listOfUnits, float x, float z, double distanceThreshold){

float playerForceStrength = 0;

for(int j = 0; j < listOfUnits.length; j++){

if(listOfUnits[j] != null && listOfUnits[j].currentHP > 0){

double d = (listOfUnits[j].centre.x - x)*(listOfUnits[j].centre.x - x)

+ (listOfUnits[j].centre.z - z)*(listOfUnits[j].centre.z - z);

if(d < distanceThreshold){

if(listOfUnits[j].type == 0 || listOfUnits[j].type == 1)

playerForceStrength+=1;

else if(listOfUnits[j].type == 6)

playerForceStrength+=1.5f;

else if(listOfUnits[j].type == 7)

playerForceStrength+=3;

}

}

}

return playerForceStrength;

}

public float getAIForceStrength(solidObject[] listOfUnits){

float AIForceStrength = 0;

for(int j = 0; j < listOfUnits.length; j++){

if(listOfUnits[j] != null && listOfUnits[j].currentHP > 0){

if(listOfUnits[j].type == 0 || listOfUnits[j].type == 1)

AIForceStrength+=1;

else if(listOfUnits[j].type == 6)

AIForceStrength+=1.5f;

else if(listOfUnits[j].type == 7)

AIForceStrength+=3;

}

}

return AIForceStrength;

}

public boolean checkIfAIHasBiggerForce(float ratio){

int numberOfLightTanks_AI = mainThread.ec.theUnitProductionAI.numberOfLightTanksControlledByCombatAI;

int numberOfRocketTanks_AI = mainThread.ec.theUnitProductionAI.numberOfRocketTanksControlledByCombatAI;

int numberOfStealthTanks_AI = mainThread.ec.theUnitProductionAI.numberOfStealthTanksControlledByCombatAI;

int numberOfHeavyTanks_AI = mainThread.ec.theUnitProductionAI.numberOfHeavyTanksControlledByCombatAI;

int numberOfLightTanks_player = mainThread.ec.theMapAwarenessAI.numberOfLightTanks_player;

int numberOfRocketTanks_player = mainThread.ec.theMapAwarenessAI.numberOfRocketTanks_player;

int numberOfStealthTanks_player = mainThread.ec.theMapAwarenessAI.numberOfStealthTanks_player;

int numberOfHeavyTanks_player = mainThread.ec.theMapAwarenessAI.numberOfHeavyTanks_player;

float m3 = 1.5f;

if(techCenter.stealthTankResearched_enemy == true && numberOfHeavyTanks_player < 4 && numberOfStealthTanks_AI > numberOfStealthTanks_player * 2)

m3+=0.5f;

if(techCenter.stealthTankResearched_enemy == true && mainThread.ec.theMapAwarenessAI.playerArmyCanBeCounteredWithStealthTanks){

m3+=0.5f;

}

float m1 = 1;

if(mainThread.ec.theMapAwarenessAI.playerArmyCanBeCounteredWithLightTanks){

m1 = 1.2f;

if(techCenter.lightTankResearched_enemy == true){

m1=1.75f;

}

}

double enemyAIForceStrength = m1*numberOfLightTanks_AI + 0.75f*numberOfRocketTanks_AI + m3*(numberOfStealthTanks_AI-mainThread.ec.theBaseExpentionAI.numberOfStealthTankScout) + 3* numberOfHeavyTanks_AI;

double playerForceStrength = unrevealedPlayerForceStrength + numberOfLightTanks_player + 0.75f*numberOfRocketTanks_player + 1.5*numberOfStealthTanks_player + 3* numberOfHeavyTanks_player;

//System.out.println("unrevealedPlayerForceStrength" + unrevealedPlayerForceStrength + " " + "enemyAIForceStrength " + enemyAIForceStrength + " " + "playerForceStrength" + playerForceStrength);

return enemyAIForceStrength > 0 && playerForceStrength/enemyAIForceStrength < ratio;

}

}