public static void AddEnemyToDatabase(GameObject EnemyPrefab, string EnemyGUID, bool isInBossTab = false, bool IsNormalEnemy = true, bool AddToMTGSpawnPool = true)
{
EnemyDatabaseEntry item = new EnemyDatabaseEntry
{
myGuid = EnemyGUID,
placeableWidth = 2,
placeableHeight = 2,
isNormalEnemy = IsNormalEnemy,
path = EnemyGUID,
isInBossTab = isInBossTab,
encounterGuid = EnemyGUID
};
EnemyDatabase.Instance.Entries.Add(item);
SpecialResources.resources.Add(EnemyGUID, EnemyPrefab);
EncounterDatabaseEntry encounterDatabaseEntry = new EncounterDatabaseEntry(EnemyPrefab.GetComponent <AIActor>().encounterTrackable)
{
path = EnemyGUID,
myGuid = EnemyPrefab.GetComponent <AIActor>().encounterTrackable.EncounterGuid
};
EncounterDatabase.Instance.Entries.Add(encounterDatabaseEntry);
if (AddToMTGSpawnPool && !string.IsNullOrEmpty(EnemyPrefab.GetComponent <AIActor>().ActorName))
{
string EnemyName = "spapi:" + EnemyPrefab.GetComponent <AIActor>().ActorName.Replace(" ", "_").Replace("(", "_").Replace(")", string.Empty).ToLower();
if (!Game.Enemies.ContainsID(EnemyName))
{
Game.Enemies.Add(EnemyName, EnemyPrefab.GetComponent <AIActor>());
}
}
}
public static void SetupUnlockOnFlag(this PickupObject self, GungeonFlags flag, bool requiredFlagValue) //thanks SpAPI
{
EncounterTrackable encounterTrackable = self.encounterTrackable;
bool flag2 = encounterTrackable.prerequisites == null;
if (flag2)
{
encounterTrackable.prerequisites = new DungeonPrerequisite[1];
encounterTrackable.prerequisites[0] = new DungeonPrerequisite
{
prerequisiteType = DungeonPrerequisite.PrerequisiteType.FLAG,
requireFlag = requiredFlagValue,
saveFlagToCheck = flag
};
}
else
{
encounterTrackable.prerequisites = encounterTrackable.prerequisites.Concat(new DungeonPrerequisite[]
{
new DungeonPrerequisite
{
prerequisiteType = DungeonPrerequisite.PrerequisiteType.FLAG,
requireFlag = requiredFlagValue,
saveFlagToCheck = flag
}
}).ToArray <DungeonPrerequisite>();
}
EncounterDatabaseEntry entry = EncounterDatabase.GetEntry(encounterTrackable.EncounterGuid);
bool flag3 = !string.IsNullOrEmpty(entry.ProxyEncounterGuid);
if (flag3)
{
entry.ProxyEncounterGuid = "";
}
bool flag4 = entry.prerequisites == null;
if (flag4)
{
entry.prerequisites = new DungeonPrerequisite[1];
entry.prerequisites[0] = new DungeonPrerequisite
{
prerequisiteType = DungeonPrerequisite.PrerequisiteType.FLAG,
requireFlag = requiredFlagValue,
saveFlagToCheck = flag
};
}
else
{
entry.prerequisites = entry.prerequisites.Concat(new DungeonPrerequisite[]
{
new DungeonPrerequisite
{
prerequisiteType = DungeonPrerequisite.PrerequisiteType.FLAG,
requireFlag = requiredFlagValue,
saveFlagToCheck = flag
}
}).ToArray <DungeonPrerequisite>();
}
}
public int Add(PickupObject value, bool updateSpriteCollections = false, string floor = "ANY")
{
int id = PickupObjectDatabase.Instance.Objects.Count;
PickupObjectDatabase.Instance.Objects.Add(value);
ModItems.Add(value);
if (value != null)
{
UnityEngine.Object.DontDestroyOnLoad(value.gameObject);
ModItemMap[value.name] = value;
value.PickupObjectId = id;
EncounterDatabaseEntry edbEntry = new EncounterDatabaseEntry(value.encounterTrackable);
edbEntry.ProxyEncounterGuid =
edbEntry.myGuid = value.encounterTrackable.EncounterGuid;
edbEntry.path = "Assets/Resources/ITEMDB:" + value.name + ".prefab";
EncounterDatabase.Instance.Entries.Add(edbEntry);
WeightedGameObject lootGameObject = new WeightedGameObject()
{
// gameObject = value.gameObject,
weight = 1f,
additionalPrerequisites = new DungeonPrerequisite[0]
};
lootGameObject.SetGameObject(value.gameObject);
if (value is Gun)
{
GameManager.Instance.RewardManager.GunsLootTable.defaultItemDrops.Add(lootGameObject);
}
else
{
GameManager.Instance.RewardManager.ItemsLootTable.defaultItemDrops.Add(lootGameObject);
}
List <WeightedGameObject> loot;
if (!ModLootPerFloor.TryGetValue(floor, out loot))
{
loot = new List <WeightedGameObject>();
}
loot.Add(lootGameObject);
ModLootPerFloor[floor] = loot;
}
if (updateSpriteCollections)
{
AmmonomiconController.ForceInstance.EncounterIconCollection.Handle();
if (value is Gun)
{
WeaponCollection.Handle();
WeaponCollection02.Handle();
ProjectileCollection.Handle();
}
else
{
ItemCollection.Handle();
}
}
return(id);
}
/// <summary>
/// Creates a new <c>EncounterDatabaseEntry</c>.
/// </summary>
/// <returns>The new encounter database entry.</returns>
/// <param name="enc_track">Encounter trackable object.</param>
/// <param name="path">String to set as the asset path.</param>
public static EncounterDatabaseEntry CreateEncounterDatabaseEntry(EncounterTrackable enc_track, string path)
{
var enc_entry = new EncounterDatabaseEntry(enc_track);
enc_entry.path = path;
enc_entry.unityGuid = enc_entry.myGuid = enc_track.EncounterGuid;
return(enc_entry);
}
public static void AddEnemyToDatabase(GameObject EnemyPrefab, string EnemyGUID)
{
EnemyDatabaseEntry item = new EnemyDatabaseEntry
{
myGuid = EnemyGUID,
placeableWidth = 2,
placeableHeight = 2,
isNormalEnemy = true,
path = EnemyGUID,
isInBossTab = false,
encounterGuid = EnemyGUID
};
EnemyDatabase.Instance.Entries.Add(item);
EncounterDatabaseEntry encounterDatabaseEntry = new EncounterDatabaseEntry(EnemyPrefab.GetComponent <AIActor>().encounterTrackable)
{
path = EnemyGUID,
myGuid = EnemyPrefab.GetComponent <AIActor>().encounterTrackable.EncounterGuid
};
EncounterDatabase.Instance.Entries.Add(encounterDatabaseEntry);
}
public bool CheckConditionsFulfilledOrig()
{
EncounterDatabaseEntry encounterDatabaseEntry = null;
if (!string.IsNullOrEmpty(this.encounteredObjectGuid))
{
encounterDatabaseEntry = EncounterDatabase.GetEntry(this.encounteredObjectGuid);
}
switch (this.prerequisiteType)
{
case DungeonPrerequisite.PrerequisiteType.ENCOUNTER:
if (encounterDatabaseEntry == null && this.encounteredRoom == null)
{
return(true);
}
if (encounterDatabaseEntry != null)
{
int num = GameStatsManager.Instance.QueryEncounterable(encounterDatabaseEntry);
switch (this.prerequisiteOperation)
{
case DungeonPrerequisite.PrerequisiteOperation.LESS_THAN:
return(num < this.requiredNumberOfEncounters);
case DungeonPrerequisite.PrerequisiteOperation.EQUAL_TO:
return(num == this.requiredNumberOfEncounters);
case DungeonPrerequisite.PrerequisiteOperation.GREATER_THAN:
return(num > this.requiredNumberOfEncounters);
default:
Debug.LogError("Switching on invalid stat comparison operation!");
break;
}
}
else if (this.encounteredRoom != null)
{
int num2 = GameStatsManager.Instance.QueryRoomEncountered(this.encounteredRoom.GUID);
switch (this.prerequisiteOperation)
{
case DungeonPrerequisite.PrerequisiteOperation.LESS_THAN:
return(num2 < this.requiredNumberOfEncounters);
case DungeonPrerequisite.PrerequisiteOperation.EQUAL_TO:
return(num2 == this.requiredNumberOfEncounters);
case DungeonPrerequisite.PrerequisiteOperation.GREATER_THAN:
return(num2 > this.requiredNumberOfEncounters);
default:
Debug.LogError("Switching on invalid stat comparison operation!");
break;
}
}
return(false);
case DungeonPrerequisite.PrerequisiteType.COMPARISON:
{
float playerStatValue = GameStatsManager.Instance.GetPlayerStatValue(this.statToCheck);
switch (this.prerequisiteOperation)
{
case DungeonPrerequisite.PrerequisiteOperation.LESS_THAN:
return(playerStatValue < this.comparisonValue);
case DungeonPrerequisite.PrerequisiteOperation.EQUAL_TO:
return(playerStatValue == this.comparisonValue);
case DungeonPrerequisite.PrerequisiteOperation.GREATER_THAN:
return(playerStatValue > this.comparisonValue);
default:
Debug.LogError("Switching on invalid stat comparison operation!");
break;
}
break;
}
case DungeonPrerequisite.PrerequisiteType.CHARACTER:
{
PlayableCharacters playableCharacters = (PlayableCharacters)(-1);
if (!BraveRandom.IgnoreGenerationDifferentiator)
{
if (GameManager.Instance.PrimaryPlayer != null)
{
playableCharacters = GameManager.Instance.PrimaryPlayer.characterIdentity;
}
else if (GameManager.PlayerPrefabForNewGame != null)
{
playableCharacters = GameManager.PlayerPrefabForNewGame.GetComponent <PlayerController>().characterIdentity;
}
else if (GameManager.Instance.BestGenerationDungeonPrefab != null)
{
playableCharacters = GameManager.Instance.BestGenerationDungeonPrefab.defaultPlayerPrefab.GetComponent <PlayerController>().characterIdentity;
}
}
return(this.requireCharacter == (playableCharacters == this.requiredCharacter));
}
case DungeonPrerequisite.PrerequisiteType.TILESET:
if (GameManager.Instance.BestGenerationDungeonPrefab != null)
{
return(this.requireTileset == (GameManager.Instance.BestGenerationDungeonPrefab.tileIndices.tilesetId == this.requiredTileset));
}
return(this.requireTileset == (GameManager.Instance.Dungeon.tileIndices.tilesetId == this.requiredTileset));
case DungeonPrerequisite.PrerequisiteType.FLAG:
return(GameStatsManager.Instance.GetFlag(this.saveFlagToCheck) == this.requireFlag);
case DungeonPrerequisite.PrerequisiteType.DEMO_MODE:
return(!this.requireDemoMode);
case DungeonPrerequisite.PrerequisiteType.MAXIMUM_COMPARISON:
{
float playerMaximum = GameStatsManager.Instance.GetPlayerMaximum(this.maxToCheck);
switch (this.prerequisiteOperation)
{
case DungeonPrerequisite.PrerequisiteOperation.LESS_THAN:
return(playerMaximum < this.comparisonValue);
case DungeonPrerequisite.PrerequisiteOperation.EQUAL_TO:
return(playerMaximum == this.comparisonValue);
case DungeonPrerequisite.PrerequisiteOperation.GREATER_THAN:
return(playerMaximum > this.comparisonValue);
default:
Debug.LogError("Switching on invalid stat comparison operation!");
break;
}
break;
}
case DungeonPrerequisite.PrerequisiteType.ENCOUNTER_OR_FLAG:
if (GameStatsManager.Instance.GetFlag(this.saveFlagToCheck) == this.requireFlag)
{
return(true);
}
if (encounterDatabaseEntry != null)
{
int num3 = GameStatsManager.Instance.QueryEncounterable(encounterDatabaseEntry);
switch (this.prerequisiteOperation)
{
case DungeonPrerequisite.PrerequisiteOperation.LESS_THAN:
return(num3 < this.requiredNumberOfEncounters);
case DungeonPrerequisite.PrerequisiteOperation.EQUAL_TO:
return(num3 == this.requiredNumberOfEncounters);
case DungeonPrerequisite.PrerequisiteOperation.GREATER_THAN:
return(num3 > this.requiredNumberOfEncounters);
default:
Debug.LogError("Switching on invalid stat comparison operation!");
break;
}
}
else if (this.encounteredRoom != null)
{
int num4 = GameStatsManager.Instance.QueryRoomEncountered(this.encounteredRoom.GUID);
switch (this.prerequisiteOperation)
{
case DungeonPrerequisite.PrerequisiteOperation.LESS_THAN:
return(num4 < this.requiredNumberOfEncounters);
case DungeonPrerequisite.PrerequisiteOperation.EQUAL_TO:
return(num4 == this.requiredNumberOfEncounters);
case DungeonPrerequisite.PrerequisiteOperation.GREATER_THAN:
return(num4 > this.requiredNumberOfEncounters);
default:
Debug.LogError("Switching on invalid stat comparison operation!");
break;
}
}
return(false);
case DungeonPrerequisite.PrerequisiteType.NUMBER_PASTS_COMPLETED:
return((float)GameStatsManager.Instance.GetNumberPastsBeaten() >= this.comparisonValue);
default:
Debug.LogError("Switching on invalid prerequisite type!!!");
break;
}
return(false);
}
/// <summary>
/// Overridable condition checker method
/// </summary>
/// <returns><see langword="true"/> if all conditions are fulfilled</returns>
public virtual new bool CheckConditionsFulfilled()
{
if (this.advancedPrerequisiteType == AdvancedPrerequisiteType.CUSTOM_FLAG)
{
return(AdvancedGameStatsManager.Instance.GetFlag(this.customFlagToCheck) == this.requireCustomFlag);
}
else if (this.advancedPrerequisiteType == AdvancedPrerequisiteType.CUSTOM_STAT_COMPARISION)
{
float playerStatValue = AdvancedGameStatsManager.Instance.GetPlayerStatValue(this.customStatToCheck);
switch (this.prerequisiteOperation)
{
case PrerequisiteOperation.LESS_THAN:
return(playerStatValue < this.comparisonValue);
case PrerequisiteOperation.EQUAL_TO:
return(playerStatValue == this.comparisonValue);
case PrerequisiteOperation.GREATER_THAN:
return(playerStatValue > this.comparisonValue);
default:
Debug.LogError("Switching on invalid stat comparison operation!");
break;
}
}
else if (this.advancedPrerequisiteType == AdvancedPrerequisiteType.CUSTOM_MAXIMUM_COMPARISON)
{
float playerMaximum = AdvancedGameStatsManager.Instance.GetPlayerMaximum(this.customMaximumToCheck);
switch (this.prerequisiteOperation)
{
case PrerequisiteOperation.LESS_THAN:
return(playerMaximum < this.comparisonValue);
case PrerequisiteOperation.EQUAL_TO:
return(playerMaximum == this.comparisonValue);
case PrerequisiteOperation.GREATER_THAN:
return(playerMaximum > this.comparisonValue);
default:
Debug.LogError("Switching on invalid stat comparison operation!");
break;
}
}
else if (this.advancedPrerequisiteType == AdvancedPrerequisiteType.NUMBER_PASTS_COMPLETED_BETTER)
{
float pastsBeaten = GameStatsManager.Instance.GetNumberPastsBeaten();
switch (this.prerequisiteOperation)
{
case PrerequisiteOperation.LESS_THAN:
return(pastsBeaten < this.comparisonValue);
case PrerequisiteOperation.EQUAL_TO:
return(pastsBeaten == this.comparisonValue);
case PrerequisiteOperation.GREATER_THAN:
return(pastsBeaten > this.comparisonValue);
default:
Debug.LogError("Switching on invalid stat comparison operation!");
break;
}
}
else if (this.advancedPrerequisiteType == AdvancedPrerequisiteType.ENCOUNTER_OR_CUSTOM_FLAG)
{
EncounterDatabaseEntry encounterDatabaseEntry = null;
if (!string.IsNullOrEmpty(this.encounteredObjectGuid))
{
encounterDatabaseEntry = EncounterDatabase.GetEntry(this.encounteredObjectGuid);
}
if (AdvancedGameStatsManager.Instance.GetFlag(this.customFlagToCheck) == this.requireCustomFlag)
{
return(true);
}
if (encounterDatabaseEntry != null)
{
int num3 = GameStatsManager.Instance.QueryEncounterable(encounterDatabaseEntry);
switch (this.prerequisiteOperation)
{
case PrerequisiteOperation.LESS_THAN:
return(num3 < this.requiredNumberOfEncounters);
case PrerequisiteOperation.EQUAL_TO:
return(num3 == this.requiredNumberOfEncounters);
case PrerequisiteOperation.GREATER_THAN:
return(num3 > this.requiredNumberOfEncounters);
default:
Debug.LogError("Switching on invalid stat comparison operation!");
break;
}
}
else if (this.encounteredRoom != null)
{
int num4 = GameStatsManager.Instance.QueryRoomEncountered(this.encounteredRoom.GUID);
switch (this.prerequisiteOperation)
{
case PrerequisiteOperation.LESS_THAN:
return(num4 < this.requiredNumberOfEncounters);
case PrerequisiteOperation.EQUAL_TO:
return(num4 == this.requiredNumberOfEncounters);
case PrerequisiteOperation.GREATER_THAN:
return(num4 > this.requiredNumberOfEncounters);
default:
Debug.LogError("Switching on invalid stat comparison operation!");
break;
}
}
return(false);
}
else
{
return(this.CheckConditionsFulfilledOrig());
}
return(false);
}
public static void SetupUnlockOnStat(this PickupObject self, TrackedStats stat, DungeonPrerequisite.PrerequisiteOperation operation, int comparisonValue)
{
EncounterTrackable encounterTrackable = self.encounterTrackable;
bool flag = encounterTrackable.prerequisites == null;
if (flag)
{
encounterTrackable.prerequisites = new DungeonPrerequisite[1];
encounterTrackable.prerequisites[0] = new DungeonPrerequisite
{
prerequisiteType = DungeonPrerequisite.PrerequisiteType.COMPARISON,
prerequisiteOperation = operation,
statToCheck = stat,
comparisonValue = (float)comparisonValue
};
}
else
{
encounterTrackable.prerequisites = encounterTrackable.prerequisites.Concat(new DungeonPrerequisite[]
{
new DungeonPrerequisite
{
prerequisiteType = DungeonPrerequisite.PrerequisiteType.COMPARISON,
prerequisiteOperation = operation,
statToCheck = stat,
comparisonValue = (float)comparisonValue
}
}).ToArray <DungeonPrerequisite>();
}
EncounterDatabaseEntry entry = EncounterDatabase.GetEntry(encounterTrackable.EncounterGuid);
bool flag2 = !string.IsNullOrEmpty(entry.ProxyEncounterGuid);
if (flag2)
{
entry.ProxyEncounterGuid = "";
}
bool flag3 = entry.prerequisites == null;
if (flag3)
{
entry.prerequisites = new DungeonPrerequisite[1];
entry.prerequisites[0] = new DungeonPrerequisite
{
prerequisiteType = DungeonPrerequisite.PrerequisiteType.COMPARISON,
prerequisiteOperation = operation,
statToCheck = stat,
comparisonValue = (float)comparisonValue
};
}
else
{
entry.prerequisites = entry.prerequisites.Concat(new DungeonPrerequisite[]
{
new DungeonPrerequisite
{
prerequisiteType = DungeonPrerequisite.PrerequisiteType.COMPARISON,
prerequisiteOperation = operation,
statToCheck = stat,
comparisonValue = (float)comparisonValue
}
}).ToArray <DungeonPrerequisite>();
}
}
