tank.java

坦克游戏

/*
 * Created on 2005-1-29
 *
 * myTankGame
 */
package components;

import java.awt.*;
import java.awt.geom.*;
import java.util.Properties;
import java.util.Vector;

import shape.*;
import resource.ResourceFactory;

/**
 * @author AnSen
 * 
 * Tank
 */
public class Tank extends GmMovComponent implements IScriptRender{

	protected double dFireDirect = 0;

	protected double dInputDirect = 0;

	protected double dTargetDirect = 0;
	
	private double dVDirect = 0;
	
	private boolean isBack = false;

	private double dRadius;

	private static String resourceID = "TANK";

	private Image[] imagesBase = null;

	private Image[] imagesBarbette = null;

	//private shape.Polygon pBarbette;

	private int iRotateRate = 8;

	AffineTransform bsTx;
	AffineTransform brTx;
	/**
	 * @param life
	 * @param ptX
	 * @param ptY
	 * @param width
	 * @param height
	 * @param direct
	 * @param container
	 */
	public Tank(double ptX, double ptY, Vector container) {
		super(-1, ptX, ptY, 0, 0, 0, container);
		Properties prop = ResourceFactory.getInstance().getProperties(
				resourceID);
		this.width = Integer.parseInt(prop.getProperty("WIDTH"));
		this.height = Integer.parseInt(prop.getProperty("HEIGHT"));
		this.iSpeed = Integer.parseInt(prop.getProperty("SPEED"));
		this.dRadius = Integer.parseInt(prop.getProperty("RADIUS"));
		this.iRotateRate = Integer.parseInt(prop.getProperty("ROTATERATE"));
		this.iMaxFrames = Integer.parseInt(prop.getProperty("MAXFRAMES"));

		shape.Polygon frame = shape.Polygon.parsePolygon(prop
				.getProperty("FRAME"));
		frame.offset(ptX, ptY);
		this.ishpframe = frame;

		imagesBase = (Image[]) prop.get("BASE_IMAGES");
		imagesBarbette = (Image[]) prop.get("BARBETTE_IMAGES");
		
		bsTx=AffineTransform.getRotateInstance(0, 0, 0);
		brTx=AffineTransform.getRotateInstance(0, 0, 0);
	}

	protected void rotateFrame(IShape frame) {
		if (frame instanceof shape.Polygon) {
			((shape.Polygon) frame).rotate(this.dDirect, ptX, ptY);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see components.GmMovComponent#move()
	 */
	public void move() {
		shape.Polygon pshp = (shape.Polygon) this.ishpframe;
		boolean bMovable = false;
		boolean bRotatble = false;
		double tmpDriect = dDirect;
		shape.Polygon preShp = pshp.cloneShape();

		preShp.move(this.dTargetDirect, dSpeed);
		bMovable = this.isMovable(preShp);

		if (bMovable) {
			dDirect = dTargetDirect;
			this.ptX += Math.cos(dDirect) * dSpeed;
			this.ptY += Math.sin(dDirect) * dSpeed;
			upSpeed();

			moveFrame(this.ishpframe);
		}

		preShp.rotate(this.dTargetDirect, ptX, ptY);
		bRotatble = this.isMovable(preShp);

		if (bRotatble) {
			dDirect = dTargetDirect;
			rotateFrame(this.ishpframe);
			dTargetDirect += (dInputDirect - dTargetDirect) / iRotateRate;
		} else {
			dDirect = tmpDriect;
			dTargetDirect = dDirect;
		}

		if (bMovable || bRotatble) {
			if(isBack){
				this.dVDirect=this.dDirect-Math.PI;
			}else{
				this.dVDirect=this.dDirect;
			}
			//listener proforme
			for (int i = 0; i < this.vGmListeners.size(); i++) {
				IGmMovListener obj = (IGmMovListener)vGmListeners.get(i);
				obj.moveProformed(dDirect, dSpeed, ptX,	ptY);
			}
		} else {
			initSpeed();
		}
	}

	protected boolean isMovable(IShape shape) {
		for (int i = 0; i < this.vContainer.size(); i++) {
			GmComponent obj = (GmComponent) vContainer.get(i);
			if (obj == this) {
				continue;
			} else {
				IShape frame = obj.getFrame();
				if (frame != null) {
					if (frame.isAcross(shape)) {
						hitWallProformed();
						return false;
					}
				}
			}
		}
		return true;
	}

	/**
	 * @return Returns the dFireDirect.
	 */
	public double getDFireDirect() {
		return dFireDirect;
	}

	/**
	 * @param fireDirect
	 *            The dFireDirect to set.
	 */
	public void setDFireDirect(double fireDirect) {
		if(dFireDirect == fireDirect){
			return;
		}
		dFireDirect = fireDirect;

		//listener proforme
		for (int i = 0; i < this.vGmListeners.size(); i++) {
			Object obj = vGmListeners.get(i);
			if (obj instanceof ITankListener) {
				((ITankListener) obj).barbetteTurnProformed(fireDirect);
			}
		}
	}

	/**
	 * @param inputDirect
	 *            The dInputDirect to set.
	 */
	public void setDirect(double inputDirect) {
		dInputDirect = inputDirect;
		double dAngle = dInputDirect - dTargetDirect;
		if (dAngle > Math.PI / 2) {
			dTargetDirect += Math.PI;
			isBack=!isBack;
		}
		if (dAngle < -Math.PI / 2) {
			dTargetDirect -= Math.PI;
			isBack=!isBack;
		}
	}

	public void fire() {
		double dx = ptX + Math.cos(dFireDirect) * (dRadius + 3);
		double dy = ptY + Math.sin(dFireDirect) * (dRadius + 3);

		Bullet bt = new Bullet(dx, dy, 3, 3, this.dFireDirect, vContainer);
		this.vContainer.addElement(bt);

		//listener proforme
		for (int i = 0; i < this.vGmListeners.size(); i++) {
			Object obj = vGmListeners.get(i);
			if (obj instanceof ITankListener) {
				((ITankListener) obj).fireProformed(dFireDirect);
			}
		}
	}

	public void addGmListener(ITankListener gls) {
		this.vGmListeners.addElement(gls);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see components.GmComponent#updateOject()
	 */
	public void updateOject() {
		//pBarbette.rotate(this.dFireDirect, ptX, ptY);
		super.updateOject();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see components.GmComponent#renderImage(java.awt.Graphics2D, int, int,
	 *      int, int)
	 */
	public void renderImage(Graphics2D g2D, int left, int top, int width,
			int height) {
		int pt_x, pt_y, ptOriginX, ptOriginY;
		int imageW, imageH;
		//g2D.setTransform(AffineTransform)
		
		Image imageBase = imagesBase[iCurrFrame];
		Image imageBarbette = imagesBarbette[iCurrFrame];
		imageW = imageBase.getWidth(null);
		imageH = imageBase.getHeight(null);
		ptOriginX = this.getPositionX() - left;
		ptOriginY = this.getPositionY() - top;
		pt_x = ptOriginX - imageW / 2;
		pt_y = ptOriginY - imageH / 2;

		AffineTransform oldTransf=g2D.getTransform();
		bsTx.setToRotation(dVDirect, ptOriginX, ptOriginY);
		g2D.setTransform(bsTx);
		//g2D.rotate(this.dVDirect, ptOriginX, ptOriginY);
		
		g2D.drawImage(imageBase, pt_x, pt_y, null);
		//g2D.rotate(-this.dVDirect, ptOriginX, ptOriginY);

		brTx.setToRotation(dFireDirect, ptOriginX, ptOriginY);
		g2D.setTransform(brTx);
		//g2D.rotate(this.dFireDirect, ptOriginX, ptOriginY);
		g2D.drawImage(imageBarbette, pt_x, pt_y, null);
		//g2D.rotate(-this.dFireDirect, ptOriginX, ptOriginY);

		g2D.setTransform(oldTransf);
		//shape.Polygon shp = (shape.Polygon) this.ishpframe;
		//g2D.drawPolygon(shp.getAwtPolygon(left, top));

	}

	/* (non-Javadoc)
	 * @see components.IScriptRender#isRenderable(int, int, int, int)
	 */
	public boolean isRenderable(int left, int top, int width, int height) {
		int pX,pY;
		pX=((int)ptX)-left;
		pY=((int)ptY)-top;
		if(pX>0&&pX<width&&pY>0&&pY<height){
			return true;
		}
		return false;
	}
	/**
	 * @return Returns the dRadius.
	 */
	public double getDRadius() {
		return dRadius;
	}
}