Gameloop | Engin Polat\'ın Windows 8 , Windows Phone 8 ve C# içerikli programcılık sitesi

Arşiv

Etiketlenen yazılar gameloop

Windows Phone 8 – XNA Oyunu / MiniCar

22 January 2015 Yorum yapılmamış

Bu yazımı okumadan önce Windows Phone ve XNA konusundaki diğer makalelerimi okumanızı öneririm.

Önce görseller ve oyunun arkaplan ses dosyası;

MiniCar : BackgroundMiniCar : MainCarMiniCar : Car1MiniCar : Car2MiniCar : Car3MiniCar : Car4MiniCar : Car5MiniCar : Car6MiniCar : Car7MiniCar : Car8

İlk olarak XNA Game Studio 4.0 grubundaki Windows Phone Game şablonundan MiniCarGame isimli projeyi oluşturalım;

Windows Phone : XNA Game Project Template

Game1.cs dosyasının ismini GameLoop.cs olarak değiştirdikten sonra, EnemyCar isminde yeni bir class ekleyelim;

public class EnemyCar
{
	public Texture2D Texture;

	public Vector2 Position;

	public float Velocity;

	public Rectangle Area;

	Random r = new Random();

	public EnemyCar(Texture2D CarTexture)
	{
		this.Texture = CarTexture;

		this.Position = new Vector2(r.Next(450, 850), 1);

		this.Velocity = (float)(r.NextDouble() * 4) + 3f;

		this.Area = new Rectangle((int)this.Position.X, (int)this.Position.Y, this.Texture.Width, this.Texture.Height);
	}
}

EnemyCar sınıfı sayesinde, ekrana getireceğimiz diğer araçların görsellerini, konumlarını, çarpışma testi yapabilmek için ekranda kapladığı alanı ve hızlarını bileceğiz.

GameLoop sınıfına geri dönelim ve sınıf seviyesindeki değişkenlere aşağıdakileri ekleyelim;

GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;

const int PENCERE_GENISLIK = 800;
const int PENCERE_YUKSEKLIK = 480;

Texture2D BackgroundTexture1;
Texture2D BackgroundTexture2;

Vector2 BackgroundPosition1 = new Vector2(0, -PENCERE_YUKSEKLIK);
Vector2 BackgroundPosition2 = new Vector2(0, 0);

Texture2D MainCarTexture;
Vector2 MainCarPosition = new Vector2(300, 300);

float KatedilenMesafe = 0f;

Rectangle ScreenArea = new Rectangle(0, 0, PENCERE_GENISLIK, PENCERE_YUKSEKLIK);
Rectangle MainCarArea = new Rectangle(300, 300, 67, 134);

TimeSpan TotalElapsedTime;

List<EnemyCar> CarList = new List<EnemyCar>();

Random r = new Random();

Texture2D[] CarTextures = new Texture2D[8];

Klavyedeki hangi tuşlara basıldığını kontrol edebilmek için KeyboardState değişkenlerimizi, arkaplanda sürekli tekrar eden ses çaldırmak için SoundEffectInstance değişkenimizi ve oyunun bittiğini takip edeceğimiz bool değişkeni de sınıf seviyesinde ekleyelim;

KeyboardState ks;
KeyboardState pks;

SoundEffectInstance BackgroundLoop;

bool IsGameOver = false;

İlk yapacağımız iş GameLoop sınıfının constructor‘ında gerekli atamaları yapmak olacak;

public GameLoop()
{
	graphics = new GraphicsDeviceManager(this);
	Content.RootDirectory = "Content";

	graphics.PreferredBackBufferWidth = PENCERE_GENISLIK;
	graphics.PreferredBackBufferHeight = PENCERE_YUKSEKLIK;
	graphics.IsFullScreen = true;
}

LoadContent() methodunda değişkenlerimiz aracılığıyla ses ve resim dosyalarını hafızaya yüklüyoruz;

protected override void LoadContent()
{
	spriteBatch = new SpriteBatch(GraphicsDevice);

	BackgroundTexture1 = Content.Load<Texture2D>("BackgroundRoad");
	BackgroundTexture2 = BackgroundTexture1;
	MainCarTexture = Content.Load<Texture2D>("MainCar");

	MesafeFont = Content.Load<SpriteFont>("Verdana14");

	for (int i = 0; i < CarTextures.Length; i++)
	{
		CarTextures[i] = Content.Load<Texture2D<("Car" + (i + 2));
	}

	BackgroundLoop = Content.Load<SoundEffect>("BackgroundLoop").CreateInstance();

	GameOverFont = Content.Load<SpriteFont>("GameOverFont");

	BackgroundLoop.IsLooped = true;
	BackgroundLoop.Play();
}

Update() method'unda ilk olarak oyundan çıkma ve baştan başlama durumunu sağlayacak kodları yazıyoruz;

ks = Keyboard.GetState();

if (ks.IsKeyDown(Keys.Escape))
{
	this.Exit();
}

if (IsGameOver && ks.IsKeyDown(Keys.Enter))
{
	IsGameOver = false;
	BackgroundLoop.Play();
	KatedilenMesafe = 0f;
	MainCarPosition = new Vector2(600, 600);
	MainCarArea.X = (int)MainCarPosition.X;
	MainCarArea.Y = (int)MainCarPosition.Y;
	CarList.Clear();
}

Eğer oyun sonlanmadıysa, klavyedeki tuşların durumuna göre arabamızı hareket ettiriyoruz, en son araba eklediğimiz zamandan itibaren belli bir sürenin üzerinde geçtiyse yeni EnemyCar ekliyoruz, EnemyCar listesindeki her bir arabayı hareket ettiriyoruz, yol görselini içeren arkaplanı hareket ettiriyoruz, katedilen mesafeyi güncelleyip, bizim arabamız ile diğer arabaların çarpışma testini yapıyoruz;

if (!IsGameOver)
{
	if (ks.IsKeyDown(Keys.Left))
	{
		MainCarPosition.X -= 3;
		MainCarArea.X -= 3;
	}
	if (ks.IsKeyDown(Keys.Right))
	{
		MainCarPosition.X += 3;
		MainCarArea.X += 3;
	}
	if (ks.IsKeyDown(Keys.Up))
	{
		MainCarPosition.Y -= 3;
		MainCarArea.Y -= 3;
	}
	if (ks.IsKeyDown(Keys.Down))
	{
		MainCarPosition.Y += 3;
		MainCarArea.Y += 3;
	}

	TotalElapsedTime += gameTime.ElapsedGameTime;

	if (TotalElapsedTime > TimeSpan.FromMilliseconds(1500))
	{
		EnemyCar car = new EnemyCar(CarTextures[r.Next(0, 8)]);

		CarList.Add(car);

		TotalElapsedTime = TimeSpan.Zero;
	}

	foreach (EnemyCar car in CarList)
	{
		car.Position.Y += car.Velocity;
		car.Area.Y = (int)car.Position.Y;
	}

	BackgroundPosition1.Y += 2;
	BackgroundPosition2.Y += 2;

	if (BackgroundPosition2.Y > PENCERE_YUKSEKLIK)
	{
		BackgroundPosition1.Y = -PENCERE_YUKSEKLIK;
		BackgroundPosition2.Y = 0;
	}

	KatedilenMesafe += 0.005f;

	foreach (EnemyCar car in CarList)
	{
		if (car.Area.Intersects(MainCarArea))
		{
			IsGameOver = true;
			BackgroundLoop.Stop();
		}
	}
}

Son olarak Update() methodunun son satırında KeyboardState‘i pks değişkenine atyoruz;

pks = ks;

Draw() methodunda kendi arabamızı, diğer arabaları ve katettiğimiz mesafeyi ekrana çiziyoruz;

GraphicsDevice.Clear(Color.CornflowerBlue);

spriteBatch.Begin();

spriteBatch.Draw(BackgroundTexture1, BackgroundPosition1, Color.White);
spriteBatch.Draw(BackgroundTexture2, BackgroundPosition2, Color.White);

spriteBatch.Draw(MainCarTexture, MainCarPosition, Color.White);

spriteBatch.DrawString(MesafeFont, "Katedilen Mesafe: " + KatedilenMesafe.ToString("N2") + " km", new Vector2(51, 51), Color.Black);
spriteBatch.DrawString(MesafeFont, "Katedilen Mesafe: " + KatedilenMesafe.ToString("N2") + " km", new Vector2(50, 50), Color.White);

foreach (EnemyCar car in CarList)
{
	spriteBatch.Draw(car.Texture, car.Position, Color.White);
}

if (IsGameOver)
{
	spriteBatch.DrawString(GameOverFont, "GAME OVER", new Vector2(433, 353), Color.Yellow);
	spriteBatch.DrawString(GameOverFont, "GAME OVER", new Vector2(430, 350), Color.Red);
}

spriteBatch.End();

Windows Phone 8 – XNA Oyunu / Savaşa Hayır

12 January 2014 1 yorum

Bu yazımı okumadan önce Windows Phone ve XNA konusundaki diğer makalelerimi okumanızı öneririm.

Önce görseller;

Savaşa Hayır : BackgroundSavaşa Hayır : Drop 1 0Savaşa Hayır : Drop 1 1Savaşa Hayır : Drop 2 0Savaşa Hayır : Drop 2 1Savaşa Hayır : Plane 0Savaşa Hayır : Plane 1Savaşa Hayır : Plane 2Savaşa Hayır : Plane 3Savaşa Hayır : Plane 4Savaşa Hayır : Plane 5

İlk olarak XNA Game Studio 4.0 grubundaki Windows Phone Game şablonundan SavasaHayir isimli projeyi oluşturalım;

Windows Phone : XNA Game Project Template

Game1.cs dosyasının ismini GameLoop.cs olarak değiştirdikten sonra, Plane isminde yeni bir class ekleyelim;

public class Plane
{
	public Texture2D Texture;

	public int Location;

	public int Speed;
}

Plane sınıfı sayesinde, ekrana getireceğimiz uçakların telefon ekranındaki konumlarını, hızlarını ve görsellerini bileceğiz.

Drop isminde yeni bir class daha ekleyelim ve aşağıdaki kod parçası ile güncelleyelim;

public class Drop
{
	public bool IsBox;

	public bool IsParachute;

	public Vector2 Location;
}

GameLoop sınıfına geri dönelim ve sınıf seviyesindeki değişkenlere aşağıdakileri ekleyelim;

GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;

Random r = new Random();

Texture2D BackgroundTexture;

Texture2D BoxTexture;
Texture2D BoxParachuteTexture;

Texture2D HumanTexture;
Texture2D HumanParachuteTexture;

Texture2D[] PlaneTextures = new Texture2D[6];

List<Plane> PlaneList = new List<Plane>();

List<Drop> DropList = new List<Drop>();

TimeSpan LastPlaneDate = TimeSpan.Zero;

int PlaneCount;
int DropCount;
int HelpCount;

Yukarıdaki kodlar için daha önce yazmış olduğum Windows Phone ve XNA konusundaki diğer makalelerimi okumanızı öneririm.

GameLoop sınıfının constructor‘ında aşağıdaki atama işlerini yapalım;

public GameLoop()
{
	graphics = new GraphicsDeviceManager(this);
	Content.RootDirectory = "Content";

	TargetElapsedTime = TimeSpan.FromTicks(333333);

	InactiveSleepTime = TimeSpan.FromSeconds(1);

	graphics.PreferredBackBufferWidth = 480;
	graphics.PreferredBackBufferHeight = 800;

	graphics.IsFullScreen = true;
}

LoadContent method’unda Texture2D tipindeki değişkenlerimize değer atayalım;

spriteBatch = new SpriteBatch(GraphicsDevice);

BackgroundTexture = Content.Load<Texture2D>("Background");

for (int iLoop = 0; iLoop < 6; iLoop++)
{
	PlaneTextures[iLoop] = Content.Load<Texture2D>("Plane" + iLoop);
}

BoxTexture = Content.Load<Texture2D>("Drop1_0");
BoxParachuteTexture = Content.Load<Texture2D>("Drop1_1");

HumanTexture = Content.Load<Texture2D>("Drop2_0");
HumanParachuteTexture = Content.Load<Texture2D>("Drop2_1");

Update method'unda Plane ve Drop listesindeki elemanların yerlerini güncelliyoruz;

foreach (var plane in PlaneList)
{
	plane.Location += plane.Speed;
}

foreach (var drop in DropList)
{
	drop.Location.Y += 4;
}

Son uçak üretme zamanımızdan itibaren 5000ms (5sn) geçtiyse yeni uçak üretme kodunu ekliyoruz;

LastPlaneDate += gameTime.ElapsedGameTime;

if (LastPlaneDate > TimeSpan.FromMilliseconds(5000))
{
	var plane = new Plane();

	plane.Texture = PlaneTextures[r.Next(0, 6)];

	plane.Speed = r.Next(3, 8);

	PlaneList.Add(plane);

	PlaneCount++;

	LastPlaneDate = TimeSpan.Zero;
}

Windows Phone oyunlarında, oyuncunun ekrana dokunduğu noktaların listesini TouchPanel sınıfının static GetState methodundan dönen TouchCollection ile alabilmekteyiz.

TouchCollection koleksiyonunun her bir elemanı TouchLocation tipindedir, State özelliğinin TouchLocationState enum’ından Pressed değerinde olduğunu kontrol ederek, ilgili noktaya dokunulduğu durumu yakalayabiliriz.

Eğer dokunulan nokta bir Plane ile kesişiyorsa, rastgele yeni bir Drop düşürebiliriz, Drop ile kesişiyorsa paraşütünün açılmasını sağlayabiliriz;

foreach (var tl in TouchPanel.GetState())
{
	if (tl.State == TouchLocationState.Pressed)
	{
		var touchArea = new Rectangle((int)tl.Position.X, (int)tl.Position.Y, 1, 1);

		foreach (var plane in PlaneList)
		{
			var planeArea = new Rectangle(plane.Location, 20, plane.Texture.Width, plane.Texture.Height);

			if (planeArea.Intersects(touchArea))
			{
				var drop = new Drop();

				drop.Location = new Vector2(tl.Position.X, 20);

				drop.IsBox = (r.Next(0, 2) == 0);

				DropList.Add(drop);

				DropCount++;

				return;
			}
		}

		foreach (var drop in DropList)
		{
			var dropArea = new Rectangle((int)drop.Location.X, (int)drop.Location.Y, 100, 200);

			if (!drop.IsParachute && dropArea.Intersects(touchArea))
			{
				drop.IsParachute = true;

				HelpCount++;

				return;
			}
		}
	}
}

Son olarak Draw method’unda elimizdeki arkaplan görselini, ekrandaki uçakları, paraşütü açılmış ve açılmamış nesneleri ekrana çizdireceğiz;

GraphicsDevice.Clear(Color.CornflowerBlue);

spriteBatch.Begin();

spriteBatch.Draw(BackgroundTexture, Vector2.Zero, Color.White);

foreach (var plane in PlaneList)
{
	spriteBatch.Draw(plane.Texture, new Vector2(plane.Location, 20), Color.White);
}

foreach (var drop in DropList)
{
	if (drop.IsBox && drop.IsParachute)
	{
		spriteBatch.Draw(BoxParachuteTexture, drop.Location, Color.White);
	}
	else if (drop.IsBox && !drop.IsParachute)
	{
		spriteBatch.Draw(BoxTexture, drop.Location, Color.White);
	}
	else if (!drop.IsBox && drop.IsParachute)
	{
		spriteBatch.Draw(HumanParachuteTexture, drop.Location, Color.White);
	}
	else
	{
		spriteBatch.Draw(HumanTexture, drop.Location, Color.White);
	}
}

spriteBatch.End();

Oyun’dan bir ekran görüntüsü;

Savaşa Hayır : Screenshot

Windows Phone 8 – XNA Oyunu / PlaneHunter

18 February 2013 3 yorum

Bu yazımı okumadan önce Windows Phone ve XNA konusundaki diğer makalelerimi okumanızı öneririm.

Her zamanki gibi önce görseller;

PlaneHunter : BackgroundPlaneHunter : CoinPlaneHunter : Target1PlaneHunter : Target2PlaneHunter : Target3PlaneHunter : Target4PlaneHunter : Target5PlaneHunter : Target6PlaneHunter : Target7

Bir tane de Sprite Font dosyamız var, HitCountFont.spritefont ismini verdiğim dosyanın, “yorum satırları kaldırılmış halini” aşağıdaki gibi düzenledim;

<?xml version="1.0" encoding="utf-8"?>
<XnaContent xmlns:Graphics="Microsoft.Xna.Framework.Content.Pipeline.Graphics">
	<Asset Type="Graphics:FontDescription">
		<FontName>Segoe UI Mono</FontName>
		<Size>14</Size>
		<Spacing>0</Spacing>
		<UseKerning>true</UseKerning>
		<Style>Regular</Style>
		<CharacterRegions>
			<CharacterRegion>
				<Start> </Start>
				<End>~</End>
			</CharacterRegion>
		</CharacterRegions>
	</Asset>
</XnaContent>

İlk olarak XNA Game Studio 4.0 grubundaki Windows Phone Game şablonundan PlaneHunter isimli projeyi oluşturalım;

Windows Phone : XNA Game Project Template

Game1.cs dosyasının ismini GameLoop.cs olarak değiştirdikten sonra, Target isminde yeni bir class ekleyelim;

public class Target
{
	public Texture2D Texture;

	public Vector2 Position;

	public Vector2 Velocity;

	public Rectangle Area;

	public SpriteEffects Effect;

	public bool IsAlive;

	public Target(Texture2D texture)
	{
		this.Texture = texture;

		this.IsAlive = true;

		this.Area = new Rectangle(0, 0, texture.Width, texture.Height);
	}
}

Target sınıfı sayesinde, ekrana getireceğimiz hedef‘lerin ekranın neresinden çıkıp, hangi yöne doğru gideceğini, hedefin vurulup/vurulmadığını, çarpışma testi yapabilmek için ekranda kapladığı alanı ve hızını bileceğiz.

GameLoop sınıfına geri dönelim ve sınıf seviyesindeki değişkenlere aşağıdakileri ekleyelim;

private const int PENCERE_GENISLIK = 800;
private const int PENCERE_YUKSEKLIK = 480;

private Texture2D backgroundTexture;

private readonly Texture2D[] targetTextures = new Texture2D[7];

private Texture2D coinTexture;
private Rectangle coinPart;
private int coinPartIndex = 0;

private SpriteFont hitCountFont;
private int targetHitCount = 0;

private readonly List targetList = new List();

private TimeSpan lastTargetSpawnTime = TimeSpan.Zero;

private readonly Rectangle screenArea = new Rectangle(0, 0, PENCERE_GENISLIK, PENCERE_YUKSEKLIK);

private readonly Random r = new Random();

Yukarıdaki kodlar için daha önce yazmış olduğum Windows Phone ve XNA konusundaki diğer makalelerimi okumanızı öneririm.

GameLoop sınıfının constructor‘ında aşağıdaki atama işlerini yapalım;

graphics.PreferredBackBufferWidth = PENCERE_GENISLIK;
graphics.PreferredBackBufferHeight = PENCERE_YUKSEKLIK;
graphics.IsFullScreen = true;

graphics.SupportedOrientations = DisplayOrientation.LandscapeLeft | DisplayOrientation.LandscapeRight;

SupportedOrientations özelliğine DisplayOrientation enum’ından LandscapeLeft ve LandscapeRight değerlerini atayarak, oyun ekranının telefon dikey değil, yatay tutulduğunda düzgün görüntüleneceğini tanımlamış olduk.

LoadContent method’unda Texture2D tipindeki değişkenlerimize değer atayalım;

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

coinTexture = Content.Load<Texture2D>("PlaneHunterCoin");
hitCountFont = Content.Load<SpriteFont>("PlaneHunterHitCountFont");

for (int i = 0; i < targetTextures.Length; i++)
{
	targetTextures[i] = Content.Load<Texture2D>("PlaneHunterTarget" + (i + 1));
}

Update method’unda son hedef üretilme zamanından itibaren yeterli süre geçmişse, yeni hedef oluşturmamız lazım;

lastTargetSpawnTime += gameTime.ElapsedGameTime;

if (lastTargetSpawnTime > TimeSpan.FromMilliseconds(1500))
{
	Target t = new Target(targetTextures[r.Next(0, 7)]);
	switch (r.Next(0, 4))
	{
		case 0:
		default:
			t.Position = new Vector2(r.Next(100, 300), 480);
			t.Velocity = new Vector2((float)r.NextDouble() * 8 + 2, (float)r.NextDouble() * -4 - 2);
			t.Effect = SpriteEffects.FlipHorizontally;
			break;
		case 1:
			t.Position = new Vector2(r.Next(500, 700), 480);
			t.Velocity = new Vector2((float)r.NextDouble() * -8 - 2, (float)r.NextDouble() * -4 - 2);
			t.Effect = SpriteEffects.None;
			break;
		case 2:
			t.Position = new Vector2(r.Next(100, 300), 0);
			t.Velocity = new Vector2((float)r.NextDouble() * 8 + 2, (float)r.NextDouble() * 4 + 2);
			t.Effect = SpriteEffects.FlipHorizontally;
			break;
		case 3:
			t.Position = new Vector2(r.Next(500, 700), 0);
			t.Velocity = new Vector2((float)r.NextDouble() * -8 - 2, (float)r.NextDouble() * 4 + 2);
			t.Effect = SpriteEffects.None;
			break;
	}

	targetList.Add(t);

	lastTargetSpawnTime = TimeSpan.Zero;
}

Yeni hedef ekleyeceğimiz zaman öncelikle hedef’i ekranın dört köşesinden rastgele birtanesine koyup, rastgele hız veriyoruz. Böylece hedefler ekranın rastgele bir yerinden çıkıp rastgele hızla rastgele bir yöne doğru hareket edecek.

Update method’unda o esnada ekranda olan hedeflerin yerlerini ve ekranda kapladıkları alanı güncelliyoruz;

foreach (Target hedef in targetList)
{
	hedef.Position += hedef.Velocity;

	hedef.Area.X = (int)hedef.Position.X;
	hedef.Area.Y = (int)hedef.Position.Y;
}

Windows Phone oyunlarında, oyuncunun ekrana dokunduğu noktaların listesini TouchPanel sınıfının static GetState methodundan dönen TouchCollection ile alabilmekteyiz.

TouchCollection koleksiyonunun her bir elemanı TouchLocation tipindedir, State özelliğinin TouchLocationState enum’ından Pressed değerinde olduğunu kontrol ederek, ilgili noktaya dokunulduğu durumu yakalayabilir, eğer bir hedef ile kesişiyorsa, hedefi öldürebiliriz;

TouchCollection tc = TouchPanel.GetState();
foreach (TouchLocation tl in tc)
{
	if (tl.State == TouchLocationState.Pressed)
	{
		Rectangle touchArea = new Rectangle((int)tl.Position.X, (int)tl.Position.Y, 1, 1);

		foreach (Target hedef in targetList)
		{
			if (hedef.Area.Intersects(touchArea))
			{
				hedef.Velocity = Vector2.Zero;

				hedef.IsAlive = false;

				targetHitCount++;
			}
		}
	}
}

Update method’unda, ekran sınırları dışına çıkan hedefleri listeden çıkartmalıyız. Eğer ekran dışına çıkan hedefleri listeden temizlemezsek, liste zamanla çok büyüyecek, telefonun kısıtlı olan hafızasını dolduracak ve oyunun önce yavaşlamasına sonra kapanmasına yol açabilecektir.

foreach (Target hedef in targetList)
{
	if (!hedef.Area.Intersects(screenArea))
	{
		targetList.Remove(hedef);

		break;
	}
}

Draw method’unda elimizdeki arkaplan görselini, hayatta olan hedefleri, hayatta olmayan hedefler için kendi etrafında dönen altın görselini ve toplam kaç hedefin vurulduğunu gösteren skor‘u ekrana çizdireceğiz;

spriteBatch.Begin();

spriteBatch.Draw(backgroundTexture, Vector2.Zero, Color.White);

foreach (Target hedef in targetList)
{
	if (hedef.IsAlive)
	{
		spriteBatch.Draw(hedef.Texture, hedef.Position, null, Color.White, 0, Vector2.Zero, 1, hedef.Effect, 0);
	}
	else
	{
		spriteBatch.Draw(coinTexture, hedef.Position, coinPart, Color.White);
	}
}

spriteBatch.DrawString(hitCountFont, "Hit Count : " + targetHitCount, new Vector2(10, 10), Color.Black);
spriteBatch.DrawString(hitCountFont, "Hit Count : " + targetHitCount, new Vector2(9, 9), Color.White);

spriteBatch.End();

Oyunumuzdan bir kare;

Windows Phone - XNA Oyunu : PlaneHunter

Oyunun kodlarını buradan indirebilirsiniz.

XNA Oyun Programlama Platformu Hakkında

30 January 2013 Yorum yapılmamış

Günümüzde tüm yazılım sektörü gibi oyun dünyası’da çok hızlı gelişmeye ve şekillenmeye başladı. Artık insanlar yeni bir oyun için aylarca beklemeye tahammül etmiyor.

Böyle zamanlarda yapılması gereken ürünü mümkün olan en hızlı yollardan tüketiciye ulaştırmaktır.
Bu durumun farkına varan oyun evleri birkaç yıl öncesine göre çok daha kısa sürelerde yeni oyun üretmenin yollarını aramaya başladı.

2004 yılında Microsoft, Indie olarak kısalttığımız Independent Game Developer‘lar (yani Bağımsız Oyun Geliştiriciler) için hızlı oyun geliştirme platformunu duyurdu ve 2006 yılının ikinci yarısında da XNA Game Studio ismi ile yayınladı.
2007 yılından beri oyun evleri ve bağımsız geliştiriciler XNA Framework ile hem 2 boyutlu hem de 3 boyutlu oyunlar geliştiriyorlar.

XNA, mümkün olan en az kod değişikliği ile şu platformlar için oyunları geliştirmemize yardımcı olur;

  • Windows üzerinde çalışan 2 boyutlu ve 3 boyutlu oyunlar
  • Microsoft’un oyun platformu olan XBOX üzerinde çalışan 2 boyutlu ve 3 boyutlu oyunlar
  • Microsoft’un mobil platformu olan Windows Phone ailesi üzerinde çalışan 2 boyutlu ve 3 boyutlu oyunlar

Özellikle mobil oyunların son yıllarda izlediği trende bakacak olursak, oyun geliştiriciler için çok güzel bir pazar olduğunu farkederiz.

XNA sayesinde, çok az kod değişikliği yaparak birden fazla platforma oyunlarımızı yayınlayabiliyoruz.

Üstelik oyun geliştirmeye başlarken ihtiyaç duyacağımız tüm araçlar (XNA Framework’un kendisi, Visual Studio’nun Express sürümü) Microsoft tarafından ücretsiz olarak sağlanıyor.

Tüm maddeleri özetleyecek olursak, XNA ile başlangıç maliyetleri olmadan, Microsoft tarafından desteklenen tüm platformlara hem 2 boyutlu, hem 3 boyutlu oyun geliştirebiliyoruz.

Neden XNA tercih etmeliyiz?

Geliştirici açısından düşünecek olursak, XNA, .Net Framework temelleri üzerine kurulduğu için, C#, VB.Net ve C++.Net gibi .Net ailesi diller ile geliştirilebiliyor.

Eğer zaten .Net dünyasına ve .Net ailesi dillere aşina iseniz, XNA ile oyun geliştirmeye hemen başlayabilirsiniz.

Üstelik XNA’de kazandığınız tecrübeler ve .Net dillerinde kazandığınız tecrübeler, birleşerek tüm yazılım geliştirme yeteneklerinizi olumlu yönde etkileyecektir.

Ayrıca Oyun Yaşam Döngüsü dediğimiz, bir oyun’un başlatıldığı andan sonlandırıldığı ana kadar geçen tüm süreçler XNA içerisinde çok net bir şekilde tanımlanmıştır.

Haliyle XNA ile oyun geliştirmeye başlamanın yanı sıra, XNA ile oyun geliştirme sürecinin kendisi de en az efor ile öğrenilecek kadar kolaylaştırılmıştır.

XNA ile geliştirilen oyunlar, minimum efor ile, WindowsXBOXWindows Phone platformlarına taşınabiliyor. Böylece hedef kitlemizi artırabilir, oyunumuzun çok daha büyük kitlelere ulaşmasını sağlayabiliriz.

Çok Oyunculu oyunlar geliştirme süreçleri de XNA sayesinde çok kolaylaştırılmıştır. XNA Framework, Yerel ağ üzerinden tek sunuculu veya tüm oyuncuların sunucu olduğu senaryo ve internet üzerinden tek sunuculu oyunların yazılması için hazır yapılar barındırmaktadır.

Tüm maddeleri özetleyecek olursak, .Net ailesi dil biliyor olmak XNA ile oyun geliştirmeye başlamak için büyük avantajdır.

Yazılım geliştirme ve oyun geliştirme tecrübelerinin transfer edilebiliyor olması aynı şekilde büyük avantajdır. Çok oyunculu oyunların yazılması için kolay kullanıma sahip sınıflar framework ile birlikte gelmektedir.

XNA Oyunu / Meyve Veren Ağaç

15 April 2012 Yorum yapılmamış

Bu yazımı okumadan önce XNA konusundaki diğer makalelerimi okumanızı öneririm.

Önce görseller;

XNA - Meyve Veren Ağaç - Araba XNA - Meyve Veren Ağaç - Adam XNA - Meyve Veren Ağaç - Sepet XNA - Meyve Veren Ağaç - Armut XNA - Meyve Veren Ağaç - Uzum XNA - Meyve Veren Ağaç - Elma XNA - Meyve Veren Ağaç - Portakal XNA - Meyve Veren Ağaç - Seftali XNA - Meyve Veren Ağaç - Cilek XNA - Meyve Veren Ağaç - Kavun XNA - Meyve Veren Ağaç - Tas XNA - Meyve Veren Ağaç - Muz XNA - Meyve Veren Ağaç - Ağaç Arkaplan

Bir tane arkaplan ses dosyamız var;

Arkaplan Müziği

Bir tane de Sprite Font dosyamız var;

SkorFont.spritefont ismini verdiğim dosyanın, “yorum satırları kaldırılmış halini” aşağıdaki gibi düzenledim;

<?xml version="1.0" encoding="utf-8"?>
<XnaContent xmlns:Graphics="Microsoft.Xna.Framework.Content.Pipeline.Graphics">
	<Asset Type="Graphics:FontDescription">
		<FontName>Arial</FontName>
		<Size>16</Size>
		<Spacing>0</Spacing>
		<UseKerning>true</UseKerning>
		<Style>Regular</Style>
		<CharacterRegions>
			<CharacterRegion>
				<Start>&#32;</Start>
				<End>&#126;</End>
			</CharacterRegion>
		</CharacterRegions>
	</Asset>
</XnaContent>

Başlayalım oyunumuzu yazmaya; MeyveVerenAgac projemizi oluşturduktan ve Game1.cs‘in ismini GameLoop.cs olarak değiştirdikten sonra, class seviyesindeki değişkenlerimizi tanımlayalım;

public const int PENCERE_GENISLIK = 800;
public const int PENCERE_YUKSEKLIK = 600;
public const bool TAM_EKRAN = false;

Texture2D Arkaplan;

Oyun penceremizin sınırlarını tutacağımız Rectangle tipinde bir değişkeni class seviyesindeki değişkenlerimize ekleyelim;

Rectangle Pencere;

Gelelim bu değişkenleri kullanmaya, GameLoop class‘ımızın constructor methodunda aşağıdaki kodları yazalım;

graphics.PreferredBackBufferWidth = PENCERE_GENISLIK;

graphics.PreferredBackBufferHeight = PENCERE_YUKSEKLIK;

graphics.IsFullScreen = TAM_EKRAN;

Pencere = new Rectangle(0, 0, PENCERE_GENISLIK, PENCERE_YUKSEKLIK);

Ses dosyalarımız için class seviyesinde değişkenlerimiz tanımlayalım;

SoundEffectInstance BackgroundLoop;

LoadContent() method‘unda değişkenlerimize yükleme işlemlerini gerçekleştirelim;

BackgroundLoop = Content.Load<SoundEffect>("BackgroundLoop").CreateInstance();

BackgroundLoop.Volume = 0.2f;
BackgroundLoop.IsLooped = true;
BackgroundLoop.Play();

Ses dosyası ile yaptığımız bu işlemleri XNA ile Pong oyunu yazalım – 2 ve XNA Oyun / Çanakkale Geçilmez – 1 yazılarımdan hatırlayacaksınız.

XNA Oyun / Çanakkale Geçilmez – 1 oyunumdan hatırlayacağınız GameObject sınıfını oluşturalım;

public enum GameObjectList
{
	Background,
	Basket,
	Random,
	Man,
	Car,
	Pear,
	Strawberry,
	Apple,
	Melon,
	Banana,
	Orange,
	Peach,
	Rock,
	Grape
}

public class GameObject : DrawableGameComponent
{
	SpriteBatch spriteBatch;

	public GameObjectList GameObjectType;

	Texture2D ObjectTexture;

	Vector2 ObjectPosition;

	Random r;

	MouseState ms;

	float FallSpeed = 0f;

	public Rectangle ObjectRectangle;

	public GameObject(Game game, GameObjectList GameObjectType) : base(game)
	{
		r = new Random();

		if (GameObjectType == GameObjectList.Random)
		{
			this.GameObjectType = (GameObjectList)r.Next(3, 14);
		}
		else
		{
			this.GameObjectType = GameObjectType;
		}

		FallSpeed = (float)(r.Next(1, 4) + r.NextDouble());
	}

	public override void Initialize()
	{
		base.Initialize();
	}

	protected override void LoadContent()
	{
		spriteBatch = new SpriteBatch(this.Game.GraphicsDevice);

		switch (this.GameObjectType)
		{
			case GameObjectList.Background:
				ObjectTexture = this.Game.Content.Load<Texture2D>("AgacArkaplan");

				ObjectPosition = Vector2.Zero;
				break;
			case GameObjectList.Man:
				ObjectTexture = this.Game.Content.Load<Texture2D>("Adam");

				ObjectPosition = new Vector2(r.Next(0, 800), 10);
				break;
			case GameObjectList.Car:
				ObjectTexture = this.Game.Content.Load<Texture2D>("Araba");

				ObjectPosition = new Vector2(r.Next(0, 800), 10);
				break;
			case GameObjectList.Pear:
				ObjectTexture = this.Game.Content.Load<Texture2D>("Armut");

				ObjectPosition = new Vector2(r.Next(0, 800), 10);
				break;
			case GameObjectList.Strawberry:
				ObjectTexture = this.Game.Content.Load<Texture2D>("Cilek");

				ObjectPosition = new Vector2(r.Next(0, 800), 10);
				break;
			case GameObjectList.Apple:
				ObjectTexture = this.Game.Content.Load<Texture2D>("Elma");

				ObjectPosition = new Vector2(r.Next(0, 800), 10);
				break;
			case GameObjectList.Melon:
				ObjectTexture = this.Game.Content.Load<Texture2D>("Kavun");

				ObjectPosition = new Vector2(r.Next(0, 800), 10);
				break;
			case GameObjectList.Banana:
				ObjectTexture = this.Game.Content.Load<Texture2D>("Muz");

				ObjectPosition = new Vector2(r.Next(0, 800), 10);
				break;
			case GameObjectList.Orange:
				ObjectTexture = this.Game.Content.Load<Texture2D>("Portakal");

				ObjectPosition = new Vector2(r.Next(0, 800), 10);
				break;
			case GameObjectList.Peach:
				ObjectTexture = this.Game.Content.Load<Texture2D>("Seftali");

				ObjectPosition = new Vector2(r.Next(0, 800), 10);
				break;
			case GameObjectList.Basket:
				ObjectTexture = this.Game.Content.Load<Texture2D>("Sepet");

				ObjectPosition = new Vector2(350, 520);
				break;
			case GameObjectList.Rock:
				ObjectTexture = this.Game.Content.Load<Texture2D>("Tas");

				ObjectPosition = new Vector2(r.Next(0, 800), 10);
				break;
			case GameObjectList.Grape:
				ObjectTexture = this.Game.Content.Load<Texture2D>("Uzum");

				ObjectPosition = new Vector2(r.Next(0, 800), 10);
				break;
		}

		ObjectRectangle = new Rectangle((int)ObjectPosition.X, (int)ObjectPosition.Y, ObjectTexture.Width, ObjectTexture.Height);

		base.LoadContent();
	}

	public override void Update(GameTime gameTime)
	{
		if (GameObjectType == GameObjectList.Basket)
		{
			ms = Mouse.GetState();

			ObjectPosition.X = ms.X;

			ObjectRectangle.X = ms.X;
		}
		else if (GameObjectType != GameObjectList.Background)
		{
			ObjectPosition.Y += FallSpeed;

			ObjectRectangle.Y = (int)ObjectPosition.Y;
		}

		base.Update(gameTime);
	}

	public override void Draw(GameTime gameTime)
	{
		spriteBatch.Begin();

		spriteBatch.Draw(ObjectTexture, ObjectPosition, Color.White);

		spriteBatch.End();

		base.Draw(gameTime);
	}
}

Yeni eklediğimiz GameObjectList enum sayesinde, GameObject sınıfından ürettiğimiz her değişken farklı bir görünüşe ve davranışa sahip olabiliyor. (Örneğin, puan alacağımız üzüm-çilek-kavun gibi meyveler veya puan kaybedeceğimiz taş-araba-insan gibi nesneler)

GameObject sınıfını Microsoft.Xna.Framework namespace‘inde yer alan DrawableGameComponent sınıfından türetiyoruz.

DrawableGameComponent sınıfından türettiğimiz için, GameObject sınıfının kendi LoadContent, Update ve Draw method’ları oluyor.

LoadContent method’unda, ilgili görseli seçip, hafızaya yüklüyoruz. Update method’unda, eğer nesne Sepet veya Arkaplan değilse, rastgele hızda aşağı düşürüyoruz. Eğer nesne Sepet ise, Mouse tarafından kontrol edilmesini sağlıyoruz;

if (GameObjectType == GameObjectList.Basket)
{
	ms = Mouse.GetState();

	ObjectPosition.X = ms.X;

	ObjectRectangle.X = ms.X;
}

Draw method’unda ise, basitçe ilgili nesneyi ekrana çizdiriyoruz.

GameLoop sınıfına aşağıdaki değişkenleri ekleyelim;

GameObject Basket;
SpriteFont ScoreFont;
Vector2 ScorePosition;

GameObject sınıfınının constructor‘ına aşağıdaki satırları ekleyelim;

Basket = new GameObject(this, GameObjectList.Basket);

this.Components.Add(Basket);

this.Components.Add(new GameObject(this, GameObjectList.Background));

LoadContent method’una aşağıdaki kodları ekleyelim;

ScoreFont = Content.Load<SpriteFont>("SkorFont");
ScorePosition = new Vector2(30, 560);

Rastgele nesne oluşturup, ağaçtan aşağı düşürmeden önce, Son Nesne Oluşturma Zamanı, Nesne Oluşturma Zaman Aralığı gibi değerleri saklayabileceğimiz değişkenlere ihtiyacımız olacak, hemen GameLoop sınıfının içerisinde tanımlayalım;

TimeSpan PreviousFallTime;
TimeSpan FallBufferTime = TimeSpan.FromMilliseconds(1000);

Böylece, her saniye yeni bir nesne oluşturmak için ihtiyaç duyacağımız tüm değişkenleri tanımlamış olduk.

Update method’una aşağıdaki kodları yazalım;

if (gameTime.TotalGameTime - PreviousFallTime > FallBufferTime)
{
	this.Components.Add(new GameObject(this, GameObjectList.Random));

	PreviousFallTime = gameTime.TotalGameTime;
}

for (int iLoop = 0; iLoop < this.Components.Count; iLoop++)
{
	GameObject CurrentComponent = (GameObject)this.Components[iLoop];

	if (CurrentComponent.GameObjectType != GameObjectList.Background && CurrentComponent.GameObjectType != GameObjectList.Basket)
	{
		if (Basket.ObjectRectangle.Intersects(CurrentComponent.ObjectRectangle))
		{
			if (CurrentComponent.GameObjectType == GameObjectList.Rock)
			{
				Skor -= 1;
			}
			else if (CurrentComponent.GameObjectType == GameObjectList.Man)
			{
				Skor -= 2;
			}
			else if (CurrentComponent.GameObjectType == GameObjectList.Car)
			{
				Skor -= 3;
			}
			else
			{
				Skor += 1;
			}

			this.Components.Remove(CurrentComponent);
		}
	}
}

Geriye sadece Draw method'u kaldı;

spriteBatch.Begin();

spriteBatch.DrawString(ScoreFont, "Skor : " + Skor, ScorePosition + Vector2.One, Color.Black);
spriteBatch.DrawString(ScoreFont, "Skor : " + Skor, ScorePosition, Color.White);

spriteBatch.End();

Skor bilgisini, bir beyaz, bir siyah renkle, iki defa çizdiriyoruz. İkinci çizimi 1px farklı konuma çizdirdiğimiz için, yazı ekranda sanki gölgesi varmış gibi gözüküyor.

İşte Meyve Veren Ağaç oyunundan bir ekran görüntüsü. Oyunun kaynak kodlarını buradan indirebilirsiniz.

Meyve Veren Ağaç oyunun bitmiş hali