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); }