729 lines
25 KiB
Java
729 lines
25 KiB
Java
package enemyAI;
|
|
|
|
import core.baseInfo;
|
|
import entity.factory;
|
|
import core.mainThread;
|
|
import core.vector;
|
|
import entity.lightTank;
|
|
import entity.solidObject;
|
|
import entity.stealthTank;
|
|
import entity.communicationCenter;
|
|
import entity.constructionYard;
|
|
import entity.gunTurret;
|
|
import entity.missileTurret;
|
|
|
|
public class defenseManagerAI {
|
|
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 solidObject[] observers;
|
|
|
|
public solidObject[] stealthTanksControlledByCombatAI;
|
|
public solidObject[] lightTanksControlledByCombatAI;
|
|
|
|
public solidObject[] defenders;
|
|
public int numOfDefenders;
|
|
|
|
public vector direction;
|
|
public vector threatToBaseDirection;
|
|
|
|
public vector minorThreatLocation;
|
|
public vector majorThreatLocation;
|
|
public int majorThreatCooldown;
|
|
|
|
public boolean needGunTurret;
|
|
public boolean needMissileTurret;
|
|
|
|
public vector gunTurretDeployLocation;
|
|
public vector missileTurretDeployLocation;
|
|
|
|
|
|
public defenseManagerAI(){
|
|
this.theBaseInfo = mainThread.ec.theBaseInfo;
|
|
|
|
observers = new solidObject[4];
|
|
|
|
defenders = new solidObject[5];
|
|
|
|
direction = new vector(0,0,0);
|
|
threatToBaseDirection = new vector(0,0,0);
|
|
|
|
minorThreatLocation = new vector(0,0,0);
|
|
majorThreatLocation = new vector(0,0,0);
|
|
|
|
gunTurretDeployLocation = new vector(0,0,0);
|
|
missileTurretDeployLocation = new vector(0,0,0);
|
|
}
|
|
|
|
|
|
//at 500 seconds mark, send 2 observers to the 2 western and southern side of the main base. After grabbing the northwest (or southeast, depends on which expansion get grabbed first) expansion
|
|
//send 2 additional observers to look for player sneak attacks
|
|
|
|
|
|
public void processAI(){
|
|
frameAI = mainThread.ec.frameAI;
|
|
|
|
|
|
|
|
if(majorThreatCooldown > 0)
|
|
majorThreatCooldown --;
|
|
|
|
currentState = mainThread.ec.theCombatManagerAI.currentState;
|
|
|
|
stealthTanksControlledByCombatAI = mainThread.ec.theUnitProductionAI.stealthTanksControlledByCombatAI;
|
|
lightTanksControlledByCombatAI = mainThread.ec.theUnitProductionAI.lightTanksControlledByCombatAI;
|
|
|
|
//after 500 seconds mark, borrow 2 stealth tanks from combat manager, and send them to guard western and southern side of the main base
|
|
if(mainThread.ec.difficulty == 2) {
|
|
if(frameAI >= 450 && mainThread.ec.theCombatManagerAI.checkIfAIHasBiggerForce(0.8f)) {
|
|
for(int i = 0; i < 2; i++) {
|
|
if(observers[i] == null || observers[i].currentHP <=0) {
|
|
for(int j = 0; j < stealthTanksControlledByCombatAI.length; j++) {
|
|
if(stealthTanksControlledByCombatAI[j] != null && stealthTanksControlledByCombatAI[j].currentHP == 80 && stealthTanksControlledByCombatAI[j].attackStatus != solidObject.isAttacking) {
|
|
observers[i] = stealthTanksControlledByCombatAI[j];
|
|
stealthTanksControlledByCombatAI[j] = null;
|
|
float xPos = 20f;
|
|
float zPos = 30.5f;
|
|
|
|
if(i == 1) {
|
|
xPos = 30f;
|
|
zPos = 20f;
|
|
}
|
|
|
|
|
|
if(frameAI > 1000) {
|
|
xPos = 0.25f;
|
|
zPos = 20.5f;
|
|
|
|
if(i == 1) {
|
|
xPos = 18.75f;
|
|
zPos = 5f;
|
|
}
|
|
}
|
|
|
|
observers[i].moveTo(xPos, zPos);
|
|
observers[i].currentCommand = solidObject.move;
|
|
observers[i].secondaryCommand = solidObject.StandBy;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//keep an eye on player units and avoid being detected
|
|
for(int i = 0; i < observers.length; i++) {
|
|
if(observers[i] != null) {
|
|
|
|
if(!evadePlayerUnit(i)) {
|
|
float xPos = 0;
|
|
float zPos = 0;
|
|
|
|
//if there is no player units in sight, return to patrol position
|
|
if(i == 0) {
|
|
if(frameAI%28 < 14) {
|
|
xPos = 15.5f;
|
|
zPos = 30.5f;
|
|
}else {
|
|
xPos = 15.5f;
|
|
zPos = 24.5f;
|
|
}
|
|
|
|
if(frameAI > 1000) {
|
|
if(frameAI%18 < 9) {
|
|
xPos = 0.25f;
|
|
zPos = 20.5f;
|
|
}else {
|
|
xPos = 5f;
|
|
zPos = 20.5f;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
if(i == 1) {
|
|
|
|
if(frameAI%30 < 15) {
|
|
xPos = 29.25f;
|
|
zPos = 17f;
|
|
}else {
|
|
xPos = 29.25f;
|
|
zPos = 10f;
|
|
}
|
|
|
|
if(frameAI > 1000) {
|
|
if(frameAI%14 < 7) {
|
|
xPos = 18.75f;
|
|
zPos = 5f;
|
|
}else {
|
|
xPos = 18.75f;
|
|
zPos = 0.5f;
|
|
}
|
|
}
|
|
|
|
}
|
|
observers[i].moveTo(xPos, zPos);
|
|
observers[i].currentCommand = solidObject.move;
|
|
observers[i].secondaryCommand = solidObject.StandBy;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
//send units to deal with minor threat on the map if there is any
|
|
vector mainPlayerForceLocation = mainThread.ec.theMapAwarenessAI.mainPlayerForceLocation;
|
|
vector mainPlayerForceDirection = mainThread.ec.theMapAwarenessAI.mainPlayerForceDirection;
|
|
int mainPlayerForceSize = mainThread.ec.theMapAwarenessAI.mainPlayerForceSize;
|
|
|
|
minorThreatLocation.reset();
|
|
if(majorThreatCooldown == 0)
|
|
majorThreatLocation.reset();
|
|
|
|
// if the size of the player unit cluster is less than 7, and no heavy tanks in the cluster, then borrow some unites from combatAI to deal with the threat
|
|
if(mainPlayerForceSize < 7 && mainPlayerForceSize>0) {
|
|
//check if base is attacked by long ranged units
|
|
boolean attackedByRocketTank = false;
|
|
int numOfHeavyTanks = numOfHeavyTankAroundLocation(mainPlayerForceLocation);
|
|
if(numOfHeavyTanks < 1) {
|
|
for(int i = 0; i < mainThread.ec.theMapAwarenessAI.numOfAIStructures; i++) {
|
|
if(mainThread.ec.theMapAwarenessAI.AIStructures[i].underAttackCountDown > 0 &&
|
|
mainThread.ec.theMapAwarenessAI.AIStructures[i].attacker != null &&
|
|
mainThread.ec.theMapAwarenessAI.AIStructures[i].attacker.currentHP > 0 &&
|
|
mainThread.ec.theMapAwarenessAI.AIStructures[i].attacker.type == 1) {
|
|
attackedByRocketTank = true;
|
|
minorThreatLocation.set(mainThread.ec.theMapAwarenessAI.AIStructures[i].attacker.centre);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!attackedByRocketTank && playerForceIsNearBase(mainPlayerForceLocation)) {
|
|
if(numOfHeavyTanks < 1)
|
|
minorThreatLocation.set(mainPlayerForceLocation);
|
|
else {
|
|
giveBackControlOfDefendersToCombatAI();
|
|
majorThreatLocation.set(mainPlayerForceLocation);
|
|
}
|
|
}
|
|
}else if(mainPlayerForceSize >= 7){
|
|
//if the size of player unit cluster is bigger or equal to 5 then check if the threat is a big one
|
|
if(playerForceIsNearBase(mainPlayerForceLocation)) {
|
|
giveBackControlOfDefendersToCombatAI();
|
|
majorThreatCooldown = 30;
|
|
majorThreatLocation.set(mainPlayerForceLocation);
|
|
}else {
|
|
float d = playerForceIsMovingTwoardsBase(mainPlayerForceLocation, mainPlayerForceDirection);
|
|
if(d != -1) {
|
|
giveBackControlOfDefendersToCombatAI();
|
|
majorThreatCooldown = 30;
|
|
majorThreatLocation.set(mainPlayerForceLocation);
|
|
majorThreatLocation.add(mainPlayerForceDirection, d);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//treat player buildings that is close to the base as major threat too.
|
|
constructionYard[] constructionYards = mainThread.theAssetManager.constructionYards;
|
|
boolean playerBuildingNearBase = false;
|
|
solidObject[] playerStructures = mainThread.ec.theMapAwarenessAI.playerStructures;
|
|
for(int i = 0; i < playerStructures.length; i++) {
|
|
if(playerStructures[i] != null && playerStructures[i].currentHP > 0) {
|
|
float x1 = playerStructures[i].centre.x;
|
|
float z1 = playerStructures[i].centre.z;
|
|
for(int j = 0; j < constructionYards.length; j++) {
|
|
if(constructionYards[j] != null && constructionYards[j].teamNo != 0 && constructionYards[j].currentHP > 0) {
|
|
float x2 = constructionYards[j].centre.x;
|
|
float z2 = constructionYards[j].centre.z;
|
|
double d = Math.sqrt((x1-x2)*(x1-x2) + (z1-z2)*(z1-z2));
|
|
|
|
if(d < 4) {
|
|
playerBuildingNearBase = true;
|
|
majorThreatCooldown = 30;
|
|
majorThreatLocation.set(playerStructures[i].centre);
|
|
break;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
if(playerBuildingNearBase) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
//take over controls of defenders from combat AI to deal with minor threat
|
|
if(minorThreatLocation.x != 0 && numOfDefenders > 0 && frameAI > 480) {
|
|
takeOverDefendersFromCombatAI();
|
|
|
|
//attack move to threat location
|
|
for(int i =0; i < defenders.length; i++) {
|
|
if(defenders[i] != null) {
|
|
defenders[i].moveTo(minorThreatLocation.x, minorThreatLocation.z);
|
|
defenders[i].currentCommand = solidObject.attackMove;
|
|
defenders[i].secondaryCommand = solidObject.attackMove;
|
|
}
|
|
}
|
|
}
|
|
|
|
//check if the minor threat is being dealt with
|
|
if(minorThreatLocation.x == 0) {
|
|
boolean defenersInStandbyMode = true;
|
|
for(int i = 0; i < defenders.length; i++) {
|
|
if(defenders[i] != null && defenders[i].currentHP > 0) {
|
|
if(defenders[i].currentCommand != 0)
|
|
defenersInStandbyMode = false;
|
|
}
|
|
}
|
|
|
|
//if defenders are idle then make sure that combatAI has control of the defenders.
|
|
if(defenersInStandbyMode) {
|
|
giveBackControlOfDefendersToCombatAI();
|
|
|
|
//move back to rally point
|
|
for(int i =0; i < defenders.length; i++) {
|
|
if(defenders[i] != null && frameAI%20==0) {
|
|
defenders[i].moveTo(mainThread.ec.theUnitProductionAI.rallyPoint.x, mainThread.ec.theUnitProductionAI.rallyPoint.z);
|
|
defenders[i].currentCommand = solidObject.attackMove;
|
|
defenders[i].secondaryCommand = solidObject.attackMove;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
int numOfConstructionYard = 0;
|
|
|
|
for(int i = 0; i < constructionYards.length; i++){
|
|
if(constructionYards[i] != null && constructionYards[i].teamNo != 0 && constructionYards[i].currentHP >0) {
|
|
numOfConstructionYard++;
|
|
}
|
|
}
|
|
|
|
boolean gunTurretAlreadyInQueue = false;
|
|
boolean missileTurretAlreadyInQueue = false;
|
|
|
|
//check if AI needs to build static defenses
|
|
/*
|
|
build a gun turret when any of the following conditions are met:
|
|
1. there are more than 1 construction yard
|
|
2. there is no other gun turret being constructed at the same time
|
|
3. not major threat detected
|
|
|
|
build a missile turret when any of the following conditions are met:
|
|
1. there are more than 1 construction yard
|
|
2. there is no other missile turret being constructed at the same time
|
|
3. major threat detected
|
|
*/
|
|
|
|
needGunTurret = false;
|
|
needMissileTurret = false;
|
|
|
|
if(numOfConstructionYard > 1) {
|
|
for(int i = 0; i < constructionYards.length; i ++){
|
|
if(constructionYards[i] != null && constructionYards[i].teamNo != 0 && constructionYards[i].currentHP > 0){
|
|
if(constructionYards[i].currentBuildingType == 200){
|
|
gunTurretAlreadyInQueue = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
for(int i = 0; i < constructionYards.length; i ++){
|
|
if(constructionYards[i] != null && constructionYards[i].teamNo != 0 && constructionYards[i].currentHP > 0){
|
|
if(constructionYards[i].currentBuildingType == 199){
|
|
missileTurretAlreadyInQueue = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if(!gunTurretAlreadyInQueue && majorThreatLocation.x ==0) {
|
|
needGunTurret = true;
|
|
}
|
|
|
|
if(!missileTurretAlreadyInQueue && majorThreatLocation.x != 0 && (mainPlayerForceSize !=0 || playerBuildingNearBase)) {
|
|
needMissileTurret = true;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//check if AI needs to deploy static defense
|
|
/*
|
|
Deploy gun turret if the minor/major threat is close enough to the construction yard
|
|
*/
|
|
|
|
solidObject[] AIStructures = mainThread.ec.theMapAwarenessAI.AIStructures;
|
|
gunTurretDeployLocation.reset();
|
|
missileTurretDeployLocation.reset();
|
|
|
|
int numOfGunTurretNearThreat = 0;
|
|
int numOfMissileTurretNearThreat = 0;
|
|
|
|
|
|
if(minorThreatLocation.x !=0){
|
|
for(int i = 0; i < AIStructures.length; i++) {
|
|
if(AIStructures[i] != null && AIStructures[i].teamNo !=0 && AIStructures[i].currentHP > 0 && (AIStructures[i].type == 200 || AIStructures[i].type == 199)) {
|
|
float d = (float)Math.sqrt((minorThreatLocation.x-AIStructures[i].centre.x)*(minorThreatLocation.x-AIStructures[i].centre.x) +
|
|
(minorThreatLocation.z-AIStructures[i].centre.z)*(minorThreatLocation.z-AIStructures[i].centre.z));
|
|
|
|
if(AIStructures[i].type == 200 && d <= 2.5)
|
|
numOfGunTurretNearThreat++;
|
|
if(AIStructures[i].type == 199 && d <= 2.9)
|
|
numOfMissileTurretNearThreat++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(majorThreatLocation.x !=0){
|
|
numOfGunTurretNearThreat = 0;
|
|
numOfMissileTurretNearThreat = 0;
|
|
|
|
for(int i = 0; i < AIStructures.length; i++) {
|
|
if(AIStructures[i] != null && AIStructures[i].teamNo !=0 && AIStructures[i].currentHP > 0 && (AIStructures[i].type == 200 || AIStructures[i].type == 199)) {
|
|
float d = (float)Math.sqrt((majorThreatLocation.x-AIStructures[i].centre.x)*(majorThreatLocation.x-AIStructures[i].centre.x) +
|
|
(majorThreatLocation.z-AIStructures[i].centre.z)*(majorThreatLocation.z-AIStructures[i].centre.z));
|
|
|
|
if(AIStructures[i].type == 200 && d <= 2.5)
|
|
numOfGunTurretNearThreat++;
|
|
if(AIStructures[i].type == 199 && d <= 2.9)
|
|
numOfMissileTurretNearThreat++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
for(int i = 0; i < constructionYards.length; i++){
|
|
if(constructionYards[i] != null && constructionYards[i].teamNo != 0 && constructionYards[i].currentHP >0) {
|
|
|
|
float distanceToThreat = 999f;
|
|
|
|
|
|
float threatX = 0;
|
|
float threatZ = 0;
|
|
|
|
if(minorThreatLocation.x !=0) {
|
|
distanceToThreat = (float)Math.sqrt((minorThreatLocation.x-constructionYards[i].centre.x)*(minorThreatLocation.x-constructionYards[i].centre.x) +
|
|
(minorThreatLocation.z-constructionYards[i].centre.z)*(minorThreatLocation.z-constructionYards[i].centre.z));
|
|
threatX = minorThreatLocation.x;
|
|
threatZ = minorThreatLocation.z;
|
|
}
|
|
|
|
if(majorThreatLocation.x !=0) {
|
|
distanceToThreat = (float)Math.sqrt((majorThreatLocation.x-constructionYards[i].centre.x)*(majorThreatLocation.x-constructionYards[i].centre.x) +
|
|
(majorThreatLocation.z-constructionYards[i].centre.z)*(majorThreatLocation.z-constructionYards[i].centre.z));
|
|
threatX = majorThreatLocation.x;
|
|
threatZ = majorThreatLocation.z;
|
|
}
|
|
|
|
|
|
//find deploy location of gun turret
|
|
if(threatX != 0 && distanceToThreat < 4.75 && (numOfGunTurretNearThreat < (float)mainPlayerForceSize/3 || playerBuildingNearBase)) {
|
|
|
|
float d = 1.85f; //minimum deploy distance from conyard
|
|
if(distanceToThreat > d + gunTurret.attackRange)
|
|
d = distanceToThreat - gunTurret.attackRange;
|
|
if(distanceToThreat < 3.5)
|
|
d = 1.75f;
|
|
|
|
gunTurretDeployLocation.x = constructionYards[i].centre.x + (threatX - constructionYards[i].centre.x)/distanceToThreat*d;
|
|
gunTurretDeployLocation.z = constructionYards[i].centre.z + (threatZ - constructionYards[i].centre.z)/distanceToThreat*d;
|
|
|
|
|
|
}
|
|
|
|
//find deploy location of missile turret
|
|
if(threatX != 0 && distanceToThreat < 5.15 && (numOfMissileTurretNearThreat < mainPlayerForceSize/6 || (playerBuildingNearBase && numOfMissileTurretNearThreat < 2))) {
|
|
|
|
float d = 1.65f; //minimum deploy distance from conyard
|
|
if(distanceToThreat > d + missileTurret.attackRange)
|
|
d = distanceToThreat - missileTurret.attackRange;
|
|
if(distanceToThreat < 4.75)
|
|
d = 1.25f;
|
|
|
|
missileTurretDeployLocation.x = constructionYards[i].centre.x + (threatX - constructionYards[i].centre.x)/distanceToThreat*d;
|
|
missileTurretDeployLocation.z = constructionYards[i].centre.z + (threatZ - constructionYards[i].centre.z)/distanceToThreat*d;
|
|
}
|
|
}
|
|
}
|
|
|
|
//tell the factory that are closest to the threat location to build a repair drone
|
|
float threatX = 0;
|
|
float threatZ = 0;
|
|
|
|
if(minorThreatLocation.x !=0) {
|
|
threatX = minorThreatLocation.x;
|
|
threatZ = minorThreatLocation.z;
|
|
}
|
|
|
|
if(majorThreatLocation.x !=0) {
|
|
threatX = majorThreatLocation.x;
|
|
threatZ = majorThreatLocation.z;
|
|
}
|
|
|
|
factory cloestFactory = null;
|
|
factory[] factories = mainThread.theAssetManager.factories;
|
|
float threatDistance = 999f;
|
|
for(int i = 0; i < factories.length; i++) {
|
|
if(factories[i] !=null && factories[i].teamNo !=0 && factories[i].currentHP > 0) {
|
|
float xPos = factories[i].centre.x;
|
|
float zPos = factories[i].centre.z;
|
|
double d = Math.sqrt( (threatX - xPos)*(threatX - xPos) + (threatZ - zPos)*(threatZ - zPos));
|
|
if(d < 5f && d < threatDistance) {
|
|
threatDistance = (float)d;
|
|
cloestFactory = factories[i];
|
|
}
|
|
}
|
|
}
|
|
if(cloestFactory != null && cloestFactory.numOfDrones == 0 && cloestFactory.numOfDroneOnQueue == 0) {
|
|
cloestFactory.cancelItemFromProductionQueue(factory.lightTankType);
|
|
cloestFactory.cancelItemFromProductionQueue(factory.rocketTankType);
|
|
cloestFactory.cancelItemFromProductionQueue(factory.stealthTankType);
|
|
cloestFactory.cancelItemFromProductionQueue(factory.heavyTankType);
|
|
cloestFactory.buildDrone();
|
|
}
|
|
|
|
|
|
//enable rapid fire ability for missiles turrets
|
|
if(communicationCenter.rapidfireResearched_enemy) {
|
|
for(int i = 0; i < AIStructures.length; i++) {
|
|
if(AIStructures[i] != null && AIStructures[i].currentHP > 0 && AIStructures[i].teamNo == 1 && AIStructures[i].type == 199) {
|
|
missileTurret t = (missileTurret)AIStructures[i];
|
|
if(t.targetObject != null && t.overCharge == false) {
|
|
mainThread.ec.theBaseInfo.numberOfOverChargedMissileTurret++;
|
|
t.overCharge = true;
|
|
mainThread.ec.theBaseInfo.reCalculatePower();
|
|
if(mainThread.ec.theBaseInfo.currentPowerConsumption > mainThread.ec.theBaseInfo.currentPowerLevel) {
|
|
mainThread.ec.theBaseInfo.numberOfOverChargedMissileTurret--;
|
|
t.overCharge = false;
|
|
mainThread.ec.theBaseInfo.reCalculatePower();
|
|
}
|
|
}else if((t.targetObject == null || mainThread.ec.theBaseInfo.currentPowerConsumption > mainThread.ec.theBaseInfo.currentPowerLevel) && t.overCharge == true) {
|
|
mainThread.ec.theBaseInfo.numberOfOverChargedMissileTurret--;
|
|
t.overCharge = false;
|
|
mainThread.ec.theBaseInfo.reCalculatePower();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public float playerForceIsMovingTwoardsBase(vector location, vector direction) {
|
|
float threatDistance = 999f;
|
|
for(int i = 0; i < mainThread.theAssetManager.refineries.length;i++) {
|
|
if(mainThread.theAssetManager.refineries[i] != null && mainThread.theAssetManager.refineries[i].teamNo != 0) {
|
|
float xPos = mainThread.theAssetManager.refineries[i].nearestGoldMine.centre.x;
|
|
float zPos = mainThread.theAssetManager.refineries[i].nearestGoldMine.centre.z;
|
|
|
|
threatToBaseDirection.set(xPos - location.x, 0, zPos - location.z);
|
|
float d = threatToBaseDirection.getLength();
|
|
threatToBaseDirection.unit();
|
|
if(threatToBaseDirection.dot(direction) > 0.8) {
|
|
|
|
float currentThreatDistance = Math.max(3f, d);
|
|
|
|
if(currentThreatDistance < threatDistance)
|
|
threatDistance = currentThreatDistance;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
if(threatDistance == 999)
|
|
return -1;
|
|
|
|
return threatDistance;
|
|
}
|
|
|
|
public void giveBackControlOfDefendersToCombatAI() {
|
|
for(int i = 0; i < defenders.length; i++) {
|
|
if(defenders[i] == null)
|
|
continue;
|
|
|
|
if(defenders[i].type == 6) {
|
|
boolean alreadyControledByCombatAI = false;
|
|
for(int j = 0; j < stealthTanksControlledByCombatAI.length; j++) {
|
|
if(defenders[i] == stealthTanksControlledByCombatAI[j]) {
|
|
alreadyControledByCombatAI = true;
|
|
break;
|
|
}
|
|
}
|
|
if(!alreadyControledByCombatAI)
|
|
mainThread.ec.theUnitProductionAI.addStealthTank((stealthTank)defenders[i]);
|
|
}else if(defenders[i].type == 0) {
|
|
boolean alreadyControledByCombatAI = false;
|
|
for(int j = 0; j < lightTanksControlledByCombatAI.length; j++) {
|
|
if(defenders[i] == lightTanksControlledByCombatAI[j]) {
|
|
alreadyControledByCombatAI = true;
|
|
break;
|
|
}
|
|
}
|
|
if(!alreadyControledByCombatAI)
|
|
mainThread.ec.theUnitProductionAI.addLightTank((lightTank)defenders[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void takeOverDefendersFromCombatAI() {
|
|
for(int i = 0; i < defenders.length; i++) {
|
|
if(defenders[i] == null)
|
|
continue;
|
|
|
|
if(defenders[i].type == 6) {
|
|
for(int j = 0; j < stealthTanksControlledByCombatAI.length; j++) {
|
|
if(defenders[i] == stealthTanksControlledByCombatAI[j]) {
|
|
stealthTanksControlledByCombatAI[j] = null;
|
|
break;
|
|
}
|
|
}
|
|
}else if(defenders[i].type == 0) {
|
|
for(int j = 0; j < lightTanksControlledByCombatAI.length; j++) {
|
|
if(defenders[i] == lightTanksControlledByCombatAI[j]) {
|
|
lightTanksControlledByCombatAI[j] = null;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean playerForceIsNearBase(vector location) {
|
|
for(int i = 0; i < mainThread.ec.theMapAwarenessAI.AIStructures.length; i++) {
|
|
if(mainThread.ec.theMapAwarenessAI.AIStructures[i] == null)
|
|
continue;
|
|
float xPos = mainThread.ec.theMapAwarenessAI.AIStructures[i].centre.x;
|
|
float zPos = mainThread.ec.theMapAwarenessAI.AIStructures[i].centre.z;
|
|
float d = (location.x - xPos)*(location.x - xPos) + (location.z - zPos)*(location.z - zPos);
|
|
if(d < 9)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public int numOfHeavyTankAroundLocation(vector location) {
|
|
solidObject o = null;
|
|
int numberOfHeaveyTankNearLocation = 0;
|
|
for(int i = 0; i < mainThread.ec.theMapAwarenessAI.playerUnitInMinimap.length; i++) {
|
|
o = mainThread.ec.theMapAwarenessAI.playerUnitInMinimap[i];
|
|
if(o !=null && o.currentHP > 0 && o.type == 7 && (o.centre.x - location.x)*(o.centre.x - location.x) + (o.centre.z - location.z)*(o.centre.z - location.z) < 4)
|
|
numberOfHeaveyTankNearLocation++;
|
|
}
|
|
|
|
return numberOfHeaveyTankNearLocation;
|
|
}
|
|
|
|
public void addUnitToDefenders(solidObject o) {
|
|
numOfDefenders = 0;
|
|
boolean defenersInStandbyMode = true;
|
|
for(int i = 0; i < defenders.length; i++) {
|
|
if(defenders[i] != null && defenders[i].currentHP > 0) {
|
|
numOfDefenders++;
|
|
if(defenders[i].currentCommand != 0)
|
|
defenersInStandbyMode = false;
|
|
}
|
|
}
|
|
|
|
|
|
if(numOfDefenders == defenders.length && (minorThreatLocation.x == 0 && defenersInStandbyMode || minorThreatLocation.x != 0 && newUnitIsCloserToThreat(o))) {
|
|
giveBackControlOfDefendersToCombatAI();
|
|
for(int i = defenders.length - 1; i > 0; i--)
|
|
defenders[i] = defenders[i - 1];
|
|
defenders[0] = o;
|
|
}else {
|
|
for(int i = 0; i < defenders.length; i++) {
|
|
if(defenders[i] == null || defenders[i].currentHP <= 0) {
|
|
defenders[i] = o;
|
|
numOfDefenders++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean newUnitIsCloserToThreat(solidObject o) {
|
|
float d = (o.centre.x - minorThreatLocation.x)*(o.centre.x - minorThreatLocation.x) + (o.centre.z - minorThreatLocation.z)*(o.centre.z - minorThreatLocation.z);
|
|
for(int i = 0; i < defenders.length; i++) {
|
|
if(defenders[i] != null && defenders[i].currentHP > 0) {
|
|
if(d > (defenders[i].centre.x - minorThreatLocation.x)*(defenders[i].centre.x - minorThreatLocation.x) + (defenders[i].centre.z - minorThreatLocation.z)*(defenders[i].centre.z - minorThreatLocation.z)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
public boolean evadePlayerUnit(int observerIndex){
|
|
//scan for hostile unit
|
|
int[] tileCheckList = stealthTank.tileCheckList;
|
|
|
|
int currentOccupiedTile = (int)(observers[observerIndex].centre.x*64)/16 + (127 - (int)(observers[observerIndex].centre.z*64)/16)*128;
|
|
|
|
|
|
direction.set(0,0,0);
|
|
boolean directionSet = false;
|
|
|
|
for(int i = 0; i < tileCheckList.length; i++){
|
|
if(tileCheckList[i] != Integer.MAX_VALUE){
|
|
int index = currentOccupiedTile + tileCheckList[i];
|
|
if(index < 0 || index >= 16384 || Math.abs(index%128 - currentOccupiedTile%128) > 20)
|
|
continue;
|
|
solidObject[] tile = mainThread.gridMap.tiles[index];
|
|
|
|
for(int j = 0; j < 4; j++){
|
|
if(tile[j] != null){
|
|
if(tile[j].teamNo != observers[observerIndex].teamNo && tile[j].teamNo != -1 && tile[j].currentHP > 0 && !tile[j].isCloaked){
|
|
|
|
|
|
if(directionSet)
|
|
break;
|
|
|
|
double d = Math.sqrt((tile[j].centre.x - observers[observerIndex].centre.x)*(tile[j].centre.x - observers[observerIndex].centre.x)
|
|
+ (tile[j].centre.z - observers[observerIndex].centre.z)*(tile[j].centre.z - observers[observerIndex].centre.z));
|
|
|
|
if(d < 0.75) {
|
|
|
|
direction.set(observers[observerIndex].centre);
|
|
direction.subtract(tile[j].centre);
|
|
direction.unit();
|
|
|
|
directionSet = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if(directionSet) {
|
|
observers[observerIndex].moveTo(observers[observerIndex].centre.x + direction.x , observers[observerIndex].centre.z + direction.z);
|
|
observers[observerIndex].currentCommand = solidObject.move;
|
|
observers[observerIndex].secondaryCommand = solidObject.StandBy;
|
|
}
|
|
|
|
return directionSet;
|
|
|
|
}
|
|
|
|
}
|