地图数据说明

来源：互联网发布：g76梯形螺纹编程实例编辑：程序博客网时间：2024/05/21 09:47

地图文件下载

:http://www.huanhuan18.com/myWeb/soft/YFEditor.air

或者： http://www.huanhuan18.com/myWeb/soft/YFEditor/

exe形式：:http://www.huanhuan18.com/myWeb/soft/YFEditor.exe

使用注意：假如需要使用低像素图片需要自己手动去点击低像素按钮来生成低像素地图地图切片也是一样需要自己主动去触发！这两个功能处理时间比较长使用时请耐心等待

数据文件说明：网络地址:
http://www.huanhuan18.com/myWeb/soft/map1.xml

<?xml version="1.0" encoding="utf-8"?>

</YFMapEditor>

相关说明:

数据说明:

mapName 是地图的名称
url是地图地址
mapWidth mapHeight   是这个地图的实际宽高
caculateWidth caculateHeight是这个地图的计算宽高是我们在数据处理中要用到的宽高
beginTileX beginTileY 第一个节点位置

roadType=1 表示可走 blockType表示不可走 alphaRoadType=2表示消隐点.也就是人物在该点时需要半透明化
值大于等3的点表示地图跳转点用来跳转到其他地图中

skipMap节点

   secondInfo用来标识在同一地域间的跳转假如两张地图之间进行跳转，则不需要考虑此属性
假如在一张地图上进行传送跳转到该地图的另一传送点则需要此属性

type 值是指的是该类型
里面<skipMap> 0,6,0,7,0,8,0,9,0,10,1,6,0,5,1,8,1,10,0,11,1,7,1,9,0,12,1,12,1,11</skipMap> 的值指的是这点存在的位置用的是tile坐标

building 节点:
url指的是图片地址 buildX buildY指的是该建筑的位置(flash坐标)    imageX imageY（flash坐标）是图片的位置，这也是我在写程序加载图片后所需要放置的位置     corner里面的值指的是该建筑的四个控制点的位置(tile坐标)，这个位置是相对的相对 buildX buildY的值（计算时需要将cornenr内部的值转换为flash坐标在与buildX buildY相加得到全局的控制点flash坐标）

block 里面的值保存的是不可走的局部位置得到全局位置也是要借助 buildX buildY值

必备工具类:

package utils.games.utils
{
   /**
   * ...
   * @author dreamnight   http://huanhuan18.com/blog   http://blog.csdn.net/hu36978
   *
   */
   public class MapUtil
   {
           import flash.geom.Point;

           import utils.games.display.GameObject;

       public function MapUtil()
       {

       }



       /*
       *在 getTilePoint函数的基础上增加了对gridlayer坐标位置的判断定位
       *
       * */

       public static function getTilePoint2(tileWidth:Number, tileHeight:Number, px:Number, py:Number,gridLayerX:Number=0,gridlayerY:Number=0):Point {

           //根据 gridlayer坐标来算出像素相对坐标
           var realX:Number = px - gridLayerX;
           var realY:Number = py - gridlayerY;

           return    MapUtil.getTilePoint(tileWidth,tileHeight,realX,realY);

           }











       /**
       *
       *   //这里的 px 是相对于原点的像素坐标   这里的网格的原点坐标在(0,0)也就是gridLayer中的grid坐标在原点并且gridlayer的坐标也在原点在以后的GridLayer中我只控制GridLayer所以这个方法实用性是当Gridlayer的坐标在原点时成立
       *

       * */
       public static function getTilePoint(tileWidth:Number, tileHeight:Number, px:Number, py:Number):Point
       {
           /**
           * 网格的x坐标
           * */
           var xtile:int = 0;
           /**
           * 网格的y坐标
           * */
           var ytile:int = 0;

            var cx:int, cy:int;
           /**
           * 计算出当前X所在的以tileWidth为宽的矩形的中心的X坐标
           * */
            cx = int(px / tileWidth) * tileWidth + tileWidth/2;
           /**
           * 计算出当前Y所在的以tileHeight为高的矩形的中心的Y坐标
           * */
            cy = int(py / tileHeight) * tileHeight + tileHeight / 2;

           //四个直线方程
           var line1:Number = py + (px - cx) *tileHeight / tileWidth - cy + tileHeight * 0.5; // 满足 >0条件
           var line2:Number = py + (cx - px) *tileHeight / tileWidth - cy + tileHeight * 0.5; //    >0
           var line3:Number = py + (cx - px) * tileHeight / tileWidth - cy - tileHeight * 0.5;//   <0
           var line4:Number = py + (px - cx) * tileHeight / tileWidth - cy - tileHeight * 0.5;// <0


           //当点在矩形内也就是 y 为偶数的 tile
           if ((line1>=0)&&(line2>=0)&&(line3<=0)&&(line4<=0)) {

               xtile = int(px / tileWidth);
               ytile = int(py / tileHeight) * 2;




               }


               //、当在棱形外
               else {

                   //对X进行定位当在左半边时

                   if ((px <= cx + tileWidth * 0.5) && (cx <= px)) {

                       xtile = int(px / tileWidth);



                       }
                       else {
                           //右半边

                            xtile = int(px / tileWidth) - 1;





                           }

               //对 y 进行定位当在上半部分时
                   if ((cy <= py) && (py <= cy + tileHeight * 0.5)) {

                       ytile = int(py / tileHeight) * 2 + 1;


                       }else {

                           ytile = (int(py / tileHeight) - 1) * 2 +1;



                           }

                   }


       return new Point(xtile,ytile);



       }




       /*
       * 得到左上角的flash坐标也就是注册点
       * */
       public static function getLeftTopPointByTile(tileWidth:int,tileHeight:int,tileX:int,tileY:int):Point {


       var point:Point = MapUtil.getTileCenterByTilePoint(tileWidth, tileHeight, tileX, tileY);

       var px:Number = point.x - tileWidth * 0.5;
       var py:Number = point.y - tileHeight * 0.5;
       return new Point(px,py);

           }



           public static function getLefTopPointByPixelPoint(tileW:Number, tileH:Number, px:Number, py:Number):Point {
               var point:Point = MapUtil.getTileCenterByPixelPoint(tileW, tileH, px, py);

                   var myX:Number = point.x - tileW * 0.5;
                   var myY:Number = point.y - tileH * 0.5;
                   return new Point(myX,myY);


               }




       //根据 tile坐标得到 tile的中心flash坐标
       public static function getTileCenterByTilePoint(tileW:Number,tileH:Number,tx:int, ty:int):Point {

           var px:Number;
           var py:Number;
           py = 0.5 * tileH * ty + 0.5 * tileH;
           //当 ty为偶数
           if (ty % 2 == 0) {
               px = tx * tileW + 0.5 * tileW;

               }
               else {

                   px=tx * tileW + tileW;


                   }


           return new Point(px,py);
           }



           //根据像素坐标<flash实际坐标> 得到 tile中心坐标

           public static function getTileCenterByPixelPoint(tileW:Number, tileH:Number, px:Number, py:Number):Point {

               var point:Point = MapUtil.getTilePoint(tileW, tileH, px, py);

               return MapUtil.getTileCenterByTilePoint(tileW,tileH,point.x,point.y);



               }

/*               // cols是含有的列数索引是从0开始
               public static function getIndexByTilePoint(tileX:int,tileY:int,cols:int):int {

                   var index:int=tileY*cols+tileX

                   return index;

                   }*/

           /*   public static function getTilePointByIndex(index:int,columns:int):Point {

                       var tileY:int = index/ columns;
                       var tileX:int = index % columns ;


                       return new Point(tileX,tileY);



                       }*/


                       /**
                       * 根据 tileX tileY来得到相应位置的点假如不存在的话就会返回null
                       *
                       *
                       * @param   array 总点数组长度为 (endTileX-beginTileX+1)*(endTileY-beginTileY+1)
                       * @param   tileX
                       * @param   tileY
                       */
                       public static function getArrayPointByTilePoint(array:Array, tileX:int, tileY:int,endTileX:int,endTleY:int,beginTileX:int=-1,beginTileY:int=-1):Point {

                           //var column:int = endTileX - beginTileX + 1;
                       //   var row:int = endTleY - beginTileY + 1;



                           var index:int = MapUtil.getTileIndex(tileX,tileY,endTileX,endTleY,beginTileX,beginTileY);
                           var point:Point = array[index];
                           return point;


                           }


                       /**
                       * 根据 px py来得到相应位置的点假如不存在的话就会返回null
                       *
                       *
                       * @param   array 总点数组长度为 (endTileX-beginTileX+1)*(endTileY-beginTileY+1)
                       * @param   px flash坐标
                       * @param   py
                       */
                           public static function getArrayPointByFlashPoint(tileW:int,tileH:int,array:Array, px:int, py:int, endTileX:int, endTleY:int, beginTileX:int = -1, beginTileY:int = -1):Point {
                               var tilePoint:Point = MapUtil.getTilePoint(tileW,tileH,px,py);

                               return MapUtil.getArrayPointByTilePoint(array,tilePoint.x,tilePoint.y,endTileX,endTleY,beginTileX,beginTileY);


                               }


                               /**
                               * 根据tileX tileY 得到在总数组中的索引
                               * @param   tileX
                               * @param   tileY
                               * @param   endTileX
                               * @param   endTleY
                               * @param   beginTileX
                               * @param   beginTileY
                               * @return
                               */
                               public static function getTileIndex(tileX:int,tileY:int,endTileX:int,endTleY:int,beginTileX:int=-1,beginTileY:int=-1):int {

                                   var column:int = endTileX - beginTileX + 1;
                                   var index:int = tileX-beginTileX + (tileY-beginTileY) * column;

                                   return index;



                                   }


















               //tileX tileY 的本地与全局的转化

               /*
               * 本地tile在Building的坐标转化为在Buildding父容器中的坐标
               *
               *
               * 注意 Buildding已经添加进全局做标中
                       也就是说   转化后的坐标是和building 的坐标在同一坐标系中

                       @param buildingTilePoint 该值是在buiding 中的坐标值
                       @param 参照对象     也就是 buildingTilePoint所属坐标系

                       最终返回的坐标是和 buiding 在同一坐标系
               *
               * */
       /*       public static function localToGlobalTile(buildingTilePoint:Point,buiding:GameObject):Point {

                   var buildingPoint:Point = buiding.getTilePosition();
                   var gx:int = buildingTilePoint.x + buildingPoint.x;
                   var gy:int = buildingTilePoint.y + buildingPoint.y;

                   return new Point(gx,gy);

                   }*/


               /*
               *
               * 全局tile坐标转化为在Buildding中的坐标
               * 注意 Buildding已经添加进全局做标中

               @globalPoint 和buiding 的坐标   是在同一坐标系中
               @buiding 参照对象

               最终返回的是globalPoint在buiding坐标系中的坐标

               * */

       /*       public static function globalToLocalTile(globalPoint:Point,buiding:GameObject):Point {


                   var buildingPoint:Point = buiding.getTilePosition();
                   var gx:int = globalPoint.x - buildingPoint.x;
                   var gy:int = globalPoint.y - buildingPoint.y;

                   return new Point(gx,gy);

                   }*/







                   /**
                   * 将数据拆成 Point对象比如
                   * @param   str str的形式是   1,2,3,4 这样的形式
                   * @return
                   */

                   public static function splitDataToPointArr(str:String):Vector.<Point> {
                       /**
                       * str字符串个数必须是偶数
                       */

                       var arr:Array = str.split(",");
                       if (arr.length % 2 != 0) {
                       //throw new Error("MapUtil ::数据有误");
                       return new Vector.<Point>();
                       //return null;
                       }
                       var len:int = arr.length;
                       var i:int = 0;
                       var point:Point;
                       var vecPoint:Vector.<Point> = new Vector.<Point>();
                       while (i != len ) {
                           point = new Point();
                           point.x = arr[i];
                           point.y =arr[i + 1];
                           vecPoint.push(point);
                           i = i + 2;
                           }


                       return vecPoint;
                       }












       ///end class

   }

}