/// <summary>
/// Handles building upgrade events.
/// </summary>
/// <param name="s">Event building.</param>
public void OnBuildingUpgrade(Building b)
{
if (BuildingUpgrade != null)
{
BuildingUpgrade.Invoke(b);
}
}
void updateCursorUpgradeIfNeeded(BuildingUpgrade upgrade)
{
if (upgrade.enabled && upgrade.upgradeType == "cursor" && !(upgrade.name == "Reinforced index finger" || upgrade.name == "Carpal tunnel prevention cream" || upgrade.name == "Ambidextrous"))
{
int totalBuildings = buildingButtonHandler.getNumberOfBuildings();
int totalCursors = buildingButtonHandler.findButtonWithName("cursor").count;
int totalNonCursors = totalBuildings - totalCursors;
if (totalNonCursors != oldTotalNonCursors)
{
oldTotalNonCursors = totalNonCursors;
string description = upgrade.description;
string cookieGainPerNonCursorString = new Regex("(?<=\\+)(\\d|\\.)+(?= cookies)").Match(description).Groups[0].ToString();
double cookieGainPerNonCursor = Convert.ToDouble(cookieGainPerNonCursorString);
double cookiesGained = cookieGainPerNonCursor * totalNonCursors;
gameStats.cookiesPerClickAddOn -= (decimal)upgrade.cookiesPerSecondAddOn;
buildingButtonHandler.findButtonWithName("cursor").cookiesPerSecondAddOn -= upgrade.cookiesPerSecondAddOn;
upgrade.cookiesPerSecondAddOn = cookiesGained;
gameStats.cookiesPerClickAddOn += (decimal)upgrade.cookiesPerSecondAddOn;
buildingButtonHandler.findButtonWithName("cursor").cookiesPerSecondAddOn += upgrade.cookiesPerSecondAddOn;
}
}
}
public async Task <IActionResult> RemoveUpgrade(BuildingUpgrade upgrade)
{
_db.BuildingUpgrades.Remove(upgrade);
await _db.SaveChangesAsync();
return(RedirectToAction("Edit", new { upgrade.BuildingId }));
}
private static void SpawnBuildings()
{
for (int y = 0; y < grid.GetLength(0); y++)
{
for (int x = 0; x < grid.GetLength(1); x++)
{
AbstractTile tile = grid[y, x];
if (!(tile is AbstractBuildingTile buildingTile))
{
continue;
}
TileData tileData = UserSettings.GameData.GridData[new Vector2IntSerializable(x, y)];
buildingTile.SetSoilType(tileData.SoilType);
buildingTile.SetFoundationType(tileData.FoundationType);
buildingTile.SetBuildingType(tileData.BuildingType);
if (tileData.HasDebris)
{
buildingTile.SpawnDebris(tileData.BuildingType, tileData.BuildingTier);
continue;
}
// If there's a building, the tier would be higher than 0
if (tileData.BuildingTier > 0)
{
buildingTile.SpawnBuilding(false);
BuildingHealth buildingHealth = buildingTile.Building.GetComponent <BuildingHealth>();
buildingHealth.SetCurrentHealth(tileData.SoilHealth, tileData.FoundationHealth, tileData.BuildingHealth);
}
else
{
if (tileData.HasSoil)
{
buildingTile.SpawnSoil();
if (tileData.HasFoundation)
{
buildingTile.SpawnFoundation();
}
}
continue;
}
BuildingUpgrade buildingUpgrade = buildingTile.Building.GetComponent <BuildingUpgrade>();
while (buildingTile.Building.CurrentTier != tileData.BuildingTier)
{
buildingUpgrade.Upgrade();
}
}
}
}
void Start()
{
populateItems();
Upgrades = new BuildingUpgrade[]
{
new BuildingUpgrade(2000, 5, 7200),
new BuildingUpgrade(5000, 8, 14400),
};
}
void updateGrandmaTypeUpgradeIfNeeded(BuildingUpgrade upgrade)
{
if (upgrade.enabled && upgrade.upgradeType == "grandma types")
{
string description = upgrade.description;
BuildingButton theBuilding = buildingForGrandmaType(upgrade);
double totalGrandmas = (double)buildingButtonHandler.findButtonWithName("grandma").count;
double grandmasPerPercentCpsIncrease = theBuilding.myName == "farm" ? 1.0 : double.Parse(new Regex("(?<=per ).+(?= grandmas)").Match(description).Groups [0].ToString() + ".0");
theBuilding.cookiesPerSecondAddOn = theBuilding.cookiesPerSecond * theBuilding.cookiesPerSecondMultiplier * 0.01 * totalGrandmas / grandmasPerPercentCpsIncrease;
}
}
// yeah it's kind of odd to use the upgrade's "cookies per second add on" as a per-click add but whatever it works
void updateClickingUpgradeIfNeeded(BuildingUpgrade upgrade)
{
if (upgrade.enabled && upgrade.upgradeType == "clicking upgrades")
{
double cookiesPerSecond = (double)gameStats.cookiesPerSecondTotal;
// decimal cookiesPerClick = gameStats.cookiesPerClick;
double add = 0.01 * cookiesPerSecond;
gameStats.cookiesPerClickAddOn -= (decimal)upgrade.cookiesPerSecondAddOn;
upgrade.cookiesPerSecondAddOn = add;
gameStats.cookiesPerClickAddOn += (decimal)upgrade.cookiesPerSecondAddOn;
}
}
void Update()
{
List <BuildingUpgrade> upgradesQuantityMet = new List <BuildingUpgrade> ();
for (int i = 0; i < upgrades.Length; i++)
{
BuildingUpgrade upgrade = upgrades[i];
updateCursorUpgradeIfNeeded(upgrade);
updateGrandmaTypeUpgradeIfNeeded(upgrade);
updateClickingUpgradeIfNeeded(upgrade);
upgrade.unlocked = quantityMet(upgrade);
if (!upgrade.enabled && quantityMet(upgrade))
{
upgradesQuantityMet.Add(upgrade);
}
}
upgradesQuantityMet = sortByPrice(upgradesQuantityMet);
for (int i = 0; i < upgradeButtons.Length; i++)
{
buttonElementHolders[i].gameObject.SetActive(upgradesQuantityMet.Count > 0);
if (upgradesQuantityMet.Count > 0)
{
// set the upgrade of the button to the last upgrade in the list and remove the upgrade from the list
upgradeButtons [i].upgrade = upgradesQuantityMet [upgradesQuantityMet.Count - 1];
upgradesQuantityMet.RemoveAt(upgradesQuantityMet.Count - 1);
buttonTexts [i].text = upgradeButtons [i].upgrade.name;
popupTexts [i].text = upgradeButtons [i].upgrade.name + " (" + gameStats.formatNumber(decimal.Parse(upgradeButtons[i].upgrade.basePrice), 0) + " cookies)\n" + upgradeButtons [i].upgrade.description;
popupTexts[i].rectTransform.anchoredPosition = new Vector2(0f, 0f);
buttonTexts [i].rectTransform.localPosition = new Vector2(buttonTexts [i].rectTransform.localPosition.x, 15f);
// set the color according to whether it is affordable or not
if (gameStats.cookies >= Convert.ToInt64(upgradeButtons [i].upgrade.basePrice))
{
upgradeButtons [i].GetComponent <Image> ().color = new Color(0.7f, 0.7f, 0.7f);
buttonTexts [i].color = Color.white;
}
else
{
upgradeButtons [i].GetComponent <Image> ().color = Color.gray;
buttonTexts [i].color = new Color(0.7f, 0.7f, 0.7f);
}
}
}
}
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);
}
public static bool CanSnapTo(BuildingUpgrade __instance, ref bool __result, Item _itemToSnapTo)
{
if (!StoreManager.Instance.IsDlcInstalled(OTWStoreAPI.DLCs.DLC2) ||
PhotonNetwork.isNonMasterClientInRoom)
{
return(true);
}
__result = _itemToSnapTo &&
_itemToSnapTo.ItemID == __instance.CompatibleItem.ItemID &&
((Building)_itemToSnapTo).IsInFinishedState;
return(false);
}
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;
}
public static bool CanSnapTo(BuildingUpgrade __instance, ref bool __result, Item _itemToSnapTo)
{
if (!StoreManager.Instance.IsDlcInstalled(OTWStoreAPI.DLCs.DLC2) ||
!BuildingHelperMod.Instance.settings.ForceNoRequirements ||
PhotonNetwork.isNonMasterClientInRoom)
{
return(true);
}
__result = _itemToSnapTo &&
_itemToSnapTo.ItemID == __instance.CompatibleItem.ItemID &&
((Building)_itemToSnapTo).IsInFinishedState;
//&& ((Building)_itemToSnapTo).CurrentUpradePhaseIndex == __instance.UpgradeFromIndex
//&& ((Building)_itemToSnapTo).PendingUpgradePhaseIndex == -1;
return(false);
}
public void AssignBuilding(BuildingUpgrade newBuilding)
{
assignedBuilding = newBuilding;
descriptionText.text = assignedBuilding.GetName();
if (newBuilding.IsBuilt())
{
ShowCompletedUpgradeInfo();
}
else
{
ShowIncompleteUpgradeInfo();
}
//Refresh make button
buildButton.AssignBuilding(newBuilding);
}
bool quantityMet(BuildingUpgrade upgrade)
{
bool a = upgrade.upgradeClass == "building" && buildingButtonHandler.findButtonWithName(upgrade.upgradeType).count >= Convert.ToInt64(upgrade.quantityNeeded);
string theThing = new Regex(" cookies").Replace(upgrade.quantityNeeded, "");
bool b = upgrade.upgradeClass == "flavored cookies" && theThing.Length < 20 && gameStats.cookies >= Convert.ToInt64(theThing);
theThing = upgrade.quantityNeeded.Replace(" hand-made cookies", "");
bool c = upgrade.upgradeClass == "clicking upgrades" && theThing.Length < 20 && gameStats.handmadeCookies >= Convert.ToInt64(theThing);
BuildingButton theBuilding = buildingForGrandmaType(upgrade);
bool d = upgrade.upgradeClass == "grandma types" && theBuilding != null && theBuilding.count >= 15 && buildingButtonHandler.findButtonWithName("grandma").count >= 1;
bool e = upgrade.basePrice.Length < 20; // this shouldn't exist. temporary fix. the numbers get too big. also seen above.
return((a || b || c || d) && e);
}
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();
}
}
}
public UpgradeBuildingAction(IBoard <TerraTile> board, TerraMysticaPlayer player, Building building, BuildingUpgrade upgrade)
: base(player)
{
if (board == null)
{
throw new ArgumentNullException(nameof(board));
}
if (building == null)
{
throw new ArgumentNullException(nameof(building));
}
if (upgrade == null)
{
throw new ArgumentNullException(nameof(upgrade));
}
this.Board = board;
this.Building = building;
this.Upgrade = upgrade;
}
void Start()
{
PVMax = PV;
upgradeLink = GetComponent<BuildingUpgrade> ();
makerLink = GetComponent<BuildingMaker> ();
}
private void UpgradeAndAssertResult(bool expectation, Action beforeExecute = null, Building target = null, BuildingUpgrade targetUpgrade = null)
{
Building building = target;
if (building == null)
{
var loc = new HexLocation(1, 1);
building = new Building(BuildingType.Dwelling, loc);
var tile = this.Board.TileForLocation(building.Location);
tile.Building = building;
tile.Owner = this.Player;
}
var upgrade = targetUpgrade ?? new BuildingUpgrade(BuildingType.TradingHouse, new Cost(new GoldResource(3)));
this.PerformActionAndAssertResult(
expectation,
() => new UpgradeBuildingAction(this.Board, this.Player, building, upgrade),
beforeExecute);
if (expectation)
{
var tile = this.Board.TileForLocation(building.Location);
tile.Building.Type.ShouldBeEquivalentTo(upgrade.NewType);
}
}
public async Task <IActionResult> BuildingUpgrade(int id, StoreBuildingUpgradeViewModel upgradeVm)
{
Building building = await _db.Buildings
.Include(b => b.Type)
.Include(b => b.BuildingUpgrades).ThenInclude(bu => bu.Upgrade)
.SingleOrDefaultAsync(b => b.Id == upgradeVm.BuildingId);
Upgrade upgrade = await _db.Upgrades.SingleOrDefaultAsync(u => u.Id == id);
ApplicationUser user = await _userManager.GetUserAsync(User);
// Check whether record exists
if (upgrade == null)
{
return(NotFound());
}
// Check whether this upgrade affects capacity, and if so affects capacity more than accepted
if (building.Capacity + upgrade.CapacityModifier > building.Type.MaxCapacity)
{
ModelState.SetModelValue(nameof(upgradeVm.BuildingId), "Your building is already max upgraded!");
}
// Check whether this upgrade is stackable, and if it is not, if it is already applied
if (!upgrade.IsStackable && building.BuildingUpgrades.Any(au => au.UpgradeId == id))
{
ModelState.SetModelValue(nameof(upgradeVm.BuildingId), "You already upgraded this building with that upgrade!");
}
// If the modelstate is invalid, show view with errors displayed
if (!ModelState.IsValid)
{
IEnumerable <Building> buildings = _db.Buildings
.Where(b => b.UserId == user.Id)
.Include(b => b.Type);
return(View(new StoreBuildingUpgradeViewModel {
Buildings = _mapper.Map <IEnumerable <Building>, IEnumerable <BuildingViewModel> >(buildings),
Upgrade = _mapper.Map <Upgrade, UpgradeViewModel>(upgrade)
}));
}
// Check for requests that should not be possible
if (building.UserId != user.Id)
{
return(StatusCode((int)HttpStatusCode.Forbidden));
}
if (user.Currency < upgrade.Price)
{
return(BadRequest());
}
// At this point all should be well, set up the model and update database
BuildingUpgrade buildingUpgrade = _mapper.Map <StoreBuildingUpgradeViewModel, BuildingUpgrade>(upgradeVm);
buildingUpgrade.UpgradeId = id;
buildingUpgrade.Id = 0;
_db.Users.Attach(user);
user.Currency -= upgrade.Price;
_db.Entry(user).Property(x => x.Currency).IsModified = true;
_db.Add(buildingUpgrade);
_db.Add(new Notification {
Message = $"You upgraded your building!",
Title = "New upgrade!",
Image = "upgrades/" + upgrade.SpritePath,
Link = "/building/details/" + upgradeVm.BuildingId,
UserId = user.Id
});
await _db.SaveChangesAsync();
return(RedirectToAction("Details", "Building", new { id = upgradeVm.BuildingId }));
}
void Start()
{
populateItems();
Upgrades = new BuildingUpgrade[0];
}
private void UpgradeAndAssertFailure(Action beforeExecute = null, Building target = null, BuildingUpgrade upgrade = null)
{
this.UpgradeAndAssertResult(false, beforeExecute, target, upgrade);
}
BuildingButton buildingForGrandmaType(BuildingUpgrade upgrade)
{
string result = new Regex("(?<=15 ).+(?=s and)").Match(upgrade.quantityNeeded).Groups [0].ToString();
return(buildingButtonHandler.findButtonWithName(result == "Factorie" ? "factory" : result.ToLower()));
}
public virtual void UpgradeBuilding(Building building, BuildingUpgrade upgrade)
{
building.Type = upgrade.NewType;
}
private void UpgradeAndAssertSuccess(Action beforeExecute = null, Building target = null, BuildingUpgrade upgrade = null)
{
this.UpgradeAndAssertResult(true, beforeExecute, target, upgrade);
}
