Adam Nathan's Blog : Hearts

XAML Video Playing Cards

Adam Nathan — Fri, 16 Sep 2005 20:29:00 GMT

On XAMLshare I just put the source for the video playing cards I showed in my PDC talk and on the Channel 9 video:

Put the XAML inside XAMLPad (Beta 1) and qualify the .wmv references with their full path. Enjoy!

Announcing www.winfxhearts.com!

Adam Nathan — Thu, 08 Sep 2005 17:30:00 GMT

To correspond with my PDC talk about making an application "light up" on Windows Vista, I've created www.winfxhearts.com. This site has a ClickOnce link that enables you can play a version of my new & improved Internet Hearts game. Here's a "before & after" look:

This is still the good ol' Win32 application, but with a dramatically different user experience thanks to WPF and ClickOnce. In the screenshot above, the reddish part of the new UI uses WPF (Avalon), but the chat window, menus, etc. are still Win32. And of course the game logic is still the same. There's no need to rewrite it!

Again, I promise to blog more details after the PDC (and not just about Avalon & ClickOnce, but Indigo, Windows Vista, plus the experiences of upgrading to VC8 & using /CLR). In the meantime, go ahead and try the game, or look for the Channel 9 video about WinFX Hearts & WPF (scheduled to appear on Monday).

You can play this version on Windows Vista Beta 1, Windows XP, or Windows Server 2003, as long as WinFX Beta 1 is installed (and a post-Beta 2 version of the .NET Framework is not installed). If you're going to PDC05, you can play the game on machines in the "Windows Vista Test Drive" Commnet area through Tuesday (9/13).

Sure, it's not as popular a game as Solitaire or Spider Solitaire, but hopefully the opportunity to play humans is an incentive. Before entering a game, you get to choose a name and a picture (either a standard one or any image on the web!):

The game doesn't begin until four players have joined, so you might have to wait awhile to play (or convince some friends to join at the same time)!

Post any questions/issues/comments here. Enjoy!

Back to Internet Hearts

Adam Nathan — Wed, 24 Aug 2005 21:57:00 GMT

Scoble and Ernie Booth stopped by my office today with their camcorder so I could talk about and demo Internet Hearts -- now with the power of WPF! -- for an upcoming Channel 9 video. Look for it during the PDC timeframe. I've been so busy preparing for the PDC that I've been slacking on blogging about the Internet Hearts migration experience. Sorry! But I should be ready to blog about it more right after the PDC.

Oh yeah, "WPF" seems like it's going to be the winning term, rather than "WinPF."

Migrating from VC6 to VC8: Resources

Adam Nathan — Fri, 15 Jul 2005 20:17:00 GMT

In order to update Internet Hearts with WinFX features, I'm going to leverage C++ Interop and recompile at least some of the source code with /clr so I can start using managed APIs. Therefore, my first step was to get the source code (which hadn't been touched in about 6 years) building with Visual C++ 2005 (aka "VC8"). Yes, I could have kept pieces compiling with VC6. Or I could have changed my approach to keep using VC6 everywhere and leverage PInvoke or COM Interop instead of C++ Interop. But C++ Interop is the most natural choice for this project... plus I want my unmanaged code to get the benefits of the latest & greatest VC compiler. Don't be fooled into thinking that Visual C++ 2005 is only interesting for managed code!

Of course, the jump from VC6 to VC8 is pretty large. A lot has happened in those 7 (or is it 8?) years! Actually, the biggest adjustment is going from VC6 to VC7.1, due to significantly increased compliance with ANSI/ISO standards, resulting in breaking changes. But if you've already made the jump to VC7.1, moving to VC8 should be much easier. The biggest change you'll notice when moving to VC8 is probably the CRT Security Enhancements, which will likely give you lots of deprecation warnings.

Next time I'll discuss what challenges I ran into upgrading the Internet Hearts codebase, but in the meantime I've done some navigating of the maze known as MSDN, and came up with the following list of migration resources. I just hope that these funky URLs will be a little more permanent than most permalinks I've tried to rely on!

Overviews:

Moving from 6.0 to 7.1:

ATL/MFC Breaking changes (6.0 to 7.0) (also seen here but the list isn't as long)
ATL/MFC Breaking changes (7.0 to 7.1)
Standard C++ Library changes and issues specific to upgrading
Compiler breaking changes
In-depth info on increased standards compliance
Project upgrading

Moving from 7.1 to 8.0:

Libraries breaking changes
ATL obsolete topics and deprecated functions with replacements
MFC obsolete topics
Compiler breaking changes
Deprecated compiler options
Some removed linker options (mentioned here and here)
Preprocessor changes

PDC talk descriptions & the game of Hearts

Adam Nathan — Thu, 14 Jul 2005 20:04:00 GMT

Today Raymond talks about marketing tweaking PDC talk descriptions and some little-known history on Microsoft Hearts, both of which made me smile since I'm going to be doing a PDC talk primarily based on my Internet Hearts project. Of course, Internet Hearts (which appeared in Windows XP) is a separate codebase from Hearts, and you get to play real (but nameless) people. Whereas Hearts, despite prompting you to log on to "the Microsoft Hearts Network," doesn't have anything to do with the network. If you disable your Internet connection, Pauline, Michele, and Ben are still there to play you!

But on to the topic of PDC talk descriptions, you can find mine at http://commnet.microsoftpdc.com/content/sessions.aspx:

Longhorn: A Case Study on How Your Application Takes Advantage of Longhorn

Wondering how to integrate Avalon for rich UI, Indigo for flexible communication and other great Longhorn features into your application? Want to see what's really involved in making your software "light up on Longhorn?" Using a special version of the Internet Hearts game as a case study, this session highlights strategies and best practices in augmenting large Win32 code bases to incrementally take advantage of new WinFX and Longhorn-specific functionality.

Session Level(s): 300

Track(s): Fundamentals

As you may have guessed, this bares little resemblance to any of my original title suggestions, although the description is mostly still intact. What do you think? Does this sound like a talk you would want to see, or is the title too dry? Is the focus on Longhorn confusing since a lot of the content will be WinFX (which works on XP)? Would you have guessed that WinFX Interop is an important component of this talk? Any feedback you share could be helpful ammunition for making some improvements here, so feel free! :)

Internet Hearts: 112,000 Lines of Code

Adam Nathan — Wed, 15 Jun 2005 23:39:00 GMT

On Monday I asked for guesses on the size of the Internet Hearts source base, and the highest (public) one was 45,000 lines of code. The answer: approximately 112,000 lines of code! 51,000 are client-specific, 35,000 are server-specific, and 26,000 are shared by both.

Higher than you expected? Well, there's a lot of functionality on the server end. And the application is actually a general-purpose game client & server designed to support multiple games (Internet Backgammon/Checkers/Hearts/Reversi/Spades). For the purpose of turning this app into a shareable sample, I've already removed the non-Hearts pieces, but the generic nature of the architecture definitely contributes to the code size.

When I apply today's technologies to this older code base, I'm pretty sure I'll be able to "do more with less": Less lines of code, less time & effort, less bugs, etc. So we should see the application shrink.

Here are some diagrams to illustrate how the baseline Internet Hearts application is structured (prior to any improvements). The orange-colored components involve UI, so they're candidates for an Avalon makeover. The indigo-colored components involve networking, so they're candidates for... you guessed it... Indigo!

The Client:

The Server:

Internet Hearts: Guess the LOC

Adam Nathan — Mon, 13 Jun 2005 22:43:00 GMT

TechEd made me gain about 5 pounds, and my bag somehow gained 20 pounds. (And I didn't get a single piece of swag from the Product Pavilion, I swear.) But I'm back in Redmond after a 24-hour journey from Orlando to Seattle, due to delays at Chicago O'Hare. I was intrigued that at the beginning of each flight, United plugged (the original) Channel 9. Perhaps they're starting to appreciate some corporate transparency, too? Now if United (or any other airline) employees started blogging, that would be interesting...

Anyway, as I mentioned right before TechEd, I now have the source code to Internet Hearts, and will blog about a few of the challenges in integrating new WinFX functionality. But first, can you guess how many lines of code comprise this application (client and server)?

Some clues: It's a C++ winsock application. It hasn't been touched since around 1999. It uses ATL & WTL. You can explore the client's functionality (on the "Games" menu) if you've got Windows XP. And to be clear, I'm talking about the card game. When I mentioned Internet Hearts to Chris Brumme, he wondered if I was talking about an online dating service! :)

Avalon Beta 1 RC Breaking Changes

Adam Nathan — Wed, 01 Jun 2005 22:29:00 GMT

Breaking changes are a fact of life when living on the bleeding edge of betas and CTPs, especially for technologies like Avalon and Indigo which haven't officially shipped yet. There have been lots of changes between the March CTP and Beta 1 RC, and there will be lots more to come. Remembering the CLR/.NET Framework changes between Beta 1, Beta 2, and the RTM of v1.0, I know we're still in for quite a ride! At least this time I don't have to try to keep a 1600-page book in sync with all the changes! :) Good luck, Chris and Chris!

I thought I'd share the changes I ran into with my playing cards sample as I moved it from the March CTP to Beta 1 RC.

In source code, the only change I made (in Hand.xaml.cs) was to make Hand derive from Viewbox rather than Grid. I could have left it alone, but it felt more natural to have Hand be a Viewbox rather than a Grid containing a Viewbox. The March CTP compiler had prevented me from doing the former.

Of the four XAML files in the complete sample, I only had to change one of them (Card.xaml). But there were lots of changes, indeed:

x:StyleID changed to Name
TransformCollection changed to TransformGroup
*Alias(Target=Background) changed to {TemplateBinding Background}
SourceId and TargetId (in EventTriggers) changed to SourceName and TargetName
DeactivateAction (in EventTriggers) changed to StopAction
On the ParellelTimelines, I had to play around with Duration and FillBehavior settings to get the desired effects when pairing the MouseEnter/MouseLeave animations. It was hard to get right, but there should be some changes in this area in the future to make things easier.
I had to alter the paths in my SetterTimelines in order to animate my transforms. For example, (Grid.RenderTransform)[0].(RotateTransform.Angle) changed to (Grid.RenderTransform).(TransformGroup.Children)[0].(RotateTransform.Angle)
In all of my DrawingBrushes, I removed the Viewbox attribute (Viewbox="0 0 1468 2053"). Another option would have been to set ViewboxUnits="Absolute". Why? The meaning of the coordinates has changed, with the default now being ViewboxUnits="RelativeToBoundingBox". But since the coordinates now get calculated automatically if you don't specify them, I just removed them altogether.
On the button, ID changed to Name. This was a big change to FrameworkElements that all Avalon components are likely to run into.

There were a lot more breaking changes that my sample managed to avoid because there were two ways to do certain things in the March CTP and now there's only one way to do them. I chose the way that survived the upgrade, but you could easily run into these changes. For example:

The deprecated attribute syntax described here (such as using *null instead of {x:Null}) was still supported in the March CTP, but not in Beta 1 RC. Upgrading means you're now forced to make the switch.
You can no longer use System.Windows.Shapes inside of a DrawingBrush. Instead, you must use the new Drawing classes: DrawingGroup, GeometryDrawing, & ImageDrawing. This is a big change, but it has lots of benefits. A DrawingBrush can now exist in a Resources dictionary, and since the Drawing classes inherit from Animatable (rather than FrameworkElement), a lot of properties are removed (which were never supported inside a DrawingBrush anyway), giving a much smaller memory footprint.
There have been a number of changes to the way styles are defined. For example, you no longer embed controls or a VisualTree inside them. You set properties, such as the "Template" property, which holds a ControlTemplate much like what the VisualTree used to be.

Are you struggling with any other breaking changes that I didn't cover? Let me know and I'll see if I can help!

XAML Playing Cards

Adam Nathan — Tue, 03 May 2005 22:34:00 GMT

Looking at the card games that ship with Windows XP, I think one of the most obvious opportunities for improvement is the look & feel of the playing cards. These games use a shared library known as cards.dll to draw cards that look like... um... this:

Don't those look so 20th century? To prepare for migrating Internet Hearts, I've created an Avalon Playing Card control with built-in animations:

It can be set to any of the 52 cards (although no jokers currently). I've also created a "Hand" control that mimics the hand dealt in the Win32 picture above:

And, of course, since they're vector graphics, they look just as good no matter how much you zoom in:

You can get the source code here, which is compatible with the March CTP of Avalon. I'll post new versions as new builds of Avalon get released.

The .zip file contains a Visual Studio solution with two projects:

Cards, which builds Cards.dll containing the Card and Hand controls pictured above
Demo, a simple application demonstrating the use of the controls

In the Cards project, Cards.xaml defines the playing card control, which is just a button styled to look like a card:

The style consists of a Viewbox (to enable scaling while maintaining the proper aspect ratio) and two rectangles: one painted with the desired card face and one painted with a shadow. This painting is done with DrawingBrushes defined in the same file. There are 53 of them: one per card face and one for the shadow. For example, here's my DrawingBrush for the 2 of Hearts:

In case you're wondering, I didn't create that XAML by hand! :) I started with Adobe Illustrator, saved the file as SVG, then dealt with it from there.

The button style also contains an event trigger for Mouse.MouseEnter and another for Mouse.MouseLeave. Each of these points to a "storyboard" that handles the card animations (such as scaling and rotating). The only piece of code I needed to write was the property that sets the face:

// The user (via code or XAML) can simply specify the
// name of the face, which must match the name of one of the
// DrawingBrushes in Card.xaml.
public string Face
{
get { return face.ToString(); }
set
{
   // Let exception happen on bad input. The system handles it well.
   face = value;
   CardButton.Background = (Brush)Resources[face];
}
}
private string face;

For now, the Hand control in Hand.xaml just hardcodes a set of cards in specific positions and rotations on a Canvas (again wrapped in a Viewbox for uniform scaling). For example:

<c:Card Width="100" Canvas.Left="10" Face="C7">
<c:Card.RenderTransform>
<RotateTransform Center="50,140" Angle="310" />
</c:Card.RenderTransform>
</c:Card>

Enjoy, and don't hesitate to give me feedback!

Migrating Internet Hearts to WinFX

Adam Nathan — Tue, 03 May 2005 09:59:00 GMT

Last year, Chris Sells wrote a series of articles in which he set out to rewrite Solitaire using Avalon. The lack of scaling graphics in the Win32 version (and lack of access to its source code, I suppose) forced him down the road of rewriting the app from scratch. Plus, the point was to explore "the initial decisions developers will make when building new applications targeting Longhorn." (This was before WinFX got decoupled from Longhorn and made available for Windows XP & Windows Server 2003.)

This year, I'm going to create a new WinFX-enabled version of Internet Hearts (the not-as-popular card game that also ships with Windows XP). But the focus is going to be on migration rather than starting from scratch. I'll gradually replace the UI with Avalon and the communication with Indigo. After all, I want to focus on the cool stuff; not rewriting the basic logic. I'll share results as I go along, and hopefully I'll be able to share the source code, pre-migration and post-migration!

I want to give special thanks to Steven Goulet (one of the folks on my new team), who came up with Internet Hearts as a great example application that could benefit from Avalon & Indigo. He also did the legwork of getting permission for the original source code. So without him, this would not be possible!