示例#1
0
    public void SetFullCharge()
    {
        PiiController piiController = bolt.GetComponent <PiiController>();

        if (piiController != null && piiController.ChargeNow < piiController.ChargeMax)
        {
            piiController.ChargeNow = piiController.ChargeMax;
        }
    }
示例#2
0
    public void PlusScore(float score)
    {
        ScorePlusCheat(score);
        //ScoreALL += score;
        ScoreTime += score;

        PiiController pii = bolt.GetComponent <PiiController>();

        if (pii.ChargeNow < pii.ChargeMax)
        {
            pii.ChargeNow += 0.1f;
        }
    }
示例#3
0
    void testViewAngle()
    {
        PiiController piiController = bolt.GetComponent <PiiController>();
        Camera        cam           = camera.GetComponent <Camera>();

        if (piiController != null && cam != null)
        {
            if (piiController.ChargeOn && cam.fieldOfView != 65)
            {
                cam.fieldOfView += (65 - cam.fieldOfView) * Time.deltaTime;
            }
            else if (!piiController.ChargeOn && cam.fieldOfView != 60)
            {
                cam.fieldOfView += (60 - cam.fieldOfView) * Time.deltaTime;
            }
        }
    }
示例#4
0
    void TestLocalPosCam()
    {
        //Возвращение камеры в нулевую позицию
        float   needToZero  = 0 - camera.transform.localPosition.x;
        Vector3 newPosition = camera.transform.localPosition;

        newPosition.x += (needToZero / 2) * Time.deltaTime;

        //Смещяем камеру от центра в зависимости от того какие изменения
        float izmenenie = old_rot_y - gameObject.transform.localRotation.ToEulerAngles().y;

        old_rot_y = gameObject.transform.localRotation.ToEulerAngles().y;

        PiiController piiController = bolt.GetComponent <PiiController>();

        if (piiController.ChargeOn)
        {
            newPosition.x -= (izmenenie / 100) * piiController.speed_pii;
            if (newPosition.x > 0.5f)
            {
                newPosition.x = 0.5f;
            }
            else if (newPosition.x < -0.5f)
            {
                newPosition.x = -0.5f;
            }
            camera.transform.localPosition = newPosition;
        }
        else
        {
            newPosition.x -= (izmenenie / 500) * piiController.speed_pii;
            if (newPosition.x > 0.5f)
            {
                newPosition.x = 0.5f;
            }
            else if (newPosition.x < -0.5f)
            {
                newPosition.x = -0.5f;
            }
            camera.transform.localPosition = newPosition;
        }
    }
示例#5
0
    void set_bolt()
    {
        Player player = null;

        //Если настроек нет
        if (player == null)
        {
            //ищем обьект по тегу
            GameObject obj = GameObject.FindWithTag("Player");
            //вытаскиваем настройки
            if (obj != null)
            {
                player = obj.GetComponent <Player>();
            }

            if (player != null)
            {
                bolt = player.bolt.GetComponent <PiiController>();
            }
        }
    }
示例#6
0
    public void TrigerPii(float presure, FaceController faceController, PiiController piiController, GameObject score_Text_func)
    {
        //Если у мочи достаточно инерции и если у предмета еще есть здоровье
        if (presure >= MinPresure && heath != 0)
        {
            float score_plus_now = 0;

            if (heath > 0)
            {
                //Сперва проверяем напрягся ли игрок
                if (player_save != null && player_save.bolt.GetComponent <PiiController>().ChargeOn)
                {
                    heath -= presure;
                    if (!gameplayParametrs.GameOver)
                    {
                        score_plus_now = score * 1.5f;
                        player_save.PlusScore(score_plus_now);
                    }
                }
                else if (player_save != null && !player_save.bolt.GetComponent <PiiController>().ChargeOn)
                {
                    score_plus_now = score;
                    player_save.PlusScore(score_plus_now);
                }
                heath -= presure;

                if (heath < 0)
                {
                    heath = 0;
                }
                heath_percent = heath / (start_heath / 100);
                //Если есть частицы то воспроизводим их
                if (particle != null)
                {
                    particle.Play();
                }

                SetColorNeed(heath_percent);

                //Если здоровье закончилось
                if (heath <= 0)
                {
                    DeathTarget();
                    test_lvl_target(player_save.gameplayParametrs);

                    score_plus_now = score * score_destroy;
                    player_save.PlusScore(score_plus_now);

                    if (faceController != null && fear_emotion_dead && Random.Range(0, 100) < 50)
                    {
                        faceController.set_fear(3f);
                    }

                    helicopter helicopterObj = gameObject.GetComponent <helicopter>();
                    if (helicopterObj != null)
                    {
                        player_save.SetFullCharge();
                    }
                }
                //Иначе звук попадания
                else
                {
                    //Воспросизводим звук попадания
                    TargetSound sounds = gameObject.GetComponent <TargetSound>();
                    if (sounds != null)
                    {
                        gameObject.GetComponent <TargetSound>().PlaySoundPii();
                    }

                    //Если цель автомобиль воспроизводим сигнализацию
                    CarStatic CarSiren = gameObject.GetComponent <CarStatic>();
                    if (CarSiren != null)
                    {
                        CarSiren.StartSignal();
                    }
                    //Если цель полиция то запускаем сирену
                    police_car police = gameObject.GetComponent <police_car>();
                    if (police != null && !police.police_active_now)
                    {
                        police.police_active_now = true;
                        police.need_sound_yn     = true;
                    }
                }
            }

            if (faceController != null && !piiController.ChargeOn)
            {
                if (Random.Range(0, 100) < 1.1f)
                {
                    faceController.set_bliss_voice(1.2f);
                }
                if (Random.Range(0, 100) < 0.1f)
                {
                    faceController.set_surprise_voice(1.2f);
                }

                if (Random.Range(0, 100) < 0.1f && fear_emotion)
                {
                    faceController.set_choked_voice();
                }
            }


            if (score_Text_func != null)
            {
                if (score_text != null)
                {
                    GameObject.Destroy(score_text);
                }

                score_text = Instantiate(score_Text_func);
                Score_text_3d score_Text_3D = score_text.GetComponent <Score_text_3d>();

                ScoreSum += score_plus_now;
                //Проверка того что нужно написать в зависимости от здоровья
                if (heath > 0)
                {
                    Color color_new = new Color(1f, 0.92f, 0, 0.62f);
                    score_Text_3D.inicialize(player_save.gameObject, ((int)heath_percent).ToString() + "%", gameObject.transform.position, color_new);
                }
                else
                {
                    Color color_new = new Color(1f, 0.47f, 0, 0.62f);
                    score_Text_3D.inicialize(player_save.gameObject, ((int)ScoreSum).ToString(), gameObject.transform.position, color_new);
                }
            }
        }
    }
    void TestTime()
    {
        //Если игрок сыт
        if (player.PiiNow)
        {
            if (TimeToEnd > 0 && !OverTime && !GameOver)
            {
                TimeToEnd -= Time.deltaTime;
                if ((TimeToEnd < 0 && lvl_now != 5) ||
                    (lvl_now == 1 && (TimeToEnd_max - TimeToEnd) > 30 && player.ScoreTime < 50) ||
                    (lvl_now == 2 && player.ScoreTime < 300) ||
                    (lvl_now == 3 && player.ScoreTime < 3000) ||
                    (lvl_now == 4 && player.ScoreTime < 5000) ||
                    (lvl_now == 5 && player.ScoreTime < 10000)
                    )
                {
                    text_center.text_next = "Over Time";
                    OverTime  = true;
                    TimeToEnd = 0;
                }
                //Если цунами настигло игрока
                else if (TimeToEnd < 0 && lvl_now == 5)
                {
                    OverTime         = true;
                    player.ScoreTime = 0;
                    TimeToEnd        = 0;
                }
            }

            /*
             * if (TimeToEnd == 0 && Time.timeScale > 0 && player.ScoreALL > 500) {
             *  Time.timeScale = Time.timeScale - 0.03f;
             *  if (Time.timeScale < 0.1f) {
             *      Time.timeScale = 0.1f;
             *      player.PiiNow = false;
             *  }
             * }
             */
            //Уменьшение напора
            if (OverTime)
            {
                //player.ScoreTime -= (player.ScoreTime/5) * Time.deltaTime;
                //player.ScoreTime -= (player.ScoreTime/0.f - player.ScoreTime/2) * Time.deltaTime * 0.5f;
                PiiController piiController = player.bolt.GetComponent <PiiController>();
                if (!piiController.ChargeOn)
                {
                    //Скорость уменьшения в овер тайме
                    float speedOverTime = 15;
                    if (lvl_now == 2)
                    {
                        speedOverTime = 10;
                    }
                    else if (lvl_now == 3)
                    {
                        speedOverTime = 15;
                    }
                    else if (lvl_now == 4)
                    {
                        speedOverTime = 20;
                    }
                    else if (lvl_now == 5 || lvl_now == 6)
                    {
                        speedOverTime = 40;
                    }

                    player.ScoreTime -= Calculations.coofing_num(player.ScoreTime * piiController.speed_pii * 0.05f, 1.5f) * Time.deltaTime * speedOverTime;
                }

                //Условие gameover
                if (player.ScoreTime < 1)
                {
                    if (get_lvl_now() < 6)
                    {
                        text_center.text_next = "Game Over";
                    }
                    else
                    {
                        text_center.text_next = "Thanks for Playing!";
                    }
                    GameOver      = true;
                    player.PiiNow = false;
                }
            }
        }
    }
示例#8
0
    //тест спавна
    void TestSpawn()
    {
        time_lastspawn += Time.deltaTime;

        //Проверка есть ли что спавнить и есть ли старт пути?
        if (autos != null && autos.Length > 0 && track_Points != null && track_Points.Length > 0)
        {
            //На каком растоянии от спавна последний заспавненный автомобиль
            float distance_last_spawn_auto = 999999;
            if (LastSpawner != null)
            {
                distance_last_spawn_auto = Vector3.Distance(gameObject.transform.position, LastSpawner.transform.position);
            }

            //Расчет максимального количества автомобилей сейчас
            if (player.gameplayParametrs.get_lvl_now() == 0)
            {
                timeout_spawn = 20 * timeout_spawn_mnozitel;
            }
            else if (player.gameplayParametrs.get_lvl_now() == 1)
            {
                timeout_spawn = 4 * timeout_spawn_mnozitel;
            }
            else if (player.gameplayParametrs.get_lvl_now() == 2)
            {
                timeout_spawn = 4 * timeout_spawn_mnozitel;
            }

            else if (player.gameplayParametrs.get_lvl_now() == 3)
            {
                timeout_spawn = 4 * timeout_spawn_mnozitel;
            }

            else if (player.gameplayParametrs.get_lvl_now() == 4)
            {
                timeout_spawn = 20 * timeout_spawn_mnozitel;
            }

            else if (player.gameplayParametrs.get_lvl_now() == 5)
            {
                timeout_spawn = 50 * timeout_spawn_mnozitel;
            }

            else if (player.gameplayParametrs.get_lvl_now() > 5)
            {
                timeout_spawn = 99999 * timeout_spawn_mnozitel;
            }
            else
            {
                timeout_spawn = 4 * timeout_spawn_mnozitel;
            }

            //Проверяем пришло ли время для спавна
            if (time_lastspawn > timeout_spawn_next && distance_last_spawn_auto > 10)
            {
                //Выбираем автомобиль
                int num_auto = Random.Range(0, autos.Length);
                if (autos[num_auto] != null)
                {
                    bool its_police = false;
                    //Проверяем если есть игрок то узнаем какой уровень и его мошьность
                    float itog_shanse   = autos[num_auto].shance_spawn;
                    float player_shance = 1;
                    if (autos[num_auto].GetComponent <police_car>() != null)
                    {
                        its_police = true;
                    }

                    if (player != null)
                    {
                        //Изменения шанса пояления этого авто
                        PiiController piiController = player.bolt.GetComponent <PiiController>();
                        player_shance = piiController.speed_pii - 12;
                        if (player_shance < 0)
                        {
                            player_shance = 0;
                        }
                        player_shance *= 8;
                    }


                    //проверяем удачу появления этого автомобиля
                    float shance = Random.Range(0f, 100f);

                    if (player_shance != 0)
                    {
                        if (its_police)
                        {
                            //Увеличиваем шанс
                            itog_shanse = itog_shanse * player_shance;
                        }
                        else
                        {
                            //Уменьшаем шанс
                            itog_shanse = itog_shanse / player_shance;
                        }
                    }


                    if (shance < itog_shanse)
                    {
                        //спавним
                        LastSpawner = Instantiate(autos[num_auto].gameObject, gameObject.transform);
                        //Перемещаем на место спавна
                        LastSpawner.transform.position = gameObject.transform.position;

                        //Заспавнено.. Теперь даем рандомный маршрут из списка
                        int        num_track  = Random.Range(0, track_Points.Length);
                        Automobile automobile = LastSpawner.GetComponent <Automobile>();
                        automobile.TrackTo = track_Points[num_track];

                        time_lastspawn     = 0;
                        timeout_spawn_next = Random.Range(1.1f, timeout_spawn);

                        //Добавляем в память игрока если он есть
                        if (player != null)
                        {
                            automobile.player = player;
                        }
                        //Если это полиция включаем сирену если надо
                        if (its_police && player != null && player.gameplayParametrs.get_lvl_now() > 2)
                        {
                            LastSpawner.GetComponent <police_car>().police_active_now = true;
                            LastSpawner.GetComponent <police_car>().need_sound_yn     = polise_need_siren;
                        }
                    }
                }
            }
        }
    }
示例#9
0
    //Повернуть камеру на указанный угл
    public void ViewAngleCalc()
    {
        //Сперва проверяем активен ли гейм плей и Активно ли управление мышью
        if (gameController.GamePlay_yn && gameController.Mouse_control_yn && gameplayParametrs != null && !gameplayParametrs.pause)
        {
            //блочим курсор
            if (Cursor.lockState != CursorLockMode.Locked && mouse_control_on)
            {
                Cursor.lockState = CursorLockMode.Locked;
                Cursor.visible   = false;
            }
            else if (!mouse_control_on && old_mouse_lock == true)
            {
                old_mouse_lock   = false;
                Cursor.lockState = CursorLockMode.None;
                Cursor.visible   = true;
            }

            float dx = Input.GetAxis("Mouse X");
            float dy = Input.GetAxis("Mouse Y");

            PiiController piiController = bolt.GetComponent <PiiController>();

            //меняем угл просмотра
            if (seting == null && mouse_control_on)
            {
                ViewAngle_y += dx * MouseSpeed * Time.deltaTime;
                ViewAngle_x -= dy * MouseSpeed * Time.deltaTime;
            }
            else if (seting != null && seting.game != null && mouse_control_on)
            {
                if (!piiController.ChargeOn)
                {
                    ViewAngle_y += dx * seting.game.speedController * 0.5f;
                    ViewAngle_x -= dy * seting.game.speedController * 0.5f;
                }
                else
                {
                    ViewAngle_y += dx * seting.game.speedController * Time.deltaTime;
                    ViewAngle_x -= dy * seting.game.speedController * Time.deltaTime;
                }
            }

            //Debug.Log(mouse_pos_old_y + "  " + Input.mousePosition.y);
            //Cursor.lockState = CursorLockMode.None;

            float view_angle_new_x = ViewAngle_x - (view_angle_old_x - ViewAngle_x) / 1.1f;
            float view_angle_new_y = ViewAngle_y - (view_angle_old_y - ViewAngle_y) / 1.1f;



            view_angle_old_x = ViewAngle_x;
            view_angle_old_y = ViewAngle_y;


            //ViewAngle_x = view_angle_new_x;
            //ViewAngle_y = view_angle_new_y;

            //PiiController piiController = bolt.GetComponent<PiiController>();
            //Расчет постоянного смещения
            //inerciaPii.NewCalc();
            float piicoof = piiController.speed_pii / 10;
            if (piicoof > 1)
            {
                piicoof = 1;
            }
            if (piiController.ChargeOn)
            {
                inerciaPii.NewCalc();
                ViewAngle_x += (inerciaPii.Smehenie.x / 6) * piicoof;
                ViewAngle_y += (inerciaPii.Smehenie.y / 6) * piicoof;

                ViewAngle_x = view_angle_new_x;
                ViewAngle_y = view_angle_new_y;
            }
            else
            {
                //ViewAngle_x += (inerciaPii.Smehenie.x / 3) * piicoof;
                //ViewAngle_y += (inerciaPii.Smehenie.y / 3) * piicoof;
            }

            //}


            //Проверяем границы
            if (ViewAngle_x > 50)
            {
                ViewAngle_x = 50;
            }
            else if (ViewAngle_x < -60)
            {
                ViewAngle_x = -60;
            }

            //Границы по бокам ограничиваем ускорением в противоположную сторону
            float ViewAngle_y_max = 85;
            if (ViewAngle_y > ViewAngle_y_max)
            {
                //ViewAngle_y = 50;
                float raznica = ViewAngle_y - ViewAngle_y_max;
                if (!piiController.ChargeOn)
                {
                    ViewAngle_y -= raznica / 2 * Time.deltaTime * 5;
                }
                else
                {
                    ViewAngle_y -= raznica / 2 * Time.deltaTime;
                }
                endViewWindow.set_all_need(0, raznica / 30, 0, 0);
            }
            else if (ViewAngle_y < -1 * ViewAngle_y_max)
            {
                //ViewAngle_y = -50;
                float raznica = ViewAngle_y + ViewAngle_y_max;
                if (!piiController.ChargeOn)
                {
                    ViewAngle_y -= raznica / 2 * Time.deltaTime * 5;
                }
                else
                {
                    ViewAngle_y -= raznica / 2 * Time.deltaTime;
                }
                endViewWindow.set_all_need(-1 * raznica / 30, 0, 0, 0);
            }

            //Меняем данные у обьектов
            gameObject.transform.eulerAngles = new Vector3(0, ViewAngle_y);

            float presure = bolt.GetComponent <PiiController>().speed_pii;

            camera.transform.eulerAngles = new Vector3(ViewAngle_x + ViewCamMinus, ViewAngle_y);
            bolt.transform.eulerAngles   = new Vector3(ViewAngle_x + presure * 0.4f, ViewAngle_y);

            //Визуализация лицевого индикатора
            if (faceController != null)
            {
                faceController.set_face_grad(ViewAngle_y);
            }
        }
        else if (gameplayParametrs.pause)
        {
            if (!mouse_control_on && old_mouse_lock == true || Cursor.lockState == CursorLockMode.Locked)
            {
                old_mouse_lock   = false;
                Cursor.lockState = CursorLockMode.None;
                Cursor.visible   = true;
            }
        }
    }
示例#10
0
    //Вычисление альфы
    void TestAlpha()
    {
        //уменьшение
        alpha -= 0.025f * Time.deltaTime;
        if (alpha < 0)
        {
            alpha = 0;
        }

        float rot_horizont = player.transform.rotation.eulerAngles.y;
        float rot_vertical = player.bolt.transform.localRotation.eulerAngles.x;

        float rot_hor_need = -25.0f;
        float rot_ver_need = -30.0f;
        float cmeshenie    = 30.0f;

        float coof_hor = 0;

        if (rot_horizont > 180)
        {
            rot_horizont -= 360.0f;
        }
        float raznicaHor = rot_hor_need - rot_horizont;

        if (raznicaHor > 0 && raznicaHor < cmeshenie)
        {
            coof_hor = 1 - (raznicaHor / cmeshenie);
        }
        else if (raznicaHor < 0 && raznicaHor > -cmeshenie)
        {
            coof_hor = 1 - (raznicaHor / -cmeshenie);
        }

        float coof_ver = 0;

        if (rot_vertical > 180)
        {
            rot_vertical -= 360.0f;
        }
        float raznicaVer = rot_ver_need - rot_vertical;

        if (raznicaVer > 0 && raznicaVer < cmeshenie / 2)
        {
            coof_ver = 1 - (raznicaVer / cmeshenie / 2);
        }
        else if (raznicaVer < 0 && raznicaVer > -cmeshenie / 2)
        {
            coof_ver = 1 - (raznicaVer / -cmeshenie / 2);
        }

        //Debug.Log("rot_horizont" + rot_horizont + " rot_hor_need" + rot_hor_need + " coof_hor" + coof_hor);

        //провека силы напора
        PiiController bolt = player.bolt.GetComponent <PiiController>();

        float powerBolt    = bolt.speed_pii + 10;
        float coofBolt     = 0;
        float powerBoltMax = 60;

        if (powerBolt > 40)
        {
            if (powerBolt > powerBoltMax)
            {
                coofBolt = 1;
            }
            else
            {
                coofBolt = 1 - ((powerBoltMax - powerBolt) / 20);
            }

            float newAlpha = coof_hor * coof_ver * coofBolt;
            if (newAlpha > alpha)
            {
                alpha += (newAlpha - alpha) / 3f;
            }
        }
    }