private HexagonTile FindColorInLine(HexagonTile search, Func <HexagonTile, HexagonTile> GetNext) { TileType found = TileType.none; HexagonTile next = GetNext(search); if (next == null || next.TileType == search.TileType || next.TileType == TileType.board || next.TileType == TileType.none || next.Fortress) { return(null); } while (next != null && next.TileType != TileType.board && next.TileType != TileType.none && next.TileType != search.TileType && !next.Fortress) { found = next.TileType; next = GetNext(next); // endboard => end search if (next == null || next.TileType == TileType.none) { return(null); } } if (next.TileType == search.TileType) { if (this.firstCapture == TileType.none) { this.firstCapture = found; } return(next); } return(null); }
private HexagonTile FindChoiceCandidateForDirection(HexagonTile search, Func <HexagonTile, HexagonTile> GetNext) { HexagonTile next = GetNext(search); // skip first if (next == null || next.TileType == search.TileType || next.TileType == TileType.board || next.TileType == TileType.none) { return(null); } while (next.TileType != TileType.board) { if (next.TileType == search.TileType) { return(null); } if (next.Fortress) // blocks possible moves { return(null); } next = GetNext(next); // endboard => end search if (next == null || next.TileType == TileType.none) { return(null); } } return(next); }
public void ConsumeFortress(Guid playerId, int id) { PlayerFortress[playerGuids.IndexOf(playerId)]--; HexagonTile choice = hexagonList.FirstOrDefault(p => p.Id == id); choice.Fortress = true; }
private void AddEditSpot(HexagonTile tile, double x, double y) { tile.X = (int)x; tile.Y = (int)y; hexagonList.Add(tile, GetEditTile(x, y)); }
private void CreateMappings() { foreach (HexagonTile t in hexagonList) { if (t.TileType != TileType.none) { this.startTile = t; break; } } mappings.Clear(); CreateMappings(this.startTile); CrossSections.Children.Clear(); foreach (HexagonTile key in mappings.Keys) { foreach (HexagonTile tile in mappings[key]) { CreateLine(key, tile); } } }
private HexagonTile FindPotentialLine(HexagonTile search, Func <HexagonTile, HexagonTile> GetNext) { HexagonTile next = GetNext(search); // skip first if (next == null || next.TileType == search.TileType || next.TileType == TileType.board || next.TileType == TileType.none) { return(null); } while (next.TileType != TileType.board) { if (next.TileType == search.TileType) { return(null); } next = GetNext(next); // endboard => end search if (next == null || next.TileType == TileType.none) { return(null); } } return(next); }
public override void ForEvery(Tile tile) { tile.Hex.ToggleGraphics(0.2); tile.Hex.ToggleOpenTile(); tile.Hex.ToggleTileName(); tile.Hex.TogglePlayerIcon(); HexagonTile hex = tile.Hex; if (tile is Landscape) { hex.Polygon.Fill = Brushes.Black; } if (tile is City city) { if (city.Government != null) { hex.Polygon.Fill = ColorHandler.ColorFromRGB(city.Government.RulingParties[0].Color); } else { hex.Polygon.Fill = Brushes.DarkSlateGray; } } }
//Starts from the goal and finds its way back to the start point, then reverses the list so the first move is at 0 Queue <HexagonTile> UnwindPath(HexagonTile goal, HexagonTile start) { Queue <HexagonTile> returnQueue = new Queue <HexagonTile>(); List <HexagonTile> temp = new List <HexagonTile>(); temp.Add(goal); bool pathUnwound = false; while (!pathUnwound) { if (temp[temp.Count - 1] == start) { pathUnwound = true; continue; } temp.Add(previousNode[temp[temp.Count - 1]]); } while (temp.Count != 0) { returnQueue.Enqueue(temp[temp.Count - 1]); temp.RemoveAt(temp.Count - 1); } return(returnQueue); }
private void OnTriggerEnter2D(Collider2D collision) { if (!interactable) { return; } if (collision.gameObject.GetComponent <Bee>() != null) { var bee = collision.gameObject.GetComponent <Bee>(); if (!(bee is player) && currentOwner == null) { OnInteractWithBee(bee); } } else if (collision.gameObject.GetComponent <HexagonTile>() != null && currentOwner != null) { HexagonTile tile = collision.gameObject.GetComponent <HexagonTile>(); OnInteractWithTile(tile); } else if (collision.gameObject.GetComponent <pickup>() != null && currentOwner != null) { var p = collision.gameObject.GetComponent <pickup>(); OnInteractWithPickup(p); } }
public void ChooseTurn(int id, Guid playerId) { if (!playerColorMapping.ContainsKey(playerId)) { logger.Error("Don't know this player: {0}", playerId); throw new Exception("Unknown player"); } if (playerColorMapping[playerId] != turnOrder[this.currentTurn]) { logger.Error("It isn't player's {0} turn", turnOrder[this.currentTurn]); throw new Exception("It is not your turn!"); } if (!GetPossibleMoves(playerId).Contains(id)) { logger.Error("Illegal move: {0}", id); throw new Exception("Tried illegal move"); } HexagonTile choice = hexagonList.FirstOrDefault(p => p.Id == id); choice.TileType = this.turnOrder[this.currentTurn]; TurnTilesToCurrentColor(choice); InitNextTurn(); }
private void AddPosibility(List <HexagonTile> posibilities, HexagonTile tile) { if (tile != null && !posibilities.Contains(tile)) { posibilities.Add(tile); } }
public void LoadSaveData(BoardSerializable boardData) { int id = 0; Dictionary <HexagonTileSerializable, HexagonTile> mapping = new Dictionary <HexagonTileSerializable, HexagonTile>(); this.hexagonList.Clear(); foreach (HexagonTileSerializable serializedTile in boardData.ActiveTileList) { HexagonTile tile = new HexagonTile() { Id = serializedTile.Id, TileType = serializedTile.TileType, X = serializedTile.X, Y = serializedTile.Y, }; if (tile.TileType != TileType.none) { mapping.Add(serializedTile, tile); this.hexagonList.Add(tile); } } foreach (HexagonTile tile in hexagonList) { MapUpTile(tile); } this.SetTurn(); }
private bool CanBeRemoved(HexagonTile tile) { if (tile.TileType != TileType.none) { return(false); } HexagonTile[] neighbours = new[] { tile.North, tile.NorthEast, tile.NorthWest, tile.South, tile.SouthEast, tile.SouthWest, }; foreach (HexagonTile neighbour in neighbours) { if (neighbour != null && neighbour.TileType != TileType.none) { return(false); } } return(true); }
public void SetLinkCount() { int count = 0; if (CurrentTile != null) { HexagonTile tile = CurrentTile; HexagonTile[] neighbours = new[] { tile.North, tile.NorthEast, tile.NorthWest, tile.South, tile.SouthEast, tile.SouthWest, }; foreach (HexagonTile neighbour in neighbours) { if (neighbour != null) { count++; } } } Links.Text = count.ToString(); }
public HexNode(HexagonTile location, int costSoFar, int costTillFinish, int additional) { currentHex = location; fromStart = costSoFar; tillFinish = costTillFinish; additionalCost = additional; totalCost = fromStart + tillFinish + additionalCost; }
void CreateAndAddHexNode(HexagonTile current, HexagonTile goal, HexNode parentNode) { previousNode.Add(current, parentNode.currentHex); int heuristicCost = Heuristic(current, goal); int additionalCost = parentNode.additionalCost + AdditionalCostFunction(current); HexNode addNode = new HexNode(current, parentNode.fromStart + 1, heuristicCost, additionalCost); open.Add(addNode); }
private void MapUpTile(HexagonTile tile) { if (tile.North == null) { tile.North = FindTileAt((int)tile.X + 0, (int)tile.Y - yFull); if (tile.North != null) { tile.North.South = tile; } } if (tile.South == null) { tile.South = FindTileAt((int)tile.X + 0, (int)tile.Y + yFull); if (tile.South != null) { tile.South.North = tile; } } if (tile.NorthWest == null) { tile.NorthWest = FindTileAt((int)tile.X - xMarge, (int)tile.Y - yMarge); if (tile.NorthWest != null) { tile.NorthWest.SouthEast = tile; } } if (tile.NorthEast == null) { tile.NorthEast = FindTileAt((int)tile.X + xMarge, (int)tile.Y - yMarge); if (tile.NorthEast != null) { tile.NorthEast.SouthWest = tile; } } if (tile.SouthWest == null) { tile.SouthWest = FindTileAt((int)tile.X - xMarge, (int)tile.Y + yMarge); if (tile.SouthWest != null) { tile.SouthWest.NorthEast = tile; } } if (tile.SouthEast == null) { tile.SouthEast = FindTileAt((int)tile.X + xMarge, (int)tile.Y + yMarge); if (tile.SouthEast != null) { tile.SouthEast.NorthWest = tile; } } }
private void TurnTilesToCurrentColor(HexagonTile chosenTile) { bool first = (this.firstCapture == TileType.none); if (FindColorInLine(chosenTile, f => f.North) != null) { TurnColorInLine(chosenTile, f => f.North); } if (FindColorInLine(chosenTile, f => f.NorthEast) != null) { TurnColorInLine(chosenTile, f => f.NorthEast); } if (FindColorInLine(chosenTile, f => f.NorthWest) != null) { TurnColorInLine(chosenTile, f => f.NorthWest); } if (FindColorInLine(chosenTile, f => f.South) != null) { TurnColorInLine(chosenTile, f => f.South); } if (FindColorInLine(chosenTile, f => f.SouthWest) != null) { TurnColorInLine(chosenTile, f => f.SouthWest); } if (FindColorInLine(chosenTile, f => f.SouthEast) != null) { TurnColorInLine(chosenTile, f => f.SouthEast); } if (first) { logger.Debug("First move"); switch (this.firstCapture) { case TileType.red: turnOrder.Add(TileType.red); turnOrder.Add(TileType.blue); break; case TileType.blue: turnOrder.Add(TileType.blue); turnOrder.Add(TileType.red); break; } logger.Debug("The order of turns is: {0}, {1}, {2}", turnOrder[0], turnOrder[1], turnOrder[2]); } var boardtiles = from p in hexagonList where p.TileType == TileType.board select p; }
private void ReplaceBoardTile(HexagonTile tile) { hexagonList[tile].MouseRightButtonDown -= RemoveHexagonTile; hexagonList[tile].MouseLeftButtonDown -= AddNewColour; hexagonList[tile].MouseLeftButtonDown += AddHexagonTile; tile.TileType = TileType.none; tile.TileValue = 0; hexagonList[tile].SetTileType(TileType.none); }
private void ReplaceBoardWithColour(HexagonTile tile) { hexagonList[tile].MouseLeftButtonDown -= AddNewColour; hexagonList[tile].MouseLeftButtonDown += AddPropertyToColour; hexagonList[tile].MouseRightButtonDown -= RemoveHexagonTile; hexagonList[tile].MouseRightButtonDown += RemoveColouredTile; tile.TileType = this.currentSelection.TileType; hexagonList[tile].SetTileType(this.currentSelection.TileType); }
// Use this for initialization void Start() { for (int i = 0; i < 5; i++) { for (int j = 0; j < 4; j++) { HexagonTile hex = new HexagonTile(i, j); } } }
private void TurnColorInLine(HexagonTile search, Func <HexagonTile, HexagonTile> GetNext) { HexagonTile next = GetNext(search); while (next.TileType != search.TileType) { next.TileType = search.TileType; next = GetNext(next); } }
//Runs A*, parameters speak for themselves. Start should be the point the unit is on. public Queue <HexagonTile> FindPath(HexagonTile start, HexagonTile goal, Unit requester) { resetStructures(); int heuristicCost = Heuristic(start, goal); HexNode startNode = new HexNode(start, 0, heuristicCost, 0); open.Add(startNode); checkedNodes.Add(startNode.currentHex); bool pathfound = false; //Take the current node, find its neighbours and add them to relevant list with costs calculated. while (!pathfound) { List <HexagonTile> neighbours = new List <HexagonTile>(); HexNode currentNode = open[open.Count - 1]; open.RemoveAt(open.Count - 1); neighbours = controller.GetAllNeighbours(currentNode.currentHex); //add the 6 neighbours of the node that's currently being checked. foreach (HexagonTile futureTile in neighbours) { if (requester.InSight(futureTile)) { if (futureTile == null || checkedNodes.Contains(futureTile)) { continue; } else { checkedNodes.Add(futureTile); if (futureTile.blocked) { continue; } } CreateAndAddHexNode(futureTile, goal, currentNode); if (futureTile == goal) { pathfound = true; } } } open = open.OrderByDescending(a => a.totalCost).ToList <HexNode>(); if (open.Count == 0) { return(new Queue <HexagonTile>()); } } return(UnwindPath(goal, start)); }
private void TurnColorInLine(HexagonTile search, Func <HexagonTile, HexagonTile> GetNext) { HexagonTile next = GetNext(search); while (next.TileType != search.TileType) { next.TileType = search.TileType; ((BoardHexagon)next.Visual).SetTileType(search.TileType); next = GetNext(next); } }
private HexagonTile GetClone(HexagonTile tile, Game target) { if (this.hexagonList.IndexOf(tile) >= 0) { return(target.hexagonList[this.hexagonList.IndexOf(tile)]); } else { return(null); } }
public List <HexagonTile> GetAllNeighbours(HexagonTile p) { List <HexagonTile> output = new List <HexagonTile>(); foreach (HexagonDirection direction in directions) { output.Add(GetNeighbor(p, direction)); } return(output); }
private void TurnTilesToCurrentColor(HexagonTile chosenTile) { bool first = (this.firstCapture == TileType.none); if (FindColorInLine(chosenTile, f => f.North) != null) { TurnColorInLine(chosenTile, f => f.North); } if (FindColorInLine(chosenTile, f => f.NorthEast) != null) { TurnColorInLine(chosenTile, f => f.NorthEast); } if (FindColorInLine(chosenTile, f => f.NorthWest) != null) { TurnColorInLine(chosenTile, f => f.NorthWest); } if (FindColorInLine(chosenTile, f => f.South) != null) { TurnColorInLine(chosenTile, f => f.South); } if (FindColorInLine(chosenTile, f => f.SouthWest) != null) { TurnColorInLine(chosenTile, f => f.SouthWest); } if (FindColorInLine(chosenTile, f => f.SouthEast) != null) { TurnColorInLine(chosenTile, f => f.SouthEast); } if (first) { switch (this.firstCapture) { case TileType.red: turnOrder[1] = TileType.red; turnOrder[2] = TileType.blue; break; case TileType.blue: turnOrder[1] = TileType.blue; turnOrder[2] = TileType.red; break; } } var boardtiles = from p in hexagonList where p.TileType == TileType.board select p; }
private List <HexagonTile> FindPosibilities(HexagonTile search, List <HexagonTile> posibilities) { AddPosibility(posibilities, FindPotentialLine(search, f => f.North)); AddPosibility(posibilities, FindPotentialLine(search, f => f.NorthWest)); AddPosibility(posibilities, FindPotentialLine(search, f => f.NorthEast)); AddPosibility(posibilities, FindPotentialLine(search, f => f.South)); AddPosibility(posibilities, FindPotentialLine(search, f => f.SouthEast)); AddPosibility(posibilities, FindPotentialLine(search, f => f.SouthWest)); return(posibilities); }
private List <HexagonTile> FindChoiceCandidatesForTile(HexagonTile search, List <HexagonTile> posibilities) { AddPosibility(posibilities, FindChoiceCandidateForDirection(search, f => f.North)); AddPosibility(posibilities, FindChoiceCandidateForDirection(search, f => f.NorthWest)); AddPosibility(posibilities, FindChoiceCandidateForDirection(search, f => f.NorthEast)); AddPosibility(posibilities, FindChoiceCandidateForDirection(search, f => f.South)); AddPosibility(posibilities, FindChoiceCandidateForDirection(search, f => f.SouthEast)); AddPosibility(posibilities, FindChoiceCandidateForDirection(search, f => f.SouthWest)); return(posibilities); }
private void ReplaceEditSpot(HexagonTile tile) { BoardHexagon control = hexagonList[tile]; control.MouseLeftButtonDown -= AddHexagonTile; control.MouseLeftButtonDown += AddNewColour; control.MouseRightButtonDown += RemoveHexagonTile; tile.TileType = TileType.board; tile.TileValue = defaultTileValue; control.SetTileType(TileType.board); }
public void LoadSaveData(BoardSerializable boardData) { Dictionary<HexagonTileSerializable, HexagonTile> mapping = new Dictionary<HexagonTileSerializable, HexagonTile>(); this.hexagonList.Clear(); this.Board.Children.Clear(); foreach (HexagonTileSerializable serializedTile in boardData.ActiveTileList) { HexagonTile tile = new HexagonTile() { TileType = serializedTile.TileType, }; if (tile.TileType != TileType.none) { mapping.Add(serializedTile, tile); this.hexagonList.Add(tile); BoardHexagon board = (BoardHexagon)this.GetBoardTile(serializedTile.X, serializedTile.Y); tile.Visual = board; board.SetTileType(tile.TileType); board.ShowLinks(false); } } foreach (HexagonTile tile in hexagonList) { MapUpTile(tile); } foreach (HexagonTile tile in hexagonList) { tile.Visual.SetLinkCount(); } this.SetTurn(); }
private List<HexagonTile> FindPosibilities(HexagonTile search, List<HexagonTile> posibilities) { AddPosibility(posibilities, FindPotentialLine(search, f => f.North)); AddPosibility(posibilities, FindPotentialLine(search, f => f.NorthWest)); AddPosibility(posibilities, FindPotentialLine(search, f => f.NorthEast)); AddPosibility(posibilities, FindPotentialLine(search, f => f.South)); AddPosibility(posibilities, FindPotentialLine(search, f => f.SouthEast)); AddPosibility(posibilities, FindPotentialLine(search, f => f.SouthWest)); return posibilities; }
private HexagonTile FindPotentialLine(HexagonTile search, Func<HexagonTile, HexagonTile> GetNext) { HexagonTile next = GetNext(search); // skip first if (next == null || next.TileType == search.TileType || next.TileType==TileType.board || next.TileType == TileType.none) { return null; } while (next.TileType != TileType.board) { if (next.TileType == search.TileType) { return null; } next = GetNext(next); // endboard => end search if (next == null || next.TileType == TileType.none) { return null; } } return next; }
private void TurnTilesToCurrentColor(HexagonTile chosenTile) { bool first = (this.firstCapture == TileType.none); if (FindColorInLine(chosenTile, f => f.North) != null) { TurnColorInLine(chosenTile, f => f.North); } if (FindColorInLine(chosenTile, f => f.NorthEast) != null) { TurnColorInLine(chosenTile, f => f.NorthEast); } if (FindColorInLine(chosenTile, f => f.NorthWest) != null) { TurnColorInLine(chosenTile, f => f.NorthWest); } if (FindColorInLine(chosenTile, f => f.South) != null) { TurnColorInLine(chosenTile, f => f.South); } if (FindColorInLine(chosenTile, f => f.SouthWest) != null) { TurnColorInLine(chosenTile, f => f.SouthWest); } if (FindColorInLine(chosenTile, f => f.SouthEast) != null) { TurnColorInLine(chosenTile, f => f.SouthEast); } if (first) { switch (this.firstCapture) { case TileType.red: turnOrder[1] = TileType.red; turnOrder[2] = TileType.blue; break; case TileType.blue: turnOrder[1] = TileType.blue; turnOrder[2] = TileType.red; break; } } var boardtiles =from p in hexagonList where p.TileType == TileType.board select p; foreach (HexagonTile p in boardtiles) { ((BoardHexagon)p.Visual).SetTileType(TileType.board); ((BoardHexagon)p.Visual).MouseLeftButtonDown -= ChooseTurn; } }
private void AddPosibility(List<HexagonTile> posibilities, HexagonTile tile) { if (tile != null && !posibilities.Contains(tile)) { posibilities.Add(tile); } }
private void MapUpTile(HexagonTile tile) { if (tile.North == null) { tile.North = FindTileAt((int)tile.Visual.X + 0, (int)tile.Visual.Y - yFull); if (tile.North != null) { tile.North.South = tile; } } if (tile.South == null) { tile.South = FindTileAt((int)tile.Visual.X + 0, (int)tile.Visual.Y + yFull); if (tile.South != null) { tile.South.North = tile; } } if (tile.NorthWest == null) { tile.NorthWest = FindTileAt((int)tile.Visual.X - xMarge, (int)tile.Visual.Y - yMarge); if (tile.NorthWest != null) { tile.NorthWest.SouthEast = tile; } } if (tile.NorthEast == null) { tile.NorthEast = FindTileAt((int)tile.Visual.X + xMarge, (int)tile.Visual.Y - yMarge); if (tile.NorthEast != null) { tile.NorthEast.SouthWest = tile; } } if (tile.SouthWest == null) { tile.SouthWest = FindTileAt((int)tile.Visual.X - xMarge, (int)tile.Visual.Y + yMarge); if (tile.SouthWest != null) { tile.SouthWest.NorthEast = tile; } } if (tile.SouthEast == null) { tile.SouthEast = FindTileAt((int)tile.Visual.X + xMarge, (int)tile.Visual.Y + yMarge); if (tile.SouthEast != null) { tile.SouthEast.NorthWest = tile; } } }
private void TurnColorInLine(HexagonTile search, Func<HexagonTile, HexagonTile> GetNext) { HexagonTile next = GetNext(search); while (next.TileType != search.TileType) { next.TileType = search.TileType; ((BoardHexagon)next.Visual).SetTileType(search.TileType); next = GetNext(next); } }
private HexagonTile FindColorInLine(HexagonTile search, Func<HexagonTile, HexagonTile> GetNext) { TileType found = TileType.none; HexagonTile next = GetNext(search); if (next == null || next.TileType == search.TileType || next.TileType == TileType.board || next.TileType == TileType.none) { return null; } while (next!=null && next.TileType != TileType.board && next.TileType != TileType.none && next.TileType !=search.TileType) { found = next.TileType; next = GetNext(next); // endboard => end search if (next == null || next.TileType == TileType.none) { return null; } } if (next.TileType == search.TileType) { if (this.firstCapture == TileType.none) { this.firstCapture = found; } return next; } return null; }