private void HandleTriggerCollision(SpeculativeRigidbody specRigidbody, SpeculativeRigidbody sourceSpecRigidbody, CollisionData collisionData)
{
PlayerController player = specRigidbody.GetComponent <PlayerController>();
AIActor aiActor = specRigidbody.GetComponent <AIActor>();
if (player)
{
if (!player.IsOnFire && player.IsGrounded && !player.IsSlidingOverSurface && player.healthHaver && player.healthHaver.IsVulnerable)
{
player.IsOnFire = true;
player.CurrentFireMeterValue += BraveTime.DeltaTime * 0.5f;
player.ApplyEffect(m_GoopDefinition.fireEffect);
}
}
else if (aiActor && aiActor.GetResistanceForEffectType(EffectResistanceType.Fire) < 1f)
{
float num = 0f;
if (aiActor.GetResistanceForEffectType(EffectResistanceType.Fire) < 1f)
{
num += 1f * BraveTime.DeltaTime;
}
aiActor.ApplyEffect(m_GoopDefinition.fireEffect);
if (num > 0f)
{
aiActor.healthHaver.ApplyDamage(num, Vector2.zero, StringTableManager.GetEnemiesString("#GOOP", -1), CoreDamageTypes.Fire, DamageCategory.Environment, false, null, false);
}
}
}
public void Awake()
{
System.Console.WriteLine("ENEMY OBJECTS");
for (int i = 0; i < EnemyDatabase.Instance.Entries.Count; i++)
{
var e = EnemyDatabase.Instance.Entries[i];
var name = "[ERROR]";
if (e == null)
{
name = "[NULL OBJECT]";
}
else
{
try {
var o = EnemyDatabase.GetOrLoadByGuid(e.myGuid);
var pdn = o.encounterTrackable?.journalData?.PrimaryDisplayName;
name = pdn != null?StringTableManager.GetEnemiesString(pdn) : o.ActorName ?? "[NULL NAME]";
} catch { }
}
Console.WriteLine($"{e.myGuid} {name}");
}
}
public static void DoEffectHook(Action <SpawnObjectPlayerItem, PlayerController> baseMethod, SpawnObjectPlayerItem self, PlayerController user)
{
if (self.IsCigarettes)
{
cigarettesUsed++;
float damage = 0.5f * cigarettesUsed;
bool dRoom = false;
bool dRun = user.HasTakenDamageThisRun;
bool dFloor = user.HasTakenDamageThisFloor;
if (user.CurrentRoom != null)
{
dRoom = user.CurrentRoom.PlayerHasTakenDamageInThisRoom;
}
user.healthHaver.NextDamageIgnoresArmor = true;
user.healthHaver.ApplyDamage(damage, Vector2.zero, StringTableManager.GetEnemiesString("#SMOKING", -1), CoreDamageTypes.None, DamageCategory.Normal, true, null, false);
user.HasTakenDamageThisRun = dRun;
user.HasTakenDamageThisFloor = dFloor;
if (user.CurrentRoom != null)
{
user.CurrentRoom.PlayerHasTakenDamageInThisRoom = dRoom;
}
StatModifier statModifier = new StatModifier();
statModifier.statToBoost = PlayerStats.StatType.Coolness;
statModifier.modifyType = StatModifier.ModifyMethod.ADDITIVE;
statModifier.amount = 1f;
user.ownerlessStatModifiers.Add(statModifier);
user.stats.RecalculateStats(user, false, false);
self.IsCigarettes = false;
baseMethod(self, user);
self.IsCigarettes = true;
}
else
{
baseMethod(self, user);
}
}
private void OopsDamage(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
PlayerController player = (GameManager.Instance.PrimaryPlayer);
this.DeathMark += 1f;
int healthInt = Convert.ToInt32(player.healthHaver.GetCurrentHealth() * 2);
int armorInt = Convert.ToInt32(player.healthHaver.Armor);
int total = healthInt + armorInt;
if (total <= DeathMark || total == DeathMark)
{
int num = 1;
if (num >= 0)
{
player.healthHaver.ApplyDamage(total, Vector2.zero, StringTableManager.GetEnemiesString("#SMOKING", -1), CoreDamageTypes.Void, DamageCategory.Unstoppable, true, null, false);
num--;
}
//base.Owner.healthHaver.Die(Vector2.zero);
}
}
public static string GetString(StringTable table, string key)
{
if (key.StartsWithInvariant("#"))
{
key = key.Substring(1);
}
switch (table)
{
case StringTable.Core: return(StringTableManager.GetString(key));
case StringTable.Enemies: return(StringTableManager.GetEnemiesString(key));
case StringTable.Intro: return(StringTableManager.GetIntroString(key));
case StringTable.Items: return(StringTableManager.GetItemsString(key));
case StringTable.Synergies: return(StringTableManager.GetSynergyString(key));
case StringTable.UI: return(Patches.dfLanguageManager.Instance.GetValue("#" + key));
}
return(key);
}
internal void AddDefaultCommands()
{
_LoggerSubscriber = (logger, loglevel, indent, str) => {
PrintLine(logger.String(loglevel, str, indent: indent), color: _LoggerColors[loglevel]);
};
AddCommand("!!", (args, histindex) => {
if (histindex - 1 < 0)
{
throw new Exception("Can't run previous command (history is empty).");
}
return(History.Execute(histindex.Value - 1));
});
AddCommand("!'", (args, histindex) => {
if (histindex - 1 < 0)
{
throw new Exception("Can't run previous command (history is empty).");
}
return(History.Entries[histindex.Value - 1]);
});
AddCommand("echo", (args) => {
return(string.Join(" ", args.ToArray()));
}).WithSubCommand("hello", (args) => {
return("Hello, world!\nHello, world!\nHello, world!\nHello, world!\nHello, world!\nHello, world!");
});
AddGroup("debug")
.WithSubCommand("spawn-rand-chest", (args) => {
var chest = GameManager.Instance.RewardManager.SpawnTotallyRandomChest(GameManager.Instance.PrimaryPlayer.CurrentRoom.GetRandomAvailableCellDumb());
return(chest.name);
})
//.WithSubCommand("force-dual-wield", (args) => {
// if (args.Count < 1) throw new Exception("At least 1 argument required.");
// var partner_id = int.Parse(args[0]);
// var player = GameManager.Instance.PrimaryPlayer;
// var gun = player.inventory.CurrentGun;
// var partner_gun = PickupObjectDatabase.GetById(partner_id) as Gun;
// player.inventory.AddGunToInventory(partner_gun);
// var forcer = gun.gameObject.AddComponent<DualWieldForcer>();
// forcer.Gun = gun;
// forcer.PartnerGunID = partner_gun.PickupObjectId;
// forcer.TargetPlayer = player;
// return "Done";
//})
.WithSubCommand("unexclude-all-items", (args) => {
foreach (var ent in PickupObjectDatabase.Instance.Objects)
{
if (ent == null)
{
continue;
}
ent.quality = PickupObject.ItemQuality.SPECIAL;
}
return("Done");
})
.WithSubCommand("activate-all-synergies", (args) => {
foreach (var ent in GameManager.Instance.SynergyManager.synergies)
{
if (ent == null)
{
continue;
}
ent.ActivationStatus = SynergyEntry.SynergyActivation.ACTIVE;
}
return("Done");
})
.WithSubCommand("character", (args) => {
if (args.Count < 1)
{
throw new Exception("At least 1 argument required.");
}
var player_controller = ModUntitled.Characters[args[0]];
if (player_controller == null)
{
throw new Exception($"Character '{args[0]}' doesn't exist.");
}
ModUntitled.Instance.StartCoroutine(_ChangeCharacter(player_controller, args.Count > 1));
return($"Changed character to {args[0]}");
})
.WithSubCommand("parser-bounds-test", (args) => {
var text = "echo Hello! \"Hello world!\" This\\ is\\ great \"It\"works\"with\"\\ wacky\" stuff\" \\[\\] \"\\[\\]\" [e[echo c][echo h][echo [echo \"o\"]] \"hel\"[echo lo][echo !]]";
CurrentCommandText = text;
return(null);
})
.WithSubCommand("giveid", (args) => {
if (args.Count < 1)
{
throw new Exception("Exactly 1 argument required.");
}
var pickup_obj = PickupObjectDatabase.Instance.InternalGetById(int.Parse(args[0]));
if (pickup_obj == null)
{
return("Item ID {args[0]} doesn't exist!");
}
LootEngine.TryGivePrefabToPlayer(pickup_obj.gameObject, GameManager.Instance.PrimaryPlayer, true);
return(pickup_obj.EncounterNameOrDisplayName);
});
//AddGroup("pool")
//.WithSubGroup(
// new Group("items")
// .WithSubCommand("idof", (args) => {
// if (args.Count < 1) throw new Exception("Exactly 1 argument required (numeric ID).");
// var id = int.Parse(args[0]);
// foreach (var pair in ModUntitled.Items.Pairs) {
// if (pair.Value.PickupObjectId == id) return pair.Key;
// }
// return "Entry not found.";
// })
// .WithSubCommand("nameof", (args) => {
// if (args.Count < 1) throw new Exception("Exactly 1 argument required (ID).");
// var id = args[0];
// foreach (var pair in ModUntitled.Items.Pairs) {
// if (pair.Key == id) return _GetPickupObjectName(pair.Value);
// }
// return "Entry not found.";
// })
// .WithSubCommand("numericof", (args) => {
// if (args.Count < 1) throw new Exception("Exactly 1 argument required (ID).");
// var id = args[0];
// foreach (var pair in ModUntitled.Items.Pairs) {
// if (pair.Key == id) return pair.Value.PickupObjectId.ToString();
// }
// return "Entry not found.";
// })
// .WithSubCommand("list", (args) => {
// var s = new StringBuilder();
// var pairs = new List<KeyValuePair<string, PickupObject>>();
// foreach (var pair in ModUntitled.Items.Pairs) {
// pairs.Add(pair);
// }
// foreach (var pair in pairs) {
// if (_GetPickupObjectName(pair.Value) == "NO NAME") {
// s.AppendLine($"[{pair.Key}] {_GetPickupObjectName(pair.Value)}");
// }
// }
// pairs.Sort((x, y) => string.Compare(_GetPickupObjectName(x.Value), _GetPickupObjectName(y.Value)));
// foreach (var pair in pairs) {
// if (_GetPickupObjectName(pair.Value) == "NO NAME") continue;
// s.AppendLine($"[{pair.Key}] {_GetPickupObjectName(pair.Value)}");
// }
// return s.ToString();
// })
// .WithSubCommand("random", (args) => {
// return ModUntitled.Items.RandomKey;
// })
//);
AddCommand("summon", (args) => {
var player = GameManager.Instance.PrimaryPlayer;
if (player == null)
{
throw new Exception("No player");
}
var cell = player.CurrentRoom.GetRandomAvailableCellDumb();
var entity = AIActor.Spawn(ModUntitled.Enemies[args[0]], cell, player.CurrentRoom, true, AIActor.AwakenAnimationType.Default, true);
if (ModUntitled.Enemies.HasTag(args[0], ModUntitled.EnemyTags.Friendly))
{
entity.CompanionOwner = player;
entity.CompanionSettings = new ActorCompanionSettings();
entity.CanTargetPlayers = false;
var companion = entity.GetComponent <CompanionController>();
if (companion != null)
{
companion.Initialize(player);
if (companion.specRigidbody)
{
PhysicsEngine.Instance.RegisterOverlappingGhostCollisionExceptions(companion.specRigidbody, null, false);
}
}
}
var name = args[0];
if (entity.encounterTrackable?.journalData?.PrimaryDisplayName != null)
{
name = StringTableManager.GetEnemiesString(entity.encounterTrackable?.journalData?.PrimaryDisplayName);
}
return(name);
});
//AddCommand("listmods", (args) => {
// var s = new StringBuilder();
// s.AppendLine("Loaded mods:");
// foreach (var mod in ModUntitled.ModLoader.LoadedMods) {
// _GetModInfo(s, mod);
// }
// return s.ToString();
//});
AddCommand("lua", (args) => {
LuaMode = true;
return("[entered lua mode]");
});
AddCommand("give", (args) => {
LootEngine.TryGivePrefabToPlayer(ModUntitled.Items[args[0]].gameObject, GameManager.Instance.PrimaryPlayer, true);
return(args[0]);
});
AddGroup("dump")
.WithSubCommand("synergy_chest", (args) => {
System.Console.WriteLine(ObjectDumper.Dump(GameManager.Instance.RewardManager.Synergy_Chest, depth: 10));
return("Dumped to log");
})
.WithSubCommand("synergies", (args) => {
var id = 0;
foreach (var synergy in GameManager.Instance.SynergyManager.synergies)
{
if (synergy.NameKey != null)
{
var name = StringTableManager.GetSynergyString(synergy.NameKey);
System.Console.WriteLine($"== SYNERGY ID {id} NAME {name} ==");
}
else
{
System.Console.WriteLine($"== SYNERGY ID {id} ==");
}
System.Console.WriteLine($" ACTIVATION STATUS: {synergy.ActivationStatus}");
System.Console.WriteLine($" # OF OBJECTS REQUIRED: {synergy.NumberObjectsRequired}");
System.Console.WriteLine($" ACTIVE WHEN GUN UNEQUIPPED?: {synergy.ActiveWhenGunUnequipped}");
System.Console.WriteLine($" REQUIRES AT LEAST ONE GUN AND ONE ITEM?: {synergy.RequiresAtLeastOneGunAndOneItem}");
System.Console.WriteLine($" MANDATORY GUNS:");
foreach (var itemid in synergy.MandatoryGunIDs)
{
System.Console.WriteLine($" - {_GetPickupObjectName(PickupObjectDatabase.GetById(itemid))}");
}
System.Console.WriteLine($" OPTIONAL GUNS:");
foreach (var itemid in synergy.OptionalGunIDs)
{
System.Console.WriteLine($" - {_GetPickupObjectName(PickupObjectDatabase.GetById(itemid))}");
}
System.Console.WriteLine($" MANDATORY ITEMS:");
foreach (var itemid in synergy.MandatoryItemIDs)
{
System.Console.WriteLine($" - {_GetPickupObjectName(PickupObjectDatabase.GetById(itemid))}");
}
System.Console.WriteLine($" OPTIONAL ITEMS:");
foreach (var itemid in synergy.OptionalItemIDs)
{
System.Console.WriteLine($" - {_GetPickupObjectName(PickupObjectDatabase.GetById(itemid))}");
}
System.Console.WriteLine($" BONUS SYNERGIES:");
foreach (var bonus in synergy.bonusSynergies)
{
System.Console.WriteLine($" - {bonus}");
}
System.Console.WriteLine($" STAT MODIFIERS:");
foreach (var statmod in synergy.statModifiers)
{
System.Console.WriteLine($" - STAT: {statmod.statToBoost}");
System.Console.WriteLine($" AMOUNT: {statmod.amount}");
System.Console.WriteLine($" MODIFY TYPE: {statmod.modifyType}");
System.Console.WriteLine($" PERSISTS ON COOP DEATH?: {statmod.PersistsOnCoopDeath}");
System.Console.WriteLine($" IGNORED FOR SAVE DATA?: {statmod.ignoredForSaveData}");
}
id++;
}
return("Dumped to log");
})
.WithSubCommand("items", (args) => {
var b = new StringBuilder();
var db = PickupObjectDatabase.Instance.Objects;
for (int i = 0; i < db.Count; i++)
{
PickupObject obj = null;
string nameprefix = "";
string name = null;
try {
obj = db[i];
} catch {
name = "[ERROR: failed getting object by index]";
}
if (obj != null)
{
try {
var displayname = obj.encounterTrackable.journalData.PrimaryDisplayName;
name = StringTableManager.ItemTable[displayname].GetWeightedString();
} catch {
name = "[ERROR: failed getting ammonomicon name]";
}
if (name == null)
{
try {
name = obj.EncounterNameOrDisplayName;
} catch {
name = "[ERROR: failed getting encounter or display name]";
}
}
}
if (name == null && obj != null)
{
name = "[NULL NAME (but object is not null)]";
}
name = $"{nameprefix} {name}";
if (name != null)
{
b.AppendLine($"{i}: {name}");
_Logger.Info($"{i}: {name}");
}
}
return(b.ToString());
});
AddGroup("log")
.WithSubCommand("sub", (args) => {
if (_Subscribed)
{
return("Already subscribed.");
}
Logger.Subscribe(_LoggerSubscriber);
_Subscribed = true;
return("Done.");
})
.WithSubCommand("unsub", (args) => {
if (!_Subscribed)
{
return("Not subscribed yet.");
}
Logger.Unsubscribe(_LoggerSubscriber);
_Subscribed = false;
return("Done.");
})
.WithSubCommand("level", (args) => {
if (args.Count == 0)
{
return(_LogLevel.ToString().ToLowerInvariant());
}
else
{
switch (args[0])
{
case "debug": _LogLevel = Logger.LogLevel.Debug; break;
case "info": _LogLevel = Logger.LogLevel.Info; break;
case "warn": _LogLevel = Logger.LogLevel.Warn; break;
case "error": _LogLevel = Logger.LogLevel.Error; break;
default: throw new Exception($"Unknown log level '{args[0]}");
}
return("Done.");
}
});
//// test commands to dump collection
//AddGroup("texdump")
//.WithSubCommand("collection", (args) =>
//{
// if (args.Count == 0)
// {
// return "No name specified";
// }
// else
// {
// string collectionName = args[0];
// Animation.Collection.Dump(collectionName);
// return "Successfull";
// }
//});
}
private void BeginHammerState(ExpandHammerState state)
{
if (state == ExpandHammerState.InitialDelay)
{
TargetAnimator.renderer.enabled = false;
HitEffectAnimator.renderer.enabled = false;
sprite.renderer.enabled = false;
m_timer = InitialDelay;
}
else if (state == ExpandHammerState.PreSwing)
{
if (m_Owner != null)
{
m_targetPlayer = m_Owner;
}
else
{
m_targetPlayer = GameManager.Instance.GetRandomActivePlayer();
}
if (TracksRandomEnemy)
{
m_SelectedEnemy = m_room.GetRandomActiveEnemy(false);
if (DisablesRegularForgeHammers && GameManager.Instance.Dungeon.tileIndices.tilesetId == GlobalDungeonData.ValidTilesets.FORGEGEON)
{
if (StaticReferenceManager.AllForgeHammers != null && StaticReferenceManager.AllForgeHammers.Count > 0)
{
List <ForgeHammerController> AllForgeHammers = StaticReferenceManager.AllForgeHammers;
for (int i = 0; i < AllForgeHammers.Count; i++)
{
if (AllForgeHammers[i].transform.position.GetAbsoluteRoom() == m_room)
{
AllForgeHammers[i].Deactivate();
}
}
}
}
}
if (GameManager.Instance.CurrentGameType == GameManager.GameType.COOP_2_PLAYER)
{
List <PlayerController> list = new List <PlayerController>(2);
Vector2 unitBottomLeft = m_room.area.UnitBottomLeft;
Vector2 unitTopRight = m_room.area.UnitTopRight;
for (int i = 0; i < GameManager.Instance.AllPlayers.Length; i++)
{
PlayerController playerController = GameManager.Instance.AllPlayers[i];
if (playerController && playerController.healthHaver.IsAlive)
{
Vector2 centerPosition = playerController.CenterPosition;
if (BraveMathCollege.AABBContains(unitBottomLeft - Vector2.one, unitTopRight + Vector2.one, centerPosition))
{
list.Add(playerController);
}
}
}
if (list.Count > 0)
{
m_targetPlayer = BraveUtility.RandomElement(list);
}
}
IntVector2 a = m_targetPlayer.CenterPosition.ToIntVector2(VectorConversions.Floor);
if (ForceLeft)
{
m_attackIsLeft = true;
}
else if (ForceRight)
{
m_attackIsLeft = false;
}
else
{
int num = 0;
while (GameManager.Instance.Dungeon.data[a + IntVector2.Left * num].type != CellType.WALL)
{
num++;
}
int num2 = 0;
while (GameManager.Instance.Dungeon.data[a + IntVector2.Right * num2].type != CellType.WALL)
{
num2++;
}
m_attackIsLeft = (num < num2);
}
m_inAnim = ((!m_attackIsLeft) ? Hammer_Anim_In_Right : Hammer_Anim_In_Left);
m_outAnim = ((!m_attackIsLeft) ? Hammer_Anim_Out_Right : Hammer_Anim_Out_Left);
TargetAnimator.StopAndResetFrame();
if (TracksPlayer | TracksRandomEnemy)
{
TargetAnimator.renderer.enabled = true;
}
else
{
TargetAnimator.renderer.enabled = false;
}
TargetAnimator.PlayAndDisableRenderer((!m_attackIsLeft) ? "hammer_right_target" : "hammer_left_target");
m_targetOffset = ((!m_attackIsLeft) ? new Vector2(4.625f, 1.9375f) : new Vector2(1.9375f, 1.9375f));
m_timer = FlashDurationBeforeAttack;
}
else if (state == ExpandHammerState.Swing)
{
sprite.renderer.enabled = true;
spriteAnimator.Play(m_inAnim);
ShadowAnimator.renderer.enabled = true;
ShadowAnimator.Play((!m_attackIsLeft) ? "hammer_right_slam_shadow" : "hammer_left_slam_shadow");
sprite.HeightOffGround = -2.5f;
sprite.UpdateZDepth();
m_additionalTrackTimer = AdditionalTrackingTime;
}
else if (state == ExpandHammerState.Grounded)
{
if (DoScreenShake)
{
GameManager.Instance.MainCameraController.DoScreenShake(ScreenShake, new Vector2?(specRigidbody.UnitCenter), false);
}
specRigidbody.enabled = true;
specRigidbody.PixelColliders[0].ManualOffsetX = ((!m_attackIsLeft) ? 59 : 16);
specRigidbody.PixelColliders[1].ManualOffsetX = ((!m_attackIsLeft) ? 59 : 16);
specRigidbody.ForceRegenerate(null, null);
specRigidbody.Reinitialize();
Exploder.DoRadialMinorBreakableBreak(TargetAnimator.sprite.WorldCenter, 4f);
HitEffectAnimator.renderer.enabled = true;
HitEffectAnimator.PlayAndDisableRenderer((!m_attackIsLeft) ? "hammer_right_slam_vfx" : "hammer_left_slam_vfx");
List <SpeculativeRigidbody> overlappingRigidbodies = PhysicsEngine.Instance.GetOverlappingRigidbodies(specRigidbody, null, false);
for (int j = 0; j < overlappingRigidbodies.Count; j++)
{
if (overlappingRigidbodies[j].gameActor)
{
Vector2 direction = overlappingRigidbodies[j].UnitCenter - specRigidbody.UnitCenter;
if (overlappingRigidbodies[j].gameActor is PlayerController)
{
PlayerController playerController2 = overlappingRigidbodies[j].gameActor as PlayerController;
if (overlappingRigidbodies[j].CollideWithOthers)
{
if (!playerController2.DodgeRollIsBlink || !playerController2.IsDodgeRolling)
{
if (overlappingRigidbodies[j].healthHaver)
{
overlappingRigidbodies[j].healthHaver.ApplyDamage(0.5f, direction, StringTableManager.GetEnemiesString("#FORGE_HAMMER", -1), CoreDamageTypes.None, DamageCategory.Normal, false, null, false);
}
if (overlappingRigidbodies[j].knockbackDoer)
{
overlappingRigidbodies[j].knockbackDoer.ApplyKnockback(direction, KnockbackForcePlayers, false);
}
}
}
}
else
{
if (overlappingRigidbodies[j].healthHaver)
{
overlappingRigidbodies[j].healthHaver.ApplyDamage(DamageToEnemies, direction, StringTableManager.GetEnemiesString("#FORGE_HAMMER", -1), CoreDamageTypes.None, DamageCategory.Normal, false, null, false);
}
if (overlappingRigidbodies[j].knockbackDoer)
{
overlappingRigidbodies[j].knockbackDoer.ApplyKnockback(direction, KnockbackForceEnemies, false);
}
}
}
}
PhysicsEngine.Instance.RegisterOverlappingGhostCollisionExceptions(specRigidbody, null, false);
if (DoGoopOnImpact)
{
DeadlyDeadlyGoopManager.GetGoopManagerForGoopType(GoopToDo).AddGoopRect(specRigidbody.UnitCenter + new Vector2(-1f, -1.25f), specRigidbody.UnitCenter + new Vector2(1f, 0.75f));
}
if (DoesBulletsOnImpact && m_isActive)
{
ShootPoint.transform.position = specRigidbody.UnitCenter;
CellData cell = ShootPoint.transform.position.GetCell();
if (cell != null && cell.type != CellType.WALL)
{
if (!m_bulletSource)
{
m_bulletSource = ShootPoint.gameObject.GetOrAddComponent <BulletScriptSource>();
}
m_bulletSource.BulletManager = bulletBank;
m_bulletSource.BulletScript = BulletScript;
m_bulletSource.Initialize();
if (TracksRandomEnemy && m_Owner != null)
{
if (bulletBank)
{
bulletBank.OnProjectileCreated = (Action <Projectile>)Delegate.Combine(bulletBank.OnProjectileCreated, new Action <Projectile>(HandleForgeHammerPostProcessProjectile));
/*if (gameObject.GetComponent<AIBulletBank>()) {
* AIBulletBank aiBulletBank = gameObject.GetComponent<AIBulletBank>();
* aiBulletBank.Bullets[0].forceCanHitEnemies = true;
* }*/
}
}
}
}
m_timer = UnityEngine.Random.Range(MinTimeToRestOnGround, MaxTimeToRestOnGround);
}
else if (state == ExpandHammerState.UpSwing)
{
spriteAnimator.Play(m_outAnim);
ShadowAnimator.PlayAndDisableRenderer((!m_attackIsLeft) ? "hammer_right_out_shadow" : "hammer_left_out_shadow");
}
else if (state == ExpandHammerState.Gone)
{
sprite.renderer.enabled = false;
m_timer = UnityEngine.Random.Range(MinTimeBetweenAttacks, MaxTimeBetweenAttacks);
}
}
private IEnumerator HandleExplosion(Vector3 position, ExplosionData data, Vector2 sourceNormal, Action onExplosionBegin, bool ignoreQueues, CoreDamageTypes damageTypes, bool ignoreDamageCaps)
{
if (data.usesComprehensiveDelay)
{
yield return(new WaitForSeconds(data.comprehensiveDelay));
}
Exploder.OnExplosionTriggered?.Invoke();
bool addFireGoop = (damageTypes | CoreDamageTypes.Fire) == damageTypes;
bool addFreezeGoop = (damageTypes | CoreDamageTypes.Ice) == damageTypes;
bool addPoisonGoop = (damageTypes | CoreDamageTypes.Poison) == damageTypes;
bool isFreezeExplosion = data.isFreezeExplosion;
if (!data.isFreezeExplosion && addFreezeGoop)
{
isFreezeExplosion = true;
data.freezeRadius = data.damageRadius;
data.freezeEffect = GameManager.Instance.Dungeon.sharedSettingsPrefab.DefaultFreezeExplosionEffect;
}
// Be sure to use a clone of ExplosionManager for this else explosion queueing breaks! //
// (it won't let you use ExplosionManager's original code on a new Exploder class normally. ;) - [Apache Thunder] //
if (!ignoreQueues)
{
ChaosExplosionManager.Instance.Queue(this);
while (!ChaosExplosionManager.Instance.IsExploderReady(this))
{
yield return(null);
}
ChaosExplosionManager.Instance.Dequeue();
if (ChaosExplosionManager.Instance.QueueCount == 0)
{
ChaosExplosionManager.Instance.StartCoroutine(HandleCurrentExplosionNotification(0.5f));
}
}
onExplosionBegin?.Invoke();
float damageRadius = data.GetDefinedDamageRadius();
float pushSqrRadius = data.pushRadius * data.pushRadius;
float bulletDeletionSqrRadius = damageRadius * damageRadius;
if (addFreezeGoop)
{
DeadlyDeadlyGoopManager.GetGoopManagerForGoopType(GameManager.Instance.Dungeon.sharedSettingsPrefab.DefaultFreezeGoop).TimedAddGoopCircle(position.XY(), damageRadius, 0.5f, false);
DeadlyDeadlyGoopManager.FreezeGoopsCircle(position.XY(), damageRadius);
}
if (addFireGoop)
{
DeadlyDeadlyGoopManager.GetGoopManagerForGoopType(GameManager.Instance.Dungeon.sharedSettingsPrefab.DefaultFireGoop).TimedAddGoopCircle(position.XY(), damageRadius, 0.5f, false);
}
if (addPoisonGoop)
{
DeadlyDeadlyGoopManager.GetGoopManagerForGoopType(GameManager.Instance.Dungeon.sharedSettingsPrefab.DefaultPoisonGoop).TimedAddGoopCircle(position.XY(), damageRadius, 0.5f, false);
}
if (!isFreezeExplosion)
{
DeadlyDeadlyGoopManager.IgniteGoopsCircle(position.XY(), damageRadius);
}
if (data.effect)
{
GameObject gameObject;
if (data.effect.GetComponent <ParticleSystem>() != null || data.effect.GetComponentInChildren <ParticleSystem>() != null)
{
gameObject = SpawnManager.SpawnVFX(data.effect, position, Quaternion.identity);
}
else
{
gameObject = SpawnManager.SpawnVFX(data.effect, position, Quaternion.identity);
}
if (data.rotateEffectToNormal && gameObject)
{
gameObject.transform.rotation = Quaternion.Euler(0f, 0f, sourceNormal.ToAngle());
}
tk2dBaseSprite component = gameObject.GetComponent <tk2dBaseSprite>();
if (component)
{
component.HeightOffGround += UnityEngine.Random.Range(-0.1f, 0.2f);
component.UpdateZDepth();
}
ExplosionDebrisLauncher[] componentsInChildren = gameObject.GetComponentsInChildren <ExplosionDebrisLauncher>();
Vector3 position2 = gameObject.transform.position.WithZ(gameObject.transform.position.y);
GameObject gameObject2 = new GameObject("SoundSource");
gameObject2.transform.position = position2;
if (data.playDefaultSFX)
{
AkSoundEngine.PostEvent("Play_WPN_grenade_blast_01", gameObject2);
}
Destroy(gameObject2, 5f);
for (int i = 0; i < componentsInChildren.Length; i++)
{
if (componentsInChildren[i])
{
if (sourceNormal == Vector2.zero)
{
componentsInChildren[i].Launch();
}
else
{
componentsInChildren[i].Launch(sourceNormal);
}
}
}
if (gameObject)
{
Transform transform = gameObject.transform.Find("scorch");
if (transform)
{
transform.gameObject.SetLayerRecursively(LayerMask.NameToLayer("BG_Critical"));
}
}
if (data.doExplosionRing)
{
}
}
yield return(new WaitForSeconds(data.explosionDelay));
List <HealthHaver> allHealth = StaticReferenceManager.AllHealthHavers;
if (allHealth != null && (data.doDamage || data.doForce))
{
for (int j = 0; j < allHealth.Count; j++)
{
HealthHaver healthHaver = allHealth[j];
if (healthHaver)
{
if (healthHaver && healthHaver.aiActor)
{
if (!healthHaver.aiActor.HasBeenEngaged)
{
goto IL_A82;
}
if (healthHaver.aiActor.CompanionOwner && data.damageToPlayer == 0f)
{
goto IL_A82;
}
}
if (!data.ignoreList.Contains(healthHaver.specRigidbody))
{
if (position.GetAbsoluteRoom() == allHealth[j].transform.position.GetAbsoluteRoom())
{
for (int k = 0; k < healthHaver.NumBodyRigidbodies; k++)
{
SpeculativeRigidbody bodyRigidbody = healthHaver.GetBodyRigidbody(k);
PlayerController playerController = (!bodyRigidbody) ? null : (bodyRigidbody.gameActor as PlayerController);
Vector2 a = healthHaver.transform.position.XY();
Vector2 vector = a - position.XY();
bool flag = false;
float num;
if (bodyRigidbody.HitboxPixelCollider != null)
{
a = bodyRigidbody.HitboxPixelCollider.UnitCenter;
vector = a - position.XY();
num = BraveMathCollege.DistToRectangle(position.XY(), bodyRigidbody.HitboxPixelCollider.UnitBottomLeft, bodyRigidbody.HitboxPixelCollider.UnitDimensions);
}
else
{
a = healthHaver.transform.position.XY();
vector = a - position.XY();
num = vector.magnitude;
}
if (!playerController || ((!data.doDamage || num >= damageRadius) && (!isFreezeExplosion || num >= data.freezeRadius) && (!data.doForce || num >= data.pushRadius)) || !IsPlayerBlockedByWall(playerController, position))
{
if (playerController)
{
if (!bodyRigidbody.CollideWithOthers)
{
goto IL_A6E;
}
if (playerController.DodgeRollIsBlink && playerController.IsDodgeRolling)
{
goto IL_A6E;
}
}
if (data.doDamage && num < damageRadius)
{
if (playerController)
{
bool flag2 = true;
if (PassiveItem.ActiveFlagItems.ContainsKey(playerController) && PassiveItem.ActiveFlagItems[playerController].ContainsKey(typeof(HelmetItem)) && num > damageRadius * HelmetItem.EXPLOSION_RADIUS_MULTIPLIER)
{
flag2 = false;
}
if (flag2 && !playerController.IsEthereal)
{
HealthHaver healthHaver2 = healthHaver;
float damage = data.damageToPlayer;
Vector2 direction = vector;
string enemiesString = StringTableManager.GetEnemiesString("#EXPLOSION", -1);
CoreDamageTypes damageTypes2 = CoreDamageTypes.None;
DamageCategory damageCategory = DamageCategory.Normal;
healthHaver2.ApplyDamage(damage, direction, enemiesString, damageTypes2, damageCategory, false, null, ignoreDamageCaps);
}
}
else
{
HealthHaver healthHaver3 = healthHaver;
float damage = data.damage;
Vector2 direction = vector;
string enemiesString = StringTableManager.GetEnemiesString("#EXPLOSION", -1);
CoreDamageTypes damageTypes2 = CoreDamageTypes.None;
DamageCategory damageCategory = DamageCategory.Normal;
healthHaver3.ApplyDamage(damage, direction, enemiesString, damageTypes2, damageCategory, false, null, ignoreDamageCaps);
if (data.IsChandelierExplosion && (!healthHaver || healthHaver.healthHaver.IsDead))
{
GameStatsManager.Instance.RegisterStatChange(TrackedStats.ENEMIES_KILLED_WITH_CHANDELIERS, 1f);
}
}
flag = true;
}
if (isFreezeExplosion && num < data.freezeRadius)
{
if (healthHaver && healthHaver.gameActor != null && !healthHaver.IsDead && (!healthHaver.aiActor || !healthHaver.aiActor.IsGone))
{
healthHaver.gameActor.ApplyEffect(data.freezeEffect, 1f, null);
}
flag = true;
}
if (data.doForce && num < data.pushRadius)
{
KnockbackDoer knockbackDoer = healthHaver.knockbackDoer;
if (knockbackDoer)
{
float num2 = 1f - num / data.pushRadius;
if (data.preventPlayerForce && healthHaver.GetComponent <PlayerController>())
{
num2 = 0f;
}
knockbackDoer.ApplyKnockback(vector.normalized, num2 * data.force, false);
}
flag = true;
}
if (flag)
{
break;
}
}
IL_A6E :;
}
}
}
}
IL_A82 :;
}
}
List <MinorBreakable> allBreakables = StaticReferenceManager.AllMinorBreakables;
if (allBreakables != null)
{
for (int l = 0; l < allBreakables.Count; l++)
{
MinorBreakable minorBreakable = allBreakables[l];
if (minorBreakable)
{
if (!minorBreakable.resistsExplosions)
{
if (!minorBreakable.OnlyBrokenByCode)
{
Vector2 vector2 = minorBreakable.CenterPoint - position.XY();
if (vector2.sqrMagnitude < pushSqrRadius)
{
minorBreakable.Break(vector2.normalized);
}
}
}
}
}
}
if (data.doDestroyProjectiles)
{
float duration = 0.2f;
PlayerController bestActivePlayer = GameManager.Instance.BestActivePlayer;
if (bestActivePlayer && bestActivePlayer.CurrentRoom != null && bestActivePlayer.CurrentRoom.area != null && bestActivePlayer.CurrentRoom.area.PrototypeRoomCategory == PrototypeDungeonRoom.RoomCategory.BOSS)
{
duration = 0.035f;
}
GameManager.Instance.Dungeon.StartCoroutine(HandleBulletDeletionFrames(position, bulletDeletionSqrRadius, duration));
}
if (data.doDamage || data.breakSecretWalls)
{
List <MajorBreakable> allMajorBreakables = StaticReferenceManager.AllMajorBreakables;
if (allMajorBreakables != null)
{
for (int m = 0; m < allMajorBreakables.Count; m++)
{
MajorBreakable majorBreakable = allMajorBreakables[m];
if (majorBreakable)
{
if (majorBreakable.enabled)
{
if (!majorBreakable.IgnoreExplosions)
{
Vector2 sourceDirection = majorBreakable.CenterPoint - position.XY();
if (sourceDirection.sqrMagnitude < pushSqrRadius && (!majorBreakable.IsSecretDoor || !data.forcePreventSecretWallDamage))
{
if (data.doDamage)
{
majorBreakable.ApplyDamage(data.damage, sourceDirection, false, true, false);
}
if (data.breakSecretWalls && majorBreakable.IsSecretDoor)
{
StaticReferenceManager.AllMajorBreakables[m].ApplyDamage(1E+10f, Vector2.zero, false, true, true);
StaticReferenceManager.AllMajorBreakables[m].ApplyDamage(1E+10f, Vector2.zero, false, true, true);
StaticReferenceManager.AllMajorBreakables[m].ApplyDamage(1E+10f, Vector2.zero, false, true, true);
}
}
}
}
}
}
}
}
if (data.doForce)
{
Exploder.DoRadialPush(position, data.debrisForce, data.pushRadius);
}
if (data.doScreenShake && GameManager.Instance.MainCameraController != null)
{
GameManager.Instance.MainCameraController.DoScreenShake(data.ss, new Vector2?(position), false);
}
if (data.doStickyFriction && GameManager.Instance.MainCameraController != null)
{
StickyFrictionManager.Instance.RegisterExplosionStickyFriction();
}
for (int n = 0; n < StaticReferenceManager.AllRatTrapdoors.Count; n++)
{
if (StaticReferenceManager.AllRatTrapdoors[n])
{
StaticReferenceManager.AllRatTrapdoors[n].OnNearbyExplosion(position);
}
}
Destroy(this.gameObject);
yield break;
}
public static void DoRadialDamage(float damage, Vector3 position, float radius, bool damagePlayers, bool damageEnemies, bool ignoreDamageCaps = false, VFXPool hitVFX = null)
{
List <HealthHaver> allHealthHavers = StaticReferenceManager.AllHealthHavers;
if (allHealthHavers != null)
{
for (int i = 0; i < allHealthHavers.Count; i++)
{
HealthHaver healthHaver = allHealthHavers[i];
if (healthHaver)
{
if (healthHaver.gameObject.activeSelf)
{
if (!healthHaver.aiActor || !healthHaver.aiActor.IsGone)
{
if (!healthHaver.aiActor || healthHaver.aiActor.isActiveAndEnabled)
{
for (int j = 0; j < healthHaver.NumBodyRigidbodies; j++)
{
SpeculativeRigidbody bodyRigidbody = healthHaver.GetBodyRigidbody(j);
Vector2 a = healthHaver.transform.position.XY();
Vector2 vector = a - position.XY();
bool flag = false;
bool flag2 = false;
float num;
if (bodyRigidbody.HitboxPixelCollider != null)
{
a = bodyRigidbody.HitboxPixelCollider.UnitCenter;
vector = a - position.XY();
num = BraveMathCollege.DistToRectangle(position.XY(), bodyRigidbody.HitboxPixelCollider.UnitBottomLeft, bodyRigidbody.HitboxPixelCollider.UnitDimensions);
}
else
{
a = healthHaver.transform.position.XY();
vector = a - position.XY();
num = vector.magnitude;
}
if (num < radius)
{
PlayerController component = healthHaver.GetComponent <PlayerController>();
if (component != null)
{
bool flag3 = true;
if (PassiveItem.ActiveFlagItems.ContainsKey(component) && PassiveItem.ActiveFlagItems[component].ContainsKey(typeof(HelmetItem)) && num > radius * HelmetItem.EXPLOSION_RADIUS_MULTIPLIER)
{
flag3 = false;
}
if (IsPlayerBlockedByWall(component, position))
{
flag3 = false;
}
if (damagePlayers && flag3 && !component.IsEthereal)
{
HealthHaver healthHaver2 = healthHaver;
float damage2 = 0.5f;
Vector2 direction = vector;
string enemiesString = StringTableManager.GetEnemiesString("#EXPLOSION", -1);
CoreDamageTypes damageTypes = CoreDamageTypes.None;
DamageCategory damageCategory = DamageCategory.Normal;
healthHaver2.ApplyDamage(damage2, direction, enemiesString, damageTypes, damageCategory, false, null, ignoreDamageCaps);
flag2 = true;
}
}
else if (damageEnemies)
{
AIActor aiActor = healthHaver.aiActor;
if (damagePlayers || !aiActor || aiActor.IsNormalEnemy)
{
HealthHaver healthHaver3 = healthHaver;
Vector2 direction = vector;
string enemiesString = StringTableManager.GetEnemiesString("#EXPLOSION", -1);
CoreDamageTypes damageTypes = CoreDamageTypes.None;
DamageCategory damageCategory = DamageCategory.Normal;
healthHaver3.ApplyDamage(damage, direction, enemiesString, damageTypes, damageCategory, false, null, ignoreDamageCaps);
flag2 = true;
}
}
flag = true;
}
if (flag2 && hitVFX != null)
{
if (bodyRigidbody.HitboxPixelCollider != null)
{
PixelCollider pixelCollider = bodyRigidbody.GetPixelCollider(ColliderType.HitBox);
Vector2 v = BraveMathCollege.ClosestPointOnRectangle(position, pixelCollider.UnitBottomLeft, pixelCollider.UnitDimensions);
hitVFX.SpawnAtPosition(v, 0f, null, null, null, null, false, null, null, false);
}
else
{
hitVFX.SpawnAtPosition(healthHaver.transform.position.XY(), 0f, null, null, null, null, false, null, null, false);
}
}
if (flag)
{
break;
}
}
}
}
}
}
}
}
}
private void OnRoomChanged(RoomHandler room)
{
//ETGModConsole.Log("OnRoomChanged Ran");
List <string> dialoguesToSay = new List <string>();
int previousStatements = 0;
Chest[] allChests = FindObjectsOfType <Chest>();
List <Chest> chestsInRoom = new List <Chest>();
foreach (Chest chest in allChests)
{
if (chest.transform.position.GetAbsoluteRoom() == Owner.CurrentRoom && !chest.IsOpen && !chest.IsBroken)
{
//ETGModConsole.Log("Found a chest in the room");
chestsInRoom.Add(chest);
}
}
if (chestsInRoom.Count > 0)
{
foreach (Chest possibleMimic in chestsInRoom)
{
if (possibleMimic.IsMimic)
{
if (chestsInRoom.Count > 1)
{
dialoguesToSay.Add("One of these chests is a mimic... be careful!");
}
else
{
dialoguesToSay.Add("Be careful, that chest's a mimic!");
}
previousStatements++;
}
}
foreach (Chest possibleSecretRainbow in chestsInRoom)
{
if (possibleSecretRainbow.ChestIdentifier == Chest.SpecialChestIdentifier.SECRET_RAINBOW)
{
if (chestsInRoom.Count > 1)
{
dialoguesToSay.Add("That Chest is a Secret Rainbow Chest!");
}
else if (previousStatements > 0)
{
dialoguesToSay.Add("One of these Chests is also secretly a Rainbow Chest!");
}
else
{
dialoguesToSay.Add("One of these Chests is secretly a Rainbow Chest!");
}
previousStatements++;
}
}
if (chestsInRoom.Count > 1)
{
int amtOfDetectedGuns = 0;
int amtOfDetectedPassives = 0;
int amtOfDetectedActives = 0;
int weirdNonItems = 0;
foreach (Chest chest in chestsInRoom)
{
int type = GetChestType(chest);
//ETGModConsole.Log("Detected Type: " + type);
if (type == 0)
{
amtOfDetectedGuns++;
}
if (type == 1)
{
amtOfDetectedPassives++;
}
if (type == 2)
{
amtOfDetectedActives++;
}
if (type == -1)
{
weirdNonItems++;
}
}
List <string> detectedItemCounts = new List <string>();
//Count guns
if (amtOfDetectedGuns > 1)
{
detectedItemCounts.Add(string.Format("{0} guns", amtOfDetectedGuns));
}
else if (amtOfDetectedGuns > 0)
{
detectedItemCounts.Add("1 gun");
}
//Count passives
if (amtOfDetectedPassives > 1)
{
detectedItemCounts.Add(string.Format("{0} passive items", amtOfDetectedPassives));
}
else if (amtOfDetectedPassives > 0)
{
detectedItemCounts.Add("1 passive item");
}
//Count actives
if (amtOfDetectedActives > 1)
{
detectedItemCounts.Add(string.Format("{0} active items", amtOfDetectedActives));
}
else if (amtOfDetectedActives > 0)
{
detectedItemCounts.Add("1 active item");
}
//Other shit
if (weirdNonItems > 1)
{
detectedItemCounts.Add(string.Format("{0} pickups, I think.", weirdNonItems));
}
else if (weirdNonItems > 0)
{
detectedItemCounts.Add("1 pickup, I think.");
}
//ETGModConsole.Log("Full Detected Item Counts Dialogue Strings!");
foreach (string itemCountsDiag in detectedItemCounts)
{
ETGModConsole.Log(itemCountsDiag);
}
string detectedShitDialogue = "";
if (detectedItemCounts.Count > 0)
{
for (int i = 0; i < detectedItemCounts.Count; i++)
{
//ETGModConsole.Log("Iteration: " + i);
//ETGModConsole.Log("Index: " + (i - 1));
string prefix = "";
if (i == (detectedItemCounts.Count - 1))
{
prefix = ", and ";
}
else if (i != 0)
{
prefix = ", ";
}
//ETGModConsole.Log("Prefix: " + prefix);
if (detectedItemCounts[i] != null)
{
detectedShitDialogue += (prefix + detectedItemCounts[i]);
}
//ETGModConsole.Log("Detected Shit Proceedural: " + detectedShitDialogue);
}
string finalComment = string.Format("Hmm.. out of these chests I'm sensing {0}.", detectedShitDialogue);
dialoguesToSay.Add(finalComment);
}
else
{
dialoguesToSay.Add("Oh dear... I think I have experienced a bug while counting items!");
}
}
else
{
//ETGModConsole.Log("There was but one chest");
string contentsComment = "I think I may have glitched out...";
int type = GetChestType(chestsInRoom[0]);
if (type == 0)
{
contentsComment = "That chest definitely has a gun in it!";
}
else if (type == 1)
{
contentsComment = "That chest contains a passive item, I think.";
}
else if (type == 2)
{
contentsComment = "That chest contains an active item!";
}
else if (type == -1)
{
contentsComment = "That chest doesn't seem to contain... any items at all?";
}
else if (type == -2 && !GameStatsManager.Instance.IsRainbowRun)
{
contentsComment = "Oooh! A Rainbow Chest! Lucky you!";
}
if (previousStatements > 0)
{
contentsComment = "Also, " + contentsComment;
}
dialoguesToSay.Add(contentsComment);
previousStatements++;
}
}
foreach (AIActor enemy in StaticReferenceManager.AllEnemies)
{
if (enemy.EnemyGuid == "479556d05c7c44f3b6abb3b2067fc778")
{
if (enemy.specRigidbody && enemy.CurrentRoom() == room)
{
if (enemy.GetComponent <WallMimicController>() != null)
{
bool isHidden = OMITBReflectionHelpers.ReflectGetField <bool>(typeof(WallMimicController), "m_isHidden", enemy.GetComponent <WallMimicController>());
if (isHidden)
{
dialoguesToSay.Add("The walls in here look hungry...");
}
}
}
}
}
foreach (RoomHandler adjacentRoom in room.connectedRooms)
{
if (adjacentRoom.area.PrototypeRoomCategory == PrototypeDungeonRoom.RoomCategory.BOSS && !adjacentRoom.hasEverBeenVisited)
{
List <string> Bossnames = new List <string>();
foreach (AIActor roomEnemy in adjacentRoom.GetActiveEnemies(RoomHandler.ActiveEnemyType.All))
{
if (roomEnemy.healthHaver && roomEnemy.healthHaver.IsBoss)
{
string bossName = roomEnemy.GetActorName();
if (!string.IsNullOrEmpty(roomEnemy.healthHaver.overrideBossName))
{
bossName = StringTableManager.GetEnemiesString(roomEnemy.healthHaver.overrideBossName, -1);
}
Bossnames.Add(bossName);
}
}
if (Bossnames.Count > 0)
{
dialoguesToSay.Add(string.Format("Looks like the {0}... good luck.", BraveUtility.RandomElement(Bossnames)));
}
else
{
dialoguesToSay.Add("There's a boss nearby... but I can't tell what it is?");
}
}
else if (adjacentRoom.area.PrototypeRoomCategory == PrototypeDungeonRoom.RoomCategory.SECRET && !adjacentRoom.hasEverBeenVisited)
{
dialoguesToSay.Add("The walls in here look suspicious.");
}
else if (adjacentRoom.area.PrototypeRoomCategory == PrototypeDungeonRoom.RoomCategory.REWARD && !adjacentRoom.hasEverBeenVisited)
{
dialoguesToSay.Add("I think I can sense some loot around here.");
}
if (adjacentRoom.area.PrototypeRoomCategory != PrototypeDungeonRoom.RoomCategory.SECRET)
{
Minimap.Instance.RevealMinimapRoom(adjacentRoom, true, true, false);
}
}
if (dialoguesToSay.Count > 0)
{
StartCoroutine(Say(dialoguesToSay));
}
}
