Пример #1
0
        private FixNode putFixNode(int sx, int sy, int dx, int dy, int tile, int flip)
        {
            String  key   = sx + "_" + sy + "_" + dx + "_" + dy;
            FixNode value = new FixNode(tile, flip);

            if (!FixTable.ContainsKey(key))
            {
                FixTable.Add(key, value);
            }
            return(value);
        }
Пример #2
0
        public void putSelectRegion(
            MapForm map,
            int bx,
            int by)
        {
            if (MapClip != null)
            {
                MapLayer clip_layer = MapClip.getCurLayer();
                MapLayer dst_layer  = map.getCurLayer();

                int px = MapClip.XCount / 2;
                int py = MapClip.XCount / 2;

                bx -= px;
                by -= py;

                for (int x = 0; x < MapClip.XCount; x++)
                {
                    for (int y = 0; y < MapClip.XCount; y++)
                    {
                        int lenx = Math.Abs(x - px);
                        int leny = Math.Abs(y - py);

                        int dbx = bx + x;
                        int dby = by + y;

                        if (dbx >= 0 && dbx < map.XCount &&
                            dby >= 0 && dby < map.YCount)
                        {
                            int      srcTile = MapClip.getTileID(clip_layer, x, y);
                            int      srcFlip = MapClip.getTileFlip(clip_layer, x, y);
                            DeepNode srcDeep = getTileDeep(srcTile, srcFlip);

                            int      dstTile = map.getTileID(dst_layer, dbx, dby);
                            int      dstFlip = map.getTileFlip(dst_layer, dbx, dby);
                            DeepNode dstDeep = getTileDeep(dstTile, dstFlip);

                            if (dstDeep == null)
                            {
                                srcTile = MapClip.getTileID(clip_layer, x, y);
                                srcFlip = MapClip.getTileFlip(clip_layer, x, y);
                                map.putTile(dst_layer, srcTile, dbx, dby);
                                map.putFlip(dst_layer, srcFlip, dbx, dby);
                            }
                            else
                            {
                                if (dstDeep.Len < srcDeep.Len)//联合
                                {
                                    if (srcDeep.DX != 0 && srcDeep.DY != 0)
                                    {
                                        if (srcDeep.DX == -dstDeep.DX ||
                                            srcDeep.DY == -dstDeep.DY)
                                        {
                                            FixNode fix = null;

                                            if (srcDeep.DX == -dstDeep.DX)
                                            {
                                                fix = getFixNode(-srcDeep.DX, srcDeep.DY, dstDeep.DX, dstDeep.DY);
                                            }
                                            else if (srcDeep.DY == -dstDeep.DY)
                                            {
                                                fix = getFixNode(srcDeep.DX, -srcDeep.DY, dstDeep.DX, dstDeep.DY);
                                            }

                                            if (fix != null)
                                            {
                                                // Console.WriteLine("联合 : " + x + ", " + y);
                                                map.putTile(dst_layer, fix.Tile, dbx, dby);
                                                map.putFlip(dst_layer, fix.Flip, dbx, dby);
                                            }
                                        }
                                    }
                                }
                                else if (dstDeep.Len > srcDeep.Len)//覆盖
                                {
                                    FixNode fix = null;

                                    if (dstDeep.DX != 0 && dstDeep.DY != 0)
                                    {
                                        if (srcDeep.DX == -dstDeep.DX)
                                        {
                                            fix = getFixNode(srcDeep.DX, 0, -dstDeep.DX, dstDeep.DY);
                                        }
                                        else if (srcDeep.DY == -dstDeep.DY)
                                        {
                                            fix = getFixNode(0, srcDeep.DY, dstDeep.DX, -dstDeep.DY);
                                        }
                                    }

                                    // Console.WriteLine("覆盖 : " + x + ", " + y);
                                    if (fix != null)
                                    {
                                        map.putTile(dst_layer, fix.Tile, dbx, dby);
                                        map.putFlip(dst_layer, fix.Flip, dbx, dby);
                                    }
                                    else
                                    {
                                        map.putTile(dst_layer, srcTile, dbx, dby);
                                        map.putFlip(dst_layer, srcFlip, dbx, dby);
                                    }
                                }
                                else if (srcDeep.Len == dstDeep.Len)
                                {
                                    if (srcTile != dstTile || srcFlip != dstFlip)//冲突
                                    {
                                        //

                                        if (srcDeep.Len == 0 || dstDeep.Len == 0)
                                        {
                                            map.putTile(dst_layer, srcTile, dbx, dby);
                                            map.putFlip(dst_layer, srcFlip, dbx, dby);
                                        }
                                        else
                                        {
                                            FixNode fix = null;
//冲突 : 0, 1
//srcDeep : -1, 0
//dstDeep : 0, 1

//冲突 : 1, 0
//srcDeep : 0, -1
//dstDeep : 1, 0

                                            Console.WriteLine("冲突 : " + x + ", " + y);
                                            Console.WriteLine("srcDeep : " + srcDeep.DX + ", " + srcDeep.DY);
                                            Console.WriteLine("dstDeep : " + dstDeep.DX + ", " + dstDeep.DY);

                                            if (x != 0 && y != 0)
                                            {
                                                fix = getFixNode(srcDeep.DX, srcDeep.DY, dstDeep.DX, dstDeep.DY);
                                            }

                                            if (fix != null)
                                            {
                                                map.putTile(dst_layer, fix.Tile, dbx, dby);
                                                map.putFlip(dst_layer, fix.Flip, dbx, dby);
                                            }

                                            /*
                                             * if (srcDeep.DX != 0 && srcDeep.DX == -dstDeep.DX &&
                                             *  srcDeep.DY != 0 && srcDeep.DY == -dstDeep.DY)
                                             * {
                                             *
                                             * }
                                             */
                                            else
                                            {
                                                int sdx = x;
                                                int sdy = y;

                                                if (srcDeep.DX != dstDeep.DX && srcDeep.DY == dstDeep.DY)//水平扩展
                                                {
                                                    sdx -= Util.getDirect(x - px);
                                                }
                                                else if (srcDeep.DX == dstDeep.DX && srcDeep.DY != dstDeep.DY)//垂直扩展
                                                {
                                                    sdy -= Util.getDirect(y - py);
                                                }
                                                else // 缩回
                                                {
                                                    sdx += Util.getDirect(px - x);
                                                    sdy += Util.getDirect(py - y);
                                                }

                                                if (sdx >= 0 && sdx < MapClip.XCount && sdy >= 0 && sdy < MapClip.YCount)
                                                {
                                                    srcTile = MapClip.getTileID(clip_layer, sdx, sdy);
                                                    srcFlip = MapClip.getTileFlip(clip_layer, sdx, sdy);
                                                    map.putTile(dst_layer, srcTile, dbx, dby);
                                                    map.putFlip(dst_layer, srcFlip, dbx, dby);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }