public void AttachOpacity(BaseMonoAbilityEntity target, float opacity)
{
PropObjectActor actor = Singleton <EventManager> .Instance.GetActor <PropObjectActor>(target.GetRuntimeID());
if (actor != null)
{
actor.SetPorpObjectOpacity(opacity);
this.CheckInit <Tuple <BaseMonoAbilityEntity, float> >(ref this._attachedOpacity);
this._attachedOpacity.Add(Tuple.Create <BaseMonoAbilityEntity, float>(target, opacity));
}
}
private bool ListenFieldEnter(EvtFieldEnter evt)
{
BaseActor actor = Singleton <EventManager> .Instance.GetActor(evt.targetID);
BaseActor actor2 = Singleton <EventManager> .Instance.GetActor(evt.otherID);
if ((((actor != null) && (actor is PropObjectActor)) && ((actor2 != null) && (actor2 is AvatarActor))) && Singleton <AvatarManager> .Instance.IsLocalAvatar(actor2.runtimeID))
{
PropObjectActor actor3 = actor as PropObjectActor;
if ((actor3 != null) && (actor3.entity is MonoTriggerProp))
{
this._trapTriggeredNum++;
if (this._trapTriggeredNum >= this.targetNum)
{
this.Fail();
}
}
}
return(false);
}
private bool ListenKilled(EvtKilled evt)
{
BaseActor actor = Singleton <EventManager> .Instance.GetActor(evt.killerID);
BaseActor actor2 = Singleton <EventManager> .Instance.GetActor(evt.targetID);
if ((((actor != null) && (actor is AvatarActor)) && (Singleton <AvatarManager> .Instance.IsLocalAvatar(actor.runtimeID) && (actor2 != null))) && (actor2 is PropObjectActor))
{
PropObjectActor actor3 = actor2 as PropObjectActor;
if ((actor3 != null) && actor3.config.Name.Contains("Box"))
{
this._tempBoxOpenedNum++;
if (this._tempBoxOpenedNum >= this.targetBoxOpenedNum)
{
this.Finish();
}
}
}
return(false);
}
public uint CreatePropObject(uint ownerID, string propName, float HP, float attack, Vector3 initPos, Vector3 initDir, bool appearAnim = false)
{
ConfigPropObject propObjectConfig = PropObjectData.GetPropObjectConfig(propName);
BaseMonoPropObject component = UnityEngine.Object.Instantiate <GameObject>(Miscs.LoadResource <GameObject>(propObjectConfig.PrefabPath, BundleType.RESOURCE_FILE)).GetComponent <BaseMonoPropObject>();
uint nextRuntimeID = Singleton <RuntimeIDManager> .Instance.GetNextRuntimeID(7);
component.transform.position = initPos;
component.transform.forward = initDir;
component.Init(ownerID, nextRuntimeID, propObjectConfig.Name, appearAnim);
if ((propName == "JokeBox") && (attack <= 0f))
{
(component as MonoBarrelProp)._toExplode = false;
}
this._propObjects.Add(nextRuntimeID, component);
this._propLs.Add(component);
PropObjectActor actor = Singleton <EventManager> .Instance.CreateActor <PropObjectActor>(component);
actor.ownerID = ownerID;
actor.InitProp(HP, attack);
actor.PostInit();
return(nextRuntimeID);
}
private bool ListenBeingHit(EvtBeingHit evt)
{
if (!evt.attackData.rejected)
{
BaseActor actor = Singleton <EventManager> .Instance.GetActor(evt.targetID);
BaseActor actor2 = Singleton <EventManager> .Instance.GetActor(evt.sourceID);
if ((((actor != null) && (actor is AvatarActor)) && (Singleton <AvatarManager> .Instance.IsLocalAvatar(actor.runtimeID) && (actor2 != null))) && (actor2 is PropObjectActor))
{
PropObjectActor actor3 = actor2 as PropObjectActor;
if ((actor3 != null) && (actor3.entity is MonoTriggerProp))
{
this._trapTriggeredNum++;
if (this._trapTriggeredNum >= this.targetNum)
{
this.Fail();
}
}
}
}
return(false);
}
public static AttackData CreateAttackDataFromAttackerAnimEvent(BaseActor from, string animEventID)
{
if (from is AvatarActor)
{
AvatarActor actor = (AvatarActor)from;
ConfigAvatarAnimEvent event2 = SharedAnimEventData.ResolveAnimEvent(actor.config, animEventID);
return(CreateAttackDataFromAttackProperty(from, event2.AttackProperty, event2.AttackEffect, event2.CameraShake));
}
if (from is MonsterActor)
{
MonsterActor actor2 = (MonsterActor)from;
ConfigMonsterAnimEvent event3 = SharedAnimEventData.ResolveAnimEvent(actor2.config, animEventID);
AttackData attackData = CreateAttackDataFromAttackProperty(from, event3.AttackProperty, event3.AttackEffect, event3.CameraShake);
actor2.RefillAttackDataDamagePercentage(animEventID, ref attackData);
return(attackData);
}
if (from is PropObjectActor)
{
PropObjectActor actor3 = (PropObjectActor)from;
ConfigPropAnimEvent event4 = SharedAnimEventData.ResolveAnimEvent(actor3.config, animEventID);
return(CreateAttackDataFromAttackProperty(from, event4.AttackProperty, event4.AttackEffect, event4.CameraShake));
}
return(null);
}
public static void ResolveAttackDataByAttackee(BaseActor to, AttackData attackData)
{
if (!attackData.rejected)
{
if (to is AvatarActor)
{
AvatarActor actor = (AvatarActor)to;
bool flag = Singleton <LevelScoreManager> .Instance.IsAllowLevelPunish();
int levelDifference = Mathf.Clamp(attackData.attackerLevel - Singleton <PlayerModule> .Instance.playerData.teamLevel, 0, 10);
if ((attackData.attackerCategory == 4) && flag)
{
attackData.attackerAniDamageRatio *= 1f + AvatarDefencePunishMetaDataReader.GetAvatarDefencePunishMetaDataByKey(levelDifference).AttackRatioIncrease;
}
attackData.attackeeAniDefenceRatio = GetAnimDefenceRatio(actor);
attackData.damage = (((attackData.attackerAttackValue * attackData.attackerAttackPercentage) + attackData.attackerAddedAttackValue) * (1f + attackData.addedAttackRatio)) * (1f + attackData.addedDamageRatio);
float defence = (actor.defense + actor.GetProperty("Actor_DefenceDelta")) * (1f + actor.GetProperty("Actor_DefenceRatio"));
float defenceRatio = GetDefenceRatio(defence, attackData.attackerLevel);
float num4 = (1f - defenceRatio) * actor.GetProperty("Actor_DamageReduceRatio");
attackData.attackeeAddedDamageTakeRatio += actor.GetProperty("Actor_DamageTakeRatio");
attackData.damage = (attackData.damage * num4) * (1f + attackData.attackeeAddedDamageTakeRatio);
attackData.plainDamage = (((((attackData.attackerNormalDamage + (attackData.attackerAttackValue * attackData.attackerNormalDamagePercentage)) * (1f + attackData.addedAttackerNormalDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor.GetProperty("Actor_ResistAllElementAttackRatio")) * actor.GetProperty("Actor_ResistNormalAttackRatio")) * (1f + actor.GetProperty("Actor_NormalAttackTakeRatio"));
attackData.fireDamage = (((((attackData.attackerFireDamage + (attackData.attackerAttackValue * attackData.attackerFireDamagePercentage)) * (1f + attackData.addedAttackerFireDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor.GetProperty("Actor_ResistAllElementAttackRatio")) * actor.GetProperty("Actor_ResistFireAttackRatio")) * (1f + actor.GetProperty("Actor_FireAttackTakeRatio"));
attackData.thunderDamage = (((((attackData.attackerThunderDamage + (attackData.attackerAttackValue * attackData.attackerThunderDamagePercentage)) * (1f + attackData.addedAttackerThunderDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor.GetProperty("Actor_ResistAllElementAttackRatio")) * actor.GetProperty("Actor_ResistThunderAttackRatio")) * (1f + actor.GetProperty("Actor_ThunderAttackTakeRatio"));
attackData.iceDamage = (((((attackData.attackerIceDamage + (attackData.attackerAttackValue * attackData.attackerIceDamagePercentage)) * (1f + attackData.addedAttackerIceDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor.GetProperty("Actor_ResistAllElementAttackRatio")) * actor.GetProperty("Actor_ResistIceAttackRatio")) * (1f + actor.GetProperty("Actor_IceAttackTakeRatio"));
attackData.alienDamage = (((((attackData.attackerAlienDamage + (attackData.attackerAttackValue * attackData.attackerAlienDamagePercentage)) * (1f + attackData.addedAttackerAlienDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor.GetProperty("Actor_ResistAllElementAttackRatio")) * actor.GetProperty("Actor_ResistAllienAttackRatio")) * (1f + actor.GetProperty("Actor_AllienAttackTakeRatio"));
attackData.attackeeNature = (EntityNature)actor.avatarDataItem.Attribute;
attackData.attackeeClass = actor.config.CommonArguments.Class;
float num5 = GetNatureDamageBonusRatio(attackData.attackerNature, attackData.attackeeNature, actor);
float damageIncreaseRate = 0f;
if ((attackData.attackerCategory == 4) && flag)
{
damageIncreaseRate = AvatarDefencePunishMetaDataReader.GetAvatarDefencePunishMetaDataByKey(levelDifference).DamageIncreaseRate;
}
float num7 = Mathf.Clamp((float)(1f - attackData.attackerAddedAllDamageReduceRatio), (float)0f, (float)1f);
attackData.damage *= (num5 * (1f + damageIncreaseRate)) * num7;
attackData.plainDamage *= (num5 * (1f + damageIncreaseRate)) * num7;
attackData.fireDamage *= (num5 * (1f + damageIncreaseRate)) * num7;
attackData.thunderDamage *= (num5 * (1f + damageIncreaseRate)) * num7;
attackData.iceDamage *= (num5 * (1f + damageIncreaseRate)) * num7;
attackData.alienDamage *= (num5 * (1f + damageIncreaseRate)) * num7;
attackData.natureDamageRatio = num5;
if (!Singleton <AvatarManager> .Instance.IsLocalAvatar(actor.runtimeID))
{
attackData.attackCameraShake = null;
}
attackData.attackeeAniDefenceRatio += actor.GetProperty("Actor_AniDefenceDelta");
}
else if (to is MonsterActor)
{
MonsterActor actor2 = (MonsterActor)to;
int num8 = Mathf.Clamp(((int)actor2.level) - Singleton <PlayerModule> .Instance.playerData.teamLevel, 0, 10);
if ((attackData.attackerCategory == 3) && Singleton <LevelScoreManager> .Instance.IsAllowLevelPunish())
{
attackData.attackerAniDamageRatio *= 1f - AvatarAttackPunishMetaDataReader.GetAvatarAttackPunishMetaDataByKey(num8).AttackRatioReduce;
}
attackData.attackeeAniDefenceRatio = GetAnimDefenceRatio(actor2);
attackData.damage = (((attackData.attackerAttackValue * attackData.attackerAttackPercentage) + attackData.attackerAddedAttackValue) * (1f + attackData.addedAttackRatio)) * (1f + attackData.addedDamageRatio);
float num9 = (actor2.defense + actor2.GetProperty("Actor_DefenceDelta")) * (1f + actor2.GetProperty("Actor_DefenceRatio"));
float num10 = GetDefenceRatio(num9, attackData.attackerLevel);
float num11 = (1f - num10) * actor2.GetProperty("Actor_DamageReduceRatio");
attackData.attackeeAddedDamageTakeRatio += actor2.GetProperty("Actor_DamageTakeRatio");
attackData.damage = (attackData.damage * num11) * (1f + attackData.attackeeAddedDamageTakeRatio);
attackData.plainDamage = (((((attackData.attackerNormalDamage + (attackData.attackerAttackValue * attackData.attackerNormalDamagePercentage)) * (1f + attackData.addedAttackerNormalDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor2.GetProperty("Actor_ResistAllElementAttackRatio")) * actor2.GetProperty("Actor_ResistNormalAttackRatio")) * (1f + actor2.GetProperty("Actor_NormalAttackTakeRatio"));
attackData.fireDamage = (((((attackData.attackerFireDamage + (attackData.attackerAttackValue * attackData.attackerFireDamagePercentage)) * (1f + attackData.addedAttackerFireDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor2.GetProperty("Actor_ResistAllElementAttackRatio")) * actor2.GetProperty("Actor_ResistFireAttackRatio")) * (1f + actor2.GetProperty("Actor_FireAttackTakeRatio"));
attackData.thunderDamage = (((((attackData.attackerThunderDamage + (attackData.attackerAttackValue * attackData.attackerThunderDamagePercentage)) * (1f + attackData.addedAttackerThunderDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor2.GetProperty("Actor_ResistAllElementAttackRatio")) * actor2.GetProperty("Actor_ResistThunderAttackRatio")) * (1f + actor2.GetProperty("Actor_ThunderAttackTakeRatio"));
attackData.iceDamage = (((((attackData.attackerIceDamage + (attackData.attackerAttackValue * attackData.attackerIceDamagePercentage)) * (1f + attackData.addedAttackerIceDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor2.GetProperty("Actor_ResistAllElementAttackRatio")) * actor2.GetProperty("Actor_ResistIceAttackRatio")) * (1f + actor2.GetProperty("Actor_IceAttackTakeRatio"));
attackData.alienDamage = (((((attackData.attackerAlienDamage + (attackData.attackerAttackValue * attackData.attackerAlienDamagePercentage)) * (1f + attackData.addedAttackerAlienDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor2.GetProperty("Actor_ResistAllElementAttackRatio")) * actor2.GetProperty("Actor_ResistAllienAttackRatio")) * (1f + actor2.GetProperty("Actor_AllienAttackTakeRatio"));
attackData.attackeeNature = (EntityNature)actor2.metaConfig.nature;
attackData.attackeeClass = actor2.config.CommonArguments.Class;
float num12 = GetNatureDamageBonusRatio(attackData.attackerNature, attackData.attackeeNature, actor2);
float damageReduceRate = 0f;
if ((attackData.attackerCategory == 3) && Singleton <LevelScoreManager> .Instance.IsAllowLevelPunish())
{
damageReduceRate = AvatarAttackPunishMetaDataReader.GetAvatarAttackPunishMetaDataByKey(num8).DamageReduceRate;
}
float num14 = Mathf.Clamp((float)(1f - attackData.attackerAddedAllDamageReduceRatio), (float)0f, (float)1f);
attackData.damage *= (num12 * (1f - damageReduceRate)) * num14;
attackData.plainDamage *= (num12 * (1f - damageReduceRate)) * num14;
attackData.fireDamage *= (num12 * (1f - damageReduceRate)) * num14;
attackData.thunderDamage *= (num12 * (1f - damageReduceRate)) * num14;
attackData.iceDamage *= (num12 * (1f - damageReduceRate)) * num14;
attackData.alienDamage *= (num12 * (1f - damageReduceRate)) * num14;
attackData.natureDamageRatio = num12;
if (actor2.monster.IsAnimatorInTag(MonsterData.MonsterTagGroup.Throw))
{
attackData.retreatVelocity *= actor2.config.CommonArguments.BePushedSpeedRatioThrow;
}
else
{
attackData.retreatVelocity *= actor2.config.CommonArguments.BePushedSpeedRatio;
}
attackData.retreatVelocity *= 1f + actor2.GetProperty("Actor_BeRetreatRatio");
if (attackData.isAnimEventAttack && (UnityEngine.Random.value < attackData.attackerCritChance))
{
attackData.damage *= attackData.attackerCritDamageRatio;
attackData.hitLevel = AttackResult.ActorHitLevel.Critical;
}
attackData.attackeeAniDefenceRatio += actor2.GetProperty("Actor_AniDefenceDelta");
if (attackData.frameHalt > 1)
{
attackData.frameHalt += 2;
}
if ((attackData.attackeeAniDefenceRatio > attackData.attackerAniDamageRatio) && (attackData.frameHalt > 1))
{
attackData.frameHalt += attackData.noBreakFrameHaltAdd;
}
}
else if (to is PropObjectActor)
{
PropObjectActor actor3 = (PropObjectActor)to;
attackData.attackeeAniDefenceRatio = 0f;
attackData.beHitEffectPattern = actor3.config.BeHitEffect;
attackData.damage = (((attackData.attackerAttackValue * attackData.attackerAttackPercentage) + attackData.attackerAddedAttackValue) * (1f + attackData.addedAttackRatio)) * (1f + attackData.addedDamageRatio);
attackData.plainDamage = (((((attackData.attackerNormalDamage + (attackData.attackerAttackValue * attackData.attackerNormalDamagePercentage)) * (1f + attackData.addedAttackerNormalDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor3.GetProperty("Actor_ResistAllElementAttackRatio")) * actor3.GetProperty("Actor_ResistNormalAttackRatio")) * (1f + actor3.GetProperty("Actor_NormalAttackTakeRatio"));
attackData.fireDamage = (((((attackData.attackerFireDamage + (attackData.attackerAttackValue * attackData.attackerFireDamagePercentage)) * (1f + attackData.addedAttackerFireDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor3.GetProperty("Actor_ResistAllElementAttackRatio")) * actor3.GetProperty("Actor_ResistFireAttackRatio")) * (1f + actor3.GetProperty("Actor_FireAttackTakeRatio"));
attackData.thunderDamage = (((((attackData.attackerThunderDamage + (attackData.attackerAttackValue * attackData.attackerThunderDamagePercentage)) * (1f + attackData.addedAttackerThunderDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor3.GetProperty("Actor_ResistAllElementAttackRatio")) * actor3.GetProperty("Actor_ResistThunderAttackRatio")) * (1f + actor3.GetProperty("Actor_ThunderAttackTakeRatio"));
attackData.iceDamage = (((((attackData.attackerIceDamage + (attackData.attackerAttackValue * attackData.attackerIceDamagePercentage)) * (1f + attackData.addedAttackerIceDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor3.GetProperty("Actor_ResistAllElementAttackRatio")) * actor3.GetProperty("Actor_ResistIceAttackRatio")) * (1f + actor3.GetProperty("Actor_IceAttackTakeRatio"));
attackData.alienDamage = (((((attackData.attackerAlienDamage + (attackData.attackerAttackValue * attackData.attackerAlienDamagePercentage)) * (1f + attackData.addedAttackerAlienDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor3.GetProperty("Actor_ResistAllElementAttackRatio")) * actor3.GetProperty("Actor_ResistAllienAttackRatio")) * (1f + actor3.GetProperty("Actor_AllienAttackTakeRatio"));
attackData.attackeeAniDefenceRatio += actor3.GetProperty("Actor_AniDefenceDelta");
if (attackData.frameHalt > 1)
{
attackData.frameHalt += 2;
}
}
attackData.resolveStep = AttackData.AttackDataStep.AttackeeResolved;
}
}
protected void DetachFromActor(BaseAbilityActor actor)
{
if (this._ownedPredicates != null)
{
for (int i = 0; i < this._ownedPredicates.Count; i++)
{
Tuple <BaseMonoAbilityEntity, string, OwnedPredicateState> tuple = this._ownedPredicates[i];
if (tuple.Item1 != null)
{
if (((OwnedPredicateState)tuple.Item3) == OwnedPredicateState.Attach)
{
tuple.Item1.RemoveAnimEventPredicate(tuple.Item2);
}
else
{
tuple.Item1.AddAnimEventPredicate(tuple.Item2);
}
}
}
this._ownedPredicates.Clear();
}
if (this._attachedPatternIndices != null)
{
for (int j = 0; j < this._attachedPatternIndices.Count; j++)
{
actor.entity.DetachEffect(this._attachedPatternIndices[j]);
}
this._attachedPatternIndices.Clear();
}
if (this._materialGroupPushed != null)
{
for (int k = 0; k < this._materialGroupPushed.Count; k++)
{
if (this._materialGroupPushed[k] != null)
{
this._materialGroupPushed[k].PopMaterialGroup();
}
}
this._materialGroupPushed.Clear();
}
if (this._animEventMasked != null)
{
for (int m = 0; m < this._animEventMasked.Count; m++)
{
if (this._animEventMasked[m].Item1 != null)
{
this._animEventMasked[m].Item1.UnmaskAnimEvent(this._animEventMasked[m].Item2);
}
}
this._animEventMasked.Clear();
}
if (this._modifiersAttached != null)
{
for (int n = 0; n < this._modifiersAttached.Count; n++)
{
ActorModifier modifier = this._modifiersAttached[n];
if (modifier.owner != null)
{
bool flag = modifier.owner.abilityPlugin.TryRemoveModifier(modifier);
}
}
this._modifiersAttached.Clear();
}
if (this._attachedStateImmunes != null)
{
for (int num6 = 0; num6 < this._attachedStateImmunes.Count; num6++)
{
Tuple <BaseAbilityActor, AbilityState> tuple2 = this._attachedStateImmunes[num6];
if (tuple2.Item1 != null)
{
tuple2.Item1.SetAbilityStateImmune(tuple2.Item2, false);
}
}
this._attachedStateImmunes.Clear();
}
if (this._attachedImmuneDebuff != null)
{
for (int num7 = 0; num7 < this._attachedImmuneDebuff.Count; num7++)
{
BaseAbilityActor actor2 = this._attachedImmuneDebuff[num7];
if (this._attachedImmuneDebuff[num7] != null)
{
actor2.SetImmuneDebuff(false);
}
}
this._attachedImmuneDebuff.Clear();
}
if (this._attachedResistanceBuffDebuffs != null)
{
for (int num8 = 0; num8 < this._attachedResistanceBuffDebuffs.Count; num8++)
{
BaseAbilityActor actor3 = this._attachedResistanceBuffDebuffs[num8].Item1;
if (actor3 != null)
{
actor3.RemoveBuffDebuffResistance(this._attachedResistanceBuffDebuffs[num8].Item2);
}
}
this._attachedResistanceBuffDebuffs.Clear();
}
if (this._attachedIsGhost != null)
{
for (int num9 = 0; num9 < this._attachedIsGhost.Count; num9++)
{
Tuple <BaseMonoAbilityEntity, bool> tuple3 = this._attachedIsGhost[num9];
if (tuple3.Item1 != null)
{
tuple3.Item1.SetCountedIsGhost(!tuple3.Item2);
}
}
this._attachedIsGhost.Clear();
}
if (this._attachedAllowSelected != null)
{
for (int num10 = 0; num10 < this._attachedAllowSelected.Count; num10++)
{
Tuple <BaseMonoAbilityEntity, bool> tuple4 = this._attachedAllowSelected[num10];
if (tuple4.Item1 != null)
{
tuple4.Item1.SetCountedDenySelect(tuple4.Item2, false);
}
}
this._attachedAllowSelected.Clear();
}
if (this._attachAllowSwitchOther != null)
{
for (int num11 = 0; num11 < this._attachAllowSwitchOther.Count; num11++)
{
Tuple <AvatarActor, bool> tuple5 = this._attachAllowSwitchOther[num11];
if (tuple5.Item1 != null)
{
tuple5.Item1.SetAllowOtherCanSwitchIn(false);
}
}
this._attachAllowSwitchOther.Clear();
}
if (this._attachMuteOtherQTE != null)
{
for (int num12 = 0; num12 < this._attachMuteOtherQTE.Count; num12++)
{
Tuple <AvatarActor, bool> tuple6 = this._attachMuteOtherQTE[num12];
if (tuple6.Item1 != null)
{
tuple6.Item1.MuteOtherQTE = false;
}
}
this._attachMuteOtherQTE.Clear();
}
if (this._attachedOpacity != null)
{
for (int num13 = 0; num13 < this._attachedOpacity.Count; num13++)
{
Tuple <BaseMonoAbilityEntity, float> tuple7 = this._attachedOpacity[num13];
if (tuple7.Item1 != null)
{
PropObjectActor actor4 = Singleton <EventManager> .Instance.GetActor <PropObjectActor>(tuple7.Item1.GetRuntimeID());
if (actor4 != null)
{
actor4.SetPorpObjectOpacity(actor4.Opacity);
}
}
}
this._attachedOpacity.Clear();
}
if (this._attachedEffectOverrides != null)
{
for (int num14 = 0; num14 < this._attachedEffectOverrides.Count; num14++)
{
Tuple <BaseMonoAbilityEntity, string> tuple8 = this._attachedEffectOverrides[num14];
if (tuple8.Item1 != null)
{
tuple8.Item1.RemoveEffectOverride(tuple8.Item2);
}
}
this._attachedEffectOverrides.Clear();
}
if (this._attachedStageTintsIndices != null)
{
for (int num15 = 0; num15 < this._attachedStageTintsIndices.Count; num15++)
{
int stackIx = this._attachedStageTintsIndices[num15];
Singleton <StageManager> .Instance.GetPerpStage().PopRenderingData(stackIx);
}
this._attachedStageTintsIndices.Clear();
}
if (this._attachedNoCollisions != null)
{
for (int num17 = 0; num17 < this._attachedNoCollisions.Count; num17++)
{
if (this._attachedNoCollisions[num17] != null)
{
this._attachedNoCollisions[num17].PopNoCollision();
}
}
this._attachedNoCollisions.Clear();
}
}
public LDEvtOnSpecificPropObjectDestroyed(double runtimeID)
{
this._propObjectActor = Singleton <EventManager> .Instance.GetActor <PropObjectActor>((uint)runtimeID);
}
