Java/LWJGL：代码无理由执行两次

我正在用LWJGL开发一个游戏。我有一个物品拾取代码，可以将物品添加到玩家的库存中，但每当我调用它时，它都会将物品添加到插槽（

x

）和插槽后的插槽（

x

）。（

x

表示任意随机数）我希望能有人帮我调试它

正在中调用类add方法：

package geniushour.gameobject.entity;

import static org.lwjgl.input.Keyboard.KEY_A;
import static org.lwjgl.input.Keyboard.KEY_D;
import static org.lwjgl.input.Keyboard.KEY_P;
import static org.lwjgl.input.Keyboard.KEY_SPACE;
import static org.lwjgl.input.Keyboard.isKeyDown;

import java.util.ArrayList;
import java.util.Random;

import geniushour.engine.Physics;
import geniushour.engine.time.Delay;
import geniushour.engine.time.Time;
import geniushour.game.Game;
import geniushour.game.Util;
import geniushour.game.type.ArmorType;
import geniushour.game.type.ClawType;
import geniushour.game.type.EntityType;
import geniushour.gameobject.GameObject;
import geniushour.gameobject.StatObject;
import geniushour.gameobject.item.Backpack;
import geniushour.gameobject.item.Item;

public class Player extends StatObject {

private Delay delay;
private boolean collide = false;
private int facingDirection = 0;
private int firstFree = 0;

private Random damageRandom;

private final int NORTH = 0;
private final int EAST = 1;
private final int SOUTH = 2;
private final int WEST = 3;

public Player(float x, float y){
    super(true,0,6);
    init(x,y,ENTITY_SIZE,ENTITY_SIZE,0.25f,1f,.25f,EntityType.PLAYER_ID.getID());
    deleteBackpack();
    setClaw(ClawType.BASIC);
    setArmorType(ArmorType.SKIN);
    setStrength(1, claw);
    delay = new Delay(500);     delay.terminate();
}
public void update(){
    ArrayList<GameObject> items = Game.rectCollide(x, y, x+ENTITY_SIZE, y+ENTITY_SIZE);
    for(GameObject go : items){
        if(go.getType() == EntityType.ITEM_ID.getID()){
            go.remove();
            inv.add ((Item)go);
        }
    }
    ArrayList<GameObject> wall = Game.rectCollide(x, y, x+ENTITY_SIZE, y+ENTITY_SIZE);
    for(GameObject go : wall){
        if(go.getType() == EntityType.BLOCK_ID.getID()){
            if(Physics.checkCollision(this, go) != null){
                collide = true;
            }
            else if(Physics.checkCollision(this, go) == null){
                collide = false;
            }
        }
        if(collide){
            if(this.facingDirection == WEST){
                move(1,0);
                collide = false;
            }
            else if(this.facingDirection == EAST){
                move(-1,0);
                collide = false;
            }
        }
    }

    if(getCurrentHealth() <= 0){
        addHP(-getCurrentHealth());
        deleteBackpack(); //TODO: Backpack temp or not?
    }

    for(int i = 0; i < inv.getLength(); i++){
        if(inv.get( i ) instanceof Backpack){
            ownBackpack();
            inv.remove(i);
            inv.setSlots(27);
        }
    }
}

    outputData(true);
}
public void getInput(){
    if(!collide){
        if(isKeyDown(KEY_A)){
            move(-1,0);
        }
        if(isKeyDown(KEY_D)){
            move(1,0);
        }
        if(isKeyDown(KEY_SPACE) && delay.over()){
            attack();
        }
        if(isKeyDown(KEY_P)){
        }
    }
}
private void move(int magX, int magY){
    if(magX == 1){
        facingDirection = EAST;
    }
    if(magX == -1){
        facingDirection = WEST;
    }

    x += getSpeed(armor) * magX * Time.getDelta();
    y += getSpeed(armor) * magY * Time.getDelta();
}
private void attack(){
    //Find GameObjects in Attack Range
    ArrayList<GameObject> obj = new ArrayList<GameObject>();

    switch(facingDirection){
        case NORTH: obj = Game.rectCollide(x, y, x + ENTITY_SIZE, y + getCloseAttackRange());
            break;
        case EAST: obj = Game.rectCollide(x, y, x + getCloseAttackRange(), y + ENTITY_SIZE);
            break;
        case SOUTH: obj = Game.rectCollide(x, y - getCloseAttackRange() + ENTITY_SIZE, x + ENTITY_SIZE, y);
            break;
        case WEST: obj = Game.rectCollide(x - getCloseAttackRange() + ENTITY_SIZE, y, x, y + ENTITY_SIZE);
            break;
    }

    //Find which GOs are Enemy Type
    ArrayList<Enemy> enemies = new ArrayList<Enemy>();
    for(GameObject go : obj){
        if(go.getType() == EntityType.ENEMY_ID.getID()){
            enemies.add((Enemy)go);
        }
    }

    //Find closest existing enemy
    if(enemies.size() > 0){

        Enemy target = enemies.get(0);
        if(enemies.size() > 1){
            for(Enemy e : enemies){
                if(Util.dist(x, y, e.getX(), e.getY()) < Util.dist(x, y, target.getX(), target.getY())){
                    target = e;
                }
            }
        }
        damageRandom = new Random();
        double e = Math.pow(getStrength(claw), (Math.cbrt(damageRandom.nextInt(15)) + 1)) / (Math.sqrt(getStrength(claw) + 1));
        target.damage((int) Math.round(e));
        Util.writeLine(" : " + target.getCurrentHealth() + "/" + target.getMaxHP());
        if(target.getCurrentHealth() <= 0){
            addXP(100);
        }
    }

    delay.start();
}
private void outputData(boolean ask){
    if(ask){
        for(int i = 0; i < inv.getLength(); i++){
            Util.writeLine("Main Inv Slot "+i+": " + inv.get(i));
        }
        Util.writeLine("");
        Util.writeLine("Backpack Owned: " + getBackpack());
        Util.writeLine("");
        Util.writeLine("Inventory Size: " + inv.getLength());
        Util.writeLine("");
        Util.writeLine("Health: "+getCurrentHealth());
        Util.writeLine("");
        Util.writeLine("End of Information Output");
    }
}
}

包geniushour.gameobject.entity；
导入静态org.lwjgl.input.Keyboard.KEY_A；
导入静态org.lwjgl.input.Keyboard.KEY\u D；
导入静态org.lwjgl.input.Keyboard.KEY\P；
导入静态org.lwjgl.input.Keyboard.KEY_空间；
导入静态org.lwjgl.input.Keyboard.isKeyDown；
导入java.util.ArrayList；
导入java.util.Random；
进口geniushour.engine.Physics；
导入geniushour.engine.time.Delay；
导入geniushour.engine.time.time；
进口geniushour.game.game；
导入geniushour.game.Util；
导入geniushour.game.type.ArmorType；
导入geniushour.game.type.ClawType；
导入geniushour.game.type.EntityType；
导入geniushour.gameobject.gameobject；
导入geniushour.gameobject.StatObject；
导入geniushour.gameobject.item.Backpack；
导入geniushour.gameobject.item.item；
公共类播放器扩展了StatObject{
私人延迟；
私有布尔碰撞=false；
专用int-facingDirection=0；
private int firstFree=0；
私有随机损伤随机模型；
私人最终int北=0；
私人最终国际东=1；
南部的私人最终int=2；
私人最终int WEST=3；
公共播放器（浮动x，浮动y）{
超级（真，0,6）；
init（x，y，ENTITY_SIZE，ENTITY_SIZE，0.25f，1f，.25f，EntityType.PLAYER_ID.getID（））；
删除背包（）；
设置爪（爪型。基本型）；
setArmorType（ArmorType.SKIN）；
固定强度（1，爪）；
延迟=新的延迟（500）；delay.terminate（）；
}
公共无效更新（）{
ArrayList items=Game.rectclide（x，y，x+实体大小，y+实体大小）；
用于（游戏对象转到：项目）{
if（go.getType（）==EntityType.ITEM\u ID.getID（））{
go.remove（）；
存货添加（（项目）go）；
}
}
ArrayList wall=Game.rectclide（x，y，x+实体大小，y+实体大小）；
用于（游戏对象转到：墙）{
if（go.getType（）==EntityType.BLOCK\u ID.getID（））{
if（Physics.checkCollision（this，go）！=null）{
碰撞=真；
}
else if（Physics.checkCollision（this，go）==null）{
碰撞=错误；
}
}
如果（碰撞）{
如果（this.facingDirection==向西）{
move（1,0）；
碰撞=错误；
}
else if（this.facingDirection==东）{
移动（-1,0）；
碰撞=错误；
}
}
}
如果（getCurrentHealth（）0）{
敌人目标=敌人。获取（0）；
如果（0.size（）>1）{
对于（敌人e：敌人）{
if（Util.dist（x，y，e.getX（），e.getY（））如果（items[index]==null&&index两次猜测，因为我不知道是什么调用update（）：1）按住键两次会使您拾取两次。2）该项不会在下一次拾取时被删除。拾取项没有按键。update（简而言之）在
public static void main（字符串args[]）中调用
即使在执行项目添加代码之前，项目也会从地面上移除。
package geniushour.game.inventory;

import geniushour.game.Util;
import geniushour.gameobject.item.Item;

public class Inventory {

private Item[] items;
private int firstFree;

public Inventory(int size){
    items = new Item[size];
    firstFree = 0;
}
public boolean add(Item item){
    for(int i = 0; i < items.length; i++){
        if(get(i) == null){
            firstFree = i;
            break;
        }
    }
    Util.writeLine(firstFree);
    if(add(item, firstFree)){
        firstFree++;
        if(firstFree > items.length){
            firstFree = items.length;
        }
        return true;
    }
    return false;
}
public boolean add(Item item, int index){
    if(items[index] == null && index <= items.length){ // != or == ?
        items[index] = item;
        return true;
    }
    else{
        return false;
    }
}
public Item get(int index){
    return items[index];
}
public void remove(int index){
    items[index] = null;
    if(index < firstFree){
        firstFree = index;
    }
    if(firstFree < 0){
        firstFree = 0;
    }
}
public void remove(Item item){
    for(int i = 0; i < items.length; i++){
        if(items[i] == item){
            remove(i);
            return;
        }
    }
}
public Item[] getItemList(){
    return items;
}
public int getLength(){
    return items.length;
}
public void setSlots(int amt){
    Item[] temp = new Item[items.length];
    for(int i = 0; i < items.length; i++){
        temp[i] = items[i];
    }
    items = new Item[amt];
    for(int i = 0; i < temp.length; i++){
        items[i] = temp[i];
    }
    temp = new Item[items.length];
}


}