private void AimTarget()
{
if (this.targetTransform != null)
{
base.angle = Utils2D.GetAngleFromTwoPosition(transform, this.targetTransform, Utils2D.AXIS.X_AND_Y);
}
}
private void AimTarget()
{
if (m_targetTransform == null && m_setTargetFromTag)
{
m_targetTransform = Utils2D.GetTransformFromTagName(m_targetTagName, m_randomSelectTagTarget);
}
if (m_targetTransform != null)
{
m_centerAngle = Utils2D.GetAngleFromTwoPosition(transform, m_targetTransform, Utils2D.AXIS.X_AND_Y);
}
}
public override void Shot()
{
if (m_targetTransform == null && m_setTargetFromTag)
{
m_targetTransform = Utils2D.GetTransformFromTagName(m_targetTagName, m_randomSelectTagTarget);
}
if (m_targetTransform == null)
{
Debug.LogWarning("Cannot shot because TargetTransform is not set.");
return;
}
m_holeCenterAngle = Utils2D.GetAngleFromTwoPosition(transform, m_targetTransform, Utils2D.AXIS.X_AND_Y);
base.Shot();
}
private IEnumerator ShotCoroutine()
{
if (m_bulletNum <= 0 || m_bulletSpeed <= 0f)
{
Debug.LogWarning("Cannot shot because BulletNum or BulletSpeed is not set.");
yield break;
}
if (m_shooting)
{
yield break;
}
m_shooting = true;
for (int i = 0; i < m_bulletNum; i++)
{
if (0 < i && 0f < m_betweenDelay)
{
FiredShot();
yield return(new WaitForSeconds(m_betweenDelay));
}
var bullet = GetBullet(transform.position);
if (bullet == null)
{
break;
}
if (m_targetTransform == null && m_setTargetFromTag)
{
m_targetTransform = Utils2D.GetTransformFromTagName(m_targetTagName, m_randomSelectTagTarget);
}
float angle = Utils2D.GetAngleFromTwoPosition(transform, m_targetTransform, Utils2D.AXIS.X_AND_Y);
ShotBullet(bullet, m_bulletSpeed, angle, true, m_targetTransform, m_homingAngleSpeed);
}
FiredShot();
FinishedShot();
yield break;
}
/// <summary>
/// Update Move
/// </summary>
public void UpdateMove(float deltaTime)
{
if (m_shooting == false)
{
return;
}
m_selfTimeCount += deltaTime;
// auto release check
if (m_useAutoRelease && m_autoReleaseTime > 0f)
{
if (m_selfTimeCount >= m_autoReleaseTime)
{
// Release
base.ReturnToPool();
return;
}
}
// pause and resume.
if (m_pauseAndResume && m_pauseTime >= 0f && m_resumeTime > m_pauseTime)
{
if (m_pauseTime <= m_selfTimeCount && m_selfTimeCount < m_resumeTime)
{
return;
}
}
Vector3 myAngles = m_transformCache.rotation.eulerAngles;
Quaternion newRotation = m_transformCache.rotation;
if (m_homing)
{
// homing target.
if (m_homingTarget != null && 0f < m_homingAngleSpeed)
{
float rotAngle = Utils2D.GetAngleFromTwoPosition(m_transformCache, m_homingTarget, m_axisMove);
float myAngle = 0f;
if (m_axisMove == Utils2D.AXIS.X_AND_Z)
{
// X and Z axis
myAngle = -myAngles.y;
}
else
{
// X and Y axis
myAngle = myAngles.z;
}
float toAngle = Mathf.MoveTowardsAngle(myAngle, rotAngle, deltaTime * m_homingAngleSpeed);
if (m_axisMove == Utils2D.AXIS.X_AND_Z)
{
// X and Z axis
newRotation = Quaternion.Euler(myAngles.x, -toAngle, myAngles.z);
}
else
{
// X and Y axis
newRotation = Quaternion.Euler(myAngles.x, myAngles.y, toAngle);
}
}
}
else if (m_wave)
{
// acceleration turning.
m_angle += (m_accelTurn * deltaTime);
// wave.
if (0f < m_waveSpeed && 0f < m_waveRangeSize)
{
float waveAngle = m_angle + (m_waveRangeSize / 2f * Mathf.Sin(m_selfFrameCnt * m_waveSpeed / 100f));
if (m_axisMove == Utils2D.AXIS.X_AND_Z)
{
// X and Z axis
newRotation = Quaternion.Euler(myAngles.x, m_baseAngle - waveAngle, myAngles.z);
}
else
{
// X and Y axis
newRotation = Quaternion.Euler(myAngles.x, myAngles.y, m_baseAngle + waveAngle);
}
}
m_selfFrameCnt += Time.deltaTime;
}
else
{
// acceleration turning.
float addAngle = m_accelTurn * deltaTime;
if (m_axisMove == Utils2D.AXIS.X_AND_Z)
{
// X and Z axis
newRotation = Quaternion.Euler(myAngles.x, myAngles.y - addAngle, myAngles.z);
}
else
{
// X and Y axis
newRotation = Quaternion.Euler(myAngles.x, myAngles.y, myAngles.z + addAngle);
}
}
// acceleration speed.
m_speed += (m_accelSpeed * deltaTime);
if (m_useMaxSpeed && m_speed > m_maxSpeed)
{
m_speed = m_maxSpeed;
}
if (m_useMinSpeed && m_speed < m_minSpeed)
{
m_speed = m_minSpeed;
}
// move.
Vector3 newPosition;
if (m_axisMove == Utils2D.AXIS.X_AND_Z)
{
// X and Z axis
newPosition = m_transformCache.position + (m_transformCache.forward * (m_speed * deltaTime));
}
else
{
// X and Y axis
newPosition = m_transformCache.position + (m_transformCache.up * (m_speed * deltaTime));
}
// set new position and rotation
m_transformCache.SetPositionAndRotation(newPosition, newRotation);
}
// Update Move
public void UpdateMove(float deltaTime)
{
if (this.isShooting == false)
{
return;
}
this.timeCount += deltaTime;
// auto release check
if (this.useDestroyAfterTime && this.destroyAfterTime > 0f)
{
if (this.timeCount >= this.destroyAfterTime && Vector3.Distance(this.transform.position, GameStateManager.Instance.game.player.transform.position) >= 6f)
{
// Release
this.DestroyBullet();
return;
}
}
// pause and resume.
if (this.pauseAndResume && this.pauseTime >= 0f && this.resumeTime > this.pauseTime)
{
if (this.pauseTime <= this.timeCount && this.timeCount < this.resumeTime)
{
return;
}
}
Vector3 myAngles = this.bulletTransform.rotation.eulerAngles;
Quaternion newRotation = this.bulletTransform.rotation;
if (this.isHoming)
{
// homing target.
if (this.homingTarget != null && 0f < this.homingAngleSpeed)
{
float rotAngle = Utils2D.GetAngleFromTwoPosition(bulletTransform, homingTarget, Utils2D.AXIS.X_AND_Y);
float myAngle = 0f;
myAngle = myAngles.z;
float toAngle = Mathf.MoveTowardsAngle(myAngle, rotAngle, deltaTime * homingAngleSpeed);
newRotation = Quaternion.Euler(myAngles.x, myAngles.y, toAngle);
}
}
else if (wave)
{
// acceleration turning.
this.angle += (this.accelTurn * deltaTime);
// wave.
if (0f < this.waveSpeed && 0f < this.waveRangeSize)
{
float waveAngle = angle + (waveRangeSize / 2f * Mathf.Sin(frameCount * waveSpeed / 100f));
newRotation = Quaternion.Euler(myAngles.x, myAngles.y, baseAngle + waveAngle);
}
this.frameCount += Time.deltaTime;
}
else
{
// acceleration turning.
float addAngle = this.accelTurn * deltaTime;
// X and Y axis
newRotation = Quaternion.Euler(myAngles.x, myAngles.y, myAngles.z + addAngle);
}
// acceleration speed.
this.speed += (this.accelSpeed * deltaTime);
if (this.useMaxSpeed && this.speed > this.maxSpeed)
{
this.speed = this.maxSpeed;
}
if (this.useMinSpeed && this.speed < this.minSpeed)
{
this.speed = this.minSpeed;
}
// move.
Vector3 newPosition;
newPosition = bulletTransform.position + (bulletTransform.up * (speed * deltaTime));
// set new position and rotation
bulletTransform.SetPositionAndRotation(newPosition, newRotation);
}
