实验三 敏捷开发与XP实践（改）

标签：

---恢复内容开始---

一、敏捷开发与XP

二、编码标准

1.编码标准中的版式就是一个很好的例子，版式虽然不会影响程序的功能，但会影响可读性。程序的版式追求清晰、美观，是程序风格的重要因素。单击Eclipse菜单中的source->Format 或用快捷键Ctrl+Shift+F就可以按Eclipse规定的规范缩进。

2. 代码标准中很重要的一项是如何给包、类、变量、方法等标识符命名，能很好的命名可以让自己的代码立马上升一个档次。Java中的一般的命名规则有：

三、重构

重构(Refactor)，就是在不改变软件外部行为的基础上，改变软件内部的结构，使其更加易于阅读、易于维护和易于变更 。

重构之后的Student Test代码：

别踩白块：

齐岳：负责代码的实现(一）

blogs：http://www.cnblogs.com/July0207/

codes：

package com.orange.block;

import android.graphics.Color;

import android.graphics.Typeface;

import android.os.Bundle;

import com.orange.engine.camera.ZoomCamera;

import com.orange.engine.options.PixelPerfectEngineOptions;

import com.orange.engine.options.PixelPerfectMode;

import com.orange.engine.options.ScreenOrientation;

import com.orange.res.FontRes;

import com.orange.res.RegionRes;

import com.orange.ui.activity.GameActivity;

import com.orange.block.res.Res;

import com.orange.block.scene.GameScene;

import com.orange.block.util.ConstantUtil;

import com.orange.block.util.LogUtil;

/**

 * 入口主Activity 类

 * @author lch<OGEngine@orangegame.cn>

 * @

 */

public class MainActivity extends GameActivity {

    @Override

    protected void onCreate(Bundle pSavedInstanceState) {

        super.onCreate(pSavedInstanceState);

    }

    @Override

    protected PixelPerfectEngineOptions onCreatePixelPerfectEngineOptions() {

        PixelPerfectEngineOptions pixelPerfectEngineOptions = new PixelPerfectEngineOptions(

                this, ZoomCamera.class);

        pixelPerfectEngineOptions

                .setScreenOrientation(ScreenOrientation.PORTRAIT_FIXED); // 设置竖屏

        pixelPerfectEngineOptions

                .setPixelPerfectMode(PixelPerfectMode.CHANGE_HEIGHT);// 适配模式,这里设置为“保持宽度不变，改变高”

        pixelPerfectEngineOptions.setDesiredSize(ConstantUtil.DESIRED_SIZE);// 参考尺寸

        return pixelPerfectEngineOptions;

    }

    @Override

    protected void onLoadResources() {

        // 加载相关初始的资源等

        LogUtil.d("开始加载资源...");

        RegionRes.loadTexturesFromAssets(Res.ALL_XML);

        FontRes.loadFont(128, 128,

                Typeface.create(Typeface.DEFAULT, Typeface.BOLD), 40, true,

                Color.RED, ConstantUtil.FONT_NAME_TIMER);

        FontRes.loadFont(256, 512,

                Typeface.create(Typeface.DEFAULT, Typeface.BOLD), 50, true,

                Color.BLACK, ConstantUtil.FONT_NAME_RESULT);

    }

    @Override

    protected void onLoadComplete() {

        // 加载资源完成后

        LogUtil.d("加载资源完成...");

        this.startScene(GameScene.class);// 启动游戏场景

    }

    @Override

    protected void onPause() {

        super.onPause();

        this.getEngine().stop();

    }

    @Override

    protected synchronized void onResume() {

        super.onResume();

        this.getEngine().start();

    }

    @Override

    protected void onDestroy() {

        super.onDestroy();

        android.os.Process.killProcess(android.os.Process.myPid());

    }

}

package com.orange.block.util;

public class ConstantUtil {

    /**屏幕参考尺寸**/

    public static final float DESIRED_SIZE = 480;

    /**标示白颜色**/

    public static final int COLOR_WHITE = 0;

    /**标示黑颜色**/

    public static final int COLOR_BLACK = 1;

    /**游戏进行状态**/

    public static final int GAME_START = 1;

    /**游戏结束状态**/

    public static final int GAME_OVER = 2;

    /** 游戏总共有多少行 **/

    public static final int LINES_LEN = 50;

    /**字体颜色的 key**/

    public static final String FONT_NAME_TIMER = "timer";

    public static final String FONT_NAME_RESULT = "result";

}

package com.orange.block.util;

import android.util.Log;

/**

 *

 * @author lch

 *

 */

public class LogUtil {

    private static boolean showLogEnabled = true;

    private static final String TAG = "OG";

    public static void out(String msg) {

        if (showLogEnabled)

            System.out.println(msg);

    }

    public static void d(String msg) {

        if (showLogEnabled)

            Log.d(TAG, msg);

    }

    public static void i(String msg) {

        if (showLogEnabled)

            Log.i(TAG, msg);

    }

    public static void v(String msg) {

        if (showLogEnabled)

            Log.v(TAG, msg);

    }

    public static void w(String msg) {

        if (showLogEnabled)

            Log.w(TAG, msg);

    }

    public static void e(String msg) {

        if (showLogEnabled)

            Log.e(TAG, msg);

    }

}

package com.orange.block.util;

import android.content.Context;

import android.content.SharedPreferences.Editor;

/**

 * 保存到 SharedPreferences 的数据

 *

 * @author lch

 *

 */

public class SharedUtil {

    private static final String SHARED_OG = "Shared_og";

    private static final String RESULT_RECORD = "result_record";

    /**

     * 保持最新的记录

     * @param pContext

     * @param pMillisPass

     */

    public static void setRecord(Context pContext, long pMillisPass) {

        Editor edit = pContext.getSharedPreferences(SHARED_OG,

                Context.MODE_PRIVATE).edit();

        edit.putLong(RESULT_RECORD, pMillisPass);

        edit.commit();

    }

    /**

     * 获取记录

     * @param context

     * @return

     */

    public static long getRecord(Context context) {

        return context

                .getSharedPreferences(SHARED_OG, Context.MODE_PRIVATE)

                .getLong(RESULT_RECORD, 0);

    }

}

package com.orange.block.scene;

import java.util.ArrayList;

import java.util.List;

import java.util.Random;

import android.view.KeyEvent;

import com.orange.content.SceneBundle;

import com.orange.entity.IEntity;

import com.orange.entity.modifier.ColorModifier;

import com.orange.entity.modifier.DelayModifier;

import com.orange.entity.modifier.IEntityModifier.IEntityModifierListener;

import com.orange.entity.modifier.LoopEntityModifier;

import com.orange.entity.modifier.MoveYModifier;

import com.orange.entity.modifier.ScaleModifier;

import com.orange.entity.modifier.SequenceEntityModifier;

import com.orange.entity.primitive.DrawMode;

import com.orange.entity.primitive.Mesh;

import com.orange.entity.scene.Scene;

import com.orange.entity.sprite.AnimatedSprite;

import com.orange.entity.text.Text;

import com.orange.res.FontRes;

import com.orange.util.color.Color;

import com.orange.util.modifier.IModifier;

import com.orange.block.control.TimerTool;

import com.orange.block.entity.Block;

import com.orange.block.entity.FailGroup;

import com.orange.block.entity.SuccGroup;

import com.orange.block.res.Res;

import com.orange.block.util.ConstantUtil;

import com.orange.block.util.LogUtil;

/**

 * 游戏场景

 *

 * @author lch

 *

 */

public class GameScene extends Scene {

    /** 块的宽 **/

    private float blockWidth = 0;

    /** 块的高 **/

    private float blockHight = 0;

    /** 用于装当前所有生成但未被删除的block **/

    private List<Block[]> blockList;

    /** 当前生成的块的行数 **/

    private int linesLength = 5;

    /** 游戏状态 **/

    private int gameStatus = ConstantUtil.GAME_START;

    /** 移动步数 **/

    private int moveNum = 0;

    /** 成功界面 **/

    private SuccGroup mSuccGroup;

    /** 失败界面 **/

    private FailGroup mFailGroup;

    /** 计时管理类 **/

    private TimerTool mTimerTool;

    /** 显示计时的Text **/

    private Text timerText;

    /**游戏提示语**/

    private AnimatedSprite game_tip;

    // 用于Z索引排序

    private static final int pZIndex_middle = 2;

    private static final int pZIndex_top = 3;

    public Text getTimerText() {

        return timerText;

    }

    public TimerTool getmTimerTool() {

        return mTimerTool;

    }

    @Override

    public void onSceneCreate(SceneBundle bundle) {

        super.onSceneCreate(bundle);

        // 镜头里显示的是4*4的块，所以用镜头宽的四分之一作为块宽

        blockWidth = this.getCameraWidth() / 4;

        blockHight = this.getCameraHeight() / 4;

        this.blockList = new ArrayList<Block[]>();

        mTimerTool = new TimerTool(this);

        initView();

    }

    private void initView() {

        // 初始化blocks

        initBlocks();

        timerText = new Text(getCameraCenterX(), 10,

                FontRes.getFont(ConstantUtil.FONT_NAME_TIMER), "00.000\"",

                "00:00.000\"".length(), getVertexBufferObjectManager());

        this.attachChild(timerText);

        timerText.setCentrePositionX(getCameraCenterX());

        timerText.setZIndex(pZIndex_top);

        mSuccGroup = new SuccGroup(getCameraWidth(), getCameraHeight(), this);

        mSuccGroup.setZIndex(pZIndex_middle);

        mSuccGroup.setVisible(false);

        this.attachChild(mSuccGroup);

        mFailGroup = new FailGroup(getCameraWidth(), getCameraHeight(), this);

        this.attachChild(mFailGroup);

        mFailGroup.setZIndex(pZIndex_middle);

        game_tip = new AnimatedSprite(0, 0, Res.GAME_TIP, getVertexBufferObjectManager());

        game_tip.setCentrePositionX(this.getCameraCenterX());

        game_tip.setBottomPositionY(this.getCameraBottomY()-60);

        this.attachChild(game_tip);

        game_tip.setZIndex(pZIndex_top);

    }

    /**

     * 初始化blocks

     */

    private void initBlocks() {

        Random mRandom = new Random();

        int blackIndex = 0;

        // 初始blocks,先创建4*5表格，使用时候再一行行增加

        for (int row = 0; row < linesLength; row++) {// 行

            // 一行blocks

            Block[] rowBolcks = new Block[4];

            // 随机一个黑块所在位置

            blackIndex = mRandom.nextInt(4);

            for (int column = 0; column < 4; column++) {// 列

                rowBolcks[column] = new Block(this, row, column, blockWidth,

                        blockHight, blackIndex, getVertexBufferObjectManager());

                this.attachChild(rowBolcks[column]);

            }

            blockList.add(rowBolcks);

        }

    }

    /**

     * 重来时，重置游戏相关

     */

    public void resetGame() {

        gameStatus = ConstantUtil.GAME_START;

        linesLength = 5;

        moveNum = 0;

        mSuccGroup.showItems(false);

        timerText.setText("00.000\"");

        timerText.setVisible(true);

        mTimerTool.resetTimer();

        mSuccGroup.setVisible(false);

        game_tip.setVisible(true);

        deletBlocks();

        initBlocks();

        // 按Z索引排序一下上下层顺序

        this.sortChildren();

    }

    /**

     * 创建添加新的一行

     */

    private void createNewRowBolcks() {

        // 超出屏幕没用的部分移除掉

        if (blockList.size() > 5) {

            Block[] rowBolcks = blockList.get(0);

            for (Block block : rowBolcks) {

                block.detachSelf();

            }

            blockList.remove(0);

        }

        // 目前顶部的一行块的Y坐标

        float topBlocksY = blockList.get(blockList.size() - 1)[0].getY();

        // 一行块

        Block[] rowBolcks = new Block[4];

        int blackIndex = new Random().nextInt(4);

        for (int column = 0; column < 4; column++) {

            // 新创建 Block

            rowBolcks[column] = new Block(this, column, blockWidth, blockHight,

                    blackIndex, getVertexBufferObjectManager());

            // 设置Y坐标

            rowBolcks[column].setBottomPositionY(topBlocksY - 1);

            // 设置已经是第几行

            rowBolcks[column].setRow(linesLength);

            this.attachChild(rowBolcks[column]);

        }

        blockList.add(rowBolcks);

        // 按Z索引排序一下上下层顺序

        this.sortChildren();

        // 当前生成的块的行数增加

        linesLength++;

    }

    /**

     * 最后一个移动，游戏胜利

     *

     * @param pBlock

     */

    private void gameSucc(Block pBlock) {

        gameStatus = ConstantUtil.GAME_OVER;

        // 最后一个移动，游戏胜利

        moveDown(pBlock, 0);

        // 停止计时

        mTimerTool.stop();

        // 显示游戏胜利画面

        mSuccGroup.showItems(true);

        // 隐藏显示时间的Text

        timerText.setVisible(false);

    }

    /**

     * 点击错误后弹出红色的失败界面,游戏失败

     */

    private void gameFail() {

        gameStatus = ConstantUtil.GAME_OVER;

        // 游戏失败，停止计时

        mTimerTool.stop();

        // 隐藏显示时间的Text

        timerText.setVisible(false);

    }

    /**

     * 游戏快到顶部时开始出现绿色的胜利界面

     */

    private void showSuccGroup() {

        // 目前顶部的一行块的Y坐标

        float topBlocksY = blockList.get(blockList.size() - 1)[0].getY();

        mSuccGroup.setBottomPositionY(topBlocksY);

        mSuccGroup.setVisible(true);

    }

    /**

     * 移除剩下的block，清空blockList

     */

    private void deletBlocks() {

        for (Block[] rowBlocks : blockList) {

            for (Block block : rowBlocks) {

                this.detachChild(block);

            }

        }

        blockList.clear();

    }

    /**

     * 点击到Block时进行的逻辑处理

     *

     * @param pBlock

     *            所点击的block

     */

    public void touchBlock(Block pBlock) {

        if (gameStatus == ConstantUtil.GAME_START) {

            if (pBlock.getRow() == moveNum + 2) {// 表示是在底部往上数的倒数第三行

                // 判断是不是点击了该点击的黑块的上一格，如果是，我们也判定这是正确点击了，做出相应移动

                upBlockTouch(pBlock);

            } else if (pBlock.getRow() == moveNum + 1) {// 表示是在底部往上数的倒数第二行

                if (pBlock.getColorType() == ConstantUtil.COLOR_BLACK) {

                    if (linesLength == moveNum + 2) {

                        // 游戏胜利

                        gameSucc(pBlock);

                    } else {

                        // 整体blocks下移

                        moveDown(pBlock, 1);

                    }

                } else if (pBlock.getColorType() == ConstantUtil.COLOR_WHITE) {

                    // 误点了白块，游戏失败

                    gameFail();

                    // 失败时pBlock的一个闪红效果

                    LoopEntityModifier loop = failAction();

                    // 播放效果

                    pBlock.registerEntityModifier(loop);

                }

            }

        }

    }

    /**

     * 失败时pBlock的一个闪红效果

     * @return

     */

    private LoopEntityModifier failAction() {

        SequenceEntityModifier sequence = new SequenceEntityModifier(

                new ColorModifier(0.1f, Color.RED, Color.WHITE),

                new DelayModifier(0.07f), new ColorModifier(0.1f,

                        Color.WHITE, Color.RED));

        LoopEntityModifier loop = new LoopEntityModifier(sequence,

                3, new IEntityModifierListener() {

                    @Override

                    public void onModifierStarted(

                            IModifier<IEntity> pModifier,

                            IEntity pItem) {

                    }

                    @Override

                    public void onModifierFinished(

                            IModifier<IEntity> pModifier,

                            IEntity pItem) {

                        //效果播放完毕，显示游戏失败界面

                        mFailGroup.showView();

                    }

                });

        return loop;

    }

    /**

     * 判断是不是点击了该点击的黑块的上一格，如果是，我们也判定这是正确点击了，做出相应移动

     *

     * @param pBlock

     *            所被点击的块

     */

    private void upBlockTouch(Block pBlock) {

        int touchColumn = pBlock.getColumn();

        for (Block[] blocks : blockList) {

            for (Block block : blocks) {

                if (block.getRow() == moveNum + 1

                        && block.getColorType() == ConstantUtil.COLOR_BLACK) {

                    if (block.getColumn() == touchColumn) {

                        // 整体blocks下移

                        moveDown(block, 1);

                    }

                    return;

                }

            }

        }

    }

    /**

     * 正确点击该点击的黑块，或者上一行的块，整体向下移动、创建新的一样块，改变黑块颜色

     *

     * @param pBlock

     * @param stepNum

     *            一般为1，到最后出现绿色成功界面的最后一步为0

     */

    private void moveDown(Block pBlock, int stepNum) {

        if(moveNum == 0){

            // 开始计时

            mTimerTool.start();

            // 隐藏提示文字

            game_tip.setVisible(false);

        }

        if (moveNum < ConstantUtil.LINES_LEN) {

            // 创建添加新的一行

            createNewRowBolcks();

        } else if (moveNum == ConstantUtil.LINES_LEN) {

            // 开始显示绿色胜利界面，即将胜利，但还没有胜利

            showSuccGroup();

        }

        // 被点击的黑块变灰

        pBlock.setColor(0.63f, 0.63f, 0.63f);

        pBlock.registerEntityModifier(new ScaleModifier(0.1f, 0.5f, 1.0f));

        // 移动步数加1

        moveNum++;

        // 需要移动的距离

        float moveDistance = this.getCameraHeight() - blockHight * stepNum

                - pBlock.getY();

        for (Block[] rowBlocks : blockList) {

            for (Block block : rowBlocks) {

                // 遍历，所有block向下移动指定距离

                moveToY(block, moveDistance);

            }

        }

        // 快到胜利出现绿色胜利界面时，胜利界面跟着移动

        if (mSuccGroup.isVisible()) {

            moveToY(mSuccGroup, moveDistance);

        }

池彬宁：负责代码的实现（二）

blogs：www.cnblogs.com/Spr1ngxx　　

codes:

package com.orange.block.res;

public class Res {

    public static final String XML_GFX_GAME = "gfx/game.xml";

    public static final String[] ALL_XML = new String[]{

        Res.XML_GFX_GAME

    };

    public static final String BTN_AGAIN = "btn_again";

    public static final String BTN_BACK = "btn_back";

    public static final String BTN_START = "btn_start";

    public static final String GAME_MODEL = "game_model";

    public static final String GAME_TIP = "game_tip";

    public static final String GAME_TITEL = "game_titel";

}

package com.orange.block.entity;

import com.orange.entity.primitive.Rectangle;

import com.orange.input.touch.TouchEvent;

import com.orange.opengl.vbo.VertexBufferObjectManager;

import com.orange.util.color.Color;

import com.orange.block.scene.GameScene;

import com.orange.block.util.ConstantUtil;

/**

 * 单个块元素

 *

 * @author lch

 *

 */

public class Block extends Rectangle {

    // 游戏场景

    private GameScene mGameScene;

    // 此block的颜色类型，白色还是黑色？

    private int colorType;

    // block 所在的行

    private int row;

    // block 所在的列

    private int column;

    // ======================get&set========================

    public int getRow() {

        return row;

    }

    public void setRow(int row) {

        this.row = row;

    }

    public int getColumn() {

        return column;

    }

    public int getColorType() {

        return colorType;

    }

    // =====================================================

    /**

     * 构造器1,初始化blocks时用到

     * @param pGameScene 游戏场景

     * @param row block所在的行

     * @param column block所在的列

     * @param pWidth block的宽

     * @param pHeight block的高

     * @param blackIndex 用来确定是否是黑块，如果blackIndex == column时设为黑块

     * @param pVertexBufferObjectManager

     */

    public Block(GameScene pGameScene, int row, int column, float pWidth,

            float pHeight, int blackIndex,

            VertexBufferObjectManager pVertexBufferObjectManager) {

        super(column * pWidth, (3 - row) * pHeight, pWidth - 1, pHeight - 1,

                pVertexBufferObjectManager);

        this.mGameScene = pGameScene;

        this.row = row;

        this.column = column;

        if (row == 0) {

            // 第一行设置为黄块

            this.setColor(Color.YELLOW);

        } else {

            // 初始化block的颜色数据,是白块还是黑块?

            initBlockData(column, blackIndex);

        }

        // 设置可以相应触碰事件

        this.setIgnoreTouch(false);

    }

    /**

     * 构造器2,新增blocks时用到

     * @param pGameScene 游戏场景

     * @param column block所在的列

     * @param pWidth block的宽

     * @param pHeight block的高

     * @param blackIndex 来确定是否是黑块，如果blackIndex == column时设为黑块

     * @param pVertexBufferObjectManager

     */

    public Block(GameScene pGameScene, int column, float pWidth, float pHeight,

            int blackIndex, VertexBufferObjectManager pVertexBufferObjectManager) {

        super(column * pWidth, 0, pWidth - 1, pHeight - 1,

                pVertexBufferObjectManager);

        this.mGameScene = pGameScene;

        this.column = column;

        // 初始化block的颜色数据,是白块还是黑块?

        initBlockData(column, blackIndex);

        // 设置可以相应触碰事件

        this.setIgnoreTouch(false);

    }

    /**

     * 初始化block的颜色数据,是白块还是黑块?

     * @param column

     * @param blackIndex

     */

    private void initBlockData(int column, int blackIndex) {

        if (blackIndex == column) {

            // 设置为黑块

            this.setColor(Color.BLACK);

            this.colorType = ConstantUtil.COLOR_BLACK;

        } else {

            // 设置为白块

            this.setColor(Color.WHITE);

            this.colorType = ConstantUtil.COLOR_WHITE;

        }

    }

    @Override

    public boolean onAreaTouched(TouchEvent pSceneTouchEvent,

            float pTouchAreaLocalX, float pTouchAreaLocalY) {

        // 触碰事件监听

        if (pSceneTouchEvent.isActionDown()) {

            // 点击到Block时进行的逻辑处理

            mGameScene.touchBlock(this);

        }

        return true;

    }

}

package com.orange.block.entity;

import android.app.AlertDialog;

import android.content.DialogInterface;

import com.orange.entity.group.EntityGroup;

import com.orange.entity.modifier.ScaleModifier;

import com.orange.entity.primitive.Rectangle;

import com.orange.entity.sprite.AnimatedSprite;

import com.orange.entity.sprite.ButtonSprite;

import com.orange.entity.sprite.ButtonSprite.OnClickListener;

import com.orange.entity.text.Text;

import com.orange.res.FontRes;

import com.orange.util.color.Color;

import com.orange.block.control.TimerTool;

import com.orange.block.res.Res;

import com.orange.block.scene.GameScene;

import com.orange.block.util.ConstantUtil;

import com.orange.block.util.SharedUtil;

/**

 * 失败界面

 *

 * @author lch

 *

 */

public class FailGroup extends EntityGroup {

    private GameScene mGameScene;

    private Rectangle bgRect;

    private AnimatedSprite titelSprite;

    private AnimatedSprite modelSprite;

    private ButtonSprite btn_back; // 返回按钮

    private ButtonSprite btn_again;// 重来按钮

    private Text txt_big;

    private Text txt_small;

    public FailGroup(float pWidth, float pHeight, GameScene pGameScene) {

        super(pWidth, pHeight, pGameScene);

        this.mGameScene = pGameScene;

        initView();

    }

    private void initView() {

        // 背景

        bgRect = new Rectangle(0, 0, this.getWidth(), this.getHeight(),

                this.getVertexBufferObjectManager());

        this.attachChild(bgRect);

        bgRect.setColor(Color.RED);

        // 标题 “别踩白块儿”

        titelSprite = new AnimatedSprite(0, 10, Res.GAME_TITEL,

                this.getVertexBufferObjectManager());

        titelSprite.setRightPositionX(this.getRightX() - 10);

        this.attachChild(titelSprite);

        // 模式 “经典模式”

        modelSprite = new AnimatedSprite(0, 150, Res.GAME_MODEL,

                this.getVertexBufferObjectManager());

        modelSprite.setCentrePositionX(this.getCentreX());

        this.attachChild(modelSprite);

        // 大字

        txt_big = new Text(0, modelSprite.getBottomY() + 130,

                FontRes.getFont(ConstantUtil.FONT_NAME_RESULT), "", 15,

                this.getVertexBufferObjectManager());

        this.attachChild(txt_big);

        txt_big.setScale(1.9f);

        // 小字

        txt_small = new Text(0, txt_big.getBottomY() + 30,

                FontRes.getFont(ConstantUtil.FONT_NAME_RESULT), "", 15,

                this.getVertexBufferObjectManager());

        this.attachChild(txt_small);

        txt_small.setScale(0.7f);

        // 返回按钮

        btn_back = new ButtonSprite(80, 0, Res.BTN_BACK,

                this.getVertexBufferObjectManager());

        btn_back.setBottomPositionY(this.getBottomY() - 50);

        btn_back.setIgnoreTouch(false);

        this.attachChild(btn_back);

        btn_back.setOnClickListener(onClickListener);

        // 重来按钮

        btn_again = new ButtonSprite(0, 0, Res.BTN_AGAIN,

                this.getVertexBufferObjectManager());

        btn_again.setRightPositionX(this.getRightX() - 80);

        btn_again.setBottomPositionY(this.getBottomY() - 50);

        btn_again.setIgnoreTouch(false);

        this.attachChild(btn_again);

        btn_again.setOnClickListener(onClickListener);

        resetView();

    }

    public void showView() {

        setBtnEnable(true);

        this.setVisible(true);

        updateBigTxt("失败了！");

        if (SharedUtil.getRecord(getActivity()) > 0) {

            TimerTool mTimerTool = mGameScene.getmTimerTool();

            updateSmallTxt("最佳: "

                    + mTimerTool.millisToTimer(SharedUtil

                            .getRecord(getActivity())));

        }

        ScaleModifier scaleModifier = new ScaleModifier(0.2f, 0.0f, 1.0f);

        this.registerEntityModifier(scaleModifier);

    }

    private void updateBigTxt(String pText) {

        txt_big.setText(pText);

        txt_big.setCentrePositionX(this.getCentreX());

    }

    private void updateSmallTxt(String pText) {

        txt_small.setText(pText);

        txt_small.setCentrePositionX(this.getCentreX());

    }

    private OnClickListener onClickListener = new OnClickListener() {

        @Override

        public void onClick(ButtonSprite pButtonSprite, float pTouchAreaLocalX,

                float pTouchAreaLocalY) {

            if (btn_back == pButtonSprite) {

                showDialog();

            } else if (btn_again == pButtonSprite) {

                resetView();

                mGameScene.resetGame();

            }

        }

    };

    private void resetView(){

        this.setScale(0);

        this.setVisible(false);

        setBtnEnable(false);

    }

    private void setBtnEnable(boolean isEnable) {

        btn_back.setEnabled(isEnable);

        btn_again.setEnabled(isEnable);

    }

    /**

     * 退出游戏确认对话框

     */

    private void showDialog() {

        getActivity().runOnUiThread(new Runnable() {

            @Override

            public void run() {

                new AlertDialog.Builder(getActivity())

                        .setTitle("退出游戏")

                        .setMessage("是否要退出游戏！")

                        .setPositiveButton("确定",

                                new DialogInterface.OnClickListener() {

                                    @Override

                                    public void onClick(DialogInterface dialog,

                                            int which) {

                                        getActivity().finish();

                                    }

                                }).setNegativeButton("取消", null).show();

            }

        });

    }

}

package com.orange.block.entity;

import android.app.AlertDialog;

import android.content.DialogInterface;

import com.orange.entity.group.EntityGroup;

import com.orange.entity.primitive.Rectangle;

import com.orange.entity.sprite.AnimatedSprite;

import com.orange.entity.sprite.ButtonSprite;

import com.orange.entity.sprite.ButtonSprite.OnClickListener;

import com.orange.entity.text.Text;

import com.orange.res.FontRes;

import com.orange.util.color.Color;

import com.orange.block.control.TimerTool;

import com.orange.block.res.Res;

import com.orange.block.scene.GameScene;

import com.orange.block.util.ConstantUtil;

import com.orange.block.util.SharedUtil;

/**

 * 成功界面

 *

 * @author lch

 *

 */

public class SuccGroup extends EntityGroup {

    private GameScene mGameScene;

    private Rectangle bgRect;

    private AnimatedSprite titelSprite;

    private AnimatedSprite modelSprite;

    private ButtonSprite btn_back; // 返回按钮

    private ButtonSprite btn_again;// 重来按钮

    private Text txt_big;

    private Text txt_small;

    public SuccGroup(float pWidth, float pHeight, GameScene pGameScene) {

        super(pWidth, pHeight, pGameScene);

        initView();

        this.mGameScene = pGameScene;

    }

    private void initView() {

        // 背景

        bgRect = new Rectangle(0, 0, this.getWidth(), this.getHeight(),

                this.getVertexBufferObjectManager());

        this.attachChild(bgRect);

        bgRect.setColor(Color.GREEN);

        // 标题 “别踩白块儿”

        titelSprite = new AnimatedSprite(0, 10, Res.GAME_TITEL,

                this.getVertexBufferObjectManager());

        titelSprite.setRightPositionX(this.getRightX() - 10);

        this.attachChild(titelSprite);

        titelSprite.setVisible(false);

        // 模式 “经典模式”

        modelSprite = new AnimatedSprite(0, 150, Res.GAME_MODEL,

                this.getVertexBufferObjectManager());

        modelSprite.setCentrePositionX(this.getCentreX());

        this.attachChild(modelSprite);

        modelSprite.setVisible(false);

        // 大字

        txt_big = new Text(0, modelSprite.getBottomY() + 100,

                FontRes.getFont(ConstantUtil.FONT_NAME_RESULT), "", 15,

                this.getVertexBufferObjectManager());

        this.attachChild(txt_big);

        txt_big.setScale(1.5f);

        txt_big.setVisible(false);

        // 小字

        txt_small = new Text(0, txt_big.getBottomY() + 10,

                FontRes.getFont(ConstantUtil.FONT_NAME_RESULT), "", 15,

                this.getVertexBufferObjectManager());

        this.attachChild(txt_small);

        txt_small.setScale(0.7f);

        txt_small.setVisible(false);

        // 返回按钮

        btn_back = new ButtonSprite(80, 0, Res.BTN_BACK,

                this.getVertexBufferObjectManager());

        btn_back.setBottomPositionY(this.getBottomY() - 50);

        btn_back.setIgnoreTouch(false);

        this.attachChild(btn_back);

        btn_back.setOnClickListener(onClickListener);

        btn_back.setVisible(false);

        // 重来按钮

        btn_again = new ButtonSprite(0, 0, Res.BTN_AGAIN,

                this.getVertexBufferObjectManager());

        btn_again.setRightPositionX(this.getRightX() - 80);

        btn_again.setBottomPositionY(this.getBottomY() - 50);

        btn_again.setIgnoreTouch(false);

        this.attachChild(btn_again);

        btn_again.setOnClickListener(onClickListener);

        btn_again.setVisible(false);

    }

    public void showItems(boolean pVisible) {

        titelSprite.setVisible(pVisible);

        modelSprite.setVisible(pVisible);

        txt_big.setVisible(pVisible);

        txt_small.setVisible(pVisible);

        btn_back.setVisible(pVisible);

        btn_again.setVisible(pVisible);

        if (pVisible) {

            TimerTool mTimerTool = mGameScene.getmTimerTool();

            updateBigTxt(mTimerTool.millisToTimer(mTimerTool

                    .getMillisPass()));

            long mMillisPass = mTimerTool.getMillisPass();

            if (mMillisPass < SharedUtil.getRecord(getActivity())

                    || SharedUtil.getRecord(getActivity()) == 0) {

                // 新记录

                updateSmallTxt("新记录");

                SharedUtil.setRecord(getActivity(), mMillisPass);

            } else {

                updateSmallTxt("最佳: "

                        + mTimerTool.millisToTimer(SharedUtil

                                .getRecord(getActivity())));

            }

        }

    }

    public void updateBigTxt(String pText) {

        txt_big.setText(pText);

        txt_big.setCentrePositionX(this.getCentreX());

    }

    public void updateSmallTxt(String pText) {

        txt_small.setText(pText);

        txt_small.setCentrePositionX(this.getCentreX());

    }

    private OnClickListener onClickListener = new OnClickListener() {

        @Override

        public void onClick(ButtonSprite pButtonSprite, float pTouchAreaLocalX,

                float pTouchAreaLocalY) {

            if (btn_back == pButtonSprite) {

                showDialog();

            } else if (btn_again == pButtonSprite) {

                mGameScene.resetGame();

            }

        }

    };

    /**

     * 退出游戏确认对话框

     */

    private void showDialog() {

        getActivity().runOnUiThread(new Runnable() {

            @Override

            public void run() {

                new AlertDialog.Builder(getActivity())

                        .setTitle("退出游戏")

                        .setMessage("是否要退出游戏！")

                        .setPositiveButton("确定",

                                new DialogInterface.OnClickListener() {

                                    @Override

                                    public void onClick(DialogInterface dialog,

                                            int which) {

                                        getActivity().finish();

                                    }

                                }).setNegativeButton("取消", null).show();

            }

        });

    }

}

贺邦：负责代码的调试与测试

blogs:http://www.cnblogs.com/L1nke/

codes:

 1 public class Test {

 2 private int fAmount;

 3 private String fCurrency;

 4

 5 public Test(int amount, String currency) {

 6 fAmount= amount;

 7 fCurrency= currency;

 8 }

 9

10 public int amount() {

11 return fAmount;

12 }

13

14 public String currency() {

15 return fCurrency;

16 }

17

18 public Test add(Test m) {

19 return new Test(amount()+m.amount(), currency());

20 }

21

22 public boolean equals(Object anObject) {

23 if (anObject instanceof Test) {

24 Test aMoney= (Test)anObject;

25 return aMoney.currency().equals(currency())

26 && amount() == aMoney.amount();

27 }

28 return false;

29 }

30 }

    }

    /**

     * 在Y轴方向上，由当前位置移动指定的距离

     *

     * @param entity

     *            要移动的实体

     * @param moveDistance

     *            需要移动的距离

     */

    private void moveToY(IEntity entity, float moveDistance) {

        float pFromY = entity.getY();

        float pToY = pFromY + moveDistance;

        entity.registerEntityModifier(new MoveYModifier(0.1f, pFromY, pToY));

    }

    @Override

    public boolean onKeyUp(int keyCode, KeyEvent event) {

        if (keyCode == KeyEvent.KEYCODE_BACK) {

            this.getActivity().finish();

            return true;

        }

        return false;

    }

    @Override

    public void onSceneResume() {

        super.onSceneResume();

        this.setIgnoreUpdate(false);

    }

    @Override

    public void onScenePause() {

        super.onScenePause();

        this.setIgnoreUpdate(true);

    }

    @Override

    public void onSceneDestroy() {

        super.onSceneDestroy();

        LogUtil.d("onSceneDestroy");

    }

    // ================================================================

    /**

     * 获取镜头的 右边 x 坐标

     */

    public float getCameraRightX() {

        return this.getCameraWidth();

    }

    /**

     * 获取镜头的 中点 x 坐标

     *

     * @return

     */

    public float getCameraCenterX() {

        return this.getCameraWidth() * 0.5f;

    }

    /**

     * 获取镜头底部Y坐标

     *

     * @return

     */

    public float getCameraBottomY() {

        return this.getCameraHeight();

    }

    /**

     * 获取镜头中心Y坐标

     *

     * @return

     */

    public float getCameraCenterY() {

        return this.getCameraHeight() * 0.5f;

    }

}

---恢复内容结束---

实验三 敏捷开发与XP实践（改）

标签：

原文地址：http://www.cnblogs.com/July0207/p/4553130.html