public static ColonistInventory Get(NPCBase npc)
{
ColonistInventory inv = null;
if (npc == null)
{
return(inv);
}
if (npc.CustomData == null)
{
npc.CustomData = new JSONNode();
}
try
{
if (!npc.CustomData.TryGetAs(GameInitializer.SETTLER_INV, out inv) || inv == null)
{
inv = new ColonistInventory(npc);
npc.CustomData.SetAs(GameInitializer.SETTLER_INV, inv);
}
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
if (inv == null)
{
inv = new ColonistInventory(npc);
}
return(inv);
}
public static void OnAssemblyLoaded(string path)
{
var settings = GameInitializer.GetJSONSettingPaths(GameInitializer.NAMESPACE + ".MenuFile");
JObject jObject = new JObject();
foreach (var info in settings)
{
try
{
foreach (var jsonNode in info.Value)
{
try
{
jObject.Merge(JsonConvert.DeserializeObject <JObject>(File.ReadAllText(info.Key + "/" + jsonNode)), new JsonMergeSettings()
{
MergeArrayHandling = MergeArrayHandling.Union, MergeNullValueHandling = MergeNullValueHandling.Ignore, PropertyNameComparison = StringComparison.InvariantCultureIgnoreCase
});
}
catch (Exception ex)
{
APILogger.LogError(ex, "Error loading settings node " + jsonNode);
}
}
}
catch (Exception ex)
{
APILogger.LogError(ex, "Error loading settings file " + info.Key + " values " + string.Join(", ", info.Value.ToArray()));
}
}
LoadedMenus = JSON.DeserializeString(JsonConvert.SerializeObject(jObject));
}
public override void OnResearchComplete(ColonyScienceState manager, EResearchCompletionReason reason)
{
base.OnResearchComplete(manager, reason);
try
{
foreach (var p in manager.Colony.Owners)
{
p.GetTempValues(true).Set(TmpValueKey, Value);
p.GetTempValues(true).Set(LevelKey, Level);
}
manager.Colony.TemporaryData.SetAs(TmpValueKey, Value);
manager.Colony.TemporaryData.SetAs(LevelKey, Level);
if (ResearchComplete != null)
{
ResearchComplete(this, new ResearchCompleteEventArgs(this, manager));
}
}
catch (Exception ex)
{
APILogger.LogError(ex, $"Error OnResearchComplete for {TmpValueKey} Level: {Level}.");
}
}
public static void OnSavingColony(Colony c, JSONNode n)
{
try
{
lock (Objectives)
{
if (Objectives.ContainsKey(c))
{
if (n.HasChild(GameInitializer.NAMESPACE + ".Objectives"))
{
n.RemoveChild(GameInitializer.NAMESPACE + ".Objectives");
}
var objectiveNode = new JSONNode(NodeType.Array);
foreach (var node in Objectives[c])
{
foreach (var catNode in node.Value)
{
objectiveNode.AddToArray(catNode.Value.ToJsonNode());
}
}
n[GameInitializer.NAMESPACE + ".Objectives"] = objectiveNode;
}
}
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
public static bool GetBestWeapon(NPC.NPCBase npc, int limit)
{
var hasItem = false;
try
{
if (npc != null)
{
var inv = ColonistInventory.Get(npc);
var stock = npc.Colony.Stockpile;
hasItem = !inv.Weapon.IsEmpty();
IWeapon bestWeapon = null;
if (hasItem)
{
bestWeapon = WeaponFactory.WeaponLookup[inv.Weapon.Id];
}
foreach (var wep in WeaponFactory.WeaponLookup.Values.Where(w => w as IPlayerMagicItem == null && w is WeaponMetadata weaponMetadata && weaponMetadata.ItemType != null).Cast <WeaponMetadata>())
{
if (stock.Contains(wep.ItemType.ItemIndex) && bestWeapon == null ||
stock.Contains(wep.ItemType.ItemIndex) && bestWeapon != null &&
bestWeapon.Damage.TotalDamage() < wep.Damage.TotalDamage() &&
stock.AmountContained(ItemId.GetItemId(bestWeapon.name)) > limit)
{
bestWeapon = wep;
}
}
if (bestWeapon != null)
{
var wepId = ItemId.GetItemId(bestWeapon.name);
if (hasItem && inv.Weapon.Id != wepId || !hasItem)
{
hasItem = true;
stock.TryRemove(wepId);
if (!inv.Weapon.IsEmpty())
{
stock.Add(inv.Weapon.Id);
}
inv.Weapon = new ItemState
{
Id = wepId,
Durability = bestWeapon.WepDurability
};
}
}
}
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
return(hasItem);
}
public static void OnUpdate()
{
if (GameInitializer.WorldLoaded && _nextUpdate < Time.SecondsSinceStartDouble)
{
lock (Objectives)
{
foreach (var machine in Objectives)
{
foreach (var category in machine.Value)
{
var invalidKeys = new List <Vector3Int>();
foreach (var state in category.Value)
{
try
{
if (!state.Value.PositionIsValid())
{
invalidKeys.Add(state.Key);
}
else
{
state.Value.RoamingJobSettings.DoWork(machine.Key, state.Value);
foreach (var objectiveLoad in state.Value.ActionEnergy)
{
if (objectiveLoad.Value <= 0 &&
state.Value.RoamingJobSettings.ActionCallbacks.TryGetValue(objectiveLoad.Key, out var objectiveAction))
{
Indicator.SendIconIndicatorNear(state.Value.Position.Add(0, 1, 0).Vector,
new IndicatorState(OBJECTIVE_REFRESH,
objectiveAction.ObjectiveLoadEmptyIcon.Id,
true,
false));
}
}
}
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
foreach (var key in invalidKeys)
{
category.Value.Remove(key);
}
}
}
}
_nextUpdate = Time.SecondsSinceStartDouble + OBJECTIVE_REFRESH;
}
}
public void OnRegisterUpgrades(UpgradesManager upgrades)
{
foreach (var extension in GetCallbacks <IOnRegisterUpgradesExtender>())
{
try
{
extension.OnRegisterUpgrades(upgrades);
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
public static void OnSendAreaHighlights(Players.Player player, List <AreaJobTracker.AreaHighlight> list, List <ushort> showWhileHoldingTypes)
{
foreach (var extension in GetCallbacks <IOnSendAreaHighlightsExtender>())
{
try
{
extension.OnSendAreaHighlights(player, list, showWhileHoldingTypes);
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
public PandaResearchable(IPandaResearch pandaResearch, int currentLevel)
{
Conditions = new List <IResearchableCondition>();
RecipeUnlocks = new List <RecipeUnlock>();
Dependencies = new List <string>();
try
{
List <IResearchableCondition> researchableConditions;
if (pandaResearch.Conditions != null && (pandaResearch.Conditions.TryGetValue(currentLevel, out researchableConditions) || pandaResearch.Conditions.TryGetValue(0, out researchableConditions)))
{
Conditions.AddRange(researchableConditions);
}
List <string> dependancies = null;
if (pandaResearch.Dependancies != null && !pandaResearch.Dependancies.TryGetValue(currentLevel, out dependancies))
{
pandaResearch.Dependancies.TryGetValue(0, out dependancies);
}
Initialize(currentLevel, pandaResearch.name, pandaResearch.BaseValue, pandaResearch.IconDirectory, dependancies, pandaResearch.BaseIterationCount, pandaResearch.AddLevelToName);
List <InventoryItem> inventoryItems;
if (pandaResearch.RequiredItems != null && (pandaResearch.RequiredItems.TryGetValue(currentLevel, out inventoryItems) || pandaResearch.RequiredItems.TryGetValue(0, out inventoryItems)))
{
AddCraftingCondition(inventoryItems, currentLevel);
}
List <RecipeUnlock> listUnlocks;
if (pandaResearch.Unlocks != null && (pandaResearch.Unlocks.TryGetValue(currentLevel, out listUnlocks) || pandaResearch.Unlocks.TryGetValue(0, out listUnlocks)))
{
RecipeUnlocks.AddRange(listUnlocks);
}
Register(currentLevel, pandaResearch.name);
}
catch (NullReferenceException nullRef)
{
APILogger.LogToFile(nullRef.StackTrace);
APILogger.LogToFile(nullRef.Message);
APILogger.LogError(nullRef);
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
public static void AfterSelectedWorld()
{
foreach (var extension in GetCallbacks <IAfterSelectedWorldExtender>())
{
try
{
extension.AfterSelectedWorld();
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
public static void OnCreatedColony(Colony c)
{
foreach (var extension in GetCallbacks <IOnColonyCreatedExtender>())
{
try
{
extension.ColonyCreated(c);
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
public void OnLoadModJSONFiles(List <ModLoader.LoadModJSONFileContext> contexts)
{
foreach (var extension in GetCallbacks <IOnLoadModJSONFilesExtender>())
{
try
{
extension.OnLoadModJSONFiles(contexts);
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
public static void AfterItemTypesDefined()
{
foreach (var extension in GetCallbacks <IAfterItemTypesDefinedExtender>())
{
try
{
extension.AfterItemTypesDefined();
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
public static void OnLoadingColony(Colony c, JSONNode n)
{
foreach (var extension in GetCallbacks <IOnLoadingColonyExtender>())
{
try
{
extension.OnLoadingColony(c, n);
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
public static void OnChangedBlock(ModLoader.OnTryChangeBlockData tryChangeBlockData)
{
foreach (var extension in GetCallbacks <IOnChangedBlockExtender>())
{
try
{
extension.OnChangedBlock(tryChangeBlockData);
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
private static void LoadExtenstions(List <ModLoader.ModDescription> list)
{
foreach (var mod in list.Where(m => m.HasAssembly))
{
try
{
// Get all Types available in the assembly in an array
var typeArray = mod.LoadedAssembly.GetTypes();
// Walk through each Type and list their Information
foreach (var type in typeArray)
{
var ifaces = type.GetInterfaces();
var isExtention = ifaces.Any(f => f.Name == nameof(IPandarosExtention));
try
{
if (isExtention && Activator.CreateInstance(type) is IPandarosExtention extension)
{
foreach (var iface in ifaces)
{
if (iface.Name != nameof(IPandarosExtention))
{
try
{
if (!_settlersExtensions.ContainsKey(iface.Name))
{
_settlersExtensions.Add(iface.Name, new List <IPandarosExtention>());
}
if (!_settlersExtensions[iface.Name].Any(f => f.GetType().Name == extension.GetType().Name))
{
_settlersExtensions[iface.Name].Add(extension);
}
}
catch (MissingMethodException)
{
// do nothing, we tried to load a interface.
}
}
}
catch (Exception ex)
{
APILogger.LogError(ex, $"Error loading interface {iface.Name} on type {type.Name}");
}
}
}
catch (Exception) { }
}
}
public static void AddItemTypes(Dictionary <string, ItemTypesServer.ItemTypeRaw> itemTypes)
{
foreach (var extension in GetCallbacks <IAddItemTypesExtender>())
{
try
{
extension.AddItemTypes(itemTypes);
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
public static void Register()
{
foreach (var extension in GetCallbacks <IOnAddResearchablesExtender>())
{
try
{
extension.OnAddResearchables();
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
private static void UpdateMagicItemms(ColonyState state)
{
try
{
if (state.MagicUpdateTime < Time.SecondsSinceStartDouble)
{
var colony = state.ColonyRef;
foreach (var follower in colony.Followers)
{
var inv = ColonistInventory.Get(follower);
if (inv.MagicItemUpdateTime < Time.SecondsSinceStartDouble)
{
foreach (var item in inv.Armor)
{
if (item.Value.Id != 0 && ArmorFactory.ArmorLookup.TryGetValue(item.Value.Id, out var armor))
{
armor.Update();
if (armor.HPTickRegen != 0)
{
follower.Heal(armor.HPTickRegen);
}
}
}
if (WeaponFactory.WeaponLookup.TryGetValue(inv.Weapon.Id, out var wep))
{
wep.Update();
if (wep.HPTickRegen != 0)
{
follower.Heal(wep.HPTickRegen);
}
}
inv.MagicItemUpdateTime = Time.SecondsSinceStartDouble + Random.Next(3, 5);
}
}
state.MagicUpdateTime = Time.SecondsSinceStartDouble + 5;
}
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
public static void AfterModsLoaded(List <ModLoader.ModDescription> list)
{
LoadExtenstions(list);
LoadImplementation(list);
foreach (var extension in GetCallbacks <IAfterModsLoadedExtention>())
{
try
{
extension.AfterModsLoaded(list);
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
public static void OnConstructInventoryManageColonyUI(Players.Player player, NetworkMenu networkMenu)
{
if (_settlersExtensions.TryGetValue(nameof(IOnConstructInventoryManageColonyUIExtender), out var pandarosExtentions))
{
foreach (var extension in pandarosExtentions.Select(ex => ex as IOnConstructInventoryManageColonyUIExtender))
{
try
{
extension.OnConstructInventoryManageColonyUI(player, networkMenu);
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
}
public static void OnCreatedColony(Colony c)
{
if (_settlersExtensions.TryGetValue(nameof(IOnColonyCreatedExtender), out var pandarosExtentions))
{
foreach (var extension in pandarosExtentions.Select(ex => ex as IOnColonyCreatedExtender))
{
try
{
extension.ColonyCreated(c);
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
}
public static void AfterWorldLoad()
{
if (_settlersExtensions.TryGetValue(nameof(IAfterWorldLoadExtender), out var pandarosExtentions))
{
foreach (var extension in pandarosExtentions.Select(ex => ex as IAfterWorldLoadExtender))
{
try
{
extension.AfterWorldLoad();
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
}
public static void Register()
{
if (_settlersExtensions.TryGetValue(nameof(IOnAddResearchablesExtender), out var pandarosExtentions))
{
foreach (var extension in pandarosExtentions.Select(ex => ex as IOnAddResearchablesExtender))
{
try
{
extension.OnAddResearchables();
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
}
public static void OnLoadingColony(Colony c, JSONNode n)
{
if (_settlersExtensions.TryGetValue(nameof(IOnLoadingColonyExtender), out var pandarosExtentions))
{
foreach (var extension in pandarosExtentions.Select(ex => ex as IOnLoadingColonyExtender))
{
try
{
extension.OnLoadingColony(c, n);
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
}
public static void AddItemTypes(Dictionary <string, ItemTypesServer.ItemTypeRaw> itemTypes)
{
if (_settlersExtensions.TryGetValue(nameof(IAddItemTypesExtender), out var pandarosExtentions))
{
foreach (var extension in pandarosExtentions.Select(ex => ex as IAddItemTypesExtender))
{
try
{
extension.AddItemTypes(itemTypes);
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
}
public static void OnUpdate()
{
foreach (var extension in _timedUpdate)
{
try
{
if (extension.NextUpdateTime < Time.SecondsSinceStartDouble)
{
extension.OnTimedUpdate();
extension.NextUpdateTime = Time.SecondsSinceStartDouble + Pipliz.Random.NextDouble(extension.NextUpdateTimeMin, extension.NextUpdateTimeMax);
}
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
public static void AfterItemTypesDefined()
{
APILogger.Log("{0} objective types loaded", ObjectiveCallbacks.Count);
foreach (var cKvp in _loadedColonies)
{
var c = cKvp.Key;
var n = cKvp.Value;
if (n.TryGetChild(GameInitializer.NAMESPACE + ".Objectives", out var objectivesNode))
{
lock (Objectives)
{
int countLoaded = 0;
foreach (var node in objectivesNode.LoopArray())
{
try
{
RegisterRoamingJobState(c, new RoamingJobState(node, c));
countLoaded++;
}
catch (Exception ex)
{
APILogger.LogError(ex, node.ToString());
}
}
if (Objectives.ContainsKey(c))
{
APILogger.LogToFile($"{countLoaded} of {Objectives[c].Count} objectives loaded from save for {c.ColonyID}!");
}
else
{
APILogger.LogToFile($"No objectives found in save for {c.ColonyID}.");
}
}
}
else
{
APILogger.LogToFile($"No objectives found in save for {c.ColonyID}.");
}
}
}
public static void AfterModsLoaded(List <ModLoader.ModDescription> list)
{
LoadExtenstions(list);
LoadImplementation(list);
if (_settlersExtensions.TryGetValue(nameof(IAfterModsLoadedExtention), out var pandarosExtentions))
{
foreach (var extension in pandarosExtentions.Select(ex => ex as IAfterModsLoadedExtention))
{
try
{
extension.AfterModsLoaded(list);
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
}
}
}
public JSONNode ToJsonNode()
{
var baseNode = new JSONNode();
try
{
baseNode[nameof(SettlerId)] = new JSONNode(SettlerId);
baseNode[nameof(ColonistsName)] = new JSONNode(ColonistsName);
var skills = new JSONNode();
foreach (var job in BonusProcs)
{
skills[job.Key.ToString()] = new JSONNode(job.Value);
}
baseNode[nameof(BonusProcs)] = skills;
var statsNode = new JSONNode();
foreach (var job in Stats)
{
statsNode[job.Key] = new JSONNode(job.Value);
}
baseNode[nameof(Stats)] = statsNode;
foreach (ArmorFactory.ArmorSlot armorType in ArmorFactory.ArmorSlotEnum)
{
baseNode[armorType.ToString()] = Armor[armorType].ToJsonNode();
}
}
catch (Exception ex)
{
APILogger.LogError(ex);
}
return(baseNode);
}
