Merhabalar; Bu hafta itibari ile Imagine Cup 2009 Oyun Geliştirme kategorisinin, Türkiye ayağı sorumlusu oldum. Yarışmacılar için bu ne demek?

. Oyun geliştirme kategorisi ile ilgili her türlü sorunuzu bana sorabilirsiniz 

. XNA ile ilgili her türlü sorunuzu bana sorabilirsiniz.

Katılacak arkadaşlar, hepinize bol şans diliyorum; bu arada unutmatan:

Mutlu Bayramlar...

Merhabalar; bir önceki yazımda kısaca XNA’de hatta ve hatta genel oyun programlama dünyasında matrislerin nasıl kullanıldığından ve ne gibi avantajlar sağladığından kısaca bahsetmiştim. Bu yazımda ise XNA’de matris yapısı (struct) ile neler yapabiliriz, hangi metodu ne amaçla kullanabiliriz gibi konulardan bahsedeceğim.

Öncelikle tarzım olduğu üzere metotları tanıyalım, sonra nasıl kullanıldıklarından bahsedeceğim.

CreateRotationX() ->

CreateRotationY() ->

CreateRotationZ() -> Z ekseni etrafında dönme hareketini sağlayacak olan matrisi geri döndürür.

CreateTranslation() -> Bir yada daha fazla eksene göre, dorusal hareket sağlayan matrisi geri döndürür.

CreateScale() ->  varlığı ölçekleyecek bir matris geri döndürür.

CreateLookAt() -> Kameranın bakış açısındakileri gösteren bakış matrisini (View matrix) oluşturur. Kameranın yerini, görüntülerin yerini ve hangi yönün yukarı olduğunu biz  belirleriz.

Not: Kamerayı monitörümüz aracılığı ile görebildiğimiz alan için, mönitörün ekranıdır diyebiliriz, sonuçta perspektif bir bakış açısında, görüntünün başladığı sınır ekrandır sonra z indexine göre görüntü derinlik kazanır. Yada basitçe bir FPS (counter strike gibi oyunlar) oyununda karakterimizin gözleri kameradır diyerek bunu kafamızda canlandıralım.

CreatePerspectiveFieldOfView() -> Perspektif izdüşüm kullanarak, görünür alanın matrisini yaratır, görünür dünyayı bir matrisle temsil eder. Bu method ile bakış matrisini (View Matrix), ekranın görüntü oranını (Aspect Ratio) , yakın  ve uzak görüntü sınırlarını paremetre olarak kullanırız, dolasıyla bu metod, View Matriximize bağımlıdır. Özetle bu metot bir perspektif görüş için ekrandan itibaren görebileceğimiz son sınıra kadar trepezoit (yamuk) bir alan oluşturur.

Not: Aspect Ratio (ekran oranı) GraphicsDevice türünden bir aygıtın,

aygıt.ViewPort.width / aygıt.ViewPort.Height  şeklinde kurabileceğimiz bir oranla hesaplanır. Sonuç genellikle 4:3 veya 16:9 gibi günümüz standart oranlarıdır.

CreatePerspectiveOffCenter() -> View Matrix’ten bağımsız bir perspektif izdüşüm matrisi oluşturur.

CreateWorld() -> Dünya matrisimizi oluşturur.

Şimdilik bu kadar metodu anlatmanın yeterli olduğunu düşünüyorum; fazlasını merak edenler MSDN kütüphanesinden yaralanabilirler.

Metotlarımızı tanıdığımıza göre şimdi matrisleri nasıl kullanacağımız konusuna değinelim;

Öncelikle dünyamızı temsil edecek bir dünya matrisi tanımlayalım;

 

Matrix worldMatrix = Matrix.Identity;

 

Matrix.Identity birim matris geri döndürür.

Şimdi de hareket işlemini nasıl sağlayacağımızı görelim;

 

worldMatrix*= Matrix.CreateRotationX(1.0f)*Matrix.CreateRotationY(1.0f);

 

Bir önceki yazımda iki matrisi çarparak haraket sağlayabileceğimizi anlatmıştım. Burda da yaptığımız aynen bu. Sadece matrisin değerlerini XNA’e tanımlatıyoruz, biz bildiğimiz klasik anlamda matrisi görmüyoruz. Gördüğünüz gibi her çarpı (*) işareti bir hareket anlamına geliyor, ikinci * işaretinde Y ekseni etrafında bir birimlik hareket, birinci * işaretinde de Y ekseni etrafında bir birimlik hareket yapıyoruz. Yani nesnemiz tek bir işlem dizisinde art arda iki hareket yapmış oluyor;

Gördüğünüz gibi XNA’de nesnelere hareket vermek bu kadar kolay, yazının başında verdiğim metotları da çarpma değeri ile çarparak hareketi çeşitlendirebiliriz.

Altın kural şu; önce, dünyayı nesneyi vb. tanımlayan bir matris atıyoruz, sonra hangi hareketi yaptıracağımıza karar veriyoruz, nesnemizi temsil eden matrisi hareketimizi sağlayacak matrisle çarpıp nesne matrisimize bu sonucu atıyoruz. Gördüğünüz gibi XNA’de matrislerden korkmanızı gerektirecek pek bir şey yok.

Herkese merhabalar, uzun bir aradan sonra XNA hakkındaki yazılarıma devam ediyorum. Malum vizelerdi, Türkiye’ye dönüş heyecanıydı ödevlerdi … bir sürü bahaneden sonra, tekrar bir seri başlatmayı düşünüyorum. XNA’ de 2 boyut ve XNA’de multiplayer yazı dizilerim oldukça iyi tepkiler aldı. Desteğiniz için hepinize teşekkür ediyorum.

Bu yazımın konusu 3 boyuta girişten ziyade XNA’de 3 boyutun mantığını anlatmak olacak, önce mantığını kavrayalım, sonra zaten bizi kimse tutamaz. Öncelikle bazı konuları maddeler halinde inceleyelim, gerektiği yerde açıklayalım.

. XNA sağ el koordinat sistemini kullanır. Yani sağ elinizin parmak uçları X eksenini gösterirken avucunuz Y eksenini ve baş parmağınız da Z eksenini gösterir.

. XNA’de 2 tip iz düşüm (projeksiyon) vardır. İz düşüm bir nesnenin görüntüsünün mesafesine göre nasıl ölçeklendiğidir gibi bilgisayar oyunlarına özel bir tanım yapalım şimdilik. Bu iki tip sırasıyla;

-          Perspektif: Cisim uzaklaştıkça daha ufak gözükür, görülebilir genişlik artar.

-          Ortogonal: Bu tipte ise uzaklaşsa bile cismin boyutu değişmez, 2 boyut gibi düşünelim.

. Köşeler: Diğer bir deyişle “açısal oluşum noktaları” evrende bir nokta düşünün. Bu noktadan çıkan doğrular aralarında açıları oluşturacaktır. Örneğin hemen bulunduğunuz odanın tavanının köşesine bakın, sırasıyla biri X, biri Y, biri de Z ekseninde 3 doğru çıkıyor değil mi? Ve aralarında 90 derecelik dik açı var. Ve her şekil köşelerin birleştirilmsiyle oluşur, çocukken bulmacalarda noktaları birleştirdiğimizi hatırlayalım. Ve eğer bu noktaların her birinden 3 boyuta doğru çizgilir çıksaydı ne olurdu? Yanıt basit 3 boyutlu modeller. Az önceki örnekten devam edelim odadaki her köşeyi birbirine bağlayın ne oldu? Bir oda yani dikdörgenler prizması, değil mi.

Eh artık 3 boyutun unsurlarını biliyoruz peki bunları nasıl kullanacağız da bir oyun ortaya çıkacak?

XNA’de köşeler:

XNA’de köşeler, yerlerini ve diğer özelliklerini renk vb. içeren yapılar (struct) yardımı ile tanımlanırlar.

VertexPositionColor -> bu yapı ile bir köşe (vertex); yeri (position) ve rengi (color) ile tanımlanır.

VertexPositionTexture -> bu yapı ile bir köşe; yeri ve dokusu (texture) ile tanımlanır, desenin kendi içinde (0,0) desenin sol üst; (1,1) desenin sağ alt köşe limitidir.

VertexPositionColorTexture -> yukarıdaki iki yapının bileşimi gibi düşünelim.

VertexPositionNormalTexture -> bir normal vektörü ve bunun yanında yer ve desen tanımlanır.

XNA’de köşeleri birleştirmek için; GraphicsDevice.DrawPrimitives metodu kullanılır, bu metodun ilkel tipler (Primitive Types) için tanımlanmış enumaration değerlerine göre köşeler bir düzen içinde birleştirilir. Buradaki ilkel tipler programlama dillerindeki int, float vb. ilkel tiplerle karıştırılmamalıdır. Bahsettiğimiz Enum değerleri, 1. Parametre olarak kullanılacaktır; hepsi PrimitiveType. xxxx  şeklinde kullanılabilirler. Bu metodu kullanmadan önce Vertex buffer dediğimiz bir köşe listesini oluşturmamız gerekir. Bunu da Enum değerlerini gösterdikten sonra anlatacağım.

.PointList -> Köşe listesinde (Vertex Buffer) bulunan her vertex birbirinden bağımsız birer nokta şeklinde çizilir.

.LineList -> Köşe listesindeki köşeler sırayla ikişerli olarak gruplandırılır ve her ikilinin arası bir çizgi ile doğrusal olarak birleştirilir.

.LineStrip -> Köşe listesindeki köşeler sıra ile art arda birleştirilir.

.TriangleList -> Köşe listesindeki köşeler üçer üçer gruplandırılır, her üçlü bağımsız bir üçgen oluşturur.

.TriangleStrip -> Her yeni üçgen kendinden önceki üçgenin son iki noktası kullanılarak oluşturulur, dolayısı ile üçgenler bağlıdır, ilk üçgen dışındaki üçgenler için tek nokta gerek ve yeterlidir.

.TriangleFan -> İlk köşemiz tüm üçgenlerin tepe noktası olur ve üçgenler birfan şeklinde oluşur. Buna örnek olarak ikiye kesilmiş portakalı verebilirim, orta noktasını ilk noktamız kabul edersek, her dilim bir üçgen oluşturacaktır, tepe noktaları ortak olacaktır.

GraphicsDevice ekranKartı;

Şeklinde tanımlanmış bir aygıtımız olduğunu varsayarak; Bir  Vertex buffer ‘ı(Köşe Listemizi) nasıl oluşturacağız; buna bakalım;

VertexBuffer köşeListesi;

           // Diyerek bir VertexBuffer tanımlamış olalım. 

VertexPositionColor[]  köşeler= new  VertexPorsitionColor[10];             

//10 köşe barındıran bir dizi oluşturduk;

köşeler[0] = new VertexPositionColor(new Vector3(0.0f, 0.0f, 0.0f),Color.White);

            // gibi bir kodla tüm köşelerimizi atayacağınızı varsayıyorum; 

köşelListesi = new VertexBuffer (ekranKartı, 10* VertexPositionColor.SizeInBytes,

                 BufferUsage.WriteOnly);

// diyerek Vertex Bufferımızı oluşturduk. Buradaki 10 listemizdeki eleman sayısı.

 

Yukarıda fark etmişsinizdir; Köşemizin yerini belirlerken Vector3 diye bir yapı kullandık; peki bu yapı nedir?

Adından da anlaşılacağı üzere Vector3 yapısı 3 boyutlu bir vektör tutar, yani X, Y ve Z koordinatlarından oluşan bir vektörü tutar. Vektör denince kafası karışanlar için, buna noktanın tanımlandığı hacim (dünya, oda … vb 3 boyutlu bir mekan) içerisindeki yerini belirtir diyelim. Yani odanın duvarında duran X ve Y koodinatlarına sahip bir sinek değil de odada uçan, oda hacmi içinde herhangi bir yerde olan sineğin konumu .

Madem Vector3 yapısına (struct) giriş yaptık kısaca metotlarının bazılarından bahsedivereyim;

Vector3.Distance() -> verilen iki nokta arasındaki uzaklığı hesaplar.

Vector3.Add()

Vector3.Subtract() -> bu metotlar, vektörel toplama ve çıkartma yapar. Yani X değerleri  X Değerlerinden, Y değerleri Y değerlerinden … çıkartılır.

Vector3.Multiply()

Vector3.Divide() -> Bu iki metor  iki vektör arası çarpma bölme işlemi veya verilen bir sayı ile bir vektörü çarpıp bölme işini yapar.

Vector3.Clamp() -> Vektörü verilen sınırların içinde tutar, sınırın dışarısında bir değer almasını engeller; yani yukarıdaki örnekteki sinek bu metot yardımı ile odanın dışına çıkamaz.

Vector3.Lerp() -> İki vektör arası doğrusal interpolasyonu hesaplar.

Vector3.SmoothStep() -> Verilen bir değeri ağılık kabul ederek, iki vektör arası interpolasyonu hesaplar.

 

Bunlardan ayrı olarak yine Vector3 yapısına dahil özelliklerden bazıları da;

Vector3.Zero -> Geriye tüm değerleri 0 olarak atanmış bir vektör döndürür. (0,0,0)

Vector3.Up -> Yukarıya bakan bir vektör döndürür (0,1,0)

Vector3.Right -> Sağa bakan bir vektör döndürür (1,0,0)

Vector3.Forward -> Sağ el koordinat sistemine göre ileri giden bir vektör döndürür (0,0,-1)

Vector3.Left , Vector3.Down, Vector3.Backward

Vector3.UnitX -> bir birim X vektörü döndürür (1,0,0)

Vector3.UnitY, Vector3.UnitZ

 

Peki bir nesne (model) köşelerin birleştirilmesinden oluşuyorsa ve her köşe bir vektör olarak temsil ediliyorsa, Oyunun geçeceği dünya nasıl temsil edilmeli?

Yanıt matrisler, eğer içinde bulunduğumuz oda bir 3 boyutlu matrisle temsil ediliyor olsaydı, kağıt üzerinde sineğimizin nerede uçuyor olduğunu işaretleyebilecektik.

XNA’de matrisler, bir nesnenin rotasyonunda (bir eksen etrafında dönme hareketleri), ölçeklendirilmesinde (uzağa giden nesne küçülür) ve translasyonunda (sabit yönlü hareket) kullanılır.

Eğer matris kullanmıyor olsaydık, bir nesnenin tüm hareketleri için vektörün her bir değerine tek tek ulaşıp o değeri değiştirecektik. Ama bu işi iki matrisin arasındaki matematiksel işlemler aracılığı ile yaparsak hem X, Y ve Z değerlerine ayrı ayrı ulaşmak zorunda kalmayacağız hem de her bir işlemi tek tek uygulamak yerine aynı anda hem haraket ettirebilecek hem de nesnenin boyutunu değiştirebileceğiz.

Matrislerin kullanılmasının bir diğer sebebi ise çağdaş ekran kartlarının tümünde GPU üzerinde matris algoritmaları olması, böylece CPU üzerine binecek yükten de kurtulmuş oluyoruz.

Bir nesneye Matris işlemleri ile haraket nasıl verilir?

Bir noktamız var koordinatları (20,10,30) olsun. Bunu 30 birim yukarı hareket ettirmek istiyoruz. Bunu nasıl yapacağız?

Sonunda Lineer Cebir dersleri bir işe yarıyor ve matrislerde çarpma yapıyoruz.

         [1, 0, 0, 0]

[20,10,30,1] x|0, 1, 0, 0|  = [20, 40, 30, 1]

                     |0, 0, 1, 0|

                     [ 0,30,0, 1]

Gördüğünüz gibi y değeri 30 arttı.

Eğer bu işlemde, ilk matrisimizde en sondaki 1’i arttırsaydık 60 birim ilerlemiş olacaktık, yani bu ilerleme katsayısıdır.

Eğer, İkinci matristeki köşegende bulunan 1’leri  arttırsaydık, nesnemizin boyu büyüyecekti, yani bu köşegen de nesnemizin ölçeklendirilmesinden sorumlu.

Ve aynı zamanda eğer ikinci matrisimizde sin ve cos değerleri kullanıyor olsaydık, nesnemiz dönme hareketi yapacaktı. Gördüğünüz gibi neredeyse hiç uğraşmadan tek matris işleminde nesnemizi hareket ettirdik.

Yazımı bitirmeden önce son bir şey söylemek istiyorum, matrisler sizi korkutmasın çünkü bu işlemleri XNA sizin için Matrix sınıfı aracılığı ile yapıyor, buradaki amacım size işin işleyiş mantığını göstermekti. Bir sonraki yazımda size Matris sınıfından bazı işlevlerinden bahsedeceğim, Eğer zaman bulursam Efektlere de tanıtma niyetinde bir giriş yapmak istiyorum. Hepinize kolay gelsin.

Önceki yazımda sabit duran nesneleri çizdirmeyi göstermiştim. Bu yazımda da aynı sınıfları kullanarak hareketli bir nesne çizdirmeyi göreceğiz.

 

Öncelikle nesnemiz hareket edeceği için bir hareket hızı olması lazım; bunu CizilecekNesne sınıfımıza değişken olarak ekliyoruz.

            public Vector2 velocity;

daha sonra; Game1.cs sınıfımıza dönelim;

nesne.velocity = new Vector2(0.0f, 0.5f);

nesne.position = new Vector2(350, 250);

bu şekilde sadece yukarı yönlü bir hız vektörü belirleyelim, ve nesnemiz için bir pozisyon değeri atayalım.

Daha sonra klavyeden girdi alarak nesnemize hareket verelim.

if (keyboardState.IsKeyDown(Keys.Up))

            obje.position -= obje.velocity;

      if (keyboardState.IsKeyDown(Keys.Down))

            obje.position += obje.velocity;

şeklinde daha önce de anlattığım gibi, kullanıcı girdisi alarak nesneyi gideceği yöne doğru hareket ettirelim. Birinci deyimde -= işareti yukarı yönlü bir harekete neden olcaktır çünkü unutmayalım ekranımızda y ekseni aşağı gittikçe artar. Sonra;

 

obje.position.Y = MathHelper.Clamp(obje.position.Y,

 0, ekranAlanı.Height-obje.sprite.Height);

 

Diyelim, bu metoda dikkat Clamp metodu birinci parametresinde verilen değeri alır; ikinci ve üçüncü parametreler arasında tutar. Eğer değer son iki parametrenin arasında ise değişmez, eğer birini geçiyorsa geçtiği max veya minimum değere eşitlenir.

Burada nesnemizin Y bileşeni ancak “0” ve  “Ekran alanı – Nesnenin boyu” arasında bir değer alabilir. Eğer birini geçerse geçtiği değere eşitlenir. Böylece nesnemiz sürekli ekranda kalacaktır.

 

Olay kısaca bu zaten diğer kısmını önceki yazıda halletmiştik şimdi araya bunları ekleyerek nesnemizi harekete geçirdik.

Önceki yazıya buradan; çevre birimlerinden girdi almaya buradan ulaşabilirsiniz.  

 

 Önceki yazımda nesnelerimizi oyun ekranında 2B olarak temsil etmek için gerekli olabilecek bazı metotlardan bahsetmiştim. Bu yazımda da bu metotları kullanarak ekranda bir temsil oluşturmayı anlatmaya çalışacağım.

Öncelikle işin mantığını sıralayalım:

1-     Nesnelerimizin ihtiycı doğrultusunda sınıflar hazırlıyoruz; örneğin durağan bir nesne için konum ve desen gibi iki değişken yeterli olabilecekken; hareket eden bir nesne için hız, yön, hareketin başlama konumu gibi özelliklere ihtiyaç duyarız.

2-     Sınıflarımızın yapıcı metotlarında (Constructor) değişkenlerimizi ayarladık,

3-     Game1.cs’de nesnemizi temsil edecek değişkenler oluşturduk.

4-     LoadContent() metodu içinde nesnemize başlangıç değerlerini yükledik.

5-     Update() metodu içinde, nesnemizin etkileşimini sağlayacak işlemleri yaptık. Gerektiğinde if deyimleri ile nesnemize yeni tepkiler verdirdik. Bu metot saniyede 50-60(değişebilir) kez tekrarlanacak buna dikkat ettik.

6-     Draw() metodunda spritebatch nesnesinin metotlarıyla çizim işlemini gerçekleştirdik. Bu da Update metodu gibi saniyede onlarca kez tekrarlanacak.

Not: XNA GS’nin bize hazırladığı metotların içini doldurmak yerine ufak metotlar tanımlayarak bu kısımların içinde çağırırsak daha bir güzel olur kodumuz ama bu yazıda buna dikkat etmeyeceğim, siz edin.

Bu yazımın konusu olarak hareketsiz nesneleri çizmeyi seçtiğim için ekranda haket etmeyen bir nesne çizeceğiz. Daha sonra hareket eden nesnenin nasıl çizileceğini ve kullanıcı girişinden nasıl etkileneceğini yazacağım.

Şimdi yavaş yavaş başlayalım;

1. Adım:

CizilecekNesne.cs:

        public Texture2D deseni;

        public Vector2 konumu;

şeklinde bazı nesne özellikleri tanımladık.

2. Adım:

CizilecekNesne.cs:

        public CizilecekNesne (Texture2D yüklüDesen)

        {

            konumu = Vector2.Zero;

            deseni = yüklüDesen;

        }

3. Adım:

            Game1.cs

               //arkaplanımız için bu değişkeni tanımladık.

        Texture2D arkaPlan;

         //bu değişken de oyunun ekran alanını tutacak.

        Rectangle ekranAlanı;

        //nesnemiz

        GameObject nesne;

4. Adım:

            Game1.cs – LoadContent methodu:

            arkaPlan = Content.Load<Texture2D>("arkaplan");

            //bunun için önceden Content klasörüne bu isimle bir resim koymuş

//olmamız gerekir

 

 

nesne = new CizilecekNesne(Content.Load<Texture2D> ("nesneFoto"));

nesne.konumu = new Vector2(

graphics.GraphicsDevice.Viewport.Width/2,

graphics.GraphicsDevice.Viewport.Height/2);

           

            ekranAlanı = new Rectangle(0, 0,

                graphics.GraphicsDevice.Viewport.Width,

                graphics.GraphicsDevice.Viewport.Height);

           

 burada arkaplanımızı nesnemizi ve ekran alanımızın temsillerini hazırladık.

5. Adım:

            Game1.cs – Draw metodu:

            spriteBatch.Begin(SpriteBlendMode.AlphaBlend);

      spriteBatch.Draw(arkaPlan, ekranAlanı, Color.White);

/* ekran alanı büyüklüğünde, arkaPlan desenine sahip bir resmi beyaz ışıkla döşedik. Dolayısıyla bu bizim arkaPlanımız oldu.*/

 

      spriteBatch.Draw(nesne.deseni, nesne.konumu, Color.White);

      // Burada da nesnemizi ekrana çizdirmiş olduk.

            spriteBatch.End();

 

Böylelikle ekrana nasıl arkaplan deseni verileceğine ve bir nesnenin nasıl çizdirileceğini görmüş olduk. İlerki yazılarımda hareketli bir nesnenin çizimini ve hareket ettirilmesini, çarpışmaları anlatmaya çalışacağım. Ama herşey buradaki gibi basit, değişken tanımla, LoadContent metodunda gerekli şeyleri yükle, Draw metodunda çiz. Eğer hareket veya etkileşim söz konusu ise nasıl davranacağına Update metodunda karar ver.

Sonraki yazılarda görüşmek dileğiyle...

Her ne kadar 3B çalışıyor olduğum için 2B’ye fazla vakit ayıramasam da bu temel öğelere burda yer vermek istiyorum. Bu yazımda bazı gerekli sınıf ve metotları anlatacağım. Sonraki yazımda ise bunları nasıl kullanacağımızı göstereceğim.

 

Sınıflar:

Texture2D sınıfı: Ekrana koyacağımız nesneyi(örneğin bir top) temsil eden grafiğin (örneğin bir top resmi) saklandığı sınıftır.

 

Vector2 sınıfı: Hepimizin lise fiziğinden bildiği hani o okla temsil edilen, i ve j gibi iki bileşeni içeren vektördür. Burda farkında olmanız gereken şey şudur ki, ekranınızda başlangıç noktası (origin) sol üst köşedir ve y ekseni yani j bileşeni aşağı doğru artmaktadır. Koordinat düzlemini baş aşağı düşünelim yani.

 

SpriteBatch sınıfı: Nesnelerimizi temsil eden sprite’ların ekrana çizilmesini sağlayan sınıftır.

XNA Game studio zaten kendisi bize bu sınıftan nesneyi yaratır.

 

Rectangle sınıfı: Çok basit olarak; Sol üst köşesinin koordinatları ve boyutlarıyla bir dikdörtgeni temsil eder.

 

Metotlar:

Content.Load<>() metodu: ContentManager sınıfının nesnesi olan Content, ki bize XNA GS tarafından sağlanmıştır; nesnesinin metodudur.  < > işaretlerinin arasına bu metot ile yükleyeceğiniz içeriği (bir texture, bir font) temsil eden bir tip yazılmalı ve parametre olarak string tipinde varlığın (asset) adı verilmelidir. Örnek olarak XNA GS’nin bize sağladığı Content klasörünün içinde “arkaPlan.tga” isminde bir resmimiz olsun. Biz de bunu içerik klasöründen alarak oyuna yüklemek isteyelim; doğal olarak bu 2 boyutlu resmi temsil edecek sınıf Texture2D olacaktır.  Yani yazmamız gereken kod: 

Texture2D backgroundTexture;

Değişkenini tanımladıktan sonra;

            backgroundTexture = Content.Load<Texture2D>("arkaPlan");

olmalıdır.

 

spriteBatch.Begin() metodu:

Bize XNA GS tarafından tanımlanan spriteBatch nesnesinin metodudur. Daha önceden anlattığım Draw() metodunun içine yazılır ve çizim işleminin nasıl yapılacağı nesnelerin nasıl ele alınacağı hakkında grafik kartına bilgi verir.

Parametre olarak;

SpriteBlendMode cinsinden bir geçiştirme biçimi alır (overload 2). Geçiştirme, alfa (saydamlık) değerlerine göre üst üste gelen nesne dokularının(texture) birbiri üstüne çizilmesi işlemidir.

Örnek olarak:

      spriteBatch.Begin(SpriteBlendMode.AlphaBlend);

Burada saydamlık(alpha) değerlerine göre geçiştirme ve çizim işleri gerçekleştirilecektir.

Bazı durumlarda üst üste gelen nesneler sorun yaratacaktır, geçiştirme istediğiniz sırayla olmayacaktır. Bu gibi durumda sıraya göre geçiştirme yapmak için yine bu metodun (overload 3) ikinci parametresi olan SpriteSortMode’tan bir sıralama tipi seçilmelidir. Örneğin nesneleri arkadan öne sıralamak için:

spriteBatch.Begin(SpriteBlendMode.AlphaBlend,

 SpriteSortMode.BackToFront, SaveStateMode.None);

SaveStateMode burada bu etkinin hatırlanması anlamına gelecektir, None yerine SaveState dersek performans kaybına uğrarız.

 

spriteBatch.Draw() metodu: 6 tane overload’ı olan bu metodu parametre parametre anlatmak yerine kısaca bahsedeyim,  bir nesnemizin, Texture2D türünden desenini, bu desenin İçine çizileceği dikdörtgeni, pozisyonununu , desenin hangi ışıkla aydınlatılacağını …vb parametre alarak nesnemizin görsel temsilini çizdirir. Örnek olarak bir arkaplan için;

 

            spriteBatch.Draw(arkaPlan, gorulebilirEkran, Color.White);

Color.White burada beyaz ışığı temsil eder ki bu da herhangi bir renk değişimi olmamasını sağlar ama diğer renk değerlerini denerseniz, resmin üzerine renkli bir ışığın etki ettiğini göreceksiniz.

 

spriteBatch.DrawString() metodu: bu metot da font’u, yazılacak yazıyı(string), içine yazılacağı dikdörtgeni(yazıyı konumlandırmak için gerekli) ve yazının rengini parametre alarak ekrana yazının çizilmesini sağlar.

      spriteBatch.DrawString(font,

                "merhaba XNA",

                new Vector2(50.0f,100.0f),

                Color.Red);

font burada 

      font = Content.Load<SpriteFont>("Arial"); 

şeklinde tanımlanmış XML formundaki bir spriteFont dosyasının temsilidir.

Şimdilik bu kadar metot yeter sanıyorum; ama gerek bu metotlarla gerekse başka metotlarla ilgili sorununuz olursa iletişime geçmekten çekinmeyin.

XNA’de bildiğiniz gibi hem Game pad hem de Klavye ile kullanıcı’dan veri alabiliyoruz. Ben işin PC tarafıyla daha çok ilgilendiğim için bu yazımda biraz Klavye ve Fare(Mouse) girdilerinden bahsetmek istiyorum.

Öncelikle bu kodları Update metoduna yazıp deneyebilirsiniz ama gerçek bir oyunda Update() metodunda sadece KlavyeKontrol() gibi bir metot kullanmalıyız. Buraya kendi kaba algoritması dışında daha özel işler için kod yazmayın, metot yazıp burda çağırın.

Öncelikle Klavyemizin o anki durumunu temsil edebilmemiz gerekir bunun için:

 

            // Burada klavyemizi temsilen bir değişken atadık,

      // ve bu değişken klavyenin o anki durumunu tutuyor.

      KeyboardState klavye = Keyboard.GetState();

 

Artık hangi tuşa basıldığını anlamak if deyimi aracılığı ile bizim kontrolümüze kalmış. Tabi  bundan sonra bir olay (event) yazıp bunu tetiğe(trigger)bağlamak buna göre otomatik sonuç sağlamak da mümkün.

     

      //Eğer klavyede basılan tuş yukarı(up)Tuşu ise:

      if(klavye.IsKeyDown(Keys.Up))

{ //true ise yapılacak hareket}

 

Burda gördüğünüz gibi IsKeyDown(Keys key) metodunu kullandık. Bize sağlanılan enum tipindeki “keys” ile istediğimiz tuşu parametre olarak verebiliyoruz.

Temeli bu şekilde olmak üzere gerisi size kalmış.

İşin fare kısmına gelecek olursak, bir problem karşımıza çıkıyor; şöyle anlatayım:

Bir oyun düşünün bir tuşu var ve bu tuşa her basışta paranızı götürüyor karşılığında size bir araba veriyor. Doğal olarak aynı anda sadece 1 ya da 2 arabaya ihtiyacınız var. Ama Update() metodu öylesine sık yenileniyor ki, siz farenin tuşuna basıp çekene kadar 40 – 50 kez yenileniyor. Eğer buna bir önlem almazsanız tuşa tek basışta 40 tane arabanız olmuş oluyor! Korkunç bir sonuç. İşte fareden girdi alırken bu sorunu göz önünde bulundurmalıyız.

Bunun için önce 2 tane MauseState değişkeni tanımlamalıyız birisi o anki durumu, diğeri ise önceki durumu tutmalı. Ve uyarmalıyım ki bu değişkenler kesinlikle update metodunun dışında olmalı ki kayıt tutabilsin.

           

// Farenin önceki ve o anki durumunu tutacak olan değişkenler.

      MouseState fareninÖncekiHali, fareninŞimdikiHali;

 

Sonra öyle bir kontrol deyimi yazmalıyız ki şimdiki durum bastığımızı gösterirken, önceki durum bırakmış olduğumuzu göstersin.

           

              fareninŞimdikiHali = Mouse.GetState();

        if (fareninŞimdikiHali.LeftButton = ButtonState.Pressed &&

        fareninÖncekiHali.LeftButton = ButtonState.Released)

        {

        // Fare tuşuna basılınca yapılacak işlemler.

        }

        fareninÖncekiHali = fareninŞimdikiHali; 

 

Bu şekilde fazladan basma sorununu da hallettik. Umarım faydalı olmuştur.

XNA’de yeni bir projeye başladığımız zaman, XNA Game Studio tarafından hazırlanmış bazı kodlarla karşılaşıyoruz. Bu metotlardan biraz bahsetmek istiyorum.

 

Initialize() Metodu:

Oyunumuz başlamadan evvel ilk olarak nelerin yapılması gerektiğini burda yazıyoruz. Oyunun işleyişinden bağımsız; veritabanından veri getirmek gibi işler buna örnek olabilir.

 

LoadContent() Metodu:

Adından da anlaşılacağı gibi içerik yüklemek için kullanıyoruz bu metodu. Bu metod oyun boyunca bir kez çağrılacaktır. O nedenle burada çağıracağımız içeriği dikkatle seçmeliyiz. Örnek olarak dokuları(texture) yüklemek verilebilir.

           

UnloadContent() Metodu:

            Bu da LoadContent() metodunun yaptığı işin tersini yapmamız içindir.

            Örneğin oyundan çıkarken verileri temizlemek gibi.

 

Update(GameTime) Metodu:

Oyunumuzun en önemli metodudur diyebiliriz. Kullanıcıdan girdi almak, bir merminin çarpışını anlamak gibi işleri burda takip ederiz. Yine bu metot aracılğıyla Draw metodunu çağırarak ekranı yenilettiririz.

 

Draw(GameTime) Metodu:

Oyunumuzun görünen kısmının kendini tekrar çizmesini sağlar. Oyun boyunca FPS(frames per second) dediğimiz değere göre saniyede birkaç kez çağrılır bu metot.

 

Temel olarak XNA Game Studionun bize sağladığı metotlar bunlar. Hangi metotta neyi kullanacağımızı iyice anlarsak performans ve tutarlılık açısından sorunlarımız bir nebze azalmış olur.

Oyun yapmaya karar verdiniz, fikriniz de çok güzel, bir yerlerden de XNA diye bir şey duydunuz; “güzelmiş” dediniz. Sizde de kişilik özelliği olarak extra sabır ve kararlılık var tam bu işin adamısınız. Peki nasıl başlayacaksınız?

Ön Şartlar:

. C# bilmek.    

. .Net çatısında biraz tecrübeli olmak ve sınıflar geliştirip onları etkileşime sokabilmek

. 3B Grafik desteği olan bir bilgisayar.(Direcx9.0c, shader model 1.1 veya üstü)

. Windows XP SP2 veya Windows Vista

. Visual Studio geliştirme ortamı veya Express sürümleri

. XNA Game Studio’nun kendisi (Arama motorunuzdan geliştirme ortamınıza uygun sürümü aratabilirsiniz)

. Eğer Xbox’a yönelik oyun yazmak istiyorsanız PCnize bağlı bir XBox 360

. Yapacağınız oyuna yönelik ön çalışma; örneğin RPG oyunu yapmak isteyen birisinin D&D D20 kurallarını bilmesi oyunun karar mekanizmasını yazarken kolaylık sağlayacaktır, burada önemli olan bu kuralları ayen almak yerine örnek alıp, sizin oyununuza daha uygulanabilirini yazmaktır.

. Temel fizik, analitik ve matematik bilgisi. Bu oyun dünyasının olmazsa olmazıdır. Örneğin duvardan seken bir topun geliş açısına göre sekme açısı ve yönü belirlenmelidir.

 

Bu önşartları hallettiniz, şimdi bir oyun programcısı olabilirsiniz; Peki bu yolda size neler kolaylık sağlayacaktır?

            . XNA Creators Club Üyeliği, bu sitede pek çok doküman ve modül bulabilirsiniz.

            . Elinizin altında kolayca ulaşabileceğiniz bir kitap. (kitap daima iyidir)

. Daha önce sizin yaşayacağınız muhtemel sorunları yaşamış insanların bulunduğu bir Türkçe forum.( Ama benim için dil farketmez diyorsanız büyük ihtimalle Creators club işinizi görecektir)

. Katmanı mimari, Tasarım şablonları vb… mimari yaklaşımları bilmek ve OOP’in sunduğu Kalıtım, Arayüz vb… avantajları kullanabilmek

 

Kolaylık sağlayacak konulardan da haberiniz var hadi ne duruyorsunuz bir “Oyun Programcısı” olun.

Yıllardan beri çok iyi bir PC oyuncusu olmuşumdur. Özellikle strateji ve rpg alanlarında çıkan şaheser oyunların çoğunu bitirmişimdir. Yalnız içimde hep bir boşluk vardı evet oyunlar iyiydi güzeldi ama benim hayal gücüme küçük geliyorlardı ben de lise yıllarından beri hep bir oyun yapmayı hayal ettim. Üniveristeye geldiğimde ise bir yandan okulda gösterdikleri dilleri öğrenirken bir yandan da DirectX’i araştırmaya başladım. C# ile yazılabildiğini gördüğüm an indirmiştim SDK sını. Bayağı uğraştım directX ile ama zaman gerçekten bir sorundu. Dolayısıyla 3B oyun yapacak kadar geliştiremedim kendimi. Ama bu yolda bir sürü sınıf da yazmıştım, onlar da bilgisayarımın tozlu harddiskinde beklemeye mahkum kaldılar.

Aradan bayağı zaman geçtikten sonra Imagine Cup ’08 finallerinde Mehmet Tunçkanat’ın bilgisayarında XNA logosunu gördüm, XNA hakkında az da olsa bilgim vardı, XNA 2.0 iken geçmeyi düşünüyordum ama hep başlama vuruşunu beklemişim. O gün logoyu gördükten sonra Mehmet hocayla küçük bir sohbet yaptık ve sonunda bana kitap yollayabileceğini söyledi ben de büyük bir sevinçle kabul ettim. Bir süre sonra gerçekten de kitap elime ulaştı. Burdan Mehmet Tunçkanat’a tekrar tekrar teşekkür ederim. Artık başlama vuruşu yapılmıştı ve benim XNA yolunda hızla ilerlemem gerekiyordu. Kitabı kısa sürede bitirdim gerçi şu an hala 2 boyutla uğraşıyorum ama temeli sağlam atmak istiyorum. Ama burda XNA’den fırsat buldukça bahsedeceğim çok eğlenceli bir konu ve insan ilgilenirken gerçekten mutlu oluyor.