Hoorcollege 14 Vijanden, excepties

Wat zit allemaal in een level? Startpositie van de speler Waterdruppels Tiles Vijanden Einde van het level Achtergronden

Omgaan met grote klassen Level is een vrij grote klasse Laden van een level De game loop Veel verschillende methoden Maar ook lastig/onhandig om in verschillende klassen op te delen Hoe kunnen we dit overzichtelijk houden? Gebruik partial classes

Partial classes Spreidt de klassedefinitie over meerdere files class A { // heeeeeeel veel code } A.cs partial class A { // hier een deel van de // members, properties en // methoden van A. } partial class A { // hier de rest van de // members, properties en // methoden van A. } A_deel1.cs A_deel2.cs

Level en Player zijn partial classes Level.cs Membervariabelen Handige properties en methoden LevelLoading.cs Alle methoden om tiles mee te laden LevelGameLoop.cs Player.cs PlayerPhysics.cs

Rocket Vliegt naar links of naar rechts Verschijnt op een willekeurig moment Uitbreiding van AnimatedGameObject!

Rocket class Rocket : AnimatedGameObject { protected double spawnTime; protected Vector2 startPosition; public Rocket(bool moveToLeft, Vector2 startPosition) { "default", true, 0.2f); this.PlayAnimation("default"); this.Mirror = moveToLeft; this.startPosition = startPosition; Reset(); }... }

Rocket public override void Reset() { this.Visible = false; this.position = startPosition; this.velocity = Vector2.Zero; this.spawnTime = GameEnvironment.Random.NextDouble() * 5; } public void CheckPlayerCollision() { Player player = GameWorld.Find("player") as Player; if (this.CollidesWith(player)) player.Die(false); }

‘Die’ methode in Player public void Die(bool falling) { if (!isAlive) return; isAlive = false; velocity.X = 0; if (falling) GameEnvironment.AssetManager.PlaySound("snd_player_fall"); else { velocity.Y = -900; GameEnvironment.AssetManager.PlaySound("snd_player_die"); } this.PlayAnimation("die"); }

Rocket public override void Update(GameTime gameTime) { base.Update(gameTime); if (spawnTime > 0) { spawnTime -= gameTime.ElapsedGameTime.TotalSeconds; return; } this.Visible = true; this.velocity.X = 600; if (Mirror) this.velocity.X *= -1f; CheckPlayerCollision(); Rectangle screenBox = new Rectangle(0, 0, GameEnvironment.Screen.X, GameEnvironment.Screen.Y); if (!screenBox.Intersects(this.BoundingBox)) this.Reset(); }

Vijanden Lopen heen en weer over de platforms Bij de randen wachten en omdraaien Hier een halve seconde wachten. En hier ook!

PatrollingEnemy klasse class PatrollingEnemy : AnimatedGameObject { protected float waitTime; public PatrollingEnemy() { waitTime = 0.0f; velocity.X = 2.0f; "default", true); PlayAnimation("default"); }... } Zijn we aan het wachten? PatrollingEnemy erft van AnimatedGameObject

PatrollingEnemy klasse Twee gevallen waarin de vijand moet stoppen met lopen en omdraaien Vijand kan niet verder vanwege blok tile. Vijand kan niet verder vanwege einde platform/blok. Tile type == Background Tile type == Normal

PatrollingEnemy klasse public override void Update(GameTime gameTime) { base.Update(gameTime); if (waitTime > 0) { waitTime -= (float)gameTime.ElapsedGameTime.TotalSeconds; if (waitTime <= 0.0f) TurnAround(); } else {... } this.CheckPlayerCollision(); } Wachten aan de randen afhandelen. Pas de wachttijd aan. Vijand moet de andere kant op lopen.

PatrollingEnemy klasse public void TurnAround() { Mirror = !Mirror; this.velocity.X = 120; if (Mirror) this.velocity.X = -this.velocity.X; } public void CheckPlayerCollision() { Player player = GameWorld.Find("player") as Player; if (this.CollidesWith(player)) player.Die(false); } Animatie spiegelen en snelheid omdraaien Vijand botst met de speler

if (waitTime > 0) {... } else { TileField tiles = GameWorld.Find("tiles") as TileField; float posX = this.BoundingBox.Left; if (!Mirror) posX = this.BoundingBox.Right; int tileX = (int)Math.Floor(posX / tiles.CellWidth); int tileY = (int)(position.Y / tiles.CellHeight); if (tiles.GetTileType(tileX, tileY - 1) == TileType.Normal || tiles.GetTileType(tileX, tileY) == TileType.Background) { waitTime = 0.5f; this.velocity.X = 0; } } De vijand rent. De vijand loopt naar rechts. We zijn bij de rand aangekomen, dus wachten!

Variaties van PatrollingEnemy Vijand die de speler achtervolgt Vijand die willekeurig van looprichting verandert Gebruik overerving!

PlayerFollowingEnemy class PlayerFollowingEnemy : PatrollingEnemy { public override void Update(GameTime gameTime) { Player player = GameWorld.Find("player") as Player; float direction = player.Position.X - position.X; if (Math.Sign(direction) != Math.Sign(velocity.X) && player.Velocity.X != 0.0f) TurnAround(); base.Update(gameTime); } } Update-methode wordt aangepast Roep de originele versie aan voor de rest van het gedrag!

UnpredictableEnemy class UnpredictableEnemy : PatrollingEnemy { public override void Update(GameTime gameTime) { base.Update(gameTime); if (waitTime > 0 || GameEnvironment.Random.NextDouble() > 0.01) return; TurnAround(); velocity.X = Math.Sign(velocity.X) * (float)GameEnvironment.Random.NextDouble() * 5.0f; } } Update-methode wordt aangepast Roep weer de originele versie van de methode aan

Turtle Kun je gebruiken om hoger te springen Niest af en toe!

Turtle klasse class Turtle : AnimatedGameObject { protected float sneezeTime, idleTime; public Turtle() { false); LoadAnimation("Sprites/Turtle/spr_idle", "idle", true); PlayAnimation("idle"); Reset(); } public override void Reset() { sneezeTime = 0.0f; idleTime = 5.0f; }... }

public override void Update(GameTime gameTime) { base.Update(gameTime); if (sneezeTime > 0) { this.PlayAnimation("sneeze"); sneezeTime-=(float)gameTime.ElapsedGameTime.TotalSeconds; if (sneezeTime <= 0.0f) { idleTime = 5.0f; sneezeTime = 0.0f; } } else if (idleTime > 0) { this.PlayAnimation("idle"); idleTime -= (float)gameTime.ElapsedGameTime.TotalSeconds; if (idleTime <= 0.0f) { idleTime = 0.0f; sneezeTime = 5.0f; } } CheckPlayerCollision(); }

Turtle klasse public void CheckPlayerCollision() { Player player = GameWorld.Find("player") as Player; if (!this.CollidesWith(player)) return; if (sneezeTime > 0) player.Die(false); else if (idleTime > 0 && player.Velocity.Y > 0) player.Jump(1500); }

Sparky Valt soms naar beneden en is dan gevaarlijk

Sparky klasse class Sparky : AnimatedGameObject { protected float idleTime, yoffset, initialY; public Sparky(float initialY) { "electrocute", false); LoadAnimation("spr_idle", "idle", true); PlayAnimation("idle"); this.initialY = initialY; Reset(); }... }

public override void Update(GameTime gameTime) { base.Update(gameTime); if (idleTime <= 0) { this.PlayAnimation("electrocute"); if (this.velocity.Y != 0) { yoffset -= this.velocity.Y; this.position += this.velocity; if (yoffset <= 0) this.velocity.Y = 0; else if (yoffset >= 120.0f) this.Reset(); } else if (Current.AnimationEnded) this.velocity.Y = -60; } else if (idleTime > 0) { this.PlayAnimation("idle"); idleTime -= (float)gameTime.ElapsedGameTime.TotalSeconds; if (idleTime <= 0.0f) this.velocity.Y = 300; } CheckPlayerCollision(); }

Sparky klasse public void CheckPlayerCollision() { Player player = GameWorld.Find("player") as Player; if (this.CollidesWith(player) && idleTime <= 0.0f) player.Die(false); }

Level finished Overlay

‘Edit states’ Een edit state is een game state die gebruikt maakt van andere game states Voorbeelden: – Game over state – Level finished state –…–…

LevelFinishedState class LevelFinishedState : GameObjectList { protected IGameLoopObject playingState; public LevelFinishedState() { GameStateManager gm = GameEnvironment.GameStateManager; playingState = gm.GetGameState("playingState"); SpriteGameObject o = new SpriteGameObject(“spr_welldone"); o.Position = new Vector2(GameEnvironment.Screen.X, GameEnvironment.Screen.Y) / 2 - o.Center; this.Add(o); } … } Plaats de overlay in het midden van het scherm.

LevelFinishedState public override void HandleInput(InputHelper inputHelper) { if (!inputHelper.KeyPressed(Keys.Space)) return; GameEnvironment.GameStateManager.SwitchTo("playingState"); (playingState as PlayingState).NextLevel(); } public override void Update(GameTime gameTime) { playingState.Update(gameTime); } public override void Draw(GameTime gameTime, SpriteBatch s) { playingState.Draw(gameTime, s); base.Draw(gameTime, s); }

public bool Completed { get { SpriteGameObject exitObj = this.Find("exit") as SpriteGameObject; Player player = this.Find("player") as Player; GameObjectList w = this.Find("waterdrops") as GameObjectList; if (!exitObj.CollidesWith(player)) return false; foreach (GameObject d in w.Objects) if (d.Visible) return false; return true; } } Level afgemaakt? Speler heeft de uitgang nog niet bereikt Alle waterdruppels zijn nog niet verzameld

Update-actie van Level public override void Update(GameTime gameTime) { TimerGameObject timer = Find("timer") as TimerGameObject; Player player = Find("player") as Player; // check if we died … // check if we ran out of time … // check if we won … base.Update(gameTime); }

Update-actie van Level // check if we died if (!player.IsAlive) timer.Running = false; // check if we ran out of time if (timer.GameOver) player.Explode(); // check if we won if (this.Completed && timer.Running) { player.LevelFinished(); timer.Running = false; }

public void Explode() { if (!isAlive || finished) return; isAlive = false; exploded = true; velocity = Vector2.Zero; position.Y += 15; this.PlayAnimation("explode"); } public void LevelFinished() { finished = true; velocity.X = 0.0f; this.PlayAnimation("celebrate"); GameEnvironment.AssetManager.playSound("snd_player_won"); }

Game development Van prototype naar commercieel product – Meer levels, uitgebreider game ontwerp – Professioneel ontworpen assets – Goed opgezette programmacode  Hoge mate van robuustheid Robuustheid – Zoveel mogelijk bugs verwijderen – Zoveel mogelijk gevallen/problemen ondervangen – Testen, testen, testen!

Robuustheid Goed ontwerp van je code is cruciaal Duidelijke afspraken voor gedrag van methoden/klassen Zoveel mogelijk bugs verwijderen Zoveel mogelijk verschillende gevallen/problemen ondervangen Testen, testen, testen!

Software testen Verschillende soorten tests: – Handmatig – Automatisch (unit tests) Verschillende niveau’s van testen: – Alpha test Intern Meestal alleen developers – Beta test Extern Grotere groep spelers

Excepties Zijn een manier om robuustheid van games te vergroten Excepties gebruik je om externe problemen op te lossen: – Er mist een bestand – De internetverbinding wordt verbroken – Een andere speler gaat plotseling off-line – …

Excepties Voorbeeld: StreamReader r = new StreamReader("test.txt"); string t = r.ReadToEnd(); // oops… the file test.txt doesn’t exist… Wat nu?

Excepties Dit soort gevallen kun je afhandelen met excepties try { StreamReader r = new StreamReader("test.txt"); string t = r.ReadToEnd(); } catch (FileNotFoundException e) { Console.WriteLine(“The file was not found”); }

Excepties Meerdere catch-gedeelten voor verschillende soorten excepties try { StreamReader r = new StreamReader("test.txt"); string t = r.ReadToEnd(); } catch (FileNotFoundException e) { Console.WriteLine("The file was not found"); } catch (IOException e) { Console.WriteLine("IOException during file read"); }

Excepties Exceptie klassen zijn georganiseerd in een hierarchie Bovenaan die hierarchie: de Exception klasse Dus de volgende catch handelt alle mogelijke excepties af: catch (Exception e) { Console.WriteLine("Unknown exception occurred"); }

Excepties Je kunt zelf ook een exceptie “werpen”: private Tile LoadTile(char tileType, int x, int y) { switch (tileType) { case '.': return new Tile(); … default: throw new IOException("Unknown tile type"); } }

Excepties En die kun je ergens anders weer afhandelen try { char c = textlines[i][j]; tiles[i,j] = LoadTile(c, i, j); } catch (IOException e) { Console.WriteLine("Exception: " + e.ToString()); } Vertaalt exceptie naar string

Overzicht programmaconstructies Opdrachten Toekenning Aanroep void-methode return-opdracht while-opdracht for(each)-opdracht {... }-bundeling if-opdracht switch-opdracht try-catch-opdracht throw-opdracht Expressies Constante Variabele Aanroep methode Expressie met operatoren Expressie met haakjes new-expressie this en base (cast)-conversie met haakjes of as kun je doen kun je uitrekenen