private void CreateVirtualPoints()
{
colInterval = (rightTopPoint.localPosition.x - leftTopPoint.localPosition.x) / (Defines.BoardProperty.COL_COUNT - 1);
rowInterval = (leftTopPoint.localPosition.z - leftBottomPoint.localPosition.z) / (Defines.BoardProperty.ROW_COUNT - 1);
GameObject boardPointPrefab = Resources.Load <GameObject>("Prefab/Game/BoardPoint");
for (int i = 0; i < Defines.BoardProperty.ROW_COUNT; i++)
{
for (int j = 0; j < Defines.BoardProperty.COL_COUNT; j++)
{
GameObject newPoint = GameObject.Instantiate(boardPointPrefab, Vector3.zero, Quaternion.identity);
newPoint.transform.parent = pointsParent;
newPoint.transform.localPosition = new Vector3(leftTopPoint.localPosition.x + colInterval * j, 0, leftTopPoint.localPosition.z - rowInterval * i);
newPoint.transform.localEulerAngles = Vector3.zero;
newPoint.name = "BoardPoint_[" + i.ToString() + ", " + j.ToString() + "]";
BoardPoint comp = newPoint.GetComponent <BoardPoint>();
comp.Init(j, i);
pointTransformList[j, i] = newPoint.transform;
pointCompList[j, i] = comp;
}
}
}
public SnakeTail(GameObject gameObj, BoardPoint position, DirectionEnum.Direction direction)
{
this.gameObject = gameObj;
this.movements = new ObjMovements(this.gameObject.transform, position);
this.position = position;
this.direction = direction;
}
private static Direction GetDefaultDirection(GameBoard gameBoard, BoardPoint head)
{
if (head == null)
{
return(Direction.Right);
}
if (prevDirection != Direction.Left &&
!strongBadElements.Contains(gameBoard.GetElementAtOrWall(head.ShiftRight())))
{
return(Direction.Right);
}
if (prevDirection != Direction.Down &&
!strongBadElements.Contains(gameBoard.GetElementAtOrWall(head.ShiftTop())))
{
return(Direction.Up);
}
if (prevDirection != Direction.Up &&
!strongBadElements.Contains(gameBoard.GetElementAtOrWall(head.ShiftBottom())))
{
return(Direction.Down);
}
return(Direction.Left);
}
public void SetMove(BoardPoint to, Action moveEndCallback)
{
toMovePoint = to;
moveTimer = 0f;
moveFlag = true;
this.moveEndCallback = moveEndCallback;
}
private SnakeAction RouteToAction(WeightedRoute best, BoardPoint start)
{
if (best != null)
{
var next = best.Route.Path.Skip(1).First();
Report(start, next, best);
if (next.X < start.X)
{
return(new SnakeAction(false, Direction.Left));
}
if (next.X > start.X)
{
return(new SnakeAction(false, Direction.Right));
}
if (next.Y < start.Y)
{
return(new SnakeAction(false, Direction.Up));
}
if (next.Y > start.Y)
{
return(new SnakeAction(false, Direction.Down));
}
}
return(new SnakeAction(false, Direction.Stop));
}
public static long[,] GetStaticWeights(GameBoard gameBoard)
{
int size = gameBoard.Size;
long[,] res = new long[size, size];
var isAchievable = AchievablePointsHandler.GetAchievablePoints(gameBoard);
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
if (isAchievable[i, j])
{
var point = new BoardPoint(i, j);
if (IsLockByWalls(gameBoard, point))
{
continue;
}
var element = gameBoard.GetElementAt(new BoardPoint(i, j));
if ((element == BoardElement.Apple || element == BoardElement.Gold || element == BoardElement.Stone) && !GameSettings.UpdateStaticWeigths)
{
continue;
}
res[i, j] = GetElementWeight(element);
}
}
}
return(res);
}
public static Graph Create(GameBoard gameBoard)
{
Graph graph = new Graph();
var size = gameBoard.Size;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
BoardElement element = gameBoard.Board[i, j];
if (ElementHelper.IsWall(element))
{
continue;
}
BoardPoint point = new BoardPoint(i, j);
graph.AddNode(point, element);
}
}
//for (var i = 0; i < objects.Count; ++i)
//{
// if (objects[i].IsOutOfBoard(gameBoard.Size)) continue;
// graph.AddNode(objects[i], gameBoard.Board[]);
// ++t;
//}
//AddNeighborhood(graph, gameBoard);
return(graph);
}
public Grower(GameObject obj)
{
BoardPointFactory pointFac = new BoardPointFactory();
this.position = pointFac.FromGameObjPosition(obj);
this.movs = new ObjMovements(obj.transform, this.position);
}
private IEnumerable <BoardPoint> GetNeighbors(BoardPoint point, GameBoard board)
{
{
var neighbor = point.ShiftLeft();
if (IsAcceptablePath(board, neighbor))
{
yield return(neighbor);
}
}
{
var neighbor = point.ShiftRight();
if (IsAcceptablePath(board, neighbor))
{
yield return(neighbor);
}
}
{
var neighbor = point.ShiftTop();
if (IsAcceptablePath(board, neighbor))
{
yield return(neighbor);
}
}
{
var neighbor = point.ShiftBottom();
if (IsAcceptablePath(board, neighbor))
{
yield return(neighbor);
}
}
}
private static bool IsAcceptablePath(GameBoard board, BoardPoint leftPoint)
{
var left = board.GetElementAt(leftPoint);
return(left == BoardElement.None || left == BoardElement.FuryPill ||
left == BoardElement.Apple || left == BoardElement.Gold);
}
private void Report(BoardPoint start, BoardPoint next, IReadOnlyList <BoardPoint> best, GameBoard gameBoard,
string name = "GOTO")
{
var last = best.Last();
Console.WriteLine($"{name} {gameBoard.GetElementAt(last)} at {last}\t{start} -> {next}");
}
public void Grow()
{
BoardPoint positionLast = this.body.LastPiece().Position;
SnakeTail newTail = tailFactory.Build(positionLast.X, positionLast.Y, Direction.NONE);
this.body.AddTail(newTail);
}
public void Tick(GameBoard board)
{
_board = board;
_root = board.GetMyPosition();
GenerateMap();
}
private void GetField(int idField, TetrisGameBoard board)
{
BoardPoint[,] result = new BoardPoint[board.Width, board.Height];
SqlCommand comm = GetCommand("GetPoints");
comm.Parameters.Add(new SqlParameter()
{
ParameterName = "@idField", DbType = DbType.Int32, Value = idField
});
DataTable table = new DataTable();
table.Load(comm.ExecuteReader());
if (table.Rows.Count != 0)
{
for (int i = 0; i < table.Rows.Count; i++)
{
var row = table.Rows[i];
TColor col = (TColor)row[0];
byte x = (byte)row[1];
byte y = (byte)row[2];
result[x, y] = new BoardPoint(col);
}
board.Field = result;
}
}
public SnakeTail(GameObject gameObj, BoardPoint target, BoardPoint position)
{
this.gameObject = gameObj;
this.movements = new ObjMovements(this.gameObject, position);
this.target = target;
this.position = position;
}
private IReadOnlyList <Route> FindEvilNear(BoardPoint start, PathFinder pathFinder, int size)
{
if (size <= 0)
{
return(Array.Empty <Route>());
}
return(pathFinder.FindRoutes(start, (elem, point, requestRoute) => elem == EnemyHeadEvil, maxLength: size));
}
public SnakeTail Build(float x, float y, DirectionEnum.Direction direction)
{
GameObject obj = GameObject.Instantiate(prefab) as GameObject;
BoardPoint pos = new BoardPoint(0, 0);
ObjMovements movs = new ObjMovements(obj.transform, pos);
movs.GoTo(x, y);
return(new SnakeTail(obj, pos, direction));
}
private int FindConcentration(BoardPoint around, IEnumerable <BoardPoint> points, int squareSize)
{
int minX = around.X - squareSize;
int maxX = around.X + squareSize;
int minY = around.Y - squareSize;
int maxY = around.Y + squareSize;
return(points.Count(p => p.X > minX && p.X < maxX && p.Y > minY && p.Y < maxY));
}
public SnakeHead(GameObject gameObject)
{
BoardPointFactory pointFac = new BoardPointFactory();
this.position = pointFac.FromGameObjPosition(gameObject);
this.gameObject = gameObject;
this.direction = Direction.UP;
this.movements = new ObjMovements(this.gameObject.transform, this.position);
this.turns = new List <Direction>();
}
public ShipAreaAllocated(Guid id, int shipId, int allocationId, int allocationSize,
BoardPoint head, BoardPoint tail)
{
Id = id;
ShipId = shipId;
AllocationId = allocationId;
AllocationSize = allocationSize;
Head = head;
Tail = tail;
}
public ShipAdded(Guid id, int shipId, int allocationRef, string name, int size,
BoardPoint head,
BoardPoint tail)
{
Id = id;
ShipId = shipId;
AllocationReference = allocationRef;
Name = name;
Size = size;
Head = head;
Tail = tail;
}
private void RemoveChecker(GameColor color)
{
if (color == GameColor.White)
{
_whiteBar.RemoveChecker();
if (_whiteBar.CheckersAmount == 0)
_whiteBar = null;
return;
}
_redBar.RemoveChecker();
if (_redBar.CheckersAmount == 0)
_redBar = null;
}
private void FindRandomDestanation()
{
var point = _board.GetMyPosition();
PathGraph path;
do
{
int offsetX = _random.Next(-_distance, _distance);
int offsetY = _random.Next(-_distance, _distance);
_randomPos = new BoardPoint(point.X + offsetX, point.Y + offsetY);
path = _pathFind.GetGraphToPoint(_randomPos.X, _randomPos.Y);
} while (path == null);
_pathToDestination = GraphToAction.ParseToStack(path);
}
public IReadOnlyList <Route> FindRoutes(BoardPoint start, IsGoal isGoal, bool stopOnFirstGoal = false,
int?maxLength = null)
{
var result = new List <Route>();
var frontier = new Queue <BoardPoint>();
frontier.Enqueue(start);
var cameFrom = new Dictionary <BoardPoint, BoardPoint> {
[start] = new BoardPoint()
};
while (frontier.Count > 0)
{
var current = frontier.Dequeue();
var currentElement = _board.GetElementAt(current);
var lazyRouteLength = new Lazy <int>(() => GetRouteLength(cameFrom, start, current));
if (isGoal(currentElement, current, () => lazyRouteLength.Value))
{
result.Add(CreateRoute(cameFrom, start, current, currentElement));
if (stopOnFirstGoal)
{
break;
}
}
if (maxLength.HasValue && lazyRouteLength.Value > maxLength)
{
break;
}
foreach (var next in GetNeighbors(current))
{
if (!cameFrom.ContainsKey(next))
{
frontier.Enqueue(next);
cameFrom[next] = current;
}
}
}
return(result);
}
private static bool IsLockByWalls(GameBoard gameBoard, BoardPoint point)
{
int cntLock = 0;
foreach (var dir in GameSettings.Directions)
{
var nextPoint = point.Shift(dir);
var element = gameBoard.GetElementAt(nextPoint);
if (element.IsBarrier())
{
cntLock++;
}
}
return(cntLock >= 3);
}
public static EnemyPart?[,] GetEnemyPlayersInfo(GameBoard gameBoard)
{
_gameBoard = gameBoard;
_size = gameBoard.Size;
int size = _size;
EnemyPart?[,] res = new EnemyPart?[size, size];
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
res[i, j] = null;
}
}
int id = 1;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
var point = new BoardPoint(i, j);
var element = gameBoard.GetElementAt(point);
if (element.IsEnemyActiveTail())
{
Stack <BoardPoint> stack = new Stack <BoardPoint>();
bool isEvil = false;
HandleEnemySnakeRec(point, point, stack, ref isEvil);
int snakeLength = stack.Count - 1;
for (int k = 0; stack.Count > 0; k++)
{
var p = stack.Pop();
res[p.X, p.Y] = new EnemyPart(snakeLength - k, isEvil, id);
}
id <<= 1;
}
}
}
return(res);
}
private void Update()
{
if (moveFlag)
{
moveTimer += Time.deltaTime / 1f;
transform.position = Vector3.Lerp(transform.position, toMovePoint.transform.position, moveTimer);
transform.localPosition = new Vector3(transform.localPosition.x, 0f, transform.localPosition.z);
if (Mathf.Abs(transform.position.z - toMovePoint.transform.position.z) < 0.1f)
{
currentPoint = toMovePoint;
moveFlag = false;
if (moveEndCallback != null)
{
moveEndCallback();
}
}
}
}
//public Node this[BoardElement index] => nodes[GetIndexOfData(index)];
public void AddNode(BoardPoint point, BoardElement element)
{
var num = Length;
var node = new Node(num);
pointToNodeDict.Add(point, node);
node.BoardPoint = point;
node.Element = element;
nodes.Add(node);
//node.AddExtraWeight(0);
foreach (var l in point.Neighborhood)
{
if (IsBoardPointInDict(l))
{
Connect(node, l);
}
}
}
private IReadOnlyList <BoardPoint> FindPath(BoardPoint start, BoardPoint goal, GameBoard board)
{
var frontier = new Queue <BoardPoint>();
frontier.Enqueue(start);
var cameFrom = new Dictionary <BoardPoint, BoardPoint> {
[start] = new BoardPoint()
};
while (frontier.Count > 0)
{
var current = frontier.Dequeue();
foreach (var next in GetNeighbors(current, board))
{
if (!cameFrom.ContainsKey(next))
{
frontier.Enqueue(next);
cameFrom[next] = current;
}
}
}
if (!cameFrom.ContainsKey(goal))
{
return(Array.Empty <BoardPoint>());
}
{
var current = goal;
var path = new List <BoardPoint>(cameFrom.Count - 1)
{
current
};
while (current != start)
{
current = cameFrom[current];
path.Add(current);
}
path.Reverse();
return(path);
}
}
private bool ConsiderGoal(BoardElement elem, BoardPoint point, Func <int> requestRouteLength,
bool isFury)
{
if (elem == Apple || elem == Gold)
{
return(true);
}
if (elem == FuryPill)
{
// route is short
return(true); //requestRouteLength() < 7;
// var toEnemy = pathFinder.FindRoutes(point, (element, boardPoint, _) => element.IsEnemy());
// return toEnemy.Any(r => r.Length < 7);
}
if (isFury)
{
var length = requestRouteLength();
switch (elem)
{
// we can eat stones
case Stone:
return(length < 12);
// we can bite other snakes bodies, don't try to eat tail: you're never reach it
case EnemyBodyHorizontal:
case EnemyBodyVertical:
case EnemyBodyLeftDown:
case EnemyBodyLeftUp:
case EnemyBodyRightDown:
case EnemyBodyRightUp:
// no problem in eating head: it is going to replace with body in the next round
case EnemyHeadDown:
case EnemyHeadLeft:
case EnemyHeadRight:
case EnemyHeadUp:
return(length < 6);
}
}
return(false);
}
private void AddChecker(GameColor color)
{
if (color == GameColor.White)
{
if (_whiteBar == null)
{
_whiteBar = new BoardPoint(color, 1);
return;
}
_whiteBar.AddChecker(color);
return;
}
if (_redBar == null)
{
_redBar = new BoardPoint(color, 1);
return;
}
_redBar.AddChecker(color);
}
private SnakeAction RandomMove(GameBoard gameBoard)
{
var random = new Random();
var currentPosition = gameBoard.GetMyHead();
do
{
var direction = (Direction)random.Next(Enum.GetValues(typeof(Direction)).Length - 1);
BoardPoint nextPosition = currentPosition.Value;
switch (direction)
{
case Direction.Down:
nextPosition = currentPosition.Value.ShiftTop();
break;
case Direction.Left:
nextPosition = currentPosition.Value.ShiftRight();
break;
case Direction.Right:
nextPosition = currentPosition.Value.ShiftLeft();
break;
case Direction.Up:
nextPosition = currentPosition.Value.ShiftBottom();
break;
case Direction.Stop:
continue;
break;
}
if (gameBoard.IsBadThingAt(nextPosition))
{
continue;
}
return(new SnakeAction(false, direction));
} while (false);
var act = random.Next() % 2 == 0;
return(new SnakeAction(false, Direction.Right));
}
internal Bar(BoardPoint whiteBar, BoardPoint redBar)
{
_redBar = redBar;
_whiteBar = whiteBar;
}
public static Bar CreateBar(BoardPoint whiteBar, BoardPoint redBar)
{
return new Bar(whiteBar, redBar);
}
