claw.java

goldminer游戏

package com.hbwhzdg.goldminer.gamecore.sprites;

import java.awt.geom.Line2D;
import java.util.HashMap;

import com.hbwhzdg.goldminer.gamecore.ScreenManager;
import com.hbwhzdg.goldminer.graphics.Animation;
import com.hbwhzdg.goldminer.graphics.Sprite;

/**
 * <p>Title: 挖矿爪子</p>
 *
 * <p>Description: 摆动以及伸长，所爪的东西。</p>
 * <p>未爪到物品时，显示绳索和抓。</p>
 * <p>当爪到物品后，显示绳索以及所爪的东西。将所爪东西的角色动画加入到本角色中，删掉原角色。</p>
 *
 * <p>Copyright: Copyright (c) 2006</p>
 *
 * <p>Company: </p>
 *
 * @author [e-mail]
 * @version 1.0
 */
public class Claw extends Sprite {
    private int clawState = 0; //爪子状态
    private Line2D.Double rope = new Line2D.Double(); //绳索
    private double length; //绳索的长度
    private double orgLength = 22; //绳索的原始长度
    private double putOutSpeed = 0.5; //爪子放出的速度,以毫秒为单位。
    private double takeBackSpeed = 0.5; //爪子爪空收回的速度。
    private HashMap allSpeed = new HashMap(); //爪住不同的物品回收速度不同，越大的物品越慢。
    private double stopTime = 2; //将物品爪回后，停多少毫秒后再摆动
    private double nStopTime = 0;
    private Sprite clawedSprite = null; //被爪起的物品。
    private Sprite prizeSprite = null; //被爪物品的奖品。
    //绳索在原坐标体系的坐标。
    //起点
    private double startOrgX = 0;
    private double startOrgY = 0;
    //终点
    private double endOrgX = 0;
    private double endOrgY = 0;
    //屏幕大小
    ScreenManager sm = ScreenManager.getInstance();
    private double screenWidth = sm.getWidth();
    private double screenHeight = sm.getHeight();
    private double orgAngle = 20; //偏转角度
    private double minAngle = 20; //最小角度
    private double angleSpeed = 1; //每毫秒转动的角度数
    private boolean way = false; //爪子转动方向

    public Claw(Animation anim) {
        super(anim);
    }

    /**
     * 初始化爪子的起点坐标，圆周摆动的长度，最小角度，转动的速率。
     * @param startOrgX double
     * @param startOrgY double
     * @param orgLength double
     * @param orgAngle double
     * @param angleSpeed double
     * @param nStopTime double
     */
    public void init(double nStartOrgX, double nStartOrgY, double nOrgLength,
                     double nMinAngle, double nAngleSpeed, double nPutOutSpeed,
                     double nTakeBackSpeed, double nStopTime) {
        if (nStartOrgX != -1) {
            this.startOrgX = nStartOrgX;
        }
        if (nStartOrgY != -1) {
            this.startOrgY = nStartOrgY;
        }
        if (nOrgLength != -1) {
            this.orgLength = nOrgLength;
            this.length = orgLength;
        }
        if (nMinAngle != -1) {
            this.minAngle = nMinAngle;
        }
        if (nAngleSpeed != -1) {
            this.angleSpeed = nAngleSpeed;
        }

        if (nPutOutSpeed != -1) {
            this.putOutSpeed = nPutOutSpeed;
        }

        if (nTakeBackSpeed != -1) {
            this.takeBackSpeed = nTakeBackSpeed;
        }

        if (nStopTime != -1) {
            this.stopTime = nStopTime * 1000;
            this.nStopTime = nStopTime * 1000;
        }

    }

    /**
     * 更新爪子的角度。
     * @param elapsedTime long
     */
    private void updateOrgAngle(long elapsedTime) {
        if (orgAngle <= minAngle) {
            way = false;
        } else if (orgAngle >= 180 - minAngle) {
            way = true;
        }
        if (way) {
            orgAngle -= elapsedTime * angleSpeed;
        } else {
            orgAngle += elapsedTime * angleSpeed;
        }

    }

    /**
     * 更新绳索。
     * @param elapsedTime long
     */
    private void updateRope(long elapsedTime) {
        if (orgAngle <= 90) {
            endOrgX = length * Math.cos(Math.PI / (180 / orgAngle)) + startOrgX;
        } else {
            endOrgX = -length * Math.cos(Math.PI / (180 / (180 - orgAngle))) +
                      startOrgX;
        }
        endOrgY = length * Math.sin(Math.PI / (180 / orgAngle)) + startOrgY;

        switch (clawState) {
        case 1:
            if (
                    (endOrgX - this.getWidth() / 2 > 0 &&
                     endOrgX + this.getWidth() / 2 < screenWidth)
                    && (endOrgY + this.getHeight() < screenHeight)
                    ) {
                length += putOutSpeed * elapsedTime;
            } else {
                //当爪子到屏幕边界后，缩回。
                clawState = 2;
            }
            break;
        case 2:
            double backSpeed = takeBackSpeed;
            //爪到物品后的回收速度
            if (clawedSprite != null) {
                if (allSpeed.get(clawedSprite.getName()) != null) {
                    backSpeed = Double.parseDouble((String) allSpeed.get(
                            clawedSprite.getName()));
                }
            }
            length -= backSpeed * elapsedTime;
            if (length < orgLength) {
                length = orgLength;
                //当爪到物品后
                if (clawedSprite != null) {
                    nStopTime -= elapsedTime;
                    if (nStopTime <= 0) { //停留时间
                        clawState = 0;
                        setClawedSprite(null);
                        setPrize(null);
                        nStopTime = stopTime;
                    }
                } else {
                    clawState = 0;
                }
            }
            break;
        }
        rope.setLine(0, 0, 0, length);
    }

    /**
     * 更新整个挖矿爪子。
     * @param elapsedTime long
     */
    public void update(long elapsedTime) {
        super.update(elapsedTime);
        if (clawState == 0) {
            updateOrgAngle(elapsedTime);
        }
        updateRope(elapsedTime);
    }

    public Line2D.Double getRope() {
        return rope;
    }

    public Sprite getClawedSprite() {
        return clawedSprite;
    }

    public int getClawState() {
        return clawState;
    }

    public double getOrgLength() {
        return orgLength;
    }

    public double getOrgX() {
        return startOrgX;
    }

    public double getOrgY() {
        return startOrgY;
    }

    public double getLength() {
        return length;
    }

    public double getScreenHeight() {
        return screenHeight;
    }

    public double getScreenWidth() {
        return screenWidth;
    }

    public double getAngleSpeed() {
        return angleSpeed;
    }

    public double getEndOrgX() {
        return endOrgX;
    }

    public double getEndOrgY() {
        return endOrgY;
    }

    public double getMinAngle() {
        return minAngle;
    }

    public double getOrgAngle() {
        return orgAngle;
    }

    public double getStartOrgX() {
        return startOrgX;
    }

    public double getStartOrgY() {
        return startOrgY;
    }

    public double getPutOutSpeed() {
        return putOutSpeed;
    }

    public double getTakeBackSpeed() {
        return takeBackSpeed;
    }

    public Sprite getPrize() {
        return prizeSprite;
    }

    public HashMap getAllSpeed() {
        return allSpeed;
    }

    public void setClawedSprite(Sprite clawedSprite) {
        this.clawedSprite = clawedSprite;
    }

    /**
     * 设置爪子的状态。<br>
     * 0：摆动；
     * 1：伸爪；
     * 2：收爪。
     * 根据爪子状态的不同，矿工有不同的动作。
     * @param clawState int
     */
    public void setClawState(int clawState) {
        this.clawState = clawState;
    }

    public void setOrgLength(double orgLength) {
        this.orgLength = orgLength;
    }

    public void setOrgX(double orgX) {
        this.startOrgX = orgX;
    }

    public void setOrgY(double orgY) {
        this.startOrgY = orgY;
    }

    public void setLength(double length) {
        this.length = length;
    }

    public void setScreenHeight(double screenHeight) {
        this.screenHeight = screenHeight;
    }

    public void setScreenWidth(double screenWidth) {
        this.screenWidth = screenWidth;
    }

    public void setAngleSpeed(double angleSpeed) {
        this.angleSpeed = angleSpeed;
    }

    public void setEndOrgX(double endOrgX) {
        this.endOrgX = endOrgX;
    }

    public void setEndOrgY(double endOrgY) {
        this.endOrgY = endOrgY;
    }

    public void setMinAngle(double minAngle) {
        this.minAngle = minAngle;
    }

    public void setOrgAngle(double orgAngle) {
        this.orgAngle = orgAngle;
    }

    public void setStartOrgX(double startOrgX) {
        this.startOrgX = startOrgX;
    }

    public void setStartOrgY(double startOrgY) {
        this.startOrgY = startOrgY;
    }

    public void setPutOutSpeed(double putOutSpeed) {
        this.putOutSpeed = putOutSpeed;
    }

    public void setTakeBackSpeed(double takeBackSpeed) {
        this.takeBackSpeed = takeBackSpeed;
    }

    public void setPrize(Sprite prize) {
        this.prizeSprite = prize;
    }

    public void setAllSpeed(HashMap allSpeed) {
        this.allSpeed = allSpeed;
    }

}