Java Game Dev: Sprawdzanie, czy gracz jest pomiędzy dwoma y coordami

Question

Tworzę grę z Slick2D. Gdy gracz znajdzie się pod oknem z wrogiem, może strzelać, a punkty zostaną dodane. Każdego mechanika wykonuje się oprócz strzelającego. Oto mój "plan", jak to będzie działać.

Gdy gracz znajdzie się poniżej okna (które program podnosi za pomocą współrzędnej y) i pożarów, punkty zostaną dodane do licznika.

W jaki sposób mogę przekonać program, że gracz rzeczywiście znajduje się poniżej okna?

Dzięki, a oto mój kod PlayState.

import org.newdawn.slick.GameContainer; 
import org.newdawn.slick.Graphics; 
import org.newdawn.slick.Input; 
import org.newdawn.slick.state.BasicGameState; 
import org.newdawn.slick.SlickException; 
import org.newdawn.slick.state.StateBasedGame; 
import org.newdawn.slick.Image; 
import org.newdawn.slick.state.transition.FadeInTransition; 
import org.newdawn.slick.state.transition.FadeOutTransition; 
import java.util.Random; 
import java.util.TimerTask; 
import java.util.Timer; 

public class PlayState extends BasicGameState{ 

int stateID = -1; 

int w = SwegBoi.WIDTH; 
int h = SwegBoi.HEIGHT; 
static int enemylocation; 
float s = SwegBoi.SCALE; 
Image playbackground; 
Image swegboiplayer; 
Image quit; 
Image enemy1; 
Image enemy2; 
float playery; 
int score = 0; 

final static Random ran = new Random(); 
static Timer tm = new Timer(); 
static long startTime = System.currentTimeMillis(); 

public static void main(String args){ 

} 


public PlayState(int stateID){ 
    this.stateID = stateID; 
} 

@Override 
public void init(GameContainer gc, StateBasedGame sbg) 
     throws SlickException { 
    swegboiplayer = new Image("resources/swegboibackgun.png"); 
    playbackground = new Image("resources/playstatebackground.png"); 
    quit = new Image("resources/mainmenuquit.png"); 
    enemy1 = new Image("resources/enemy1.png"); 
    enemy2 = new Image("resources/enemy1.png"); 

    tm.schedule(new TimerTask() { 

     @Override 
     public void run() { 
      enemylocation = ran.nextInt(4) + 1; 
     } 
    }, 1, 2000); 


} 




@Override 
public void render(GameContainer gc, StateBasedGame sbg, Graphics g) 
     throws SlickException { 
    playbackground.setFilter(Image.FILTER_NEAREST); 
    playbackground.draw(0, 0, s*10); 
    quit.draw((w-175*s),5 *s,s/2); 

    if(enemylocation==1){ 
     enemy1.setFilter(Image.FILTER_NEAREST); 
     enemy1.draw(200,170,s*10); 
    } 
    if(enemylocation==2){ 
     enemy1.setFilter(Image.FILTER_NEAREST); 
     enemy1.draw(200,360,s*10); 
    } 
    if(enemylocation==3){ 
     enemy1.setFilter(Image.FILTER_NEAREST); 
     enemy1.draw(950,170,s*10); 
    } 
    if(enemylocation==4){ 
     enemy1.setFilter(Image.FILTER_NEAREST); 
     enemy1.draw(950,360,s*10); 
    } 

    swegboiplayer.setFilter(Image.FILTER_NEAREST); 
    swegboiplayer.draw((w*s)/2-(playery*s), 450*s, s*5); 

    g.drawString("Alpha V0.1",6,6); 
} 



@Override 
public void update(GameContainer gc, StateBasedGame sbg, int delta) 
     throws SlickException { 
    Input input = gc.getInput(); 
    if(input.isKeyDown(Input.KEY_LEFT)){playery += 17;} 
    if(input.isKeyDown(Input.KEY_RIGHT)){playery -= 17;} 
    int mouseX = input.getMouseX(); 
    int mouseY = input.getMouseY(); 

    if(mouseHover(mouseX,mouseY,(w-175*s),5*s,quit.getHeight()/2,quit.getWidth()) == true){ 
     if(input.isMousePressed(0)){ 
      sbg.enterState(SwegBoi.MAINMENUSTATE,new FadeOutTransition(), new FadeInTransition()); 
     } 
     quit = new Image("resources/mainmenuquithover.png"); 
    }else{ 
     quit = new Image("resources/mainmenuquit.png"); 

    }} 



@Override 
public int getID() { 
    return stateID; 
} 


public boolean mouseHover(int mouseX, int mouseY, float x, float y, float height, float width){ 
    if((mouseX >= x && mouseX <= x + width && mouseY >= y && mouseY <= y + height)){ 
     return true; 
    }else{ 
     return false; 
    } 

}}

Answer 1

Coś jak to powinno działać. Za każdym razem, gdy się poruszasz, sprawdź, czy jesteś w zasięgu wrogiej pozycji x i ustal, czy strzelanie powinno być włączone, czy wyłączone. Określ zakres dla każdej pozycji X przeciwników.

private void checkShootStatus() 
    { 
     // Calculate image bounds X Position + width 
     float swegboiplayerEndBound = swegboiplayer.getX() + swegboiplayer.getWidth(); 
     float enemyEndBound = enemy.getX() + enemy.getWidth(); 

     // Check enemy 1 
     if (swegboiplayerEndBound > enemy.getX() && swegboiplayer.getX() < enemyEndBound) 
     { 
     canShoot = true; 
     } 
     else 
     { 
     canShoot = false; 
     } 
    } 

Ponieważ nie można uzyskać x położenia obrazu, należy utworzyć klasy otoki do śledzenia X/Y położenia odtwarzacza i wroga.

public class Player extends Image 
{ 
    private String image; 
    private float x = 0; 
    private float y = 0; 

    public Player(String image) throws SlickException 
    { 
     super(image); 

     this.setImage(image); 
    } 

    public float getY() 
    { 
     return y; 
    } 

    public void setY(float y) 
    { 
     this.y = y; 
    } 

    public String getImage() 
    { 
     return image; 
    } 

    public void setImage(String image) 
    { 
     this.image = image; 
    } 

    public float getX() 
    { 
     return x; 
    } 

    public void setX(float x) 
    { 
     this.x = x; 
    } 
} 

Wróg

public class Enemy extends Image 
{ 
    private String image; 
    private int x; 
    private int y; 

    public Enemy(String image) throws SlickException 
    { 
     super(image); 

     this.setImage(image); 
    } 

    public int getY() 
    { 
     return y; 
    } 

    public void setY(int y) 
    { 
     this.y = y; 
    } 

    public String getImage() 
    { 
     return image; 
    } 

    public void setImage(String image) 
    { 
     this.image = image; 
    } 

    public int getX() 
    { 
     return x; 
    } 

    public void setX(int x) 
    { 
     this.x = x; 
    } 
}