Today, I discovered that the StringReaders/Writers in .Net only support UTF-16 encoding, which may lead to some breakage if you’re using it in combination with the XMLSerializer object.

If you really need to maintain UTF-8 compatibility, you should use a MemoryStream. This is actually just as simple as using a StringReader:

  MemoryStream m = new MemoryStream();
  try
  {
    XmlSerializer formatter = 
        new XmlSerializer(typeof(TMakeUpYourMind));
    formatter.Serialize(m, this);
    m.Flush();
    m.Seek(0, 0);
    StreamReader rd = new StreamReader(m);
    try
    {
      res = rd.ReadToEnd();
    }
    finally
    {
      rd.Dispose();
    }
  }
  finally
  {
    m.Dispose();
  }

Don’t forget to ‘rewind’ the stream to position 0.

I’m not sure why this isn’t mentioned in the SDK. Also note to the Visual Studio Express developers: please make this weekly ‘registration of Visual Studio Express’ on my computer stop. I’m sure it’s a bug because everytime I register I get the same e-mail in with the same deals. I’ve already got 12 of them. Please.

Since the weather was bad yesterday and (it appears) it’s going to be same-o-same-o today, I decided to check into (this last month’s) Card objects project. All earlier created objects were ‘non-visual’ objects and since we’re playing cards, it probably makes sense to create a couple of visual components that show the player’s hands.

I decided to base my custom component on the PictureBox control, mainly because I’m not concerned about using specific drag and drop effects at this stage. If you make a descendant of the PictureBox and plan to do some custom drawing, you should override the PictureBox’s OnPaint event:

Continue reading →

For something completely unrelated, I decided to check into my older Delphi code and noticed the ‘remnants’ of the code that actually started as a framework for a (basic) Spades¹ card game. So hey: the code was actually so readable that most of it was easily turned into a C# version (that is minus the bidding code).

The fun part of it all was the ease of sorting in C#. Actually, you still need to write code to get that going, but compared to the things I needed to get a hand sorted in Delphi, that can be a different story (it’s actually not too bad either if you use regular TLists and that):

First of all make your base object descend from the IComparable class. This means, you’ll have to add a CompareTo method to your base object

 public class TCard : IComparable
    {
        private TFaceValue ffacevalue;
        private bool ffaceup = false;
        private TSuit fsuit;
        
        // Code removed for brevity reasons...

        public int CalcValue
        {
            get { return NumericValue(); }
        }

        public int CompareTo(TCard acard)
        {
            return this.CalcValue.CompareTo(acard.CalcValue);
        }
    }

Then create a class based on IComparer:

    public class THandComparer : IComparer
    {
        private TSortOptions fsort = TSortOptions.Ascending;

        public TSortOptions SortOption
        {
            get { return fsort; }
            set { fsort = value; }
        }

        public int Compare(TCard x, TCard y)
        {
            if (fsort == TSortOptions.Ascending)
            {
                return x.CompareTo(y);
            }
            else
            {
                return y.CompareTo(x);
            }
        }
    }

I decided to give the player an option to sort the cards descending or ascending based on the combination of suit and card value: Notice that for descending order, you literally just switch the objects (the base CompareTo method returns -1, 0 or 1!)

And then in the THand Class:

 
        // [....]
        public void Sort()
        {
            THandComparer fcomparer = new THandComparer();
            fcomparer.SortOption = forder;

            fhand.Sort(fcomparer);
        }

What rest are the drawing procedures, the card faces (I should have a couple of sets somewhere on my source backup disks) and the bidding engine.

¹ I find it amazing that Pagat once again serves as a reference for card games, just like it used to do back in 2000.