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