Java，Slick，一个不应该移动的对象正在移动？

在我制作的游戏中，我需要NPC/MOB。 我上了一个名为“农民”（我的第一个暴徒）的班。 在运行游戏的主类中，我拥有所有信息，并且从Farmer调用了一个名为mob1的对象 我需要这样做，如果玩家在300像素范围内的暴徒，它开始向它移动。我试过这么做，但到目前为止，即使播放器距离我们2000像素，暴徒也会开始移动

这是我的农民班

package Entitys.NPCs;


public class Peasant {

    public Peasant(float InitX, float InitY, int MobID){
        MobX = InitX;
        MobY = InitY;
    }
    //This class shall be used as an object creator. This will randomly move a graphic around, near to a player
    private float MobX;
    private float MobY;
    private int AmountMoved = 0;
    private boolean MoveRight = true;
    private boolean MoveLeft;
    public boolean PlayerDetected = false;
    long timer;
    //Used to find the mobs X
    public float getX(){
        return MobX;
    }

    //Used to find the mobs Y
    public float getY(){
        return MobY;
    }

    //Used to set the mobs X
    public void setX(float X){
        MobX = X;
    }   

    //Used to set the mobs Y
    public void setY(float Y){
        MobY = Y;
    }

    //Used to simply move the mob on its X co-ords
    public void moveX(int delta){
        MobX += delta*0.1f;
    }

    //Used to simply move the mob on its Y co-ords
    public void moveY(int delta){
        MobY += delta*0.1f;
    }

    public void autoEveryThing(int delta, float playerX, float playerY) {
        // If the player has not been spotted the NPC/Mob will move left and
        // right by 100 Pixels.
        if(MobX-300<playerX){
            PlayerDetected=true;
        }

        if(PlayerDetected=true){
            if(MobX>playerX){
                MobX-=delta*0.12;
            }
        }

    }

}

package Entitys.NPCs；
公营农民{
公共地址（float InitX、float InitY、int MobID）{
MobX=InitX；
MobY=NITY；
}
//这个类将被用作对象创建者。这将随机移动一个图形，靠近一个玩家
私有浮动MobX；
私人浮动摩比；
私有int AmountMoved=0；
私有布尔MoveRight=true；
私有布尔左移；
公共布尔值playerDetect=false；
长定时器；
//用于查找暴徒X
公共浮点getX（）{
返回MobX；
}
//过去常常发现暴徒们很疯狂
公共浮球{
返回莫比；
}
//用于设置怪物X
公共无效集合X（浮动X）{
MobX=X；
}   
//用来让暴徒们疯狂
公共无效setY（浮动Y）{
MobY=Y；
}
//用来简单地移动X坐标上的怪物
公共void moveX（内部增量）{
MobX+=delta*0.1f；
}
//用于简单地移动Y坐标上的暴徒
公共无效移动（内部增量）{
MobY+=delta*0.1f；
}
public void autoearthing（整数增量、浮点playerX、浮点playerY）{
//如果玩家未被发现，NPC/暴徒将向左移动并移动
//右减100像素。
if（MobX-300playerX）{
MobX-=delta*0.12；
}
}
}
}

这是主要课程：

    package Worlds.World1;

import org.lwjgl.input.Mouse;
import org.newdawn.slick.Animation;
import org.newdawn.slick.Color;
import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Graphics;
import org.newdawn.slick.Image;
import org.newdawn.slick.Input;
import org.newdawn.slick.SlickException;
import org.newdawn.slick.state.BasicGameState;
import org.newdawn.slick.state.StateBasedGame;

import Entitys.NPCs.*;

import Main.SimpleMob;

public class World1A extends BasicGameState{
    String mousePosition;
    Image world;
    Animation player, playerLeft, playerRight;
    int[] duration = {200,200};
    float playerX;
    float playerY;
    float WorldX;
    float WorldY;
    float PlayerVisibleScreenX;
    float PlayerVisibleScreenY;
    String MovementDirection;
    Peasant mob1;
    public World1A(int state){
    }

    public void init(GameContainer gc, StateBasedGame sbg) throws SlickException{
        Image [] WalkingLeft = {new Image("res/Sprites/buckysLeft.png"),new Image("res/Sprites/buckysLeft.png")};
        Image [] WalkingRight = {new Image("res/Sprites/buckysRight.png"),new Image("res/Sprites/buckysRight.png")};

        playerLeft = new Animation(WalkingLeft, duration, false);
        playerRight = new Animation(WalkingRight, duration, false);
        player = playerRight;
        WorldX = 0;
        WorldY = 0;
        world= new Image("res/WorldImages/WorldBackGround.png");
        mousePosition="null";
        MovementDirection = "Not Moved Yet";
        mob1= new Peasant(2000, 200, 1);
        if(WorldX<=0){
            playerX = Math.abs(WorldX);
        }else{
            playerX=0-WorldX;
        }
    }

    public void render(GameContainer gc, StateBasedGame sbg, Graphics g) throws SlickException{
        player.draw(450, 300);
        if(WorldX>0){
            world.draw(0, 0);
            g.fillOval(0+mob1.getX(), 0+mob1.getY(), 50, 50);
            g.fillRect(0, 0+340, 500, 10);
            player.draw(-WorldX + 450, 300);
        }else{
            world.draw(WorldX, WorldY);
            g.fillOval(WorldX+mob1.getX(), WorldY+mob1.getY(), 50, 50);
            g.fillRect(WorldX, WorldY+340, 500, 10);
            g.fillOval(WorldX+mob1.getX(), WorldY+mob1.getY(), 50, 50);
            player.draw(450, 300);
        }
        g.setColor(Color.white);

        //All this is co-ords ect, it is for developement help
        g.drawString(String.valueOf(mob1.getX()), 50, 200);
        g.drawString("World X: "+ String.valueOf(WorldX), 50, 225);
        g.drawString("Player X: "+ String.valueOf(playerX), 50, 250);
        g.drawString("Player Detetcted?: "+ String.valueOf(mob1.PlayerDetected), 50, 265);
    }

    public void update(GameContainer gc, StateBasedGame sbg, int delta) throws SlickException{
        if(WorldX<=0){
            playerX = Math.abs(WorldX);
        }else{
            playerX=0-WorldX;
        }
        mob1.autoEveryThing(delta, playerX, playerY);
        int posX = Mouse.getX();
        int posY = Mouse.getY();
        mousePosition = "X: " + posX + "\nY: " + posY;

        Input input = gc.getInput();
        if(input.isKeyDown(Input.KEY_LEFT)){
            WorldX += delta * 0.1f;
            MovementDirection = "Left";
            player = playerLeft;
        }else if(input.isKeyDown(Input.KEY_RIGHT)){
            WorldX -= delta * 0.1f;
            MovementDirection = "Right";
            player = playerRight;
        }else{
            MovementDirection = "Not Moving";
        }
    }


    //DO NOT CHANGE
    public int getID(){
        return 2;
    }

}

package Worlds.World1；
导入org.lwjgl.input.Mouse；
导入org.newdawn.slick.Animation；
导入org.newdawn.slick.Color；
导入org.newdawn.slick.GameContainer；
导入org.newdawn.slick.Graphics；
导入org.newdawn.slick.Image；
导入org.newdawn.slick.Input；
导入org.newdawn.slick.SlickException；
导入org.newdawn.slick.state.BasicGameState；
导入org.newdawn.slick.state.StateBasedGame；
进口实体。NPC。*；
导入Main.SimpleMob；
公共类World1A扩展了BasicGameState{
串鼠标定位；
形象世界；
动画播放器、播放器左侧、播放器右侧；
int[]持续时间={200200}；
浮动playerX；
浮子游戏；
浮动WorldX；
浮世；
浮动PlayerScreenX；
飘浮的画面；
字符串移动方向；
农民暴动1；
公共世界1A（国际州）{
}
public void init（GameContainer gc，StateBasedGame sbg）引发异常{
Image[]WalkingLeft={新图像（“res/Sprites/buckysLeft.png”）、新图像（“res/Sprites/buckysLeft.png”）；
Image[]WalkingRight={新图像（“res/Sprites/buckysRight.png”）、新图像（“res/Sprites/buckysRight.png”）；
playerLeft=新动画（向左行走、持续时间、假）；
playerRight=新动画（WalkingRight、duration、false）；
player=playerRight；
WorldX=0；
世俗=0；
world=新图像（“res/WorldImages/WorldBackGround.png”）；
mousePosition=“null”；
MovementDirection=“尚未移动”；
mob1=新农民（2000、200、1）；
if（WorldX0）{
世界画（0,0）；
g、 fillOval（0+mob1.getX（），0+mob1.getY（），50,50）；
g、 fillRect（0,0+340500,10）；
玩家平局（-WorldX+450300）；
}否则{
world.draw（WorldX，WorldY）；
g、 fillOval（WorldX+mob1.getX（），WorldY+mob1.getY（），50,50）；
g、 fillRect（WorldX，WorldY+340500,10）；
g、 fillOval（WorldX+mob1.getX（），WorldY+mob1.getY（），50,50）；
球员平局（450300）；
}
g、 setColor（Color.white）；
//所有这些都是为了帮助开发
g、 抽绳（String.valueOf（mob1.getX（）），50200）；
g、 抽绳（“世界X:+String.valueOf（世界X），50225）；
g、 抽绳（“玩家X:+String.valueOf（玩家X），50250）；
g、 抽绳（“玩家检测：”+String.valueOf（mob1.PlayerDetected），50265）；
}
公共无效更新（GameContainer gc、StateBasedGame sbg、int delta）引发异常{
如果（WorldX
你应该使用的是错误的吗==

   if(PlayerDetected==true){

甚至更好

boolean isPlayerDetected;

if (isPlayerDetected) 

进一步考虑

 double dx = mobX - playerX;
 double dy = mobY - playerY;
 double distance = Math.sqrt(dx*dx + dy*dy);
 if (distance < 300) {
     // is within distacne threshold
 }

double dx=mobX-playerX；
双dy=莫比-游戏；
双距离=数学sqrt（dx*dx+dy*dy）；
如果（距离<300）{
//在临界值内
}
你不应该使用距离公式，而不是MobX-300吗？我的意思是作为一个一般的设计问题；MobX-300只检测玩家是否在怪物的左边，更不用说它只考虑x值。y可能是0到1000，怪物仍然会检测玩家。哦，我的上帝……我真是个白痴！！！！谢谢你！不过有一个问题，诺玛lly如果我犯了这个错误，我会得到一个错误，但这次不是吗？我也犯了，当我开始C时。请证明并接受，如果有帮助；-）
 double dx = mobX - playerX;
 double dy = mobY - playerY;
 double distance = Math.sqrt(dx*dx + dy*dy);
 if (distance < 300) {
     // is within distacne threshold
 }