The Applied Games Group Blog

Work Experience Student - Max Steele

apg — Thu, 28 Aug 2008 12:38:00 GMT

Last week we enjoyed having Max Steele here for a week of work experience. Max is a 6th form student, currently studying for his A-levels and hoping to pursue a career in Computer science. Before his time here Max had never done any coding so we thought we would throw him in at the deep end and set him the task of programming a Blackjack game in F#. It was very interesting to teach someone about functional programming from the ground up without them having written an imperative program before. In fact this lack of knowledge might actually have helped, as he was not tempted to fill the code with for loops etc! Here is what Max has to say about his experience in Cambridge.

This week I have been here in The Applied Games Group on work experience over my summer vacation from school. I have currently just completed an AS-level year in Further Mathematics, Philosophy and Economics and intend to apply to university in the coming months for something along the lines of a Maths and Computer Science course.

When I came into the Group I was put under David Stern’s wing, with no prior experience to any sort of programming whatsoever. I was very keen to learn about programming and gain a better understanding of how computers work on the whole. Unfortunately there was no other option other than to be thrown straight into the deep end with a book called ‘Expert F#’, a book that definitely is not for someone in my position. As I tried to read through sections like the introduction of this book and other articles on functional programming I slowly started to grasp loose concepts, despite sometimes understanding only a few words a sentence. Talking with Phillip about how the platforms of computers are compiled helped greatly and although I went home with an aching head each night I am sure a lot of this information clung on to something to recall on in the future.

Luckily, towards the end of my first day I was found an exercise by David to teach take me through some of the basic functions including arrays and lists as well. Progressing from this we decided to try to create a Blackjack game. The aim was to first create the most basic program where the player can play head on against a dealer with set rules to his gameplay. After more than two days full of work and new functions I finally was able to create the most simple of games allowing you to keep score against the dealer as you play. David is due a lot of credit for this work and I am very grateful for the hours of time he put in over the week to help me understand this completely new way of thinking. What was most exciting was to realise that I had learnt enough of this to think on my own and write new functions by myself. After creating the main structure as well as the user interface controlling the player with David, I was able to go on and create almost all of the dealer actions by myself. All of what seemed like unbearable slow progress in learning this code earlier in the week really came together and gave me a great feeling of accomplishment at this point.

As for the future, I am really glad I have been able to enjoy the experience of this week and will definitely continue on with this work in the future at home to create a complete Blackjack game where all actions like “split” and “double down” will be possible. I would lastly like to thank everyone for their help and friendliness both in and outside of work this week and hope that I may meet some of you again one day if I end up in a similar line of work. Enjoy the game! - Max

I have attached Max's code to this post - have fun!

- David Stern

TrueSkill in F#

apg — Mon, 16 Jun 2008 07:25:00 GMT

Following the publication of the F# source code for the TrueSkill Through Time paper, we have used the same inference library code to demonstrate how the original TrueSkill algorithm can be coded. In the attached source code, only the program.fs file is different to the TrueSkill through Time blog post and it builds up the factor graph for an arbitrary N-player game with an arbitrary draw probability. Both these numbers can be entered on the command line when running the resulting sample. We tried to make sure to stay as close as possible to the description on page 3 of the TrueSkill technical report.

let priorMu = 25.0<SkillPoints>

let priorSigma = priorMu / 3.0

let priorSkills = Array.init noPlayers (fun i -> Gaussian.Create (priorMu, priorSigma))

let (posteriorSkills, logZ) =

NPlayerTrueSkillUpdate (0.5*priorSigma, 0.01*priorSigma, drawProb / 100.0) priorSkills

Note that one can no longer accidentally pass the variance instead of the standard deviation because the former being of type float<SkillPoints^2>. Try yourself!

Update 2: We had some feedback from Andrew Kennedy that we exploited a current "bug" in the units-of-measure code where literals (such as 1.0) can have generic units. We removed the incorrect usages and re-posted the ZIP file.

Update 3: We extended the example to work with draws. Thanks to Chih-Jen Lin for the suggestion!

Ralf Herbrich & Thore Graepel

Create a Game with Popfly

apg — Wed, 04 Jun 2008 15:22:00 GMT

Popfly has a great Alpha that lets you create a game in your browser, no programming required, and then easily embed it on your own site.

The following is one of the sample games - Space Boy:

You can read more on Somasegar's WebLog: PopFly Game Creator. It looks like Silverlight is going to be a very interesting platform for games.

Phil

Statically link with ILMerge

apg — Thu, 29 May 2008 21:49:00 GMT

Today Ralf & I were looking at ways to bundle up a bunch of .Net assemblies into a single assembly for use within our group; the goal to expose only the functionality we want and only need to reference one assembly in our projects. Enter command line app ILMerge by Michael Barnett of Microsoft Research which lets you merge a set of dlls into a single assembly and selectively hide functionality by changing public access modifiers to internal. The first assembly you specify on the command line is the primary one and it's types maintain their access modifiers, the subsequent assembles are the ones that can be hidden by using ILMerge's ExcludeFile parameter where you can specify a file which in turn contains a list of regular expressions for the types you would like to keep public. When you merge the assemblies if you have also written XML code documentation files these get merged too, so you even get to keep the intellisense tooltips on the classes and functions you have documented with /// comments. For C# projects you can specify XML documentation output in the project's Visual Studio build properties, and for F# projects you can use the command line -doc filename option. To quickly check if we were getting the desired results in our target assembly we used the ILdasm tool to walk through our types. While checking the output we noticed that by default in the current F#, triple slash XML comments get embedded in the assembly for use in Visual Studio for tooltips; but if you are already generating seperate XML documentation it is possible to turn off this feature with the --no-interface-data command line option. So in summary ILMerge appears to be a great, highly customisable tool that lets you distribute a single assembly exposing just the functionality you want to expose (just like linking good old .Lib files in C++ :)).

Phil

BabyJack Inline Video Card Game

apg — Mon, 26 May 2008 13:27:00 GMT

Its been yet another wet and windy bank holiday weekend here in the UK, so I decided to involve the family and create a video Blackjack called BabyJack, despite the baby's name being Sean not Jack :). Just press the Play button below to pit your wits against the baby...

For those of you interested in how it was done; the video was shot on a simple digital camera, and then sepia and film age effects were applied in Vista's Movie Maker, with sound generated by my eldest son Thomas playing piano in the background. The stills were created using Microsoft Paint and the Chiller font. The video itself was embedded in the page using the Windows Media Player Control; and the interaction was coded in Javascript using trusty Notepad.

Phil Trelford

Lunar Lander Retro Vector XNA 2.0 Game sample written in F#

apg — Mon, 12 May 2008 00:36:00 GMT

While travelling to Microsoft HQ in Redmond earlier in the year for the annual TechFest event - for some fun I decided to have a go at writing a small retro game in F# using XNA 2.0, and attached are the results. When moving over to Pacific time I usually find myself waking up at 4am for the first few days, leaving me with plenty of wide awake hours I wouldn't normally have to while away, and this is when the sample was born. I decided on an implementation of Lunar Lander basically because it is pretty simple both logically and graphically, and at the same time fun and achievable in a relatively short time. The sample lets you play with a game pad or keyboard ('Z' and 'X' to rotate, Space to thrust), and to complete the game you must land on the long flat section before you run out of fuel and hit the jagged terrain.

For those interested, the source is attached to this post, which comprises a Visual Studio 2005 solution, a C# XNA 2.0 shell project to take advantage of the content pipeline for audio, an F# game implementation project and a small utility project to create terrain vectors from points in an image file. Please feel free to download and play with it, in theory if you have XNA 2.0 and F# installed then you should be able to just load the solution and press F5 to build and run.

Phillip Trelford

LEGO Halo 3 Foundry Forge Kit

apg — Fri, 18 Apr 2008 11:47:00 GMT

We have recently come accross Jeff Keegan's solution to being obsessed with Halo 3's Forge mode, but stuck at work without an Xbox:

The LEGO Halo 3 Foundry Forge Kit! (LH3FFK)

We loved the idea, and asked Jeff to tell us the story. Here it is in Jeff's very own words:

"Halo 3 has a feature that lets you modify existing maps, but it's limited in that it only lets you place/move/remove objects - you can't change the terrain. That limitation changed slightly when Bungie gave us the Halo 3 map "Foundry", a large warehouse where virtually every object in the room is removable, and the terrain is basically a big empty box. With Foundry, they essentially threw down the gauntlet and said "Here's a blank slate - go have fun and create something cool". Many of us have risen to the occasion, pouring hours upon hours into the art of placing virtual shipping containers, bridges, staircases, crates, and wire fences in that big empty box, all to create that one perfect sandbox to play in.

One day, while talking about some map ideas with my friend Aron at work, we found ourselves drawing whiteboard illustrations just to convey the ideas that were coming to mind. Someone had already created a PDF file showing a top-down view of the empty warehouse (and a bunch of paper cutouts of containers that were to scale), but that crude tool only allowed you to create these very two-dimensional maps, hugging the ground. Looking at the Lego constructions on my desk, Aron said what I'd already been thinking for a while - someone should do this with Lego bricks. A few days later I had the entire design modeled in Lego Digital Designer - my Lego Halo 3 Foundry Forge Kit (LH3FFK). Before clicking the check-price button to see how much the actual pieces would cost, I wondered to myself how much I could stomach.. I imagined the best case scenario: that 20 years from now I'd fondly remember that cool Halo Lego map thing I did back in '08, that I'd create a bunch of incredible maps we play every Thursday, that I'd have fun building and using it, and that at least a few people said they thought it was cool. How much would I pay for that? I thought, maaaaybe, at the most, umm.. ehh.. $300? I cringed at the amount, amazed that I'd let myself go that high. I clicked the button and saw $380. Doh!

After one initial scaled-down purchase ($80), a cost saving trip to the local Lego store, some more self convincing, a final big purchase from Lego's Pick-a-Brick website, and more than 30 days of waiting for overseas shipping, I now have my kit. It took two days to sort out all of the Lego pieces and build the LH3FFK pieces. It's incredibly satisfying designing levels by hand; Forge is great (and also satisfying), but actually holding the blocks and manipulating them just feels different. My favorite part about this whole exercise? When I was a kid, every time I built a Lego building or maze, I'd think "Man, I wish we could shrink ourselves down to that size and run around in there, climb this, jump off of that, and crawl through this". Now, I can! Well worth the price of ten pounds of acrylonitrile butadiene styrene.

Now if only I could keep my daughters from turning my Big Arena map into a Lego tea party."

We love Jeff's passion! Here are two more (clickable) screenshots:

Joaquin Quiñonero Candela

TrueSkill Through Time

apg — Sat, 05 Apr 2008 15:59:00 GMT

In December 2007, we published a paper about the application of TrueSkill to all recorded data of professional and semi-professional Chess play from 1850 to 2006. The dataset can be obtained from ChessBase. We are very happy to be able to release the F# source code that performed all these massive computations. A few things to bear in mind when running this code:

The full factor graph has ~30,000,000 factors and ~25,000,000 variables. At this size, the analysis is among the largest applications of (approximate) Bayesian inference to date. Nevertheless, the full message passing schedule allocates no more than 11 GB of memory and is run in under 20 minutes on an Intel Pentium 4 processor. These numbers hold for the adaptive draw margin model run on 3.5 million games.
Due to the huge amount of results (>1,200,000 skills of all players in all their active years) we use SQL server to store the result set. Please let us know if you think a purely text based result output is needed and we will add it.
There is a very interesting, related paper by Prof. Mark Glickman which analyses subset of this data (88 top players of all time).

The attached ZIP file contains the entire source code which should compile without problems with F# 1.9.3.14. You can either load the solution in Visual Studio 2008 or simply run build.bat form the command line - in either case you will end up with a chessanalysis.exe program or an analysis.exe program. If you want to try out the application, we included the first 1,000 lines of match outcomes (this is part of the first 5 years of data we have).

As for running the code, here are the parameter switches of the command line application:

        -no-safe                          Does not save results predictions (default: off)
        -q                                    Verbosity level off; only works on single runs (default: on)
        -N <int>                           First N games only (default: ALL)
        -delta <float>                  Maximum deviation in any marginal for convergence (default: 0.01)
        -muS <float>                   Mean of prior skill belief (default: 1200)
        -sigmaS <float>              Standard deviation of prior skill belief (default: 400)
        -muD <float>                  Mean of prior draw margin belief (default: 300)
        -sigmaD <float>              Standard deviation of prior draw margin belief (default: 100)
        -beta <float>                 Standard deviation of performance distr. (default: 600)
        -tauS <float>                   Standard deviation of skill dynamics distr. (default: 40)
        -tauD <float>                   Standard deviation of draw margin dynamics distr. (default: 10)
        -server <string>               SQL server name for output (default: 'camresapga01')
        -prefix <string>                Table name prefix for output (default: 'Result')
        -db <string>                     Name of the database for output (default: 'ChessBase')
        -mf                                  Fixed draw margin (default)
        -mf2                                 Fixed draw margin with two factors for draw
        -maf                                 Fixed draw margin with ADF (iterate per year)
        -maf2                              Fixed draw margin with pure ADF
        -mv                                  Variable draw margin
        -as                                   Single run (default)
        -am                                  Model selection

So, a good first test is analysis.exe -no-safe SmallChessBase.csv.

We are very interested to hear your feedback - both on the model, our paper and the F# code.

Update: Following the release of the F# September 2008 CTP we have updated the source code to work with F# 1.9.6.2. Also, we added one of the new features of F#, namely units-of-measure. Note that one can no longer accidentally pass the variance instead of the standard deviation beceause the former being of type float<ELOPoints^2>. We have also added full debug support so simply press F5 to experiment with the -no-safe SmallChessBase.csv option mentioned above.

Update: We removed a reduant schedule creation in the function FixedDrawMarginADFAnalyse. Thanks to Henry (Xinhua) Zhang for pointing out this mistake!

Ralf Herbrich & Thore Graepel

Arkwright Scholar Erroll Wood Visits MSRC

apg — Sat, 01 Mar 2008 23:53:00 GMT

Erroll Wood visited Microsoft Research Cambridge as an Arkwright scholar, and chatted to the Applied Games Group on Monday 11 of February 2008. Before handing in the mike to Erroll, let us link to some of the games he has written:

Tank Patrol: http://www.newgrounds.com/portal/view/298719
Turret Defence: http://www.newgrounds.com/portal/view/329519
Comet Blaster: http://www.newgrounds.com/portal/view/358561
Turret Defence 2: http://www.newgrounds.com/portal/view/393174

Now, here's the story of the Arkwright scholarship in Erroll's own words

In my GCSE year I took a paper and an interview for an Arkwright scholarship – a Design & Technology sponsorship scheme aimed to stimulate young people to raise the profile of the Design & Technology subject. Those who are accepted into the scheme are given £500 over 2 years to spend in the academic field and many more opportunities. Their school also receives £500 over two years to buy equipment. A few months after the interview I was pleasantly surprised to find out I’d secured a place with Microsoft Research Cambridge with its MD Andrew Herbert as my sponsor but I was most pleased to be given the chance to spend a few days in MSRC – a valuable experience.

I found the whole branch very impressive and the people working there really seemed to enjoy what they were doing. I was given a tour round plenty of different projects and it was interesting and exciting to get a peek at what might end up in big profile products in the near future. I also got a few days to work with the Computational Biology team helping them finish off a website though I did spend a lot of time just chatting and getting to know the team which was great.

This is a games blog I understand and I guess one of the reasons MSRC chose to sponsor me was my expressed interest in programming and games. As a hobby and to make some pocket money on the side I design and program games in flash to be played through web browsers. I’ve always enjoyed playing games and it’s a real pleasure to be able to make them as well so others can experience what you’ve created for them. It is a time consuming process however and I wish I was able to make more of them more often, but as it is I can only get them out during holidays when I’ve got more free time it seems.

To recap, thanks to all the guys who made my stay at MSRC so enjoyable and I wish everyone all the best!

Erroll

I very much enjoyed talking to Erroll, and got addicted to Turret Defence 2.

Joaquin Quiñonero Candela

ArmoredBlitz: Rise and Demise

apg — Thu, 21 Feb 2008 07:43:00 GMT

ArmoredBlitz, a first person tank shooter and a real-time strategy game all in one, was selected as one of the five winners of the Silicon Minds contest. Its creator, Jacob Liechty is a freshman at Purdue University studying Computer Science. Jacob also devotes much of his time apart from his studies to video game and graphical programming, spending the month leading up to contest deadline creating ArmoredBlitz and its assets from the ground up using XNA and C#.

I called Jacob to deliver the good news on Sunday, February 3rd. He was very happy, and so was I. Rise. Then I spoke the obligatory words of caution: we needed to check eligibility. Eligibility? Yes, things like making sure that the contestant resides in an eligible country - the US is eligible, so no problem here - and that no close family member works for Microsoft. Panic. You mean, like my brother? What do you mean your brother? My brother, Adam Liechty is a developer at Microsoft! Demise.

Well... you could... fire my brother? Just kidding, I'll try not to stress out :)

-Jacob

Dura lex sed lex. The Law is hard, but (hey) it's the law. There is no way on earth the fact that Adam works for Microsoft could have given Jacob an advantage. Yet, just to make sure there is not the shadow of a doubt, the rules need to be this hard.

So we're putting this blog post together to honour Jacob's efforts, and the fact that it was the Law that killed his game. We are researchers: we loved it and had selected it as a winner.

Joaquin Quiñonero Candela, Microsoft Research Cambridge

Here is a photo of Jacob:

And here are some links:

· Silicon Minds contest: www.dreambuildplay.com

· YouTube video: http://www.youtube.com/watch?v=Io6gBC8lnw4