/// <summary>
/// Bullet Shot
/// </summary>
public void Shot(float speed, float angle, float accelSpeed, float accelTurn,
bool homing, Transform homingTarget, float homingAngleSpeed,
bool wave, float waveSpeed, float waveRangeSize,
bool pauseAndResume, float pauseTime, float resumeTime, UbhUtil.AXIS axisMove)
{
if (_Shooting)
{
return;
}
_Shooting = true;
StartCoroutine(MoveCoroutine(speed, angle, accelSpeed, accelTurn,
homing, homingTarget, homingAngleSpeed,
wave, waveSpeed, waveRangeSize,
pauseAndResume, pauseTime, resumeTime, axisMove));
}
/// <summary>
/// Bullet Shot
/// </summary>
public void Shot(UbhBaseShot parentBaseShot,
float speed, float angle, float accelSpeed, float accelTurn,
bool homing, Transform homingTarget, float homingAngleSpeed,
bool wave, float waveSpeed, float waveRangeSize,
bool pauseAndResume, float pauseTime, float resumeTime, UbhUtil.AXIS axisMove)
{
if (shooting)
{
return;
}
shooting = true;
m_parentBaseShot = parentBaseShot;
m_speed = speed;
m_angle = angle;
m_accelSpeed = accelSpeed;
m_accelTurn = accelTurn;
m_homing = homing;
m_homingTarget = homingTarget;
m_homingAngleSpeed = homingAngleSpeed;
m_wave = wave;
m_waveSpeed = waveSpeed;
m_waveRangeSize = waveRangeSize;
m_pauseAndResume = pauseAndResume;
m_pauseTime = pauseTime;
m_resumeTime = resumeTime;
m_axisMove = axisMove;
if (m_axisMove == UbhUtil.AXIS.X_AND_Z)
{
// X and Z axis
m_transformCache.SetEulerAnglesY(-m_angle);
}
else
{
// X and Y axis
m_transformCache.SetEulerAnglesZ(m_angle);
}
m_selfFrameCnt = 0f;
m_selfTimeCount = 0f;
}
/// <summary>
/// Bullet Shot
/// </summary>
public void Shot(UbhBaseShot parentBaseShot,
float speed, float angle, float accelSpeed, float accelTurn,
bool homing, Transform homingTarget, float homingAngleSpeed,
bool wave, float waveSpeed, float waveRangeSize,
bool pauseAndResume, float pauseTime, float resumeTime,
bool useAutoRelease, float autoReleaseTime,
UbhUtil.AXIS axisMove, bool inheritAngle)
{
if (m_shooting)
{
return;
}
m_shooting = true;
m_parentBaseShot = parentBaseShot;
m_speed = speed;
m_angle = angle;
m_accelSpeed = accelSpeed;
m_accelTurn = accelTurn;
m_homing = homing;
m_homingTarget = homingTarget;
m_homingAngleSpeed = homingAngleSpeed;
m_wave = wave;
m_waveSpeed = waveSpeed;
m_waveRangeSize = waveRangeSize;
m_pauseAndResume = pauseAndResume;
m_pauseTime = pauseTime;
m_resumeTime = resumeTime;
m_useAutoRelease = useAutoRelease;
m_autoReleaseTime = autoReleaseTime;
m_axisMove = axisMove;
m_baseAngle = 0f;
if (inheritAngle && m_parentBaseShot.lockOnShot == false)
{
if (m_axisMove == UbhUtil.AXIS.X_AND_Z)
{
// X and Z axis
m_baseAngle = m_parentBaseShot.shotCtrl.transform.eulerAngles.y;
}
else
{
// X and Y axis
m_baseAngle = m_parentBaseShot.shotCtrl.transform.eulerAngles.z;
}
}
if (m_axisMove == UbhUtil.AXIS.X_AND_Z)
{
// X and Z axis
m_transformCache.SetEulerAnglesY(m_baseAngle - m_angle);
}
else
{
// X and Y axis
m_transformCache.SetEulerAnglesZ(m_baseAngle + m_angle);
}
m_selfFrameCnt = 0f;
m_selfTimeCount = 0f;
}
IEnumerator MoveCoroutine(float speed, float angle, float accelSpeed, float accelTurn,
bool homing, Transform homingTarget, float homingAngleSpeed,
bool wave, float waveSpeed, float waveRangeSize,
bool pauseAndResume, float pauseTime, float resumeTime, UbhUtil.AXIS axisMove)
{
if (axisMove == UbhUtil.AXIS.X_AND_Z)
{
// X and Z axis
transform.SetEulerAnglesY(-angle);
}
else
{
// X and Y axis
transform.SetEulerAnglesZ(angle);
}
float selfFrameCnt = 0f;
float selfTimeCount = 0f;
while (true)
{
if (homing)
{
// homing target.
if (homingTarget != null && 0f < homingAngleSpeed)
{
float rotAngle = UbhUtil.GetAngleFromTwoPosition(transform, homingTarget, axisMove);
float myAngle = 0f;
if (axisMove == UbhUtil.AXIS.X_AND_Z)
{
// X and Z axis
myAngle = -transform.eulerAngles.y;
}
else
{
// X and Y axis
myAngle = transform.eulerAngles.z;
}
float toAngle = Mathf.MoveTowardsAngle(myAngle, rotAngle, UbhTimer.Instance.DeltaTime * homingAngleSpeed);
if (axisMove == UbhUtil.AXIS.X_AND_Z)
{
// X and Z axis
transform.SetEulerAnglesY(-toAngle);
}
else
{
// X and Y axis
transform.SetEulerAnglesZ(toAngle);
}
}
}
else if (wave)
{
// acceleration turning.
angle += (accelTurn * UbhTimer.Instance.DeltaTime);
// wave.
if (0f < waveSpeed && 0f < waveRangeSize)
{
float waveAngle = angle + (waveRangeSize / 2f * Mathf.Sin(selfFrameCnt * waveSpeed / 100f));
if (axisMove == UbhUtil.AXIS.X_AND_Z)
{
// X and Z axis
transform.SetEulerAnglesY(-waveAngle);
}
else
{
// X and Y axis
transform.SetEulerAnglesZ(waveAngle);
}
}
selfFrameCnt++;
}
else
{
// acceleration turning.
float addAngle = accelTurn * UbhTimer.Instance.DeltaTime;
if (axisMove == UbhUtil.AXIS.X_AND_Z)
{
// X and Z axis
transform.AddEulerAnglesY(-addAngle);
}
else
{
// X and Y axis
transform.AddEulerAnglesZ(addAngle);
}
}
// acceleration speed.
speed += (accelSpeed * UbhTimer.Instance.DeltaTime);
// move.
if (axisMove == UbhUtil.AXIS.X_AND_Z)
{
// X and Z axis
transform.position += transform.forward.normalized * speed * UbhTimer.Instance.DeltaTime;
}
else
{
// X and Y axis
transform.position += transform.up.normalized * speed * UbhTimer.Instance.DeltaTime;
}
yield return(0);
selfTimeCount += UbhTimer.Instance.DeltaTime;
// pause and resume.
if (pauseAndResume && pauseTime >= 0f && resumeTime > pauseTime)
{
while (pauseTime <= selfTimeCount && selfTimeCount < resumeTime)
{
yield return(0);
selfTimeCount += UbhTimer.Instance.DeltaTime;
}
}
}
}
/// <summary>
/// Get angle from two transforms position.
/// </summary>
public static float GetAngleFromTwoPosition(Transform fromTrans, Transform toTrans, UbhUtil.AXIS axisMove)
{
switch (axisMove)
{
case AXIS.X_AND_Y:
return(GetZangleFromTwoPosition(fromTrans, toTrans));
case AXIS.X_AND_Z:
return(GetYangleFromTwoPosition(fromTrans, toTrans));
default:
return(0f);
}
}