private void BreakEgg(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
float value = UnityEngine.Random.Range(0.0f, 1.0f);
bool flag = value < 0.15;
if (flag && !Owner.HasPickupID(817))
{
PlayerController player = this.Owner;
float curHealth = player.healthHaver.GetCurrentHealth();
AkSoundEngine.PostEvent("Play_WPN_egg_impact_01", base.gameObject);
player.PlayEffectOnActor(ResourceCache.Acquire("Global VFX/VFX_Healing_Sparkles_001") as GameObject, Vector3.zero, true, false, false);
player.healthHaver.ForceSetCurrentHealth(curHealth + 0.5f);
UnityEngine.Object.Destroy(base.gameObject, 1f);
player.DropPassiveItem(this);
PickupObject.ItemQuality itemQuality = PickupObject.ItemQuality.D;
PickupObject itemOfTypeAndQuality = LootEngine.GetItemOfTypeAndQuality <PickupObject>(itemQuality, (UnityEngine.Random.value >= 0.5f) ? GameManager.Instance.RewardManager.GunsLootTable : GameManager.Instance.RewardManager.ItemsLootTable, false);
if (itemOfTypeAndQuality)
{
LootEngine.SpawnItem(itemOfTypeAndQuality.gameObject, base.transform.position, Vector2.up, 0.1f, true, false, false);
}
}
else
{
return;
}
}
private void RobotTookCrestDamage(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
PlayerController player = this.Owner;
float curArmor = player.healthHaver.Armor;
GameManager.Instance.StartCoroutine(this.RobotCrestgain());
}
private void RobotTookDamage(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
PlayerController player = this.Owner;
float curArmor = player.healthHaver.Armor;
if (curArmor > 1f)
{
}
}
protected void ApplyDamage(float damage, Vector2 direction, string sourceName, CoreDamageTypes damageTypes = CoreDamageTypes.None, DamageCategory damageCategory = DamageCategory.Normal, bool ignoreInvulnerabilityFrames = false, PixelCollider hitPixelCollider = null, bool ignoreDamageCaps = false)
{
orig_ApplyDamage(damage, direction, sourceName, damageTypes, damageCategory, ignoreInvulnerabilityFrames, hitPixelCollider, ignoreDamageCaps);
if (0f < currentHealth && 0f < damage && ETGModGUI.UseDamageIndicators)
{
ETGDamageIndicatorGUI.HealthHaverTookDamage(this, damage);
}
}
private void OnDamaged(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
PlayerController player = GameManager.Instance.PrimaryPlayer;
bool flag = player.CurrentRoom != null;
if (flag)
{
player.CurrentRoom.PlayerHasTakenDamageInThisRoom = false;
}
}
private void oof(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
bool flag3 = this.m_owner.CurrentRoom != null;
if (flag3)
{
AkSoundEngine.PostEvent("Play_ENM_kali_burst_01", base.gameObject);
this.m_owner.CurrentRoom.ApplyActionToNearbyEnemies(this.m_owner.CenterPosition, 20f, new Action <AIActor, float>(this.ProcessEnemy));
}
}
public void OnTakeDamage(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
this.DamageToEnemiesInRoom = 6f;
base.Owner.CurrentRoom.ApplyActionToNearbyEnemies(base.Owner.CenterPosition, 100f, delegate(AIActor enemy, float dist)
{
if (enemy && enemy.healthHaver)
{
enemy.healthHaver.ApplyDamage(this.DamageToEnemiesInRoom, Vector2.zero, string.Empty, CoreDamageTypes.None, DamageCategory.Normal, false, null, false);
}
});
}
// Token: 0x0600033C RID: 828 RVA: 0x0001E984 File Offset: 0x0001CB84
public static void AddCurrentGunDamageTypeModifier(this Gun gun, CoreDamageTypes damageTypes, float damageMultiplier)
{
gun.currentGunDamageTypeModifiers = gun.currentGunDamageTypeModifiers.Concat(new DamageTypeModifier[]
{
new DamageTypeModifier
{
damageType = damageTypes,
damageMultiplier = damageMultiplier
}
}).ToArray <DamageTypeModifier>();
}
private void Check4LunarSyngergy(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
bool flag1 = base.LastOwner.HasPickupID(631);
if (flag1 && !this.onCooldown)
{
this.onCooldown = true;
ApplyStat(base.LastOwner, PlayerStats.StatType.Damage, 0.025f, StatModifier.ModifyMethod.ADDITIVE);
GameManager.Instance.StartCoroutine(StartCooldown());
}
}
private void PlayerTookDamage(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
if (activeOutline == true)
{
GameManager.Instance.StartCoroutine(this.GainOutline());
}
else if (activeOutline == false)
{
GameManager.Instance.StartCoroutine(this.LoseOutline());
}
}
private IEnumerator HandleDelayedDamage(SpeculativeRigidbody targetRigidbody, float damage, Vector2 damageVec, PixelCollider hitPixelCollider)
{
yield return(new WaitForSeconds(0.5f));
if (targetRigidbody && targetRigidbody.healthHaver)
{
HealthHaver healthHaver = targetRigidbody.healthHaver;
string ownerName = this.OwnerName;
CoreDamageTypes coreDamageTypes = this.damageTypes;
DamageCategory damageCategory = (!this.IsBlackBullet) ? DamageCategory.Normal : DamageCategory.BlackBullet;
healthHaver.ApplyDamage(damage, damageVec, ownerName, coreDamageTypes, damageCategory, false, hitPixelCollider, this.ignoreDamageCaps);
}
yield break;
}
private void FailContract(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
AkSoundEngine.PostEvent("Play_BOSS_lichB_intro_01", base.gameObject);
GameStatsManager.Instance.RegisterStatChange(TrackedStats.TIMES_HIT_WITH_THE_GRIPPY, 1f);
int num = 1;
if (num < 1)
{
num = 1;
}
List <RoomHandler> list = new List <RoomHandler>();
List <RoomHandler> list2 = new List <RoomHandler>();
PlayerController player = base.Owner;
list.Add(player.CurrentRoom);
while (list.Count - 1 < num)
{
RoomHandler roomHandler = list[list.Count - 1];
list2.Clear();
foreach (RoomHandler roomHandler2 in roomHandler.connectedRooms)
{
if (roomHandler2.hasEverBeenVisited && roomHandler2.distanceFromEntrance < roomHandler.distanceFromEntrance && !list.Contains(roomHandler2))
{
if (!roomHandler2.area.IsProceduralRoom || roomHandler2.area.proceduralCells == null)
{
list2.Add(roomHandler2);
}
}
}
if (list2.Count == 0)
{
break;
}
list.Add(BraveUtility.RandomElement <RoomHandler>(list2));
}
if (list.Count > 1)
{
base.Owner.RespawnInPreviousRoom(false, PlayerController.EscapeSealedRoomStyle.GRIP_MASTER, true, list[list.Count - 1]);
for (int i = 1; i < list.Count - 1; i++)
{
list[i].ResetPredefinedRoomLikeDarkSouls();
}
}
else
{
base.Owner.RespawnInPreviousRoom(false, PlayerController.EscapeSealedRoomStyle.GRIP_MASTER, true, null);
}
base.Owner.specRigidbody.Velocity = Vector2.zero;
base.Owner.knockbackDoer.TriggerTemporaryKnockbackInvulnerability(1f);
}
private void PlayerTookCrestDamage(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
PlayerController player = this.Owner;
float curHealth = player.healthHaver.GetCurrentHealth();
if (curHealth > 0.5f)
{
player.healthHaver.ForceSetCurrentHealth(curHealth - 0.5f);
GameManager.Instance.StartCoroutine(this.Crestgain());
}
else
{
return;
}
}
private void TimeIsTicking(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
this.Countdown += 1f;
bool flag = this.Countdown == 1f;
if (flag)
{
string header = "";
string text = "";
header = "The blood flows in...";
text = "The cogs start turning.";
this.Notify(header, text);
GameManager.Instance.StartCoroutine(TheCountdown());
}
}
// Token: 0x060004F7 RID: 1271 RVA: 0x0002A6B8 File Offset: 0x000288B8
private void PlayerTookDamage(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
bool flag = this.activeOutline;
if (flag)
{
GameManager.Instance.StartCoroutine(this.GainOutline());
}
else
{
bool flag2 = !this.activeOutline;
if (flag2)
{
}
}
}
private void OnDamaged(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
if ((m_attachedPlayer != null) && (m_attachedPlayer.CurrentGun != null) && (m_attachedPlayer.CurrentGun.CanActuallyBeDropped(m_attachedPlayer)))
{
if (CurseManager.CurseIsActive("Curse of Butterfingers"))
{
if (GameManager.Instance.AnyPlayerHasActiveSynergy("The Last Crusade"))
{
StartCoroutine(GoodButterfingersEffect());
}
else
{
StartCoroutine(ButterFingersGun());
}
}
}
}
private void ChaosHole(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
{
Projectile projectile = ((Gun)ETGMod.Databases.Items["black_hole_gun"]).DefaultModule.projectiles[0];
GameObject gameObject = SpawnManager.SpawnProjectile(projectile.gameObject, base.Owner.sprite.WorldCenter, Quaternion.Euler(0f, 0f, (base.Owner.CurrentGun == null) ? 0f : base.Owner.CurrentGun.CurrentAngle), true);
Projectile component = gameObject.GetComponent <Projectile>();
bool flag = component != null;
bool flag2 = flag;
if (flag2)
{
component.Owner = base.Owner;
component.Shooter = base.Owner.specRigidbody;
component.baseData.speed = 4f;
component.baseData.damage = 0.1f;
}
}
}
private void CompanionOnDamaged(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
m_healthRemaining = resultValue;
m_maxHealthRemaining = maxValue;
if (m_canSpawnRings && RingDropChance > UnityEngine.Random.value)
{
if (m_extantCompanion)
{
m_extantCompanion.GetComponent <AIActor>().behaviorSpeculator.Stun(1);
m_extantCompanion.GetComponent <AIAnimator>().PlayUntilFinished(HitAnimation);
int RingCount = UnityEngine.Random.Range(3, 10);
ExpandUtility.SpawnCustomCurrency(m_extantCompanion.GetComponent <SpeculativeRigidbody>().GetUnitCenter(ColliderType.HitBox), RingCount, SonicRing.RingID);
AkSoundEngine.PostEvent("Play_EX_SonicLoseRings_01", m_extantCompanion);
}
}
m_canSpawnRings = false;
}
public void HealthHaver_ApplyDamageHook(
HealthHaver self, float damage, Vector2 direction, string sourceName, CoreDamageTypes damageTypes = CoreDamageTypes.None, DamageCategory damageCategory = DamageCategory.Normal,
bool ignoreInvulnerabilityFrames = false, PixelCollider hitPixelCollider = null, bool ignoreDamageCaps = false)
{//Killithid's ghosts spawn without correct hitboxes and crash game on hit, this method is a bandaid for that. Kills all enemies and projectiles in room
try
{
self.orig_ApplyDamage(damage, direction, sourceName, damageTypes, damageCategory, ignoreInvulnerabilityFrames, hitPixelCollider, ignoreDamageCaps);
if (0f < self.GetCurrentHealth() && 0f < damage && ETGModGUI.UseDamageIndicators)
{
ETGDamageIndicatorGUI.HealthHaverTookDamage(self, damage);
}
}
catch (Exception e)
{
Debug.Log("[Randomizer] HealthHaverHook Error" + e);
RandomHandleEnemyInfo.DestroyEverything();
throw;
}
}
private void PlayerTookDamage(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
AIActor component = BabyGoodModular.ModulePrefab.GetComponent <AIActor>();
AIActor beans = component as AIActor;
BunnyModule.Log("start");
Projectile projectile = ((Gun)ETGMod.Databases.Items[390]).DefaultModule.projectiles[0];
// Vector3 vector = player.unadjustedAimPoint - player.LockedApproximateSpriteCenter;
//Vector3 vector2 = player.specRigidbody.UnitCenter;
GameObject gameObject = SpawnManager.SpawnProjectile(projectile.gameObject, beans.sprite.WorldCenter, Quaternion.Euler(0f, 0f, ((base.Owner.CurrentGun == null) ? 1.2f : base.Owner.CurrentGun.CurrentAngle) + UnityEngine.Random.Range(-180, 180)), true);
Projectile component1 = gameObject.GetComponent <Projectile>();
BounceProjModifier bouncy = component.gameObject.AddComponent <BounceProjModifier>();
bouncy.numberOfBounces = 2;
{
component1.Owner = base.Owner;
component1.Shooter = base.Owner.specRigidbody;
}
//LootEngine.SpawnItem(PickupObjectDatabase.GetById(68).gameObject, beans.sprite.WorldCenter, Vector2.down, .7f, false, true, false);
//BunnyModule.Log("end");
}
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);
}
}
private void SwapPositions(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
if (resultValue > 0)
{
attempts++;
RoomHandler absoluteRoom = daguy.CenterPosition.GetAbsoluteRoom();
AIActor randomActiveEnemy2 = absoluteRoom.GetRandomActiveEnemy(false);
while (randomActiveEnemy2 == daguy && !(attempts >= 100))
{
attempts = 0;
randomActiveEnemy2 = absoluteRoom.GetRandomActiveEnemy(false);
}
if (randomActiveEnemy2 != daguy)
{
Vector2 vector = daguy.CenterPosition;
daguy.transform.position = randomActiveEnemy2.CenterPosition;
randomActiveEnemy2.transform.position = vector;
daguy.specRigidbody.Reinitialize();
randomActiveEnemy2.specRigidbody.Reinitialize();
}
}
}
private void HandleGenieSpawn(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
PlayerController player = this.Owner;
if (ActiveGenie != true && Owner.IsInCombat)
{
ActiveGenie = true;
GameManager.Instance.StartCoroutine(this.GenieTimer());
}
if (player.HasPickupID(369))
{
Projectile projectile = ((Gun)ETGMod.Databases.Items[369]).DefaultModule.projectiles[0];
GameObject gameObject = SpawnManager.SpawnProjectile(projectile.gameObject, player.sprite.WorldCenter, Quaternion.Euler(0f, 0f, 0f), true);
Projectile component = gameObject.GetComponent <Projectile>();
if (component != null)
{
component.Owner = player;
component.baseData.range = 0f;
component.baseData.damage = 0f;
component.collidesWithPlayer = true;
}
}
}
private void PlayerTookDamage(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
playerHP = Owner.healthHaver.GetCurrentHealthPercentage();
string playerHPMSG = playerHP + "";
if (statsChanged == true)
{
ETGModConsole.Log(playerHPMSG, false);
//if (fireRateBuff <= 0) return;
float curFireRate2 = Owner.stats.GetBaseStatValue(PlayerStats.StatType.RateOfFire);
float newFireRate2 = curFireRate2 - fireRateBuff;
Owner.stats.SetBaseStatValue(PlayerStats.StatType.RateOfFire, newFireRate2, Owner);
fireRateBuff = -1;
ETGModConsole.Log(playerHPMSG, false);
// if (reloadBuff <= 0) return;
float curReload2 = Owner.stats.GetBaseStatValue(PlayerStats.StatType.ReloadSpeed);
float newReload2 = curReload2 - reloadBuff;
Owner.stats.SetBaseStatValue(PlayerStats.StatType.RateOfFire, newReload2, Owner);
reloadBuff = -1;
}
float curFireRate = Owner.stats.GetBaseStatValue(PlayerStats.StatType.RateOfFire);
float newFireRate = curFireRate + ((1 - playerHP) * 2);
Owner.stats.SetBaseStatValue(PlayerStats.StatType.RateOfFire, newFireRate, Owner);
fireRateBuff = newFireRate - curFireRate;
float curReload = Owner.stats.GetBaseStatValue(PlayerStats.StatType.ReloadSpeed);
float newReload = curReload - ((1 - playerHP) / 4);
Owner.stats.SetBaseStatValue(PlayerStats.StatType.ReloadSpeed, newReload, Owner);
reloadBuff = newReload - curReload;
}
private void charmAll(float healthRemaining, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
if (damageTypes != CoreDamageTypes.Void)
{
}
}
public static void GenerateRoomLayoutFromPNG(PrototypeDungeonRoom room, string filePath, PrototypeRoomPitEntry.PitBorderType PitBorderType = PrototypeRoomPitEntry.PitBorderType.FLAT, CoreDamageTypes DamageCellsType = CoreDamageTypes.None)
{
Texture2D m_TextureFromResource = ResourceExtractor.GetTextureFromResource(TextureBasePath + filePath);
float DamageToPlayersPerTick = 0;
float DamageToEnemiesPerTick = 0;
float TickFrequency = 0;
bool RespectsFlying = true;
bool DamageCellsArePoison = false;
if (DamageCellsType == CoreDamageTypes.Fire)
{
DamageToPlayersPerTick = 0.5f;
TickFrequency = 1;
}
else if (DamageCellsType == CoreDamageTypes.Poison)
{
DamageCellsArePoison = true;
DamageToPlayersPerTick = 0.5f;
TickFrequency = 1;
}
if (m_TextureFromResource == null)
{
ETGModConsole.Log("[ExpandTheGungeon] GenerateRoomFromImage: Error! Requested Texture Resource is Null!");
return;
}
Color WhitePixel = new Color32(255, 255, 255, 255); // Wall Cell
Color PinkPixel = new Color32(255, 0, 255, 255); // Diagonal Wall Cell (North East)
Color YellowPixel = new Color32(255, 255, 0, 255); // Diagonal Wall Cell (North West)
Color HalfPinkPixel = new Color32(127, 0, 127, 255); // Diagonal Wall Cell (South East)
Color HalfYellowPixel = new Color32(127, 127, 0, 255); // Diagonal Wall Cell (South West)
Color BluePixel = new Color32(0, 0, 255, 255); // Floor Cell
Color BlueHalfGreenPixel = new Color32(0, 127, 255, 255); // Floor Cell (Ice Override)
Color HalfBluePixel = new Color32(0, 0, 127, 255); // Floor Cell (Water Override)
Color HalfRedPixel = new Color32(0, 0, 127, 255); // Floor Cell (Carpet Override)
Color GreenHalfRBPixel = new Color32(127, 255, 127, 255); // Floor Cell (Grass Override)
Color HalfWhitePixel = new Color32(127, 127, 127, 255); // Floor Cell (Bone Override)
Color OrangePixel = new Color32(255, 127, 0, 255); // Floor Cell (Flesh Override)
Color RedHalfGBPixel = new Color32(255, 127, 127, 255); // Floor Cell (ThickGoop Override)
Color GreenPixel = new Color32(0, 255, 0, 255); // Damage Floor Cell
Color RedPixel = new Color32(255, 0, 0, 255); // Pit Cell
int width = room.Width;
int height = room.Height;
int ArrayLength = (width * height);
if (m_TextureFromResource.GetPixels32().Length != ArrayLength)
{
ETGModConsole.Log("[ExpandTheGungeon] GenerateRoomFromImage: Error! Image resolution doesn't match size of room!");
return;
}
room.FullCellData = new PrototypeDungeonRoomCellData[ArrayLength];
List <Vector2> m_Pits = new List <Vector2>();
for (int X = 0; X < width; X++)
{
for (int Y = 0; Y < height; Y++)
{
int ArrayPosition = (Y * width + X);
Color? m_Pixel = m_TextureFromResource.GetPixel(X, Y);
CellType cellType = CellType.FLOOR;
DiagonalWallType diagonalWallType = DiagonalWallType.NONE;
CellVisualData.CellFloorType OverrideFloorType = CellVisualData.CellFloorType.Stone;
bool isDamageCell = false;
bool cellDamagesPlayer = false;
if (m_Pixel.HasValue)
{
if (m_Pixel.Value == WhitePixel | m_Pixel.Value == PinkPixel |
m_Pixel.Value == YellowPixel | m_Pixel.Value == HalfPinkPixel |
m_Pixel.Value == HalfYellowPixel)
{
cellType = CellType.WALL;
if (m_Pixel.Value == PinkPixel)
{
diagonalWallType = DiagonalWallType.NORTHEAST;
}
else if (m_Pixel.Value == YellowPixel)
{
diagonalWallType = DiagonalWallType.NORTHWEST;
}
else if (m_Pixel.Value == HalfPinkPixel)
{
diagonalWallType = DiagonalWallType.SOUTHEAST;
}
else if (m_Pixel.Value == HalfYellowPixel)
{
diagonalWallType = DiagonalWallType.SOUTHWEST;
}
}
else if (m_Pixel.Value == RedPixel)
{
cellType = CellType.PIT;
m_Pits.Add(new Vector2(X, Y));
}
else if (m_Pixel.Value == BluePixel | m_Pixel.Value == GreenPixel |
m_Pixel.Value == BlueHalfGreenPixel | m_Pixel.Value == HalfBluePixel |
m_Pixel.Value == HalfRedPixel | m_Pixel.Value == GreenHalfRBPixel |
m_Pixel.Value == HalfWhitePixel | m_Pixel.Value == OrangePixel |
m_Pixel.Value == RedHalfGBPixel)
{
cellType = CellType.FLOOR;
if (m_Pixel.Value == GreenPixel)
{
isDamageCell = true;
if (DamageCellsType == CoreDamageTypes.Ice)
{
cellDamagesPlayer = false;
}
else
{
cellDamagesPlayer = true;
}
}
else if (m_Pixel.Value == BlueHalfGreenPixel)
{
OverrideFloorType = CellVisualData.CellFloorType.Ice;
}
else if (m_Pixel.Value == HalfBluePixel)
{
OverrideFloorType = CellVisualData.CellFloorType.Water;
}
else if (m_Pixel.Value == HalfRedPixel)
{
OverrideFloorType = CellVisualData.CellFloorType.Carpet;
}
else if (m_Pixel.Value == GreenHalfRBPixel)
{
OverrideFloorType = CellVisualData.CellFloorType.Grass;
}
else if (m_Pixel.Value == HalfWhitePixel)
{
OverrideFloorType = CellVisualData.CellFloorType.Bone;
}
else if (m_Pixel.Value == OrangePixel)
{
OverrideFloorType = CellVisualData.CellFloorType.Flesh;
}
else if (m_Pixel.Value == RedHalfGBPixel)
{
OverrideFloorType = CellVisualData.CellFloorType.ThickGoop;
}
}
else
{
cellType = CellType.FLOOR;
}
}
else
{
cellType = CellType.FLOOR;
}
if (DamageCellsType != CoreDamageTypes.None && isDamageCell)
{
room.FullCellData[ArrayPosition] = GenerateCellData(cellType, diagonalWallType, cellDamagesPlayer, DamageCellsArePoison, DamageCellsType, DamageToPlayersPerTick, DamageToEnemiesPerTick, TickFrequency, RespectsFlying);
}
else
{
room.FullCellData[ArrayPosition] = GenerateCellData(cellType, diagonalWallType, OverrideFloorType: OverrideFloorType);
}
}
}
if (m_Pits.Count > 0)
{
room.pits = new List <PrototypeRoomPitEntry>()
{
new PrototypeRoomPitEntry(m_Pits)
{
containedCells = m_Pits,
borderType = PitBorderType
}
};
}
room.OnBeforeSerialize();
room.OnAfterDeserialize();
room.UpdatePrecalculatedData();
}
public static PrototypeDungeonRoomCellData GenerateCellData(CellType cellType, DiagonalWallType diagnalWallType = DiagonalWallType.NONE, bool DoesDamage = false, bool IsPoison = false, CoreDamageTypes DamageType = CoreDamageTypes.None, float DamageToPlayersPerTick = 0, float DamageToEnemiesPerTick = 0, float TickFrequency = 0, bool RespectsFlying = true, CellVisualData.CellFloorType OverrideFloorType = CellVisualData.CellFloorType.Stone)
{
PrototypeDungeonRoomCellData m_NewCellData = new PrototypeDungeonRoomCellData(string.Empty, cellType)
{
state = cellType,
diagonalWallType = diagnalWallType,
breakable = false,
str = string.Empty,
conditionalOnParentExit = false,
conditionalCellIsPit = false,
parentExitIndex = -1,
containsManuallyPlacedLight = false,
lightPixelsOffsetY = 0,
lightStampIndex = 0,
doesDamage = DoesDamage,
damageDefinition = new CellDamageDefinition()
{
damageTypes = DamageType,
damageToPlayersPerTick = DamageToEnemiesPerTick,
damageToEnemiesPerTick = DamageToEnemiesPerTick,
tickFrequency = TickFrequency,
respectsFlying = RespectsFlying,
isPoison = IsPoison
},
appearance = new PrototypeDungeonRoomCellAppearance()
{
overrideDungeonMaterialIndex = -1,
IsPhantomCarpet = false,
ForceDisallowGoop = false,
OverrideFloorType = OverrideFloorType,
globalOverrideIndices = new PrototypeIndexOverrideData()
{
indices = new List <int>(0)
}
},
ForceTileNonDecorated = false,
additionalPlacedObjectIndices = new List <int>()
{
-1
},
placedObjectRUBELIndex = -1
};
if (DamageType == CoreDamageTypes.Poison)
{
m_NewCellData.ForceTileNonDecorated = true;
m_NewCellData.appearance.OverrideFloorType = CellVisualData.CellFloorType.Stone;
m_NewCellData.damageDefinition.damageTypes = CoreDamageTypes.Poison;
}
else if (DamageType == CoreDamageTypes.Fire)
{
m_NewCellData.ForceTileNonDecorated = true;
m_NewCellData.appearance.OverrideFloorType = CellVisualData.CellFloorType.Stone;
m_NewCellData.damageDefinition.damageTypes = CoreDamageTypes.Fire;
}
return(m_NewCellData);
}
private void OnDamaged(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
this.BreakStealth(gun.CurrentOwner as PlayerController);
}
private void OnDamaged(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
this.BreakStealth(this.StoredPlayer);
}
private void HandleDamaged(float resultValue, float maxValue, CoreDamageTypes damageTypes, DamageCategory damageCategory, Vector2 damageDirection)
{
base.healthHaver.FullHeal();
}
