abstractsprite.java

全面运用所学的JAVA理论对所设计的类进一步完善

package tankgame2007;

import java.awt.Graphics;

public abstract class AbstractSprite { //这是Sprite父类
    int X, Y, width, height;
    boolean visible, active;
    int collisionX,collisionY;
    abstract public void paintSprite(Graphics g, int SpiritDirection);
    abstract public void paintSprite(Graphics g);
    abstract public void updateState(int SpiritDirection);

    public int getX(){  //获得精灵X坐标值
        return X;
    }

    public int getY(){ //获得精灵Y坐标值
        return Y;
    }

    public void setLocation(int X, int Y) { //设置精灵X，Y坐标值
        this.X = X;
        this.Y = Y;
    }

    public int getWidth(){ //获得精灵的宽
        return width;
    }

    public int getHeight() { //获得精灵的高
        return height;
    }

    public void setSize(int width, int height) { //设置精灵宽高值
        this.width = width;
        this.height = height;
    }

    public boolean canVisible() { //获得精灵是否可见的属性
        return visible;
    }

    public void setVisible(boolean v) {//设置精灵是否可见
        visible = v;
    }

    public boolean canMove() {//获得精灵是否可移动的属性
        return active;
    }

    public void setMove(boolean m) {//设置精灵是否可移动的属性
        active = m;
    }


    //检测碰撞算法2-------------------------------------------------------------
    public boolean isCollided(AbstractSprite target) {
      boolean collided = false;
      if(this.visible == true && target.visible == true){
        int cX=(this.getX()+this.getWidth()/2)-
               (target.getX()+target.getWidth()/2);
        int cW=(this.getWidth()+target.getWidth())/2;
        int cY=(this.getY()+this.getHeight()/2)-
               (target.getY()+target.getHeight()/2);
        int cH=(this.getHeight()+target.getHeight())/2;
        if((java.lang.Math.abs(cX) < java.lang.Math.abs(cW)) &&
           (java.lang.Math.abs(cY) < java.lang.Math.abs(cH))){
            collided = true;
        }
      }
      return collided;
    }


  // 检测与地图的碰撞
  public boolean isCollide(int TileWidth,
                           int TileHeight,
                           int MapCols,
                           int moveDirection) {
     boolean collided = false;
    try{

    int mapRow = (this.Y) / TileHeight;
    int mapCol = (this.X) / TileWidth;
    int mapIndexOfLeftTop = mapRow * MapCols + mapCol;
    mapRow = (this.Y) / TileHeight;
    mapCol = (this.X + this.width) / TileWidth;
    int mapIndexOfRightTop = mapRow * MapCols + mapCol;
    mapRow = (this.Y + this.height) / TileHeight;
    mapCol = (this.X) / TileWidth;
    int mapIndexOfLeftBottom = mapRow * MapCols + mapCol;
    mapRow = (this.Y + this.height) / TileHeight;
    mapCol = (this.X + this.width) / TileWidth;
    int mapIndexOfRightBottom = mapRow * MapCols + mapCol;
    //======================================================================

    switch (moveDirection) {
      case 0:
        if ( (MapArray.wall[mapIndexOfLeftTop] > 0) ||
            ( (MapArray.wall[mapIndexOfLeftBottom] > 0))) {
         if(MapArray.wall[mapIndexOfLeftTop] > 0){
           collisionX = (mapIndexOfLeftTop%MapCols)*TileWidth+TileWidth+1;
         }else{
           collisionX = (mapIndexOfLeftBottom%MapCols)*TileWidth+TileWidth+1;
         }
          collided = true;
        }
        break;
      case 1:
        if ( (MapArray.wall[mapIndexOfRightTop] > 0) ||
            ( (MapArray.wall[mapIndexOfRightBottom] > 0))) {
         if(MapArray.wall[mapIndexOfRightTop] > 0){
           collisionX = (mapIndexOfRightTop%MapCols)*TileWidth-this.getWidth()-1;
         }else{
           collisionX = (mapIndexOfRightBottom%MapCols)*TileWidth-this.getWidth()-1;
         }
          collided = true;
        }
        break;
      case 2:
        if ( (MapArray.wall[mapIndexOfLeftTop] > 0) ||
            ( (MapArray.wall[mapIndexOfRightTop] > 0))) {
         if(MapArray.wall[mapIndexOfLeftTop] > 0){
           collisionY = (mapIndexOfLeftTop/MapCols+1)*TileHeight+1;
         }else{
           collisionY = (mapIndexOfRightTop/MapCols+1)*TileHeight+1;
         }
          collided = true;
        }
        break;
      case 3:
        if ( (MapArray.wall[mapIndexOfLeftBottom] > 0) ||
            ( (MapArray.wall[mapIndexOfRightBottom] > 0))) {
         if(MapArray.wall[mapIndexOfLeftBottom] > 0){
           collisionY = (mapIndexOfLeftBottom/MapCols)*TileHeight-this.getHeight()-1;
         }else{
           collisionY = (mapIndexOfRightBottom/MapCols)*TileHeight-this.getHeight()-1;
         }
          collided = true;
        }
    }

  }
  catch(Exception e){

  }

    return collided;
  }
  public int getCollisionX(){
    return collisionX;
  }

  public int getCollisionY(){
    return collisionY;
  }

    //====================================================================
}