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:
Alles anzeigen
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:
Nun muss die Startposition der bombe erstellt werden:
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,
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
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:
Alles anzeigen
dann müssen die in LoadContent auch noch geladen werden:
Alles anzeigen
Und nun gibt es nur noch einen neuen zeiger auf die bombe hinzuzufügen
Alles anzeigen
hinzufügen.
Nun geht es an das zeichnen, in der Draw Methode
Alles anzeigen
}[/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:
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
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:
Alles anzeigen
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:
nun müssen wir die natürlich auch mitladen, dafür gehen wir in die Initialize Methode aus der game.CS
Alles anzeigen
Nun bauen wir das mit einer simplen abfrage noch ein:
Alles anzeigen
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:
Alles anzeigen
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)
Alles anzeigen
für gewöhnlich würden wir die Leben so zeichnen lassen
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
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:
dabei 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:
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)
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:
Quellcode
- 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:
Nun muss die Startposition der bombe erstellt werden:
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,
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
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:
Quellcode
- 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:
Quellcode
- 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
Quellcode
- //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);
hinzufügen.
Nun geht es an das zeichnen, in der Draw Methode
Quellcode
- 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:
Quellcode
- 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
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:
Quellcode
- //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:
nun müssen wir die natürlich auch mitladen, dafür gehen wir in die Initialize Methode aus der game.CS
Quellcode
- 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:
Quellcode
- //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:
Quellcode
- //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)
Quellcode
- 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
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
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:
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:
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)