18.libgdx制作预览图,背景移动循环,改变地图颜色

经过构思,游戏将分为两部分,

1,预览图,只负责展示世界形势

2,根据预览图生成的战役项

现在要记录的是我制作预览图的部分

1.预览图只有实际地图的1/4,首先生成地图(建议不要缩放以前地图,由于误差原因会导致地图色绘制不准),由于方法只支持int值,1/4导致一些误差(海洋中有些尖刺),不得不手动修复

然后处理为4024*2024大小通过分割工具分割为几部分

再通过xml记录绘制位置,在游戏中合成大图

<SmallMaps><!--存放位置为img下的name文件夹,id与mapId一一对应-->
    <Maps id="1" name="world" width="3308" height="1536" >
    <map n="1.png" x="0" y="0"/>
    <map n="2.png" x="1000" y="0"/>
    <map n="3.png" x="2000" y="0"/>
    <map n="4.png" x="3000" y="0"/>
    <map n="5.png" x="0" y="1000"/>
    <map n="6.png" x="1000" y="1000"/>
    <map n="7.png" x="2000" y="1000"/>
    <map n="8.png" x="3000" y="1000"/>
    </Maps>
</SmallMaps>

经过考虑,将把预览图内容放入actor中

首先实现根据玩家动作缩放,移动预览图

然后是地图循环

先定义ifLoop,drawLoop状态,在actor中的draw方法里

如果是drawLoop状态,则在上次绘制的右边追加一次绘制

{
            Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
            //一次性绘制
            oldColor=batch.getColor();
            batch.draw(spriteMain, getX(), getY(), getOriginX(), getOriginY(), getWidth(), getHeight(),
                    getZoom(), getZoom(), getRotation());
            batch.draw(spriteCountry, getX(), getY(), getOriginX(), getOriginY(), getWidth(), getHeight(),
                    getZoom(), getZoom(), getRotation());
 
            //batch.setColor(Color.RED);
            if(drawLoop){
                batch.draw(spriteMain, getX()+mapW_px*this.zoom, getY(), getOriginX(), getOriginY(), getWidth(), getHeight(),
                        getZoom(), getZoom(), getRotation());
                batch.draw(spriteCountry, getX()+mapW_px*this.zoom, getY(), getOriginX(), getOriginY(), getWidth(), getHeight(),
                        getZoom(), getZoom(), getRotation());
            }
            //batch.setColor(oldColor);
 
        }

draw方法修改

然后是通过x坐标判断drawLoop状态

public void setX(float x) {
        if(ifLoop){////判断当前坐标是否需要循环显示右边
            if(x<=xMin&&x >= (-xMax * zoom + vw)){
                drawLoop=false;
            }else if(x>xMin){//从起点向左
                drawLoop=true;
                x=(-xMax  -vw)+x;
            }else if(x < (-xMax  + vw)&&x>(-xMax )){//划入右边,接近循环
                drawLoop=true;
            }else if(x<=(-xMax -vw)) {//划出并还原
                drawLoop=false;
                x = x + xMax +vw;
            }/**/
        }else {
            if (x > xMin) {
                x = xMin;
            } else if (x < -(xMax)) {
                x = -(xMax);
            }
        }
        this.x = x;
    }

判断x坐标位置实现循环

然后就可以实现循环了.

以下为地图色思路:

地图色这里使用的是区块色,前几天花了两天时间重绘了地图色

首先说思路:

首先绘制区块色(缩放1/4)

然后与预览图一起加载这里会完美的盖到一起(如果是用相同坐标绘制是不会有偏差的)

然后是区块变色,这里参考了libgdx 涂口红的原理,使用 texture.draw(pixmap,0,0);

变色前:

变色后:

package com.zhfy.game.screen;
 
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input;
import com.badlogic.gdx.InputMultiplexer;
import com.badlogic.gdx.InputProcessor;
import com.badlogic.gdx.ScreenAdapter;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.BitmapFont;
import com.badlogic.gdx.graphics.profiling.GLProfiler;
import com.badlogic.gdx.input.GestureDetector;
import com.badlogic.gdx.input.GestureDetector.GestureListener;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.scenes.scene2d.Group;
import com.badlogic.gdx.scenes.scene2d.InputEvent;
import com.badlogic.gdx.scenes.scene2d.Stage;
import com.badlogic.gdx.scenes.scene2d.ui.ImageButton;
import com.badlogic.gdx.scenes.scene2d.ui.Label;
import com.badlogic.gdx.scenes.scene2d.ui.Label.LabelStyle;
import com.badlogic.gdx.scenes.scene2d.utils.ClickListener;
import com.badlogic.gdx.scenes.scene2d.utils.TextureRegionDrawable;
import com.badlogic.gdx.utils.XmlReader;
import com.badlogic.gdx.utils.XmlReader.Element;
import com.badlogic.gdx.utils.viewport.StretchViewport;
import com.zhfy.game.MainGame;
import com.zhfy.game.config.ResConfig;
import com.zhfy.game.framework.GameLayout;
import com.zhfy.game.framework.GameMap;
import com.zhfy.game.framework.GameUtil;
import com.zhfy.game.model.framework.TextureRegionListDAO;
import com.zhfy.game.screen.actor.MapActor;
import com.zhfy.game.screen.actor.SMapActor;
 
/**
 * 主游戏场景（游戏主界面）, 实现 Screen 接口 或者 继承 ScreenAdapter 类 <br/>
 * 这里就展示一张图片代表游戏主界面
 */
public class GameScreen extends ScreenAdapter  {
 
    private MainGame game;
 
    private Stage gameStage;
 
    private TextureRegionListDAO imgLists;
 
    private TextureRegionListDAO imgUpList;
 
    private TextureRegionListDAO imgDownList;
 
    private ImageButton button;
    //使用场景
    private int screenId=81;
 
    private int stageId;
 
    InputProcessorEvent processorEvent;
    MapListener mapListener;
    InputMultiplexer multiplexer;
 
    boolean isTouching;
    float touchBaseX;
    float touchBaseY;
    float touch_X;
    float touch_Y;
    float moveX;
    float moveY;
    Label label;
    //中心点位置
    float cx;
    float cy;
    float javaHeap;
    float javaMaxHeap;
    boolean ifLoop;
 
    //游戏舞台的基本宽高
    static  float GAMESTAGE_WIDTH;
    static  float GAMESTAGE_HEIGHT;
    //GLProfile  gp = new GrayFilter();
    GLProfiler  gp;
 
    //ui
    private Element uiR;
    private List<Element> ui;
    private XmlReader reader ;
    private String bgTexture;
    private float tempX,tempY,tempW,tempH;
    com.badlogic.gdx.utils.Array<Element> buttonEs;
    private Map tempMap;
 
    private int i;//function的计数标志,从1开始
    private SMapActor mapActor;
 
    private float mapX;
    private float mapY;
    private float mapXMax;
    private float mapYMax;
    private float mapScaleX;
    private float mapScaleY;
 
    public GameScreen(MainGame mainGame)  {
 
        this.game=mainGame;
 
        GAMESTAGE_WIDTH=game.getWorldWidth();
        GAMESTAGE_HEIGHT=game.getWorldHeight();
 
        //ui
        {
            reader = ResConfig.reader;
            uiR=GameLayout.getXmlERootByScreenId(screenId);
            ui=GameUtil.getXmlEByRootE(uiR);
        }
 
        setStageId(mainGame.getStageId());
 
        //1根据mapid读取地图DAO
        //2加载地图图片,生成图片作为背景
        /*textureMap=framework.getMapByMapId(mapId);
        defMap=framework.getDefMapByMapId(mapId);
        mapW=defMap.getWidth();
        mapH=defMap.getHeight();
        mapSprite = new Sprite(textureMap);*/
 
        //3增加拖动等功能,可以拖动地图
        //4替换地图dao的地图素材
        //5保存地图
 
        gp =new GLProfiler(Gdx. graphics);
        gp.enable();
 
        isTouching=false;
        multiplexer = new InputMultiplexer();
 
        // 使用伸展视口创建舞台
        gameStage = new Stage(new StretchViewport(GAMESTAGE_WIDTH, GAMESTAGE_HEIGHT));
        // 将输入处理设置到舞台（必须设置, 否则点击按钮没效果）
 
        multiplexer.addProcessor(gameStage);
        // 创建游戏人物演员
        //mapActor = new mapActor(new TextureRegion(mapSprite),0,0,mapW,mapH,GAMESTAGE_WIDTH, GAMESTAGE_HEIGHT);
 
        //mapActor = new MapActor(stageId,GAMESTAGE_WIDTH, GAMESTAGE_HEIGHT,mainGame.getAssetManager(),screenId);
 
        // 添加演员到舞台
        // gameStage.addActor(mapActor);
        //stageId不对,应从中获取对应的mapId,ifLoop也是 TODO
        ifLoop=true;
        mapActor  = new SMapActor(stageId,GAMESTAGE_WIDTH, GAMESTAGE_HEIGHT,mainGame.getAssetManager(),screenId);
        gameStage.addActor(mapActor);
        //将来以玩家选择国家首都为位置标准 TODO
 
        //根据screenId初始化资源
        //获取对应图片
        imgLists=GameUtil.getTextureReigonByScreenId( screenId,mainGame.getAssetManager());
 
        i=1;
        for  (Element window:ui) {
            tempX=window.getInt("x");tempY=window.getInt("y");tempW=window.getInt("w");tempH=window.getInt("h");
 
            // 添加演员到舞台
            imgUpList=new TextureRegionListDAO();
            imgDownList=new TextureRegionListDAO();
            //遍历window的buttons按钮
            buttonEs = window.getChildByName("buttons").getChildrenByNameRecursively("button");  // 递归遍历，否则的话返回null
            for (Element buttonE : buttonEs) {
                //Gdx.app.log("ui测试", button.get("remark"));
                imgUpList.add(imgLists.getTextureByName(buttonE.get("imgUpName")));
                imgDownList.add(imgLists.getTextureByName(buttonE.get("imgDownName")));
 
                button = new ImageButton(new TextureRegionDrawable(imgLists.getTextureByName(buttonE.get("imgUpName")).getTextureRegion()),new TextureRegionDrawable(imgLists.getTextureByName(buttonE.get("imgDownName")).getTextureRegion()),new TextureRegionDrawable(imgLists.getTextureByName(buttonE.get("imgDownName")).getTextureRegion()));
                button.setSize(buttonE.getInt("w")==0?imgLists.getTextureByName(buttonE.get("imgUpName")).getTextureRegion().getRegionWidth():buttonE.getInt("w")*imgLists.getTextureByName(buttonE.get("imgUpName")).getTextureRegion().getRegionWidth()/100, buttonE.getInt("h")==0?imgLists.getTextureByName(buttonE.get("imgUpName")).getTextureRegion().getRegionHeight():buttonE.getInt("h")*imgLists.getTextureByName(buttonE.get("imgUpName")).getTextureRegion().getRegionHeight()/100);
                button.setPosition(
                        buttonE.getInt("x")*gameStage.getWidth()/100+button.getWidth()/2>gameStage.getWidth()?gameStage.getWidth()-button.getWidth():buttonE.getInt("x")*gameStage.getWidth()/100-button.getWidth()/2<0?0:buttonE.getInt("x")*gameStage.getWidth()/100-button.getWidth()/2,
                        buttonE.getInt("y")*gameStage.getWidth()/100+button.getHeight()/2>gameStage.getHeight()?gameStage.getHeight()-button.getHeight():buttonE.getInt("y")*gameStage.getHeight()/100-button.getHeight()/2<0?0:buttonE.getInt("y")*gameStage.getHeight()/100-button.getHeight()/2);
                tempMap=new HashMap();
                tempMap.put("FUNCTION_ID", buttonE.get("functionId"));
                tempMap.put("ID", i);
                i++;
                function(tempMap);
                gameStage.addActor(button);
                Gdx.input.setInputProcessor(gameStage);
            }
        }
        //文字示例
        label=new Label("FPS:"+Gdx.graphics.getFramesPerSecond(),new LabelStyle(new BitmapFont(), null));
 
        label.setWidth(200);//设置每行的宽度
        label.setWrap(true);//开启换行
        label.setPosition(20, 40);
        gameStage.addActor(label);
 
        processorEvent = new InputProcessorEvent();
        mapListener=new MapListener();
 
        Gdx.app.log("平台", Gdx.app.getType()+"");
        switch (Gdx.app.getType()) {
            case Desktop:// Code for Desktop applicationbreak;
                multiplexer.addProcessor(processorEvent);
            case Android:// Code for Android applicationbreak;
                multiplexer.addProcessor(new GestureDetector(mapListener));
            case WebGL:// Code for WebGL applicationbreak;
                multiplexer.addProcessor(processorEvent);
            default:// Unhandled (new?) platform applicationbreak;
                multiplexer.addProcessor(processorEvent);
                multiplexer.addProcessor(new GestureDetector(mapListener));
        }
        Gdx.input.setInputProcessor(multiplexer);
 
    }
 
    @Override
    public void render(float delta) {
 
        handleInput();
        gameStage.draw();
        gameStage.act();
        //Gdx.app.log("FPS:", Gdx.graphics.getFramesPerSecond()+"");
 
        javaHeap=(Math.round(Gdx.app.getJavaHeap()/1024/1024*10)/10);
        if(javaHeap>javaMaxHeap) {
            javaMaxHeap=javaHeap;
        }
 
        label.setText("FPS:"+Gdx.graphics.getFramesPerSecond());
        label.getText().appendLine("");
        label.getText().appendLine("javaHeap:"+javaHeap+"m/"+javaMaxHeap+"m");
        label.getText().appendLine("drawCalls:"+gp.getDrawCalls());
        label.getText().appendLine("nativeHeap:"+Math.round(Gdx.app.getNativeHeap()/1024/1024*10)/10+"m");
        //label.getText().appendLine("inputKeyMode:"+mapActor.getKeyMode());//快捷键模式
        gp.reset();
    }
 
    public void dispose() {
        super.dispose();
        // 场景被销毁时释放资源
        if (gameStage != null) {
            gameStage.dispose();
            gameStage=null;
        }
        if(mapActor!=null){
            mapActor.dispose();
            mapActor=null;
        }
 
    }
 
    //实现的功能
    public void function(Map map){
        int i=Integer.parseInt(map.get("FUNCTION_ID").toString());
        switch(i) {
            case 0://返回
                button.addListener(new ClickListener() {
                    public void clicked(InputEvent event, float x, float y) {
                        //Gdx.app.log("点击了第1个按钮", "x:" + x+" y:" + y);
                        if(game!=null) {
                            game.showGameScreen(screenId,1);
                        }
                    }
                });
                break;
            case 1://加载
                button.addListener(new ClickListener() {
                    public void clicked(InputEvent event, float x, float y) {
                        Gdx.app.log("点击了第2个按钮1", "x:" + x+" y:" + y+" stageId:"+stageId);
 
                    }
                });
                break;
            case 2://保存bin
                button.addListener(new ClickListener() {
                    public void clicked(InputEvent event, float x, float y) {
                        Gdx.app.log("点击了第3个按钮2", "x:" + x+" y:" + y+" stageId:"+stageId);
 
                    }
                });
                break;
            case 3://随机装饰(除特殊装饰外)
                button.addListener(new ClickListener() {
                    public void clicked(InputEvent event, float x, float y) {
                        Gdx.app.log("点击了第4个按钮", "x:" + x+" y:" + y+" stageId:"+stageId);
 
                    }
                });
                break;
            case 4:
                button.addListener(new ClickListener() {
                    public void clicked(InputEvent event, float x, float y) {
                        Gdx.app.log("点击了第4个按钮", "x:" + x+" y:" + y+" stageId:"+stageId);
 
                    }
                });
                break;
            case 5:
                button.addListener(new ClickListener() {
                    public void clicked(InputEvent event, float x, float y) {
                        Gdx.app.log("点击了第4个按钮", "x:" + x+" y:" + y+" stageId:"+stageId);
 
                    }
                });
                break;
            case 6:
                button.addListener(new ClickListener() {
                    public void clicked(InputEvent event, float x, float y) {
                        Gdx.app.log("点击了第5个按钮", "x:" + x+" y:" + y+" stageId:"+stageId);
 
                    }
                });
                break;
            default://查询绘制省区
                button.addListener(new ClickListener() {
                    public void clicked(InputEvent event, float x, float y) {
                        Gdx.app.log("点击了默认按钮", "x:" + x+" y:" + y);
                    }
                });
                break;
        }
    }
 
    public void resize(int width, int height) {
        // use true here to center the camera
        // that's what you probably want in case of a UI
        gameStage.getViewport().update(width, height, false);
    }
 
    //电脑
    class InputProcessorEvent implements InputProcessor {
 
        @Override
        public boolean keyDown(int keycode) {
            /*if (keycode == Keys.BACK) {
                // 处理返回事件
            } else if (keycode == Keys.MENU) {
                // 处理菜单事件
            }*/
            return true;  // 如果此处设置为false那么不会执行key up
        }
 
        @Override
        public boolean keyUp(int keycode) {
            return true;
        }
        @Override
        public boolean keyTyped(char character) {  // 可以输出按键的字母和数字，不过貌似不好使
            return true;
        }
 
        @Override
        public boolean touchDown(int screenX, int screenY, int pointer, int button) {
            return true;
        }
 
        @Override
        public boolean touchUp(int screenX, int screenY, int pointer, int button) {
            return true;
        }
 
        @Override
        public boolean touchDragged(int screenX, int screenY, int pointer) {
            return true;
        }
 
        @Override
        public boolean mouseMoved(int screenX, int screenY) {
            cx=screenX;
            cy=screenY;
            return true;
        }
 
        @Override
        public boolean scrolled(int amount) {
 
            if(amount>0) {
                mapActor.setZoom(mapActor.getZoom()+0.01f,cx,cy);
            }else {
                mapActor.setZoom(mapActor.getZoom()-0.01f,cx,cy);
            }
            //Gdx.app.log("", mapActor.getZoom()+"");
            return true;
        }
 
    }
    //触摸屏
 
    class MapListener implements GestureListener{
 
        @Override
        public boolean touchDown(float x, float y, int pointer, int button) {
            Gdx.app.log("touchDown", "x:" + x+" y:" + y);
            return false;
        }
 
        @Override
        public boolean tap(float x, float y, int count, int button) {
            Gdx.app.log("tap", "x:" + x+" y:" + y);
            return false;
        }
 
        @Override
        public boolean longPress(float x, float y) {
            Gdx.app.log("longPress", "x:" + x+" y:" + y);
            return false;
        }
 
        @Override
        public boolean fling(float velocityX, float velocityY, int button) {
            Gdx.app.log("fling", "velocityX:" + velocityX+" velocityY:" + velocityY);
            return false;
        }
 
        @Override
        public boolean pan(float x, float y, float deltaX, float deltaY) {
            Gdx.app.log("touchDown", "x:" + x+" y:" + y);
            return false;
        }
 
        @Override
        public boolean panStop(float x, float y, int pointer, int button) {
            Gdx.app.log("touchDown", "x:" + x+" y:" + y);
            return false;
        }
 
        @Override
        public boolean zoom (float originalDistance, float currentDistance){
            Gdx.app.log("zoom", "originalDistance:" + originalDistance+" currentDistance:" + currentDistance);
            //TODO 触摸缩放事件
            return false;
        }
 
        @Override
        public boolean pinch (Vector2 initialFirstPointer, Vector2 initialSecondPointer, Vector2 firstPointer, Vector2 secondPointer){
            Gdx.app.log("pinch", "");
            return false;
        }
        @Override
        public void pinchStop () {
            Gdx.app.log("pinchStop", "");
        }
 
    }
 
    private void handleInput() {
 
        // justTouched 是开始按下手指的第一个点。
        if (Gdx.input.justTouched() && isTouching == false) {
            isTouching = true;
            touchBaseX = Gdx.input.getX(0);
            touchBaseY = Gdx.input.getY(0);
            //touchBaseX += cam.position.x - GAMESTAGE_WIDTH / 2;
            //Gdx.app.log("触摸", "1");
 
            // isTouched 是结束时，手指按下的点。
        } else if (Gdx.input.isTouched(0) && isTouching == true) {
            touch_X = Gdx.input.getX(0);
            touch_Y = Gdx.input.getY(0);
            moveX=(touchBaseX-touch_X)/20;
            moveY=(touch_Y-touchBaseY)/20;
            if(moveX>50) {
                moveX=50;
            }
            if(moveX<-50) {
                moveX=-50;
            }
            if(moveY>50) {
                moveY=50;
            }
            if(moveY<-50) {
                moveY=-50;
            }
            mapActor.setX(mapActor.getX()-moveX);
            mapActor.setY(mapActor.getY()-moveY);
 
            //Gdx.app.log("移动","x:"+mapActor.getX()+" y:"+mapActor.getY());
        }else {
            isTouching =false;
        }
           /*
           if (Gdx.input.isKeyPressed(Input.Keys.A)) {
             mapActor.setZoom(mapActor.getZoom()+0.0001f,cx,cy);
           }
           if (Gdx.input.isKeyPressed(Input.Keys.Q)) {
               mapActor.setZoom(mapActor.getZoom()-0.0001f,cx,cy);
           }*/
 
        if (Gdx.input.isKeyPressed(Input.Keys.LEFT)) {
            mapActor.setX(mapActor.getX()+1);
        }
        if (Gdx.input.isKeyPressed(Input.Keys.RIGHT)) {
            mapActor.setX(mapActor.getX()-1);
        }
        if (Gdx.input.isKeyPressed(Input.Keys.DOWN)) {
            mapActor.setY(mapActor.getY()+1);
        }
        if (Gdx.input.isKeyPressed(Input.Keys.UP)) {
            mapActor.setY(mapActor.getY()-1);
        }
    }
 
    public int getStageId() {
        return stageId;
    }
 
    public void setStageId(int stageId) {
        this.stageId = stageId;
    }
}

GameScreen

package com.zhfy.game.screen.actor;
 
import java.util.ArrayList;
import java.util.List;
 
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.assets.AssetManager;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.Pixmap;
import com.badlogic.gdx.graphics.PixmapIO;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.Batch;
import com.badlogic.gdx.graphics.g2d.BitmapFont;
import com.badlogic.gdx.graphics.g2d.Sprite;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
import com.badlogic.gdx.scenes.scene2d.Actor;
import com.badlogic.gdx.scenes.scene2d.InputEvent;
import com.badlogic.gdx.scenes.scene2d.ui.Label;
import com.badlogic.gdx.scenes.scene2d.ui.Label.LabelStyle;
import com.badlogic.gdx.scenes.scene2d.utils.ClickListener;
import com.zhfy.game.config.ResConfig;
import com.zhfy.game.config.ResConfig.Map;
import com.zhfy.game.framework.ComUtil;
import com.zhfy.game.framework.GameFramework;
import com.zhfy.game.framework.GameMap;
import com.zhfy.game.framework.GameUtil;
import com.zhfy.game.model.content.BTLDAO;
import com.zhfy.game.model.content.MapBinDAO;
import com.zhfy.game.model.content.def.DefMap;
import com.zhfy.game.model.content.def.DefPt;
import com.zhfy.game.model.content.def.DefStage;
import com.zhfy.game.model.framework.Coord;
import com.zhfy.game.model.framework.SpriteDAO;
import com.zhfy.game.model.framework.SpriteListDAO;
 
public class SMapActor extends Actor {
    //做实时绘制前的备份
 
    // 本类用来存放背景地图,获取地图范围,移动,缩放背景地图,确定点击位置等,以及环状地图
    //private DefMap defMap;
    private Pixmap pixmap;// 临时画布
    private MapBinDAO mapBinDAO;
    private BTLDAO btlDao;
    private DefStage defStage;
 
    private List<Integer> coastGrid;
    private List<Integer> regionGrid;
 
    private Texture textureMain;// 主图
    private Texture textureCountry;
    private Pixmap pixmapCountry;
 
    private Sprite spriteMain;// 主图
    private Sprite spriteCountry;
    private GameFramework gameFramework;
    private float x;
    private float y;
    private int w;
    private int h;
 
    private int mapId;
    private int mapW_px;
    private int mapH_px;
    private boolean ifLoop;// 是否循环
    private boolean drawLoop;
    private float zoom;
    private float zoomMax;
    private float zoomMin;
    private float xMin;
    private float yMin;
    private float xMax;
    private float yMax;
 
    private float vw;
    private float vh;
 
    private float vx;
    private float vy;
 
    private Coord coord;
    private Coord gridCoord;
    private AssetManager am;
    Color oldColor;
    private int screenId;
    private boolean ifNeedUnload;//是否需要卸载,在资源加载完后卸载,如果未加载完退出,在退出时顺带清理资源
 
    public float getVx() {
        return vx;
    }
 
    public void setVx(float vx) {
        this.vx = vx;
    }
 
    public float getVy() {
        return vy;
    }
 
    public void setVy(float vy) {
        this.vy = vy;
    }
 
    // 颜色层
    //private Texture textureGrid;
    private SpriteDAO spriteGrid;
    private SpriteListDAO spriteGrids;
    private int gw;
    private int gh;
 
    public SMapActor(int stageId, float vw, float vh, AssetManager am, int screenId) {
        super();
        this.am=am;
        ifLoop = true;//TODO
        drawLoop=false;
        ifNeedUnload=false;
 
        this.screenId=screenId;
        // 获取defMap
 
        this.gameFramework=new GameFramework();
        defStage = gameFramework.getDefStageByStageId(stageId);
        long start = System.currentTimeMillis();
        btlDao=gameFramework.getBtlDaoByStageId(stageId);
        long end = System.currentTimeMillis();       // 记录结束时间
        Gdx.app.log("stage加载时间", (end-start)+"");
        mapBinDAO = gameFramework.getMapDaoByMapId(stageId);;
        //mapBinDAO=new MapBinDAO(btlDao);
 
        coastGrid=mapBinDAO.getIdsByAround(12);
        regionGrid=mapBinDAO.getAllRegionIds();
 
        {
            // 绘制主要图
            textureMain=  new Texture(GameMap.drawSmallMapAndClearPixmap(stageId,am));
            spriteMain= new Sprite(textureMain);
        }
 
        {
            this.x = 0;// TODO 随后设计为玩家起始位置
            this.y = 0;
            this.w = mapBinDAO.getMapWidth();
            this.h = mapBinDAO.getMapHeight();
            this.vw = vw;
            this.vh = vh;
            // 实际宽高
            this.mapW_px = textureMain.getWidth();
            this.mapH_px = textureMain.getHeight();
            this.zoom = 1f;
            this.zoomMax = 1.2f;
            this.zoomMin = 0.5f;
            this.xMax = mapW_px*this.zoom-vw;;
            this.yMax = mapH_px*this.zoom-vh;
            this.yMin = 0;
            this.xMin = 0;
 
        }
 
        /**/{//绘制一个区域图
            // 绘制画布转为装饰
            long startTime = System.currentTimeMillis();
            pixmapCountry = GameMap.createPixmap((int)(w*ResConfig.Map.SMALLMAP_SCALE),(int)(h*ResConfig.Map.SMALLMAP_SCALE));
            GameMap.getPixmapByDaoForColor(mapBinDAO,pixmapCountry,ResConfig.Map.SMALLMAP_SCALE,coastGrid);
            //PixmapIO.writePNG(Gdx.files.external("textureColor.png"), pixmapCountry);
            textureCountry=new Texture(pixmapCountry);
            long endTime = System.currentTimeMillis();    //获取结束时间
            Gdx.app.log("色图构建", " 运行时间:"+(endTime - startTime) + "ms");
            spriteCountry= new Sprite(textureCountry);
            spriteCountry.setSize(textureMain.getWidth(),textureMain.getHeight());
        }
 
        /*{
            // 绘制画布转为装饰
            pixmap = GameMap.createPixmap((int)(w*ResConfig.Map.SMALLMAP_SCALE),(int)(h*ResConfig.Map.SMALLMAP_SCALE));
            pixmap=GameMap.coverImgByPtimgId(pixmap, 2);
            gameFramework.getPixmapDecorateByDao(pixmap, mapBinDAO,am,ResConfig.Map.SMALLMAP_SCALE);
            PixmapIO.writePNG(Gdx.files.external("textureDecorate.png"), pixmap);
            pixmap.dispose();
        }*/
 
        setSize(spriteMain.getWidth(), spriteMain.getHeight());
 
        addListener(new ClickListener() {
            @Override
            public void clicked(InputEvent event, float x, float y) {//TODO 点击生成任务区域
                // 点击图片，图片隐藏![这里写图片描述](https://img-blog.csdn.net/20160425220710777)
                // super.clicked(event, x, y);
                //                // Gdx.app.log("点击的精灵位置1", "x:" + (getX()/getZoom()+x)+" y:"
                //                // +(getY()/getZoom()+ y));
                //
                //                // 由于要在actor等中使用坐标绘图,所以采用libgdx的actor坐标系
                //                // 左下为0,0,向右上方向负数扩展
                //
                //                // Gdx.app.log("点击背景位置1", "bgx:" + getX()+" bgy:" + getY()+"
                //                // zoom:" + getZoom()+" x:" + x+" y:" + y+" rgw:" +
                //                // getRegion().getRegionWidth()+" rgh:" +
                //                // getRegion().getRegionHeight());
                //                // Gdx.app.log("点击背景位置2", "actX:" + (getX()-x)/getZoom()+"
                //                // actY:"+ (getY()-y)/getZoom());
 
                //coord = GameMap.getHotCell(getImgXCoordByActX((getX() - x) / getZoom()), getImgYCoordByActY((getY() - y) / getZoom()),zoom);
 
                //Gdx.app.log("点击背景位置3", "imgX:" + getImgXCoordByActX((getX() - x) / getZoom()) + " imgY:" + getImgYCoordByActY((getY() - y) / getZoom()));
                //Gdx.app.log("点击背景位置4", "imgX:" + coord.getX() + " imgY:" + coord.getY());
                /*pixmapCountry.drawLine(200, (int)x, 50, (int)y);
                textureCountry.draw(pixmapCountry, 0, 0);*/
               // MapBinDAO mapBinDAO, Pixmap pixmap,float scale,int regionId,Color color,List<Integer> coastGrid
 
                pixmapCountry=GameMap.updateColorByRegion(mapBinDAO,pixmapCountry, Map.SMALLMAP_SCALE,regionGrid.get(ComUtil.getOneByListRand(regionGrid)),GameUtil.getColorByNum((int)(Math.random()*60000)),coastGrid);
                textureCountry.draw(pixmapCountry,0,0);
            }
        });
 
    }
 
    @Override
    public void act(float delta) {
        super.act(delta);
    }
 
    @Override
    public void draw(Batch batch, float parentAlpha) {
        super.draw(batch, parentAlpha);
        if (spriteMain == null || !isVisible()) {
            return;
        }
 
        {
            Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
            //一次性绘制
            //oldColor=batch.getColor();
            batch.draw(spriteMain, getX(), getY(), getOriginX(), getOriginY(), getWidth(), getHeight(),
                    getZoom(), getZoom(), getRotation());
            batch.draw(spriteCountry, getX(), getY(), getOriginX(), getOriginY(), getWidth(), getHeight(),
                    getZoom(), getZoom(), getRotation());
 
            //batch.setColor(Color.RED);
            if(drawLoop){
                batch.draw(spriteMain, getX()+mapW_px*this.zoom, getY(), getOriginX(), getOriginY(), getWidth(), getHeight(),
                        getZoom(), getZoom(), getRotation());
                batch.draw(spriteCountry, getX()+mapW_px*this.zoom, getY(), getOriginX(), getOriginY(), getWidth(), getHeight(),
                        getZoom(), getZoom(), getRotation());
            }
            //batch.setColor(oldColor);
 
        }
 
    }
    public float getX() {
        return x;
    }
    public void setX(float x) {
        if(ifLoop){////判断当前坐标是否需要循环显示右边
            if(x<=xMin&&x >= (-xMax * zoom + vw)){
                drawLoop=false;
            }else if(x>xMin){//从起点向左
                drawLoop=true;
                x=(-xMax  -vw)+x;
            }else if(x < (-xMax  + vw)&&x>(-xMax )){//划入右边,接近循环
                drawLoop=true;
            }else if(x<=(-xMax -vw)) {//划出并还原
                drawLoop=false;
                x = x + xMax +vw;
            }/**/
        }else {
            if (x > xMin) {
                x = xMin;
            } else if (x < -(xMax)) {
                x = -(xMax);
            }
        }
        this.x = x;
    }
 
    public float getY() {
        return y;
    }
    public void setY(float y) {
        if (y > yMin) {
            y = yMin;
        } else if (y < -yMax) {
            y = -yMax;
        }
        this.y = y;
    }
 
    public int getW() {
        return w;
    }
 
    public void setW(int w) {
        this.w = w;
    }
 
    public int getH() {
        return h;
    }
 
    public void setH(int h) {
        this.h = h;
    }
 
    public float getVw() {
        return vw;
    }
 
    public void setVw(float vw) {
        this.vw = vw;
    }
 
    public float getVh() {
        return vh;
    }
 
    public void setVh(float vh) {
        this.vh = vh;
    }
 
    public float getZoom() {
        return zoom;
    }
 
    public void setZoom(float zoom,float cx,float cy) {
        this.xMax = mapW_px*zoom-vw;;
        this.yMax = mapH_px*zoom-vh;
        this.xMin = 0;
        this.yMin = 0;
 
        if (zoom > zoomMax) {
            zoom = zoomMax;
        } else if (zoom < zoomMin) {
            zoom = zoomMin;
        } else {
            setX( x + ((x - cx) * (zoom-this.zoom)) / zoom);
            setY( y + ((y - (vh-cy)) * (zoom-this.zoom)) / zoom);
            this.zoom = zoom;
        }
 
    }
 
    // 将↓→坐标(左上角为0,0,越向右下越大)转为←↓act坐标(左下角为0,0,越向右上越小)
    public float getActXCoordByImgX(float print_x) {
        return (-print_x);
    }
 
    public float getActYCoordByImgY(float print_y) {
        return (print_y - spriteMain.getHeight());
    }
 
    // 将←↓act坐标(左下角为0,0,越向右上越小)转化为↓→坐标(左上角为0,0,越向右下越大)
    // 将↓→坐标(左上角为0,0,越向右下越大)转为←↓act坐标(左下角为0,0,越向右上越小)
    public float getImgXCoordByActX(float print_x) {
        if(print_x!=0f) {
            return (-print_x);
        }else {
            return 0f;
        }
    }
 
    public float getImgYCoordByActY(float print_y) {
        return (spriteMain.getHeight() + print_y);
    }
 
    // 清理5张图层
    public void dispose() {
        if(pixmapCountry!=null){
            pixmapCountry.dispose();
            pixmapCountry=null;
        }
        if (textureMain != null) {
            textureMain.dispose();
            textureMain=null;
        }
        if (textureCountry!=null){
            textureCountry.dispose();
            textureCountry=null;
        }
        if (ifNeedUnload) {
            GameUtil.unloadSingleResByScreenId(am, screenId);
        }
 
    }
 
    public Pixmap getPixmap() {
        return pixmap;
    }
 
    public void setPixmap(Pixmap pixmap) {
        this.pixmap = pixmap;
    }
 
    public MapBinDAO getMapBinDAO() {
        return mapBinDAO;
    }
 
    public void setMapBinDAO(MapBinDAO mapBinDAO) {
        this.mapBinDAO = mapBinDAO;
    }
 
    public Texture gettextureMain() {
        return textureMain;
    }
 
    public void settextureMain(Texture textureMain) {
        this.textureMain = textureMain;
    }
 
    public Sprite getspriteMain() {
        return spriteMain;
    }
 
    public void setspriteMain(Sprite spriteMain) {
        this.spriteMain = spriteMain;
    }
 
    public SpriteDAO getSpriteGrid() {
        return spriteGrid;
    }
 
    public void setSpriteGrid(SpriteDAO spriteGrid) {
        this.spriteGrid = spriteGrid;
    }
 
    public float getZoomMax() {
        return zoomMax;
    }
 
    public void setZoomMax(float zoomMax) {
        this.zoomMax = zoomMax;
    }
 
    public int getGw() {
        return gw;
    }
 
    public void setGw(int gw) {
        this.gw = gw;
    }
 
    public int getGh() {
        return gh;
    }
 
    public void setGh(int gh) {
        this.gh = gh;
    }
 
    public SpriteListDAO getSpriteGrids() {
        return spriteGrids;
    }
 
    public void setSpriteGrids(SpriteListDAO spriteGrids) {
        this.spriteGrids = spriteGrids;
    }
}

SMapActor

package com.zhfy.game.framework;
 
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
 
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.assets.AssetManager;
import com.badlogic.gdx.files.FileHandle;
import com.badlogic.gdx.graphics.Pixmap;
import com.badlogic.gdx.graphics.Pixmap.Format;
import com.badlogic.gdx.graphics.PixmapIO;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.TextureData;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
import com.badlogic.gdx.scenes.scene2d.Stage;
import com.badlogic.gdx.utils.Array;
import com.badlogic.gdx.utils.XmlReader;
import com.badlogic.gdx.utils.XmlReader.Element;
import com.badlogic.gdx.utils.viewport.StretchViewport;
import com.zhfy.game.MainGame;
import com.zhfy.game.config.ResConfig;
import com.zhfy.game.framework.tool.BTLTooL;
import com.zhfy.game.framework.tool.FSearchTool;
import com.zhfy.game.model.content.BTLDAO;
import com.zhfy.game.model.content.MapBinDAO;
import com.zhfy.game.model.content.def.DefMap;
import com.zhfy.game.model.content.def.DefPt;
import com.zhfy.game.model.content.def.DefStage;
import com.zhfy.game.model.content.def.DefTerrainimg;
import com.zhfy.game.model.framework.PixmapDAO;
import com.zhfy.game.model.framework.PixmapListDAO;
import com.zhfy.game.model.framework.TextureDAO;
import com.zhfy.game.model.framework.TextureListDAO;
import com.zhfy.game.model.framework.TextureRegionDAO;
import com.zhfy.game.model.framework.TextureRegionListDAO;
import com.zhfy.game.screen.actor.base.BaseActor;
 
public class GameFramework {
 
    //private TextureListDAO imgLists;
 
    //private Texture imgBg;
 
    //private List<Stage> stages;
 
    private byte[] bt;// 等待清空
 
    //private MapBinDAO mapBinDao;// 等待清空
 
    //private Pixmap pixmap;// 使用完就清空
 
    //private PixmapListDAO pixmapLists;// 使用完就清空
 
    private FSearchTool tool ;//哪个用到哪个初始化
 
    /*//TODO
    // 通过使用场景来清理图片
    public void textureDispose(int beforeScreenId,int nextScreenId) {
        Gdx.app.log("执行了内存销毁 " ," screenId:"+beforeScreenId);
        //获取当前场景,下一个场景要加载的资源图
        //比对资源,把不用的资源清除掉
        // 通过使用场景id获取图片名集合
        List<String> nameList = getTextureNameByScreenId(beforeScreenId);
        // 根据图片名集合清理资源
        imgLists.clearTexture(nameList);
        // 清理背景图
        if (imgBg != null) {
            imgBg.dispose();
            imgBg = null;
        }
    }*/
 
    // 通过screenId获取要读取的图片资源
    public List<String> getTextureNameByScreenId(int screenId) {
        List<String> strs = new ArrayList<String>();
        XmlReader reader = ResConfig.reader;
        Element root = ResConfig.ConfigScreen;
        int childNum = root.getChildCount();
        for (int i = 0; i < childNum; i++) {
            if (root.getChild(i).getInt("id") == screenId) {
                Array<Element> xmlFiles = root.getChild(i)
                        .getChildrenByNameRecursively("xmlFile");
                for (Element xmlFile : xmlFiles) {
                    strs.add(xmlFile.get("name"));
                }
                break;
            }
        }
        return strs;
    }
 
    /*// 根据screenid,获取要加载的资源
    public TextureRegionListDAO getTextureReigonByScreenId(int screenId) {
        // 验证imgLists是否有东西
        List<String> nameList = getTextureNameByScreenId(screenId);
        TextureRegionListDAO imgList = new TextureRegionListDAO();
        for (int i = 0; i < nameList.size(); i++) {
            XmlReader reader = ResConfig.reader;
            *//**
             * root是整个xml文件从根节点算起，此处是指<Credits> </Credits>
             *//*
            Element root = reader.parse(
                    Gdx.files.internal("image/" + nameList.get(i) + ".xml"));
            String imgFile = root.getAttribute("imagePath");
            // 每个图片添加的时候都要加使用场景,多场景用;分割screenid="1"
            Array<Element> images = root.getChildrenByNameRecursively("sprite");
            for (Element image : images) {
                TextureRegion imgRegion = new TextureRegion(
                        imgLists.getName(nameList.get(i)).getTexture(),
                        image.getInt("x"), image.getInt("y"), image.getInt("w"),
                        image.getInt("h"));
                TextureRegionDAO imgRegionDAO = new TextureRegionDAO();
                imgRegionDAO.setTextureRegion(imgRegion);
                imgRegionDAO.setRefx(image.getInt("refx"));
                imgRegionDAO.setRefy(image.getInt("refy"));
                imgRegionDAO.setName(image.get("n").replace(".png", ""));
                imgList.add(imgRegionDAO);
                // Gdx.app.log("getImgName",image.get("n").replace(".png", "")+"
                // x:"+image.getInt("refx")+" y:"+image.getInt("refy"));
            }
        }
        imgList.check();
        return imgList;
    }*/
 
    /*// 根据imgName,获取要加载的资源
    public TextureRegionListDAO getTextureReigonByImgFileName(
            String imgFileName) {
        // 验证imgLists是否有东西
        TextureRegionListDAO imgList = new TextureRegionListDAO();
        XmlReader reader = ResConfig.reader;
        Element root = reader
                .parse(Gdx.files.internal("image/" + imgFileName + ".xml"));
        String imgFile = root.getAttribute("imagePath");
        // 每个图片添加的时候都要加使用场景,多场景用;分割screenid="1"
        Array<Element> images = root.getChildrenByNameRecursively("sprite");
        for (Element image : images) {
            TextureRegion imgRegion = new TextureRegion(
                    imgLists.getName(imgFileName).getTexture(),
                    image.getInt("x"), image.getInt("y"), image.getInt("w"),
                    image.getInt("h"));
            TextureRegionDAO imgRegionDAO = new TextureRegionDAO();
            imgRegionDAO.setTextureRegion(imgRegion);
            imgRegionDAO.setRefx(image.getInt("refx"));
            imgRegionDAO.setRefy(image.getInt("refy"));
            imgRegionDAO.setName(image.get("n").replace(".png", ""));
            imgList.add(imgRegionDAO);
            // Gdx.app.log("getImgName",image.get("n").replace(".png", "")+"
            // x:"+image.getInt("refx")+" y:"+image.getInt("refy"));
        }
        imgList.check();
        return imgList;
    }*/
 
    // TODO 未验证
    // 根据imgName,获取要加载的资源
    /*public PixmapListDAO getPixmapByImgFileName(String fileName) {
        PixmapListDAO pixmapLists=new PixmapListDAO();
        // 验证pixmapLists是否有东西
        XmlReader reader = ResConfig.reader;
        Element root = reader
                .parse(Gdx.files.internal("pixmap/" + fileName + ".xml"));
        // 每个图片添加的时候都要加使用场景,多场景用;分割screenid="1"
        Array<Element> images = root.getChildrenByNameRecursively("sprite");
        for (Element image : images) {
            PixmapDAO pixmapDAO = new PixmapDAO();
            pixmapDAO.setPixmap( new Pixmap(Gdx.files.internal("pixmap/"+image.get("n"))));;
            pixmapDAO.setRefx(image.getInt("refx"));
            pixmapDAO.setRefy(image.getInt("refy"));
            pixmapDAO.setName(image.get("n").replace(".png", ""));
            pixmapLists.add(pixmapDAO);
        }
        pixmapLists.check();
        return pixmapLists;
    }*/
 
   /* // 根据screenId获取加载的背景图名称
    public Texture getBgTextureByScreenId(int screenId,AssetManager as) {
        XmlReader reader = ResConfig.reader;
        String str = "";
        Element root = ResConfig.ConfigScreen;
        int childNum = root.getChildCount();
        for (int i = 0; i < childNum; i++) {
            if (root.getChild(i).getInt("id") == screenId) {
                str = root.getChild(i).get("bgImg");
                //imgBg = new Texture(Gdx.files.internal("image/" + str + ".png"));
                imgBg =as.get("image/" + str + ".png", Texture.class);
                return imgBg;
            }
        }
        return null;
    }*/
 
    // 根据screenId来把资源存入 getResourceByScreentId
    /*public void init(int screenId) {
        imgLists = new TextureListDAO();
        List<String> nameList = getTextureNameByScreenId(screenId);
        //stages = new ArrayList<Stage>();
 
        for (int i = 0; i < nameList.size(); i++) {
            XmlReader reader = ResConfig.reader;
            *//**
             * root是整个xml文件从根节点算起，此处是指<Credits> </Credits>
             *//*
            Element root = reader.parse(
                    Gdx.files.internal("image/" + nameList.get(i) + ".xml"));
            String imgFile = root.getAttribute("imagePath");
            // 加入临时文件
            TextureDAO tempImgDao = new TextureDAO();
            tempImgDao.setName(imgFile.toString().substring(0,
                    imgFile.toString().lastIndexOf(".")));
            tempImgDao.setTexture(
                    new Texture(Gdx.files.internal("image/" + imgFile)));
            imgLists.add(tempImgDao);
            // Gdx.app.log( "setImgName", imgFile.toString().substring(0,
            // imgFile.toString().lastIndexOf(".")));
        }
    }*/
 
    // 根据配置文件生成相关stage对象并返回
    // stage相当于一个窗口,一个游戏场景由一个或多个窗口组成
    // 暂时废弃
   /* public List<Stage> getStagesByScreenId(int screenId) {
        Stage stage = new Stage(new StretchViewport(ResConfig.FIX_WORLD_WIDTH,
                Gdx.graphics.getHeight() * ResConfig.FIX_WORLD_WIDTH / Gdx.graphics.getWidth()));
        GameFramework framework = new GameFramework();
        // 根据screenId获取下级元素
        XmlReader reader = ResConfig.reader;
        Element root = reader
                .parse(Gdx.files.internal("config/config_layout.xml"));
        int childNum = root.getChildCount();
        for (int i = 0; i < childNum; i++) {
            if (root.getChild(i).getInt("screenId") == screenId) {
                // 绘制背景图
                imgBg = new Texture(Gdx.files.internal(
                        "image/" + root.getChild(i).get("bg") + ".png"));
                BaseActor actor = new BaseActor(new TextureRegion(imgBg));
                stage.addActor(actor);
                // 如果defaultWinId不为空,则查找对应win
                if (!root.getChild(i).get("defaultWinId").equals("")) {
                    int childNum1 = root.getChild(i).getChildCount();
 
                    for (int i1 = 0; i1 < childNum1; i1++) {
                        // 生成win下的各个组件 pixmap 拼合图 textures 装饰图 buttons 按钮
                        Element pixmaps = root.getChild(i).getChild(i1)
                                .getChildByName("pixmaps");
                        // Gdx.app.log("imgs",imgs.size+"");
                        // 临时-拼合图
                        {
                            Array<Element> pixmapList = pixmaps
                                    .getChildrenByNameRecursively("pixmap");
                            for (Element pixmap : pixmapList) {
                                Array<Element> imgs = pixmap
                                        .getChildrenByNameRecursively("img");
                                // Gdx.app.log("imgs",imgs.size+"");
                                for (Element img : imgs) {
 
                                }
                            }
                        }
                        Element textures = root.getChild(i).getChild(i1)
                                .getChildByName("textures");
                        // 装饰图
                        {
 
                        }
 
                        Element buttons = root.getChild(i).getChild(i1)
                                .getChildByName("buttons");
                        // 按钮
                        {
 
                        }
 
                        if (stage != null) {
                            //stages.add(stage);
                        }
                        // 打开默认窗口
                    }
                }
            }
        }
        return null;
    }*/
 
    // 根据mapid生成MapBinDAO类 画全图
    public MapBinDAO getMapDaoByMapId(int mapId) {
        XmlReader reader = ResConfig.reader;
        String str = "";
        Element root = reader.parse(Gdx.files.internal("config/def_map.xml"));
        int childNum = root.getChildCount();
        MapBinDAO mapBinDao=null;
        for (int i = 0; i < childNum; i++) {
            if (root.getChild(i).getInt("id") == mapId) {
                str = root.getChild(i).get("name");
                //TODO 安卓不能加载,会闪退
                bt = Gdx.files.local("bin/" + str + ".bin").readBytes();
                //bt = Gdx.files.internal("bin/" + str + ".bin").readBytes();
                try {
                    mapBinDao = GameMap.saveBin(bt);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return mapBinDao;
            }
        }
        return mapBinDao;
    }
 
    public BTLDAO getBtlDaoByStageId(int stageId) {
        XmlReader reader = ResConfig.reader;
        String str = "";
       // FileHandle file = Gdx.files.internal("rule/rule_fb1_btl.xml");
        Element root = reader.parse(Gdx.files.internal("config/def_stage.xml"));
        int childNum = root.getChildCount();
        BTLDAO btlDao=null;
 
        for (int i = 0; i < childNum; i++) {
            if (root.getChild(i).getInt("id") == stageId) {
                str = root.getChild(i).get("name");
                bt = Gdx.files.internal("stage/" + str + ".btl").readBytes();
                try {
                    btlDao = BTLTooL.LoadBtl("rule/rule_fb1_btl.xml",bt);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return btlDao;
            }
        }
        return btlDao;
    }
 
    //根据传入的地图编号保存地图
    public void saveMapDaoByMapId(MapBinDAO mapbin,int mapId) {
        XmlReader reader = ResConfig.reader;
        String str = "";
        Element root = reader.parse(Gdx.files.internal("config/def_map.xml"));
        int childNum = root.getChildCount();
        for (int i = 0; i < childNum; i++) {
            if (root.getChild(i).getInt("id") == mapId) {
                str = root.getChild(i).get("name");
                String path="bin/" + str + ".bin";
                GameMap.saveMapBin(mapbin,path);
            }
        }
    }
 
    //根据MapId获得地图属性
    public DefMap getDefMapByMapId(int id) {
        DefMap defMap = new DefMap();
        List<DefMap> defMaps = new ArrayList<DefMap>();
        try {
            defMaps = GameUtil.getDaoListByClass(defMap, "config/def_map.xml");
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (defMaps != null) {
            try {
                tool= new FSearchTool(defMaps, "id");
                return (DefMap) tool.searchTask((id+""));
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
 
        }
        return null;
    }
 
  //根据MapId获得地图属性
    public DefStage getDefStageByStageId(int id) {
        DefStage defStage = new DefStage();
        List<DefStage> defStages = new ArrayList<DefStage>();
        try {
            defStages = GameUtil.getDaoListByClass(defStage, "config/def_stage.xml");
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (defStages != null) {
            try {
                tool= new FSearchTool(defStages, "id");
                return (DefStage) tool.searchTask((id+""));
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
 
        }
        return null;
    }
 
 // 依据id画全图
    public Texture getMapByMapId(int id,AssetManager am,float scale)  {
        // 2.1加载图片资源 一次性使用 用完就删
        //TextureRegionListDAO mapRegionList = getTextureReigonByImgFileName("bt_tiles");
        PixmapListDAO pixmapLists=getPixmapListByFileName("pm_tiles",am);
 
        MapBinDAO mapBinDao=null;
 
        // 2.2加载地图属性
        DefTerrainimg defTerrainimg = new DefTerrainimg();
        DefMap defMap = new DefMap();
        List<DefTerrainimg> defTerrainimgs = new ArrayList<DefTerrainimg>();
        List<DefMap> defMaps = new ArrayList<DefMap>();
        boolean state=false;
 
        try {
            defTerrainimgs = GameUtil.getDaoListByClass(defTerrainimg,
                    "config/def_terrainimg.xml");
            defMaps = GameUtil.getDaoListByClass(defMap, "config/def_map.xml");
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 2.3加载bin
        mapBinDao = getMapDaoByMapId(id);
 
        // 2.4读取map.xml获取地图属性
        if (defMaps != null) {
            /*for (int i = 0; i < defMaps.size(); i++) {
                if (defMaps.get(i).getId() == id) {
                    defMap = defMaps.get(i);
                    state=true;
                    break;
                }
            }*/
 
            try {
                tool= new FSearchTool(defMaps, "id");
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            defMap =(DefMap) tool.searchTask((id+""));
            if(defMap!=null) {
                state=true;
            }
        }
 
        if(state) {
            Gdx.app.log("存在地图:", "继续");
        }else {
            Gdx.app.log("不存在地图:", "终止");
            return null;
        }
 
        // 2.5生成Pixmap
        Pixmap  pixmap=GameMap.createPixmapByDefMap(defMap);
        //绘制底纹
        pixmap=GameMap.coverImgByPtimgId(pixmap,2);
 
        long startTime = System.currentTimeMillis();    //获取开始时间
        //绘图
        pixmap=GameMap.getPixmapByDao(mapBinDao,pixmap,pixmapLists,defTerrainimgs,0,mapBinDao.getMapbin().size(),scale);
        long endTime = System.currentTimeMillis();    //获取结束时间
 
        Gdx.app.log("地图构建", " 运行时间:"+(endTime - startTime) + "ms");
 
        // 再由新的 Pixmap 对象生成一个新的 Texture 对象
         Texture textureMap = new Texture(pixmap, Format.RGBA8888,false);
        if(pixmap!=null) {
            //这里输出截图进行测试
            //PixmapIO.writePNG(Gdx.files.external(defMap.getName()+".png"), pixmap);
            pixmap.dispose();
            //Gdx.app.log("地图图片保存", "成功");
        }
        //clearPixmapListByFileName("pm_tiles");
        return textureMap;
    }
 
    // 根据条件画图
    public Pixmap getPixmapDecorateByDao(Pixmap pixmap,MapBinDAO mapBinDao,AssetManager am,float scale)  {
        // 2.1加载图片资源 一次性使用 用完就删
        //TextureRegionListDAO mapRegionList = getTextureReigonByImgFileName("bt_tiles");
        PixmapListDAO pixmapLists=getPixmapListByFileName("pm_tiles",am);
 
        // 2.2加载地图属性
        DefTerrainimg defTerrainimg = new DefTerrainimg();
        List<DefTerrainimg> defTerrainimgs = new ArrayList<DefTerrainimg>();
 
        try {
            defTerrainimgs = GameUtil.getDaoListByClass(defTerrainimg,
                    "config/def_terrainimg.xml");
        } catch (Exception e) {
            e.printStackTrace();
        }
 
        long startTime = System.currentTimeMillis();    //获取开始时间
        //绘图
        pixmap=GameMap.getPixmapByDao(mapBinDao,pixmap,pixmapLists,defTerrainimgs,0,mapBinDao.getMapbin().size(),scale);
        long endTime = System.currentTimeMillis();    //获取结束时间
        Gdx.app.log("地图构建", " 运行时间:"+(endTime - startTime) + "ms");
 
        //clearPixmapListByFileName("pm_tiles");
        return pixmap;
    }
 
    //根据条件给陆地打孔 废弃
   /* public Pixmap getLandByDAO(MapBinDAO mapBinDAO, Pixmap pixmap, int mapx, int mapy,int mapw,int maph) {
        //加载打孔图片
        PixmapListDAO pixmapLists=getPixmapListByFileName("pm_shadow");
        pixmap=GameMap.getLandByDAO(mapBinDAO,pixmap,pixmapLists,mapx,mapy,mapw,maph);
        //clearPixmapListByFileName("pm_shadow");
        return pixmap;
    }*/
 
    //加载内存图片PixmapListDAO pixmapLists 目标pm_tiles 则传入pm_tiles TODO
    public static PixmapListDAO getPixmapListByFileName(String fileName,AssetManager am) {
        //1读取路径下说明文件
        XmlReader reader = ResConfig.reader;
        Element root = reader
                .parse(Gdx.files.internal("pixmap/"+fileName.substring(3)+"/" + fileName + ".xml"));
        // 每个图片添加的时候都要加使用场景,多场景用;分割screenid="1"
        Array<Element> images = root.getChildrenByNameRecursively("sprite");
        //验证pixmapLists是否有东西
            PixmapListDAO   pixmapLists=new PixmapListDAO();
        //2根据说明文件添加到pixmapLists
        for (Element image : images) {
            PixmapDAO pixmapDAO = new PixmapDAO();
            //pixmapDAO.setPixmap( new Pixmap(Gdx.files.internal("pixmap/"+fileName.substring(3)+"/" +image.get("n"))));;
            pixmapDAO.setPixmap(am.get("pixmap/"+fileName.substring(3)+"/" +image.get("n"),Pixmap.class));
 
            pixmapDAO.setRefx(image.getInt("refx"));
            pixmapDAO.setRefy(image.getInt("refy"));
            pixmapDAO.setName(image.get("n").replace(".png", ""));
            pixmapLists.add(pixmapDAO);
        }
        pixmapLists.check();
        return pixmapLists;
    }
    //清除内存图片PixmapListDAO pixmapLists
    /*public void clearPixmapListByFileName(String fileName) {
        //1读取路径下说明文件
        //2根据说明文件移除pixmapLists的内容,并depose
        XmlReader reader = ResConfig.reader;
        Element root = reader
                .parse(Gdx.files.internal("pixmap/"+fileName.substring(3)+"/" + fileName + ".xml"));
        // 每个图片添加的时候都要加使用场景,多场景用;分割screenid="1"
        Array<Element> images = root.getChildrenByNameRecursively("sprite");
        for (Element image : images) {
            pixmapLists.remove(image.get("n").replace(".png", ""));
        }
        pixmapLists.check();
    }*/
 
}

GameFramework

package com.zhfy.game.model.content;

import java.io.BufferedInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.Pixmap;
import com.zhfy.game.framework.ComUtil;
import com.zhfy.game.framework.GameMap;
import com.zhfy.game.framework.GameUtil;
import com.zhfy.game.model.content.btl.BtlModule1;
import com.zhfy.game.model.content.def.DefMap;
import com.zhfy.game.model.content.def.DefTerrainimg;
import com.zhfy.game.model.framework.Coord;

public class MapBinDAO {

    public int mapVersion;// 2-地图版本
    public int mapWidth;// 4-长
    public int mapHeight;// 4-宽
    public List<MapBin> MapBin;// 

    //写死了
    public MapBinDAO(BTLDAO btlDao){
        if(btlDao!=null) {
            mapVersion=1;
            mapWidth=Integer.parseInt(btlDao.getBm0().getBm0_13());
            mapHeight=Integer.parseInt(btlDao.getBm0().getBm0_14());
            MapBin=new ArrayList<MapBin>();
            MapBin mapBin;
            for(BtlModule1 bm1:btlDao.getBm1()) {
                mapBin=new MapBin();
                mapBin.setBlockType(Integer.parseInt(bm1.getBm1_1()));
                mapBin.setBackTile(Integer.parseInt(bm1.getBm1_2()));
                mapBin.setBackIdx(Integer.parseInt(bm1.getBm1_3()));
                mapBin.setBackRefX(Integer.parseInt(bm1.getBm1_4()));
                mapBin.setBackRefY(Integer.parseInt(bm1.getBm1_5()));
                mapBin.setWaterPass(Integer.parseInt(bm1.getBm1_6()));
                mapBin.setLandPass(Integer.parseInt(bm1.getBm1_7()));
                mapBin.setRegionId(Integer.parseInt(bm1.getBm1_8()));
                mapBin.setClimateId(Integer.parseInt(bm1.getBm1_9()));
                mapBin.setBuildId(Integer.parseInt(bm1.getBm1_10()));
                mapBin.setBuildLv(Integer.parseInt(bm1.getBm1_11()));
                mapBin.setFacility(Integer.parseInt(bm1.getBm1_12()));
                mapBin.setAreaId(Integer.parseInt(bm1.getBm1_13()));
                MapBin.add(mapBin);
            }
        }
    }

    public int getMapVersion() {
        return mapVersion;
    }

    public void setMapVersion(int mapVersion) {
        this.mapVersion = mapVersion;
    }

    public int getMapWidth() {
        return mapWidth;
    }

    public void setMapWidth(int mapWidth) {
        this.mapWidth = mapWidth;
    }

    public int getMapHeight() {
        return mapHeight;
    }

    public void setMapHeight(int mapHeight) {
        this.mapHeight = mapHeight;
    }

    public List<MapBin> getMapbin() {
        return MapBin;
    }

    public void setMapbin(List<MapBin> MapBin) {
        this.MapBin = MapBin;
    }

    public void initRegionId() {
        int i, iMax;
        iMax = MapBin.size();
        for (i = 0; i < iMax; i++) {
            MapBin.get(i).setRegionId(i);
        }
    }

    //随机装饰(除特殊装饰,以及ref有值的外)
    public void randomAllDecoration() {
        Random rand = new Random();
        //储存地块最高范围
        Map map = GameMap.getDecorateRandMaxMap(); //Map(id_type+"_min",idx_min) Map(id_type+"_max",idx_max)
        //循环遍历所有地块
        int i;
        int iLength = MapBin.size();
        int vMin, vMax;
        for (i = 0; i < iLength; i++) {
            /*
             * if(MapBin.get(i).getBackTile()==5) { Gdx.app.log("MapBin.i:",
             * "imin:"+(MapBin.get(i).getBackTile()+"_"+MapBin.get(i).
             * getBlockType()+"_min")+" imax:"+(MapBin.get(i).getBackTile()+"_"+
             * MapBin.get(i).getBlockType()+"_max")); }
             */
            if (map.containsKey(MapBin.get(i).getBackTile() + "_" + MapBin.get(i).getBlockType() + "_min") && map.containsKey(MapBin.get(i).getBackTile() + "_" + MapBin.get(i).getBlockType() + "_max") && MapBin.get(i).getBackRefX() == 0 && MapBin.get(i).getBackRefY() == 0) {

                vMin = (Integer) map.get(MapBin.get(i).getBackTile() + "_" + MapBin.get(i).getBlockType() + "_min");
                vMax = (Integer) map.get(MapBin.get(i).getBackTile() + "_" + MapBin.get(i).getBlockType() + "_max");
                //Gdx.app.log("", " backTile:"+MapBin.get(i).getBackTile()+" type:"+MapBin.get(i).getBackTile()+" max:"+map.get(MapBin.get(i).getBackTile()+"_"+MapBin.get(i).getBlockType()+"_max")+" min:"+map.get(MapBin.get(i).getBackTile()+"_"+MapBin.get(i).getBlockType()+"_min")+" backIdx:"+backIdx);
                MapBin.get(i).setBackIdx(rand.nextInt(vMax - vMin + 1) + vMin);
            }
            if (map.containsKey(MapBin.get(i).getForeTile() + "_" + MapBin.get(i).getBlockType() + "_min") && map.containsKey(MapBin.get(i).getForeTile() + "_" + MapBin.get(i).getBlockType() + "_max") && MapBin.get(i).getForeRefX() == 0 && MapBin.get(i).getForeRefY() == 0) {
                vMin = (Integer) map.get(MapBin.get(i).getForeTile() + "_" + MapBin.get(i).getBlockType() + "_min");
                vMax = (Integer) map.get(MapBin.get(i).getForeTile() + "_" + MapBin.get(i).getBlockType() + "_max");
                //Gdx.app.log("", " backTile:"+MapBin.get(i).getBackTile()+" type:"+MapBin.get(i).getBackTile()+" max:"+map.get(MapBin.get(i).getBackTile()+"_"+MapBin.get(i).getBlockType()+"_max")+" min:"+map.get(MapBin.get(i).getBackTile()+"_"+MapBin.get(i).getBlockType()+"_min")+" backIdx:"+backIdx);
                MapBin.get(i).setForeIdx(rand.nextInt(vMax - vMin + 1) + vMin);
            }
        }
    }

    //随机增加2层装饰
    public void randomForeDecoration() {
        int foreId, vMin, vMax;
        Random rand = new Random();
        //储存地块最高范围
        Map map = GameMap.getDecorateRandMaxMap();
        //循环遍历所有地块
        int i;
        int iLength = MapBin.size();
        Object o1;

        for (i = 0; i < iLength; i++) {
            //配对规则
            //4丘陵 4 5 6
            //5山地 4 5 6
            //6森林 4 5 6
            if (rand.nextInt(100) < 31 && map.containsKey(MapBin.get(i).getBackTile() + "_" + MapBin.get(i).getBlockType() + "_min") && map.containsKey(MapBin.get(i).getBackTile() + "_" + MapBin.get(i).getBlockType() + "_max") && MapBin.get(i).getBackTile() > 3 && MapBin.get(i).getBackTile() < 7) {
                foreId = 4 + rand.nextInt(3);
                MapBin.get(i).setForeTile(foreId);
                o1 = map.get(foreId + "_" + MapBin.get(i).getBlockType() + "_min");
                if (o1 != null && MapBin.get(i).getForeRefX() == 0 && MapBin.get(i).getForeRefY() == 0) {
                    vMin = (Integer) map.get(foreId + "_" + MapBin.get(i).getBlockType() + "_min");
                    vMax = (Integer) map.get(foreId + "_" + MapBin.get(i).getBlockType() + "_max");
                    //Gdx.app.log("", " backTile:"+MapBin.get(i).getBackTile()+" type:"+MapBin.get(i).getBackTile()+" max:"+map.get(MapBin.get(i).getBackTile()+"_"+MapBin.get(i).getBlockType()+"_max")+" min:"+map.get(MapBin.get(i).getBackTile()+"_"+MapBin.get(i).getBlockType()+"_min")+" backIdx:"+backIdx);
                    MapBin.get(i).setForeIdx(rand.nextInt(vMax - vMin + 1) + vMin);
                }
            } else {
                MapBin.get(i).setForeTile(0);
                MapBin.get(i).setForeIdx(0);
            }
        }
    }

    //规则 有建筑或有地名的区块=id 否则为0
    public void resetRegionId() {
        int i;
        int iMax = MapBin.size();
        for (i = 0; i < iMax; i++) {
            if (MapBin.get(i).getAreaId() == 0 && MapBin.get(i).getBuildId() == 0) {
                MapBin.get(i).setRegionId(0);
            } else {
                MapBin.get(i).setRegionId(i);
            }
        }
    }

    //根据纬度生成随机气候 TODO
    public void randomClimate() {

    }

    //随机海岸河流 TODO
    public void randomCoastRever() {

    }

    //完全随机地图 TODO
    public void randomAll(int i) {

    }

    //重新切割省区 TODO
    public void cutRegion() {
        Random rand = new Random();
        int tempId, exct = 0, i = 0, iMax = 0, j, jMax, rsct, riSize;
        List<Integer> regions = null;
        List<Integer> temps = null;
        Map regionCountMap = new HashMap();
        Boolean ifSea =false;

        for (j = 0; j < 5; j++) {
            exct=0;
            regions = getRegions(j);
            Gdx.app.log("阶段1", "核心地块数" + regions.size()+"获得地块类:"+j); //循环 挨个对核心地块进行循环
            while (exct < 20-j && regions.size() != 0) {
                for (i = regions.size() - 1; i >= 0; i--) {
                    tempId = getRegionId(regions.get(i));
                    if(!ifSea){//判断海洋,移除
                        if(tempId>=0&&MapBin.get(tempId).getBlockType()==1){
                            tempId=-1;
                        }
                    }
                    if (tempId >= 0) {
                        riSize = getIdByRegion(tempId).size();
                        if (riSize > (13 + Math.random() * 5)) {
                            regions.remove(i);
                        } else {
                            MapBin.get(tempId).setRegionId(regions.get(i));
                        }
                    } else {
                        regions.remove(i);
                    }
                }
                Gdx.app.log("阶段2", "核心地块数" + regions.size() + " 循环次数:" + exct);
                exct++;
            }
        }
        //循环2 自定义随机地块 // 随机一定条件取核心值
        //循环挨个核心地块循环 //如果核心地块周围有非核心地块的空地且面积不超过一定值,则染色(条件可放宽),否则移除,直到移除全部地块
        {
            regions = getRegionIdsByChance((int) 5,ifSea);
            rsct = getRegionForIdIs0();
            Gdx.app.log("阶段3", "剩余绘制数" + rsct);
            for (Integer rg : regions) {
                if(!ifSea&&MapBin.get(rg).getBlockType()==1){

                }else{
                    MapBin.get(rg).setRegionId(rg);
                }

            }
        }

        int rgc = 0;//可用地块
        while (rsct > 0) {//空白地块不能等于0
            jMax = regions.size();
            if(jMax==0) {
                break;
            }
            for (j = jMax - 1; j >= 0; j--) {//regions.get(j)为当前地块值
                //定义当前地块为特定地块 //循环填充周围地块
                iMax=(int)(10 + Math.random() * 10);
                for (i = 0; i < iMax; i++) {
                    rgc = getRegionId(regions.get(j));
                    if (rgc == -1) {
                        regions.remove(regions.get(j));
                        break;
                    } else {
                        MapBin.get(rgc).setRegionId(regions.get(j));
                    }
                }
            }
            rsct = getRegionForIdIs0();
            Gdx.app.log("阶段3", "剩余绘制数" + rsct + " 核心地块数:" + regions.size());
        }

        /* 自检,合并不规范地块 */
        {
            //0查看所有region为0的地块并合并到周围地块
            {
                regions = getIdsForBlankRegion();
                for (Integer region : regions) {//rsCoords.size()  rand.nextInt(
                    temps = getAroundIdById(region, 9);
                    if (temps.size() != 0) {
                        MapBin.get(region).setRegionId(temps.get(rand.nextInt(temps.size())));
                    } else {
                        //此时剩下的应该是碎小的岛屿或水洞
                        temps = getAroundIdById(region, 0);
                        if (temps.size() != 0) {
                            MapBin.get(region).setRegionId(temps.get(rand.nextInt(temps.size())));
                        } else {
                            Gdx.app.log("警告:有空白地块无法合并到周围地块:", region + "");
                        }

                    }
                }
            }
            //对所有region数量进行检查
            //Map.Entry entry;
            int rgct, argId;
            List<Integer> argIds, regionCounts;
            {
                checkRegion();

                regionCountMap = getRegionCountMap();
                regionCounts = ComUtil.getKeyByMap(regionCountMap);
                for (Integer rgId : regionCounts) {
                    if (regionCountMap.containsKey(rgId) && regionCountMap.get(rgId) != null) {
                        rgct = Integer.parseInt(regionCountMap.get(rgId).toString());
                        if (rgct < 7) {
                            if (MapBin.get(rgId).getBuildId() == 1) {
                                //0:低于5的城市合并周围的最低地块普通或建筑地块(小于5)
                                argIds = getAroundRegionId(rgId);//获取周围地块
                                for (Integer tarId : argIds) {
                                    if (Integer.parseInt(regionCountMap.get(tarId).toString()) < 6 && MapBin.get(tarId).getBuildId() != 1 && MapBin.get(tarId).getBlockType() != 1) {
                                        updateRegionIds(rgId, tarId);
                                        regionCountMap.put(rgId, (Integer.parseInt(regionCountMap.get(tarId).toString()) + Integer.parseInt(regionCountMap.get(rgId).toString())));
                                        regionCountMap.remove(tarId);
                                        break;
                                    }
                                }
                            } else if (MapBin.get(rgId).getBuildId() == 4) {
                                if(ifSea) {//如果容许海洋,则合并
                                    //1:低于5的海港合并周围的最低海洋地块(小于5)
                                    argIds = getAroundRegionId(rgId);//获取周围地块
                                    for (Integer tarId : argIds) {
                                        if (Integer.parseInt(regionCountMap.get(tarId).toString()) < 6 && MapBin.get(tarId).getBuildId() != 4 && MapBin.get(tarId).getBlockType() == 1) {
                                            updateRegionIds(rgId, tarId);
                                            regionCountMap.put(rgId, (Integer.parseInt(regionCountMap.get(tarId).toString()) + Integer.parseInt(regionCountMap.get(rgId).toString())));
                                            regionCountMap.remove(tarId);
                                            break;
                                        }
                                    }
                                }else{
                                    //否则把海港归到最近的地块
                                    updHabourForE();
                                }
                            } else if (MapBin.get(rgId).getBlockType() != 1 && MapBin.get(rgId).getBuildId() == 0) {
                                //2:低于5的陆地地块合并到周围地块数量最低的陆地地块
                                argIds = getAroundRegionId(rgId);//获取周围地块
                                for (Integer tarId : argIds) {
                                    if (Integer.parseInt(regionCountMap.get(tarId).toString()) < 6 && MapBin.get(tarId).getBuildId() != 4 && MapBin.get(tarId).getBlockType() != 1) {
                                        updateRegionIds(rgId, tarId);
                                        regionCountMap.put(rgId, (Integer.parseInt(regionCountMap.get(tarId).toString()) + Integer.parseInt(regionCountMap.get(rgId).toString())));
                                        regionCountMap.remove(tarId);
                                        break;
                                    }
                                }

                            } else if (MapBin.get(rgId).getBlockType() == 1&&ifSea) {
                                //3:低于5的海洋地块合并到周围地块数量最低的海洋地块

                                argIds = getAroundRegionId(rgId);//获取周围地块
                                for (Integer tarId : argIds) {
                                    if (Integer.parseInt(regionCountMap.get(tarId).toString()) < 6 && MapBin.get(tarId).getBuildId() != 4 && MapBin.get(tarId).getBlockType() == 1) {
                                        updateRegionIds(rgId, tarId);
                                        regionCountMap.put(rgId, (Integer.parseInt(regionCountMap.get(tarId).toString()) + Integer.parseInt(regionCountMap.get(rgId).toString())));
                                        regionCountMap.remove(tarId);
                                        break;
                                    }
                                }
                            } else if (MapBin.get(rgId).getBlockType() != 1 && MapBin.get(rgId).getBuildId() != 1) {
                                //4:低于5的非城市建筑陆地地块合并到最近的城市地块

                                argIds = getAroundRegionId(rgId);//获取周围地块
                                for (Integer tarId : argIds) {
                                    if (Integer.parseInt(regionCountMap.get(tarId).toString()) < 6 && MapBin.get(tarId).getBuildId() != 4 && MapBin.get(tarId).getBlockType() != 1) {
                                        updateRegionIds(rgId, tarId);
                                        regionCountMap.put(rgId, (Integer.parseInt(regionCountMap.get(tarId).toString()) + Integer.parseInt(regionCountMap.get(rgId).toString())));
                                        regionCountMap.remove(tarId);
                                        break;
                                    }
                                }

                            } else {
                                Gdx.app.log("警告:未检测到的地块:", rgId + "");
                            }
                        }
                    }
                }
            }

            //0查看所有孤岛类地块并合并到周围地块
            {
                //自动合并孤岛类地块
                mergeIslandGridByRegion();
                regions = getIdsForBlankRegion();
                for (Integer region : regions) {//rsCoords.size()  rand.nextInt(
                    if (MapBin.get(region).getBlockType() == 1) {
                        temps = getAroundIdById(region, 3);
                    } else {
                        temps = getAroundIdById(region, 4);
                    }
                    if (temps.size() != 0) {
                        MapBin.get(region).setRegionId(temps.get(rand.nextInt(temps.size())));
                    } else {
                        Gdx.app.log("警告:有空白地块无法合并到周围地块:", region + "");
                    }
                }
            }
            {//如果不需要海则清除
                if(!ifSea){
                    for(MapBin mapbin:MapBin){
                        if(mapbin.getBlockType()==1&&mapbin.getBuildId()!=4){
                            mapbin.setRegionId(0);
                        }
                    }
                }
            }
            Gdx.app.log("执行完成", "");
        }
    }

    //重新切割省区
      public void cutRegionForE(int maxC) {
          Random rand = new Random();
          int tempId, exct = 0, i = 0, iMax = 0, j, jMax, rsct, riSize;
          List<Integer> regions = null;
          List<Integer> temps = null;
          Map regionCountMap = new HashMap();

         {
              exct=0;
              regions = getRegions(1);
              Gdx.app.log("阶段1", "核心地块数" + regions.size()+"获得地块类:"+1); //循环 挨个对核心地块进行循环
              while (exct < maxC && regions.size() != 0) {
                  for (i = regions.size() - 1; i >= 0; i--) {
                      tempId = getRegionIdForE(regions.get(i));
                      if (tempId >= 0) {
                          MapBin.get(tempId).setRegionId(regions.get(i));
                      } else {
                          regions.remove(i);
                      }
                  }
                  Gdx.app.log("阶段2", "核心地块数" + regions.size() + " 循环次数:" + exct);
                  exct++;
              }
          }

         //打印空白陆地地块和海洋有港口的地块
            // logBlankGrid();
      }

    //把region是target的修改为 rgId
    private void updateRegionIds(Integer rgId, Integer targetId) {
        //交换前检查合不合法
        if(MapBin.get(MapBin.get(rgId).getRegionId()).getRegionId()!=MapBin.get(rgId).getRegionId()) {
            Gdx.app.log("警告:不合法,修正前", "rgId:"+rgId+" targetId:"+targetId);
            rgId=MapBin.get(MapBin.get(rgId).getRegionId()).getRegionId();
            Gdx.app.log("警告:不合法,修正后", "rgId:"+rgId+" targetId:"+targetId);
        }
        for (MapBin mapBin : MapBin) {
            if (mapBin.getRegionId() == targetId) {
                mapBin.setRegionId(rgId);
            }
        }

    }

    public List<Integer> getAroundRegionId(int rgId) {
        List<Integer> regions = new ArrayList<Integer>();
        List<Integer> tempId;
        int i, iMax = MapBin.size();
        int blockType = MapBin.get(rgId).getBlockType();
        for (i = 0; i < iMax; i++) {
            if (MapBin.get(i).getRegionId() == rgId) {
                if (blockType != 1) {
                    //陆地
                    tempId = getAroundIdById(i, 4);
                } else {
                    //海洋
                    tempId = getAroundIdById(i, 3);
                }
                for (Integer id : tempId) {
                    if (MapBin.get(id).getRegionId() != rgId) {
                        regions.add(MapBin.get(id).getRegionId());
                    }
                }
            }
        }
        tempId = new ArrayList<Integer>();//去重
        for (Integer in : regions) {
            if (!tempId.contains(in)) {
                tempId.add(in);
            }
        }
        return tempId;
    }

    //根据条件获得核心地块
    private List<Integer> getRegions(int i) {

        //0 全部核心地块 只限城市和海港
        //1 只限于陆地的核心地块 只限城市
        //2 只限于陆地的核心地块 只限工厂且未被覆盖
        //3 只限于陆地的核心地块 只限机场且未被覆盖
        //4 只限于陆地的核心地块 只限油库且未被覆盖
        //5 只限于海洋的核心地块 只限海港
        //6 全部核心地块,不限类型
        int m;
        int mMax = MapBin.size();
        List<Integer> regions = new ArrayList<Integer>();
        if (i == 0) {
            for (m = 0; m < mMax; m++) {
                if (MapBin.get(m).getAreaId() != 0 || (MapBin.get(m).getBuildId() == 1 || MapBin.get(m).getBuildId() == 4)) {
                    regions.add(m);
                }
            }
        } else if (i == 1) {
            for (m = 0; m < mMax; m++) {
                if (MapBin.get(m).getBlockType() != 1 && (MapBin.get(m).getAreaId() != 0 || (MapBin.get(m).getBuildId() == 1))) {
                    regions.add(m);
                }
            }
        } else if (i == 2) {
            for (m = 0; m < mMax; m++) {
                if (MapBin.get(m).getBlockType() != 1 && (MapBin.get(m).getRegionId() == m || MapBin.get(m).getRegionId() == 0) && (MapBin.get(m).getAreaId() != 0 || (MapBin.get(m).getBuildId() == 2))) {
                    regions.add(m);
                }
            }
        } else if (i == 3) {
            for (m = 0; m < mMax; m++) {
                if (MapBin.get(m).getBlockType() != 1 && (MapBin.get(m).getRegionId() == m || MapBin.get(m).getRegionId() == 0) && (MapBin.get(m).getAreaId() != 0 || (MapBin.get(m).getBuildId() == 3))) {
                    regions.add(m);
                }
            }
        } else if (i == 4) {
            for (m = 0; m < mMax; m++) {
                if (MapBin.get(m).getBlockType() != 1 && (MapBin.get(m).getRegionId() == m || MapBin.get(m).getRegionId() == 0) && (MapBin.get(m).getAreaId() != 0 || (MapBin.get(m).getBuildId() == 5))) {
                    regions.add(m);
                }
            }
        } else if (i == 5) {
            for (m = 0; m < mMax; m++) {
                if (MapBin.get(m).getBlockType() == 1 && (MapBin.get(m).getAreaId() != 0 || (MapBin.get(m).getBuildId() == 4))) {
                    regions.add(m);
                }
            }
        } else if (i == 6) {
            for (m = 0; m < mMax; m++) {
                if(!regions.contains(MapBin.get(m).getRegionId())) {
                    regions.add(m);
                }
            }
        }
        return regions;
    }

    //根据id获得周围6边的地块id
    /*
     * type 0全部 1获取region为0的地块 3获取周围的有region的海洋地块 4获取周围的有region的陆地地块
     * 5只获取region为0的海洋地块 6只获取region为0的陆地地块 7只获取region为0的陆地平原地块
     * 8只获取region为0的陆地非平原地块 9根据id区分海洋陆地,获取region为0的地块
     * 10 获取周围是陆地的地块 11获取周围是海洋的地块
     * 12获取沿海陆地地块
     */
    public List<Integer> getAroundIdById(int id, int type) {
        List<Integer> ids = new ArrayList<Integer>();
        List<Integer> rsIds = new ArrayList<Integer>();
        boolean top = false;
        boolean foot = false;
        boolean left = false;
        boolean right = false;
        //判断处于哪个边
        int y = (int) id / mapWidth;
        int x = id - y * mapWidth;
        int t1, t2, t3, t4, t5, t6;

        if ((x&1) == 1) {
            t1 = id - 1;
            t2 = id - mapWidth;
            t3 = id + 1;
            t4 = id + mapWidth - 1;
            t5 = id + mapWidth;
            t6 = id + mapWidth + 1;
        } else {
            t1 = id - mapWidth - 1;
            t2 = id - mapWidth;
            t3 = id - mapWidth + 1;
            t4 = id - 1;
            t5 = id + mapWidth;
            t6 = id + 1;
        }
        if (x == 0) {
            left = true;
        }
        if (x == mapWidth - 1) {
            right = true;
        }
        if (y == 0) {
            top = true;
        }
        if (y == mapHeight - 1) {
            foot = true;
        }

        if (!top && !left) {
            ids.add(t1);
        }
        if (!top) {
            ids.add(t2);
        }
        if (!top && !right) {
            ids.add(t3);
        }
        if (!foot && !left) {
            ids.add(t4);
        }
        if (!foot) {
            ids.add(t5);
        }
        if (!foot && !right) {
            ids.add(t6);
        }

        //type 0全部 1只读取region为0的值  5只获取region为0的海洋地块 6只获取region为0的陆地地块
        //7只获取region为0的陆地平原地块  8只获取region为0的陆地非平原地块
        //10 获取周围是陆地的地块 11获取周围是海洋的地块
        if (type == 0) {
            return ids;
        } else {
            for (Integer id2 : ids) {
                if (type == 1 && MapBin.get(id2).getRegionId() == 0) {
                    rsIds.add(id2);
                } else if (type == 6 && MapBin.get(id2).getRegionId() == 0 && MapBin.get(id2).getBlockType() != 1) {
                    rsIds.add(id2);
                } else if (type == 5 && MapBin.get(id2).getRegionId() == 0 && (MapBin.get(id2).getBlockType() == 1 || MapBin.get(id2).getBackTile() == 1)) {
                    rsIds.add(id2);
                } else if (type == 7 && MapBin.get(id2).getRegionId() == 0 && MapBin.get(id2).getBlockType() != 1 && MapBin.get(id2).getBackTile() == 0) {
                    rsIds.add(id2);
                } else if (type == 8 && MapBin.get(id2).getRegionId() == 0 && MapBin.get(id2).getBlockType() != 1 && MapBin.get(id2).getBackTile() != 0) {
                    rsIds.add(id2);
                } else if (type == 3 && MapBin.get(id2).getRegionId() != 0 && (MapBin.get(id2).getBlockType() == 1)) {
                    rsIds.add(id2);
                } else if (type == 4 && MapBin.get(id2).getRegionId() != 0 && (MapBin.get(id2).getBlockType() != 1)) {
                    rsIds.add(id2);
                } else if (type == 9 && ((MapBin.get(id).getBlockType()!=1) ==(MapBin.get(id2).getBlockType() != 1))) {
                    rsIds.add(id2);
                }  else if (type == 10 && (MapBin.get(id2).getBlockType() != 1)) {
                    rsIds.add(id2);
                }  else if (type == 11 && (MapBin.get(id2).getBlockType() == 1)) {
                    rsIds.add(id2);
                }else if (type == 12 && (MapBin.get(id2).getBlockType() == 1)&& (MapBin.get(id).getBlockType() != 1)) {
                    rsIds.add(id2);
                }
            }
            return rsIds;
        }
    }

    public List<Integer> getAroundIdByIds(List<Integer> ids, int type) {
        List<Integer> rss = new ArrayList<Integer>();
        for (Integer id : ids) {
            List<Integer> rs = getAroundIdById(id, type);
            rss.addAll(rs);
        }
        return rss;
    }

    private List<Integer> getIdByRegion(int regionId) {
        int m;
        int mMax = MapBin.size();
        List<Integer> rs = new ArrayList<Integer>();

        for (m = 0; m < mMax; m++) {
            if (MapBin.get(m).getRegionId() == regionId) {
                int s=m;
                rs.add(s);
            }
        }
        return rs;
    }

    //-1找不到
    //获得要扩展的id
    public int getRegionId(int r) {
        List<Integer> rsIds;
        //1判断自身是海洋还是陆地
        if (MapBin.get(r).getBlockType() == 1) {//海
            //获取周边的海洋地块
            rsIds = getAroundIdById(r, 5);
            if (rsIds.size() == 0) {
                rsIds = getAroundIdByIds(getIdByRegion(r), 5);
                if (rsIds == null || rsIds.size() == 0) {
                    //如果周围没有空余地块,则使用相邻的相邻地块判断
                    return -1;
                }
            }
            //根据条件随机获取其中一个地块id
            //return(rsIds.get(rand.nextInt(rsIds.size())));
            return getShortAroundId(rsIds,  MapBin.get(r).getRegionId());
        } else {//陆
                //获取周边陆地地块
            rsIds = getAroundIdById(r, 7);
            if (rsIds.size() != 0&&ComUtil.ifGet(30)) {
                return getShortAroundId(rsIds,  MapBin.get(r).getRegionId());
            } else {
                rsIds = getAroundIdById(r, 8);
                if (rsIds.size() != 0&&ComUtil.ifGet(30)) {
                    return getShortAroundId(rsIds,  MapBin.get(r).getRegionId());
                } else {
                    rsIds = getAroundIdById(r, 6);
                    if (rsIds.size() != 0&&ComUtil.ifGet(30)) {
                        return getShortAroundId(rsIds,  MapBin.get(r).getRegionId());
                    } else {
                        rsIds = getAroundIdByIds(getIdByRegion(r), 6);
                        if (rsIds != null && rsIds.size() == 0&&ComUtil.ifGet(50)) {
                            //如果周围没有空余地块,则使用相邻的相邻地块判断
                            rsIds = getAroundIdByIds(getIdByRegion(r), 7);
                            if (rsIds != null && rsIds.size() == 0) {
                                //如果周围没有空余地块,则使用相邻的相邻地块判断
                                rsIds = getAroundIdByIds(getIdByRegion(r), 8);
                                if (rsIds != null && rsIds.size() == 0) {
                                            return -1;
                                }
                            }
                        }
                        if (rsIds == null) {
                            return -1;
                        }
                        return getShortAroundId(rsIds,  MapBin.get(r).getRegionId());
                    }
                }
            }
        }
    }

  //-1找不到
    //获得要扩展的id
    public int getRegionIdForE(int r) {
        List<Integer> rsIds;
        List<Integer> tempIds;
        //1判断自身是海洋还是陆地
        if (MapBin.get(r).getBlockType() == 1) {//海
            //获取周边的海洋地块
            rsIds = getAroundIdById(r, 5);
            if (rsIds.size() == 0) {
                rsIds = getAroundIdByIds(getIdByRegion(r), 5);
                if (rsIds == null || rsIds.size() == 0) {
                    //如果周围没有空余地块,则使用相邻的相邻地块判断
                    return -1;
                }
            }
            //根据条件随机获取其中一个地块id
            //return(rsIds.get(rand.nextInt(rsIds.size())));
            return getShortAroundId(rsIds,  MapBin.get(r).getRegionId());
        } else {//陆
                //获取周边陆地地块
            rsIds = getAroundIdById(r, 6);
            if (rsIds.size() == 0) {
                tempIds= getIdByRegion(r);
                rsIds = getAroundIdByIds(tempIds, 6);
                if (rsIds == null || rsIds.size() <3) {
                    //如果周围没有空余地块,则使用相邻的相邻地块判断
                    //Gdx.app.log("清除核心", r+"");
                    return -1;
                }
            }
            int id= getShortAroundId(rsIds, MapBin.get(r).getRegionId());
             return id;
        }
    }

    //chance 最高获取概率,最低默认为10 如果不容许有海洋地块,则多抽0.1
    private List<Integer> getRegionIdsByChance(int chance,boolean ifSea) {
        if(!ifSea){
            chance= (int) (chance*1.2);
        }

        int cutSide = 5;
        Random rand = new Random();

        int i, j, m,rsMax,rpMax;
        int mMax = MapBin.size();//chance<(int)(Math.random()*(100)
        List<Integer> rs = new ArrayList<Integer>();
        List<Integer> result = new ArrayList<Integer>();
        //获取全部为空的地块
        for (m = 0; m < mMax; m++) {
            if (MapBin.get(m).getRegionId() == 0) {
                if(ifSea){
                    rs.add(m);
                }else if(!ifSea&&MapBin.get(m).getBlockType()!=1){
                    rs.add(m);
                }
            }
        }
        if (rs.size() == 0) {
            return rs;
        }
        rsMax=rs.size();
        rpMax=rsMax*chance/100;
        /*List<Coord> coords = converCoords(rs);
        List<Coord> rsCoords = new ArrayList<Coord>();
        rs = new ArrayList<Integer>();
        for (i = mapWidth; i >= 0; i = i - cutSide) {
            for (j = mapHeight; j >= 0; j = j - cutSide) {
                for (m = coords.size() - 1; m >= 0; m--) {
                    if (coords.get(m).getX() > i && coords.get(m).getY() > j) {
                        rsCoords.add(coords.get(m));
                        coords.remove(m);
                    }
                    if (rsCoords.size()>0) {
                        rs.add(rsCoords.get(rand.nextInt(rsCoords.size())).getId());
                        rsCoords.clear();
                        rs=ComUtil.getNewList(rs);
                    }
                    if(rs.size()>rsMax*chance/100){
                        break;
                    }
                    if (coords.size() == 0) {
                        break;
                    }
                }
            }
        }*/
        int tempId;
        for(i = 0;i<rpMax;i++){
            //显示数字并将其从列表中删除,从而实现不重复.
            tempId=new Random().nextInt(rs.size());
            rs.remove(tempId);
            result.add(tempId);
            }

        Gdx.app.log("获得随机核心", rsMax+":"+result.size());
        return result;
    }

    //获取空白值
    private int getRegionForIdIs0() {
        int ct = 0, m, mMax = MapBin.size();
        for (m = 0; m < mMax; m++) {
            if (MapBin.get(m).getRegionId() == 0) {
                ct++;
            }
        }
        return ct;
    }

    //获得空白地块
    private List<Integer> getIdsForBlankRegion() {
        int m;
        int mMax = MapBin.size();
        List<Integer> rs = new ArrayList<Integer>();
        for (m = 0; m < mMax; m++) {
            if (MapBin.get(m).getRegionId() == 0) {
                rs.add(m);
            }
        }
        return rs;
    }

    //将id转为coord(x,y,id,regionId)
    private Coord converCoord(int id) {
        int y = (int) id / mapWidth;
        int x = id - y * mapWidth;
        return new Coord(x, y, id, MapBin.get(id).getRegionId());
    }

    //将id转为coord
    private List<Coord> converCoords(List<Integer> ids) {
        int m;
        int mMax = ids.size();
        List<Coord> rsIds = new ArrayList<Coord>();
        for (m = 0; m < mMax; m++) {
            int s=m;
            rsIds.add(converCoord(ids.get(s)));
        }
        return rsIds;
    }

    //获得最近的地块
    public int getShortAroundId(List<Integer> ids, int regionId) {
       // Gdx.app.log("求最近的地块,regionId", regionId+"");
        List<Coord> coords = converCoords(ids);
        int i, j, iMax = coords.size(), tempId = -1;double jl,jl2;
        Coord coord = converCoord(regionId);
        for (i = 0; i < iMax; i++) {
            for (j = 0; j < iMax; j++) {
                 jl=Math.pow((coords.get(i).getX() - coord.getX()),2) + Math.pow((coords.get(i).getY() - coord.getY()),2);
                 jl2=(Math.pow((coords.get(j).getX() - coord.getX()),2) + Math.pow((coords.get(j).getY() - coord.getY()),2));
                //Gdx.app.log("求最近的地块,交换前", "i:"+coords.get(i).getId()+" 距离系数:"+jl);
               // Gdx.app.log("求最近的地块,交换前", "j:"+coords.get(i).getId()+" 距离系数:"+jl2);

                if (jl<jl2) { // 交换两数的位置
                    //Gdx.app.log("求最近的地块,交换前", "i:"+coords.get(i).getId()+" j:"+coords.get(j).getId());
                    ComUtil.swap(coords, i, j);
                    //Gdx.app.log("求最近的地块,交换后", "i:"+coords.get(i).getId()+" j:"+coords.get(j).getId());
                }
            }
        }
        //Gdx.app.log("求最近的地块,最前", coords.get(0).getId()+"");
        //Gdx.app.log("求最近的地块,最后", coords.get(coords.size()-1).getId()+"");
        Random rand = new Random();
        {//去除非同一势力 TODO
            for (i = coords.size() - 1; i >= 0; i--) {
                if(!ifComLegion(coords.get(i).getId(),coord.getId())) {
                    coords.remove(i);
                }
            }
        }

        if (coords.size() > 2) {
            tempId = coords.get(rand.nextInt(2)).getId();
        } else if (coords.size() == 0) {
            return -1;
        } else {
            tempId = coords.get(0).getId();
        }
        // 1.8的写法  取出List中的对象的属性值
        //List<Integer> xs = coords.stream().map(Coord::getX).collect(Collectors.toList());
        //List<Integer> ys = coords.stream().map(Coord::getY).collect(Collectors.toList());

        List<Integer> xs=new ArrayList<Integer>();
        List<Integer> ys=new ArrayList<Integer>();

        for(Coord cd:coords){
            xs.add(cd.getX());
            ys.add(cd.getY());
        }

        int maxX=Collections.max(xs);
        int minX=Collections.min(xs);
        int maxY=Collections.max(ys);
        int minY=Collections.min(ys);

        if((maxX-minX)>3||(maxY-minY)>3) {
            if((maxY-minY)!=0&&(maxX-minX)!=0&&((maxX-minX)/(maxY-minY)>2||(maxY-minY)/(maxX-minX)>2)||getRegionCountByRegionId(regionId)<((maxX-minX)*(maxY-minY)/3)) {
                return -1;
            }
        }
        /*if(getRegionCountByRegionId(regionId)>(10 + Math.random() * 5)) {
            return -1;
        }*/
        return tempId;
    }

    //获取各region的数量记录为map
    private Map getRegionCountMap() {
        Map rsMap = new HashMap();
        for (MapBin mapBin : MapBin) {
            if (!rsMap.containsKey(mapBin.getRegionId())) {
                rsMap.put(mapBin.getRegionId(), 1);
            } else {
                rsMap.put(mapBin.getRegionId(), Integer.parseInt(rsMap.get(mapBin.getRegionId()).toString()) + 1);
            }
        }
        return rsMap;
    }

    //获取通过region获取region的数量
    private int getRegionCountByRegionId(int regionId) {
        int c=0;
        for (MapBin mapBin : MapBin) {
            if (mapBin.getRegionId()==regionId) {
                c++;
            }
        }
        return c;
    }

    //通过region获取ids
    public List<Integer> getIdsByRegionId(int regionId){
        List<Integer> rs= new ArrayList<Integer>();
        int c=0;
        for (MapBin mapBin : MapBin) {
            if (mapBin.getRegionId()==regionId) {
                rs.add(c);
            }
            c++;
        }
        return rs;
    }
    //获取所有region
    public List<Integer> getAllRegionIds(){
        List<Integer> rs = new ArrayList<Integer>();
        for (MapBin mapBin : MapBin) {
            if (mapBin.getRegionId()!=0&&!rs.contains(mapBin.getRegionId())) {
                rs.add(mapBin.getRegionId());
            }
        }
        return rs;
    }

    //合并孤岛类地块
    private void mergeIslandGridByRegion() {
        int i,iMax=MapBin.size(),rsI=0;
        String rz;
        List<Integer> rs;
        int tempRegionId;
        for (i=0;i<iMax;i++) {
            //获得结果值
            rs= getAroundIdById(i,9);
            Collections.sort(rs);
            rsI=0;
            //判断是否是孤岛
            for(Integer id:rs) {
                if(MapBin.get(id).getRegionId()!=MapBin.get(i).getRegionId()) {
                    rsI++;
                }
            }
            if(rsI>4) {
                rz= ComUtil.getListMostRepeatData(rs);
                //updateRegionIds(MapBin.get(Integer.parseInt(rz)).getRegionId(),i);
                MapBin.get(i).setRegionId(MapBin.get(Integer.parseInt(rz)).getRegionId());
            }

        }
    }

    public static void main(String[] args) {
        int i;

        for (i = 0; i < 30; i++) {
            System.out.println("sj:" + (int) (10 + Math.random() * 15));
        }

    }

    //检查所属的区块是不是合法的region,如果不是给周围的地块 TODO测试
    private void checkRegion() {
        int i,iMax=MapBin.size();String rsI;
        List<Integer> rs;
        for (i=0;i<iMax;i++) {
            //获得结果值
            rs= getAroundIdById(i,9);
            Collections.sort(rs);
            if(MapBin.get(MapBin.get(i).getRegionId()).getRegionId()!=MapBin.get(i).getRegionId()) {
                rsI=ComUtil.getListMostRepeatData(rs);
                if(rsI!=null&&rsI!="") {
                    //Gdx.app.log("所属区域region不合法:", "i:"+i);
                    updateRegionIds(MapBin.get(Integer.parseInt(rsI)).getRegionId(),MapBin.get(i).getRegionId());
                }
            }
        }
    }

  //打印空白的非海洋地块(包括港口)
    private  void logBlankGrid() {
       int i=0;
        for (MapBin mapBin : MapBin) {
            if (mapBin.getRegionId()==0&&(mapBin.getBackTile()!=1&&mapBin.getBackTile()!=2)) {
                Gdx.app.log("空白地块", i+"");
            }
            i++;
        }
    }

  //验证势力是否一致   r源id  i目标id
   private boolean ifComLegion(int r,int i) {
       int sourceLegion=MapBin.get(r).getFacility();
       int regionLegion=MapBin.get(i).getFacility();
       if(sourceLegion==regionLegion) {
           return true;
       }else if(sourceLegion==255) {
           return true;
       }else {
           return false;
       }

   }

   //将海港城市归为最近的陆地城市
    private void updHabourRegionForE() {
        List<Integer> habour= getRegions(5);
        List<Integer> rsIds,tempIds;int id;
        Random rand = new Random();
        for(Integer r:habour) {
            rsIds = getAroundIdById(r, 4);
            if (rsIds.size() == 0) {
               Gdx.app.log("警告", r+":海港周围为空");
            }else {
                id= rsIds.get(rand.nextInt(rsIds.size()));
                if(id!=-1&&MapBin.get(r).getRegionId()==r) {
                    MapBin.get(r).setRegionId(MapBin.get(id).getRegionId());
                }
            }
        }
    }

    public void updHabourForE() {
        updHabourRegionForE();
        logBlankGrid();
    }

    //替换当前的地区的所有相同区块为一个id的所在区块
    public void replaceRegionIdById(int id){
        int regionId=MapBin.get(id).getRegionId();
        for (MapBin mapBin : MapBin) {
            if(mapBin.getRegionId()==regionId){
                mapBin.setRegionId(id);
            }
        }
    }

    //替换当前空白的地块以及与其相邻的地块的region
    public void replaceRegionIdForFFArea(int id,int regionId){
        //替换不穿海,只替换该区域的
        List<Integer> rs= new ArrayList<Integer>();
        List<Integer> tempI;
        if(MapBin.get(id).getRegionId()!=0){
            return;
        }else{
            List<Integer> tempIds=getAroundIdById(id, 6);
            rs.addAll(tempIds);
            int n=0;
            do{
                tempIds= (List<Integer>) ((ArrayList<Integer>) rs).clone();
                for(int i:tempIds){
                    tempI=getAroundIdById(i, 6);
                    rs.removeAll(tempI);
                    rs.addAll(tempI);
                }
                n=n+1;
                if(n>5){
                    break;
                }
            }while(ComUtil.ifListContainListByInteger(rs,tempIds));

            for(int i:rs){
                MapBin.get(i).setRegionId(regionId);
            }
        }
    }

    //批量获取符合某种条件的地块,条件参看getAroundIdById
    public List<Integer> getIdsByAround(int type){
        List<Integer> rsGrid=new ArrayList<Integer>();
        List<Integer> rs;
        int id=0;
        for (MapBin mapBin : MapBin) {
            rs = getAroundIdById(id, type);
            if(rs.size()>0){
                rsGrid.add(id);
            }
            id=id+1;
        }
        return rsGrid;
    }

}

MapBinDAO

package com.zhfy.game.framework;

import java.awt.Graphics;
import java.awt.geom.Point2D;
import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.assets.AssetManager;
import com.badlogic.gdx.files.FileHandle;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.Pixmap;
import com.badlogic.gdx.graphics.Pixmap.Blending;
import com.badlogic.gdx.graphics.Pixmap.Filter;
import com.badlogic.gdx.graphics.PixmapIO;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.utils.XmlReader;
import com.zhfy.game.config.ResConfig;
import com.zhfy.game.framework.tool.FileByte;
import com.zhfy.game.model.content.MapBin;
import com.zhfy.game.model.content.MapBinDAO;
import com.zhfy.game.model.content.def.DefMap;
import com.zhfy.game.model.content.def.DefPt;
import com.zhfy.game.model.content.def.DefTerrainimg;
import com.zhfy.game.model.framework.Coord;
import com.zhfy.game.model.framework.PixmapDAO;
import com.zhfy.game.model.framework.PixmapListDAO;

public class GameMap {
    // 六边形地图绘制 全部static方法

    public static void main(String[] args) throws Exception {

        // saveBinByWirteByte(fb,"123");
        // MapBinDAO fb=apBin("123");
        // saveMapBin(fb,"123");
    }

    // 写为bin数组
    @SuppressWarnings("unused")
    public static void saveMapBin(MapBinDAO binFile, String Path) {
        try {
            //FileOutputStream fs_out = new FileOutputStream(Path);//"D://test.bin"
            FileByte out=new FileByte();
            out.writeShort(binFile.mapVersion);//
            out.writeInt(binFile.mapWidth);//
            out.writeInt(binFile.mapHeight);//
            for (int i = 0; i < binFile.getMapbin().size(); i++) {
                out.writeByte(binFile.getMapbin().get(i).getBlockType());//
                out.writeByte(binFile.getMapbin().get(i).getBackTile());//
                out.writeByte(binFile.getMapbin().get(i).getBackIdx());//
                out.writeByte(binFile.getMapbin().get(i).getBackRefX());//
                out.writeByte(binFile.getMapbin().get(i).getBackRefY());//
                out.writeByte(binFile.getMapbin().get(i).getForeTile());//
                out.writeByte(binFile.getMapbin().get(i).getForeIdx());//
                out.writeByte(binFile.getMapbin().get(i).getForeRefX());//
                out.writeByte(binFile.getMapbin().get(i).getForeRefY());//
                out.writeByte(binFile.getMapbin().get(i).getWaterPass());//
                out.writeByte(binFile.getMapbin().get(i).getLandPass());//
                out.writeInt(binFile.getMapbin().get(i).getRegionId());//
                out.writeByte(binFile.getMapbin().get(i).getClimateId());//
                out.writeByte(binFile.getMapbin().get(i).getBuildId());//
                out.writeByte(binFile.getMapbin().get(i).getBuildLv());//
                out.writeByte(binFile.getMapbin().get(i).getFacility());//
                out.writeShort(binFile.getMapbin().get(i).getAreaId());//
            }
            FileHandle file = Gdx.files.local(Path);
            file.writeBytes(out.getByte(), false);
            //out.writeInt(i);//8位  2147483647
            //out.writeShort(i2);//4位 32769
            //out.writeByte(i3);//2位  127

        } catch (FileNotFoundException fe) {
            System.err.println(fe);
        } catch (IOException ioe) {
            System.err.println(ioe);
        }
        System.out.println("Ok");
    }

   public static void saveMapBin2(MapBinDAO binFile, String Path) {
        try {
            FileOutputStream fs_out = new FileOutputStream(Path);//"D://test.bin"
            DataOutputStream out = new DataOutputStream(fs_out);
            out.writeShort(binFile.mapVersion);//
            out.writeInt(binFile.mapWidth);//
            out.writeInt(binFile.mapHeight);//
            for (int i = 0; i < binFile.getMapbin().size(); i++) {
                out.writeByte(binFile.getMapbin().get(i).getBlockType());//
                out.writeByte(binFile.getMapbin().get(i).getBackTile());//
                out.writeByte(binFile.getMapbin().get(i).getBackIdx());//
                out.writeByte(binFile.getMapbin().get(i).getBackRefX());//
                out.writeByte(binFile.getMapbin().get(i).getBackRefY());//
                out.writeByte(binFile.getMapbin().get(i).getForeTile());//
                out.writeByte(binFile.getMapbin().get(i).getForeIdx());//
                out.writeByte(binFile.getMapbin().get(i).getForeRefX());//
                out.writeByte(binFile.getMapbin().get(i).getForeRefY());//
                out.writeByte(binFile.getMapbin().get(i).getWaterPass());//
                out.writeByte(binFile.getMapbin().get(i).getLandPass());//
                out.writeInt(binFile.getMapbin().get(i).getRegionId());//
                out.writeByte(binFile.getMapbin().get(i).getClimateId());//
            }
            out.close();

            //out.writeInt(i);//8位  2147483647
            //out.writeShort(i2);//4位 32769
            //out.writeByte(i3);//2位  127
            // out.close();

        } catch (FileNotFoundException fe) {
            System.err.println(fe);
        } catch (IOException ioe) {
            System.err.println(ioe);
        }
        System.out.println("Ok");
    }/* */

    // 循环遍历 在地块图上 是海洋和海岸的位置打窟窿,海岸使用id为2的抹除相应地形
    public static Pixmap getLandByDAO(MapBinDAO mapBinDAO, Pixmap pixmap,PixmapListDAO pixmapLists, int mapx, int mapy,int mapw,int maph) {

        int x = 0;
        int y = 0;
        //int x_px_circle = 0;
        //int y_px_circle = 0;
        int x_px = 0;
        int y_px = 0;
        PixmapDAO shadowPixmap;
        Pixmap shadowTargetPixmap = new Pixmap(46, 40, Pixmap.Format.RGBA8888);;
        String shadowName;

        HashMap<String, String> terrainimgMap = new HashMap<String, String>();

        //六边形四个角的坐标
        int hexgaon_x1=0;//左上,左下
        int hexgaon_x2=0;//右上,右下
        int hexgaon_x3=0;//左中
        int hexgaon_x4=0;//右中
        int hexgaon_y1=0;//上
        int hexgaon_y2=0;//中
        int hexgaon_y3=0;//下

        //TODO 随后增加对地图属性的解析

        int beginIndex=0;
        int EndIndex=mapw*maph;

        int xC;
        int yC;

        Blending blend = pixmap.getBlending();

        pixmap.setBlending(Blending.None);

        for (int id = beginIndex; id < EndIndex; id++) {
            x = (id % mapBinDAO.getMapWidth()) + 1;
            y = (id / mapBinDAO.getMapWidth()) + 1;
            //x_px_circle = (int) (((x - 1) * ResConfig.Map.GRID_WIDTH) * Config.Map.MAP_SCALE + Config.Map.HEXAGON_WIDTH * Config.Map.MAP_SCALE / 2);
            //y_px_circle = (int) ((((x & 1) == 1 ? (y - 1) * ResConfig.Map.HEXAGON_HEIGHT : (y - 1) * ResConfig.Map.HEXAGON_HEIGHT + ResConfig.Map.HEXAGON_HEIGHT_REF)) * Config.Map.MAP_SCALE + Config.Map.HEXAGON_HEIGHT * Config.Map.MAP_SCALE / 2);

            x_px = (int) ((x - 1) * ResConfig.Map.GRID_WIDTH* ResConfig.Map.MAP_SCALE);
            y_px = (int) (((x & 1) == 1 ? (y - 1) * ResConfig.Map.HEXAGON_HEIGHT : (y - 1) * ResConfig.Map.HEXAGON_HEIGHT + ResConfig.Map.HEXAGON_HEIGHT_REF)* ResConfig.Map.MAP_SCALE);

            if (mapBinDAO.getMapbin().get(id).getBackTile() == 1 ) {

                // 这里填充圆，或四个三角形组合的六边形
               // pixmap.fillCircle(x_px_circle, y_px_circle, (int) ((Config.Map.HEXAGON_WIDTH+12) * Config.Map.MAP_SCALE / 2));
                //六个点
                hexgaon_x1=(int) (((x - 1) * ResConfig.Map.GRID_WIDTH) * ResConfig.Map.MAP_SCALE +35*ResConfig.Map.MAP_SCALE);//左上,左下 原来是36
                hexgaon_x2=(int) (((x - 1) * ResConfig.Map.GRID_WIDTH) * ResConfig.Map.MAP_SCALE +113*ResConfig.Map.MAP_SCALE);//右上,右下 ResConfig.Map.GRID_WIDTH
                hexgaon_x3=(int) (((x - 1) * ResConfig.Map.GRID_WIDTH) * ResConfig.Map.MAP_SCALE-1);//左中
                hexgaon_x4=(int) (((x - 1) * ResConfig.Map.GRID_WIDTH) * ResConfig.Map.MAP_SCALE + ResConfig.Map.HEXAGON_WIDTH * ResConfig.Map.MAP_SCALE );//右中
                hexgaon_y1=(int) ((((x & 1) == 1 ? (y - 1) * ResConfig.Map.HEXAGON_HEIGHT : (y - 1) * ResConfig.Map.HEXAGON_HEIGHT + ResConfig.Map.HEXAGON_HEIGHT_REF)) * ResConfig.Map.MAP_SCALE -1);//上
                hexgaon_y2=(int) ((((x & 1) == 1 ? (y - 1) * ResConfig.Map.HEXAGON_HEIGHT : (y - 1) * ResConfig.Map.HEXAGON_HEIGHT + ResConfig.Map.HEXAGON_HEIGHT_REF)) * ResConfig.Map.MAP_SCALE + ResConfig.Map.HEXAGON_HEIGHT * ResConfig.Map.MAP_SCALE / 2);//中
                hexgaon_y3=(int) ((((x & 1) == 1 ? (y - 1) * ResConfig.Map.HEXAGON_HEIGHT : (y - 1) * ResConfig.Map.HEXAGON_HEIGHT + ResConfig.Map.HEXAGON_HEIGHT_REF)) * ResConfig.Map.MAP_SCALE + ResConfig.Map.HEXAGON_HEIGHT * ResConfig.Map.MAP_SCALE );//下

                pixmap.fillTriangle(hexgaon_x3, hexgaon_y2, hexgaon_x1, hexgaon_y1, hexgaon_x2, hexgaon_y1);
                pixmap.fillTriangle(hexgaon_x3, hexgaon_y2, hexgaon_x2, hexgaon_y1, hexgaon_x4, hexgaon_y2);
                pixmap.fillTriangle(hexgaon_x3, hexgaon_y2, hexgaon_x2, hexgaon_y3, hexgaon_x4, hexgaon_y2);
                pixmap.fillTriangle(hexgaon_x3, hexgaon_y2, hexgaon_x1, hexgaon_y3, hexgaon_x2, hexgaon_y3);

                // Gdx.app.log("切除陆地", "id:" + id +" x:"+x+" y:"+ y+"
                // x_px:"+x_px+" y_px:"+ y_px);
            }else if(mapBinDAO.getMapbin().get(id).getBackTile() == 2) {
                //pixmap.setBlending(blend);
                shadowName=terrainimgMap.get(mapBinDAO.getMapbin().get(id).getBackTile() + "_" + mapBinDAO.getMapbin().get(id).getBackIdx());
                if(shadowName!=null) {
                    shadowPixmap = pixmapLists.getPixmapByName(shadowName);
                    /*
                    pixmap.drawPixmap(shadowPixmap.getPixmap(), 0, 0, (int)(shadowPixmap.getPixmap().getWidth()), (int)(shadowPixmap.getPixmap().getHeight()), x_px,
                            y_px, (int) (shadowPixmap.getPixmap().getWidth() * Config.Map.MAP_SCALE), (int) (shadowPixmap.getPixmap().getHeight() * Config.Map.MAP_SCALE));
                     */

                    //Gdx.app.log("切除海岸边缘","shadowName:"+shadowName);
                   /*
                    TODO
                                                       * 暂时未完成
                                                       *根据阴影的形状来切割掉像素,实现边界对齐
                    * */
                   //pixmap.setBlending(Blending.None);
                    shadowTargetPixmap.drawPixmap(shadowPixmap.getPixmap(), 0, 0, (int)(shadowPixmap.getPixmap().getWidth()), (int)(shadowPixmap.getPixmap().getHeight()), 0,
                            0, (int) (shadowPixmap.getPixmap().getWidth() * ResConfig.Map.MAP_SCALE), (int) (shadowPixmap.getPixmap().getHeight() * ResConfig.Map.MAP_SCALE));

                    for ( xC=0; xC<(int) (shadowTargetPixmap.getWidth() ); xC++) {
                        for ( yC=0; yC<(int) (shadowTargetPixmap.getHeight() ); yC++) {
                             //int color = pixmap.getPixel(xC, yC);
                             /*if(shadowPixmap.getPixmap().getPixel(xC, yC)>256&&shadowPixmap.getPixmap().getPixel(xC, yC)<66000){
                                 pixmap.drawPixel(xC+x_px, yC+y_px, 0);
                             }*/
                            /*if(shadowPixmap.getName().equals("coast_58")) {
                                //Gdx.app.log("切除海岸边缘","color:"+shadowTargetPixmap.getPixel(xC, yC)+" x:"+xC+" y:"+yC);
                                Gdx.app.log("",""+shadowTargetPixmap.getPixel(xC, yC));
                            }*/

                            if(shadowTargetPixmap.getPixel(xC, yC)==65535||shadowTargetPixmap.getPixel(xC, yC)==65022){
                                pixmap.drawPixel(xC+x_px, yC+y_px,0);

                                    Gdx.app.log("切除海岸边缘","color:"+shadowPixmap.getPixmap().getPixel(xC, yC)+" x:"+xC+" y:"+yC);

                            }/*else {
                                Gdx.app.log("切除海岸边缘","color:"+pixmap.getPixel(xC, yC)+" x:"+xC+" y:"+yC);
                            }*/

                        }
                    }

                }

            }
        }
     // 把blending设置回来
        pixmap.setBlending(blend);
        return pixmap;
    }

    // 通过dao绘制图片
    // pixmap要绘制的目标图片
    // pixmapLists使用图片
    // defTerrainimgs图片说明文件
    public static Pixmap getPixmapByDao(MapBinDAO mapBinDAO, Pixmap pixmap, PixmapListDAO pixmapLists, List<DefTerrainimg> defTerrainimgs, int beginIndex, int EndIndex,float scale) {
        // 解析dao
        if (mapBinDAO.getMapbin() != null) {

            int x = 0;
            int y = 0;
            int x_px = 0;
            int y_px = 0;
            HashMap<String, String> terrainimgMap = new HashMap<String, String>();
            // 将要取得的图片的id和名字放入位置
            for (DefTerrainimg defTerrainimg : defTerrainimgs) {
                terrainimgMap.put(defTerrainimg.getId() + "_" + defTerrainimg.getIdx(), defTerrainimg.getImage());
            }
            String imgBack;
            String imgFore;
            PixmapDAO backPixmap;
            PixmapDAO forePixmap;
            int refSize=0;//对水面大小补位,否则可能有空缺
            //Pixmap.Filter filter;
            // 单线程绘制图片
            for (int id = beginIndex; id < EndIndex; id++) {

                x = (id % mapBinDAO.getMapWidth()) + 1;
                y = (id / mapBinDAO.getMapWidth()) + 1;
                // x_px=(int) ((x-1)*139.5);
                // y_px=(int) ((x&1) == 1?(y-1)*161:(y-1)*161+80.5);
                x_px = (int) ((x - 1) * ResConfig.Map.GRID_WIDTH);
                y_px = (int) (((x & 1) == 1 ? (y - 1) * ResConfig.Map.HEXAGON_HEIGHT : (y - 1) * ResConfig.Map.HEXAGON_HEIGHT + ResConfig.Map.HEXAGON_HEIGHT_REF));

                //Gdx.app.log("地图开始构建", "mapId:" + id + " x:" + x + " y:" + y);
                if (mapBinDAO.getMapbin().get(id).getBackTile() != 0 /*&& mapBinDAO.getMapbin().get(id).getBackTile() != 1*/) {
                    if(mapBinDAO.getMapbin().get(id).getBackTile() == 1&&scale<0.5f){
                        refSize=1;
                    }else{
                        refSize=0;
                    }
                    // 获取该位置要画的地形 z
                    imgBack = terrainimgMap.get(mapBinDAO.getMapbin().get(id).getBackTile() + "_" + mapBinDAO.getMapbin().get(id).getBackIdx());
                    if (imgBack == null) {
                        //Gdx.app.log("地图层1未找到", mapBinDAO.getMapbin().get(id).getBackTile() + "_" + mapBinDAO.getMapbin().get(id).getBackIdx());
                        imgBack = terrainimgMap.get(mapBinDAO.getMapbin().get(id).getBackTile() + "_"+ComUtil.getRandom(1,4));
                    }
                    // 获取图像并绘制到上面
                    backPixmap = pixmapLists.getPixmapByName(imgBack);
                    if (backPixmap != null) {
                        pixmap.drawPixmap
                                (backPixmap.getPixmap(),
                                        0,
                                        0,
                                        backPixmap.getPixmap().getWidth(),
                                        backPixmap.getPixmap().getHeight(),
                                        (int) (scale*((x_px + mapBinDAO.getMapbin().get(id).getBackRefX()+backPixmap.getRefx()) * ResConfig.Map.MAP_SCALE))-refSize*2,
                                        (int) (scale*((y_px + mapBinDAO.getMapbin().get(id).getBackRefY()+backPixmap.getRefy()) * ResConfig.Map.MAP_SCALE))-refSize*2,
                                        (int) (scale*backPixmap.getPixmap().getWidth() * ResConfig.Map.MAP_SCALE)+refSize*3,
                                        (int) (scale*backPixmap.getPixmap().getHeight() * ResConfig.Map.MAP_SCALE)+refSize*3);

                        //Gdx.app.log("地图层1构建成功", " backid:" + mapBinDAO.getMapbin().get(id).getBackTile() + "_" + mapBinDAO.getMapbin().get(id).getBackIdx() + "img:" + imgBack);
                    } /*
                       * else { Gdx.app.log("地图层1构建失败", " backid:" +
                       * mapBinDAO.getMapbin().get(id).getBackTile() + "_" +
                       * mapBinDAO.getMapbin().get(id).getBackIdx()); }
                       */
                } /*
                   * else { Gdx.app.log("地图层1忽略构建", ""); }
                   */
                // 忽略底图和海洋
                if (mapBinDAO.getMapbin().get(id).getForeTile() != 0 && mapBinDAO.getMapbin().get(id).getForeTile() != 1) {
                    imgFore = terrainimgMap.get(mapBinDAO.getMapbin().get(id).getForeTile() + "_" + mapBinDAO.getMapbin().get(id).getForeIdx());
                    if (imgFore == null) {
                        Gdx.app.log("地图层2未找到",mapBinDAO.getMapbin().get(id).getForeTile() + "_" + mapBinDAO.getMapbin().get(id).getForeIdx());
                        imgFore = terrainimgMap.get(mapBinDAO.getMapbin().get(id).getForeTile() + "_1");
                    }
                    forePixmap = pixmapLists.getPixmapByName(imgFore);
                    if (forePixmap != null) {
                        pixmap.drawPixmap
                                (forePixmap.getPixmap(),
                                        0,
                                        0,
                                        forePixmap.getPixmap().getWidth(),
                                        forePixmap.getPixmap().getHeight(),
                                        (int) (scale*((x_px + mapBinDAO.getMapbin().get(id).getForeRefX()+forePixmap.getRefx()) * ResConfig.Map.MAP_SCALE)),
                                        (int) (scale*((y_px + mapBinDAO.getMapbin().get(id).getForeRefY()+forePixmap.getRefy()) * ResConfig.Map.MAP_SCALE)),
                                        (int) (scale*forePixmap.getPixmap().getWidth() * ResConfig.Map.MAP_SCALE),
                                        (int) (scale*forePixmap.getPixmap().getHeight() * ResConfig.Map.MAP_SCALE));
                    } /*
                       * else { Gdx.app.log("地图层2构建成功", " backid:" +
                       * mapBinDAO.getMapbin().get(id).getForeTile() + "_" +
                       * mapBinDAO.getMapbin().get(id).getForeIdx()); }
                       */
                } /*
                   * else { Gdx.app.log("地图层2", "忽略构建"); }
                   */
            }
            Gdx.app.log("地图构建", "完成");
          //  PixmapIO.writePNG(Gdx.files.external("texture_world.png"), pixmap);                

            return pixmap;
        } else {
            Gdx.app.log("地图构建", "失败");
            return null;
        }
    }

    //绘制颜色区块图
    public static Pixmap getPixmapByDaoForColor(MapBinDAO mapBinDAO, Pixmap pixmap,float scale,List<Integer> coastGrid) {

        // 解析dao
        if (mapBinDAO.getMapbin() != null) {

            int x = 0;
            int y = 0;
            int x_px_circle = 0;
            int y_px_circle = 0;
            int hexgaon_x1;
            int hexgaon_x2;
            int hexgaon_x3;
            int hexgaon_x4;
            int hexgaon_y1;
            int hexgaon_y2;
            int hexgaon_y3;

            //沿海地块用圆形来填充
            //List<Integer> coastGrid=mapBinDAO.getIdsByAround(12);

            int color;
            int nextRegionId=0;
            //先绘制海岸  //沿海地块用圆形来填充
            pixmap.setBlending(Blending.None);
            for(int id:coastGrid) {
                if(mapBinDAO.getMapbin().get(id).getBlockType()!=1&&mapBinDAO.getMapbin().get(id).getRegionId()!=0){
                    x = (id % mapBinDAO.getMapWidth()) + 1;
                    y = (id / mapBinDAO.getMapWidth()) + 1;
                    x_px_circle = (int) (scale*(((x - 1) * ResConfig.Map.GRID_WIDTH) * ResConfig.Map.MAP_SCALE + ResConfig.Map.HEXAGON_WIDTH * ResConfig.Map.MAP_SCALE / 2));
                    y_px_circle = (int) (scale*((((x & 1) == 1 ? (y - 1) * ResConfig.Map.HEXAGON_HEIGHT : (y - 1) * ResConfig.Map.HEXAGON_HEIGHT + ResConfig.Map.HEXAGON_HEIGHT_REF)) * ResConfig.Map.MAP_SCALE + ResConfig.Map.HEXAGON_HEIGHT * ResConfig.Map.MAP_SCALE / 2));

                    //Gdx.app.log("海陆绘制圆", "" + id);
                    //沿海地块用圆形来填充
                    if (mapBinDAO.getMapbin().get(id).getRegionId() != nextRegionId) {
                        color = GameUtil.getColorByNum(mapBinDAO.getMapbin().get(id).getRegionId());
                        //获取颜色
                        pixmap.setColor(color);
                        nextRegionId = mapBinDAO.getMapbin().get(id).getRegionId();
                        //Gdx.app.log("setColor","id:"+id+" color:"+color);
                    }
                    pixmap.fillCircle(x_px_circle, y_px_circle, (int) ((ResConfig.Map.HEXAGON_WIDTH + 13) * ResConfig.Map.MAP_SCALE / 2*scale));
                }
            }

            // 单线程绘制所有图片
            for (int id = 0; id < mapBinDAO.getMapbin().size(); id++) {

                x = (id % mapBinDAO.getMapWidth()) + 1;
                y = (id / mapBinDAO.getMapWidth()) + 1;

                hexgaon_x1=(int) (scale*(((x - 1) * ResConfig.Map.GRID_WIDTH) * ResConfig.Map.MAP_SCALE +35*ResConfig.Map.MAP_SCALE));//左上,左下 原来是36
                hexgaon_x2=(int) (scale*(((x - 1) * ResConfig.Map.GRID_WIDTH) * ResConfig.Map.MAP_SCALE +113*ResConfig.Map.MAP_SCALE));//右上,右下 ResConfig.Map.GRID_WIDTH
                hexgaon_x3=(int) (scale*(((x - 1) * ResConfig.Map.GRID_WIDTH) * ResConfig.Map.MAP_SCALE-1));//左中
                hexgaon_x4=(int) (scale*(((x - 1) * ResConfig.Map.GRID_WIDTH) * ResConfig.Map.MAP_SCALE + ResConfig.Map.HEXAGON_WIDTH * ResConfig.Map.MAP_SCALE ));//右中
                hexgaon_y1=(int) (scale*((((x & 1) == 1 ? (y - 1) * ResConfig.Map.HEXAGON_HEIGHT : (y - 1) * ResConfig.Map.HEXAGON_HEIGHT + ResConfig.Map.HEXAGON_HEIGHT_REF)) * ResConfig.Map.MAP_SCALE -1));//上
                hexgaon_y2=(int) (scale*((((x & 1) == 1 ? (y - 1) * ResConfig.Map.HEXAGON_HEIGHT : (y - 1) * ResConfig.Map.HEXAGON_HEIGHT + ResConfig.Map.HEXAGON_HEIGHT_REF)) * ResConfig.Map.MAP_SCALE + ResConfig.Map.HEXAGON_HEIGHT * ResConfig.Map.MAP_SCALE / 2));//中
                hexgaon_y3=(int) (scale*((((x & 1) == 1 ? (y - 1) * ResConfig.Map.HEXAGON_HEIGHT : (y - 1) * ResConfig.Map.HEXAGON_HEIGHT + ResConfig.Map.HEXAGON_HEIGHT_REF)) * ResConfig.Map.MAP_SCALE + ResConfig.Map.HEXAGON_HEIGHT * ResConfig.Map.MAP_SCALE ));//下

                if (mapBinDAO.getMapbin().get(id).getRegionId() != nextRegionId) {
                    color = GameUtil.getColorByNum(mapBinDAO.getMapbin().get(id).getRegionId());
                    //获取颜色
                    pixmap.setColor(color);
                    nextRegionId = mapBinDAO.getMapbin().get(id).getRegionId();
                    //Gdx.app.log("setColor","id:"+id+" color:"+color);
                }

                //Gdx.app.log("地图开始构建", "mapId:" + id + " x:" + x + " y:" + y);
                if (mapBinDAO.getMapbin().get(id).getBlockType()!=1&&mapBinDAO.getMapbin().get(id).getRegionId()!=0) {

                    pixmap.fillTriangle(hexgaon_x3, hexgaon_y2, hexgaon_x1, hexgaon_y1, hexgaon_x2, hexgaon_y1);
                    pixmap.fillTriangle(hexgaon_x3, hexgaon_y2, hexgaon_x2, hexgaon_y1, hexgaon_x4, hexgaon_y2);
                    pixmap.fillTriangle(hexgaon_x3, hexgaon_y2, hexgaon_x2, hexgaon_y3, hexgaon_x4, hexgaon_y2);
                    pixmap.fillTriangle(hexgaon_x3, hexgaon_y2, hexgaon_x1, hexgaon_y3, hexgaon_x2, hexgaon_y3);
                }

            }

            Gdx.app.log("色图构建", "完成");
            //  PixmapIO.writePNG(Gdx.files.external("texture_world.png"), pixmap);

            return pixmap;
        } else {
            Gdx.app.log("色图构建", "失败");
            return null;
        }
    }
    //修改region的颜色
    public static Pixmap updateColorByRegion(MapBinDAO mapBinDAO, Pixmap pixmap,float scale,int regionId,int color,List<Integer> coastGrid){

//待绘制地块
        List<Integer> ids=mapBinDAO.getIdsByRegionId(regionId);
        if (mapBinDAO.getMapbin() != null&&ids.size()>0) {
            pixmap.setColor(color);
            int x = 0;
            int y = 0;
            int x_px_circle = 0;
            int y_px_circle = 0;
            int hexgaon_x1;
            int hexgaon_x2;
            int hexgaon_x3;
            int hexgaon_x4;
            int hexgaon_y1;
            int hexgaon_y2;
            int hexgaon_y3;

            //先绘制海岸  //沿海地块用圆形来填充
            pixmap.setBlending(Blending.None);
            for(int id:ids) {
                if(mapBinDAO.getMapbin().get(id).getBlockType()!=1&&mapBinDAO.getMapbin().get(id).getRegionId()!=0 &&coastGrid.contains(id)){
                    x = (id % mapBinDAO.getMapWidth()) + 1;
                    y = (id / mapBinDAO.getMapWidth()) + 1;
                    x_px_circle = (int) (scale*(((x - 1) * ResConfig.Map.GRID_WIDTH) * ResConfig.Map.MAP_SCALE + ResConfig.Map.HEXAGON_WIDTH * ResConfig.Map.MAP_SCALE / 2));
                    y_px_circle = (int) (scale*((((x & 1) == 1 ? (y - 1) * ResConfig.Map.HEXAGON_HEIGHT : (y - 1) * ResConfig.Map.HEXAGON_HEIGHT + ResConfig.Map.HEXAGON_HEIGHT_REF)) * ResConfig.Map.MAP_SCALE + ResConfig.Map.HEXAGON_HEIGHT * ResConfig.Map.MAP_SCALE / 2));
                    //Gdx.app.log("海陆绘制圆", "" + id);
                    //沿海地块用圆形来填充
                    pixmap.fillCircle(x_px_circle, y_px_circle, (int) ((ResConfig.Map.HEXAGON_WIDTH + 13) * ResConfig.Map.MAP_SCALE / 2*scale));
                }
            }
            // 单线程绘制所有图片
            for (int id:ids) {

                x = (id % mapBinDAO.getMapWidth()) + 1;
                y = (id / mapBinDAO.getMapWidth()) + 1;

                hexgaon_x1=(int) (scale*(((x - 1) * ResConfig.Map.GRID_WIDTH) * ResConfig.Map.MAP_SCALE +35*ResConfig.Map.MAP_SCALE));//左上,左下 原来是36
                hexgaon_x2=(int) (scale*(((x - 1) * ResConfig.Map.GRID_WIDTH) * ResConfig.Map.MAP_SCALE +113*ResConfig.Map.MAP_SCALE));//右上,右下 ResConfig.Map.GRID_WIDTH
                hexgaon_x3=(int) (scale*(((x - 1) * ResConfig.Map.GRID_WIDTH) * ResConfig.Map.MAP_SCALE-1));//左中
                hexgaon_x4=(int) (scale*(((x - 1) * ResConfig.Map.GRID_WIDTH) * ResConfig.Map.MAP_SCALE + ResConfig.Map.HEXAGON_WIDTH * ResConfig.Map.MAP_SCALE ));//右中
                hexgaon_y1=(int) (scale*((((x & 1) == 1 ? (y - 1) * ResConfig.Map.HEXAGON_HEIGHT : (y - 1) * ResConfig.Map.HEXAGON_HEIGHT + ResConfig.Map.HEXAGON_HEIGHT_REF)) * ResConfig.Map.MAP_SCALE -1));//上
                hexgaon_y2=(int) (scale*((((x & 1) == 1 ? (y - 1) * ResConfig.Map.HEXAGON_HEIGHT : (y - 1) * ResConfig.Map.HEXAGON_HEIGHT + ResConfig.Map.HEXAGON_HEIGHT_REF)) * ResConfig.Map.MAP_SCALE + ResConfig.Map.HEXAGON_HEIGHT * ResConfig.Map.MAP_SCALE / 2));//中
                hexgaon_y3=(int) (scale*((((x & 1) == 1 ? (y - 1) * ResConfig.Map.HEXAGON_HEIGHT : (y - 1) * ResConfig.Map.HEXAGON_HEIGHT + ResConfig.Map.HEXAGON_HEIGHT_REF)) * ResConfig.Map.MAP_SCALE + ResConfig.Map.HEXAGON_HEIGHT * ResConfig.Map.MAP_SCALE ));//下

                //Gdx.app.log("地图开始构建", "mapId:" + id + " x:" + x + " y:" + y);
                if (mapBinDAO.getMapbin().get(id).getBlockType()!=1&&mapBinDAO.getMapbin().get(id).getRegionId()!=0) {

                    pixmap.fillTriangle(hexgaon_x3, hexgaon_y2, hexgaon_x1, hexgaon_y1, hexgaon_x2, hexgaon_y1);
                    pixmap.fillTriangle(hexgaon_x3, hexgaon_y2, hexgaon_x2, hexgaon_y1, hexgaon_x4, hexgaon_y2);
                    pixmap.fillTriangle(hexgaon_x3, hexgaon_y2, hexgaon_x2, hexgaon_y3, hexgaon_x4, hexgaon_y2);
                    pixmap.fillTriangle(hexgaon_x3, hexgaon_y2, hexgaon_x1, hexgaon_y3, hexgaon_x2, hexgaon_y3);
                }
            }
            Gdx.app.log("色图构建", "完成"+" regionId:"+regionId+" color:"+color);
             //PixmapIO.writePNG(Gdx.files.external("updateColor_"+regionId+".png"), pixmap);
            return pixmap;
        } else {
            Gdx.app.log("色图构建", "失败");
            return pixmap;
        }
    }

    // 绘制分区图片 512*512
    // pixmap要绘制的目标图片
    // pixmapLists使用图片
    // defTerrainimgs图片说明文件
    //beginX,beginY绘制的起始坐标
    public static Pixmap getPixmapForArea(MapBinDAO mapBinDAO, Pixmap pixmap, PixmapListDAO pixmapLists, List<DefTerrainimg> defTerrainimgs, int beginX, int beginY) {

        int areaW=ResConfig.Map.PT_GRID_WIDTH;
        int areaH=ResConfig.Map.PT_GRID_HEIGHT+1;

        beginX=beginX+1;
        beginY=beginY+1;

        int mapRefX=0;
        int mapRefXPx=0;

        //如果beginX不是1,则要从这个开始的再开始绘制
        if(beginX>1) {
            mapRefX=-1;
            mapRefXPx=(int) ((beginX-1)*ResConfig.Atlas.PT_SIDE % (ResConfig.Map.GRID_WIDTH*ResConfig.Map.MAP_SCALE)/ResConfig.Map.MAP_SCALE);
        }/**/

        int areaSum=areaW*areaH;
        int mapW=mapBinDAO.mapWidth;

        //区域偏移量

        // 解析dao
        if (mapBinDAO.getMapbin() != null) {

            int x = 0;
            int y = 0;
            int x_px = 0;
            int y_px = 0;
            HashMap<String, String> terrainimgMap = new HashMap<String, String>();
            // 将要取得的图片的id和名字放入位置
            for (DefTerrainimg defTerrainimg : defTerrainimgs) {
                terrainimgMap.put(defTerrainimg.getId() + "_" + defTerrainimg.getIdx(), defTerrainimg.getImage());
            }
            String imgBack;
            String imgFore;
            PixmapDAO backPixmap;
            PixmapDAO forePixmap;
            int id;

            // 单线程绘制图片
            for (int i = 0; i < areaSum; i++) {

                x = (i % areaW) + 1;
                y = (i / areaW) + 1;

                //判断是否跨行
                if(((beginX-1)*areaW+x-1)<mapW) {
                    id=((beginX-1)*areaW+x-1+mapRefX)+((beginY-1)*(areaH)+y-1)*mapW;//计算当前绘制的id
                }else {
                    id=((beginX-1)*areaW+x-1+mapRefX)+((beginY-1)*(areaH)+y-1)*mapW-mapW;
                }

                x_px = (int) ((x - 1) * ResConfig.Map.GRID_WIDTH)-mapRefXPx;
                y_px = (int) (((id & 1) == 1 ? (y - 1) * ResConfig.Map.HEXAGON_HEIGHT+ ResConfig.Map.HEXAGON_HEIGHT_REF : (y - 1) * ResConfig.Map.HEXAGON_HEIGHT ));

                /*if(beginX==2&&beginY==1) {
                    Gdx.app.log("测试:", "id:"+id+" x:"+x+" y:"+y+" x_px:"+x_px+" y_px:"+y_px);
                }*/

                if(id>=mapBinDAO.getMapbin().size()) {
                    break;
                }
                if (mapBinDAO.getMapbin().get(id).getBackTile() != 0 /*&& mapBinDAO.getMapbin().get(id).getBackTile() != 1*/) {

                  //Gdx.app.log("地图开始构建", "mapId:" + id + " x:" + x + " y:" + y);
                    // 获取该位置要画的地形 z
                    imgBack = terrainimgMap.get(mapBinDAO.getMapbin().get(id).getBackTile() + "_" + mapBinDAO.getMapbin().get(id).getBackIdx());
                    if (imgBack == null) {
                        //Gdx.app.log("地图层1未找到", mapBinDAO.getMapbin().get(id).getBackTile() + "_" + mapBinDAO.getMapbin().get(id).getBackIdx());
                        imgBack = terrainimgMap.get(mapBinDAO.getMapbin().get(id).getBackTile() + "_"+ComUtil.getRandom(1,4));
                    }
                    // 获取图像并绘制到上面
                    backPixmap = pixmapLists.getPixmapByName(imgBack);
                    if (backPixmap != null) {

                       pixmap.drawPixmap(backPixmap.getPixmap(), 0, 0, backPixmap.getPixmap().getWidth(), backPixmap.getPixmap().getHeight(), (int) ((x_px + mapBinDAO.getMapbin().get(id).getBackRefX()) * ResConfig.Map.MAP_SCALE),
                                (int) ((y_px + mapBinDAO.getMapbin().get(id).getBackRefY()) * ResConfig.Map.MAP_SCALE), (int) (backPixmap.getPixmap().getWidth() * ResConfig.Map.MAP_SCALE), (int) (backPixmap.getPixmap().getHeight() * ResConfig.Map.MAP_SCALE));
                     }
                }
                // 忽略底图和海洋
                if (mapBinDAO.getMapbin().get(id).getForeTile() != 0 && mapBinDAO.getMapbin().get(id).getForeTile() != 1) {
                    imgFore = terrainimgMap.get(mapBinDAO.getMapbin().get(id).getForeTile() + "_" + mapBinDAO.getMapbin().get(id).getForeIdx());
                    if (imgFore == null) {
                        Gdx.app.log("地图层2未找到",mapBinDAO.getMapbin().get(id).getForeTile() + "_" + mapBinDAO.getMapbin().get(id).getForeIdx());
                        imgFore = terrainimgMap.get(mapBinDAO.getMapbin().get(id).getForeTile() + "_1");
                    }
                    forePixmap = pixmapLists.getPixmapByName(imgFore);
                    if (forePixmap != null) {
                        pixmap.drawPixmap(forePixmap.getPixmap(), x_px + mapBinDAO.getMapbin().get(id).getForeRefX(), y_px + mapBinDAO.getMapbin().get(id).getForeRefY(), 0, 0, forePixmap.getPixmap().getWidth(), forePixmap.getPixmap().getHeight());
                    }
                }
            }
            /*if(beginX==2&&beginY==1) {
                PixmapIO.writePNG(Gdx.files.external("texture_"+beginY+"."+beginX+".png"), pixmap);
            }*/
            //PixmapIO.writePNG(Gdx.files.external("texture_"+beginY+"."+beginX+".png"), pixmap);

            Gdx.app.log("地图构建", "完成");
            return pixmap;
        } else {
            Gdx.app.log("地图构建", "失败");
            return null;
        }
    }

    // 读取地图 保存位置编号
    public static MapBinDAO saveBin(byte[] bt) throws IOException {

        MapBinDAO fs = new MapBinDAO(null);
        List<MapBin> mps = new ArrayList<MapBin>();

        /*
         * //TODO根据Index获取保存位置
         *
         * //定位bin位置 byte[] bt = GameUtils.readFile("D:\\test1.bin");
         */
        // 新建对象
        StringBuilder buf = new StringBuilder();
        int line = 0;// 十六进制标记
        for (byte d : bt) {
            if (line % 1 == 0) {
                buf.append(String.format("%02x", d));
                // System.out.println(String.format("%02x", d));
                // buf.append(",") ;
                line++;
            }
        }
        // 解析并赋值
        int bufTag = 0;
        // System.out.println(buf.substring(bufTag, bufTag+4));
        fs.setMapVersion(Integer.parseInt(buf.substring(bufTag, bufTag + 4), 16));
        bufTag = bufTag + 4;

        // System.out.println(buf.substring(bufTag, bufTag+8));
        int width = Integer.parseInt(buf.substring(bufTag, bufTag + 8), 16);
        bufTag = bufTag + 8;
        // System.out.println(buf.substring(bufTag, bufTag+8));
        int height = Integer.parseInt(buf.substring(bufTag, bufTag + 8), 16);
        bufTag = bufTag + 8;
        fs.setMapWidth(width);
        fs.setMapHeight(height);
        int totalCount = width * height;

        // System.out.println(fs.mapVersion);
        // System.out.println(width);
        // System.out.println(height);
        // System.out.println(totalCount);

        for (int i = 0; i < totalCount; i++) {
            MapBin mp = new MapBin();
            mp.setBlockType(Integer.parseInt(buf.substring(bufTag, bufTag + 2), 16));
            bufTag = bufTag + 2;
            mp.setBackTile(Integer.parseInt(buf.substring(bufTag, bufTag + 2), 16));
            bufTag = bufTag + 2;
            mp.setBackIdx(Integer.parseInt(buf.substring(bufTag, bufTag + 2), 16));
            bufTag = bufTag + 2;
            mp.setBackRefX(Integer.parseInt(buf.substring(bufTag, bufTag + 2), 16));
            bufTag = bufTag + 2;
            mp.setBackRefY(Integer.parseInt(buf.substring(bufTag, bufTag + 2), 16));
            bufTag = bufTag + 2;
            mp.setForeTile(Integer.parseInt(buf.substring(bufTag, bufTag + 2), 16));
            bufTag = bufTag + 2;
            mp.setForeIdx(Integer.parseInt(buf.substring(bufTag, bufTag + 2), 16));
            bufTag = bufTag + 2;
            mp.setForeRefX(Integer.parseInt(buf.substring(bufTag, bufTag + 2), 16));
            bufTag = bufTag + 2;
            mp.setForeRefY(Integer.parseInt(buf.substring(bufTag, bufTag + 2), 16));
            bufTag = bufTag + 2;
            mp.setWaterPass(Integer.parseInt(buf.substring(bufTag, bufTag + 2), 16));
            bufTag = bufTag + 2;
            mp.setLandPass(Integer.parseInt(buf.substring(bufTag, bufTag + 2), 16));
            bufTag = bufTag + 2;
            mp.setRegionId(Integer.parseInt(buf.substring(bufTag, bufTag + 8), 16));
            bufTag = bufTag + 8;
            mp.setClimateId(Integer.parseInt(buf.substring(bufTag, bufTag + 2), 16));
            bufTag = bufTag + 2;
            mp.setBuildId(Integer.parseInt(buf.substring(bufTag, bufTag+2),16));
            bufTag=bufTag+2;
            mp.setBuildLv(Integer.parseInt(buf.substring(bufTag, bufTag+2),16));
            bufTag=bufTag+2;
            mp.setFacility(Integer.parseInt(buf.substring(bufTag, bufTag+2),16));
            bufTag=bufTag+2;
            mp.setAreaId(Integer.parseInt(buf.substring(bufTag, bufTag+4),16));
            bufTag=bufTag+4;
            mps.add(mp);
        }
        fs.setMapbin(mps);

        return fs;
    }

    public static int getWidth(int w) {
        return (int) ((148 + ResConfig.Map.GRID_WIDTH * (w - 1)));
    }

    public static int getHeight(int h) {
        return (int) ((192 + ResConfig.Map.HEXAGON_HEIGHT * (h - 1)));
    }

    // 六边形网格定位
    // @param xPos 输入，所需查询的点的x坐标
    // @param yPos 输入，所需查询的点的y坐标
    // @param cell_x 输出，改点所在网格的x坐标
    // @param cell_y 输出，改点所在网格的y坐标
    public static Coord getHotCell(float xPos, float yPos,float zoom) {

        float GRID_WIDTH = ResConfig.Map.GRID_WIDTH;// (CELL_BORDER*1.5f)
        float GRID_HEIGHT =ResConfig.Map.HEXAGON_HEIGHT;// (CELL_BORDER*0.8660254f)
        float Grid_BORDER=GRID_WIDTH/1.5f;

        int cell_y;
        int cell_x;
        xPos=xPos/ResConfig.Map.MAP_SCALE;
        yPos=yPos/ResConfig.Map.MAP_SCALE;
        cell_x = (int) (xPos / GRID_WIDTH);
        float x = xPos - cell_x * GRID_WIDTH;

        cell_y = (int) (yPos   / GRID_HEIGHT);
        float y = yPos -     cell_y * GRID_HEIGHT;

        //if(! (Grid_BORDER-Math.abs((x-1/2*GRID_WIDTH))>Math.abs(y-1/2*GRID_HEIGHT)/Math.sqrt(3))) {
        if(! (Math.abs(GRID_WIDTH/2-x)+Math.abs(GRID_HEIGHT/2-y)/Math.sqrt(3)<=Grid_BORDER*Math.sqrt(3))) {
            //不在六边形内部
            if(x>GRID_WIDTH/2) {
                //在右边
                cell_x++;
            }
        }

        /*if( cell_x % 2==1 && y<64) {
            cell_y--;
        }
        if((cell_x&1)!=1&& y>64) {
            cell_y=cell_y-1;
        }
        if(cell_y<0) {
            cell_y=0;
        }*/

        Coord coord = new Coord(cell_x, cell_y);
        return coord;

    }

    // 六边形网格定位
    // @param xPos 输入，所需查询的点的x坐标
    // @param yPos 输入，所需查询的点的y坐标,y必须转换,因为以左上开始计算
    // @param cell_x 输出，改点所在网格的x坐标
    // @param cell_y 输出，改点所在网格的y坐标
    public static Coord getHotCell2(float xPos, float yPos) {

        float GRID_WIDTH =ResConfig.Map.GRID_WIDTH;
        float GRID_HEIGHT =ResConfig.Map.HEXAGON_HEIGHT;// (CELL_BORDER*0.8660254f)
        float GRID_W_B=(GRID_WIDTH/4);//宽-变成/2 即小长 

        int cell_y;
        int cell_x;
        float vertex_x_px;
        float vertex_y_px;
        xPos=xPos/ResConfig.Map.MAP_SCALE;//不知道为什么会出现偏移,所以通过这里来减少偏移
        yPos=yPos/ResConfig.Map.MAP_SCALE;
        cell_x = (int) (xPos / GRID_WIDTH);
        float x = Math.abs(xPos - cell_x * GRID_WIDTH);
        cell_y = (int) (yPos   / GRID_HEIGHT);
        float y = Math.abs(yPos -     cell_y * GRID_HEIGHT);

        //先判断位置
        if(x<GRID_W_B) {
            if(y<GRID_HEIGHT/2) {
                //在上
                if(x/Math.tan(60)<y) {
                    cell_x++;
                }
            }else {
                //在下
                if(x/Math.tan(60)<(y-GRID_HEIGHT/2)) {
                    cell_x++;
                }
            }
        //右边
        }/**/

        if( cell_x % 2==0 && y<64) {
            cell_y--;
        }else if(cell_x % 2!=0){
            cell_y--;
        }
        /*if((cell_x&1)!=1&& y>64) {
            cell_y=cell_y-1;
        }
        if(cell_y<0) {
            cell_y=0;
        }*/

        vertex_x_px=cell_x*GRID_WIDTH*ResConfig.Map.MAP_SCALE;
        vertex_y_px=cell_x%2!=0?(cell_y+1)*GRID_HEIGHT*ResConfig.Map.MAP_SCALE:(cell_y+0.5f)*GRID_HEIGHT*ResConfig.Map.MAP_SCALE;
        Coord coord = new Coord(-cell_x, cell_y-1,vertex_x_px,vertex_y_px);
        return coord;
    }

    // TODO
    // 横六边形地图类
    class hexagonMap {
        private int w;
        private int h;
        private float w_px;// 单个像素长度
        private float h_px;// 单个像素宽度
        private float sum_w_px;
        private float sum_h_px;
    }

    //画六边形网格
    public static Pixmap drawHexagonGrid(Pixmap pixmap, MapBinDAO mapBinDAO)// 画网格
    {
        // 加载边框
        int x = 0;
        int y = 0;
        int x_px = 0;
        int y_px = 0;
        // 将要取得的图片的id和名字放入位置
        Pixmap gridPixmap = new Pixmap(Gdx.files.internal("pixmap/tiles/grid.png"));
        // 绘制网格图片
        for (int id = 0; id < mapBinDAO.getMapbin().size(); id++) {
            x = (id % mapBinDAO.getMapWidth()) + 1;
            y = (id / mapBinDAO.getMapWidth()) + 1;
            // x_px=(int) ((x-1)*139.5);
            // y_px=(int) ((x&1) == 1?(y-1)*161:(y-1)*161+80.5);
            x_px = (int) ((x - 1) * ResConfig.Map.GRID_WIDTH);
            y_px = (int) (((x & 1) == 1 ? (y - 1) * ResConfig.Map.HEXAGON_HEIGHT : (y - 1) * ResConfig.Map.HEXAGON_HEIGHT + ResConfig.Map.HEXAGON_HEIGHT_REF));
            // Gdx.app.log("绘制地图网格", "mapId:" + id + " x:" + x + " y:" + y);
            pixmap.drawPixmap(gridPixmap, 0, 0, gridPixmap.getWidth(), gridPixmap.getHeight(), (int) ((x_px + mapBinDAO.getMapbin().get(id).getBackRefX()) * ResConfig.Map.MAP_SCALE), (int) ((y_px + mapBinDAO.getMapbin().get(id).getBackRefY()) * ResConfig.Map.MAP_SCALE),
                    (int) (gridPixmap.getWidth() * ResConfig.Map.MAP_SCALE), (int) (gridPixmap.getHeight() * ResConfig.Map.MAP_SCALE));
        }
        // 清除边框
        gridPixmap.dispose();
        return pixmap;
    }

  //画六边形网格
    public static Pixmap drawHexagonGridByView(Pixmap pixmap,AssetManager am)// 画网格
    {
        // 加载边框
        int x = 0;
        int y = 0;
        int x_px = 0;
        int y_px = 0;
        // 将要取得的图片的id和名字放入位置
        //Pixmap gridPixmap = new Pixmap(Gdx.files.internal("pixmap/tiles/grid.png"));
        Pixmap gridPixmap = am.get(("pixmap/tiles/grid.png"),Pixmap.class);

        int w=(int)(pixmap.getWidth()/ResConfig.Map.GRID_WIDTH/ResConfig.Map.MAP_SCALE)+3;
        int h=(int)(pixmap.getHeight()/ResConfig.Map.HEXAGON_HEIGHT/ResConfig.Map.MAP_SCALE)+3;
        int size=w*h;

        // 绘制网格图片
        for (int id = 0; id < size; id++) {
            x = (id % w) + 1;
            y = (id / w) + 1;
            // x_px=(int) ((x-1)*139.5);
            // y_px=(int) ((x&1) == 1?(y-1)*161:(y-1)*161+80.5);
            x_px = (int) ((x - 1) * ResConfig.Map.GRID_WIDTH);
            y_px = (int) (((x & 1) == 1 ? (y - 1) * ResConfig.Map.HEXAGON_HEIGHT : (y - 1) * ResConfig.Map.HEXAGON_HEIGHT + ResConfig.Map.HEXAGON_HEIGHT_REF));
             //Gdx.app.log("绘制地图网格", "mapId:" + id + " x:" + x + " y:" + y+ " x_px:" + x_px + " y_px:" + y_px);
            pixmap.drawPixmap(gridPixmap, 0, 0, gridPixmap.getWidth(), gridPixmap.getHeight(), (int) ((x_px)* ResConfig.Map.MAP_SCALE), (int) ((y_px) * ResConfig.Map.MAP_SCALE),
                    (int) (gridPixmap.getWidth() * ResConfig.Map.MAP_SCALE), (int) (gridPixmap.getHeight() * ResConfig.Map.MAP_SCALE));
        }
        // 清除边框
        //gridPixmap.dispose();
        return pixmap;
    }

    // Pixmap大小计算
    // w=186+139.5*(x-1) h=242+161*(y-1)
    // int w = (int) (186 + 139.5 * (defMap.getWidth() - 1));
    // int h = 242 + 161 * (defMap.getHeight() - 1);
    // int w = (int) ((148 + ResConfig.Map.GRID_WIDTH * (defMap.getWidth() - 1)));
    // int h = (int) ((191 + ResConfig.Map.HEXAGON_HEIGHT * (defMap.getHeight() - 1)));
    public static Pixmap createPixmapByDefMap(DefMap defMap) {
        int w = GameMap.getWidth(defMap.getWidth());
        int h = GameMap.getHeight(defMap.getHeight());

        int sum = defMap.getWidth() * defMap.getHeight();
        /*
         * if(sum>10000) { scale=(float) (((int)(10-(sum-10000)*0.0001))*0.06);
         * }
         */
        w = (int) (w * ResConfig.Map.MAP_SCALE);
        h = (int) (h * ResConfig.Map.MAP_SCALE);

        //Gdx.app.log("地图大小", "sum:" + sum + " w:" + defMap.getWidth() + " h:" + defMap.getHeight());
        //Gdx.app.log("地图图片大小", "缩放比例:" + Config.Map.MAP_SCALE + " w_px:" + w + " h_px:" + h);
        return new Pixmap(w, h, Pixmap.Format.RGBA8888);
    }

    public static Pixmap createPixmap(int mapW,int mapH) {
        int w = GameMap.getWidth(mapW);
        int h = GameMap.getHeight(mapH);

        int sum = w * h;
        /*
         * if(sum>10000) { scale=(float) (((int)(10-(sum-10000)*0.0001))*0.06);
         * }
         */
        w = (int) (w * ResConfig.Map.MAP_SCALE);
        h = (int) (h * ResConfig.Map.MAP_SCALE);

        //Gdx.app.log("地图大小", "sum:" + sum + " w:" + defMap.getWidth() + " h:" + defMap.getHeight());
        //Gdx.app.log("地图图片大小", "缩放比例:" + Config.Map.MAP_SCALE + " w_px:" + w + " h_px:" + h);
        return new Pixmap(w, h, Pixmap.Format.RGBA8888);
    }

    //创建一个当前窗口大小的画布
    public static Pixmap createPixmapByView(float vw,float vh) {
        int w = (int)vw;
        int h = (int)vh;
        //Gdx.app.log("海洋地图:"," w:" + w + " h:" +h);

       return new Pixmap(w, h, Pixmap.Format.RGBA8888);
    }

    // 使用前必须初始化 pixmap
    // ptId-->type -1固定 1海洋 0底图通用 2沙漠 3雪地 4草地 5泥地 6外星 7热带草地
    public static Pixmap coverImgByPtimgId(Pixmap pixmap, int ptId) {
        // 通过配置文件获取读取的pt
        DefPt defPt = new DefPt();
        List<DefPt> defPts = new ArrayList<DefPt>();
        try {
            defPts = GameUtil.getDaoListByClass(defPt, "config/def_pt.xml");
        } catch (Exception e) {
            e.printStackTrace();
        }
        String imgPtStr = null;
        for (int i = 0; i < defPts.size(); i++) {
            if (defPts.get(i).getId() == ptId) {
                imgPtStr = defPts.get(i).getImage();
                break;
            }
        }
        if (imgPtStr != null && pixmap != null) {
            // 获取图片资源
            Pixmap imgPt = new Pixmap(Gdx.files.internal("pixmap/pts/" + imgPtStr));
            // 获取目标长宽,并循环绘制
            int w = (int) ((pixmap.getWidth() / imgPt.getWidth()) + 1);
            int h = (int) ((pixmap.getHeight() / imgPt.getHeight()) + 1);
            int x = 0;
            int y = 0;
            int x_px;
            int y_px;
            int coverCount = w * h;

            // Gdx.app.log("地图底图开始构建", "w:" + w + " h:" + h );
            for (int i = 0; i < coverCount; i++) {
                x = i % w;
                y = (int) (i / w);
                x_px = x * imgPt.getWidth();
                y_px = y * imgPt.getHeight();
                 Gdx.app.log("地图底图开始构建", " id:" + i + " x:" + x + " y:" + y+ "x_px:" + x_px + " y_px:" + y_px);
                pixmap.drawPixmap(imgPt, x_px, y_px, 0, 0, imgPt.getWidth(), imgPt.getHeight());
            }
            /*if(ptId==1){
                int color = pixmap.getPixel(12, 12);
                //pixmap.drawPixel(xC, yC, color);
                Gdx.app.log("海色","color:"+color);
            }*/

            // 清除资源
            imgPt.dispose();
        }
        return pixmap;
    }

   //获得地形装饰的最高上限,最低下限为0
   //储存方式为 Map(id_type+"_min",idx_min) Map(id_type+"_max",idx_max)
    public static Map getDecorateRandMaxMap() {
        DefTerrainimg defTerrainimg = new DefTerrainimg();
        List<DefTerrainimg> defTerrainimgs = new ArrayList<DefTerrainimg>();
        try {
            defTerrainimgs = GameUtil.getDaoListByClass(defTerrainimg,
                    "config/def_terrainimg.xml");
        } catch (Exception e) {
            e.printStackTrace();
        }
        int i,iLength;
        iLength=defTerrainimgs.size();
        Map map=new HashMap();
        for(i=0;i<iLength;i++) {//省略掉类型为-1的值
            if(defTerrainimgs.get(i).getType()==-1) {
            } else if(!map.containsKey((defTerrainimgs.get(i).getId()+"_"+defTerrainimgs.get(i).getType()+"_min"))) {
                map.put(defTerrainimgs.get(i).getId()+"_"+defTerrainimgs.get(i).getType()+"_min", defTerrainimgs.get(i).getIdx());
            } else if(!map.containsKey((defTerrainimgs.get(i).getId()+"_"+defTerrainimgs.get(i).getType()+"_max"))) {
                map.put(defTerrainimgs.get(i).getId()+"_"+defTerrainimgs.get(i).getType()+"_max", defTerrainimgs.get(i).getIdx());
            }else if((Integer)map.get(defTerrainimgs.get(i).getId()+"_"+defTerrainimgs.get(i).getType()+"_min")>defTerrainimgs.get(i).getIdx()  ) {
                map.put(defTerrainimgs.get(i).getId()+"_"+defTerrainimgs.get(i).getType()+"_min", defTerrainimgs.get(i).getIdx());
            }else if((Integer)map.get(defTerrainimgs.get(i).getId()+"_"+defTerrainimgs.get(i).getType()+"_max")<defTerrainimgs.get(i).getIdx()  ) {
                map.put(defTerrainimgs.get(i).getId()+"_"+defTerrainimgs.get(i).getType()+"_max", defTerrainimgs.get(i).getIdx());
            }
        }
        return map;
    }

    //添加周围的id坐标
    public static List<Coord>  addCoordByIds(List<Integer> aroundIds,int w){
        int cell_x,cell_y;float vertex_x_px,vertex_y_px;
        List<Coord> coords = new ArrayList<Coord>();

        for(Integer id:aroundIds) {
            cell_x=id-(int)(id/w)*w;
            cell_y=(int)(id/w)+1;
            vertex_x_px=-cell_x*ResConfig.Map.GRID_WIDTH*ResConfig.Map.MAP_SCALE;
            vertex_y_px=-cell_x%2!=0?(cell_y+1)*ResConfig.Map.HEXAGON_HEIGHT*ResConfig.Map.MAP_SCALE:(cell_y+0.5f)*ResConfig.Map.HEXAGON_HEIGHT*ResConfig.Map.MAP_SCALE;
            coords.add(new Coord(cell_x,cell_y,vertex_x_px,vertex_y_px));
        }
        return coords;
    }

    //根据smallMap文件绘制图片顺便清理图片
    public static Pixmap drawSmallMapAndClearPixmap(int mapId,AssetManager am){
        XmlReader reader = ResConfig.reader;
        XmlReader.Element root = reader.parse(Gdx.files.internal("config/def_smallmap.xml"));
        int childNum = root.getChildCount();
        String imgFileName;
        int w=0;
        int h=0;
        Pixmap pixmap = null;XmlReader.Element xmlFile;
        for (int i = 0; i < childNum; i++) {
            if (root.getChild(i).getInt("id")==mapId) {
                imgFileName=root.getChild(i).get("name");
                xmlFile=root.getChild(i);
                pixmap = GameMap.createPixmapByView(xmlFile.getInt("width"), xmlFile.getInt("height"));
                for(int j=0;j<xmlFile.getChildCount();j++) {
                    pixmap.drawPixmap(am.get(("image/"+imgFileName+"/"+xmlFile.getChild(j).get("n")),Pixmap.class),xmlFile.getChild(j).getInt("x"),xmlFile.getChild(j).getInt("y"));
                    am.unload("image/"+imgFileName+"/"+xmlFile.getChild(j).get("n"));
                }
                break;
            }
        }
        //PixmapIO.writePNG(Gdx.files.external("smallWorld.png"), pixmap);
        return pixmap;
    }

}

GameMap