For everyone who could not be at the event G4tv has good coverage of D.I.C.E. on their website.

Now watch the Indie Game Challenge Awards or look at some photos below. Thomas is being interviewed by Adam Sessler about Zeit² in the video starting at 10:50min.

Congrats to all the co-finalists! AHHHHHHHH, Vessel, Climb to the top of the Castle, and all the others… we are honored to be nominated next to these brilliant indie games.

Thanks to everyone that keeps supporting us on our game developers journey. Andy Nealen, RCP and of course everyone that contributed to the game and believed in our game! I’m sure you can tell how excited we are here at Brightside Games right now!

Visit http://www.indiegamechallenge.com/finalists/zeit-squared/ and vote for us if you like our game.

My highscore right now is 628.000 after the second day but Matthew and Jason (the devs) have over 1.8 million so still some room to improve . Decimation X is currently best rated game and best selling game on XBLIG in Japan.

You can also read more and watch a trailer over at gamesetwatch.com and technabob.com

There is also a very entertaining video report about the indie game companies that where nominated which was on Spike TV last night. Watch it now.

Congrats and good luck!

STEP 1 – Setting up the database

First you will have to create a MySQL Table:
CREATE TABLE IF NOT EXISTS `mygame_highscores` (
`ID` int(11) NOT NULL auto_increment,
`ModeID` varchar(256) NOT NULL,
`Name` varchar(256) NOT NULL,
`Info` varchar(256) NOT NULL,
`Score` int(11) NOT NULL,
`Timestamp` timestamp NOT NULL default CURRENT_TIMESTAMP,
PRIMARY KEY  (`ID`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1;

ID contains an auto-incremented Number that is unique for every entry.
ModeID contains an identifier for which mode or level a highscore was achieved. This way you can save multiple highscores tables in one MySQL table.
Name is the name of the player that got the new score. (In an advanced version you would use an UserID that refers to another table in your database)
Info contains anything you wanna store with your score, i.e. what time the user needed to finish a level.
Score has the number that represents the score the player got.
Timestamp lets you identify when a score was saved. That way you can have weekly leaderboards for example.

Let’s enter some dummy data to our table. this example only inserts two records but feel free to add more for better testing.

INSERT INTO `databasename`.`mygame_highscores` (
`ID` ,
`ModeID` ,
`Name` ,
`Info` ,
`Score` ,
`Timestamp`
)
VALUES (
NULL , '1', 'Marcus', '10:30 min', '100',
CURRENT_TIMESTAMP
), (
NULL , '1', 'Peter', '9:12 min', '90',
CURRENT_TIMESTAMP
);

Read on the next page how we write our PHP script to request scores.

Basically there are two ways to controll the volume of a running cue. There can be more, but thats all I found out.

1. Categories

The first one works with categories. You can create a category in the Xact tool, stick some sounds to it and change the category volume at runtime. Rightclick on the Categroies entry in Xact or on an existing category to add a new one or a subcategory. Give it a name and select the sounds you want to add to this category in your soundbank. Now select the new category in the lower left menu from a dropdown list.

In the component that cares for the audio of your game you should somewhere have an AudioEngine instance, if you want to work with Xact.  This AudioEngine provides access to lots of properties and entities of your Xact .xap project. With GetCategory and the corresponding name as a string, you can grap your category and set the volume level with SetVolume. This could look like that:

public class AudioInterface : GameComponent
{
  private AudioEngine audioEngine;
  private WaveBank waveBank;
  private SoundBank soundBank;

  public AudioInterface(Game _game) : base(_game)
  {
    audioEngine = new AudioEngine("Content/Audio/myGameAudio.xgs");
    waveBank = new WaveBank(audioEngine, "Content/Audio/Wave Bank.xwb");
    soundBank = new SoundBank(audioEngine, "Content/Audio/Sound Bank.xsb");
  }

  private void SetCategoryVolume(string _name, float _level)
  {
    AudioCategory cat = audioEngine.GetCategory(_name);
    cat.SetVolume(_level);
  }

  public override void Update(GameTime _gameTime)
  {
    audioEngine.Update();
  }

  //TODO add some more usfull audio stuff
}

Working with categories is cool because you can modify a lot of sound cues at once, but changing volumes via categories for single music tracks is pretty anoying. The number and subcategory structure of your Xact project can become very big and confusing. A better way are variables.

2. Variables

Right below the Categories entry in Xact is an entry called Variables. Here you can create your own variables, set a range or an initial value and change the value at runtime via the AudioEngine instance. By connecting that variable to a sound from the soundbank, you can controll a lots of properties for  that sound at runtime with the variable. One of them is volume. To do that you need a RPC (Runtime Parameter Controll) Preset which can be added right below the variables. That preset holds one ore more curves wich are connected to your variable and defines how the specified property changes, if you increase or decrease the variable value at runtime. If that preset is made, hook your sounds to it and thats it.

A wonderful tutorial about variables, presets and dynaming music volume can be found at Kevin Gadd’s blog. This one has a lot of pictures and code snippets and should give you a lot of information about that topic.

After doing all the Xact work you could extend your audio engine with something like that

  public void setGlobalVariable(string _name, float _value)
  {
    m_audioEngine.SetGlobalVariable(_name, _value);
  }

  public float getGlobalVariable(string _name)
  {
    return m_audioEngine.GetGlobalVariable(_name);
  }

and change the music volume by setting your volume variable to fade the music or set a specified level directly.

  private enum FadeState { None, FadeIn, FadeOut }

  private float FadeValue(GameTime _gameTime, FadeState _mode, float _start,
                          float _duration, string _variable)
  {
    float fadeElapsedTime = (float)(_gameTime.TotalGameTime.TotalSeconds - _start);
    float intensity = MathHelper.Clamp(fadeElapsedTime / _duration, 0f, 1f);
    switch (_mode)
    {
      case FadeState.FadeIn:
        audioInterface.setGlobalVariable(_variable, intensity);
        break;
      case FadeState.FadeOut:
        audioInterface.setGlobalVariable(_variable, 1f - intensity);
        break;
      default:
        //do nothing
        break;
    }
    return intensity;
  }

The presets together with variables are pretty migthy. For example I used a variable and a preset with two curves (as you can see in the image above) to crossfade two sounds by connecting a rising curve to the first track and a falling to the second and modifying them with the corresponding variable.

So much for now, have fun with Xact and dynamic volume.

Cheers Volker

Visit the ModDB Zeit² Page

See the original press releases

www.gruenderwettbewerb.de

gruendung.tu-berlin.de

pressestelle.tu-berlin.de

www.bmwi.de

Pictures of the event:

In order to work with external tools XML is a wonderful format to share the results and make them accessible in your code. There are lots of libraries for xml import and export you can include in your tool and if the xml file is not too long, you can even read or edit it manually with a simple text editor. That’s the reason why we use a lot of custom content types in Zeit². So the automatic serialisation is a welcome innovation for XNA and makes my live a lot easier.

You can find a pretty good introduction to the basic features and also some example code at Shawn Hargreaves Blog.

However there are still things I needed some time for to figure out, because they were not mentioned in the article above. So let me explain them to spare you the work [and to make me remember them the next time ].

Collections

You have the possibility to add collections to your type such as lists or arrays. Actually its no big deal to add a collection member to your type, but the tricky part is the format in the xml file. There are two different ways of separating collection entries. They can be space- or tag separated.

The separation method depends on the C# type you want to use. There are value-types and reference-types (pointer types should work like reference-types). Out of the value-types, the simple-types are space separated. These are predefined types such as int or float but also from XNA like Vector2 or Color.

The struct-types, enum-types and and all reference-types are separated with tags. The standard tag is <Item> but you can change the collection item name by adding the attribute [ContentSerializerAttribute(CollectionItemName = "CollectionItem")] to the managed type member.

For the example I used a space separated list with XNA Colors, the standard collection item name for the puppies and a customized one for the flees.

public class Dog
{
   public string name;
   public Color[] furColors;
   public Puppy[] puppies;
   [ContentSerializerAttribute(CollectionItemName = "FleeItem")]
   public List<Flee> flees;
}

public struct Puppy
{
   public string name;
}

public class Flee
{
   public int size;
}

<?xml version="1.0" encoding="utf-8"?>
<XnaContent>
 <Asset Type="GameLib.Dog[]">
   <Item>
     <name>Ace</name>
     <furColors>
       FFFFCCFF
       AAFFFF23
       1243FFFF
     </furColors>
     <puppies>
       <Item>
         <name>King</name>
       </Item>
       <Item>
         <name>Queen</name>
       </Item>
     </puppies>
     <flees>
       <FleeItem>
         <size>5</size>
       </FleeItem>
       <FleeItem>
         <size>28</size>
       </FleeItem>
     </flees>
   </Item>
 </Asset>
</XnaContent>

Optional Parameter

Another very useful thing is the optional attribute. By adding [ContentSerializerAttribute(Optional = true)] to a managed type member, you can skip it in the xml file if you don’t need it for an entry and use a standard value instead.

public class Flee
{
   [ContentSerializerAttribute(Optional = true)]
   public int size = 4;
}

So much for now, have fun with Automatic XNB Serialisation.

Cheers Volker

Check it out an become a fan at http://www.facebook.com/pages/Zeit2/148943270140