title: What is a simple way to stop a Entity when it collides into another?
body: <p>I have two Entities, a Player and a Block. The player and the block are both squares. I want the player to stop moving when it runs into a block. I have some of the code done but it only work's for horizontal and I was wondering using my existing code if I can add a vertical collision part to it.</p>
  
  <p>I need horizontal and vertical collisions because I need to know which way the player is hitting the block and on what side. This will help me determine if the X or Y velocity should be stopped when it is colliding into the block.</p>
  
  <p>I have already done a lot of research on this topic but nothing really to simple and wasn't explained to well with the Slick2d's Rectangle object. If you have used Slick;s Shape classes you already know that it has a .intersect(Shape s) method. I already use this in my code to see if checking which side it is colliding into and stopping the player is necessary.</p>
  
  <p>Here is the classes I think would be relative to see (If you need another class just ask).</p>
  
  <p>Entity:</p>
  
  <pre><code>import org.newdawn.slick.GameContainer;
  import org.newdawn.slick.Graphics;
  import org.newdawn.slick.SlickException;
  import org.newdawn.slick.geom.Shape;
  import org.newdawn.slick.state.StateBasedGame;
  
  public abstract class Entity {
  
      private Shape shape;
      private float velX = 0f, velY = 0f;
  
      public Entity(Shape shape){
          this.shape = shape;
      }
  
      //Get Methods
      public Shape getShape(){ return shape; }
      public float getVelocityX(){ return velX; }
      public float getVelocityY(){ return velY; }
  
      //Set Methods
      public void setVelocityX(float velX){ this.velX = velX; }
      public void setVelocityY(float velY){ this.velY = velY; }
  
      protected abstract void onUpdate(GameContainer gc, StateBasedGame sbg, int d) throws SlickException;
      protected abstract void onRender(GameContainer gc, StateBasedGame sbg, Graphics g) throws SlickException;
  
      public void update(GameContainer gc, StateBasedGame sbg, int d) throws SlickException {
          //Use velocity to change x and y.
          this.shape.setX(shape.getX() + (velX * (float)d));
          this.shape.setY(shape.getY() + (velY * (float)d));
  
          onUpdate(gc, sbg, d);
      }
  
      public void render(GameContainer gc, StateBasedGame sbg, Graphics g) throws SlickException {
          onRender(gc, sbg, g);
      }
  
  }
  </code></pre>
  
  <p>WorldEntity:</p>
  
  <pre><code>import org.newdawn.slick.geom.Shape;
  
  public abstract class WorldEntity extends Entity{
  
      private World world;
  
      public WorldEntity(World world, Shape shape) {
          super(shape);
          this.world = world;
      }
  
      //Get Methods
      public World getWorld(){ return world; }
  
      public abstract boolean collidedWithEntity(Entity e);
      public abstract void remove();
  
  }
  </code></pre>
  
  <p>Block:</p>
  
  <pre><code>import org.newdawn.slick.Color;
  import org.newdawn.slick.GameContainer;
  import org.newdawn.slick.Graphics;
  import org.newdawn.slick.Image;
  import org.newdawn.slick.SlickException;
  import org.newdawn.slick.geom.Rectangle;
  import org.newdawn.slick.state.StateBasedGame;
  
  public class Block extends WorldEntity{
  
      private BlockType type;
  
      public Block(World world, float x, float y, BlockType type) {
          super(world, new Rectangle(x, y, 48, 48));
          this.type = type;
      }
  
      //Get Methods
      public Color getColor(){ return type.getColor(); }
      public Image getTexture(){ return type.getTexture(); }
      public boolean isSolid(){ return type.isSolid(); }
      public BlockType getType(){ return type; }
  
      @Override
      public boolean collidedWithEntity(Entity e) {
          return false;
      }
  
      @Override
      protected void onUpdate(GameContainer gc, StateBasedGame sbg, int d) throws SlickException {
  
      }
  
      @Override
      protected void onRender(GameContainer gc, StateBasedGame sbg, Graphics g) throws SlickException {
          if(type.getTexture() != null){
              if(type.getColor() != null){
                  g.drawImage(type.getTexture(), getShape().getX(), getShape().getX(), type.getColor());
              }
              else{
                  g.drawImage(type.getTexture(), getShape().getX(), getShape().getX());
              }
          }
          else{
              g.setColor(type.getColor());
              g.fill(getShape());
          }
      }
  
      @Override
      public void remove() {
          getWorld().getBlocks().remove(this);
      }
  
  }
  </code></pre>
  
  <p>Player:</p>
  
  <pre><code>import org.newdawn.slick.Color;
  import org.newdawn.slick.GameContainer;
  import org.newdawn.slick.Graphics;
  import org.newdawn.slick.Input;
  import org.newdawn.slick.SlickException;
  import org.newdawn.slick.geom.Rectangle;
  import org.newdawn.slick.geom.Shape;
  import org.newdawn.slick.state.StateBasedGame;
  
  import us.chrisix.coloroid.world.Block;
  import us.chrisix.coloroid.world.Entity;
  import us.chrisix.coloroid.world.World;
  import us.chrisix.coloroid.world.WorldEntity;
  
  public class Player extends WorldEntity{
  
      private Color c;
      private float speed = 0.3f;
  
      public Player(World world, float x, float y, Color c) {
          super(world, new Rectangle(x, y, 48, 48));
          this.c = c;
      }
  
      public Color getColor(){ return c; }
  
      @Override
      public boolean collidedWithEntity(Entity e) {
          if(e instanceof Block &amp;&amp; e.getShape().intersects(getShape()) &amp;&amp; ((Block) e).isSolid()){
              Shape b = e.getShape();
              Shape p = getShape();
              if(b.getX() &gt; p.getX()){
                  p.setX(b.getX() - 48.1f);
                  setVelocityX(0);
              }
              else if(b.getX() &lt; p.getX()){
                  p.setX(b.getX() + 48.1f);
                  setVelocityX(0);
              }
              return true;
          }
          return false;
      }
  
      @Override
      public void remove() {
  
      }
  
      @Override
      protected void onUpdate(GameContainer gc, StateBasedGame sbg, int d) throws SlickException {
          Input in = gc.getInput();
          if(in.isKeyDown(Input.KEY_D)){
              this.setVelocityX(speed);
          }
          else if(in.isKeyDown(Input.KEY_A)){
                  this.setVelocityX(-speed);
          }
          else{
              this.setVelocityX(0);
          }
  
          if(in.isKeyDown(Input.KEY_W)){
              this.setVelocityY(-speed);
          }
          else if(in.isKeyDown(Input.KEY_S)){
              this.setVelocityY(speed);
          }
          else{
              this.setVelocityY(0);
          }
      }
  
      @Override
      protected void onRender(GameContainer gc, StateBasedGame sbg, Graphics g) throws SlickException {
          g.setColor(c);
          g.fill(getShape());
          g.setColor(Color.black);
          g.draw(getShape());
          g.draw(new Rectangle(getShape().getX() + 1, getShape().getY() + 1, 46, 46));
      }
  
  }
  </code></pre>
  
  <p>The part of code I hoping to just be imporved is the Player.collidedWithEntity(Entity e).</p>
  
  <p>If you have any questions on how I worded things or on my code, I encourage you to ask for clarification. Thank you for taking the time to read this.</p>