In the last tutorial Working with Sprite Sheets I said that I would cover updating your scene in an upcoming tutorial. This is that tutorial.
In this tutorial we are going to cover three different ways that you can update your scene. As you saw earlier it is possible to update things directly inside your game loop, either directly or using a timer. However GameEngine2D has a number of superior scheduling options built in, and we will look at 3 different options. The first is using a Node’s Schedule method, the second is to derive from Node and override Update() and using the Scheduler singleton. The last is to declare a ActionBase derived object, to create a re-usable updater. We are going to create 3 bouncing smiling faces, each controlled by a different system.
We are going to start with the following basic skeleton:
using System; using System.Collections.Generic; using Sce.Pss.Core; using Sce.Pss.Core.Environment; using Sce.Pss.Core.Graphics; using Sce.Pss.Core.Input; using Sce.Pss.Core.Imaging; // for Font using Sce.Pss.HighLevel.GameEngine2D; using Sce.Pss.HighLevel.GameEngine2D.Base; namespace Updating { public class AppMain { public static void Main (string[] args) { Director.Initialize(); Scene scene = new Scene(); scene.Camera.SetViewFromViewport(); Director.Instance.RunWithScene(scene); } } }
That is about as stripped down a functional program as you can make. Be sure to add a reference to GameEngine2D. The Imaging using statement is needed for the Font object that we will use later. Nothing here should be new to you if you have gone through the earlier tutorials.
Alright, lets get started using the Schedule method. First a quick explanation of how Update() works. Remember in earlier tutorials when you called Director.Instance.Update()? Well this triggers off a chain reaction of events. This results in the current scene ( the one specified in the RunWithScene call ) having it’s Update call, which in turn results in all the (registered)Nodes in the Scene having their Update() methods called. This process happens once per frame. Schedule() marks the node to be called during update, and provides a method to be called when the update occurs. In this case we are going to declare that method using a Lambda. Let’s take a look:
First off, we declare our sprite:
Texture2D texture = new Texture2D("/Application/smile.png",false); TextureInfo ti = new TextureInfo(texture); SpriteUV sprite = new SpriteUV(ti); sprite.Quad.S = new Vector2(128,128); sprite.Position = scene.Camera.CalcBounds().Center; sprite.Position = new Vector2(sprite.Position.X - 256,sprite.Position.Y); sprite.CenterSprite();
Everything here you’ve seen before. The position is all relative to the middle of the screen. We will be rendering 3 sprites, this one will be positioned off to the left. Now for the new stuff:
bool goingUp = true; sprite.Schedule( (dt) => { if(goingUp) { sprite.Position = new Vector2(sprite.Position.X, sprite.Position.Y + 3); if(sprite.Position.Y >= 390) goingUp = false; } else { sprite.Position = new Vector2(sprite.Position.X, sprite.Position.Y - 3); if(sprite.Position.Y <= 64) goingUp = true; } });
Schedule takes a (lambda) function that is called every time Update() is called. dt is the elapsed time since Update() was last called, although we aren’t using it this time. Our actual method is pretty straight forward, we have a bool that determines which direction we are going. We add 3 to our Y direction until we get near the the top of the screen, then flip direction. Otherwise we are going down, by decrementing by 3 until we get to the bottom. ( 64 is half of our sprite height ). The Schedule() method is probably the simplest way to update a Node ( SpriteUV is derived from Node ) object.
Next we look at handling updates by deriving from Node ( actually, SpriteUV again ) and overriding the Update() method. Create a new class, I am calling mine BouncingSmile.cs but you can call it whatever you want. Enter the following code:
using System; using Sce.Pss.Core; using Sce.Pss.Core.Graphics; using Sce.Pss.HighLevel.GameEngine2D; using Sce.Pss.HighLevel.GameEngine2D.Base; namespace Updating { public class BouncingSmile : SpriteUV { private bool _goingUp; public BouncingSmile () { Texture2D texture = new Texture2D("/Application/smile.png",true); this.TextureInfo = new TextureInfo(texture); this.Quad.S = new Vector2(128,128); _goingUp = true; } public override void Update (float dt) { if(_goingUp) { this.Position = new Vector2(this.Position.X, this.Position.Y + 3); if(this.Position.Y >= 390) _goingUp = false; } else { this.Position = new Vector2(this.Position.X, this.Position.Y - 3); if(this.Position.Y <= 64) _goingUp = true; } } } }
As you can see, the Update() method is basically identical to our lambda method earlier. Otherwise we are basically just handling the creation of our sprite, just like we did back in the Hello World sample.
Now that we have a class with an Update() method defined, lets go back to AppMain.cs and put it to use.
BouncingSmile bs = new BouncingSmile(); bs.Position = scene.Camera.CalcBounds().Center; bs.CenterSprite(); Scheduler.Instance.ScheduleUpdateForTarget(bs,1,false);
We declare our BouncingSmile object object ( whose constructor took care of creating it’s Sprite ), then position it in the middle of the screen. Finally we register our object so that it’s Update method is going to be called. We do this using the Scheduler singleton. ScheduleUpdateForTarget results in the target ( bs ) having it’s Update() called every frame. In addition to the target to update, you pass in the priority ( how early in the Scheduler’s update phase it will be called ) and whether or not to start paused. The end result of this is virtually identical to the earlier Schedule() method. Our next method is much different however.
We are now going to create another class, this one called BounceAction.cs. Create it, then add the following code:
using System; using Sce.Pss.Core; using Sce.Pss.HighLevel.GameEngine2D; using Sce.Pss.HighLevel.GameEngine2D.Base; namespace Updating { public class BounceAction : ActionBase { private bool goingUp; public BounceAction () { goingUp = true; } public override void Update (float dt) { base.Update (dt); if(goingUp) { this.Target.Position = new Vector2(this.Target.Position.X, this.Target.Position.Y + 3); if(this.Target.Position.Y >= 390) goingUp = false; } else { this.Target.Position = new Vector2(this.Target.Position.X, this.Target.Position.Y - 3); if(this.Target.Position.Y <= 64) goingUp = true; } } } }
We are creating a new class derived from ActionBase. Actions are exactly what they sound like, runnable events. ActionBase is the very base class of action types available. Unlike our earlier examples, BounceAction isn’t actually tied to any single object, it can be applied to any Node derived object, making it very easy to create reusable/retargetable actions. Once again, the code looks virtually identical to our prior examples.
Now head back to AppMain.cs and add the following code:
Texture2D texture2 = new Texture2D("/Application/smile.png",false); TextureInfo ti2 = new TextureInfo(texture); SpriteUV sprite2 = new SpriteUV(ti); sprite2.Quad.S = new Vector2(128,128); sprite2.Position = scene.Camera.CalcBounds().Center; sprite2.Position = new Vector2(sprite2.Position.X + 256,sprite2.Position.Y); sprite2.CenterSprite(); BounceAction ba = new BounceAction(); ActionManager.Instance.AddAction(ba,sprite2); ba.Run();
The majority of that code is just us creating another sprite object. The key part are the last three lines. What we are doing here is creating a BounceAction, then registering it with the ActionManager singleton, applying it to our new sprite. Finally we trigger our action to actually run. Just like the Scheduler singleton, ActionManager is called once per frame. The power of using ActionManager is that the action isn’t tied to the thing being acted upon. There are some powerful things you can do with ActionManager, like queuing up actions up, or blending between actions, etc…
So there were three different different ways to handle updates with your PS Suite GameEngine2D node objects. In a moment I will post the completed source for AppMain.cs. There is however one new concept in the following code, Labels. In the comments for my earlier Hello World example, I said there were better ways to actually display Hello World on screen, and that way is using the Label class.
In order to make a Label, you first need a Font, which in turn needs a FontMap texture.
Font font = new Font(FontAlias.System,16,FontStyle.Bold); FontMap fontMap = new FontMap(font,512);
Then it is just a matter of creating your Label:
Label label1 = new Label("Derived from Node",fontMap); label1.Position = new Vector2(0,0);
Then add it to the scene to be displayed:
scene.AddChild(label1);
And that… is the easiest way to display text on screen.
Alright, now lets put everything together.
using System; using System.Collections.Generic; using Sce.Pss.Core; using Sce.Pss.Core.Environment; using Sce.Pss.Core.Graphics; using Sce.Pss.Core.Input; using Sce.Pss.Core.Imaging; // for font using Sce.Pss.HighLevel.GameEngine2D; using Sce.Pss.HighLevel.GameEngine2D.Base; namespace Updating { public class AppMain { public static void Main (string[] args) { Director.Initialize(); Font font = new Font(FontAlias.System,16,FontStyle.Bold); FontMap fontMap = new FontMap(font,512); Scene scene = new Scene(); scene.Camera.SetViewFromViewport(); //Center sprite BouncingSmile bs = new BouncingSmile(); bs.Position = scene.Camera.CalcBounds().Center; bs.CenterSprite(); Label label1 = new Label("Derived from Node",fontMap); label1.Position = new Vector2(bs.Position.X - 80, bs.Position.Y + 200); Scheduler.Instance.ScheduleUpdateForTarget(bs,1,false); //Left sprite Texture2D texture = new Texture2D("/Application/smile.png",false); TextureInfo ti = new TextureInfo(texture); SpriteUV sprite = new SpriteUV(ti); sprite.Quad.S = new Vector2(128,128); sprite.Position = scene.Camera.CalcBounds().Center; sprite.Position = new Vector2(sprite.Position.X - 256,sprite.Position.Y); sprite.CenterSprite(); bool goingUp = true; sprite.Schedule( (dt) => { if(goingUp) { sprite.Position = new Vector2(sprite.Position.X, sprite.Position.Y + 3); if(sprite.Position.Y >= 390) goingUp = false; } else { sprite.Position = new Vector2(sprite.Position.X, sprite.Position.Y - 3); if(sprite.Position.Y <= 64) goingUp = true; } }); Label label2 = new Label("Using lambda",fontMap); label2.Position = new Vector2(sprite.Position.X - 60, sprite.Position.Y + 200); //Right sprite Texture2D texture2 = new Texture2D("/Application/smile.png",false); TextureInfo ti2 = new TextureInfo(texture); SpriteUV sprite2 = new SpriteUV(ti); sprite2.Quad.S = new Vector2(128,128); sprite2.Position = scene.Camera.CalcBounds().Center; sprite2.Position = new Vector2(sprite2.Position.X + 256,sprite2.Position.Y); sprite2.CenterSprite(); BounceAction ba = new BounceAction(); ActionManager.Instance.AddAction(ba,sprite2); ba.Run(); Label label3 = new Label("ActionBase",fontMap); label3.Position = new Vector2(sprite2.Position.X - 50, sprite2.Position.Y + 200); scene.AddChild(sprite); scene.AddChild(bs); scene.AddChild (sprite2); scene.AddChild(label1); scene.AddChild(label2); scene.AddChild(label3); Director.Instance.RunWithScene(scene); } } }
And here is our finished application:
As always, you can download the entire project here. Oh, and this time I actually remember to test it on my Vita! 