Splitting Up Rome2rio’s Monolith

A few of the things that I’ve covered are:

• Our approach to dismantling the code and converting it to .NET Core
• Refactoring techniques that made a difference
• Implications of HTTP and other insights

Hopefully this helps out some other people who are embarking on a similar journey. All feedback appreciated!

Can’t use the normal exploit that I’ve used in the past which is named “LetterBomb”, because you need to know the MAC address of the wii, and I can’t open the settings menu on the wii. Not sure exactly why but I am guessing someone modded it in the past and stuffed it up Can’t use the “str2hax” exploit because you have to change the DNS server, and I can’t get into settings

I then tried using “BlueBomb”, which exploits a vulnerability in the bluetooth driver, and you can only run it from linux, it would connect via bluetooth but the exploit would hang. No dice.

The only exploit left to run is an “old school” saved game exploit. You load a hacked saved game onto an SD card, copy it to your wii, run the game and load the saved game. They exist for a few games, none of which I own.

One of the games is “Lego Batman”, someone in Bayswater is selling it for $5. I buy it. Take it home, runs on the wii fine. Great. Copy the hacked save came onto an SD card, put it into the wii… and the wii doesn’t recognise my SD card. It doesn’t want to read ANY of my (5) SD cards. I find out it needs to be an original “SD Card”, not a “sdxc” or a “sdhc” card.

Find out a friend has an ancient SD card that should work. Meet up with him, take it home, it doesn’t work.

Find out my friend wiped it on a linux machine and didn’t create a partition on it. Boot linux, re-format SD card, create a partition, I can read it!

Copy hacked saved game onto SD card, put into wii, it appears! Copied save game file onto the wii.

Run Batman Lego. Saved game doesn’t appear.

After MUCH faffing and different attempts, it appears you need to do it in the following specific order: Play the first stage of lego batman (I’ve done it 3 times now) and compete it until it creates a saved game on the wii Copy this save game file onto your SD card (this sort of ‘initialises’ the SD card, not sure what it does)

Delete the save game file off the wii

Copy the hacked saved game onto the SD card

Copy the hacked saved game file from the SD card onto the wii

The save game now appears inside Lego Batman!!

Load the save game, do the exploit, and the exploit started up! Hooray! Here’s how it looks:

But oh no! The Exploit then hung! It turns out it doesn’t work on wii’s that haven’t been upgraded to the latest firmware!

So that’s where I am right now. Apparently I can use a different program to upgrade the firmware to the latest version but there’s a danger in bricking the wii. Oh well, I’m going to try it anyway.

Trying to fix the firmware installed on the wii manually, what could possibly go wrong

Now let’s see if I’ve bricked it:

ASP.NET suggests using a library named Polly for this, and it’s fantastic, but it’s also not exactly clear how to implement it properly… especially when you need multiple circuit breakers. So let’s do it.

Using Polly in your ASP.NET 6 application

In this example we have an application that calls two API’s - one is the google timezone API, which is called by using a standard HttpClient, and another is Redis, which uses it’s own custom client.

As a first step, create a few policies and add them to a PolicyRegistry. This is done so that each individual class can specify which policy it wishes to use.

In your Program.cs file:

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);

// I'm using Serilog, if you are using something else, you can add it here
PollyPolicies circuitBreakerManager = new PollyPolicies(Serilog.Log.Logger);

// The creation of the policies is inside the PollyPolicies class. This is done
// just so that they are grouped together in one place alongside the logging
var googleApiCircuitBreakerPolicy = circuitBreakerManager.GetGoogleApiCircuitBreakerPolicy();
var redisCircuitBreakerPolicy = circuitBreakerManager.GetRedisCircuitBreakerPolicy();

// We add our policies to a Registry which is just a glorified List<>. 
builder.Services.AddPolicyRegistry(new PolicyRegistry()
{
    { PollyPolicies.GooglePolicyName, googleApiCircuitBreakerPolicy },
    { PollyPolicies.RedisPolicyName, redisCircuitBreakerPolicy }
});

// When we setup our HttpClient, we need to also add the "addPolicyHandler" call as shown:
builder.Services.AddHttpClient<IGoogleTimezoneService, GoogleTimezoneService>()
    .AddPolicyHandler(googleApiCircuitBreakerPolicy);

...

app.Run();

Now we need to create our Policies, so create a file named PollyPolicies.cs:

public class PollyPolicies
{
    public const string GooglePolicyName = "googleApiCircuitBreaker";
    public const string RedisPolicyName = "redisCircuitBreaker";

    private readonly Serilog.ILogger _logger;

    public PollyPolicies(Serilog.ILogger logger)
    {
        _logger = logger;
    }

    public IAsyncPolicy<HttpResponseMessage> GetGoogleApiCircuitBreakerPolicy()
    {
        // The google API is called using a HttpClient, so we can use the handy
        // HandleTransientHttpError() call. But this will not catch timeouts!
        // Make sure to fine-tune these numbers for your specific use-case

        return HttpPolicyExtensions
            .HandleTransientHttpError()
            .AdvancedCircuitBreakerAsync(
                failureThreshold: 0.1,
                samplingDuration: TimeSpan.FromSeconds(20),
                minimumThroughput: 5,
                durationOfBreak: TimeSpan.FromSeconds(60),
                this.OnGoogleBreak,
                this.OnGoogleReset,
                this.OnGoogleHalfOpen);
    }

    public AsyncCircuitBreakerPolicy GetRedisCircuitBreakerPolicy()
    {
        // The Redis API throws quite a few different exceptions (about 5) depending
        // on what the problem is, so we're just going to handle any exception:

        return Policy.Handle<Exception>().AdvancedCircuitBreakerAsync(
            failureThreshold: 0.01,
            samplingDuration: TimeSpan.FromSeconds(5),
            minimumThroughput: 15,
            durationOfBreak: TimeSpan.FromSeconds(360),
            this.OnRedisBreak,
            this.OnRedisReset,
            this.OnRedisHalfOpen);
    }

    public void OnGoogleReset()
    {
        _logger?.Warning("Google API circuit closed, requests flow normally.");
    }

    public void OnGoogleHalfOpen()
    {
        _logger?.Warning("Google API circuit half open");
    }

    public void OnGoogleBreak(DelegateResult<HttpResponseMessage> result, TimeSpan ts)
    {
        _logger?.Warning("Google API circuit cut because {ResultStatusCode} " +
            "or {Exception}, so requests will not flow.",
            result.Exception, result.Result?.StatusCode);
    }

    public void OnRedisReset()
    {
        _logger?.Warning("Redis circuit closed, requests flow normally.");
    }

    public void OnRedisHalfOpen()
    {
        _logger?.Warning("Redis circuit half open");
    }

    public void OnRedisBreak(Exception result, TimeSpan ts)
    {
        _logger?.Warning("Redis circuit cut because {Exception}, " + 
            "so requests will not flow.", result);
    }
}

We’ve now added two different circuit breaker policies that we can use in our code wherever we want. Let’s go ahead and use this policy in some of our code.

Using the circuit breaker

Now we need to update our code that calls the google API to use our circuit breaker. The cool part of the previous call to AddPolicyHandler() that is chained to the AddHttpClient call means that it will be used automatically! I’m not sure if this is cool or a bit too magical, but that’s what you need to do.

public partial class GoogleTimezoneService : IGoogleTimezoneService
{
    private readonly HttpClient _httpClient;
    private readonly ILogger<GoogleTimezoneService> _logger;
    private readonly ICircuitBreakerPolicy<HttpResponseMessage> _breaker;

    public GoogleTimezoneService(
        HttpClient httpClient, 
        ILogger<GoogleTimezoneService> logger, 
        IReadOnlyPolicyRegistry<string> pollyPolicyRegistry)
    {
        _logger = logger;
        _httpClient = httpClient;
        _breaker = pollyPolicyRegistry.Get<ICircuitBreakerPolicy<HttpResponseMessage>>(
            PollyPolicyNames.GooglePolicyName);
    }

    public async Task<string> GetResponseContentAsync(string endpoint)
    {
        try
        {
            // This is a bit of optimisation. When the circuit breaker is closed, it 
            // will throw a BrokenCircuitException if we try to use it. However if we 
            // know it's closed, there's no point in making the request and throwing
            // the exception, so let's just return
            if (_breaker.CircuitState == CircuitState.Open || 
                _breaker.CircuitState == CircuitState.Isolated)
                return null;

            HttpResponseMessage response = await _httpClient.GetAsync(endpoint);
            return await response.Content.ReadAsStringAsync();
        }
        catch (BrokenCircuitException ex)
        {
            // this can happen when the circuit has been set to half open, and 
            // we are verifying that it's back up, but it's not, so it throws a
            // BrokenCircuitException, so in that case, we might as well log it 
            // and just return null
            _logger.LogWarning("Exception {e} when trying to re-open circuit for " + 
                "google timezone api at {Url}", 
                ex, _httpClient.BaseAddress + endpoint);
                
            return null;
        }
        catch (Exception ex)
        {
            _logger.LogWarning("Exception {e} when calling google timezone api at {Url}", 
                ex, _httpClient.BaseAddress + endpoint);

            return null;
        }
    }
}

Now we need to update our Redis code to use our circuit breaker. In this case we need to retrieve it from the polly registry and then use it. We are going to use the ExecuteAsync() call, which executes any code you want, and behaves like how we defined it in the policy. In this case if the code throws any Exception, it will handle it according to our desired circuit breaker policy logic.

public class RedisCache
{
    private readonly ILogger<RedisCache> _logger;
    private readonly AsyncCircuitBreakerPolicy _circuitBreakerPolicy;

    public RedisCache(ILogger<RedisCache> logger, 
                      IReadOnlyPolicyRegistry<string> pollyPolicyRegistry)
    {
        _logger = logger;
        _circuitBreakerPolicy = pollyPolicyRegistry.Get<AsyncCircuitBreakerPolicy>(
             PollyPolicyNames.RedisPolicyName);
    }
    
    ...
    
    // returns a string from redis
    public async Task<string> GetStringAsync(string key)
    {
        // this stops us from making the call if the circuit is open. If we take
        // this out, the ExecuteAsync() method below will throw a BrokenCircuitException
        // on every call, so this is just a performance optimisation:
        
        if (_circuitBreakerPolicy.CircuitState == CircuitState.Open || 
            _circuitBreakerPolicy.CircuitState == CircuitState.Isolated)
            return null;

        // Where the magic happens. ExecuteAsync will handle and then re-raise any 
        // exceptions thrown, so we need to catch them here too.
        try
        {
            return await _circuitBreakerPolicy.ExecuteAsync(() =>
                _redisClient.GetStringAsync(key));
        }
        catch (Exception e)
        {
            _logger.LogWarning("Error with Redis when fetching {key}: {e}", key, e);
            return null;
        }
    }
}

And that’s the bare minimum that you need to be able to enforce a circuit breaker for any code that might throw an exception.

Adding extra policies

If you would also like to use other policies like automatic retries, you can add them at startup:

var retryPolicy = HttpPolicyExtensions
    .HandleTransientHttpError()
    .WaitAndRetryAsync(3, retryNumber => TimeSpan.FromSeconds(1));

and you can chain policies together:

builder.Services.AddHttpClient<IGoogleTimezoneService, GoogleTimezoneService>()
    .AddPolicyHandler(googleApiRetryPolicy)
    .AddPolicyHandler(googleApiCircuitBreakerPolicy);

That should be enough to get you started. Now make sure you test your circuit breaker code! It’s easy to get wrong!

The first step is to throw out the useless wall plug and screw that it came with:

And instead, buy some 8x40mm dynabolts:

Next step, remove the two allen key bolts, as they get in the way:

You’ll end up with the bracket:

Put it up against the wall and draw a dot inside each of the three holes:

You should end up with something like this:

And the next step is to drill out one of those holes. You’ll need a some masonry drill bits. You’ll also need a drill with a hammer action - I suggest getting a corded drill if you only have a battery operated one, as they have a lot more power.

You’ll also need to work out how far to drill in. The dynabolt needs to go in as far as the bolt on the end:

So to make sure you don’t drill in too far, line up the drill bit and the dynabolt, and you can either use a bit of tape around the drill bit to make sure you don’t go in too far, or in my case the drill that I’m using has a depth gauge:

Now get yourself some protection. Ears, eyes, mouth and nose:

Start with the smallest drill bit size (5mm) and get drilling. In my case I started with the bottom hole. Hopefully you’ll end up with a hole like this:

Now this is the crucial bit! Put the bracket over the hole that you just drilled and make sure things still line up:

If not, get out that sharpie again and create a new mark. Drill the top hole next, and then make sure the bracket holes still line up. In this case you can see that the middle hole was a tiny bit too high:

Now that we have three 5mm holes drilled, we need to expand them to fit the dynabolt. In this case, the 8mm dynabolt needs an 8mm drill bit:

Let’s line them up to make sure. As you can see here, the bolt sticks out from behind the drill bit, and the drill bit is the same width as the sleeve bolt itself:

Now that you’ve drilled the 8mm holes, take the bolts off the dynabolts:

And attach them to the bracket. You only want to screw them on a little bit as shown here:

Now line them up with your holes:

And with a good old fashioned hammer, smack them in. Do each one 1 or 2cm at a time. Make sure to follow through with your hammer strokes! You should end up with the bracket against the bricks. Don’t stress if it’s not flush against the bricks. Now for the fun part. Using a wrench, tighten up those bolts. Go crazy!

Now re-attach the bike rack to the bracket using the allen key bolts, and voila, one bike rack!

Fortunately StepMania does, but it only runs on a PC, so to be able to play it there, I need a dance pad that I can plug in via USB.

Unfortunately in Australia they are crazy expensive. The one to get is the L-TEK hard pad from Poland. However that will cost me like $550.

Luckily, I found the DDR A Game pad on marketplace:

While it looks cool - these particular pads don’t have the best reviews. Apparently they aren’t made particularly well.. but hey, how hard can it be to improve? I also had no idea if it worked, but really… it’s just a bunch of buttons. So I bought it.

The connector at the top of the pad is a “VGA” port (technically a DE-15 d-sub, and it seems like you can buy different connectors for it so that you can plug your pad into a PC, or a PS-2, or a wii, etc. So yeah, I could just buy the right one online, but where’s the fun in that? Maybe I can build one myself using an Arduino and have lots of fun in the process?

After a bit of poking around the VGA connector with a multimeter, I found that the middle pin is the ground, and the pads are just simple switches hooked up to individual pins. So all I needed was to connect it up to an Arduino and make it simulate a keyboard.

Here’s my first attempt, I bought a male VGA plug, soldered up the connectors and plugged them into an Arduino Uno:

And then I programmed it to light up the onboard LED whenever a button is pressed:

Woo! All the pads/buttons seem to work ok!

All I need now is to emulate a USB keyboard from the Arduino… but it turns out that an Arduino Uno can’t emulate a USB device, what I needed was an Arduino Leonardo. So I bought one of them, wired it up:

And wrote some code to emulate keyboard presses:

#include "Keyboard.h"

// the number of the onboard LED pin
const int ledPin = 13;    

// these are the inputs on the arduino that we expect the pads to be wired into
int buttonPin[6]        = {2, 4, 6, 8, 10, 12};

// current button states
int buttonState[6]      = {1, 1, 1, 1, 1, 1};

// previous button states
int prevButtonState[6]  = {1, 1, 1, 1, 1, 1};

// these are the keys that are simulated by the keypad
int keyboardButtons[6]  = {KEY_RIGHT_ARROW, KEY_DOWN_ARROW, KEY_UP_ARROW, KEY_PAGE_DOWN, KEY_PAGE_UP, KEY_LEFT_ARROW};

// flag indicating that at least one button is pressed, if true, we light up the onboard LED
bool buttonPressed;

void setup() {

  // initialize the onboard LED pin as an output  
  pinMode(ledPin, OUTPUT);                  
  
  // initialize the 6 inputs as pullup inputs
  for (int i=0;i<6;i++) {
    pinMode(buttonPin[i], INPUT_PULLUP); 
  }

  // Initialise keyboard
  Keyboard.begin();
}

void loop() {

  buttonPressed = false;

  // read the state of the input buttons
  for (int i=0;i<6;i++) {

    buttonState[i] = digitalRead(buttonPin[i]);

    if (buttonState[i] == LOW)
    {
      digitalWrite(ledPin, HIGH);  // turn led on
      buttonPressed = true;
    }

    // If a button has changed state and it's pressed
    if (buttonState[i] != prevButtonState[i] && buttonState[i] == LOW)
    {
        Keyboard.press(keyboardButtons[i]);
        prevButtonState[i] = buttonState[i];
    }

    // If a button has changed state and it's released
    if (buttonState[i] != prevButtonState[i] && buttonState[i] == HIGH)
    {
        Keyboard.release(keyboardButtons[i]);
        prevButtonState[i] = buttonState[i];
    }
  }

  // If none of the buttons are pressed, turn off the LED
  if (!buttonPressed)
  {
    digitalWrite(ledPin, LOW);
  }
}

And it worked!

Here’s a link to the code in github if anyone needs it: https://github.com/rocklan/ddr-dance-pad.

So what’s the moral of the story? Building stuff yourself is fun. Don’t be afraid to try!

Here’s the chart:

Verse 1

Bm
It's 5AM, now it's time to get out of bed

Another day is ready to start again

             G
The shower's running, The coffee is burning now

E                                      A  G  F#7
Gotta get out the door in time for the train


Verse 2

Bm
Cell phone is ringing, the message is coming in

The traffic's jammed,  now let's see who is gonna win. yeah the

G              A                    Bsus4              B7 
game is on, if you are strong and   you wanna play...


Pre-Chorus

                Em                   F#/Bb
No one said the race would be just a piece of cake

F#m                  B7
Work your way to the top! You've got to

Em                       E
Put in the time pay your dues

           A                 F#/Bb 
The corner office is there,  Waiting for you!


Chorus:

Emaj7					Eb7             	
You, yeah, you are a star there's no mistaking you will

Abmsus4               F#m  B7
Make it to the end!        I know you've   

Emaj7                  Eb7
got what it takes to believe in yourself 

Abm                 F#m           B7
You will never give in,    you're a star!
       
Emaj7                              F#
No one else in the world could replace the way you smile

Ebm          F#m      B7         Emaj7
The way you look when you're inspired

                Ebm      Abm
I know you will shine no matter what you will face

'Cause you're are a star!

Outro 

Bm x6  

F#m7 x2

Bm

Importing the certificate locally

Let’s get it working locally first. Within a powershell window, let’s try a few commands. First off, let’s load in our new certificate that we want to install. Assuming that we have a certificate in pfx format that is ready to be imported, let’s install it into our certificate store:

$certname = "c:\my-certificate.pfx"
$certpwd = "certificate-install-password"

$pfxpass = $certpwd |ConvertTo-SecureString -AsPlainText -Force

$newCert = Import-PfxCertificate -FilePath $certname `
    -CertStoreLocation "Cert:\LocalMachine\My" `
    -password $pfxpass

Your new certificate should be installed and viewiable in IIS by clicking on your computer name (not on one of the sites!) and then choosing “Server Certificates”, and you should see something like this:

Great!

Updating IIS to use the new certificate

Now how about we update one particular binding to use this new certificate:

# load in the admin scripts for doing stuff with IIS:
Import-Module Webadministration

# fetch the default web site:
$site = Get-ChildItem -Path "IIS:\Sites" | where {( $_.Name -eq "Default Web Site" )}

You might want to check that your $site variable has the right web site before you proceed. Just run echo $site and it should be pretty obvious.

Now let’s fetch the first SSL binding that is mapped to port 443:

$binding = $site.Bindings.Collection | `
    where {( $_.protocol -eq 'https' -and $_.bindingInformation -eq '*:443:')}

and let’s do the magic:

$binding.AddSslCertificate($newCert.Thumbprint, "my")

BTW, this AddSslCertificate command doesn’t seem to be documented anywhere, and in my opinion it’s confusingly named - if there’s already an SSL certificate assigned to the binding then it will update it to use the new one. But hey, it works:

Woo!

Now this is all well and good, but how do we do this across multiple servers, remotely?

Installing certs on multiple servers

Let’s copy the cert to a few servers:

$servers = @('server1','server2','server3')
$servers | foreach-Object { copy-item -Path $certname -Destination "\\$_\c`$" }

This will copy the cert into the c:\ drive on the desired servers. Note the extra confusing use of the tilde character which you have to use in powershell to escape a dollar sign in a string!

Now let’s connect to all of these servers and import the certificate:

# Establish a connection to all of those servers:
$session = New-PsSession -ComputerName $servers

$importCertificatesCommand = ({
    Import-Module Webadministration

    $newCert = Import-PfxCertificate `
      -FilePath "c:\$($using:certname)"  `
      -CertStoreLocation "Cert:\LocalMachine\My" `
      -password $using:pfxpass
})

Invoke-Command -session $session -scriptblock $importCertificatesCommand

There’s a bunch of magic here. New-PsSession creates a new connection to a remote server, for the supplied list of server names. Invoke-Command executes the desired command against all of the servers that we’ve opened a connection to, and then we are adding the $using prefix to any variables that we wish to access outside of this command.

Once that’s done, we can delete the certificate off the servers:

Invoke-command -Session $session { remove-item -path "c:\$($using:certname)" }

Things are starting to look good! We have the cert imported, shall we update IIS to use this new certificate across all our servers, if they are using an older certificate that we know is about to expire? Let’s update our command:

$importCertificatesCommand = ({

    $newCert = Import-PfxCertificate `
      -FilePath "c:\$($using:certname)"  `
      -CertStoreLocation "Cert:\LocalMachine\My" `
      -password $using:pfxpass

    Import-Module Webadministration

    $sites = Get-ChildItem -Path IIS:\Sites

    foreach ($site in $sites)
    {
        foreach ($binding in $site.Bindings.Collection)
        {
            if ($binding.protocol -eq 'https')
            {
                $search = "Cert:\LocalMachine\My\$($binding.certificateHash)"
                $certs = Get-ChildItem -path $search -Recurse
                $hostname = hostname
                
                if (($certs.count -gt 0) -and 
                    ($certs[0].Subject.StartsWith("CN=MyOldCertificate")))
                {
                    echo "Updating $hostname, site: `"$($site.name)`", binding: `"$($binding.bindingInformation)`", current cert: `"$($certs[0].Subject)`", Expiry Date: `"$($certs[0].NotAfter)`""

                    $binding.AddSslCertificate($newCert.Thumbprint, "my")
                }
            }
        }
    }
})

With a bit of luck, you should see something like this:

A few friends and I started playing Doom online, and we quickly discovered it’s a lot more fun with real-time voice chat. So we added a Discord Server, and we chat over that while we’re playing. It’s great fun! Except… being a nerd… I want more.

The problem that I was having was administering the doom server. Simple things like changing maps, changing the difficulty and seeing which players have died, is difficult. It’s hard for anyone else to do, and it’s hard to see what’s going on. What I really wanted was a way of typing commands into Discord and controlling Zandronum. Plus, it would be really nice if we could receive messages from Zandronum, telling us what’s going on.

Writing the Discord Bot

So to get started, I needed to write a c# discord bot. I found a great library named discord.net that I could use to connect to a discord server and send a message:

var discordClient = new DiscordSocketClient();

discordClient.MessageReceived += (socket) => {
    if (socket.Content == "Hi testbot")
        socket.Channel.SendMessageAsync("Hi, " + socket.Author.ToString());
    return Task.CompletedTask;
}

await discordClient.LoginAsync(TokenType.Bot, "MyBotTokenCredentials");

This little block of code connects to Discord using the MyBotTokenCredentials, and then if someone types Hi testbot into the chat it will reply with Hi -username-. Pretty cool! Of course the first order of the day was to make it reply with the classic Dad joke:

On reflection this was as good as it was going to get so I probably should have just stopped here. But anyway, there’s a good guide on setting up a discord.net bot here that I followed if you want to have a crack at it yourself.

So once this was working I needed it to run in Azure, as part of an always-running asp.net application. So I threw it into a hosted service, which basically looked like this:

private DiscordSocketClient _discordClient;
 
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    // initialise the _discordClient here, then connect:
    ...
    _discordClient.MessageReceived += _client_MessageReceived;
    await _discordClient.StartAsync();
}
 
private async Task _client_MessageReceived(SocketMessage arg)
{
    if (args.Content.StartsWith("!doombot"))
    {
        ... do something clever
    }
}

Freaking sweet. Oh by the way, one little gotcha is that if you want to send stuff to a channel at bot startup, you have to wait until your bot is online:

var discordClient = new DiscordSocketClient();

bool isReady = false;

discordClient.Ready += () => {
    isReady = true;
    return Task.CompletedTask;
};

await discordClient.LoginAsync(TokenType.Bot, "BotToken");

while (!_isReady)
    System.Threading.Thread.Sleep(1000);

var botTestingChannel = _discordClient
    .Guilds
    .First()
    .Channels
    .First(x => x.Name == "bot-testing") as IMessageChannel;
   
await botTestingChannel.SendMessageAsync("Hello world!");</pre>

That one took me a while to figure out!

So that’s the Discord bot side of things worked out. Now we need to get it to talk to our Doom Server, which is named Zandronum.

Talking to Zandronum over UDP

Zandronum has two different protocols you can use to talk to it. One is named the Launcher Protocol that operates over UDP. It deals with unauthenticated requests, so you can query a public doom server and ask some basic questions like ‘how many players are online’ and ‘what is the current map’. Behind the scenes it’s what tools like DoomSeeker use.

I say simple, but of course the devil is in the details. The most complicated part is that every message is compressed using Huffman coding… but for some reason with a hard-coded customised unique tree. There is some example code provided in java and python…. but nothing dotnet!

Fortunately, Sam Izzo is a games developer and a very smart guy, and he was able to get the basics of the UDP Launcher Protocol working. We could send messages to the server! Here’s the console app dumping out some basic info:

The next step was to try to make it do something more interesting - we needed to be able to authenticate and send through some commands. For that, we need to use the RCon (Remote Console) Protocol. The protocol is very similar, but we have to do a handshake first, and then we can start streaming messages from the doom console, and sending it commands. In this convoluted screenshot, you can see the Zandronum server running, and you can see the console application in the background dumping out what’s going on:

Zandronum dotnet NuGet Package

Once all of this code was up and running, I bundled it into a nuget package so that nobody else has to go through the same pain again! It seems to be reasonably stable but I’m sure there’s always bugs.

Putting it all together

Now it’s a matter of gluing the two together. We needed to be able to read and write console data from the zandronum server and stream it back to Discord. So let’s do that:

var zandronum = new Zandronum(_zandronumServer, _zandronumPort);
zandronum.Rcon.ServerMessage += (sender, eventArgs) =>
{
    ZandronumMessageEventArgs ea = e as ZandronumMessageEventArgs;
    botTestingChannel.SendMessageAsync(ea.Message);
};
zandronum.Rcon.ConnectToRcon(_zandronumRConPassword);

Now let’s add some bots to a server (in this case, named Chubbs, Crash and Gamma) and see what happens:

Cool! Now let’s hook up the bot to be able to pass commands back to the server:

discordClient.MessageReceived += (socket) => {
    if (socket.Content.StartsWith("!doom ")) {
        string rconCommand = arg.Content.Substring(6, arg.Content.Length - 6);
        _zandronum.Rcon.SendCommand(rconCommand);
    }
    return Task.CompletedTask;
}

And let’s give it a shot:

So far it’s been running ok and it’s pretty stable. The discord.net library is very nice in that it handles disconnections and re-connects!

The next step would be to implement discord’s slash commands… but maybe that’s for version 2! :)

So why co-op? We started off playing deathmatch but found that playing co-op was more fun. Working together in Survival Mode to beat a map forces a lot of cooperation and planning, and there’s a lot more at stake when you’re on your last life!

Now finding good co-op maps is difficult. There’s thousands to choose from and you don’t want to waste your time on the boring ones. Some of them aren’t designed for cooperative play. A lot of the time I would go through the Cacowards, pick out a few and try them out, but even then it’s a bit of a guess into what is good. Some of them are just too hard, some are too easy… it’s a difficult balancing act.

The following is a list of WADS that we have played so that we can keep track of what we’ve done, and what we’d like to play next.

Awesome co-op / survival wads that are strongly recommended

• Eviternity - massive, incredible Mega WAD. Freaking awesome.
• Valiant - Skillsaw is a genius
• Sunlust - Fun, amazing, very ‘dark and moody’ though.
• Toke’s Coop Build - Old school WAD with some great ideas. Super creative.
• Lost Civilisation - Utterly fantastic WAD
• Ancient Aliens - Amazing WAD. Awesome new monsters, storyline and quirky. So much fun.
• Resurge

Other WADS that were good fun

• Destination Unknown
• DoomWare - This is one CRAZY WAD. Hilarious, but gets boring pretty quickly!
• Antaresian Reliquary - Really good, if a bit unbalanced… MAP04 will absolutely kick your butt. We spent 3 weekends on it!!