public bool mod_CanBuild(BlueprintSettlementBuilding building)
{
if (!KingmakerPatchSettings.CurrencyFallback.Enabled)
{
return(this.source_CanBuild(building));
}
if (!KingdomCurrencyFallback.CanSpend(this.GetActualCost(building)))
{
UberDebug.LogSystem("[fireundubh] mod_CanBuild: Cannot spend");
return(false);
}
SpecialSlotType specialSlot = building.SpecialSlot;
if (specialSlot != SpecialSlotType.None)
{
if (this.IsSpecialSlotFilled(specialSlot))
{
return(false);
}
}
else if (this.alias_m_SlotsLeft < building.SlotCount)
{
return(false);
}
return(this.alias_CanBuildByLevel(building));
}
public virtual void mod_Start(bool raiseEvent = true)
{
if (!KingmakerPatchSettings.CurrencyFallback.Enabled)
{
this.source_Start(raiseEvent);
return;
}
this.alias_IsStarted = true;
this.alias_StartedOn = KingdomState.Instance.CurrentDay;
KingdomCurrencyFallback.SpendPoints(this.OneTimeBPCost);
if (raiseEvent)
{
this.alias_OnTaskChanged();
}
EventBus.RaiseEvent((IKingdomTaskEventsHandler h) => h.OnTaskStarted(this));
if (this.SkipPlayerTime <= 0)
{
return;
}
Kingmaker.Game.Instance.AdvanceGameTime(TimeSpan.FromDays(this.SkipPlayerTime));
foreach (UnitEntityData unitEntityData in Kingmaker.Game.Instance.Player.AllCharacters)
{
RestController.ApplyRest(unitEntityData.Descriptor);
}
new KingdomTimelineManager().UpdateTimeline();
}
public SettlementBuilding mod_UpgradeBuilding(SettlementBuilding building)
{
if (!KingmakerPatchSettings.CurrencyFallback.Enabled)
{
return(this.source_UpgradeBuilding(building));
}
if (!building.IsFinished || !this.alias_m_Buildings.HasFact(building) || !building.Blueprint.UpgradesTo)
{
return(null);
}
if (!KingdomCurrencyFallback.CanSpend(this.GetActualCost(building.Blueprint.UpgradesTo)))
{
UberDebug.LogWarning("Cannot upgrade " + building.Blueprint + ": not enough BP");
return(null);
}
KingdomCurrencyFallback.SpendPoints(this.GetActualCost(building.Blueprint));
SettlementBuilding result = this.alias_m_Buildings.Upgrade(building);
this.Update();
EventBus.RaiseEvent((ISettlementBuildUpdate h) => h.OnBuildUpdate(building));
return(result);
}
public void mod_ClaimResource()
{
if (!KingmakerPatchSettings.CurrencyFallback.Enabled)
{
this.source_ClaimResource();
return;
}
if (this.Resource != ResourceStateType.CanClaim)
{
return;
}
KingdomCurrencyFallback.SpendPoints(KingdomRoot.Instance.DefaultMapResourceCost);
KingdomState.Instance.Resources.Add(this.Blueprint);
this.Blueprint.ResourceStats.Apply();
if (GlobalMapRules.Instance && GlobalMapRules.Instance.ClaimedResourceVisual)
{
GlobalMapLocation locationObject = GlobalMapRules.Instance.GetLocationObject(this.Blueprint);
if (locationObject)
{
Object.Instantiate(GlobalMapRules.Instance.ClaimedResourceVisual, locationObject.transform, false);
}
}
if (KingdomRoot.Instance.Locations.Count(l => l.HasKingdomResource) == KingdomState.Instance.Resources.Count)
{
Kingmaker.Game.Instance.Player.Achievements.Unlock(AchievementType.IntensiveDevelopment);
}
}
public bool mod_CanBuildUprgade(BlueprintSettlementBuilding building)
{
if (!KingmakerPatchSettings.CurrencyFallback.Enabled)
{
return(this.source_CanBuildUprgade(building));
}
return(KingdomCurrencyFallback.CanSpend(this.GetActualCost(building)) && building.MinLevel <= this.Level && this.Buildings.Any(b => b.Blueprint.UpgradesTo == building));
}
public void mod_FoundSettlement(RegionSettlementLocation settlementLocation, string name = null)
{
if (!KingmakerPatchSettings.CurrencyFallback.Enabled)
{
this.source_FoundSettlement(settlementLocation, name);
return;
}
if (!this.Blueprint.SettlementBuildArea)
{
UberDebug.LogError("Cannot found a settlement in {0}: no building area set up", settlementLocation);
return;
}
if (this.Settlement != null)
{
UberDebug.LogError("Cannot found a settlement in {0}: already built", settlementLocation);
return;
}
if (settlementLocation != null && settlementLocation.AssociatedLocation == null)
{
UberDebug.LogError("Cannot found a settlement in {0}: no globalmap location associated", settlementLocation);
return;
}
if (settlementLocation == null && this.Blueprint.SettlementGlobalmapLocations.Length == 0)
{
UberDebug.LogError("Cannot found a settlement in {0}: no location specified and no default found", this.Blueprint);
return;
}
KingdomCurrencyFallback.SpendPoints(KingdomRoot.Instance.SettlementBPCost);
var settlementState = new SettlementState(SettlementState.LevelType.Village)
{
Region = this
};
SettlementState settlementState2 = settlementState;
settlementState2.HasWaterSlot = settlementLocation?.HasWaterSlot == true;
settlementState.Name = name ?? this.Blueprint.DefaultSettlementName;
settlementState.Location = settlementLocation?.AssociatedLocation ?? this.Blueprint.SettlementGlobalmapLocations.FirstOrDefault();
settlementState.SettlementLocation = settlementLocation;
this.Settlement = settlementState;
this.SetSettlementUIMarkers();
EventBus.RaiseEvent((ISettlementFoundingHandler h) => h.OnSettlementFounded(this.Settlement));
}
public SettlementBuilding mod_Build(BlueprintSettlementBuilding building, SettlementGridTopology.Slot slot, bool force = false)
{
if (!KingmakerPatchSettings.CurrencyFallback.Enabled)
{
return(this.source_Build(building, slot, force));
}
var removedBuilding = true;
if (!force)
{
if (!this.CanBuild(building))
{
return(null);
}
BuildingSlot slotObject = slot.GetSlotObject();
if (slotObject?.CanBuildHere(building) != true)
{
return(null);
}
KingdomCurrencyFallback.SpendPoints(this.GetActualCost(building));
removedBuilding = this.FreeBuildings.Remove(building) || KingdomState.Instance.FreeBuildings.Remove(building);
}
SettlementBuilding settlementBuilding = this.alias_m_Buildings.Build(building);
settlementBuilding.BuildOnSlot(slot);
if (building.SpecialSlot == SpecialSlotType.None)
{
this.alias_m_SlotsLeft -= building.SlotCount;
}
if (!force && !removedBuilding || this.alias_SellDiscountedBuilding != building)
{
this.alias_SellDiscountedBuilding = null;
}
this.Update();
EventBus.RaiseEvent((ISettlementBuildingHandler h) => h.OnBuildingStarted(this, settlementBuilding));
return(settlementBuilding);
}
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);
}
public void mod_UpdateBuildEnabled()
{
if (!KingmakerPatchSettings.CurrencyFallback.Enabled)
{
this.source_UpdateBuildEnabled();
return;
}
bool canAfford = KingdomCurrencyFallback.CanSpend(KingdomRoot.Instance.SettlementBPCost);
if (canAfford)
{
canAfford = !this.alias_m_InputNameField.text.Empty();
}
this.alias_m_Build.interactable = canAfford;
}
