Search code examples
c#auto-update

game client updater

I'm a MMORPG Private Server dev and I'm looking forward to create an all in one updater for the user's clients because it is very annoying and lame to use patches that must be manually downloaded.

I'm new in C# but I already succeeded at making my own launcher with my own interface and basic game start/options buttons and notice that is read from my webserver.

Now, I want to make an integrated update function for that and I'm pretty lost, I have no idea where to start. This is what it would look like, it's just a concept

enter image description here

It will have the main button which is used to start the game AND update it, basically when you open the program the button would write "UPDATE" and is disabled(while it searches for new updates) and if any are found, it would turn into a clickable button, then after the updates are downloaded it would just change itself into "start game".

A progressbar for the overall update and another one to see the progress on the current file that is downloading only, all that with basic info like percentage and how much files need to be downloaded.

I need to find a way for the launcher to check the files on the webserver by HTTP method and check if they are same as client or newer ones so it doesn't always redownload files already same version and also a method so that the updater will download the update as a compressed archive and auto extract and overwrite existing files when they are done downloading.

NOTE: The files being updated are not .exe, they mostly are textures/config files/maps/images/etc...

Solution

  • I'll sketch a possible architecture for this system. It's incomplete, you should consider it a form of detailed pseudo-C#-code for the first half and a set of hints and suggestions for the second.

    I believe you may need two applications for this:

    • A C# WinForms client.
    • A C# server-side application, maybe a web service.

    I'll not focus on security issues on this answers, but they are obviously very important. I expect that security can be implemented at a higher level, maybe using SSL. The web service would run within IIS and implementing some form of security should be mainly a matter of configuration.

    The server-side part is not strictly required, especially if you do't want compression; probably there is a way to configure your server so that it returns a easily parsable list of files when an HTTP request is made at website.com/updater. However it is more flexible to have a web service, and probably it's even easier to implement. You can start by looking at this MSDN article. If you do want compression, you can probably configure the server to transparently compress individual files. I'll try to sketch all possible variants.

    In the case of a single update ZIP file, basically the updater web service should be able to answer two different requests; first, it can return a list of all game files, relative to the server directory website.com/updater, together with their last write timestamp (GetUpdateInfo method in the web service). The client would compare this list with the local files; some files may not exist anymore on the server (maybe the client must delete the local copy), some may not exist on the client (they are entirely new content), and some other files may exist both on the client and on the server, and in that case the client needs to check the last write time to determine if it needs the updated version. The client would build a list of the paths of these files, relative to the game content directory. The game content directory should mirror the server website.com/updater directory.

    Second, the client sends this list to the server (GetUpdateURL in the web service). The server would create a ZIP containing the update and reply with its URL.

    [ServiceContract]
public interface IUpdater
{
    [OperationContract]
    public FileModified[] GetUpdateInfo();

    [OperationContract]
    public string GetUpdateURL();
}

[DataContract]
public class FileModified
{
    [DataMember]
    public string Path;

    [DataMember]
    public DateTime Modified;
}

public class Updater : IUpdater
{
    public FileModified[] GetUpdateInfo()
    {
        // Get the physical directory
        string updateDir = HostingEnvironment.MapPath("website.com/updater");

        IList<FileModified> updateInfo = new List<FileModified>();

        foreach (string path in Directory.GetFiles(updateDir))
        {
            FileModified fm = new FileModified();
            fm.Path = // You may need to adjust path so that it is local with respect to updateDir
            fm.Modified = new FileInfo(path).LastWriteTime;
            updateInfo.Add(fm);
        }

        return updateInfo.ToArray();
    }

    [OperationContract]
    public string GetUpdateURL(string[] files)
    {
        // You could use System.IO.Compression.ZipArchive and its
        // method CreateEntryFromFile. You create a ZipArchive by
        // calling ZipFile.Open. The name of the file should probably
        // be unique for the update session, to avoid that two concurrent
        // updates from different clients will conflict. You could also
        // cache the ZIP packages you create, in a way that if a future
        // update requires the same exact file you would return the same
        // ZIP.

        // You have to return the URL of the ZIP, not its local path on the
        // server. There may be several ways to do this, and they tend to
        // depend on the server configuration.

        return urlOfTheUpdate;
    }
}

    The client would download the ZIP file by using HttpWebRequest and HttpWebResponse objects. To update the progress bar (you would have only one progress bar in this setup, check my comment to your question) you need to create a BackgroundWorker. This article and this other article cover the relevant aspects (unfortunately the example is written in VB.NET, but it looks very similar to what would be in C#). To advance the progress bar you need to keep track of how many bytes you received:

    int nTotalRead = 0;
HttpWebRequest theRequest;
HttpWebResponse theResponse;

...

byte[] readBytes = new byte[1024];
int bytesRead = theResponse.GetResponseStream.Read(readBytes, 0, 4096);

nTotalRead += bytesread;
int percent = (int)((nTotalRead * 100.0) / length);

    Once you received the file you can use System.IO.Compression.ZipArchive.ExtractToDirectory to update your game.

    If you don't want to explicitly compress the files with .NET, you can still use the first method of the web service to obtain the list of updated file, and copy the ones you need on the client using an HttpWebRequest/HttpWebResponse pair for each. This way you can actually have two progress bars. The one that counts files will simply be set to a percentage like:

    int filesPercent = (int)((nCurrentFile * 100.0) / nTotalFiles);

    If you have another way to obtain the list, you don't even need the web service.

    If you want to individually compress your files, but you can't have this feature automatically implemented by the server, you should define a web service with this interface:

    [ServiceContract]
public interface IUpdater
{
    [OperationContract]
    public FileModified[] GetUpdateInfo();

    [OperationContract]
    public string CompressFileAndGetURL(string path);
}

    In which you can ask the server to compress a specific file and return the URL of the compressed single-file archive.

    Edit - Important

    Especially in the case that your updates are very frequent, you need to pay special attention to time zones.

    Edit - An Alternative

    I should restate that one of the main issues here is obtaining the list of files in the current release from the server; this file should include the last write time of each file. A server like Apache can provide such a list for free, although usually it is intended for human consumption, but it is easily parsable by a program, nevertheless. I'm sure there must be some script/extension to have that list formatted in an even more machine-friend way.

    There is another way to obtain that list; you could have a text file on the server that, for every game content file, stores its last write time or, maybe even better, a progressive release number. You would compare release numbers instead of dates to check which files you need. This would protext yourself from time zone issues. In this case however you need to maintain a local copy of this list, because files have no such thing as a release number, but only a name and a set of dates.