"别踩白块儿"游戏源代码分析和下载(二)

四、游戏交互实现

1、前面已经介绍在 Block 类实现了每个block的触碰监听，block 实现触碰监听，当按下时，调起在GameScene中实现的touchBlock方法。下面来看改方法的实.

1.         /**
   

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

3.          * 
   

4.          * @param pBlock
   

5.          *            所点击的block
   

6.          */
   

7.         public void touchBlock(Block pBlock) {
   

8. 
   

9.                 if (gameStatus == ConstantUtil.GAME_START) {
   

10. 
    

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

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

13.                                 upBlockTouch(pBlock);
    

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

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

16.                                         if (linesLength == moveNum + 2) {
    

17.                                                 // 游戏胜利
    

18.                                                 gameSucc(pBlock);
    

19.                                         } else {
    

20.                                                 // 整体blocks下移
    

21.                                                 moveDown(pBlock, 1);
    

22.                                         }
    

23. 
    

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

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

26.                                         gameFail();
    

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

28.                                         LoopEntityModifier loop = failAction();
    

29.                                         // 播放效果
    

30.                                         pBlock.registerEntityModifier(loop);
    

31.                                 }
    

32. 
    

33.                         }
    

34. 
    

35.                 }
    

36. 
    

37.         }

复制代码

上面的代码已经有所注释，这里再简单解析一下。

①理论上可以点击的一行为倒数第二行，如果点击到该行的黑块，则所有block向下移动一格，如果点击到该行的白块，则游戏失败，弹出失败界面。

②为了体验上的优化，如果点击到倒数第二行黑块所在列正对上的一个block(不管是黑块还是白块)也视为正确点击了黑块。因为在快速点击黑块的同时整体的block也迅速向下移动，很容易点击到上一格，此时我们认为这也是正确的点。

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

1. /**
   

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

3.          * 
   

4.          * @param pBlock
   

5.          *            所被点击的块
   

6.          */
   

7.         private void upBlockTouch(Block pBlock) {
   

8.                 int touchColumn = pBlock.getColumn();
   

9.                 for (Block[] blocks : blockList) {
   

10.                         for (Block block : blocks) {
    

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

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

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

14.                                                 // 整体blocks下移
    

15.                                                 moveDown(block, 1);
    

16.                                         }
    

17.                                         return;
    

18.                                 }
    

19.                         }
    

20. 
    

21.                 }
    

22.         }

复制代码

3、方块下移等相关逻辑moveDown方法的实现。

1. // 正确点击该点击的黑块，或者上一行的块，整体向下移动、创建新的一样块，改变黑块        private void moveDown(Block pBlock, int stepNum) {
   

2.                 if(moveNum == 0){
   

3.                         // 开始计时
   

4.                         mTimerTool.start();
   

5.                         // 隐藏提示文字
   

6.                         game_tip.setVisible(false);
   

7.                 }
   

8.                 if (moveNum < ConstantUtil.LINES_LEN) {
   

9.                         // 创建添加新的一行
   

10.                         createNewRowBolcks();
    

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

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

13.                         showSuccGroup();
    

14.                 }
    

15.                 // 被点击的黑块变灰
    

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

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

18.                 // 移动步数加1
    

19.                 moveNum++;
    

20.                 // 需要移动的距离
    

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

22.                                 - pBlock.getY();
    

23.                 for (Block[] rowBlocks : blockList) {
    

24.                         for (Block block : rowBlocks) {
    

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

26.                                 moveToY(block, moveDistance);
    

27.                         }
    

28.                 }
    

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

30.                 if (mSuccGroup.isVisible()) {
    

31.                         moveToY(mSuccGroup, moveDistance);
    

32.                 }
    

33.         }

复制代码

①moveNum用来记录移动了多少步，第一次开始下移时，我们开始计时以及隐藏下边的提示文字。

②如果还没有达到预设的总行数就创建添加新的一行blocks，如果到了则开始显示绿色胜利界面。

③被点击的黑块变灰色，加点小小的动作效果。

④计算出需要向下移动的距离，遍历所有blocks，向下移动指定距离。

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

4、创建添加新的一行createNewRowBolcks()方法的实现。

1. //创建添加新的一行
   

2.         private void createNewRowBolcks() {
   

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

4.                 if (blockList.size() > 5) {
   

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

6.                         for (Block block : rowBolcks) {
   

7.                                 block.detachSelf();
   

8.                         }
   

9.                         blockList.remove(0);
   

10.                 }
    

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

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

13.                 // 一行块
    

14.                 Block[] rowBolcks = new Block[4];
    

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

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

17.                         // 新创建 Block
    

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

19.                                         blackIndex, getVertexBufferObjectManager());
    

20.                         // 设置Y坐标
    

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

22.                         // 设置已经是第几行
    

23.                         rowBolcks[column].setRow(linesLength);
    

24.                         this.attachChild(rowBolcks[column]);
    

25.                 }
    

26.                 blockList.add(rowBolcks);
    

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

28.                 this.sortChildren();
    

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

30.                 linesLength++;
    

31.         }

复制代码

① 先把超出屏幕没用的部分移除掉，把新增的一行blocks的位置设在最顶端，设置已经是第几行。

  

5、游戏成功或者游戏失败

1.     /**
   

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

3.          * 
   

4.          * @param pBlock
   

5.          */
   

6.         private void gameSucc(Block pBlock) {
   

7.                 gameStatus = ConstantUtil.GAME_OVER;
   

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

9.                 moveDown(pBlock, 0);
   

10.                 // 停止计时
    

11.                 mTimerTool.stop();
    

12.                 // 显示游戏胜利画面
    

13.                 mSuccGroup.showItems(true);
    

14.                 // 隐藏显示时间的Text
    

15.                 timerText.setVisible(false);
    

16.         }
    

17. 
    

18.         /**
    

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

20.          */
    

21.         private void gameFail() {
    

22.                 gameStatus = ConstantUtil.GAME_OVER;
    

23.                 // 游戏失败，停止计时
    

24.                 mTimerTool.stop();
    

25.                 // 隐藏显示时间的Text
    

26.                 timerText.setVisible(false);
    

27.         }

复制代码

五、计时控制类TimerTool 的实现。

我们知道游戏一开始就会有时间的计时，完成指定任务后，时间越短越厉害，玩家通过不断刷新记录来提高对游戏的成就感，所以计时、显示历史最佳记录必不可少。下面我们就来看看如何实现计时。

我们使用OGEngine引擎中的TimerHandler来实现计时，我们先来了解一下TimerHandler。从源码我们发现它实现IUpdateHandler接口。

1. public class TimerHandler implements IUpdateHandler{

复制代码

再来看一下它的构造器

1. /**
   

2.          * @param pTimerSeconds 经过多少秒后执行 pTimerCallback 中的回调
   

3.          * @param pAutoReset 是否循环执行
   

4.          * @param pTimerCallback 回调函数
   

5.          */
   

6.         public TimerHandler(final float pTimerSeconds, final boolean pAutoReset, final ITimerCallback pTimerCallback) {
   

7.                 if(pTimerSeconds <= 0){
   

8.                         throw new IllegalStateException("pTimerSeconds must be > 0!");
   

9.                 }
   

10. 
    

11.                 this.mTimerSeconds = pTimerSeconds;
    

12.                 this.mAutoReset = pAutoReset;
    

13.                 this.mTimerCallback = pTimerCallback;
    

14.         }

复制代码

下面来看TimerTool 的具体实现。

①所定义的成员变量，构造器实现。

1. public class TimerTool {
   

2.         private GameScene mGameScene;
   

3.         private TimerHandler mTimerHandler;
   

4.         /**当前经过的总毫秒数**/
   

5.         private long millisPass = 0;
   

6.         /**是否计时中**/
   

7.         private boolean isCountDowning = false;
   

8.         /**多少毫秒累加一次计时**/
   

9.         private static long stepMillis = 83;
   

10.         public TimerTool(GameScene pGameScene) {
    

11.                 this.mGameScene = pGameScene;
    

12.                 initTimerHandler();
    

13.         }
    

14. 
    

复制代码

②初始化TimerHandler

1. // 初始化TimerHandler,设置为每隔stepMillis * 0.001f秒循环回调onTimePassed方法
   

2.         private void initTimerHandler() {
   

3.                 mTimerHandler = new TimerHandler(stepMillis * 0.001f, true,
   

4.                                 new ITimerCallback() {
   

5.                                         @Override
   

6.                                         public void onTimePassed(TimerHandler pTimerHandler) {
   

7.                                                 // 累加所经过的时间，并在界面上更新显示当前时间
   

8.                                                 addMillisPass();
   

9.                                         }
   

10.                                 });
    

11.         }
    

12. 
    

复制代码

③相关时间的逻辑实现

1. // 重置时间
   

2.         public void resetTimer() {
   

3.                 millisPass = 0;
   

4.                 isCountDowning = false;
   

5.         }
   

6.         // 累加所经过的时间，并在界面上更新显示当前时间
   

7.         private void addMillisPass() {
   

8.                 millisPass += stepMillis;
   

9.                 mGameScene.getTimerText().setText(millisToTimer(millisPass));
   

10.         }
    

11.         // 获取当前经过的总毫秒数
    

12.         public long getMillisPass() {
    

13.                 return millisPass;
    

14.         }
    

15.         // 把毫秒转化为一种分、秒、毫秒的文本显示模式字符串
    

16.         public String millisToTimer(long pMillisPass) {
    

17.                 String timer = "";
    

18.                 long min = pMillisPass / 60000;
    

19.                 long sec = (pMillisPass - min * 60000) / 1000;
    

20.                 String secStr = sec < 10 ? "0" + sec : String.valueOf(sec);
    

21.                 long millisec = pMillisPass % 1000;
    

22. 
    

23.                 if (min > 0) {
    

24.                         timer += min + ":";
    

25.                 }
    

26.                 timer += secStr + "." + millisec + "\"";
    

27.                 return timer;
    

28.         }
    

29.        

复制代码

④开始计时和结束计时

1. // 注册mTimerHandler开始计时
   

2.         public void start() {
   

3.                 if (!isCountDowning) {
   

4.                         isCountDowning = true;
   

5.                         mGameScene.registerUpdateHandler(mTimerHandler);
   

6.                 }
   

7.         }
   

8.         // 反注册mTimerHandler停止计时
   

9.         public void stop() {
   

10.                 mGameScene.unregisterUpdateHandler(mTimerHandler);
    

11.         }
    

12. 
    

复制代码

在正确点击第一块黑块的时候开始计时，游戏失败或者游戏完成时停止计时，保存好记录的时间，在胜利界面或失败界面根据实际情况实现所用时间跟最佳记录的显示。

本游戏就介绍到这里，更多细节请看游戏源码。。。。。。

源码下载地址

 http://www.eoeandroid.com/forum-863-1.html

www.ogengine.com