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); }