egret引擎生命周期相关_egret 页面生命周期

1.游戏开发生命周期

关于游戏开发中的生命周期相关的知识，参考一下：https://www.jianshu.com/p/ebc9e087676e

2.egret 2d引擎中的生命周期

对于egret 2D中的生命周期我们来了解一下：
(1)心跳
egret的 SystemTicker，是引擎的心跳计时器，egret通过SystemTicker来执行每一帧的eventLoop，渲染等操作。
保持游戏框架的运行。
pause():void 是暂停心跳的操作。
resume():void 是恢复心跳
update函数，egret在运行每帧是回调。
(2)计时器
egret.startTick(callBack: (timeStamp: number) => boolean, thisObject: any):void;
egret开启计时器的注册函数。
egret.stopTick(callBack: (timeStamp: number) => boolean, thisObject: any): void;
egret停止计时器函数。
在游戏中经常会出现有些对象随着时间的变化而变化的。一旦有这种需求，那么就需要用到计时器 来记录时间并且在合适的时间
里对物品的属性变化进行操作。
如果有大量的这类型的需求，那么我们应该集中来管理，那么就需要一个计时器回调函数管理器。
心跳管理器

/**
 * Timer管理器
 */
class TimerMgr extends BaseClass {
	private _handlers: Array<TimerHandler>;
	private _currTime: number;
	private _currFrame: number;
	private currHandler: TimerHandler = null;
	private nexthandles: Array<TimerHandler>;


	/**
	 * 构造函数
	 */
	public constructor() {
		super();
		this._handlers = [];
		this.nexthandles = null;

		this._currTime = egret.getTimer();
		this._currFrame = 0;

		egret.startTick(this.onEnterFrame, this);
	}

	public static ins(): TimerMgr {
		return super.ins() as TimerMgr;
	}

	public getFrameId(): number {
		return this._currFrame;
	}

	public getCurrTime(): number {
		return this._currTime;
	}

	// 从大到小排序
	public static binFunc(b1: TimerHandler, b2: TimerHandler): number {
		if (b1.exeTime > b2.exeTime) return -1;
		else if (b1.exeTime < b2.exeTime) return 1;
		else return 0;
	}

	private static DeleteHandle(handler: TimerHandler) {
		handler.clear();
		ObjPool.push(handler);
	}

	/**
	 * 每帧执行函数
	 * @param frameTime
	 */
	private onEnterFrame(time: number): boolean {
		this._currFrame++;
		this._currTime = egret.getTimer();
		let currTime: number = 0;

		// process the nextlist first
		let nexthandles = this.nexthandles;
		this.nexthandles = null;
		if (nexthandles && nexthandles.length > 0) {
			for (let handler of nexthandles) {
				handler.method.call(handler.methodObj);
				TimerMgr.DeleteHandle(handler);
			}

			nexthandles = null;
		}

		if (this._handlers.length <= 0) return false;

		let handler = this._handlers[this._handlers.length - 1];
		while (handler.exeTime <= this._currTime) {
			this.currHandler = handler = this._handlers.pop();
			let times = (this._currTime - handler.exeTime) / handler.delay;
			if (times > 1) {
				handler.method.call(handler.methodObj, times);
			} else {
				handler.method.call(handler.methodObj);
			}
			currTime = egret.getTimer();
			handler.exeTime = currTime + handler.delay;
			let repeat: boolean = handler.forever;
			if (!repeat) {
				if (handler.repeatCount > 1) {
					handler.repeatCount--;
					repeat = true;
				} else {
					if (handler.onFinish) {
						handler.onFinish.apply(handler.finishObj);
					}
				}
			}

			if (repeat) {
				let index = Algorithm.binSearch(this._handlers, handler, TimerMgr.binFunc);
				this._handlers.splice(index, 0, handler);
			}
			else {
				TimerMgr.DeleteHandle(handler);
			}

			if (currTime - this._currTime > 5) break;

			if (this._handlers.length <= 0) break;
			else handler = this._handlers[this._handlers.length - 1];
		}
		this.currHandler = null;

		return false;
	}

	private create(startTime: number, delay: number, repeat: number, method: Function, methodObj: any,
		onFinish: Function, fobj: any, remove: boolean = false): void {
		if (delay < 0 || repeat < 0 || method == null) {
			return;
		}

		let handler: TimerHandler = ObjPool.pop("TimerHandler");
		handler.forever = repeat == 0;
		handler.repeatCount = repeat;
		handler.delay = delay;
		handler.method = method;
		handler.methodObj = methodObj;
		handler.onFinish = onFinish;
		handler.finishObj = fobj;
		handler.exeTime = startTime + this._currTime;
		// this._handlers.push(handler);

		let index = Algorithm.binSearch(this._handlers, handler, TimerMgr.binFunc);
		this._handlers.splice(index, 0, handler);
	}

	/**
	 *
	 * 定时执行
	 * @param delay 执行间隔:毫秒
	 * @param repeat 执行次数, 0为无限次
	 * @param method 执行函数
	 * @param methodObj 执行函数所属对象
	 * @param onFinish 完成执行函数
	 * @param fobj 完成执行函数所属对象
	 * @param remove 是否删除已经存在的
	 *
	 */
	public doTimer(delay: number, repeat: number, method: Function, methodObj: any
		, onFinish: Function = null, fobj: any = null, remove: boolean = false): void {
		this.create(delay, delay, repeat, method, methodObj, onFinish, fobj, remove);
	}

	/**
	 *
	 * 定时执行
	 * @param startTime 延迟多久第一次执行
	 * @param delay 执行间隔:毫秒
	 * @param repeat 执行次数, 0为无限次
	 * @param method 执行函数
	 * @param methodObj 执行函数所属对象
	 * @param onFinish 完成执行函数
	 * @param fobj 完成执行函数所属对象
	 * @param remove 是否删除已经存在的
	 *
	 */
	public doTimerDelay(startTime: number, delay: number, repeat: number, method: Function, methodObj: any
		, onFinish: Function = null, fobj: any = null): void {
		this.create(startTime, delay, repeat, method, methodObj, onFinish, fobj);
	}

	/** 下一帧执行，且只执行一次*/
	public doNext(method: Function, methodObj: any) {
		let handler: TimerHandler = ObjPool.pop("TimerHandler");
		handler.method = method;
		handler.methodObj = methodObj;

		if (!this.nexthandles)
			this.nexthandles = [];
		this.nexthandles.push(handler);
	}

	/**
	 * 清理
	 * @param method 要移除的函数
	 * @param methodObj 要移除的函数对应的对象
	 */
	public remove(method: Function, methodObj: any): void {
		let currHandler = this.currHandler;
		if (currHandler && currHandler.method == method &&
			currHandler.methodObj == methodObj) {
			currHandler.forever = false;
			currHandler.repeatCount = 0;
		}

		for (let i = this._handlers.length - 1; i >= 0; i--) {
			let handler = this._handlers[i];
			if (handler.method == method && handler.methodObj == methodObj) {
				this._handlers.splice(i, 1);
				TimerMgr.DeleteHandle(handler);
			}
		}
	}

	/**
	 * 清理
	 * @param methodObj 要移除的函数对应的对象
	 */
	public removeAll(methodObj: any): void {
		let currHandler = this.currHandler;
		if (currHandler && currHandler.methodObj == methodObj) {
			currHandler.forever = false;
			currHandler.repeatCount = 0;
		}

		for (let i = this._handlers.length - 1; i >= 0; i--) {
			let handler = this._handlers[i];
			if (handler.methodObj == methodObj) {
				this._handlers.splice(i, 1);
				TimerMgr.DeleteHandle(handler);
			}
		}
	}

	/**
	 * 检测是否已经存在
	 * @param method
	 * @param methodObj
	 *
	 */
	public isExists(method: Function, methodObj: any): boolean {
		for (let handler of this._handlers) {
			if (handler.method == method && handler.methodObj == methodObj) {
				return true;
			}
		}
		return false;
	}
}


class TimerHandler {
	/**执行间隔*/
	public delay: number = 0;
	/**是否重复执行*/
	public forever: boolean = false;
	/**重复执行次数*/
	public repeatCount: number = 0;
	/**执行时间*/
	public exeTime: number = 0;
	/**处理函数*/
	public method: Function;
	/**处理函数所属对象*/
	public methodObj: any;
	/**完成处理函数*/
	public onFinish: Function;
	/**完成处理函数所属对象*/
	public finishObj: any;

	/**清理*/
	public clear(): void {
		this.method = null;
		this.methodObj = null;
		this.onFinish = null;
		this.finishObj = null;
		this.forever = false;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266

(3)帧事件
帧事件是egret 每一帧都发出的一个基础事件类型。
帧事件的是生命周期的体现，相当于unity的updata函数。
帧事件的监听，继承自DisplayObject

this.addEventListener(egret.Event.ENTER_FRAME，this.onUpdata，this);
1

移除

this.removeEventListener(egret.Event.ENTER_FRAME，this.onUpdata，this);
1