132fa5ebc0
view of the back ground. Also the screen resolution and the shadowmap resolution are no longer hard coded everywhere. They are defined in mainThread.java.
2073 lines
73 KiB
Java
2073 lines
73 KiB
Java
package entity;
|
|
|
|
import java.awt.Rectangle;
|
|
|
|
import core.*;
|
|
import enemyAI.enemyCommander;
|
|
|
|
//the factory model
|
|
public class factory extends solidObject{
|
|
|
|
//the polygons of the model
|
|
private polygon3D[] polygons;
|
|
private polygon3D[] doorUpper;
|
|
private polygon3D[] doorLower;
|
|
private polygon3D[] fanA;
|
|
private polygon3D[] fanB;
|
|
|
|
public static int maxHP = 850;
|
|
|
|
public int countDownToDeath = 16;
|
|
|
|
public vector tempVector = new vector(0,0,0);
|
|
public vector tempVector0 = new vector(0,0,0);
|
|
public vector tempVector1 = new vector(0,0,0);
|
|
public vector tempVector2 = new vector(0,0,0);
|
|
public vector tempVector3 = new vector(0,0,0);
|
|
|
|
//factory occupies 6 tiles
|
|
public int [] tileIndex = new int[6];
|
|
|
|
public int[] tempInt;
|
|
|
|
public float[] tempFloat;
|
|
|
|
public vector shadowvertex0, tempshadowvertex0,shadowvertex1, tempshadowvertex1,shadowvertex2, tempshadowvertex2,shadowvertex3, tempshadowvertex3;
|
|
|
|
//a screen space boundary which is used to test if the object is visible from camera point of view
|
|
public final static Rectangle visibleBoundary = new Rectangle(-85,-85,screen_width+152, screen_height+250);
|
|
|
|
//a screen space boundary which is used to test if the entire object is within the screen
|
|
public final static Rectangle screenBoundary = new Rectangle(60,60,screen_width-120, screen_height-110);
|
|
|
|
//screen space boundary which is used to test if the shadow of the object is within the screen
|
|
public final static Rectangle shadowBoundary1 = new Rectangle(30,70,screen_width-30, screen_height-30);
|
|
|
|
//a screen space boundary which is used to test if the vision polygon of the object is visible.
|
|
public final static Rectangle visionBoundary = new Rectangle(0,0,1600, 2000);
|
|
|
|
//a bitmap representation of the vision of the building for enemy commander
|
|
public static boolean[] bitmapVisionForEnemy;
|
|
|
|
//factory never moves
|
|
public final static vector movenment = new vector(0,0,0);
|
|
|
|
//number of polygons
|
|
public int numOfPolygons;
|
|
|
|
//distortion polygon index
|
|
public int distortionA, distortionB;
|
|
|
|
//power tower center
|
|
public vector powerTowerCenterA, powerTowerCenterB;
|
|
|
|
public boolean canBuildLightTank, canBuildDrone, canBuildRocketTank, canBuildHarvester, canBuildStealthTank, canBuildHeavyTank, canBuildMCV;
|
|
public int lightTankProgress, droneProgress, rocketTankProgress, harvesterProgress, stealthTankProgress, heavyTankProgress, MCVProgress;
|
|
public int creditSpentOnBuilding;
|
|
public baseInfo theBaseInfo;
|
|
public byte[] productionQueue;
|
|
public int numOfLightTankOnQueue, numOfRocketTankOnQueue, numOfStealthTankOnQueue, numOfHarvesterOnQueue, numOfHeavyTankOnQueue, numOfDroneOnQueue, numOfMCVOnQueue;
|
|
public int numOfDrones;
|
|
public boolean isDeliveringUnit, doorOpened, doorClosed, openingDoor, closingDoor;
|
|
public float doorHeightMark;
|
|
public boolean doorHeightMarked;
|
|
public solidObject deliveredUnit;
|
|
|
|
|
|
public static int lightTankType = 0;
|
|
public static int rocketTankType = 1;
|
|
public static int harvesterType = 2;
|
|
public static int droneType = 5;
|
|
public static int MCVType = 3;
|
|
public static int stealthTankType = 6;
|
|
public static int heavyTankType = 7;
|
|
|
|
public int currentStatus;
|
|
public static int isBuilding = 1;
|
|
public static int isIdle = 0;
|
|
|
|
public vector rallyCenter;
|
|
public vector[] rallyPoints;
|
|
public boolean rallyPointChanged;
|
|
|
|
public goldMine targetGoldMine;
|
|
|
|
public drone[] myDrones;
|
|
|
|
|
|
|
|
public factory(float x, float y, float z, int teamNo){
|
|
//uncontrollable unit, but act as a big sized static collidable agent
|
|
type = 105;
|
|
|
|
currentHP = 850;
|
|
|
|
myDrones = new drone[3];
|
|
|
|
if(teamNo == 0){
|
|
isRevealed = true;
|
|
theBaseInfo = mainThread.pc.theBaseInfo;
|
|
}else{
|
|
theBaseInfo = mainThread.ec.theBaseInfo;
|
|
}
|
|
|
|
theBaseInfo.numberOfFactory++;
|
|
|
|
this.teamNo = teamNo;
|
|
|
|
ID = globalUniqID++;
|
|
|
|
currentCommand = StandBy;
|
|
|
|
if(teamNo == 0){
|
|
isRevealed = true;
|
|
}
|
|
|
|
if(bitmapVisionForEnemy == null){
|
|
bitmapVisionForEnemy = createBitmapVision(8);
|
|
}
|
|
|
|
lightTankProgress = 255;
|
|
droneProgress = 255;
|
|
rocketTankProgress = 255;
|
|
harvesterProgress = 255;
|
|
stealthTankProgress = 255;
|
|
heavyTankProgress = 255;
|
|
MCVProgress = 255;
|
|
|
|
//create 2D boundary
|
|
boundary2D = new Rect((int)(x*64) - 24, (int)(z*64) + 16, 48, 32);
|
|
boundary2D.owner = this;
|
|
int centerX = (int)(x*64);
|
|
int centerY = (int)(z*64);
|
|
|
|
tileIndex[0] = (centerX - 16)/16 + (127 - (centerY + 8)/16)*128;
|
|
tileIndex[1] = (centerX + 16)/16 + (127 - (centerY + 8)/16)*128;
|
|
tileIndex[2] = (centerX + 16)/16 + (127 - (centerY - 8)/16)*128;
|
|
tileIndex[3] = (centerX - 16)/16 + (127 - (centerY - 8)/16)*128;
|
|
tileIndex[4] = (centerX)/16 + (127 - (centerY + 8)/16)*128;
|
|
tileIndex[5] = (centerX)/16 + (127 - (centerY - 8)/16)*128;
|
|
|
|
|
|
|
|
mainThread.gridMap.tiles[tileIndex[0]][0] = this;
|
|
mainThread.gridMap.tiles[tileIndex[1]][0] = this;
|
|
mainThread.gridMap.tiles[tileIndex[2]][0] = this;
|
|
mainThread.gridMap.tiles[tileIndex[3]][0] = this;
|
|
mainThread.gridMap.tiles[tileIndex[4]][0] = this;
|
|
mainThread.gridMap.tiles[tileIndex[5]][0] = this;
|
|
|
|
|
|
mainThread.gridMap.tiles[tileIndex[0]][1] = this;
|
|
mainThread.gridMap.tiles[tileIndex[1]][1] = this;
|
|
mainThread.gridMap.tiles[tileIndex[2]][1] = this;
|
|
mainThread.gridMap.tiles[tileIndex[3]][1] = this;
|
|
mainThread.gridMap.tiles[tileIndex[4]][1] = this;
|
|
mainThread.gridMap.tiles[tileIndex[5]][1] = this;
|
|
|
|
mainThread.gridMap.tiles[tileIndex[0]][2] = this;
|
|
mainThread.gridMap.tiles[tileIndex[1]][2] = this;
|
|
mainThread.gridMap.tiles[tileIndex[2]][2] = this;
|
|
mainThread.gridMap.tiles[tileIndex[3]][2] = this;
|
|
mainThread.gridMap.tiles[tileIndex[4]][2] = this;
|
|
mainThread.gridMap.tiles[tileIndex[5]][2] = this;
|
|
|
|
mainThread.gridMap.tiles[tileIndex[0]][3] = this;
|
|
mainThread.gridMap.tiles[tileIndex[1]][3] = this;
|
|
mainThread.gridMap.tiles[tileIndex[2]][3] = this;
|
|
mainThread.gridMap.tiles[tileIndex[3]][3] = this;
|
|
mainThread.gridMap.tiles[tileIndex[4]][3] = this;
|
|
mainThread.gridMap.tiles[tileIndex[5]][3] = this;
|
|
|
|
|
|
mainThread.gridMap.tiles[tileIndex[0]][4] = this;
|
|
mainThread.gridMap.tiles[tileIndex[1]][4] = this;
|
|
mainThread.gridMap.tiles[tileIndex[2]][4] = this;
|
|
mainThread.gridMap.tiles[tileIndex[3]][4] = this;
|
|
mainThread.gridMap.tiles[tileIndex[4]][4] = this;
|
|
mainThread.gridMap.tiles[tileIndex[5]][4] = this;
|
|
|
|
int tileIndex6 = tileIndex[5] + 128;
|
|
int tileIndex7 = tileIndex[5] + 128 - 1;
|
|
int tileIndex8 = tileIndex[5] + 128 + 1;
|
|
mainThread.gridMap.tiles[tileIndex6][4] = this;
|
|
mainThread.gridMap.tiles[tileIndex7][4] = this;
|
|
mainThread.gridMap.tiles[tileIndex8][4] = this;
|
|
|
|
|
|
//init model
|
|
start = new vector(x,y,z);
|
|
iDirection = new vector(1f,0,0);
|
|
jDirection = new vector(0,1f,0);
|
|
kDirection = new vector(0,0,1f);
|
|
|
|
|
|
//define centre of the model in world coordinate
|
|
start = new vector(x,y,z);
|
|
centre = start.myClone();
|
|
tempCentre = start.myClone();
|
|
|
|
shadowvertex0 =start.myClone();
|
|
shadowvertex0.add(-0.45f,-0.2f, -0.3f);
|
|
tempshadowvertex0 = new vector(0,0,0);
|
|
|
|
shadowvertex1 =start.myClone();
|
|
shadowvertex1.add(-0.45f,-0.2f, 0.2f);
|
|
tempshadowvertex1 = new vector(0,0,0);
|
|
|
|
shadowvertex2 =start.myClone();
|
|
shadowvertex2.add(0.2f,-0.2f, -0.3f);
|
|
tempshadowvertex2 = new vector(0,0,0);
|
|
|
|
shadowvertex3 =start.myClone();
|
|
shadowvertex3.add(0.2f,-0.2f, 0.2f);
|
|
tempshadowvertex3 = new vector(0,0,0);
|
|
|
|
makePolygons();
|
|
|
|
productionQueue = new byte[1000];
|
|
for(int i = 0; i < productionQueue.length; i++)
|
|
productionQueue[i] = -1;
|
|
|
|
doorClosed = true;
|
|
|
|
rallyCenter = new vector(centre.x,-0.3f,centre.z-0.625f);
|
|
float l = 0.25f;
|
|
rallyPoints = new vector[]{
|
|
new vector(0,0,-l-0.03f), new vector(l + 0.075f,0,-l-0.03f), new vector(-l -0.075f,0,-l-0.03f),
|
|
new vector(l+0.075f,0,0), new vector(-l-0.075f,0,0), new vector(0,0,0),
|
|
new vector(-l-0.1f,0,l), new vector(l,0,l), new vector(0,0,l)
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
public void makePolygons(){
|
|
polygons = new polygon3D[300];
|
|
|
|
int polyIndex;
|
|
|
|
int factorySkin = 51;
|
|
int roofSkin = 44;
|
|
if(teamNo == 1)
|
|
roofSkin = 53;
|
|
|
|
|
|
//roof
|
|
v = new vector[]{put(-0.27, 0.56, 0.16), put(0.11, 0.56, 0.16), put(0.11, 0.56, 0.1), put(-0.27, 0.56, 0.1)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[roofSkin], 10,2,1));
|
|
|
|
v = new vector[]{put(0.11, 0.56, 0.16), put(-0.27, 0.56, 0.16), put(-0.27, 0.55, 0.16), put(0.11, 0.55, 0.16)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[roofSkin], 10,1,1));
|
|
|
|
v = new vector[]{put(0.11, 0.55, 0.1), put(-0.27, 0.55, 0.1), put(-0.27, 0.56, 0.1), put(0.11, 0.56, 0.1)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[roofSkin], 10,1,1));
|
|
|
|
v = new vector[]{put(0.11, 0.56, 0.1), put(0.11, 0.56, 0.16), put(0.204, 0.3, 0.16), put(0.204, 0.3, 0.1)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[roofSkin], 1,10,1));
|
|
|
|
v = new vector[]{put(0.11, 0.56, 0.1), put(0.204, 0.3, 0.1), put(0.19, 0.3, 0.1), put(0.094, 0.56, 0.1)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[roofSkin], 10,10,1));
|
|
|
|
v = new vector[]{put(0.094, 0.56, 0.16), put(0.19, 0.3, 0.16), put(0.204, 0.3, 0.16), put(0.11, 0.56, 0.16)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[roofSkin], 10,10,1));
|
|
|
|
v = new vector[]{put(-0.27, 0.56, 0.16), put(-0.27, 0.56, 0.1), put(-0.364, 0.3, 0.1), put(-0.364, 0.3, 0.16)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[roofSkin], 1,10,1));
|
|
|
|
v = new vector[]{put(-0.27, 0.56, 0.16), put(-0.364, 0.3, 0.16), put(-0.35, 0.3, 0.16), put(-0.255, 0.56, 0.16)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[roofSkin], 10,10,1));
|
|
|
|
v = new vector[]{put(-0.255, 0.56, 0.1), put(-0.35, 0.3, 0.1), put(-0.364, 0.3, 0.1), put(-0.27, 0.56, 0.1)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[roofSkin], 10,10,1));
|
|
|
|
start.z-=0.27f;
|
|
v = new vector[]{put(-0.27, 0.56, 0.16), put(0.11, 0.56, 0.16), put(0.11, 0.56, 0.1), put(-0.27, 0.56, 0.1)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[roofSkin], 10,2,1));
|
|
|
|
v = new vector[]{put(0.11, 0.56, 0.16), put(-0.27, 0.56, 0.16), put(-0.27, 0.55, 0.16), put(0.11, 0.55, 0.16)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[roofSkin], 10,1,1));
|
|
|
|
v = new vector[]{put(0.11, 0.55, 0.1), put(-0.27, 0.55, 0.1), put(-0.27, 0.56, 0.1), put(0.11, 0.56, 0.1)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[roofSkin], 10,1,1));
|
|
|
|
v = new vector[]{put(0.11, 0.56, 0.1), put(0.11, 0.56, 0.16), put(0.204, 0.3, 0.16), put(0.204, 0.3, 0.1)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[roofSkin], 1,10,1));
|
|
|
|
v = new vector[]{put(0.11, 0.56, 0.1), put(0.204, 0.3, 0.1), put(0.19, 0.3, 0.1), put(0.094, 0.56, 0.1)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[roofSkin], 10,10,1));
|
|
|
|
v = new vector[]{put(0.094, 0.56, 0.16), put(0.19, 0.3, 0.16), put(0.204, 0.3, 0.16), put(0.11, 0.56, 0.16)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[roofSkin], 10,10,1));
|
|
|
|
v = new vector[]{put(-0.27, 0.56, 0.16), put(-0.27, 0.56, 0.1), put(-0.364, 0.3, 0.1), put(-0.364, 0.3, 0.16)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[roofSkin], 1,10,1));
|
|
|
|
v = new vector[]{put(-0.27, 0.56, 0.16), put(-0.364, 0.3, 0.16), put(-0.35, 0.3, 0.16), put(-0.255, 0.56, 0.16)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[roofSkin], 10,10,1));
|
|
|
|
v = new vector[]{put(-0.255, 0.56, 0.1), put(-0.35, 0.3, 0.1), put(-0.364, 0.3, 0.1), put(-0.27, 0.56, 0.1)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[roofSkin], 10,10,1));
|
|
start.z+=0.27f;
|
|
|
|
|
|
|
|
|
|
//main structure
|
|
v = new vector[]{put(-0.26, 0.55, 0.24), put(-0.26, 0.55, -0.24), put(-0.35, 0.3, -0.24), put(-0.35, 0.3, 0.24)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[factorySkin], 1,1,1));
|
|
polygons[polyIndex].shadowBias = 10000;
|
|
|
|
v = new vector[]{put(0.19, 0.3, 0.24), put(0.19, 0.3, -0.24), put(0.1, 0.55, -0.24), put(0.1, 0.55, 0.24)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[factorySkin], 1,1,1));
|
|
polygons[polyIndex].shadowBias = 10000;
|
|
|
|
v = new vector[]{put(-0.26, 0.55, 0.24), put(0.1, 0.55, 0.24), put(0.1, 0.55, -0.24), put(-0.26, 0.55, -0.24)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[factorySkin], 1,1,1));
|
|
polygons[polyIndex].shadowBias = 10000;
|
|
|
|
|
|
v = new vector[]{put(0.085, 0.55, 0.24),put(0.085, 0.55, -0.24), put(0.175, 0.3, -0.24), put(0.175, 0.3, 0.24)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[factorySkin], 1,1,1));
|
|
|
|
v = new vector[]{put(0.085, 0.55, 0.24), put(0.175, 0.3, 0.24), put(0.19, 0.3, 0.24), put(0.1, 0.55, 0.24)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[factorySkin], 1,1,1));
|
|
|
|
|
|
v = new vector[]{put(-0.335, 0.3, 0.24), put(-0.335, 0.3, -0.24), put(-0.245, 0.55, -0.24), put(-0.245, 0.55, 0.24)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[factorySkin], 1,1,1));
|
|
|
|
v = new vector[]{put(-0.245, 0.55, 0.24), put(-0.26, 0.55, 0.24), put(-0.35, 0.3, 0.24),put(-0.335, 0.3, 0.24)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[factorySkin], 1,1,1));
|
|
|
|
|
|
|
|
v = new vector[]{put(0.1, 0.55, 0.225), put(-0.26, 0.55, 0.225), put(-0.35, 0.3, 0.225), put(0.19, 0.3, 0.225)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[factorySkin], 1,1,1));
|
|
polygons[polyIndex].shadowBias = 10000;
|
|
|
|
v = new vector[]{put(0.1, 0.55, 0.24), put(-0.26, 0.55, 0.24), put(-0.26, 0.535, 0.24), put(0.1, 0.535, 0.24)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[factorySkin], 1,1,1));
|
|
|
|
v = new vector[]{put(0.1, 0.535, -0.24), put(-0.26, 0.535, -0.24), put(-0.26, 0.55, -0.24), put(0.1, 0.55, -0.24)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[factorySkin], 1,1,1));
|
|
|
|
v = new vector[]{put(0.1, 0.55, -0.24), put(0.19, 0.3, -0.24), put(0.175, 0.3, -0.24), put(0.085, 0.55, -0.24)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[factorySkin], 1,1,1));
|
|
|
|
v = new vector[]{put(-0.335, 0.3, -0.24), put(-0.35, 0.3, -0.24), put(-0.26, 0.55, -0.24),put(-0.245, 0.55, -0.24)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[factorySkin], 1,1,1));
|
|
|
|
v = new vector[]{put(-0.26, 0.55, -0.225),put(-0.21, 0.55, -0.225), put(-0.21, 0.3, -0.225), put(-0.35, 0.3, -0.225), };
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, put(-0.26, 0.55, -0.225), put(0.1, 0.55, -0.225), put(-0.26, 0, -0.225), mainThread.textures[12], 1,1,1));
|
|
polygons[polyIndex].diffuse_I-=5;
|
|
|
|
v = new vector[]{ put(0.05, 0.55, -0.225),put(0.1, 0.55, -0.225),put(0.19, 0.3, -0.225), put(0.05, 0.3, -0.225)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, put(-0.26, 0.55, -0.225), put(0.1, 0.55, -0.225), put(-0.26, 0, -0.225), mainThread.textures[12], 1,1,1));
|
|
polygons[polyIndex].diffuse_I-=5;
|
|
|
|
v= new vector[]{put(-0.21, 0.55, -0.225), put(0.05, 0.55, -0.225), put(0.05, 0.5, -0.225), put(-0.21, 0.5, -0.225)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, put(-0.26, 0.55, -0.225), put(0.1, 0.55, -0.225), put(-0.26, 0, -0.225), mainThread.textures[12], 1,1,1));
|
|
polygons[polyIndex].diffuse_I-=5;
|
|
|
|
v = new vector[]{put(-0.21, 0.55, -0.225), put(-0.21, 0.55, -0.19), put(-0.21, 0.3, -0.19), put(-0.21, 0.3, -0.225)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,0.7f,1));
|
|
|
|
v = new vector[]{put(0.05, 0.55, -0.19), put(0.05, 0.55, -0.225),put(0.05, 0.3, -0.225), put(0.05, 0.3, -0.19)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,0.7f,1));
|
|
|
|
|
|
int doorIndex = 31;
|
|
if(teamNo != 0)
|
|
doorIndex = 32;
|
|
|
|
|
|
//door lower
|
|
float a = -0.215f;
|
|
float b = a +0.03f;
|
|
float c = b + 0.01f;
|
|
float d = c + 0.03f;
|
|
float e = d + 0.01f;
|
|
float f = e + 0.03f;
|
|
float g = f + 0.01f;
|
|
float h = g + 0.03f;
|
|
float i = h + 0.01f;
|
|
float j = i + 0.03f;
|
|
float k = j + 0.01f;
|
|
float l = k + 0.03f;
|
|
float m = l + 0.01f;
|
|
float n = m + 0.03f;
|
|
|
|
|
|
|
|
v = new vector[]{put(-0.21, 0.38, -0.215), put(0.05, 0.38, -0.215), put(0.05, 0.3, -0.215), put(-0.21, 0.3, -0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[36], 1,0.5f,1));
|
|
|
|
float v1 = a;
|
|
float v2 = a;
|
|
float v3 = b;
|
|
float v4 = c;
|
|
float v5 = d;
|
|
|
|
|
|
v = new vector[]{put(v1, 0.38, -0.215), put(v2, 0.42, -0.215),put(v3, 0.42, -0.215), put(v4, 0.38, -0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v,put(-0.21, 0.42, -0.215), put(0.05, 0.42, -0.215), put(-0.21, 0.38, -0.215), mainThread.textures[doorIndex], 7,0.7f,1));
|
|
|
|
v = new vector[]{put(v2, 0.42, -0.205), put(v2, 0.42, -0.215), put(v1, 0.38, -0.215), put(v1, 0.38, -0.205)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,0.8f,1));
|
|
|
|
v = new vector[]{put(v2, 0.42, -0.215), put(v2, 0.42, -0.205), put(v3, 0.42, -0.205), put(v3, 0.42, -0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,0.8f,1));
|
|
|
|
v = new vector[]{put(v3, 0.42, -0.215), put(v3, 0.42, -0.205), put(v4, 0.38, -0.205), put(v4, 0.38, -0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,0.8f,1));
|
|
|
|
v = new vector[]{put(v4, 0.38, -0.215), put(v4, 0.38, -0.205), put(v5, 0.38, -0.205), put(v5, 0.38, -0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,0.8f,1));
|
|
|
|
v1 = d;
|
|
v2 = e;
|
|
v3 = f;
|
|
v4 = g;
|
|
v5 = h;
|
|
|
|
|
|
v = new vector[]{put(v1, 0.38, -0.215), put(v2, 0.42, -0.215),put(v3, 0.42, -0.215), put(v4, 0.38, -0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v,put(-0.21, 0.42, -0.215), put(0.05, 0.42, -0.215), put(-0.21, 0.38, -0.215), mainThread.textures[doorIndex], 7,0.7f,1));
|
|
|
|
v = new vector[]{put(v2, 0.42, -0.205), put(v2, 0.42, -0.215), put(v1, 0.38, -0.215), put(v1, 0.38, -0.205)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,1f,1));
|
|
|
|
v = new vector[]{put(v2, 0.42, -0.215), put(v2, 0.42, -0.205), put(v3, 0.42, -0.205), put(v3, 0.42, -0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,1f,1));
|
|
|
|
v = new vector[]{put(v3, 0.42, -0.215), put(v3, 0.42, -0.205), put(v4, 0.38, -0.205), put(v4, 0.38, -0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,1f,1));
|
|
|
|
v = new vector[]{put(v4, 0.38, -0.215), put(v4, 0.38, -0.205), put(v5, 0.38, -0.205), put(v5, 0.38, -0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,1f,1));
|
|
|
|
v1 = h;
|
|
v2 = i;
|
|
v3 = j;
|
|
v4 = k;
|
|
v5 = l;
|
|
|
|
|
|
v = new vector[]{put(v1, 0.38, -0.215), put(v2, 0.42, -0.215),put(v3, 0.42, -0.215), put(v4, 0.38, -0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v,put(-0.21, 0.42, -0.215), put(0.05, 0.42, -0.215), put(-0.21, 0.38, -0.215), mainThread.textures[doorIndex], 7,0.7f,1));
|
|
|
|
v = new vector[]{put(v2, 0.42, -0.205), put(v2, 0.42, -0.215), put(v1, 0.38, -0.215), put(v1, 0.38, -0.205)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,1f,1));
|
|
|
|
v = new vector[]{put(v2, 0.42, -0.215), put(v2, 0.42, -0.205), put(v3, 0.42, -0.205), put(v3, 0.42, -0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,1f,1));
|
|
|
|
v = new vector[]{put(v3, 0.42, -0.215), put(v3, 0.42, -0.205), put(v4, 0.38, -0.205), put(v4, 0.38, -0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,1f,1));
|
|
|
|
v = new vector[]{put(v4, 0.38, -0.215), put(v4, 0.38, -0.205), put(v5, 0.38, -0.205), put(v5, 0.38, -0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,1f,1));
|
|
|
|
v1 = l;
|
|
v2 = m;
|
|
v3 = n;
|
|
v4 = n;
|
|
|
|
|
|
|
|
v = new vector[]{put(v1, 0.38, -0.215), put(v2, 0.42, -0.215),put(v3, 0.42, -0.215), put(v4, 0.38, -0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v,put(-0.21, 0.42, -0.215), put(0.05, 0.42, -0.215), put(-0.21, 0.38, -0.215), mainThread.textures[doorIndex], 7,0.7f,1));
|
|
|
|
v = new vector[]{put(v2, 0.42, -0.205), put(v2, 0.42, -0.215), put(v1, 0.38, -0.215), put(v1, 0.38, -0.205)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,1f,1));
|
|
|
|
v = new vector[]{put(v2, 0.42, -0.215), put(v2, 0.42, -0.205), put(v3, 0.42, -0.205), put(v3, 0.42, -0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,1f,1));
|
|
|
|
v = new vector[]{put(v3, 0.42, -0.215), put(v3, 0.42, -0.205), put(v4, 0.38, -0.205), put(v4, 0.38, -0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,1f,1));
|
|
|
|
|
|
doorLower = new polygon3D[20];
|
|
for(int count = 34; count < 54; count++){
|
|
doorLower[count - 34] = polygons[count];
|
|
}
|
|
|
|
|
|
|
|
|
|
//door upper
|
|
v = new vector[]{put(-0.21, 0.57, -0.215), put(0.05, 0.57, -0.215), put(0.05, 0.42, -0.215), put(-0.21, 0.42, -0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[36], 1,0.5f,1));
|
|
|
|
v = new vector[]{put(-0.21, 0.42, -0.205), put(0.05, 0.42, -0.205), put(0.05, 0.57, -0.205), put(-0.21, 0.57, -0.205)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[36], 1,0.5f,1));
|
|
|
|
v = new vector[]{put(-0.21, 0.57, -0.215), put(-0.21, 0.57, -0.205), put(0.05, 0.57, -0.205), put(0.05, 0.57, -0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[36], 0.1f,1f,1));
|
|
|
|
v = new vector[]{put(-0.21, 0.57, -0.205), put(-0.21, 0.57, -0.215), put(-0.21, 0.42, -0.215), put(-0.21, 0.42, -0.205)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[36], 0.1f,1f,1));
|
|
|
|
v = new vector[]{put(0.05, 0.42, -0.205), put(0.05, 0.42, -0.215), put(0.05, 0.57, -0.215), put(0.05, 0.57, -0.205)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[36], 0.1f,1f,1));
|
|
|
|
|
|
v1 = b;
|
|
v2 = e;
|
|
v3 = d;
|
|
v4 = c;
|
|
|
|
v = new vector[]{put(v1, 0.42,-0.215), put(v2, 0.42,-0.215), put(v3, 0.38,-0.215), put(v4, 0.38,-0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v,put(-0.21, 0.42, -0.215), put(0.05, 0.42, -0.215), put(-0.21, 0.38, -0.215), mainThread.textures[doorIndex], 7,0.7f,1));
|
|
|
|
v = new vector[]{put(v2, 0.42,-0.215), put(v2, 0.42,-0.205), put(v3, 0.38,-0.205),put(v3, 0.38,-0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,1f,1));
|
|
|
|
v = new vector[]{put(v1, 0.42,-0.205), put(v1, 0.42,-0.215), put(v4, 0.38,-0.215), put(v4, 0.38,-0.205)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,1f,1));
|
|
|
|
v1 = f;
|
|
v2 = i;
|
|
v3 = h;
|
|
v4 = g;
|
|
|
|
v = new vector[]{put(v1, 0.42,-0.215), put(v2, 0.42,-0.215), put(v3, 0.38,-0.215), put(v4, 0.38,-0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v,put(-0.21, 0.42, -0.215), put(0.05, 0.42, -0.215), put(-0.21, 0.38, -0.215), mainThread.textures[doorIndex], 7,0.7f,1));
|
|
|
|
v = new vector[]{put(v2, 0.42,-0.215), put(v2, 0.42,-0.205), put(v3, 0.38,-0.205),put(v3, 0.38,-0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,1f,1));
|
|
|
|
v = new vector[]{put(v1, 0.42,-0.205), put(v1, 0.42,-0.215), put(v4, 0.38,-0.215), put(v4, 0.38,-0.205)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,1f,1));
|
|
|
|
v1 = j;
|
|
v2 = m;
|
|
v3 = l;
|
|
v4 = k;
|
|
|
|
v = new vector[]{put(v1, 0.42,-0.215), put(v2, 0.42,-0.215), put(v3, 0.38,-0.215), put(v4, 0.38,-0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v,put(-0.21, 0.42, -0.215), put(0.05, 0.42, -0.215), put(-0.21, 0.38, -0.215), mainThread.textures[doorIndex], 7,0.7f,1));
|
|
|
|
v = new vector[]{put(v2, 0.42,-0.215), put(v2, 0.42,-0.205), put(v3, 0.38,-0.205),put(v3, 0.38,-0.215)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,1f,1));
|
|
|
|
v = new vector[]{put(v1, 0.42,-0.205), put(v1, 0.42,-0.215), put(v4, 0.38,-0.215), put(v4, 0.38,-0.205)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[27], 0.1f,1f,1));
|
|
|
|
doorUpper = new polygon3D[14];
|
|
for(int count = 54; count < 68; count++){
|
|
doorUpper[count - 54] = polygons[count];
|
|
}
|
|
|
|
|
|
//power tower A
|
|
float r = 0.08f;
|
|
float delta = (float)Math.PI/8;
|
|
float w = 0.29f;
|
|
h = 0.12f;
|
|
powerTowerCenterA = put(w, 0, h);
|
|
|
|
for(i = 0; i < 16; i++){
|
|
v = new vector[]{put(r*Math.cos(i*delta) + w, 0.5, r*Math.sin(i*delta) + h),
|
|
put(r*Math.cos((i+1)*delta) + w, 0.5, r*Math.sin((i+1)*delta)+h),
|
|
put(r*Math.cos((i+1)*delta) + w, 0.3, r*Math.sin((i+1)*delta)+h),
|
|
put(r*Math.cos(i*delta) + w, 0.3, r*Math.sin(i*delta)+h)
|
|
};
|
|
|
|
tempVector.set(v[1]);
|
|
tempVector.subtract(v[0]);
|
|
tempVector0.set(v[0]);
|
|
tempVector1.set(v[1]);
|
|
tempVector3.set(v[3]);
|
|
tempVector1.add(tempVector);
|
|
|
|
int p = (int)i % 8;
|
|
for(j = 0; j < p; j++){
|
|
tempVector0.subtract(tempVector);
|
|
tempVector1.subtract(tempVector);
|
|
tempVector3.subtract(tempVector);
|
|
}
|
|
|
|
change(w,0.5f,h, tempVector);
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, tempVector0.myClone(),tempVector1.myClone(), tempVector3.myClone(), mainThread.textures[12], 1f,1f,1));
|
|
polygons[polyIndex].textureScaledWidth = (int)(polygons[polyIndex].myTexture.width*0.5);
|
|
polygons[polyIndex].createShadeSpan(tempVector, v[0].myClone(), v[1]);
|
|
}
|
|
|
|
float r1= r - 0.02f;
|
|
for(i = 0; i < 16; i++){
|
|
v = new vector[]{put(r1*Math.cos(i*delta) + w, 0.515, r1*Math.sin(i*delta) + h),
|
|
put(r1*Math.cos((i+1)*delta) + w, 0.515, r1*Math.sin((i+1)*delta)+h),
|
|
put(r*Math.cos((i+1)*delta) + w, 0.5, r*Math.sin((i+1)*delta)+h),
|
|
put(r*Math.cos(i*delta) + w, 0.5, r*Math.sin(i*delta)+h)
|
|
};
|
|
|
|
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(),v[1].myClone(), v[3].myClone(), mainThread.textures[12], 0.1f,0.1f,1));
|
|
}
|
|
|
|
for(i = 0; i < 16; i++){
|
|
v = new vector[]{ put(r1*Math.cos(i*delta) + w, 0.3, r1*Math.sin(i*delta)+h),
|
|
put(r1*Math.cos((i+1)*delta) + w, 0.3, r1*Math.sin((i+1)*delta)+h),
|
|
put(r1*Math.cos((i+1)*delta) + w, 0.515, r1*Math.sin((i+1)*delta)+h),
|
|
put(r1*Math.cos(i*delta) + w, 0.515, r1*Math.sin(i*delta) + h)
|
|
};
|
|
|
|
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(),v[1].myClone(), v[3].myClone(), mainThread.textures[12], 0.1f,1f,1));
|
|
}
|
|
|
|
float r2 = r1-0.035f;
|
|
v = new vector[16];
|
|
for(i = 0; i < 16; i++){
|
|
v[15 - (int)i] = put(r2*Math.cos((i+1)*delta) + w, 0.505, r2*Math.sin((i+1)*delta)+h);
|
|
}
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, put(0,0.505, 1),put(1,0.505, 1), put(0,0.505, 0), mainThread.textures[26], 5f,5f,1));
|
|
|
|
for(i = 0; i < 16; i++){
|
|
v = new vector[]{ put(r2*Math.cos(i*delta) + w, 0.505, r2*Math.sin(i*delta) + h),
|
|
put(r2*Math.cos((i+1)*delta) + w, 0.505, r2*Math.sin((i+1)*delta)+h),
|
|
put(r2*Math.cos((i+1)*delta) + w, 0.47, r2*Math.sin((i+1)*delta)+h),
|
|
put(r2*Math.cos(i*delta) + w, 0.47, r2*Math.sin(i*delta)+h)
|
|
};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(),v[1].myClone(), v[3].myClone(), mainThread.textures[26], 1f,1f,1));
|
|
}
|
|
|
|
float r3 = r2 + 0.03f;
|
|
fanA = new polygon3D[32];
|
|
for(i = 0; i < 16; i++){
|
|
v = new vector[]{put(w,0.505, h), put(r3*Math.cos(i*delta) + w, 0.505, r3*Math.sin(i*delta) + h), put(r3*Math.cos(i*delta) + w, 0.47, r3*Math.sin(i*delta) + h), put(w,0.47, h)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(),v[1].myClone(), v[3].myClone(), mainThread.textures[25], 1f,1f,1));
|
|
fanA[(int)i*2] = polygons[polyIndex];
|
|
|
|
v = new vector[]{put(w,0.47, h), put(r3*Math.cos(i*delta) + w, 0.47, r3*Math.sin(i*delta) + h), put(r3*Math.cos(i*delta) + w, 0.505, r3*Math.sin(i*delta) + h), put(w,0.505, h)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(),v[1].myClone(), v[3].myClone(), mainThread.textures[25], 1f,1f,1));
|
|
fanA[(int)i*2 + 1] = polygons[polyIndex];
|
|
}
|
|
|
|
|
|
v = new vector[16];
|
|
for(i = 0; i < 16; i++){
|
|
v[15 - (int)i] = put(r1*Math.cos((i+1)*delta) + w, 0.49, r1*Math.sin((i+1)*delta)+h);
|
|
}
|
|
distortionA = addPolygon(polygons, new polygon3D(v, put(0,0.49, 1),put(1,0.49, 1), put(0,0.49, 0), mainThread.textures[54], 5f,5f,6));
|
|
|
|
|
|
|
|
|
|
//power tower B
|
|
h = -0.12f;
|
|
powerTowerCenterB = put(w, 0, h);
|
|
|
|
for(i = 0; i < 16; i++){
|
|
v = new vector[]{put(r*Math.cos(i*delta) + w, 0.5, r*Math.sin(i*delta) + h),
|
|
put(r*Math.cos((i+1)*delta) + w, 0.5, r*Math.sin((i+1)*delta)+h),
|
|
put(r*Math.cos((i+1)*delta) + w, 0.3, r*Math.sin((i+1)*delta)+h),
|
|
put(r*Math.cos(i*delta) + w, 0.3, r*Math.sin(i*delta)+h)
|
|
};
|
|
|
|
tempVector.set(v[1]);
|
|
tempVector.subtract(v[0]);
|
|
tempVector0.set(v[0]);
|
|
tempVector1.set(v[1]);
|
|
tempVector3.set(v[3]);
|
|
tempVector1.add(tempVector);
|
|
|
|
int p = (int)i % 8;
|
|
for(j = 0; j < p; j++){
|
|
tempVector0.subtract(tempVector);
|
|
tempVector1.subtract(tempVector);
|
|
tempVector3.subtract(tempVector);
|
|
}
|
|
|
|
change(w,0.5f,h, tempVector);
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, tempVector0.myClone(),tempVector1.myClone(), tempVector3.myClone(), mainThread.textures[12], 1f,1f,1));
|
|
polygons[polyIndex].textureScaledWidth = (int)(polygons[polyIndex].myTexture.width*0.5);
|
|
polygons[polyIndex].createShadeSpan(tempVector, v[0].myClone(), v[1]);
|
|
}
|
|
|
|
r1= r - 0.02f;
|
|
for(i = 0; i < 16; i++){
|
|
v = new vector[]{put(r1*Math.cos(i*delta) + w, 0.515, r1*Math.sin(i*delta) + h),
|
|
put(r1*Math.cos((i+1)*delta) + w, 0.515, r1*Math.sin((i+1)*delta)+h),
|
|
put(r*Math.cos((i+1)*delta) + w, 0.5, r*Math.sin((i+1)*delta)+h),
|
|
put(r*Math.cos(i*delta) + w, 0.5, r*Math.sin(i*delta)+h)
|
|
};
|
|
|
|
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(),v[1].myClone(), v[3].myClone(), mainThread.textures[12], 0.1f,0.1f,1));
|
|
}
|
|
|
|
for(i = 0; i < 16; i++){
|
|
v = new vector[]{ put(r1*Math.cos(i*delta) + w, 0.3, r1*Math.sin(i*delta)+h),
|
|
put(r1*Math.cos((i+1)*delta) + w, 0.3, r1*Math.sin((i+1)*delta)+h),
|
|
put(r1*Math.cos((i+1)*delta) + w, 0.515, r1*Math.sin((i+1)*delta)+h),
|
|
put(r1*Math.cos(i*delta) + w, 0.515, r1*Math.sin(i*delta) + h)
|
|
};
|
|
|
|
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(),v[1].myClone(), v[3].myClone(), mainThread.textures[12], 0.1f,1f,1));
|
|
}
|
|
|
|
|
|
v = new vector[16];
|
|
for(i = 0; i < 16; i++){
|
|
v[15 - (int)i] = put(r2*Math.cos((i+1)*delta) + w, 0.505, r2*Math.sin((i+1)*delta)+h);
|
|
}
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, put(0,0.505, 1),put(1,0.505, 1), put(0,0.505, 0), mainThread.textures[26], 5f,5f,1));
|
|
|
|
for(i = 0; i < 16; i++){
|
|
v = new vector[]{ put(r2*Math.cos(i*delta) + w, 0.505, r2*Math.sin(i*delta) + h),
|
|
put(r2*Math.cos((i+1)*delta) + w, 0.505, r2*Math.sin((i+1)*delta)+h),
|
|
put(r2*Math.cos((i+1)*delta) + w, 0.47, r2*Math.sin((i+1)*delta)+h),
|
|
put(r2*Math.cos(i*delta) + w, 0.47, r2*Math.sin(i*delta)+h)
|
|
};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(),v[1].myClone(), v[3].myClone(), mainThread.textures[26], 1f,1f,1));
|
|
}
|
|
|
|
fanB = new polygon3D[32];
|
|
for(i = 0; i < 16; i++){
|
|
v = new vector[]{put(w,0.505, h), put(r3*Math.cos(i*delta) + w, 0.505, r3*Math.sin(i*delta) + h), put(r3*Math.cos(i*delta) + w, 0.47, r3*Math.sin(i*delta) + h), put(w,0.47, h)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(),v[1].myClone(), v[3].myClone(), mainThread.textures[25], 1f,1f,1));
|
|
fanB[(int)i*2] = polygons[polyIndex];
|
|
|
|
v = new vector[]{put(w,0.47, h), put(r3*Math.cos(i*delta) + w, 0.47, r3*Math.sin(i*delta) + h), put(r3*Math.cos(i*delta) + w, 0.505, r3*Math.sin(i*delta) + h), put(w,0.505, h)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, v[0].myClone(),v[1].myClone(), v[3].myClone(), mainThread.textures[25], 1f,1f,1));
|
|
fanB[(int)i*2 + 1] = polygons[polyIndex];
|
|
}
|
|
|
|
v = new vector[16];
|
|
for(i = 0; i < 16; i++){
|
|
v[15 - (int)i] = put(r1*Math.cos((i+1)*delta) + w, 0.48, r1*Math.sin((i+1)*delta)+h);
|
|
}
|
|
distortionB = addPolygon(polygons, new polygon3D(v, put(0,0.48, 1),put(1,0.48, 1), put(0,0.48, 0), mainThread.textures[54], 5f,5f,6));
|
|
|
|
|
|
|
|
//Concrete foundation
|
|
v = new vector[]{put(-0.38, 0.3, -0.2), put(0.38, 0.3, -0.2), put(0.38, 0.3, -0.225), put(0.345, 0.3, -0.26), put(-0.345, 0.3, -0.26), put(-0.38, 0.3, -0.225)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, put(-0.38, 0.3, 0.26), put(0.38, 0.3, 0.26), put(-0.38, 0.3, -0.26), mainThread.textures[30], 1,1,1));
|
|
polygons[polyIndex].shadowBias = 5000;
|
|
|
|
v = new vector[]{put(-0.38, 0.3, 0.225), put(-0.345, 0.3, 0.26), put(0.345, 0.3, 0.26), put(0.38, 0.3, 0.225), put(0.38, 0.3, 0.2), put(-0.38, 0.3, 0.2)};
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, put(-0.38, 0.3, 0.26), put(0.38, 0.3, 0.26), put(-0.38, 0.3, -0.26), mainThread.textures[30], 1,1,1));
|
|
polygons[polyIndex].shadowBias = 5000;
|
|
|
|
v = new vector[]{put(-0.14, 0.3, 0.225), put(0.38, 0.3, 0.225), put(0.38, 0.3, -0.225), put(-0.14, 0.3, -0.225) };
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, put(-0.38, 0.3, 0.26), put(0.38, 0.3, 0.26), put(-0.38, 0.3, -0.26), mainThread.textures[30], 1,1,1));
|
|
polygons[polyIndex].shadowBias = 5000;
|
|
|
|
v = new vector[]{put(-0.38, 0.3, 0.225), put(-0.33, 0.3, 0.225), put(-0.33, 0.3, -0.225), put(-0.38, 0.3, -0.225) };
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, put(-0.38, 0.3, 0.26), put(0.38, 0.3, 0.26), put(-0.38, 0.3, -0.26), mainThread.textures[30], 1,1,1));
|
|
polygons[polyIndex].shadowBias = 5000;
|
|
|
|
v = new vector[]{put(-0.345, 0.3, 0.225), put(-0.14, 0.3, 0.225), put(-0.14, 0.3, -0.225), put(-0.345, 0.3, -0.225) };
|
|
polyIndex = addPolygon(polygons, new polygon3D(v, put(-0.38, 0.3, 0.26), put(0.38, 0.3, 0.26), put(-0.38, 0.3, -0.26), mainThread.textures[30], 1,1,1));
|
|
polygons[polyIndex].shadowBias = 5000;
|
|
|
|
v = new vector[]{put(-0.345, 0.3, -0.26), put(0.345, 0.3, -0.26), put(0.345, 0.28, -0.26), put(-0.345, 0.28, -0.26)};
|
|
addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[30], 1,1f,1));
|
|
polygons[polyIndex].shadowBias = 5000;
|
|
|
|
v = new vector[]{put(-0.345, 0.28,0.26), put(0.345, 0.28, 0.26), put(0.345, 0.3, 0.26), put(-0.345, 0.3, 0.26)};
|
|
addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[30], 1,1f,1));
|
|
|
|
v = new vector[]{put(-0.38, 0.3, 0.225), put(-0.38, 0.3, -0.225), put(-0.38, 0.28, -0.225), put(-0.38, 0.28, 0.225)};
|
|
addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[30], 1,1f,1));
|
|
|
|
v = new vector[]{put(0.38, 0.28, 0.225), put(0.38, 0.28, -0.225), put(0.38, 0.3, -0.225), put(0.38, 0.3, 0.225)};
|
|
addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[30], 1,1f,1));
|
|
|
|
v = new vector[]{put(-0.345, 0.3, 0.26), put(-0.38, 0.3, 0.225), put(-0.38, 0.28, 0.225), put(-0.345, 0.28, 0.26)};
|
|
addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[30], 1,1f,1));
|
|
|
|
v = new vector[]{put(0.345, 0.28, 0.26), put(0.38, 0.28, 0.225), put(0.38, 0.3, 0.225), put(0.345, 0.3, 0.26)};
|
|
addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[30], 1,1f,1));
|
|
|
|
v = new vector[]{put(-0.345, 0.28, -0.26), put(-0.38, 0.28, -0.225), put(-0.38, 0.3, -0.225), put(-0.345, 0.3, -0.26)};
|
|
addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[30], 1,1f,1));
|
|
|
|
v = new vector[]{put(0.345, 0.3, -0.26), put(0.38, 0.3, -0.225), put(0.38, 0.28, -0.225), put(0.345, 0.28, -0.26)};
|
|
addPolygon(polygons, new polygon3D(v, v[0].myClone(), v[1].myClone(), v[3].myClone(), mainThread.textures[30], 1,1f,1));
|
|
|
|
|
|
for(int z = 0; z < numOfPolygons; z++){
|
|
polygons[z].findDiffuse();
|
|
polygons[z].parentObject = this;
|
|
|
|
}
|
|
}
|
|
|
|
|
|
public int addPolygon(polygon3D[] polys, polygon3D poly){
|
|
for(int i = 0; i < polys.length; i++){
|
|
if(polys[i] == null){
|
|
polys[i] = poly;
|
|
numOfPolygons++;
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
//update the model
|
|
public void update(){
|
|
|
|
//update tech tree info
|
|
canBuildLightTank = theBaseInfo.canBuildLightTank;
|
|
canBuildRocketTank = theBaseInfo.canBuildRocketTank;
|
|
canBuildHarvester = theBaseInfo.canBuildHarvester;
|
|
canBuildDrone = theBaseInfo.canBuildDrone;
|
|
canBuildMCV = theBaseInfo.canBuildMCV;
|
|
canBuildStealthTank = theBaseInfo.canBuildStealthTank;
|
|
canBuildHeavyTank = theBaseInfo.canBuildHeavyTank;
|
|
|
|
|
|
//process emerging from ground animation
|
|
if(centre.y < -0.79f){
|
|
centre.y+=0.02f;
|
|
|
|
float delta_h = 0.02f;
|
|
if(centre.y > -0.79f){
|
|
delta_h = 0.02f -0.79f - centre.y;
|
|
centre.y = -0.79f;
|
|
}
|
|
|
|
for(int i = 0; i < numOfPolygons; i++){
|
|
polygons[i].origin.y+=delta_h;
|
|
polygons[i].rightEnd.y+=delta_h;
|
|
polygons[i].bottomEnd.y+=delta_h;
|
|
|
|
for(int j = 0; j < polygons[i].vertex3D.length; j++){
|
|
polygons[i].vertex3D[j].y+=delta_h;
|
|
}
|
|
}
|
|
|
|
shadowvertex0.y+=delta_h;
|
|
shadowvertex1.y+=delta_h;
|
|
shadowvertex2.y+=delta_h;
|
|
shadowvertex3.y+=delta_h;
|
|
|
|
|
|
//the building is invulnerable during emerging stage
|
|
currentHP = maxHP;
|
|
}
|
|
|
|
if(underAttackCountDown > 0)
|
|
underAttackCountDown--;
|
|
|
|
|
|
//check if building has been destroyed
|
|
if(currentHP <= 0){
|
|
countDownToDeath--;
|
|
|
|
if(countDownToDeath == 0){
|
|
//spawn an explosion when the object is destroyed
|
|
float[] tempFloat = theAssetManager.explosionInfo[theAssetManager.explosionCount];
|
|
tempFloat[0] = centre.x;
|
|
tempFloat[1] = centre.y + 0.45f;
|
|
tempFloat[2] = centre.z;
|
|
tempFloat[3] = 3.5f;
|
|
tempFloat[4] = 1;
|
|
tempFloat[5] = 0;
|
|
tempFloat[6] = 7;
|
|
tempFloat[7] = this.height;
|
|
theAssetManager.explosionCount++;
|
|
theAssetManager.removeObject(this);
|
|
|
|
|
|
//removeFromGridMap();
|
|
mainThread.gridMap.tiles[tileIndex[0]][0] = null;
|
|
mainThread.gridMap.tiles[tileIndex[1]][0] = null;
|
|
mainThread.gridMap.tiles[tileIndex[2]][0] = null;
|
|
mainThread.gridMap.tiles[tileIndex[3]][0] = null;
|
|
mainThread.gridMap.tiles[tileIndex[4]][0] = null;
|
|
mainThread.gridMap.tiles[tileIndex[5]][0] = null;
|
|
|
|
|
|
mainThread.gridMap.tiles[tileIndex[0]][1] = null;
|
|
mainThread.gridMap.tiles[tileIndex[1]][1] = null;
|
|
mainThread.gridMap.tiles[tileIndex[2]][1] = null;
|
|
mainThread.gridMap.tiles[tileIndex[3]][1] = null;
|
|
mainThread.gridMap.tiles[tileIndex[4]][1] = null;
|
|
mainThread.gridMap.tiles[tileIndex[5]][1] = null;
|
|
|
|
mainThread.gridMap.tiles[tileIndex[0]][2] = null;
|
|
mainThread.gridMap.tiles[tileIndex[1]][2] = null;
|
|
mainThread.gridMap.tiles[tileIndex[2]][2] = null;
|
|
mainThread.gridMap.tiles[tileIndex[3]][2] = null;
|
|
mainThread.gridMap.tiles[tileIndex[4]][2] = null;
|
|
mainThread.gridMap.tiles[tileIndex[5]][2] = null;
|
|
|
|
mainThread.gridMap.tiles[tileIndex[0]][3] = null;
|
|
mainThread.gridMap.tiles[tileIndex[1]][3] = null;
|
|
mainThread.gridMap.tiles[tileIndex[2]][3] = null;
|
|
mainThread.gridMap.tiles[tileIndex[3]][3] = null;
|
|
mainThread.gridMap.tiles[tileIndex[4]][3] = null;
|
|
mainThread.gridMap.tiles[tileIndex[5]][3] = null;
|
|
|
|
|
|
mainThread.gridMap.tiles[tileIndex[0]][4] = null;
|
|
mainThread.gridMap.tiles[tileIndex[1]][4] = null;
|
|
mainThread.gridMap.tiles[tileIndex[2]][4] = null;
|
|
mainThread.gridMap.tiles[tileIndex[3]][4] = null;
|
|
mainThread.gridMap.tiles[tileIndex[4]][4] = null;
|
|
mainThread.gridMap.tiles[tileIndex[5]][4] = null;
|
|
|
|
int tileIndex6 = tileIndex[5] + 128;
|
|
int tileIndex7 = tileIndex[5] + 128 - 1;
|
|
int tileIndex8 = tileIndex[5] + 128 + 1;
|
|
mainThread.gridMap.tiles[tileIndex6][4] = null;
|
|
mainThread.gridMap.tiles[tileIndex7][4] = null;
|
|
mainThread.gridMap.tiles[tileIndex8][4] = null;
|
|
|
|
|
|
theBaseInfo.numberOfFactory--;
|
|
|
|
if(deliveredUnit != null)
|
|
deliveredUnit.disableUnitLevelAI = false;
|
|
|
|
cancelBuilding();
|
|
|
|
if(attacker.teamNo != teamNo)
|
|
attacker.experience+=40;
|
|
|
|
return;
|
|
}else{
|
|
|
|
float[] tempFloat = theAssetManager.explosionInfo[theAssetManager.explosionCount];
|
|
tempFloat[0] = centre.x + (float)Math.random()*0.6f - 0.3f;
|
|
tempFloat[1] = centre.y + 0.45f;
|
|
tempFloat[2] = centre.z + (float)Math.random()/2.5f - 0.2f;
|
|
tempFloat[3] = 1.5f;
|
|
tempFloat[4] = 1;
|
|
tempFloat[5] = 0;
|
|
tempFloat[6] = 6 + (gameData.getRandom()%4);
|
|
tempFloat[7] = this.height;
|
|
theAssetManager.explosionCount++;
|
|
|
|
}
|
|
}
|
|
|
|
if(isRepairing && currentHP >0){
|
|
if(mainThread.gameFrame%8==0 && theBaseInfo.currentCredit > 0 && currentHP <maxHP){
|
|
currentHP+=2;
|
|
theBaseInfo.currentCredit--;
|
|
if(currentHP > maxHP)
|
|
currentHP = maxHP;
|
|
}
|
|
}
|
|
|
|
//process building event (at half speed when lower power)
|
|
if(currentStatus == isBuilding){
|
|
|
|
if(!(theBaseInfo.lowPower && mainThread.gameFrame%2==0)){
|
|
|
|
//light tank event
|
|
if(lightTankProgress < 240){
|
|
grayAllOtherIcons(lightTankType, lightTankProgress);
|
|
if(theBaseInfo.currentCredit >0){
|
|
|
|
theBaseInfo.currentCredit--;
|
|
creditSpentOnBuilding++;
|
|
lightTankProgress = 240 * creditSpentOnBuilding/300;
|
|
}
|
|
}
|
|
if(lightTankProgress == 240){
|
|
if(!isDeliveringUnit){
|
|
lightTank o = new lightTank(new vector(centre.x -0.07f,-0.3f, centre.z - 0.03f), 180, teamNo);
|
|
|
|
if(teamNo == 0 && techCenter.lightTankResearched_player){
|
|
o.attackRange = 1.99f;
|
|
}else if(teamNo != 0 && techCenter.lightTankResearched_enemy){
|
|
o.attackRange = 1.99f;
|
|
}
|
|
|
|
deliveredUnit = o;
|
|
o.disableUnitLevelAI = true;
|
|
|
|
mainThread.theAssetManager.addLightTank(o);
|
|
lightTankProgress = 255;
|
|
removelItemFromProductionQueue(lightTankType);
|
|
isDeliveringUnit = true;
|
|
}
|
|
}
|
|
|
|
//rocket tank event
|
|
if(rocketTankProgress < 240){
|
|
grayAllOtherIcons(rocketTankType, rocketTankProgress);
|
|
if(theBaseInfo.currentCredit >0){
|
|
|
|
theBaseInfo.currentCredit--;
|
|
creditSpentOnBuilding++;
|
|
rocketTankProgress = 240 * creditSpentOnBuilding/450;
|
|
}
|
|
}
|
|
if(rocketTankProgress == 240){
|
|
if(!isDeliveringUnit){
|
|
rocketTank o = new rocketTank(new vector(centre.x -0.07f,-0.3f, centre.z - 0.03f), 180, teamNo);
|
|
if(teamNo == 0 && techCenter.rocketTankResearched_player){
|
|
o.damageMultiplier =2;
|
|
}else if(teamNo != 0 && techCenter.rocketTankResearched_enemy){
|
|
o.damageMultiplier =2;
|
|
}
|
|
|
|
deliveredUnit = o;
|
|
o.disableUnitLevelAI = true;
|
|
|
|
mainThread.theAssetManager.addRocketTank(o);
|
|
rocketTankProgress = 255;
|
|
removelItemFromProductionQueue(rocketTankType);
|
|
isDeliveringUnit = true;
|
|
}
|
|
}
|
|
|
|
//harvester event
|
|
if(harvesterProgress < 240){
|
|
grayAllOtherIcons(harvesterType, harvesterProgress);
|
|
|
|
if(!canBuildHarvester){
|
|
int num = numOfHarvesterOnQueue;
|
|
for(int i = 0; i <= num; i++)
|
|
cancelItemFromProductionQueue(harvesterType);
|
|
}else{
|
|
if(theBaseInfo.currentCredit >0){
|
|
|
|
theBaseInfo.currentCredit--;
|
|
creditSpentOnBuilding++;
|
|
harvesterProgress = 240 * creditSpentOnBuilding/800;
|
|
}
|
|
}
|
|
}
|
|
if(harvesterProgress == 240){
|
|
if(!canBuildHarvester){
|
|
int num = numOfHarvesterOnQueue;
|
|
for(int i = 0; i <= num; i++)
|
|
cancelItemFromProductionQueue(harvesterType);
|
|
}else{
|
|
if(!isDeliveringUnit){
|
|
harvester o = new harvester(new vector(centre.x -0.07f,-0.3f, centre.z - 0.03f), 180, teamNo);
|
|
|
|
if(teamNo == 0 && communicationCenter.harvesterSpeedResearched_player){
|
|
o.speed = 0.014f;
|
|
o.bodyTurnRate = 8;
|
|
}else if(teamNo != 0 && communicationCenter.harvesterSpeedResearched_enemy){
|
|
o.speed = 0.014f;
|
|
o.bodyTurnRate = 8;
|
|
}
|
|
|
|
deliveredUnit = o;
|
|
o.disableUnitLevelAI = true;
|
|
|
|
mainThread.theAssetManager.addHarvester(o);
|
|
harvesterProgress = 255;
|
|
removelItemFromProductionQueue(harvesterType);
|
|
isDeliveringUnit = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//MCV event
|
|
if(MCVProgress < 240){
|
|
grayAllOtherIcons(MCVType, MCVProgress);
|
|
|
|
if(!canBuildMCV){
|
|
int num = numOfMCVOnQueue;
|
|
for(int i = 0; i <= num; i++)
|
|
cancelItemFromProductionQueue(MCVType);
|
|
}else{
|
|
if(theBaseInfo.currentCredit >0){
|
|
theBaseInfo.currentCredit--;
|
|
creditSpentOnBuilding++;
|
|
MCVProgress = 240 * creditSpentOnBuilding/1700;
|
|
}
|
|
}
|
|
}
|
|
if(MCVProgress == 240){
|
|
if(!canBuildMCV){
|
|
int num = numOfMCVOnQueue;
|
|
for(int i = 0; i <= num; i++)
|
|
cancelItemFromProductionQueue(MCVType);
|
|
}else{
|
|
if(!isDeliveringUnit){
|
|
constructionVehicle o = new constructionVehicle(new vector(centre.x -0.07f,-0.3f, centre.z - 0.03f), 180, teamNo);
|
|
deliveredUnit = o;
|
|
o.disableUnitLevelAI = true;
|
|
|
|
mainThread.theAssetManager.addConstructionVehicle(o);
|
|
MCVProgress = 255;
|
|
removelItemFromProductionQueue(MCVType);
|
|
isDeliveringUnit = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//drone event
|
|
if(droneProgress < 240){
|
|
grayAllOtherIcons(droneType, droneProgress);
|
|
if(theBaseInfo.currentCredit >0){
|
|
|
|
theBaseInfo.currentCredit--;
|
|
creditSpentOnBuilding++;
|
|
droneProgress = 240 * creditSpentOnBuilding/250;
|
|
}
|
|
}
|
|
if(droneProgress == 240){
|
|
if(!isDeliveringUnit){
|
|
drone o = new drone(new vector(centre.x -0.07f,-0.27f, centre.z - 0.03f), 180, this);
|
|
numOfDrones++;
|
|
deliveredUnit = o;
|
|
o.disableUnitLevelAI = true;
|
|
|
|
mainThread.theAssetManager.addDrone(o);
|
|
droneProgress = 255;
|
|
removelItemFromProductionQueue(droneType);
|
|
isDeliveringUnit = true;
|
|
}
|
|
}
|
|
|
|
//stealth tank event
|
|
if(stealthTankProgress < 240){
|
|
grayAllOtherIcons(stealthTankType, stealthTankProgress);
|
|
if(!canBuildStealthTank){
|
|
int num = numOfStealthTankOnQueue;
|
|
for(int i = 0; i <= num; i++)
|
|
cancelItemFromProductionQueue(stealthTankType);
|
|
}else{
|
|
|
|
if(theBaseInfo.currentCredit >0){
|
|
|
|
theBaseInfo.currentCredit--;
|
|
creditSpentOnBuilding++;
|
|
stealthTankProgress = 240 * creditSpentOnBuilding/600;
|
|
}
|
|
}
|
|
}
|
|
if(stealthTankProgress == 240){
|
|
if(!canBuildStealthTank){
|
|
int num = numOfStealthTankOnQueue;
|
|
for(int i = 0; i <= num; i++)
|
|
cancelItemFromProductionQueue(stealthTankType);
|
|
}else{
|
|
if(!isDeliveringUnit){
|
|
stealthTank o = new stealthTank(new vector(centre.x -0.07f,-0.3f, centre.z - 0.03f), 180, teamNo);
|
|
if(teamNo == 0 && techCenter.stealthTankResearched_player){
|
|
o.hasMultiShotUpgrade = true;
|
|
}else if(teamNo != 0 && techCenter.stealthTankResearched_enemy){
|
|
o.hasMultiShotUpgrade = true;
|
|
}
|
|
|
|
deliveredUnit = o;
|
|
o.disableUnitLevelAI = true;
|
|
|
|
mainThread.theAssetManager.addStealthTank(o);
|
|
stealthTankProgress = 255;
|
|
removelItemFromProductionQueue(stealthTankType);
|
|
isDeliveringUnit = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//heavy tank event
|
|
if(heavyTankProgress < 240){
|
|
grayAllOtherIcons(heavyTankType, heavyTankProgress);
|
|
if(!canBuildHeavyTank){
|
|
int num = numOfHeavyTankOnQueue;
|
|
for(int i = 0; i <= num; i++)
|
|
cancelItemFromProductionQueue(heavyTankType);
|
|
}else{
|
|
|
|
if(theBaseInfo.currentCredit >0){
|
|
|
|
theBaseInfo.currentCredit--;
|
|
creditSpentOnBuilding++;
|
|
heavyTankProgress = 240 * creditSpentOnBuilding/1100;
|
|
}
|
|
}
|
|
}
|
|
if(heavyTankProgress == 240){
|
|
if(!canBuildHeavyTank){
|
|
int num = numOfHeavyTankOnQueue;
|
|
for(int i = 0; i <= num; i++)
|
|
cancelItemFromProductionQueue(heavyTankType);
|
|
}else{
|
|
if(!isDeliveringUnit){
|
|
heavyTank o = new heavyTank(new vector(centre.x -0.07f,-0.3f, centre.z - 0.03f), 180, teamNo);
|
|
if(teamNo == 0 && techCenter.heavyTankResearched_player){
|
|
o.canSelfRepair = true;
|
|
}else if(teamNo != 0 && techCenter.heavyTankResearched_enemy){
|
|
o.canSelfRepair = true;
|
|
}
|
|
deliveredUnit = o;
|
|
o.disableUnitLevelAI = true;
|
|
|
|
mainThread.theAssetManager.addHeavyTank(o);
|
|
heavyTankProgress = 255;
|
|
removelItemFromProductionQueue(heavyTankType);
|
|
isDeliveringUnit = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}else{
|
|
lightTankProgress = 255;
|
|
rocketTankProgress = 255;
|
|
harvesterProgress = 255;
|
|
droneProgress = 255;
|
|
MCVProgress = 255;
|
|
stealthTankProgress = 255;
|
|
heavyTankProgress = 255;
|
|
}
|
|
|
|
|
|
//process delivering Unit event
|
|
if(isDeliveringUnit){
|
|
|
|
if(deliveredUnit != null && deliveredUnit.currentHP <=0){
|
|
deliveredUnit = null;
|
|
closingDoor = true;
|
|
openingDoor = false;
|
|
}
|
|
|
|
if(deliveredUnit!= null){
|
|
if(doorClosed){
|
|
closingDoor = false;
|
|
doorClosed = false;
|
|
openingDoor = true;
|
|
}
|
|
|
|
if(doorOpened){
|
|
|
|
xPos = (int)((deliveredUnit.centre.x)*64) - 8;
|
|
|
|
if(deliveredUnit.centre.z - (centre.z - 0.375f) <= 0.01f){
|
|
if(deliveredUnit.type == droneType){
|
|
deliveredUnit.disableUnitLevelAI = false;
|
|
}else{
|
|
deliveredUnit.movement.set(0,0,deliveredUnit.centre.z - (centre.z - 0.375f));
|
|
deliveredUnit.disableUnitLevelAI = false;
|
|
deliveredUnit.leftFactory = true;
|
|
|
|
if(deliveredUnit.type == harvesterType){
|
|
|
|
if(targetGoldMine != null)
|
|
deliveredUnit.harvest(targetGoldMine);
|
|
else
|
|
moveDeliveredUnitToRallyPoint();
|
|
harvester o = (harvester)deliveredUnit;
|
|
o.heuristicRecalculationCountDown = 1;
|
|
|
|
|
|
}else{
|
|
moveDeliveredUnitToRallyPoint();
|
|
}
|
|
}
|
|
|
|
deliveredUnit = null;
|
|
closingDoor = true;
|
|
openingDoor = false;
|
|
doorOpened = false;
|
|
|
|
}else{
|
|
|
|
yPos = (int)((deliveredUnit.centre.z -0.01f)*64) + 8;
|
|
boolean canMove = true;
|
|
|
|
if(deliveredUnit.type != droneType){
|
|
|
|
|
|
xPos_old = deliveredUnit.boundary2D.x1;
|
|
yPos_old = deliveredUnit.boundary2D.y1;
|
|
|
|
deliveredUnit.boundary2D.setOrigin(xPos, yPos);
|
|
|
|
|
|
for(int i = 0; i < 4; i++){
|
|
solidObject o = mainThread.gridMap.tiles[tileIndex[5]+128][i];
|
|
if(o != null && o != deliveredUnit){
|
|
if(o.boundary2D.intersect(deliveredUnit.boundary2D)){
|
|
canMove = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
for(int i = 0; i < 4; i++){
|
|
solidObject o = mainThread.gridMap.tiles[tileIndex[5]+127][i];
|
|
if(o != null && o != deliveredUnit){
|
|
if(o.boundary2D.intersect(deliveredUnit.boundary2D)){
|
|
canMove = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
if(!canMove){
|
|
deliveredUnit.movement.reset();
|
|
deliveredUnit.boundary2D.setOrigin(xPos_old, yPos_old);
|
|
}else{
|
|
|
|
if(deliveredUnit.type != droneType){
|
|
deliveredUnit.boundary2D.setOrigin(xPos_old, yPos_old);
|
|
deliveredUnit.movement.set(0,0,-0.01f);
|
|
}else{
|
|
deliveredUnit.centre.z-=0.01f;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
}
|
|
|
|
float dHeight = 0.005f;
|
|
if(openingDoor){
|
|
for(int i = 0; i < doorUpper.length; i++){
|
|
if(i == 0 && !doorHeightMarked){
|
|
doorHeightMark = doorUpper[i].origin.y;
|
|
doorHeightMarked = true;
|
|
}
|
|
|
|
doorUpper[i].origin.y+=dHeight;
|
|
doorUpper[i].bottomEnd.y+=dHeight;
|
|
doorUpper[i].rightEnd.y+=dHeight;
|
|
|
|
for(int j = 0; j < doorUpper[i].vertex3D.length; j++){
|
|
doorUpper[i].vertex3D[j].y+=dHeight;
|
|
}
|
|
}
|
|
|
|
for(int i = 0; i < doorLower.length; i++){
|
|
doorLower[i].origin.y-=dHeight;
|
|
doorLower[i].bottomEnd.y-=dHeight;
|
|
doorLower[i].rightEnd.y-=dHeight;
|
|
|
|
for(int j = 0; j < doorLower[i].vertex3D.length; j++){
|
|
doorLower[i].vertex3D[j].y-=dHeight;
|
|
}
|
|
}
|
|
if(doorUpper[0].origin.y > -0.256){
|
|
openingDoor = false;
|
|
doorOpened = true;
|
|
}
|
|
}
|
|
|
|
if(closingDoor){
|
|
for(int i = 0; i < doorUpper.length; i++){
|
|
doorUpper[i].origin.y-=dHeight;
|
|
doorUpper[i].bottomEnd.y-=dHeight;
|
|
doorUpper[i].rightEnd.y-=dHeight;
|
|
|
|
for(int j = 0; j < doorUpper[i].vertex3D.length; j++){
|
|
doorUpper[i].vertex3D[j].y-=dHeight;
|
|
}
|
|
}
|
|
for(int i = 0; i < doorLower.length; i++){
|
|
doorLower[i].origin.y+=dHeight;
|
|
doorLower[i].bottomEnd.y+=dHeight;
|
|
doorLower[i].rightEnd.y+=dHeight;
|
|
|
|
for(int j = 0; j < doorLower[i].vertex3D.length; j++){
|
|
doorLower[i].vertex3D[j].y+=dHeight;
|
|
}
|
|
}
|
|
if(doorUpper[0].origin.y <= doorHeightMark){
|
|
closingDoor = false;
|
|
isDeliveringUnit = false;
|
|
doorClosed = true;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
//mark itself on obstacle map
|
|
mainThread.gridMap.currentObstacleMap[tileIndex[0]] = false;
|
|
mainThread.gridMap.currentObstacleMap[tileIndex[1]] = false;
|
|
mainThread.gridMap.currentObstacleMap[tileIndex[2]] = false;
|
|
mainThread.gridMap.currentObstacleMap[tileIndex[3]] = false;
|
|
mainThread.gridMap.currentObstacleMap[tileIndex[4]] = false;
|
|
mainThread.gridMap.currentObstacleMap[tileIndex[5]] = false;
|
|
|
|
|
|
//update center in camera coordinate
|
|
tempCentre.set(centre);
|
|
tempCentre.subtract(camera.position);
|
|
tempCentre.rotate_XZ(camera.XZ_angle);
|
|
tempCentre.rotate_YZ(camera.YZ_angle);
|
|
tempCentre.updateLocation();
|
|
|
|
theAssetManager = mainThread.theAssetManager;
|
|
|
|
//test if the object is visible in camera point of view
|
|
if(visibleBoundary.contains(tempCentre.screenX, tempCentre.screenY) && isRevealed){
|
|
visible = true;
|
|
|
|
if(screenBoundary.contains(tempCentre.screenX, tempCentre.screenY))
|
|
withinViewScreen = true;
|
|
else
|
|
withinViewScreen = false;
|
|
|
|
tempshadowvertex0.set(shadowvertex0);
|
|
tempshadowvertex0.subtract(camera.position);
|
|
tempshadowvertex0.rotate_XZ(camera.XZ_angle);
|
|
tempshadowvertex0.rotate_YZ(camera.YZ_angle);
|
|
tempshadowvertex0.updateLocation();
|
|
|
|
tempshadowvertex1.set(shadowvertex1);
|
|
tempshadowvertex1.subtract(camera.position);
|
|
tempshadowvertex1.rotate_XZ(camera.XZ_angle);
|
|
tempshadowvertex1.rotate_YZ(camera.YZ_angle);
|
|
tempshadowvertex1.updateLocation();
|
|
|
|
tempshadowvertex2.set(shadowvertex2);
|
|
tempshadowvertex2.subtract(camera.position);
|
|
tempshadowvertex2.rotate_XZ(camera.XZ_angle);
|
|
tempshadowvertex2.rotate_YZ(camera.YZ_angle);
|
|
tempshadowvertex2.updateLocation();
|
|
|
|
tempshadowvertex3.set(shadowvertex3);
|
|
tempshadowvertex3.subtract(camera.position);
|
|
tempshadowvertex3.rotate_XZ(camera.XZ_angle);
|
|
tempshadowvertex3.rotate_YZ(camera.YZ_angle);
|
|
tempshadowvertex3.updateLocation();
|
|
|
|
|
|
|
|
//if the object is visible then draw it on the shadow buffer from light point of view
|
|
if(shadowBoundary1.contains(tempshadowvertex0.screenX, tempshadowvertex0.screenY) ||
|
|
shadowBoundary1.contains(tempshadowvertex1.screenX, tempshadowvertex1.screenY) ||
|
|
shadowBoundary1.contains(tempshadowvertex2.screenX, tempshadowvertex2.screenY) ||
|
|
shadowBoundary1.contains(tempshadowvertex3.screenX, tempshadowvertex3.screenY)
|
|
){
|
|
for(int i = 0; i < numOfPolygons; i++){
|
|
polygons[i].update_lightspace();
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//add this object to visible unit list
|
|
theAssetManager.visibleUnit[theAssetManager.visibleUnitCount] = this;
|
|
theAssetManager.visibleUnitCount++;
|
|
|
|
|
|
}else{
|
|
visible = false;
|
|
}
|
|
|
|
|
|
//create vision for enemy commander
|
|
if(teamNo == 1){
|
|
int xPos = boundary2D.x1/16 - 8 + 10 + 1;
|
|
int yPos = 127 - boundary2D.y1/16 - 8 + 10;
|
|
|
|
for(int y = 0; y < 17; y++){
|
|
for(int x = 0; x < 17; x++){
|
|
if(bitmapVisionForEnemy[x+ y*17])
|
|
enemyCommander.tempBitmap[xPos + x + (yPos+y)*148] =true;
|
|
}
|
|
}
|
|
}
|
|
|
|
visionBoundary.x = (int)(tempCentre.screenX - 800);
|
|
visionBoundary.y = (int)(tempCentre.screenY - 1000);
|
|
visionInsideScreen = camera.screen.intersects(visionBoundary);
|
|
|
|
|
|
if(visionInsideScreen){
|
|
if(teamNo == 0){
|
|
tempFloat = theAssetManager.visionPolygonInfo[theAssetManager.visionPolygonCount];
|
|
tempFloat[0] = teamNo;
|
|
tempFloat[1] = centre.x;
|
|
tempFloat[2] = -0.4f;
|
|
tempFloat[3] = centre.z;
|
|
tempFloat[4] = 2;
|
|
theAssetManager.visionPolygonCount++;
|
|
}
|
|
}
|
|
|
|
if(theAssetManager.minimapBitmap[tileIndex[0]] ||
|
|
theAssetManager.minimapBitmap[tileIndex[1]] ||
|
|
theAssetManager.minimapBitmap[tileIndex[2]] ||
|
|
theAssetManager.minimapBitmap[tileIndex[3]] ||
|
|
theAssetManager.minimapBitmap[tileIndex[4]] ||
|
|
theAssetManager.minimapBitmap[tileIndex[5]])
|
|
isRevealed = true;
|
|
|
|
visible_minimap = isRevealed;
|
|
|
|
if(visible_minimap){
|
|
tempInt = theAssetManager.unitsForMiniMap[theAssetManager.unitsForMiniMapCount];
|
|
tempInt[0] = teamNo;
|
|
tempInt[1] = boundary2D.x1/16;
|
|
tempInt[2] = 127 - boundary2D.y1/16;
|
|
tempInt[3] = 2;
|
|
if(teamNo == 0 && underAttackCountDown > 0)
|
|
tempInt[4] = 10001;
|
|
else
|
|
tempInt[4] = 10000;
|
|
theAssetManager.unitsForMiniMapCount++;
|
|
|
|
}
|
|
|
|
//update power tower animation
|
|
if(!visible)
|
|
return;
|
|
|
|
polygons[distortionA].origin.x-=0.001f;
|
|
polygons[distortionA].rightEnd.x-=0.001f;
|
|
polygons[distortionA].bottomEnd.x -= 0.001f;
|
|
polygons[distortionA].origin.z-=0.001f;
|
|
polygons[distortionA].rightEnd.z-=0.001f;
|
|
polygons[distortionA].bottomEnd.z -= 0.001f;
|
|
|
|
for(int i = 0; i < fanA.length; i++){
|
|
fanA[i].origin.subtract(powerTowerCenterA);
|
|
fanA[i].origin.rotate_XZ(4);
|
|
fanA[i].origin.add(powerTowerCenterA);
|
|
|
|
|
|
fanA[i].bottomEnd.subtract(powerTowerCenterA);
|
|
fanA[i].bottomEnd.rotate_XZ(4);
|
|
fanA[i].bottomEnd.add(powerTowerCenterA);
|
|
|
|
|
|
fanA[i].rightEnd.subtract(powerTowerCenterA);
|
|
fanA[i].rightEnd.rotate_XZ(4);
|
|
fanA[i].rightEnd.add(powerTowerCenterA);
|
|
|
|
for(int j = 0; j < fanA[i].vertex3D.length; j++){
|
|
fanA[i].vertex3D[j].subtract(powerTowerCenterA);
|
|
fanA[i].vertex3D[j].rotate_XZ(4);
|
|
fanA[i].vertex3D[j].add(powerTowerCenterA);
|
|
}
|
|
fanA[i].normal.rotate_XZ(4);
|
|
fanA[i].findDiffuse();
|
|
}
|
|
|
|
polygons[distortionB].origin.x-=0.001f;
|
|
polygons[distortionB].rightEnd.x-=0.001f;
|
|
polygons[distortionB].bottomEnd.x -= 0.001f;
|
|
polygons[distortionB].origin.z-=0.001f;
|
|
polygons[distortionB].rightEnd.z-=0.001f;
|
|
polygons[distortionB].bottomEnd.z -= 0.001f;
|
|
|
|
for(int i = 0; i < fanB.length; i++){
|
|
fanB[i].origin.subtract(powerTowerCenterB);
|
|
fanB[i].origin.rotate_XZ(4);
|
|
fanB[i].origin.add(powerTowerCenterB);
|
|
|
|
|
|
fanB[i].bottomEnd.subtract(powerTowerCenterB);
|
|
fanB[i].bottomEnd.rotate_XZ(4);
|
|
fanB[i].bottomEnd.add(powerTowerCenterB);
|
|
|
|
|
|
fanB[i].rightEnd.subtract(powerTowerCenterB);
|
|
fanB[i].rightEnd.rotate_XZ(4);
|
|
fanB[i].rightEnd.add(powerTowerCenterB);
|
|
|
|
for(int j = 0; j < fanB[i].vertex3D.length; j++){
|
|
fanB[i].vertex3D[j].subtract(powerTowerCenterB);
|
|
fanB[i].vertex3D[j].rotate_XZ(4);
|
|
fanB[i].vertex3D[j].add(powerTowerCenterB);
|
|
}
|
|
fanB[i].normal.rotate_XZ(4);
|
|
fanB[i].findDiffuse();
|
|
}
|
|
}
|
|
|
|
public void buildLightTank(){
|
|
if(numOfLightTankOnQueue >= 100)
|
|
return;
|
|
if(canBuildLightTank){
|
|
if(currentStatus != isBuilding){
|
|
lightTankProgress = 0;
|
|
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}
|
|
numOfLightTankOnQueue++;
|
|
addToProductionQueue(lightTankType);
|
|
}
|
|
}
|
|
|
|
public void buildRocketTank(){
|
|
if(numOfRocketTankOnQueue >= 100)
|
|
return;
|
|
if(canBuildRocketTank){
|
|
if(currentStatus != isBuilding){
|
|
rocketTankProgress = 0;
|
|
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}
|
|
numOfRocketTankOnQueue++;
|
|
addToProductionQueue(rocketTankType);
|
|
}
|
|
}
|
|
|
|
public void buildHarvester(){
|
|
if(numOfHarvesterOnQueue >= 100)
|
|
return;
|
|
if(canBuildHarvester){
|
|
if(currentStatus != isBuilding){
|
|
harvesterProgress = 0;
|
|
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}
|
|
numOfHarvesterOnQueue++;
|
|
addToProductionQueue(harvesterType);
|
|
}
|
|
}
|
|
|
|
public void buildDrone(){
|
|
if(numOfDroneOnQueue + numOfDrones == 3)
|
|
return;
|
|
if(canBuildDrone){
|
|
if(currentStatus != isBuilding){
|
|
droneProgress = 0;
|
|
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}
|
|
numOfDroneOnQueue++;
|
|
addToProductionQueue(droneType);
|
|
}
|
|
}
|
|
|
|
public void buildMCV(){
|
|
if(numOfMCVOnQueue >= 100)
|
|
return;
|
|
if(canBuildMCV){
|
|
if(currentStatus != isBuilding){
|
|
MCVProgress = 0;
|
|
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}
|
|
numOfMCVOnQueue++;
|
|
addToProductionQueue(MCVType);
|
|
}
|
|
}
|
|
|
|
public void buildStealthTank(){
|
|
if(numOfStealthTankOnQueue >= 100)
|
|
return;
|
|
if(canBuildStealthTank){
|
|
if(currentStatus != isBuilding){
|
|
stealthTankProgress = 0;
|
|
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}
|
|
numOfStealthTankOnQueue++;
|
|
addToProductionQueue(stealthTankType);
|
|
}
|
|
}
|
|
|
|
public void buildHeavyTank(){
|
|
if(numOfHeavyTankOnQueue >= 100)
|
|
return;
|
|
if(canBuildHeavyTank){
|
|
if(currentStatus != isBuilding){
|
|
heavyTankProgress = 0;
|
|
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}
|
|
numOfHeavyTankOnQueue++;
|
|
addToProductionQueue(heavyTankType);
|
|
}
|
|
}
|
|
|
|
|
|
public void grayAllOtherIcons(int type, int progress){
|
|
lightTankProgress = 254;
|
|
rocketTankProgress = 254;
|
|
harvesterProgress = 254;
|
|
droneProgress = 254;
|
|
MCVProgress = 254;
|
|
stealthTankProgress = 254;
|
|
heavyTankProgress = 254;
|
|
|
|
if(type == lightTankType){
|
|
lightTankProgress = progress;
|
|
}
|
|
if(type == rocketTankType){
|
|
rocketTankProgress = progress;
|
|
}
|
|
if(type == harvesterType){
|
|
harvesterProgress = progress;
|
|
}
|
|
if(type == droneType){
|
|
droneProgress = progress;
|
|
}
|
|
if(type == MCVType){
|
|
MCVProgress = progress;
|
|
}
|
|
if(type == stealthTankType){
|
|
stealthTankProgress = progress;
|
|
}
|
|
if(type == heavyTankType){
|
|
heavyTankProgress = progress;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public void addToProductionQueue(int type){
|
|
for(int i = 0; i < productionQueue.length; i++){
|
|
if(productionQueue[i] == -1){
|
|
productionQueue[i] = (byte)type;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void cancelItemFromProductionQueue(int type){
|
|
for(int i = productionQueue.length - 1; i >= 0; i--){
|
|
if(productionQueue[i] == type){
|
|
if(type == lightTankType){
|
|
numOfLightTankOnQueue--;
|
|
if(i == 0){
|
|
theBaseInfo.currentCredit+=creditSpentOnBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
lightTankProgress = 255;
|
|
currentStatus = isIdle;
|
|
}
|
|
}
|
|
if(type == rocketTankType){
|
|
numOfRocketTankOnQueue--;
|
|
if(i == 0){
|
|
theBaseInfo.currentCredit+=creditSpentOnBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
rocketTankProgress = 255;
|
|
currentStatus = isIdle;
|
|
}
|
|
}
|
|
if(type == harvesterType){
|
|
numOfHarvesterOnQueue--;
|
|
if(i == 0){
|
|
theBaseInfo.currentCredit+=creditSpentOnBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
harvesterProgress = 255;
|
|
currentStatus = isIdle;
|
|
}
|
|
}
|
|
if(type == droneType){
|
|
numOfDroneOnQueue--;
|
|
if(i == 0){
|
|
theBaseInfo.currentCredit+=creditSpentOnBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
droneProgress = 255;
|
|
currentStatus = isIdle;
|
|
}
|
|
}
|
|
if(type == MCVType){
|
|
numOfMCVOnQueue--;
|
|
if(i == 0){
|
|
theBaseInfo.currentCredit+=creditSpentOnBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
MCVProgress = 255;
|
|
currentStatus = isIdle;
|
|
}
|
|
}
|
|
if(type == stealthTankType){
|
|
numOfStealthTankOnQueue--;
|
|
if(i == 0){
|
|
theBaseInfo.currentCredit+=creditSpentOnBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
stealthTankProgress = 255;
|
|
currentStatus = isIdle;
|
|
}
|
|
}
|
|
if(type == heavyTankType){
|
|
numOfHeavyTankOnQueue--;
|
|
if(i == 0){
|
|
theBaseInfo.currentCredit+=creditSpentOnBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
heavyTankProgress = 255;
|
|
currentStatus = isIdle;
|
|
}
|
|
}
|
|
|
|
for(int j = i; j < productionQueue.length - 1; j++){
|
|
productionQueue[j] = productionQueue[j+1];
|
|
if(productionQueue[j+1] == -1)
|
|
break;
|
|
}
|
|
productionQueue[productionQueue.length - 1] = -1;
|
|
|
|
if(i == 0){
|
|
if(productionQueue[i] == lightTankType){
|
|
lightTankProgress = 0;
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}else if(productionQueue[i] == rocketTankType){
|
|
rocketTankProgress = 0;
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}else if(productionQueue[i] == harvesterType){
|
|
harvesterProgress = 0;
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}else if(productionQueue[i] == droneType){
|
|
droneProgress = 0;
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}else if(productionQueue[i] == MCVType){
|
|
MCVProgress = 0;
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}else if(productionQueue[i] == stealthTankType){
|
|
stealthTankProgress = 0;
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}else if(productionQueue[i] == heavyTankType){
|
|
heavyTankProgress = 0;
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void removelItemFromProductionQueue(int type){
|
|
|
|
if(type == lightTankType){
|
|
numOfLightTankOnQueue--;
|
|
creditSpentOnBuilding = 0;
|
|
lightTankProgress = 255;
|
|
currentStatus = isIdle;
|
|
}
|
|
if(type == rocketTankType){
|
|
numOfRocketTankOnQueue--;
|
|
creditSpentOnBuilding = 0;
|
|
rocketTankProgress = 255;
|
|
currentStatus = isIdle;
|
|
}
|
|
if(type == harvesterType){
|
|
numOfHarvesterOnQueue--;
|
|
creditSpentOnBuilding = 0;
|
|
harvesterProgress = 255;
|
|
currentStatus = isIdle;
|
|
}
|
|
if(type == droneType){
|
|
numOfDroneOnQueue--;
|
|
creditSpentOnBuilding = 0;
|
|
droneProgress = 255;
|
|
currentStatus = isIdle;
|
|
}
|
|
if(type == MCVType){
|
|
numOfMCVOnQueue--;
|
|
creditSpentOnBuilding = 0;
|
|
MCVProgress = 255;
|
|
currentStatus = isIdle;
|
|
}
|
|
if(type == stealthTankType){
|
|
numOfStealthTankOnQueue--;
|
|
creditSpentOnBuilding = 0;
|
|
stealthTankProgress = 255;
|
|
currentStatus = isIdle;
|
|
}
|
|
if(type == heavyTankType){
|
|
numOfHeavyTankOnQueue--;
|
|
creditSpentOnBuilding = 0;
|
|
heavyTankProgress = 255;
|
|
currentStatus = isIdle;
|
|
}
|
|
|
|
|
|
for(int j = 0; j < productionQueue.length - 1; j++){
|
|
productionQueue[j] = productionQueue[j+1];
|
|
if(productionQueue[j+1] == -1)
|
|
break;
|
|
}
|
|
productionQueue[productionQueue.length - 1] = -1;
|
|
|
|
if(productionQueue[0] != -1){
|
|
if(productionQueue[0] == lightTankType){
|
|
lightTankProgress = 0;
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}
|
|
if(productionQueue[0] == rocketTankType){
|
|
rocketTankProgress = 0;
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}
|
|
if(productionQueue[0] == harvesterType){
|
|
harvesterProgress = 0;
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}
|
|
if(productionQueue[0] == droneType){
|
|
droneProgress = 0;
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}
|
|
if(productionQueue[0] == MCVType){
|
|
MCVProgress = 0;
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}
|
|
if(productionQueue[0] == stealthTankType){
|
|
stealthTankProgress = 0;
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}
|
|
if(productionQueue[0] == heavyTankType){
|
|
heavyTankProgress = 0;
|
|
currentStatus = isBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
//cancel all the building process, refund money spent on current process
|
|
public void cancelBuilding(){
|
|
theBaseInfo.currentCredit+=creditSpentOnBuilding;
|
|
creditSpentOnBuilding = 0;
|
|
currentStatus = isIdle;
|
|
lightTankProgress = 255;
|
|
rocketTankProgress = 255;
|
|
harvesterProgress = 255;
|
|
droneProgress = 255;
|
|
MCVProgress = 255;
|
|
stealthTankProgress = 255;
|
|
heavyTankProgress = 255;
|
|
for(int i = 0; i < productionQueue.length; i++)
|
|
productionQueue[i] = -1;
|
|
numOfLightTankOnQueue = 0;
|
|
numOfStealthTankOnQueue = 0;
|
|
numOfRocketTankOnQueue = 0;
|
|
numOfHeavyTankOnQueue = 0;
|
|
}
|
|
|
|
//draw the model
|
|
public void draw(){
|
|
if(!visible)
|
|
return;
|
|
for(int i = 0; i < numOfPolygons; i++){
|
|
|
|
polygons[i].update();
|
|
}
|
|
|
|
if(centre.y < -0.8f){
|
|
polygons[distortionA].visible = false;
|
|
polygons[distortionB].visible = false;
|
|
}
|
|
|
|
for(int i = 0; i < numOfPolygons; i++){
|
|
polygons[i].draw();
|
|
}
|
|
}
|
|
|
|
public void drawRallyPointLine(){
|
|
if(isSelected && teamNo == 0 && mainThread.pc.theSideBarManager.onlyFactorySelected){
|
|
geometry.drawLine(centre, rallyCenter, 0xff00, (byte)16);
|
|
}
|
|
|
|
if(isSelected && teamNo == 0 && mainThread.pc.theSideBarManager.onlyFactorySelected && targetGoldMine != null){
|
|
geometry.drawLine(centre, targetGoldMine.centre, 0xffff00, (byte)15);
|
|
}
|
|
}
|
|
|
|
public vector getMovement(){
|
|
return movenment;
|
|
}
|
|
|
|
|
|
//factory can't not move, instead it will set its rally point to the destination position
|
|
public void moveTo(float destinationX, float destinationY){
|
|
if(teamNo != 0 || mainThread.pc.theSideBarManager.onlyFactorySelected){
|
|
|
|
rallyCenter.set(destinationX, -0.3f, destinationY);
|
|
rallyPointChanged = true;
|
|
}
|
|
}
|
|
|
|
public void moveDeliveredUnitToRallyPoint(){
|
|
|
|
|
|
if(rallyPointChanged){
|
|
if(deliveredUnit.type != 0 && deliveredUnit.type != 1 && deliveredUnit.type != 6 && deliveredUnit.type !=7 ){
|
|
deliveredUnit.moveTo(rallyCenter.x, rallyCenter.z);
|
|
deliveredUnit.currentCommand = solidObject.move;
|
|
deliveredUnit.secondaryCommand = solidObject.StandBy;
|
|
return;
|
|
}else{
|
|
deliveredUnit.attackMoveTo(rallyCenter.x, rallyCenter.z);
|
|
deliveredUnit.currentCommand = solidObject.attackMove;
|
|
deliveredUnit.secondaryCommand = solidObject.attackMove;
|
|
return;
|
|
}
|
|
}
|
|
|
|
//default rally points
|
|
for(int i = 0; i < rallyPoints.length; i++){
|
|
float rallyX = rallyCenter.x + rallyPoints[i].x;
|
|
float rallyY = rallyCenter.z + rallyPoints[i].z;
|
|
|
|
|
|
|
|
int tileIndex = ((int)(rallyX*64) - 8) /16 + (127 - (((int)(rallyY*64) + 8) - 1)/16)*128;
|
|
|
|
|
|
|
|
|
|
|
|
boolean rallyPointClear = true;
|
|
for(int j = 0; j < 4; j ++){
|
|
if(mainThread.gridMap.tiles[tileIndex][j]!= null && mainThread.gridMap.tiles[tileIndex][j] != deliveredUnit){
|
|
probeBlock.width = 8;
|
|
probeBlock.height = 8;
|
|
probeBlock.setOrigin((int)(rallyX*64)-4, (int)(rallyY*64)+4);
|
|
|
|
if(mainThread.gridMap.tiles[tileIndex][j].boundary2D.intersect(probeBlock)){
|
|
|
|
rallyPointClear = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(rallyPointClear){
|
|
deliveredUnit.moveTo(rallyX, rallyY);
|
|
deliveredUnit.currentCommand = solidObject.move;
|
|
deliveredUnit.secondaryCommand = solidObject.StandBy;
|
|
return;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public boolean isIdle(){
|
|
return lightTankProgress == 255 && rocketTankProgress == 255 && harvesterProgress == 255 && droneProgress == 255 && MCVProgress == 255 && stealthTankProgress == 255 && heavyTankProgress == 255;
|
|
}
|
|
|
|
public void harvest(solidObject o){
|
|
if(targetGoldMine != o)
|
|
targetGoldMine = (goldMine)o;
|
|
else if(targetGoldMine == o && mainThread.pc.theSideBarManager.factoryRallyOnSameGoldMine)
|
|
targetGoldMine = null;
|
|
}
|
|
}
|