private Vector3 GetTargetPostion()
{
Vector3 xZPosition;
Vector3 forward;
RaycastHit hit;
if (this.syncWithAttackTarget)
{
xZPosition = (this.targetEntity.Value as BaseMonoMonster).GetAttackTarget().XZPosition;
forward = -this.targetEntity.Value.transform.forward;
}
else
{
xZPosition = this.targetEntity.Value.XZPosition;
forward = this.targetEntity.Value.transform.forward;
}
if (this.offsetRadius.Value != 0f)
{
Vector3 vector3 = (Vector3)(Quaternion.Euler(0f, this.offsetAngle.Value, 0f) * forward);
xZPosition += (Vector3)(vector3 * this.offsetRadius.Value);
}
bool flag = false;
BaseMonoAnimatorEntity component = base.GetComponent <BaseMonoAnimatorEntity>();
Vector3 start = new Vector3(component.transform.position.x, 0.1f, component.transform.position.z);
Vector3 end = new Vector3(xZPosition.x, 0.1f, xZPosition.z);
if (Physics.Linecast(start, end, out hit, (((int)1) << InLevelData.OBSTACLE_COLLIDER_LAYER) | (((int)1) << InLevelData.STAGE_COLLIDER_LAYER)))
{
flag = true;
}
if (flag)
{
Vector3 point = hit.point;
Vector3 vector11 = start - end;
Vector3 normalized = vector11.normalized;
float num = 0.1f;
Vector3 vector8 = point + ((Vector3)(normalized * num));
xZPosition = new Vector3(vector8.x, xZPosition.y, vector8.z);
}
return(xZPosition);
}
public override void OnAwake()
{
BaseMonoAnimatorEntity component = base.GetComponent <BaseMonoAnimatorEntity>();
if (component is BaseMonoAvatar)
{
this._aiEntity = (BaseMonoAvatar)component;
}
else if (component is BaseMonoMonster)
{
this._aiEntity = (BaseMonoMonster)component;
}
if (this.isRandom)
{
this.CD.Value = UnityEngine.Random.Range(this.minRandTime, this.maxRandTime);
}
else
{
this.CD.Value = this.defaultTime;
}
}
public AbilityMonsterDefendMixin(ActorAbility instancedAbility, ActorModifier instancedModifier, ConfigAbilityMixin config) : base(instancedAbility, instancedModifier, config)
{
this._breakDefendAniDamageRatio = 1f;
this._defendActionRange = 1f;
this._defendActionChance = 1f;
this._shieldLightLayer = 3;
this._shieldLightMax = 1f;
this._layerWeightTransitionDuration = 0.3f;
this.config = (MonsterDefendMixin)config;
this._defendAngle = instancedAbility.Evaluate(this.config.DefendAngle);
this._defendActionTimer = new EntityTimer(instancedAbility.Evaluate(this.config.DefendActionCD));
this._inDefendStateTimer = new EntityTimer(instancedAbility.Evaluate(this.config.InDefendMaxTime));
this._breakDefendAniDamageRatio = instancedAbility.Evaluate(this.config.BreakDefendAniDamageRatio);
this._defendActionRange = instancedAbility.Evaluate(this.config.DefendActionRange);
this._defendActionChance = instancedAbility.Evaluate(this.config.DefendActionChance);
this._defendActionChance = Mathf.Clamp(this._defendActionChance, 0f, 1f);
this._defendActionTimer.SetActive(this.config.DefendSuccessActions.Length > 0);
this._shieldLightLayer = this.config.ShieldLightLayer;
this._shieldLightMax = Mathf.Clamp(this.config.ShieldLightMax, 0f, 1f);
this._shieldLightMin = Mathf.Clamp(this.config.ShieldLightMin, 0f, 1f);
this._allowLayerControl = this.config.AllowLayerLightControl;
this._animatorEntity = (BaseMonoAnimatorEntity)base.entity;
}
public override void HandleAnimatorEvent(BaseMonoAnimatorEntity entity)
{
entity.MultiAnimEventHandler(this.MultiEventID);
}
public override void HandleAnimatorEvent(BaseMonoAnimatorEntity entity)
{
entity.TriggerEffectPattern(this.EffectPatternName);
}
public override void HandleAnimatorEvent(BaseMonoAnimatorEntity entity)
{
entity.DeadHandler();
}
public override void HandleAnimatorEvent(BaseMonoAnimatorEntity entity)
{
entity.StopAllEffects();
}
public override void OnRemoved()
{
BaseMonoAnimatorEntity entity = base.actor.entity as BaseMonoAnimatorEntity;
entity.onCurrentSkillIDChanged = (Action <string, string>)Delegate.Remove(entity.onCurrentSkillIDChanged, new Action <string, string>(this.OnSkillIDChanged));
}
public static void KianaRuntimeAttachHandler(ConfigWeapon config, Transform weaponProtoTrans, BaseMonoAnimatorEntity avatar, string avatarType)
{
KianaWeaponAttach attach = (KianaWeaponAttach)config.Attach;
if (!string.IsNullOrEmpty(attach.WeaponEffectPattern))
{
GameObject obj2 = Singleton <EffectManager> .Instance.CreateGroupedEffectPattern(attach.WeaponEffectPattern, avatar);
GameObject obj3 = Singleton <EffectManager> .Instance.CreateGroupedEffectPattern(attach.WeaponEffectPattern, avatar);
SetTransformParentAndReset(obj2.transform, avatar.GetAttachPoint("LeftGunPoint"));
SetTransformParentAndReset(obj3.transform, avatar.GetAttachPoint("RightGunPoint"));
}
}
public AbilityAttachModifierToAnimatorBooleanMixin(ActorAbility instancedAbility, ActorModifier instancedModifier, ConfigAbilityMixin config) : base(instancedAbility, instancedModifier, config)
{
this.config = (AttachModifierToAnimatorBooleanMixin)config;
this._animatorEntity = (BaseMonoAnimatorEntity)base.entity;
}
public override void HandleAnimatorEvent(BaseMonoAnimatorEntity entity)
{
}
public static void BronyaRuntimeAttachHandler(ConfigWeapon config, Transform weaponProtoTrans, BaseMonoAnimatorEntity avatar, string avatarType)
{
BronyaWeaponAttach attach = (BronyaWeaponAttach)config.Attach;
if (!string.IsNullOrEmpty(attach.WeaponEffectPattern))
{
SetTransformParentAndReset(Singleton <EffectManager> .Instance.CreateGroupedEffectPattern(attach.WeaponEffectPattern, avatar).transform, avatar.GetAttachPoint("GunPoint"));
}
}
public override void HandleAnimatorEvent(BaseMonoAnimatorEntity entity)
{
(entity as BaseMonoAvatar).ClearSkillTriggers();
}
public override void HandleAnimatorEvent(BaseMonoAnimatorEntity entity)
{
entity.ClearAttackTarget();
}
public override void OnAwake()
{
base.OnAwake();
this._entity = base.GetComponent <BaseMonoAnimatorEntity>();
this.TargetPosition.Value = this.GetSpawnPointPos(this.SpawnPointName);
}
public override void OnAwake()
{
BaseMonoEntity component = base.GetComponent <BaseMonoEntity>();
this._animatorEntity = (BaseMonoAnimatorEntity)component;
}
public AbilityAttachAdditiveVelocityMixin(ActorAbility instancedAbility, ActorModifier instancedModifier, ConfigAbilityMixin config) : base(instancedAbility, instancedModifier, config)
{
this.config = (AttachAdditiveVelocityMixin)config;
this._animatorEntity = base.entity as BaseMonoAnimatorEntity;
}
public override TaskStatus OnUpdate()
{
if (this.targetEntity.Value == null)
{
return(TaskStatus.Failure);
}
BaseMonoAnimatorEntity component = base.GetComponent <BaseMonoAnimatorEntity>();
if (this.syncWithAttackTarget && ((this.targetEntity.Value as BaseMonoMonster).GetAttackTarget() == null))
{
return(TaskStatus.Failure);
}
Vector3 targetPostion = this.GetTargetPostion();
if (this.isTeleporting)
{
if (this.teleportTimeSpan.Value > 0f)
{
if (this.teleportTimer >= this.teleportTimeSpan.Value)
{
this.isTeleporting = false;
}
}
else if (component.gameObject.activeSelf)
{
component.FireEffect("Monster_TeleportTo_Small");
this.isTeleporting = false;
}
}
if (Vector3.Distance(component.XZPosition, targetPostion) > 1f)
{
if (this.teleportTimeSpan.Value > 0f)
{
if (!this.isTeleporting)
{
this.teleportTimer = 0f;
this.isTeleporting = true;
}
}
else if (component.gameObject.activeSelf)
{
component.FireEffect("Monster_TeleportFrom_Small");
this.isTeleporting = true;
}
}
if (this.syncWithAttackTarget)
{
Vector3 vector2 = targetPostion - component.transform.position;
component.transform.forward = vector2.normalized;
}
else
{
component.transform.forward = this.targetEntity.Value.transform.forward;
}
if (this.isTeleporting && (this.teleportTimeSpan.Value > 0f))
{
this.teleportTimer += Time.deltaTime;
component.transform.position = Vector3.Lerp(component.transform.position, targetPostion, this.teleportTimer / this.teleportTimeSpan.Value);
}
else
{
component.transform.position = targetPostion;
}
component.SetLocomotionBool("IsMove", (this.targetEntity.Value as BaseMonoAnimatorEntity).GetLocomotionBool("IsMove"), false);
component.SetLocomotionBool("IsMoveHorizontal", (this.targetEntity.Value as BaseMonoAnimatorEntity).GetLocomotionBool("IsMoveHorizontal"), false);
component.SetLocomotionFloat("MoveSpeed", (this.targetEntity.Value as BaseMonoAnimatorEntity).GetLocomotionFloat("MoveSpeed"), false);
component.SetLocomotionFloat("AbsMoveSpeed", (this.targetEntity.Value as BaseMonoAnimatorEntity).GetLocomotionFloat("AbsMoveSpeed"), false);
if (this.syncOneFrame && !this.isTeleporting)
{
return(TaskStatus.Success);
}
return(TaskStatus.Running);
}
public void Init(uint runtimeID, BaseMonoAnimatorEntity owner)
{
base.commonConfig = owner.commonConfig;
base.Init(runtimeID);
this.owner = owner;
}
public override void OnAwake()
{
this._entity = base.GetComponent <BaseMonoAnimatorEntity>();
}
public abstract void HandleAnimatorEvent(BaseMonoAnimatorEntity entity);
public void Init(BaseMonoAnimatorEntity owner, BaseMonoAnimatorEntity target, ConfigMonsterAttackHint config)
{
this._timer = 0f;
this._owner = owner;
this._config = config;
this._outerState = OuterState.Glow;
this._innerState = InnerState.Hide;
if (config is RectAttackHint)
{
RectAttackHint hint = (RectAttackHint)config;
if ((config.OffsetBase == HintOffsetBase.Target) && (target != null))
{
base.transform.position = target.XZPosition + ((Vector3)(target.FaceDirection * (hint.OffsetZ + (0.5f * hint.Distance))));
}
else if (config.OffsetBase == HintOffsetBase.Owner)
{
base.transform.position = owner.XZPosition + ((Vector3)(owner.FaceDirection * (hint.OffsetZ + (0.5f * hint.Distance))));
}
base.transform.forward = owner.FaceDirection;
base.transform.SetLocalScaleX(hint.Width);
base.transform.SetLocalScaleZ(hint.Distance);
this._innerMinScale = 0f;
this._innerMaxScale = 1f;
}
else
{
Vector3 vector5;
if (config is CircleAttackHint)
{
CircleAttackHint hint2 = (CircleAttackHint)config;
if ((config.OffsetBase == HintOffsetBase.Target) && (target != null))
{
base.transform.position = target.XZPosition + ((Vector3)(target.FaceDirection * hint2.OffsetZ));
}
else if (config.OffsetBase == HintOffsetBase.Owner)
{
base.transform.position = owner.XZPosition + ((Vector3)(owner.FaceDirection * hint2.OffsetZ));
}
base.transform.forward = owner.FaceDirection;
vector5 = (Vector3)(Vector3.one * hint2.Radius);
this.outerHint.localScale = vector5;
this.innerHint.localScale = vector5;
this._innerMinScale = 0f;
this._innerMaxScale = hint2.Radius;
this.outerHint.GetComponent <MeshRenderer>().material.SetFloat("_FanAngle", 6.283185f);
this.innerHint.GetComponent <MeshRenderer>().material.SetFloat("_FanAngle", 6.283185f);
GameObject obj2 = new GameObject("Flags");
obj2.transform.SetParent(base.transform);
Vector3 zero = Vector3.zero;
zero.y = 0.04f;
obj2.transform.localPosition = zero;
int num = Mathf.Min(Mathf.FloorToInt((hint2.Radius * 7f) / this.flagGap), 6);
float num2 = (6.283185f / ((float)num)) * 57.29578f;
for (int i = 0; i < num; i++)
{
Transform transform = UnityEngine.Object.Instantiate <Transform>(this.flag);
transform.SetParent(obj2.transform, false);
transform.gameObject.SetActive(true);
transform.localRotation = Quaternion.AngleAxis(num2 * i, Vector3.up);
Vector3 vector2 = (Vector3)(transform.localRotation * (Vector3.forward * (hint2.Radius - this.flagBorderOffset)));
transform.localPosition = vector2;
transform.GetComponent <Renderer>().sharedMaterial = this._sharedFlagMaterial;
}
}
else if (config is SectorAttackHint)
{
SectorAttackHint hint3 = (SectorAttackHint)config;
if ((config.OffsetBase == HintOffsetBase.Target) && (target != null))
{
base.transform.position = target.XZPosition + ((Vector3)(target.FaceDirection * hint3.OffsetZ));
}
else if (config.OffsetBase == HintOffsetBase.Owner)
{
base.transform.position = owner.XZPosition + ((Vector3)(owner.FaceDirection * hint3.OffsetZ));
}
base.transform.forward = owner.FaceDirection;
vector5 = (Vector3)(Vector3.one * hint3.Radius);
this.outerHint.localScale = vector5;
this.innerHint.localScale = vector5;
this._innerMinScale = 0f;
this._innerMaxScale = hint3.Radius;
this.outerHint.GetComponent <MeshRenderer>().material.SetFloat("_FanAngle", 0.01745329f * hint3.Angle);
this.innerHint.GetComponent <MeshRenderer>().material.SetFloat("_FanAngle", 0.01745329f * hint3.Angle);
GameObject obj3 = new GameObject("Flags");
obj3.transform.SetParent(base.transform);
Vector3 vector3 = Vector3.zero;
vector3.y = 0.04f;
obj3.transform.localPosition = vector3;
obj3.transform.forward = owner.FaceDirection;
int num4 = Mathf.Min(Mathf.FloorToInt((((((hint3.Radius * 7f) * 0.01745329f) * hint3.Angle) / 3.141593f) / 2f) / this.flagGap), 6);
float num5 = ((0.01745329f * hint3.Angle) / ((float)num4)) * 57.29578f;
bool flag = (num4 % 2) == 0;
for (int j = 0; j < num4; j++)
{
Transform transform2 = UnityEngine.Object.Instantiate <Transform>(this.flag);
transform2.SetParent(obj3.transform, false);
transform2.gameObject.SetActive(true);
if (flag)
{
transform2.localRotation = ((j % 2) != 0) ? Quaternion.AngleAxis(-num5 * ((j / 2) + 0.5f), Vector3.up) : Quaternion.AngleAxis(num5 * ((j / 2) + 0.5f), Vector3.up);
}
else if (j == 0)
{
transform2.localRotation = Quaternion.AngleAxis(0f, Vector3.up);
}
else
{
transform2.localRotation = ((j % 2) != 0) ? Quaternion.AngleAxis(-num5 * j, Vector3.up) : Quaternion.AngleAxis(num5 * j, Vector3.up);
}
Vector3 vector4 = (Vector3)(transform2.localRotation * (Vector3.forward * (hint3.Radius - this.flagBorderOffset)));
transform2.localPosition = vector4;
transform2.GetComponent <Renderer>().sharedMaterial = this._sharedFlagMaterial;
}
}
}
}
public AbilityAvatarLimitSkillByStaminaMixin(ActorAbility instancedAbility, ActorModifier instancedModifier, ConfigAbilityMixin config) : base(instancedAbility, instancedModifier, config)
{
this.config = (AvatarLimitSkillByStaminaMixin)config;
this._animatorEntity = (BaseMonoAnimatorEntity)base.entity;
this._avatarActor = (AvatarActor)base.actor;
}
public static void HimekoRuntimeAttachHandler(ConfigWeapon config, Transform weaponProtoTrans, BaseMonoAnimatorEntity himeko, string avatarType)
{
}
public AbilityAvatarWeaponOverHeatMixin(ActorAbility instancedAbility, ActorModifier instancedModifier, ConfigAbilityMixin config) : base(instancedAbility, instancedModifier, config)
{
this.config = (AvatarWeaponOverHeatMixin)config;
this._animatorEntity = (BaseMonoAnimatorEntity)base.entity;
this._avatarActor = (AvatarActor)base.actor;
}
public static void MeiRuntimeAttachHandler(ConfigWeapon config, Transform weaponProtoTrans, BaseMonoAnimatorEntity avatar, string avatarType)
{
MeiWeaponAttach attach = (MeiWeaponAttach)config.Attach;
if (!string.IsNullOrEmpty(attach.WeaponEffectPattern))
{
if ((avatarType == "Mei_C1_DH") || (avatarType == "Mei_C3_WS"))
{
SetTransformParentAndReset(Singleton <EffectManager> .Instance.CreateGroupedEffectPattern(attach.WeaponEffectPattern, avatar).transform, avatar.GetAttachPoint("WeaponRightHand"));
}
else if ((avatarType == "Mei_C2_CK") || (avatarType == "Mei_C4_LD"))
{
GameObject obj3 = Singleton <EffectManager> .Instance.CreateGroupedEffectPattern(attach.WeaponEffectPattern, avatar);
GameObject obj4 = Singleton <EffectManager> .Instance.CreateGroupedEffectPattern(attach.WeaponEffectPattern, avatar);
SetTransformParentAndReset(obj3.transform, avatar.GetAttachPoint("WeaponLeftHand"));
SetTransformParentAndReset(obj4.transform, avatar.GetAttachPoint("WeaponRightHand"));
}
}
}
public ShaderLerpPlugin(BaseMonoAnimatorEntity entity) : base(entity)
{
this._lerpInstances = new List <LerpInstance>();
this._newShaderEntries = new List <Tuple <E_ShaderData, int> >();
this._animatorEntity = entity;
}
