C++ ile Labirent Oyunu Oluşturmak İçin Adım Adım Kılavuz

Ana Sayfa » Python » C++ ile Labirent Oyunu Oluşturmak İçin Adım Adım Kılavuz

Eğer C++ kullanarak kendi labirent oyununuzu geliştirmek istediyseniz... Eğer grafik motorları, fizik kütüphaneleri veya ses ara yazılımları sizi bunaltıyorsa, bu kılavuz tam size göre. Başlangıçta gerçekten önemli olan şeylere odaklanacağız: oyunun iç mantığı, dünyanın bellekte nasıl yaşadığı ve oyuncunun klavye aracılığıyla onunla nasıl etkileşim kurduğu. Bu temel sağlamlaştıktan sonra, görsel incelik veya süslü efektler eklemek, aşılması imkansız bir dağ olmaktan ziyade sadece bir katman daha haline gelir.

Buradaki amaç, C++ kullanarak tamamen oynanabilir bir labirent deneyimi yaratmaktır. Basit bir konsol sürümünden başlayarak, kavramsal olarak daha gelişmiş bir DirectX 3D projesi olan UWP "Mermer Labirent" ile bağlantı kuracağız. Labirenti ızgaralarla nasıl temsil edeceğinizi, oyuncu konumunu haritadan ayrı olarak nasıl yöneteceğinizi, hareketi nasıl doğrulayacağınızı, toplanabilir eşyalar ve tuzaklar eklemeyi, canları nasıl ele alacağınızı, zamanı nasıl takip edeceğinizi ve temel bir oyun döngüsünü nasıl yapılandıracağınızı göreceksiniz. Bu süreçte, aynı fikirlerin daha zengin girdi ve ses içeren grafiksel bir 3D labirente nasıl uyarlanabileceğini de göstereceğiz.

Labirenti Bellek İçi Bir Izgara Olarak Tasarlamak

Konsol labirent oyunumuzun temeli, satır ve sütunlardan oluşan bir ızgaradır. Ekran üzerinde herhangi bir şey yazdırılmadan önce tamamen bellekte yaşayan bir yapı söz konusudur. Kavramsal olarak, bu ızgaradaki her hücre belirli bir içerik türünü depolar: duvarlar, açık yollar, oyuncunun başlangıç ​​noktası veya tuzaklar ve toplanabilir eşyalar gibi özel öğeler. Bu yaklaşım çok önemlidir çünkü ekran yalnızca mevcut oyun durumunun bir yansıması olmalı, mantığın gerçekten yaşadığı yer olmamalıdır.

C++'da bu ızgarayı modellemenin çok kullanışlı bir yolu, şunu kullanmaktır: vector<string>Burada her dize labirentin bir satırını, her dizedeki karakter ise bir hücreyi temsil eder. Izgarayı temiz ve tutarlı tutmak için tüm satırların aynı sayıda sütuna sahip olması gerekir. Bu tutarlılık, hem oluşturmayı hem de çarpışma kontrollerini basitleştirir, çünkü güvenle şunu varsayabilirsiniz: map[row][column] Bilinen sınırlar içinde kaldığınız sürece geçerlidir.

Haritadaki her karakter farklı bir karo türünü kodlar.. Örneğin, kullanabilirsiniz # Oyuncunun geçemeyeceği duvarları işaretlemek için, yürünebilir zemin için boşluklar (veya boşluk veya nokta gibi belirli bir karakter), * koleksiyonluk eşyalar için ve belki X Tehlikeli tuzaklar için. Oyuncunun kendisinin ızgaraya kalıcı olarak yazılması gerekmez; bunun yerine, sahneyi mevcut koordinatlarına göre çizerken onu geçici olarak oluşturursunuz.

Programın ilk sürümü, tabloyu tek tek dolaşıp her satırı yazdırıyor. Konsola satır satır yazdırın. Bu basit görünse de, sınırları, koridorları ve başlangıç ​​düzenini zaten tanımlıyor. Bu aşamada iki temel fikri ayırmış oluyorsunuz: labirent yapısı (statik) ve sistem durumu (dinamik), dinamik kısım henüz tam olarak uygulanmamış olsa bile.

Kapsamı bilerek dar tutmak stratejik bir tercihtir.Bu projede oyun motorları, harici grafik kütüphaneleri veya gelişmiş pencereleme sistemleri kullanmıyorsunuz. Dokular, animasyonlu sprite'lar veya karmaşık ses işleme hatları yok. Çıktı, standart konsol aracılığıyla gerçekleşiyor; bu da sizi bir render API'sinde hata ayıklamak yerine oyun kurallarına, durum güncellemelerine ve kod organizasyonuna odaklanmanızı sağlıyor.

Oyuncunun durumunu haritadan ayrı olarak temsil etme

Labirent haritası yerleştirildikten sonraki önemli adım, oyuncuyu ızgaradan ayırmaktır.Kalıcı bir şey yerleştirmek yerine... P harita dizisindeki karakter veya vector<string>Oyuncunun konumunu iki ayrı değişkenle, genellikle bir tamsayı satırı ve sütunuyla (örneğin, playerRow hem de playerColBu ayrım, labirent planı ile oyunun mevcut durumu arasında net bir ayrım sağlar.

Sahneyi çizerken, harita üzerinde döngü yaparsınız ve oyuncu sembolünü yalnızca render zamanında eklersiniz.Sık kullanılan bir yöntem şudur: Her hücre için, eğer koordinatları oyuncunun koordinatlarıyla eşleşiyorsa, o hücreyi çiz. 'P'Aksi takdirde, statik haritada ne varsa onu çizin. Bu, harita verilerini sürekli yeniden yazmaya gerek kalmadan oyuncuyu hareket ettirmeyi kolaylaştırır ve statik duvarların dinamik varlıklarla karışma olasılığını azaltır.

Hareket mekanizması, klasik WASD tuşlarıyla çalıştırılabilir.: W yukarı için, A sol için, S aşağı ve için D Sağ için. Her tuşa basış yeni bir potansiyel konum önerir (örneğin, newRow = playerRow - 1 (Yukarı doğru hareket ederken). Güncellemeyi gerçekten uygulamadan önce, oyun hedef hücrenin geçerli sınırlar içinde olup olmadığını ve bir duvar karakteri olup olmadığını kontrol eder. Bu kontrollerden herhangi biri başarısız olursa, hareket reddedilir ve oyuncu bulunduğu yerde kalır.

Bu doğrulama adımı, ızgara tabanlı bir labirentteki çarpışma mantığının kalbidir.Karakterin engellerden kaymasına veya ekran dışına kaybolmasına izin vermek yerine, dünyayı tutarlı hale getiren kurallar uyguluyorsunuz: duvarlar sağlam, labirentin sınırları var ve oyuncu tasarlanmış alanın dışına ışınlanamıyor. Basit bir konsol projesinde bile, bunlar daha sonra 3D çarpışma algılayıcıları ve fizik motorları kullanarak uygulayacağınız aynı kavramsal kontrollerdir.

Oyuncunun kendi koordinatları olduğundan, dünya modelini genişletme özgürlüğüne sahipsiniz. Statik harita temsiline dokunmadan puan, can veya envanter gibi ek sistemlerle birlikte. Labirent, sadece bir karo düzeni olarak kalır. Oyun sırasında değişen her şey (konum, toplanan eşyalar, kaybedilen canlar) her karede bağımsız olarak güncellenen ayrı değişkenlerde ve yapılarda yer alır.

Koleksiyonluk Eşyalar, Puan ve Kazanma Koşulları

Boş bir labirentte dolaşmak bir süre sonra sıkıcı hale geliyor, bu yüzden bir sonraki mantıklı adım onu ​​koleksiyon eşyalarıyla doldurmak.Basit bir yöntem olarak şunu kullanabilirsiniz: * Oyuncunun alabileceği bir eşya içeren hücreleri işaretlemek için kullanılan karakter. Bunlar madeni paraları, mücevherleri veya genel "puanları" temsil edebilir, ancak oyun motorunun bakış açısından bunlar sadece belirli bir sembole sahip karolardır.

Her hareket sırasında, oyuncunun yeni bir hücreye girebileceğini doğruladıktan sonra, o hücrede toplanabilir bir eşya olup olmadığını kontrol edersiniz.Eğer öyle olursa, bir puan sayacını artırırsınız (örneğin, score++ (Ya da 10 puan gibi sabit bir değer ekleyin) ve ardından haritayı o konumda yürünebilir boş bir hücreye güncelleyin. Bu, eşyayı almayı ve zemini gelecekteki ziyaretler için boş bırakmayı taklit eder.

Oyunun hedef odaklı kalmasını sağlamak için, labirentte kaç tane toplanabilir eşya kaldığını takip edebilirsiniz.Kolay bir yöntem, harita yüklenirken tümünü tarayarak bir sayaç başlatmaktır. * Karakterler. Oyuncu her karakter topladığında, sayaç azalır. Sayaç sıfıra ulaştığında, doğal bir zafer koşulu oluşur: oyuncu labirentteki tüm eşyaları temizlemiş olur.

Alternatif olarak veya ek olarak, belirli bir çıkış hücresini kazanma alanı olarak tanımlayabilirsiniz.Örneğin, labirentin sağ alt köşesi hazine odasını temsil edebilir. Sağlanan kod fikirlerinde, sıklıkla şu gibi koordinatlar göreceksiniz: (60, 40) or (60, 4) Özel konumlar olarak işaretlenmiştir. Oyuncu tüm zorunlu görevleri (her şeyi toplamak gibi) tamamlayarak bu karelerden birine ulaştığında, tebrik mesajı görüntülenir ve oyun döngüsü durdurulur.

Koleksiyon öğelerini mekansal navigasyonla birleştirerek, basit hareketi gerçek bir oyun deneyimine dönüştürüyorsunuz.Oyuncu artık çıkmaz sokakları keşfetmek, tuzakların etrafında risk almak veya daha önce ziyaret ettiği koridorlardan geri dönmek için bir nedene sahip. Daha üst düzeyde, bu aynı zamanda keşfetme, yağmalama ve hedefleri tamamlama gibi temel döngülerin birçok seviye veya ortamda tekrarlandığı daha büyük oyun tasarımlarının yapısını da yansıtıyor.

Tuzaklar, Yaşamlar ve Sürekli Tehditler

Labirentinize gerilim katmak için, dikkatsiz hareketleri cezalandıran tuzaklar ekleyebilirsiniz.Sık kullanılan bir yöntem, tuzakları şu şekilde temsil etmektir: X Haritadaki karakterler. Koleksiyon eşyalarının aksine, tetiklendiklerinde kaybolmaları amaçlanmamıştır; oyuncunun hatırlaması ve gelecekteki geçişlerde kaçınması gereken kalıcı tehlikeler olarak işlev görürler.

Oyuncu bir tuzak hücresine bastığında, can sayacını azaltır ve pozisyonunu sıfırlarsınız. Labirentin başlangıç ​​koordinatlarına veya belirlenmiş bir kontrol noktasına geri dönebilirsiniz. Bu, yönetilmesi gereken yeni bir kaynak olan canları getirir ve labirent teknik olarak çözülebilir olsa bile başarısızlık riskini ortaya çıkarır. Can sayısı sıfıra düşerse, oyunu sonlandırabilir ve "Oyun Bitti" mesajını yazdırabilirsiniz.

Tuzakları sürekli olarak oyunda tutmak sadece stilistik bir karar olmaktan öte, oyuncunun zihinsel modelini basitleştirir.Toplanabilir eşyalar, tüketilebilen kaynakları temsil ettikleri için haritayı değiştirir. Tuzaklar ise, dünya düzenini değiştirmeden oyuncunun durumunu (canlar, konum) değiştirir. Bu net ayrım, kodunuzu düzenli tutmanıza yardımcı olur: haritaya bağlı davranış, karaktere bağlı davranıştan farklıdır.

Bu prensip, daha gelişmiş oyun motorları ve 3 boyutlu ortamlar için de son derece doğal bir şekilde geçerlidir.DirectX tabanlı Marble Maze tarzı bir oyunda, tahtadaki çukurlar tuzak görevi görür: birine düşmek, tahta geometrisini değiştirmeden bilyeyi en son kontrol noktasına geri gönderir. Kontrol noktaları, yıkılabilir veya tüketilebilir karolar olarak değil, yeniden doğma davranışını etkileyen mantıksal işaretleyiciler olarak dünya uzayında işlev görür.

Konsol uygulamasını daha da ileriye taşımak isterseniz, tuzakları rastgele düzenlerle birleştirebilirsiniz.Örneğin, labirentin belirli kısımlarını oluşturmak için rand() Ve bazı hücrelere 0, 1 veya 2 gibi değerler atanarak, bazıları duvarları, bazıları güvenli yolları temsil ederken, birkaç hücre de tuzak adayı haline geliyor. Bu sayede her yeni oyun farklı bir his verirken, temel kurallar aynı kalıyor.

Giriş Verilerini İşleme: Engellenen Okuma İşlemlerinden Gerçek Bir Oyun Döngüsüne

Birçok başlangıç ​​seviyesi konsol programı, kullanıcının Enter tuşuna basmasını bekleyerek girişi engellemeye dayanır. Her komuttan sonra. Bu menüler için sorun değil, ancak gerçek bir oyun için sürekli, duyarlı bir kontrole ihtiyacınız var. Program her hamlede yürütmeyi durdurmak yerine, sürekli döngüde kalmalı, bir tuşa basılıp basılmadığını kontrol etmeli ve yalnızca gerektiğinde güncellemelidir.

Windows'ta yaygın bir yöntem şudur: _kbhit() hem de _getch() itibaren <conio.h>. İşlev _kbhit() Bu fonksiyon, tüm işlemi durdurmadan giriş arabelleğinde bekleyen bir tuş olup olmadığını size söyler. Eğer true döndürürse, o tuşu alırsınız. _getch() ve bunu bir komut olarak yorumlar (WASD, ok tuşları, çıkmak için ESC tuşu vb.). Eğer hiçbir tuş girilmezse, döngü devam eder ve bu da kareyi yeniden çizmenize, zamanlayıcıları güncellemenize veya öğeleri canlandırmanıza olanak tanır.

Bu engellemeyen giriş, ana rutininizi düzgün bir oyun döngüsüne dönüştüren şeydir.Kullanıcı onaylarıyla ayrılmış katı bir "giriş → güncelleme → çizim → bekleme" döngüsü yerine, sürekli bir döngüye sahipsiniz; bu döngü tekrar tekrar: girişi kontrol eder, konumları ve durumu günceller ve labirenti yeniden çizer. Bu tür döngüler, metin tabanlı macera oyunlarından AAA 3D ​​nişancı oyunlarına kadar neredeyse her etkileşimli oyunun temelinde yer alır.

Hareket komutlarının ötesinde ek komutlar da verebilirsiniz.Örneğin, örnek kod parçacıklarında şu gibi anahtarlar belirtiliyor: R Oyundan çıkmak için, N Yeni oluşturulmuş bir labirent ve hatta bir anahtar istemek gibi T Son işlem süresini göstermek için. Bunları işlemek, basılan tuşu giriş işleme bloğundaki belirli karakterlerle karşılaştırmaktan ibarettir.

UWP DirectX oyunları gibi daha gelişmiş ortamlarda, giriş kaynakları çoğalır.Aynı labirent konsepti klavye, oyun kumandası, fare, ivmeölçer veya dokunmatik ekran ile kontrol edilebilir. Her cihaz türü için API farklıdır, ancak fikir değişmez: oyun döngüsü sürekli olarak en son giriş durumunu kontrol eder, bunu oyun eylemlerine dönüştürür ve güncellenmiş kareyi oluşturmadan önce simülasyon mantığına iletir.

Konsol Görüntüleme ve HUD'ı İyileştirme

Metin tabanlı bir konsolda bile, labirentinizin kusursuz bir oyun gibi görünmesini sağlamak için çok şey yapabilirsiniz.Sürekli yeni satırlar yazdırmak ve labirentin aşağı kaymasına izin vermek yerine, aynı ekran alanını tekrar tekrar yenileyebilirsiniz. Windows'ta, bunu çağırmak... system("cls") Her karede konsolu temizler, ardından güncellenmiş labirenti, oyuncuyu, skoru ve mesajları çizersiniz. Basit ve en verimli yöntem değil, ancak küçük projeler için iyi çalışıyor.

Metni tam olarak istediğiniz yere konumlandırmak için, aşağıdaki gibi bir yardımcı fonksiyon kullanabilirsiniz. gotoxy(int x, int y)Windows altında, bu işlev çağrı yapar. SetConsoleCursorPosition() itibaren windows.h, kullanarak COORD İstenilen koordinatları belirtmek için bir yapı. İmleci açıkça hareket ettirerek, labirenti ekranın bir bölümüne ve skor, can ve kalan eşyaları gösteren bir HUD'u üst veya alt kısma yerleştirebilirsiniz.

Yanıp sönen metin imlecini gizlemek görsel deneyimi de iyileştirir.Bunu şu yolla yapabilirsiniz: SetConsoleCursorInfo()bir yapılandırma CONSOLE_CURSOR_INFO yapı öyle ki bVisible ayarlandı FALSEBu küçük bir detay ama dikkat dağıtıcı unsurları azaltıyor ve labirent ızgarasının ham bir terminal görüntüsünden ziyade gerçek bir oyun alanı gibi görünmesini sağlıyor.

ASCII karakterleri, daha kişisel bir dokunuşla kenarlıklar ve duvarlar çizmenizi sağlar.Örneğin, 205 (çift yatay çizgi), 186 (çift dikey çizgi), 201 (sol üst köşe), 187 (sağ üst köşe), 200 (sol alt köşe) ve 188 (sağ alt köşe) gibi değerler şu şekilde dönüştürülebilir: char ve labirentin etrafına dekoratif bir çerçeve oluşturacak şekilde basılmıştır. 219 gibi dolu bloklar kalın duvarlar için harika sonuç verir. Bu, haritaya rastgele bir sembol koleksiyonundan ziyade daha "oyun benzeri" bir görünüm kazandırır.

Hatta küçük bir "açılış ekranı" veya tanıtım afişi bile gösterebilirsiniz. Proje adını, yazar bilgilerini ve samimi bir selamlamayı yazdıran, ardından ana döngüyü başlatmadan önce herhangi bir tuşa basılmasını bekleyen bir kod parçası. Bu tür bir giriş, projenin tonunu belirliyor, temel kontrolleri açıklıyor (örneğin, "Başlatmak için herhangi bir tuşa basın, hareket etmek için ok tuşlarını veya WASD tuşlarını kullanın") ve yalnızca metin çıktısı kullanılmasına rağmen projenin tamamlanmış hissiyatını veriyor.

Zamanlama, Rastgele Labirentler ve Performans Hususları

Oyuncunun labirenti çözmesinin ne kadar sürdüğünü ölçmek, kolay ama etkili bir diğer ekleme.C++'da basit bir yaklaşım, şunu kullanmaktır: clock_t türü ve clock() işlevi <time.h>Koşuya başlarken ararsınız. clock() Başlangıç ​​zamanını saklamak için. Oyuncu hedefe ulaştığında veya bitiş koşulunu tetiklediğinde, orijinal değeri yeni değerden çıkararak geçen tik sayısını hesaplarsınız. clock() aramak.

tarafından döndürülen ham değer clock() İşlemci tiklerini temsil eder, saniyeleri değil.Bunu insan anlayabileceği birimlere dönüştürmek için sabite bölmeniz gerekir. CLOCKS_PER_SECBu, oyuncunun labirentte gezinmek için harcadığı saniye sayısını verir. Bu sayıyı görüntülemek ve kullanıcıya "Sürenizi görmek için T tuşuna basın" gibi bir seçenek sunmak, kişisel rekorlarını kırmaya çalışırken oyunun tekrar oynanabilirliğini artırabilir.

Eğer maceraperest hissediyorsanız, dinamik olarak yeni labirentler de oluşturabilirsiniz.Kod parçalarından birinde, şu ifadeye benzer bir ifadeyle harita hücrelerine rastgele değerler atama örneği bulunmaktadır. map[i][j] = rand() % 3Bu rastgele sayıları farklı karo türleri olarak yorumlayabilirsiniz; örneğin 0 duvar, 1 açık yol ve 2 özel yürünebilir karo anlamına gelir. Biraz daha mantıkla, bunları oyuncunun bir anahtar kullanarak yeni bir labirent istediğinde her seferinde değişen tutarlı labirent yapılarına dönüştürebilirsiniz. N.

Döngüdeki küçük bir gecikme, işlemcinin %100 kullanım oranına ulaşmasını engelleyebilir.Windows işlevi Sleep(30) Ana döngünün her tekrarı arasında programı yaklaşık 30 milisaniye duraklatır. Bu, daha akıcı bir performans sağlar ve işlem gücünün israfını önler; bu durum özellikle oyun dikey senkronizasyon veya kare sınırlaması olmadan çıplak bir konsolda çalışırken önemlidir.

Zamanlama ve rastgeleleştirmeyi entegre ederken, oyun mantığını ve sunumunu ayrı tutun.Rastgele üretim yalnızca temel harita verilerine dokunmalı, zaman hesaplamaları değişkenleri güncellemelidir ve görüntüleme kodu yalnızca bu değerleri okuyarak bunları göstermelidir. Bu ayrım, oyunun daha sonra genişletilmesini, sorunların giderilmesini veya temel mantığın başka bir platforma veya görüntüleme sistemine taşınmasını çok daha kolaylaştıracaktır.

Konsol Labirentinden 3D DirectX Mermer Labirentine

Konsol oyunlarındaki labirent oyunlarına alıştıktan sonra, bunun 3 boyutlu bir oyuna nasıl yansıyacağını merak etmeniz doğal.Windows 10'da iyi bir örnek, C++ ve DirectX kullanarak 3 boyutlu bir Mermer Labirenti oluşturan Evrensel Windows Platformu projesidir. Bu tür oyunlarda, karakteri hücre hücre hareket ettirmezsiniz; bunun yerine, çelik veya cam bir mermerin simüle edilmiş yerçekimi altında labirentte yuvarlanması için fiziksel görünümlü bir tahtayı eğersiniz.

3 boyutlu mermer labirentinin temel amacı, bir nesneyi deliklere düşmeden başlangıçtan bitişe kadar yönlendirmektir.Labirent, ahşaptan yapılmış ancak kodla uygulanmış bir masa üstü oyuncağı gibi davranır. İvmeölçer girişi, oyun kumandası kontrolleri, fare hareketleri veya dokunmatik hareketler aracılığıyla tahtayı eğersiniz ve bilye fizik hesaplamalarına yanıt verir; dikkatli olmazsanız duvarlara çarpar ve çukurlara düşer. Kontrol noktaları, bir kaza sonrasında bilyenin en son ulaşılan güvenli konumda yeniden ortaya çıkmasını sağlar.

Bunu DirectX ile C++ kullanarak oluşturmak için birkaç temel API ve kütüphaneye ihtiyacınız olacak.Direct3D ve Direct2D, 3 boyutlu labirenti ve 2 boyutlu katmanları oluştururken, Windows Runtime API'leri UWP uygulama yaşam döngüsünü yönetir. Geometri ve fizik hesaplamaları genellikle vektör ve matris işlemleri, çarpışma tespiti ve hareket entegrasyonu için DirectXMath'ı kullanır. Ses için ise XAudio2, müzik parçalarını ve yuvarlanma, çarpma veya deliklere düşme gibi ses efektlerini işlemek için ana motor görevi görür.

Grafiksel yönü daha karmaşık olsa da, mantıksal yapısı konsol labirentini yansıtıyor.Hâlâ bir dünya temsili (tahta ve delikler), hareket eden bir varlık (mermer), engeller (duvarlar) ve başarısızlık koşulları (çukura düşme) var. Eskiden karakterler olan şeyler... vector<string> Artık bunlar 3 boyutlu modeller ve çarpışma hacimleri haline geliyor, ancak zihinsel modeliniz—kurallar ve hedefler—özünde aynı kalıyor.

DirectX kullanarak bir UWP labirent oyunu oluşturmak, C++ ve temel DirectX kavramlarını zaten bildiğinizi varsayar.COM'u, dokular ve gölgelendiriciler gibi kaynakları nasıl yöneteceğinizi ve UWP'nin uygulama yapısı açısından klasik masaüstü uygulamalarından nasıl farklılaştığını bilmeniz gerekir. Marble Maze için resmi belgeler genellikle proje düzeni, grafik işlem hattı kurulumu, dokunmatik ve sensörler için giriş işleme ve ses entegrasyonu gibi yönleri modüler bir şekilde ele alır, böylece bileşenleri kendi projelerinizde yeniden kullanabilirsiniz.

Kod Tabanının Yapılandırılması: Başlık Dosyaları, Kaynak Kodları ve Sınıflar

İster konsol ortamında ister UWP DirectX projesinde çalışıyor olun, kodunuzu düzenlemek çok önemlidir.Her şeyi bir anda ortaya dökmek yerine... main.cppİşlevselliği ayrı başlık ve kaynak dosyalarına bölmek daha iyidir. Örneğin, şöyle bir yapı oluşturabilirsiniz: Maze.h hem de Maze.cpp harita mantığı için, Player.h hem de Player.cpp oyuncu durumu için ve konsol işlemleri için ayrı bir yardımcı dosya (dahil olmak üzere) gotoxy ve imleç yapılandırması).

Başlık dosyaları sınıflarınızın ve fonksiyonlarınızın arayüzünü tanımlarken, kaynak dosyaları ise davranışlarını tanımlar.Başlık dosyalarını şu şekilde dahil edersiniz: main.cpp kullanma #include Böylece derleyici, mevcut türler ve işlevler hakkında bilgi sahibi olur. Bu modülerlik, özellikle düşmanlar, çoklu seviyeler veya gelişmiş HUD bileşenleri gibi daha fazla öğe eklediğinizde, okunabilirliği ve bakım kolaylığını artırır.

C++ sınıflarında, kurucular ve yıkıcılar kaynakların ömrünü yönetir.Bir nesne oluşturulduğunda çalışan yapıcı (constructor) fonksiyon, başlangıç ​​durumunu ayarlayabilir, bellek ayırabilir veya tanıtıcıları yapılandırabilir. Nesne yok edildiğinde çağrılan yıkıcı (destructor) fonksiyon ise kaynakları serbest bırakmak, dosyaları kapatmak veya dinamik olarak ayrılan belleği boşaltmak için doğru yerdir. Küçük bir labirent projesinde bile, yıkıcı fonksiyonları doğru kullanmak, bellek sızıntılarını ve gereksiz tanıtıcıları önlemeye yardımcı olur.

Windows'a özgü kısımlar için, sistem düzeyindeki tanıtıcılar ve yapılarla da etkileşim kuracaksınız.Konsol kontrolü şunlara dayanır: HANDLE elde edilen değerler GetStdHandle()Bunu, aşağıdaki gibi fonksiyonlara aktarırsınız. SetConsoleCursorPosition() hem de SetConsoleCursorInfo()Bu tanıtıcıları diğer kaynaklarla aynı şekilde ele alın: ya küçük bir sınıf içine alın ya da farklı standart çıktı tanıtıcılarını karıştırmamak veya durum takibini kaybetmemek için dikkatlice yönetin.

Bu disiplinli yapı, DirectX gibi gelişmiş API'lere geçiş yaptığınızda ekstra faydalar sağlar.Orada, her birinin kendi oluşturma ve yok etme kuralları olan cihazlar, bağlamlar, takas zincirleri, tamponlar ve dokularla ilgileneceksiniz. Konsol yardımcılarını, labirent mantığını ve oyuncu durumunu birbirinden bağımsız tutmayı zaten öğrendiyseniz, daha büyük bir projede aynı şeyi işleme, giriş ve ses alt sistemleriyle yapmak doğal gelecektir.

Özetle, basit konsol labirentlerinden tam teşekküllü 3 boyutlu Marble Maze'e kadar C++ ile yazılmış bir labirent oyunu, birkaç sağlam fikre dayanıyor.: Dünyayı bellekte yapılandırılmış veri olarak temsil edin, oyuncu durumunu haritadan ayrı tutun, hareketleri ve çarpışmaları doğrulayın, toplanabilir öğeler ve kazanma koşullarıyla anlamlı hedefler ekleyin, tuzaklar ve canlarla gerçek tehlike ekleyin ve her şeyi duyarlı bir oyun döngüsü ve net kod organizasyonuyla düzenleyin. Bu temelleri minimal bir konsol bağlamında öğrenmek, daha zengin grafiklere ve çoklu cihaz girişine geçişi çok daha az korkutucu hale getirir ve gelecekte oluşturmaya karar verdiğiniz herhangi bir C++ oyunu için yeniden kullanılabilir bir zihinsel araç seti sağlar.