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