·您当前的位置:首页 > 技术教程 > AS2与AS3技术 >

[AS3]as3对大地图分片后实现连续加载的源代码实例

时间:2014-08-20 13:53酷播
[AS3]as3对大地图分片后实现连续加载的源代码实例

首先我们确定几个关键点:

窗口大小:windowW:Number,windowH:Number; 指的是可视区域的大小 我们可以把他想成客户端的分别率

单位地图大小: uintPicW:Number,uintPicH:Number; 指的是你切割的地图图片的单元大小。

当前地图坐标:position:point;这里大家就可以想成是你人物的当前所处坐标

清楚了上面的几个关键点,我们再来看下面的这个图:



阴影区域就是可视区域 A、B、C、D就是切割的单元地图

我们可以很容易的求出窗口的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. package com.heptaFish.common.game.map.layers 
  2.  
  3.  
  4. import com.heptaFish.common.config.Config; 
  5.  
  6. import com.heptaFish.common.core.BaseDisplayObject; 
  7.  
  8. import com.heptaFish.common.game.map.impl.GameMap; 
  9.  
  10. import com.heptaFish.common.hack.HeptaFishGC; 
  11.  
  12. import com.heptaFish.common.loader.impl.ImageLoader; 
  13.  
  14. import com.heptaFish.common.map.impl.HashMap; 
  15.  
  16.  
  17.  
  18. import flash.display.Bitmap; 
  19.  
  20. import flash.events.Event; 
  21.  
  22. import flash.events.IOErrorEvent; 
  23.  
  24. import flash.events.ProgressEvent; 
  25.  
  26. import flash.geom.Point; 
  27.  
  28. //地图层 图片 
  29.  
  30. public class MapLayer extends BaseDisplayObject 
  31.  
  32.  
  33.   //图片读取器 
  34.  
  35.   private var _imageLoader:ImageLoader; 
  36.  
  37.   //地图图片 用于整块加载模式 
  38.  
  39.   private var _image:Bitmap; 
  40.  
  41.   //地图图片数组 用于栅格式加载地图模式 
  42.  
  43.   private var _imageMap:HashMap; 
  44.  
  45.   //小地图图片 
  46.  
  47.   private var _simage:Bitmap; 
  48.  
  49.   // 
  50.  
  51.   private var _map:GameMap; 
  52.  
  53.   private var _loadType:int;//加载类型 0:整块加载 1:栅格加载 
  54.  
  55.   private var _visualWidth:Number;//地图可视宽度 
  56.  
  57.   private var _visualHeight:Number;//地图可视高度 
  58.  
  59.   private var _sliceWidth:Number;//地图切割单元宽度 
  60.  
  61.   private var _sliceHeight:Number;//地图切割单元高度 
  62.  
  63.   private var _preloadX:Number;//横向预加载屏数 
  64.  
  65.   private var _preloadY:Number;//纵向预加载屏数 
  66.  
  67.   private var _loadingMap:HashMap;//正在加载的屏map 
  68.  
  69.   private var _waitLoadingArr:Array;//等待加载的loadermap 
  70.  
  71.    
  72.  
  73.   private var _loadingNo:int = Config.getInt("concurrencyImageLoader"); 
  74.  
  75.    
  76.  
  77.   private var _screenImageRow:int;//一屏需要加载的横向图片数 
  78.  
  79.   private var _screenImageCol:int;//一屏需要加载的纵向图片数 
  80.  
  81.   private var _row:int;//总横向节点数 
  82.  
  83.   private var _col:int;//总纵向节点数 
  84.  
  85.    
  86.  
  87.   private var _nowPlayerPointoint;//当前人物所处的屏 
  88.  
  89.    
  90.  
  91.   public function MapLayer(map:GameMap) 
  92.  
  93.   { 
  94.  
  95.    _map = map;  
  96.  
  97.    _loadType = parseInt(_map.mapXML.@loadType); 
  98.  
  99.   } 
  100.  
  101.   //读取地图图片 
  102.  
  103.   public function load():void{ 
  104.  
  105.    //加载小地图 
  106.  
  107.    var imageLoader:ImageLoader = new ImageLoader(); 
  108.  
  109.    var fileName:String =Config.getValue("mapLib") + _map.name + "/map_s.jpg"; 
  110.  
  111.    imageLoader.load(fileName); 
  112.  
  113.    imageLoader.addEventListener(Event.COMPLETE,loadSmallSuccess); 
  114.  
  115.    imageLoader.addEventListener(ProgressEvent.PROGRESS,loadingHandler); 
  116.  
  117.    imageLoader.addEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler); 
  118.  
  119.     
  120.  
  121.   } 
  122.  
  123.   //读取大地图成功 
  124.  
  125.   private function loadBigSuccess(evet:Event):void{ 
  126.  
  127.    var imageLoader:ImageLoader = ImageLoader(evet.target); 
  128.  
  129.    var image:Bitmap = new Bitmap(imageLoader._data); 
  130.  
  131.    addChild(image); 
  132.  
  133.    if(_simage != null && _simage.parent == this){ 
  134.  
  135.     removeChild(_simage); 
  136.  
  137.     _simage = null
  138.  
  139.    } 
  140.  
  141.    this.width = image.width; 
  142.  
  143.    this.height = image.height; 
  144.  
  145.    imageLoader.removeEventListener(Event.COMPLETE,loadBigSuccess); 
  146.  
  147.    imageLoader.removeEventListener(ProgressEvent.PROGRESS,loadingHandler); 
  148.  
  149.    imageLoader.removeEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler); 
  150.  
  151.    imageLoader = null
  152.  
  153.    dispatchEvent(evet); 
  154.  
  155.    HeptaFishGC.gc(); 
  156.  
  157.   } 
  158.  
  159.   //读取小地图成功 
  160.  
  161.   private function loadSmallSuccess(evet:Event):void{ 
  162.  
  163.    var imageLoader:ImageLoader = ImageLoader(evet.target); 
  164.  
  165.    var image:Bitmap = new Bitmap(imageLoader._data); 
  166.  
  167.    image.width = _map.mapWidth; 
  168.  
  169.    image.height = _map.mapHeight; 
  170.  
  171.    addChild(image); 
  172.  
  173.    this.width = image.width; 
  174.  
  175.    this.height = image.height; 
  176.  
  177.    imageLoader.removeEventListener(Event.COMPLETE,loadSmallSuccess); 
  178.  
  179.    imageLoader.removeEventListener(ProgressEvent.PROGRESS,loadingHandler); 
  180.  
  181.    imageLoader.removeEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler); 
  182.  
  183.    imageLoader = null
  184.  
  185.    dispatchEvent(evet); 
  186.  
  187.    HeptaFishGC.gc();    
  188.  
  189.    switch(_loadType){ 
  190.  
  191.     case 0://整块加载     
  192.  
  193.      //加载大地图 
  194.  
  195.      var bfileName:String =Config.getValue("mapLib") + _map.name + "/map.jpg"; 
  196.  
  197.      var bLoader:ImageLoader = new ImageLoader();  
  198.  
  199.      bLoader.load(bfileName); 
  200.  
  201.      bLoader.addEventListener(Event.COMPLETE,loadBigSuccess); 
  202.  
  203.      bLoader.addEventListener(ProgressEvent.PROGRESS,loadingHandler); 
  204.  
  205.      bLoader.addEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler); 
  206.  
  207.      break; 
  208.  
  209.     case 1: 
  210.  
  211.      _loadingMap = new HashMap(); 
  212.  
  213.      _imageMap = new HashMap(); 
  214.  
  215.      _waitLoadingArr = new Array(); 
  216.  
  217.      _visualWidth = _map.app.screen.size.x; 
  218.  
  219.      _visualHeight = _map.app.screen.size.y; 
  220.  
  221.      _sliceWidth = parseFloat(_map.mapXML.@sliceWidth); 
  222.  
  223.      _sliceHeight = parseFloat(_map.mapXML.@sliceHeight); 
  224.  
  225.      _preloadX = parseFloat(_map.mapXML.@preloadX); 
  226.  
  227.      _preloadY = parseFloat(_map.mapXML.@preloadY); 
  228.  
  229.      _screenImageRow = Math.round(_visualWidth/_sliceWidth); 
  230.  
  231.      _screenImageCol = Math.round(_visualHeight/_sliceHeight); 
  232.  
  233.      _row = Math.ceil(_map.mapWidth/_sliceWidth); 
  234.  
  235.      _col = Math.ceil(_map.mapHeight/_sliceHeight); 
  236.  
  237.      loadSliceImage(_map.initPlayerPoint); 
  238.  
  239.      break; 
  240.  
  241.     default: 
  242.  
  243.      break; 
  244.  
  245.       
  246.  
  247.    } 
  248.  
  249.   } 
  250.  
  251.    
  252.  
  253.   //根据player坐标读取周边指定屏数地图 
  254.  
  255.   private function loadSliceImage(playerPointoint):void{ 
  256.  
  257.    var nowX:int = Math.floor(playerPoint.x/_sliceWidth);//现在所处的索引X 
  258.  
  259.    var nowY:int = Math.floor(playerPoint.y/_sliceHeight);//现在所处的索引Y 
  260.  
  261.    var nowScreenX:int = Math.floor(nowX/_screenImageRow);//现在所处的屏索引X 
  262.  
  263.    var nowScreenY:int = Math.floor(nowY/_screenImageCol);//现在所处的屏索引Y 
  264.  
  265. //   trace("nowScreenX:" + nowScreenX); 
  266.  
  267. //   trace("nowScreenY:" + nowScreenY); 
  268.  
  269.    _nowPlayerPoint = new Point(nowScreenX,nowScreenY); 
  270.  
  271.    loadScreenImage(nowScreenX,nowScreenY); 
  272.  
  273. //   removeScreenImage(nowScreenX,nowScreenY); 
  274.  
  275.    var startX:int = (nowScreenX - _preloadX < 0 ? 0 : nowScreenX - _preloadX); 
  276.  
  277.    var startY:int = (nowScreenY - _preloadY < 0 ? 0 : nowScreenY - _preloadY); 
  278.  
  279.     
  280.  
  281.    var endX:int = (nowScreenX + _preloadX > _row ? _row : nowScreenX + _preloadX); 
  282.  
  283.    var endY:int = (nowScreenY + _preloadY > _col ? _col : nowScreenY + _preloadY); 
  284.  
  285.     
  286.  
  287.    for(var xx:int = startX; xx < endX;xx++){ 
  288.  
  289.     for(var yy:int = startY; yy < endY;yy++){ 
  290.  
  291.      if(xx == nowScreenX && yy == nowScreenY){ 
  292.  
  293.       continue; 
  294.  
  295.      }else{ 
  296.  
  297.       loadScreenImage(xx,yy); 
  298.  
  299.      } 
  300.  
  301.     } 
  302.  
  303.    } 
  304.  
  305.   } 
  306.  
  307.   //加载指定屏的地图图片 
  308.  
  309.   private function loadScreenImage(screenX:int,screenY:int):void{ 
  310.  
  311.    var starX:int = _screenImageRow*screenX < 0 ? 0 : _screenImageRow*screenX; 
  312.  
  313.    var starY:int = _screenImageCol*screenY < 0 ? 0 : _screenImageCol*screenY; 
  314.  
  315.    var endX:int = _screenImageRow*(screenX+1) > _row - 1 ? _row -1 : _screenImageRow*(screenX+1); 
  316.  
  317.    var endY:int = _screenImageCol*(screenY+1) > _col-1  ? _col-1 : _screenImageCol*(screenY+1); 
  318.  
  319.    for(var yy:int=starY;yy<endY+1;yy++){ 
  320.  
  321.     for(var xx:int = starX;xx<endX+1;xx++){ 
  322.  
  323.      var tempKey:String = yy+"_"+xx; 
  324.  
  325.      if(!_loadingMap.containsValue(tempKey) && !_imageMap.containsKey(tempKey)){ 
  326.  
  327.       _waitLoadingArr.push(tempKey); 
  328.  
  329.      } 
  330.  
  331.     } 
  332.  
  333.     _waitLoadingArr.reverse(); 
  334.  
  335.     loadImage(); 
  336.  
  337.    } 
  338.  
  339.   } 
  340.  
  341.    
  342.  
  343.   private function loadImage():void{ 
  344.  
  345.    if(_waitLoadingArr.length > 0){ 
  346.  
  347.     for(var i:int = 0;i<_loadingNo - _loadingMap.size();i++){ 
  348.  
  349.      var key:String = _waitLoadingArr.pop(); 
  350.  
  351.      var imageLoader:ImageLoader = new ImageLoader(); 
  352.  
  353.      var fileName:String = Config.getValue("mapLib") + _map.name +"/" + key  + ".jpg"; 
  354.  
  355. //     trace("fileName:" + fileName); 
  356.  
  357.      _loadingMap.put(imageLoader,key); 
  358.  
  359.      imageLoader.addEventListener(Event.COMPLETE,loadScreenImageSuccess); 
  360.  
  361.      imageLoader.addEventListener(ProgressEvent.PROGRESS,loadingHandler); 
  362.  
  363.      imageLoader.addEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler); 
  364.  
  365.      imageLoader.load(fileName); 
  366.  
  367.     } 
  368.  
  369.    } 
  370.  
  371.   } 
  372.  
  373.    
  374.  
  375.   //成功加载某屏的图片 
  376.  
  377.   private function loadScreenImageSuccess(evet:Event):void{ 
  378.  
  379.    var imageLoader:ImageLoader = ImageLoader(evet.target); 
  380.  
  381.    var tempStr:String = String(_loadingMap.getValue(imageLoader)); 
  382.  
  383.    var tempStrtempStrArr:Array = tempStr.split("_"); 
  384.  
  385.    var yy:int = tempStrArr[0]; 
  386.  
  387.    var xx:int = tempStrArr[1]; 
  388.  
  389.    _loadingMap.remove(imageLoader); 
  390.  
  391.    var image:Bitmap = new Bitmap(imageLoader._data); 
  392.  
  393.    image.x = _sliceWidth*xx; 
  394.  
  395.    image.y = _sliceHeight*yy; 
  396.  
  397.    this.addChild(image); 
  398.  
  399.    _imageMap.put(yy+"_"+xx,image); 
  400.  
  401.    imageLoader.removeEventListener(Event.COMPLETE,loadScreenImageSuccess); 
  402.  
  403.    imageLoader.removeEventListener(ProgressEvent.PROGRESS,loadingHandler); 
  404.  
  405.    imageLoader.removeEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler); 
  406.  
  407.    imageLoader = null
  408.  
  409.    loadImage(); 
  410.  
  411.   } 
  412.  
  413.   //卸载指定屏的地图图片 
  414.  
  415.   private function removeScreenImage(screenX:int,screenY:int):void{ 
  416.  
  417.    var startX:int = (screenX - _preloadX < 0 ? 0 : screenX - _preloadX); 
  418.  
  419.    var startY:int = (screenY - _preloadY < 0 ? 0 : screenY - _preloadY); 
  420.  
  421.     
  422.  
  423.    var endX:int = (screenX + _preloadX > _row ? _row : screenX + _preloadX); 
  424.  
  425.    var endY:int = (screenY + _preloadY > _col ? _col : screenY + _preloadY); 
  426.  
  427.    var keyArr:Array = _imageMap.keys(); 
  428.  
  429.    for(var i:int = 0;i < keyArr.length;i++){ 
  430.  
  431.     var key:String = keyArr
  432.  
  433.     var tempStrArr:Array = key.split("_"); 
  434.  
  435.     var yy:int = tempStrArr[0]; 
  436.  
  437.     var xx:int = tempStrArr[1]; 
  438.  
  439.     if(xx < startX*_screenImageRow || xx > endX * _screenImageRow || yy < startY*_screenImageCol ||  
  440.  
  441.  
  442.  
  443. yy > endY*_screenImageCol){ 
  444.  
  445.      var image:Bitmap = Bitmap(_imageMap.getValue(key)); 
  446.  
  447.      this.removeChild(image); 
  448.  
  449.      image = null
  450.  
  451.      _imageMap.remove(key); 
  452.  
  453.     } 
  454.  
  455.    } 
  456.    HeptaFishGC.gc(); 
  457.  
  458.   } 
  459.  
  460.   //检查是否需要加载 
  461.  
  462.   public function checkLoad(pointoint):void{ 
  463.    var nowX:int = Math.floor(point.x/_sliceWidth);//现在所处的索引X 
  464.    var nowY:int = Math.floor(point.y/_sliceHeight);//现在所处的索引Y 
  465.    var nowScreenX:int = Math.floor(nowX/_screenImageRow);//现在所处的屏索引X 
  466.    var nowScreenY:int = Math.floor(nowY/_screenImageCol);//现在所处的屏索引Y 
  467.    if(nowScreenX != _nowPlayerPoint.x || nowScreenY != _nowPlayerPoint.y){ 
  468.     loadSliceImage(point); 
  469.    } 
  470.   } 
  471.  
  472.  

 

热门文章推荐

请稍候...

保利威视云平台-轻松实现点播直播视频应用

酷播云数据统计分析跨平台播放器