You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1409 lines
41 KiB
1409 lines
41 KiB
using DG.Tweening;
|
|
using DG.Tweening.Core;
|
|
using DG.Tweening.Plugins.Options;
|
|
using IVDataFormat;
|
|
using Spine.Unity;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Numerics;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
using Quaternion = UnityEngine.Quaternion;
|
|
using Random = UnityEngine.Random;
|
|
using Vector3 = UnityEngine.Vector3;
|
|
|
|
public class IVSkill : MonoBehaviour
|
|
{
|
|
[System.Serializable]
|
|
public struct stSkillSequence
|
|
{
|
|
public float time;
|
|
public UnityEvent method;
|
|
}
|
|
|
|
#region Skill Settings
|
|
[SerializeField] // 스킬 종류.
|
|
protected eSkillType skillType;
|
|
|
|
[SerializeField, Space(10)] // 상태이상.
|
|
protected eSkillDebuff debuff;
|
|
|
|
[SerializeField, Space(10)] // 타겟/캐릭터 따라다님.
|
|
protected bool bTrace = false;
|
|
[SerializeField] // 적 끌어당김.
|
|
protected bool bPull = false;
|
|
[SerializeField] // 사거리.
|
|
protected int iRange = 1000000;
|
|
[SerializeField] // 총 연출 시간.
|
|
protected float fPlayTime = 1f;
|
|
[SerializeField]
|
|
protected float ShakeStrength = 0f;
|
|
[SerializeField]
|
|
protected int iVibrato = 10;
|
|
[SerializeField]
|
|
protected int useFrom;
|
|
|
|
// 발사체 시작 위치.
|
|
[SerializeField, Space(10)]
|
|
protected Transform trfShotStart;
|
|
// 발사체.
|
|
[SerializeField, Space(10)]
|
|
protected Transform[] trfShots;
|
|
protected TweenerCore<Vector3, Vector3, VectorOptions>[] twcShots;
|
|
[SerializeField, Space(10)]
|
|
protected SpriteRenderer[] sprShotItems;
|
|
// 스킬 범위.
|
|
[SerializeField, Space(10)]
|
|
protected Collider[] colliders;
|
|
// 최대 타격 횟수. 발사체 1개를 연속 발사하는 경우에만 사용.
|
|
[SerializeField]
|
|
protected int iMaxShot;
|
|
protected int iShot;
|
|
|
|
[SerializeField, Space(10)]
|
|
protected IVBullet[] bullets;
|
|
[SerializeField]
|
|
protected IVSummon summon;
|
|
|
|
// 스킬 연출 및 기능.
|
|
[SerializeField, Space(10)]
|
|
protected stSkillSequence[] skillSequences;
|
|
|
|
protected SkeletonAnimation[] skAnims;
|
|
protected ParticleSystem[] ptcEffects;
|
|
protected AudioSource[] asEffects;
|
|
#endregion Skill Settings
|
|
public int idNumber = -1;
|
|
|
|
#region Variables
|
|
protected BattleMgr battleMgr;
|
|
protected Transform trfObject;
|
|
|
|
// 재생중.
|
|
Coroutine playSkillCoroutine;
|
|
protected bool IsPlaying => playSkillCoroutine != null;
|
|
|
|
// 아군 스킬인지.
|
|
protected bool bFriendlySkill = true;
|
|
// 타겟.
|
|
protected int iTarget = -1;
|
|
// 여러명 타겟
|
|
protected List<int> iTargets;
|
|
// 추적 타겟.
|
|
protected Transform trfTrace = null;
|
|
|
|
// 크리티컬 배율.
|
|
protected float fCrtDam = 0f;
|
|
// 크리티컬 확률.
|
|
protected int iCrtRate = 0;
|
|
// 데미지1.
|
|
protected BigInteger biDmg = 0;
|
|
// 값.
|
|
protected float fRate = 0f;
|
|
// 소환물 공격간격
|
|
protected float fSummonInterval = 0.3f;
|
|
|
|
// 상태이상 수치, 시간.
|
|
protected BigInteger biDebuffValue;
|
|
protected float fDebuffTime;
|
|
protected bool bfront;
|
|
|
|
// 같은 대상인지 구분
|
|
protected int iDamCnt = 0;
|
|
|
|
// 직선으로 날려보낼 거리
|
|
protected float fDistance;
|
|
// 날라가는 시간, 딜레이 시간
|
|
protected float fTime, fDelayTime;
|
|
protected float fx = 0, fy = 0;
|
|
protected int iSplit;
|
|
private Vector3[] SavePos = new Vector3[13];
|
|
#endregion Variables
|
|
|
|
protected void LateUpdate()
|
|
{
|
|
if (bTrace && trfTrace != null)
|
|
transform.position = trfTrace.position;
|
|
}
|
|
|
|
#region Init
|
|
// 초기화.
|
|
public void Init(BattleMgr mgr)
|
|
{
|
|
battleMgr = mgr;
|
|
skAnims = transform.GetComponentsInChildren<SkeletonAnimation>(true);
|
|
asEffects = transform.GetComponentsInChildren<AudioSource>(true);
|
|
ptcEffects = transform.GetComponentsInChildren<ParticleSystem>(true);
|
|
|
|
twcShots = new TweenerCore<Vector3, Vector3, VectorOptions>[trfShots.Length];
|
|
iTargets = new List<int>();
|
|
}
|
|
|
|
// 사거리 가져오기.
|
|
public int GetRange()
|
|
{
|
|
return iRange / dConst.RangeDivide;
|
|
}
|
|
#endregion Init
|
|
|
|
#region SetOption
|
|
// 상태이상.
|
|
public void SetDebuff(BigInteger bivalue, float ftime)
|
|
{
|
|
biDebuffValue = bivalue;
|
|
fDebuffTime = ftime;
|
|
}
|
|
|
|
public void MoveToShotPos(int ishotNum)
|
|
{
|
|
if (transform.Find("trfObject") != null)
|
|
trfObject = transform.Find("trfObject");
|
|
|
|
trfObject.position = trfShots[ishotNum].position;
|
|
}
|
|
|
|
public void SetTransform()
|
|
{
|
|
for (int i = 0; i < trfShots.Length; i++)
|
|
{
|
|
trfShots[i].position = trfShotStart.position + Vector3.up * 4f;
|
|
trfShots[i].gameObject.SetActive(true);
|
|
}
|
|
}
|
|
|
|
public void SetSplit(int isplit)
|
|
{
|
|
iSplit = isplit;
|
|
}
|
|
|
|
public void SetDistance(float fdt)
|
|
{
|
|
fDistance = fdt;
|
|
}
|
|
|
|
public void SetBulletTime(float ftime)
|
|
{
|
|
fTime = ftime;
|
|
}
|
|
|
|
public void SetDelayTime(float ftime)
|
|
{
|
|
fDelayTime = ftime;
|
|
}
|
|
|
|
public void SetX(float x)
|
|
{
|
|
fx = x;
|
|
}
|
|
|
|
public void SetY(float y)
|
|
{
|
|
fy = y;
|
|
}
|
|
|
|
public void setDistanceRandom()
|
|
{
|
|
fDistance = Random.Range(5, 12);
|
|
}
|
|
|
|
public void setFront()
|
|
{
|
|
bfront = battleMgr.GetIsFront(bFriendlySkill);
|
|
ChangeFront(bfront);
|
|
}
|
|
|
|
public void setSummonAttackInterval(float finterval)
|
|
{
|
|
fSummonInterval = finterval;
|
|
}
|
|
|
|
public void StartFade(int inum)
|
|
{
|
|
if(useFrom == 0)
|
|
{
|
|
if (inum > 0)
|
|
battleMgr.SkillFade(true);
|
|
else
|
|
battleMgr.SkillFade(false);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Base Method
|
|
private void ChangeFront(bool bFrontRight)
|
|
{
|
|
if (bFrontRight)
|
|
{
|
|
transform.localScale = Global.V3_1;
|
|
}
|
|
else
|
|
{
|
|
transform.localScale = Global.V3_1XRev;
|
|
}
|
|
}
|
|
|
|
protected IEnumerator PlaySkill()
|
|
{
|
|
float elapsed = 0f;
|
|
|
|
int currentSequenceIndex = 0;
|
|
float offset = 0f;
|
|
|
|
while(elapsed < fPlayTime)
|
|
{
|
|
if(currentSequenceIndex < skillSequences.Length)
|
|
{
|
|
var sequence = skillSequences[currentSequenceIndex];
|
|
|
|
if (offset + sequence.time <= elapsed)
|
|
{
|
|
sequence.method?.Invoke();
|
|
offset += sequence.time;
|
|
++currentSequenceIndex;
|
|
}
|
|
}
|
|
|
|
elapsed += Time.deltaTime;
|
|
yield return null;
|
|
}
|
|
|
|
iTarget = -1;
|
|
playSkillCoroutine = null;
|
|
gameObject.SetActive(false);
|
|
}
|
|
|
|
public void StopSkill()
|
|
{
|
|
if (!IsPlaying) return;
|
|
|
|
StopCoroutine(playSkillCoroutine);
|
|
|
|
for (int i = 0; i < skAnims.Length; ++i)
|
|
{
|
|
skAnims[i].enabled = false;
|
|
}
|
|
|
|
for (int i = 0; i < trfShots.Length; ++i)
|
|
{
|
|
if (twcShots[i] != null && twcShots[i].IsPlaying())
|
|
twcShots[i].Pause();
|
|
|
|
trfShots[i].gameObject?.SetActive(false);
|
|
}
|
|
|
|
for (int i = 0; i < ptcEffects.Length; ++i)
|
|
{
|
|
ptcEffects[i]?.Stop();
|
|
}
|
|
|
|
for (int i = 0; i < asEffects.Length; ++i)
|
|
{
|
|
asEffects[i]?.Stop();
|
|
}
|
|
|
|
iTarget = -1;
|
|
playSkillCoroutine = null;
|
|
gameObject.SetActive(false);
|
|
}
|
|
#endregion Base Method
|
|
|
|
#region Control Method
|
|
// 애니메이션 재생.
|
|
public void PlayAnimation(int index)
|
|
{
|
|
if (index < 0 || index >= skAnims.Length)
|
|
return;
|
|
skAnims[index].enabled = true;
|
|
skAnims[index].AnimationState.SetAnimation(0, "animation", false);
|
|
}
|
|
|
|
public void SetAnimation(string name)
|
|
{
|
|
if(skAnims[0] != null)
|
|
{
|
|
skAnims[0].enabled = true;
|
|
if(name == "idle")
|
|
skAnims[0].AnimationState.SetAnimation(0, "idle", true);
|
|
else if (name == "move")
|
|
skAnims[0].AnimationState.SetAnimation(0, "move", true);
|
|
else
|
|
skAnims[0].AnimationState.SetAnimation(0, name, false);
|
|
}
|
|
}
|
|
|
|
// 사운드 재생.
|
|
public void PlaySound(int index)
|
|
{
|
|
if (index < 0 || index >= asEffects.Length)
|
|
return;
|
|
if (SoundMgr.EfcOn)
|
|
{
|
|
asEffects[index].Play();
|
|
}
|
|
}
|
|
|
|
// 사운드 랜덤 재생.
|
|
public void PlaySoundRandom(int istartindex)
|
|
{
|
|
if (SoundMgr.EfcOn)
|
|
{
|
|
int index = Random.Range(istartindex, asEffects.Length);
|
|
asEffects[index].Play();
|
|
}
|
|
}
|
|
|
|
// 카메라 흔들기.
|
|
public void ShakeCamera1(float fstrength)
|
|
{
|
|
IVCameraController.SShakeCamera(0.1f, fstrength);
|
|
}
|
|
|
|
// 카메라 흔들기.
|
|
public void ShakeCamera3(float fstrength)
|
|
{
|
|
IVCameraController.SShakeCamera(0.3f, fstrength);
|
|
}
|
|
|
|
// 카메라 흔들기.
|
|
public void ShakeCamera5(float fstrength)
|
|
{
|
|
IVCameraController.SShakeCamera(0.5f, fstrength);
|
|
}
|
|
|
|
// 카메라 흔들기.
|
|
public void ShakeCamera10(float fstrength)
|
|
{
|
|
IVCameraController.SShakeCamera(1f, fstrength);
|
|
}
|
|
#endregion Control Method
|
|
|
|
#region Shot Method
|
|
public void SetBullet()
|
|
{
|
|
for (int i = 0; i < bullets.Length; ++i)
|
|
{
|
|
bullets[i].SetStatus(battleMgr, biDmg, fCrtDam, iCrtRate, idNumber, iDamCnt, ShakeStrength, iVibrato, useFrom);
|
|
}
|
|
}
|
|
|
|
// 직선으로 발사 메서드를 사용하기 전에, SetDistance를 가장 먼저 시퀀스에 포함시켜 날려보낼 거리를 할당필요
|
|
// 직선으로 발사
|
|
public void ShotToFront(float ftime)
|
|
{
|
|
if (iTarget < 0 || twcShots.Length < 1)
|
|
return;
|
|
|
|
Vector3 v3endpos = battleMgr.GetTargetPos(bFriendlySkill, iTarget);
|
|
|
|
Vector3 v3driection = (v3endpos - trfShotStart.position).normalized;
|
|
v3endpos = trfShotStart.position + v3driection * fDistance;
|
|
trfShots[0].position = trfShotStart.position;
|
|
trfShots[0].right = v3driection;
|
|
trfShots[0].gameObject.SetActive(true);
|
|
twcShots[0] = trfShots[0].DOMove(v3endpos, ftime).SetEase(Ease.Linear).SetAutoKill(true);
|
|
}
|
|
|
|
private IEnumerator ShotToAngle(float ftime)
|
|
{
|
|
float sum = 0f;
|
|
float addAngle = 360f / trfShots.Length;
|
|
Vector3 direction;
|
|
Vector3 dir = Vector3.left;
|
|
for (int i = 0; i < trfShots.Length; i++)
|
|
{
|
|
trfShots[i].position = trfShotStart.position;
|
|
trfShots[i].gameObject.SetActive(true);
|
|
direction = Quaternion.Euler(0, 0, sum) * dir;
|
|
twcShots[i] = trfShots[i].DOMove(trfShotStart.position + direction * fDistance, ftime).SetEase(Ease.Linear).SetAutoKill(true);
|
|
trfShots[i].rotation = Quaternion.Euler(0, 0, sum);
|
|
yield return YieldInstructionCache.WaitForSeconds(0.02f);
|
|
sum += -addAngle;
|
|
}
|
|
}
|
|
|
|
public void ShotToAngleDelay(float ftime)
|
|
{
|
|
for(int i = 0; i < trfShots.Length; i++)
|
|
{
|
|
trfShots[i].gameObject.SetActive(false);
|
|
}
|
|
StartCoroutine(ShotToAngle(ftime));
|
|
}
|
|
|
|
public void ThrowToTarget(float ftime)
|
|
{
|
|
Vector3 v3endpos;
|
|
|
|
trfShots[0].position = trfShotStart.position;
|
|
|
|
if (useFrom == 0)
|
|
v3endpos = battleMgr.GetTargetPos(true, battleMgr.GetTargetIndex(true));
|
|
else
|
|
v3endpos = battleMgr.GetPlayer().transform.position;
|
|
|
|
float fdt = Vector3.Distance(trfShotStart.position, battleMgr.GetTargetPos(true, battleMgr.GetTargetIndex(true)));
|
|
trfShots[0].rotation = Quaternion.identity;
|
|
|
|
trfShots[0].DOJump(v3endpos, fdt*0.3f , 1,ftime).SetEase(Ease.OutCubic); // ftime
|
|
trfShots[0].DORotate(new Vector3(0, 0, Random.Range(120, 360)), 1f);
|
|
}
|
|
|
|
public void ThrowToFront(float ftime)
|
|
{
|
|
trfShots[0].position = trfShotStart.position;
|
|
Vector3 v3endpos;
|
|
|
|
if (battleMgr.GetIsFront(bFriendlySkill))
|
|
v3endpos = trfShotStart.position + (Vector3.right * fDistance);
|
|
else
|
|
v3endpos = trfShotStart.position + (Vector3.left * fDistance);
|
|
|
|
trfShots[0].DOJump(v3endpos, 4f, 1, ftime);
|
|
}
|
|
|
|
public void ThrowToRandom(float ftime)
|
|
{
|
|
StartCoroutine(ThrowToRandomDelay(ftime));
|
|
}
|
|
|
|
public IEnumerator ThrowToRandomDelay(float ftime)
|
|
{
|
|
for (int i = 0; i < trfShots.Length; i++)
|
|
{
|
|
trfShots[i].position = trfShotStart.position;
|
|
Vector3 v3endpos;
|
|
//Quaternion v3endrot;
|
|
|
|
v3endpos = trfShots[i].position + Random.insideUnitSphere * Random.Range(8, 15);
|
|
trfShots[i].rotation = Quaternion.identity;
|
|
//v3endrot = Quaternion.Euler());
|
|
|
|
trfShots[i].DOJump(v3endpos, 4f, 1, ftime);//.SetEase(Ease.InQuad);
|
|
trfShots[i].DORotate(new Vector3(0, 0, Random.Range(120, 360)), 1f);
|
|
yield return YieldInstructionCache.WaitForSeconds(0.1f);
|
|
}
|
|
}
|
|
|
|
public void ThrowToRandomChain(float ftime)
|
|
{
|
|
for(int i = 1; i < sprShotItems.Length; i++)
|
|
{
|
|
sprShotItems[i].enabled = false;
|
|
}
|
|
|
|
trfShots[0].position = trfShotStart.position;
|
|
|
|
SavePos[0] = battleMgr.GetTargetPos(true,battleMgr.GetTargetIndex(true));
|
|
trfShots[0].rotation = Quaternion.identity;
|
|
|
|
trfShots[0].DOJump(SavePos[0], 2f, 1, 0.5f); // ftime
|
|
trfShots[0].DORotate(new Vector3(0, 0, Random.Range(120, 360)), 1f);
|
|
|
|
|
|
StartCoroutine(ThrowToRandomChainRepeat(1, ftime));
|
|
}
|
|
|
|
public IEnumerator ThrowToRandomChainRepeat(int icnt, float ftime)
|
|
{
|
|
yield return new WaitForSeconds(0.5f);
|
|
|
|
ftime *= 0.5f;
|
|
|
|
int saveCnt = 0;
|
|
int splitNum = 2;
|
|
int throwCnt = iSplit;
|
|
|
|
for (int i = icnt; i < trfShots.Length; i++)
|
|
{
|
|
sprShotItems[i].enabled = true;
|
|
trfShots[i].position = SavePos[(i-1)/ iSplit];
|
|
SavePos[i] = trfShots[i].position + Random.insideUnitSphere * Random.Range((12 / splitNum) + 2, (14 / splitNum) + 2);
|
|
trfShots[i].rotation = Quaternion.identity;
|
|
trfShots[i].DOMove(SavePos[i],ftime);
|
|
trfShots[i].DORotate(new Vector3(0, 0, Random.Range(120, 360)), 1f);
|
|
|
|
saveCnt++;
|
|
|
|
if (i >= throwCnt)
|
|
{
|
|
yield return new WaitForSeconds(ftime);
|
|
for(int j = 0; j < throwCnt; j++)
|
|
{
|
|
sprShotItems[j].enabled = false;
|
|
}
|
|
throwCnt = iSplit + throwCnt* iSplit;
|
|
//ftime *= 0.5f;
|
|
splitNum++;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// 좌우 직선으로 발사 (대각선 x)
|
|
public void ShotToFrontHorizon(float ftime)
|
|
{
|
|
Vector3 v3endpos;
|
|
|
|
if (battleMgr.GetIsFront(bFriendlySkill))
|
|
v3endpos = trfShotStart.position + (Vector3.right * fDistance);
|
|
else
|
|
v3endpos = trfShotStart.position + (Vector3.left * fDistance);
|
|
|
|
trfShots[0].position = trfShotStart.position;
|
|
trfShots[0].gameObject.SetActive(true);
|
|
twcShots[0] = trfShots[0].DOMove(v3endpos, ftime).SetEase(Ease.Linear).SetAutoKill(true);
|
|
}
|
|
|
|
// 발사 메서드를 사용하기 전에, SetDistance를 가장 먼저 시퀀스에 포함시켜 날려보낼 거리를 할당필요
|
|
// 화면을 가로지르는 투사체 발사
|
|
|
|
private IEnumerator CrossScreenToTargetDelay(int icol, float fdelay)
|
|
{
|
|
Vector3 v3startpos, v3endpos, v3targetpos;
|
|
v3targetpos = trfShotStart.position + new Vector3(fx, fy, 0);
|
|
|
|
if (bfront)
|
|
{
|
|
v3startpos = v3targetpos + Vector3.left * fDistance;
|
|
v3endpos = v3targetpos + Vector3.right * fDistance;
|
|
}
|
|
else
|
|
{
|
|
v3startpos = v3targetpos + Vector3.right * fDistance;
|
|
v3endpos = v3targetpos + Vector3.left * fDistance;
|
|
}
|
|
|
|
trfShots[icol].position = v3startpos;
|
|
trfShots[icol].gameObject.SetActive(true);
|
|
yield return new WaitForSeconds(fdelay);
|
|
//skAnims[0].transform.position = new Vector3(skAnims[0].transform.position.x, trfShots[0].position.y, skAnims[0].transform.position.z);
|
|
twcShots[icol] = trfShots[icol].DOMove(v3endpos, fTime).SetEase(Ease.Linear).SetAutoKill(true);
|
|
}
|
|
public void CrossScreenToTarget(int icol)
|
|
{
|
|
if (iTarget < 0 || twcShots.Length < 1)
|
|
return;
|
|
|
|
StartCoroutine(CrossScreenToTargetDelay(icol, fDelayTime));
|
|
}
|
|
|
|
// 단일 타겟에게 발사.
|
|
public void ShotToTarget(float ftime)
|
|
{
|
|
iTarget = battleMgr.GetTargetIndexExcept(bFriendlySkill, iTarget);
|
|
if (iTarget < 0 || twcShots.Length < 1)
|
|
return;
|
|
Vector3 v3endpos = battleMgr.GetTargetPos(bFriendlySkill, iTarget);
|
|
trfShots[0].position = trfShotStart.position;
|
|
trfShots[0].gameObject.SetActive(true);
|
|
twcShots[0] = trfShots[0].DOMove(v3endpos, ftime).SetEase(Ease.OutQuint).SetAutoKill(true);
|
|
}
|
|
|
|
// 복수 타겟에게 발사.
|
|
public void ShotToTargets(float ftime)
|
|
{
|
|
int[] itargets;
|
|
Vector3[] v3endposes;
|
|
iTarget = battleMgr.GetTargetIndexExcept(bFriendlySkill, iTarget);
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
itargets = battleMgr.GetEnemyIndexes(twcShots.Length, iTarget);
|
|
v3endposes = battleMgr.GetEnemyPoses(itargets);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
itargets = battleMgr.GetFriendlyIndexes(twcShots.Length, iTarget);
|
|
v3endposes = battleMgr.GetFriendlyPoses();
|
|
}
|
|
|
|
for (int i = 0; i < itargets.Length; i++)
|
|
{
|
|
if (itargets[i] < 0)
|
|
{
|
|
trfShots[0].gameObject.SetActive(false);
|
|
continue;
|
|
}
|
|
iTargets.Add(itargets[i]);
|
|
trfShots[i].position = trfShotStart.position;
|
|
trfShots[i].gameObject.SetActive(true);
|
|
twcShots[i] = trfShots[i].DOMove(v3endposes[i], ftime).SetEase(Ease.Linear).SetAutoKill(true);
|
|
}
|
|
}
|
|
|
|
// 단일 타겟에게 발사 후 이어서 발사 및 데미지.
|
|
public void ShotToTargetTrain(float ftime)
|
|
{
|
|
if (iTarget < 0 || twcShots.Length < 1)
|
|
return;
|
|
|
|
iShot++;
|
|
trfShotStart.position = battleMgr.GetPlayer().transform.position;
|
|
Vector3 v3endpos = battleMgr.GetTargetPos(bFriendlySkill, iTarget);
|
|
|
|
trfShots[0].position = trfShotStart.position;
|
|
trfShots[0].gameObject.SetActive(true);
|
|
twcShots[0] = trfShots[0].DOMove(v3endpos, ftime).SetEase(Ease.Linear).SetAutoKill(false).OnComplete(ShotTrainDamage);
|
|
}
|
|
|
|
// 현재 타겟에게 데미지 후 다른 타겟에게 이어서 발사.
|
|
protected void ShotTrainDamage()
|
|
{
|
|
SendDamageSingle();
|
|
|
|
iShot++;
|
|
// 최대 횟수면 중지.
|
|
if (iShot > iMaxShot)
|
|
{
|
|
twcShots[0].Kill(false);
|
|
return;
|
|
}
|
|
|
|
// 다른 타겟 없으면 중지.
|
|
iTarget = battleMgr.GetTargetIndexExceptObj(trfShots[0].position, bFriendlySkill, iTarget);
|
|
float distance = BattleMgr.SCalcDistance(trfShots[0].position, battleMgr.GetTargetPos(true, iTarget));
|
|
if (iTarget < 0 || distance > 12)
|
|
{
|
|
twcShots[0].Kill(false);
|
|
StopSkill();
|
|
return;
|
|
}
|
|
|
|
// 위치 변경 후 다시 재생.
|
|
Vector3 v3endpos = battleMgr.GetTargetPos(bFriendlySkill, iTarget);
|
|
twcShots[0].ChangeValues(trfShots[0].position, v3endpos);
|
|
twcShots[0].Restart();
|
|
}
|
|
|
|
// 콜라이더 하나만 사용할 때 사용가능 콜라이더 범위안에 적에게 발사
|
|
private void ShotToBounds()
|
|
{
|
|
iTarget = battleMgr.GetTargetPosInBounds(bFriendlySkill, colliders[0].bounds);
|
|
if (transform.position.x > battleMgr.GetTargetPos(true,iTarget).x)
|
|
transform.localScale = Global.V3_1XRev;
|
|
else
|
|
transform.localScale = Global.V3_1;
|
|
|
|
if (battleMgr.GetTarget(true, iTarget) == null || battleMgr.GetTarget(true, iTarget).GetDie())
|
|
return;
|
|
|
|
if (iTarget < 0)
|
|
{
|
|
skAnims[0].timeScale = 1.0f;
|
|
if (skAnims[0].AnimationName != "idle")
|
|
{
|
|
SetAnimation("idle");
|
|
return;
|
|
}
|
|
}
|
|
|
|
skAnims[0].timeScale = 3.0f;
|
|
SetAnimation("attack");
|
|
|
|
SendDamageSingle();
|
|
}
|
|
|
|
public IEnumerator ShotToBoundsContinue(float ftime)
|
|
{
|
|
int icount = 0;
|
|
float itick = 0f;
|
|
while(icount < 100 && itick < ftime)
|
|
{
|
|
|
|
ShotToBounds();
|
|
icount++;
|
|
yield return new WaitForSeconds(0.2f);
|
|
itick += 0.2f;
|
|
|
|
if (itick >= ftime || icount >= 100)
|
|
StopCoroutine(nameof(ShotToBoundsContinue));
|
|
}
|
|
}
|
|
|
|
public void corShotToBoundsContinue(float ftime)
|
|
{
|
|
StartCoroutine(ShotToBoundsContinue(ftime));
|
|
}
|
|
#endregion Shot Method
|
|
|
|
|
|
#region Damage Method
|
|
|
|
public void SetSummon()
|
|
{
|
|
summon.SetStatus(biDmg, fCrtDam,iCrtRate, fPlayTime - 2f, battleMgr.GetPlayer().transform.position, idNumber, fSummonInterval);
|
|
}
|
|
|
|
public void SendDamage(CreatureBase target)
|
|
{
|
|
if (!target.IsBattleAvail()) return;
|
|
|
|
switch (debuff)
|
|
{
|
|
case eSkillDebuff.Stun: // 기절
|
|
target.SetStun(fDebuffTime);
|
|
break;
|
|
case eSkillDebuff.DecMove: // 둔화
|
|
target.SetDecMove(fDebuffTime, (float)BigInteger.Divide(biDebuffValue, dConst.RateMaxBi));
|
|
break;
|
|
case eSkillDebuff.Push: // 넉백
|
|
target.PushFrame((float)BigInteger.Divide(biDebuffValue, dConst.RateMaxBi));
|
|
break;
|
|
case eSkillDebuff.DamageSec:// 출혈
|
|
target.SetDamageSec(fDebuffTime, biDebuffValue, fCrtDam, iCrtRate, idNumber);
|
|
break;
|
|
}
|
|
|
|
target.GetDamage(biDmg, fCrtDam, iCrtRate);
|
|
}
|
|
|
|
// 전체 데미지.
|
|
public void SendDamageAll()
|
|
{
|
|
DebuffAll(debuff);
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.DamageToEnemyAll(biDmg, fCrtDam, iCrtRate);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.DamageToFriendly(biDmg, fCrtDam, iCrtRate);
|
|
}
|
|
}
|
|
|
|
// 단일 데미지.
|
|
public void SendDamageSingle()
|
|
{
|
|
DebuffSingle(debuff);
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.DamageToEnemy(iTarget, biDmg, fCrtDam, iCrtRate, shake : ShakeStrength, ivibrato : iVibrato, idnum: idNumber);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.DamageToFriendly(biDmg, fCrtDam, iCrtRate);
|
|
}
|
|
}
|
|
|
|
public void SendDamageMultiful()
|
|
{
|
|
for(int i = 0; i < iTargets.Count; i++)
|
|
{
|
|
DebuffSingle(debuff);
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.DamageToEnemy(iTargets[i], biDmg, fCrtDam, iCrtRate, idnum: idNumber);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.DamageToFriendly(biDmg, fCrtDam, iCrtRate);
|
|
}
|
|
}
|
|
iTargets.Clear();
|
|
}
|
|
|
|
// 범위 데미지.
|
|
public void SendDamageBounds(int boundindex)
|
|
{
|
|
if (boundindex >= colliders.Length)
|
|
return;
|
|
|
|
DebuffBounds(debuff, boundindex);
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.DamageToEnemy(colliders[boundindex].bounds, biDmg, fCrtDam, iCrtRate, idNumber, shake : ShakeStrength, ivibrato : iVibrato);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.DamageToFriendly(colliders[boundindex].bounds, biDmg, fCrtDam, iCrtRate);
|
|
}
|
|
}
|
|
|
|
public void SendDamageBoundsDt(int boundindex)
|
|
{
|
|
if (boundindex >= colliders.Length)
|
|
return;
|
|
|
|
DebuffBounds(debuff, boundindex);
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.DamageToEnemyDt(colliders[boundindex].bounds, biDmg, fCrtDam, iCrtRate, idNumber, shake: ShakeStrength, ivibrato: iVibrato, fdistance : fDistance);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.DamageToFreiendlyDt(colliders[boundindex].bounds, biDmg, fCrtDam, iCrtRate, fdistance: fDistance);
|
|
}
|
|
}
|
|
|
|
// 하나의 콜라이더만 사용할 때 사용 (몬스터를 관통하는 투사체류)
|
|
public void CorSendDamageBoundsContinue(float ftime)
|
|
{
|
|
StartCoroutine(SendDamageBoundsContinue(ftime));
|
|
}
|
|
|
|
private IEnumerator SendDamageBoundsContinue(float ftime)
|
|
{
|
|
float itick = 0f;
|
|
while(ftime > itick)
|
|
{
|
|
DebuffBounds(debuff, 0);
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.DamageToEnemy(colliders[0].bounds, biDmg, fCrtDam, iCrtRate, idNumber, shake : ShakeStrength, ivibrato: iVibrato);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.DamageToFriendly(colliders[0].bounds, biDmg, fCrtDam, iCrtRate);
|
|
}
|
|
yield return YieldInstructionCache.WaitForSeconds(0.2f);
|
|
}
|
|
}
|
|
|
|
// 하나의 콜라이더만 사용할 때 사용(몬스터를 관통하는 투사체류)
|
|
public void corSendDamageBoundsContinueNOL(float ftime)
|
|
{
|
|
StartCoroutine(SendDamageBoundsContinueNOL(ftime));
|
|
}
|
|
|
|
private IEnumerator SendDamageBoundsContinueNOL(float ftime)
|
|
{
|
|
float itick = 0f;
|
|
while (ftime > itick)
|
|
{
|
|
DebuffBounds(debuff, 0);
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.DamageToEnemy(colliders[0].bounds, biDmg, fCrtDam, iCrtRate, idNumber, iDamCnt, shake : ShakeStrength, ivibrato: iVibrato);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.DamageToFriendly(colliders[0].bounds, biDmg, fCrtDam, iCrtRate, iDamCnt);
|
|
}
|
|
yield return YieldInstructionCache.WaitForSeconds(0.1f);
|
|
}
|
|
}
|
|
|
|
public void SendDamageBoundsNonOverLapping(int boundindex)
|
|
{
|
|
if (boundindex >= colliders.Length)
|
|
return;
|
|
|
|
DebuffBounds(debuff, 0);
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.DamageToEnemy(colliders[boundindex].bounds, biDmg, fCrtDam, iCrtRate, iDamCnt, idNumber, shake : ShakeStrength, ivibrato: iVibrato);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.DamageToFriendly(colliders[boundindex].bounds, biDmg, fCrtDam, iCrtRate, iDamCnt);
|
|
}
|
|
}
|
|
|
|
// 위의 메서드 SendDamageBoundsNonOverLapping를 쓰기 전에 최초로 한번은 사용
|
|
public void AddDamCnt()
|
|
{
|
|
iDamCnt++;
|
|
}
|
|
#endregion Damage Method
|
|
|
|
#region Move Method
|
|
public void RushToEnemy(float fdt)
|
|
{
|
|
if(useFrom == 0)
|
|
battleMgr.RushToEnemy(fdt);
|
|
else
|
|
battleMgr.RushToEnemy(fdt, useFrom);
|
|
}
|
|
|
|
// 사용전 setDistance 설정 필요
|
|
public void RushToDir(int dir)
|
|
{
|
|
battleMgr.RushToDir(dir, fDistance, bfront);
|
|
}
|
|
#endregion
|
|
|
|
#region Debuff Method
|
|
public void DebuffSingle(eSkillDebuff eDebuff)
|
|
{
|
|
switch (eDebuff)
|
|
{
|
|
case eSkillDebuff.None: // 없음
|
|
break;
|
|
case eSkillDebuff.Stun: // 기절
|
|
DebuffStunSingle();
|
|
break;
|
|
case eSkillDebuff.DecMove: // 둔화
|
|
DebuffDecMovSingle();
|
|
break;
|
|
case eSkillDebuff.Push: // 넉백
|
|
DebuffPushSingle();
|
|
break;
|
|
case eSkillDebuff.DamageSec:// 출혈
|
|
DebuffDamageSecSingle();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void DebuffBounds(eSkillDebuff eDebuff, int boundsIndex)
|
|
{
|
|
switch (eDebuff)
|
|
{
|
|
case eSkillDebuff.None: // 없음
|
|
break;
|
|
case eSkillDebuff.Stun: // 기절
|
|
DebuffStunBounds(boundsIndex);
|
|
break;
|
|
case eSkillDebuff.DecMove: // 둔화
|
|
DebuffDecMovBounds(boundsIndex);
|
|
break;
|
|
case eSkillDebuff.Push: // 넉백
|
|
DebuffPushBounds(boundsIndex);
|
|
break;
|
|
case eSkillDebuff.DamageSec:// 출혈
|
|
DebuffDamageSecBounds(boundsIndex);
|
|
break;
|
|
case eSkillDebuff.Pull: // 끌어당기기
|
|
DebuffPushPullBounds(boundsIndex);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void DebuffAll(eSkillDebuff eDebuff)
|
|
{
|
|
switch (eDebuff)
|
|
{
|
|
case eSkillDebuff.None: // 없음
|
|
break;
|
|
case eSkillDebuff.Stun: // 기절
|
|
DebuffStunAll();
|
|
break;
|
|
case eSkillDebuff.DecMove: // 둔화
|
|
DebuffDecMovAll();
|
|
break;
|
|
case eSkillDebuff.Push: // 넉백
|
|
DebuffPushAll();
|
|
break;
|
|
case eSkillDebuff.DamageSec:// 출혈
|
|
DebuffDamageSecAll();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// 전체 둔화.
|
|
public void DebuffDecMovAll()
|
|
{
|
|
float fdebuffValue = (float)BigInteger.Divide(biDebuffValue, dConst.RateMaxBi);
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.DecMovToEnemyAll(fDebuffTime, fdebuffValue);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.DecMovToFriendlyAll(fDebuffTime, fdebuffValue);
|
|
}
|
|
}
|
|
|
|
// 단일 둔화.
|
|
public void DebuffDecMovSingle()
|
|
{
|
|
float fdebuffValue = (float)BigInteger.Divide(biDebuffValue, dConst.RateMaxBi);
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.DecMovToEnemy(iTarget, fDebuffTime, fdebuffValue);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.DecMovToFriendly(fDebuffTime, fdebuffValue);
|
|
}
|
|
}
|
|
|
|
// 범위 둔화.
|
|
public void DebuffDecMovBounds(int boundindex)
|
|
{
|
|
if (boundindex >= colliders.Length)
|
|
return;
|
|
|
|
float fdebuffValue = (float)BigInteger.Divide(biDebuffValue, dConst.RateMaxBi);
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.DecMovToEnemy(colliders[boundindex].bounds, fDebuffTime, fdebuffValue);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.DecMovToFriendly(colliders[boundindex].bounds, fDebuffTime, fdebuffValue);
|
|
}
|
|
}
|
|
|
|
// 전체 출혈.
|
|
public void DebuffDamageSecAll()
|
|
{
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.DamageSecToEnemyAll(fDebuffTime, biDebuffValue, fCrtDam, iCrtRate, idNumber);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.DamageSecToFriendlyAll(fDebuffTime, biDebuffValue, fCrtDam, iCrtRate);
|
|
}
|
|
}
|
|
|
|
// 단일 출혈.
|
|
public void DebuffDamageSecSingle()
|
|
{
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.DamageSecToEnemy(iTarget, fDebuffTime, biDebuffValue, fCrtDam, iCrtRate, idNumber);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.DamageSecToFriendly(fDebuffTime, biDebuffValue, fCrtDam, iCrtRate);
|
|
}
|
|
}
|
|
|
|
// 범위 출혈.
|
|
public void DebuffDamageSecBounds(int boundindex)
|
|
{
|
|
if (boundindex >= colliders.Length)
|
|
return;
|
|
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.DamageSecToEnemy(colliders[boundindex].bounds, fDebuffTime, biDebuffValue, fCrtDam, iCrtRate, iDamCnt, idNumber);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.DamageSecToFriendly(colliders[boundindex].bounds, fDebuffTime, biDebuffValue, fCrtDam, iCrtRate, iDamCnt);
|
|
}
|
|
}
|
|
|
|
// 전체 기절.
|
|
public void DebuffStunAll()
|
|
{
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.StunToEnemyAll(fDebuffTime);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.StunToFriendlyAll(fDebuffTime);
|
|
}
|
|
}
|
|
|
|
// 단일 기절.
|
|
public void DebuffStunSingle()
|
|
{
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.StunToEnemy(iTarget, fDebuffTime);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.StunToFriendly(fDebuffTime);
|
|
}
|
|
}
|
|
|
|
// 범위 기절.
|
|
public void DebuffStunBounds(int boundindex)
|
|
{
|
|
if (boundindex >= colliders.Length)
|
|
return;
|
|
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.StunToEnemy(colliders[boundindex].bounds, fDebuffTime);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.StunToFriendly(colliders[boundindex].bounds, fDebuffTime);
|
|
}
|
|
}
|
|
|
|
// 전체 넉백.
|
|
public void DebuffPushAll()
|
|
{
|
|
float fdebuffValue = (float)BigInteger.Divide(biDebuffValue, dConst.RateMaxBi);
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.PushToEnemyAll(fdebuffValue);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.PushToFriendlyAll(fdebuffValue);
|
|
}
|
|
}
|
|
|
|
// 단일 넉백.
|
|
public void DebuffPushSingle()
|
|
{
|
|
float fdebuffValue = (float)BigInteger.Divide(biDebuffValue, dConst.RateMaxBi);
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.PushToEnemy(iTarget, fdebuffValue, iDamCnt);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.PushToFriendly(fdebuffValue, iDamCnt);
|
|
}
|
|
}
|
|
|
|
// 범위 넉백.
|
|
public void DebuffPushBounds(int boundindex)
|
|
{
|
|
if (boundindex >= colliders.Length)
|
|
return;
|
|
|
|
float fdebuffValue = (float)BigInteger.Divide(biDebuffValue, dConst.RateMaxBi);
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.PushToEnemy(colliders[boundindex].bounds, fdebuffValue, iDamCnt);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.PushToFriendly(colliders[boundindex].bounds, fdebuffValue, iDamCnt);
|
|
}
|
|
}
|
|
|
|
// 범위 끌어당기기
|
|
public void DebuffPushPullBounds(int boundindex)
|
|
{
|
|
if (boundindex >= colliders.Length)
|
|
return;
|
|
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.PullToEnemy(colliders[boundindex].bounds, biDebuffValue, trfShots[boundindex]);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.PullToFriendly(colliders[boundindex].bounds, biDebuffValue, trfShots[boundindex]);
|
|
}
|
|
}
|
|
#endregion Debuff Method
|
|
|
|
|
|
#region Heal Method
|
|
// 전체 힐.
|
|
public void SendHealAll()
|
|
{
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.HealToFriendly(fRate);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.HealToEnemyAll(fRate);
|
|
}
|
|
}
|
|
|
|
// 단일 힐.
|
|
public void SendHealSingle()
|
|
{
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.HealToFriendly(fRate);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.HealToEnemy(iTarget, fRate);
|
|
}
|
|
}
|
|
|
|
// 범위 힐.
|
|
public void SendHealRange(int boundindex)
|
|
{
|
|
if (boundindex >= colliders.Length)
|
|
return;
|
|
|
|
// 아군이 사용한 스킬.
|
|
if (bFriendlySkill)
|
|
{
|
|
battleMgr.HealToFriendly(colliders[boundindex].bounds, fRate);
|
|
}
|
|
// 적이 사용한 스킬.
|
|
else
|
|
{
|
|
battleMgr.HealToEnemy(colliders[boundindex].bounds, fRate);
|
|
}
|
|
}
|
|
#endregion Heal Method
|
|
|
|
|
|
#region Start Skill
|
|
public void StartSkill(bool bfriendskill, float fcrtdam, int icrtrate, BigInteger biDmg, Transform trfuse, Transform trftarget, int itarget, bool bright)
|
|
{
|
|
switch (skillType)
|
|
{
|
|
// 시전자 위치에서 일정 범위에 데미지.
|
|
case eSkillType.RangeValueAtUse:
|
|
StartSkillRange(bfriendskill, trfuse.position, fcrtdam, icrtrate, biDmg, bright);
|
|
break;
|
|
// 타겟 위치에서 일정 범위에 데미지.
|
|
case eSkillType.RangeValueAtTarget:
|
|
StartSkillRange(bfriendskill, trftarget.position, fcrtdam, icrtrate, biDmg, bright);
|
|
break;
|
|
|
|
// 시전자를 따라다니며 일정 범위에 데미지.
|
|
case eSkillType.RangeValueTraceUse:
|
|
StartSkillRangeTrace(bfriendskill, trfuse, fcrtdam, icrtrate, biDmg, bright);
|
|
break;
|
|
|
|
// 타겟을 따라다니며 일정 범위에 데미지.
|
|
case eSkillType.RangeValueTraceTarget:
|
|
StartSkillRangeTrace(bfriendskill, trftarget, fcrtdam, icrtrate, biDmg, bright);
|
|
break;
|
|
|
|
// 시전자 위치에서 타겟에 데미지.
|
|
case eSkillType.OneValueAtUse:
|
|
StartSkillTarget(bfriendskill, trfuse.position, fcrtdam, icrtrate, biDmg, bright, itarget);
|
|
break;
|
|
|
|
// 타겟 위치에서 타겟에 데미지.
|
|
case eSkillType.OneValueAtTarget:
|
|
StartSkillTarget(bfriendskill, trftarget.position, fcrtdam, icrtrate, biDmg, bright, itarget);
|
|
break;
|
|
|
|
// 시전자를 따라다니며 타겟에 데미지.
|
|
case eSkillType.OneValueTraceUse:
|
|
StartSkillTargetTrace(bfriendskill, trfuse, fcrtdam, icrtrate, biDmg, bright, itarget);
|
|
break;
|
|
|
|
// 타겟을 따라다니며 타겟에 데미지.
|
|
case eSkillType.OneValueTraceTarget:
|
|
StartSkillTargetTrace(bfriendskill, trftarget, fcrtdam, icrtrate, biDmg, bright, itarget);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// 타겟 데미지.
|
|
protected void StartSkillTarget(bool bfriendskill, Vector3 v3pos, float fcrtdam, int icrtrate, BigInteger bidmg, bool bright, int itarget)
|
|
{
|
|
if (IsPlaying) return;
|
|
|
|
bFriendlySkill = bfriendskill;
|
|
fCrtDam = fcrtdam;
|
|
iCrtRate = icrtrate;
|
|
biDmg = bidmg;
|
|
iTarget = itarget;
|
|
iShot = 0;
|
|
|
|
transform.position = v3pos;
|
|
if (ptcEffects.Length == 0)
|
|
ChangeFront(bright);
|
|
gameObject.SetActive(true);
|
|
playSkillCoroutine = StartCoroutine(PlaySkill());
|
|
}
|
|
|
|
// 타겟 데미지(타겟 트레이스).
|
|
protected void StartSkillTargetTrace(bool bfriendskill, Transform trftrace, float fcrtdam, int icrtrate, BigInteger bidmg, bool bright, int itarget)
|
|
{
|
|
if (IsPlaying) return;
|
|
|
|
trfTrace = trftrace;
|
|
|
|
bFriendlySkill = bfriendskill;
|
|
fCrtDam = fcrtdam;
|
|
iCrtRate = icrtrate;
|
|
biDmg = bidmg;
|
|
iTarget = itarget;
|
|
iShot = 0;
|
|
|
|
transform.position = trftrace.position;
|
|
if (ptcEffects.Length == 0)
|
|
ChangeFront(bright);
|
|
gameObject.SetActive(true);
|
|
playSkillCoroutine = StartCoroutine(PlaySkill());
|
|
}
|
|
|
|
// 범위 데미지.
|
|
protected void StartSkillRange(bool bfriendskill, Vector3 v3pos, float fcrtdam, int icrtrate, BigInteger bidmg, bool bright)
|
|
{
|
|
if (IsPlaying) return;
|
|
|
|
bFriendlySkill = bfriendskill;
|
|
fCrtDam = fcrtdam;
|
|
iCrtRate = icrtrate;
|
|
biDmg = bidmg;
|
|
|
|
transform.position = v3pos;
|
|
if (ptcEffects.Length == 0)
|
|
ChangeFront(bright);
|
|
gameObject.SetActive(true);
|
|
playSkillCoroutine = StartCoroutine(PlaySkill());
|
|
}
|
|
|
|
// 범위 데미지(타겟 트레이스).
|
|
protected void StartSkillRangeTrace(bool bfriendskill, Transform trftrace, float fcrtdam, int icrtrate, BigInteger bidmg, bool bright)
|
|
{
|
|
if (IsPlaying) return;
|
|
|
|
trfTrace = trftrace;
|
|
|
|
bFriendlySkill = bfriendskill;
|
|
fCrtDam = fcrtdam;
|
|
iCrtRate = icrtrate;
|
|
biDmg = bidmg;
|
|
|
|
transform.position = trftrace.position;
|
|
if (ptcEffects.Length == 0)
|
|
ChangeFront(bright);
|
|
gameObject.SetActive(true);
|
|
playSkillCoroutine = StartCoroutine(PlaySkill());
|
|
}
|
|
#endregion Start Skill
|
|
|
|
}
|