static bool Prefix(SettlementState __instance, SettlementBuilding building, ref SettlementBuilding __result,
                               BuildingsCollection ___m_Buildings)
            {
                try
                {
                    if (!Main.enabled)
                    {
                        return(true);
                    }
                    if (!Main.settings.currencyFallback)
                    {
                        return(true);
                    }

                    if (!building.IsFinished || !___m_Buildings.HasFact(building) || !building.Blueprint.UpgradesTo)
                    {
                        return(false);
                    }

                    if (!KingdomCurrencyFallback.CanSpend(__instance.GetActualCost(building.Blueprint.UpgradesTo)))
                    {
                        UberDebug.LogWarning("Cannot upgrade " + building.Blueprint + ": not enough BP");
                        return(false);
                    }

                    KingdomCurrencyFallback.SpendPoints(__instance.GetActualCost(building.Blueprint));

                    SettlementBuilding result = ___m_Buildings.Upgrade(building);

                    __instance.Update();

                    EventBus.RaiseEvent((ISettlementBuildUpdate h) => h.OnBuildUpdate(building));

                    __result = result;
                    return(false);
                }
                catch (Exception ex)
                {
                    Main.Error(ex);
                    return(true);
                }
            }
Exemplo n.º 2
0
            public void mod_Initialize(BlueprintSettlementBuilding building, SettlementBuilding settlementBuilding, SettlementState settlement)
            {
                if (!KingmakerPatchSettings.CurrencyFallback.Enabled)
                {
                    this.source_Initialize(building, settlementBuilding, settlement);
                    return;
                }

                string costFormat      = LocalizationManagerNew.LoadString("9191fbc8-23ac-4bd4-8167-28de8d418122");
                string costSplitFormat = LocalizationManagerNew.LoadString("da676fed-170f-4099-8b09-ba516d632dd7");

                this.alias_Slots.sprite = KingdomUIRoot.Instance.Settlement.GetSlotSprite(building.SlotCount);

                if (settlementBuilding == null)
                {
                    int actualCost = settlement.GetActualCost(building, out bool isDiscounted);
                    this.alias_DiscountLayer.gameObject.SetActive(actualCost == 0 || isDiscounted);

                    if (actualCost == 0)
                    {
                        this.alias_Cost.text = string.Format(costFormat, KingdomUIRoot.Instance.Texts.BuildFreeCost);
                    }
                    else
                    {
                        Tuple <int, int> costSplit = KingdomCurrencyFallback.SplitCost(actualCost);

                        LocalizedString format = isDiscounted ? KingdomUIRoot.Instance.Texts.BuildPointsDiscountFormat : KingdomUIRoot.Instance.Texts.BuildPointsFormat;

                        if (costSplit.Item2 == 0)
                        {
                            this.alias_Cost.text = string.Format(costFormat, string.Format(format, costSplit.Item1));
                        }
                        else
                        {
                            this.alias_Cost.text = string.Format(costSplitFormat, string.Format(format, costSplit.Item1), costSplit.Item2);
                        }
                    }
                }
                else
                {
                    this.alias_DiscountLayer.gameObject.SetActive(false);
                    this.alias_Cost.text = string.Format(costFormat, string.Format(KingdomUIRoot.Instance.Texts.BuildPointsFormat, settlementBuilding.Owner.GetSellPrice(building)));
                }

                this.alias_SetColor(building, settlementBuilding, settlement);
            }
            static bool Prefix(SettlementState __instance, ref bool __result, BlueprintSettlementBuilding building, int ___m_SlotsLeft)
            {
                try
                {
                    if (!Main.enabled)
                    {
                        return(true);
                    }
                    if (!Main.settings.currencyFallback)
                    {
                        return(true);
                    }

                    if (!KingdomCurrencyFallback.CanSpend(__instance.GetActualCost(building)))
                    {
                        UberDebug.LogSystem("[KingdomResolution] SettlementState_CanBuild_Patch: Cannot spend");
                        __result = false;
                        return(false);
                    }

                    SpecialSlotType specialSlot = building.SpecialSlot;

                    if (specialSlot != SpecialSlotType.None)
                    {
                        if (__instance.IsSpecialSlotFilled(specialSlot))
                        {
                            return(false);
                        }
                    }
                    else if (___m_SlotsLeft < building.SlotCount)
                    {
                        return(false);
                    }

                    __result = CanBuildByLevel(__instance, building);
                    return(false);
                }
                catch (Exception ex)
                {
                    Main.Error(ex);
                    return(true);
                }
            }
            static bool Prefix(SettlementState __instance, ref bool __result, BlueprintSettlementBuilding building)
            {
                try
                {
                    if (!Main.enabled)
                    {
                        return(true);
                    }
                    if (!Main.settings.currencyFallback)
                    {
                        return(true);
                    }

                    __result = KingdomCurrencyFallback.CanSpend(__instance.GetActualCost(building)) && building.MinLevel <= __instance.Level && __instance.Buildings.Any(b => b.Blueprint.UpgradesTo == building);
                    return(false);
                }
                catch (Exception ex)
                {
                    Main.Error(ex);
                    return(true);
                }
            }
            static bool Prefix(SettlementState __instance, ref SettlementBuilding __result,
                               BlueprintSettlementBuilding building, SettlementGridTopology.Slot slot, bool force,
                               ref int ___m_SlotsLeft, BuildingsCollection ___m_Buildings)
            {
                try
                {
                    if (!Main.enabled)
                    {
                        return(true);
                    }
                    if (!Main.settings.currencyFallback)
                    {
                        return(true);
                    }

                    var removedBuilding = true;

                    if (!force)
                    {
                        if (!__instance.CanBuild(building))
                        {
                            __result = null;
                            return(false);
                        }

                        BuildingSlot slotObject = slot.GetSlotObject();

                        if (slotObject?.CanBuildHere(building) != true)
                        {
                            return(false);
                        }

                        KingdomCurrencyFallback.SpendPoints(__instance.GetActualCost(building));

                        removedBuilding = __instance.FreeBuildings.Remove(building) || KingdomState.Instance.FreeBuildings.Remove(building);
                    }

                    SettlementBuilding settlementBuilding = ___m_Buildings.Build(building);
                    settlementBuilding.BuildOnSlot(slot);

                    if (building.SpecialSlot == SpecialSlotType.None)
                    {
                        ___m_SlotsLeft -= building.SlotCount;
                    }

                    if (!force && !removedBuilding || SellDiscountedBuildingGetter(__instance) != building)
                    {
                        SellDiscountedBuildingSetter(__instance, null);
                    }

                    __instance.Update();

                    EventBus.RaiseEvent((ISettlementBuildingHandler h) => h.OnBuildingStarted(__instance, settlementBuilding));

                    __result = settlementBuilding;
                    return(false);
                }
                catch (Exception ex)
                {
                    Main.Error(ex);
                    return(true);
                }
            }
            static bool Prefix(object __instance, BlueprintSettlementBuilding building, SettlementBuilding settlementBuilding, SettlementState settlement,
                               Image ___Slots, TextMeshProUGUI ___Cost, Image ___DiscountLayer)
            {
                try
                {
                    if (!Main.enabled)
                    {
                        return(true);
                    }
                    if (!Main.settings.currencyFallback)
                    {
                        return(true);
                    }

                    string costFormat      = KingdomCurrencyFallback.costFormat;
                    string costSplitFormat = KingdomCurrencyFallback.costSplitFormat;

                    ___Slots.sprite = KingdomUIRoot.Instance.Settlement.GetSlotSprite(building.SlotCount);

                    if (settlementBuilding == null)
                    {
                        int actualCost = settlement.GetActualCost(building, out bool isDiscounted);
                        ___DiscountLayer?.gameObject?.SetActive(actualCost == 0 || isDiscounted);

                        if (actualCost == 0)
                        {
                            ___Cost.text = string.Format(costFormat, KingdomUIRoot.Instance.Texts.BuildFreeCost);
                        }
                        else
                        {
                            Tuple <int, int> costSplit = KingdomCurrencyFallback.SplitCost(actualCost);

                            LocalizedString format = isDiscounted ? KingdomUIRoot.Instance.Texts.BuildPointsDiscountFormat : KingdomUIRoot.Instance.Texts.BuildPointsFormat;

                            if (costSplit.Item2 == 0)
                            {
                                ___Cost.text = string.Format(costFormat, string.Format(format, costSplit.Item1));
                            }
                            else
                            {
                                ___Cost.text = string.Format(costSplitFormat, string.Format(format, costSplit.Item1), costSplit.Item2);
                            }
                        }
                    }
                    else
                    {
                        try
                        {
                            ___DiscountLayer.gameObject.SetActive(false);
                        }
                        catch (NullReferenceException) {
                            //accessing ___DiscountLayer.gameObject after the gameObject has been destroyed causes the getter to throw an exception
                        }
                        ___Cost.text = string.Format(costFormat, string.Format(KingdomUIRoot.Instance.Texts.BuildPointsFormat, settlementBuilding.Owner.GetSellPrice(building)));
                    }

                    SetColor(__instance, building, settlementBuilding, settlement);
                    return(false);
                }
                catch (Exception ex)
                {
                    Main.Error(ex);
                    return(true);
                }
            }