internal bool UpdateGlobalMapLocation()
{
if (this.mapLocation == null)
{
this.mapLocation = GlobalMapLocation.Instances.FirstOrDefault(map => map.Blueprint.AssetGuid == this.AssetGuid);
if (this.mapLocation == null)
{
Log.Error($"Cannot find GlobalMapLocation for assetGuid=[{this.AssetGuid}]");
return(false);
}
}
if (this.Name == null)
{
this.Name = mapLocation.Blueprint.GetName(false);
}
this.mapLocation.HoverColor = this.IsVisible ? this.Color : this.mapLocation.CurrentColor;
this.mapLocation.OverrideHCol = this.IsVisible;
// Don't have a direct way to set a highlight color on the map icon,
// so fake it by marking customized locations as being hovered.
Helpers.SetField(this.mapLocation, "m_Hover", this.IsVisible);
this.mapLocation.UpdateHighlight();
return(true);
}
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);
}
}
internal static void PostHandleHoverchange(GlobalMapLocation location, bool isHover)
{
// The hover ring is our highlight so reinstate it when the mouse moves out of the location
if (!isHover)
{
ModGlobalMapLocation.FindByAssetGuid(location.Blueprint.AssetGuid)?.UpdateGlobalMapLocation();
}
}
private static bool Prefix(GlobalMapLocation __instance)
{
if (IsShiftPressed)
{
CustomGlobalMapLocations.CustomizeGlobalMapLocation(__instance);
}
// Don't pass the click through to the map if control or shift are pressed
return(!(IsControlPressed || IsShiftPressed));
}
private ModGlobalMapLocation(GlobalMapLocation location)
{
this.mapLocation = location;
this.AssetGuid = location.Blueprint.AssetGuid;
this.Name = mapLocation.Blueprint.GetName(false);
this.Notes = $"Custom location #{StateManager.CurrentState.MarkerNumber++}";
this.Color = Color.green;
this.IsVisible = true;
GlobalMapLocations.Add(this);
}
internal static void CustomizeGlobalMapLocation(GlobalMapLocation location)
{
ModGlobalMapLocation mapLocation = ModGlobalMapLocation.FindOrCreateByAssetGuid(location.Blueprint.AssetGuid);
if (mapLocation != null)
{
mapLocation.UpdateGlobalMapLocation();
Game.Instance.UI.Common.UISound.Play(UISoundType.ButtonClick);
}
else
{
Log.Error($"Could not findOrCreate location name=[{location.Blueprint.GetName(false)}] guid=[{location.Blueprint.AssetGuid}]");
}
}
static bool Prefix(LocationData __instance)
{
try
{
if (!Main.enabled)
{
return(true);
}
if (!Main.settings.currencyFallback)
{
return(true);
}
if (__instance.Resource != ResourceStateType.CanClaim)
{
return(false);
}
KingdomCurrencyFallback.SpendPoints(KingdomRoot.Instance.DefaultMapResourceCost);
KingdomState.Instance.Resources.Add(__instance.Blueprint);
__instance.Blueprint.ResourceStats.Apply();
if (GlobalMapRules.Instance && GlobalMapRules.Instance.ClaimedResourceVisual)
{
GlobalMapLocation locationObject = GlobalMapRules.Instance.GetLocationObject(__instance.Blueprint);
if (locationObject)
{
UnityEngine.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);
}
return(false);
}
catch (Exception ex)
{
Main.Error(ex);
return(true);
}
}
internal static ModGlobalMapLocation FindOrCreateByAssetGuid(string assetGuid)
{
var modLocation = GlobalMapLocations.FirstOrDefault(location => location.AssetGuid == assetGuid);
if (modLocation == null)
{
GlobalMapLocation mapLocation = GlobalMapLocation.Instances.FirstOrDefault(map => map.Blueprint.AssetGuid == assetGuid);
if (mapLocation != null)
{
modLocation = new ModGlobalMapLocation(mapLocation);
}
else
{
Log.Write($"Cannot find GlobalMapLocation for assetGuid=[{assetGuid}]");
}
}
return(modLocation);
}
static void Postfix(TextMeshProUGUI ___m_DescText, GlobalMapLocation ___m_Location,
GameObject ___m_StandartControllers, GameObject ___m_OkControllers)
{
try
{
if (!Main.enabled)
{
return;
}
if (!Main.settings.currencyFallback)
{
return;
}
LocationData.ResourceStateType resource = ___m_Location.Data.Resource;
if (resource == ResourceStateType.CantClaimWrongRegion)
{
return;
}
if (resource != ResourceStateType.CanClaim)
{
return;
}
if (!KingdomCurrencyFallback.CanSpend(KingdomRoot.Instance.DefaultMapResourceCost))
{
return;
}
string resourceCostSplitFormat = KingdomCurrencyFallback.resourceCostSplitFormat;
UITextGlobalMap globalMap = Game.Instance.BlueprintRoot.LocalizedTexts.UserInterfacesText.GlobalMap;
Tuple <int, int> costSplit = KingdomCurrencyFallback.SplitCost(KingdomRoot.Instance.DefaultMapResourceCost);
if (costSplit.Item2 == 0)
{
return;
}
var bpText = string.Format(resourceCostSplitFormat, costSplit.Item1, costSplit.Item2);
___m_DescText.text = string.Format(globalMap.ResourceAvailable, bpText, KingdomState.Instance.BuildPoints);
___m_StandartControllers.SetActive(true);
___m_OkControllers.SetActive(false);
}
catch (Exception ex)
{
Main.Error(ex);
}
}
public void mod_Tick()
{
if (!KingmakerPatchSettings.Cheats.Abracadabra)
{
this.source_Tick();
return;
}
GlobalMapState globalMap = Kingmaker.Game.Instance.Player.GlobalMap;
Dictionary <BlueprintLocation, LocationData> .ValueCollection locations = globalMap.Locations.Values;
// don't run foreach on tick if we don't have to
// this will return true until all locations, except hidden locations and waypoints, are revealed
bool canRevealLocations = locations.Any(l => !l.IsRevealed && !IsHiddenOrWaypoint(l));
if (!canRevealLocations)
{
return;
}
// removed distance checks
foreach (LocationData locationData in locations)
{
if (locationData.IsRevealed)
{
continue;
}
GlobalMapLocation locationObject = GlobalMapRules.Instance.GetLocationObject(locationData.Blueprint);
if (!locationObject)
{
continue;
}
ConditionsChecker possibleToRevealCondition = locationData.Blueprint.PossibleToRevealCondition;
LocationType type = locationData.Blueprint.Type;
switch (type)
{
case LocationType.Location:
case LocationType.Landmark:
if (!possibleToRevealCondition.HasConditions || possibleToRevealCondition.Check())
{
GlobalMapRules.Instance.RevealLocation(locationObject);
}
break;
default:
if (type != LocationType.HiddenLocation)
{
continue;
}
if (possibleToRevealCondition.HasConditions && !possibleToRevealCondition.Check())
{
continue;
}
GlobalMapRules.Instance.RevealLocation(locationObject);
break;
}
}
}
private static void Postfix(GlobalMapLocation __instance, bool isHover)
{
CustomGlobalMapLocations.PostHandleHoverchange(__instance, isHover);
}
