コード例 #1
0
    void Start()
    {
        if (ileriYolObjeleri.Length != ileriYolObjeleriUzunluklar.Length)
        {
            // Eğer her bir zemin prefab'ının uzunluğu tek tek girilmemişse hata mesajı verip
            // component'i objeden at (yani oyunu oynanmaz hale getir)
            Debug.LogError("HATA: SonsuzYolScript'teki Duz Yol Objeleri ile " +
                           "Duz Yol Objeleri Uzunluklar'ın boyutu (size) " +
                           "aynı olmak zorundadır.");

            Destroy(this);
        }
        else
        {
            // Havuzu (pool) doldur
            havuz = GetComponent <ObjeHavuzu>();

            int havuzdakiObjeSayisi = yolMaksimumUzunluk / 3;
            havuz.HavuzuDoldur(ileriYolObjeleri, solaDonus, sagaDonus,
                               ikiYoneDonus, puanPrefab, havuzdakiObjeSayisi,
                               ardArdaDiziliPuanObjesiSayisi);
            // Havuzu doldurduk!

            // Rastgele bir yol oluştur
            ileriYol = new YolContainer();
            sagYol   = new YolContainer();
            solYol   = new YolContainer();

            YolOlustur(ileriYol, Vector3.forward * -314.6f, Vector3.forward);
            DonemecOlustur(ileriYol.BitisNoktasi(), ileriYol.Yon());
        }
    }
コード例 #2
0
    // Random bir şekilde düz bir yol oluşturmaya yarayan fonksiyon
    private void YolOlustur(YolContainer c, Vector3 baslangicNoktasi, YolYonu yolYonu)
    {
        // yolun uzunluğunu rastgele olarak belirle
        int yolUzunluk = Random.Range(yolMinimumUzunluk, yolMaksimumUzunluk + 1);

        // yolu oluştur (yola zeminleri dik)
        c.YolOlustur(baslangicNoktasi, yolYonu, yolUzunluk);
        // yola puan objelerini diz
        c.YolaPuanObjeleriDiz(ardArdaDiziliPuanObjesiSayisi);
    }
コード例 #3
0
    private void Start()
    {
        // Rastgele bir yol oluştur
        ileriYol = new YolContainer();
        sagYol   = new YolContainer();
        solYol   = new YolContainer();

        YolOlustur(ileriYol, new Vector3(0f, 0f, 15f), YolYonu.Ileri);
        DonemecOlustur(ileriYol.BitisNoktasi, YolYonu.Ileri);
    }
コード例 #4
0
    // Random bir şekilde düz bir yol oluşturmaya yarayan fonksiyon
    void YolOlustur(YolContainer c, Vector3 baslangicNoktasi, Vector3 ileriYon)
    {
        // yolun uzunluğunu rastgele olarak belirle
        int yolUzunluk = Random.Range(yolMinimumUzunluk, yolMaksimumUzunluk + 1);

        baslangicNoktasi.y = 19.2f;
        // yolu oluştur (yola zeminleri dik)
        c.YolOlustur(havuz, ileriYolObjeleriUzunluklar, baslangicNoktasi, ileriYon, yolUzunluk);
        // yola puan objelerini diz
        c.YolaPuanObjeleriDiz(havuz, ardArdaDiziliPuanObjesiSayisi);
    }
コード例 #5
0
    void Update()
    {
        if (sol)
        {
            // Eğer ileriYol'un ucundaki kavşaktan sola dönme talimatı verilmişse:
            sol = false;

            // eğer elimizde bir solYol varsa (yani bu kavşaktan sola dönüş mümkünse):
            if (solYol.Uzunluk() > 0)
            {
                // karakteri (player) 90 derece sola döndür
                Player player = GameObject.FindWithTag("Player").GetComponent <Player>();
                player.transform.Rotate(Vector3.down * 90f);

                // player'ın yön değişkenlerini ayarla
                Vector3 bn = solYol.BitisNoktasi();
                Vector3 iy = solYol.Yon();
                player.ileriYon = iy;
                player.sagYon   = solYol.SagYon();

                // player'ın yatay eksende gidebileceği minimum ve maksimum limitleri ayarla
                if (iy == Vector3.forward || iy == Vector3.back)
                {
                    player.limitMinDeger = bn.x - 17f;
                    player.limitMaxDeger = bn.x + 17f;
                }
                else
                {
                    player.limitMinDeger = bn.z - 17f;
                    player.limitMaxDeger = bn.z + 17f;
                }

                // sol yolu artık ileri yol (üzerinde koşulan yol) olarak ata
                YolContainer temp = ileriYol;
                ileriYol = solYol;
                solYol   = temp;

                // yolun devamını oluştur
                StartCoroutine(YoluGuncelle());
            }
        }
        else if (sag)
        {
            // Eğer ileriYol'un ucundaki kavşaktan sağa dönme talimatı verilmişse:
            sag = false;

            // eğer elimizde bir sagYol varsa (yani bu kavşaktan sağa dönüş mümkünse):
            if (sagYol.Uzunluk() > 0)
            {
                // karakteri (player) 90 derece sağa döndür
                Player player = GameObject.FindWithTag("Player").GetComponent <Player>();
                player.transform.Rotate(Vector3.up * 90f);

                // player'ın yön değişkenlerini ayarla
                Vector3 bn = sagYol.BitisNoktasi();
                Vector3 iy = sagYol.Yon();
                player.ileriYon = iy;
                player.sagYon   = sagYol.SagYon();

                // player'ın yatay eksende gidebileceği minimum ve maksimum limitleri ayarla
                if (iy == Vector3.forward || iy == Vector3.back)
                {
                    player.limitMinDeger = bn.x - 17f;
                    player.limitMaxDeger = bn.x + 17f;
                }
                else
                {
                    player.limitMinDeger = bn.z - 17f;
                    player.limitMaxDeger = bn.z + 17f;
                }

                // sağ yolu artık ileri yol (üzerinde koşulan yol) olarak ata
                YolContainer temp = ileriYol;
                ileriYol = sagYol;
                sagYol   = temp;

                // yolun devamını oluştur
                StartCoroutine(YoluGuncelle());
            }
        }
    }
コード例 #6
0
    private void Update()
    {
        YolContainer yeniIleriYol;

        if (sol)          // Eğer ileriYol'un ucundaki kavşaktan sola dönme talimatı verilmişse
        {
            yeniIleriYol = solYol;
        }
        else if (sag)          // Eğer ileriYol'un ucundaki kavşaktan sağa dönme talimatı verilmişse
        {
            yeniIleriYol = sagYol;
        }
        else
        {
            yeniIleriYol = null;
        }

        // eğer elimizde geçerli bir yol varsa (yani bu kavşaktan ilgili yöne dönüş mümkünse):
        if (yeniIleriYol != null && yeniIleriYol.Uzunluk > 0)
        {
            // player'ın yön değişkenlerini ayarla
            Player player = Player.Instance;
            player.transform.localEulerAngles = YolEgiminiBul(yeniIleriYol.Yon);
            player.yon      = yeniIleriYol.Yon;
            player.ileriYon = yeniIleriYol.IleriYon;
            player.sagYon   = yeniIleriYol.SagYon;

            // player'ın yatay eksende gidebileceği minimum ve maksimum limitleri
            // ayarla (konseptle alakalı detaylı açıklama Player scriptinde mevcut)
            Vector3 yolBitisNoktasi = yeniIleriYol.BitisNoktasi;
            if (yeniIleriYol.Yon == YolYonu.Ileri || yeniIleriYol.Yon == YolYonu.Geri)
            {
                player.limitMinDeger = yolBitisNoktasi.x - 2.75f;
                player.limitMaxDeger = yolBitisNoktasi.x + 2.75f;
            }
            else
            {
                player.limitMinDeger = yolBitisNoktasi.z - 2.75f;
                player.limitMaxDeger = yolBitisNoktasi.z + 2.75f;
            }

            // sol yolu artık ileri yol (üzerinde koşulan yol) olarak ata
            YolContainer temp = ileriYol;
            ileriYol = yeniIleriYol;

            if (sol)
            {
                solYol = temp;
            }
            else
            {
                sagYol = temp;
            }

            // yolun devamını oluştur
            StartCoroutine(YoluGuncelle());
        }

        sol = false;
        sag = false;
    }