public override void FixedUpdateComponent(float _FixedDeltaTime)
{
base.FixedUpdateComponent(_FixedDeltaTime);
if (m_TailAttack)
{
Vector3 dir = m_FireDragonCharacter.m_TailPoint[0].position - m_FireDragonCharacter.transform.position;
dir.y = 0.0f;
dir.Normalize();
HashSet <CharacterBase> list = OverlabShape(m_FireDragonCharacter, m_FireDragonCharacter.transform.position, dir, 2.5f, 6.5f);
foreach (CharacterBase c in list)
{
if (m_DamageList.Contains(c))
{
continue;
}
c.GiveToDamage(m_FireDragonCharacter, m_TailAttackDamage, true);
m_DamageList.Add(c);
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_TailAttackHitEffectPrefab);
life.Initialize();
life.transform.position = c.transform.position + Vector3.up;
life.gameObject.SetActive(true);
}
}
}
void HitBreath()
{
RaycastHit[] hits = Physics.SphereCastAll(m_CurrentBreathPoint.position, 0.5f, m_CurrentBreathPoint.forward, m_UseMaxDistance, m_FireDragonCharacter.m_EnemyLayerMask);
foreach (RaycastHit h in hits)
{
CharacterBase character = h.transform.GetComponentInParent <CharacterBase>();
if (!character)
{
continue;
}
if (character.m_Team == m_AICharacter.m_Team)
{
continue;
}
if (m_DamageHash.Contains(character))
{
continue;
}
m_DamageHash.Add(character);
character.GiveToDamage(m_FireDragonCharacter, m_Damage, true);
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_BreathHitEffectPrefab);
life.Initialize();
life.transform.position = character.transform.position + Vector3.up;
life.gameObject.SetActive(true);
}
}
public override void AttackMomentEvent()
{
if (m_Live == E_LIVE.DEAD)
{
return;
}
Vector3 location = transform.position + (transform.forward * m_AttackRange) + new Vector3(0.0f, 0.01f, 0.0f);
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_AttackImpactEffect.name);
if (life)
{
life.Initialize();
life.transform.position = location;
life.gameObject.SetActive(true);
}
List <Character> list = FindEnemyAllArea(this, location, 2.0f);
if (list != null)
{
for (int i = 0; i < list.Count; ++i)
{
list[i].GiveToDamage(GetDamages(), this);
}
}
}
IEnumerator C_SkillEvent(float _Delay)
{
yield return(new WaitForSeconds(_Delay));
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_CastEndEffectPrefab.name);
if (life)
{
life.Initialize();
life.transform.position = m_PlayerCharacter.transform.position;
life.gameObject.SetActive(true);
}
Shader.SetGlobalFloat("GrayScaleFactor", 1.0f);
GameManager.Instance.TimeScale = 0.1f;
while (m_SkillTimer > 0.0f)
{
m_SkillTimer -= Time.deltaTime;
yield return(null);
}
Shader.SetGlobalFloat("GrayScaleFactor", 0.0f);
GameManager.Instance.TimeScale = 1.0f;
m_Coroutine = null;
}
void FrontWingAttackRight()
{
HitDamage(m_FireDragonCharacter, m_FireDragonCharacter.m_RightHandPoint.transform.position, m_WingAttackDamage, 1);
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_DragonWingAttackSmokePrefab);
life.Initialize();
life.transform.position = m_FireDragonCharacter.m_RightHandPoint.transform.position + Vector3.down * 0.5f;
life.gameObject.SetActive(true);
}
void BreathStart()
{
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_BreathFirePrefab);
life.Initialize();
life.transform.SetParent(m_CurrentBreathPoint);
sunTT.sunTTHelper.SetLocalTransformIdentity(life.transform);
life.gameObject.SetActive(true);
m_DamageHash.Clear();
m_EnableBreath = true;
}
void HitEffect(string _EffectPath, Vector3 _EffectPosition)
{
UIManager.Instacne.m_MotionCancelGauge.AddGauge(1);
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(_EffectPath);
if (life)
{
life.Initialize();
life.transform.position = _EffectPosition;
life.gameObject.SetActive(true);
}
}
public override void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
float frame = stateInfo.normalizedTime;
if (frame > 1.0f)
{
frame = frame - Mathf.Floor(frame);
if (frame < m_CurrentFrame)
{
m_Enable = true;
}
}
m_CurrentFrame = frame;
if (!m_Enable)
{
return;
}
if (m_CurrentFrame <= m_PlayNormalizeFrame)
{
return;
}
m_Enable = false;
CharacterBase character = animator.GetComponentInParent <CharacterBase>();
if (character)
{
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_ObjectPrefab.name);
if (life)
{
life.Initialize();
switch (m_SpawnPoint)
{
case E_POINT.LEFTHAND:
life.transform.position = character.m_LeftHandPoint.position;
break;
case E_POINT.RIGHTHAND:
life.transform.position = character.m_RightHandPoint.position;
break;
case E_POINT.ORIGIN:
life.transform.position = character.transform.position;
break;
default:
break;
}
life.gameObject.SetActive(true);
}
}
}
void FrontTailStart()
{
m_DamageList.Clear();
SoundManager.Instance.PlayDefaultSound(m_CharacterBase.m_AudioList[2], 0.5f);
for (int i = 0; i < m_FireDragonCharacter.m_TailPoint.Length; ++i)
{
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_TailAttackSmokeEffectPrefab);
life.Initialize();
life.SetTargetTransform(m_FireDragonCharacter.m_TailPoint[i]);
life.gameObject.SetActive(true);
}
m_TailAttack = true;
}
public void UseMeteor()
{
m_UseMeteor = true;
m_CharacterBase.m_Immortal = true;
m_CharacterBase.m_Animator.CrossFade(m_AnimKeyFlyStart, 0.3f);
m_FlyTimer = m_FlyTime;
m_MeteorSpawnTimer = m_MeteorSpawnDelay;
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_FlySmokePrefab);
life.Initialize();
life.transform.position = m_FireDragonCharacter.transform.position;
life.gameObject.SetActive(true);
}
void HitEvent()
{
Vector3 pos = m_CharacterBase.transform.position + (Vector3.up + m_CharacterBase.transform.forward);
if (HitDamage(m_CharacterBase, pos, Mathf.Floor((m_Damage + (UIManager.Instacne.m_ComboViewer.GetCurrentCombo() * 1.2f))), 0.7f))
{
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_HitEffectPrefabName);
if (life)
{
life.Initialize();
life.transform.SetPositionAndRotation(m_CharacterBase.transform.position + (Vector3.up + m_CharacterBase.transform.forward * 0.35f), m_CharacterBase.transform.rotation);
life.gameObject.SetActive(true);
}
}
}
private void OnEnable()
{
m_LightPower = m_StartValue;
if (m_First)
{
return;
}
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_EnableEffect.name);
life.Initialize();
life.SetTargetTransform(this.transform);
life.gameObject.SetActive(true);
}
protected override void OnUpdate()
{
float deltatime = Time.DeltaTime * GameManager.Instance.TimeScale;
EntityCommandBuffer commandBuffer = m_EndSimulationEcbSystem.CreateCommandBuffer();
Entities.ForEach((Entity _Entity, ref BulletComponent _Bullet, ref Translation _Translation) =>
{
Ray ray = new Ray(_Translation.Value, _Bullet.Direction);
RaycastHit hit;
float length = _Bullet.Speed * deltatime;
if (Physics.Raycast(ray, out hit, length, _Bullet.TargetLayerMask, QueryTriggerInteraction.Collide))
{
CharacterBase character = hit.transform.GetComponent <CharacterBase>();
if (character)
{
//Debug.Log("character hit!!");
_Translation.Value = hit.point;
commandBuffer.DestroyEntity(_Entity);
character.GiveToDamage(_Bullet.HostID, _Bullet.Damage);
}
else
{
if (math.dot(-_Bullet.Direction, hit.normal) > 0.0f)
{
_Translation.Value = hit.point;
commandBuffer.DestroyEntity(_Entity);
}
else
{
_Translation.Value += _Bullet.Direction * length;
return;
}
}
LifeTimerWithObjectPool hiteffect = ObjectPool.GetObject <LifeTimerWithObjectPool>(BulletHitPrefabs[(int)_Bullet.BulletType].name);
if (hiteffect)
{
hiteffect.Initialize();
hiteffect.transform.position = hit.point;
hiteffect.gameObject.SetActive(true);
}
}
_Translation.Value += _Bullet.Direction * length;
});
}
IEnumerator C_SkillEvent(float _Delay)
{
yield return(new WaitForSeconds(_Delay));
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_CastEndEffectPrefab.name);
if (life)
{
life.m_LifeTime = m_SkillDuration;
life.Initialize();
life.transform.position = m_PlayerCharacter.transform.position;
life.gameObject.SetActive(true);
}
m_Coroutine = null;
}
void HitEvent()
{
Vector3 pos = m_CharacterBase.transform.position + Vector3.up;
if (HitDamage(m_CharacterBase, pos, m_PlayerCharacter.transform.forward, m_Damage, 0.5f, 1.5f))
{
UIManager.Instacne.m_MotionCancelGauge.AddGauge(1);
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_HitEffectPrefabName);
if (life)
{
life.Initialize();
life.transform.SetPositionAndRotation(m_CharacterBase.transform.position + (Vector3.up + m_CharacterBase.transform.forward * 0.35f), m_CharacterBase.transform.rotation);
life.gameObject.SetActive(true);
}
}
}
void HitEvent()
{
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_HitEffectPrefabName);
if (life)
{
life.Initialize();
life.transform.position = m_CharacterBase.transform.position + m_CharacterBase.transform.forward;
life.gameObject.SetActive(true);
}
Vector3 pos = m_CharacterBase.transform.position + (Vector3.up + m_CharacterBase.transform.forward);
if (HitDamage(m_CharacterBase, pos, m_Damage, 0.75f))
{
UIManager.Instacne.m_MotionCancelGauge.AddGauge(1);
}
}
private void Update()
{
float deltatime = Time.deltaTime;
m_Ray.origin = transform.position;
m_Ray.direction = m_Direction;
if (!m_Hit && Physics.SphereCast(m_Ray, 0.5f, out m_RayHit, m_Speed * deltatime, m_GroundLayer))
{
m_Hit = true;
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_MiniMeteorImpactPrefab.name);
life.Initialize();
life.transform.position = m_RayHit.point;
life.gameObject.SetActive(true);
RaycastHit[] hits = Physics.SphereCastAll(m_Ray, m_DamageRadius, m_Speed * deltatime, m_Other.m_EnemyLayerMask);
foreach (RaycastHit h in hits)
{
CharacterBase character = h.transform.GetComponentInParent <CharacterBase>();
if (!character)
{
continue;
}
if (character.m_Live == CharacterBase.E_Live.DEAD)
{
continue;
}
if (character.m_Team == m_Other.m_Team)
{
continue;
}
character.GiveToDamage(m_Other, m_Damage, true);
}
LifeTimerWithObjectPool mylife = GetComponent <LifeTimerWithObjectPool>();
mylife.SetTimer(1.5f);
}
else
{
Vector3 nextpos = transform.position + m_Direction * m_Speed * deltatime;
transform.position = nextpos;
}
}
private void OnDisable()
{
if (m_First)
{
m_First = false;
return;
}
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_DisableEffect.name);
life.Initialize();
life.transform.position = this.transform.position;
life.gameObject.SetActive(true);
m_TrailEnableTimer = m_TrailEnableTime;
if (m_TrailEnableTimer > 0.0f)
{
m_Trail.gameObject.SetActive(false);
}
}
public void UseSkill_RPC()
{
m_Caster.SetCharging_RPC(false);
m_CurrentCooldown = m_MaxCooldown;
if (m_UseEffect != null)
{
LifeTimerWithObjectPool effect = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_UseEffect.name);
if (effect)
{
effect.transform.position = transform.position + m_EffectLocalPosition;
effect.Initialize();
effect.gameObject.SetActive(true);
}
}
if (m_UseSoundClip != null)
{
SoundManager.Instance.PlayEffectSound(m_UseSoundClip);
}
m_UseSkillAction?.Invoke();
}
public override void GiveToDamage(CharacterBase _Attacker, float _Damage, bool _Knockback = false)
{
if (m_Immortal)
{
return;
}
if (m_Down)
{
return;
}
if (m_IsDashing)
{
CreateSpectrumMesh(1.5f, true, GameManager.Instacne.m_Main.m_SpectrumMaterialSkyBlue);
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>("AvoidEffect");
life.Initialize();
life.transform.position = transform.position + Vector3.up;
life.gameObject.SetActive(true);
UIManager.Instacne.m_MotionCancelGauge.AddGauge(2);
return;
}
if (m_UseHitAnimation)
{
if (m_Health - _Damage > 0.0f)
{
if (!_Knockback)
{
int number = Random.Range(0, 100);
SoundManager.Instance.PlayDefaultSound(number > 50 ? m_AudioListHit[0] : m_AudioListHit[1]);
}
else
{
SoundManager.Instance.PlayDefaultSound(m_AudioListHit[2]);
}
}
AllWeaponDisable();
}
base.GiveToDamage(_Attacker, _Damage, _Knockback);
}
protected override void SkillAction()
{
base.SkillAction();
Debug.Log("ForceField");
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_CastStartEffectPrefab.name);
if (life)
{
life.Initialize();
life.transform.SetParent(m_PlayerCharacter.m_RightHandPoint);
sunTT.sunTTHelper.SetLocalTransform(life.transform, Vector3.zero, Quaternion.identity);
life.gameObject.SetActive(true);
}
m_PlayerCharacter.SetCastMode(2, true, true);
if (m_Coroutine != null)
{
return;
}
m_Coroutine = StartCoroutine(C_SkillEvent(0.7f));
}
protected override void SkillAction()
{
base.SkillAction();
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_CastStartEffectPrefab.name);
if (life)
{
life.Initialize();
life.transform.SetParent(m_PlayerCharacter.m_LeftHandPoint);
sunTT.sunTTHelper.SetLocalTransform(life.transform, Vector3.zero, Quaternion.identity);
life.gameObject.SetActive(true);
}
m_PlayerCharacter.SetCastMode(1, true, m_PlayerCharacter.m_UnderAnimState != CharacterBase.E_UnderBodyAnimState.JUMP);
m_SkillTimer = m_SkillDuration;
if (m_Coroutine != null)
{
return;
}
m_Coroutine = StartCoroutine(C_SkillEvent(1.0f));
}
void FrontHeadHitEvent()
{
if (Random.Range(0, 1) == 0)
{
SoundManager.Instance.PlayDefaultSound(m_CharacterBase.m_AudioList[0], 0.5f);
}
else
{
SoundManager.Instance.PlayDefaultSound(m_CharacterBase.m_AudioList[1], 0.5f);
}
Vector3 pos = m_FireDragonCharacter.m_HeadPoint.transform.position;
if (HitDamage(m_CharacterBase, pos, m_HeadAttackDamage, 0.75f))
{
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_DragonHeadAttackHitPrefab);
life.Initialize();
life.transform.position = pos;
life.gameObject.SetActive(true);
}
}
void FinishPunch(InputActionPhase _Phase)
{
if (_Phase != InputActionPhase.Started)
{
return;
}
if (UIManager.Instacne.m_ComboViewer.GetCurrentCombo() < 7)
{
return;
}
if (!CheckSkillAvailability())
{
return;
}
if (CheckMotionCancelAvailability())
{
SkillAnimationPlay(true, 0.5f);
}
else if (!DefaultStateCheck())
{
return;
}
else
{
SkillAnimationPlay();
}
m_PlayerCharacter.AllWeaponDisable();
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_ChargeEffect);
life.Initialize();
life.SetTargetTransform(m_CharacterBase.m_RightHandPoint);
life.gameObject.SetActive(true);
SoundManager.Instance.PlayDefaultSound(m_PlayerCharacter.m_FinishAttackClip1);
StartNewMotion();
m_PlayerCharacter.m_Immortal = true;
m_PlayerCharacter.m_StopCharacter = true;
m_PlayerCharacter.m_FinishCamera.SetFocus();
}
void UseSkillEvent()
{
m_Trigger[m_TriggerNumber] = true;
++m_TriggerNumber;
m_Caster.SetStateAndAnimationLocal(E_ANIMATION.SPECIAL1, 0.25f, 1.0f, 1.5f);
if (!m_PhotonView.IsMine)
{
return;
}
for (int i = 0; i < m_SpawnLocation.Length; ++i)
{
Vector3 spawnpos = m_Caster.transform.position + m_SpawnLocation[i] + new Vector3(0.0f, 0.01f, 0.0f);
LifeTimerWithObjectPool effect = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_SummonEffectPrefab.name);
if (effect)
{
effect.Initialize();
effect.transform.position = spawnpos;
effect.gameObject.SetActive(true);
}
if (!m_PhotonView.IsMine)
{
continue;
}
GameObject g = PhotonNetwork.InstantiateSceneObject(m_SummonMonsterPath + "/" + m_SummonMonsterPrefab.name, spawnpos, Quaternion.identity);
if (g)
{
Character c = g.GetComponent <Character>();
if (c)
{
c.SetFreeze(1.0f, true);
}
}
}
}
protected override void DamageEvent(float[] _Damage, float[] _CalculateDamage, int[] _DamageType, float _CalculateFullDamage, bool _Critical, Character _Attacker)
{
base.DamageEvent(_Damage, _CalculateDamage, _DamageType, _CalculateFullDamage, _Critical, _Attacker);
LifeTimerWithObjectPool effect = ObjectPool.GetObject <LifeTimerWithObjectPool>(((E_DAMAGETYPE)_DamageType[0]).ToString()); // 데미지 이팩트
if (effect)
{
effect.Initialize();
effect.transform.localScale = Vector3.one * (m_BodyCollider.radius * 2.0f);
effect.transform.position = transform.position + new Vector3(0.0f, m_BodyCollider.center.y, 0.0f);
effect.gameObject.SetActive(true);
}
float YOffset = 0.0f;
for (int i = 0; i < _DamageType.Length; ++i)
{
Billboard b = ObjectPool.GetObject <Billboard>("DamageText");
if (b)
{
b.gameObject.SetActive(true);
b.Initialize(_Critical ? ((int)_CalculateDamage[i]).ToString() + "!!" : ((int)_CalculateDamage[i]).ToString(),
transform.position + new Vector3(0.0f, 1.0f + (m_BodyCollider.height * 0.5f + m_BodyCollider.center.y + YOffset), 0.0f),
2.0f);
b.SetColor(Common.m_DamageColor[_DamageType[i]]);
YOffset += 0.33f;
}
}
if (m_Health <= 0.0f && m_PhotonView.IsMine)
{
SetStateAndAnimationNetwork(E_ANIMATION.DEAD, 0.15f, 1.0f, 0.0f);
return;
}
if (m_PlayHitAnimation)
{
m_Animator.CrossFade("Hit", 0.1f);
SetFreeze(0.5f);
}
if (m_IsAutoPlay)
{
float damage = 0.0f;
for (int i = 0; i < _Damage.Length; ++i)
{
damage += _Damage[i];
}
Character target = null;
HateTarget t = null;
target = _Attacker as Character;
if (target != null)
{
if (m_DicHateTarget.TryGetValue(target.gameObject.GetInstanceID(), out t))
{
t.m_Hate += damage;
}
else
{
m_DicHateTarget.Add(target.gameObject.GetInstanceID(), new HateTarget(target, damage));
}
}
}
}
IEnumerator C_DragonLanding()
{
m_MainCanvas.gameObject.SetActive(false);
m_Dragon.m_Rigidbody.velocity = Vector3.up * 1.5f;
bool land = false;
while (!land)
{
if (Physics.Raycast(m_Dragon.transform.position, Vector3.down, 0.5f, 1 << LayerMask.NameToLayer("Ground")))
{
m_Dragon.m_Rigidbody.velocity = Vector3.up * 0.5f;
m_Dragon.m_Animator.CrossFade("FlyLand", 0.2f);
land = true;
}
yield return(null);
}
yield return(new WaitForSeconds(0.25f));
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_LandingSmokePrefab.name);
life.Initialize();
life.transform.position = m_Dragon.transform.position;
life.gameObject.SetActive(true);
yield return(new WaitForSeconds(1.0f));
m_Dragon.m_Animator.CrossFade("Roer1", 0.15f);
yield return(new WaitForSeconds(1.5f));
SetPointBlur(m_Dragon.m_HeadPoint.position, 0, 0);
CustomColorGradingPass.m_UsePass = true;
float roartime = 0.0f;
while (roartime < 1.5f)
{
roartime += Time.deltaTime;
SetPointBlur(m_Dragon.m_HeadPoint.position, roartime * 0.01f, roartime * 10);
yield return(null);
}
yield return(new WaitForSeconds(0.5f));
roartime = 1.0f;
while (roartime > 0.0f)
{
roartime -= Time.deltaTime;
SetPointBlur(m_Dragon.m_HeadPoint.position, roartime * 0.015f, roartime * 10);
yield return(null);
}
CustomColorGradingPass.m_UsePass = false;
m_StartCimemaCam.ResetPriority();
yield return(new WaitForSeconds(1.5f));
GameManager.Instacne.m_Main.IsPlayStop = false;
m_MainCanvas.gameObject.SetActive(true);
m_GameTimer.Visible(true);
m_GameTimer.m_IsStop = false;
}
void MotionProgress(float _DeltaTime)
{
if (!m_UseMeteor)
{
return;
}
if (m_FlyTimer > 0.0f)
{
m_FlyTimer -= _DeltaTime;
m_CharacterBase.m_Rigidbody.velocity = Vector3.up * 5.5f;
if (m_FlyTimer <= 0.5f)
{
m_CharacterBase.m_Animator.SetLayerWeight(1, (1.0f - m_FlyTimer * 2.0f));
}
if (m_FlyTimer <= 0.0f)
{
m_DurationTimer = m_Duration;
SoundManager.Instance.PlayDefaultSound(m_FireDragonCharacter.m_RoarClip, 0.8f);
Vector3 effpos = m_AICharacter.transform.position;
effpos.y = 20.0f;
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_SkySmokePrefb);
life.Initialize();
life.transform.position = effpos;
life.gameObject.SetActive(true);
}
return;
}
if (m_DurationTimer > 0.0f)
{
m_DurationTimer -= _DeltaTime;
m_CharacterBase.m_Rigidbody.velocity = Vector3.up * 1.0f;
if (m_DurationTimer <= 0.5f)
{
m_CharacterBase.m_Animator.SetLayerWeight(1, m_DurationTimer * 2.0f);
}
else
{
if (m_MeteorSpawnTimer > 0.0f)
{
m_MeteorSpawnTimer -= _DeltaTime;
if (m_MeteorSpawnTimer <= 0.0f)
{
m_MeteorSpawnTimer = m_MeteorSpawnDelay;
Vector3 mpos = m_AICharacter.transform.position;
mpos.y = 25.0f;
Vector3 direction = Vector3.zero;
if (Random.Range(0, 100) > 40 || m_AICharacter.m_TargetCharacter == null)
{
mpos.x += Random.Range(-25, 25);
mpos.z += Random.Range(-25, 25);
direction = new Vector3(Random.Range(-0.5f, 0.5f), -1.0f, Random.Range(-0.5f, 0.5f));
}
else
{
Vector3 targetpos = m_AICharacter.m_TargetCharacter.transform.position;
targetpos.y = 0.0f;
targetpos.x += Random.Range(-5, 5);
targetpos.z += Random.Range(-5, 5);
mpos.x = targetpos.x;
mpos.z = targetpos.z;
direction = new Vector3(Random.Range(-0.25f, 0.25f), -1.0f, Random.Range(-0.25f, 0.25f));
}
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_MeteorPrefab);
life.Initialize();
life.transform.position = mpos;
MiniMeteorComponent meteor = life.GetComponent <MiniMeteorComponent>();
meteor.Initialize(m_FireDragonCharacter, direction, 10.0f, m_MeteorDamage, 3.5f);
life.gameObject.SetActive(true);
}
}
}
if (m_DurationTimer <= 0.0f)
{
m_LandingTimer = m_LandingTime;
}
return;
}
if (m_LandingTimer > 0.0f)
{
m_LandingTimer -= _DeltaTime;
if (m_LandingTimer <= 0.0f)
{
m_CharacterBase.m_Animator.CrossFade(m_AnimKeyFlyLand, 0.15f);
LifeTimerWithObjectPool life = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_FlySmokePrefab);
life.Initialize();
life.transform.position = m_FireDragonCharacter.transform.position + Vector3.down;
life.gameObject.SetActive(true);
}
}
}
IEnumerator C_Progress()
{
m_Caster.SetStateAndAnimationLocal(E_ANIMATION.SPECIAL1, 0.25f, 1.0f, 0.0f, true);
float timer = m_ChargeTime;
Vector3 effectpos = m_Caster.transform.position + (m_Caster.transform.rotation * m_ChargeEffectLocalLocation);
LifeTimerWithObjectPool ribbon = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_ChargeRibbonEffect.name);
if (ribbon)
{
ribbon.Initialize();
ribbon.transform.position = effectpos;
ribbon.gameObject.SetActive(true);
}
LifeTimerWithObjectPool ball = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_ChargeBallEffect.name);
if (ball)
{
ball.Initialize();
ball.transform.localScale = Vector3.one;
ball.transform.position = effectpos;
ball.gameObject.SetActive(true);
}
while (timer > 0.0f)
{
if (!m_Caster.IsCharging())
{
ObjectPool.PushObject(ribbon.gameObject);
ObjectPool.PushObject(ball.gameObject);
yield break;
}
float deltatime = Time.deltaTime;
timer -= deltatime;
ball.transform.localScale += Vector3.one * deltatime;
yield return(null);
}
ObjectPool.PushObject(ribbon.gameObject);
ObjectPool.PushObject(ball.gameObject);
m_Caster.SetCharging(false);
LifeTimerWithObjectPool blast = ObjectPool.GetObject <LifeTimerWithObjectPool>(m_BlastEffect.name);
if (blast)
{
blast.Initialize();
blast.transform.position = m_Caster.transform.position + new Vector3(0.0f, 0.5f, 0.0f);
blast.gameObject.SetActive(true);
}
List <Character> list = Character.FindEnemyAllArea(m_Caster, m_Caster.transform.position, m_Radius);
if (list != null)
{
float[] damage = new float[] { CalculateSkillDamage(m_Caster, m_DamageType, m_DamageMultiply) };
int[] type = new int[] { (int)m_DamageType };
for (int i = 0; i < list.Count; ++i)
{
list[i].GiveToDamage(damage, type, m_Caster);
}
}
}
