void OnEnable()
{
if (gameManager.getBuildingCatalog().getBuildingLastClicked() != null)
{
buildingAttributes = gameManager.getBuildingCatalog().getBuildingLastClicked().GetComponent <BuildingAttributes>();
}
}
public void addProductionBuildingToTown(BuildingAttributes building)
{
if (!productionBuildingsInTown.Contains(building))
{
productionBuildingsInTown.Add(building);
}
}
public void ChangeThePrice(BuildingAttributes building, GameObject newItem = null)
{
if (buildingUIGameObject.ContainsKey(building.buildingType))
{
newItem = buildingUIGameObject[building.buildingType];
}
foreach (Transform child in newItem.transform.Find("Grid"))
{
child.gameObject.SetActive(false);
}
newItem.GetComponent <BuildingShopItem>().ChangePriceForBuilding(building.initialBuildingPrice.supplyPrices, building.buildingInhancements[0].coefficientIncreasingPrice);
int counterOfPrices = 0;
foreach (Price price in building.initialBuildingPrice.supplyPrices)
{
if (price.startingLevel <= GameManager.Instance.GetAmountOfBuildingsOfType(building.buildingType))
{
GameObject supplyUI = newItem.transform.Find("Grid").GetChild(counterOfPrices).gameObject;
supplyUI.SetActive(true);
supplyUI.transform.Find("Image").GetComponent <Image>().sprite = GameManager.Instance.FindSupplyAttributeBySupplyType(price.supplyType).icon;
Quantity quantityToDisplay = new Quantity(price.amount, price.quantityType);
quantityToDisplay.MultiplyCurrentValueByConstant(((GameManager.Instance.GetAmountOfBuildingsOfType(building.buildingType) * building.buildingInhancements[0].coefficientIncreasingPrice) + 1));
supplyUI.transform.Find("Price").GetComponent <TMP_Text>().text = quantityToDisplay.GetAmountToDisplay().ToString() + GameManager.Instance.QuantityTypes[quantityToDisplay.GetQuantityToDisplay()];
counterOfPrices++;
}
}
}
public bool notifyWhenStorageBuildingWithFreeSpaceChange(string itemName, int amount)
{
// IF CHANGING FROM SOMETHING TO NULL
if (closestStorageBuildingWithFreeSpace != null && townAlliegence.getClosestStoragetBuildingWithFreeSpace(this.transform.position, itemName, amount) == null)
{
//Debug.Log("closest storage building with freespace went from something to null");
closestStorageBuildingWithFreeSpace = null;
return(true);
}
// IF CHANGING FROM NULL TO SOMETHING
if (townAlliegence)
{
if (closestStorageBuildingWithFreeSpace == null && townAlliegence.getClosestStoragetBuildingWithFreeSpace(this.transform.position, itemName, amount) != null)
{
//Debug.Log("closest storage building with freespace went from null to something");
closestStorageBuildingWithFreeSpace = townAlliegence.getClosestStoragetBuildingWithFreeSpace(this.transform.position, itemName, amount);
return(true);
}
}
// IF CHANGE TO NEW BUILDING
if (closestStorageBuildingWithFreeSpace && townAlliegence.getClosestStoragetBuildingWithFreeSpace(this.transform.position, itemName, amount))
{
if (!closestStorageBuildingWithFreeSpace.Equals(townAlliegence.getClosestStoragetBuildingWithFreeSpace(this.transform.position, itemName, amount)))
{
//Debug.Log("Closest storage building with freespace changed from something to other");
closestStorageBuildingWithFreeSpace = townAlliegence.getClosestStoragetBuildingWithFreeSpace(this.transform.position, itemName, amount);
return(true);
}
}
return(false);
}
public void addResidentialBuildingToTown(BuildingAttributes building)
{
if (!residentialBuildingsInTown.Contains(building))
{
residentialBuildingsInTown.Add(building);
}
}
public void addBuildingToTown(BuildingAttributes building)
{
if (!buildingsInTown.Contains(building))
{
buildingsInTown.Add(building);
}
}
public void addBoardingHouseToTown(BuildingAttributes building)
{
if (!boardingHousesInTown.Contains(building))
{
boardingHousesInTown.Add(building);
}
}
public IEnumerator goToBuildingCourentine(BuildingAttributes building)
{
if (building != null)
{
isMovingToBuilding = true;
movedToBuilding = false;
Vector3 buildingPosition = new Vector3(building.getPositionX(), building.getPositionY(), building.getPositionZ());
if (playerInsideBuilding == true)
{
leaveBuilding();
}
agent.SetDestination(buildingPosition);
while (isMovingToBuilding)
{
if (agent.hasPath)
{
if (agent.remainingDistance <= 0.6)
{
movedToBuilding = true;
agent.ResetPath();
goInsideBuilding(building);
break;
}
}
yield return(null);
}
isMovingToBuilding = false;
}
}
public void addStorageBuildingToTown(BuildingAttributes building)
{
if (!storageBuildingsInTown.Contains(building))
{
storageBuildingsInTown.Add(building);
}
}
public bool notifyWhenStorageBuildingChange(Dictionary <string, int> listOfItems)
{
// IF CHANGING FROM SOMETHING TO NULL
if (closestStorageBuilding != null && townAlliegence.getClosestStorageBuildingWithListOfItems(this.transform.position, listOfItems) == null)
{
//Debug.Log("closest storage building went from something to null");
closestStorageBuilding = null;
return(true);
}
// IF CHANGING FROM NULL TO SOMETHING
if (townAlliegence)
{
if (closestStorageBuilding == null && townAlliegence.getClosestStorageBuildingWithListOfItems(this.transform.position, listOfItems) != null)
{
//Debug.Log("closest storage building went from null to something");
closestStorageBuilding = townAlliegence.getClosestStorageBuildingWithListOfItems(this.transform.position, listOfItems);
return(true);
}
}
// IF CHANGE TO NEW BUILDING
if (closestStorageBuilding && townAlliegence.getClosestStorageBuildingWithListOfItems(this.transform.position, listOfItems))
{
if (!closestStorageBuilding.Equals(townAlliegence.getClosestStorageBuildingWithListOfItems(this.transform.position, listOfItems)))
{
//Debug.Log("Closest storage building changed from something to other");
closestStorageBuilding = townAlliegence.getClosestStorageBuildingWithListOfItems(this.transform.position, listOfItems);
return(true);
}
}
return(false);
}
// Start is called before the first frame update
void Start()
{
buildingAttributes = GetComponent <BuildingAttributes>();
terrainGeneration = TerrainGeneration.instance;
gameManager = GameManager.instance;
x = (int)(transform.position.x + 0.5);
y = (int)(transform.position.z + 0.5);
}
public BuildingAttributes GetNewBuildingAttributes(List<Building> buildings) {
BuildingAttributes buildingAttributes = new BuildingAttributes();
buildingAttributes.quad = GetNewBuildingQuad(buildings);
buildingAttributes.color = GetNewBuildingColor();
buildingAttributes.sortingOrder = GetSortingOrder(buildingAttributes.quad, buildings);
return buildingAttributes;
}
public void SetBuilding(Building b)
{
var selectedObject = new BuildingAttributes();
selectedObject.SetCurrentBuilding(b, this);
this.DataContext = selectedObject;
_propertyGrid.Update();
}
public void goInsideBuilding(BuildingAttributes building)
{
//Debug.Log("went inside building");
setBuildingIsInsideOf(building);
building.addCitizenToInsideBuilding(this);
transform.GetChild(0).gameObject.SetActive(false);
isInsideBuilding = true;
}
public void goInsideBuilding(BuildingAttributes building)
{
setBuildingIsInsideOf(building);
building.setPlayerEnteredBuilding(true);
gameManager.GetUI().buildingOpen();
hideBody(true);
setMovementDisabled(true);
playerInsideBuilding = true;
}
private void CreateBuilding(BuildingAttributes buildingAttributes) {
Building building = buildingPrefab.Spawn();
building.transform.parent = transform;
building.SetBuildingAttributes(buildingAttributes);
buildings.Add(building);
if (SignalCreatedBuilding != null) SignalCreatedBuilding(building);
if (buildings.Count == 1) {
if (SignalCreatedFirstBuilding != null) SignalCreatedFirstBuilding(building);
}
}
public BuildingInfo()
{
_Meta = new BuildingMeta();
_Meta._PrefabName = "Prefab Name";
_Meta._BuildingType = eBuildingType.FERTILITY;
_Attributes = new BuildingAttributes();
_Attributes._TimeRequiredInBuilding = 0.0f;
_Attributes._Capacity = 0;
}
public void updateWorkersInBuildingList()
{
gameManager = GameObject.FindGameObjectWithTag("GameManager").GetComponent <GameManager>();
if (gameManager.getBuildingCatalog().getBuildingLastClicked() != null)
{
buildingAttributes = gameManager.getBuildingCatalog().getBuildingLastClicked().GetComponent <BuildingAttributes>();
}
foreach (Transform child in transform)
{
Destroy(child.gameObject);
}
if (buildingAttributes)
{
// SHOWING PLAYER IF INSIDE BUILDING
if (buildingAttributes.getPlayerEnteredBuilding())
{
GameObject newButton = Instantiate(citizenButton, transform);
newButton.GetComponentInChildren <Text>().text = gameManager.getPlayerBehavior().getPlayerFirstName() + " " + gameManager.getPlayerBehavior().getPlayerLastName();
newButton.GetComponent <WorkersButton>().setCitizenID(9999);
Button button = newButton.GetComponent <Button>();
ColorBlock block = button.colors;
block.normalColor = Color.yellow; //new Color(159, 12, 255);
button.colors = block;
}
// SHOWING CITIZENS
foreach (Citizen citizen in buildingAttributes.getWorkersInBuilding())
{
GameObject newButton = Instantiate(citizenButton, transform);
newButton.GetComponentInChildren <Text>().text = citizen.getFirstName() + " " + citizen.getLastName();
newButton.GetComponent <WorkersButton>().setCitizenID(citizen.getCitizenID());
if (gameManager.getCitizenCatalog().getSelectedCitizen())
{
if (citizen.getCitizenID() == gameManager.getCitizenCatalog().getSelectedCitizen().getCitizenID())
{
Button button = newButton.GetComponent <Button>();
ColorBlock block = button.colors;
block.normalColor = Color.green; //new Color(159, 12, 255);
button.colors = block;
}
else
{
Button button = newButton.GetComponent <Button>();
ColorBlock block = button.colors;
block.normalColor = new Color(255, 255, 255);
button.colors = block;
}
}
}
}
}
public bool checkIfBuildingIsInsideTown(BuildingAttributes building)
{
foreach (BuildingAttributes buildings in buildingsInTown)
{
if (buildings.Equals(building))
{
return(true);
}
}
return(false);
}
public IEnumerator putItemInBuilding(Dictionary <string, int> listOfItems, BuildingAttributes targetBuilding)
{
if (!movingItemToBuilding)
{
movingItemToBuilding = true;
//Debug.Log("started put item in building");
while (movingItemToBuilding)
{
if (notifyWhenTargetBuildingReached(targetBuilding))
{
//Debug.Log("reched targetbuilding with lsit of items");
foreach (var item in listOfItems)
{
putItemInBuildingInventory(targetBuilding, item.Key, item.Value);
//Debug.Log("item transferred from building to citizen");
}
yield return(new WaitForSeconds(2));
break;
}
else
{
if (targetBuilding != null)
{
StartCoroutine(goToBuildingCourentine = goToBuilding(targetBuilding));
}
else
{
//Debug.Log("targetbuilding not found");
break;
}
}
foreach (var item in listOfItems)
{
notifyWhenStorageBuildingWithFreeSpaceChange(item.Key, item.Value);
if (notifyWhenStorageBuildingWithFreeSpaceChange(item.Key, item.Value))
{
targetBuilding = closestStorageBuildingWithFreeSpace;
stopMovement();
}
if (targetBuilding == null)
{
break;
}
}
yield return(null);
}
StopCoroutine(goToBuildingCourentine);
stopMovement();
movingItemToBuilding = false;
}
}
public bool notifyWhenTargetBuildingReached(BuildingAttributes targetBuilding)
{
if (buildingInsideOf)
{
if (buildingInsideOf.Equals(targetBuilding))
{
return(true);
}
}
return(false);
}
private void SetAttributes(GameObject newItem, BuildingAttributes building)
{
//newItem.transform.parent = parentOfShop;
//newItem.transform.SetParent(parentOfShop);
newItem.GetComponent <BuildingShopItem>().BuildingType = building.buildingType;
newItem.transform.Find("Image").GetComponent <Image>().sprite = building.icon;
newItem.transform.Find("Title").GetComponent <TMP_Text>().text = building.name;
ChangeThePrice(building, newItem);
}
public IEnumerator getItemFromBuilding(Dictionary <string, int> listOfItems, BuildingAttributes targetBuilding)
{
if (work)
{
if (work.getItemCurrentlyProduced() != null && !gatheringItemFromBuilding)
{
gatheringItemFromBuilding = true;
//Debug.Log("started get item from building");
while (gatheringItemFromBuilding)
{
if (notifyWhenTargetBuildingReached(targetBuilding))
{
//Debug.Log("reched targetbuilding with lsit of items");
foreach (var item in listOfItems)
{
getItemFromBuildingInventory(targetBuilding, item.Key, item.Value);
//Debug.Log("item transferred from building to citizen");
}
yield return(new WaitForSeconds(2));
break;
}
else
{
if (targetBuilding != null)
{
StartCoroutine(goToBuildingCourentine = goToBuilding(targetBuilding));
}
else
{
//Debug.Log("targetbuilding not found");
break;
}
}
if (notifyWhenStorageBuildingChange(listOfItems))
{
//Debug.Log("storage building changed");
targetBuilding = closestStorageBuilding;
if (targetBuilding == null)
{
break;
}
}
yield return(null);
}
StopCoroutine(goToBuildingCourentine);
stopMovement();
gatheringItemFromBuilding = false;
}
}
}
public bool getItemFromBuildingInventory(BuildingAttributes targetBuilding, string itemName, int amount)
{
bool result = false;
if (buildingInsideOf)
{
result = targetBuilding.getBuildingAttributes().getBuildingInventory().sendItemFromThisToOther(getCitizenInventory(), itemName, amount);
}
else
{
gameManager.getMessageLogText().addMessageToLog("Citizen is not inside a building");
}
return(result);
}
public IEnumerator goToBuilding(BuildingAttributes building)
{
if (building != null)
{
if (!isMovingToBuilding)
{
isMovingToBuilding = true;
movedToBuilding = false;
//Debug.Log("goToBuilding har started");
Vector3 buildingPosition = new Vector3(building.getPositionX(), building.getPositionY(), building.getPositionZ());
if (isInsideBuilding == true)
{
leaveBuilding();
}
citizenAgent.SetDestination(buildingPosition);
while (isMovingToBuilding)
{
if (citizenAgent.hasPath)
{
if (citizenAgent.remainingDistance <= 0.6 && !movedToBuilding)
{
movedToBuilding = true;
goInsideBuilding(building);
//Debug.Log("reached destination");
citizenAgent.ResetPath();
break;
}
}
yield return(null);
}
isMovingToBuilding = false;
}
}
else
{
if (isInsideBuilding == true)
{
leaveBuilding();
}
if (townCurrentlyInsideOf)
{
citizenAgent.SetDestination(new Vector3(townCurrentlyInsideOf.getTownCenter().x + Random.Range(-8.0f, 8.0f), 0, townCurrentlyInsideOf.getTownCenter().z + Random.Range(-8.0f, 8.0f)));
}
}
}
public virtual void Initialize()
{
ResourceTable = new List <Resource>();
Root = new ResourceSet <Resource>("Root", null);
modifierInfos = new ModifierInfos();
modifierInfos.Load(modifiersFile);
Attributes = new Database.Attributes(Root);
BuildingAttributes = new BuildingAttributes(Root);
CritterAttributes = new CritterAttributes(Root);
effects = new ResourceSet <Effect>("Effects", Root);
traits = new TraitSet();
traitGroups = new TraitGroupSet();
FertilityModifiers = new FertilityModifiers();
Amounts = new Database.Amounts();
Amounts.Load();
AttributeConverters = new Database.AttributeConverters();
LoadEffects();
LoadFertilityModifiers();
}
public void updateItemsThatCanBeProducedList()
{
if (gameManager.getBuildingCatalog().getBuildingLastClicked())
{
buildingAttributes = gameManager.getBuildingCatalog().getBuildingLastClicked().GetComponent <BuildingAttributes>();
}
foreach (Transform child in transform)
{
Destroy(child.gameObject);
}
if (buildingAttributes)
{
foreach (var item in buildingAttributes.getItemsProducedInBuilding())
{
GameObject newButton = Instantiate(itemButton, transform);
newButton.GetComponentInChildren <Text>().text = item.Key;
newButton.GetComponent <SelectItemButton>().setItem(item.Key);
if (gameManager.getItemCatalog().getSelectedItem() != null)
{
if (gameManager.getItemCatalog().getSelectedItem().getName() == item.Key)
{
Button button = newButton.GetComponent <Button>();
ColorBlock block = button.colors;
block.normalColor = Color.green; //new Color(159, 12, 255);
button.colors = block;
}
else
{
Button button = newButton.GetComponent <Button>();
ColorBlock block = button.colors;
block.normalColor = new Color(255, 255, 255);
button.colors = block;
}
}
}
}
}
private void SetInhancementsOfPanel(Transform buildingPanel, BuildingType buildingType, ResourceCreatingBuilding thisBuilding)
{
Transform inhancementsSet = buildingPanel.transform.Find("LeftPanel").GetChild(0).GetChild(0);
BuildingAttributes buildingAttributes = GameManager.Instance.FindBuildingAttributeByBuilidingType(buildingType);
for (int i = 0; i < buildingAttributes.buildingInhancements.Count; i++)
{
Transform currentInhancement = inhancementsSet.GetChild(i);
currentInhancement.Find("Title").GetComponent <TMP_Text>().text = GameManager.Instance.NamesOfInhancementsInSupplyCollectingInhancements[i];
currentInhancement.GetComponent <BuildingInhancementInPanelButton>().SetBuildingAssignedToThisInhancement(thisBuilding);
//currentInhancement.GetComponent<BuildingInhancementInPanelButton>().UpdateInhancementAttributes();
for (int j = 0; j < buildingAttributes.buildingInhancements[i].supplyPrices.Count; j++)
{
if (buildingAttributes.buildingInhancements[i].supplyPrices[j].startingLevel <= thisBuilding.CurrentLevelOfSupplyQuantityOverClick)
{
Transform supply = inhancementsSet.GetChild(i).Find("Grid").GetChild(j);
Debug.Log("Supply " + supply);
supply.gameObject.SetActive(true);
SupplyAttributes attributes = GameManager.Instance.FindSupplyAttributeBySupplyType(buildingAttributes.buildingInhancements[i].supplyPrices[j].supplyType);
supply.Find("Image").GetComponent <Image>().sprite = attributes.icon;
/*
* Quantity quantityToDisplay = new Quantity(buildingAttributes.buildingInhancements[i].supplyPrices[j].amount, buildingAttributes.buildingInhancements[i].supplyPrices[j].quantityType);
* quantityToDisplay.MultiplyCurrentValueByConstant(((1 + (buildingAttributes.buildingInhancements[i].coefficientIncreasingPrice * thisBuilding.GetLevelOfInhancement(i)))));
*
* supply.Find("Price").GetComponent<TMP_Text>().text = quantityToDisplay.GetAmountToDisplay().ToString() + GameManager.Instance.QuantityTypes[quantityToDisplay.GetQuantityToDisplay()];
*/
}
}
}
}
public BuildingAttributes instantiateBuilding()
{
if (currentlyCraftedBuilding.GetComponentInChildren <MeshCollider>())
{
currentlyCraftedBuilding.GetComponentInChildren <MeshCollider>().isTrigger = false;
}
else if (!currentlyCraftedBuilding.GetComponentInChildren <MeshCollider>())
{
currentlyCraftedBuilding.GetComponentInChildren <BoxCollider>().isTrigger = false;
}
BuildingAttributes buildingAttributes = currentlyCraftedBuilding.GetComponent <BuildingAttributes>();
// STORAGE CAPACITY
if (buildingAttributes.gameObject.GetComponent <Inventory>())
{
buildingAttributes.GetComponent <Inventory>().setInventoryCapacity(buildingAttributes.getStorageCapacity());
buildingAttributes.gameObject.GetComponent <Inventory>().instatiateInventory();
}
// PLAYER OWNED
buildingAttributes.setIsOwnedByPlayer(true);
// TOWN BUILDING IS A PART OF
buildingAttributes.setTownBuildingIsApartOf(gameManager.GetUI().getPlayerOwnedSelectedTown());
// POSITION
if (buildingAttributes.gameObject.GetComponent <BoxCollider>())
{
buildingAttributes.setPositionX(currentlyCraftedBuilding.transform.GetComponent <BoxCollider>().bounds.center.x);
buildingAttributes.setPositionY(currentlyCraftedBuilding.transform.GetComponent <BoxCollider>().bounds.center.y);
buildingAttributes.setPositionZ(currentlyCraftedBuilding.transform.GetComponent <BoxCollider>().bounds.center.z);
}
else
{
buildingAttributes.setPositionX(buildingAttributes.transform.position.x);
buildingAttributes.setPositionY(buildingAttributes.transform.position.y);
buildingAttributes.setPositionZ(buildingAttributes.transform.position.z);
}
// TAGS AND LAYERS
currentlyCraftedBuilding.tag = craftingSavedTag;
buildingAttributes.setBuildingTag(craftingSavedTag);
currentlyCraftedBuilding.layer = LayerMask.NameToLayer(craftingSavedLayer);
// ADD BUILDING TO TOWN, ACTIVATE ONTRIGGER FOR TOWN
currentlyCraftedBuilding.SetActive(false);
currentlyCraftedBuilding.SetActive(true);
foreach (var item in itemsToRemoveFromInventory)
{
gameManager.getInventoryCatalog().getMainInventory().removeItemFromInventory(item.Key, item.Value);
}
currentlyCraftedBuilding = null;
foreach (Town town in gameManager.getPlayerBehavior().getTownsOwned())
{
town.townIndicator(false);
}
//gameManager.GetUI().getPlayerOwnedSelectedTown().townIndicator(false);
setIsCrafting(false);
buildingAttributes.transform.gameObject.SetActive(false);
buildingAttributes.buildingIndicatorOff();
return(buildingAttributes);
}
public void instantiateUnfinishedBuilding(BuildingAttributes building)
{
unfinishedBuilding.GetComponent <UnfinishedBuilding>().setBuilding(building);
Instantiate(unfinishedBuilding, building.transform.position, building.transform.rotation);
}
public void InitMesh(BuildingAttributes buildingAttributes) {
CreateBuilding(buildingAttributes.quad);
ApplyToMesh();
}
public void removeStorageBuildingFromTown(BuildingAttributes building)
{
storageBuildingsInTown.Remove(building);
}
public void SetBuildingAttributes(BuildingAttributes newAttributes) {
_attributes = newAttributes;
buildingMeshCreator.InitMesh(_attributes);
meshRenderer.material.color = _attributes.color;
meshRenderer.sortingOrder = newAttributes.sortingOrder;
}
public void removeResidentialBuildingFromTown(BuildingAttributes building)
{
residentialBuildingsInTown.Remove(building);
}
