1. open up the TileSet Builder tool, small splash screen.

2. next, you select tile image file that holds the tiles

3. now we can input some basic info about the TileSet, such as the amount of tiles on the sheet, the size of any spacing between the tiles and the height and width of each tile. A preview of the tile set is shown as well, you can click on it to see it full size and unstreached. Later im going to try and a grid over the preview image so you can check if the inputs are correct.

4. next we define the base tile information

5. and then we can tweak it more in more detail! this is mainly for setting up anumated tile sets, you can remove a tile from the set(you only want the base animation frame to be part of the set), change the FPS and ID numer of a tile aswell as add and remove frames from the animation list.

6. finaly were all done, and can save out the TileSet

At the moment the tool is a bit sloppy, you can probably tell its far from idea, but its great for buiding up XML files for quick testing!

(note: mouse not showing up on screen shots :(, trust me, the tile location stuff is right )

Currently Supports

• - Maps of any size with any amount of layers
• - smooth scrolling
• - basic saving and loading
• - tile picking
• - multiple tile sheets
• - tiles with attached data

Coming in the next few builds
- better camera support (zooming, possibly rotation)
- better file definition
- quadtree based object renderer
- intergration with CrimsonEngine’s object and console systems
- improved resolution independance

save the following xml as UsingXNA.snippet

- <CodeSnippets xmlns=”http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet“>

- <CodeSnippet Format=”1.0.0“>

- <Header>

  <Title>XNA Using statments</Title>

  <Author>NekoCake Industries</Author>

  <Description>Inserts all the using statments needed for good xna useage</Description>

  <HelpUrl>www.nekocake.com</HelpUrl>

- <SnippetTypes>

  <SnippetType>Expansion</SnippetType>

  </SnippetTypes>

  <Shortcut>UsingXNA</Shortcut>

  </Header>

- <Snippet>

- <Code Language=”CSharp“>

- <![CDATA[

#region Using Statements using System; using System.Collections.Generic; using Microsoft.Xna.Framework; using Microsoft.Xna.Framework.Audio; using Microsoft.Xna.Framework.Content; using Microsoft.Xna.Framework.Graphics; using Microsoft.Xna.Framework.Input; using Microsoft.Xna.Framework.Storage; #endregion

  ]]>

  </Code>

  </Snippet>

  </CodeSnippet>

  </CodeSnippets>

Then start up GSE, click tools -> code snippet manager -> add then find where you saved the xml, and load it in. whenever you need the xna refences, just type UsingXNA and press tab twice when intelesence picks it up!

Still alive, still makeing progress! i started a rewite on Crimson Engine last month. Wanted to reimplement my object system and other things i thought wernt flexible enough. Just finished re implementing animated sprites last night, so its high time for an ‘im still alive’ post. I plan to write up some new tutorials and engine design posts over the next few weeks, and clean up the site abit!

Well, as you can see, I’ve crossed off everything that doesn’t exist in my current design. That’s not to say this old functionality is being removed, just that its being moved around and redesigned to be a lot more powerful that it ever was before. I’m also trying to decouple the game simulation from the world view, a trick that i learned from reading Game Coding Complete by Mike McShaffry. (This is a great book not only on the technical side of game development, but also things like how to manage the project, testing, folder layout…. the sheer amount of information in this book is mind-blowing! My personal favorite thing about it is the little ‘tales from the pixel mines’ inserts, where Mike shares stories for the development on games he did at origin (Ultima!) and Microsoft. You can learn so much from reading about the choices and problems in these sections! Do yourself a favor, and get this book)

 So, “how does it look now!?!” i hear you shout, well like this.

Each icon represents a different core area of the engine. Authority is the game rules, its where the simulation takes place. This will include a physics engine, the information on the current level, the data structures containing all the current entities in the world and things like that. You could almost think of it as a server (infact, this architecture is very good for extending your game to be multi-player). It also contains the command interpreter, which is very important! (shall all become clear soon)

The view is not a single piece of code like the authority, There is actually loads of em. Im implementing a base view which can be extended for more specialized purposes. They are basically filters on the game state(held in the authority). The most obvious example on one would be the player view. It has all the code in it for drawing the world to the screen, converting button presses in to commands, making music play and stuff like that. You could also make one to command a team of A.I players. It wouldn’t need any drawing code, but it would need to be able to sense whats happening in the area of world-space it can see (filtering everything it cant out)and then sending commands to the authority for the next step in simulation.

That’s where it comes exciting for me. The game I’m designing this engine to build will rely alot on A.I… good A.I that doesnt cheat. This system lets the A.I only get the same information a human player would, and use the exact same methods to interact with the game world a human is. For me, that’s big!

 So whats that last bit all about? have a closer look!

Please remember this is still far from done, its in a kind of half way state between class layout and program flow diagram! Whats important is that the class CrimsonEng is the engines entry point, create an instance and throw it a start-up script and the game shall load! Its basically a massive collection on managers which will be available for the other systems to use (via the interfaces and core libs). My current plan is to not use the default game class that xna ships with, as it wont fit very well with my engines design (maby more on this next time).  Some interesting things here are things like eventMan and MessengerMan. Messages are going to be from entity to entity, good for A.I characters or triggers. Events will be for wider reaching things, like state changes or button presses. I think its important to separate and specialises these kind of messaging functionalities. Well, Thats it for this installment! Cant wait to get my laptob back to start building this thing!

I included a method for calculating what angle the sprite should be rendered at to produce a cool looking animation. It used a mathematical function called arc tan to calculate this angle.

To tell you the truth, i cant really remember what the actual problem was, but I’m fairly sure that if the control points were not layed out in a perfect right angled triangle shape, the red lines imposed on the image wouldn’t meet at the bottom to form a right angle…. which my method relied on to produce a correct angle (going by memory, as i say, i might be remembering this wrong). it would produce slightly odd results with some quadratic curves, like the one pictured and would definitely screw up on higher order curves.

A much nicer way of doing it would be to store a heading. Every time you update the position of the sprite over the curve, if you normalise its position (presuming your useing a vector for its position) and the calculate the dot product of that heading with the previous heading, you should get the angle between them in radians…. you should beable to use that to create a better looking movement over a curve, of any order.  (please note, i havent got xna installed and working at the moment because of my previously mentioned computer problems, so i cant test out this theory!)

Fist off, a big thanks to Dan Fernandez for the cool visual studio tshirt he sent me! Its allso go the Lego nxt robot on it. Cool stuff

Next up i moved in to my new flat in durham, and then came back down south to spend some of the summer at home, set up my laptop and xbox up in my room, ready to code!

Then, as im about to start working on Crimson again, my laptop overheats! i check  everything, make sure all the vents are free from dust, and again, it overheats. Phone up alienware, they sent me some new thermal compound. redid the seal between the cpu and the hsf… overheats! Got a returns box coming next week, then it will take 5 days for a fully repaired flabtop to work its way back to my home

 Good news is, ive been working stuff out on paper, and ive got a better idea of the layout  for the engine code. not a full design yet, im going to read loads more articles and browse through some other engines to sure up any doubts i still have. The current plan is to have loads of little virtual machines in my code, and for entity’s and engine code to beable to register processes with them. This should allow me to handle threads quite well, and use some of the knowledge ive learned at uni in the operating systems lectures!

 Allso, you might just have noticed, ive changed the theme! i hated the old one, this ones alot more consistant with the main site… and lets you see more than one post a page!

ahh well, if it goes well I might post it! wish me luck.

First of, whats a profiler? A profiler is a tool that can tell you what your code is actualy doing. It tells you how much time it spends in each piece of code. You can get external programs which can profile your .Net application. So why bother writing our own? because games are different to office applications! We want to know what our game is doing frame by frame. External profilers will sample your game application over a few seconds and tell you what happend over thoese seconds, we want to know what happend on a frame by frame basis.

So, what should the profiler be? The profiler component should collect every imaginable piece of data about how the game is currently running, it should include stuff we might want accessible in any game build (I always like to have FPS and Frame Time easily accessible in pc games) and stuff we might want to use in ‘profiling’ builds, like a print out of exactly which pieces of code are being called, how many times they get called and how they relate to another (execution hierarchy). Basically I want to be able to get code to compile into a build of my game which will print out what my game is doing.

How will the profiler know a piece of code is starting and stopping its execution? The constructor for the class registers all the counters to be used in that class and gets id numbers for each performance check, and then at the beginning and end of each method we want to measure we check in and out with the profiler. The code to do all this can be shoved inside a #IF statement so it only gets compiled in if we want a profile build. This means normal release and debug builds are not affected by the new code, and hopefully it will have a small enough footprint not to change the characteristics of the code too much when it is compled in. Is it just me or does this seem far too simple?

As it turns out, yes. Recently I’d been browsing Amazon for some game programming books to buy, and I remembered that some volumes of Game Programming Gems had articles on this very subject listed in their indeces. One quick check of the Durham University library website revelaed that they did in fact have all the books in the main library, on the 4th floor in the fine arts section for some odd reason, and the articles in the first two volumes of the books confirmed my suspicions. It really is that easy… if you have a good clock. The implementation I present to you implements some ideas from the articles mashed in with what I had been working on before I read them.

So first we tackle the problem of a clock. why not use XNAs gameTime I hear you ask? It’s not high res enough! That may sound silly, but gameTime only gives us millisecond resolution. We need a better clock. As discussed earlier, we need to draw every frame in about 16 miliseconds in order to get 60 fps. so we need a clock that can tell us the time in much smaller units than that in order to measure how long it takes each part of the update and drawing cycle to run. At the worst we want a clock that updates every 1 millisecond, better would be microsecond, jackpot would be nanoseconds (its not just how low it goes, but how quickly it updates, theres no point if it can tell us the time in nanoseconds if we can only read it every 4 milliseconds!).

Lucky for us System.Diagnostics.Stopwatch exists (it should work on the xbox as well but I haven’t tested it myself). This is a good and proper high res clock. I wrote a small test app to test it out, you can grab it here. from what I gather it is hardware dependant, so I built this test app and bullied a few people into running it, and the news is good: it doesn’t seem to differ much at all! Stopwatch has a base frequency, which is how many times the clock ticks a second. So the first test was to check if the frequency of the ticks was at all constant over different processors. I managed to test it on two different athlon 64, athlon 64 mobile, celeron m, PIII and an intel T2300. All of the had the same frequency of 3579545 ticks a second, which equates to about 1 tick every 279 nano seconds!

The second part of the test sees how quickly we can access the clock. I did this with a simple loop:
watch.Start();
for (int i = 0; i < 10000; i++)
{
  nano[i] = watch.ElapsedTicks;
}
watch.Stop();
 We just check the elapsed ticks 10,000 times and put the elapsed time into an array. I then found out the average time between the checks and it turned out to be about 5 ticks between every check, giving 1395 ns or 1.3 microsecond. Why did I do all this? Just to prove to myself that I was able to get a good reading from the clock. It’s unrealistic to presume we can check the clock every tick. Seeing as 1.3 microseconds is a good estimate for the smallest unit of time we can grab from the clock, and its allot smaller that 16 miliseconds, Stopwatch has passed the test and we can use it to time our game loop and hopefully I’ve proved to you that its quick enough for the task!

Just to let you know now, I won’t release the code for this componet myself, as what I have at the moment was written very quickly and is not fit to be released, but if you ask I’ll redo it and post it. Instead im going to describe how to implement a profiler. I decided to use performanceMan as a base for this component. First I cleaned up the code, pulling out all the unnecessary things in it so it just handled gametime and fps and printed it to the screen, no more GUI. Next up was adding an instance of stopwatch to the class and instancing it in the constructor. Now, one of the problems we wanted to tackle is if were not running a profiling build, we don’t even want the profile code to compile in to the game, we don’t want it there at all! How do we manage this? All the code to do with profiler we put in a #if preprocessor block. for example, this is what I have in my constructor.

#if profile
               watch = new System.Diagnostics.Stopwatch();
               watch.Start();
               nanosecondsPerTick = 1000000000 /System.Diagnostics.Stopwatch.Frequency; //1 tick in nanoseconds
#endif

Now we need to tell Visual Studio how to build a profile build of our game. On the drop down box where you can select ‘debug’ or ‘release’ choose configuration manager. In here you can make a new configuration, call it profile and tell it to copy settings from release. This way we wont have the debug features in the profile build, but from my experience when you profile you game, you’re not checking for bugs, you’re finding out where it spends its time, so you want it to run as fast as possible. Next you have to open your project properties and go to the build tab and set the configuration to profile. In the ‘conditional compilation symbols’ box add ‘profile’. This lets us use profile as the switch in the preprocessor if’s.

Next we need an object to represent each counter. We can use a class because garbage should not be an problem here as we don’t allocate and deallocate loads of these every frame, we tend to keep our counters for the whole life cycle of the game. Now, what do we need to track in a counter? We definetly need to keep some identifiers, a string for the name of the counter and an integer to hold its id number. We also need some fields to hold the frame by frame action.  Something like the following shall suffice.

public int calls; // number of times this counter has been used this frame
public bool open; // is this counter running
public long startTick; // the tick we started this counter on
public long accumulatedTicks; // ammount of ticks we have run this counter for this frame

So, the idea here is when we start a timer, we check if the counter is already open. If it is, throw an error or something. We only want each counter to be running once. If it’s free, we set open to false, increment calls and set startTick to ElapsedTicks (which we get from the stopwatch).  When we finish the code and stop the counter, first we grab the current ElaspsedTicks and take away the start ticks, the remainder is the amount of ticks the code took to run. Add this to accumulatedTicks, oh and set open to close.

If we run a piece of code over and over, the calls stack up and the accumulatedTicks holds the combined time that the counter has been running, so we need some variables to handle some basic statistics. I decided to keep track of high and low points and the average running time over a frame. If we had 12 enemies in our game, there update code will run 12 times and obviously calls would be 12, so if we divide the accumulatedTicks by calls we get the amount of time (in ticks) it took on average for each update cycle to run, which is a good stat to print. We can also then test this against a variable holding the shortest and longest time it took to run, and update as appropriate. Remember before you draw them to multiply the number of tics by nanosecondsPerTick to get the amount of nanoseconds that passed. your probably then going to end up with some silly big times though, so you can divide you time in nanoseconds by 1000 to get it in microseconds or by 1000000 to get it in milliseconds. a simple if statement in your drawing code to decided which division to use and what unit to print will help, too. The last thing you should track in each counter is an integer to hold the id of a parent counter. In this we will store the id the counter that contains this counter.

 This allows us to print out counters in the correct order, as seen in this image (the nuber in the brackets is the id for each counter). I’ll describe how this works in a bit!

Ok so far we have a profiler class that has a stopwatch and keeps track of the fps and frametime, and a class to represnt a counter. We need to add the profiler logic to our profiler class, and define a interface for it to use so we can use it as a global service. Let’s look at the interface first.

interface Iprofile
{
        int AddCounter(string counterName);
        int GetCounterID(string counterName);
        void DeleteCounter(int id);
        void UnDeleteCounter(int id);
        void StartCounting(int counter);
        void StopCounting(int counter);
        string EndOfFrame();
}Anything of note here? Not really, everything acts as expected. Ive already discussed what start and stop counting do, add and get counter act as you would imagine. DeleteCounter doesn’t delete a counter, rather moves it to a different list of counters. This allows you to change the behavior of the profiler as it runs. You can stop a counter from being updated (start and stop should fail silently) so you can change the depth of the profiling as you want. undelete simply puts the counter back in the active counters list. Now, back to the relationship thing! We need a third list of counters, every time startCouning is called a counter is added to the runningCounters list. If there are any other counters in the list, the one at the top is assigned the parent of the new counter. StopCounting removes a counter from the running list aswell. This allows EndOfFrame to do its job. The draw method for the profiler calls EndOfFrame to gather all the information from the counters and format it in to a string. We have allread discussed most of its job so I won’t reiterate it, the only thing left to tackle what it does with related counters. First it iterates through the list counters for one which doesn’t have a parent. It adds this to the string first, then it looks for one that has the current counter as a parent. It now adds this one to the string (spritebatch.DrawString will use \n to draw on a new line, so remember to add them!). it keeps running through the list of counters, finding the children, adding to the list, fining the next parent and so on till all the counters are in the string, at which point we return it. Doing it like this puts the counters in the correct order, so AI update in the previous example would sort under update. It’s a good idea to add an indent to the children so you can see they are children. Format the output string like a table and it should be fairly pleasing to the eye.As you can see, I have some work to do on the output. The units are currently mixed up (average is in microseconds, the min and max are in miliseconds) and the table doesn’t line up stably, but it does demonstrate what we’re after. It doesn’t seem to have any effect on performance either, so that’s all good!

Well, there you have it, a description of how to implement a Profiler into your game. As it stands some things could be tweaked here and there, I’ve hardly touched on error detection, it won’t work with recursive methods and there are probably hundreds of ways you can tweak it to work better with your game. Well, have fun adding one to your game engine, and tell me how it goes!

Without any diagrams, things get messy quickly. I had the thing planned out in my head, i had no paper in my room, my windows were too small to write on (at home i design programs on my windows with dry wipe markers) so i decided to go ahead anyway, and not so surprisingly it got messy. I then decided to use blue J (a java ide we use in university) to draw down what id written so far. Now i know how things connect and i can visualize it better. Id say a visual program designer is a good tool, you can pull things and its cool, but not as cool as using a window!

 Animated sprites have been a fun feature to add, my implementation hangs around the concept of an animation sheet. my orc test sprite has some animations in separate.png files and some bunched together on the same .png. So how do i handle them? every animation gets a animation sheet, which contains its start frame, end frame and a reference to its texture. these are held in a dictionary as a value, the key to that dictionary is a CompassDirection (north, NorthEast ect).  I have a load of these in a list, and i keep there indexes in another dictionary with a AnimationState(move, idle, jump etc). To get the correct animation sheet you just need to know what direction and animation you currently in and pull em out. More difficult problems were finding out the current direction and grabbing the current frame from a texture. At the moment i only support the xbox controller, so i needed a way to turn the vector2 returned from the thumb stick in to a cardinal direction. I did this using the magic of dot product. The dot product between two vectors will give you the angle between them. All i needed to do was to have a list of all the directions i wanted to test, try the dot product between them all and then use the animation with the smallest dot product (which would be the closet to the angle of the stick) Heres some code for you!

public class DirectionSet // the 8 compass directions represented in vectors
  {
  public Dictionary directions = new Dictionary();
  public DirectionSet()
  {
  directions.Add(0, new Vector2(0f, 1f));
  directions.Add(1, new Vector2(0.5f, 0.5f));
  directions.Add(2, new Vector2(1f, 0f));
  directions.Add(3, new Vector2(0.5f, -0.5f));
  directions.Add(4, new Vector2(0f, -1f));
  directions.Add(5, new Vector2(-0.5f, -1f));
  directions.Add(6, new Vector2(-1f, 0f));
  directions.Add(7, new Vector2(-1f, 1f));
  }
  }

Use this function to get the sticks direction:

public int GrabAnimationDirection(Vector2 stick)
  {
  float bestDot = -100;
  int bestAnim = 0;
  for (int i = 0; i < 8; i++)
  {
  Vector2 normal = Vector2.Normalize(directionSet.directions[i]);//normalise the directions
  float dot = Vector2.Dot(velocity, normal); //find the angle
  if (dot >= bestDot) //if its smaller, save it
  {
  bestDot = dot;
  bestAnim = i;
  }
  }
  return besttAnim;
  }

Then i just cast the returned int to my CompassDirection enum for use!

The other problem is alot easier, how do we choose the tile? First, we need a frame counter to increment. I increment it every 33ms (30fps).  we also need to know the number of columns in the sprite sheet and the height and width of each sprite. with this info we can find the top left corner of each frame

int x = (frame % column) * width;
int y = (frame / column) * height;

Its really simple when you think about it, just grab a sprite sheet, and try these for a frame in the middle, I’m sure your understand how it works straight away!

The other useful thing i learned is how to cast a string in to a enum. Which is really useful when reading info out of an xml file.

(CompassDirection)Enum.Parse(typeof(CompassDirection), “North”);
remember to test its going to work first!
Enum.IsDefined(typeof(CompassDirection),”apples”);
would return false, because apples just arn’t directions no matter how hard they try.

anyways, Crimson 0.0.2.24380 new features!

Features:

• Better, more flexible animation system, which supports:
  • Idle animations
  • Movement
  • Shooting
  • Death
  • and flexible to add others!
• Loading XML files which describe an animation, and serializing them in to actual animation sprites.
• early prototype of the input manager.
• updates to my content manager

also, for anyone who is interested, heres a short demo. It only works with an xbox controller at the moment. left stick moves you around, B jumps and A kills you. If anyone can run it and tell me how it runs on there pc id be grateful!

Demo