public virtual void GrantTurn()
{
LevelScene.CurrentTurnOwnerDamageDealt = TurnDamageDealt = new ProjectileDamage(Owner.ID);
OnGrantTurn?.Invoke();
OnGrantTurn = default;
LevelScene.CurrentTurnOwner = SyncMobile;
Movement.RemainingStepsThisTurn = Movement.MaximumStepsPerTurn;
Movement.IsAbleToMove = true;
IsAbleToShoot = true;
IsAbleToUseItem = true;
if (IsPlayable)
{
SyncMobile.ReduceSSCooldown();
if (SyncMobile.SSLockRemainingTurns == 0)
{
LevelScene.HUD.EnableSS();
}
}
LevelScene.HUD.GrantTurn(this);
Crosshair.PlayAnimation();
AudioHandler.PlaySoundEffect(SoundEffectParameter.InGameGameplayNewTurn);
GameScene.Camera.TrackObject(this);
}
private void FireChildInternal(Vector3 location, bool over)
{
if (!this.spawnAvailable && !over)
{
return;
}
for (int i = 0; i < this.spawnCount; i++)
{
GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(this.childProjectilePrefab, location, Util.QuaternionSafeLookRotation(base.transform.forward));
ProjectileController controller = gameObject.GetComponent <ProjectileController>();
if (controller)
{
controller.procChainMask = this.projectileController.procChainMask;
controller.procCoefficient = this.projectileController.procCoefficient * this.childProcCoefficient;
controller.Networkowner = this.projectileController.owner;
}
gameObject.GetComponent <TeamFilter>().teamIndex = base.GetComponent <TeamFilter>().teamIndex;
ProjectileDamage damage = gameObject.GetComponent <ProjectileDamage>();
if (damage)
{
damage.damage = this.projectileDamage.damage * this.childDamageCoefficient;
damage.crit = this.projectileDamage.crit;
damage.force = this.projectileDamage.force;
damage.damageColorIndex = this.projectileDamage.damageColorIndex;
}
NetworkServer.Spawn(gameObject);
}
this.spawnAvailable = false;
}
//Adds tracking grenade to projectile register list
internal static void RegisterDebuffNade()
{
//Start with base engi grenade cause it has a nice grenade shape
debuffGrenadePrefab = LegacyResourcesAPI.Load <GameObject>("prefabs/projectiles/engigrenadeprojectile").InstantiateClone("DebuffGrenade", true);
//As long as it actually exists we can do stuff with it
if (debuffGrenadePrefab)
{
//We want ours to go a bit faster than the shitty nade that engi uses
debuffGrenadePrefab.GetComponent <ProjectileSimple>().desiredForwardSpeed *= 1.5f;
//We gotta take hold of the impact explosion component
ProjectileImpactExplosion debuffGrenadeExplosion = debuffGrenadePrefab.GetComponent <ProjectileImpactExplosion>();
//We want ours to explode on impact instead of bouncing around
debuffGrenadeExplosion.destroyOnWorld = true;
//We want hella more radius
debuffGrenadeExplosion.blastRadius = Configuration.GetConfigValue <float>(Configuration.CaptainDebuffnadeRadius);
//Linear falloff, idk what it normally is but this way we know for sure its linear
debuffGrenadeExplosion.falloffModel = BlastAttack.FalloffModel.Linear;
//Implement our own proc coefficient-to-damage-type stuff
debuffGrenadeExplosion.blastProcCoefficient = BuffsLoading.ProcToDamageTypeEncoder(BuffsLoading.trackingOnHit.procIndex, 1f);
//Change the explosion fx to something cooler as well
debuffGrenadeExplosion.impactEffect = LegacyResourcesAPI.Load <GameObject>("prefabs/effects/omnieffect/OmniExplosionVFXScavCannonImpactExplosion");
//Nab the damage component of it
ProjectileDamage debuffGrenadeDamage = debuffGrenadePrefab.GetComponent <ProjectileDamage>();
//This lets us use our own special damage type, it converts back to generic when being read off
debuffGrenadeDamage.damageType = DamageType.NonLethal;
//Add the projectile to the list
projList.Add(debuffGrenadePrefab);
}
}
private void OnTriggerEnter(Collider other)
{
other.GetComponent <TeamFilter>();
Rigidbody component = other.GetComponent <Rigidbody>();
ProjectileController component2 = other.GetComponent <ProjectileController>();
ProjectileDamage component3 = other.GetComponent <ProjectileDamage>();
if (component && !ReflectedProjectileTracker.rigidBodies.Contains(component) && component2 && component3)
{
if (component2.teamFilter.teamIndex != teamFilter.teamIndex)
{
component2.teamFilter.teamIndex = teamFilter.teamIndex;
if (component2.owner)
{
component.rotation = Util.QuaternionSafeLookRotation(component2.owner.transform.position - component.position);
}
}
component2.procCoefficient = 0;
var tracker = component2.gameObject.AddComponent <ReflectedProjectileTracker>();
tracker.rigidBody = component;
ProjectileManager.instance.FireProjectile(other.gameObject, other.transform.position, Util.QuaternionSafeLookRotation(component2.owner.transform.position - component.position),
component2.owner, damageMultiplier, component3.force, component3.crit, component3.damageColorIndex, component2.owner);
Destroy(other.gameObject);
}
}
// Token: 0x060030BD RID: 12477 RVA: 0x000D1D84 File Offset: 0x000CFF84
public override void OnEnter()
{
base.OnEnter();
if (NetworkServer.active)
{
ProjectileDamage component = base.GetComponent <ProjectileDamage>();
Vector3 position = base.transform.position;
new BlastAttack
{
position = position,
attacker = base.projectileController.owner,
baseDamage = component.damage,
baseForce = component.force,
bonusForce = Vector3.zero,
canHurtAttacker = false,
crit = component.crit,
damageColorIndex = component.damageColorIndex,
damageType = component.damageType,
falloffModel = BlastAttack.FalloffModel.None,
inflictor = base.gameObject,
procChainMask = base.projectileController.procChainMask,
radius = Detonate.blastRadius,
teamIndex = base.projectileController.teamFilter.teamIndex,
procCoefficient = base.projectileController.procCoefficient
}.Fire();
EffectManager.SpawnEffect(Detonate.blastEffectPrefab, new EffectData
{
origin = position,
scale = Detonate.blastRadius
}, true);
EntityState.Destroy(base.gameObject);
}
}
// Token: 0x060030C6 RID: 12486 RVA: 0x000D1F04 File Offset: 0x000D0104
public override void OnEnter()
{
base.OnEnter();
if (base.isAuthority)
{
FireMine.ResolveVelocities();
Transform transform = base.transform.Find("FirePoint");
ProjectileDamage component = base.GetComponent <ProjectileDamage>();
Vector3 forward = transform.TransformVector(FireMine.velocities[this.fireIndex]);
FireProjectileInfo fireProjectileInfo = new FireProjectileInfo
{
crit = component.crit,
damage = component.damage,
damageColorIndex = component.damageColorIndex,
force = component.force,
owner = base.owner,
position = transform.position,
procChainMask = base.projectileController.procChainMask,
projectilePrefab = FireMine.projectilePrefab,
rotation = Quaternion.LookRotation(forward),
fuseOverride = -1f,
useFuseOverride = false,
speedOverride = forward.magnitude,
useSpeedOverride = true
};
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
}
}
private void Start()
{
this.timer = this.timeToDecay;
this.projectileDamage = base.GetComponent <ProjectileDamage>();
this.originalDamage = projectileDamage.damage;
}
private static void CreateVoidBlast()
{
voidBlastPrefab = CloneProjectilePrefab("CommandoGrenadeProjectile", "NemryVoidBlastProjectile");
ProjectileImpactExplosion bombImpactExplosion = voidBlastPrefab.GetComponent <ProjectileImpactExplosion>();
InitializeImpactExplosion(bombImpactExplosion);
bombImpactExplosion.blastRadius = 8f;
bombImpactExplosion.destroyOnEnemy = true;
bombImpactExplosion.lifetime = 12f;
bombImpactExplosion.impactEffect = Resources.Load <GameObject>("Prefabs/Effects/NullifierExplosion");
//bombImpactExplosion.lifetimeExpiredSound = Modules.Assets.CreateNetworkSoundEventDef("HenryBombExplosion");
bombImpactExplosion.timerAfterImpact = true;
bombImpactExplosion.lifetimeAfterImpact = 0.1f;
ProjectileDamage bombDamage = voidBlastPrefab.GetComponent <ProjectileDamage>();
bombDamage.damageType = DamageType.Nullify;
ProjectileController bombController = voidBlastPrefab.GetComponent <ProjectileController>();
bombController.ghostPrefab = Resources.Load <GameObject>("Prefabs/ProjectileGhosts/NullifierPreBombGhost");
bombController.startSound = "";
voidBlastPrefab.GetComponent <Rigidbody>().useGravity = false;
}
static void ProcMissile(int stack, CharacterBody attackerBody, CharacterMaster attackerMaster, TeamIndex attackerTeamIndex, ProcChainMask procChainMask, GameObject victim, DamageInfo damageInfo)
{
if (stack <= 0)
{
return;
}
GameObject AttackerGO = attackerBody.gameObject;
InputBankTest AttackerBankTest = AttackerGO.GetComponent <InputBankTest>();
Vector3 position = AttackerBankTest ? AttackerBankTest.aimOrigin : GlobalEventManager.instance.transform.position;
Vector3 vector3 = AttackerBankTest ? AttackerBankTest.aimDirection : GlobalEventManager.instance.transform.forward;
Vector3 up = Vector3.up;
if (!Util.CheckRoll(10f * damageInfo.procCoefficient, attackerMaster))
{
return;
}
GameObject MissileGO = UnityEngine.Object.Instantiate <GameObject>(GlobalEventManager.instance.missilePrefab, position, Util.QuaternionSafeLookRotation(up + UnityEngine.Random.insideUnitSphere * 0.0f));
ProjectileController MissileControler = MissileGO.GetComponent <ProjectileController>();
MissileControler.Networkowner = AttackerGO.gameObject;
MissileControler.procChainMask = procChainMask;
MissileControler.procChainMask.AddProc(ProcType.Missile);
MissileGO.GetComponent <TeamFilter>().teamIndex = attackerTeamIndex;
MissileGO.GetComponent <MissileController>().target = victim.transform;
float damageCoefficient = 3f * (float)stack;
float num = Util.OnHitProcDamage(damageInfo.damage, attackerBody.damage, damageCoefficient);
ProjectileDamage MissileDamage = MissileGO.GetComponent <ProjectileDamage>();
MissileDamage.damage = num;
MissileDamage.crit = damageInfo.crit;
MissileDamage.force = 200f;
MissileDamage.damageColorIndex = DamageColorIndex.Item;
NetworkServer.Spawn(MissileGO);
}
protected void FireChild(Vector3 direction)
{
GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(this.childrenProjectilePrefab, base.transform.position, Util.QuaternionSafeLookRotation(direction));
ProjectileController component = gameObject.GetComponent <ProjectileController>();
if (component)
{
component.procChainMask = this.projectileController.procChainMask;
component.procCoefficient = this.projectileController.procCoefficient;
component.Networkowner = this.projectileController.owner;
}
gameObject.GetComponent <TeamFilter>().teamIndex = base.GetComponent <TeamFilter>().teamIndex;
ProjectileDamage component2 = gameObject.GetComponent <ProjectileDamage>();
if (component2)
{
component2.damage = this.projectileDamage.damage * this.childrenDamageCoefficient;
component2.crit = this.projectileDamage.crit;
component2.force = this.projectileDamage.force;
component2.damageColorIndex = this.projectileDamage.damageColorIndex;
}
if (gameObject.GetComponent <ProjectileStickOnImpact>() != null)
{
ProjectileStickOnImpact stickComponent = gameObject.GetComponent <ProjectileStickOnImpact>();
stickComponent.TrySticking(hitEnemyCollider, hitEnemyInfo.estimatedImpactNormal);
}
NetworkServer.Spawn(gameObject);
}
public void StartTurnRequesterThread()
{
RequestNextTurn = false;
turnRequesterThread = new Thread(() =>
{
while (true)
{
lock (MobileList)
{
if (TerminateThreads)
{
break;
}
if (RequestNextTurn && MobileList.Find(x => x.Movement.IsFalling && x.IsAlive) == null)
{
RequestNextTurn = false;
ServerInformationHandler.RequestNextPlayerTurn(CurrentTurnOwnerDamageDealt);
CurrentTurnOwnerDamageDealt = null;
}
}
Thread.Sleep(1000);
}
});
turnRequesterThread.Name = "Turn Requester Thread";
turnRequesterThread.IsBackground = true;
turnRequesterThread.Start();
}
private void Awake()
{
this.projectileController = base.GetComponent <ProjectileController>();
this.projectileDamage = base.GetComponent <ProjectileDamage>();
this.stopwatch = this.maxCoefficient;
Debug.LogWarning($"start stopwatch: {this.stopwatch}");
}
/*
An arrow trap is used to fire projectiles (usually at the player).
The item type created is controlled by the object quality and owner
target = (currobj.quality << 5) | currobj.owner; //This is set in UWexporter
The vector is simply the heading of the trap.
Examples of usage
The mine collapse on level2
The skulls launched at the player on level3 -Troll area.
*/
public override void ExecuteTrap (object_base src, int triggerX, int triggerY, int State)
{
int item_index= (quality << 5) | owner;
ObjectLoaderInfo newobjt= ObjectLoader.newWorldObject(item_index,0,0,0,256);
GameObject myObj = ObjectInteraction.CreateNewObject(CurrentTileMap(),newobjt,CurrentObjectList().objInfo, GameWorldController.instance.DynamicObjectMarker().gameObject, this.transform.position).gameObject;
if (ObjectTileX == TileMap.ObjectStorageTile)
{
Vector3 pos = CurrentTileMap().getTileVector(triggerX,triggerY);
pos = new Vector3(pos.x,this.transform.position.y,pos.z);
myObj.transform.position=pos;
}
else
{
myObj.transform.position = this.transform.position;
}
myObj.transform.rotation = this.transform.rotation;
if (myObj.GetComponent<Rigidbody>()==null)
{
myObj.AddComponent<Rigidbody>();
}
UnFreezeMovement(myObj);
myObj.GetComponent<Rigidbody>().collisionDetectionMode=CollisionDetectionMode.Continuous;
myObj.GetComponent<Rigidbody>().AddForce(myObj.transform.forward* 20.0f *((float)(owner)));
GameObject myObjChild = new GameObject(myObj.name + "_damage");
myObjChild.transform.position =myObj.transform.position;
myObjChild.transform.parent =myObj.transform;
ProjectileDamage pd= myObjChild.AddComponent<ProjectileDamage>();
pd.Source=this.gameObject;//Traps don't need to be identified.
pd.Damage=10;//Dunno what drives damage here?
pd.AttackCharge=100f;
pd.AttackScore=15;//down the middle.
}
private void Start()
{
this.projectileController = base.GetComponent <ProjectileController>();
this.projectileDamage = base.GetComponent <ProjectileDamage>();
this.ResetOverlap();
}
private static void CreateFireSpellRing()
{
fireSpellRingPrefab = CloneProjectilePrefab("Fireball", "ManipulatorFireRing");
UnityEngine.GameObject.Destroy(fireSpellRingPrefab.GetComponent <ProjectileSingleTargetImpact>());
ManipulatorProjectileAttachOnImpact manipulatorAttach = fireSpellRingPrefab.AddComponent <ManipulatorProjectileAttachOnImpact>();
ProjectileDamage manipulatorDamage = fireSpellRingPrefab.GetComponent <ProjectileDamage>();
manipulatorAttach.destroyOnWorld = true;
manipulatorAttach.destroyWhenNotAlive = false;
manipulatorAttach.attachTickMax = fireSpellTickMax;
manipulatorAttach.attachDuration = fireSpellAttachDuration;
manipulatorAttach.attachDamageCoefficient = fireSpellAttachCoefficient;
manipulatorAttach.attachPrefab = CreateAttachRing();
manipulatorAttach.ownerController = fireSpellRingPrefab.GetComponent <ProjectileController>();
manipulatorAttach.attachPrefab.transform.SetParent(fireSpellRingPrefab.transform);
//Debug.LogWarning("Manipulator Attach Prefab: " + manipulatorAttach.attachPrefab);
ProjectileController ringController = fireSpellRingPrefab.GetComponent <ProjectileController>();
ringController.procCoefficient = StatValues.fireSpellCoefficient;
ProjectileSimple fireRingSimple = fireSpellRingPrefab.GetComponent <ProjectileSimple>();
//fireRingSimple.velocity = fireSpellRingVelocity;
fireRingSimple.desiredForwardSpeed = fireSpellRingVelocity;
fireRingSimple.lifetime = 3f;
}
public void Awake()
{
this.stickOnImpact = base.GetComponent <ProjectileStickOnImpact>();
this.projectileController = base.GetComponent <ProjectileController>();
this.projectileDamage = base.GetComponent <ProjectileDamage>();
this.singleTargetImpact = base.GetComponent <ProjectileSingleTargetImpact>();
this.stickOnImpact.stickEvent.AddListener(this.OnStickEvent);
}
private void BuildFlareProjectile()
{
GameObject flareProjectile = Resources.Load <GameObject>("prefabs/projectiles/magefireboltbasic").InstantiateClone("SS2PyroFlare", true);
ProjectileCatalog.getAdditionalEntries += delegate(List <GameObject> list)
{
list.Add(flareProjectile);
};
ProjectileSimple ps = flareProjectile.GetComponent <ProjectileSimple>();
ps.lifetime = 18f;
ProjectileImpactExplosion pie = flareProjectile.GetComponent <ProjectileImpactExplosion>();
pie.blastRadius = 8f;
pie.blastDamageCoefficient = 1f;
pie.blastProcCoefficient = 1f;
pie.timerAfterImpact = false;
pie.falloffModel = BlastAttack.FalloffModel.None;
pie.lifetime = 18f;
pie.destroyOnEnemy = true;
pie.destroyOnWorld = true;
ProjectileDamage pd = flareProjectile.GetComponent <ProjectileDamage>();
pd.damage = 0f;
pd.damageColorIndex = DamageColorIndex.Default;
pd.damageType = DamageType.IgniteOnHit;
Flaregun.projectilePrefab = flareProjectile;
FireFlareBurst.projectilePrefab = flareProjectile; //unused skill
GameObject reflectProjectile = Resources.Load <GameObject>("prefabs/projectiles/magefireboltbasic").InstantiateClone("SS2PyroFlareReflect", true);
ProjectileCatalog.getAdditionalEntries += delegate(List <GameObject> list)
{
list.Add(reflectProjectile);
};
ProjectileImpactExplosion pie2 = reflectProjectile.GetComponent <ProjectileImpactExplosion>();
pie2.blastRadius = 8f;
pie2.blastDamageCoefficient = 1f;
pie2.blastProcCoefficient = 1f;
pie2.timerAfterImpact = false;
pie2.falloffModel = BlastAttack.FalloffModel.None;
pie2.lifetime = 18f;
pie2.destroyOnEnemy = true;
pie2.destroyOnWorld = true;
ProjectileDamage pd2 = reflectProjectile.GetComponent <ProjectileDamage>();
pd2.damage = 0f;
pd2.damageColorIndex = DamageColorIndex.Default;
pd2.damageType = DamageType.IgniteOnHit;
HeatWave.reflectProjectilePrefab = reflectProjectile;
}
public override void OnEnter()
{
base.OnEnter();
//Get the component
this.projectileDamage = GetComponent <ProjectileDamage>();
//Start timer at 0 so it pops once at start
this.pulseTimer = 0f;
//It has yet to pulse
this.pulseCounter = 0;
}
void Awake()
{
projectileDamage = gameObject.GetComponent <ProjectileDamage>();
projectileSingleTargetImpact = gameObject.GetComponent <ProjectileSingleTargetImpact>();
if (!projectileDamage || !projectileSingleTargetImpact)
{
enabled = false;
return;
}
} //nullcheck
public virtual void Attack(Vector3 attackDirection)
{
GameObject projectile = Instantiate(ProjectilePrefab, transform.position - attackDirection, Quaternion.identity) as GameObject;
ProjectileMovement mov = projectile.GetComponent <ProjectileMovement>();
mov.Rotate(attackDirection);
ProjectileDamage damage = projectile.GetComponent <ProjectileDamage>();
damage.Creator = transform;
}
public ProjectileFloatingText(
ProjectileDamage damage,
[Inject(Id = Identifiers.HUD)] FloatingText.Factory floatingTextFactory,
PlayerRegistry registry)
{
_damage = damage;
_floatingTextFactory = floatingTextFactory;
_registry = registry;
PreInitialize();
}
private void OnCollisionEnter2D(Collision2D other)
{
if (other.gameObject.CompareTag("Enemy"))
{
ProjectileDamage pd = gameObject.GetComponent <ProjectileDamage>();
int health = pd.damageEnemy(other.collider);
}
else
{
Destroy(gameObject);
}
}
public static void RequestNextPlayerTurn(ProjectileDamage projectileDamageDealt)
{
ServerInformationBroker.Instance.GameServerServiceProvider.RequestQueue.Enqueue(
NetworkObjectParameters.GameServerInGameRequestNextPlayerTurn,
null);
if (projectileDamageDealt != null)
{
ServerInformationBroker.Instance.GameServerServiceProvider.RequestQueue.Enqueue(
NetworkObjectParameters.GameServerInGameRequestDamage,
projectileDamageDealt);
}
}
void Awake()
{
Damage = ScriptableObject.Instantiate(Damage);
Direction = ScriptableObject.Instantiate(Direction);
Velocity = ScriptableObject.Instantiate(Velocity);
ProjectileMovement movement = GetComponent <ProjectileMovement>();
movement.Direction.InstanceVariable = Direction;
movement.Velocity.InstanceVariable = Velocity;
ProjectileDamage damage = GetComponent <ProjectileDamage>();
damage.Damage.InstanceVariable = Damage;
}
// Token: 0x06000471 RID: 1137 RVA: 0x00012AD4 File Offset: 0x00010CD4
protected override void Pulse()
{
float num = 1f;
ProjectileDamage component = base.GetComponent <ProjectileDamage>();
if (component)
{
num = component.damage;
}
this.HealOccupants(DroneProjectileHover.pulseRadius, DroneProjectileHoverHeal.healPointsCoefficient * num, DroneProjectileHoverHeal.healFraction);
EffectData effectData = new EffectData();
effectData.origin = base.transform.position;
effectData.scale = DroneProjectileHover.pulseRadius;
EffectManager.instance.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/ImpactEffects/ExplosionVFX"), effectData, true);
}
private void BuildBlazeborneProjectile()
{
GameObject projectile = Resources.Load <GameObject>("prefabs/projectiles/EngiHarpoon").InstantiateClone("SS2PyroBlazeborneMissle", true);
ProjectileCatalog.getAdditionalEntries += delegate(List <GameObject> list)
{
list.Add(projectile);
};
ProjectileDamage pd = projectile.GetComponent <ProjectileDamage>();
pd.damage = 0f;
pd.damageColorIndex = DamageColorIndex.Default;
pd.damageType = (DamageType.IgniteOnHit | DamageType.SlowOnHit); //damagetype is for identification purposes. refactor once custom damagetype support exists
Blazeborne.projectilePrefab = projectile;
}
// Token: 0x060030F9 RID: 12537 RVA: 0x000D2764 File Offset: 0x000D0964
private void Explode()
{
ProjectileDamage component = base.GetComponent <ProjectileDamage>();
float num = 0f;
float num2 = 0f;
float num3 = 0f;
EntityStateMachine armingStateMachine = base.armingStateMachine;
BaseMineArmingState baseMineArmingState;
if ((baseMineArmingState = (((armingStateMachine != null) ? armingStateMachine.state : null) as BaseMineArmingState)) != null)
{
num = baseMineArmingState.damageScale;
num2 = baseMineArmingState.forceScale;
num3 = baseMineArmingState.blastRadiusScale;
}
float num4 = Detonate.blastRadius * num3;
new BlastAttack
{
procChainMask = base.projectileController.procChainMask,
procCoefficient = base.projectileController.procCoefficient,
attacker = base.projectileController.owner,
inflictor = base.gameObject,
teamIndex = base.projectileController.teamFilter.teamIndex,
procCoefficient = base.projectileController.procCoefficient,
baseDamage = component.damage * num,
baseForce = component.force * num2,
falloffModel = BlastAttack.FalloffModel.None,
crit = component.crit,
radius = num4,
position = base.transform.position,
damageColorIndex = component.damageColorIndex
}.Fire();
if (Detonate.explosionEffectPrefab)
{
EffectManager.SpawnEffect(Detonate.explosionEffectPrefab, new EffectData
{
origin = base.transform.position,
rotation = base.transform.rotation,
scale = num4
}, true);
}
EntityState.Destroy(base.gameObject);
}
// Token: 0x06002B3D RID: 11069 RVA: 0x000B6378 File Offset: 0x000B4578
public override void OnEnter()
{
base.OnEnter();
ProjectileController component = base.GetComponent <ProjectileController>();
if (component)
{
this.owner = component.owner;
this.procChainMask = component.procChainMask;
this.procCoefficient = component.procCoefficient;
this.teamIndex = component.teamFilter.teamIndex;
}
ProjectileDamage component2 = base.GetComponent <ProjectileDamage>();
if (component2)
{
this.damage = component2.damage;
this.damageType = component2.damageType;
this.crit = component2.crit;
}
}
// Token: 0x06002B83 RID: 11139 RVA: 0x000B7804 File Offset: 0x000B5A04
public override void OnEnter()
{
base.OnEnter();
ProjectileController component = base.GetComponent <ProjectileController>();
if (component)
{
this.owner = component.owner;
this.procChainMask = component.procChainMask;
this.procCoefficient = component.procCoefficient;
this.teamIndex = component.teamFilter.teamIndex;
}
ProjectileDamage component2 = base.GetComponent <ProjectileDamage>();
if (component2)
{
this.damage = component2.damage;
this.damageType = component2.damageType;
this.crit = component2.crit;
}
if (NetworkServer.active)
{
this.rootedBodies = new List <CharacterBody>();
}
base.PlayAnimation("Base", "SpawnToIdle");
Util.PlaySound(TreebotFlower2Projectile.enterSoundString, base.gameObject);
if (TreebotFlower2Projectile.enterEffectPrefab)
{
EffectManager.SimpleEffect(TreebotFlower2Projectile.enterEffectPrefab, base.transform.position, base.transform.rotation, false);
}
ChildLocator component3 = base.GetModelTransform().GetComponent <ChildLocator>();
if (component3)
{
Transform transform = component3.FindChild("AreaIndicator");
transform.localScale = new Vector3(TreebotFlower2Projectile.radius, TreebotFlower2Projectile.radius, TreebotFlower2Projectile.radius);
transform.gameObject.SetActive(true);
}
}
public override void SetupBehavior()
{
base.SetupBehavior();
GameObject sporeGrenadeDotZonePrefab = Resources.Load <GameObject>("prefabs/projectiles/SporeGrenadeProjectileDotZone");
WaterPoolPrefab = sporeGrenadeDotZonePrefab.InstantiateClone("Bulletstorm_WaterPool");
ProjectileDotZone projectileDotZone = WaterPoolPrefab.GetComponent <ProjectileDotZone>();
projectileDotZone.attackerFiltering = AttackerFiltering.Default;
projectileDotZone.lifetime = CoolantLeak_Duration;
ProjectileDamage projectileDamage = WaterPoolPrefab.GetComponent <ProjectileDamage>();
projectileDamage.damageType = DamageType.Shock5s;
projectileDamage.enabled = false;
GameObject sporeGrenadePrefab = Resources.Load <GameObject>("prefabs/projectiles/SporeGrenadeProjectile");
WaterPoolPlacerPrefab = sporeGrenadePrefab.InstantiateClone("Bulletstorm_WaterPoolPlacer");
WaterPoolPlacerPrefab.GetComponent <ProjectileDamage>().damageColorIndex = DamageColorIndex.Item;
ProjectileImpactExplosion projectileImpactExplosion = WaterPoolPlacerPrefab.GetComponent <ProjectileImpactExplosion>();
projectileImpactExplosion.impactEffect = null;
projectileImpactExplosion.childrenProjectilePrefab = WaterPoolPrefab;
ProjectileCatalog.getAdditionalEntries += list => list.Add(WaterPoolPlacerPrefab);
ProjectileCatalog.getAdditionalEntries += list => list.Add(WaterPoolPrefab);
if (WaterPoolPlacerPrefab)
{
PrefabAPI.RegisterNetworkPrefab(WaterPoolPlacerPrefab);
}
if (WaterPoolPrefab)
{
PrefabAPI.RegisterNetworkPrefab(WaterPoolPrefab);
}
}
