Ejemplo n.º 1
0
        public static bool IsVisible(Vector2w posStart, Vector2w posEnd, Map map, BlockInfo blockInfo)
        {
            Vector2f startPos = new Vector2f(posStart.x + 0.5f, posStart.y + 0.5f);
            Vector2f endPos   = new Vector2f(posEnd.x + 0.5f, posEnd.y + 0.5f);

            return(TraceRayVisible(startPos, endPos, posStart.GetR(posEnd), map, blockInfo));
        }
Ejemplo n.º 2
0
 public GameActionRotateUnit(uint unitUid, int dir, Vector2w pos)
 {
     actionType = EGameAction.rotateUnit;
     unitUID    = unitUid;
     this.pos   = new Vector2w(pos);
     this.dir   = dir;
 }
Ejemplo n.º 3
0
 public MsgServerCreateBattle(uint userId, int seed, Vector2w size)
     : base(EMsgNetServer.createBattle)
 {
     id        = userId;
     this.seed = seed;
     this.size = size;
     json      = JsonWriter.Serialize(this);
 }
Ejemplo n.º 4
0
 public bool IsMap(Vector2w pos)
 {
     if (pos.x < 0 || pos.y < 0 || pos.x >= size.x || pos.y >= size.y)
     {
         return(false);
     }
     return(true);
 }
Ejemplo n.º 5
0
        public Vector2w GetFreeStartPos(Random rnd)
        {
            int      idx = rnd.Next(0, map.unitPoint.Count);
            Vector2w p   = map.unitPoint[idx];

            map.unitPoint.RemoveAt(idx);
            return(p);
        }
Ejemplo n.º 6
0
 public bool IsVisibleBlock(Vector2w pos, BlockInfo blockInfo)
 {
     if (map[pos.x, pos.y].block == null)
     {
         return(true);
     }
     return(blockInfo[map[pos.x, pos.y].block.type].isVisible);
 }
Ejemplo n.º 7
0
 public int GetR(Vector2w inVec)
 {
     if (Math.Abs(x - inVec.x) > Math.Abs(y - inVec.y))
     {
         return(Math.Abs(x - inVec.x));
     }
     return(Math.Abs(y - inVec.y));
 }
Ejemplo n.º 8
0
 public GameActionVisible(Unit unit, bool visible)
 {
     actionType   = EGameAction.visibleUnit;
     this.visible = visible;
     unitUID      = unit.uid;
     pos          = unit.pos;
     dir          = unit.dir;
     unitType     = unit.id;
 }
Ejemplo n.º 9
0
 public void Create(Vector2w size)
 {
     this.size = size;
     map       = new MapItem[size.x, size.y];
     for (int x = 0; x < size.x; x++)
     {
         for (int y = 0; y < size.y; y++)
         {
             map[x, y] = new MapItem();
         }
     }
 }
Ejemplo n.º 10
0
 static bool IsShotFree(Vector2w pos, bool isThrow, Map map, BlockInfo blockInfo)
 {
     if (!isThrow && map.IsUnitPos(pos))
     {
         return(true);
     }
     if (!map.IsMoveBlock(pos, blockInfo))
     {
         return(false);
     }
     return(true);
 }
Ejemplo n.º 11
0
 public bool IsBeside(Vector2w p)
 {
     if (p.x != x && p.y != y)
     {
         return(false);
     }
     if (GetR(p) != 1)
     {
         return(false);
     }
     return(true);
 }
Ejemplo n.º 12
0
        public Map Create(int seed, Vector2w size, BlockInfo blockInfo)
        {
            this.blockInfo = blockInfo;
            moveMap        = new int[size.x, size.y];
            rnd            = new Random(seed);

            map = new Map();
            map.Create(size);

            GenerateTile();
            GenerateBlocks();
            GenerateUnitPoint();

            return(map);
        }
Ejemplo n.º 13
0
 private bool SetStartPoint(int idx)
 {
     for (int x = 0; x < map.Size.x; x++)
     {
         for (int y = 0; y < map.Size.y; y++)
         {
             Vector2w p = new Vector2w(x, y);
             if (map.IsMove(p, blockInfo) && moveMap[p.x, p.y] == 0)
             {
                 moveMap[p.x, p.y] = idx;
                 return(true);
             }
         }
     }
     return(false);
 }
Ejemplo n.º 14
0
        private bool FillAround(int x, int y, int idx, Dictionary <int, int> cnt)
        {
            bool res = false;

            for (int i = 0; i < 4; i++)
            {
                Vector2w p = new Vector2w(x, y) + offset[i];
                if (map.IsMap(p) && map.IsMove(p, blockInfo) && moveMap[p.x, p.y] == 0)
                {
                    moveMap[p.x, p.y] = idx;
                    cnt[idx]++;
                    res = true;
                }
            }
            return(res);
        }
Ejemplo n.º 15
0
 public bool IsMove(Vector2w pos, BlockInfo blockInfo)
 {
     if (IsUnitPos(pos))
     {
         return(false);
     }
     if (map[pos.x, pos.y].block == null)
     {
         return(true);
     }
     if (blockInfo[map[pos.x, pos.y].block.type].isMove)
     {
         return(true);
     }
     return(false);
 }
Ejemplo n.º 16
0
 /*
  *      public override string ToString()
  *      {
  *              return x.ToString() + "," + y;
  *      }
  */
 public void MoveTo1(Vector2w inTarget)
 {
     if (x < inTarget.x)
     {
         x++;
     }
     else if (x > inTarget.x)
     {
         x--;
     }
     if (y < inTarget.y)
     {
         y++;
     }
     else if (y > inTarget.y)
     {
         y--;
     }
 }
Ejemplo n.º 17
0
        public void Create(PrepareBattle prepareBattle, int seed)
        {
            mode      = prepareBattle.mode;
            this.seed = seed;

            MapGenerator generator = new MapGenerator();
            int          s         = 24;

            if (prepareBattle.users.Count > 2)
            {
                s = 32;
            }
            size = new Vector2w(s, s);
            map  = generator.Create(seed, size, GameData.blockInfo);

            data = new BattleData();
            data.Init(prepareBattle);

            findRoad = new FindRoad(size);
        }
Ejemplo n.º 18
0
        private Vector2w OffsetUnitPoint(Vector2w pos)
        {
            int r = 1;

            do
            {
                for (int x = 0; x < r * 2 + 1; x++)
                {
                    for (int y = 0; y < r * 2 + 1; y++)
                    {
                        Vector2w p = new Vector2w(pos.x + x - 1, pos.y + y - 1);
                        if (map.IsMap(p) && moveMap[p.x, p.y] != 0)
                        {
                            return(p);
                        }
                    }
                }
                r++;
            } while (true);
        }
Ejemplo n.º 19
0
        private void GenerateBlocks()
        {
            int percent = 20;
            int count   = map.Size.x * map.Size.y * percent / 100;

            for (int i = 0; i < count; i++)
            {
                Vector2w pos;
                do
                {
                    pos = new Vector2w(rnd.Next(0, map.Size.x), rnd.Next(0, map.Size.x));
                } while (map.IsBlock(pos));

                int   idxBlock = rnd.Next(0, blocks.Length);
                Block block    = new Block()
                {
                    health = blockInfo[blocks[idxBlock]].health, type = blocks[idxBlock]
                };
                map.SetBlock(pos, block);
            }
        }
Ejemplo n.º 20
0
        public static int GetDir(Vector2w pos, Vector2w target)
        {
            if (pos == target)
            {
                return(0);
            }
            int dirX = target.x - pos.x;
            int dirY = target.y - pos.y;

            if (dirY > 0)
            {
                return(0);
            }
            if (dirY < 0)
            {
                return(2);
            }
            if (dirX > 0)
            {
                return(1);
            }
            return(3);
        }
Ejemplo n.º 21
0
        public static bool TraceRayShot(Vector2f posStart, Vector2f posEnd, int length, out List <Vector2f> outPosCollisions, bool isThrow, Map map, BlockInfo blockInfo)
        {
            outPosCollisions = new List <Vector2f>();
            Vector2f aDir = posEnd - posStart;
            float    ax;
            float    ay;

            if (Math.Abs(aDir.x) > Math.Abs(aDir.y))
            {
                if (Math.Abs(aDir.y) > 0.001f)
                {
                    ay = aDir.y / Math.Abs(aDir.x);
                }
                else
                {
                    ay = 0;
                }
                ax = 1.0f;
                if (aDir.x < 0)
                {
                    ax = -1.0f;
                }
            }
            else
            {
                if (Math.Abs(aDir.x - 0.0f) > 0.001f)
                {
                    ax = aDir.x / Math.Abs(aDir.y);
                }
                else
                {
                    ax = 0;
                }
                ay = 1.0f;
                if (aDir.y < 0)
                {
                    ay = -1.0f;
                }
            }
            Vector2f aCurPos   = new Vector2f(posStart.x, posStart.y);
            int      aCountLen = 0;

            while (true)
            {
                aCurPos.x += ax;
                aCurPos.y += ay;

                Vector2w pos = new Vector2w((int)Math.Floor(aCurPos.x), (int)Math.Floor(aCurPos.y));
                if (!map.IsMap(pos))
                {
                    if (isThrow)
                    {
                        aCurPos.x -= ax;
                        aCurPos.y -= ay;
                    }
                    outPosCollisions.Add(aCurPos);
                    return(false);
                }

                if (!IsShotFree(pos, isThrow, map, blockInfo))
                {
                    if (!isThrow)
                    {
                        outPosCollisions.Add(aCurPos);
                        return(true);
                    }
                    else
                    {
                        aCurPos.x -= ax;
                        aCurPos.y -= ay;
                        outPosCollisions.Add(aCurPos);
                        return(true);
                    }
                }
                if (map.IsUnitPos(pos))
                {
                    outPosCollisions.Add(aCurPos);
                }
                aCountLen++;
                if (aCountLen >= length)
                {
                    outPosCollisions.Add(aCurPos);
                    return(false);
                }
            }
        }
Ejemplo n.º 22
0
 public GameActionDamagePos(int damage, Vector2w pos)
 {
     actionType  = EGameAction.damagePos;
     this.damage = damage;
     this.pos    = pos;
 }
Ejemplo n.º 23
0
 public GameActionShotUnit(uint unitUid, Vector2w pos)
 {
     actionType = EGameAction.shotUnit;
     unitUID    = unitUid;
     this.pos   = pos;
 }
Ejemplo n.º 24
0
 public GameActionMoveUnit(uint unitUid, Vector2w pos)
 {
     actionType = EGameAction.moveUnit;
     unitUID    = unitUid;
     this.pos   = new Vector2w(pos);
 }
Ejemplo n.º 25
0
 public MsgClientUnitMove(Vector2w pos)
     : base(EMsgNetClient.unitMove)
 {
     this.pos = pos;
 }
Ejemplo n.º 26
0
 public MsgClientUnitShot(Vector2w pos)
     : base(EMsgNetClient.unitShot)
 {
     this.pos = pos;
 }
Ejemplo n.º 27
0
        public bool Find(Vector2w startPos, Vector2w endPos, Map map, BlockInfo blockInfo, List <Vector2w> outRoad)
        {
            for (int x = 0; x < size.x; x++)
            {
                for (int y = 0; y < size.y; y++)
                {
                    findMap[x, y] = 1001;
                }
            }

            findMap[startPos.x, startPos.y] = 1000;
            findMap[endPos.x, endPos.y]     = 0;

            int index = 0;

            bool res  = false;
            bool exit = false;

            do
            {
                res = false;
                for (int x = 0; x < size.x; x++)
                {
                    for (int y = 0; y < size.y; y++)
                    {
                        if (findMap[x, y] == index)
                        {
                            for (int i = 0; i < 4; i++)
                            {
                                Vector2w p = new Vector2w(x + offset[i].x, y + offset[i].y);
                                if (map.IsMap(p))
                                {
                                    if (findMap[p.x, p.y] == 1000)
                                    {
                                        exit = true;
                                        break;
                                    }
                                    if (findMap[x, y] == 1001 && map.IsMove(p, blockInfo))
                                    {
                                        findMap[p.x, p.y] = index + 1;
                                        res = true;
                                    }
                                }
                            }
                        }
                        if (exit)
                        {
                            break;
                        }
                    }
                    if (exit)
                    {
                        break;
                    }
                }
                if (exit)
                {
                    break;
                }
                index++;
            } while (res);

            outRoad.Add(startPos);

            int      memIndex = 1000;
            Vector2w pos      = new Vector2w(startPos);

            do
            {
                int memDir = -1;
                for (int i = 0; i < 4; i++)
                {
                    Vector2w p = pos + offset[i];
                    if (map.IsMap(p))
                    {
                        if (findMap[p.x, p.y] < memIndex)
                        {
                            memIndex = findMap[p.x, p.y];
                            memDir   = i;
                        }
                    }
                }
                if (memDir == -1)
                {
                    return(false);
                }
                pos = pos + offset[memDir];
                outRoad.Add(new Vector2w(pos));
                if (outRoad.Count > 500)
                {
                    return(true);
                }
            } while (memIndex != 0);

            return(true);
        }
Ejemplo n.º 28
0
 public FindRoad(Vector2w size)
 {
     this.size = size;
     findMap   = new int[size.x, size.y];
 }
Ejemplo n.º 29
0
 public bool Equals(Vector2w other)
 {
     return(other.x == x && other.y == y);
 }
Ejemplo n.º 30
0
        private static bool TraceRayVisible(Vector2f inStart, Vector2f inEnd, int inLength, Map map, BlockInfo blockInfo)
        {
            Vector2f aDir = inEnd - inStart;
            float    ax;
            float    ay;

            if (Math.Abs(aDir.x) > Math.Abs(aDir.y))
            {
                if (Math.Abs(aDir.y) > 0.001f)
                {
                    ay = aDir.y / Math.Abs(aDir.x);
                }
                else
                {
                    ay = 0;
                }
                ax = 1.0f;
                if (aDir.x < 0)
                {
                    ax = -1.0f;
                }
            }
            else
            {
                if (Math.Abs(aDir.x - 0.0f) > 0.001f)
                {
                    ax = aDir.x / Math.Abs(aDir.y);
                }
                else
                {
                    ax = 0;
                }
                ay = 1.0f;
                if (aDir.y < 0)
                {
                    ay = -1.0f;
                }
            }
            Vector2f aCurPos   = new Vector2f(inStart.x, inStart.y);
            int      aCountLen = 0;

            while (true)
            {
                aCurPos.x += ax;
                aCurPos.y += ay;

                Vector2w aPos = new Vector2w((int)Math.Floor(aCurPos.x), (int)Math.Floor(aCurPos.y));

                if (!map.IsMap(aPos))
                {
                    return(false);
                }
                aCountLen++;
                if (aCountLen >= inLength)
                {
                    return(true);
                }
                if (!map.IsVisibleBlock(aPos, blockInfo))
                {
                    return(false);
                }
            }
        }