sprite.java

一个java的免费游戏引擎,里面有文档,和例子

// Decompiled by Jad v1.5.7g. Copyright 2000 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi 

package com.golden.gamedev.object;

import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.image.BufferedImage;
import java.io.Serializable;

// Referenced classes of package com.golden.gamedev.object:
//            Background

public class Sprite implements Serializable {

	private Background background;

	private double x;

	private double y;

	private double xSpeed;

	private double ySpeed;

	private double oldX;

	private double oldY;

	private static double LeftOffset;

	private static double TopOffset;

	private transient BufferedImage image;

	protected int width;

	protected int height;

	private int ID;

	private Object dataID;

	private int layer;

	private boolean isActive;

	private boolean isImmutable;//多 而 小，经常用的sprite 可以设为不可以变的 true

	public Sprite(BufferedImage bufferedimage, double xpos, double ypos) {
		isActive = true;
		x = oldX = xpos;
		y = oldY = ypos;
		if (bufferedimage != null) {
			image = bufferedimage;
			width = bufferedimage.getWidth();
			height = bufferedimage.getHeight();
		}
		background = Background.getDefaultBackground();
	}

	public Sprite(BufferedImage bufferedimage) {
		this(bufferedimage, 0.0D, 0.0D);
	}

	public Sprite(double x, double y) {
		this(null, x, y);
	}

	public Sprite() {
		this(0.0D, 0.0D);
	}

	public void setBackground(Background background) {
		this.background = background;
		if (background == null)
			background = Background.getDefaultBackground();
	}

	public Background getBackground() {
		return background;
	}

	public BufferedImage getImage() {
		return image;
	}

	public void setImage(BufferedImage bufferedimage) {
		image = bufferedimage;
		width = height = 0;
		if (bufferedimage != null) {
			width = bufferedimage.getWidth();
			height = bufferedimage.getHeight();
		}
	}

	public int getWidth() {
		return width;
	}

	public int getHeight() {
		return height;
	}

	/**
	 * 
	 * @param elapsedTime 移动了的时间
	 * @param animX
	 * @param animY
	 * @param speed
	 * @return
	 */
	public boolean moveTo(long elapsedTime, double animX, double animY, double speed) {
		if (x == animX && y == animY)
			return true;
		
		//Math.atan2(animY - y, animX - x))转换为极坐标，返回极坐标中的角度
		//-------------------------------- + 90D 逆时针方向
		double d4 = Math.toRadians(90D + Math.toDegrees(Math.atan2(animY - y, animX - x)));
		//d5 x方向上移动的距离
		double d5 = Math.sin(d4)* speed * (double) elapsedTime;
		//d6 y方向上移动的距离
		double d6 = -Math.cos(d4) * speed * (double) elapsedTime;
		boolean flag = false;
		boolean flag1 = false;
		if (d5 != 0.0D) {
			if (d5 > 0.0D) {
				if (x + d5 >= animX) {
					d5 = animX - x;
					flag = true;
				}
			} else if (x + d5 <= animX) {
				d5 = animX - x;
				flag = true;
			}
		} else if (x == animX)
			flag = true;
		if (d6 != 0.0D) {
			if (d6 > 0.0D) {
				if (y + d6 >= animY) {
					d6 = animY - y;
					flag1 = true;
				}
			} else if (y + d6 <= animY) {
				d6 = animY - y;
				flag1 = true;
			}
		} else if (y == animY)
			flag1 = true;
		move(d5, d6);
		return flag && flag1;
	}

	public void setLocation(double dx, double dy) {
		oldX = x = dx;
		oldY = y = dy;
	}

	public void move(double dx, double dy) {
		if (dx != 0.0D) {
			oldX = x;
			x += dx;
		}
		if (dy != 0.0D) {
			oldY = y;
			y += dy;
		}
	}

	public void moveX(double dx) {
		if (dx != 0.0D) {
			oldX = x;
			x += dx;
		}
	}

	public void moveY(double dy) {
		if (dy != 0.0D) {
			oldY = y;
			y += dy;
		}
	}

	public void setX(double xs) {
		oldX = x = xs;
	}

	public void setY(double ys) {
		oldY = y = ys;
	}

	public void forceX(double xs) {
		x = xs;
	}

	public void forceY(double ys) {
		y = ys;
	}

	public double getX() {
		return x;
	}

	public double getY() {
		return y;
	}

	public double getOldX() {
		return oldX;
	}

	public double getOldY() {
		return oldY;
	}

	public void setSpeed(double vx, double vy) {
		xSpeed = vx;
		ySpeed = vy;
	}

	public void setHorizontalSpeed(double vx) {
		xSpeed = vx;
	}

	public void setVerticalSpeed(double vy) {
		ySpeed = vy;
	}

	public void setMovement(double speed, double angleDir) {//
		double d3 = Math.toRadians(angleDir);
		setSpeed(Math.sin(d3) * speed, -Math.cos(d3) * speed);
	}

	public void addHorizontalSpeed(long elapsedTime, double accel, double maxSpeed) {
		if (accel != 0.0D && elapsedTime != 0L) {
			xSpeed += accel * (double) elapsedTime;
			if (accel < 0.0D) {
				if (xSpeed < maxSpeed) {
					xSpeed = maxSpeed;
					return;
				}
			} else if (xSpeed > maxSpeed)
				xSpeed = maxSpeed;
		}
	}

	public void addVerticalSpeed(long elapsedTime, double accel, double maxSpeed) {
		if (accel != 0.0D && elapsedTime != 0L) {
			ySpeed += accel * (double) elapsedTime;
			if (accel < 0.0D) {
				if (ySpeed < maxSpeed) {
					ySpeed = maxSpeed;
					return;
				}
			} else if (ySpeed > maxSpeed)
				ySpeed = maxSpeed;
		}
	}

	public double getHorizontalSpeed() {
		return xSpeed;
	}

	public double getVerticalSpeed() {
		return ySpeed;
	}

	public double getScreenX() {
		return (x - background.getX()) + (double) background.getClip().x;
	}

	public double getScreenY() {
		return (y - background.getY()) + (double) background.getClip().y;
	}
	
	/**
	 * 
	 * @param leftOffset
	 * @param topOffset
	 * @param rightOffset
	 * @param bottomOffset
	 * @return
	 */
	public boolean isOnScreen(int leftOffset, int topOffset, int rightOffset, int bottomOffset) {
		LeftOffset = x - background.getX();
		TopOffset = y - background.getY();
		return LeftOffset + (double) width > (double) (-leftOffset)
				&& TopOffset + (double) height > (double) (-topOffset)
				&& LeftOffset < (double) (background.getClip().width + rightOffset)
				&& TopOffset < (double) (background.getClip().height + bottomOffset);
	}

	public boolean isOnScreen() {
		return isOnScreen(0, 0, 0, 0);
	}

	public void update(long elapsedTime) {
		updateMovement(elapsedTime);
	}

	protected void updateMovement(long elapsedTime) {
		move(xSpeed * (double) elapsedTime, ySpeed * (double) elapsedTime);
	}

	public void render(Graphics2D graphics2d) {
		LeftOffset = x - background.getX();//sprite到background的左边界的距离
		TopOffset = y - background.getY();//sprite到background的上边界的距离
		if (LeftOffset + (double) width > 0.0D && TopOffset + (double) height > 0.0D
				&& LeftOffset <= (double) background.getClip().width
				&& TopOffset <= (double) background.getClip().height) {
			LeftOffset += background.getClip().x;
			TopOffset += background.getClip().y;
			render(graphics2d, (int) LeftOffset, (int) TopOffset);
		}
	}

	public void render(Graphics2D graphics2d, int x, int y) {
		graphics2d.drawImage(image, x, y, null);
	}

	public int getID() {
		return ID;
	}

	public void setID(int id) {
		ID = id;
	}

	public Object getDataID() {
		return dataID;
	}

	public void setDataID(Object objId) {
		dataID = objId;
	}

	public int getLayer() {
		return layer;
	}

	public void setLayer(int i) {
		layer = i;
	}

	public boolean isActive() {
		return isActive;
	}

	public void setActive(boolean flag) {
		isActive = flag;
	}

	public boolean isImmutable() {
		return isImmutable;
	}

	public void setImmutable(boolean flag) {
		isImmutable = true;
	}

	public double getDistance(Sprite sprite) {
		return Math.sqrt(Math.pow(getX() - sprite.getX(), 2D)
				+ Math.pow(getY() - sprite.getY(), 2D));
	}
}