public override void Update()
{
if (Owner && !Dungeon.IsGenerating && Owner.IsInCombat && base.transform.position.GetAbsoluteRoom() == Owner.CurrentRoom)
{
if (timer > 0)
{
timer -= BraveTime.DeltaTime;
}
if (timer <= 0)
{
this.aiAnimator.PlayUntilFinished("attack", false, null, -1f, false);
Exploder.DoRadialKnockback(this.specRigidbody.UnitCenter, 70, 10);
float dmg = 2.5f;
if (PassiveItem.IsFlagSetForCharacter(this.Owner, typeof(BattleStandardItem)))
{
dmg *= BattleStandardItem.BattleStandardCompanionDamageMultiplier;
}
if (this.Owner.CurrentGun && this.Owner.CurrentGun.LuteCompanionBuffActive)
{
dmg *= 2;
}
Exploder.DoRadialDamage(dmg, this.specRigidbody.UnitCenter, 10, false, true, false, null);
timer = 1.5f;
}
}
}
private void HandleCompanionPostProcessProjectile(Projectile obj)
{
obj.IsBulletScript = false;
if (obj)
{
obj.collidesWithPlayer = false;
obj.collidesWithEnemies = true;
obj.TreatedAsNonProjectileForChallenge = true;
obj.UpdateCollisionMask();
}
if (this.owner)
{
if (PassiveItem.IsFlagSetForCharacter(this.owner, typeof(BattleStandardItem)))
{
obj.baseData.damage *= BattleStandardItem.BattleStandardCompanionDamageMultiplier;
}
if (this.owner.CurrentGun && this.owner.CurrentGun.LuteCompanionBuffActive)
{
obj.baseData.damage *= 2f;
}
if (this.owner.PlayerHasActiveSynergy("#GRIM_SUPERREAPER"))
{
obj.baseData.damage *= 2f;
}
this.owner.DoPostProcessProjectile(obj);
}
}
// Token: 0x0600769E RID: 30366 RVA: 0x002E4CD4 File Offset: 0x002E2ED4
private void Shoot(Vector2 targetPosition, Vector2 startOffset)
{
Vector2 vector = base.transform.position.XY() + startOffset;
Vector2 vector2 = targetPosition - vector;
float z = Mathf.Atan2(vector2.y, vector2.x) * 57.29578f;
GameObject gameObject = this.GetProjectile().gameObject;
GameObject gameObject2 = SpawnManager.SpawnProjectile(gameObject, vector, Quaternion.Euler(0f, 0f, z), true);
Projectile component = gameObject2.GetComponent <Projectile>();
component.collidesWithEnemies = true;
component.collidesWithPlayer = false;
component.Owner = this.m_owner;
component.Shooter = this.m_owner.specRigidbody;
component.TreatedAsNonProjectileForChallenge = true;
if (this.m_owner)
{
if (PassiveItem.IsFlagSetForCharacter(this.m_owner, typeof(BattleStandardItem)))
{
component.baseData.damage *= BattleStandardItem.BattleStandardCompanionDamageMultiplier;
}
if (this.m_owner.CurrentGun && this.m_owner.CurrentGun.LuteCompanionBuffActive)
{
component.baseData.damage *= 2f;
component.RuntimeUpdateScale(1.75f);
}
this.m_owner.DoPostProcessProjectile(component);
}
}
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));
}
}
}
}
}
public static void PlayerGunsnItem()
{//used for giving player random gun and item. Initialized in hook
PlayerController player = GameManager.Instance.PrimaryPlayer;
bool flag = player == null;
if (flag)
{
ETGModConsole.Log("<color=#FF0000FF>Please select a character and enter the gungeon.</color>", false);
}
else
{
Gun[] guns = UnityEngine.Resources.FindObjectsOfTypeAll <Gun>();
PassiveItem[] passiveitems = UnityEngine.Resources.FindObjectsOfTypeAll <PassiveItem>();
PlayerItem[] playeritems = UnityEngine.Resources.FindObjectsOfTypeAll <PlayerItem>();
System.Random rnd = new System.Random();
//ETGModConsole.Log(String.Format("Length guns {0}, passive {1}, active{2}", guns.Length, passiveitems.Length, playeritems.Length));
int guns_count = rnd.Next(0, guns.Length);
int passiveitems_count = rnd.Next(0, passiveitems.Length);
Gun gun = guns[guns_count];
PassiveItem passiveitem = passiveitems[passiveitems_count];
//ETGModConsole.Log(gun.gunName);
PickupObject pickupgun = PickupObjectDatabase.Instance.InternalGetById(gun.PickupObjectId);
PickupObject pickuppassive = PickupObjectDatabase.Instance.InternalGetById(passiveitem.PickupObjectId);
LootEngine.TryGivePrefabToPlayer(pickupgun.gameObject, Game.PrimaryPlayer, false);
LootEngine.TryGivePrefabToPlayer(pickuppassive.gameObject, Game.PrimaryPlayer, false);
}
}
public override void Update()
{ // deathcontroller
if (host != null && host.healthHaver.GetCurrentHealth() == 0)
{
this.LastOwner.CurrentStoneGunTimer = 1f;
this.LastOwner.MovementModifiers -= this.NoMotionModifier;
this.LastOwner.IsStationary = false;
modifierController = 0;
this.LastOwner.IsEthereal = false;
this.LastOwner.SetIsStealthed(false, "cause they just are");
PassiveItem.DecrementFlag(this.LastOwner, typeof(LiveAmmoItem));
this.LastOwner.stats.RecalculateStats(LastOwner, true);
CamToggle = 0;
GameManager.Instance.MainCameraController.StartTrackingPlayer();
GameManager.Instance.MainCameraController.SetManualControl(false, true);
}
if (host != null && CamToggle == 1)
{
// in head state
CameraController m_camera = GameManager.Instance.MainCameraController;
m_camera.StopTrackingPlayer();
m_camera.SetManualControl(true, false);
m_camera.OverridePosition = host.CenterPosition;
TargetNumber1(host, this.LastOwner);
RoomHandler room = this.LastOwner.CurrentRoom;
proximity(this.LastOwner);
foreach (var enemy in room.GetActiveEnemies(RoomHandler.ActiveEnemyType.All))
{
System.Random rng = new System.Random();
int chanceToFire = rng.Next(1, 80);
if (chanceToFire == 1 && enemy != host)
{
enemy.aiShooter.ShootAtTarget();
}
}
//poison
List <AIActor> activeEnemies = base.LastOwner.CurrentRoom.GetActiveEnemies(RoomHandler.ActiveEnemyType.All);
Vector2 centerPosition = host.specRigidbody.UnitCenter;
foreach (AIActor aiactor in activeEnemies)
{
bool flag3 = Vector2.Distance(aiactor.CenterPosition, centerPosition) < 1.5f && aiactor.healthHaver.GetMaxHealth() > 0f && aiactor != null && aiactor.specRigidbody != null && base.LastOwner != null;
if (flag3 && aiactor != host)
{
aiactor.ApplyEffect(Game.Items["irradiated_lead"].GetComponent <BulletStatusEffectItem>().HealthModifierEffect, 4f, null);
aiactor.ApplyEffect(Game.Items["hot_lead"].GetComponent <BulletStatusEffectItem>().HealthModifierEffect, 4f, null);
aiactor.ApplyEffect(Game.Items["battery_bullets"].GetComponent <BulletStatusEffectItem>().HealthModifierEffect, 4f, null);
}
}
}
base.Update();
}
void FixedUpdate()
{
if (Time.time - lastSwitch > switchTime)
{
SetGoopIndex(Random.Range(1, goopDefs.Count));
lastSwitch = Time.time;
this.aiActor.OverrideTarget = this.m_owner?.CurrentRoom?.GetRandomActiveEnemy(false)?.specRigidbody;
}
if (!this.m_owner.IsInCombat)
{
SetGoopIndex(0);
}
sprite.color = Color.Lerp(sprite.color, tint, .1f);
float circleSize = .5f;
if (PassiveItem.IsFlagSetForCharacter(m_owner, typeof(BattleStandardItem)))
{
circleSize *= 2;
}
var ddgm = DeadlyDeadlyGoopManager.GetGoopManagerForGoopType(currentGoop);
ddgm.AddGoopCircle(sprite.WorldCenter, circleSize);
//if (currentGoop.name.Contains("water"))
//ddgm.ElectrifyGoopCircle(sprite.WorldBottomCenter, 1);
}
public override void OnPickUp(PlayerItemPickUpData data)
{
// Get Item Reference
PassiveItem passiveItem = Item as PassiveItem;
// Spawn Item
if (Item.gameObject.IsPrefab())
{
passiveItem = ItemDB.Inst.SpawnItem(Item.GetType()).GetComponent <PassiveItem>();
}
// Add To Inventory
if (PlayerInventoryManager.passiveInventory.TryUpgradeItem(passiveItem.GetType()))
{
Destroy(passiveItem.gameObject);
goto EXIT;
}
if (PlayerInventoryManager.passiveInventory.TryAddItem(passiveItem))
{
goto EXIT;
}
return;
EXIT:
Destroy(gameObject);
}
protected override void DoEffect(PlayerController player)
{
if (numberOfUses == 2)
{
Vector2 vector = player.unadjustedAimPoint.XY() - player.CenterPosition;
float zRotation = BraveMathCollege.Atan2Degrees(vector);
player.StartCoroutine(this.HandleSwing(player, vector, 0f, 20f));
}
if (numberOfUses == 1)
{
player.CurrentStoneGunTimer = 1f;
player.MovementModifiers -= this.NoMotionModifier;
player.IsStationary = false;
modifierController = 0;
player.IsEthereal = false;
if (host != null)
{
host.healthHaver.ApplyDamage(99999, Vector2.zero, "unbound", CoreDamageTypes.Magic, DamageCategory.Unstoppable, true, null, false);
host = null;
}
player.SetIsStealthed(false, "cause they just are");
PassiveItem.DecrementFlag(player, typeof(LiveAmmoItem));
this.LastOwner.stats.RecalculateStats(LastOwner, true);
CamToggle = 0;
GameManager.Instance.MainCameraController.StartTrackingPlayer();
GameManager.Instance.MainCameraController.SetManualControl(false, true);
}
}
public static void AddStat(this PassiveItem item, PlayerStats.StatType statType, float amount, StatModifier.ModifyMethod method = StatModifier.ModifyMethod.ADDITIVE)
{
StatModifier statModifier = new StatModifier
{
amount = amount,
statToBoost = statType,
modifyType = method
};
foreach (StatModifier statModifier2 in item.passiveStatModifiers)
{
bool flag = statModifier2.statToBoost == statType;
if (flag)
{
return;
}
}
bool flag2 = item.passiveStatModifiers == null;
if (flag2)
{
item.passiveStatModifiers = new StatModifier[]
{
statModifier
};
return;
}
item.passiveStatModifiers = item.passiveStatModifiers.Concat(new StatModifier[]
{
statModifier
}).ToArray <StatModifier>();
}
protected override void OnPreDrop(PlayerController user)
{
PassiveItem.DecrementFlag(user, typeof(PickpocketGuide));
unstealthBehavior unstealthBehavior = user.gameObject.GetOrAddComponent <unstealthBehavior>();
UnityEngine.Object.DestroyImmediate(unstealthBehavior);
}
private void onPassiveItemCollected(Character character, int ItemID)
{
CharacterStats characterStats = character.characterStats;
PassiveItem passiveItem = passiveItemLibrary[ItemID];
characterStats.MaxHealth += passiveItem.maxHealth;
characterStats.HealthRegen += passiveItem.healthRegen;
characterStats.MaxEnergy += passiveItem.maxEnergy;
characterStats.EnergyRegen += passiveItem.energyRegen;
characterStats.ShootEnergyCost += passiveItem.shootEnergyCost;
characterStats.SpecialMovementCost += passiveItem.specialMovementCost;
characterStats.ShieldEnergyRate += passiveItem.shieldEnergyRate;
characterStats.RateOfFire /= passiveItem.rateOfFire; //rate of fire will always be handled by division;
characterStats.DamageDealt += passiveItem.damageDealt;
characterStats.ProjectileSpeed += passiveItem.projectileSpeed;
characterStats.ProjectileLifeSpan += passiveItem.projectileLifeSpan;
characterStats.MovementSpeed += passiveItem.movementSpeed;
characterStats.SpecialMovementSpeed += passiveItem.specialMovementSpeed;
if (passiveItem.characterModelChange)
{
playerVisualLibrary[ItemID](characterStats);
characterStats.updateProjectile();
}
Messenger <CharacterStats> .Broadcast(GameEvent.CHARACTER_UPDATED, characterStats);
}
private void Awake() //Build all Activatable Items, decode passive items json,
{
passiveItemLibrary = new Dictionary <int, PassiveItem>();
string m_PassiveItemsPath = Application.dataPath + "/PassiveItems.json";
string json;
var fileStream = new FileStream(m_PassiveItemsPath, FileMode.Open, FileAccess.Read);
using (var streamReader = new StreamReader(fileStream, Encoding.UTF8))
{
while ((json = streamReader.ReadLine()) != null)
{
PassiveItem currPassiveItem = JsonUtility.FromJson <PassiveItem>(@json);
passiveItemLibrary[currPassiveItem.ID] = currPassiveItem;
}
}
Debug.Log("Passive Item Library populated");
playerVisualLibrary = new Dictionary <int, System.Action <CharacterStats> >();
Messenger <Character, int> .AddListener(GameEvent.PASSIVE_ITEM_COLLECTED, onPassiveItemCollected);
}
// Token: 0x06007CE5 RID: 31973 RVA: 0x00316054 File Offset: 0x00314254
public void Interact(PlayerController interactor)
{
if (!PassiveItem.IsFlagSetAtAll(typeof(CatchingMitts)) || base.projectile == null)
{
return;
}
PlayerController player = GameManager.Instance.PrimaryPlayer;
CatchingMitts.cooldownBehavior cooldownBehavior = player.GetComponent <CatchingMitts.cooldownBehavior>();
if (cooldownBehavior.parentItem.cooldown > 0.25f)
{
base.projectile.DieInAir(false, true, true, false);
this.m_room.DeregisterInteractable(this);
SpriteOutlineManager.RemoveOutlineFromSprite(base.sprite, false);
if (player.PlayerHasActiveSynergy("Shortstop"))
{
player.CurrentGun.GainAmmo(1);
}
else if (UnityEngine.Random.value <= 0.5f)
{
player.CurrentGun.GainAmmo(1);
}
cooldownBehavior.parentItem.cooldown = 0f;
}
}
protected void HandleForgeHammerPostProcessProjectile(Projectile obj)
{
if (obj)
{
obj.collidesWithPlayer = false;
obj.collidesWithEnemies = true;
obj.TreatedAsNonProjectileForChallenge = true;
if (m_Owner)
{
if (PassiveItem.IsFlagSetForCharacter(m_Owner, typeof(BattleStandardItem)))
{
obj.baseData.damage *= BattleStandardItem.BattleStandardCompanionDamageMultiplier;
}
if (m_Owner.CurrentGun && m_Owner.CurrentGun.LuteCompanionBuffActive)
{
obj.baseData.damage *= 2f;
obj.RuntimeUpdateScale(1f / obj.AdditionalScaleMultiplier);
obj.RuntimeUpdateScale(1.75f);
}
obj.baseData.damage *= 5f;
m_Owner.DoPostProcessProjectile(obj);
}
else
{
obj.baseData.damage *= 4;
}
}
}
public override DebrisObject Drop(PlayerController player)
{
DebrisObject debrisObject = base.Drop(player);
debrisObject.GetComponent <Hoverboard>().m_pickedUpThisRun = true;
PassiveItem.DecrementFlag(player, typeof(WingsItem));
return(debrisObject);
}
public void ctor(PassiveItem p)
{
object_ctor();
ItemID = ((Semi.Patches.PickupObject)(global::PickupObject) p).UniqueItemID;
SerializedData = new List <object>();
p.MidGameSerialize(SerializedData);
}
protected override void OnDestroy()
{
base.OnDestroy();
if (base.Owner != null)
{
PassiveItem.DecrementFlag(base.Owner, typeof(LiveAmmoItem));
}
}
public override DebrisObject Drop(PlayerController player)
{
PassiveItem.DecrementFlag(player, typeof(CatchingMitts));
cooldownBehavior cooldownBehavior = player.gameObject.GetComponent <cooldownBehavior>();
UnityEngine.Object.Destroy(cooldownBehavior);
return(base.Drop(player));
}
private IEnumerator DoLaserAttack()
{
isAttacking = true;
this.aiAnimator.PlayUntilFinished("attack", false, null, -1f, false);
yield return(new WaitForSeconds(0.5f));
//Start Firing Lasers
this.aiActor.MovementSpeed *= 0.0001f;
this.aiAnimator.PlayForDuration("contattack", 1);
Projectile beamToFire = LaserBullets.SimpleRedBeam.projectile;
if (UnityEngine.Random.value <= 0.5f)
{
int angle = 135;
for (int i = 0; i < 4; i++)
{
BeamController beam = BeamToolbox.FreeFireBeamFromAnywhere(beamToFire, this.m_owner, this.gameObject, Vector2.zero, false, angle, 1, true);
Projectile beamprojcomponent = beam.GetComponent <Projectile>();
beamprojcomponent.baseData.damage *= 3f;
if (PassiveItem.IsFlagSetForCharacter(this.Owner, typeof(BattleStandardItem)))
{
beamprojcomponent.baseData.damage *= BattleStandardItem.BattleStandardCompanionDamageMultiplier;
}
if (this.Owner.CurrentGun && this.Owner.CurrentGun.LuteCompanionBuffActive)
{
beamprojcomponent.baseData.damage *= 2;
}
angle -= 90;
}
}
else
{
int angle = 180;
for (int i = 0; i < 4; i++)
{
BeamController beam = BeamToolbox.FreeFireBeamFromAnywhere(beamToFire, this.m_owner, this.gameObject, Vector2.zero, false, angle, 1, true);
Projectile beamprojcomponent = beam.GetComponent <Projectile>();
beamprojcomponent.baseData.damage *= 3f;
if (PassiveItem.IsFlagSetForCharacter(this.Owner, typeof(BattleStandardItem)))
{
beamprojcomponent.baseData.damage *= BattleStandardItem.BattleStandardCompanionDamageMultiplier;
}
if (this.Owner.CurrentGun && this.Owner.CurrentGun.LuteCompanionBuffActive)
{
beamprojcomponent.baseData.damage *= 2;
}
angle -= 90;
}
}
yield return(new WaitForSeconds(1f));
//Stop shit
isAttacking = false;
timer = 1.5f;
this.aiActor.MovementSpeed /= 0.0001f;
yield break;
}
public static void RemovePassiveItem(PlayerController self, PassiveItem passive)
{
int num = self.passiveItems.IndexOf(passive);
if (num >= 0)
{
TakeableEnemy.RemovePassiveItemAt(self, num);
}
}
public static void RemovePassiveItemAt(PlayerController self, int index)
{
PassiveItem passiveItem = self.passiveItems[index];
self.passiveItems.RemoveAt(index);
GameUIRoot.Instance.RemovePassiveItemFromDock(passiveItem);
UnityEngine.Object.Destroy(passiveItem);
self.stats.RecalculateStats(self, false, false);
}
// Token: 0x06007CE4 RID: 31972 RVA: 0x00316033 File Offset: 0x00314233
public void OnExitRange(PlayerController interactor)
{
if (!PassiveItem.IsFlagSetAtAll(typeof(PickpocketGuide)))
{
return;
}
SpriteOutlineManager.RemoveOutlineFromSprite(base.sprite, true);
SpriteOutlineManager.AddOutlineToSprite(base.sprite, Color.black);
}
private void Start()
{
if (!PassiveItem.IsFlagSetAtAll(typeof(PickpocketGuide)))
{
return;
}
this.m_room = GameManager.Instance.Dungeon.data.GetAbsoluteRoomFromPosition(base.transform.position.IntXY(VectorConversions.Round));
this.m_room.RegisterInteractable(this);
}
public static void RemovePassiveItemAtIndex(this PlayerController player, int index)
{
PassiveItem passiveItem = player.passiveItems[index];
GameUIRoot.Instance.RemovePassiveItemFromDock(passiveItem);
player.passiveItems.RemoveAt(index);
UnityEngine.Object.Destroy(passiveItem);
player.stats.RecalculateStats(player, false, false);
}
// Token: 0x06007CE3 RID: 31971 RVA: 0x0026DAFF File Offset: 0x0026BCFF
public void OnEnteredRange(PlayerController interactor)
{
if (!PassiveItem.IsFlagSetAtAll(typeof(LootersGloves)))
{
return;
}
SpriteOutlineManager.RemoveOutlineFromSprite(base.sprite, true);
SpriteOutlineManager.AddOutlineToSprite(base.sprite, Color.white);
}
// Token: 0x06007CE4 RID: 31972 RVA: 0x00316033 File Offset: 0x00314233
public void OnExitRange(PlayerController interactor)
{
if (!PassiveItem.IsFlagSetAtAll(typeof(CatchingMitts)) || !base.sprite || !base.projectile)
{
return;
}
SpriteOutlineManager.RemoveOutlineFromSprite(base.sprite, true);
SpriteOutlineManager.AddOutlineToSprite(base.sprite, Color.black);
}
private void Start()
{
if (!PassiveItem.IsFlagSetAtAll(typeof(LootersGloves)))
{
return;
}
this.m_room = GameManager.Instance.Dungeon.data.GetAbsoluteRoomFromPosition(base.transform.position.IntXY(VectorConversions.Round));
this.m_room.RegisterInteractable(this);
SpriteOutlineManager.AddOutlineToSprite(base.sprite, Color.black);
}
protected override void OnDestroy()
{
base.OnDestroy();
if (base.LastOwner != null)
{
PassiveItem.DecrementFlag(base.LastOwner, typeof(PickpocketGuide));
unstealthBehavior unstealthBehavior = base.LastOwner.gameObject.GetOrAddComponent <unstealthBehavior>();
UnityEngine.Object.DestroyImmediate(unstealthBehavior);
}
}
protected override void OnDestroy()
{
base.OnDestroy();
if (base.Owner != null)
{
PlayerController player = base.Owner;
PassiveItem.DecrementFlag(player, typeof(CatchingMitts));
cooldownBehavior cooldownBehavior = player.gameObject.GetComponent <cooldownBehavior>();
UnityEngine.Object.Destroy(cooldownBehavior);
}
}
