コード例 #1
0
ファイル: TurretState.cs プロジェクト: jpann/MissileDefense
    public static Color GetStateColor(TurretState state)
    {
        Color color = Color.white;

        switch (state)
        {
            case TurretState.FULL:
                color = Color.white;
                break;
            case TurretState.SLIGHTLY_DAMAGED:
                color = new Color(253, 255, 184);
                break;
            case TurretState.DAMAGED:
                color = Color.yellow;
                break;
            case TurretState.MORE_DAMAGED:
                color = new Color(255, 136, 0);
                break;
            case TurretState.HEAVILY_DAMAGED:
                color = Color.red;
                break;
            case TurretState.DESTROYED:
                color = Color.grey;
                break;
        }

        return color;
    }
コード例 #2
0
 public void getTurretState()
 {
     if (currentTurretState == TurretState.ATTACK)
     {
         //10% under fiendens energi
         if (this.Energy + ((this.Energy / 100) * 10)  < eData.Energy)
             currentTurretState= TurretState.SAVEENERGY;
         else if (!isOnTarget)
             currentTurretState= TurretState.SCAN;
     }
     else if (currentTurretState == TurretState.SAVEENERGY)
     {
         // har mer energi
         if (this.Energy > eData.Energy)
             currentTurretState= TurretState.ATTACK;
         else if (!isOnTarget)
             currentTurretState= TurretState.SCAN;
     }
     else if (currentTurretState == TurretState.SCAN)
     {
         if (isOnTarget)
         {
             if (this.Energy + (this.Energy / 100) * 10 < eData.Energy)
                 currentTurretState= TurretState.SAVEENERGY;
             else
                 currentTurretState= TurretState.ATTACK;
         }
     }
 }
コード例 #3
0
 public AbstractTurret(int maxHealth, int attackDamage, float cooldown, int row, int column, float fireRate, int shotAmount, AreaOfEffect areaOfEffect, TurretState turretState)
     : base(maxHealth, attackDamage, cooldown, row, column)
 {
     FireRate = fireRate;
     maximumAmmo = shotAmount;
     CurrentAmmo = shotAmount;
     Cost = cost;
     this.areaOfEffect = areaOfEffect;
     this.turretState = turretState;
 }
コード例 #4
0
 public void ChangeTurretState(TurretState myTurretState)
 {
     switch (myTurretState)
     {
         case TurretState.active:
             break;
         case TurretState.spooking:
             break;
         case TurretState.recharging:
             break;
     }
 }
コード例 #5
0
 void firingState()
 {
     //Initialize the state if I'm just now entering.
     if (currentState != TurretState.FIRING)
     {
         framesInState = 0;
         timeInState   = 0.0f;
         if (debugMode)
         {
             Debug.Log("Entered firing State");
         }
         currentState = TurretState.FIRING;
         return;
     }
     else
     {
         cSlice.shoot(projectile, barrel.gameObject.transform.position, barrel.gameObject.transform.forward, barrel.gameObject.transform.rotation, false);
         coolingState();
         return;
     }
 }
コード例 #6
0
    void setState()
    {
        if (closeSomthing || dr.PlayerGetInSide || playOnce[4])     //  플레이어가 트리거 안으로 들어오면 무조건 디펜스 모드임 수색함
        {
            if (nearSomthing == null)
            {
                nearSomthing = dr.EnterThing;
            }

            TS = TurretState.DefenceMode;

            if (ctrlCorutain)
            {
                PlaySound("turret_CentreMode_Activated");
            }
        }
        else
        {
            timer[1] += Time.deltaTime;
            if (timer[1] > 10f)
            {
                timer[1] = 0f;
            }
            if (!closeSomthing && !dr.PlayerGetInSide)
            {
                TS = TurretState.Working;
                if (!isDetectTarget)
                {
                    PlaySound("turret_retire_1");
                }
            }
        }


        if (isDetectTarget)
        {
            Head.transform.DOKill();
            TS = TurretState.FindedTarget;
        }
    }
コード例 #7
0
    //Main turret behaviour states, can be overriden in inherited members to perform customizable function
    public virtual void TurretStates()
    {
        switch (turretState)
        {
        //Searching state
        case TurretState.searching:

            if (targets.Count != 0)
            {
                LookAtTarget();

                if (CurrentTarget)
                {
                    //Debug.Log("Target Acquired");
                    Vector3 Dir   = (CurrentTarget.transform.position - barrel.transform.position);
                    float   angle = Vector3.Angle(Dir, barrel.transform.forward);

                    //Debug.Log("angle is " + angle);
                    if (angle <= 5)
                    {
                        turretState = TurretState.firingtarget;
                    }
                }
            }
            else
            {
                //Debug.Log("Searching for target");
                CurrentTarget = null;
                SearchTarget();
            }
            break;

        case TurretState.firingtarget:

            //Debug.Log("Firing Target");
            FireAtTarget();
            //StartCoroutine(Countdown(1f));
            break;
        }
    }
コード例 #8
0
    /// <summary>
    ///
    /// </summary>
    /// <param name="target"></param>
    /// <param name="_fireNum"></param>
    public override void SetEnemy(Vector3 targetPosition, int _fireNum = 1)
    {
        if (gun == null)
        {
            return;
        }
        // 获取朝向向量
        Vector3 rot = Quaternion.LookRotation(targetPosition - gun.position).eulerAngles;

        turretRollTarget = rot.y;
        gunRollTarget    = rot.x;
        isTurretMove     = true;
        isGunMove        = true;
        enemyPos         = targetPosition;

        if (currentTurState == TurretState.Fire)
        {
            StopCoroutine("AttackIE");      // 停止当前的开火
        }
        fireNum         = _fireNum;
        currentTurState = TurretState.AimAt;
    }
コード例 #9
0
    /// <summary>
    /// 初始化炮弹
    /// </summary>
    /// <param name="_fireNum">弹药发射轮数</param>
    /// <returns></returns>
    IEnumerator AttackIE(int _fireNum)
    {
        if (ammunition == null)
        {
            StopCoroutine("AttackIE");
            yield return(null);
        }

        for (int i = 0; i < _fireNum; i++)
        {
            for (int j = 0; j < launch.Length; j++)
            {
                InitFirePower(launch[j], ammunition);
                yield return(new WaitForSeconds(0.2f));
            }
            yield return(new WaitForSeconds(2));
        }
        enemy           = null;
        currentTurState = TurretState.Reset;
        ResetState();

        yield return(null);
    }
コード例 #10
0
    // OnStateEnter is called when a transition starts and the state machine starts to evaluate this state
    override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
    {
        // set enemy sprites
        this.animator = animator;
        sp            = animator.GetComponent <TurretSP> ();
        state         = animator.GetComponentInChildren <TurretState> ();

        if (lineUpdate)
        {
            lineUpdate.EnableLine();
        }

        if (shoot)
        {
            shoot.StopShoot();
            UpdateTargetPos();
        }

        shooting = false;

        sp.SetEnemySprite();
        state.SetTargetsToPlayer();
    }
コード例 #11
0
        public void Update(List <Enemy> enemies, GameTime gameTime)
        {
            deltaTime = (float)(gameTime.ElapsedGameTime.TotalSeconds);
            fireRate += deltaTime;

            counter1++;

            if (counter1 > 10)
            {
                counter1 = 0;

                pickTarget(enemies);
            }

            if (target != null && target.Active)
            {
                SetAngle((int)target.Position.X, (int)target.Position.Y);

                if (fireRate >= 0.25f)
                {
                    fireRate = 0f;

                    target.TakeDamage(2);

                    //Bullet b = bullets.Dequeue();
                    //Shoot(target, b);
                    //bullets.Enqueue(b);
                }

                turretState = TurretState.firing;
            }
            else
            {
                turretState = TurretState.idle;
            }
        }
コード例 #12
0
ファイル: Tank.cs プロジェクト: ly774508966/hololens
    // Update is called once per frame
    private void Update()
    {
        if (m_dead)
        {
            // Wait until sounds have stopped playing then kill
            if (!m_audioSource.isPlaying)
            {
                Destroy(this.gameObject);
            }
            return;
        }

        // As soon as we enter the frame, start the lock-on sequence
        if (!m_lockIndicatorHelper.lockIndicator.IsActive() && m_lockIndicatorHelper.InViewFrustum(m_boxCollider.bounds))
        {
            //m_lockIndicatorHelper.lockIndicator.StartLockOnSequence();
        }

        // Animate turret
        Vector3 toPlayer = Camera.main.transform.position - transform.position;

        toPlayer.y = 0; // we only care about distance along ground plane
        float distanceToPlayer = Vector3.Magnitude(toPlayer);
        float now   = Time.time;
        float delta = now - m_t0;

        switch (m_state)
        {
        default:
            break;

        case TurretState.ScanningSleep:
            if (distanceToPlayer <= playerTrackingDistance)
            {
                m_state = TurretState.TrackingStart;
            }
            else if (now >= m_t1)
            {
                Vector3 old_angles = m_turret.localRotation.eulerAngles;
                Vector3 new_angles = old_angles;
                new_angles.y          = m_angles[Random.Range(0, m_angles.Length)];
                m_turretStartRotation = m_turret.localRotation;
                m_turretEndRotation   = Quaternion.Euler(new_angles);
                m_t0    = now;
                m_t1    = now + Mathf.Abs(new_angles.y - old_angles.y) / turretScanSpeed;
                m_state = TurretState.ScanningSweep;
            }
            break;

        case TurretState.ScanningSweep:
            if (distanceToPlayer <= playerTrackingDistance)
            {
                m_state = TurretState.TrackingStart;
            }
            else if (now < m_t1)
            {
                m_turret.localRotation = Quaternion.Slerp(m_turretStartRotation, m_turretEndRotation, delta / (m_t1 - m_t0));
            }
            else
            {
                m_t0    = now;
                m_t1    = now + 2;
                m_state = TurretState.ScanningSleep;
            }
            break;

        case TurretState.TrackingStart:
            if (distanceToPlayer > playerTrackingDistance)
            {
                m_state            = TurretState.TrackingEnd;
                m_gunStartRotation = m_gun.localRotation;
                m_gunEndRotation   = m_gunZeroRotation;
                m_t0 = now;
                m_t1 = now + 2;
            }
            else
            {
                /*
                 * Player position is transformed to turret-local space and then the
                 * direction to rotate at the tracking speed is determined using a
                 * cross product.
                 *
                 * We compare two vectors: turret aim direction and player in local
                 * YZ (X is the axis we rotate the turret about in its local space).
                 * The cross product produces a vector along X and the magnitude is:
                 * |aimVector|*|playerLocalYZ|*sin(angle) = 1*1*sin(angle) =
                 * sin(angle).
                 */
                Vector3 playerLocalPos = m_turret.transform.InverseTransformPoint(Camera.main.transform.position);
                Vector3 playerLocalYZ  = Vector3.Normalize(new Vector3(0, playerLocalPos.y, playerLocalPos.z));
                Vector3 aimVector      = Vector3.forward; // direction turret is pointing
                float   sinAngle       = Vector3.Cross(aimVector, playerLocalYZ).x;
                float   direction      = Mathf.Sign(sinAngle);
                if (Mathf.Abs(sinAngle) > Mathf.Sin(2 * Mathf.Deg2Rad))
                {
                    m_turret.Rotate(direction * Time.deltaTime * turretTrackingSpeed, 0, 0);
                }
                else
                {
                    // Raise gun
                    Vector3 targetAngles = m_gun.localRotation.eulerAngles;
                    targetAngles.z = maxGunAngle; // bone -- and gun -- axis is along x, so rotate about z
                    Quaternion targetElevation  = Quaternion.Euler(targetAngles);
                    Vector3    currentGunVector = m_gun.localRotation * Vector3.right;
                    Vector3    targetGunVector  = targetElevation * Vector3.right;
                    float      angleToTarget    = Mathf.Abs(Vector3.Angle(currentGunVector, targetGunVector));
                    float      time             = angleToTarget / turretScanSpeed;
                    m_gun.localRotation = Quaternion.Lerp(m_gun.localRotation, targetElevation, Time.deltaTime / time);
                }
            }
            break;

        case TurretState.TrackingEnd:
            // Lower gun then return to scanning
            if (now < m_t1)
            {
                m_gun.localRotation = Quaternion.Lerp(m_gunStartRotation, m_gunEndRotation, delta / (m_t1 - m_t0));
            }
            else
            {
                m_t1    = now + 1;
                m_state = TurretState.ScanningSleep;
            }
            break;
        }
    }
コード例 #13
0
    public void Heal(float amount)
    {
        this.Health = this.Health + amount;

        state = TurretStateManager.GetState(health);

        if (objSprite == null)
            return;

        objSprite.color = TurretStateManager.GetStateColor(state);
    }
コード例 #14
0
    public void TakeDamage(float amount)
    {
        //Debug.Log("TurretBarrelController:TakeDamage() - amount = " + amount);

        health -= amount;

        health = Mathf.Clamp(health, 0.0f, maxHealth);

        state = TurretStateManager.GetState(health);

        if (objSprite == null)
            return;

        objSprite.color = TurretStateManager.GetStateColor(state);

        GameInfoManager.Instance.IncrementDamageReceived(amount);
    }
コード例 #15
0
        void FSM()
        {
            switch (m_curTurretState)
            {
            case TurretState.idle:
                break;

            case TurretState.aiming:
                aimer.LookAt(m_target);
                float targetY = aimer.localEulerAngles.y;
                if (Mathf.Abs(transform.localEulerAngles.z - targetY) > 5f)
                {
                    transform.Rotate(Vector3.forward, rotateSpeed * Time.deltaTime * m_rotateDir);
                }
                else
                {
                    transform.localEulerAngles = new Vector3(0, 0, targetY);
                    m_curTurretState           = TurretState.attacking;
                }
                break;

            case TurretState.attacking:
                if (!m_target)
                {
                    m_curTurretState = TurretState.idle;
                    return;
                }
                if (m_canFire)
                {
                    GameObject go   = Instantiate(projectile, projectilePos[m_curBarrelIndex].position, projectilePos[m_curBarrelIndex].rotation) as GameObject;
                    Rigidbody  body = go.GetComponent <Rigidbody>();
                    body.velocity = go.transform.forward * muzzleSpeed;
                    m_canFire     = false;
                    m_curBarrelShot--;
                    if (m_curBarrelShot == 0)
                    {
                        m_curBarrelIndex++;
                        m_curBarrelShot = shotPerBarrel;
                        if (m_curBarrelIndex >= projectilePos.Length)
                        {
                            m_curBarrelIndex = 0;
                        }
                    }
                    if (m_curMagAmmo > 0)
                    {
                        m_curMagAmmo--;
                        if (m_curMagAmmo == 0)
                        {
                            m_curTurretState = TurretState.reloading;
                            m_timer          = 0f;
                        }
                    }
                }
                else
                {
                    if (m_timer < fireInterval)
                    {
                        m_timer += Time.deltaTime;
                        // Adjust shoot angle
                        aimer.LookAt(m_target);
                        float targetPosY = aimer.localEulerAngles.y;
                        if (Mathf.Abs(transform.localEulerAngles.z - targetPosY) > 5f)
                        {
                            transform.Rotate(Vector3.forward, rotateSpeed * Time.deltaTime * m_rotateDir);
                        }
                        else
                        {
                            transform.localEulerAngles = new Vector3(0, 0, targetPosY);
                            m_curTurretState           = TurretState.attacking;
                        }
                    }
                    else
                    {
                        m_timer   = 0f;
                        m_canFire = true;
                    }
                }
                break;

            case TurretState.reloading:
                if (m_timer < reloadTime)
                {
                    m_timer += Time.deltaTime;
                }
                else
                {
                    m_timer = 0f;
                    if (m_curMagCount > 0)
                    {
                        m_curMagCount--;
                        m_curMagAmmo     = magazineSize;
                        m_curTurretState = TurretState.aiming;
                        m_canFire        = true;
                        m_curBarrelIndex = 0;
                        m_curBarrelShot  = shotPerBarrel;
                    }
                    else if (m_curMagCount == -1)
                    {
                        m_curMagAmmo     = magazineSize;
                        m_curTurretState = TurretState.aiming;
                        m_canFire        = true;
                        m_curBarrelIndex = 0;
                        m_curBarrelShot  = shotPerBarrel;
                    }
                    else
                    {
                        m_curTurretState = TurretState.idle;
                    }
                }
                break;
            }
        }
コード例 #16
0
    // Update is called once per frame
    void Update()
    {
        RailgunTurretSFX.volume = PlayerPrefs.GetFloat("SFXVolume", 0.2f);

        if (target && !target.IsDead)
        {
            //aim at the target
            AimAtTarget();
        }



        switch (currentTurretState)
        {
        //the turret is neither charging up, nor firing, it is just there doing nothing, looking at the enemy (if there's one)
        case TurretState.Idle:

            //move on to next state if there is a target and we have waited long enough
            if (target && waitTimeCountdown <= 0)
            {
                //begin charging up!
                currentTurretState = TurretState.ChargingUp;

                //reset charging up duration
                chargingCountdown = chargingDuration;

                //set the trigger of the animator
                turretAnimator.SetTrigger("Charge");

                Debug.Log(currentTurretState.ToString());
            }
            else if (waitTimeCountdown > 0)
            {
                //countdown
                waitTimeCountdown -= Time.deltaTime;
            }

            break;

        //the turret is currently charging up a shot
        case TurretState.ChargingUp:

            //start the charging countdown
            chargingCountdown -= Time.deltaTime;

            if (chargingCountdown <= 0)
            {
                //reset the charging countdown
                chargingCountdown = chargingDuration;

                //move on to the firing state
                currentTurretState = TurretState.Firing;

                Debug.Log(currentTurretState.ToString());
            }

            break;

        case TurretState.Firing:

            /**
             * //start the firing countdown
             * firingCountdown -= Time.deltaTime;
             *
             * if (firingCountdown > 0)
             * {
             *  //our railgun beam will be able to damage enemies
             *  beam.canDamageEnemies = true;
             * }
             * else
             * {
             *  //stop firing and go back to idle state
             *  currentTurretState = TurretState.Idle;
             *
             *  //reset the firing countdown
             *  firingCountdown = firingDuration;
             *
             *  //set a cooldown time before it can charge up and fire again
             *  waitTimeCountdown = waitTimeBeforeCharging;
             *
             *  //our railgun beam will not be able to damage enemies
             *  beam.canDamageEnemies = false;
             *
             * }
             */

            //fire the railgun bullet
            FireRailgunBullet();

            //damage all enemies caught in the bullet
            foreach (EnemyController enemy in GetEnemiesInBeam())
            {
                if (enemy)
                {
                    enemy.Damage(damage);
                }
            }

            //go back to idle
            currentTurretState = TurretState.Idle;

            Debug.Log(currentTurretState.ToString());
            //reset wait duration
            waitTimeCountdown = waitTimeBeforeCharging;

            break;
        }
    }
コード例 #17
0
    /*
     *
     * ---------------------------------------------------------------------------------
     * Targeting State
     *
     */

    void targetingState()
    {
        if (currentState != TurretState.TARGETING)
        {
            framesInState = 0;
            timeInState   = 0.0f;
            if (debugMode)
            {
                Debug.Log("Entered targeting State");
            }
            currentState = TurretState.TARGETING;
            target       = null;
        }
        else
        {
            framesInState++;
            timeInState += Time.smoothDeltaTime;

            bool noTargets = true;
            foreach (Potential p in potentials)
            {
                try
                {
                    p.distance = (p.player.transform.position - this.transform.position).sqrMagnitude;
                    if (p.distance < targetingRange * targetingRange)
                    {
                        p.inRange      = true;
                        p.lastTimeSeen = Time.time;
                        p.timeInRange += Time.deltaTime;
                        noTargets      = false;
                    }
                    else
                    {
                        p.inRange = false;
                    }
                }
                catch (System.Exception e)
                {
                    e.ToString();
                }
            }

            if (noTargets && timeInState > coolingTime)
            {
                waitingState();
            }
            else if (noTargets)
            {
                wanderTurret();
            }
            else
            {
                foreach (Potential p in potentials)
                {
                    if (p.inRange)
                    {
                        if (target == null)
                        {
                            target = p;
                        }
                        else if (p.timeInRange * UnityEngine.Random.Range(0f, 1f) > target.timeInRange * UnityEngine.Random.Range(0f, 1f))
                        {
                            target = p;
                        }
                    }
                }
                turningState();
            }
        }
    }
コード例 #18
0
ファイル: Turret.cs プロジェクト: Swift-Yu/ShootGame3D
        void Update()
        {
            // Seek for detection
            if (state == TurretState.InRadarSeek && enableSeekTarget)
            {
                target = radar.GetTarget(cachedTransform, faction, true);

                // Target is found
                if (target != null)
                {
                    targetOldPosition = target.transform.position;
                    state             = TurretState.InAcquisition;
                    velocitySum       = Vector3.zero;
                    frameCount        = 1;
                }
                // Reset target position
                else
                {
                    float localHubYawAngle = hub.localEulerAngles.y > 180?hub.localEulerAngles.y - 360:hub.localEulerAngles.y;
                    float localAxisAngle   = axis.localEulerAngles.x > 180?axis.localEulerAngles.x - 360:axis.localEulerAngles.x;

                    // Yaw
                    if (hubRotation)
                    {
                        if (Mathf.Abs(localHubYawAngle) > speed * Time.deltaTime)
                        {
                            if (localHubYawAngle < 0)
                            {
                                hub.Rotate(Vector3.up * speed * Time.deltaTime, Space.Self);
                            }
                            else
                            {
                                hub.Rotate(Vector3.up * -speed * Time.deltaTime, Space.Self);
                            }
                        }
                    }

                    // Ptich
                    if (axisRotation)
                    {
                        if (Mathf.Abs(localAxisAngle) > speed * Time.deltaTime)
                        {
                            if (localAxisAngle < 0)
                            {
                                axis.Rotate(Vector3.left * -speed * Time.deltaTime, Space.Self);
                            }
                            else
                            {
                                axis.Rotate(Vector3.left * speed * Time.deltaTime, Space.Self);
                            }
                        }
                    }
                }
            }

            // Reach & track
            if (state != TurretState.InRadarSeek)
            {
                float distance = 0;
                // Target visible
                if (radar.fov.IsVisble(cachedTransform, target, out distance))
                {
                    float advance = 0;
                    if (weaponSpeed > 0)
                    {
                        advance = (distance / weaponSpeed);
                    }

                    // Target + velocity in range
                    Vector3 targetLookAt = target.transform.position + targetVelocity * advance;
                    if (radar.fov.InFov(cachedTransform, targetLookAt, out distance))
                    {
                        // In reach
                        if (state == TurretState.InAcquisition)
                        {
                            Vector2 globalAngle = MathH.GetDeltaAngle(cachedTransform, targetLookAt, axis.localPosition);

                            float localHubYawAngle = hub.localEulerAngles.y > 180?hub.localEulerAngles.y - 360:hub.localEulerAngles.y;
                            float localAxisAngle   = axis.localEulerAngles.x > 180?axis.localEulerAngles.x - 360:axis.localEulerAngles.x;

                            // Yaw
                            bool lockYaw = false;
                            if (hubRotation)
                            {
                                if (Mathf.Abs(globalAngle.y - localHubYawAngle) > speed * Time.deltaTime)
                                {
                                    if (localHubYawAngle < globalAngle.y)
                                    {
                                        hub.Rotate(Vector3.up * speed * Time.deltaTime, Space.Self);
                                    }
                                    else
                                    {
                                        hub.Rotate(Vector3.up * -speed * Time.deltaTime, Space.Self);
                                    }
                                }
                                else
                                {
                                    lockYaw = true;
                                }
                            }
                            else
                            {
                                lockYaw = true;
                            }

                            // Ptich
                            bool lockPitch = false;
                            if (axisRotation)
                            {
                                if (Mathf.Abs(globalAngle.x - localAxisAngle) > speed * Time.deltaTime)
                                {
                                    if (localAxisAngle < globalAngle.x)
                                    {
                                        axis.Rotate(Vector3.left * -speed * Time.deltaTime, Space.Self);
                                    }
                                    else
                                    {
                                        axis.Rotate(Vector3.left * speed * Time.deltaTime, Space.Self);
                                    }
                                }
                                else
                                {
                                    lockPitch = true;
                                }
                            }
                            else
                            {
                                lockPitch = true;
                            }

                            if (lockPitch && lockYaw)
                            {
                                state = TurretState.InPursue;
                            }
                        }
                        // In track
                        else
                        {
                            if (hubRotation)
                            {
                                hub.LookAt(targetLookAt);
                                hub.localRotation = Quaternion.Euler(new Vector3(0, hub.localRotation.eulerAngles.y, 0));
                            }

                            if (axisRotation)
                            {
                                axis.LookAt(targetLookAt);
                                axis.localRotation = Quaternion.Euler(new Vector3(axis.localRotation.eulerAngles.x, 0, 0));
                            }

                            launcher.Shoot(target);
                        }
                    }
                    else
                    {
                        launcher.StopShoot();
                        state = TurretState.InRadarSeek;
                        //targetOldPosition = Vector3.zero;
                    }
                }
                else
                {
                    launcher.StopShoot();
                    state = TurretState.InRadarSeek;
                    //targetOldPosition = Vector3.zero;
                }
            }
        }
コード例 #19
0
 // Use this for initialization
 public virtual void Start()
 {
     playerGameObjects  = new ArrayList();
     currentTurretState = TurretState.Idle;
 }
コード例 #20
0
ファイル: Turret.cs プロジェクト: Wingxvii/RTSGame
    protected override void BaseFixedUpdate()
    {
        float dist = Vector3.Distance(DroidManager.Instance.playerTarget.transform.position, this.transform.position);

        switch (state)
        {
        case TurretState.Idle:

            if (dist < visionRange)
            {
                state       = TurretState.IdleShooting;
                attackPoint = DroidManager.Instance.playerTarget;
            }
            break;

        case TurretState.IdleShooting:
            //look at

            if (dist < maxRange)
            {
                this.transform.LookAt(DroidManager.Instance.playerTarget.transform.position);

                if (currentAmno > 0)
                {
                    muzzle.Play();
                    if (!HitWall() && accuracy - (dist / 100.0f) > Random.Range(0.0f, 1.0f))
                    {
                        DroidManager.Instance.playerTarget.OnDamage(attackDamage);
                    }
                    currentAmno--;
                    state        = TurretState.Recoil;
                    reloadTimer += recoilRate;
                }
                else
                {
                    reloadTimer += reloadRate;
                    state        = TurretState.Reloading;
                }
            }
            else
            {
                state = TurretState.Idle;
            }
            break;

        case TurretState.TargetedShooting:
            //look at
            if (dist < maxRange)
            {
                this.transform.LookAt(DroidManager.Instance.playerTarget.transform.position);

                if (currentAmno > 0)
                {
                    muzzle.Play();

                    if (!HitWall() && accuracy - (dist / 100.0f) > Random.Range(0.0f, 1.0f))
                    {
                        DroidManager.Instance.playerTarget.OnDamage(attackDamage);
                    }
                    currentAmno--;
                    state        = TurretState.Recoil;
                    reloadTimer += recoilRate;
                }
                else
                {
                    reloadTimer += reloadRate;
                    state        = TurretState.Reloading;
                }
            }
            else
            {
                state = TurretState.Idle;
            }

            break;

        case TurretState.Recoil:
            //look at
            this.transform.LookAt(DroidManager.Instance.playerTarget.transform.position);

            if (reloadTimer <= 0.0f)
            {
                state = TurretState.IdleShooting;
            }
            break;

        case TurretState.Reloading:
            if (reloadTimer <= 0.0f)
            {
                currentAmno = 10;
                state       = TurretState.Idle;
            }
            break;
        }
    }
コード例 #21
0
 public void putToOverload()
 {
     state = TurretState.onOverload;
 }
コード例 #22
0
 void Start()
 {
     turretState = TurretState.LockingOn;
 }
コード例 #23
0
ファイル: Turret.cs プロジェクト: Wingxvii/RTSGame
 public void Reload()
 {
     reloadTimer += reloadRate;
     state        = TurretState.Reloading;
 }
コード例 #24
0
 public void ChangingTurretState(TurretState _newState)
 {
     ExitTurretState();
     turretState = _newState;
     EnterTurretState();
 }
コード例 #25
0
    void Update()
    {
        if (!m_health.IsAlive())
        {
            m_state = TurretState.IDLE;
        }

        switch (m_state)
        {
        case TurretState.IDLE:
            Vector3 topDir = Vector3.RotateTowards(top.transform.forward, idleTopTarget, idleTopSpeed * Mathf.Deg2Rad * Time.deltaTime, 0f);
            top.transform.rotation = Quaternion.LookRotation(topDir, Vector3.up);

            Vector3 barrelAngles = barrel.transform.localEulerAngles;
            float   newAngle     = barrelAngles.x;
            if (barrelAngles.x > idleBarrelAngle)
            {
                newAngle = Mathf.Max(barrelAngles.x - idleBarrelSpeed * Time.deltaTime, idleBarrelAngle);
            }
            else if (barrelAngles.x < idleBarrelAngle)
            {
                newAngle = Mathf.Min(barrelAngles.x + idleBarrelSpeed * Time.deltaTime, idleBarrelAngle);
            }
            barrelAngles.x = newAngle;
            barrel.transform.localEulerAngles = barrelAngles;

            if (!m_health.IsAlive())
            {
                break;
            }

            float      closestDist  = Mathf.Infinity;
            GameObject closestEnemy = null;
            foreach (GameObject enemy in GameObject.FindGameObjectsWithTag("Enemy"))
            {
                float sqrDist1 = Vector3.ProjectOnPlane(enemy.transform.position - transform.position, Vector3.up).sqrMagnitude;
                if (sqrDist1 <= engageDist * engageDist)
                {
                    if (sqrDist1 < closestDist)
                    {
                        closestDist  = sqrDist1;
                        closestEnemy = enemy;
                    }
                }
            }
            if (closestEnemy != null)
            {
                m_target         = closestEnemy;
                m_state          = TurretState.ATTACKING;
                m_lastAttackTime = Time.time - Random.Range(attackCooldown * .4f, attackCooldown * 0.65f);
            }

            break;

        case TurretState.ATTACKING:
            bool needNewTarget = false;
            if (m_target == null)
            {
                needNewTarget = true;
            }
            else
            {
                float sqrDist = Vector3.ProjectOnPlane(m_target.transform.position - transform.position, Vector3.up).sqrMagnitude;
                if (sqrDist > (engageDist + 5) * (engageDist + 5))
                {
                    needNewTarget = true;
                }
            }

            if (needNewTarget)
            {
                float      closestDist1  = Mathf.Infinity;
                GameObject closestEnemy1 = null;
                foreach (GameObject enemy in GameObject.FindGameObjectsWithTag("Enemy"))
                {
                    if (!enemy.GetComponent <Health>().IsAlive())
                    {
                        continue;
                    }

                    float sqrDist2 = Vector3.ProjectOnPlane(enemy.transform.position - transform.position, Vector3.up).sqrMagnitude;
                    if (sqrDist2 <= engageDist * engageDist)
                    {
                        if (sqrDist2 < closestDist1)
                        {
                            closestDist  = sqrDist2;
                            closestEnemy = enemy;
                        }
                    }
                }
                if (closestEnemy1 != null)
                {
                    m_target = closestEnemy1;
                }
                else
                {
                    m_target = null;
                    m_state  = TurretState.IDLE;
                }
            }

            if (m_target == null)
            {
                break;
            }

            //
            Vector3 targetDir      = m_target.transform.position - top.transform.position;
            Vector3 targetDirHoriz = targetDir;
            targetDirHoriz.y = 0f;
            Vector3 newTopDir = Vector3.Slerp(top.transform.forward, targetDirHoriz, 6f * Time.deltaTime);
            top.transform.rotation = Quaternion.LookRotation(newTopDir, Vector3.up);
            float targetAngle = Mathf.Asin(targetDir.y / targetDir.magnitude) * Mathf.Rad2Deg;
            targetAngle = 90f - targetAngle;
            barrel.transform.localEulerAngles = new Vector3(Mathf.Lerp(barrel.transform.localEulerAngles.x, targetAngle, 4f * Time.deltaTime), 0f, 0f);

            //
            if (Time.time > m_lastAttackTime + attackCooldown)
            {
                Timing.RunCoroutineSingleton(_AttackTarget(m_target), gameObject, "_AttackTarget", SingletonBehavior.Overwrite);
            }

            break;

        default:
            break;
        }
    }
コード例 #26
0
    public void TakeDamage(float amount)
    {
        Debug.Log("MinigunController:TakeDamage() - amount = " + amount);

        health -= amount;

        health = Mathf.Clamp(health, 0.0f, maxHealth);

        state = TurretStateManager.GetState(health);

        if (objSprite == null)
            return;

        UpdateSprite();
    }