Example #1
0
 public Band(Map myMap, Coords startPos, UInt16 ID, Team team, Brain brain, List <Creature> members, SpriteBatchCreature myBitmap)
     : base(myMap, startPos, ID, team, brain)
 {
     _members  = members;
     _myBitmap = myBitmap;
 }
        private List<Direction> _PathfinderAStar(Coords start, Coords endTopLeft, Coords endBottomRight, BitArray[] _passabilityMap, hFunction h)
        {
            // NOTE: Should later implemented a collision predictor mechanic to work in tandem
            // with the path-finder to provide better agent behavior.
            // NOTE: Consider returning the number of tiles scanned in case no path is found.
            // This will alert a boxed-in creature of its predicament.
            // NOTE: Introduce a flag for a straight-line initial check(for outdoors environmens and
            // for when the goal is near).

            Int32 rangeX = _passabilityMap.Length;
            Int32 rangeY = _passabilityMap[0].Count;

            NodeAStar?[,] nodeArray = new NodeAStar?[rangeX, rangeY];

            NodeAStar startNode = new NodeAStar();
            startNode.costSoFar = 0;
            startNode.estimatedTotalCost = h(start);

            nodeArray[start.X, start.Y] = startNode;

            List<Coords> ListOpen = new List<Coords>();
            ListOpen.Add(start);
            while (ListOpen.Count > 0)
            {
                // I have to use this bool the way I've implemented the algo. Consider rewriting.
                bool resortList = false;

                Coords currentCoords = ListOpen.First();
                // Check to see if goal is reached.
                //if (currentCoords.Equals(endTopLeft))
                if (StaticMathFunctions.CoordinateIsInBox(currentCoords, endTopLeft, endBottomRight))
                {
                    break;
                }

                NodeAStar currentNode = nodeArray[currentCoords.X, currentCoords.Y].Value;
                for (byte i = 0; i <= 5; ++i)
                {
                    Direction currentDir = (Direction)(i);
                    //Coords dirCoords = StaticMathFunctions.DirectionToCoords(currentDir);
                    Coords potential = StaticMathFunctions.CoordsNeighboringInDirection(currentCoords, currentDir);
                    // check if move in dir is allowed
                    if (potential.X >= 0 && potential.X < rangeX && potential.Y >= 0 && potential.Y < rangeY // bounds check
                        && _passabilityMap[potential.X][potential.Y]) // passability check
                    {
                        // Using the simplest cost function possible. Can be easily updated
                        // once tile walkability coefficients are added.
                        //Coords newNodePosition = new Coords(CoordsType.General, currentCoords.X + dirCoords.X, currentCoords.Y + dirCoords.Y);
                        Coords newNodePosition = potential;
                        float accruedCost = currentNode.costSoFar + 1;

                        // Straight line correction
                        if (currentDir == nodeArray[currentCoords.X, currentCoords.Y].Value.connection)
                        {
                            accruedCost -= Constants.PathfinderStraightPathCorrection;
                        }

                        // Check to see if the node under examination is in the closed list.
                        //NodeAStar? oldNode = nodeArray[newNodePosition.X, newNodePosition.Y];
                        if (nodeArray[newNodePosition.X, newNodePosition.Y] != null)
                        {
                            // If node is in closed list, see if it needs updating.
                            if (nodeArray[newNodePosition.X, newNodePosition.Y].Value.costSoFar > accruedCost)
                            {
                                float expectedAdditionalCost =
                                    nodeArray[newNodePosition.X, newNodePosition.Y].Value.estimatedTotalCost -
                                    nodeArray[newNodePosition.X, newNodePosition.Y].Value.costSoFar;
                                NodeAStar nodeToAdd =
                                    new NodeAStar(currentDir, accruedCost, accruedCost + expectedAdditionalCost);
                                nodeArray[newNodePosition.X, newNodePosition.Y] = nodeToAdd;
                                ListOpen.Add(newNodePosition);
                                resortList = true;
                            }
                        }
                        // Node is in open list. Process it.
                        else
                        {
                            float expectedAdditionalCost = h(newNodePosition);
                            NodeAStar nodeToAdd =
                                new NodeAStar(currentDir, accruedCost, accruedCost + expectedAdditionalCost);
                            nodeArray[newNodePosition.X, newNodePosition.Y] = nodeToAdd;
                            ListOpen.Add(newNodePosition);
                            resortList = true;
                        }
                    }
                }

                ListOpen.RemoveAt(0);
                if (resortList)
                {
                    ListOpen.Sort(
                        delegate(Coords c1, Coords c2)
                        {
                            float difference = nodeArray[c1.X, c1.Y].Value.estimatedTotalCost -
                                nodeArray[c2.X, c2.Y].Value.estimatedTotalCost;

                            Int32 returnValue = 0;
                            if (difference > 0)
                            {
                                returnValue = 1;
                            }
                            else if (difference < 0)
                            {
                                returnValue = -1;
                            }
                            return returnValue;
                        }
                    );
                }
            }

            List<Direction> ListRoute = new List<Direction>();

            // Return empty route if the open list is empty, i.e. there is no path to the target
            // Ideally, the game logic should be fixed so that the search isn't even attempted
            // if there is no path between the two points.
            if (ListOpen.Count == 0)
            {
                return ListRoute;
            }

            Coords trackbackCoords = endTopLeft;
            while (trackbackCoords != start)
            {
                Direction newDirection = nodeArray[trackbackCoords.X, trackbackCoords.Y].Value.connection;
                ListRoute.Add(newDirection);
                trackbackCoords = StaticMathFunctions.CoordsNeighboringInDirection(new Coords(CoordsType.Tile, trackbackCoords),
                    StaticMathFunctions.OppositeDirection(newDirection));
            }

            // Might be faster without reversing
            //ListRoute.Reverse();

            // We skip the reversal, so pick directions from the END of the list.
            return ListRoute;
        }
Example #3
0
 public virtual void PositionSet(Coords newValue)
 {
     _positionTile = newValue;
 }
 /// <summary>
 /// Tile-level (coarse) A* pathfinding.
 /// </summary>
 /// <param name="start"> Start Coords </param>
 /// <param name="end"> Target tile Coords </param>
 /// <param name="h"> Heuristic function </param>
 /// <returns> Route to goal, as a list of Directions </returns>
 public List<Direction> PathfinderAStarCoarse(Coords start, Coords end, HeuristicFunction h)
 {
     return this.PathfinderAStarCoarse(start, end, end, h);
 }
        private void CalculateMoveRange(Coords origin, UInt16[] moveCosts, UInt16 availableAP)
        {
            _currentOrigin = origin;

            for (int i = 0; i < _currentMap.BoundX; ++i)
            {
                for (int j = 0; j < _currentMap.BoundY; ++j)
                {
                    _APCount[i, j] = -1;
                    _directionMap[i, j] = null;
                }
            }

            _APCount[origin.X, origin.Y] = availableAP;

            // WARNING: Code repetition with influence maps / A*

            Queue<Coords> currentQueue = new Queue<Coords>();
            Queue<Coords> nextQueue = new Queue<Coords>();

            currentQueue.Enqueue(origin);

            UInt32 currentDistance = 0;

            // main loop
            // Stopping conditions: the two queues are exhausted, OR InfluenceMapMaxDistance is reached
            while
                (
                ((currentQueue.Count > 0) & (nextQueue.Count > 0))
                |
                (currentDistance < Constants.InfluenceMapMaxDistance)
                )
            {
                // Checks if it's time to start the next pass
                if (currentQueue.Count == 0)
                {
                    currentQueue = nextQueue;
                    nextQueue = new Queue<Coords>();
                    currentDistance++;
                    continue;
                }

                Coords currentCoords = currentQueue.Peek();
                //Coords delta1 = currentCoords - origin;
                Tile currentTile = _currentMap.GetTile(currentCoords);

                // Analyzes the neighbors of the current Tile for possible additions to nextQueue
                for (byte i = 0; i < 6; i++)
                {
                    Direction currentDir = (Direction)i;
                    Coords toCheck = StaticMathFunctions.CoordsNeighboringInDirection(currentCoords, currentDir);
                    if (_currentMap.CheckInBounds(toCheck))
                    {
                        Tile targetTile = _currentMap.GetTile(toCheck);
                        UInt16 cost = moveCosts[(sbyte)targetTile.MyTerrainType];

                        if (cost > 0 && _currentMap.TenancyMap[toCheck.X, toCheck.Y] == null) // ignore impassable terrain and ignore occupied tiles
                        {
                            // checks if this approach is cheaper than the best approach so far
                            Int32 currentAPleft = _APCount[toCheck.X, toCheck.Y];
                            Int32 potentialAPleft = _APCount[currentCoords.X, currentCoords.Y] - cost;
                            if (currentAPleft < potentialAPleft)
                            {
                                _APCount[toCheck.X, toCheck.Y] = (UInt16)potentialAPleft;
                                _directionMap[toCheck.X, toCheck.Y] = currentDir;
                                nextQueue.Enqueue(toCheck);
                            }
                        }
                    }
                }

                currentQueue.Dequeue();
            }


            for (int i = 0; i < _currentMap.BoundX; ++i)
            {
                for (int j = 0; j < _currentMap.BoundY; ++j)
                {
                    _rangeMap[i][j] = _APCount[i, j] >= 0;
                }
            }

            //return rangeMap;
        }
Example #6
0
 public InfluenceSourceMap(Map currentMap, Coords source, InfluenceSpreadFunction f, float minTreshold, float maxRange)
     : this(currentMap, source, f)
 {
     _lowTreshold = minTreshold;
     _maxTreshold = maxRange;
 }
 /// <summary>
 /// Tile-level (coarse) A* pathfinding.
 /// </summary>
 /// <param name="start"> Start Coords </param>
 /// <param name="endTopLeft"> Goal-box TopLeft Coords </param>
 /// <param name="endBottomRight"> Goal-box BottomRight Coords </param>
 /// <param name="h"> Heuristic function </param>
 /// <returns> Route to goal, as a list of Directions </returns>
 public List<Direction> PathfinderAStarCoarse(Coords start, Coords endTopLeft, Coords endBottomRight, HeuristicFunction h)
 {
     return this._PathfinderAStar(new Coords(CoordsType.General, start), new Coords(CoordsType.General, endTopLeft), new Coords(CoordsType.General, endBottomRight), this._passabilityMap,
         delegate(Coords c) { return h(c, StaticMathFunctions.CoordsAverage(endTopLeft, endBottomRight)); });
 }
Example #8
0
 /// <summary>
 /// Returns the visibility status of coord c for a team: -1 is unexplored, 0 unseen, a positive return
 /// indicates the number of team members observing the tile.
 /// </summary>
 public Int16 VisibilityCheck(Coords c, Team team)
 {
     return(_teamVisibilityTracker[team.UniqueID][c.X, c.Y]);
 }
Example #9
0
        /// Generates the influence map.
        /// Uses a silly recursive algorithm.
        /// Stopping conditions: Let's use two, to avoid stupid infinite loops.
        /// One is a distance threshold check.
        // Second is a min influence threshold check.

        /// <summary>
        /// Generates the influence map.
        /// Uses a silly recursive algorithm.
        /// Stopping conditions: Let's use two, to avoid stupid infinite loops.
        /// One is a distance threshold check.
        /// Second is a min influence threshold check.
        /// </summary>
        public void GenerateInfluenceMap()
        {
            // boolean array to keep note of which tiles have been processed
            //BitArray[,] takenCareOf = new BitArray[_currentMap.BoundX, _currentMap.BoundY];
            BitArray[] takenCareOf = new BitArray[_currentMap.BoundX];
            for (int i = 0; i < _currentMap.BoundX; ++i)
            {
                takenCareOf[i] = new BitArray(_currentMap.BoundY);
            }
            takenCareOf[Source.X][Source.Y] = true;

            // sets up two queues - one for the current pass, one for the next one
            // distance increments by one at each pass
            // if too slow, the process should be broken up so it does a number of passes each tick
            Queue <Coords> currentQueue = new Queue <Coords>();
            Queue <Coords> nextQueue    = new Queue <Coords>();

            currentQueue.Enqueue(_source);

            UInt32 currentDistance = 0;

            // main loop
            // Stopping conditions: the two queues are exhausted, OR InfluenceMapMaxDistance is reached
            while
            (
                ((currentQueue.Count > 0) & (nextQueue.Count > 0))
                |
                (currentDistance < Constants.InfluenceMapMaxDistance)
            )
            {
                // Checks if it's time to start the next pass
                if (currentQueue.Count == 0)
                {
                    currentQueue = nextQueue;
                    nextQueue    = new Queue <Coords>();
                    currentDistance++;
                    continue;
                }

                Coords currentCoords = currentQueue.Peek();
                Tile   currentTile   = CurrentMap.GetTile(currentCoords);

                // Analyzes the neighbors of the current Tile for possible additions to nextQueue
                for (byte i = 0; i < 6; i++)
                {
                    Direction currentDir = (Direction)i;
                    if (currentTile.AllowedMovesCheckInDirection(currentDir))
                    {
                        Coords toCheck = StaticMathFunctions.CoordsNeighboringInDirection(currentCoords, currentDir);
                        if (!takenCareOf[toCheck.X][toCheck.Y])
                        {
                            nextQueue.Enqueue(toCheck);
                            takenCareOf[toCheck.X][toCheck.Y] = true;
                        }
                    }
                }

                float newVal = _f(currentDistance);

                // Check to avert infnite / excessively deep loop
                if (newVal > _lowTreshold)
                {
                    this.SetMapValue(currentCoords, newVal);
                }

                currentQueue.Dequeue();
            }
        }
Example #10
0
        /// <summary>
        /// Checks if an agent sees the tile at coordinates 'c'.
        /// </summary>
        public bool VisibilityCheck(Coords c, Unit critter)
        {
            //Coords c = new Coords(CoordsType.Tile, critter.PositionDouble);

            return(_visibilityTrackers[c.X, c.Y].ContainsKey(critter.UniqueID));
        }
Example #11
0
        /// <summary>
        /// Returns true if the agent standing at c1 can see c2.
        /// If diagonal strictness if flagged, returns false when the ray passes through
        /// an intersection, one of the lots on which is impassable.
        /// </summary>
        public bool RayTracerVisibilityCheckTile(Coords c1, Coords c2, bool diagonalStrictness, UInt16 sightRange)
        {
            // CODE REPETITION! CONSIDER REVISING.
            // NOTES:
            // -This is not done for hexes, it's for squares
            // -I rasterize the grid by another factor of 4 so I can shift the y-odd rows one to the right. This leads to twice
            // as many checks, half unnecessary.


            // This is only for tiles.
            if (c1.Type != CoordsType.Tile || c2.Type != CoordsType.Tile)
            {
                throw new Exception("Non-Tile coords passed for RayTracerVisibilityCheckTile.");
                //return false;
            }

            Int32 x0 = c1.X * 2 + c1.Y % 2;
            Int32 y0 = c1.Y * 2;
            Int32 x1 = c2.X * 2 + c2.Y % 2;
            Int32 y1 = c2.Y * 2;

            if (x0 < x1)
            {
                ++x0;
            }
            else if (x0 > x1)
            {
                ++x1;
            }

            if (y0 < y1)
            {
                ++y0;
            }
            else
            {
                ++y1;
            }

            int dx    = Math.Abs(x1 - x0);
            int dy    = Math.Abs(y1 - y0);
            int x     = x0;
            int y     = y0;
            int n     = 1 + dx + dy;
            int x_inc = (x1 > x0) ? 1 : -1;
            int y_inc = (y1 > y0) ? 1 : -1;
            int error = dx - dy;

            dx *= 2;
            dy *= 2;

            //n *= 2;
            //n -= 1;
            //x *= 2;
            //y *= 2;

            float accrued = 0;

            for (; n > 0; --n)
            {
                Coords currentCoords = new Coords(CoordsType.Tile, (x - (y / 2) % 2) / 2, (y) / 2);
                if (y < 0)
                {
                    continue;
                }

                accrued += _visibilityMap[currentCoords.X, currentCoords.Y];

                // We ignore accrued visibility for now. Can add it later.
                if (((this._visibilityMap[currentCoords.X, currentCoords.Y] == 0) || accrued > sightRange)
                    &&
                    (currentCoords != c2)
                    )
                {
                    return(false);
                }

                if (!diagonalStrictness)
                {
                    if (error > 0)
                    {
                        x     += x_inc;
                        error -= dy;
                    }
                    else if (error < 0)
                    {
                        y     += y_inc;
                        error += dx;
                    }
                    else
                    {
                        x     += x_inc;
                        error -= dy;
                        y     += y_inc;
                        error += dx;
                        --n;
                    }
                }
                else
                {
                    if (error > 0)
                    {
                        x     += x_inc;
                        error -= dy;
                    }
                    else
                    {
                        y     += y_inc;
                        error += dx;
                    }
                }
            }

            return(true);
        }
Example #12
0
 public bool CheckInBounds(Coords c)
 {
     return((c.X >= 0) && (c.Y >= 0) && (c.X < this._xMax) && (c.Y < this._yMax));
 }
Example #13
0
        /*
         * /// <summary>
         * /// Performs a terrain passability check betwee two points by doing pixel validity checks at interval delta.
         * /// </summary>
         * public List<Creature> RayTracerPassabilityCheckRough(Creature client, Vector v1, Vector v2, double delta)
         * {
         *  Vector difference = v2 - v1;
         *  Vector deltaV = difference;
         *  deltaV.ScaleToLength(delta);
         *
         *  Vector currentPosition = v1;
         *
         *  for (int i = 0; i < difference.Length() / deltaV.Length(); ++i)
         *  {
         *      Coords pixel = new Coords(CoordsType.Pixel, currentPosition);
         *      List<Creature> collision = _myCollider.CreatureClippingCheck(client, pixel, false);
         *      if (collision == null || collision.Count > 0)
         *      {
         *          return collision;
         *      }
         *      currentPosition += deltaV;
         *  }
         *
         *  return new List<Creature>();
         * }
         */

        /*
         * /// <summary>
         * /// Returns the Bresenham line between p0 and p1; Borrowed the code
         * /// from some dude whose name I don't have, who in turn borrowed from Wikipedia.
         * /// </summary>
         * private List<Coords> BresenhamLine(Coords p0, Coords p1)
         * {
         *  List<Coords> returnList = new List<Coords>();
         *
         *  Boolean steep = Math.Abs(p1.Y - p0.Y) > Math.Abs(p1.X - p0.X);
         *
         *  if (steep == true)
         *  {
         *      Coords tmpPoint = new Coords(CoordsType.Tile, p0.X, p0.Y);
         *      p0 = new Coords(CoordsType.Tile, tmpPoint.Y, tmpPoint.X);
         *
         *      tmpPoint = p1;
         *      p1 = new Coords(CoordsType.Tile, tmpPoint.Y, tmpPoint.X);
         *  }
         *
         *  Int32 deltaX = Math.Abs(p1.X - p0.X);
         *  Int32 deltaY = Math.Abs(p1.Y - p0.Y);
         *  Int32 error = 0;
         *  Int32 deltaError = deltaY;
         *  Int32 yStep = 0;
         *  Int32 xStep = 0;
         *  Int32 y = p0.Y;
         *  Int32 x = p0.X;
         *
         *  if (p0.Y < p1.Y)
         *  {
         *      yStep = 1;
         *  }
         *  else
         *  {
         *      yStep = -1;
         *  }
         *
         *  if (p0.X < p1.X)
         *  {
         *      xStep = 1;
         *  }
         *  else
         *  {
         *      xStep = -1;
         *  }
         *
         *  Int32 tmpX = 0;
         *  Int32 tmpY = 0;
         *
         *  while (x != p1.X)
         *  {
         *
         *      x += xStep;
         *      error += deltaError;
         *
         *      //if the error exceeds the X delta then
         *      //move one along on the Y axis
         *      if ((2 * error) > deltaX)
         *      {
         *          y += yStep;
         *          error -= deltaX;
         *      }
         *
         *      //flip the coords if they're steep
         *      if (steep)
         *      {
         *          tmpX = y;
         *          tmpY = x;
         *      }
         *      else
         *      {
         *          tmpX = x;
         *          tmpY = y;
         *      }
         *
         *      //check the point generated is legal
         *      //and if it is add it to the list
         *      if (_myCollider.CheckInBounds(new Coords(CoordsType.Tile, tmpX, tmpY)) == true)
         *      {
         *          returnList.Add(new Coords(CoordsType.Tile, tmpX, tmpY));
         *      }
         *      else
         *      {   //a bad point has been found, so return the list thus far
         *          return returnList;
         *      }
         *
         *  }
         *
         *  return returnList;
         * }
         */

        /// <summary>
        /// Checks if the Bresenham line between p0 and p1 goes only through visible tiles
        /// !!! Code repetition, should redo.
        /// </summary>
        public bool BresenhamLineCheckVisible(Coords p0, Coords p1)
        {
            if (p0.Equals(p1))
            {
                return(true);
            }

            Boolean steep = Math.Abs(p1.Y - p0.Y) > Math.Abs(p1.X - p0.X);

            // fix this stupidity
            Coords p0original = new Coords(CoordsType.Tile, p0.X, p0.Y);
            Coords p1original = new Coords(CoordsType.Tile, p1.X, p1.Y);

            if (steep == true)
            {
                Coords tmpPoint = new Coords(CoordsType.Tile, p0.X, p0.Y);
                p0 = new Coords(CoordsType.Tile, tmpPoint.Y, tmpPoint.X);

                tmpPoint = p1;
                p1       = new Coords(CoordsType.Tile, tmpPoint.Y, tmpPoint.X);
            }

            Int32 deltaX     = Math.Abs(p1.X - p0.X);
            Int32 deltaY     = Math.Abs(p1.Y - p0.Y);
            Int32 error      = 0;
            Int32 deltaError = deltaY;
            Int32 yStep      = 0;
            Int32 xStep      = 0;
            Int32 y          = p0.Y;
            Int32 x          = p0.X;

            if (p0.Y < p1.Y)
            {
                yStep = 1;
            }
            else
            {
                yStep = -1;
            }

            if (p0.X < p1.X)
            {
                xStep = 1;
            }
            else
            {
                xStep = -1;
            }

            Int32 tmpX = 0;
            Int32 tmpY = 0;


            float visibilityTotal = 1f;

            while (x != p1.X)
            {
                x     += xStep;
                error += deltaError;

                //if the error exceeds the X delta then
                //move one along on the Y axis
                if ((2 * error) > deltaX)
                {
                    y     += yStep;
                    error -= deltaX;
                }

                //flip the coords if they're steep
                if (steep)
                {
                    tmpX = y;
                    tmpY = x;
                }
                else
                {
                    tmpX = x;
                    tmpY = y;
                }

                // check the point generated is legal
                // using passability check. creatures will leave shadows. should write a visibility
                // check later
                Coords currentCoords = new Coords(CoordsType.Tile, tmpX, tmpY);
                // for this to look good you must make sure it takes account of the eucledean distances over which the coeffcients hold
                // otherwise you get square FOVs.
                visibilityTotal *= this._visibilityMap[currentCoords.X, currentCoords.Y];

                if (
                    (visibilityTotal < Constants.VisibilityTreshold)
                    &
                    (!(currentCoords.Equals(p0original) | currentCoords.Equals(p1original)))
                    )
                {
                    return(false);
                }
            }

            return(true);
        }
Example #14
0
        public bool RayTracerVisibilityCheckPixel(Vector c1, Vector c2)
        {
            double x0 = c1.X;
            double y0 = c1.Y;
            double x1 = c2.X;
            double y1 = c2.Y;

            double dx = Math.Abs(x1 - x0);
            double dy = Math.Abs(y1 - y0);

            int x = (int)(Math.Floor(x0));
            int y = (int)(Math.Floor(y0));

            int    n = 1;
            int    x_inc, y_inc;
            double error;

            if (dx == 0)
            {
                x_inc = 0;
                error = Double.PositiveInfinity;
            }
            else if (x1 > x0)
            {
                x_inc = 1;
                n    += (int)(Math.Floor(x1)) - x;
                error = (Math.Floor(x0) + 1 - x0) * dy;
            }
            else
            {
                x_inc = -1;
                n    += x - (int)(Math.Floor(x1));
                error = (x0 - Math.Floor(x0)) * dy;
            }

            if (dy == 0)
            {
                y_inc  = 0;
                error -= Double.PositiveInfinity;
            }
            else if (y1 > y0)
            {
                y_inc  = 1;
                n     += (int)(Math.Floor(y1)) - y;
                error -= (Math.Floor(y0) + 1 - y0) * dx;
            }
            else
            {
                y_inc  = -1;
                n     += y - (int)(Math.Floor(y1));
                error -= (y0 - Math.Floor(y0)) * dx;
            }


            Coords c2Tile = new Coords(CoordsType.Tile, c2);

            for (; n > 0; --n)
            {
                Coords currentCoords = new Coords(CoordsType.Tile, x, y);

                // We ignore accrued visibility for now. Can add it later.
                if ((this._visibilityMap[currentCoords.X, currentCoords.Y] == 0) && (currentCoords != c2Tile))
                {
                    return(false);
                }

                if (error > 0)
                {
                    y     += y_inc;
                    error -= dx;
                }
                else
                {
                    x     += x_inc;
                    error += dy;
                }
            }

            return(true);
        }
Example #15
0
 public bool TileIsPassable(Coords c)
 {
     return(Constants.APMoveCostsStandard[(sbyte)GetTile(c).MyTerrainType] > 0);
 }
Example #16
0
 public void SetTile(Coords coords, Tile newValue)
 {
     _tiles[coords.X, coords.Y] = newValue;
 }