Exemple #1
0
        public IEnumerator auto_play()
        {
            for (;;)
            {
                float time = MyRandom.Range(0.5f, 1f);
                float dir  = (float)((int)MyRandom.Range(0f, 8f)) * Mathf.PI * 0.25f;
                for (var i = new Utility.WaitForSeconds(time, update_time_); !i.end(update_time_);)
                {
                    autoplay_buttons_[(int)InputManager.Button.Horizontal] = (int)(Mathf.Cos(dir) * 128f);
                    autoplay_buttons_[(int)InputManager.Button.Vertical]   = (int)(Mathf.Sin(dir) * 128f);
                    if (MyRandom.ProbabilityForSecond(1f, SystemManager.Instance.getDT()))
                    {
                        autoplay_buttons_[(int)InputManager.Button.Fire] = 0;
                    }
                    else
                    {
                        autoplay_buttons_[(int)InputManager.Button.Fire] = 1;
                    }
                    if (MyRandom.ProbabilityForSecond(0.6f, SystemManager.Instance.getDT()))
                    {
                        autoplay_buttons_[(int)InputManager.Button.Roll] = MyRandom.Range(-1, 2);
                    }
                    yield return(null);

                    if (hit_wall_)
                    {
                        break;
                    }
                }
            }
        }
Exemple #2
0
        public IEnumerator zako_act()
        {
            rigidbody_.setDamper(2f);
            rigidbody_.setRotateDamper(2f);
            target_position_.x = MyRandom.Range(-20f, 20);
            target_position_.y = MyRandom.Range(-20f, 20);
            rigidbody_.addForceZ(40f);
            yield return(null);

            // for (var i = Utility.WaitForSeconds(10f, update_time_); i.MoveNext();) {
            for (var i = new Utility.WaitForSeconds(10f, update_time_); !i.end(update_time_);)
            {
                rigidbody_.addForceX(target_position_.x - rigidbody_.transform_.position_.x * 2f);
                rigidbody_.addForceY(target_position_.y - rigidbody_.transform_.position_.y * 2f);
                rigidbody_.addForceZ(10f);
                rigidbody_.addTorqueZ(-rigidbody_.velocity_.x * 1f);

                if (MyRandom.ProbabilityForSecond(1.5f, SystemManager.Instance.getDT()))
                {
                    var pos = Player.Instance.rigidbody_.transform_.position_;
                    pos.z += MyRandom.Range(-10f, 10f);
                    EnemyBullet.create(ref rigidbody_.transform_.position_,
                                       ref pos,
                                       50f /* speed */,
                                       update_time_);
                }

                if (phase_ == Phase.Dying)
                {
                    // for (var j = Utility.WaitForSeconds(0.1f, update_time_); j.MoveNext();) {
                    for (var j = new Utility.WaitForSeconds(0.1f, update_time_); j.end(update_time_);)
                    {
                        yield return(null);
                    }
                    break;
                }

                yield return(null);
            }
            destroy();
        }
Exemple #3
0
        public override void update(float dt, float update_time)
        {
            update_time_ = update_time;

            if (MyCollider.getHitOpponentForPlayer(collider_) != MyCollider.Type.None)
            {
                var pos = new Vector3(MyRandom.Range(-2f, 2f),
                                      MyRandom.Range(-2f, 2f),
                                      MyRandom.Range(-2f, 2f));
                HUD.Instance.setDamagePoint(ref pos);
            }

            if (Options.Instance.AutoPlay)
            {
                enumerator_.MoveNext();
            }

            int  hori        = getButton(InputManager.Button.Horizontal);
            int  vert        = getButton(InputManager.Button.Vertical);
            bool fire_button = getButton(InputManager.Button.Fire) > 0;
            int  lr          = getButton(InputManager.Button.Roll);

            roll_target_ += (float)(lr) * 150f * dt;
            roll_         = Mathf.Lerp(roll_, roll_target_, 0.1f);
            const float MOVE_FORCE   = 1f;
            const float CURSOR_FORCE = 6f;

            float sn = Mathf.Sin(roll_ * Mathf.Deg2Rad);
            float cs = Mathf.Cos(roll_ * Mathf.Deg2Rad);
            float vx = hori * cs - vert * sn;
            float vy = hori * sn + vert * cs;

            rigidbody_.addForceXY(vx * MOVE_FORCE, vy * MOVE_FORCE);
            target_cursor_.addForceXY(vx * CURSOR_FORCE, vy * CURSOR_FORCE);

            if (hori < 0)
            {
                pitch_acceleration_ += 2000f;
            }
            else if (hori > 0)
            {
                pitch_acceleration_ += -2000f;
            }

            // cursor update
            {
                // 外に向けさせない
                float x    = rigidbody_.transform_.position_.x + target_cursor_.transform_.position_.x;
                float y    = rigidbody_.transform_.position_.y + target_cursor_.transform_.position_.y;
                float len2 = x * x + y * y;
                float R    = 64f;
                if (len2 > Tube.RADIUS_SQR)
                {
                    R = 256f;
                }
                target_cursor_.addForceX(-target_cursor_.transform_.position_.x * R);
                target_cursor_.addForceY(-target_cursor_.transform_.position_.y * R);
                target_cursor_.update(dt);
            }

            // pitch
            pitch_acceleration_ += -pitch_ * 8f;          // spring
            pitch_acceleration_ += -pitch_velocity_ * 4f; // friction
            pitch_velocity_     += pitch_acceleration_ * dt;
            pitch_ += pitch_velocity_ * dt;
            pitch_acceleration_ = 0f;

            // rotate
            rigidbody_.transform_.rotation_ = Quaternion.LookRotation(target_cursor_.transform_.position_) * Quaternion.Euler(0, 0, pitch_);

            // update
            rigidbody_.update(dt);
            float radius = Tube.RADIUS - PLAYER_WIDTH2;

            if (rigidbody_.transform_.position_.sqrMagnitude >= radius * radius)
            {
                hit_wall_ = true;
                rigidbody_.cancelUpdateForTube(dt);
                if (MyRandom.ProbabilityForSecond(60f, SystemManager.Instance.getDT()))
                {
                    float x    = rigidbody_.transform_.position_.x;
                    float y    = rigidbody_.transform_.position_.y;
                    float z    = rigidbody_.transform_.position_.z;
                    float len  = Mathf.Sqrt(x * x + y * y);
                    float rlen = 1f / len;
                    float r    = rlen * Tube.RADIUS;
                    var   v    = new Vector3(x * r, y * r, z);
                    Spark.Instance.spawn(ref v, Spark.Type.Orange, update_time);
                }
            }
            else
            {
                hit_wall_ = false;
            }

            // collider
            MyCollider.updatePlayer(collider_, ref rigidbody_.transform_.position_);

            // fire bullets
            if (fire_button && update_time - fire_time_ > 0.06667f)
            {
                var lpos = rigidbody_.transform_.transformPosition(ref l_bullet_locator_);
                Bullet.create(ref lpos, ref rigidbody_.transform_.rotation_, 120f /* speed */, update_time);
                var rpos = rigidbody_.transform_.transformPosition(ref r_bullet_locator_);
                Bullet.create(ref rpos, ref rigidbody_.transform_.rotation_, 120f /* speed */, update_time);
                SystemManager.Instance.registSound(DrawBuffer.SE.Bullet);
                fire_time_ = update_time;
            }

            // fire missiles
            if (fire_button && !prev_fire_button_)                              // tmp
            {
                bool fired = LockTarget.fireMissiles(this);
                if (fired)
                {
                    SystemManager.Instance.registSound(DrawBuffer.SE.Missile);
                }
            }
            prev_fire_button_ = fire_button;

            // trail
            {
                float flow_z = -30f * dt;
                var   lpos   = rigidbody_.transform_.transformPosition(ref l_trail_locator_);
                Trail.Instance.update(l_trail_, ref lpos, flow_z, update_time);
                var rpos = rigidbody_.transform_.transformPosition(ref r_trail_locator_);
                Trail.Instance.update(r_trail_, ref rpos, flow_z, update_time);
            }
        }