Разные вопросы от нуба AngryGrey :)

[WereVarg]

Синтаксис:

Синтаксис: [ Показать ]

Используется csharp

 foreach (Transfrom kid in BigDaddy) Destroy (kid.gameObject);
 

[AngryGrey]

Помогите кто нибудь, а то сам как то в замешательстве.

Необходимо отсчитать 10 секунд, после чего вывести сообщение, после сообщения отсчитать еще 5 секунд и вывести другое! (это просто для примера, на самом деле все гораздо сложнее нежели обычный вывод сообщения, но структура такая же)

Некий скрипт подобный вот этому:

Синтаксис:

Синтаксис: [ Показать ]

Используется csharp

using UnityEngine;
using System.Collections;

public class asas : MonoBehaviour {
                private float timer;
                private float sd = 5.0f;
        // Use this for initialization
        void Start () {
        timer = 10.0f;
        }
       
        // Update is called once per frame
        void Update () {
                        if (timer > 0)
                        {      
                                timer -= Time.deltaTime;
                        }
                        else if (timer <= 0)
                        {
                                //Выводим сообщение через 10секунд
                                Debug.Log("10s lost");
                                //Вроде как должна быть паузой
                                while (sd > 0){
                                        sd -= Time.deltaTime;
                                }
                                //Выводим сообщение после паузы
                                Debug.Log("5s lost");
                                timer=10.0f;
                                sd=5.0f;
                        }
        }
}

 

В Update это все запихивать нельзя, не будет работать ни практически, ни теоритически... Вторая надпись будет выводится игнорируя задержку в while, т.е. сразу же после первой, а не через 5 секунд...
Как подобное реализовать в UNITY, мне не понятно

[waruiyume]

Синтаксис:

Синтаксис: [ Показать ]

Используется csharp

using UnityEngine;
using System.Collections;

public class NewBehaviourScript : MonoBehaviour
{
        // Use this for initialization
        void Start ()
        {
            StartCoroutine("Test");
        }

    IEnumerator Test()
    {
        yield return new WaitForSeconds(1f);
        Debug.Log("1");
        yield return new WaitForSeconds(3f);
        Debug.Log("3");
        yield return new WaitForSeconds(4f);
        Debug.Log("4");
        yield return new WaitForSeconds(5f);
        Debug.Log("5");
    }
}
 

http://docs.unity3d.com/Documentation/S ... Yield.html

[AngryGrey]

В общем крутил я эту функцию и так и этак... и либо она мне не подходит... либо я чет не так делаю...

[AngryGrey]

Вот, может кому пригодится.
Скрипт почти полностью описывает игру тетрис. Скрипт не оптимизирован и крайне сырой.

Синтаксис:

Синтаксис: [ Показать ]

Используется csharp

using UnityEngine;
using System.Collections;

public class BaseScript : MonoBehaviour {
        public Transform baseBlock;
        public Transform basePlane;
        public Transform exposion;
        private Transform myTransform;
        private bool game_stop = false;
        //Переменные таймера
        private float myTimer = 1.0f;
        private float timer;
        private float myTimerStop = 4.0f;
        //-----------------------------------------
        //Переменные размеров игрового поля
        public int x = 0;
        public int y = 0;
        //Массив кубиков игрового поля
        private Transform[,] Base;
        //Массив текущего состояния стакана
        private int[,] ready_mass;
        //-----------------------------------------
       
        //Массив хранящий фигуру (нужен для расчета поворота)
        private int[,] figura;
        //Ширина фигуры
        private int xf = 0;
        //Высота фигуры
        private int yf = 0;
        //Текущее положение фигуры
        private int xp = 0;
        private int yp = 0;
        //Координаты взятые из массива текущих координат точек фигуры
        private int i_gps = 0;
        private int n_gps = 0;
        //Массив текущих координат точек фигуры
        private int[,] gpsFigura = new int [4,2];
        //Номер существующей фигуры
        private int f_num = 0;
        //Номер фигуры, которая будет создана
        private int f_f_num = 0;
        //Массив строк для удаления
        private int[] y_destroy;
        //Количесво удаляемых строк
        private int ny_destroy;
       
        //Функция предназначенная для расчета поворота фигуры
        void rotate_figura(bool R_rotate){
                int [,] temp_figura = new int [yf,xf];
                i_gps = 0;
                n_gps = 0;
                bool ok = true;
                int[,] fgpsFigura = new int [4,2];
                for (int i = 0; i < xf && ok; i++)
                        {
                                for (int n = 0; n < yf; n++)
                                {
                                        if (R_rotate){
                                                //Поворот вправо
                                                temp_figura[(yf-1)-n,i]=figura[(xf-1)-i,(yf-1)-n];
                                        }
                                        else{
                                                //Поворот влево
                                                temp_figura[(yf-1)-n,i]=figura[i,n];
                                        }
                                        //Сохранение новых координат точек фигуры
                                    if (temp_figura[(yf-1)-n,i]>0)
                                        {
                                                if (ready_mass[(yf-1)-n+xp,i+yp]>0)
                                                {
                                                        ok = false;
                                                        break;
                                                }
                                                fgpsFigura[i_gps,n_gps] = (yf-1)-n;
                                                fgpsFigura[i_gps,n_gps+1] = i;
                                                i_gps++;       
                                        }
                                }
                        }
                if (ok)
                {
                        for (int i = 0; i < 4; i++)
                        {
                                gpsFigura[i,0] = fgpsFigura[i,0];
                                gpsFigura[i,1] = fgpsFigura[i,1];
                        }
                        figura = new int [yf,xf];
                        figura = temp_figura;
                        int temp = xf;
                        xf = yf;
                        yf = temp;
                }
        }              
       
        //Функция отвечает за возможность движения фигуры
        bool colider_figura(int tempXp, int tempYp){
                i_gps = 0;
                n_gps = 0;
                if (tempXp < 0 || tempXp > x-xf || tempYp < 0)
                {
                        return false;
                }
                else{
                        for (int i = 0; i < 4; i++)
                        {
                                i_gps = gpsFigura[i,0];
                                n_gps = gpsFigura[i,1];
                                if (ready_mass[i_gps + tempXp, n_gps + tempYp]>0)
                                {
                                        return false;
                                }
                        }
                }
                return true;
        }
       
        //Функция предназначена для построения игрового поля размером X на Y
        void build() {
                ready_mass = new int [x,y];
                y_destroy = new int [y];
                Base = new Transform [x,y]; //Инициализация массива размером X на Y
                 //Установка на сцену "подложки" игрового поля
                Transform clone_basePlane = Instantiate (basePlane, myTransform.position, Quaternion.identity) as Transform;
                //Расчет положения и масштаба "подложки" игрового поля в зависимости от количества кубиков
                clone_basePlane.localScale = new Vector3((baseBlock.transform.localScale.x+0.5f)*x, 0.1f, (baseBlock.transform.localScale.z+0.5f)*y);
                clone_basePlane.position = new Vector3(
                                                                        myTransform.position.x+(x-1)*(baseBlock.transform.localScale.x+0.5f)/2.0f,
                                                                        myTransform.position.y,
                                                                        myTransform.position.z+(y-1)*(baseBlock.transform.localScale.z+0.5f)/2.0f);
               
                clone_basePlane.parent = myTransform;
               
                //Цикл заполнения
                for (int i = 0; i < x; i++)
                {
                        for (int n = 0;  n < y; n++)
                        {
                                        Transform clone_baseBlock = Instantiate (baseBlock, new Vector3 (
                                                                                                                        myTransform.position.x+(baseBlock.transform.localScale.x+0.5f)*i,
                                                                                                                        myTransform.position.y+baseBlock.transform.localScale.z/2.0f+0.2f,
                                                                                                                        myTransform.position.z+(baseBlock.transform.localScale.z+0.5f)*n),
                                                                                                Quaternion.identity) as Transform;
                                       
                                        Base[i,n] = clone_baseBlock;
                                        clone_baseBlock.parent = myTransform;
                        }
                }
        }
       

       
        //Функция создания фигур
        void spawn(){
                f_num = f_f_num;
                f_f_num = Random.Range(0,7);
                if (f_num == 0){
                        //Фигура "Г"
                        xf = 2;
                        yf = 3;
                        figura = new int[xf,yf];
                        figura[0,0] = 1;
                        figura[0,1] = 1;
                        figura[0,2] = 1;
                        figura[1,2] = 1;
                }
                if (f_num == 1){
                        //Фигура "L"
                        xf = 2;
                        yf = 3;
                        figura = new int[xf,yf];
                        figura[1,0] = 1;
                        figura[1,1] = 1;
                        figura[1,2] = 1;
                        figura[0,2] = 1;
                }
                if (f_num == 2){
                        //Фигура "Z"
                        xf = 2;
                        yf = 3;
                        figura = new int[xf,yf];
                        figura[0,0]=1;
                        figura[0,1]=1;
                        figura[1,1]=1;
                        figura[1,2]=1;
                }
                if (f_num == 3){
                        //Фигура "S"
                        xf = 2;
                        yf = 3;
                        figura = new int[xf,yf];
                        figura[0,1]=1;
                        figura[0,2]=1;
                        figura[1,1]=1;
                        figura[1,0]=1;
                }
                if (f_num == 4){
                        //Фигура "I"
                        xf = 1;
                        yf = 4;
                        figura = new int[xf,yf];
                        figura[0,0] = 1;
                        figura[0,1] = 1;
                        figura[0,2] = 1;
                        figura[0,3] = 1;
                }
                if (f_num == 5){
                        //Фигура "квадрат"
                        xf = 2;
                        yf = 2;
                        figura = new int[xf,yf];
                        figura[0,0] = 1;
                        figura[0,1] = 1;
                        figura[1,0] = 1;
                        figura[1,1] = 1;
                }
                if (f_num == 6){
                        //Фигура "Т"
                        xf = 2;
                        yf = 3;
                        figura = new int [xf,yf];
                        figura[0,0]=1;
                        figura[0,1]=1;
                        figura[0,2]=1;
                        figura[1,1]=1;
                }
                //Запоминание новых координат точек              
                i_gps = 0;
                n_gps = 0;
                for (int i = 0; i < xf; i++)
                        {
                                for (int n = 0; n < yf; n++)
                                {
                                        if (figura[i,n]>0)
                                        {
                                                gpsFigura[i_gps,n_gps] = i;
                                                gpsFigura[i_gps,n_gps+1] = n;
                                                i_gps++;
                                        }
                                }
                        }              
                xp=Mathf.RoundToInt(x/2)-1;
                yp=y-yf;               
        }
       
        //---------------------------------------------Основная фунция игры---------------------------------------------------------
        void main_game(){
        //Если при следующем ходе нет препятсвий, то ход
        if (colider_figura(xp,yp-1))
                {
                        yp--;
                }
        //Иначе
        else
                {
                        //Если положение фигуры больше размерности поля игры, то игра окончена
                        if (yp+yf >= y)
                                {
                                        game_stop = true;
                                        Debug.Log("Game END");
                                        return;
                                }
                        //Иначе, добавляем фигуру к общему массиву в месте остановки
                        else
                                {
                                        i_gps = 0;
                                        n_gps = 0;
                                        for (int i = 0; i < 4; i++)
                                                {
                                                        i_gps = gpsFigura[i,0];
                                                        n_gps = gpsFigura[i,1];
                                                        ready_mass[i_gps+xp,n_gps+yp] = figura[i_gps,n_gps];
                                                }
                                       
                                        //От сюда идет проверка на наличие заполенных строк массива
                                        ny_destroy = 0;
                                        bool clear_full = false;
                                        for (int n = yp; n < yp+yf; n++)
                                                {
                                                        bool full = true;
                                                        for (int i = 0; i < x; i++)
                                                                {
                                                                        if (ready_mass[i,n] == 0)
                                                                                {
                                                                                        full = false;
                                                                                        break;
                                                                                }      
                                                                }
                                                        //Если есть полная строка, то она отмечается
                                                        if (full)
                                                                {
                                                                        y_destroy[ny_destroy] = n;
                                                                        ny_destroy++;
                                                                        clear_full = true;
                                                                }
                                                }
                                        //Если было хоть одно зануление, то разрушаем стакан
                                        if(clear_full)
                                                {
                                                        //Функция до сдвига должна будет удалить кубы и воспроизвести взрыв
                                                        for (int i = 0; i < ny_destroy; i++)
                                                                {
                                                                        for (int n = 0; n < x; n++)
                                                                                {
                                                                                        ready_mass[n,y_destroy[i]] = 0;
                                                                                        Instantiate (exposion, Base[n,y_destroy[i]].transform.position, Quaternion.identity);
                                                                                        game_stop = true;
                                                                                }
                                                                }
                                                }
                                        spawn();                       
                                }
                }
        }      
        //------------------------------------------------------------------------------------------------------------------------------
       
       
       
       
       
        // Use this for initialization
        void Start () {
        myTransform = transform;
        gameObject.renderer.enabled = false;
        build();
        f_f_num = Random.Range(0,7);
        spawn();
        }

        // Update is called once per frame
        void Update () {
               
        //Обработка клавиш
        if (Input.GetMouseButtonDown(0))
                {
                        rotate_figura(true);
                }
        if (Input.GetMouseButtonDown(1))
                {
                        rotate_figura(false);
                }
                if (Input.GetKeyDown("a") && colider_figura(xp-1,yp))
                {
                        xp--;
                }
                if (Input.GetKeyDown("d") && colider_figura(xp+1,yp))
                {
                        xp++;
                }      
                if (Input.GetKeyDown("s"))
                {
                        myTimer = 0.05f;
                }
                if (Input.GetKeyUp("s"))
                {
                        myTimer = 1.0f;
                }
               
                //-------------Основной таймер игры-----------------------
                if (timer > 0 && !game_stop)
                        {      
                                timer -= Time.deltaTime;
                        }
                else if (timer <= 0 && !game_stop)
                        {
                                main_game();
                                timer = myTimer;       
                        }
                //---------------------------------------------------------
               
               
                //-----------------------Таймер ожидания происходящих событий----------------------------
                if (myTimerStop > 0 && game_stop)
                        {
                                myTimerStop -= Time.deltaTime;
                        }
                else if (myTimerStop <= 0 && game_stop)
                        {      
                                //Пересовка игрового поля
                                int destroyed = 0;
                                for (int p = 0; p < ny_destroy; p++)
                                        {
                                                for (int n = y_destroy[p]; n < y-1; n++)
                                                        {
                                                                for (int i = 0; i < x; i++)
                                                                        {
                                                                                ready_mass[i,n-destroyed] = ready_mass[i,n-destroyed+1];
                                                                        }
                                                        }
                                                destroyed++;
                                        }
                                game_stop = false;
                                timer = myTimer;
                                myTimerStop = 4.0f;
                        }
        //-------------------------------------------------------------------------------------------
               
               
        //-----------------------Прорисовка игрового поля----------------------------
        for (int i = 0; i < x; i++)
                {
                        for (int n = 0; n < y; n++)
                        {
                                if (ready_mass[i,n]>0)
                                {
                                        Base[i,n].gameObject.renderer.enabled = true;
                                }      
                                else
                                {
                                        Base[i,n].gameObject.renderer.enabled = false;
                                }
                        }
                }
                i_gps = 0;
                n_gps = 0;
                for (int i = 0; i < 4; i++)
                        {
                                i_gps = gpsFigura[i,0];
                                n_gps = gpsFigura[i,1];
                                if (i_gps+xp < x && n_gps+yp < y)
                                {
                                        Base[i_gps+xp,n_gps+yp].gameObject.renderer.enabled = true;
                                }
                        }
        //---------------------------------------------------------------------------
               
        }
}

 

[lawson]

и что ты хочешь, медаль за проделанную работу?

[Denis313]