private ITower pointOnExistingTower(float x, float y) {
for (int i = 0; i < towers.size(); i++) {
ITower t = towers.get(i);
if (t.getEntity().contains(x, y)) return t;
}
return null;
}
private void addEnemiesToTowerQueues() {
for (ITower tower : towers) {
tower.clearQueue();
for (Enemy enemy : enemies) {
if (enemy.isDead() || enemy.getUserData() == "dead") continue;
if (tower.inSights(enemy.getXReal(), enemy.getYReal())) {
tower.addEnemyToQueue(enemy);
}
}
}
}
/**
* 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);
}
/** 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();
}
}
/** TODO So ugly :( Maybe make it its own class? */
@Override
public boolean onSceneTouchEvent(final Scene pScene, final TouchEvent pSceneTouchEvent) {
final Float x = pSceneTouchEvent.getX();
final Float y = pSceneTouchEvent.getY();
currentTile = this.tmxLayer.getTMXTileAt(x, y);
// if the user pinches or dragtouches the screen then...
if (this.mPinchZoomDetector != null) {
this.mPinchZoomDetector.onTouchEvent(pSceneTouchEvent);
if (this.mPinchZoomDetector.isZooming()) {
this.mScrollDetector.setEnabled(false);
} else if (!towerMove) {
if (pSceneTouchEvent.isActionDown()) {
this.mScrollDetector.setEnabled(true);
}
this.mScrollDetector.onTouchEvent(pSceneTouchEvent);
}
} else {
this.mScrollDetector.onTouchEvent(pSceneTouchEvent);
}
if (pSceneTouchEvent.isActionDown()) {
downCoords.set(x, y);
SubMenuManager.setReticalPosition(-500.0f, -500.0f);
Log.i("Detaching now", "NOW");
SubMenuManager.remove();
this.unregisterTouchArea(SubMenuManager.getDeleteSprite());
panel.detachTowerUpgradeDeleteText();
panel.detachTowerTextDescription();
panel.attachTowerTextDescription(pointOnTile(TouchEvent.ACTION_DOWN));
}
Class<?> tClass;
if (pSceneTouchEvent.isActionMove()) {
tClass = pointOnTile(TouchEvent.ACTION_MOVE);
if (tClass != null && !towerMove) {
dragTower = null;
towerMove = true;
if (tClass.equals(TurretTower.class) && canAfford(TurretTower.COST)) {
dragTower = new TurretTower(x, y, resourceManager.getTurretTowerRegion());
} else if (tClass.equals(DartTower.class) && canAfford(DartTower.COST)) {
dragTower = new DartTower(x, y, resourceManager.getDartTowerRegion());
} else if (tClass.equals(FlameTower.class) && canAfford(FlameTower.COST)) {
dragTower = new FlameTower(x, y, resourceManager.getFlameTowerRegion());
} else if (tClass.equals(IceTower.class) && canAfford(IceTower.COST)) {
dragTower = new IceTower(x, y, resourceManager.getIceTowerRegion());
} else if (tClass.equals(SpikeTower.class) && canAfford(SpikeTower.COST)) {
dragTower = new SpikeTower(x, y, resourceManager.getSpikeTowerRegion());
} else towerMove = false;
if (dragTower != null) {
dragTower.getEntity().setZIndex(2);
dragTower.getEntity().setScale(0.5f);
activity.runOnUpdateThread(
new Runnable() {
@Override
public void run() {
attachChild(dragTower.getEntity());
try {
attachChild(SubMenuManager.getReticle(dragTower));
} catch (Exception e) {
}
sortChildren();
}
});
tClass = null;
}
}
// Moving an active drag tower
else if (towerMove) {
if (pointOnMap(x, y)) {
dragTower.setPosition(
currentTile.getTileX() - GameMap.getTileSize() / 2,
currentTile.getTileY() - GameMap.getTileSize() / 2);
if (highlightTile == null) {
highlightTile =
new Rectangle(
currentTile.getTileX(),
currentTile.getTileY(),
GameMap.getTileSize(),
GameMap.getTileSize(),
activity.getVertexBufferObjectManager());
highlightTile.setTag(777);
highlightTile.setZIndex(1);
this.attachChild(highlightTile);
this.sortChildren();
} else {
highlightTile.setPosition(currentTile.getTileX(), currentTile.getTileY());
}
if (!inLegitimatePosition(currentTile)) {
highlightTile.setColor(Color.RED);
} else {
highlightTile.setColor(Color.BLUE);
}
// if you drag the dragtower off the map, and then back on, we need to be able to tag it
// so we can display the highlight tile again
if (this.getChildByTag(777) == null) {
this.attachChild(highlightTile);
this.sortChildren();
}
}
// if point NOT on map
else {
if (highlightTile != null) {
detachHighlightTile();
}
dragTower.setPosition(
pSceneTouchEvent.getX() - dragTower.getEntity().getWidth() / 2,
pSceneTouchEvent.getY() - dragTower.getEntity().getHeight() / 2);
}
}
} else if (pSceneTouchEvent.isActionUp()) {
if (zooming) {
fingerOnSceneCount--;
if (fingerOnSceneCount == 0) {
zooming = false;
setUserDataforTowerTiles("");
for (TowerTile tile : panel.getTiles()) {
tile.returnOnMoved();
}
}
}
if (towerMove) {
towerMove = false;
if (currentTile != null
&& highlightTile != null
&& highlightTile.getColor().equals(Color.BLUE)) {
// Add the tile to the blocked list
blockedTileList.add(currentTile);
towers.add(dragTower);
SubMenuManager.getReticle(dragTower).detachSelf();
// need to get it out of the scene so that the next dragtower doesn't have to start with
// it from where the
// previous tower was placed
SubMenuManager.setReticalPosition(-500.0f, -500.0f);
// Nothing is free in this world
this.payAmount(dragTower.getCost());
// If we are in the middle of a wave, the AStarPath class must update
// the path since there is now a new tower on the field
updateAffectedEnemies(currentTile, aStarHelper.isNavigating());
} else {
removeCurrentTower(false);
}
if (highlightTile != null) {
detachHighlightTile();
}
} else if (Math.abs(downCoords.x - x) < 15.0f && Math.abs(downCoords.y - y) < 15.0f) {
final ITower tower = pointOnExistingTower(x, y);
if (tower != null) {
this.attachChild(SubMenuManager.display(tower));
Log.i("Reticle", "Visible? " + SubMenuManager.getReticle(tower).isVisible() + "");
panel.attachTowerUpgradeDeleteText(tower);
if (camera.getZoomFactor() - 1.0f < 0.00005f && camera.getYMin() < 0.00005f) {
final float displacement = tower.getRadius() - tower.getEntity().getHeightScaled() / 2;
if (tower.getY() == -20.0f) {
camera.set(
camera.getXMin(),
camera.getYMin() - displacement,
camera.getXMax(),
camera.getYMax() - displacement);
} else if (tower.getY() == 340.0f) {
camera.set(
camera.getXMin(),
camera.getYMin() + displacement,
camera.getXMax(),
camera.getYMax() + displacement);
}
}
}
}
}
return true;
}
/** Each tower fires at the first enemy in their respective queue Runs every .025 seconds */
private void collisionDetect() {
for (ITower t : towers) {
Enemy enemy = t.getLockedOn();
if (enemy == null) {
t.onIdleInWave();
continue;
}
if (enemy.isDead()) {
t.removeEnemyFromQueue(enemy);
continue;
}
if (t.inSights(enemy.getXReal(), enemy.getYReal())) {
t.onImpact(enemy);
t.shoot(enemy);
/** TODO: Make a "canRotate" variable for each class so this isn't such a hack */
if (t.getClass() == IceTower.class || t.getClass() == SpikeTower.class) continue;
dx = t.getEntity().getX() - (enemy.getX() - enemy.getWidthScaled() / 3.5f);
dy = t.getEntity().getY() - (enemy.getY() - enemy.getHeightScaled() / 3.5f);
angle = MathUtils.atan2(dy, dx);
realAngle = (float) (angle * (180.0f / Math.PI));
t.getEntity().setRotation(realAngle);
} else {
t.removeEnemyFromQueue(enemy);
t.onEnemyOutOfRange(enemy);
}
}
}
/** Removes the dragtower and the currentTile */
public void removeCurrentTower(boolean removeTile) {
if (removeTile) this.addAmount(dragTower.getCost());
removeTower(dragTower, removeTile);
}
