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

Arşiv

Etiketlenen yazılar drawstring

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 Oyunu / Vahşi Batı

25 June 2012 3 yorum

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

Her zamanki gibi önce görseller;

XNA Oyun - Vahşi Batı - Cursor XNA Oyun - Vahşi Batı - Tombstone XNA Oyun - Vahşi Batı - Horse XNA Oyun - Vahşi Batı - Background

Bir tane silah sesi dosyamız var;

Magnum Gunshot

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>Segoe UI Mono</FontName>
		<Size>18</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; VahsiBati projemizi oluşturduktan ve Game1.cs‘in ismini GameLoop.cs olarak değiştirdikten sonra, Target isminde bir sınıf oluşturalım;

public class Target
{
	public const int FrameWidth = 104;

	public Vector2 Position;

	private Rectangle _Area = new Rectangle(0, 0, FrameWidth, FrameWidth);
	public Rectangle Area
	{
		get
		{
			_Area.X = (int)Position.X;
			_Area.Y = (int)Position.Y;

			return _Area;
		}
	}

	public bool ToLeft;

	public float RunSpeed;

	public int FrameIndex;

	public SpriteEffects SpriteEffect;

	public TimeSpan LastFrameChange = TimeSpan.Zero;

	public TimeSpan FrameChangeBuffer = TimeSpan.Zero;

	public bool IsDead = false;
}

Target sınıfı sayesinde, ekrana getireceğimiz hedef‘lerin ekranın neresinden çıkıp, hangi yöne doğru gideceğini bileceğiz, hedefin vurulup/vurulmadığını bileceğiz, çarpışma testi yapabilmek için ekranda kapladığı alanı bileceğiz, hızını bileceğiz, ayrıca hedef‘imizin harekete sahip olmasını sağlayabileceğiz (bknz; XNA ile Karakter Hareketi)

GameLoop.cs dosyasına geri dönelim, ilk önce arkaplanımızın hareketli olması için (bknz; XNA ile Hareketli Arkaplan) sınıf seviyesinde şu değişkenleri tanımlayalım;

Rectangle Screen;

Texture2D Background1;
Texture2D Background2;

Rectangle Background1Position;
Rectangle Background2Position;

GameLoop constructor‘ında Screen değişkenine;

Screen = new Rectangle(0, 0, graphics.PreferredBackBufferWidth, graphics.PreferredBackBufferHeight);

LoadContent method’unda Background değişkenlerine değer atayalım;

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

Background1Position = new Rectangle(0, 0, Background1.Width, Background1.Height);
Background2Position = new Rectangle(Background1.Width, 0, Background2.Width, Background2.Height);

Update method’unda Background‘un yerini güncelleyelim;

Background1Position.X -= 1;
Background2Position.X -= 1;

if (Background1Position.X < -Background1.Width)
{
	Background1Position.X = Background2Position.X + Background2.Width;
}

if (Background2Position.X < -Background2.Width)
{
	Background2Position.X = Background1Position.X + Background1.Width;
}

Son olarak Draw method'unda Background'u ekrana çizelim;

spriteBatch.Begin();

spriteBatch.Draw(Background1, Background1Position, Color.White);
spriteBatch.Draw(Background2, Background2Position, Color.White);

spriteBatch.End();

Ekrana işaretçi çizdirmek için, sınıf seviyesinde aşağıdaki değişkenleri ekleyelim;

Texture2D Cursor;

Vector2 CursorPosition = Vector2.Zero;
Vector2 CursorCenter = Vector2.Zero;

Rectangle CursorZone;

MouseState ms;
MouseState pms;

GameLoop constructor‘ında CursorZone değişkenini dolduralım;

CursorZone = new Rectangle(0, 0, 5, 5);

LoadContent method‘unda Cursor değişkenlerine değer atayalım;

Cursor = Content.Load<Texture2D>("Cursor");
CursorCenter = new Vector2(Cursor.Width / 2, Cursor.Height / 2);

Update method‘unda işaretçinin ekranda görüntüleneceği yeri hesaplayalım;

ms = Mouse.GetState();

CursorPosition = new Vector2(ms.X, ms.Y);

pms = ms;

Draw method’unda Cursor nesnemizi ekrana çizdirelim;

spriteBatch.Draw(Cursor, CursorPosition, null, Color.White, 0f, CursorCenter, 0.6f, SpriteEffects.None, 0f);

Sınıf seviyesinde aşağıdaki değişkenleri tanımlayalım;

Texture2D Horse;

Texture2D Tombstone;

SpriteFont SkorFont;
Vector2 SkorPosition;

SoundEffect Gunshot;

Random r;

int Score = 0;

Böylece hedef‘in görselini, vurulduğunda dönüşeceği mezarlık görselini, ateş etme sırasında duyulacak silah sesini, kaç hedef vurduğumuzu tutabileceğimiz değişkenlerimiz tanımlamış olduk.

Constructor‘da r değişkenine değer ataması yapalım;

r = new Random();

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

Horse = Content.Load<Texture2D>("Horse");
Tombstone = Content.Load<Texture2D>("Tombstone");

SkorFont = Content.Load<SpriteFont>("SkorFont");
SkorPosition = new Vector2(20, 10);

Gunshot = Content.Load<SoundEffect>("Magnum");

Henüz ekranda hedefleri göremesek‘te oyunumuzun önemli kısımlarının hazırlıklarını tamamladık. Artık hedef listesini tanımlayabilir, Update ve Draw method’larında kullanabiliriz. Sınıf seviyesinde aşağıdaki değişkenleri tanımlayalım;

TimeSpan LastHorseSpawn = TimeSpan.Zero;
TimeSpan SpawnHorseBuffer = TimeSpan.FromSeconds(3);

List<Target> TargetList = new List<Target>();

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

if (gameTime.TotalGameTime - LastHorseSpawn > SpawnHorseBuffer)
{
	Target t = new Target();
	t.FrameIndex = 0;
	t.ToLeft = r.Next(0, 2) == 0;
	t.RunSpeed = Convert.ToSingle(r.Next(20, 70)) / 10;
	t.FrameChangeBuffer = TimeSpan.FromMilliseconds(100 + -t.RunSpeed);

	if (t.ToLeft)
	{
		t.Position = new Vector2(graphics.PreferredBackBufferWidth - t.Area.Width, r.Next(200, 400));
		t.SpriteEffect = SpriteEffects.FlipHorizontally;
	}
	else
	{
		t.Position = new Vector2(0, r.Next(200, 400));
		t.SpriteEffect = SpriteEffects.None;
	}

	TargetList.Add(t);

	LastHorseSpawn = gameTime.TotalGameTime;
}

Hedef’in ekranın solundan sağına/sağından soluna gideceğine rastgele karar veriyoruz (ToLeft alanı sayesinde)

Hedef’in ekranda koşma hızına rastgele karar veriyoruz (RunSpeed alanı sayesinde)

Update method’unda hedef listesindeki hedeflerin hala ekranda göründüğünü kontrol ediyoruz, eğer ekrandan çıkmışlarsa hedef listesinden de çıkartıyoruz. Ekranda kalan hedefleri, koşma hızları kadar koşturuyoruz;

foreach (var t in TargetList)
{
	if (!Screen.Intersects(t.Area))
	{
		TargetList.Remove(t);
		break;
	}

	if (gameTime.TotalGameTime - t.LastFrameChange > t.FrameChangeBuffer)
	{
		t.FrameIndex += 1;
		t.LastFrameChange = gameTime.TotalGameTime;
	}

	if (t.FrameIndex > 3)
	{
		t.FrameIndex = 0;
	}

	if (t.ToLeft)
	{
		t.Position.X -= t.RunSpeed;
	}
	else
	{
		t.Position.X += t.RunSpeed;
	}
}

Update method’unda ayrıca, mouse‘un sol tuşuna basıldığında ateş edilmesini sağlamamız gerekiyor. Öncelikle sol tuşa ilk basıldığı anı buluyoruz, silah sesi çıkartıyoruz, hedef listesindeki hedefleri kontrol ediyoruz. Eğer vurulan hedef varsa, mezarlık görseline döndürüyoruz, Skor‘umuzu 1 arttırıyoruz;

if (ms.LeftButton == ButtonState.Pressed && pms.LeftButton == ButtonState.Released)
{
	Gunshot.Play();

	CursorZone.X = ms.X - 2;
	CursorZone.Y = ms.Y - 2;

	foreach (var t in TargetList)
	{
		if (!t.IsDead && t.Area.Intersects(CursorZone))
		{
			Score++;
			t.Position += new Vector2(20, 20);
			t.IsDead = true;
			t.ToLeft = true;
			t.RunSpeed = 1;
			break;
		}
	}
}

Son olarak Draw method’unda, hala hedef listesinde olan hedefleri ve skorumuzu ekrana çizdirmemiz gerekiyor;

foreach (var t in TargetList)
{
	if (t.IsDead)
	{
		spriteBatch.Draw(Tombstone, t.Position, Color.White);
	}
	else
	{
		spriteBatch.Draw(Horse, t.Position, new Rectangle(t.FrameIndex * Target.FrameWidth, 0, Target.FrameWidth, Target.FrameWidth), Color.White, 0f, Vector2.Zero, Vector2.One, t.SpriteEffect, 0);
	}
}

spriteBatch.DrawString(SkorFont, "Skor : " + Score, SkorPosition + Vector2.One, Color.Black);
spriteBatch.DrawString(SkorFont, "Skor : " + Score, SkorPosition, Color.White);

İşte Vahşi Batı oyunundan bir ekran görüntüsü. Oyunun kaynak kodlarını buradan indirebilirsiniz.

XNA Oyun : Vahşi Batı

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

XNA oyunlarında saniyedeki kare sayısını (FPS) hesaplamak

15 July 2011 1 yorum

Hemen her oyun’da, saniyede çizilen ekran sayısı (FPSFrame Per Second) bilgisi oyun penceresinde gösterilir.

FPS nedir?

FPS, oyunun bir saniye içerisinde oyun penceresine çizebildiği ekran sayısıdır. Bizim animasyon olarak gördüğümüz akışlar aslında ardı ardına hızlı bir şekilde çizilen tek kare resimlerdir.

Sinema filmleri bile aslında ekranda sırayla gösterilen tek kare resimlerden oluşmaktadır.

İnsan gözü, saniye 25 kare’den büyük hızlarda tek kare resimleri, bir akış olarak algılar.

XNA Framework, saniyede 60 kare ekran çizmeye çalışır.

Oyunlarımızda FPS nasıl hesaplarız?

Formül aslında basit, Draw() method’unda bir değişkenin değerini 1 arttıracağız. Update() method’unda her saniye geçişinde değişkeni sıfırlayacağız.

FPS bilgisini ekranda nasıl gösteririz?

Draw() method’unda değişkenin değerini ekranda gösterirsek, bir saniye içerisinde kaç defa Update() method’unun çalıştırıldığını, yani saniyedeki ekran sayısını (FPS) göstermiş oluruz.

Şimdi yazacağımız örnek projede, klavyeden boşluk (space) tuşuna basıldığında FPS bilgisini ekranda göstereceğiz, tekrar basıldığında gizleyeceğiz.

Örnek proje

Öncelikle sınıf seviyesinde değişkenlerimizi oluşturalım;

int SaniyedeKareSayisi = 0;
double FPS = 0;
bool DetayGoster = false;
KeyboardState pks;

Update() method’unda FPS hesaplayalım;

KeyboardState ks = Keyboard.GetState();

if (pks.IsKeyDown(Keys.Space) && ks.IsKeyUp(Keys.Space))
{
	DetayGoster = !DetayGoster;
}

if (DetayGoster && gameTime.TotalGameTime.Milliseconds == 0)
{
	FPS = SaniyedeKareSayisi;
	SaniyedeKareSayisi = 0;
}

pks = ks;

Oyun penceresinde yazı gösterebilmek için, SpriteFont sınıfından bir değişkene ihtiyacımız olacak.

SpriteFont Arial;

Content projemize Arial isminde bir SpriteFont dosyası ekleyelim.

XNA Oyun Programlama - FPS Hesaplama / SpriteFont Ekleme Dialog Kutusu

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

LoadContent() method’unda Arial değişkenimize değer atayalım;

Arial = Content.Load("Arial");

Draw() method’unda hesaplanan FPS bilgisini ekranda gösterelim;

spriteBatch.Begin();

if (DetayGoster)
{
	SaniyedeKareSayisi++;

	spriteBatch.DrawString(Arial, "FPS : " + FPS.ToString(), new Vector2(50, 50), Color.Black);
}

spriteBatch.End();

Artık oyun penceremizde saniyedeki ekran sayısını (FPS) gösterebiliriz.

XNA Oyun Programlama - FPS Hesaplama Sonucu

Oyunun kodlarını indirmek için tıklayınız.

XNA ile Pong oyunu yazalım – 2

11 March 2010 Yorum yapılmamış

XNA ile Pong oyunu yazalım – 1 yazıma bu yazı ile devam ediyorum.

XNA ile ekrana yazı yazdırmak için öncelikle Content projesi içerisinde bir spritefont dosyası oluşturmalıyız.

Pong projesi için ben Arial.spritefont ismini verdiğim dosyayı oluşturdum, “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>

Gördüğünüz gibi, font dosyası aslında font’un özelliklerini yazdığımız bir Xml dosyası.

GameLoop sınıfının değişkenlerine Arial font dosyamızı yükleyeceğimiz değişkeni de ekleyelim;

SpriteFont Arial;

LoadContent() method’unda Arial.spritefont dosyasını Arial değişkenine yükleyelim;

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

Şimdi Draw() method‘una aşağıdaki kodları ekleyerek, oyuncuların skorlarını ekrana yazdıralım;

spriteBatch.DrawString(Arial, "Oyuncu 1 : " + Oyuncu1Skor, new Vector2((float)(PENCERE_GENISLIK * 0.05), 30), Color.Yellow);
spriteBatch.DrawString(Arial, "Oyuncu 2 : " + Oyuncu2Skor, new Vector2((float)(PENCERE_GENISLIK * 0.80), 30), Color.Yellow);

Bu kod parçası ile, spriteBatch değişkeninde yeralan DrawString() method’unu kullandık. DrawString() method’unun parametrelerine bakacak olursak;

  • Birinci parametre olarak, spritefont tipinde bir değişken alır
  • İkinci parametre, ekrana yazdırmak istediğimiz yazıdır
  • Üçüncü parametre olarak Vector2 tipinde yazıyı nereye yazacağımız bilgisini ister
  • Son olarak, yazının rengini verdiğimiz dördüncü parametre vardır

Biz, Pong oyununda ilk oyuncunun skorunu ekranın %5 kadar içine, ikinci oyuncunun skorunu ise ekranın %20 kadar içine yazdırdık.

Gelelim, oyunda ses çıkartmaya;

Öncelikle wav formatında iki ses dosyasını Content içerisine sürükleyip bırakalım.

Class seviyesindeki değişkenlere iki tane daha ekleyelim;

SoundEffectInstance ArkaplanSes;
SoundEffectInstance SkorSes;

LoadContent() method’unda bu değişkenlerin değerlerini atayalım;

ArkaplanSes = Content.Load<SoundEffect>("Pong").CreateInstance();
SkorSes = Content.Load<SoundEffect>("recycle").CreateInstance();

Gördüğünüz gibi, SoundEffectInstance tipinde iki değişken tanımladık. Bu değişkenlere Content içindeki ses dosyalarını yüklerken, SoundEffect tipinin CreateInstance() method‘unu kullandık.

Böylece ses değişkenlerimiz kullanıma hazır hale geldi.

LoadContent() method’una aşağıdaki kodları da ekleyerek, arkaplanda çalacak ses değişkeninin sesini %20 oranına düşürelim ve loop olmasını sağlayalım (Böylece ses dosyasının sonuna geldiğinde başa dönüp çalmaya devam edecek).

Son olarak Play() methodu ile, ses dosyasını çalmaya başlayalım;

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

Update() method’unda oyuncuların skor kazandığı kodlara aşağıdaki satırı da ekleyelim;

SkorSes.Play();

Böylece oyuncular skor yaptıkça, SkorSes değişkeninde yüklü olan ses dosyası çalınacak.

İşte Pong oyunundan ekran görüntüsü. Oyunun kaynak kodlarını buradan indirebilirsiniz.

XNA Pong oyunun bitmiş hali