Now available on the Windows Phone marketplace, Udder Chaos!

“Protect your cows from Alien hordes as they try to abduct your precious livestock. Alien hordes too hard? Upgrade your weapons and gain smart bombs to blow them out of the sky.

Includes global leaderboards, endless mode, easier kid-mode, and option to remove ads.”

The trial is completely fully featured and ad-supported … and if you purchase the game, all ads are removed.

If you’ve got an XBox 360, you can also download Udder Chaos on the XBox Live Indie Games channel!

http://forums.create.msdn.com/forums/t/80247.aspx

If you’ve got an AppHub account, please take a moment and give us a review.

AppHub members can download the game for play test here, and give us feedback on the game’s forum thread here.

I came onto this project rather recently, the game was mostly done.  So I’ve been working for the last few weeks on the leaderboards implementation and other polish tasks and bugs along with a great team: Vic, Dave, Pablo, and Taylor (not to mention the other guys on the credits that worked on the game before I got involved).

One interesting part of this project has been the cross platform development. It’s a topic that I’d like to go into more detail another day, but the game builds and runs simultaneously on windows, xbox, and windows phone. There are some definite challenges to this kind of development, especially when you have to consider different input mechanisms and screen/menu layouts on the different platforms. It’s been a great experience so far, and it’s fueling some thoughts about how to structure code to facilitate cross-platform dev.

We plan on getting the windows phone build out after the xbox version ships. Can’t wait to see the feedback we get in playtest, and hopefully we’ll ship it soon.

It was quite amusing to listen to the organizers talk about attendee behavior because it reminded me very much of the experiences I had running the Orlando .NET user group. I guess people don’t really change, regardless of geographic location

Even though I’ve been living and breathing XNA for the last few years … I was reminded last night of how alien a concept game development is to many very competent developers. The concepts which seemed to need the most explaining were the mathematical aspects, and state management.

>In a world of pre-packaged controls, and silverlight behaviors for animation, it seemed that a lot of people had trouble grasping the concept of storing the state, which occurs separately from update, which occurs separately from the drawing. So I started thinking about how one might explain these concepts to your average day to day business application or systems developer.

MVC!

Yep, I said it … I think Model View Controller is a valid analogy that can be used to explain the way a real time game application works. Think about it:

• Model: In XNA demos, the “model” data usually goes into private class level fields of the Game class. This data is usually textures, 3d models, effects, audio, and position data (Matrices, Vectors). The next step that most game developers take is to abstract all that stuff out into sprite, actor, or entity classes.
• Controller: The Update method acts as the controller. It takes user input, or in-game “events” such as collision and facilitates the calculation of the new state based on that information. This is classic “controller” responsibility.
• View: The Draw method is clearly a “view” upon the current state of the model. In a well factored game, there are no calculations in the view. If you’re drawing 2d, you iterate over your models, request their texture and position information, and draw it with the SpriteBatch. If 3d, iterate over the models (in the MVC sense), ask them for their Models and draw that.

Although the exact expression of “MVC” is not often used in the games industry, in the strictest sense, it is still a variation on the pattern. The concept could be very helpful to speakers and trainers who are teaching XNA to the uninitiated. If they can get the crowd over that initial impedance mismatch, then they can move on to more advanced topics faster, which would surely please the group.

In a naive implementation of handling touch input, you could just take the touch point as fact, and the entity would snap directly over to the user’s finger in the scenario described above. This may be visually jarring, which of course may be ok for your game. However, if you want your entity to have more of a realistic presence in the game world, to feel more “real”, the you probably don’t want it teleporting around the screen; At the same time, you want the user’s input not to feel laggy or non-responsive.

So how do we handle this fundamental difference in user input techniques?

The problem of incomplete or inconsistent input reminded me of the network prediction sample, which is available on the XNA Creator’s Club site (http://creators.xna.com/en-US/sample/networkprediction). In that sample, they present two solutions to deal with the issues brought on by network latency. Particularly, I was interested in their smoothing solution because it solves my problem.

Smoothing is a simple concept. When a network packet is received, rather than teleporting immediately to the new position, we can interpolate gradually from the previous position toward this new location, giving the illusion of continuous motion …

I took that smoothing concept and applied it here so that when the user re-touches in another location, the onscreen entity will smoothly accelerate towards his current touch point. And because it’s using interpolation, it will always catch up to the current location after half a second regardless of where the user is moving his finger.

• Required: Windows Phone CTP
• Download: XNATouchSmoothing.zip

The entity class from the project is listed below. The important bits are the “isCatchingUp” and “currentSmoothing” variables. When the input handling code realizes that it needs to catch up, it starts to decay the “currentSmoothing” variable, which is then used in the interpolation to smoothly transition to the current location (via Vector2.Lerp).

class Entity
{
    private Vector2 lastKnownPosition;
    private Vector2 touchPosition;
    private float currentSmoothing;

    public Vector2 Position;
    public Texture2D Texture;

    public void Update()
    {
        var touches = TouchPanel.GetState();
        float decay = 1f / 15f;

        bool isTouching = touches.Count > 0;
        bool isCatchingUp = currentSmoothing > 0;

        if (isTouching)
        {
            if (isCatchingUp)
            {
                currentSmoothing -= decay;
            }

            foreach (var touch in touches)
            {
                touchPosition = touch.Position;
            }
        }
        else if (!isCatchingUp)
        {
            currentSmoothing = 1;
        }

        if (!isCatchingUp)
        {
            lastKnownPosition = touchPosition;
        }

        Vector2 positionToDraw = lastKnownPosition;
        if (isCatchingUp)
        {
            Vector2.Lerp(
                ref touchPosition,
                ref lastKnownPosition,
                currentSmoothing,
                out positionToDraw);
        }

        this.Position = new Vector2(
            positionToDraw.X - Texture.Width / 2,
            positionToDraw.Y - Texture.Height / 2);
    }
}

Little touches like this add an extra level of polish that players will appreciate … and yes, I intended the pun

I’ve uploaded the slides to my presentation which was titled, “How to Finish a Game with XNA“. You can download them here:
XNA_CodeCamp_2010_Slides

If you attended the meeting, please don’t hesitate to contact me if you have a question about XNA, Windows Phone, or any other topic that we spoke about

Microsoft’s patterns and practices group wrote the book on web and desktop application architectures (literally). One of the sections in that book is application archetypes which describes the types of applications that you can build. This is useful because an ecosystem can spring up around each archetype (controls, usability studies, tutorials) which can provide a lot of feedback and guidance for new projects to follow.

To that end I wanted to start a list of the different archetypes that might be available to choose from when designing a game for windows phone 7. Don’t confuse this with a discussion about game genres … those are already well known and documented. This list covers types of applications, game mechanics, and input styles that you can use to directly affect your game’s design in a fundamental way.

• The Mini-Console
  If you already have a game that you’ve written (using XNA for example) and you want to do a direct port to the phone, then you are writing a Mini-Console game. Games like this will generally be played in landscape mode, which gives the developer enough room to provide a virtual d-pad and button(s) on the bottom left/right of the screen. The idea here is that the user will feel like they are playing a handheld console like the DS or PSP.
• The ARG
  Alternate Reality Games are growing in popularity. They typified by involving real world elements in one way or another. This can involve using the player’s real world lat-lon location to have in-game effects (using the System.Device.Location namespace), or using the device’s camera as an input mechanism. I don’t see much of these, but it’s an interesting space which I hope more people will investigate.
• The Physical
  These types of games involve the user physically manipulating either the screen, or the device itself to affect the game play. Games like this have to take this analog data and approximate the user’s intent in making that motion or touch. I often see games which should be mini-consoles try to use this type of physical input just because they can … and it sometimes results in awkward gameplay. More research and testing needs to be done in this space to figure out what works and what doesn’t. For an example of the types of things we should be thinking about, check out my article on approximating touch points.
• The Casual
  Casual Games are tearing their way through the game industry. Read this report from the recent game developer’s conference for some of that commentary (http://www.designer-notes.com/?p=195). Regardless of which side of that divide you land on, I think one thing everyone can agree on is that casual games are here to stay. WP7′s push notifications and asynchronous game features will be very useful for games like these.

I’d love to keep updating this post with links to more resources on each archetype … if you find something please don’t hesitate to post it as a comment and I will update the post as time goes on

One of the things that I’ve been thinking a lot about recently is writing software that, instead of strictly defining things can infer a user’s intent. As I pondered the solution above, it occurred to me that defining a bounding box exactly 34 pixels in size was doing just that … limiting the ability for the software to infer the user’s intent in touching the screen. What if his touch point is 35 pixels away from his intended target?

Instead, what if you compare the user’s touch point against the entity positions and simply select the closest one (regardless of whether it’s 35 or 36 pixels away)?

The method below does just that given an array of entities and a touch location:

private static Entity FindNearestEntity(Entity[] entities, ref TouchLocation touch)
{
    Entity selectedEntity = null;
    float currentDistance = 0;

    // The entity with the nearest
    for (int i = 0; i < entities.Length; i++)
    {
        var entity = entities[i];

        float distance = Vector2.DistanceSquared(touch.Position, entity.Position);
        if (distance < currentDistance)
        {
            selectedEntity = entity;
            currentDistance = distance;
        }
    }
    return selectedEntity;
}

This assumes single finger data entry, meaning that it’s probably best served for things like menus and options.

It’s pretty exciting now that XNA has these touch APIs available to it. I am looking forward to doing more research in this space, and playing around with different “natural user interfaces”.

For some great additional resources, be sure to drop by the natural user interface group on the web at: http://nuigroup.com/

1. Create a new XNA Game Project for the phone
2. Add this line of code to the Draw method:

graphics.GraphicsDevice.Clear(Color.White);

And BAM! that’s it!