public static void main(String[] args) {
World world = new World("defense");
ArrayList<Enemy> enemies = new ArrayList<Enemy>();
ArrayList<Tower> towers = new ArrayList<Tower>();
ArrayList<Bullet> bullets = new ArrayList<Bullet>();
while (true) {
world.draw();
for (Bullet bullet : bullets) {
bullet.move(); // TODO
bullet.draw(); // TODO
}
for (int i = 0; i < enemies.size(); i++) {
Enemy enemy = enemies.get(i);
enemy.move();
enemy.draw();
for (int j = 0; j < bullets.size(); j++) {
Bullet bullet = bullets.get(j);
if (bullet.isHitting(enemy)) {
enemies.remove(i);
bullets.remove(j);
i--;
break;
}
}
}
if (Window.mouse.clicked()) {
int x = Window.mouse.getX() / world.getScale();
int y = Window.mouse.getY() / world.getScale();
Space space = world.getSpace(x, y);
String color = "orange";
int reload = 50;
int range = world.getScale() * 5;
if (space.getType() == world.GRASS && space.hasTower() == false) {
Tower tower = new Tower(space, world, color, reload, range, null);
tower.setComparator(new CloseComparator(tower));
towers.add(tower);
}
}
for (Tower tower : towers) {
tower.draw(world.getScale() / 2); // TODO
Bullet bullet = tower.fire(enemies);
if (bullet != null) {
bullets.add(bullet);
}
}
Window.frame();
if (Window.random(-40, 40) == 0) {
enemies.add(new Enemy(10, 3, world));
}
}
}
public float getRowY() {
if (!this.isEmpty()) {
Enemy e = enemyList.getFirst();
return e.getY();
}
return -100;
}
protected void specificUpdate(GameTime gameTime) {
this.applyGravity();
super.de.update(gameTime);
if (!this.actable
&& (MathUtils.abs((float) (this.Pos.x - this._player.Pos.x)) <= this.actDis)) {
this.actable = true;
}
if (this.actable) {
super._Paused = false;
if (super._Frame == 8) {
super._TimePerFrame = 0.06666667f;
super.setAnimation(new int[] {9, 10, 11, 10});
this.moveable = true;
}
}
if (this.moveable) {
if ((this.Pos.x - this._player.Pos.x) >= 0f) {
this.i_am_hardly_walking_to_left = true;
this.i_am_hardly_walking_to_right = false;
this.isfacingToLeft = true;
this.Pos.x -= this.VX;
} else {
this.i_am_hardly_walking_to_left = false;
this.i_am_hardly_walking_to_right = true;
this.isfacingToLeft = false;
this.Pos.x += this.VX;
}
}
super.color = LColor.white;
}
public static void Start(Player player, Level level, Enemy enemy) {
System.out.println(player.getCharName() + " Health: " + player.getHealth());
System.out.println(enemy.getName() + " " + enemy.getType() + " Health: " + enemy.getHealth());
System.out.println("Level: " + level.getLevelType());
int choice = ChooseAttacks();
CalculateDamage(choice, player, level, enemy);
}
/**
* Creates a new "game" from the current engine.Globals.game variable. While the ANN stays the
* same, the speed, actor positions, score, et cetera, are all reset.
*/
public void newGame() {
stopped = true;
player.setLives(STARTING_LIVES);
player.setScore(0);
Graphics g = strategy.getDrawGraphics();
waiting = true;
Globals.state = ENEMY_HUNTER_STATE;
player.setCenter(board.getPlayerStartPoint());
player.setDirection(Player.DEFAULT_STARTING_DIRECTION);
board.reset();
Globals.blipsLeft = Globals.game.getBoard().getBlipCount();
for (Enemy enemy : enemies) {
enemy.reset();
}
GamePainters.drawBoard(board, g, this);
GamePainters.drawEnemies(enemies, g, this);
GamePainters.drawPlayer(player, g, this);
GamePainters.paintBottomBar(player, board, g, this);
strategy.show();
}
public void fire() {
if (!canFire()) return;
Enemy target = getTargetEnemy();
if (target == null) return;
if (this.towerType == TowerType.ArrowTower) {
Effect effect =
new Effect(
1, TowerType.ArrowTower.getAttack(level), Effect.Target.SINGLE, Effect.Type.DAMAGE);
effect.setTargetEnemy(target);
grid.getLevel().getCurrentWave().addEffect(effect);
grid.getLevel()
.getCurrentWave()
.addAmmoSprite(
new AmmoSprite(
this.grid, target.getLastGrid(), Configuration.TOWER_ARROWTOWER_AMMOSPRITE_TYPE));
} else if (this.towerType == TowerType.CannonTower) {
Effect effect =
new Effect(
1, TowerType.CannonTower.getAttack(level), Effect.Target.SPLASH, Effect.Type.DAMAGE);
effect.setTargetGrid(target.getGrid());
grid.getLevel().getCurrentWave().addEffect(effect);
grid.getLevel()
.getCurrentWave()
.addAmmoSprite(
new AmmoSprite(
this.grid,
target.getLastGrid(),
Configuration.TOWER_CANNONTOWER_AMMOSPRITE_TYPE));
} else throw new AssertionError();
// setib turns to fire kuhugi
// efekt vaja tekitada
}
/**
* determines whether a projectile hits an enemy
*
* @param enemy - enemy projectile hits
* @return - true if enemy gets hit, false otherwise
*/
public boolean hitEnemy(Enemy enemy) {
if (myX >= enemy.getX() - 25 && myX <= enemy.getX() + 25) {
if (myY <= enemy.getY() + 25 && myY >= enemy.getY() - 25) {
return true;
}
}
return false;
}
public static void enemyDead(Position pos) {
for (Enemy en : enList) {
if (en.getPosition().getRow() == pos.getRow()
&& en.getPosition().getColumn() == pos.getColumn()) {
en.declareDead();
}
}
}
public void update() {
for (Iterator ite = enemyList.iterator(); ite.hasNext(); ) {
Enemy e = (Enemy) ite.next();
if (!e.isAlive()) {
ite.remove();
}
}
}
@Override
public ArrayList<Position> getEnemiesPositions() {
ArrayList<Position> positions = new ArrayList<Position>();
for (Enemy enemy : enemyList) {
positions.add(enemy.getPosition());
}
return positions;
}
private int getNextYForEnemy(Enemy en, DataPoint dp) {
double dist = computeDistance(en.getCoordX(), en.getCoordY(), dp.getCoordX(), dp.getCoordY());
if (dist <= ENEMY_DIST_BY_TURN) {
return dp.getCoordY();
} else {
return (int)
(en.getCoordY() + ((dp.getCoordY() - en.getCoordY()) * ENEMY_DIST_BY_TURN / dist));
}
}
private void decreaseAglie(Enemy enemy) {
System.out.println(enemy.getType() + "的敏捷下降：" + deAglieNum);
int td = enemy.getAgile() - deAglieNum;
if (td < 0) {
enemy.setAgile(0);
System.out.println(enemy.getType() + "的敏捷已经下降为0");
} else {
enemy.setAgile(td);
}
}
private int testEnemyCol() {
for (int i = 0; i < game.enemies.size(); i++) {
Enemy e = game.enemies.get(i);
if (bounding.intersects(e.getBounding()) && e.isAlive()) {
e.die();
return i;
}
}
return -1;
}
public void initEnemy() {
List<Map<String, Object>> lst =
gameDao.getSimpleJdbcTemplate().queryForList(RelationDAO.SQL_SELECT_ENEMY, player.getId());
for (Map<String, Object> map : lst) {
Enemy enemy = gameDao.getRelationDAO().loadEnemy(map);
if (enemy != null) {
emyMgr.put(enemy.getEnemyId(), enemy);
}
}
}
public void addEnemy(Position position) {
boolean positionAlreadyUsed = false;
for (Enemy enemy : enemyList) {
if (enemy.getPosition().equals(position)) {
positionAlreadyUsed = true;
enemyList.remove(enemy);
break;
}
}
if (!positionAlreadyUsed)
enemyList.add(new Enemy(new Position(position.getX(), position.getY()), Direction.UP));
}
@Override
public void create(Vector2f loc, Vector2f dir) {
Enemy alien = (Enemy) entities.get(ndx);
if (count < maxCount) {
alien.create();
alien.setLoc(loc);
alien.setDir(dir);
activeNdxs.add(ndx);
count++;
ndx++;
if (ndx == maxCount) ndx = 0;
}
}
/**
* Remove enemies that are either out of bound or dead. Also checks if this wave is defeated. If
* it is, starts a new wave and adds 25 to the money
*
* @return none
*/
private void remove() {
Iterator<Enemy> iterator = enemies.iterator();
while (iterator.hasNext()) {
Enemy enemy = iterator.next();
if (enemy.isDead() || enemy.isOutOfBound()) {
iterator.remove();
}
if (enemies.isEmpty()) {
money += 25;
TowerDefenseGame.getControlPanel().newWave();
}
}
}
public void checkEnemyCollision() {
for (Enemy e : enemyList) {
if (e.getOnScreen()) { // can be removed later on
// goes through all the enemies and checks if they collide
if (e.checkCollision(e.getPics().get(e.getCounter()), player1)) {
if (player1.getInvi() == false) {
// If the player is not invisble then you get spiked.
if (player1.getVelocity() > 0) { // if the player hits it from the bottom
player1.setSpikeVelo();
loseCoins();
} else {
player1.setVelo(
50); // if the player is on top instead the player bounces off the enemy
if (musicOn) {
bounce.play();
}
}
}
eRemove.add(e); // once we hit, we remove the enemy
}
} else {
eRemove.add(e); // if the enemy goes of the screen, we remove
}
}
for (Enemy e : eRemove) {
poofList.add(new Poof(e.getX(), e.getY(), 1)); // removes all the enemies
enemyList.remove(e);
}
eRemove = new ArrayList<Enemy>();
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
height = this.getHeight();
width = this.getWidth();
drawPlayers(g);
g.setColor(Color.WHITE);
g.drawString("Score", width - 60, 25);
g.drawString(String.valueOf(score), width - 60, 40);
if (countdownF) {
g.drawString(String.valueOf(counterN), width / 2 - 10, height / 2);
} else {
if ((spawnCircleB) && (spawnIncrease)) {
spawnCircles();
}
if (spawnMonsterB) {
spawnMonsters();
}
if (spawnRandomersB) {
spawnRandomers();
}
if (spawnRainB) {
spawnRain();
}
if (spawnBombB()) {
spawnBomb();
}
try {
Iterator i = enemies.iterator();
while (i.hasNext()) {
Enemy e = (Enemy) i.next();
Iterator j = players.iterator();
while (j.hasNext()) {
Player p = (Player) j.next();
e.move(players, programSpeedAdjust /*/players.size()*/);
if ((e.collidesWith(p.getX(), p.getY())) && (!p.getImmunity())) {
p.decLives(p.getX(), p.getY());
p.setImmunity(true);
}
}
e.paint(g);
}
} catch (Exception e) {
}
}
drawLayout(g);
}
private int getTurnToKillEnemyInThisPosition(Enemy en, DataPoint dp) {
int i = 0;
int enemyLife = en.getEnemyLife();
int currentX = en.getCoordX();
int currentY = en.getCoordY();
while (enemyLife > 0) {
currentX = getNextXForEnemy(currentX, currentY, dp);
currentY = getNextYForEnemy(currentX, currentY, dp);
int dist = computeDistance(getCoordX(), getCoordX(), currentX, currentY);
enemyLife -= computeImpactEfficiency(dist);
i++;
}
return i;
}
public static void CalculateDamage(int choice, Player player, Level level, Enemy enemy) {
float locationMultiplier = 1;
float defenderMultiplier = 1;
float totalMultiplier;
float calcDmg;
lType = level.getLevelType();
eType = enemy.getType();
defenderMultiplier = setDefenderMultiplier(defenderMultiplier, choice);
locationMultiplier = setLocationMultiplier(locationMultiplier, choice);
totalMultiplier = (defenderMultiplier * locationMultiplier);
calcDmg = player.getBaseDamage() * totalMultiplier;
enemy.setHealth(enemy.getHealth() - calcDmg);
}
/**
* Can i kill enemy in one shoot at the next turn
*
* @param en
* @param enemyLife
* @return
*/
private boolean enoughDamageToKillInOneShootNextTurn(Enemy en, DataPoint dp) {
int dist =
computeDistance(
getCoordX(), getCoordY(), getNextXForEnemy(en, dp), getNextYForEnemy(en, dp));
int damage = computeImpactEfficiency(dist);
return damage >= en.getEnemyLife() ? true : false;
}
public Enemy2(Player player) {
super.actWidth = 42f;
super.actHeight = 58f;
this._player = player;
super.life = 3;
super.loadSe("assets/enemyDE", 0.3f);
super.Load("assets/e2", 0x12, 9, 2f, true);
super.setAnimation(new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11});
super._Paused = true;
this.Origin.x = super.getWidth() / 2f;
this.Origin.y = super.getHeight();
this.bounds.x = (int) (-super.actWidth / 2f);
this.bounds.y = -((int) super.actHeight);
this.bounds.width = (int) super.actWidth;
this.bounds.height = (int) super.actHeight;
}
private boolean spawnBombB() {
boolean bombPartsExist = false;
try {
Iterator i = enemies.iterator();
while (i.hasNext()) {
Enemy e = (Enemy) i.next();
if (e.getClass().equals(EnemyTypes.Bomb.class)
|| (e.getClass().equals(EnemyTypes.Shrapnel.class))) {
bombPartsExist = true;
break;
}
}
} catch (Exception e) {
}
return !bombPartsExist;
}
/**
* This method will move mario vertically and then check if he should be removed because he is out
* of the world. It will also check if mario should kill an enemy which he is standing on. If the
* s key is pressed and there is a pipe below mario, the world will change.
*/
protected void moveVertically() {
ySpeed++;
setLocation(getX(), getY() + ySpeed / 2);
onGround = false;
while (getOneObjectAtOffset(0, getImage().getHeight() / 2 - 2, Ground.class) != null) {
setLocation(getX(), getY() - 1);
onGround = true;
ySpeed = 0;
}
while (getOneObjectAtOffset(0, getImage().getHeight() / 2 - 2, Brick.class) != null) {
setLocation(getX(), getY() - 1);
onGround = true;
ySpeed = 0;
}
while (getOneObjectAtOffset(0, -getImage().getHeight() / 2 + 1, Block.class) != null) {
setLocation(getX(), getY() + 1);
ySpeed = 0;
}
while (getOneObjectAtOffset(0, -getImage().getHeight() / 2 + 1, Brick.class) != null) {
setLocation(getX(), getY() + 1);
ySpeed = 0;
}
Enemy g = (Enemy) getOneIntersectingObject(Enemy.class);
// Actor ghost = getOneObjectAtOffset (0, getImage().getHeight()/2, Ghost.class);
Actor evilminion = getOneObjectAtOffset(0, getImage().getHeight() / 2, EvilMinion.class);
Actor Scarlet = getOneObjectAtOffset(0, getImage().getHeight() / 2, Scarlet.class);
// if(ghost != null)
// {
// ySpeed = -20;
// squish.play();
// getWorld().removeObject(ghost);
// }
// if(evilminion != null)
// {
// ySpeed = -20;
// //squish.play();
// getWorld().removeObject(evilminion);
// }
if (g != null) {
ySpeed = -20;
// squish.play();
g.hit(1);
}
}
public void scrollEnemies() {
for (Enemy i : enemyList) {
i.setY(i.getY() + (int) (player1.getVelocity() * 0.3));
i.setYPos(i.getYPos() + (int) (player1.getVelocity() * 0.3));
i.setYMax(i.getYMax() + (int) (player1.getVelocity() * 0.3));
}
}
public void paint(Graphics g) {
// update drawing
for (int i = 0; i < 14; i++)
for (int j = 0; j < 10; j++) g.drawImage(backgroundImage, 60 * i, 60 * j, this);
g.drawImage(
playerImage,
player.getCenterX(),
player.getCenterY(),
player.getCenterX() + 60,
player.getCenterY() + 60,
player.getRotation() * 60,
0,
player.getRotation() * 60 + 60,
60,
this);
for (Enemy e : enemies) {
g.drawImage(
enemyImage,
e.getCenterX(),
e.getCenterY(),
e.getCenterX() + 60,
e.getCenterY() + 60,
e.getRotation() * 60,
0,
e.getRotation() * 60 + 60,
60,
this);
}
for (Wall w : walls) {
g.drawImage(wallImage, w.getCenterX(), w.getCenterY(), this);
}
}
/**
* Paints all the components on the game map. Towers are painted first, then the path, then all
* the enemies.
*
* @return none.
*/
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
// Draws all the towers
for (Tower tower : towers) {
tower.draw(g);
}
// Draws the path
for (PathFragment fragment : paths) {
fragment.draw(g);
}
// Draws all the enemies
for (Enemy enermy : enemies) {
enermy.draw(g);
}
}
@Override
public void update(int elapsedTime) {
super.update(elapsedTime);
if (stunned <= 0.0) {
// TODO: Different logic
facePlayer();
approachPlayer();
}
}
private void doShooting() {
PositionFinder p = new PositionFinder(enemies, this);
en = p.findNearest();
if (en == null) return;
Point2D myPos = new Point2D.Double(getX(), getY());
if (HoT) {
/* Perform head on target for gun movement */
aimingPoint = new Point2D.Double(en.getX(), en.getY());
double turnGunAmt = (getHeadingRadians() + en.getBearingRadians() - getGunHeadingRadians());
turnGunAmt = Utils.normalRelativeAngle(turnGunAmt);
setTurnGunRightRadians(turnGunAmt);
} else {
/* Perform circular targeting */
Rectangle2D battlefield =
new Rectangle2D.Double(0, 0, getBattleFieldWidth(), getBattleFieldHeight());
long when = calcTimeToReachEnemy();
aimingPoint = org.pattern.utils.Utils.getFuturePoint(en, when);
if (!battlefield.contains(aimingPoint)) {
HoT = true;
return;
}
double theta =
Utils.normalAbsoluteAngle(
Math.atan2(aimingPoint.getX() - getX(), aimingPoint.getY() - getY()));
setTurnGunRightRadians(Utils.normalRelativeAngle(theta - getGunHeadingRadians()));
}
if (getGunHeat() == 0) {
double firePower = 3.0;
fire(firePower);
}
}
