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