public bool Inject(ModHelperDef def)
{
if (def.PostLoadInjectors.NullOrEmpty())
{
return(true);
}
foreach (var injectorType in def.PostLoadInjectors)
{
try
{
var injectorObject = (SpecialInjector)Activator.CreateInstance(injectorType);
if (injectorObject == null)
{
CCL_Log.Message(string.Format("Unable to create instance of '{0}'", injectorType.ToString()));
return(false);
}
if (!injectorObject.Inject())
{
CCL_Log.Message(string.Format("Error injecting '{0}'", injectorType.ToString()));
return(false);
}
}
catch (Exception e)
{
CCL_Log.Message(e.ToString(), string.Format("Error injecting '{0}'", injectorType.ToString()));
return(false);
}
}
dictInjected.Add(def.defName, true);
return(true);
}
public bool Inject(ModHelperDef def)
{
if (def.MapComponents.NullOrEmpty())
{
return(true);
}
var existingComponents = Find.Map.components;
foreach (var componentType in def.MapComponents)
{
if (!existingComponents.Exists(c => c.GetType() == componentType))
{
var componentObject = (MapComponent)Activator.CreateInstance(componentType);
if (componentObject == null)
{
CCL_Log.Message(string.Format("Unable to create instance of '{0}'", componentType));
return(false);
}
existingComponents.Add(componentObject);
}
}
return(true);
}
public static void Log()
{
#if DEBUG
CCL_Log.Message("v" + Current + " (debug)");
#else
CCL_Log.Message("v" + Current);
#endif
}
public bool Inject(ModHelperDef def)
{
if (def.ThingComps.NullOrEmpty())
{
return(true);
}
for (var index = 0; index < def.ThingComps.Count; index++)
{
var injectionSet = def.ThingComps[index];
if (
(!injectionSet.requiredMod.NullOrEmpty()) &&
(Find_Extensions.ModByName(injectionSet.requiredMod) == null)
)
{
continue;
}
var thingDefs = DefInjectionQualifier.FilteredThingDefs(injectionSet.qualifier, ref injectionSet.qualifierInt, injectionSet.targetDefs);
if (!thingDefs.NullOrEmpty())
{
#if DEBUG
var stringBuilder = new StringBuilder();
stringBuilder.Append("ThingComps :: Qualifier returned: ");
#endif
foreach (var thingDef in thingDefs)
{
#if DEBUG
stringBuilder.Append(thingDef.defName + ", ");
#endif
// TODO: Make a full copy using the comp in this def as a template
// Currently adds the comp in this def so all target use the same def
if (!thingDef.HasComp(injectionSet.compProps.compClass))
{
thingDef.comps.Add(injectionSet.compProps);
}
}
#if DEBUG
CCL_Log.Message(stringBuilder.ToString(), def.ModName);
#endif
}
}
return(true);
}
public bool Inject(ModHelperDef def)
{
if (def.ITabs.NullOrEmpty())
{
return(true);
}
for (var index = 0; index < def.ITabs.Count; index++)
{
var injectionSet = def.ITabs[index];
if (
(!injectionSet.requiredMod.NullOrEmpty()) &&
(Find_Extensions.ModByName(injectionSet.requiredMod) == null)
)
{
continue;
}
var thingDefs = DefInjectionQualifier.FilteredThingDefs(injectionSet.qualifier, ref injectionSet.qualifierInt, injectionSet.targetDefs);
if (!thingDefs.NullOrEmpty())
{
#if DEBUG
var stringBuilder = new StringBuilder();
stringBuilder.Append("ITabs :: Qualifier returned: ");
#endif
foreach (var thingDef in thingDefs)
{
#if DEBUG
stringBuilder.Append(thingDef.defName + ", ");
#endif
if (!InjectITab(injectionSet.newITab, injectionSet.replaceITab, thingDef))
{
return(false);
}
}
#if DEBUG
CCL_Log.Message(stringBuilder.ToString(), def.ModName);
#endif
}
}
return(true);
}
public bool Inject(ModHelperDef def)
{
if (def.Facilities.NullOrEmpty())
{
return(true);
}
for (var index = 0; index < def.Facilities.Count; index++)
{
var injectionSet = def.Facilities[index];
if (
(!injectionSet.requiredMod.NullOrEmpty()) &&
(Find_Extensions.ModByName(injectionSet.requiredMod) == null)
)
{
continue;
}
var facilityDef = DefDatabase <ThingDef> .GetNamed(injectionSet.facility);
var thingDefs = DefInjectionQualifier.FilteredThingDefs(injectionSet.qualifier, ref injectionSet.qualifierInt, injectionSet.targetDefs);
if (!thingDefs.NullOrEmpty())
{
#if DEBUG
var stringBuilder = new StringBuilder();
stringBuilder.Append("Facilities :: Qualifier returned: ");
#endif
foreach (var thingDef in thingDefs)
{
#if DEBUG
stringBuilder.Append(thingDef.defName + ", ");
#endif
LinkFacility(thingDef, facilityDef);
}
#if DEBUG
CCL_Log.Message(stringBuilder.ToString(), def.ModName);
#endif
}
}
return(true);
}
public override bool Inject()
{
CCL_Log.Message("PostLoadInjectorTest - Injected");
return(true);
}
public override void ResolveReferences()
{
base.ResolveReferences();
if (!this.addToDatabase)
{
return;
}
if (BackstoryDatabase.allBackstories.ContainsKey(this.UniqueSaveKey()))
{
return;
}
Backstory b = new Backstory();
if (!this.title.NullOrEmpty())
{
b.title = this.title;
}
else
{
CCL_Log.Error(defName + " backstory has empty title. Skipping...", "Backstories");
return;
}
if (!titleShort.NullOrEmpty())
{
b.titleShort = titleShort;
}
else
{
b.titleShort = b.title;
}
if (!baseDescription.NullOrEmpty())
{
b.baseDesc = baseDescription;
}
else
{
CCL_Log.Message(defName + " backstory has empty description.", "Backstories");
b.baseDesc = "Empty.";
}
b.bodyTypeGlobal = bodyTypeGlobal;
b.bodyTypeMale = bodyTypeMale;
b.bodyTypeFemale = bodyTypeFemale;
b.slot = slot;
b.shuffleable = shuffleable;
if (spawnCategories.NullOrEmpty())
{
CCL_Log.Error(defName + " backstory doesn't have any spawn categories defined. Skipping...", "Backstories");
return;
}
else
{
b.spawnCategories = spawnCategories;
}
if (workAllows.Count > 0)
{
foreach (WorkTags current in Enum.GetValues(typeof(WorkTags)))
{
if (!workAllows.Contains(current))
{
b.workDisables |= current;
}
}
}
else if (workDisables.Count > 0)
{
foreach (var tag in workDisables)
{
b.workDisables |= tag;
}
}
else
{
b.workDisables = WorkTags.None;
}
b.skillGains = skillGains.ToDictionary(i => i.defName, i => i.amount);
if (forcedTraits.Count > 0)
{
b.forcedTraits = new List <TraitEntry>();
foreach (var trait in forcedTraits)
{
var newTrait = new TraitEntry(trait.def, trait.degree);
b.forcedTraits.Add(newTrait);
}
}
if (disallowedTraits.Count > 0)
{
b.disallowedTraits = new List <TraitEntry>();
foreach (var trait in disallowedTraits)
{
var newTrait = new TraitEntry(trait.def, trait.degree);
b.disallowedTraits.Add(newTrait);
}
}
b.ResolveReferences();
b.PostLoad();
b.uniqueSaveKey = this.UniqueSaveKey();
bool flag = false;
foreach (var s in b.ConfigErrors(false))
{
if (!flag)
{
flag = true;
CCL_Log.Error("Errors in custom backstory with defName: " + defName + ", backstory will be skipped.", "Backstories");
}
CCL_Log.Error(defName + " error: " + s, "Backstories");
}
if (!flag)
{
BackstoryDatabase.AddBackstory(b);
//CCL_Log.Message("Added " + this.UniqueSaveKey() + " backstory", "Backstories");
}
}
public bool Inject(ModHelperDef def)
{
if (def.Designators.NullOrEmpty())
{
return(true);
}
foreach (var designatorData in def.Designators)
{
// Get the category
var designationCategory = DefDatabase <DesignationCategoryDef> .GetNamed(designatorData.designationCategoryDef, false);
// First instatiate and inject the designator into the list of resolved designators
if (!designationCategory.resolvedDesignators.Exists(d => d.GetType() == designatorData.designatorClass))
{
// Create the new designator
var designatorObject = (Designator)Activator.CreateInstance(designatorData.designatorClass);
if (designatorObject == null)
{
CCL_Log.Message(string.Format("Unable to create instance of '{0}'", designatorData.designatorClass));
return(false);
}
if (designatorData.designatorNextTo == null)
{
// Inject the designator
designationCategory.resolvedDesignators.Add(designatorObject);
}
else
{
// Prefers to be beside a specific designator
var designatorIndex = designationCategory.resolvedDesignators.FindIndex(d => (
(d.GetType() == designatorData.designatorNextTo)
));
if (designatorIndex < 0)
{
// Other designator doesn't exist (yet?)
// Inject the designator at the end
designationCategory.resolvedDesignators.Add(designatorObject);
}
else
{
// Inject beside desired designator
designationCategory.resolvedDesignators.Insert(designatorIndex + 1, designatorObject);
}
}
}
// Now inject the designator class into the list of classes as a saftey net for another mod resolving the category
if (!designationCategory.specialDesignatorClasses.Exists(s => s == designatorData.designatorClass))
{
if (designatorData.designatorNextTo == null)
{
// Inject the designator class at the end of the list
designationCategory.specialDesignatorClasses.Add(designatorData.designatorClass);
}
else
{
// Prefers to be beside a specific designator
var designatorIndex = designationCategory.specialDesignatorClasses.FindIndex(s => s == designatorData.designatorNextTo);
if (designatorIndex < 0)
{
// Can't find desired designator class
// Inject the designator at the end
designationCategory.specialDesignatorClasses.Add(designatorData.designatorClass);
}
else
{
// Inject beside desired designator class
designationCategory.specialDesignatorClasses.Insert(designatorIndex + 1, designatorData.designatorClass);
}
}
}
}
return(true);
}
public bool Inject(ModHelperDef def)
{
if (def.ThingDefAvailability.NullOrEmpty())
{
return(true);
}
for (int index = 0; index < def.ThingDefAvailability.Count; ++index)
{
var injectionSet = def.ThingDefAvailability[index];
if (
(!injectionSet.requiredMod.NullOrEmpty()) &&
(Find_Extensions.ModByName(injectionSet.requiredMod) == null)
)
{
continue;
}
var thingDefs = DefInjectionQualifier.FilteredThingDefs(injectionSet.qualifier, ref injectionSet.qualifierInt, injectionSet.targetDefs);
if (!thingDefs.NullOrEmpty())
{
#if DEBUG
var stringBuilder = new StringBuilder();
stringBuilder.Append("ThingDefAvailability :: Qualifier returned: ");
#endif
bool setMenuHidden = !injectionSet.menuHidden.NullOrEmpty();
bool setDesignation = !injectionSet.designationCategory.NullOrEmpty();
bool setResearch = injectionSet.researchPrerequisites != null;
bool menuHidden = false;
List <ResearchProjectDef> research = null;
if (setMenuHidden)
{
menuHidden = injectionSet.menuHidden.ToLower() == "true" ? true : false;
}
if (
(setResearch) &&
(injectionSet.researchPrerequisites.Count > 0)
)
{
research = DefDatabase <ResearchProjectDef> .AllDefs.Where(projectDef => injectionSet.researchPrerequisites.Contains(projectDef.defName)).ToList();
}
foreach (var thingDef in thingDefs)
{
#if DEBUG
stringBuilder.Append(thingDef.defName + ", ");
#endif
if (setMenuHidden)
{
thingDef.menuHidden = menuHidden;
}
if (setDesignation)
{
thingDef.ChangeDesignationCategory(injectionSet.designationCategory);
}
if (setResearch)
{
thingDef.researchPrerequisites = research;
}
}
#if DEBUG
CCL_Log.Message(stringBuilder.ToString(), def.ModName);
#endif
}
}
dictInjected.Add(def.defName, true);
return(true);
}
