예제 #1
0
    void SpawnTrees()
    {
        if (treeSpawnCounter <= 0 && GameCore.Instance.currentStage != Stage.Z_BOSS)
        {
            treeSpawnCounter = Random.Range(1, 6);

            Vector3 spawnPosition       = AuxLib.SetPositionOnRaycastHit2D(new Vector3(transform.position.x - 10, 20, 0), "Terrain", Vector2.down, 1);
            Vector3 spawnPositionCheckR = AuxLib.SetPositionOnRaycastHit2D(new Vector3(spawnPosition.x + 2, 20, 0), "Terrain", Vector2.down, 1);
            Vector3 spawnPositionCheckL = AuxLib.SetPositionOnRaycastHit2D(new Vector3(spawnPosition.x - 2, 20, 0), "Terrain", Vector2.down, 1);

            if (spawnPosition.y >= 20)
            {
                treeSpawnCounter = 0;
            }

            else if (spawnPositionCheckR.y <= spawnPosition.y - 0.4)
            {
                GameObject go = Instantiate(Resources.Load("Prefabs/Assets/Tree_00"), spawnPositionCheckR, Quaternion.identity) as GameObject;
            }

            else if (spawnPositionCheckL.y <= spawnPosition.y - 0.4)
            {
                GameObject go = Instantiate(Resources.Load("Prefabs/Assets/Tree_00"), spawnPositionCheckL, Quaternion.identity) as GameObject;
            }

            else
            {
                GameObject go = Instantiate(Resources.Load("Prefabs/Assets/Tree_00"), spawnPosition, Quaternion.identity) as GameObject;
            }
        }

        treeSpawnCounter -= Time.deltaTime;
    }
예제 #2
0
    public void Spawn(string path, Vector3 startPos)
    {
        GameObject go;

        go = Instantiate(Resources.Load(path), AuxLib.SetPositionOnRaycastHit2D(startPos, "Terrain", Vector2.down, spawnHeight), Quaternion.identity) as GameObject;
        //Debug.Log("Initial Position Assigned: "+startPos);
    }
예제 #3
0
    void GetNearestRayDir(ref Ray _screenRay, ref Vector3 _srcPos, ref Vector3 _dir, ref Vector3 _dstPos)
    {
        Ray[] _rayGroup = new Ray[6];
        _rayGroup[PXAxis] = new Ray(_srcPos, m_axisPX);
        _rayGroup[NXAxis] = new Ray(_srcPos, m_axisNX);
        _rayGroup[PZAxis] = new Ray(_srcPos, m_axisPZ);
        _rayGroup[NZAxis] = new Ray(_srcPos, m_axisNZ);
        _rayGroup[PYAxis] = new Ray(_srcPos, m_axisPY);
        _rayGroup[NYAxis] = new Ray(_srcPos, m_axisNY);

        float _minDistSq = float.MaxValue;
        float _s = 0.0f, _t = 0.0f;
        int   _iDir = 0;

        for (int _i = 0; _i != 6; ++_i)
        {
            if (_rayGroup[_i].direction.x == 0.0f && _rayGroup[_i].direction.y == 0.0f && _rayGroup[_i].direction.z == 0.0f)
            {
                continue;
            }
            float _tempS = 0.0f, _tempT = 0.0f;
            float _distSq = AuxLib.Get().DistSqRayRay(ref _rayGroup[_i], ref _screenRay, ref _tempS, ref _tempT);
            if (_minDistSq > _distSq)
            {
                _minDistSq = _distSq;
                _s         = _tempS;
                _t         = _tempT;
                _iDir      = _i;
            }
        }

        _dir    = _rayGroup[_iDir].direction;
        _dstPos = _rayGroup[_iDir].origin + _rayGroup[_iDir].direction * _s;
    }
예제 #4
0
    void SpawnFlowers()
    {
        if (flowerSpawnCtr <= 0)
        {
            flowerSpawnCtr = Random.Range(minTimeFlower, maxTimeFlower);

            Vector3 spawnPosition       = AuxLib.SetPositionOnRaycastHit2D(new Vector3(transform.position.x - 10, 20, 0), "Terrain", Vector2.down, 1);
            Vector3 spawnPositionCheckR = AuxLib.SetPositionOnRaycastHit2D(new Vector3(spawnPosition.x + 2, 20, 0), "Terrain", Vector2.down, 1);
            Vector3 spawnPositionCheckL = AuxLib.SetPositionOnRaycastHit2D(new Vector3(spawnPosition.x - 2, 20, 0), "Terrain", Vector2.down, 1);

            if (spawnPosition.y >= 20)
            {
                flowerSpawnCtr = 0;
            }

            else if (spawnPositionCheckR.y <= spawnPosition.y - 0.4)
            {
                GameObject go = Instantiate(Resources.Load("Prefabs/Interactable/Flower"), spawnPositionCheckR, Quaternion.identity) as GameObject;
            }

            else if (spawnPositionCheckL.y <= spawnPosition.y - 0.4)
            {
                GameObject go = Instantiate(Resources.Load("Prefabs/Interactable/Flower"), spawnPositionCheckL, Quaternion.identity) as GameObject;
            }

            else
            {
                GameObject go = Instantiate(Resources.Load("Prefabs/Interactable/Flower"), spawnPosition, Quaternion.identity) as GameObject;
            }
        }

        flowerSpawnCtr -= Time.deltaTime;
    }
예제 #5
0
        // ---- Ubacivanje podataka u bazi ----
        private void BtnSubmitData_Click(object sender, EventArgs e)
        {
            // ---- Provera ispravnosti podataka ----
            if (String.IsNullOrWhiteSpace(TbPunoIme.Text))
            {
                MessageBox.Show("Unesi Puno ime trenera!");
                return;
            }
            else if (String.IsNullOrWhiteSpace(TbMestoRodjenja.Text))
            {
                MessageBox.Show("Unesi mesto rodjenja trenera!");
                return;
            }
            else if (String.IsNullOrWhiteSpace(TbTrenutniKlub.Text))
            {
                MessageBox.Show("Unesi trenutni klub(reprezentaciju) koju trenira trener!");
                return;
            }
            Trener forSave = new Trener();

            forSave.PunoIme           = StringCleaner.checkString(TbPunoIme.Text);
            forSave.MestoRodjenja     = StringCleaner.checkString(TbMestoRodjenja.Text);
            forSave.TrenutniKlub      = StringCleaner.checkString(TbTrenutniKlub.Text);
            forSave.TrenerskaKarijera = StringCleaner.checkString(RtbTrenerskaKarijera.Text);
            forSave.Uspesi            = StringCleaner.checkString(RtbUspesi.Text);
            forSave.DatumRodjenja     = StringCleaner.checkString(dateTimePicker1.Value.ToShortDateString());

            var _client   = new MongoClient();
            var _database = _client.GetDatabase("test");

            var collection = _database.GetCollection <BsonDocument>("treneri");
            var filter     = new BsonDocument()
            {
                { "PunoIme", TbPunoIme.Text }
            };

            var filterForUniqueCheck = Builders <BsonDocument> .Filter.Eq("PunoIme", this.TbPunoIme.Text);

            var document = forSave.ToBsonDocument();
            //test if  exists
            var test = collection.Find(filterForUniqueCheck).Count();

            if (test == 0)
            {
                collection.InsertOne(document);
                if (slikaTrenera != null)
                {
                    AuxLib.AddImageToGridFS(slikaTrenera, forSave.PunoIme, format);
                }

                MessageBox.Show("Uspesno dodat novi trener!");
            }
            else
            {
                //TO DO : URADITI UPDATE SLIKE (AuxLib treba da ima remove image i remove mp3 i da se izbaci slika i ubaci nova);
                collection.ReplaceOne(filter, document);
                MessageBox.Show("Uspesno azuriran trener!");
            }
        }
예제 #6
0
 public static AuxLib Get()
 {
     if (m_this == null)
     {
         m_this = new AuxLib();
     }
     return(m_this);
 }
예제 #7
0
    // Update is called once per frame
    void Update()
    {
        if (GameCore.Instance.gameState == GameState.PLAY)
        {
            movementSpeedAux = movementSpeed * AuxLib.Map(GameCore.Instance.playerController.rBody.velocity.x, GameCore.Instance.playerController.minSpeed, GameCore.Instance.playerController.maxSpeed, 0, 1);
            animatedOffset  += new Vector2(movementSpeedAux, 0) * Time.deltaTime;


            this.GetComponent <MeshRenderer>().material.SetTextureOffset("_MainTex", animatedOffset);
        }
    }
예제 #8
0
    void CreateParallaxLayers()
    {
        for (int i = 0; i < parallaxLayers.Count; i++)
        {
            GameObject go = new GameObject();
            go.transform.parent = this.transform;

            if (parallaxLayers[i].order == ParallaxLayerOrder.BACK)
            {
                go.name = "Parallax_BackLayer " + i;
                go.transform.localPosition = new Vector3(0, 0, AuxLib.Map(i, 0, parallaxLayers.Count, parallaxLayerMin, parallaxLayerMax));
            }
            else
            {
                go.name = "Parallax_FrontLayer " + i;
                go.transform.localPosition = new Vector3(0, 0, AuxLib.Map(i, 0, parallaxLayers.Count, -parallaxLayerMin, -parallaxLayerMax));
            }

            GameObject goDay = GameObject.CreatePrimitive(PrimitiveType.Quad);
            goDay.name                    = "DayLayer";
            goDay.transform.parent        = go.transform;
            goDay.transform.localPosition = Vector3.zero;
            Destroy(goDay.GetComponent <MeshCollider>());
            goDay.GetComponent <MeshRenderer>().material             = Resources.Load("Materials/MAT_ParallaxLayer") as Material;
            goDay.GetComponent <MeshRenderer>().material.mainTexture = parallaxLayers[i].day;

            if (parallaxLayers[i].order == ParallaxLayerOrder.FRONT)
            {
                goDay.GetComponent <MeshRenderer>().sortingLayerName = "FrontParallax";
                Debug.Log("Sorting layer: " + goDay.GetComponent <MeshRenderer>().sortingLayerName);
            }

            goDay.layer = GameCore.DAY_LAYER;
            goDay.AddComponent <ParallaxLayerBehaviour>().movementSpeed = parallaxLayers[i].speed;


            GameObject goNight = GameObject.CreatePrimitive(PrimitiveType.Quad);
            goNight.name                    = "NightLayer";
            goNight.transform.parent        = go.transform;
            goNight.transform.localPosition = Vector3.zero;
            Destroy(goNight.GetComponent <MeshCollider>());
            goNight.GetComponent <MeshRenderer>().material             = Resources.Load("Materials/MAT_ParallaxLayer") as Material;
            goNight.GetComponent <MeshRenderer>().material.mainTexture = parallaxLayers[i].night;

            if (parallaxLayers[i].order == ParallaxLayerOrder.FRONT)
            {
                goNight.GetComponent <MeshRenderer>().sortingLayerName = "FrontParallax";
            }

            goNight.layer = GameCore.NIGHT_LAYER;
            goNight.AddComponent <ParallaxLayerBehaviour>().movementSpeed = parallaxLayers[i].speed;
        }
    }
예제 #9
0
    // Update is called once per frame
    void FixedUpdate()
    {
        switch (GameCore.Instance.gameState)
        {
        case GameState.AWAKE:
            break;

        case GameState.PAUSE:
            break;

        case GameState.PLAY:
        {
            if (counter <= 0 && GameCore.Instance.currentStage != WorldConstructor.Stage.Z_BOSS)
            {
                counter     = Random.Range(randomSpawnTimeRange.x, randomSpawnTimeRange.y);
                spawnHeight = Random.Range(3.0f, 7.0f);

                //Debug.Log(GameCore.Instance.player.transform.position);
                Vector3 playerDistance = new Vector3(GameCore.Instance.player.transform.position.x + 30, 10, 0);
                Vector3 spawnPosition  = AuxLib.SetPositionOnRaycastHit2D(playerDistance, "Terrain", Vector2.down, spawnHeight);

                if (spawnPosition.y >= 7)
                {
                    counter = 0;
                }
                else
                {
                    GameObject go = Instantiate(Resources.Load("Prefabs/Enemies/Raven"), spawnPosition, Quaternion.identity) as GameObject;
                }
            }

            counter -= Time.deltaTime;
        }
        break;

        case GameState.GAMEOVER:
            break;

        default:
            break;
        }
    }
예제 #10
0
 private void TbTrenutniKlub_Leave(object sender, EventArgs e)
 {
     AuxLib.Check(this.TbTrenutniKlub.Text, this.TbTrenutniKlub);
 }
예제 #11
0
    void UpdateDragBrick()
    {
        Ray     _ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        Vector3 _pos = m_firstBrick.m_go.transform.position;

        Ray[] _rayGroup = new Ray[6];

        if (m_firstBrick.m_dirP != NoDir && m_firstBrick.m_dirN != NoDir)
        {
            if (m_firstBrick.m_dirP == PXAxis)
            {
                _rayGroup[PXAxis] = new Ray(_pos, m_axisPX);
            }

            if (m_firstBrick.m_dirN == NXAxis)
            {
                _rayGroup[NXAxis] = new Ray(_pos, m_axisNX);
            }

            if (m_firstBrick.m_dirP == PZAxis)
            {
                _rayGroup[PZAxis] = new Ray(_pos, m_axisPZ);
            }

            if (m_firstBrick.m_dirN == NZAxis)
            {
                _rayGroup[NZAxis] = new Ray(_pos, m_axisNZ);
            }

            if (m_firstBrick.m_dirP == PYAxis)
            {
                _rayGroup[PYAxis] = new Ray(_pos, m_axisPY);
            }

            if (m_firstBrick.m_dirN == NYAxis)
            {
                _rayGroup[NYAxis] = new Ray(_pos, m_axisNY);
            }
        }
        else
        {
            _rayGroup[PXAxis] = new Ray(_pos, m_axisPX);
            _rayGroup[NXAxis] = new Ray(_pos, m_axisNX);
            _rayGroup[PZAxis] = new Ray(_pos, m_axisPZ);
            _rayGroup[NZAxis] = new Ray(_pos, m_axisNZ);
            _rayGroup[PYAxis] = new Ray(_pos, m_axisPY);
            //_rayGroup[NYAxis] = new Ray(_pos, m_axisNY);
        }

        float _minDistSq = float.MaxValue;
        float _s = 0.0f, _t = 0.0f;
        int   _iDir = 0;

        for (int _i = 0; _i != 6; ++_i)
        {
            if (_rayGroup[_i].direction.x == 0.0f && _rayGroup[_i].direction.y == 0.0f && _rayGroup[_i].direction.z == 0.0f)
            {
                continue;
            }
            float _tempS = 0.0f, _tempT = 0.0f;
            float _distSq = AuxLib.Get().DistSqRayRay(ref _rayGroup[_i], ref _ray, ref _tempS, ref _tempT);
            if (_minDistSq > _distSq)
            {
                _minDistSq = _distSq;
                _s         = _tempS;
                _t         = _tempT;
                _iDir      = _i;
            }
        }

        if (m_dragDir != _iDir)
        {
            DestroyDragList();
            m_dragIdx    = new IntVec3(m_firstBrick.m_go.transform.position);
            m_bCollision = false;
        }
        m_dragDir = _iDir;

        Vector3 _destPos = new Vector3();

        _destPos = _rayGroup[_iDir].origin + _rayGroup[_iDir].direction * _s;
        IntVec3 _destIdx = new IntVec3(_destPos);

        if (m_dragIdx != _destIdx)
        {
            int  _iOffset = 0;
            bool _bInc    = true;
            switch (m_dragDir)
            {
            case PXAxis:
            {
                _iOffset = Mathf.Abs(_destIdx.x - m_dragIdx.x);
                if (_destIdx.x < m_dragIdx.x)
                {
                    _bInc = false;
                }

                for (int _i = 1; _i <= _iOffset; ++_i)
                {
                    IntVec3 _curIdx = new IntVec3(m_dragIdx);
                    if (_bInc == true)
                    {
                        if (m_bCollision == true)
                        {
                            break;
                        }
                        _curIdx.x += _i;
                        if (m_buildBrickMap.ContainsKey(_curIdx) == false)
                        {
                            CubeBrick _cb = new CubeBrick();
                            _cb.m_dirP = PXAxis;
                            _cb.m_dirN = NXAxis;

                            _cb.m_go = (GameObject)Instantiate(m_prefabBrick, new Vector3(_curIdx.x + 0.5f, _curIdx.y + 0.5f, _curIdx.z + 0.5f), Quaternion.identity);
                            m_dragBrickList.Add(_cb);
                        }
                        else
                        {
                            m_bCollision = true;
                        }
                    }
                    else
                    {
                        int _iPos = m_dragBrickList.Count - 1;
                        if (_iPos >= 0)
                        {
                            CubeBrick _cb = m_dragBrickList[_iPos];
                            Object.DestroyImmediate(_cb.m_go);
                            m_dragBrickList.RemoveAt(_iPos);
                        }
                    }
                }
                break;
            }

            case NXAxis:
            {
                _iOffset = Mathf.Abs(_destIdx.x - m_dragIdx.x);
                if (_destIdx.x > m_dragIdx.x)
                {
                    _bInc = false;
                }

                for (int _i = 1; _i <= _iOffset; ++_i)
                {
                    IntVec3 _curIdx = new IntVec3(m_dragIdx);
                    if (_bInc == true)
                    {
                        if (m_bCollision == true)
                        {
                            break;
                        }
                        _curIdx.x -= _i;
                        if (m_buildBrickMap.ContainsKey(_curIdx) == false)
                        {
                            CubeBrick _cb = new CubeBrick();
                            _cb.m_dirP = PXAxis;
                            _cb.m_dirN = NXAxis;
                            _cb.m_go   = (GameObject)Instantiate(m_prefabBrick, new Vector3(_curIdx.x + 0.5f, _curIdx.y + 0.5f, _curIdx.z + 0.5f), Quaternion.identity);
                            m_dragBrickList.Add(_cb);
                        }
                        else
                        {
                            m_bCollision = true;
                        }
                    }
                    else
                    {
                        int _iPos = m_dragBrickList.Count - 1;
                        if (_iPos >= 0)
                        {
                            CubeBrick _cb = m_dragBrickList[_iPos];
                            Object.DestroyImmediate(_cb.m_go);
                            m_dragBrickList.RemoveAt(_iPos);
                        }
                    }
                }
                break;
            }

            case PYAxis:
            {
                _iOffset = Mathf.Abs(_destIdx.y - m_dragIdx.y);
                if (_destIdx.y < m_dragIdx.y)
                {
                    _bInc = false;
                }

                for (int _i = 1; _i <= _iOffset; ++_i)
                {
                    IntVec3 _curIdx = new IntVec3(m_dragIdx);
                    if (_bInc == true)
                    {
                        if (m_bCollision == true)
                        {
                            break;
                        }
                        _curIdx.y += _i;
                        if (m_buildBrickMap.ContainsKey(_curIdx) == false)
                        {
                            CubeBrick _cb = new CubeBrick();
                            _cb.m_dirP = PYAxis;
                            _cb.m_dirN = NYAxis;
                            _cb.m_go   = (GameObject)Instantiate(m_prefabBrick, new Vector3(_curIdx.x + 0.5f, _curIdx.y + 0.5f, _curIdx.z + 0.5f), Quaternion.identity);
                            m_dragBrickList.Add(_cb);
                        }
                        else
                        {
                            m_bCollision = true;
                        }
                    }
                    else
                    {
                        int _iPos = m_dragBrickList.Count - 1;
                        if (_iPos >= 0)
                        {
                            CubeBrick _cb = m_dragBrickList[_iPos];
                            Object.DestroyImmediate(_cb.m_go);
                            m_dragBrickList.RemoveAt(_iPos);
                        }
                    }
                }
                break;
            }

            case NYAxis:
            {
                _iOffset = Mathf.Abs(_destIdx.y - m_dragIdx.y);
                if (_destIdx.y > m_dragIdx.y)
                {
                    _bInc = false;
                }

                for (int _i = 1; _i <= _iOffset; ++_i)
                {
                    IntVec3 _curIdx = new IntVec3(m_dragIdx);
                    if (_bInc == true)
                    {
                        if (m_bCollision == true)
                        {
                            break;
                        }
                        _curIdx.y -= _i;
                        if (m_buildBrickMap.ContainsKey(_curIdx) == false)
                        {
                            CubeBrick _cb = new CubeBrick();
                            _cb.m_dirP = PYAxis;
                            _cb.m_dirN = NYAxis;
                            _cb.m_go   = (GameObject)Instantiate(m_prefabBrick, new Vector3(_curIdx.x + 0.5f, _curIdx.y + 0.5f, _curIdx.z + 0.5f), Quaternion.identity);
                            m_dragBrickList.Add(_cb);
                        }
                        else
                        {
                            m_bCollision = true;
                        }
                    }
                    else
                    {
                        int _iPos = m_dragBrickList.Count - 1;
                        if (_iPos >= 0)
                        {
                            CubeBrick _cb = m_dragBrickList[_iPos];
                            Object.DestroyImmediate(_cb.m_go);
                            m_dragBrickList.RemoveAt(_iPos);
                        }
                    }
                }
                break;
            }

            case PZAxis:
            {
                _iOffset = Mathf.Abs(_destIdx.z - m_dragIdx.z);
                if (_destIdx.z < m_dragIdx.z)
                {
                    _bInc = false;
                }

                for (int _i = 1; _i <= _iOffset; ++_i)
                {
                    IntVec3 _curIdx = new IntVec3(m_dragIdx);
                    if (_bInc == true)
                    {
                        if (m_bCollision == true)
                        {
                            break;
                        }
                        _curIdx.z += _i;
                        if (m_buildBrickMap.ContainsKey(_curIdx) == false)
                        {
                            CubeBrick _cb = new CubeBrick();
                            _cb.m_dirP = PZAxis;
                            _cb.m_dirN = NZAxis;
                            _cb.m_go   = (GameObject)Instantiate(m_prefabBrick, new Vector3(_curIdx.x + 0.5f, _curIdx.y + 0.5f, _curIdx.z + 0.5f), Quaternion.identity);
                            m_dragBrickList.Add(_cb);
                        }
                        else
                        {
                            m_bCollision = true;
                        }
                    }
                    else
                    {
                        int _iPos = m_dragBrickList.Count - 1;
                        if (_iPos >= 0)
                        {
                            CubeBrick _cb = m_dragBrickList[_iPos];
                            Object.DestroyImmediate(_cb.m_go);
                            m_dragBrickList.RemoveAt(_iPos);
                        }
                    }
                }
                break;
            }

            case NZAxis:
            {
                _iOffset = Mathf.Abs(_destIdx.z - m_dragIdx.z);
                if (_destIdx.z > m_dragIdx.z)
                {
                    _bInc = false;
                }

                for (int _i = 1; _i <= _iOffset; ++_i)
                {
                    IntVec3 _curIdx = new IntVec3(m_dragIdx);
                    if (_bInc == true)
                    {
                        if (m_bCollision == true)
                        {
                            break;
                        }
                        _curIdx.z -= _i;
                        if (m_buildBrickMap.ContainsKey(_curIdx) == false)
                        {
                            CubeBrick _cb = new CubeBrick();
                            _cb.m_dirP = PZAxis;
                            _cb.m_dirN = NZAxis;
                            _cb.m_go   = (GameObject)Instantiate(m_prefabBrick, new Vector3(_curIdx.x + 0.5f, _curIdx.y + 0.5f, _curIdx.z + 0.5f), Quaternion.identity);
                            m_dragBrickList.Add(_cb);
                        }
                        else
                        {
                            m_bCollision = true;
                        }
                    }
                    else
                    {
                        int _iPos = m_dragBrickList.Count - 1;
                        if (_iPos >= 0)
                        {
                            CubeBrick _cb = m_dragBrickList[_iPos];
                            Object.DestroyImmediate(_cb.m_go);
                            m_dragBrickList.RemoveAt(_iPos);
                        }
                    }
                }
                break;
            }
            }

            m_dragIdx = _destIdx;
        }
    }
예제 #12
0
 void UpdateCameraSize()
 {
     camSize = Mathf.Lerp(camSize, AuxLib.Map(playerController.rBody.velocity.x, playerController.minSpeed, playerController.maxSpeed, minCamSize, maxCamSize), Time.deltaTime * 4f);
 }
예제 #13
0
    void Update()
    {
        switch (GameCore.Instance.gameState)
        {
        case GameState.AWAKE:
        {
            if (!GameCore.Instance.barrier)
            {
                barrierBarBorders.gameObject.SetActive(false);
            }
            if (GameCore.Instance.currentStage == WorldConstructor.Stage.Z_BOSS)
            {
                StartGame();
            }
        }
        break;

        case GameState.PAUSE:
            break;

        case GameState.PLAY:
        {
            hudDisplay.SetBool("Playing", true);

            if (GameCore.Instance.staminaBoost)
            {
                staminaBarValue.GetComponent <RectTransform>().SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, AuxLib.Map(GameCore.Instance.playerController.GetCurrentPower(), 0, GameCore.Instance.playerController.maxPower, 0, 512 * 2));
                staminaBarBorders.GetComponent <RectTransform>().SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, 512);
            }
            else
            {
                staminaBarValue.GetComponent <RectTransform>().SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, AuxLib.Map(GameCore.Instance.playerController.GetCurrentPower(), 0, GameCore.Instance.playerController.maxPower, 0, 256 * 2));
            }

            if (GameCore.Instance.barrier)
            {
                barrierBarValue.GetComponent <RectTransform>().SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, AuxLib.Map(GameCore.Instance.playerController.GetCurrentBarrier(), 0, GameCore.Instance.playerController.maxBarrier, 0, barrierBarLength * 2));
                barrierBarBorders.GetComponent <RectTransform>().SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, barrierBarLength);
                if (GameCore.Instance.playerController.barrier <= 0)
                {
                    GameCore.Instance.barrier = false;
                    GameCore.Instance.playerController.transform.GetChild(0).GetChild(0).gameObject.SetActive(false);
                    GameCore.Instance.playerController.transform.GetChild(1).GetChild(0).gameObject.SetActive(false);
                }
            }
        }
        break;

        case GameState.GAMEOVER:
        {
            endMenuAnimator.SetBool("Show", true);
            finalScore.GetComponent <Text>().text = "SCORE: " + GameCore.Instance.finalScore;
        }
        break;

        default:
            break;
        }

        score.GetComponent <Text>().text = "SCORE: " + GameCore.Instance.finalScore;
    }
예제 #14
0
 public void DecreaseBarrierValue(float percentOnTotal)
 {
     barrier -= AuxLib.Map(Mathf.Clamp(percentOnTotal, 0, 100), 0, 100, 0, maxBarrier);
 }
예제 #15
0
 public void DecreaseStamina(float percentOnTotal)
 {
     power -= AuxLib.Map(Mathf.Clamp(percentOnTotal, 0, 100), 0, 100, 0, maxPower);
 }
예제 #16
0
 public void RecoverStamina(float percentOnTotal)
 {
     power += AuxLib.Map(Mathf.Clamp(percentOnTotal, 0, 100), 0, 100, 0, maxPower);
 }