public override void Shot()
{
if (m_bulletNum <= 0 || m_bulletSpeed <= 0f)
{
Debug.LogWarning("Cannot shot because BulletNum or BulletSpeed is not set.");
return;
}
m_holeCenterAngle = Utils2D.GetNormalizedAngle(m_holeCenterAngle);
float startAngle = m_holeCenterAngle - (m_holeSize / 2f);
float endAngle = m_holeCenterAngle + (m_holeSize / 2f);
float shiftAngle = 360f / (float)m_bulletNum;
for (int i = 0; i < m_bulletNum; i++)
{
float angle = shiftAngle * i;
if (startAngle <= angle && angle <= endAngle)
{
continue;
}
var bullet = GetBullet(transform.position);
if (bullet == null)
{
break;
}
ShotBullet(bullet, m_bulletSpeed, angle);
}
FiredShot();
FinishedShot();
}
private IEnumerator ShotCoroutine()
{
if (m_bulletNum <= 0 || m_bulletSpeed <= 0f || m_wayNum <= 0 || m_spiralWayNum <= 0)
{
Debug.LogWarning("Cannot shot because BulletNum or BulletSpeed or WayNum or SpiralWayNum is not set.");
yield break;
}
if (m_shooting)
{
yield break;
}
m_shooting = true;
float spiralWayShiftAngle = 360f / m_spiralWayNum;
int wayIndex = 0;
int spiralWayIndex = 0;
for (int i = 0; i < m_bulletNum; i++)
{
if (m_wayNum <= wayIndex)
{
wayIndex = 0;
spiralWayIndex++;
if (m_spiralWayNum <= spiralWayIndex)
{
spiralWayIndex = 0;
if (0f < m_nextLineDelay)
{
FiredShot();
yield return(new WaitForSeconds(m_nextLineDelay));
}
}
}
var bullet = GetBullet(transform.position);
if (bullet == null)
{
break;
}
float centerAngle = m_startAngle + (spiralWayShiftAngle * spiralWayIndex) + (m_shiftAngle * Mathf.Floor(i / m_wayNum));
float baseAngle = m_wayNum % 2 == 0 ? centerAngle - (m_betweenAngle / 2f) : centerAngle;
float angle = Utils2D.GetShiftedAngle(wayIndex, baseAngle, m_betweenAngle);
ShotBullet(bullet, m_bulletSpeed, angle);
wayIndex++;
}
FiredShot();
FinishedShot();
yield break;
}
private void AimTarget()
{
if (this.targetTransform != null)
{
base.angle = Utils2D.GetAngleFromTwoPosition(transform, this.targetTransform, Utils2D.AXIS.X_AND_Y);
}
}
private IEnumerator ShotCoroutine()
{
if (m_bulletNum <= 0 || m_bulletSpeed <= 0f || m_wayNum <= 0)
{
Debug.LogWarning("Cannot shot because BulletNum or BulletSpeed or WayNum is not set.");
yield break;
}
if (m_shooting)
{
yield break;
}
m_shooting = true;
int wayIndex = 0;
float bulletSpeed = m_bulletSpeed;
float shiftAngle = 0f;
for (int i = 0; i < m_bulletNum; i++)
{
if (m_wayNum <= wayIndex)
{
wayIndex = 0;
if (0f < m_nextLineDelay)
{
FiredShot();
yield return(new WaitForSeconds(m_nextLineDelay));
}
bulletSpeed += m_diffSpeed;
shiftAngle += m_shiftAngle;
}
var bullet = GetBullet(transform.position);
if (bullet == null)
{
break;
}
float baseAngle = m_wayNum % 2 == 0 ? m_centerAngle - (m_betweenAngle / 2f) : m_centerAngle;
float angle = Utils2D.GetShiftedAngle(wayIndex, baseAngle, m_betweenAngle) + shiftAngle;
ShotBullet(bullet, bulletSpeed, angle);
wayIndex++;
}
FiredShot();
FinishedShot();
yield break;
}
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_bulletNum <= 0 || m_bulletSpeed <= 0f || m_wayNum <= 0)
{
Debug.LogWarning("Cannot shot because BulletNum or BulletSpeed or WayNum is not set.");
return;
}
if (m_shooting)
{
return;
}
m_shooting = true;
int wayIndex = 0;
float bulletSpeed = m_bulletSpeed;
for (int i = 0; i < m_bulletNum; i++)
{
if (m_wayNum <= wayIndex)
{
wayIndex = 0;
bulletSpeed -= m_diffSpeed;
while (bulletSpeed <= 0)
{
bulletSpeed += Mathf.Abs(m_diffSpeed);
}
}
var bullet = GetBullet(transform.position);
if (bullet == null)
{
break;
}
float baseAngle = m_wayNum % 2 == 0 ? m_centerAngle - (m_betweenAngle / 2f) : m_centerAngle;
float angle = Utils2D.GetShiftedAngle(wayIndex, baseAngle, m_betweenAngle);
ShotBullet(bullet, bulletSpeed, angle);
wayIndex++;
}
FiredShot();
FinishedShot();
}
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();
}
void Build()
{
points = Utils2D.Constrain(points, threshold);
var polygon = Polygon2D.Contour(points.ToArray());
var vertices = polygon.Vertices;
if (vertices.Length < 3)
{
return; // error
}
var triangulation = new Triangulation2D(polygon, angle);
var go = Instantiate(prefab);
go.transform.SetParent(transform, false);
go.GetComponent <DemoMesh>().SetTriangulation(triangulation);
Clear();
}
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;
}
private IEnumerator ShotCoroutine()
{
if (base.bulletNum <= 0 || base.bulletSpeed <= 0f)
{
Debug.LogWarning("Cannot shot because BulletNum or BulletSpeed is not set.");
yield break;
}
if (base.isShooting)
{
yield break;
}
base.isShooting = true;
for (int i = 0; i < base.bulletNum; i++)
{
if (0 < i && 0f < this.betweenDelay)
{
FiredShot();
yield return(new WaitForSeconds(this.betweenDelay));
}
var bullet = GetBullet(transform.position);
if (bullet == null)
{
break;
}
float shootingAngle = Random.Range(0, 360);
if (Mathf.Abs(shootingAngle - prevAngle) <= this.minimumAngleDistance)
{
shootingAngle = Random.Range(0.0f, 1.0f) >= 0.5f ? shootingAngle + this.minimumAngleSeparation : shootingAngle - this.minimumAngleSeparation;
shootingAngle = Utils2D.GetNormalizedAngle(shootingAngle);
}
ShotBullet(bullet, bulletSpeed, shootingAngle);
this.prevAngle = shootingAngle;
}
FiredShot();
FinishedShot();
}
void Build()
{
if (points.Count < 3)
{
return;
}
points = Utils2D.Constrain(points, threshold);
if (points.Count < 3)
{
return;
}
teddy = new Teddy(points);
var mesh = teddy.Build(MeshSmoothingMethod.HC, 2, 0.2f, 0.75f);
var go = Instantiate(prefab);
go.transform.parent = transform;
var puppet = go.GetComponent <Puppet>();
puppet.SetMesh(mesh);
puppets.Add(puppet);
}
/// <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);
}