private void SetupRepairButton(AbstractBuildingTile tile, AbstractMarketManager manager)
{
int price = tile.Building.Data.RepairCost;
BuildingHealth buildingHealth = tile.Building.GetComponent <BuildingHealth>();
float percentage = buildingHealth.CurrentBuildingHealthPercentage;
price = (int)((1 - percentage) * price);
repairText.text = price.ToString();
if (!CanAffort(price))
{
BlockButton(btnRepair);
return;
}
UnblockButton(btnRepair);
SetButton(btnRepair, OnClick);
void OnClick()
{
ReduceMoney(price);
buildingHealth.ResetBuildingHealth();
manager.CloseMarket();
}
}
private void SetupDemolishButton(AbstractBuildingTile tile, AbstractMarketManager manager)
{
int price = tile.GetCurrentFoundationData().DestructionCost;
demolishText.text = price.ToString();
if (!CanAffort(price) || tile.HasBuilding)
{
BlockButton(btnDemolish, true);
return;
}
BlockButton(btnDemolish, false);
SetButton(btnDemolish, OnClick);
void OnClick()
{
confirmDemolishPopup.ShowPopUp(OnConfirmDemolish);
}
void OnConfirmDemolish()
{
ReduceMoney(price);
tile.RemoveFoundation();
manager.CloseMarket();
}
}
protected override void SetupScreen(AbstractBuildingTile tile, AbstractMarketManager manager)
{
if (tile.HasDebris) // Tile has debris
{
SetBars(null);
HasDebris(tile, manager);
return;
}
if (tile.HasBuilding) // Tile has building, foundation and soil
{
SetBars(tile);
HasBuilding(tile, manager);
return;
}
// Healthbars only matter in case of a building
SetBars(null);
if (tile.HasFoundation) // Tile has foundation and soil
{
HasFoundation(tile, manager);
return;
}
if (tile.HasSoil) // Tile has soil
{
HasSoil(tile, manager);
return;
}
// The tile is empty
HandleEmpty(tile, manager);
}
private void SetText(KeyValuePair <BuildingType, BuyButtonData> buttonData, AbstractBuildingTile tile)
{
BuildingData[] data = tile.GetBuildingData(buttonData.Key);
// Type
if (typeTextWriter == null)
{
typeTextWriter = new StringVariableWriter(buttonData.Value.Text.Type.text);
}
string type = LanguageUtil.GetJsonString(buttonData.Key.ToString().ToUpper());
buttonData.Value.Text.Type.text = typeTextWriter.UpdateText(type);
// Price
buttonData.Value.Text.Price.text = string.Format(GetString(priceKey), data[0].Price);
// Health
buttonData.Value.Text.Health.text = string.Format(GetString(healthKey), data[0].MaxHealth);
// Rent
float rentPerMinute = 60.0f / data[0].SecondsPerRent;
float rentcollectionsPerHour = rentPerMinute * 60.0f;
buttonData.Value.Text.Rent.text = string.Format(GetString(rentKey), data[0].Rent * rentcollectionsPerHour);
// Upgrades
buttonData.Value.Text.Upgrades.text = string.Format(GetString(upgradeKey), data.Length);
}
private void SetupDemolishButton(AbstractBuildingTile tile, AbstractMarketManager manager)
{
int price = tile.Building.Data.DestructionCost;
demolishText.text = price.ToString();
if (!CanAffort(price))
{
BlockButton(btnDemolish);
return;
}
UnblockButton(btnDemolish);
SetButton(btnDemolish, OnClick);
void OnClick()
{
confirmDemolishPopup.ShowPopUp(OnConfirmDemolish);
}
void OnConfirmDemolish()
{
tile.Building.RemoveBuilding();
tile.SpawnSoil();
tile.SpawnFoundation();
manager.CloseMarket();
}
}
private void HasDebris(AbstractBuildingTile tile, AbstractMarketManager manager)
{
BlockButtons(true, true, true);
screenData.HasDebris = true;
SetText("Blocked by Debris!", "Blocked by Debris!", "Blocked by Debris!");
}
protected override void ActivateExtension(AbstractBuildingTile tile, AbstractMarketManager manager)
{
SerializableEnumDictionary <BuildingType, BuyButtonData> buildingButtons = GetComponent <BuildingBuyScreen>().GetbuyButtonData();
foreach (KeyValuePair <BuildingType, BuyButtonData> buttonData in buildingButtons)
{
SetText(buttonData, tile);
}
}
protected override void SetupMarket(OpenMarketEvent openEvent)
{
tile = openEvent.BuildingTile;
if (!tile)
{
tile = openEvent.Building.GetComponentInParent <AbstractBuildingTile>();
}
}
private void HandleEmpty(AbstractBuildingTile tile, AbstractMarketManager manager)
{
BlockButtons(true, true, false);
SetButton(soilButton, () => manager.PutScreenInFocus(manager.Screens.SoilBuyScreen));
screenData.SetBuildingFoundationSoil(false, false, false);
SetText("NoBuilding!", "NoFoundation!", "NoSoil!");
}
private void HasSoil(AbstractBuildingTile tile, AbstractMarketManager manager)
{
BlockButtons(true, false, false);
SetButton(foundationButton, () => manager.PutScreenInFocus(manager.Screens.FoundationBuyScreen));
SetButton(soilButton, () => manager.PutScreenInFocus(manager.Screens.SoilManageScreen));
screenData.SetBuildingFoundationSoil(false, false, true);
SetText("NoBuilding!", "NoFoundation!", tile.GetSoilType().ToString());
}
private void HasBuilding(AbstractBuildingTile tile, AbstractMarketManager manager)
{
BlockButtons(false, false, false);
SetButton(buildingButton, () => manager.PutScreenInFocus(manager.Screens.BuildingManageScreen));
SetButton(foundationButton, () => manager.PutScreenInFocus(manager.Screens.FoundationManageScreen));
SetButton(soilButton, () => manager.PutScreenInFocus(manager.Screens.SoilManageScreen));
screenData.SetBuildingFoundationSoil(true, true, true);
SetText(tile.Building.BuildingType.ToString(), tile.GetFoundationType().ToString(), tile.GetSoilType().ToString());
}
private void OnSelectedBuilding(SelectedBuildingTileEvent selectedBuildingEvent)
{
AbstractBuildingTile tile = selectedBuildingEvent.Tile;
if (tile == null || !tile.HasDebris)
{
return;
}
transform.GetChild(0).gameObject.SetActive(true);
SetButton(tile);
}
protected override void ActivateExtension(AbstractBuildingTile tile, AbstractMarketManager manager)
{
SetSpriteToCurrent(currentBuildingSprite, tile.Building);
BuildingUpgrade buildingUpgrade = tile.Building.GetComponent <BuildingUpgrade>();
if (buildingUpgrade.CanUpgrade())
{
SetSpriteToNext(nextBuildingSprite, tile.Building);
return;
}
SetSpriteToCurrent(nextBuildingSprite, tile.Building);
}
private void SelectBuilding(Material selectMaterial)
{
AbstractBuildingTile buildingTile = (AbstractBuildingTile)tile;
// In case of no soil, a building or debris we just select the tile itself
if (buildingTile.HasBuilding || buildingTile.HasDebris || !buildingTile.HasSoil)
{
SelectObject(CachedGameObject, selectMaterial);
return;
}
// In case of soil or foundation, select the soil object
SelectObject(buildingTile.Soil, selectMaterial);
}
protected override void SetupScreen(AbstractBuildingTile tile, AbstractMarketManager manager)
{
if (tile.HasBuilding)
{
BlockButton(btnRepair, false);
SetupRepairButton(tile, manager);
}
else
{
BlockButton(btnRepair, true);
}
SetupDemolishButton(tile, manager);
}
private void SetSprites(AbstractBuildingTile tile, MainScreenData screenData)
{
if (screenData.HasDebris)
{
foreach (KeyValuePair <SpriteType, Image> pair in images)
{
if (pair.Key == SpriteType.BuildingTile)
{
SetSprite(pair.Key, brokenBuildingSprites[screenData.BuildingType][tile.DestroyedBuildingTier]);
}
SetSprite(pair.Key, blockedSprites[pair.Key]);
}
return;
}
if (screenData.HasBuilding)
{
SetSprite(SpriteType.Building, buildingSprites[screenData.BuildingType][tile.Building.CurrentTier]);
SetSprite(SpriteType.BuildingTile, buildingTileSprite);
SetSprite(SpriteType.Foundation, foundationSprites[screenData.FoundationType]);
SetSprite(SpriteType.Soil, soilSprites[screenData.SoilType]);
return;
}
if (screenData.HasFoundation)
{
SetSprite(SpriteType.Building, emptySprites[SpriteType.Building]);
SetSprite(SpriteType.BuildingTile, emptySprites[SpriteType.BuildingTile]);
SetSprite(SpriteType.Foundation, foundationSprites[screenData.FoundationType]);
SetSprite(SpriteType.Soil, soilSprites[screenData.SoilType]);
return;
}
if (screenData.HasSoil)
{
SetSprite(SpriteType.Building, blockedSprites[SpriteType.Building]);
SetSprite(SpriteType.BuildingTile, blockedSprites[SpriteType.BuildingTile]);
SetSprite(SpriteType.Foundation, emptySprites[SpriteType.Foundation]);
SetSprite(SpriteType.Soil, soilSprites[screenData.SoilType]);
return;
}
foreach (KeyValuePair <SpriteType, Image> pair in images)
{
SetSprite(pair.Key, blockedSprites[pair.Key]);
}
}
private void SetTierText(AbstractBuildingTile tile, BuildingUpgrade buildingUpgrade)
{
currentTierHealth.text = ((int)tile.Building.Data.MaxHealth).ToString();
currentTierRent.text = tile.Building.Data.Rent.ToString();
if (buildingUpgrade.CanUpgrade())
{
nextTierHealth.text = ((int)tile.Building.NextTierData.MaxHealth).ToString();
nextTierRent.text = tile.Building.NextTierData.Rent.ToString();
return;
}
nextTierHealth.text = currentTierHealth.text;
nextTierRent.text = currentTierRent.text;
}
private void OnSelectedBuilding(SelectedBuildingTileEvent selectedBuildingEvent)
{
AbstractBuildingTile tile = selectedBuildingEvent.Tile;
if (tile == null || tile.HasDebris)
{
SetActive(false);
return;
}
selectedTile = tile;
buildingHealth = tile.Building.GetComponent <BuildingHealth>();
SetActive(true);
SetButtons();
}
private void Update()
{
if (!child.activeSelf)
{
return;
}
if (selectedTile && selectedTile.HasDebris)
{
selectedTile = null;
buildingHealth = null;
SetActive(false);
return;
}
SetBars();
SetButtons();
}
private void SetBars(AbstractBuildingTile tile)
{
bool active = tile != null;
buildingHealthBar.CachedGameObject.SetActive(active);
foundationHealthBar.CachedGameObject.SetActive(active);
soilHealthBar.CachedGameObject.SetActive(active);
if (!active)
{
return;
}
BuildingHealth health = tile.Building.GetComponent <BuildingHealth>();
health.SetBuildingHealthBar(buildingHealthBar);
health.SetFoundationHealthBar(foundationHealthBar);
health.SetSoilHealthBar(soilHealthBar);
}
private void SetText(KeyValuePair <SoilType, BuyButtonData> buttonData, AbstractBuildingTile tile)
{
SoilTypeData data = tile.GetSoilData(buttonData.Key);
// Type
if (typeTextWriter == null)
{
typeTextWriter = new StringVariableWriter(buttonData.Value.Text.Type.text);
}
string type = LanguageUtil.GetJsonString(buttonData.Key.ToString().ToUpper());
buttonData.Value.Text.Type.text = typeTextWriter.UpdateText(type);
// Price
buttonData.Value.Text.Price.text = string.Format(GetString(priceKey), data.BuildCost);
// Health
buttonData.Value.Text.Health.text = string.Format(GetString(healthKey), data.MaxHealth);
}
private void Select(AbstractBuildingTile tile, SerializableKeyValuePair <TBuyType, BuyButtonData> pair, AbstractMarketManager manager)
{
// if we select the selected button, don't do anything
if (selectedButtonDatum != null && selectedButtonDatum.Value.Equals(pair))
{
return;
}
BuyButtonData buyButtondatum = pair.Value;
SetTextActive(buyButtondatum, true);
btnBuy.transform.position = buyButtondatum.Button.transform.position;
OnSelectBuyButton(tile, pair.Key);
Deselect(selectedButtonDatum);
selectedButtonDatum = pair;
SetupBuyButton(tile, manager);
}
private void SetupBuyButton(AbstractBuildingTile tile, AbstractMarketManager manager)
{
int price = GetPrice(tile);
if (!CanAffort(price))
{
BlockButton(btnBuy, true);
return;
}
BlockButton(btnBuy, false);
SetButton(btnBuy, OnClick);
void OnClick()
{
ReduceMoney(price);
BuyButtonClick(tile, manager);
}
}
public override void StartTutorial(GameObject arrow, TutorialManager manager)
{
base.StartTutorial(arrow, manager);
Building building = FindObjectOfType <Building>();
AbstractBuildingTile abstractBuildingTile = building.GetComponentInParent <AbstractBuildingTile>();
meshRenderer = abstractBuildingTile.GetComponent <Renderer>();
Canvas buildingCanvas = building.GetComponentInChildren <Canvas>();
oldMaterial = meshRenderer.sharedMaterial;
prefabInstance = Instantiate(arrow, buildingCanvas.transform);
prefabInstance.transform.localScale = new Vector3(scale, scale, scale);
prefabInstance.transform.Translate(Vector3.up * offsetDistance, Space.Self);
meshRenderer.sharedMaterial = material;
OpenMarketEvent.ParameterlessListeners += OnMarketScreen;
}
private void SetupUpgradeButtons(AbstractBuildingTile tile, AbstractMarketManager manager)
{
BuildingUpgrade buildingUpgrade = tile.Building.GetComponent <BuildingUpgrade>();
SetTierText(tile, buildingUpgrade);
if (!buildingUpgrade.CanUpgrade())
{
btnUpgrade.ForEach(BlockButton);
upgradeText.text = LanguageUtil.GetJsonString(maxUpgradeKey);
return;
}
int price = tile.Building.UpgradeCost;
upgradeText.text = price.ToString();
if (!CanAffort(price))
{
btnUpgrade.ForEach(BlockButton);
return;
}
btnUpgrade.ForEach(UnblockButton);
btnUpgrade.ForEach(Setup);
void Setup(Button button)
{
SetButton(button, OnClick);
void OnClick()
{
ReduceMoney(price);
buildingUpgrade.Upgrade();
manager.CloseMarket();
}
}
}
private static bool SelectedBuilding(PlotSelectable selectable, AbstractBuildingTile abstractBuildingTile)
{
// Selected the selected object, so open market
if (selectable == selected)
{
Deselect(selectable);
if (abstractBuildingTile.HasDebris)
{
EventManager.Instance.RaiseEvent(new SelectedBuildingTileEvent(abstractBuildingTile, true));
return(true);
}
EventManager.Instance.RaiseEvent(new OpenMarketEvent(abstractBuildingTile));
return(true);
}
// Send the tile if it has a building, else send null so that the listeners know you selected something that has no building
EventManager.Instance.RaiseEvent(new SelectedBuildingTileEvent(abstractBuildingTile.HasBuilding ? abstractBuildingTile : null, true));
return(false);
}
private void SetButton(AbstractBuildingTile tile)
{
delete.onClick.RemoveAllListeners();
int price = tile.DebrisRemovalCost;
priceText.text = price.ToString();
if (MoneyManager.Instance.PlayerHasEnoughMoney(price))
{
delete.onClick.AddListener(OnClick);
}
void OnClick()
{
EventManager.Instance.RaiseEvent(new DecreaseMoneyEvent(price));
tile.RemoveDebris();
transform.GetChild(0).gameObject.SetActive(false);
}
}
protected override void BuyButtonClick(AbstractBuildingTile tile, AbstractMarketManager manager)
{
base.BuyButtonClick(tile, manager);
switch (selectedPowerup)
{
case PowerUpType.AvoidMonster:
PowerUpManager.Instance.AvoidMonsters++;
break;
case PowerUpType.FixProblems:
PowerUpManager.Instance.FixProblems++;
break;
case PowerUpType.AvoidWeatherEvent:
PowerUpManager.Instance.AvoidWeather++;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private void SetupTypeButtons(AbstractBuildingTile tile, AbstractMarketManager manager)
{
TBuyType[] unlocked = GetUnlockedTypes();
foreach (KeyValuePair <TBuyType, BuyButtonData> pair in buttonDataPerBuyType)
{
Button button = pair.Value.Button;
if (!unlocked.Contains(pair.Key))
{
BlockButton(button, true);
continue;
}
if (selectedButtonDatum == null)
{
Select(tile, pair, manager);
}
BlockButton(button, false);
SetButton(button, () => Select(tile, pair, manager));
}
}
protected override int GetPrice(AbstractBuildingTile tile) => PowerUpManager.Instance.GetPowerUp(selectedPowerup).Price;