Sprite / Window Collision

[Dan Moody]

Hello all,

I know I post on here a lot but A: I have so many questions and B: This is best place for me to get help.

I currently have sprites working, I can move them around and stuff but I want to keep the sprite in the window, sort of like a border so the sprite cannot move outside of view.

I have already tried using a method called keepInView() and it basically got the x and y of the player entity and went kinda something like this:

public void keepInView() {
if (x > 800) x = 800;
if (x < 0) x = 0;
if (y > 800) y = 600;
if (y < 0) y = 0; 

But this didnt work....and I've tried playing around in the code and I've had no luck anywhere...

Here's my code for all 3 files so far:


Launcher.java :

// package
package main;

// imports
import javax.swing.JFrame;

// class
public class Launcher extends JFrame
{
	// important things
	Panel panel;
	
	// constructor
	public Launcher()
	{
		super("Sprite Collision");
		panel = new Panel();
		setSize(800,600);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		getContentPane().add(panel);
		setVisible(true);
		setResizable(false);
	}
	
	public void go()
	{
		panel.startGame();
	}
	
	public static void main(String[] args)
	{
		Launcher game = new Launcher();
		game.go();
	}
}

Panel.java

// package
package main;

// imports
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Toolkit;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import javax.swing.JPanel;

// class
public class Panel extends JPanel implements KeyListener
{	
	// smooth graphics kit
	BufferedImage buffer;
	
	// mobs
	Entity player;
	Entity enemy;
	
	// positions
	int xPos, yPos = 100;
	
	// constructor
	public Panel()
	{
		setIgnoreRepaint(true);
		addKeyListener(this);
		setFocusable(true);
	}
	
	public void keyTyped(KeyEvent e)
	{
		
	}
	
	public void keyPressed(KeyEvent e)
	{
		int key = e.getKeyCode();
		if (key == KeyEvent.VK_A) {
			player.left = true;
		}
		
		if (key == KeyEvent.VK_D) {
			player.right = true;
		}
		
		if (key == KeyEvent.VK_W) {
			player.up = true;
		}
		
		if (key == KeyEvent.VK_S) {
			player.down = true;
		}
	}
	
	public void keyReleased(KeyEvent e)
	{
		int key = e.getKeyCode();
		if (key == KeyEvent.VK_A) {
			player.left = false;
		}
		
		if (key == KeyEvent.VK_D) {
			player.right = false;
		}
		
		if (key == KeyEvent.VK_W) {
			player.up = false;
		}
		
		if (key == KeyEvent.VK_S) {
			player.down = false;
		}
	}
	
	// Game Logic Methods
	public void Initialize()
	{
		buffer = new BufferedImage(800,600,BufferedImage.TYPE_INT_RGB);
		player = new Entity(xPos,yPos);
		enemy = new Entity(400,400);
	}
	
	public void update()
	{
		player.move();
	}
	
	public void checkCollisions()
	{
		if (player.getBounds().intersects(enemy.getBounds())) {
			player.collision = true;
		} else {
			player.collision = false;
		}
	}
	
	public void drawBuffer()
	{
		Graphics2D buff2d = buffer.createGraphics();
		buff2d.setColor(Color.black);
		buff2d.fillRect(0,0,800,600);
		if (player.collision == false) {
			buff2d.setColor(Color.red);
			buff2d.fillRect(player.getX(), player.getY(), player.getWidth(), player.getHeight());
			
			buff2d.setColor(Color.blue);
			buff2d.fillRect(enemy.getX(), enemy.getY(), enemy.getWidth(), enemy.getHeight());
			
			buff2d.dispose();
		} else {
			buff2d.setColor(Color.white);
			buff2d.drawString("C O L L I S I O N !", 350, 350);
			buff2d.dispose();
		}
	}
	
	public void drawScreen()
	{
		Graphics2D g2d = (Graphics2D)this.getGraphics();
		g2d.drawImage(buffer,0,0,this);
		Toolkit.getDefaultToolkit().sync();
		g2d.dispose();
	}
	
	public void startGame()
	{
		Initialize();
		while(true)
		{
		    try
		    {
		        update();
		        checkCollisions();
		        drawBuffer();
		        drawScreen();
		        Thread.sleep(15);
		    }
		    catch(Exception e)
		    {
		        e.printStackTrace();
		    }	
		}
	}
}

Entity.java

// package
package main;

import java.awt.Rectangle;

public class Entity
{
     int x,y,speed,width,height;
     boolean up, down, left, right,collision;
   
    public Entity(int x, int y)
    {
        this.x = x;
        this.y = y;
        speed = 3;
        width = 100;
        height = 100;
        up = false;
        down = false;
        left = false;
        right = false;
        collision = false;
   }
    
    public int getX()
    {
        return x;
    }
    
    public int getY()
    {
        return y;
    }
    
    public int getWidth()
    {
        return width;
    }
    
    public int getHeight()
    {
        return height;
    }
    
    public Rectangle getBounds()
    {
        return new Rectangle(getX(),getY(),getWidth(),getHeight());
    }

    public void move()
    {
        if (up)
            y -= speed;
        if (down)
            y += speed;
        if (left)
            x -= speed;
        if (right)
            x += speed;
    }
}

Any help is greatly appreciated....

Also, where can I get some really good LWJGL tutorials? I'm going to try that once I have the hang of this

[Stephan van Hulst]

Well, you haven't told us why your first attempt doesn't work. What's wrong with the keepInView() method, besides the fact that the lower border is incorrect?

More importantly though, I want to discourage the way you're drawing to the screen. You should be overriding JPanel's paintComponent() method instead. Take a close look at the following example:

import javax.swing.*;

final class CollisionForm {

  CollisionForm() {
    JFrame frame = new JFrame("Collision Example");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    CollisionPanel panel = new CollisionPanel();
    frame.setContentPane(panel);

    frame.setSize(800, 600);
    frame.setResizable(false);
    frame.setVisible(true);

    panel.start();
  }

  public static void main(String... args) {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        new CollisionForm();
      }
    });
  }
}

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

final class CollisionPanel extends JPanel {

  private final Timer timer;
  private final Entity player, enemy;
  private boolean collision;
  private double collisionTime;

  CollisionPanel() {
    setFocusable(true);
    setOpaque(true);

    player = new Entity();
    enemy = new Entity();
    reset();

    addKeyListener(new KeyAdapter() {
      @Override
      public void keyPressed(KeyEvent e) {
        switch (e.getKeyCode()) {
          case KeyEvent.VK_A: player.moveLeft (true); break;
          case KeyEvent.VK_D: player.moveRight(true); break;
          case KeyEvent.VK_W: player.moveUp   (true); break;
          case KeyEvent.VK_S: player.moveDown (true); break;

          case KeyEvent.VK_ENTER: reset(); break;
        }
      }

      @Override
      public void keyReleased(KeyEvent e) {
        switch (e.getKeyCode()) {
          case KeyEvent.VK_A: player.moveLeft (false); break;
          case KeyEvent.VK_D: player.moveRight(false); break;
          case KeyEvent.VK_W: player.moveUp   (false); break;
          case KeyEvent.VK_S: player.moveDown (false); break;
        }
      }
    });

    timer = new Timer(20, new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        long time = System.currentTimeMillis();

        if (collision) {
          if (time - collisionTime > 1500)
            reset();
        }

        else {
          player.update(time);
          enemy.update(time);
          handleCollisions(time);
        }

        repaint();
      }
    });
  }

  void reset() {
    player.halt();
    player.setPosition(200,250);

    enemy.halt();
    enemy.setPosition(500,250);

    collision = false;
  }

  private void handleCollisions(long time) {
    Rectangle bounds1 = player.getBounds();
    Rectangle bounds2 = enemy.getBounds();
    Rectangle pane    = getBounds();

    int w = pane.width  - bounds1.width;

    if (bounds1.x < 0)
      player.setPosition(0, bounds1.y);
    else if (bounds1.x >= w)
      player.setPosition(w, bounds1.y);

    bounds1 = player.getBounds();
    int h = pane.height - bounds1.height;

    if (bounds1.y < 0)
      player.setPosition(bounds1.x, 0);
    else if (bounds1.y >= h)
      player.setPosition(bounds1.x, h);

    if (bounds1.intersects(bounds2)) {
      collision = true;
      collisionTime = time;
    }
  }

  void start() {
    timer.start();
  }

  void stop() {
    timer.stop();
  }

  @Override
  protected void paintComponent(Graphics g) {
    Rectangle clip = g.getClipBounds();

    g.setColor(Color.BLACK);
    g.fillRect(clip.x, clip.y, clip.width, clip.height);

    if (collision) {
      g.setColor(Color.WHITE);
      g.drawString("C O L L I S I O N !", 350, 350);
    }

    else {
      Rectangle bounds = player.getBounds();
      g.setColor(Color.RED);
      g.fillRect(bounds.x, bounds.y, bounds.width, bounds.height);

      bounds = enemy.getBounds();
      g.setColor(Color.BLUE);
      g.fillRect(bounds.x, bounds.y, bounds.width, bounds.height);
    }
  }
}

import java.awt.*;

final class Entity {

  private double x, y, width, height, speed;
  private boolean moveLeft, moveRight, moveUp, moveDown;
  private long lastUpdate;

  Entity() {
    width = 100;
    height = 100;
    speed = 0.2;
    lastUpdate = System.currentTimeMillis();
  }

  Rectangle getBounds() {
    Rectangle result = new Rectangle();
    result.setRect(x, y, width, height);
    return result;
  }

  void setPosition(int x, int y) {
    this.x = x;
    this.y = y;
  }

  void moveLeft(boolean moving) {
    moveLeft = moving;
  }

  void moveRight(boolean moving) {
    moveRight = moving;
  }

  void moveUp(boolean moving) {
    moveUp = moving;
  }

  void moveDown(boolean moving) {
    moveDown = moving;
  }

  void halt() {
    moveLeft  = false;
    moveRight = false;
    moveUp    = false;
    moveDown  = false;
  }

  void update(long time) {
    long diff = time - lastUpdate;
    lastUpdate = time;

    if (moveLeft)
      x -= diff * speed;

    if (moveRight)
      x += diff * speed;

    if (moveUp)
      y -= diff * speed;

    if (moveDown)
      y += diff * speed;
  }
}

[Jj Hill]

I see no error in the keepInView method. At least not in the logic. Unless you aren't constantly calling keepInView. If you aren't constantly calling in(in the paintComponent() method) then it will stop, and keep on going.