Sziasztok.
Ide is eljutottam, bele kezdtem a játék írásba.
Én nem azt az ózsdi Game Maker-t használom, abban nincs semmi élmény, ráadásul nagyon limitált.
A legegyszerûbb módszer a játékok programozására az XNA.
Ugyanis, C++-ban sokkal nehezebb játékot írni, vagy esetleg Java-ban, ezért feltalálták ezt a referenciát is, ez C# nyelvben van.
Vágjunk is bele.
Elõször is, töltsük le a Visual C# 2010 Express-t. Ez ingyenes, legális, Microsoft oldalán megtalálható.
Amikre még szükségünk van:
- .NET Framework 4.0, vagy újabb.
katt- XNA Framework 4.0, vagy újabb.
katt- XNA Game Studio 4.0.
kattHa ez megvan, nyissuk meg a Visual C#-ot, kezdjünk egy új project-et, és válasszuk ki a Windows Game 4.0-ás sablont.
Ezt fogjuk látni:
![\"tut1.jpg\"](\"http://noob.hu/2011/07/14/tut1.jpg\")
Full kód:
using System; //Ezeket ne nagyon bántsuk, ezzel ágyazzuk be a különbözõ referenciákat (ti úgy ismeritek, mint függvénykönyvtárak)
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
//Ez a névtér. Ezen belül fut le minden
namespace WindowsGame3
{
/// <summary>
/// Ez az osztályunk. Ezen kívül nem kell jelenleg létrehoznunk/lefuttatnunk semmit.
/// </summary>
public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics; //A grafikus hardver azonosítója
SpriteBatch spriteBatch; //Kirajzoláshoz használjuk
//Konstruktor, ez fut le elõször, mikor a játékunk elindul
public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = \"Content\";
}
/// <summary>
/// Ezzel töltjük be a játékot, eleinte nem kell vele kezdenünk semmit (a betöltés ELÕTT fut le).
/// Itt be lehet tölteni az összes nem-grafikus elemet.
/// A base.Initialize meghívásával enumerálhatunk a különbözõ elemek között
/// És persze inicializálni õket
/// </summary>
protected override void Initialize()
{
base.Initialize();
}
/// <summary>
/// A LoadContent-el töltjük be az olyan elemeket, amiket a játék megjelenít/megmutat.
/// Ez lehet kép, hang, betûtípus, stb.
/// </summary>
protected override void LoadContent()
{
// Egy új SpriteBatch -ot hozunk létre, amit a textúrák kirajzolásához fogunk használni
spriteBatch = new SpriteBatch(GraphicsDevice);
// A this.Content, és azon belüli funkciókat fogjul használni a betöltésre
}
/// <summary>
/// UnloadContent -nél pedig \"eldobjuk\" az elemeket
/// all content.
/// </summary>
protected override void UnloadContent()
{
}
/// <summary>
/// Ezzel a függvénnyel \"Logikusan\" fut a játékunk, ezzel megoldhatunk olyanokat,
/// mint az ütközések, bemenetek lekérésre (billentyû, egér, stb), lejátszani hangokat, stb
/// </summary>
/// <param name=\"gameTime\">Az idõzítéseket rögzíti.</param>
protected override void Update(GameTime gameTime)
{
// Játékból kilépési kód
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();
// Itt fogjuk majd a különbözõ bemeneti mûveleteket folytatni
base.Update(gameTime);
}
/// <summary>
/// Ez akkor hívódik meg, ha a játék újra rajzolja magát.
/// </summary>
/// <param name=\"gameTime\">Az idõzítéseket rögzíti.</param>
protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);
// Itt fogunk kirajzolni mindent.
// Gyakorlatilag mikor ez a függvény meghívódik, akkor a képen minden újra rajzolódik,
// Tehát, mindig új képkockát (frame-t) látunk.
// A processzorodtól függ, hogy milyen gyorsan bírja ezt meghívni,
// És, amennyiszer ez a függvény lefut másodpercenként, annyi FPS-ed (képkocka/sec) van.
base.Draw(gameTime);
}
}
}
Az elsõ dolog, amit tennünk kell, hogy rajzolunk egy alap sprite-ot (2D-s textúrát)
Paintben is meg lehet. Most egy golyóval (elnézést, körrel) fogunk dolgozni.
Rajzolunk egy kört, és a hátterét kiszínezzük rózsaszínre, így a hátteret az XNA nem fogja megjeleníteni.
És beimportáljuk:
![\"tut2.jpg\"](\"http://noob.hu/2011/07/14/tut2.jpg\")
(Keresd ki a lementett képet)
FONTOS: A content részbe importáld be (solution explorerben alul \"ProjectnevedContent\")
Létrehozunk az osztályunkban egy változót a körnek.
(tehát a public class Game1 rész alatt)
Texture2D ball; //Szerintem érthetõ
Hozzunk létre még egy változót, ami a pozícióját tárolja a körnek (ez a mozgatáshoz lesz majd szükséges).
Vector2 position = new Vector2(0, 0); //A Vector2 azt jelenti, hogy két eleme van a változónknak, a (0,0) pedig azt, hogy a két elem értéke 0
Utolsó létrehozásnak pedig, a billentyûzet állapotát tároljuk el.
KeyboardState keyboardState;
Létrehozásnak ennyi elég.
Most betöltjük magát a textúrát, a LoadContent() függvény segítségével.
ball = Content.Load<Texture2D>(\"ball\"); //a ball a létrehozott változónk, a Content.Load a betöltõ funkció, a <Texture2D> -vel jelezzük,
//hogy ez 2D-s, és a \"ball\" pedig a fájlt jelenti, kiterjesztését NE írjuk oda
Most rajzoljuk ki a kört.
Keressük ki a Draw függvényt.
protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue); //Mindig törölni kell a vga-ból az adatokat
spriteBatch.Begin(); //Elkezdjük a rajzolást, ez alá kerül minden kirajzoló függvény
spriteBatch.Draw(ball, position, Color.White); //A golyót kirajzoljuk, és pozíciónak a változónkat használjuk
spriteBatch.End(); //Befejezzük a batch-olást
base.Draw(gameTime); //Kirajzolás
}
Most az irányítást programozzuk be.
A módszer egyszerû.
A position változót mindig változtatjuk a gombok hatására, így a Draw függvénynél, mindig oda rajzolja ki, ahova mondja neki a position változó.
Ezt az Update() függvénynél tesszük meg.
Elõször lekérjük a billentyûzet \"állapotát\", vagyis, hogy mely gombok vannak lenyomva.
keyboardState = Keyboard.GetState(); //az elején létrehozott keyboardState változóban tároljuk
Majd lekérdezzük, hogy melyik gomb van lenyomva, és az alapján változtatjuk a position változónk értékét.
if (keyboardState.IsKeyDown(Keys.Up)) //ha a felfele nyilat nyomja
position.Y -= 5; //Felfele mozgatjuk
Szerencsére az XNA-ban vannak definíciók az összes gombra, még a nyilakra is.
Fontos tudni, hogy a képernyõn, a 0-ás koordináta a két tengelyen a BAL FELSÕ sarok. Ezért minusz, ha felfele akarjuk mozgatni.
Majd oldalra:
if (keyboardState.IsKeyDown(Keys.Left)) //Bal nyíl
position.X -= 5; //balra mozgatjuk
Innentõl már egyszerû az egész. Mindegyik gombra külön megcsináljuk a kódot:
keyboardState = Keyboard.GetState();
if (keyboardState.IsKeyDown(Keys.Up))
position.Y -= 5;
if (keyboardState.IsKeyDown(Keys.Down))
position.Y += 5;
if (keyboardState.IsKeyDown(Keys.Left))
position.X -= 5;
if (keyboardState.IsKeyDown(Keys.Right))
position.X += 5;
Csak megjegyzésként, ez nem olyan, mint a PAWN, hogy 2-5 ms-ért harcolni kell mint az állat... fõleg azért nem, mert itt nincs hatásra ránk a net.
Ez mind szép és jó, csak ilyenkor ki tudunk menni a képernyõbõl a körrel. Erre van egy ugyanúgy egyszerû megoldás.
Meg kell néznünk, hogy a position változónk nagyobb-e mint a játék ablakának a szélessége/magassága.
Ellenkezõ esetben, kisebb-e mint nulla.
if (position.Y < 0) //Ha az Y pozíciója (magasság) kisebb, mint 0
position.Y = 0; //0-án marad a pozíció, tehát nem mozog
Ha pedig esetleg, a maximum pozíciót érjük el, és nem a minimumot:
if (position.Y > graphics.PreferredBackBufferHeight - ball.Height) //Ha az Y pozíciója nagyobb, mint a felbontásunk magassága - a golyó magassága
position.Y = graphics.PreferredBackBufferHeight - ball.Height; //Beállíjuk arra, amennyire hivatkoztunk
X pozíciónál ugyanez, csak ott a Width szót kell alkalmazni (szélesség).
if (position.X > graphics.PreferredBackBufferWidth - ball.Width)
position.X = graphics.PreferredBackBufferWidth - ball.Width;
A kód teljesen így néz ki:
if (position.Y < 0)
position.Y = 0;
if (position.Y > graphics.PreferredBackBufferHeight - ball.Height)
position.Y = graphics.PreferredBackBufferHeight - ball.Height;
if (position.X < 0)
position.X = 0;
if (position.X > graphics.PreferredBackBufferWidth - ball.Width)
position.X = graphics.PreferredBackBufferWidth - ball.Width;
És ennyi lenne mára. Létrehoztunk egy alap irányítást/grafikát. Több leckét is fogok csinálni, amint többet fogok tanulni ebbõl a nyelvbõl/referenciából.
Remélem hasznos.
