protected void ShotBullet(JIBulletController bullet, IEnumerator bulletMoveRoutine)
{
if (bullet == null)
{
return;
}
bullet.Shot(bulletMoveRoutine);
}
// The method for bullet movemnt
IEnumerator BulletMove(JIBulletController bullet, float angle)
{
Transform bulletTrans = bullet.transform;
float sectorRadius = m_sectorRadius;
float timeToReachEdge = m_timeToReachEdge;
float waitingTime = m_waitingTime;
float speedAfterWait = m_speedAfterWait;
float accelAfterWait = m_accelAfterWait;
float angleSpeedAfterWait = m_angleSpeedAfterWait;
if (bulletTrans == null)
{
Debug.LogWarning("The shooting bullet is not exist!");
yield break;
}
bulletTrans.SetEulerAnglesZ(angle - 90f);
Vector3 startPos = bulletTrans.position;
Vector3 endPos = startPos + new Vector3(Mathf.Cos(Mathf.Deg2Rad * angle), Mathf.Sin(Mathf.Deg2Rad * angle), 0) * sectorRadius;
float timer = 0f;
// Bullet movement before waiting
while (true)
{
float t = timer / timeToReachEdge;
t = Mathf.Clamp01(-(Mathf.Pow(t - 1f, 2f) - 1f)); // Pow2Out
bulletTrans.position = Vector3.Lerp(startPos, endPos, t);
timer += JITimer.Instance.DeltTime;
if (t >= 0.995f)
{
break;
}
yield return(null);
}
// Wait for a while
yield return(UbhUtil.WaitForSeconds(waitingTime));
// Bullet movemnt after waiting
while (true)
{
// turning.
float addAngle = angleSpeedAfterWait * JITimer.Instance.DeltTime;
bulletTrans.AddEulerAnglesZ(addAngle);
// acceleration speed
speedAfterWait += accelAfterWait * JITimer.Instance.DeltTime;
// move
bulletTrans.position += bulletTrans.up * speedAfterWait * JITimer.Instance.DeltTime;
yield return(0);
}
}
protected override void ShotMatrixBullet(JIBulletController bullet, float angle)
{
float length = 1 / Mathf.Sqrt(2) * m_RectWidth;
Vector3 destination = new Vector3(Mathf.Cos(Mathf.Deg2Rad * angle), Mathf.Sin(Mathf.Deg2Rad * angle)) * length;
destination += transform.position;
bullet.StartCoroutine(BulletMove(bullet, angle, destination));
bullet.OnBulletDestroy += StopAllCoroutOnBullet;
}
// Different from ShotBullet Method(in UbhBaseShot Class), it just care about bullet angle and speed
private void ShotChildBullet(JIBulletController bullet, float speed, float angle)
{
if (bullet == null)
{
return;
}
bullet.Shot(speed, angle, 0, 0,
false, null, 0, 0,
false, 0, 0,
false, 0, 0);
}
/// <summary>
/// Shot JIBulletController object.
/// </summary>
protected void ShotBullet(JIBulletController bullet, float speed, float angle,
bool homing = false, Transform homingTarget = null, float homingAngleSpeed = 0f, float maxHomingAngle = 0f,
bool wave = false, float waveSpeed = 0f, float waveRangeSize = 0f)
{
if (bullet == null)
{
return;
}
bullet.Shot(speed, angle, m_angleSpeed, m_accelerationSpeed,
homing, homingTarget, homingAngleSpeed, maxHomingAngle,
wave, waveSpeed, waveRangeSize,
m_usePauseAndResume, m_pauseTime, m_resumeTime);
}
IEnumerator BulletMove(JIBulletController bullet, float angle, Vector3 destination)
{
Transform bulletTrans = bullet.transform;
if (bulletTrans == null)
{
Debug.LogWarning("The shooting bullet is not exist!");
yield break;
}
bulletTrans.SetEulerAnglesZ(angle);
float timeToReachRect = m_timeToReachRectEdge;
float waitTime = m_waitingTime;
Rect bounceBound = m_bounceBound;
// Bullet movement before waiting.
float t = 0;
Vector3 moveDir = destination - bulletTrans.position;
Vector3 startPosition = bulletTrans.position;
while (true)
{
if (m_bindTransform)
{
startPosition = m_bindTransform.position;
}
t += JITimer.Instance.DeltTime / timeToReachRect;
bulletTrans.position = moveDir * t + startPosition;
if (t >= 0.995f)
{
break;
}
yield return(null);
}
// Wait for a while
yield return(UbhUtil.WaitForSeconds(waitTime));
// Get bounce shot component
var bounceShot = bulletTrans.GetComponentInChildren <LinearBounceShot>();
bounceShot.m_bounceBound = new Rect(bounceBound);
bounceShot.m_shotAngle = angle;
bounceShot.Shot();
}
// Note : Copy from LinearBounceShot script.
IEnumerator BulletMove(JIBulletController bullet, float angle)
{
Transform bulletTrans = bullet.transform;
float speed = m_bulletSpeed;
float accel = m_accelerationSpeed;
float angleSpeed = m_angleSpeed;
float maxBounceTimes = m_bounceTimes;
Rect bounceBound = m_bounceBound;
if (bulletTrans == null)
{
Debug.LogWarning("The shooting bullet is not exist!");
yield break;
}
bulletTrans.SetEulerAnglesZ(angle - 90);
int bounceTime = 0;
while (true)
{
// turning.
angle += angleSpeed * JITimer.Instance.DeltTime;
bulletTrans.SetEulerAnglesZ(angle - 90);
// acceleration speed
speed += accel * JITimer.Instance.DeltTime;
// move
Vector3 newPosition = bulletTrans.position + bulletTrans.up * speed * JITimer.Instance.DeltTime;
if (bounceBound.Contains(newPosition) || bounceTime >= maxBounceTimes)
{
bulletTrans.position = newPosition;
}
else // cross with edge
{
bulletTrans.position = LinearBounceShot.GetIntersectWithRect(bulletTrans.position, newPosition, ref bounceBound, ref angle);
bulletTrans.SetEulerAnglesZ(angle - 90);
bounceTime++;
}
yield return(0);
}
}
// The method for bullet move
IEnumerator BulletMove(JIBulletController bullet, float angle)
{
Transform bulletTrans = bullet.transform;
float bulletSpeed = m_bulletSpeed;
float accelerationSpeed = m_accelerationSpeed;
float angleSpeed = m_angleSpeed;
float addAngleAfterChangeDirection = m_AddAngleAfterChangeDirection;
float selfTimeCount = 0;
float pauseBeforeChangeDirection = m_PauseBeforeChangeDirection;
float bulletSpeedAfterChangeDir = m_BulletSpeedAfterChangeDir;
bool usePauseAndResume = m_usePauseAndResume;
float pauseTime = m_pauseTime;
float resumeTime = m_resumeTime;
if (bulletTrans == null)
{
Debug.LogWarning("The shooting bullet is not exist!");
yield break;
}
bulletTrans.SetEulerAnglesZ(angle);
while (true)
{
float addAngle = angleSpeed * JITimer.Instance.DeltTime;
bulletTrans.AddEulerAnglesZ(addAngle);
bulletSpeed += accelerationSpeed * JITimer.Instance.DeltTime;
bulletTrans.position += bulletTrans.up * bulletSpeed * JITimer.Instance.DeltTime;
yield return(0);
selfTimeCount += JITimer.Instance.DeltTime;
// When the speed == 0, shoot two other bullet
if (selfTimeCount > Mathf.Abs(bulletSpeed / accelerationSpeed))
{
yield return(UbhUtil.WaitForSeconds(pauseBeforeChangeDirection));
bulletSpeed = bulletSpeedAfterChangeDir;
var bulletUpper = GetBullet(bulletTrans.position, bulletTrans.rotation);
var bulletUnder = GetBullet(bulletTrans.position, bulletTrans.rotation);
if (bulletUpper == null || bulletUnder == null)
{
break;
}
ShotChildBullet(bulletUpper, bulletSpeed, angle + addAngleAfterChangeDirection);
ShotChildBullet(bulletUnder, bulletSpeed, angle - addAngleAfterChangeDirection);
AutoReleaseBulletGameObject(bulletUpper.gameObject);
AutoReleaseBulletGameObject(bulletUnder.gameObject);
BulletPool.Instance.ReleaseGameObject(bulletTrans.gameObject);
FinishedShot(this);
yield break;
}
// pause and resume.
if (usePauseAndResume && pauseTime >= 0f && resumeTime > pauseTime)
{
while (pauseTime <= selfTimeCount && selfTimeCount < resumeTime)
{
yield return(0);
selfTimeCount += JITimer.Instance.DeltTime;
}
}
}
}
private void StopAllCoroutOnBullet(JIBulletController bullet)
{
bullet.StopAllCoroutines();
}
protected override void ShotMatrixBullet(JIBulletController bullet, float angle)
{
bullet.StartCoroutine(BulletMove(bullet, angle));
bullet.OnBulletDestroy += StopAllCoroutOnBullet;
}
protected virtual void ShotMatrixBullet(JIBulletController bullet, float angle)
{
ShotBullet(bullet, m_bulletSpeed, angle);
}
