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

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

一、敏捷开发与XP

二、编码标准

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

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

• 要体现各自的含义
• 包、类、变量用名词
• 方法名用动宾
• 包名全部小写，如：io，awt
• 类名第一个字母要大写，如：HelloWorldApp
• 变量名第一个字母要小写，如：userName
• 方法名第一个字母要小写：setName

三、重构

重构(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 }

步骤	耗时	百分比
需求分析	20min	3.8%
设计	50min	9.6%
代码实现	300min	57.7%
测试	120min	23.1%
分析总结	30min	5.8%

}

/**

* 在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;

}

}

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