// Check if a city wall can be built at a vertex
public bool canBuildCityWall(Vertex location, int[] resources,
int cityWalls, Enums.Color color)
{
GamePiece city = location.getOccupyingPiece();
// Make sure the location is valid
if (Object.ReferenceEquals(city, null))
{
return(false);
}
if (city.getPieceType() != Enums.PieceType.CITY)
{
return(false);
}
if (location.getHasWall())
{
return(false);
}
if (city.getColor() != color)
{
return(false);
}
if (cityWalls < 1)
{
return(false);
}
// Make sure there are enough resources
if (resources[(int)Enums.ResourceType.BRICK] < 2)
{
return(false);
}
return(true);
}
// Upgrade a knight at vertex v
public bool upgradeKnight(int[] resources, int[] devChart, Vertex v, List <GamePiece> pieces,
Enums.Color color, bool server)
{
// Check if the knight can be upgraded
if (!ma.canUpgradeKnight(resources, devChart, v, pieces, color))
{
return(false);
}
Knight k = (Knight)v.getOccupyingPiece();
int level = k.getLevel();
assignAuthority(server);
RpcUpgradeKnight(resources, devChart, v.transform.position, level, color);
Player current = GameManager.instance.getCurrentPlayer();
// Spend the correct resources
current.changeResource(Enums.ResourceType.WOOL, -1);
Bank.instance.depositResource(Enums.ResourceType.WOOL, 1, current.isServer);
current.changeResource(Enums.ResourceType.ORE, -1);
Bank.instance.depositResource(Enums.ResourceType.ORE, 1, current.isServer);
removeAuthority(server);
return(true);
}
// Check if a knight can be activated
public bool canActivateKnight(int[] resources, Vertex v, Enums.Color color)
{
// Make sure there is a grain available
if (resources[(int)Enums.ResourceType.GRAIN] < 1)
{
return(false);
}
// Make sure there is a knight that can be activated
GamePiece sourcePiece = v.getOccupyingPiece();
if (Object.ReferenceEquals(sourcePiece, null))
{
return(false);
}
if (sourcePiece.getColor() != color)
{
return(false);
}
if (sourcePiece.getPieceType() != Enums.PieceType.KNIGHT)
{
return(false);
}
Knight sourceKnight = (Knight)sourcePiece;
if (sourceKnight.isActive())
{
return(false);
}
return(true);
}
// Build a settlement at location
public bool buidSettlement(Vertex location, int[] resources,
List <GamePiece> pieces, Enums.Color color, bool server)
{
if (!ma.canBuildSettlement(location, resources, pieces, color))
{
return(false);
}
assignAuthority(server);
RpcBuildSettlement(location.transform.position, color);
Player current = GameManager.instance.getCurrentPlayer();
// Add an appropriate amount of victory points
current.changeVictoryPoints(1);
current.changeVictoryPoints(location.getChits());
// Spend the correct resources
current.changeResource(Enums.ResourceType.BRICK, -1);
Bank.instance.depositResource(Enums.ResourceType.BRICK, 1, current.isServer);
current.changeResource(Enums.ResourceType.GRAIN, -1);
Bank.instance.depositResource(Enums.ResourceType.GRAIN, 1, current.isServer);
current.changeResource(Enums.ResourceType.WOOL, -1);
Bank.instance.depositResource(Enums.ResourceType.WOOL, 1, current.isServer);
current.changeResource(Enums.ResourceType.LUMBER, -1);
Bank.instance.depositResource(Enums.ResourceType.LUMBER, 1, current.isServer);
removeAuthority(server);
return(true);
}
void RpcBuildCity(Vector3 location, Enums.Color color)
{
// Remove the current settlement
Vertex source = BoardState.instance.vertexPosition[location];
GamePiece settlement = source.getOccupyingPiece();
Destroy(BoardState.instance.spawnedObjects [location]);
BoardState.instance.spawnedObjects.Remove(location);
GameObject spawnedCity = Instantiate <GameObject>(PrefabHolder.instance.city, location, Quaternion.identity);
fixPieceRotationAndPosition(spawnedCity);
spawnedCity.GetComponent <MeshRenderer>().material.SetColor("_Color", translateColor(color));
BoardState.instance.spawnedObjects.Add(location, spawnedCity);
// Remove settlement at location
settlement.takeOffBoard();
Player current = GameManager.instance.getCurrentPlayer();
List <GamePiece> pieces = current.getGamePieces();
City city = City.getFreeCity(pieces);
source.setOccupyingPiece(city);
city.putOnBoard();
}
// Build a city at location
public bool buildCity(Vertex location, int[] resources,
List <GamePiece> pieces, Enums.Color color, bool server)
{
Debug.Log("hello1");
if (!ma.canBuildCity(location, resources, pieces, color))
{
return(false);
}
Debug.Log("hello2");
assignAuthority(server);
RpcBuildCity(location.transform.position, color);
Player current = GameManager.instance.getCurrentPlayer();
// Add an appropriate amount of victory points
current.changeVictoryPoints(1);
// Spend the resources
current.changeResource(Enums.ResourceType.GRAIN, -2);
Bank.instance.depositResource(Enums.ResourceType.GRAIN, 2, current.isServer);
current.changeResource(Enums.ResourceType.ORE, -3);
Bank.instance.depositResource(Enums.ResourceType.ORE, 3, current.isServer);
removeAuthority(server);
return(true);
}
/// <summary>
/// Convert the specified p_Color Enum into a Color for an image to use
/// </summary>
/// <param name="p_Color">P color.</param>
private Color convert(Enums.Color p_Color)
{
Color rColor = new Color(0, 0, 0);
switch (p_Color)
{
case Enums.Color.BLUE:
rColor = Color.blue;
break;
case Enums.Color.ORANGE:
rColor = new Color32(0xF6, 0xA1, 0x09, 0xFF);
break;
case Enums.Color.RED:
rColor = Color.red;
break;
case Enums.Color.WHITE:
rColor = Color.white;
break;
default:
break;
}
return(rColor);
}
// Build a ship at location
public bool buildShip(Edge location, int[] resources,
List <GamePiece> pieces, Enums.Color color, bool server)
{
Debug.Log("ship2");
if (!ma.canBuildShip(location, resources, pieces, color))
{
return(false);
}
Debug.Log("ship3");
assignAuthority(server);
RpcBuildShip(location.transform.position, color);
Player current = GameManager.instance.getCurrentPlayer();
// Spend the resources
current.changeResource(Enums.ResourceType.WOOL, -1);
Bank.instance.depositResource(Enums.ResourceType.WOOL, 1, current.isServer);
current.changeResource(Enums.ResourceType.LUMBER, -1);
Bank.instance.depositResource(Enums.ResourceType.LUMBER, 1, current.isServer);
removeAuthority(server);
return(true);
}
// Check if a vertex is next to a ship of a color
public bool nextToMyShip(Vertex v, Enums.Color color)
{
foreach (Edge e in v.getNeighbouringEdges())
{
GamePiece p = e.getOccupyingPiece();
if (Object.ReferenceEquals(p, null))
{
continue;
}
if (p.getPieceType() != Enums.PieceType.ROAD)
{
continue;
}
Road road = (Road)p;
if (!road.getIsShip())
{
continue;
}
if (p.getColor() == color)
{
return(true);
}
}
return(false);
}
// Check if an edge is next to a town-piece of a color
public bool nextToMyCityOrSettlement(Edge e, Enums.Color color)
{
GamePiece leftPiece = e.getLeftVertex().getOccupyingPiece();
GamePiece rightPiece = e.getRightVertex().getOccupyingPiece();
// Check the left vertex of the edge
if (!Object.ReferenceEquals(leftPiece, null))
{
if (leftPiece.getColor() == color)
{
if (leftPiece.getPieceType() == Enums.PieceType.CITY ||
leftPiece.getPieceType() == Enums.PieceType.SETTLEMENT)
{
return(true);
}
}
}
// Check the right vertex of the edge
if (!Object.ReferenceEquals(rightPiece, null))
{
if (rightPiece.getColor() == color)
{
if (rightPiece.getPieceType() == Enums.PieceType.CITY ||
rightPiece.getPieceType() == Enums.PieceType.SETTLEMENT)
{
return(true);
}
}
}
return(false);
}
// An algorithm that determines the longest route of a collection of edges in a given color
public int longestRoute(List <Edge> edges, Enums.Color color)
{
// Check the base cases
if (edges.Count == 0)
{
return(0);
}
if (edges.Count == 1)
{
return(1);
}
// Recursively check every edge to see if it is the start of the longest route
int max = 0;
foreach (Edge endpoint in edges)
{
Vertex left = endpoint.getLeftVertex();
Vertex right = endpoint.getRightVertex();
int current = recLongRoute(endpoint, left, edges, 0);
if (current > max)
{
max = current;
}
current = recLongRoute(endpoint, right, edges, 0);
if (current > max)
{
max = current;
}
}
return(max);
}
void RpcAlternateDisplaceKnight(Vector3 displacedLocation,
int targetLevel, bool active, Enums.Color color)
{
Vertex displacedPiece = BoardState.instance.vertexPosition[displacedLocation];
Player current = GameManager.instance.getCurrentPlayer();
List <GamePiece> pieces = current.getGamePieces();
Knight targetKnight = Knight.getFreeKnight(pieces);
targetKnight.updateLevel(targetLevel);
if (active)
{
targetKnight.activateKnight();
targetKnight.notActivatedThisTurn();
}
GameObject targetKnightObject = getKnightFromLevel(targetLevel, displacedLocation);
targetKnightObject.GetComponent <MeshRenderer>().material.SetColor("_Color", translateColor(color));
BoardState.instance.spawnedObjects.Add(displacedLocation, targetKnightObject);
displacedPiece.setOccupyingPiece(targetKnight);
// Deactivate the knight
targetKnight.putOnBoard();
// Check if longest road needs to be updated
}
void RpcDisplaceKnight(Vector3 source, Vector3 target,
int sourceLevel, int targetLevel, Enums.Color color)
{
Vertex sourcePiece = BoardState.instance.vertexPosition[source];
Vertex targetPiece = BoardState.instance.vertexPosition[target];
Knight sourceKnight = (Knight)sourcePiece.getOccupyingPiece();
Knight targetKnight = (Knight)targetPiece.getOccupyingPiece();
Destroy(BoardState.instance.spawnedObjects [source]);
Destroy(BoardState.instance.spawnedObjects [target]);
GameObject sourceKnightObject = getKnightFromLevel(sourceLevel, target);
sourceKnightObject.GetComponent <MeshRenderer>().material.SetColor("_Color", translateColor(color));
BoardState.instance.spawnedObjects.Remove(target);
BoardState.instance.spawnedObjects.Remove(source);
BoardState.instance.spawnedObjects.Add(target, sourceKnightObject);
// Move the knight
sourcePiece.setOccupyingPiece(null);
targetPiece.setOccupyingPiece(sourceKnight);
// Deactivate the knight
sourceKnight.deactivateKnight();
targetKnight.takeOffBoard();
// Check if longest road needs to be updated
}
public void alternateDisplaceKnight(Vertex displacedLocation, int targetLevel,
bool active, Enums.Color color, bool server)
{
assignAuthority(server);
RpcAlternateDisplaceKnight(displacedLocation.transform.position,
targetLevel, active, color);
removeAuthority(server);
}
// Final initialization step, assign colors, game manager, movemanager
public void Init()
{
this.myColor = (Enums.Color)iD;
foreach (GamePiece piece in pieces)
{
piece.setColor(myColor);
}
}
// Check if a knight can displace another knight
public bool canKnightDisplace(Vertex source, Vertex target, Enums.Color color)
{
// Make sure there is a knight that can be moved
GamePiece sourcePiece = source.getOccupyingPiece();
if (Object.ReferenceEquals(sourcePiece, null))
{
return(false);
}
if (sourcePiece.getPieceType() != Enums.PieceType.KNIGHT)
{
return(false);
}
if (sourcePiece.getColor() != color)
{
return(false);
}
Knight sourceKnight = (Knight)sourcePiece;
if (!sourceKnight.isActive())
{
return(false);
}
if (sourceKnight.wasActivatedThisTurn())
{
return(false);
}
// Make sure there is a lower-level knight at the target vertex
GamePiece targetPiece = target.getOccupyingPiece();
if (!Object.ReferenceEquals(targetPiece, null))
{
if (targetPiece.getColor() == color)
{
return(false);
}
if (targetPiece.getPieceType() != Enums.PieceType.KNIGHT)
{
return(false);
}
Knight targetKnight = (Knight)targetPiece;
if (targetKnight.getLevel() >= sourceKnight.getLevel())
{
return(false);
}
}
else
{
return(false);
}
// Check to see if the vertices are connected
graph.vertexReset(source);
return(graph.areConnectedVertices(source, target, color));
}
// Displace a knight at target with knight at source
public bool displaceKnight(Vertex source, Vertex target, Enums.Color color, bool server)
{
// Check if the knight can displace
if (!ma.canKnightDisplace(source, target, color))
{
return(false);
}
Knight kSource = (Knight)source.getOccupyingPiece();
int sourceLevel = kSource.getLevel();
Knight kTarget = (Knight)target.getOccupyingPiece();
int targetLevel = kTarget.getLevel();
bool gone = true;
foreach (Vertex v in BoardState.instance.vertexPosition.Values)
{
if (graph.areConnectedVertices(v, target, color))
{
if (!Object.ReferenceEquals(v.getOccupyingPiece(), null))
{
if (Object.ReferenceEquals(v, source))
{
gone = false;
break;
}
}
else
{
gone = false;
break;
}
}
}
if (!gone)
{
int currTurn = GameManager.instance.getPlayerTurn();
foreach (Player p in GameManager.instance.players)
{
p.CmdSetMoveType(MoveType.SPECIAL);
p.CmdSetOldTurn(currTurn);
}
Player opponent = GameManager.instance.getPlayer((int)kTarget.getColor());
opponent.CmdSetSpecial(Special.KNIGHT_DISPLACED);
opponent.CmdSetI1(targetLevel);
opponent.CmdSetB1(kTarget.isActive());
GameManager.instance.setSpecialTurn((int)kTarget.getColor(), server);
}
assignAuthority(server);
RpcDisplaceKnight(source.transform.position, target.transform.position,
sourceLevel, targetLevel, color);
removeAuthority(server);
return(true);
}
//----------------------------------------------------------------------------//
public void SetPointColor(Enums.Color Color)
{
//We never want to change the color of a base, or destination point
//They are assigned manually in the editor.
if (this is Waypoint || this is StartingPoint)
{
_pointColor = Color;
}
}
// Check if initial ship can be placed on an edge
public bool canPlaceInitialShip(Edge e, Enums.Color color)
{
// Make sure the location is valid
bool nextToWater = false;
if (!Object.ReferenceEquals(e.getLeftHex(), null))
{
if (e.getLeftHex().getTerrainType() == Enums.TerrainType.WATER)
{
nextToWater = true;
}
}
if (!Object.ReferenceEquals(e.getRightHex(), null))
{
if (e.getRightHex().getTerrainType() == Enums.TerrainType.WATER)
{
nextToWater = true;
}
}
if (e.getTerrainType() == Enums.TerrainType.WATER)
{
nextToWater = true;
}
if (!nextToWater)
{
return(false);
}
// Make sure the road is going on the correct town-piece
if (graph.nextToMyCityOrSettlement(e, color))
{
Vertex current = e.getLeftVertex();
GamePiece piece = current.getOccupyingPiece();
if (Object.ReferenceEquals(piece, null))
{
current = e.getRightVertex();
piece = current.getOccupyingPiece();
}
int count = 0;
foreach (Edge edge in current.getNeighbouringEdges())
{
if (!Object.ReferenceEquals(edge.getOccupyingPiece(), null))
{
count++;
break;
}
}
if (count > 0)
{
return(false);
}
return(true);
}
return(false);
}
// Check if a settlement can be built at given vertex
public bool canBuildSettlement(Vertex location, int[] resources,
List <GamePiece> pieces, Enums.Color color)
{
// Make sure the location is valid
if (location.getTerrainType() == Enums.TerrainType.WATER)
{
return(false);
}
if (!graph.freeVertex(location))
{
return(false);
}
if (!graph.nextToMyEdge(location, color))
{
return(false);
}
// Make sure there is an available piece
bool availablePiece = false;
foreach (GamePiece p in pieces)
{
if (p.getPieceType() != Enums.PieceType.SETTLEMENT)
{
continue;
}
if (!p.isOnBoard())
{
availablePiece = true;
}
}
if (!availablePiece)
{
return(false);
}
// Make sure there are enough resources
if (resources[(int)Enums.ResourceType.GRAIN] < 1)
{
return(false);
}
if (resources[(int)Enums.ResourceType.WOOL] < 1)
{
return(false);
}
if (resources[(int)Enums.ResourceType.BRICK] < 1)
{
return(false);
}
if (resources[(int)Enums.ResourceType.LUMBER] < 1)
{
return(false);
}
return(true);
}
// Place an initial ship
public bool placeInitialShip(Edge e, Enums.Color color, List <GamePiece> pieces, bool server)
{
if (!ma.canPlaceInitialShip(e, color))
{
return(false);
}
assignAuthority(server);
RpcPlaceInitialShip(e.transform.position, color);
removeAuthority(server);
return(true);
}
public Player getPlayer(Enums.Color color)
{
foreach (Player p in players)
{
if (p.getColor() == color)
{
return(p);
}
}
return(null);
}
public List <Vertex> buildableChaseRobber(Enums.Color color)
{
List <Vertex> vertices = new List <Vertex>();
foreach (Vertex v in BoardState.instance.vertexPosition.Values)
{
if (ma.canChaseRobber(v, color))
{
vertices.Add(v);
}
}
return(vertices);
}
public List <Edge> buildablePlaceInitialShip(Enums.Color color)
{
List <Edge> edges = new List <Edge>();
foreach (Edge e in BoardState.instance.edgePosition.Values)
{
if (ma.canPlaceInitialShip(e, color))
{
edges.Add(e);
}
}
return(edges);
}
public List <Vertex> buildableActivateKnight(int[] resources, Enums.Color color)
{
List <Vertex> vertices = new List <Vertex>();
foreach (Vertex v in BoardState.instance.vertexPosition.Values)
{
if (ma.canActivateKnight(resources, v, color))
{
vertices.Add(v);
}
}
return(vertices);
}
public List <Edge> buildableBuildShip(int[] resources,
List <GamePiece> pieces, Enums.Color color)
{
List <Edge> edges = new List <Edge>();
foreach (Edge e in BoardState.instance.edgePosition.Values)
{
if (ma.canBuildShip(e, resources, pieces, color))
{
edges.Add(e);
}
}
return(edges);
}
public List <Vertex> buildableBuildSettlement(int[] resources,
List <GamePiece> pieces, Enums.Color color)
{
List <Vertex> vertices = new List <Vertex>();
foreach (Vertex v in BoardState.instance.vertexPosition.Values)
{
if (ma.canBuildSettlement(v, resources, pieces, color))
{
vertices.Add(v);
}
}
return(vertices);
}
void RpcBuildCityWall(Vector3 location, Enums.Color color)
{
Vertex source = BoardState.instance.vertexPosition[location];
GameObject spawnedCityWall = Instantiate <GameObject>(PrefabHolder.instance.cityWall, location, Quaternion.identity);
fixPieceRotationAndPosition(spawnedCityWall);
spawnedCityWall.GetComponent <MeshRenderer>().material.SetColor("_Color", translateColor(color));
BoardState.instance.spawnedObjects.Add(location, spawnedCityWall);
Player current = GameManager.instance.getCurrentPlayer();
current.changeCityWallCount(-1);
source.addWall();
}
public List <Vertex> buildableBuildCityWall(int[] resources,
int cityWalls, Enums.Color color)
{
List <Vertex> vertices = new List <Vertex>();
foreach (Vertex v in BoardState.instance.vertexPosition.Values)
{
if (ma.canBuildCityWall(v, resources, cityWalls, color))
{
vertices.Add(v);
}
}
return(vertices);
}
void RpcUpgradeKnight(int[] resources, int[] devChart, Vector3 v, int level, Enums.Color color)
{
Vertex source = BoardState.instance.vertexPosition[v];
GameObject newKnight = getKnightFromLevel(level + 1, v);
newKnight.GetComponent <MeshRenderer>().material.SetColor("_Color", translateColor(color));
BoardState.instance.spawnedObjects.Add(v, newKnight);
// Upgrade the knight
Knight knight = (Knight)source.getOccupyingPiece();
knight.upgrade();
}
