Uri uri = new Uri("http://whatismyip.org");
            WebClient client = new WebClient();
            client.DownloadStringCompleted += new DownloadStringCompletedEventHandler(client_DownloadStringCompleted);
            client.DownloadStringAsync(uri);

  void client_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            player.IP = e.Result;
        }

Building a High-end HTPC from Matthew Delisle on Vimeo.

Asus Mini-ITX motherboard

XBMC Setup guide

[H]ard Forum HTPC Thread

Win7 codecs

XBMC

Microsoft Security Essentials

Boxee

Lenovo mini wireless keyboard

Logitech Harmony

Logitech Dinovo wireless keyboard

Logitech Dinovo mini

Rii mini wireless keyboard

If you want me to build you an HTPC, send me an email.

Even if you are not interested in localization, the article has some cool tricks dealing with Silverlight XAPs and http handlers.

Link to article on MSDN

Filco Majestouch Ninja tenkeyless unboxing from Matthew Delisle on Vimeo.

Keyboard on Amazon

2 30 inch monitors in front, 1 22 inch on the side. Watching 2 different MMA fights.

A Lian Li PC-P80 case compared with a Silverstone SG04 and a Lian Li PC-V354. The PC-P80 is the largest case I’ve owned and the tallest case I know of. The SG04 and PC-V354 are SFF (small form factor) cases, meaning that they are made specifically to conserve space.

Some pics of my now disassembled radiator setup…

Summary: Using a MySQL database instance instead of
files for storage. There were some concurrency issues with the files.

Download: uploading soon.

I’ve created a MySQL database on the web server and a table called
HighScores that has columns similar to the properties in the
HighScore class, and I’ve add a LeaderBoardId column to take
the place of the filename.

The SQL code to create the table is:

CREATE TABLE `HighScores` (
`LeaderBoardId` VARCHAR( 10 ) NOT NULL ,
`PlayerName` VARCHAR( 32 ) NOT NULL ,
`Score` BIGINT NOT NULL ,
`UserId` VARCHAR( 32 ) NOT NULL ,
`NumberofPlays` INT NOT NULL ,
`Timestamp` VARCHAR( 32 ) NOT NULL ,
PRIMARY KEY ( `LeaderBoardId` , `UserId` )
) ENGINE = MYISAM ;

First, download the MySql/.Net connector.

Next, add a reference to the MySQL.Data.Dll to the
LeaderboardService project. Add a using statement
‘using MySql.Data.MySqlClient’ to the service class.

Now, create the connection string as a private variable. The
connection string is in the form: “Server=;Database=;Uid=;Pwd=’

private MySqlConnection connection = new MySqlConnection("Server=sc.gibson.com;Database=db1;Uid=God;Pwd=God");

First, let’s modify the LoadLeaderboard operation. The great thing
about switching over to a relational database is that I get to take
away the lock used for files, and all the serialization and
de-serialization code.

The code in the LoadLeaderboard operation creates a
MySqlCommand, fills in the command text, specifying a leader
board id, and runs through a reader to populate a HighScores object.

  private bool LoadLeaderboard(string id)
        {
            HighScores scores = new HighScores();

            MySqlCommand command = connection.CreateCommand();
            command.CommandText = "SELECT * FROM `HighScores` WHERE `LeaderBoardId` = " + id;

            try
            {
                connection.Open();

                MySqlDataReader reader = command.ExecuteReader();
                while (reader.Read())
                {
                    // Read each highscore object...
                    HighScore score = new HighScore();

                    int tempInt;

                    if (int.TryParse(reader["NumberofPlays"].ToString(), out tempInt)) {
                    score.NumberOfPlays = tempInt;
                    }

                    score.PlayerName = reader["PlayerName"].ToString();

                    long tempLong;

                    if (long.TryParse(reader["Score"].ToString(), out tempLong)) {
                        score.Score = tempLong;
                    }

                    DateTime tempDT;

                    if (DateTime.TryParse(reader["Timestamp"].ToString(), out tempDT)) {
                        score.Timestamp = tempDT;
                    }

                    score.UserId = reader["UserId"].ToString();

                    scores.Scores.Add(score);
                }

                if (Boards.ContainsKey(id))
                {
                    Boards[id] = scores;
                }
                else
                {
                    Boards.Add(id, scores);
                }
            }
            catch (Exception ex)
            {

            }
            finally
            {
                connection.Close();
            }

            return true;
        }

The next method I want to modify is the SetScore method. There
is no need to check to see if a leader board has been loaded
anymore. I can check to see if a leader board with a specific id is
in memory and if that leader board has an entry for the current
user. Using this data, I assume that if there is an entry in memory,
there is an entry in the database. If there is an entry in the db, I
run an update, otherwise I use an insert command.

        public void SetScore(string leaderboardId, string userId, string playerName, long score, int numPlays, int randomNumber, double checksum)
        {
            if (checksum == CalculateChecksum(randomNumber))
            {
                    bool found = WriteHighScore(leaderboardId, userId, playerName, score, numPlays);

                    // Save to DB
                    try
                    {
                        connection.Open();
                        MySqlCommand command = connection.CreateCommand();

                        if (found) //update
                        {
                            command.CommandText = "Update HighScores SET UserId = '" + userId + "', PlayerName = '" + playerName + "', Score = '" + score + "', NumberofPlays = '" + numPlays + "', Timestamp = '" + DateTime.UtcNow + "' WHERE LeaderboardId = '" + leaderboardId + "'";
                            command.ExecuteNonQuery();
                        }
                        else //insert
                        {
                            command.CommandText = "Insert into HighScores (LeaderBoardId, UserId, PlayerName, Score, NumberofPlays, Timestamp) VALUES ('" + leaderboardId + "', '" + userId + "', '" + playerName + "','" + score + "','" + numPlays + "','" + DateTime.UtcNow + "')";
                            command.ExecuteNonQuery();
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                    }
                    finally
                    {
                        connection.Close();
                    }
            }
        }

I can remove the SaveScoreToFile method. Next on the chopping block
is the ClearLeaderboard operation. The implementation is very simple,
using a Delete statement, specifying the leader board id.

  public void ClearLeaderboard(string leaderboardId, int randomNumber, double checksum)
        {
            if (checksum == CalculateChecksum(randomNumber))
            {
                try
                {
                    connection.Open();
                    MySqlCommand command = connection.CreateCommand();

                    command.CommandText = "Delete from `HighScores` where `LeaderBoardId` = " + leaderboardId;
                    command.ExecuteNonQuery();
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
                finally
                {
                    connection.Close();
                }
            }
        }

Summary: Added RemoveLeaders operation, user ids, a score created
date and changed the leader board id to a string.


Download Source Code

There were some modifications requested for the leaderboard service.
First, the user id should be passed in to uniquely identify a user.
Second, the leader board identifier should be a string type and not
an integer. Third, the number of plays should be passed in. Fourth,
a timestamp should be added each time a score is submitted. A new
operation has been requested called RemoveLeaders that takes in a
list of user id’s, a leader board id and removes entries associated
with those entries from that leader board.

The first thing I’ve done is change the leader board id’s to strings in
the interface and the class. Here is the new interface:

[OperationContract]
        HighScores GetLeaderboard(string leaderboardId, int randomNumber, double checksum);

        [OperationContract]
        void SetScore(string leaderboardId, string playerName, long score, int randomNumber, double checksum);

        [OperationContract]
        void ClearLeaderboard(string leaderboardId, int randomNumber, double checksum);

The next thing I’ll do is modify the SetScore operation to take as
input the user id and number of plays in the last game.

This involves adding the user Id and number of plays to the
HighScore class and editing the WriteHighScore method.

Here is the modified HighScore class:

[DataContract]
    public class HighScore
    {
        [DataMember]
        public string PlayerName { get; set; }

        [DataMember]
        public long Score { get; set; }

        [DataMember]
        public int NumberOfPlays { get; set; }

        [DataMember]
        public string UserId { get; set; }

        [DataMember]
        public DateTime Timestamp { get; set; }

        public HighScore()
        {   }

        public HighScore(string userId, string name, long score, int numPlays, DateTime timestamp)
        {
            PlayerName = name;
            Score = score;
            UserId = userId;
            NumberOfPlays = numPlays;
            Timestamp = timestamp;
        }

        public void Serialize(XmlWriter writer)
        {
            writer.WriteStartElement("HighScore");
            writer.WriteElementString("PlayerName", PlayerName);
            writer.WriteElementString("Score", Score.ToString());
            writer.WriteElementString("UserId", UserId);
            writer.WriteElementString("NumberOfPlays", NumberOfPlays.ToString());
            writer.WriteElementString("Timestamp", Timestamp.ToUniversalTime().ToString());
            writer.WriteEndElement();
        }

        public void Deserialize(IEnumerable<XElement> elements)
        {
            foreach (var ele in elements)
            {
                switch (ele.Name.LocalName.ToLower())
                {
                    case "playername":
                        PlayerName = ele.Value;
                        break;
                    case "score":
                        Score = long.Parse(ele.Value);
                        break;
                    case "userid":
                        UserId = ele.Value;
                        break;
                    case "NumberOfPlays":
                        NumberOfPlays = int.Parse(ele.Value);
                        break;
                    case "timestamp":
                        Timestamp = DateTime.Parse(ele.Value);
                        break;
                }
            }
        }
    }

The modifications to the WriteHighScore method only involve change the
input parameters for the HighScore constructor.

Next, I’ll create the RemoveLeaders operation. The operation takes
in a leader board id and a list of users and removes entries
associated with those user from the leader board.

The declaration looks like this:

void RemoveLeaders(string leaderboardId, string[] userIds, int randomNumber, double checksum);

The implementation involves the following steps:

* Load the leaderboard
* Create a new HighScore list
* Add an entry to the new list if it’s not in the user Id array
* Save the new list in memory and to a file

The code looks like this:

 public void RemoveLeaders(string leaderboardId, string[] userIds, int randomNumber, int checksum)
        {
            if (checksum == CalculateChecksum(randomNumber))
            {
                HighScores board;

                if (LoadLeaderboard(leaderboardId))
                {
                    board = Boards[leaderboardId];
                }
                else
                {
                    return;
                }

                HighScores result = new HighScores();

                foreach (HighScore score in board)
                {
                    bool found = false;
                    for (int i = 0; i < userIds.Length; ++i)
                    {
                        if (score.UserId == userIds[i])
                            found = true;
                    }

                    if (!found)
                    {
                        result.Add(score);
                    }
                }

                Boards[leaderboardId] = result;

                SaveScoreToFile(leaderboardId);
            }
        }

The code includes some other minor modifications, such as ordering
by number of plays and score.

Installing a Swiftech 360 Rad from Matthew Delisle on Vimeo.