关于提高webgame地图加载速度技术解决方案.docx
《关于提高webgame地图加载速度技术解决方案.docx》由会员分享，可在线阅读，更多相关《关于提高webgame地图加载速度技术解决方案.docx（11页珍藏版）》请在冰豆网上搜索。
关于提高webgame地图加载速度技术解决方案
关于提高加载速度技术解决方案
1、将包含多个子文件的Flash分解成A、B、C等多个小文件加载
A、导航拆成一级导航和二级地图导航
B、场景边框和聊天菜单分开加载
C、场景内一些元素作为情景物品分层加载，如树木、云朵、小动画
2、将大场景进行分割，分段加载。
如旺铺街，如果以后店铺数目过多时应分成几段加载，此方法的缺点是人物行走感官上出现不连贯
3、永久缓存
浏览器具有缓存功能，可以把Web应用的一部分保存在内存当中。
这样，同一Web应用的不同的浏览器页面就可以共享内存中的内容，而不必从服务器端多次下载这些相同的内容。
但随着浏览器窗口的关闭而被清除。
因此，我们也可以称浏览器缓存为临时缓存。
当你下次访问相同Web应用的时候，你仍然需要下载曾经的缓存内容。
Flex3提供了永久缓存的功能：
通过在编译Flex程序的时候把FlexFramework和程序的公共部分指定为RSL（RuntimeSharedLibrary），就能够达到永久缓存的效果。
此方法需要研究FlashPlayer的内部机制。
4、服务器硬件扩展
提高本身服务器的硬件资源和带宽资源，以解决高用户的请求
5、改善加载进度条的友好程度，改善加载上的时间体验
6、开启硬件加速，最新的FlashPlayer已经支持硬件加速功能，但是支持GPU计算开启硬件加速的机器仍不是主流，可在帮助中提示用户可以开启硬件加速
7、过滤不需要的功能
8、研发浏览器插件，使用C++等语言进行专属插件，工作量较大
9、flash地图图片分块加载
将地图场景进行程序上的分块，片要在可见区域里需要显示它的时候，才加载，实现分批加载。
本方法需要对程序进行大幅改动，需在二期时执行
附：
解决方法例子
图首先我们确定几个关键点：
窗口大小：
windowW:
Number,windowH:
Number;指的是可视区域的大小我们可以把他想成客户端的分别率
单位地图大小：
uintPicW：
Number，uintPicH：
Number;指的是你切割的地图图片的单元大小。
当前地图坐标：
position：
point;这里大家就可以想成是你人物的当前所处坐标
我们可以很容易的求出窗口的4个点，所占的地图的索引：
x0=position.x-windowW/2;
x1=position.x+windowW/2;
y0=position.y-windowH/2;
y1=position.y+windowH/2;
mapIndexX0=uint（x0/256）;
mapIndexX1=uint（x1/256）;
mapIndexY0=uint（y0/256）;
mapIndexY1=uint（y1/256）;
源码:
1.
2.packagecom.heptaFmon.game.map.layers
3.{
4.importcom.heptaFmon.config.Config;
5.importcom.heptaFmon.core.BaseDisplayObject;
6.importcom.heptaFmon.game.map.impl.GameMap;
7.importcom.heptaFmon.hack.HeptaFishGC;
8.importcom.heptaFmon.loader.impl.ImageLoader;
9.importcom.heptaFmon.map.impl.HashMap;
10.
11.importflash.display.Bitmap;
12.importflash.events.Event;
13.importflash.events.IOErrorEvent;
14.importflash.events.ProgressEvent;
15.importflash.geom.Point;
16.//地图层图片
17.publicclassMapLayerextendsBaseDisplayObject
18.{
19. //图片读取器
20. privatevar_imageLoader:
ImageLoader;
21. //地图图片用于整块加载模式
22. privatevar_image:
Bitmap;
23. //地图图片数组用于栅格式加载地图模式
24. privatevar_imageMap:
HashMap;
25. //小地图图片
26. privatevar_simage:
Bitmap;
27. //
28. privatevar_map:
GameMap;
29. privatevar_loadType:
int;//加载类型0：
整块加载1：
栅格加载
30. privatevar_visualWidth:
Number;//地图可视宽度
31. privatevar_visualHeight:
Number;//地图可视高度
32. privatevar_sliceWidth:
Number;//地图切割单元宽度
33. privatevar_sliceHeight:
Number;//地图切割单元高度
34. privatevar_preloadX:
Number;//横向预加载屏数
35. privatevar_preloadY:
Number;//纵向预加载屏数
36. privatevar_loadingMap:
HashMap;//正在加载的屏map
37. privatevar_waitLoadingArr:
Array;//等待加载的loadermap
38.
39. privatevar_loadingNo:
int=Config.getInt（"concurrencyImageLoader"）;
40.
41. privatevar_screenImageRow:
int;//一屏需要加载的横向图片数
42. privatevar_screenImageCol:
int;//一屏需要加载的纵向图片数
43. privatevar_row:
int;//总横向节点数
44. privatevar_col:
int;//总纵向节点数
45.
46. privatevar_nowPlayerPointoint;//当前人物所处的屏
47.
48. publicfunctionMapLayer（map:
GameMap）
49. {
50. _map=map;
51. _loadType=parseInt（_map.mapXML.@loadType）;
52. }
53. //读取地图图片
54. publicfunctionload（）:
void{
55. //加载小地图
56. varimageLoader:
ImageLoader=newImageLoader（）;
57. varfileName:
String=Config.getValue（"mapLib"）+_map.name+"/map_s.jpg";
58. imageLoader.load（fileName）;
59. imageLoader.addEventListener（Event.COMPLETE,loadSmallSuccess）;
60. imageLoader.addEventListener（ProgressEvent.PROGRESS,loadingHandler）;
61. imageLoader.addEventListener（IOErrorEvent.IO_ERROR,ioErrorHandler）;
62.
63. }
64. //读取大地图成功
65. privatefunctionloadBigSuccess（evet:
Event）:
void{
66. varimageLoader:
ImageLoader=ImageLoader（evet.target）;
67. varimage:
Bitmap=newBitmap（imageLoader._data）;
68. addChild（image）;
69. if（_simage!
=null&&_simage.parent==this）{
70. removeChild（_simage）;
71. _simage=null;
72. }
73. this.width=image.width;
74. this.height=image.height;
75. imageLoader.removeEventListener（Event.COMPLETE,loadBigSuccess）;
76. imageLoader.removeEventListener（ProgressEvent.PROGRESS,loadingHandler）;
77. imageLoader.removeEventListener（IOErrorEvent.IO_ERROR,ioErrorHandler）;
78. imageLoader=null;
79. dispatchEvent（evet）;
80. HeptaFishGC.gc（）;
81. }
82. //读取小地图成功
83. privatefunctionloadSmallSuccess（evet:
Event）:
void{
84. varimageLoader:
ImageLoader=ImageLoader（evet.target）;
85. varimage:
Bitmap=newBitmap（imageLoader._data）;
86. image.width=_map.mapWidth;
87. image.height=_map.mapHeight;
88. addChild（image）;
89. this.width=image.width;
90. this.height=image.height;
91. imageLoader.removeEventListener（Event.COMPLETE,loadSmallSuccess）;
92. imageLoader.removeEventListener（ProgressEvent.PROGRESS,loadingHandler）;
93. imageLoader.removeEventListener（IOErrorEvent.IO_ERROR,ioErrorHandler）;
94. imageLoader=null;
95. dispatchEvent（evet）;
96. HeptaFishGC.gc（）;
97. switch（_loadType）{
98. case0:
//整块加载
99. //加载大地图
100. varbfileName:
String=Config.getValue（"mapLib"）+_map.name+"/map.jpg";
101. varbLoader:
ImageLoader=newImageLoader（）;
102. bLoader.load（bfileName）;
103. bLoader.addEventListener（Event.COMPLETE,loadBigSuccess）;
104. bLoader.addEventListener（ProgressEvent.PROGRESS,loadingHandler）;
105. bLoader.addEventListener（IOErrorEvent.IO_ERROR,ioErrorHandler）;
106. break;
107. case1:
108. _loadingMap=newHashMap（）;
109. _imageMap=newHashMap（）;
110. _waitLoadingArr=newArray（）;
111. _visualWidth=_map.app.screen.size.x;
112. _visualHeight=_map.app.screen.size.y;
113. _sliceWidth=parseFloat（_map.mapXML.@sliceWidth）;
114. _sliceHeight=parseFloat（_map.mapXML.@sliceHeight）;
115. _preloadX=parseFloat（_map.mapXML.@preloadX）;
116. _preloadY=parseFloat（_map.mapXML.@preloadY）;
117. _screenImageRow=Math.round（_visualWidth/_sliceWidth）;
118. _screenImageCol=Math.round（_visualHeight/_sliceHeight）;
119. _row=Math.ceil（_map.mapWidth/_sliceWidth）;
120. _col=Math.ceil（_map.mapHeight/_sliceHeight）;
121. loadSliceImage（_map.initPlayerPoint）;
122. break;
123. default:
124. break;
125.
126. }
127. }
128.
129. //根据player坐标读取周边指定屏数地图
130. privatefunctionloadSliceImage（playerPointoint）:
void{
131. varnowX:
int=Math.floor（playerPoint.x/_sliceWidth）;//现在所处的索引X
132. varnowY:
int=Math.floor（playerPoint.y/_sliceHeight）;//现在所处的索引Y
133. varnowScreenX:
int=Math.floor（nowX/_screenImageRow）;//现在所处的屏索引X
134. varnowScreenY:
int=Math.floor（nowY/_screenImageCol）;//现在所处的屏索引Y
135.// trace（"nowScreenX:
"+nowScreenX）;
136.// trace（"nowScreenY:
"+nowScreenY）;
137. _nowPlayerPoint=newPoint（nowScreenX,nowScreenY）;
138. loadScreenImage（nowScreenX,nowScreenY）;
139.// removeScreenImage（nowScreenX,nowScreenY）;
140. varstartX:
int=（nowScreenX-_preloadX<0?
0:
nowScreenX-_preloadX）;
141. varstartY:
int=（nowScreenY-_preloadY<0?
0:
nowScreenY-_preloadY）;
142.
143. varendX:
int=（nowScreenX+_preloadX>_row?
_row:
nowScreenX+_preloadX）;
144. varendY:
int=（nowScreenY+_preloadY>_col?
_col:
nowScreenY+_preloadY）;
145.
146. for（varxx:
int=startX;xx147. for（varyy:
int=startY;yy148. if（xx==nowScreenX&&yy==nowScreenY）{
149. continue;
150. }else{
151. loadScreenImage（xx,yy）;
152. }
153. }
154. }
155. }
156. //加载指定屏的地图图片
157. privatefunctionloadScreenImage（screenX:
int,screenY:
int）:
void{
158. varstarX:
int=_screenImageRow*screenX<0?
0:
_screenImageRow*screenX;
159. varstarY:
int=_screenImageCol*screenY<0?
0:
_screenImageCol*screenY;
160. varendX:
int=_screenImageRow*（screenX+1）>_row-1?
_row-1:
_screenImageRow*（screenX+1）;
161. varendY:
int=_screenImageCol*（screenY+1）>_col-1 ?
_col-1:
_screenImageCol*（screenY+1）;
162. for（varyy:
int=starY;yy163. for（varxx:
int=starX;xx164. vartempKey:
String=yy+"_"+xx;
165. if（!
_loadingMap.containsValue（tempKey）&&!
_imageMap.containsKey（tempKey））{
166. _waitLoadingArr.push（tempKey）;
167. }
168. }
169. _waitLoadingArr.reverse（）;
170. loadImage（）;
171. }
172. }
173.
174. privatefunctionloadImage（）:
void{
175. if（_waitLoadingArr.length>0）{
176. for（vari:
int=0;i<_loadingNo-_loadingMap.size（）;i++）{
177. varkey:
String=_waitLoadingArr.pop（）;
178. varimageLoader:
ImageLoader=newImageLoader（）;
179. varfileName:
String=Config.getValue（"mapLib"）+_map.name+"/"+key +".jpg";
180.// trace（"fileName:
"+fileName）;
181. _loadingMap.put（imageLoader,key）;
182. imageLoader.addEventListener（Event.COMPLETE,loadScreenImageSuccess）;
183. imageLoader.addEventListener（ProgressEvent.PROGRESS,loadingHandler）;
184. imageLoader.addEventListener（IOErrorEvent.IO_ERROR,ioErrorHandler）;
185. imageLoader.load（fileName）;
186. }
187. }
188. }
189.
190. //成功加载某屏的图片
191. privatefunctionloadScreenImageSuccess（evet:
Event）:
void{
192. varimageLoader:
ImageLoader=ImageLoader（evet.target）;
193. vartempStr:
String=String（_loadingMap.getValue（imageLoader））;
194. vartempStrArr:
Array=tempStr.split（"_"）;
195. varyy:
int=tempStrArr[0];
196. varxx:
int=tempStrArr[1];
197. _loadingMap.remove（imageLoader）;
198. varimage:
Bitmap=newBitmap（imageLoader._data）;
199. image.x=_sliceWidth*xx;
200. image.y=_sliceHeight*yy;
201. this.addChild（image）;
202. _imageMap.put（yy+"_"+xx,image）;
203. imageLoader.removeEventListener（Event.COMPLETE,loadScreenImageSuccess）;
204. imageLoader.removeEventListener（ProgressEvent.PROGRESS,loadingH
升级会员 