Using C# for game scripts, part 1

Alright, today I'm going to continue where my previous posts (Loading Map/Game Data from XML) left off. Those posts showed you how to get game data into your game, but how do you define game behavior? Simple! With scripts.

Now, there are lots of solutions for scripting available with one of the mose popular being Lua. However, I want this to be simple and easy, so we're going to be using C#. I mean, what's the point of doing all this setup that needs to be done with Lua when we have a perfectly working compiler and development environment sitting at our fingertips? =)

Ok, so first things first. When we are creating scripts that are going to be run, we need to have some time of entry point into the script; that is, we need to know how to execute the script. One simple way is to create and interface or a base class that defines the available methods that we can actually call on our script.

Continuing with the example of a text-based adventure, let's figure out how we might allow for developers to create commands the user can type to interact with the game. All we need to do this will be the name of the command and an entry point into the script.

   1:  public abstract class Command {
   2:      private string name;
   4:      public string Name {
   5:          get { return; }
   6:          set { = value; }
   7:      }
   9:      public virtual void Execute(Game game, string arguments) {
  10:      }
  11:  }

Now we have the base command in place, next we need a script that actually does something interesting. With this, you're just going to have to bear with me as I won't be posting the details of the Game class, but just assume the properties on it exist. =) Besides, this is more of a proof-of-concept.

   1:  public class MoveCommand : Command {
   2:      public override void Execute(Game game, string direction) {
   3:          direction = direction.ToLower();
   5:          // Determine if the player can move the way they wanted to.
   6:          Area currentArea = game.Map[game.Player.Position];
   7:          if (currentArea.HasExit(direction)) {
   8:              if (direction == "north") game.Player.Move(0, 1);
   9:              else if (direction == "east") game.Player.Move(1, 0);
  10:              else if (direction == "south") game.Player.Move(0, -1);
  11:              else if (direction == "west") game.Player.Move(-1, 0);
  13:              currentArea = game.Map[game.Player.Position];
  14:              game.Describe(currentArea);
  15:          }
  16:          else {
  17:              TextBuffer.AddTextLine("Invalid direction to move: " + direction);
  18:          }
  19:      }
  20:  }

It should be fairly obvious what this is script is supposed to do, after all it is called MoveCommand. 😉 Basically we are just going to move the player in one of the given directions with the Area that we are in has an exit/door in that direction.

We know have two-thirds of the puzzle. The next question to answer is, "How the heck do I get that into my game?". The answer is much simpler than you might think:

   1:  // You need to define these somehow, maybe from a backing XML file. 😉
   2:  string scriptPath;
   3:  string scriptFileName;
   4:  string scriptTypeName;
   5:  string commandName;
   7:  // Create the actual type in memory so it can be used.
   8:  CodeDomProvider provider = new CSharpCodeProvider();
   9:  CompilerParameters compilerParams = new CompilerParameters();
  10:  compilerParams.CompilerOptions = "/target:library";
  11:  compilerParams.GenerateExecutable = false;
  12:  compilerParams.GenerateInMemory = true;
  13:  compilerParams.IncludeDebugInformation = false;
  15:  compilerParams.ReferencedAssemblies.Add("mscorlib.dll");
  16:  compilerParams.ReferencedAssemblies.Add("YourGame.exe");
  18:  CompilerResults result = provider.CompileAssemblyFromFile(compilerParams, Path.Combine(scriptPath, scriptFileName));
  19:  if (!result.Errors.HasErrors) {
  20:      Type type = result.CompiledAssembly.GetType(scriptTypeName);
  21:      Command cmd = Activator.CreateInstance(type) as Command;
  22:      if (cmd != null) {
  23:          cmd.Name = commandName;
  24:          this.availableCommands.Add(cmd.Name.ToLower(), cmd);
  25:      }
  26:  }

Simple huh? Heh, well... if you know what all those lines of code do then it is. Basically all we are doing is having the CodeDom compile that piece of code for us. This results in an assembly which we can then use reflection to retrieve an instance of the MoveCommand from this newly compiled assembly.

You might be wondering where you put this in your game code. Well, I put in my Initialize method which is one of the first methods that gets called. I actually wrap it in a LoadCommands method which goes through and compiles all of my game scripts, which are of course, defined using an XML file. =)

This approach works fine and dandy for script files that are independent of one another, but what if we want scripts to be able to use methods defines in other scripts? Well, for that we'll need to compile all of the scripts into a single assembly. I'll cover how to do that in my next post.

Comments (4)
  1. Max Battcher says:

    Correct me if I’m wrong, but I thought dynamic compilation doesn’t work on the Compact Framework…  Are you planning to include a solution for cross-platform (ie, Xbox) work?

  2. Dean Harding says:

    I guess you’d have to precompile everything for the .NET CF. Probably not a problem on XBOX, cause people would not be able to modify what’s on the disc anyway…

  3. dowens says:

    You know, I didn’t even have the Xbox 360 in mind when creating this post. You guys are 100% correct that this will NOT work with compact framework. In either part 2 or part 3 of this post I’ll go over precompiling scripts and getting those into your game.



  4. David’s Blog has some recent entries I would like to refer: Using C# for game scripts, part 2 Using C#

Comments are closed.

Skip to main content