Levels (Seviyeler)

Breakout maalesef yalnızca tek bir mutlu yeşil yüzden ibaret değil; çok sayıda renkli tuğlayla dolu seviyeleri olan bir oyun. Bu seviyelerin herhangi sayıda satır ve/veya sütunu destekleyecek şekilde yapılandırılabilir olmasını, yıkılamayan sağlam tuğlalar içermesini, birden fazla tuğla rengine sahip olmasını ve (metin) dosyalarında harici olarak saklanmasını istiyoruz.

Bu bölümde çok sayıda tuğlayı yönetmek için kullanılan bir oyun seviyesi nesnesinin koduna kısaca bakacağız. Öncelikle bir tuğlanın ne olduğunu tanımlamamız gerekiyor.

Oyundaki bir nesnenin temel temsilcisi olarak hareket eden oyun nesnesi (game object) adlı bir bileşen oluşturuyoruz. Böyle bir oyun nesnesi konum, boyut ve hız gibi durum verilerini tutar. Renk, döndürme bileşeni, solid ve/veya yıkılmış olup olmadığı ile sprite olarak bir Texture2D değişkeni içerir.

Oyundaki her nesne GameObject sınıfının bir örneği veya türevi olarak temsil edilir. GameObject sınıfının kaynak kodu: başlık, kod.

Breakout'taki bir seviye tamamen tuğlalardan oluşur; bu nedenle bir seviyeyi tam olarak bu şekilde temsil edebiliriz: tuğlalar koleksiyonu. Bir tuğla, oyun nesnesiyle aynı duruma ihtiyaç duyduğundan seviyedeki her tuğlayı GameObject olarak temsil ediyoruz. GameLevel sınıfının bildirimi şöyle görünür:

class GameLevel
{
public:
    // seviye durumu
    std::vector<GameObject> Bricks;
    // kurucu
    GameLevel() { }
    // seviyeyi dosyadan yükle
    void Load(const char *file, unsigned int levelWidth, unsigned int levelHeight);
    // seviyeyi çiz
    void Draw(SpriteRenderer &renderer);
    // seviyenin tamamlanıp tamamlanmadığını kontrol et (yıkılabilir tüm tuğlalar yıkıldı mı)
    bool IsCompleted();
private:
    // seviyeyi kutucuk verisinden başlat
    void init(std::vector<std::vector<unsigned int>> tileData, 
              unsigned int levelWidth, unsigned int levelHeight);
};

Seviye harici bir (metin) dosyasından yüklendiğinden bir tür seviye yapısı önermeliyiz. Seviyenin metin dosyasında nasıl görünebileceğine dair örnek:

1 1 1 1 1 1 
2 2 0 0 2 2
3 3 4 4 3 3

Seviye, her sayının bir tuğla türünü temsil ettiği ve her birinin boşlukla ayrıldığı matris benzeri bir yapıda saklanır. Seçtiğimiz temsil:

• 0: Tuğla yok, seviyede boş alan.

• 1: Sağlam tuğla, yıkılamaz.

• 1'den büyük her sayı: Yıkılabilir tuğla; her sayı yalnızca renk bakımından farklılık gösterir.

Yukarıdaki örnek seviye GameLevel tarafından işlendikten sonra şöyle görünür:

Seviye örneği

GameLevel sınıfı, seviyeyi dosyadan üretmek için iki fonksiyon kullanır. İlk olarak Load fonksiyonunda tüm sayılar iki boyutlu bir vektöre yüklenir; ardından init fonksiyonu bu sayıları işler:

void GameLevel::Load(const char *file, unsigned int levelWidth, unsigned int levelHeight)
{
    // eski verileri temizle
    this->Bricks.clear();
    // dosyadan yükle
    unsigned int tileCode;
    GameLevel level;
    std::string line;
    std::ifstream fstream(file);
    std::vector<std::vector<unsigned int>> tileData;
    if (fstream)
    {
        while (std::getline(fstream, line))
        {
            std::istringstream sstream(line);
            std::vector<unsigned int> row;
            while (sstream >> tileCode)
                row.push_back(tileCode);
            tileData.push_back(row);
        }
        if (tileData.size() > 0)
            this->init(tileData, levelWidth, levelHeight);
    }
}

Yüklenen tileData, oyun seviyesinin init fonksiyonuna iletilir:

void GameLevel::init(std::vector<std::vector<unsigned int>> tileData, 
                     unsigned int lvlWidth, unsigned int lvlHeight)
{
    // boyutları hesapla
    unsigned int height = tileData.size();
    unsigned int width  = tileData[0].size();
    float unit_width    = lvlWidth / static_cast<float>(width);
    float unit_height   = lvlHeight / height;
    // tileData'ya göre seviye kutucuklarını başlat
    for (unsigned int y = 0; y < height; ++y)
    {
        for (unsigned int x = 0; x < width; ++x)
        {
            if (tileData[y][x] == 1) // solid
            {
                glm::vec2 pos(unit_width * x, unit_height * y);
                glm::vec2 size(unit_width, unit_height);
                GameObject obj(pos, size, 
                    ResourceManager::GetTexture("block_solid"), 
                    glm::vec3(0.8f, 0.8f, 0.7f)
                );
                obj.IsSolid = true;
                this->Bricks.push_back(obj);
            }
            else if (tileData[y][x] > 1)	
            {
                glm::vec3 color = glm::vec3(1.0f); // orijinal: beyaz
                if (tileData[y][x] == 2)
                    color = glm::vec3(0.2f, 0.6f, 1.0f);
                else if (tileData[y][x] == 3)
                    color = glm::vec3(0.0f, 0.7f, 0.0f);
                else if (tileData[y][x] == 4)
                    color = glm::vec3(0.8f, 0.8f, 0.4f);
                else if (tileData[y][x] == 5)
                    color = glm::vec3(1.0f, 0.5f, 0.0f);

                glm::vec2 pos(unit_width * x, unit_height * y);
                glm::vec2 size(unit_width, unit_height);
                this->Bricks.push_back(
                    GameObject(pos, size, ResourceManager::GetTexture("block"), color)
                );
            }
        }
    }  
}

init fonksiyonu yüklenen her sayıyı yineler ve işlenen sayıya göre seviyenin Bricks vektörüne bir GameObject ekler. Her tuğlanın boyutu (unit_width ve unit_height), toplam tuğla sayısına göre otomatik hesaplanır; böylece her tuğla ekran sınırlarına mükemmel biçimde sığar.

İki yeni doku ile oyun nesnelerini yüklüyoruz: bir block dokusu ve bir solid block dokusu.

Tuğla dokuları

Güzel bir numara: bu dokular tamamen gri tonlamadır. Bu sayede oyun kodundaki gri tonlamalı renkleri tanımlanmış renk vektörüyle çarptığımızda renkleri düzgünce değiştirebiliriz; tıpkı SpriteRenderer'da yaptığımız gibi.

GameLevel sınıfının kaynak kodu: başlık, kod.

---

Oyun İçinde

Breakout oyununda birden fazla seviyeyi desteklemek istediğimizden, oyun sınıfını GameLevel türünde değişkenler barındıran bir vektör ekleyerek biraz genişletmemiz gerekiyor. Aktif seviyeyi de depoluyoruz:

class Game
{
    [...]
    std::vector<GameLevel> Levels;
    unsigned int           Level;
    [...]  
};

Bu serinin Breakout oyunu toplam 4 seviye içeriyor:

• Standard

• A few small gaps

• Space invader

• Bounce galore

Dokular ve seviyeler oyun sınıfının Init fonksiyonunda başlatılır:

void Game::Init()
{
    [...]
    // dokuları yükle
    ResourceManager::LoadTexture("textures/background.jpg", false, "background");
    ResourceManager::LoadTexture("textures/awesomeface.png", true, "face");
    ResourceManager::LoadTexture("textures/block.png", false, "block");
    ResourceManager::LoadTexture("textures/block_solid.png", false, "block_solid");
    // seviyeleri yükle
    GameLevel one; one.Load("levels/one.lvl", this->Width, this->Height / 2);
    GameLevel two; two.Load("levels/two.lvl", this->Width, this->Height / 2);
    GameLevel three; three.Load("levels/three.lvl", this->Width, this->Height / 2);
    GameLevel four; four.Load("levels/four.lvl", this->Width, this->Height / 2);
    this->Levels.push_back(one);
    this->Levels.push_back(two);
    this->Levels.push_back(three);
    this->Levels.push_back(four);
    this->Level = 0;
}

Şimdi geriye kalan, seviyeyi gerçekten çizmek. Bunu mevcut aktif seviyenin Draw fonksiyonunu çağırarak yapıyoruz; bu da her GameObject'in Draw fonksiyonunu çağırır. Seviyenin yanı sıra güzel bir arka plan görüntüsüyle sahneyi de çiziyoruz:

void Game::Render()
{
    if(this->State == GAME_ACTIVE)
    {
        // arka planı çiz
        Renderer->DrawSprite(ResourceManager::GetTexture("background"), 
            glm::vec2(0.0f, 0.0f), glm::vec2(this->Width, this->Height), 0.0f
        );
        // seviyeyi çiz
        this->Levels[this->Level].Draw(*Renderer);
    }
}

Sonuç, oyunu gerçekten daha canlı hissettiren güzelce çizilmiş bir seviye:

Seviye renderı

Oyuncu Paddle'ı

Fırsatı kaçırmamak için sahnenin alt kısmına oyuncu tarafından kontrol edilen bir paddle ekleyelim. Paddle yalnızca yatay harekete izin verir ve sahnenin herhangi bir kenarına dokunduğunda hareketi durmalıdır. Paddle için şu dokuyu kullanacağız:

Paddle dokusu

Paddle nesnesinin bir konumu, boyutu ve sprite dokusu olacağından paddle'ı da GameObject olarak tanımlamak mantıklı:

// Oyuncu paddle'ının başlangıç boyutu
const glm::vec2 PLAYER_SIZE(100.0f, 20.0f);
// Oyuncu paddle'ının başlangıç hızı
const float PLAYER_VELOCITY(500.0f);

GameObject *Player;
  
void Game::Init()
{
    [...]    
    ResourceManager::LoadTexture("textures/paddle.png", true, "paddle");
    [...]
    glm::vec2 playerPos = glm::vec2(
        this->Width / 2.0f - PLAYER_SIZE.x / 2.0f, 
        this->Height - PLAYER_SIZE.y
    );
    Player = new GameObject(playerPos, PLAYER_SIZE, ResourceManager::GetTexture("paddle"));
}

Oyunun ProcessInput fonksiyonuna da giriyoruz; kullanıcı A veya D tuşuna bastığında paddle'ı yatay olarak hareket ettiriyoruz:

void Game::ProcessInput(float dt)
{
    if (this->State == GAME_ACTIVE)
    {
        float velocity = PLAYER_VELOCITY * dt;
        // oyuncu tahtasını hareket ettir
        if (this->Keys[GLFW_KEY_A])
        {
            if (Player->Position.x >= 0.0f)
                Player->Position.x -= velocity;
        }
        if (this->Keys[GLFW_KEY_D])
        {
            if (Player->Position.x <= this->Width - Player->Size.x)
                Player->Position.x += velocity;
        }
    }
}

x değerinin 0'dan küçük olması durumunda sol kenara taşmış olacağından, paddle'ı yalnızca sol tarafta x değeri 0.0'dan büyük olduğunda sola taşırız. Sağ kenar için de aynı karşılaştırmayı yapıyoruz; paddle'ın genişliğini sağ kenarın x konumundan çıkarmamız gerekiyor.

Oyunu çalıştırdığınızda hem seviyeyi hem de sahnenin alt kenarına hizalanmış bir paddle görürsünüz:

Seviye + paddle

Güncellenmiş Game sınıfı kaynak kodu: başlık, kod.