示例#1
0
    string AmmoInfo(Gun rw, int firingModeIndex)
    {
        GunGeneralStats  ggs = rw.firingModes[firingModeIndex].general;
        GunMagazineStats m   = rw.firingModes[firingModeIndex].magazine;

        string s = "";

        if (ggs.consumesAmmo == false)
        {
            if (m == null)
            {
                s = "INFINITE";
            }
            else
            {
                s = m.data.current + "/INF";
            }
        }
        else
        {
            if (m == null)
            {
                s = player.ammo.GetStock(ggs.ammoType).ToString();
            }
            else
            {
                s = m.data.current + "/" + (player.ammo.GetStock(ggs.ammoType) - m.data.current);
            }
        }

        return(s);
    }
示例#2
0
    // Update is called once per frame
    void Update()
    {
        Transform playerHead = player.movement.head.transform;

        #region Objectives
        UpdateObjectiveList();
        #endregion

        #region Minimap

        float      height = maxCameraDistance;
        RaycastHit spaceAbovePlayerCheck;
        if (Physics.Raycast(transform.position, transform.up, out spaceAbovePlayerCheck, maxCameraDistance, terrainDetection))
        {
            height = Vector3.Distance(transform.position, spaceAbovePlayerCheck.point);
            height = Mathf.Clamp(height, minCameraDistance, maxCameraDistance);
        }

        minimapCamera.transform.localPosition = new Vector3(0, height, 0);
        #endregion


        #region Basic reticle and interacting
        RaycastHit lookingAt;
        if (Physics.Raycast(playerHead.position, transform.forward, out lookingAt, lookRange, lookDetection))
        {
            Character c = Character.FromObject(lookingAt.collider.gameObject);
            if (c != null)
            {
                if (player.HostileTowards(c))
                {
                    ColourReticle(enemyColour);
                }
                else
                {
                    ColourReticle(allyColour);
                }
            }
            else
            {
                ColourReticle(reticleDefaultColour);
            }



            // Do interacting stuff
        }
        else
        {
            ColourReticle(reticleDefaultColour);
        }
        #endregion

        #region Weapon HUD

        opticsOverlay.gameObject.SetActive(opticsOverlay.graphic.sprite != null);

        Gun rw = player.weapons.CurrentWeapon();
        if (rw != null)
        {
            GunGeneralStats ggs = rw.firingModes[rw.firingModeIndex].general;
            GunOpticsStats  gos = rw.firingModes[rw.firingModeIndex].optics;


            bool activeWeapon = !player.weapons.IsSwitchingWeapon;
            bool noIronsights = gos == null || gos.disableReticle == false;
            reticleCentre.gameObject.SetActive(!activeWeapon || noIronsights);
            reticleUp.gameObject.SetActive(activeWeapon && noIronsights);
            reticleDown.gameObject.SetActive(activeWeapon && noIronsights);
            reticleLeft.gameObject.SetActive(activeWeapon && noIronsights);
            reticleRight.gameObject.SetActive(activeWeapon && noIronsights);
            ammoDisplay.gameObject.SetActive(activeWeapon);
            opticsOverlay.gameObject.SetActive(activeWeapon);
            opticsTransition.gameObject.SetActive(activeWeapon);

            if (activeWeapon == true)
            {
                if (gos == null)
                {
                    ADSTransition(0, null);
                }

                if (noIronsights)
                {
                    #region Calculate reticle width

                    float spread = player.weapons.standingAccuracy.Calculate() + ggs.projectileSpread; // Combines the player's accuracy stat with the spread of their current weapon

                    Vector3 reticleOffsetPoint = Quaternion.AngleAxis(spread, playerHead.right) * playerHead.forward;
                    reticleOffsetPoint = playerHead.position + reticleOffsetPoint * ggs.range;

                    //Debug.DrawLine(playerHead.position, reticleOffsetPoint, Color.blue);
                    //Debug.DrawLine(playerHead.position, playerHead.position + playerHead.forward * ggs.range, Color.red);

                    reticleOffsetPoint = hudCamera.WorldToScreenPoint(reticleOffsetPoint);                                                     // Obtains the screen position of this point
                    Vector2 canvasOffset = reticleCentre.rectTransform.rect.center;
                    RectTransformUtility.ScreenPointToLocalPointInRectangle(canvasTransform, reticleOffsetPoint, hudCamera, out canvasOffset); // Converts screen point value to its appropriate location on the heads up display canvas
                    float reticleRadius = Vector2.Distance(reticleCentre.rectTransform.rect.center, canvasOffset);                             // Obtains the width of the weapon's cone of fire at the maximum range, in canvas space

                    // Adjust reticleRadius to match the canvas size
                    reticleUp.rectTransform.anchoredPosition    = new Vector3(0, reticleRadius);
                    reticleDown.rectTransform.anchoredPosition  = new Vector3(0, -reticleRadius);
                    reticleLeft.rectTransform.anchoredPosition  = new Vector3(-reticleRadius, 0);
                    reticleRight.rectTransform.anchoredPosition = new Vector3(reticleRadius, 0);
                    #endregion
                }


                firingMode.text       = rw.firingModes[rw.firingModeIndex].name;
                firingModeIcon.sprite = rw.firingModes[rw.firingModeIndex].hudIcon;

                ammoCounter.text = AmmoInfo(rw, rw.firingModeIndex);


                GunMagazineStats m = rw.firingModes[rw.firingModeIndex].magazine;

                /*
                 * switch(ggs.consumesAmmo == false, m == null)
                 * {
                 *  case (true, true):
                 *      // Infinite ammo, meter is always full
                 *      ammoBar.fillAmount = 1;
                 *      break;
                 *  case (false, true):
                 *      float percentage
                 *      ammoBar.fillAmount = ph.a.ammoTypes[()]
                 *      break;
                 *  default:
                 *      ammoBar.fillAmount = m.data.PercentageFull;
                 *      break;
                 * }
                 */
                if (ggs.consumesAmmo == false)
                {
                    if (m == null)
                    {
                        FillMeter(ammoBar, 1, 1);
                    }
                    else
                    {
                        FillMeter(ammoBar, m.data.current, m.data.max);
                    }
                }
                else
                {
                    if (m == null)
                    {
                        FillMeter(ammoBar, player.ammo.GetStock(ggs.ammoType), player.ammo.GetMax(ggs.ammoType));
                    }
                    else
                    {
                        FillMeter(ammoBar, m.data.current, m.data.max);
                    }
                }
            }
        }

        #endregion
    }