protected override void DoEffect(PlayerController player)
{
BraveUtility.RandomElement(ImprovedCandies.PositiveCandyEffects).Invoke(player);
player.BloopItemAboveHead(base.sprite);
ETGModConsole.Log("GJ idiot ...");
}
private IEnumerator KillInventoryCompanion(PlayerController user)
{
//ETGModConsole.Log("KillInventoryCompanion Triggered");
PickupObject item = BraveUtility.RandomElement(CompanionItems);
Gun gunness = item.gameObject.GetComponent <Gun>();
DebrisObject debrisObject = SpecialDrop.DropItem(user, item, gunness != null);
yield return(new WaitForSeconds(1f));
if (debrisObject != null)
{
AkSoundEngine.PostEvent("Play_WPN_smileyrevolver_shot_01", gameObject);
Instantiate <GameObject>(EasyVFXDatabase.TeleporterPrototypeTelefragVFX, debrisObject.sprite.WorldCenter, Quaternion.identity);
GameManager.Instance.StartCoroutine(DoReward(user, debrisObject.sprite.WorldCenter, item.PickupObjectId));
UnityEngine.Object.Destroy(debrisObject.gameObject);
}
else
{
ETGModConsole.Log("DebrisObject was null in the kill code, this should never happen.");
}
yield break;
}
private void Start()
{
Dungeon m_dungeonPrefab = DungeonDatabase.GetOrLoadByName("finalscenario_guide");
DungeonFlow dungeonFlowPrefab = m_dungeonPrefab.PatternSettings.flows[0];
PrototypeDungeonRoom GuidePastRoom = dungeonFlowPrefab.AllNodes[0].overrideExactRoom;
GameObject GuidePastRoomObject = GuidePastRoom.placedObjects[0].nonenemyBehaviour.gameObject;
GameObject m_RainPrefab = GuidePastRoomObject.transform.Find("Rain").gameObject;
GameObject m_ThunderStorm = Instantiate(m_RainPrefab);
m_ThunderStorm.name = "ExpandRain";
m_StormController = m_ThunderStorm.GetComponent <ThunderstormController>();
ParticleSystem m_CachedParticleSystem = m_StormController.RainSystemTransform.GetComponent <ParticleSystem>();
if (useCustomIntensity)
{
BraveUtility.SetEmissionRate(m_CachedParticleSystem, RainIntensity);
}
m_StormController.DecayVertical = isLocalToRoom;
m_StormController.DoLighting = false;
LightningRenderers = m_StormController.LightningRenderers;
m_ThunderStorm.transform.parent = gameObject.transform;
dungeonFlowPrefab = null;
m_dungeonPrefab = null;
isActive = true;
}
public void Invisible(Projectile proj, float f)
{
if (proj != null && proj.sprite != null)
{
proj.sprite.renderer.enabled = false;
}
if (proj.GetComponentInChildren <TrailController>() != null)
{
Destroy(proj.GetComponentInChildren <TrailController>());
}
proj.StartCoroutine(this.DelayedDestroyParticles(proj));
if (proj.ParticleTrail != null)
{
BraveUtility.EnableEmission(proj.ParticleTrail, false);
}
if (proj.particleSystem != null)
{
Destroy(proj.particleSystem);
}
if (proj.CustomTrailRenderer != null)
{
proj.CustomTrailRenderer.enabled = false;
}
if (proj.TrailRenderer != null)
{
proj.TrailRenderer.enabled = false;
}
if (proj.TrailRendererController != null)
{
proj.TrailRendererController.enabled = false;
}
}
private void Awake()
{
m_hasAwoken = true;
if (!m_gun)
{
m_gun = GetComponent <Gun>();
}
if (m_gun)
{
m_gun.OnInitializedWithOwner = (Action <GameActor>)Delegate.Combine(m_gun.OnInitializedWithOwner, new Action <GameActor>(OnGunInitialized));
m_gun.OnDropped = (Action)Delegate.Combine(m_gun.OnDropped, new Action(OnGunDroppedOrDestroyed));
if (m_gun.CurrentOwner != null)
{
OnGunInitialized(m_gun.CurrentOwner);
}
if (TransfmorgifyTargetGUIDs != null && TransfmorgifyTargetGUIDs.Count <= 0 && IsBootlegShotgun)
{
List <string> m_GUIDlist = new List <string>()
{
ExpandCustomEnemyDatabase.BootlegShotgunManBlueGUID,
ExpandCustomEnemyDatabase.BootlegShotgunManRedGUID
};
m_GUIDlist = m_GUIDlist.Shuffle();
TransfmorgifyTargetGUIDs.Add(BraveUtility.RandomElement(m_GUIDlist));
}
}
}
private DungeonData.Direction GetFacingDirection(IntVector2 pos1, IntVector2 pos2)
{
DungeonData data = GameManager.Instance.Dungeon.data;
if (data.isWall(pos1 + IntVector2.Down) && data.isWall(pos1 + IntVector2.Up))
{
return(DungeonData.Direction.EAST);
}
if (data.isWall(pos2 + IntVector2.Down) && data.isWall(pos2 + IntVector2.Up))
{
return(DungeonData.Direction.WEST);
}
if (data.isWall(pos1 + IntVector2.Down) && data.isWall(pos2 + IntVector2.Down))
{
return(DungeonData.Direction.NORTH);
}
if (data.isWall(pos1 + IntVector2.Up) && data.isWall(pos2 + IntVector2.Up))
{
return(DungeonData.Direction.SOUTH);
}
Debug.LogError("Not able to determine the direction of a wall mimic! Using random direction instead!");
// return DungeonData.Direction.SOUTH;
return(BraveUtility.RandomElement(new List <DungeonData.Direction>()
{
DungeonData.Direction.EAST,
DungeonData.Direction.WEST,
DungeonData.Direction.NORTH,
DungeonData.Direction.SOUTH
}
));
}
public static void AddRandomCurse(bool doPopup = false)
{
List <CurseData> refinedData = new List <CurseData>();
refinedData.AddRange(CursePrefabs);
if (CurrentActiveCurses.Count > 0)
{
for (int i = (refinedData.Count - 1); i >= 0; i--)
{
if (CurseManager.CurseIsActive(refinedData[i].curseName))
{
refinedData.RemoveAt(i);
}
else if (cursesLastFloor != null && cursesLastFloor.Contains(refinedData[i].curseName))
{
refinedData.RemoveAt(i);
}
else if (bannedCursesThisRun != null && bannedCursesThisRun.Contains(refinedData[i].curseName))
{
refinedData.RemoveAt(i);
}
}
}
if (refinedData.Count > 0)
{
CurseData pickedCurse = BraveUtility.RandomElement(refinedData);
AddCurse(pickedCurse.curseName, doPopup);
}
}
protected override void OnTrigger(Vector2 damageDirection)
{
if (m_hasTriggered)
{
return;
}
m_hasTriggered = true;
if (guaranteedSpawnGenerations <= 0f && chanceToSpawn < 1f && UnityEngine.Random.value > chanceToSpawn)
{
return;
}
if (!string.IsNullOrEmpty(spawnVfx))
{
aiAnimator.PlayVfx(spawnVfx, null, null, null);
}
string[] array = null;
if (enemySelection == EnemySelection.All)
{
array = enemyGuidsToSpawn;
}
else if (enemySelection == EnemySelection.Random)
{
array = new string[UnityEngine.Random.Range(minSpawnCount, maxSpawnCount)];
for (int i = 0; i < array.Length; i++)
{
array[i] = BraveUtility.RandomElement(enemyGuidsToSpawn);
}
}
SpawnEnemies(array);
}
protected override void DoEffect(PlayerController user)
{
if (user.carriedConsumables.KeyBullets == 1)
{
Vector2 yourPosition = user.sprite.WorldCenter + new Vector2(-0.5f, 0f);
List <Chest> possibleChests = new List <Chest>
{
GameManager.Instance.RewardManager.D_Chest,
GameManager.Instance.RewardManager.C_Chest,
GameManager.Instance.RewardManager.B_Chest,
};
Chest chest = Chest.Spawn(BraveUtility.RandomElement(possibleChests), yourPosition, yourPosition.GetAbsoluteRoom());
chest.IsLocked = false;
user.carriedConsumables.KeyBullets -= 1;
}
else if (user.carriedConsumables.KeyBullets > 1 && user.carriedConsumables.KeyBullets < 7)
{
Vector2 yourPosition = user.sprite.WorldCenter + new Vector2(-0.5f, 0f);
List <Chest> possibleChests = new List <Chest>
{
GameManager.Instance.RewardManager.A_Chest,
GameManager.Instance.RewardManager.S_Chest,
};
Chest chest = Chest.Spawn(BraveUtility.RandomElement(possibleChests), yourPosition, yourPosition.GetAbsoluteRoom());
chest.IsLocked = false;
user.carriedConsumables.KeyBullets -= 2;
}
else
{
Vector2 yourPosition = user.sprite.WorldCenter + new Vector2(-0.5f, 0f);
Chest chest = Chest.Spawn(GameManager.Instance.RewardManager.Rainbow_Chest, yourPosition, yourPosition.GetAbsoluteRoom());
chest.IsLocked = false;
user.carriedConsumables.KeyBullets -= 7;
}
}
private void DoSpawn()
{
DisplacedEnemy enemy = BraveUtility.RandomElement(listOfDisplacedEnemies.DisplacedEnemies);
var Enemy = EnemyDatabase.GetOrLoadByGuid(enemy.GUID);
IntVector2?bestRewardLocation = m_player.CurrentRoom.GetRandomVisibleClearSpot(2, 2);
AIActor TargetActor = AIActor.Spawn(Enemy.aiActor, bestRewardLocation.Value, GameManager.Instance.Dungeon.data.GetAbsoluteRoomFromPosition(bestRewardLocation.Value), true, AIActor.AwakenAnimationType.Default, true);
PhysicsEngine.Instance.RegisterOverlappingGhostCollisionExceptions(TargetActor.specRigidbody, null, false);
if (TargetActor.IsBlackPhantom && !enemy.ISJAMMED)
{
TargetActor.UnbecomeBlackPhantom();
}
else if (!TargetActor.IsBlackPhantom && enemy.ISJAMMED)
{
TargetActor.BecomeBlackPhantom();
}
TargetActor.healthHaver.ForceSetCurrentHealth(enemy.HEALTH);
listOfDisplacedEnemies.DisplacedEnemies.Remove(enemy);
AkSoundEngine.PostEvent("Play_OBJ_chestwarp_use_01", gameObject);
var tpvfx = (PickupObjectDatabase.GetById(573) as ChestTeleporterItem).TeleportVFX;
SpawnManager.SpawnVFX(tpvfx, TargetActor.sprite.WorldCenter, Quaternion.identity, true);
}
private void HitEnemy(Projectile projectile, SpeculativeRigidbody enemy, bool killed)
{
projectile.Speed *= 1.2f;
projectile.baseData.damage *= .8f;
PierceProjModifier orAddComponent = projectile.gameObject.GetOrAddComponent <PierceProjModifier>();
orAddComponent.penetratesBreakables = true;
orAddComponent.penetration++;
Vector2 dirVec = UnityEngine.Random.insideUnitCircle;
float num = this.ChanceToSeekEnemyOnBounce;
if (UnityEngine.Random.value < num && enemy.aiActor)
{
Func <AIActor, bool> isValid = (AIActor a) => a && a.HasBeenEngaged && a.healthHaver && a.healthHaver.IsVulnerable;
AIActor closestToPosition = BraveUtility.GetClosestToPosition <AIActor>(enemy.aiActor.ParentRoom.GetActiveEnemies(RoomHandler.ActiveEnemyType.All), enemy.UnitCenter, isValid, new AIActor[]
{
enemy.aiActor
});
if (closestToPosition)
{
dirVec = closestToPosition.CenterPosition - projectile.transform.position.XY();
}
}
projectile.SendInDirection(dirVec, false, true);
}
public static void HandleLoadout(PlayerController player)
{
var starterGuns = AllStarterGuns[Random.Range(0, AllStarterGuns.Length)];
player.inventory.AddGunToInventory(Gungeon.Game.Items[starterGuns.First] as Gun, false);
if (!string.IsNullOrEmpty(starterGuns.Second))
{
player.inventory.AddGunToInventory(Gungeon.Game.Items[starterGuns.Second] as Gun, false);
}
if (BraveUtility.RandomBool())
{
var gun = GetWeightedRandomItem <Gun>();
player.startingGunIds.Add(gun.PickupObjectId);
LootEngine.TryGivePrefabToPlayer(gun.gameObject, player, true);
}
else
{
var active = GetWeightedRandomItem <PlayerItem>();
player.startingActiveItemIds.Add(active.PickupObjectId);
LootEngine.TryGivePrefabToPlayer(active.gameObject, player, true);
}
var passive = GetWeightedRandomItem <PassiveItem>();
passive.CanBeDropped = false;
player.startingGunIds.Add(passive.PickupObjectId);
LootEngine.TryGivePrefabToPlayer(passive.gameObject, player, true);
}
public override void OnReloadPressed(PlayerController player, Gun gun, bool bSOMETHING)
{
if (ActiveBullets.Count > 0)
{
foreach (Projectile bullet in ActiveBullets)
{
if (bullet)
{
Vector2 dirVec = UnityEngine.Random.insideUnitCircle;
Vector2 bulletPosition = bullet.sprite.WorldCenter;
Func <AIActor, bool> isValid = (AIActor a) => a && a.HasBeenEngaged && a.healthHaver && a.healthHaver.IsVulnerable;
IntVector2 bulletPositionIntVector2 = bulletPosition.ToIntVector2();
AIActor closestToPosition = BraveUtility.GetClosestToPosition <AIActor>(GameManager.Instance.Dungeon.data.GetAbsoluteRoomFromPosition(bulletPositionIntVector2).GetActiveEnemies(RoomHandler.ActiveEnemyType.All), bullet.sprite.WorldCenter, isValid, new AIActor[]
{
});
if (closestToPosition)
{
dirVec = closestToPosition.CenterPosition - bullet.transform.position.XY();
}
bullet.SendInDirection(dirVec, false, true);
if (!player.PlayerHasActiveSynergy("Pistols Requiem"))
{
BulletsToRemoveFromActiveBullets.Add(bullet);
}
}
}
foreach (Projectile bullet in BulletsToRemoveFromActiveBullets)
{
ActiveBullets.Remove(bullet);
}
BulletsToRemoveFromActiveBullets.Clear();
}
base.OnReloadPressed(player, gun, bSOMETHING);
}
private void Start()
{
//base.aiActor.HasBeenEngaged = true;
base.aiActor.healthHaver.OnPreDeath += (obj) =>
{
//AkSoundEngine.PostEvent("Play_ENM_beholster_death_01", base.aiActor.gameObject);
//Chest chest2 = GameManager.Instance.RewardManager.SpawnTotallyRandomChest(spawnspot)rg;
//chest2.IsLocked = false;
};
base.healthHaver.healthHaver.OnDeath += (obj) =>
{
float itemsToSpawn = UnityEngine.Random.Range(3, 6);
float spewItemDir = 360 / itemsToSpawn;
// new Vector2(spewItemDir * itemsToSpawn, 0);
for (int i = 0; i < itemsToSpawn; i++)
{
int id = BraveUtility.RandomElement <int>(TheStranger.Lootdrops);
LootEngine.SpawnItem(PickupObjectDatabase.GetById(id).gameObject, base.aiActor.sprite.WorldCenter, new Vector2(spewItemDir * itemsToSpawn, spewItemDir * itemsToSpawn), 2.2f, false, true, false);
}
Chest chest2 = GameManager.Instance.RewardManager.SpawnTotallyRandomChest(GameManager.Instance.PrimaryPlayer.CurrentRoom.GetRandomVisibleClearSpot(1, 1));
chest2.IsLocked = false;
};;
this.aiActor.knockbackDoer.SetImmobile(true, "nope.");
}
private void HandleRatBossSetup()
{
GameObject SpecialRatBoss = DungeonPlaceableUtility.InstantiateDungeonPlaceable(EnemyDatabase.GetOrLoadByGuid("6868795625bd46f3ae3e4377adce288b").gameObject, m_ParentRoom, new IntVector2(17, 28), true, AIActor.AwakenAnimationType.Awaken, true);
AIActor RatBossAIActor = SpecialRatBoss.GetComponent <AIActor>();
if (RatBossAIActor != null)
{
PickupObject.ItemQuality targetQuality = (UnityEngine.Random.value >= 0.2f) ? ((!BraveUtility.RandomBool()) ? PickupObject.ItemQuality.C : PickupObject.ItemQuality.D) : PickupObject.ItemQuality.B;
GenericLootTable lootTable = (!BraveUtility.RandomBool()) ? GameManager.Instance.RewardManager.GunsLootTable : GameManager.Instance.RewardManager.ItemsLootTable;
PickupObject item = LootEngine.GetItemOfTypeAndQuality <PickupObject>(targetQuality, lootTable, false);
PickupObject item2 = LootEngine.GetItemOfTypeAndQuality <PickupObject>(targetQuality, lootTable, false);
Destroy(RatBossAIActor.gameObject.GetComponent <ResourcefulRatDeathController>());
Destroy(RatBossAIActor.gameObject.GetComponent <ResourcefulRatRewardRoomController>());
RatBossAIActor.State = AIActor.ActorState.Awakening;
RatBossAIActor.StealthDeath = true;
RatBossAIActor.healthHaver.gameObject.AddComponent <ExpandSpawnGlitchObjectOnDeath>();
ExpandSpawnGlitchObjectOnDeath ObjectSpawnerComponent = RatBossAIActor.healthHaver.gameObject.GetComponent <ExpandSpawnGlitchObjectOnDeath>();
ObjectSpawnerComponent.spawnRatCorpse = true;
ObjectSpawnerComponent.ratCorpseSpawnsKey = true;
ObjectSpawnerComponent.parentEnemyWasRat = true;
if (item && item2)
{
RatBossAIActor.AdditionalSafeItemDrops = new List <PickupObject> {
item, item2
};
}
RatBossAIActor.healthHaver.enabled = true;
RatBossAIActor.healthHaver.forcePreventVictoryMusic = true;
RatBossAIActor.ConfigureOnPlacement(m_ParentRoom);
RatBossAIActor.specRigidbody.CollideWithOthers = true;
}
}
private void PickStats()
{
if (hasPicked)
{
return;
}
else
{
for (int i = 0; i < 2; i++)
{
Effect effect = BraveUtility.RandomElement(statEffects);
statEffects.Remove(effect);
if (effect.modifyMethod == StatModifier.ModifyMethod.MULTIPLICATIVE)
{
AddStat(effect.statToEffect, effect.amount, StatModifier.ModifyMethod.MULTIPLICATIVE);
}
else
{
AddStat(effect.statToEffect, effect.amount, StatModifier.ModifyMethod.ADDITIVE);
}
}
Owner.stats.RecalculateStats(Owner, true, false);
hasPicked = true;
}
}
private void AssignPillPools()
{
BlueBluePillEffect = BraveUtility.RandomElement(pillEffectPool);
pillEffectPool.Remove(BlueBluePillEffect);
PillPoolsAssigned = true;
}
public static void ChestPreOpen(Chest self, PlayerController opener)
{
JammedChestBehav jamness = self.gameObject.GetComponent <JammedChestBehav>();
if (jamness != null)
{
self.PredictContents(opener);
if (UnityEngine.Random.value <= 0.5f)
{
List <PickupObject> items = GenerateContents(self.lootTable, self.breakertronLootTable, opener, 0, new System.Random());
self.contents.AddRange(items);
}
else
{
int lootID = BraveUtility.RandomElement(LootIDs);
PickupObject obj = PickupObjectDatabase.GetById(lootID);
self.contents.Add(obj);
}
}
if (jamness != null)
{
SaveAPIManager.RegisterStatChange(CustomTrackedStats.JAMMED_CHESTS_OPENED, 1);
LootEngine.SpawnCurrency(self.sprite.WorldCenter, UnityEngine.Random.Range(10, 21), false);
if (UnityEngine.Random.value <= 0.25f && opener.name != "PlayerShade(Clone)")
{
opener.healthHaver.ApplyDamage(1f, Vector2.zero, "Jammed Chest");
}
}
}
private void ApplyLinearDamage(Vector2 p1, Vector2 p2)
{
float damage = damagePerHit;
if (PassiveItem.IsFlagSetForCharacter(Owner, typeof(BattleStandardItem)))
{
damage *= BattleStandardItem.BattleStandardCompanionDamageMultiplier;
}
for (int i = 0; i < StaticReferenceManager.AllEnemies.Count; i++)
{
AIActor aiactor = StaticReferenceManager.AllEnemies[i];
if (!this.m_damagedEnemies.Contains(aiactor))
{
if (aiactor && aiactor.HasBeenEngaged && aiactor.IsNormalEnemy && aiactor.specRigidbody)
{
Vector2 zero = Vector2.zero;
bool flag = BraveUtility.LineIntersectsAABB(p1, p2, aiactor.specRigidbody.HitboxPixelCollider.UnitBottomLeft, aiactor.specRigidbody.HitboxPixelCollider.UnitDimensions, out zero);
if (flag)
{
aiactor.healthHaver.ApplyDamage(this.damagePerHit, Vector2.zero, "Chain Lightning", CoreDamageTypes.Electric, DamageCategory.Normal, false, null, false);
GameManager.Instance.StartCoroutine(this.HandleDamageCooldown(aiactor));
}
}
}
}
}
protected override void OnTrigger(Vector2 damageDirection)
{
if (m_hasTriggered)
{
return;
}
m_hasTriggered = true;
if (chanceToSpawn < 1f && UnityEngine.Random.value > chanceToSpawn)
{
return;
}
if (spawnRatKey)
{
SpawnRatKey(); return;
}
GameObject[] array = null;
if (objectSelection == ObjectSelection.All)
{
array = objectsToSpawn;
}
else if (objectSelection == ObjectSelection.Random)
{
array = new GameObject[UnityEngine.Random.Range(minSpawnCount, maxSpawnCount)];
for (int i = 0; i < array.Length; i++)
{
array[i] = BraveUtility.RandomElement(objectsToSpawn);
}
}
if (parentEnemyWasRat)
{
PickupObject.RatBeatenAtPunchout = true;
}
SpawnObjects(array);
}
private void InitStorm()
{
Dungeon m_dungeonPrefab = DungeonDatabase.GetOrLoadByName("finalscenario_guide");
DungeonFlow dungeonFlowPrefab = m_dungeonPrefab.PatternSettings.flows[0];
PrototypeDungeonRoom GuidePastRoom = dungeonFlowPrefab.AllNodes[0].overrideExactRoom;
GameObject GuidePastRoomObject = GuidePastRoom.placedObjects[0].nonenemyBehaviour.gameObject;
GameObject m_RainPrefab = GuidePastRoomObject.transform.Find("Rain").gameObject;
m_ThunderStorm = Instantiate(m_RainPrefab);
m_ThunderStorm.name = "ChaosRain";
ThunderstormController stormController = m_ThunderStorm.GetComponent <ThunderstormController>();
ParticleSystem m_CachedParticleSystem = stormController.RainSystemTransform.GetComponent <ParticleSystem>();
if (useCustomIntensity)
{
BraveUtility.SetEmissionRate(m_CachedParticleSystem, RainIntensity);
}
m_cachedEmissionRate = m_CachedParticleSystem.emission.rate.constant;
stormController.DecayVertical = false;
stormController.DoLighting = false;
m_ChaosLightning = new GameObject("ChaosLightning");
m_ChaosLightning.AddComponent <ChaosWeatherController>();
ChaosWeatherController LightningComponent = m_ChaosLightning.GetComponent <ChaosWeatherController>();
LightningComponent.LightningRenderers = stormController.LightningRenderers;
dungeonFlowPrefab = null;
m_dungeonPrefab = null;
}
public static Vector2 GetVectorToNearestEnemy(this Vector3 bulletPos, float angleFromAim = 0, float angleVariance = 0, PlayerController playerToScaleAccuracyOff = null)
{
Vector2 dirVec = UnityEngine.Random.insideUnitCircle;
Vector2 bulletPosition = bulletPos;
Func <AIActor, bool> isValid = (AIActor a) => a && a.HasBeenEngaged && a.healthHaver && a.healthHaver.IsVulnerable;
IntVector2 bulletPositionIntVector2 = bulletPosition.ToIntVector2();
AIActor closestToPosition = BraveUtility.GetClosestToPosition <AIActor>(GameManager.Instance.Dungeon.data.GetAbsoluteRoomFromPosition(bulletPositionIntVector2).GetActiveEnemies(RoomHandler.ActiveEnemyType.All), bulletPosition, isValid, new AIActor[]
{
});
if (closestToPosition)
{
dirVec = closestToPosition.CenterPosition - bulletPosition;
}
if (angleFromAim != 0)
{
dirVec = dirVec.Rotate(angleFromAim);
}
if (angleVariance != 0)
{
if (playerToScaleAccuracyOff != null)
{
angleVariance *= playerToScaleAccuracyOff.stats.GetStatValue(PlayerStats.StatType.Accuracy);
}
float positiveVariance = angleVariance * 0.5f;
float negativeVariance = positiveVariance * -1f;
float finalVariance = UnityEngine.Random.Range(negativeVariance, positiveVariance);
dirVec = dirVec.Rotate(finalVariance);
}
return(dirVec);
}
private void EndEffect(PlayerController player)
{
if (UnityEngine.Random.value < this.m_exhaustionChance)
{
player.StartCoroutine(this.EndEffectCR(player));
}
if (UnityEngine.Random.value < this.m_exhaustionChance)
{
List <RoomHandler> rooms = new List <RoomHandler>();
foreach (RoomHandler room in GameManager.Instance.Dungeon.data.rooms)
{
if (!room.hasEverBeenVisited)
{
rooms.Add(room);
}
}
if (rooms.Count > 0)
{
RoomHandler randomRoom = BraveUtility.RandomElement(rooms);
IntVector2? randomAvailableCell = randomRoom.GetRandomAvailableCell(new IntVector2?(GreenChamberEyeController.hallucinationEyePrefab.GetComponent <GreenChamberEyeController>().specRigidbody.UnitDimensions.ToIntVector2(VectorConversions.Ceil)),
new CellTypes?(CellTypes.FLOOR | CellTypes.PIT), false, null);
if (randomAvailableCell.HasValue)
{
Instantiate(GreenChamberEyeController.hallucinationEyePrefab, randomAvailableCell.Value.ToVector3(0), Quaternion.identity).GetComponent <GreenChamberEyeController>().BindWithRoom(randomRoom);
}
}
}
this.m_exhaustionChance = Mathf.Min(this.m_exhaustionChance += 0.01f, 0.05f);
AkSoundEngine.PostEvent("Play_ENM_lighten_world_01", player.gameObject);
this.spriteAnimator.Play("unmelt");
}
public static Vector2 GetPositionOfNearestEnemy(this Vector2 startPosition, bool canTargetNonRoomClear, bool targetSprite = false, List <AIActor> excludedActors = null)
{
List <AIActor> exclude = new List <AIActor>();
if (excludedActors != null && excludedActors.Count > 0)
{
exclude.AddRange(excludedActors);
}
Func <AIActor, bool> isValid = (AIActor a) => a && a.HasBeenEngaged && a.healthHaver && a.healthHaver.IsVulnerable && a.healthHaver.IsAlive && !a.IsGone && !exclude.Contains(a) && a.IsWorthShootingAt && a.isActiveAndEnabled && a.CanTargetPlayers && a.GetComponent <CompanionController>() == null;
IntVector2 intVectorStartPos = startPosition.ToIntVector2();
RoomHandler.ActiveEnemyType enemyType = RoomHandler.ActiveEnemyType.RoomClear;
if (canTargetNonRoomClear)
{
enemyType = RoomHandler.ActiveEnemyType.All;
}
AIActor closestToPosition = BraveUtility.GetClosestToPosition <AIActor>(GameManager.Instance.Dungeon.data.GetAbsoluteRoomFromPosition(intVectorStartPos).GetActiveEnemies(enemyType), startPosition, isValid, new AIActor[] { });
if (closestToPosition == null)
{
return(Vector2.zero);
}
if (targetSprite && closestToPosition.sprite)
{
return(closestToPosition.sprite.WorldCenter);
}
else
{
return(closestToPosition.specRigidbody.UnitCenter);
}
}
public override void OnEffectApplied(GameActor actor, RuntimeGameActorEffectData effectData, float partialAmount = 1f)
{
base.OnEffectApplied(actor, effectData, partialAmount);
effectData.OnActorPreDeath = delegate(Vector2 dir)
{
GameActorWitherEffect.DestroyFlames(effectData);
};
actor.healthHaver.OnPreDeath += effectData.OnActorPreDeath;
{
if (effectData.vfxObjects == null)
{
effectData.vfxObjects = new List <Tuple <GameObject, float> >();
}
effectData.OnFlameAnimationCompleted = delegate(tk2dSpriteAnimator spriteAnimator, tk2dSpriteAnimationClip clip)
{
if (effectData.destroyVfx || !actor)
{
spriteAnimator.AnimationCompleted = (Action <tk2dSpriteAnimator, tk2dSpriteAnimationClip>)Delegate.Remove(spriteAnimator.AnimationCompleted, effectData.OnFlameAnimationCompleted);
UnityEngine.Object.Destroy(spriteAnimator.gameObject);
return;
}
if (UnityEngine.Random.value < this.flameMoveChance)
{
Vector2 a = actor.specRigidbody.HitboxPixelCollider.UnitDimensions / 2f;
Vector2 b = BraveUtility.RandomVector2(-a + this.flameBuffer, a - this.flameBuffer);
Vector2 v = actor.specRigidbody.HitboxPixelCollider.UnitCenter + b;
spriteAnimator.transform.position = v;
}
spriteAnimator.Play(clip, 0f, clip.fps * UnityEngine.Random.Range(1f - this.flameFpsVariation, 1f + this.flameFpsVariation), false);
};
}
}
public static bool IsHeartInRoom(Action <CaterpillarDevourHeartBehavior> orig, CaterpillarDevourHeartBehavior self)
{
AIActor m_aiActor = (AIActor)typeof(CaterpillarDevourHeartBehavior).GetField("m_aiActor", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(self);
PlayerController companionOwner = m_aiActor.CompanionOwner;
if (!companionOwner || companionOwner.CurrentRoom == null)
{
return(false);
}
List <HealthPickup> componentsAbsoluteInRoom = companionOwner.CurrentRoom.GetComponentsAbsoluteInRoom <HealthPickup>();
for (int i = 0; i < componentsAbsoluteInRoom.Count; i++)
{
HealthPickup healthPickup = componentsAbsoluteInRoom[i];
if (healthPickup)
{
if (healthPickup.armorAmount != 0)
{
componentsAbsoluteInRoom.RemoveAt(i);
i--;
}
}
}
HealthPickup closestToPosition = BraveUtility.GetClosestToPosition <HealthPickup>(componentsAbsoluteInRoom, m_aiActor.CenterPosition, new HealthPickup[0]);
if (closestToPosition != null)
{
typeof(CaterpillarDevourHeartBehavior).GetField("m_targetHeart", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(self, closestToPosition);
return(true);
}
return(false);
}
// This function doesn't null check orLoadByGuid. If non fake prefab custom enemies are spawned (like the special rats on Hollow), then this would cause exception.
// Added fall back GUIDs and use one of those for AIActor instead if this happens.
public void AddSpecificEnemyToRoomProcedurallyFixed(RoomHandler room, string enemyGuid, bool reinforcementSpawn = false, Vector2?goalPosition = null)
{
AIActor orLoadByGuid = EnemyDatabase.GetOrLoadByGuid(enemyGuid);
if (!orLoadByGuid)
{
List <string> FallbackGUIDs = new List <string>()
{
ExpandCustomEnemyDatabase.BootlegBullatGUID,
ExpandCustomEnemyDatabase.BootlegBulletManGUID,
ExpandCustomEnemyDatabase.BootlegBulletManBandanaGUID,
ExpandCustomEnemyDatabase.BootlegShotgunManBlueGUID,
ExpandCustomEnemyDatabase.BootlegShotgunManRedGUID
};
FallbackGUIDs = FallbackGUIDs.Shuffle();
orLoadByGuid = EnemyDatabase.GetOrLoadByGuid(BraveUtility.RandomElement(FallbackGUIDs));
}
IntVector2 clearance = orLoadByGuid.specRigidbody.UnitDimensions.ToIntVector2(VectorConversions.Ceil);
CellValidator cellValidator = delegate(IntVector2 c) {
for (int i = 0; i < clearance.x; i++)
{
int x = c.x + i;
for (int j = 0; j < clearance.y; j++)
{
int y = c.y + j;
if (GameManager.Instance.Dungeon.data.isTopWall(x, y))
{
return(false);
}
}
}
return(true);
};
IntVector2?intVector;
if (goalPosition != null)
{
intVector = room.GetNearestAvailableCell(goalPosition.Value, new IntVector2?(clearance), new CellTypes?(CellTypes.FLOOR), false, cellValidator);
}
else
{
intVector = room.GetRandomAvailableCell(new IntVector2?(clearance), new CellTypes?(CellTypes.FLOOR), false, cellValidator);
}
if (intVector != null)
{
AIActor aiactor = AIActor.Spawn(orLoadByGuid, intVector.Value, room, true, AIActor.AwakenAnimationType.Spawn, false);
if (aiactor && reinforcementSpawn)
{
if (aiactor.specRigidbody)
{
aiactor.specRigidbody.CollideWithOthers = false;
}
aiactor.HandleReinforcementFallIntoRoom(0f);
}
}
else
{
Debug.LogError("failed placement");
}
}
private void PickStats()
{
if (hasPicked)
{
return;
}
else
{
PlayableCharacters characterIdentity = Owner.characterIdentity;
Effect effect = BraveUtility.RandomElement(statEffects);
statEffects.Remove(effect);
if (effect.modifyMethod == StatModifier.ModifyMethod.MULTIPLICATIVE)
{
AddStat(effect.statToEffect, effect.amount, StatModifier.ModifyMethod.MULTIPLICATIVE);
}
else
{
if (effect.statToEffect == PlayerStats.StatType.Health && characterIdentity == PlayableCharacters.Robot)
{
LootEngine.GivePrefabToPlayer(PickupObjectDatabase.GetById(120).gameObject, Owner);
}
AddStat(effect.statToEffect, effect.amount, StatModifier.ModifyMethod.ADDITIVE);
}
Owner.stats.RecalculateStats(Owner, true, false);
hasPicked = true;
}
}
private void RandomToadieAirDrop(GameObject lootCratePrefab, RoomHandler currentRoom, IntVector2?Clearence = null)
{
if (!Clearence.HasValue)
{
Clearence = new IntVector2(2, 2);
}
IntVector2?DropLocation = FindRandomDropLocation(currentRoom, Clearence.Value);
if (DropLocation.HasValue)
{
EmergencyCrateController lootCrate = Instantiate(lootCratePrefab, DropLocation.Value.ToVector2().ToVector3ZUp(1f), Quaternion.identity).GetComponent <EmergencyCrateController>();
if (lootCrate == null)
{
return;
}
lootCrate.ChanceToExplode = 0;
lootCrate.ChanceToSpawnEnemy = 1;
lootCrate.EnemyPlaceable = m_CustomEnemyPlacable(BraveUtility.RandomElement(ToadieGUIDs));
lootCrate.Trigger(new Vector3(-5f, -5f, -5f), DropLocation.Value.ToVector3() + new Vector3(15f, 15f, 15f), currentRoom, true);
currentRoom.ExtantEmergencyCrate = lootCrate.gameObject;
}
return;
}
private void OnPreSpawn(AIActor actor)
{
if (Owner && actor && (actor.EnemyGuid == "699cd24270af4cd183d671090d8323a1" || actor.EnemyGuid == "a446c626b56d4166915a4e29869737fd"))
{
actor.AdditionalSafeItemDrops.Add(PickupObjectDatabase.GetById(BraveUtility.RandomElement(lootIDlist)));
}
}
