Java 敌人的毁灭

我目前正在使用Slick2D在java中开发一种platformer，按照我目前的设置方式，敌人是ArrayList中的敌人对象。玩家可以向他们发射小圆圈（也在阵列列表中），如果他们连接起来，将会发生敌人“死亡”的情况。这就是我遇到麻烦的地方。我怎样才能摆脱那样的东西？我曾尝试在for-each循环中将它们从数组中删除，但这会引发异常，因为它仍在搜索所述数组（我认为）

这不起作用，所以现在我尝试创建一个子弹和敌人交互的索引数组，然后在循环后删除它们，如中所示：

for (int i = 0; i < bullets.size(); i++) {
  for (int z = 0; z < enemies.size(); z++) {
    if (bullets.get(i).intersects(enemies.get(z).getPoly())) {
      bRemove.add(i);
      eRemove.add(z);
    }
  }
}

for (Integer i : bRemove) {
  bullets.remove(i);
}

for (Integer i : eRemove) {
  enemies.remove(i);
}

for（int i=0；i

现在似乎什么都没有发生。有人知道我该怎么做吗？这是主要课程的全部内容：

package ca.wmc.BasicPlatform;

import java.lang.Math;
import java.util.ArrayList;

import org.newdawn.slick.Animation;
import org.newdawn.slick.AppGameContainer;
import org.newdawn.slick.BasicGame;
import org.newdawn.slick.geom.Circle;
import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Graphics;
import org.newdawn.slick.Input;
import org.newdawn.slick.Image;
import org.newdawn.slick.SlickException;
import org.newdawn.slick.SpriteSheet;
import org.newdawn.slick.geom.Polygon;

public class Game extends BasicGame  {

Player quote;
public BlockMap map;
private boolean start;
private int startCount;
private boolean lost;
private int lostCount;
private int hpTime = 0;
private ArrayList<Enemy> enemies;
private ArrayList<Bullet> bullets;
private int reload = 0;
private final double a = 2;
private int t = 0;

public Game() {
    super("Super Simple Platform");
}

public void init(GameContainer container) throws SlickException {
    container.setVSync(true);
    container.setTargetFrameRate(60);
    map = new BlockMap("tiled/newmap.tmx");
    quote = new Player("tiled/Quote.gif", 320, 320, 3, -8);
    enemies = new ArrayList<Enemy>();
    enemies.add(new Enemy("tiled/King.gif", 50, 0, -8, 26, 32));
    enemies.add(new Enemy("tiled/Quote.gif", 200, 150, -8, 28, 32));
    start = false;
    lost = false;
    bullets = new ArrayList<Bullet>();
}

public void update(GameContainer container, int delta) throws SlickException {
    if (!start) {
        if (container.getInput().isKeyDown(Input.KEY_Z)) {
            start = true;
        }
    } else {
        if (!lost) {

            ArrayList<Integer> eRemove = new ArrayList<Integer>();
            ArrayList<Integer> bRemove = new ArrayList<Integer>();

            quote.update(container, a, t, delta);
            for (Enemy enemy : enemies) {
                enemy.update(quote, a, t);
            }

            if (t == 5) {
                t = 0;
            } else {
                t++;
            }

            if (container.getInput().isKeyDown(Input.KEY_X) && reload == 0) {
                if (quote.getCurAnimation() == quote.right()) {
                    bullets.add(new Bullet(quote.getXPos() + 28, quote.getYPos() + (int)(20 * Math.random() - 22) + 25, "r"));
                } else {
                    bullets.add(new Bullet(quote.getXPos() + 28, quote.getYPos() + (int)(20 * Math.random() - 22) + 25, "l"));
                }
                reload = 10;
            }

            if (reload > 0) {
                reload--;
            }

            for (Bullet bullet : bullets) {
                if (bullet.getDirection()) {
                    bullet.setCenterX(bullet.getCenterX() + 10);
                } else { 
                    bullet.setCenterX(bullet.getCenterX() - 10);
                }
            }

            for (Enemy enemy : enemies) {
                if (quote.getPoly().intersects(enemy.getPoly()) && hpTime > 50 && quote.getHP() != 0) {
                    quote.setHP(quote.getHP() - 1);
                    hpTime = 0;
                    if (quote.getHP() <= 0) {
                        lost = true;
                    }
                }
            }

            hpTime++;

            if (startCount <= 100) {
                startCount++;
            }

            for (int i = 0; i < bullets.size(); i++) {
                for (int z = 0; z < enemies.size(); z++) {
                    if (bullets.get(i).intersects(enemies.get(z).getPoly())) {
                        bRemove.add(i);
                        eRemove.add(z);
                    }
                }
            }

            for (Integer i : bRemove) {
                bullets.remove(i);
            }

            for (Integer i : eRemove) {
                enemies.remove(i);
            }
        }

        if (quote.getYPos() > 640) {
            lost = true;
        }

    }
}

public void render(GameContainer container, Graphics g) throws SlickException{
    g.drawImage(new Image("apsci.jpg"), 0, 0);
    BlockMap.tmap.render(0, 0);
    g.drawAnimation(quote.getCurAnimation(), quote.getXPos(), quote.getYPos());
    for (Enemy enemy : enemies) {
        g.drawAnimation(enemy.getCurAnimation(), enemy.getXPos(), enemy.getYPos());
    }

    for (Circle bullet : bullets) {
        g.draw(bullet);
    }

    g.drawString("HP: " + quote.getHP(), 10, 450);

    if (!start) {
        g.drawString(getTitle(), 150, 0);
        g.drawString("Controls: arrow keys to move, Z to jump, X to fire.", 150, 50);
        g.drawString("Defeat the evil.          Press Z to start.", 150, 100);
    }

    if (startCount < 100) {
        for (Enemy enemy : enemies) {
            g.drawString("The Evil -->", enemy.getXPos() - 125, enemy.getYPos() + 10 + (int)(2 * Math.random()));
        }
        g.drawString("<-- You", quote.getXPos() + 50, quote.getYPos() + 10 + (int)(2 * Math.random()));
    }

    if (lost) {
        g.drawString("You have lost.", 200, 210);
    }
    if (lostCount > 150) {
        g.drawString("Game over.", 200, 260);
    }
    if (lostCount > 200) {
        g.drawString("If that wasn't already obvious.", 200, 310);
    }
}

public static void main(String[] args) throws SlickException{
    // TODO Auto-generated method stub
    try {
        AppGameContainer app = new AppGameContainer(new Game(), 640, 480, false);
        app.start();
    } catch (SlickException e) {
        e.printStackTrace();
    }

}

package ca.wmc.BasicPlatform；
导入java.lang.Math；
导入java.util.ArrayList；
导入org.newdawn.slick.Animation；
导入org.newdawn.slick.AppGameContainer；
导入org.newdawn.slick.BasicGame；
导入org.newdawn.slick.geom.Circle；
导入org.newdawn.slick.GameContainer；
导入org.newdawn.slick.Graphics；
导入org.newdawn.slick.Input；
导入org.newdawn.slick.Image；
导入org.newdawn.slick.SlickException；
导入org.newdawn.slick.SpriteSheet；
导入org.newdawn.slick.geom.Polygon；
公共类游戏扩展BasicGame{
球员报价；
公共区块地图；
私有布尔启动；
私人int startCount；
私有布尔丢失；
私人整数损失账户；
私有int hpTime=0；
私人ArrayList敌人；
私人ArrayList子弹；
私有int重载=0；
私人决赛双a=2；
私有整数t=0；
公共游戏（）{
超级（“超级简单平台”）；
}
公共void init（GameContainer容器）引发异常{
container.setVSync（true）；
容器。setTargetFrameRate（60）；
map=新区块图（“平铺/newmap.tmx”）；
quote=新播放器（“tiled/quote.gif”，320320,3，-8）；
敌人=新的ArrayList（）；
添加（新敌人（“tiled/King.gif”，50,0，-8,26,32））；
添加（新敌人（“tiled/Quote.gif”，200150，-8,28,32））；
开始=错误；
丢失=错误；
项目符号=新的ArrayList（）；
}
公共无效更新（GameContainer，int delta）引发异常{
如果（！开始）{
if（container.getInput（）.isKeyDown（Input.KEY_Z））{
开始=真；
}
}否则{
如果（！丢失）{
ArrayList eRemove=新建ArrayList（）；
ArrayList bRemove=新的ArrayList（）；
报价。更新（集装箱、a、t、三角洲）；
为（敌人：敌人）{
更新（引用，a，t）；
}
如果（t==5）{
t=0；
}否则{
t++；
}
if（container.getInput（）.isKeyDown（Input.KEY_X）&&reload==0）{
if（quote.getCurAnimation（）==quote.right（））{
添加（新的项目符号（quote.getXPos（）+28，quote.getYPos（）+（int）（20*Math.random（）-22）+25，“r”）；
}否则{
添加（新的项目符号（quote.getXPos（）+28，quote.getYPos（）+（int）（20*Math.random（）-22）+25，“l”）；
}
重新加载=10；
}
如果（重新加载>0）{
重新加载--；
}
用于（项目符号：项目符号）{
if（bullet.getDirection（））{
bullet.setCenterX（bullet.getCenterX（）+10）；
}否则{
bullet.setCenterX（bullet.getCenterX（）-10）；
}
}
为（敌人：敌人）{
如果（quote.getPoly（）.相交（敌方.getPoly（））&&hpTime>50&"e.getHP（）！=0）{
quote.setHP（quote.getHP（）-1）；
hpTime=0；
if（quote.getHP（）150）{
g、 抽绳（“游戏结束”，200260）；
}
如果（lostCount>200）{
g、 抽绳（“如果这还不明显的话。”，200，310）；
}
}
公共静态void main（字符串[]args）引发异常{
//TODO自动生成的方法存根
试一试{
AppGameContainer app=新建AppGameContainer（新建游戏（），640，480，false）；
app.start（）；
}接住（滑溜）{
e、 printStackTrace（）；
}
}

---

}

是，尝试从当前正在迭代的ArrayList中删除元素肯定会导致问题

---

你确定你的“intersect”代码正常工作吗？快速查看，替换方法就是你所需要的。如果它没有做任何事情，也许它没有在应该的时候找到交集。

是的，尝试从你当前迭代的ArrayList中删除元素肯定会导致问题

---

你确定你的“intersect”代码正在工作吗？快速查看，替换方法就是你所需要的。如果它没有做任何事情，也许它没有在应该的时候找到交点。

正如你所指出的，你不能使用for-each循环修改某些内容并继续迭代。相反，你需要使用for-each循环<代码>迭代器：

由于在

ArrayList

中删除也要求删除对象后的每个对象向左移动一个索引（因此是

O（n）

操作），因此我建议您也可以使用

LinkedList

来代替

关于样式，您还应该始终通过对象的接口引用

集合

对象，而不是它们的实现

ArrayList<Integer> eRemove = new ArrayList<Integer>();

ArrayList eRemove=new ArrayList（）；

应该是

List<Integer> eRemove = new ArrayList<Integer>();

List eRemove=new Arr
List<Integer> eRemove = new ArrayList<Integer>();

List<Integer> eRemove = new LinkedList<Integer();

for (int i = 0; i < bullets.size(); i++) {
        boolean hit = false;
        for (int z = 0; z < enemies.size(); z++) {

            if (bullets.get(i).intersects(enemies.get(z).getPoly())) {
                hit = true;
                enemies.remove(z);
                z--;
            }
        }

        if (hit) {
            bullets.remove(i);
            i--;
        }
}