Rigs of Rods

Rigs of Rods is an open source vehicle simulator licensed under the GNU General Public License version 3. What makes Rigs of Rods different to most simulators is its unique soft-body physics: vehicles, machines, objects, etc. are simulated in real-time as flexible soft-body objects, giving the simulation an extremely accurate behavior which entirely depends on the physical construction of the vehicles or objects you create.

Features

• Soft-body physics. Objects according to their weight distribution, construction, and/or suspension (in the case of vehicles).
• Advanced flight model based on blade element theory. It allows the accurate simulation of any airplane, based entirely on its physical dimensions and wing airfoils, similar to X-Plane.
• Accurate buoyancy model based on elemental pressure gradients, enabling boats with complex hulls to move realistically in the swell.
• Basic support for dual-core processing. More multithreading and CUDA support is planned.
• Basic support for scripting using AngelScript.
• Based on the OGRE Graphics Engine.

What is RoR? (from the Doc/Things you can do in Rigs of Rods.pdf)

Rigs of Rods is a realistic multi-simulator.

Primarily a truck simulator, it can also simulate cars, cranes, airplanes, boats, bridges, and any arbitrary construction.

Vehicles chassis and wheels are simulated in real-time as flexible objects, giving the simulation an extremely accurate behavior, while allowing the vehicles to be simply specified structurally.

Gameplay is emergent and takes place in a virtual 9km² sandbox environment.

Rigs of Rods is a two-year, one man hobby project, still ongoing.

While there's binaries you can get to play with this, it wouldn't be Coding4Fun post if we didn't look at the source behind those binaries.

Compiling Sources under Windows

You can download and compile the Rigs of Rods sources completely with tools that are available for free.

Contents

• 1 Required Software
• 2 Setting up the environment
• 3 Getting the source code from sourceforge
• 4 Using CMake
• 5 Compiling the source code
• 6 Troubleshooting

This page does an outstanding job of walking you through getting the tools, source and getting it to compile. Following along I was able to get it to compile with no problems.

Given the size of this project it will take a number of minutes to compile...

If all you want to do is play and build something, make sure you check out the RoR Book which is a very in-depth guide for creating vehicles;

1. RoRBook/Introduction What is a truck in RoR. What are beams, nodes and stuff. Also, where to look for errors
2. RoRBook/Setup a working environment Requirements for creating trucks: (notepad, setup working environment)
3. Land-based Vehicles and Basics
   1. RoRBook/Basic Truck Requirements - Basic requirements for getting the game to accept a truck.
   2. RoRBook/First beams and nodes - The basics of creating a truck for RoR.
   3. RoRBook/Rigidity
   4. RoRBook/Wheels
   5. RoRBook/Engine
   6. RoRBook/Suspension
   7. RoRBook/Steering
   8. RoRBook/Commands
   9. RoRBook/Hooks
   10. RoRBook/Submeshes
   11. RoRBook/Flares
   12. RoRBook/Props - A tutorial on how to get a basic prop working on your truck/load.
   13. RoRBook/Set_beam_defaults
   14. RoRBook/Cinecam/Cameras
   15. RoRBook/Details (exhausts, custom dashboard, etc)
4. Objects and Texturing
   1. RoRBook/Meshes
      1. RoRBook/Meshes/Tools
      2. RoRBook/Meshes/Basic rules
   2. RoRBook/Materials
   3. RoRBook/Flexbodies - An introduction to flexbodies and how to get them working properly.
5. Aircraft and Winged Vehicles
   1. RoRBook/Simple airplane body construction
   2. RoRBook/Wings
   3. RoRBook/Fusedrag
   4. RoRBook/Airplane engines
      1. RoRBook/Propeller engines
      2. RoRBook/Jetengines
6. Nautical Vehicles and Boats
   1. RoRBook/Simple boat body construction Building a boat with a functional hull
   2. RoRBook/Boat engines
7. Packaging Guides on how to properly package your vehicle for upload to the repository.
8. Sections.

Pirates! for Windows Phone

Table of Contents

• Introduction
• System Requirements
• Farseer Physics Engine
• Adjusting The Game To 60 Frames Per Second
• Converting Images Into Physical Objects
• The Handle Input Loop
• The Update Loop
• The Draw Loop
• Final Considerations
• History

Introduction

Ahoy, Mate! In this article we are presenting a Windows Phone game (or at least the beginning of a game...) and hopefully it's going to be lots of fun in the end. But behind of the fun lies the basic technologies needed to build it. I'll present then in steps, and I hope to capture you interest until the end of the article.

"Pirates!" for Windows Phone is a game build in C# and XNA, using Farseer Physics Engine. The idea of the game is largely inspired on and also pays tribute to Rovio's "Angry Birds" game, which reached 500 million downloads at the end of 2011. Angry Birds may have addicted many people around the world, but from my part, I'm not addicted to the playing itself, but to pursuing the pieces needed to build a game like that.

Instead of birds, a cannon full of cannon balls. Instead of pigs, a big pirate ship full of pirates. Your mission here is to aim the cannon and destroy all pirates. (disclaimer: this story has nothing to do with the ongoing "SOPA" and "PIPA" thing...)

Here comes a short video that to give you a glimpse of what we are talking about here:

One thing thing that stood out for me, though simple, was how the author covered some tweaks to help improve the Farseer frame rate;

Farseer Physics Engine

Farseer is a wonderful open source physics engine, based on the original Box 2D open source project (as an aside, the Angry Birds game uses Box2D). The difference is that Box2D is written in C++ (and has been ported to many languages), while Farseer is made with C# aiming Silverlight and XNA. Also, the Farseer website claims this framework has many other features other than the ones provided by the original Box2D release.

Adjusting The Game To 60 Frames Per Second

In order to achieve the maximum frames per second (around 60 fps) provided by WP Mango in your device, you have to change the Farseer source code you downloaded like this:

1. Double click the "Samples XNA WP7" solution. Choose the "Upgrade Windows Phone Projects..." to upgrade them all to the latest Windows Phone 7.5 Mango.
2. In the constructor of game class, add this event handler:
3. ...

The article continues from there, through each major area;

Converting Images Into Physical Objects

All dynamic objects in the game are created from the texture images. This is a very nice feature of Farseer engine that makes our life much easier. The farseer built-in functions create a solid object from our labyrinth plain image, provided that we leave the empty spaces with the transparent color, like this:

...

The Handle Input Loop

The Handle Input Loop is exposed by Farseer Engine and gives us the opportunity to detect and handle the users gestures.

This method is responsible for:

• Detecting the left ThumbStick movement and translating it into cannon movements.
• Detecting the "A" right button and shooting the cannon.
• ...

  The Update Loop

  In XNA framework, the Update Loop is invoked when the game has determined that game logic needs to be processed. This might include the management of the game state, the processing of user input, or the updating of simulation data. By overriding this method, we can add logic which is specific to our Pirates game.

  In XNA, The Update method works in combination with the Draw method, and you must take into account that each one has its own specific role. That is, never try to draw sprites inside the Update method, and never ever calculate/update positions inside the Draw method.

  The purpose of the Update class here is:

  • To calculate the new cloud positions. There are 3 layers of clouds and each layer moves at its own speed.
  • To alternate the sea appearance between one of the 4 existing sea textures.
  • To move the camera according to the game state transitions (that is, at first the game is showing you the pirate ship, then the camera moves to your ship).
  • To update the camera position along the path described by the cannon ball. This is useful to keep track of the game action.
  • To control the camera zoom when needed.
  • And maybe the most important of all: to update the cannon ball position (along with the smoke trace left while flying)
  • ...

    The Draw Loop

    The Draw loop is called by the XNA framework it is time to draw a frame. We override this method to draw all the frames needed for our Pirates game.

    This loop handles entirely the presentation part of the game:

    • It draws the background texture
    • It draws the sky, clouds, sea and ships
    • It draws the cannon ball, the cannon and the smoke traces
    • It draws the pirates and other objects on the scene.
    • It draws the score and high scores.
    • ...

Let's take a peek at the Solution (which ran and deployed to the emulator the first time for me with no problems);

The game project/code is easily approachable with most of the code in one place, PirateDemo.cs.

This isn't a complete game at this point, but it's a great starting point and even in this state fun to play with and best of all, covers a number of important things, such as the physics engine, game state management, etc.

If you're thinking about creating your own like game, this might be a great article and code to start your journey with...

It's been WAY too long since we've had Brian Beckman sharing knowledge, insights and perspectives on Channel 9. This changes now!

Needless to say, I was incredibly happy to spend an hour with Brian learning all about what he's up to these days. Not surprisingly, he's writing code and employing Rx and monads to solve very interesting problems. In this conversation (a code lesson, algorithm survey, a splash of random topical diversion), Brian explains and demonstrates his latest endeavor: implementing the Viterbi algorithm in C#. What's the Viterbi algorithm, Brian? What are hidden Markov models? What are you using this stuff for? Where does Rx fit into this? What's going on? By the way, it's awesome to learn that a Niner has been sharing C# monadic implementations with Brian (state monad, maybe monad).

Of course, no conversation with Brian - a physicist by training and a software architect at Microsoft - is complete without talking about some current physics problem: Finding the elusive Higgs Boson is all the rage these days, so we talk about what it means.

Brian also shares insights on Haskell, functional and hybrid programming languages (C# is imperative, but it provides functional capabilities like LINQ, for example, upon which Rx is built (Rx is LINQ-to-Streams or observable sequences of events, really)...). We also finally discuss his previous work at MS that we never got a chance to talk to him about while he was doing it. Before joining the Bing Mobile team, Brian was working on a project to create a new functional programming language. What was it?

Thank you, Brian!

Happy holidays from Channel 9 wherever you are and whatever, if anything, you're celebrating!


Notes and More:

The code Brian demos (download it, unzip it, launch VS, open the solution, then watch this video and play along): https://github.com/rebcabin/DotNetExtensionsImproved

From Wikipedia - information on Markov and Viterbi:

A hidden Markov model (HMM) is a statistical Markov model in which the system being modeled is assumed to be a Markov process with unobserved (hidden) states

The Viterbi algorithm is a dynamic programming algorithm for finding the most likely sequence of hidden states – called the Viterbi path – that results in a sequence of observed events, especially in the context of Markov information sources, and more generally, hidden Markov models.

His keynote was titled "Temporally Quaquaversal Virtual Nanomachine Programming In Multiple Topologically Connected Quantum-Relativistic Parallel Timespaces...Made Easy!" You'll be able to watch this as soon as the YOW! session videos are released to the web.

Here we learn what Damian wanted to achieve with his excellent and creative technical keynote. We also get Damian's thoughts on the state of modern development and how developers can maximize their capabilities (learn and use multiple languages—it's one of the best things you can do). And more. Thanks for taking the time to chat, Damian. I look forward to seeing your next talk!

Tune in. Enjoy.

 Damian's YOW! speaker page

The YOW! Developer Conference offers outstanding opportunities to learn more about the latest practices, technologies, and methodologies for building innovative software solutions as well as the chance to meet and network with international software experts and other talented developers in Australia. Thanks to Dave Thomas and the event's excellent staff - Mary Catherine (MC), Lisa, Aino, Melissa, and others - for inviting me to this excellent pure developer event and thanks to all of the speakers for letting me take some of their time to record conversations for Channel 9. If you live in Australia, or aren't too far away, or just like to travel (who doesn't?), then you need to go to this yearly event. It's outstanding. There are many great developers down under. That's for sure. The speakers are exceptional—Dave and team set a high bar!

Timecodes by George (thank you!):

[00:24] the reason behind Damian's talk

[02:15] comments on the positronic variable and multiverses simulation in Perl

[03:15] bad habits & 2 diff types of programmers

[06:50] language specialization issue

[08:50] analogy with natural languages

[10:45] current state of PERL

[14:00] question on the push towards the "The general purpose language"

[16:20] programming languages design tradeoffs

[17:20] comments about Damian's keynote address and developers feedback to it

[18:50] programming == manipulating reality with language == kind of same what physicists do

[21:10] math as a language and analogy as a means for communicating it

Structural models and data filtering algorithms can also find application at a biological level, assisting us in better understanding our own selves, as well as the diseases which often impact us.
To this end, David Heckerman, Distinguished Scientist in the eScience group, is one person at Microsoft working to find new ways to apply advanced technological algorithms to our own biology.

David began his education with the intent of becoming a physicist, but his interests eventually led him into the medical sciences. While working on his MD at Stanford, he began looking at the problems of Artificial Intelligence. For his PhD work, he submitted an impressive construct he called the “probabilistic expert system." In fact, it was so impressive that in 1992 Microsoft hired him to build such systems for non-medical applications.

David's work at Microsoft began to lead him further and further from his original medical focus. One of his pioneering areas of study was for graphical models known as Bayesian networks, and it was while working on these models that he recognized how they could be applied to medicine and biology. Today, his efforts have allowed him to return to his medical education roots, and he is working both to design such things as a vaccine for HIV and search for genetic causes of disease.

To find out more and a full tutorial, visit Coding4Fun's article:
http://blogs.msdn.com/b/coding4fun/archive/2010/06/15/10025512.aspx

To find out more and a full tutorial, visit Coding4Fun's article:
http://blogs.msdn.com/b/coding4fun/archive/2010/06/15/10025512.aspx

To find out more and a full tutorial, visit Coding4Fun's article:
http://blogs.msdn.com/b/coding4fun/archive/2010/06/15/10025512.aspx

To find out more and a full tutorial, visit Coding4Fun's article:
http://blogs.msdn.com/b/coding4fun/archive/2010/06/15/10025512.aspx

To find out more and a full tutorial, visit Coding4Fun's article:
http://blogs.msdn.com/b/coding4fun/archive/2010/06/15/10025512.aspx

To find out more and a full tutorial, visit Coding4Fun's article:
http://blogs.msdn.com/b/coding4fun/archive/2010/06/15/10025512.aspx

Multi-Targeting

Windows Phone 7 uses a version of Silverlight 3 with a few bonus features. Because this version of Silverlight is so close to the Web version of Silverlight 3, we'll take the approach of Multitargeting a solution for both platforms. To do so, start with a Silverlight 3 (web) application template, and then add in a Windows Phone project with linked files that re-use the Silverlight 3 solution. This allows us to deploy to many different platforms using the same code base.

Let's get started by creating our Solution in this way.

Creating the Solution and MainPage

1. In Expression Blend 4, create a new Silverlight Application + Website template named Shuffleboard. Be sure to select “3.0” from the Version dropdown, as this is what is supported by Windows Phone (in a little bit we'll add in the Windows Phone project template as well).
   
2. In the Objects and Timeline Panel, select the main UserControl and set its Width to 480 and its Height to 800. This is the size of a Windows Phone UI in Portrait mode.
3. Select the LayoutRoot Grid and set its Width to 480 and its Height to 800.
4. For games, a Canvas layout container is better than a Grid, so let's change the LayoutRoot container type. Right-click LayoutRoot and select Change Layout Type/Canvas.
   
5. Since some parts of our UI can appear outside of the game area, we want to add a Clip to this main canvas so that the user does not see these outside elements. Add the following just under the LayoutRoot Canvas:
   This XAML is snippet “MainPage Clip” inside snippets.txt.

   <Canvas.Clip>
       <RectangleGeometry Rect="0,0,480,800"/>
   </Canvas.Clip>

6. We'll be using some pre-built Behaviors that make it easy to introduce physics into Silverlight using the Farseer Physics Library. Right-click the Silverlight project and select Add Reference. Select the following assemblies, located in the sample download:
   
   \ShuffleBoard\Bin\Debug\FarseerPhysics.dll
   \ShuffleBoard\Bin\Debug\Spritehand.FarseerHelper.dll
   \ShuffleBoard\Bin\Debug\Spritehand.PhysicsBehaviors.dll
   
   NOTE: To learn more about the Physics Helper Library, visit http://physicshelper.codeplex.com

Creating the Game User Control

Next we'll create a separate user control that will contain the core game logic. By creating a separate user control, we can easily target different platforms by placing the user control inside different MainPage elements.

1. Right-click the Shuffleboard Silverlight project and select Add New Item. Select UserControl and name the control “ucMainGame”.
   
2. Change the LayoutRoot element from a Grid to a Canvas.
3. Set the Width to 480 and the Height to 800 for both the UserControl and LayoutRoot Canvas elements.
4. Set the Background color to Black for the LayoutRoot Canvas.
5. Build the project by pressing Ctrl+Shift+B.
6. Back on MainPage, add an instance of ucMainGame to the page by going to the Assets Panel and expanding Controls/All. Drag an instance of ucMainGame to the artboard.
   
7. Rename the ucMainGame control to ucMainGame1.
8. Set the Left and Top properties of ucMainGame1 to 0.

Creating the Table

We'll use a pre-rendered PNG image for the shuffleboard table.

1. Create a new subfolder in the Silverlight project named “images”.
2. Add the following JPG image into the new images subfolder, located in the sample download:
   \ShuffleBoard\images\shuffleboardTable.jpg
3. Open the ucMainGame user control.
4. Insert a new Canvas element named cnvTable, and set the following attributes:
   1. Width = 480
   2. Height = 800
   3. Left = 0
   4. Top = 0
5. In the Assets Panel, expand the Behaviors category and drag a PhysicsControllerBehavior on the cnvTable. This behavior introduces the core physics simulation into the game. Set the properties of the Physics Contoller as follows (this turns of gravity and sets some other physics parms):
   
6. Inside the cnvTable Canvas, add a second Canvas named cnvTableInner, which will hold the table image. Set the following properties on cnvTableInner:
   1. Width = 360
   2. Height = 1077
   3. Left = 60
   4. Top = -277
7. Drag the shuffleboardTable.jpg image from the Projects Panel into cnvTableInner. Set the following properties on the image:
   1. Width = 360
   2. Height = 1077
   3. Left = 0
   4. Top = 0
8. The Objects and Timeline Panel should look like so:
   
9. We will need to detect when a puck hits the edge of the table and “falls off.” Let's add in some Rectangle elements and add Physics Behaviors to them.
10. Add a new Rectangle named rectSensorLeft and size it so that it covers the entire left side of the table. Set the following properties:
    1. Width = 60
    2. Height = 1190
    3. Left = -40
    4. Top = -334
    5. Opacity = 20%
11. Drag a PhysicsObjectBehavior from the Assets Panel Behaviors onto rectSensorLeft, and then set its IsStatic property to true.
12. Add three more Rectangles by copying rectSensorLeft, so that they surround the borders of the table:
    1. rectSensorRight
    2. rectSensorTop
    3. rectSensorBottom
13. Your artboard should look similar to the following:
    
14. Now we'll add in the goal Rectangles at the end of the table. These will be used to determine the number of points a puck receives. Draw out three Rectangles that cover the width of the board and are 100 pixels high. Name these rectPoints3, rectPoints2, and rectPoints1. Set their Stroke to Red and their Fill to No brush.
15. Add a TextBlock element inside each Rectangle to depict the points. Set the text properties to 3, 2, and 1 so that the artboard looks similar to the following:
    
16. We'll also need a Rectangle representing the “slide zone” where players can legally slide a puck (we don't want to allow sliding all of the way down the table!). Add a Rectangle named rectInBounds and position it at the lower end of the table:
    1. Width=360
    2. Height=292
    3. Left = 60
    4. Top = 508
    5. Fill = No Brush
    6. Stroke = Red

Adding the Pucks

For the pucks, we are going to add in an existing control which has the artwork completed.

1. Right-click the project and select Add Existing Item.
2. Browse to the following two files in the sample code download:
   \ShuffleBoard\ucPuck.xaml
   \ShuffleBoard\ucPuck.xaml.cs
3. Open ucPuck.xaml on the artboard and notice the following in the Objects and Timeline Panel:
   
   1. There is a Canvas named Puck that has a PhysicsObjectBehavior applied to it. This allows each instance of this Canvas to behave like a Physics Object so it animates with velocity and force and participates in collisions. Note that this Behavior has a large MomentOfInertia value. This keeps the object from rotating due to torque and collisions. Also note the RestitutionCoefficient, which gives the object some “bounce.”
      
   2. There is a “cnvInner” Canvas that defines the look of the Puck.
   3. There is a StoryBoard defined, sbLostPuck, which we will execute when the puck “falls off the edge” of the table.
   4. Open the code-behind file, ucPuck.xaml.cs, and note the get / set property for the color of the puck. This will allow us to create both Red and Blue pucks for each player.
4. Build the project by hitting Ctrl+Shift+F5 and go back to ucMainGame.
5. From the Assets Panel, expand Controls/All and find the ucPuck control. Drag an instance of this onto the artboard. Name this bluePuck1.
6. Copy and paste bluePuck1 twice so that you have three blue pucks. Name the new pucks bluePuck2 and bluePuck3.
7. Copy and paste a fourth puck and name it redPuck1. In the Properties Panel, go to the Miscellaneous Category and change the ColorHighlight and ColorMain properties to a Red color:
   
8. Copy and Paste redPuck1 two times and rename these new pucks redPuck2 and redPuck3.
9. Let's test our table. Find the PhysicsControllerBehavior just under the cnvTable Canvas in the Objects and Timeline Panel and set the MousePickEnabled property to true.
10. Run the project by clicking F5. Try dragging some pucks around with the mouse.

Adding the Scoreboard

We need a way of tracking players' scores, so let's add in a simple scoreboard for Blue vs. Red.

1. Right-click the project and select Add Existing Item.
2. Browse to the following two files in the download:
   \ShuffleBoard\ShuffleBoard\ucScoreBoard.xaml
   \ShuffleBoard\ShuffleBoard\ucScoreBoard.xaml.cs
3. Open ucScoreBoard and notice the following:
   1. It has a TextBlock for Red scores and a TextBlock for Blue scores.
   2. In the code-behind, there are setters and getters to set the score.
4. Build the project by selecting Ctrl+Shift+B.
5. Switch back to ucMainGame.
6. Drag an instance of ucScoreBoard from the Assets Panel onto into LayoutRoot.
7. Name the element ucScoreBoard1, and position it at the top left of the Canvas like so:

Adding a Player Up Display

We'll need a simple control that displays which player's turn it is.

1. Right-click the Silverlight project and select Add/Existing Item.
2. Browse to and select the following two files in the sample folder:
   \ShuffleBoard\ucPlayerUp.xaml
   \ShuffleBoard\ucPlayerUp.xaml.cs
3. Note the following about ucPlayerUp:
   1. The code-behind file has a simple property, IsBlueTurn, which shows the appropriate message in the UI.
4. Build the project by clicking Ctrl+Shift+B
5. Back on ucMainGame, drag an instance of ucPlayerUp into cnvTableInner.
6. Name the control ucPlayerUp1 , and set the following properties:
   

Adding a 3D Look

Let's give our table a bit of a 3D look by adding a Perspective transform so the table appears to go off into the distance.

1. Create a new StoryBoard named sbRotateTable.
   
2. Select the cnvTable Canvas element.
3. Advance the timeline ahead one second.
4. In the Properties Panel, under Projection, set the X value to -40.
   
5. Your artboard should now look something like this:
   
6. Close the Storyboard to end recording.
   
7. We want to rotate the table after the PhysicsController is initialized so the Physics Helper can determine the boundaries of the physics objects properly. Start by adding in some Using statements at the top of ucMainGame.xaml.cs:
   This code is snippet “ucMainGame Imports” inside snippets.txt.

   using System.Collections.Generic;
   using Spritehand.FarseerHelper;
   using FarseerGames.FarseerPhysics.Mathematics;
   using System.ComponentModel;

8. Next, let's add in some class-level declarations, which will store the physics controller, list of pucks, and some variables used to track shooting and scoring:
   This code is snippet “ucMainGame Declarations” inside snippets.txt.

   PhysicsControllerMain _physicsController;
   List<PhysicsSprite> _pucks = new List<PhysicsSprite>();
   List<PhysicsSprite> _redPucks = new List<PhysicsSprite>();
   Point _ptStartShot;
   bool _draggingPuck;
   int _draggingStartTick;
   
   int _currentPuckToShoot = 0;
   int _currentPuckShot = -1;
   int _gameOverScore = 15;

9. In the ucMainGame() constructor, add some code to set the MaxFrameRate to 30 (Windows Phone will be limited to 30 FPS) and wire up the Loaded event handler.
   This code is snippet “ucMainGame Constructor” inside snippets.txt.

   this.Loaded += new RoutedEventHandler(ucMainGame_Loaded);
   Application.Current.Host.Settings.MaxFrameRate = 30;

10. Implement the ucMainGame_Loaded event handler, which gets a reference to the Physics Controller and wires up our event handlers.
    This code is snippet “ucMainGame Loaded” inside snippets.txt.

    void ucMainGame_Loaded(object sender, RoutedEventArgs e)
    {
        if (DesignerProperties.GetIsInDesignMode(this))
            return;
    
        _physicsController = 
            cnvTable.GetValue(
                PhysicsControllerMain.PhysicsControllerProperty
            ) as PhysicsControllerMain;
        _physicsController.Initialized += _physicsController_Initialized;
        _physicsController.Collision += _physicsController_Collision;
        _physicsController.TimerLoop += _physicsController_TimerLoop;
    }

11. Next, we'll add in the event handlers that we just wired up in the loaded event. Note that the Initialized event starts the Rotate Table StoryBoard.
    This code is “ucMainGame Event Handlers” inside snippets.txt.

    void _physicsController_Initialized(object source)
    {
        sbRotateTable.Begin();
    }
    
    void _physicsController_Collision(string sprite1, string sprite2)
    { }
    
    void _physicsController_TimerLoop(object source)
    { }

12. Run the Project by clicking F5. Note the 3D look and try manipulating the pucks with the mouse.

Controlling the Pucks

Next, we'll add logic to control the player's turn and control and along with score. Note that, when we implement the Windows Phone version in a bit, we can take advantage of Multitouch Manipulation events. But since these events are not available in the Web version of Silverlight 3, we'll use a simple mouse input mechanism.

1. Let's turn off the default mouse manipulation. Select the PhysicsControllerBehavior just under the cnvTable Canvas and set the MousePickEnabled property to false.
2. We need to get references to our Pucks, which the Physics Helper has translated into PhysicsSprite objects. A Physics Sprite contains the XAML UI for the Physics Object, plus the Physics Engine attributes for the underlying physics objects–including boundary shape, mass, velocity, etc.
   This code is “ucMainGame Initialized” inside snippets.txt.
3. Now we need to handle the Mouse events on the pucks in order to control the player's shot. When the player clicks the mouse down on a puck, we track the position along with time that they clicked. When the player moves the mouse, we update the puck position and also check if the player paused or moved backwards. We do this in case the player is just adjusting the puck position and not yet sliding the puck for a shot. Finally, in the Mouse up event, we release the puck in the specified direction and apply an appropriate amount of force to it.  Copy in the snippet “Puck Mouse Control” from snippets.txt.  Code is not shown here for brevity.
4. When the Physics Helper Library does its magic, it translates existing UI Elements into PhysicsSprite objects. So what if we want to get at the original controls, perhaps to execute a StoryBoard that we defined on them? We can do this by using the FindName method to get the original user control instance. So, add the code below, which we'll use to get a reference to the Puck Storyboard “sbLostPuck”.

   ucPuck GetPuckControl(string spriteName)
   {
       ucPuck puck;
       var parent = PhysicsControllerMain.ParentCanvas;
       switch (spriteName)
       {
           case "Puck":
               puck = parent.FindName("bluePuck1") 
                       as ucPuck;
               break;
           case "Puck_1":
               puck = parent.FindName("bluePuck2") 
                       as ucPuck;
               break;
           case "Puck_2":
               puck = parent.FindName("bluePuck3") 
                       as ucPuck;
               break;
           case "Puck_3":
               puck = parent.FindName("redPuck1") 
                       as ucPuck;
               break;
           case "Puck_4":
               puck = parent.FindName("redPuck2") 
                       as ucPuck;
               break;
           default:
               puck = parent.FindName("redPuck3") 
                       as ucPuck;
               break;
       }
   
       return puck;
   }

5. Finally, to score, we'll determine if the puck lies between any of the Rectangles in the end zone.
   This code is the snippet “Get Points for Puck” in snippets.txt.

   int GetPointsForPuck(PhysicsSprite puck)
   {
       int score = 0;
       Vector2 puckPos = puck.BodyObject.Position;
   
       double left = Convert.ToDouble(
           rectPoints3.GetValue(Canvas.LeftProperty));
       double top = Convert.ToDouble(
           rectPoints3.GetValue(Canvas.TopProperty));
   
       if ((puckPos.X > left && puckPos.X < left + rectPoints3.Width) 
        && (puckPos.Y > top && puckPos.Y < top + rectPoints3.Height))
           score = 3;
   
       left = Convert.ToDouble(rectPoints2.GetValue(Canvas.LeftProperty));
       top = Convert.ToDouble(rectPoints2.GetValue(Canvas.TopProperty));
       if ((puckPos.X > left && puckPos.X < left + rectPoints2.Width) 
        && (puckPos.Y > top && puckPos.Y < top + rectPoints2.Height))
           score = 2;
   
       left = Convert.ToDouble(rectPoints1.GetValue(Canvas.LeftProperty));
       top = Convert.ToDouble(rectPoints1.GetValue(Canvas.TopProperty));
       if ((puckPos.X > left && puckPos.X < left + rectPoints1.Width) 
        && (puckPos.Y > top && puckPos.Y < top + rectPoints1.Height))
           score = 1;
   
       return score;
   }

Implement the “Game Loop”

Most games are controlled by a “Game Loop” that executes many times per second. Within this Game Loop, we can check for collisions, perform enemy AI, and scoring. The PhysicsController fires an event called “TimerLoop” that we can use for this purpose.

1. Replace the existing TimerLoop and Collision events with the following code snippet, which checks to see if any pucks have been shot and if we are ready for the next shot. Do this by seeing if the puck velocity has slowed down to nearly a stop…
   This code is snippet “Timer Loop” inside snippets.txt.

   void _physicsController_TimerLoop(object source)
   {
       // check to see if the current shot is completed
       if (_currentPuckShot >= 0)
       {
       var puck = _pucks[_currentPuckShot].BodyObject;
   
           if (puck.Enabled == false ||
             Math.Abs(puck.LinearVelocity.X) < 3                                   
             && 
             Math.Abs(puck.LinearVelocity.Y) < 3)
           {
               // did the shot clear the end zone?
               if (!PointWithinBounds(
                 new Point(puck.Position.X, 
                          puck.Position.Y)))
               {
                   _currentPuckShot = -1;
                   _currentPuckToShoot++;
                   SetupThePuck();
               }
           }
       }
   }
   
   void _physicsController_Collision(string sprite1, string sprite2)
   {
       // check for puck off sides
       if (sprite1.StartsWith("rectSensor") && sprite2.StartsWith("Puck"))
       {
           ucPuck puck = GetPuckControl(sprite2);
   
           _physicsController.PhysicsObjects[sprite2].
               BodyObject.Enabled = false;
   
           puck.sbLostPuck.Begin();
       }
   }

Targeting Windows Phone

So far, we've created a Silverlight 3, web-based version of a shuffleboard game. Next we'll quickly port this to Windows Phone, taking advantage of some of the platform's capabilities, such as multitouch. We'll do this by using linked files that point back to our existing Silverlight 3 project.

1. Right-click the Silverlight solution in Blend and select Add New Project.
2. Select Windows Phone Application and enter ShuffleBoard.WindowsPhone for the name.
   
3. Delete the TitleGrid and ContentGrid elements from the Objects and Timeline Panel.
4. Convert LayoutRoot to a Canvas by right-clicking it and selecting Change Layout Type/Canvas.
5. Right-click the project and select Add Reference. Browse to the following assemblies located in the sample download (these are the WindowsPhone versions of the Physics Helper and Farseer):
   
   \ShuffleBoard.WindowsPhone\Bin\Debug\FarseerPhysics.dll
   \ShuffleBoard.WindowsPhone\Bin\Debug\Spritehand.FarseerHelper.dll
   \ShuffleBoard.WindowsPhone\Bin\Debug\Spritehand.PhysicsBehaviors.dll
   
6. We need references to the assemblies used for Behaviors. An easy way to do this is to add a Behavior to an element and then delete it. From the Assets panel, drag a PhysicsControllerBehavior onto LayoutRoot and then delete it. Note that this adds a reference to System.Windows.Interactivity to the project.
7. Next, we'll add in the linked files from the existing Silverlight 3 project. Right-click the ShuffleBoard.WindowsPhone project and select Add/Link to Existing Item. Select the following files:
   1. ucMainGame.xaml
   2. ucMainGame.xaml.cs
   3. ucPlayerUp.xaml
   4. ucPlayerUp.xaml.cs
   5. ucPuck.xaml
   6. ucPuck.xaml.cs
   7. ucScoreBoard.xaml
   8. ucScoreBoard.xaml.cs
8. 8. Add a new folder to the project named images.
9. 9. Right-click the images folder and select Link to Existing item, then navigate to the following image in the sample folder:
   \ShuffleBoard\images\shuffleboardTable.jpg
   
10. Build the project by clicking Ctrl+Shift+B.
11. From the Assets Panel, under Controls/All, find ucMainGame and drag an instance onto LayoutRoot. Set the Left and Top properties to 0.
12. Right-click the WindowsPhone project and select “Startup” to set this as the startup project.
13. Run the project by clicking F5.

Windows Phone Touch Input

So far, we've used a simple mouse-event-based input mechanism for shooting the pucks. But on the Windows Phone 7 platform, we can do better than that by using Multitouch events. These events include an inertia property that will make our puck physics more realistic.

1. Since we are going to need to support two different platforms now (Web and Windows Phone), we need to introduce a Conditional Compilation Symbol so that the compiler can differentiate between each platform's code.
2. Open the solution inside Visual Studio by right-clicking it in the Projects Panel and then select “Edit in Visual Studio”
   
3. Right-click the ShuffleBoard.WindowsPhone Project and select Properties.
4. 4. Add in a new compilation symbol for WINDOWS_PHONE.
   NOTE: Future releases of WP7 Tools will likely define a default compilation symbol, so you may already see one defined here.
   
5. Now we'll add in the Windows Phone-specific events for manipulation using touch. Open ucMainGame.xaml.cs and find the _physicsController_Initialized event handler. Replace the events for the mouse events with the following, which will wire up either the manipulation events (for Windows Phone) or the mouse events (for Silverlight Web):
   This code is snippet “Manipulation Events” inside snippets.txt.

   #if WINDOWS_PHONE
       puck.ManipulationStarted += 
         new EventHandler<ManipulationStartedEventArgs>
         (puck_ManipulationStarted);
       puck.ManipulationCompleted += 
         new EventHandler<ManipulationCompletedEventArgs>
         (puck_ManipulationCompleted);
       puck.ManipulationDelta += 
         new EventHandler<ManipulationDeltaEventArgs>
         (puck_ManipulationDelta);
   #else
       puck.MouseLeftButtonDown += 
         new MouseButtonEventHandler(puck_MouseLeftButtonDown);
       puck.MouseMove += 
         new MouseEventHandler(puck_MouseMove);
       puck.MouseLeftButtonUp += 
         new MouseButtonEventHandler(puck_MouseLeftButtonUp);
   #endif

6. Now we just need to implement those event handlers for manipulation. The main consideration here is that the ManipulationCompleted event passes in a FinalVelocity.LinearVelocity parameter, which we can use to create realistic physics from the user's shot:

   Add the code snippet “Manipulation Event Handlers” from snippets.txt

   Vector2 force = new Vector2(
       (float)(e.FinalVelocities.LinearVelocity.X * scalePower), 
       (float)(e.FinalVelocities.LinearVelocity.Y * scalePower));

7. Run the project by clicking F5, and try sliding some pucks.

Performance

Depending on your configuration, you may experience poor performance for the shuffleboard game when running it in the Windows Phone emulator. There are different reasons for this, including video card drivers and virtualization settings. Please refer to this blog post, which details these performance considerations.

1. 1. Inside the ucMainGame constructor, let's turn on the Frame Rate counter so we can see our current frame rate. This code is snippet “Frame Rate Counter” inside snippets.txt

   Application.Current.Host.Settings.EnableFrameRateCounter = true;

2. Run the project by hitting F5, and note the current frame rate.
   NOTE: Your development configuration may prevent you from having an adequate framerate in the Windows Phone Emulator! Please refer to this blog post for tips on emulator performance.

One performance tweak we can easily make is taking advantage of hardware acceleration. Silverlight enables us to use the video card to render elements, which can greatly increase performance. To do this, we add a Cachemode=”BitmapCache” attribute to any elements we want to hardware accelerate.

1. Open ucPuck.xaml and note that there is a CacheMode attribute on the Puck Canvas.
2. Open ucMainGame.xaml and add a CacheMode attribute to the cnvTable Canvas element.

   <Canvas x:Name="cnvTable" Width="480" Height="800" 
   d:LayoutOverrides="Width, Height" CacheMode="BitmapCache">

3. Run the project and note the frame rate change.

Adding Sound

Sound is one area where Windows Phone and Web Silverlight differ a bit. Under Silverlight for Web, we can use the MediaElement class to play back WMA and MP3 format audio. Multiple instances of the MediaElement class can be played simultaneously, and the sound output will be automatically mixed.

However, on Windows Phone we have access to the XNA game libraries, including sound support. This is a much more efficient way to add mixed sound to a Silverlight game on Windows Phone, but it only supports WAV format sound files.

The Physics Helper Library has a useful class wrapper for sounds, which we'll use to play a “hit puck” sound on both platforms.

1. In the ShuffleBoard (Silverlight Web) project, right-click and select Add Folder.
2. Name the folder sounds.
3. Add an existing item to the sounds folder from this location:
   \ShuffleBoard\ShuffleBoard\sounds\hitPuck.wma
4. Set the Build Action of the file to Content.
5. In the ShuffleBoard.WindowsPhone project, right-click and select Add Folder.
6. Name the folder sounds.
7. Add an existing item to the sounds folder from this location:
   \ShuffleBoard.WindowsPhone\sounds\hitPuck.wav
8. Set the Build Action of the file to Content.
9. Inside ucMainGame.xaml.cs, add a class-level declaration for a SoundMain class (this is defined in the Physics Helper Library):
   This snippet is “Declare the Sound” inside snippets.txt.

   SoundMain _soundPuckHit;

10. 10. Inside the ucMainGame_Loaded event, add code to declare the two sounds. Note that Windows Phone uses a WAV format sound without a “/” prefix for the root.
    This snippet is “Declare the Sound” inside snippets.txt.

    #if WINDOWS_PHONE
        _soundPuckHit = new SoundMain(this.LayoutRoot,
                       "sounds/hitPuck.wav", 2, 0);
    #else
        _soundPuckHit = new SoundMain(this.LayoutRoot, 
                       "/sounds/hitPuck.wma", 2, 0);
    #endif

11. Inside the _physicscontroller_collision event, add code to play the sound if a puck-to-puck collision occurs and the velocity is > 10:
    This snippet is “Play the Sound” inside snippets.txt.

    // check for puck to puck collsion
    if (sprite1.StartsWith("Puck") && sprite2.StartsWith("Puck"))
    {
        PhysicsSprite sprite = _physicsController.PhysicsObjects[sprite1];
    
        if (Math.Abs(sprite.BodyObject.LinearVelocity.X) > 10
            || Math.Abs(sprite.BodyObject.LinearVelocity.Y) > 10)
        {
            _soundPuckHit.Play();
        }
    }

12. Run the project and try hitting pucks together.

Summary

Since the 1.1 Alpha release, Silverlight has offered a compelling casual game development environment. With the addition of Windows Phone, along with demos of Silverlight running on other embedded devices, you can bet the future of Silverlight for gaming is bright.

Here are a few resources for more information:

Andy's blog
http://www.andybeaulieu.com

Andy's Silverlight Demos
http://www.spritehand.com

The Physics Helper Library
http://physicshelper.codeplex.com

Great free resource for learning Expression Blend and Silverlight
http://www.microsoft.com/design/toolbox/