/// <summary>
/// Moves main camera
/// </summary>
/// <param name="delta"></param>
/// <returns></returns>
public bool Move_Camera(Map.Direction direction)
{
if (Game.Instance.State != Game.GameState.RUNNING)
{
return(false);
}
bool success = true;
switch (direction)
{
case Map.Direction.North:
Camera.main.transform.Translate(new Vector3(0.0f, speed, 0.0f));
break;
case Map.Direction.East:
Camera.main.transform.Translate(new Vector3(speed, 0.0f, 0.0f));
break;
case Map.Direction.South:
Camera.main.transform.Translate(new Vector3(0.0f, -speed, 0.0f));
break;
case Map.Direction.West:
Camera.main.transform.Translate(new Vector3(-speed, 0.0f, 0.0f));
break;
default:
success = false;
break;
}
return(success);
}
public Vector2 edgeForDirection(Map.Direction direction)
{
float x = -1.0f, y = -1.0f;
switch (direction)
{
case Map.Direction.North:
x = northX;
y = northY;
break;
case Map.Direction.South:
x = southX;
y = southY;
break;
case Map.Direction.East:
x = eastX;
y = eastY;
break;
case Map.Direction.West:
x = westX;
y = westY;
break;
}
return(new Vector2(x, y));
}
public void Move(Map.Direction direction)
{
switch (direction)
{
case Map.Direction.Up:
map.UpdateUnitPosition(this.gameObject, this.yPosition + 1, this.xPosition);
this.yPosition += 1;
break;
case Map.Direction.Down:
map.UpdateUnitPosition(this.gameObject, this.yPosition - 1, this.xPosition);
this.yPosition -= 1;
break;
case Map.Direction.Left:
map.UpdateUnitPosition(this.gameObject, this.yPosition, this.xPosition + 1);
this.xPosition -= 1;
break;
case Map.Direction.Right:
map.UpdateUnitPosition(this.gameObject, this.yPosition, this.xPosition + 1);
this.xPosition -= 1;
break;
default:
break;
}
}
public bool Walkable(Tile fromTile, Map.Direction directionOfTravel)
{
if (validDirections == ValidDirection.None || fromTile.validDirections == ValidDirection.None)
{
return(false);
}
ValidDirection toDirectionMask = ValidDirection.None;
ValidDirection fromDirectionMask = ValidDirection.None;
switch (directionOfTravel)
{
case Map.Direction.North:
toDirectionMask = ValidDirection.South;
fromDirectionMask = ValidDirection.North;
break;
case Map.Direction.South:
toDirectionMask = ValidDirection.North;
fromDirectionMask = ValidDirection.South;
break;
case Map.Direction.East:
toDirectionMask = ValidDirection.West;
fromDirectionMask = ValidDirection.East;
break;
case Map.Direction.West:
toDirectionMask = ValidDirection.East;
fromDirectionMask = ValidDirection.West;
break;
}
return(((validDirections & toDirectionMask) != ValidDirection.None) && ((fromTile.validDirections & fromDirectionMask) != ValidDirection.None));
}
public override void Update(GameTime gameTime)
{
if (pacman.Killed)
{
return;
}
KeyboardState keyboardState = Keyboard.GetState();
mainDirection = lastDirection;
Keys[] keys = lastKeyboardState.GetPressedKeys();
if (keys.Length > 0)
{
Keys key = keys[0];
if (lastKeyboardState.IsKeyDown(key))
{
if (keyboardState.IsKeyUp(key))
{
switch (key)
{
case Keys.Right:
mainDirection = Map.Direction.Right;
break;
case Keys.Down:
mainDirection = Map.Direction.Down;
break;
case Keys.Left:
mainDirection = Map.Direction.Left;
break;
case Keys.Up:
mainDirection = Map.Direction.Up;
break;
}
secondDirection = mainDirection;
}
}
}
if (mainDirection.Equals(secondDirection))
{
UpdatePacmanPosition(mainDirection);
}
else
{
UpdatePacmanPosition(mainDirection);
UpdatePacmanPosition(secondDirection);
}
lastKeyboardState = keyboardState;
base.Update(gameTime);
}
public static int[] InDirectionFrom(int[] coord, Map.Direction direction)
{
int[] newCoord = new int[] { coord[0], coord[1] };
switch (direction)
{
case Map.Direction.N:
newCoord[1]--;
break;
case Map.Direction.NW:
if (coord[0] % 2 == 0)
{
newCoord[1]--;
}
newCoord[0]--;
break;
case Map.Direction.W:
newCoord[0] -= 2;
break;
case Map.Direction.SW:
if (coord[0] % 2 == 1)
{
newCoord[1]++;
}
newCoord[0]--;
break;
case Map.Direction.S:
newCoord[1]++;
break;
case Map.Direction.SE:
if (coord[0] % 2 == 1)
{
newCoord[1]++;
}
newCoord[0]++;
break;
case Map.Direction.E:
newCoord[0] += 2;
break;
case Map.Direction.NE:
if (coord[0] % 2 == 0)
{
newCoord[1]--;
}
newCoord[0]++;
break;
}
return(newCoord);
}
/// <summary>
/// Update the direction of the cahracter
/// </summary>
/// <param name="pDirection">The new direction</param>
public void SetDirection(Map.Direction pDirection)
{
// Make sure it's not the same direction as it's already facing
if (mDirection != pDirection)
{
mDirection = pDirection;
// Update the animation
UpdateAnimation(mIsIdle);
}
}
public Tortle(Point startPosition, Map.Direction facing)
{
_Position = startPosition;
Facing = facing;
DirectionInOrder = new[] {
Map.Direction.North,
Map.Direction.East,
Map.Direction.South,
Map.Direction.West
};
HealthPoint = 1;
}
internal List <Result> MoveDirection(Battle b, Map.Direction direction)
{
var results = new List <Result>();
if (direction == Map.Direction.Up) //only swimming
{
var blockIn = b.map.BlockAt(this.Position);
var blockAbove = b.map.BlockAt(this.Position + new Vector3Int(0, 0, 1));
if (blockIn.Flugen && blockAbove.Flugen)
{
MoveTo(b, this.Position + new Vector3Int(0, 0, 1), 1);
return(results);
}
}
else
{
var blockIn = b.map.BlockAt(this.Position);
var blockOn = b.map.StandingOn(this);
var destinationBlock = b.map.BlockAt(this.Position + Map.VectorFromDirection(direction));
if (destinationBlock.Solid)
{
//check for climbing
var blockAbove = b.map.BlockAt(this.Position + Map.VectorFromDirection(direction) +
new Vector3Int(0, 0, 1));
if (blockAbove.Solid)
{
results.Add(new Result(Result.ResultType.InvalidAction, "blocked", "cannot move there", null));
}
else
{
MoveTo(b, this.Position + Map.VectorFromDirection(direction) +
new Vector3Int(0, 0, 1), blockOn.MoveCost + 1);
return(results);
}
}
MoveTo(b, this.Position + Map.VectorFromDirection(direction), blockOn.MoveCost);
//check for falling
var newBlockOn = b.map.BlockAt(this.Position + new Vector3Int(0, 0, -1));
var newBlockIn = b.map.BlockAt(this.Position);
if (!newBlockOn.Solid && !newBlockIn.Flugen)
{
results.AddRange(Fall(b, 0));
}
return(results);
}
throw new NotImplementedException();
}
private Vector2 SetPosition(Map.Direction direction, int velocity)
{
Vector2 position = Vector2.Zero;
switch (direction)
{
case Map.Direction.Right: position.X += velocity; break;
case Map.Direction.Down: position.Y += velocity; break;
case Map.Direction.Left: position.X -= velocity; break;
case Map.Direction.Up: position.Y -= velocity; break;
}
return(position);
}
public List <Result> MakeMove(Guid unitID, Map.Direction direction)
{
var unit = units.First(u => u.ID == unitID);
if (unit.SideID != currentSide.ID)
{
return(null); //TODO: better message
}
if (unit.IsDead)
{
var results = new List <Result>();
results.Add(new Result(Result.ResultType.InvalidAction, "dead", unit.Name + " is dead", null));
return(results);
}
return(unit.MoveDirection(this, direction));
}
public void CreateFromJSON(JSONNode node)
{
name = node["name"];
description = node["description"];
id = node["id"];
position = NPC.MapPointFromJSON(node["position"]);
initialDirection = NPC.DirectionFromString(node["direction"]);
var triggersJSON = node["triggers"];
if (triggersJSON != null)
{
for (int i = 0; i < triggersJSON.Count; i++)
{
ActionTrigger trigger = new ActionTrigger(triggersJSON[i]);
triggers[trigger.type] = trigger;
}
}
}
private Map.Direction GetDirection(Vector2 difference)
{
Map.Direction direction = Map.Direction.Right;
switch (difference.X)
{
case -1: direction = Map.Direction.Left; break;
case 1: direction = Map.Direction.Right; break;
}
switch (difference.Y)
{
case -1: direction = Map.Direction.Up; break;
case 1: direction = Map.Direction.Down; break;
}
return(direction);
}
//! Convert Map.Direction to LookDirection.
public static LookDirection Convert(Map.Direction Dir)
{
LookDirection direction = LookDirection.EAST;
switch (Dir)
{
case ja2.Map.Direction.EAST:
direction = LookDirection.EAST;
break;
case ja2.Map.Direction.NORTH:
direction = LookDirection.NORTH;
break;
case ja2.Map.Direction.NORTH_EAST:
direction = LookDirection.NORTHEAST;
break;
case ja2.Map.Direction.NORTH_WEST:
direction = LookDirection.NORTHWEST;
break;
case ja2.Map.Direction.SOUTH:
direction = LookDirection.SOUTH;
break;
case ja2.Map.Direction.SOUTH_EAST:
direction = LookDirection.SOUTHEAST;
break;
case ja2.Map.Direction.SOUTH_WEST:
direction = LookDirection.SOUTHWEST;
break;
case ja2.Map.Direction.WEST:
direction = LookDirection.WEST;
break;
}
return(direction);
}
private void UpdatePacmanPosition(Map.Direction direction)
{
position = Vector2.Zero;
switch (direction)
{
case Map.Direction.Right: position.X += pacman.Velocity; rotation = 0f; break;
case Map.Direction.Down: position.Y += pacman.Velocity; rotation = MathHelper.ToRadians(90f); break;
case Map.Direction.Left: position.X -= pacman.Velocity; rotation = MathHelper.ToRadians(180f); break;
case Map.Direction.Up: position.Y -= pacman.Velocity; rotation = MathHelper.ToRadians(270f); break;
}
pacman.UpdatePosition(position);
if (pacman.IsIntersectsWithWalls())
{
pacman.UpdatePosition(-position);
}
else
{
if (pacman.IsIntersectsWithFood())
{
pacman.Score += 10;
BallEated();
if (pacman.Map.FoodBlocks.Count == 0)
{
}
}
lastDirection = direction;
pacman.Rotation = rotation;
}
}
//implementing and overriding methods
public override void Move(Map.Direction d)
{
switch (d)
{
case Map.Direction.North:
ypos--;
break;
case Map.Direction.South:
xpos++;
break;
case Map.Direction.East:
ypos++;
break;
case Map.Direction.West:
xpos--;
break;
default:
break;
}
}
IEnumerator WalkAlongPath()
{
// currentPath could be replaced underneath us if the user
// changes destination mid-walk.
StopCoroutine("WalkToStep");
while (currentPath.Count > 0)
{
MovementStep step = currentPath[0];
currentPath.RemoveAt(0);
animator.SetBool("Walking", true);
Map.Direction newDirection = Map.CalculateDirectionTravelling(currentPosition, step.MapPoint);
animator.SetInteger("Direction", (int)newDirection);
MapPoint fromPoint = currentPosition;
currentPosition = step.MapPoint;
WalkingStep ws = new WalkingStep {
fromPoint = fromPoint,
step = step,
direction = newDirection
};
yield return(StartCoroutine("WalkToStep", ws));
}
animator.SetBool("Walking", false);
walking = false;
if (currentCompletionHandler != null)
{
currentCompletionHandler(true);
}
}
// assigns the x, y, and direction values
public Intersection(int v1, int v2, Map.Direction dir)
{
x = v1;
y = v2;
direction = dir;
}
public Outcome MoveCharacter(Character guy, Map.Direction dir)
{
var outcome = new Outcome();
outcome.SideID = guy.SideID;
if (!IsActiveAndControllable(guy))
{
outcome.Message.AppendLine(guy.Name + " cannot act at this time, is not activated");
return(outcome);
}
if (guy.Incapacitated)
{
outcome.Message.AppendLine(guy.Name + " is incapacitated and cannot move");
return(outcome);
}
var destination = guy.Pos + Map.DirectionToPosition[dir];
if (!IsOpen(destination))
{
outcome.Message.AppendLine(guy.Name + " tried to move to " + destination +
" but there is something there already");
return(outcome); //blocked TODO: error
}
//has enough movement
bool adjacentToOpponent = IsAdjacentToOpponent(guy.Pos, guy.SideID);
if (adjacentToOpponent && guy.Stamina.Value < 1)
{
outcome.Message.AppendLine("Cannot move through threatened area without stamina");
return(outcome);
}
int moveCost = map.GetTile(guy.Pos).MoveCostFor(guy);
if (adjacentToOpponent)
{
moveCost++; //effective +1
}
if (moveCost > (guy.Move.Value + guy.Stamina.Value))
{
outcome.Message.AppendLine(guy.Name + " only has " + guy.Move.Value + " movement" +
" remaining, but needs " + moveCost + " to move");
return(outcome); //TODO: error
}
moveCost = map.GetTile(guy.Pos).MoveCostFor(guy);
int staminaCost = adjacentToOpponent ? 1 : 0;
guy.PayMovement(moveCost, staminaCost);
var oldPos = guy.Pos;
guy.Pos = destination;
if (OnCharacterMoved != null)
{
OnCharacterMoved(this, new CharacterMovedEventArgs(guy.Name, guy.ID, oldPos, destination));
}
var steppedOn = map.GetTile(destination);
steppedOn.CharacterEntered(this, guy); //TODO: better?
outcome.Message.AppendLine(guy.Name + " moved to " + destination);
outcome.UserID = guy.ID;
outcome.ActionTaken = "Move";
outcome.PosTarget = destination;
return(outcome);
}
private void UpdateEnemiesPositions()
{
foreach (Enemy enemy in enemies)
{
Stack <Vector2> roadPoints = enemy.RoadPoints;
Vector2 mapPosition = enemy.MapPosition;
Map.Direction direction = enemy.Direction;
if (mapPosition.Equals(roadPoints.Peek()))
{
Vector2 point = roadPoints.Pop();
if (roadPoints.Count == 0)
{
enemy.DestinationPoint = map.FreeRandomPoint;
roadPoints = roadSeeker.GetRoadPoints(enemy.MapPosition, enemy.DestinationPoint);
point = roadPoints.Pop();
enemy.RoadPoints = roadPoints;
if (enemy.Ghost)
{
EnemyRestored();
enemy.Velocity = enemy.OriginalVelocity;
enemy.Ghost = false;
enemy.Protected = isProtected;
}
}
Vector2 prePoint = roadPoints.Pop();
Vector2 difference = prePoint - point;
enemy.Direction = GetDirection(difference);
enemy.UpdateTexture();
roadPoints.Push(prePoint);
}
if (enemy.IsIntersectsWithWalls())
{
Vector2 basePosition = enemy.Position;
basePosition.X = mapPosition.X * enemy.Rectangle.Width;
basePosition.Y = mapPosition.Y * enemy.Rectangle.Height;
enemy.Position = basePosition;
}
Vector2 position = SetPosition(direction, enemy.Velocity);
enemy.UpdatePosition(position);
if (enemy.Rectangle.Intersects(map.Pacman.Rectangle))
{
if (!enemy.Ghost)
{
if (!isProtected)
{
GhostEated();
map.Pacman.Score += 200;
enemy.RoadPoints = roadSeeker.GetRoadPoints(enemy.MapPosition, enemy.OriginalMapPosition);
enemy.Velocity = 6;
enemy.Ghost = true;
enemy.Protected = true;
enemy.Position = new Vector2(
enemy.MapPosition.X * enemy.Rectangle.Width,
enemy.MapPosition.Y * enemy.Rectangle.Height);
}
else
{
map.Pacman.Killed = true;
PacmanDie();
foreach (Enemy en in enemies)
{
en.RoadPoints = roadSeeker.GetRoadPoints(en.OriginalMapPosition, map.FreeRandomPoint);
}
}
}
}
}
}
public static void WallSelect(int x, int y, Map.Direction direction)
{
switch (direction)
{
case Map.Direction.Omni:
WallSelect(x, y, Map.Direction.N);
WallSelect(x, y, Map.Direction.S);
break;
case Map.Direction.N:
MapDisplay.CurrentMap.TileAt(x, y).SelectWalls(!Deselect);
break;
case Map.Direction.NW:
MapDisplay.CurrentMap.TileAt(x, y).SelectWall(!Deselect, true);
break;
case Map.Direction.W:
WallSelect(x, y, Map.Direction.NW);
WallSelect(x, y, Map.Direction.SW);
break;
case Map.Direction.SW:
if (x % 2 == 0)
{
MapDisplay.CurrentMap.TileAt(x + 1, y).SelectWall(!Deselect, false);
}
else
{
MapDisplay.CurrentMap.TileAt(x + 1, y + 1).SelectWall(!Deselect, false);
}
break;
case Map.Direction.S:
if (x % 2 == 0)
{
MapDisplay.CurrentMap.TileAt(x + 1, y).SelectWall(!Deselect, false);
MapDisplay.CurrentMap.TileAt(x - 1, y).SelectWall(!Deselect, true);
}
else
{
MapDisplay.CurrentMap.TileAt(x + 1, y + 1).SelectWall(!Deselect, false);
MapDisplay.CurrentMap.TileAt(x - 1, y + 1).SelectWall(!Deselect, true);
}
break;
case Map.Direction.SE:
if (x % 2 == 0)
{
MapDisplay.CurrentMap.TileAt(x - 1, y).SelectWall(!Deselect, true);
}
else
{
MapDisplay.CurrentMap.TileAt(x - 1, y + 1).SelectWall(!Deselect, true);
}
break;
case Map.Direction.E:
WallSelect(x, y, Map.Direction.NE);
WallSelect(x, y, Map.Direction.SE);
break;
case Map.Direction.NE:
MapDisplay.CurrentMap.TileAt(x, y).SelectWall(!Deselect, false);
break;
}
}
public static void OutlineWallSelect(Map.Direction direction)
{
foreach (int[] coord in selectedTiles)
{
if (direction == Map.Direction.Omni || direction == Map.Direction.N || direction == Map.Direction.W || direction == Map.Direction.NW)
{
if (!selectedTiles.Exists(t => t.SequenceEqual(Tile.InDirectionFrom(coord, Map.Direction.NW))))
{
MapDisplay.CurrentMap.TileAt(coord).SelectWall(!Deselect, false);
if (!selectedTiles.Exists(t => t.SequenceEqual(Tile.InDirectionFrom(coord, Map.Direction.SW))))
{
MapDisplay.CurrentMap.TileAt(Tile.InDirectionFrom(coord, Map.Direction.SW)).SelectWall(!Deselect, true);
}
if (selectedTiles.Exists(t => t.SequenceEqual(Tile.InDirectionFrom(coord, Map.Direction.SE))))
{
if (!selectedTiles.Exists(t => t.SequenceEqual(Tile.InDirectionFrom(coord, Map.Direction.NE))))
{
MapDisplay.CurrentMap.TileAt(coord).SelectWall(!Deselect, true);
}
}
}
}
if (direction == Map.Direction.Omni || direction == Map.Direction.N || direction == Map.Direction.E || direction == Map.Direction.NE)
{
if (!selectedTiles.Exists(t => t.SequenceEqual(Tile.InDirectionFrom(coord, Map.Direction.NE))))
{
MapDisplay.CurrentMap.TileAt(coord).SelectWall(!Deselect, true);
if (!selectedTiles.Exists(t => t.SequenceEqual(Tile.InDirectionFrom(coord, Map.Direction.SE))))
{
MapDisplay.CurrentMap.TileAt(Tile.InDirectionFrom(coord, Map.Direction.SE)).SelectWall(!Deselect, false);
}
if (selectedTiles.Exists(t => t.SequenceEqual(Tile.InDirectionFrom(coord, Map.Direction.SW))))
{
if (!selectedTiles.Exists(t => t.SequenceEqual(Tile.InDirectionFrom(coord, Map.Direction.NW))))
{
MapDisplay.CurrentMap.TileAt(coord).SelectWall(!Deselect, false);
}
}
}
}
if (direction == Map.Direction.Omni || direction == Map.Direction.S || direction == Map.Direction.E || direction == Map.Direction.SE)
{
if (!selectedTiles.Exists(t => t.SequenceEqual(Tile.InDirectionFrom(coord, Map.Direction.SE))))
{
MapDisplay.CurrentMap.TileAt(Tile.InDirectionFrom(coord, Map.Direction.SE)).SelectWall(!Deselect, false);
if (!selectedTiles.Exists(t => t.SequenceEqual(Tile.InDirectionFrom(coord, Map.Direction.NE))))
{
MapDisplay.CurrentMap.TileAt(coord).SelectWall(!Deselect, true);
}
if (selectedTiles.Exists(t => t.SequenceEqual(Tile.InDirectionFrom(coord, Map.Direction.NW))))
{
if (!selectedTiles.Exists(t => t.SequenceEqual(Tile.InDirectionFrom(coord, Map.Direction.SW))))
{
MapDisplay.CurrentMap.TileAt(Tile.InDirectionFrom(coord, Map.Direction.SW)).SelectWall(!Deselect, true);
}
}
}
}
if (direction == Map.Direction.Omni || direction == Map.Direction.S || direction == Map.Direction.W || direction == Map.Direction.SW)
{
if (!selectedTiles.Exists(t => t.SequenceEqual(Tile.InDirectionFrom(coord, Map.Direction.SW))))
{
MapDisplay.CurrentMap.TileAt(Tile.InDirectionFrom(coord, Map.Direction.SW)).SelectWall(!Deselect, true);
if (!selectedTiles.Exists(t => t.SequenceEqual(Tile.InDirectionFrom(coord, Map.Direction.NW))))
{
MapDisplay.CurrentMap.TileAt(coord).SelectWall(!Deselect, false);
}
if (selectedTiles.Exists(t => t.SequenceEqual(Tile.InDirectionFrom(coord, Map.Direction.NE))))
{
if (!selectedTiles.Exists(t => t.SequenceEqual(Tile.InDirectionFrom(coord, Map.Direction.SE))))
{
MapDisplay.CurrentMap.TileAt(Tile.InDirectionFrom(coord, Map.Direction.SE)).SelectWall(!Deselect, false);
}
}
}
}
}
}
public static void WallSelect(int[] coord, Map.Direction direction)
{
WallSelect(coord[0], coord[1], direction);
}
//method to move it around public abstract void Move(Map.Direction d);
public bool BackAwayFromCell(Cell cellToBackAwayFrom)
{
ArrayList directions = new ArrayList();
Map.Direction targetDirection = Map.GetDirection(Owner.CurrentCell, cellToBackAwayFrom);
switch (targetDirection)
{
case Map.Direction.East:
directions.Add(Map.Direction.West.ToString());
directions.Add(Map.Direction.Northwest.ToString());
directions.Add(Map.Direction.Southwest.ToString());
break;
case Map.Direction.North:
directions.Add(Map.Direction.South.ToString());
directions.Add(Map.Direction.Southwest.ToString());
directions.Add(Map.Direction.Southeast.ToString());
break;
case Map.Direction.Northeast:
directions.Add(Map.Direction.South.ToString());
directions.Add(Map.Direction.Southwest.ToString());
directions.Add(Map.Direction.West.ToString());
break;
case Map.Direction.Northwest:
directions.Add(Map.Direction.South.ToString());
directions.Add(Map.Direction.Southeast.ToString());
directions.Add(Map.Direction.East.ToString());
break;
case Map.Direction.South:
directions.Add(Map.Direction.North.ToString());
directions.Add(Map.Direction.Northwest.ToString());
directions.Add(Map.Direction.Northeast.ToString());
break;
case Map.Direction.Southeast:
directions.Add(Map.Direction.North.ToString());
directions.Add(Map.Direction.Northwest.ToString());
directions.Add(Map.Direction.West.ToString());
break;
case Map.Direction.Southwest:
directions.Add(Map.Direction.North.ToString());
directions.Add(Map.Direction.Northeast.ToString());
directions.Add(Map.Direction.East.ToString());
break;
case Map.Direction.None:
List <Cell> cList = Map.GetAdjacentCells(Owner.CurrentCell, Owner);
if (cList != null)
{
int rand = Rules.dice.Next(cList.Count);
Cell nCell = (Cell)cList[rand];
Owner.Brain.AIGotoXYZ(nCell.X, nCell.Y, nCell.Z);
return(true);
}
else
{
return(false);
}
}
for (int a = 0; a < directions.Count; a++)
{
Cell cell = Map.GetCellRelevantToCell(Owner.CurrentCell, directions[a].ToString().ToLower(), true);
if (Owner.GetCellCost(cell) <= 2)
{
//Owner.AIGotoXYZ(cell.X, cell.Y, cell.Z);
return(true);
}
}
return(false);
}
