AndEngine引擎运行原理

通过对于一般游戏的逻辑原理的分析，以及对AndEngine源码的阅读，总算是对游戏的一般架构以及AndEngine是如何实现这一架构的原理有了一定的了解，总结一下备忘！

一般的游戏主逻辑：（在游戏的主线程中）

[java]  view plain copy

1. <span style="font-size:16px;">while (true)  
2. {  
3.     用户交互监听（用户输入）  
4.     逻辑运算  
5.     绘制屏幕  
6. }</span>  

如果简单的写成这样会有一个很严重的问题，就是在不同配置的机器上游戏运行的效果不一样，因为线程是在一直不停的运行的，而不同的CPU会影响到逻辑的运算，而不同的GPU又会影响其绘制效率，所以就是，在不同的配置的机器上在一定的时间内，循环运行的次数是不一样的，假设一个精灵会在一帧中走10px，不同机器上每秒跑10帧和跑100帧，那么精灵就会出现在不同的机器上在相同的时间内移动的距离是不同的！这是很严重的！所以，主逻辑有了下面的改进，

[java]  view plain copy

1. <span style="font-size:16px;">while (true)  
2. {  
3.         startTime = currentTime;  
4.         用户输入监听  
5.         逻辑运算  
6.         endTime = currentTime;  
7.               
8.         deltaTime = endTime - startTime;  
9.         if (deltaTime < FRAME_LENGTH_PER_SECOND)  
10.         {  
11.             sleep(deltaTime);  
12.         }  
13.               
14.         绘制屏幕  
15. }</span>  

注意currentTime是获取的系统当前时间，deltaTime即用于用户输入监听，逻辑运算的时间，而FRAME_LENGTH_PER_SECOND这个值很重要，这是我们希望每帧用的时间（当然是毫秒级的，即 每秒 / 我们希望游戏在不同的机器上每秒都运行的帧数上限制，比如我们希望游戏在所有的机器上都保持在30帧以内，则FRAME_LENGTH_PER_SECOND=1000 / 30 = 33ms（毫秒）），当然我们是认为绘制屏幕过程很快的，如果使用双缓冲的话，在逻辑运算部分就已经将要绘制的内容绘制到缓冲区了，而绘制屏幕的过程则相当于缓冲区到屏幕的一个拷贝，过程会非常快！

帅帅的分割线===============================================================================================

下面就要来介绍一下AndEngine是来如何实现这个主线程死循环的！

在Engine类中有一个内部类UpdateThread类，

[java]  view plain copy

1. <span style="font-size:16px;">  private class UpdateThread extends Thread  
2.     {  
3.         // ===========================================================  
4.         // Constants  
5.         // ===========================================================  
6.   
7.         // ===========================================================  
8.         // Fields  
9.         // ===========================================================  
10.   
11.         // ===========================================================  
12.         // Constructors  
13.         // ===========================================================  
14.   
15.         public UpdateThread()  
16.         {  
17.             super(UpdateThread.class.getSimpleName());  
18.         }  
19.   
20.         // ===========================================================  
21.         // Getter & Setter  
22.         // ===========================================================  
23.   
24.         // ===========================================================  
25.         // Methods for/from SuperClass/Interfaces  
26.         // ===========================================================  
27.   
28.         @Override  
29.         public void run()  
30.         {  
31.             android.os.Process.setThreadPriority(Engine.this.mEngineOptions.getUpdateThreadPriority());  
32.             try  
33.             {  
34.                 while (true)  
35.                 {  
36.                     Engine.this.onTickUpdate();  
37.                 }  
38.             }  
39.             catch (final InterruptedException e)  
40.             {  
41.                 Debug.d(this.getClass().getSimpleName() + " interrupted. Don't worry - this "  
42.                         + e.getClass().getSimpleName() + " is most likely expected!", e);  
43.                 this.interrupt();  
44.             }  
45.         }  
46.   
47.         // ===========================================================  
48.         // Methods  
49.         // ===========================================================  
50.   
51.         // ===========================================================  
52.         // Inner and Anonymous Classes  
53.         // ===========================================================  
54.     }</span>  

看到了吧，在其run()方法中，就是这个游戏的主循环，而这个主线程是在Engine的构造方法中启动的（可以看代码）

问题来了，这只是实现的我们一般游戏的引擎，是有不同配置机器运行效率不同的问题的，当然我们可以靠TimerHandler来大概控制，可是却不是可靠的，那么我们想要的控制帧数的引擎该怎么做呢？其实AndEngine已经为我们实现了，即 LimitedFPSEngine类，从名字上看，这个类实现的功能就是和我们想要的控制帧数是一样的！下面是LimitedFPSEngine类中的onUpdate方法，源码已经很认真的解释了控制帧数的原理，

[java]  view plain copy

1. <span style="font-size:16px;">@Override  
2.     public void onUpdate(final long pNanosecondsElapsed) throws InterruptedException  
3.     {  
4.         final long preferredFrameLengthNanoseconds = this.mPreferredFrameLengthNanoseconds;  
5.         final long deltaFrameLengthNanoseconds = preferredFrameLengthNanoseconds - pNanosecondsElapsed;  
6.   
7.         if (deltaFrameLengthNanoseconds <= 0)  
8.         {  
9.             super.onUpdate(pNanosecondsElapsed);  
10.         }  
11.         else  
12.         {  
13.             final int sleepTimeMilliseconds = (int) (deltaFrameLengthNanoseconds / NANOSECONDS_PER_MILLISECOND);  
14.   
15.             Thread.sleep(sleepTimeMilliseconds);  
16.             super.onUpdate(pNanosecondsElapsed + deltaFrameLengthNanoseconds);  
17.         }  
18.     }</span>  

LimitedFPSEngine是Engine的子类，在其onUpdate方法中，也会调用父类(Engine)的onUpdate方法，而Engine的onupdate方法就做了我们每帧需要的一些运算(Scene的更新是递归的噢)

这篇内容主要记录一下AndEngine的运行原理，下一篇将会记录一下AndEngine与我们的Android游戏的一些粘合点

不是大神，难免有疏漏，各位如果认为我在哪总结有不妥之处，敬请拍砖！谢谢！

原文地址：http://blog.csdn.net/onerain88/article/details/7265926

最近也在学习AndEngine共同学习，备忘。