So Nun zum nächsten Teil: Die angriffe und die leben.
Unswar wird man über das drücken der Leer-Taste Bomben werfen.
Was euch also schon Klar sein sollte ist, dass wir in der update Methode eine weitere abfrage brauchen:
protected override void Update(GameTime gameTime)
{
// Ermöglicht ein Beenden des Spiels
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();
//Variable die den tastenstatus enthält
KeyboardState ks = Keyboard.GetState();
//variablen für die richtung der beschläunigung
int mX = 0;
int mY = 0;
//tasten abfrage
if (ks.IsKeyDown(Keys.Up))
mY += 1;
if (ks.IsKeyDown(Keys.Down))
mY -= 1;
if (ks.IsKeyDown(Keys.Right))
mX += 1;
if (ks.IsKeyDown(Keys.Left))
mX -= 1;
[COLOR="red"] //Bomben werfen
if (ks.IsKeyDown(Keys.Space)) {
}[/COLOR]
float newX = mX * (float)gameTime.ElapsedGameTime.TotalSeconds * 80; //beschleunigungsfaktor für x errechnen
float newY = -mY * (float)gameTime.ElapsedGameTime.TotalSeconds * 80; //beschleunigungsfaktor für y errechnen[...]
Nun entsteht hierbei ein kleines Problem, aber darum kümmere ich mich später...
Erst einmal muss nun eine neue bombe erstellt werden, die dann hinzugefügt wird:
Bomb b = new Bomb();
Nun muss die Startposition der bombe erstellt werden:
b.pos = new Vector2([COLOR="orange"]player.tex.Width / 2[/COLOR] + player.pos.X, [COLOR="#ff00ff"]player.tex.Height[/COLOR] + player.pos.Y);
Der orange teil sorgt dafür das die bombe in der Mitte der Spieler Textur entsteht, der Lilane damit sie unterhalb des Spielers entsteht.
Als geschwindigkeit wird eine geste geschwindigkeit nach unten verwendet,
b.speed = new Vector2([COLOR="orange"]player.speed.X / 3f[/COLOR] , [COLOR="#ff00ff"]135[/COLOR]);
Den Orangen teil verwende ich diesmal um eine kleine bewegung in die richtung des spielers hinzubekommen, da die Bombe ja immernoch einen teil der geschwindigkeit hat.
Lila ist die startgeschwindigkeit; 135 px/s nach unten.
Der schaden soll ein wenig (pseudo-)Zufällig errechnet werden, dafür verwende ich die random Klasse
//Neuen Pseudo-Zahl Generator
Random rnd = new Random(DateTime.Now.Millisecond);
//Damage bestimmen
b.damage = rnd.Next(5, 13);
//Generator löschen für den garbage Collector
rnd = null;
Damit wird ein "Zufälliger wert zwischen 5 und zwölf ermittelt.
Es bleiben noch BoomInstance(sound) und Tex(Textur)
für beide könnte man ganz einfach den Content aufrufen, aber sowas in der Update Methode kostet wertvolle zeit. Deshalb erstellen wir vorher schon diese beiden objekte und schreiben dann nur einen verweis in die Bombe.
Für das erstellen brauchen wir erst mal 2 weitere Variablen im GameEnvironment aus der Objekte.cs:
public struct GameEnvironment {
/// <summary>
/// Hintergrund Musik
/// </summary>
public SoundEffect bgMusic { get; set; }
/// <summary>
/// Hintergrund Musik Instance
/// </summary>
public SoundEffectInstance bgMusicInstance { get; set; }
/// <summary>
/// Ob das Menü offen ist
/// </summary>
public bool isMenu { get; set; }
/// <summary>
/// Ob das Spiel Gewonnen ist
/// </summary>
public bool won { get; set; }
/// <summary>
/// Ob das Spiel Verloren ist
/// </summary>
public bool lost { get; set; }
/// <summary>
/// Die Hintergrund Farbe
/// </summary>
public Color bgColor { get; set; }
/// <summary>
/// Das bild des mauszeigers
/// </summary>
public Texture2D cursorTex { get; set; }
/// <summary>
/// die position des Mauscursors
/// </summary>
public Vector2 mousePos { get; set; }
/// <summary>
/// Die Breite
/// </summary>
public int windowWidth { get; set; }
/// <summary>
/// Die Höhe
/// </summary>
public int windowHeight { get; set; }
[COLOR="red"] /// <summary>
/// Die Textur der Spieler bomben
/// </summary>
public Texture2D pBombTex { get; set; }
/// <summary>
/// Die Textur der Gegner bomben
/// </summary>
public Texture2D eBombTex { get; set; }
/// <summary>
/// Der Sound der Spieler bomben
/// </summary>
public SoundEffect pBombSound { get; set; }
/// <summary>
/// Der Sound der Gegner bomben
/// </summary>
public SoundEffect eBombSound { get; set; }[/COLOR]
}
dann müssen die in LoadContent auch noch geladen werden:
protected override void LoadContent()
{
// Erstellen Sie einen neuen SpriteBatch, der zum Zeichnen von Texturen verwendet werden kann.
spriteBatch = new SpriteBatch(GraphicsDevice);
player.tex = Content.Load<Texture2D>("PlayerIMG"); //Textur für den Spieler
enemy.tex = Content.Load<Texture2D>("EnemyIMG"); //Textur für den Spieler
environment.bgMusic = Content.Load<SoundEffect>("BGM"); //Hintergrund Musik Laden
environment.bgMusicInstance = environment.bgMusic.CreateInstance(); // Hintergrund Musik Instanz zum abspielen Erstellen
environment.bgMusicInstance.IsLooped = true;//Damit die musik wieder von forn anfängt
environment.bgMusicInstance.Play();//Abspielen starten
environment.cursorTex = Content.Load<Texture2D>("Cursor"); //Mauszeiger bild Laden
[COLOR="red"] environment.eBombSound = Content.Load<SoundEffect>("Laser"); //Gegner Laser Sound Laden
environment.pBombSound = Content.Load<SoundEffect>("Boom"); //Spieler Bomben Sound Laden
environment.pBombTex = Content.Load<Texture2D>("bomb"); //Spieler Bomben Textur Laden
environment.eBombTex = Content.Load<Texture2D>("Shot"); //Gegner Bomben Textur Laden[/COLOR]
}Und nun gibt es nur noch einen neuen zeiger auf die bombe hinzuzufügen
//Bomben werfen
if (ks.IsKeyDown(Keys.Space)) {
//Erstellen
Bomb b = new Bomb();
//Startposition errechnen
b.pos = new Vector2(player.tex.Width / 2 + player.pos.X, player.tex.Height + player.pos.Y);
//Startgeschwindigkeit errechnen
b.speed = new Vector2(player.speed.X / 3f, 135);
//Neuen Pseudo-Zahl Generator
Random rnd = new Random(DateTime.Now.Millisecond);
//Damage bestimmen
b.damage = rnd.Next(5, 13);
//Generator löschen für den garbage Collector
rnd = null;
[COLOR="red"] //auf Textur verweisen
b.tex = environment.pBombTex;
//sound Instanz erstellen
b.boomInstance = environment.pBombSound.CreateInstance();[/COLOR]
Und dann noch mit
[CODE] player.Bombs.Add(b);[/CODE]
hinzufügen.
Nun geht es an das zeichnen, in der Draw Methode
[CODE] protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);
spriteBatch.Begin();//Zeichnen starten
spriteBatch.Draw(player.tex, player.pos, Color.White);//Spieler zeichnen
spriteBatch.Draw(enemy.tex, enemy.pos, Color.White);//gegner zeichnen
[COLOR="red"] foreach (Bomb b in player.Bombs) // Jede bombe des spielers durchgehen
spriteBatch.Draw(b.tex, b.pos, Color.White); //und zeichnen
foreach (Bomb b in enemy.Bombs)// Jede bombe des gegners durchgehen
spriteBatch.Draw(b.tex, b.pos, Color.White); //und zeichnen[/COLOR]
spriteBatch.End();//Zeichnen ende
base.Draw(gameTime);
}[/CODE]
}Jetzt geht es nur noch an die Bewegung der bomben:
Dafür wird nun in der Update Methode eigentlich das Selbe gemacht wie für den gegner nur halt nach unten/oben:
for (int i = 0; i <= player.Bombs.Count - 1; i++ )/*Jeden Bombenindex durchgehen*/ {
Bomb b = player.Bombs[i]; //Bombe am index aufrufen
b.pos += b.speed* (float)gameTime.ElapsedGameTime.TotalSeconds; //neue position ermitteln
player.Bombs.Add(b); //Neuen eintrag setzen
player.Bombs.RemoveAt(i); //Alten eintrag löschen
}Bomben kolision:
Das folgende verfahren ist total naiv und unprofessionell, und nur bei wenigen kollisionen zu enpfehlen, da ich jede bombe mit jedem objekt abgleiche
die rechenleistung ist also
Anzahl_DER_OBJEKTE^ANZAHL_DER_BOMBEN * LEISTUNG_PRO_ABFRAGE
und dies kann einen enormen verschleiß an zeit haben, wenn man viele objekte hat.
dennoch für das recht es.
Für die kollisionserkennung verwenden wir die schleife zur bewegung, und hängen die abfrage einfach rein, sodass sollte eine kollision vorliegen das objekt einfach nicht mehr hinzugefügt wird:
//Bomben bewegen
for (int i = 0; i <= player.Bombs.Count - 1; i++ )/*Jeden Bombenindex durchgehen*/ {
Bomb b = player.Bombs[i]; //Bombe am index aufrufen
b.pos += b.speed* (float)gameTime.ElapsedGameTime.TotalSeconds; //neue position ermitteln
//wenn die bombe nicht im gegner ist
[COLOR="red"] if (!(b.pos.Y + b.tex.Height >= enemy.pos.Y & b.pos.X >= enemy.pos.X - b.tex.Width & b.pos.X <= enemy.pos.X + enemy.tex.Width))[/COLOR] {
//wenn die bomben auf dem boden aufkommen
[COLOR="orange"]if (b.pos.Y >= environment.windowHeight - b.tex.Height)[/COLOR] {
b.boomInstance.Play();
} else { //sonst
player.Bombs.Add(b); //Neuen eintrag setzen
}
} else { //sonst
b.boomInstance.Play(); //explosions Sound Spielen
enemy.lives -= b.damage;//schaden abziehen
}
player.Bombs.RemoveAt(i); //Alten eintrag löschen
}
Das rote fragt ab ob der gegner berührt ist, wenn nicht wird mit dem orangenen abgefragt ob der boden berührt ist, wenn der gegner berührt ist wird der Sound gespielt und der gegner verliert leben, beim boden wird nur der sound gespielt, und nur wenn nichts davon Stimmt bleibt die bombe in der liste.
Nun zu dem kleinen poblem:
Sobald man auf leer klickt wirft man X bomben.
Dies beheben wir mit einer wartezeit: also wenn die noch nicht um ist wird keine bombe geworfen.
Dafür fügen wir 2 neue variablen zur player und zur enemy struktur hinzu:
/// <summary>
/// Der Zeitpunkt des letzten schusses
/// </summary>
public float lastShot { get; set; }
/// <summary>
/// Die Wartezeit bis zum nächsten
/// </summary>
public float waitTime { get; set; }
nun müssen wir die natürlich auch mitladen, dafür gehen wir in die Initialize Methode aus der game.CS
protected override void Initialize()
{
// TODO: Fügen Sie Ihre Initialisierungslogik hier hinzu
player = new Player();
enemy = new Enemy();
environment = new GameEnvironment();
//Globale Einstellungen
environment.bgColor = Color.CornflowerBlue; //Die Hintergrundfarbe für das Spiel(Standart hintergrundfarbe von)
environment.isMenu = false; //Ob das Menu offen ist (Vor erst nicht, das Menu kommt später)
environment.lost = false; //Ob das Spiel verloren ist
environment.won = false; //Ob das Spiel gewonnen ist
environment.windowHeight = this.GraphicsDevice.Viewport.Height; //Die Fenster Höhe abspeichern
environment.windowWidth = this.GraphicsDevice.Viewport.Width; //Die Fenster Breite abspeichern
//Player Einstellungen
player.Bombs = new List<Bomb>(); //Bomben Array/Liste Initialisieren
player.lives = 3; //Leben festlegen
player.pos = new Vector2(0, 0); //Standartposition für den Spieler bei Spielbeginn
player.speed = new Vector2(0, 0); //keine bewegung am start
[COLOR="red"] player.lastShot = 0f;
player.waitTime = 0.5f;[/COLOR]
//Gegner Einstellungen
enemy.Bombs = new List<Bomb>(); //Bomben Array/Liste Initialisieren
enemy.lives = 100; //Leben festlegen (100%)
enemy.pos = new Vector2(0f, environment.windowHeight - 97f); //Die position (0pixel auf X, und die Fenster höhe - die höhe des bildes auf der Y)
enemy.speed = new Vector2(150f, 0f); //Geschwindigketi(mit 5 pixeln pro sek nach rechts)
[COLOR="red"] enemy.lastShot = 0f;
enemy.waitTime = 2f;[/COLOR]
base.Initialize();
}
Nun bauen wir das mit einer simplen abfrage noch ein:
//Abfragen on schon lang genug gewartet wurde
[COLOR="red"]if ((float)gameTime.TotalGameTime.TotalSeconds >= player.lastShot + player.waitTime) {[/COLOR]
//Bomben werfen
if (ks.IsKeyDown(Keys.Space)) {
[COLOR="red"] //Neue LastShot Zeit
player.lastShot = (float)gameTime.TotalGameTime.TotalSeconds;[/COLOR]
//Erstellen
Bomb b = new Bomb();
//Startposition errechnen
b.pos = new Vector2(player.tex.Width / 2 + player.pos.X, player.tex.Height + player.pos.Y);
//Startgeschwindigkeit errechnen
b.speed = new Vector2(player.speed.X / 3f, 135);
//Neuen Pseudo-Zahl Generator
Random rnd = new Random(DateTime.Now.Millisecond);
//Damage bestimmen
b.damage = rnd.Next(5, 13);
//Generator löschen für den garbage Collector
rnd = null;
//auf Textur verweisen
b.tex = environment.pBombTex;
//sound Instanz erstellen
b.boomInstance = environment.pBombSound.CreateInstance();
//Bombe hinzufügen
player.Bombs.Add(b);
}
}
mit (float)gameTime.TotalGameTime.TotalSeconds wird der float wert der aktuellen spiel zeit in sekunden rausgefunden, mit dem zeitpunkt des letzten schusses verglichen, und wenn die waitTime vorbei ist kann erneut geschossen werden.
Jetzt muss das ganze nur noch auf den gegner umgeschrieben werden, da der gegner ein pc ist wird anstatt mit der tastenabfrage mit einem zufall von 1 und 2 entschieden ob geschossen wird oder nicht:
//Abfragen on schon lang genug gewartet wurde
if ((float)gameTime.TotalGameTime.TotalSeconds >= enemy.lastShot + enemy.waitTime)
{
Random gen = new Random(DateTime.Now.Millisecond);
//Bomben werfen
if (gen.Next(1,3)==1)
{
//Neue LastShot Zeit
enemy.lastShot = (float)gameTime.TotalGameTime.TotalSeconds;
//Erstellen
Bomb b = new Bomb();
//Startposition errechnen
b.pos = new Vector2(enemy.tex.Width / 2 + enemy.pos.X, enemy.pos.Y);
//Startgeschwindigkeit errechnen
b.speed = new Vector2(0f, -135);
//Damage bestimmen
b.damage = 1;
//auf Textur verweisen
b.tex = environment.eBombTex;
//sound Instanz erstellen
b.boomInstance = environment.eBombSound.CreateInstance();
//Bombe hinzufügen
enemy.Bombs.Add(b);
}
}
//Bomben bewegen
for (int i = 0; i <= enemy.Bombs.Count - 1; i++)/*Jeden Bombenindex durchgehen*/
{
Bomb b = enemy.Bombs[i]; //Bombe am index aufrufen
b.pos += b.speed * (float)gameTime.ElapsedGameTime.TotalSeconds; //neue position ermitteln
//wenn die bombe nicht im gegner ist
if (!(b.pos.Y + b.tex.Height >= player.pos.Y [COLOR="red"]& b.pos.Y <= player.pos.Y+player.tex.Height[/COLOR] & b.pos.X >= player.pos.X - b.tex.Width & b.pos.X <= player.pos.X + player.tex.Width))
{
//wenn die bomben auf dem boden aufkommen
[COLOR="orange"] if (b.pos.Y <= 0)
{
b.boomInstance.Play();
}[/COLOR]
else
{ //sonst
enemy.Bombs.Add(b); //Neuen eintrag setzen
}
}
else
{ //sonst
b.boomInstance.Play();
player.lives -= b.damage;
}
enemy.Bombs.RemoveAt(i); //Alten eintrag löschen
}
Die änderungen sind: ich habe player und enemy vertauscht, den roten punkt zur kollisonsabfrage hinzugefügt(damit auch untendrunter abgefragt wird) und ich habe die richtung auf - gestellt, damit sie hoch fliegen, und mit den orangenen teil habe ich die rand kollision auf den oberen rand gestellt.
Die leben:
Zu erst laden wir die textur im load content(hab ich im anderen tutorial vergessen)
protected override void LoadContent()
{
// Erstellen Sie einen neuen SpriteBatch, der zum Zeichnen von Texturen verwendet werden kann.
spriteBatch = new SpriteBatch(GraphicsDevice);
player.tex = Content.Load<Texture2D>("PlayerIMG"); //Textur für den Spieler
[COLOR="red"] player.liveTex = Content.Load<Texture2D>("PL"); //Lebenstextur laden[/COLOR]
enemy.tex = Content.Load<Texture2D>("EnemyIMG"); //Textur für den Spieler
[COLOR="red"] enemy.liveTex = Content.Load<Texture2D>("EL"); //Lebenstextur laden[/COLOR]
environment.bgMusic = Content.Load<SoundEffect>("BGM"); //Hintergrund Musik Laden
environment.bgMusicInstance = environment.bgMusic.CreateInstance(); // Hintergrund Musik Instanz zum abspielen Erstellen
environment.bgMusicInstance.IsLooped = true;//Damit die musik wieder von forn anfängt
environment.bgMusicInstance.Play();//Abspielen starten
environment.cursorTex = Content.Load<Texture2D>("Cursor"); //Mauszeiger bild Laden
environment.eBombSound = Content.Load<SoundEffect>("Laser"); //Gegner Laser Sound Laden
environment.pBombSound = Content.Load<SoundEffect>("Boom"); //Spieler Bomben Sound Laden
environment.pBombTex = Content.Load<Texture2D>("bomb"); //Spieler Bomben Textur Laden
environment.eBombTex = Content.Load<Texture2D>("Shot"); //Gegner Bomben Textur Laden
}für gewöhnlich würden wir die Leben so zeichnen lassen
spriteBatch.Draw(enemy.liveTex, new Rectangle(0, 0, environment.windowWidth, 15), Color.White);
da haben wir aber immer nur skalierte leben, um was abzuschneiden benötigen wir das source rectange.
Dabei handelt es sich um den ausschnitt, der gezeigt werden soll, alles andere fällt weg
um nur den lebensteil des gegners anzuzeigen brauchen wir
spriteBatch.Draw(enemy.liveTex, new Rectangle(0, 0, (environment.windowWidth / 100) * enemy.lives, 15), new Rectangle(0, 0, (environment.windowWidth / 100) * enemy.lives, 15), Color.White); // ausschnitt zeichnen
hier bei ist vor allem wichtig dass das destination rectangle(das erste) nicht größer als das source rectangle(das 2te) ist. das source rectangle geht von dem punkt 0,0 auf eurer textur, nicht von dem in dem programm aus also entspricht 0,0 der position der textur, während sich das destination rectangle nach den programm koordinaten richtet
Die form der größen berechnung ist reine prozentrechnugn, und dass muss ich wohl von euch erwarten.
die spieler textur wird so gezeichnet:
spriteBatch.Draw(player.liveTex, new Vector2(environment.windowWidth-45, 15), new Rectangle(0, 0, 15*player.lives, 15), Color.White); // ausschnitt zeichnendabei habe ich einen vector 2 genommen, da höhen und breiten angaben in diesem fall sinnlos sind(die textur hat ne feste größe)
und dass new Rectangle(0, 0, 15*player.lives, 15) berechnet die anzahl der herzen(1 herz = 15 px)
So gut wenn ihr das gemacht habt ist das spiel eigentlich soweit fertig, Was jetzt noch kommt hat weniger was mit XNA zu tun, das sind eher extras die durch reine anfrageng geschehen.
Dann kommt am Ende noch einmal ein kleines tutorial wie man das ganze auf windows phone und XBox umschreibt.
Die komplette bisherige projektmappe bekommt ihr hier:
http://rapidshare.com/files/453578802/Bomber.zip
Ach nochwas: Die hintergrund musik hab ich komplett selbst gemacht: die gehört mir(falls einer auf die idee kommen sollte das teil oder teile davon zu verwenden)