/**
* This method actually notifies which enemies need to update their paths
*
* @param inMiddleOfWave
* @param enemy
*/
private void updateEnemyPaths(boolean inMiddleOfWave, Enemy enemy) {
if (inMiddleOfWave) {
Log.i("Updating path", "Updating path");
enemy.setNeedToUpdatePath(true);
for (Enemy child : enemy.childArray) {
child.setNeedToUpdatePath(true);
}
} else {
Path p = null;
Enemy en = null;
for (Enemy e : currentWave.getEnemies()) {
if (e.getClass() != BeachballEnemy.class) {
p = aStarHelper.getPath(e);
en = e;
break;
}
}
// We have a wave full of beach-ball enemies
if (en == null) return;
if (p == null) {
removeCurrentTower(true);
p = aStarHelper.getPath(en);
}
for (Enemy e : currentWave.getEnemies()) {
if (e.getClass() != BeachballEnemy.class) e.setPath(p.deepCopy());
else aStarHelper.getPath(e);
}
}
}
/**
* When placing a tower on the field, this checks if the path needs to be updated for each enemy
*
* @param current
* @param inMiddleOfWave
*/
private void updateAffectedEnemies(TMXTile current, boolean inMiddleOfWave) {
List<Enemy> enemies = currentWave.getEnemies();
Path p;
float pX;
float pY;
outer:
for (Enemy enemy : enemies) {
if (enemy == null) continue;
p = enemy.getPath();
for (int i = 0; i < p.getCoordinatesX().length; i++) {
pX = p.getCoordinatesX()[i];
pY = p.getCoordinatesY()[i];
TMXTile tile = this.tmxLayer.getTMXTileAt(pX - enemy.getOffsetX(), pY - enemy.getOffsetY());
if (current.equals(tile)) {
updateEnemyPaths(inMiddleOfWave, enemy);
if (!inMiddleOfWave) break outer;
else break;
}
}
}
if (inMiddleOfWave) {
Enemy dummy = new Enemy();
dummy.setUserData("dummy");
Path path = aStarHelper.getPath(dummy);
if (path == null) {
removeCurrentTower(true);
}
}
}
/**
* Removes a tower from the field
*
* @param Tower t
*/
public void removeTower(final ITower t, boolean removeTile) {
TMXTile tile =
tmxLayer.getTMXTileAt(
t.getEntity().getX() + GameMap.getTileSize() / 2,
t.getEntity().getY() + GameMap.getTileSize() / 2);
if (blockedTileList.contains(tile) && removeTile) {
blockedTileList.remove(tile);
}
activity.runOnUpdateThread(
new Runnable() {
@Override
public void run() {
t.getEntity().detachSelf();
SubMenuManager.getReticle(t).detachSelf();
t.getEntity().clearEntityModifiers();
t.getEntity().clearUpdateHandlers();
}
});
if (towers.contains(t)) {
towers.remove(t);
}
// if the user manually deleted the tower, we need to adjust for that for the paths of the
// enemies
if (aStarHelper.isNavigating())
for (Enemy e : currentWave.getEnemies()) updateEnemyPaths(true, e);
else updateEnemyPaths(false, null);
}
/**
* Checks to see if the wave has commenced. Should only fire once per wave even though there are 2
* distinct ways to end a wave. If the wave has ended, it calls the method to initialize the next
* wave.
*/
public void seeIfWaveFinished() {
if (!initializedNewWave) {
if ((deadEnemies + aStarHelper.getNumberOfEnemiesFinished()
== currentWave.getEnemies().size())) {
initializedNewWave = true;
waveFinished = true;
endInWaveUpdateHandlers();
initializeNextWave();
}
}
}
/** Initializes paths and move modifiers of all enemies in the next wave */
public void initializeNextWave() {
Log.i("Init wave", "here");
// If the previous wave was eliminated even before all enemies technically started, the time
// handler
// that handles their first move modifier would never get unregistered, putting the game in
// limbo
this.unregisterUpdateHandler(waveGenerator.getTimeHandler());
if (startButton.getCurrentTileIndex() > 1)
startButton.setCurrentTileIndex(startButton.getCurrentTileIndex() - 2);
// The player wins the game!!
if (waveCount == 70 && lives != 0) {
displayWinScreen();
return;
}
waveGenerator.initWave(waveCount);
currentWave = waveGenerator.get(waveCount);
enemies = (CopyOnWriteArrayList<Enemy>) currentWave.getEnemies();
waveCount++;
panel.setWaveText(waveCount);
this.aStarHelper.finishWave();
this.deadEnemies = 0;
/** Just for debugging */
for (Enemy enemy : currentWave.getEnemies()) {
if (enemy == null) continue;
enemy.setUserData(null);
enemy.returnHealthToNormal();
}
for (ITower tower : towers) {
tower.onWaveEnd();
}
}
// ***********************************************************
// CONSTRUCTOR
// ***********************************************************
public GameScene(MapType type) {
instance = this;
gameMap = new GameMap(type);
// Zoom-Camera configuration
this.setOnAreaTouchTraversalFrontToBack();
this.mScrollDetector = new SurfaceScrollDetector(this);
activity = TowerDefenseActivity.getSharedInstance();
resourceManager = ResourceManager.getInstance();
if (MultiTouch.isSupported(activity)) {
this.mPinchZoomDetector = new PinchZoomDetector(this);
} else {
this.mPinchZoomDetector = null;
}
this.setOnSceneTouchListener(this);
this.setOnSceneTouchListenerBindingOnActionDownEnabled(true);
fingerOnSceneCount = 0;
zooming = false;
String map = "";
if (type == MapType.DESERT) map = "tmx/new_desert_path.tmx";
else if (type == MapType.GRASS) map = "tmx/grass_path.tmx";
else if (type == MapType.TUNDRA) map = "tmx/tundra_path.tmx";
try {
final TMXLoader tmxLoader =
new TMXLoader(
activity.getAssets(),
activity.getEngine().getTextureManager(),
TextureOptions.BILINEAR_PREMULTIPLYALPHA,
activity.getVertexBufferObjectManager(),
new ITMXTilePropertiesListener() {
@Override
public void onTMXTileWithPropertiesCreated(
final TMXTiledMap pTMXTiledMap,
final TMXLayer pTMXLayer,
final TMXTile pTMXTile,
final TMXProperties<TMXTileProperty> pTMXTileProperties) {}
});
this.mTMXTiledMap = tmxLoader.loadFromAsset(map);
} catch (final TMXLoadException e) {
Debug.e(e);
}
gameMap.setMap(mTMXTiledMap);
tmxLayer = this.mTMXTiledMap.getTMXLayers().get(0);
tmxLayer.setIgnoreUpdate(true);
this.attachChild(tmxLayer);
mCamera = activity.getCamera();
this.mCamera.setBounds(
0, (mCamera.getHeight() - tmxLayer.getHeight()), tmxLayer.getWidth(), tmxLayer.getHeight());
this.mCamera.setBoundsEnabled(true);
float camera_width = activity.getCamera().getWidth();
float camera_height = activity.getCamera().getHeight();
if (camera_width / tmxLayer.getHeight() >= camera_height / tmxLayer.getWidth())
maxZoom = camera_width / (tmxLayer.getHeight() * 2);
else maxZoom = camera_height / (tmxLayer.getWidth() * 2);
// 2-dimensional array of tiles
TMXTile[][] tiles = tmxLayer.getTMXTiles();
startTile = null;
endTile = null;
outer:
for (int i = 0; i < tiles.length; i++) {
for (int j = 0; j < tiles[0].length; j++) {
int[] start = gameMap.getStartTile();
int[] end = gameMap.getEndTile();
if (i == start[0] && j == start[1]) {
startTile = tiles[i][j];
} else if (i == end[0] && j == end[1]) {
endTile = tiles[i][j];
break outer;
}
}
}
money = 60;
lives = 20;
// Initializes the HUD
panel = new BottomPanel(mCamera, gameMap);
this.attachChild(panel);
TowerTile.initializeMap();
TowerTile turretTile = new TowerTile(resourceManager.getTurretTowerRegion());
panel.placeTowerAccess(turretTile, 1);
TowerTile iceTile = new TowerTile(resourceManager.getIceTowerRegion());
panel.placeTowerAccess(iceTile, 2);
TowerTile dartTile = new TowerTile(resourceManager.getDartTowerRegion());
panel.placeTowerAccess(dartTile, 3);
TowerTile spikeTile = new TowerTile(resourceManager.getSpikeTowerRegion());
panel.placeTowerAccess(spikeTile, 4);
TowerTile flameTile = new TowerTile(resourceManager.getFlameTowerRegion());
panel.placeTowerAccess(flameTile, 5);
startButton =
new AnimatedSprite(
0.0f,
0.0f,
resourceManager.getStartButtonRegion(),
activity.getVertexBufferObjectManager()) {
@Override
public boolean onAreaTouched(
TouchEvent pSceneTouchEvent, float pTouchAreaLocalX, float pTouchAreaLocalY) {
if (readyToPressAgain) {
startCurrentWave();
readyToPressAgain = false;
this.registerUpdateHandler(
new TimerHandler(
1.0f,
new ITimerCallback() {
@Override
public void onTimePassed(TimerHandler pTimerHandler) {
readyToPressAgain = true;
unregisterUpdateHandler(pTimerHandler);
}
}));
}
panel.detachTowerTextDescription();
return true;
}
};
startButton.setScale(0.473372781f);
panel.placeStartButton(startButton);
// Getting texture regions for submenu items
SubMenuManager.getDeleteRegion(resourceManager.getDeleteOptionRegion());
SubMenuManager.getUpgradeRegion(resourceManager.getUpgradeOptionRegion());
SubMenuManager.getReticalRegion(resourceManager.getTowerSightRegion());
// Initializing tower array
towers = new ArrayList<ITower>();
downCoords = new Vector2();
blockedTileList = new ArrayList<TMXTile>();
aStarHelper = new AStarPathHelper(mTMXTiledMap, endTile);
waveGenerator = new WaveHelper();
waveCount = 0;
deadEnemies = 0;
waveFinished = true;
initializedNewWave = false;
// Sets up paths/move modifiers of enemies in the first wave
initializeNextWave();
FlameTower.initialize(resourceManager.getFlameParticleRegion());
Log.i(
"Info",
"Dead Enemies: "
+ deadEnemies
+ " Finished Enemies: "
+ aStarHelper.getNumberOfEnemiesFinished()
+ " Current Wave Length: "
+ currentWave.getEnemies().size());
speedFactor = 0.5f;
readyToPressAgain = true;
// collisionDetect = new TimerHandler((float)0.0125/speedFactor, true, new ITimerCallback() {
collisionDetect =
new TimerHandler(
0.025f,
true,
new ITimerCallback() {
@Override
public void onTimePassed(TimerHandler pTimerHandler) {
collisionDetect();
}
});
enemyQueues =
new TimerHandler(
0.3f,
true,
new ITimerCallback() {
@Override
public void onTimePassed(TimerHandler pTimerHandler) {
addEnemiesToTowerQueues();
}
});
disableBackButton = false;
}
