public static Action_Type MapBuildingToAction(Building.Building_Type bt)
{
Action_Type at_ = Action_Type.NOTHING;
switch (bt)
{
case Building.Building_Type.Dwelling:
at_ = Action_Type.Build_Dwelling;
break;
case Building.Building_Type.Trading_Post:
at_ = Action_Type.Build_TP;
break;
case Building.Building_Type.Stronghold:
at_ = Action_Type.Build_Stronghold;
break;
case Building.Building_Type.Temple:
at_ = Action_Type.Build_Temple;
break;
case Building.Building_Type.Sanctuary:
at_ = Action_Type.Build_Sanctuary;
break;
}
return(at_);
}
public void ResetFlags()
{
build_flag = Building.Building_Type.NOTHING;
terra_flag = Terrain.TerrainType.NOTHING;
magic_cast_flag = MagicController.SpellType.NOTHING;
round_bonus_flag = RoundBonusManager.RoundBonusType.NOTHING;
}
public void FreeBuild(Building.Building_Type bt)
{
switch (bt)
{
case Building.Building_Type.Dwelling:
current_dwelling++;
break;
case Building.Building_Type.Trading_Post:
ui.DisplayRemaining(Building.Building_Type.Dwelling, Get_Remaining_Index(Building.Building_Type.Dwelling));
current_tp++; current_dwelling--;
break;
case Building.Building_Type.Stronghold:
ui.DisplayRemaining(Building.Building_Type.Trading_Post, Get_Remaining_Index(Building.Building_Type.Trading_Post));
current_fortress++; current_tp--;
CheckPoints(PointBonus.Action_Type.BuildT3); //Special point bonus
break;
case Building.Building_Type.Sanctuary:
ui.DisplayRemaining(Building.Building_Type.Trading_Post, Get_Remaining_Index(Building.Building_Type.Trading_Post));
current_temple++; current_tp--;
CheckPoints(PointBonus.Action_Type.BuildT3); //Special point bonus
break;
case Building.Building_Type.Temple:
current_sanctuary++; current_temple--;
ui.DisplayRemaining(Building.Building_Type.Temple, Get_Remaining_Index(Building.Building_Type.Temple));
break;
}
ui.DisplayRemaining(bt, Get_Remaining_Index(bt));
}
//Returns true if you should end turn
bool Build(Building.Building_Type newBuildingType, Tile builtUpon)
{
//Change local player resources
localPlayer.Build(newBuildingType);
localPlayer.AddBuiltCoordinate(builtUpon);
bool endTurn = true;
//Enable favour tile building if
if (localPlayer.CheckWonderTile(global.BuildFlag))
{
networkedUI.PanelInteractivityEnDisable(networkedUI.favourButtons, true);
networkedUI.DisEnableFavourTiles();
favourTileAvailable = true;
endTurn = false;
}
//Enable town tile picking if a city was founded
if (board.JoinTileToTownGroup(builtUpon, newBuildingType, localPlayer))
{
networkedUI.PanelInteractivityEnDisable(networkedUI.townButtons, true);
networkedUI.DisEnableTownTiles();
endTurn = false;
}
return(endTurn);
}
//Building and Terraforming
public bool CheckCanBuild(Building.Building_Type bt)
{
int[] temp = null;
switch (bt)
{
case Building.Building_Type.Dwelling:
temp = faction.Get_cost_build_dwelling(); break;
case Building.Building_Type.Trading_Post:
temp = faction.Get_cost_build_TP(); break;
case Building.Building_Type.Stronghold:
temp = faction.Get_cost_build_stronghold(); break;
case Building.Building_Type.Sanctuary:
temp = faction.Get_cost_build_temple(); break;
case Building.Building_Type.Temple:
temp = faction.Get_cost_build_sanctuary(); break;
}
if (publicPlayerAttributes.PlayerGold - temp[0] >= 0 && publicPlayerAttributes.PlayerWorkers - temp[1] >= 0)
{
return(true);
}
return(false);
}
public void Display_Remaining(Building.Building_Type bt_, int building_index_)
{
remaining_buildings[(int)bt_].transform.GetChild(building_index_).gameObject.SetActive(
#pragma warning disable CS0618 // Type or member is obsolete
!remaining_buildings[(int)bt_].transform.GetChild(building_index_).gameObject.active //Set to the opposite of what it is now
#pragma warning restore CS0618 // Type or member is obsolete
);
}
public static Dictionary <Thing_Types, int> GetResourcesNeededToCreate(Building.Building_Type type)
{
Dictionary <Thing_Types, int> buildingMaterialNeeded = new Dictionary <Thing_Types, int>();
if (type == Building_Type.House)
{
buildingMaterialNeeded.Add(Thing_Types.Wood, 50);
}
return(buildingMaterialNeeded);
}
//Only resets locally, prevents turns being executed twice.
public void ResetData()
{
CoordinateX = 0; CoordinateY = 0;
Built = Building.Building_Type.NOTHING;
Terraformed = Terrain.TerrainType.NOTHING;
PickedRoundBonus = RoundBonusManager.RoundBonusType.NOTHING;
ReturnedRoundBonus = RoundBonusManager.RoundBonusType.NOTHING;
FoundedCityBonus = TownFoundingBonusManager.TownTiletype.NOTHING;
CastedSpell = MagicController.SpellType.NOTHING;
Change = ChangeFlag.NOTHING;
}
public void Build(Building.Building_Type bt)
{
switch (bt)
{
case Building.Building_Type.Dwelling:
publicPlayerAttributes.CmdSetGold(publicPlayerAttributes.PlayerGold - faction.Get_cost_build_dwelling()[0]);
publicPlayerAttributes.CmdSetWorkers(publicPlayerAttributes.PlayerWorkers - faction.Get_cost_build_dwelling()[1]);
current_dwelling++;
break;
case Building.Building_Type.Trading_Post:
//First calculate resources and all that
publicPlayerAttributes.CmdSetGold(publicPlayerAttributes.PlayerGold - faction.Get_cost_build_TP()[0]);
publicPlayerAttributes.CmdSetWorkers(publicPlayerAttributes.PlayerWorkers - faction.Get_cost_build_TP()[1]);
//Then update UI to display remaining buildings of the type that increased. So when a player builds a TP they regain a dwelling.
ui.DisplayRemaining(Building.Building_Type.Dwelling, Get_Remaining_Index(Building.Building_Type.Dwelling));
current_tp++; current_dwelling--;
break;
case Building.Building_Type.Stronghold:
publicPlayerAttributes.CmdSetGold(publicPlayerAttributes.PlayerGold - faction.Get_cost_build_stronghold()[0]);
publicPlayerAttributes.CmdSetWorkers(publicPlayerAttributes.PlayerWorkers - faction.Get_cost_build_stronghold()[1]);
ui.DisplayRemaining(Building.Building_Type.Trading_Post, Get_Remaining_Index(Building.Building_Type.Trading_Post));
current_fortress++; current_tp--;
CheckPoints(PointBonus.Action_Type.BuildT3); //Special point bonus
break;
case Building.Building_Type.Temple:
publicPlayerAttributes.CmdSetGold(publicPlayerAttributes.PlayerGold - faction.Get_cost_build_temple()[0]);
publicPlayerAttributes.CmdSetWorkers(publicPlayerAttributes.PlayerWorkers - faction.Get_cost_build_temple()[1]);
ui.DisplayRemaining(Building.Building_Type.Trading_Post, Get_Remaining_Index(Building.Building_Type.Trading_Post));
current_temple++; current_tp--;
break;
case Building.Building_Type.Sanctuary:
publicPlayerAttributes.CmdSetGold(publicPlayerAttributes.PlayerGold - faction.Get_cost_build_sanctuary()[0]);
publicPlayerAttributes.CmdSetWorkers(publicPlayerAttributes.PlayerWorkers - faction.Get_cost_build_sanctuary()[1]);
ui.DisplayRemaining(Building.Building_Type.Temple, Get_Remaining_Index(Building.Building_Type.Temple));
current_sanctuary++; current_temple--;
CheckPoints(PointBonus.Action_Type.BuildT3); //Special point bonus
break;
}
CheckPoints(PointBonus.MapBuildingToAction(bt)); //Check if we gained any points#
ui.UpdatePoints(publicPlayerAttributes.PlayerPoints);
//Finally update UI for building which is losing one of itself
ui.DisplayRemaining(bt, Get_Remaining_Index(bt));
}
//Gives you the remaning number of buildings of given type in the players building pool
int Get_Remaining_Index(Building.Building_Type bt)
{
switch (bt)
{
case Building.Building_Type.Dwelling: return(faction.max_dwelling - current_dwelling);
case Building.Building_Type.Trading_Post: return(faction.max_tp - current_tp);
case Building.Building_Type.Stronghold: return(faction.max_fortress - current_fortress);
case Building.Building_Type.Temple: return(faction.max_temple - current_temple);
case Building.Building_Type.Sanctuary: return(faction.max_sanctuary - current_sanctuary);
}
return(0);
}
//Returns true if this building is a successful upgrade
public void Build(Building.Building_Type bt, Material mat)
{
//Destroy previous building.
if (HasBuilding())
{
Destroy(transform.GetChild(0).GetChild(1).GetChild(0).gameObject);
}
//Build the building
TileBuilding.Build(bt);
//Instantiate new building on the map
GameObject x = Instantiate(buildings[(int)bt], transform.GetChild(0).GetChild(1));
x.transform.Translate(new Vector3(0, 0, 0), Space.World);
x.GetComponentInChildren <Renderer>().material = mat;
}
//Return true if a new town can be founded
public bool JoinTileToTownGroup(Tile builtUpon, Building.Building_Type newBuildingType, Player player)
{
//Need to gather neighbours within range of given tile first. INCLUDING ANY JOINED BY BRIDGES
List <Tile> neighboursAfterBridgesAccountedFor = GetNeighbours(builtUpon.GetCoordinates().GetXY());
if (builtUpon.Bridges.Count > 0) //First check it has bridges
{
foreach (Bridge b in builtUpon.Bridges) //For every bridge cross it and see if it's a friendly owned tile. If it is, add it to the neighbours group.
{
if (b.CrossBridgeFrom(builtUpon).OwnersPlayerID == player.playerID)
{
neighboursAfterBridgesAccountedFor.Add(b.CrossBridgeFrom(builtUpon));
}
}
}
return(tgc.JoinTownGroup(builtUpon, newBuildingType, neighboursAfterBridgesAccountedFor, player));//Since it was just added we can access towngroup straight from the given tile
}
public static BuildingAnimationPiece[] GetPiecesForAnimation(Building.Building_Type type, Transform parentTransform)
{
List <BuildingAnimationPiece> pieces = new List <BuildingAnimationPiece>();
if (type == Building.Building_Type.House)
{
for (int x = 0; x < parentTransform.childCount; x++)
{
for (int y = 0; y < parentTransform.GetChild(x).childCount; y++)
{
Transform pieceTransform = parentTransform.GetChild(x).GetChild(y);
BuildingAnimationPiece piece = new BuildingAnimationPiece(pieceTransform,
pieceTransform.position, pieceTransform.rotation, new Vector3(0, 0, 0));
pieces.Add(piece);
}
}
}
return(pieces.ToArray());
}
//Accessor Methods from here
int GetNoBuildings(Building.Building_Type bt_)
{
switch (bt_)
{
case Building.Building_Type.Dwelling:
return(current_dwelling);
case Building.Building_Type.Trading_Post:
return(current_tp);
case Building.Building_Type.Stronghold:
return(current_fortress);
case Building.Building_Type.Temple:
return(current_temple);
case Building.Building_Type.Sanctuary:
return(current_sanctuary);
}
return(0);
}
public static Building.Building_Type MapActionToBuilding(Action_Type at_)
{
Building.Building_Type bt = Building.Building_Type.NOTHING;
switch (at_)
{
case Action_Type.Have_Dwelling:
bt = Building.Building_Type.Dwelling; break;
case Action_Type.Have_TP:
bt = Building.Building_Type.Trading_Post; break;
case Action_Type.Have_Temple:
bt = Building.Building_Type.Temple; break;
case Action_Type.Have_Sanctuary:
bt = Building.Building_Type.Sanctuary; break;
case Action_Type.Have_Stronghold:
bt = Building.Building_Type.Stronghold; break;
}
return(bt);
}
/* Take the tile that was built upon and all surrounding tiles with townGroups from the same player.
* // Take also the type of building being built, sadly the tile is joined to a group before the building is actually built so this is requried
*/
public bool JoinTownGroup(Tile builtUpon, Building.Building_Type newBuildingType, List <Tile> neighbours, Player player)
{
List <TownGroup> surroundingGroups = GetSurroundingGroups(neighbours, player);
//if (surroundingGroups.Count < 1 && tile_.GetTownGroup() == null) { tile_.GetTownGroup().AddTownProgress(Building.GetBuildingValue);} //If theres no surrounding groups but it is already part of a group (i.e. upgrading an isolated building)
if (surroundingGroups.Count < 1 && builtUpon.GetTownGroup() == null)
{
AddToTownGroup(builtUpon, CreateTownGroup(builtUpon, player));
} //If it's on it's own, just create a new group for it
else if (surroundingGroups.Count == 1)
{
AddToTownGroup(builtUpon, surroundingGroups[0]);
} //If it's surrounded by only a single TownGroup then join the tile to that one
else if (surroundingGroups.Count > 1)
{
AddToTownGroup(builtUpon, MergeTownGroups(surroundingGroups, CreateTownGroup(builtUpon, player)));
} //If surrounded by 2 or more then all townGroups need to be merged into one.
//Now that it's been added to the group, add it's points on
builtUpon.GetTownGroup().AddTownProgress(Building.GetBuildingValue(newBuildingType));
return(CheckNewTown(builtUpon.GetTownGroup())); //Return true or false depending on whether a new town is built or not
}
public void ResetFlag()
{
to_be_built = Building.ParseInt(5);
}
public void DisplayRemaining(Building.Building_Type bt_, int building_index)
{
remainingBuildingUI.Display_Remaining(bt_, building_index);
}
void Cmd_ChangeBuildFlagData(Building.Building_Type newBuilding)
{
Rpc_ChangeBuildFlagData(newBuilding);
}
void Rpc_ChangeBuildFlagData(Building.Building_Type newBuilding)
{
Built = newBuilding;
}
public void SendBuildData(int[] coordinate, Building.Building_Type newBuilding)
{
Cmd_ChangeBuildFlagData(newBuilding);
Cmd_ChangeCoordinateData(coordinate[0], coordinate[1]);
Cmd_SetChangeFlag(ChangeFlag.Build);
}
//Takes a coordinate, type of building and player information and simulates
//the building of given building_type. Also records this to the Board class.
public void SimulateBuild(int[] coordinate, Building.Building_Type typeToBuild, Material playersBuildingMaterial, int playerID)
{
tileMap.GetTile(coordinate).Build(typeToBuild, playersBuildingMaterial);
tileMap.GetTile(coordinate).OwnersPlayerID = playerID;
}
public BuildingAnimation(Building.Building_Type type, Transform parentTransform)
{
this.parentTransform = parentTransform;
this.buildingType = type;
pieces = BuildingAnimationPiece.GetPiecesForAnimation(type, parentTransform);
}
public void Set_Building_Flag(int flag_)
{
ResetFlags();
build_flag = (Building.Building_Type)flag_;
}
void Awake()
{
to_be_built = Building.Building_Type.NOTHING;
}
public bool CheckWonderTile(Building.Building_Type bt)
{
return(Building.Equals(bt, Building.Building_Type.Sanctuary) || Building.Equals(bt, Building.Building_Type.Temple));
}
