The Solution

Before we start, we need to set up a solution and subprojects.

Create a new Solution of type Console Application and call it MartianTrail. This will be our game itself.

You’ll need a unit test project as well, called MartianTrail.Tests. I prefer xUnit. As a matter of personal preference, I usually install the following NuGet dependencies to the test project: Fluent Assertions, Moq, AutoFixture, and AutoFixture.AutoMoq. These aren’t necessary, so I’ll leave those up to you.

Communications

As we start building out the game, the first thing we need is the ability for the player and game to communicate. For this, create a new folder called UserInteraction, and in it a new code file containing a couple of DUs that represent interactions with the player and the possible consequences.

These are as follows:

UserInteraction

Information provided by the user via the console. This information has these possible states:

IntegerInput

The player entered a numeric value. We can use this for determining which choice from a selection the player made, or validating amounts of money spent.

TextInput

The player entered text that wasn’t numeric.

EmptyInput

The player just pressed the Enter key without any input. This is a form of error state.

UserInputError

An exception was raised from the console.

Operation

An interaction with the user in which we aren’t expecting any data back. This occurs in situations such as writing a message to the console, but not expecting anything to be typed back. Here are its possible states:

Success

The operation completed without error.

Failure

The operation resulted in an exception being thrown. The exception is captured in this object.

Details of how to implement these unions, along with a ConsoleShim and User​Inter⁠action client class can be found in Chapter 6.

Now that we’re able to swap data two ways between the game and player, we need something to say.

Want to Learn How to Play?

The first task of the game upon loading is to ask the player whether they’d like instructions on how to play.

For that, we need to combine our existing abilities to take input from the player and to send messages, and have the function that results from the combination also return a calculated Boolean value that will determine whether the message should be sent. This removes the need to have if statements in the purely functional area of the codebase.

Add these two functions to both the IPlayerInteraction interface and the Player​In⁠teraction class that implements it:

public Operation WriteMessage(params string[] prompt) =>
    console.WriteLine(prompt);

public Operation WriteMessageConditional(
    bool condition,
    params string[] prompt) =>
    condition
        ? WriteMessage(prompt)
        : new Success();

Now, back in the root of the project, we can create a new folder called Instruction that contains an interface called IDisplayInstructions and its implementation DisplayInstructions.cs. These represent the operation to ask the player if they want instructions on how to play, and the message that’s written to screen if they do.

The interface is as simple as it gets. We don’t necessarily care how the operation went, so a void return type is fine:

public interface IDisplayInstructions
{
    void DisplayInstructions();
}

I’m not going to present the whole of the code for the DisplayInstructions class here, because the instructions are fairly lengthy. Instead, I’ll show a few choice extracts.

First, a UserInteraction instance needs to be injected via the constructor, to allow us to test it, as well as to provide a method for communication with the player:

private readonly IPlayerInteraction userInteraction;

public DisplayInstructions(IPlayerInteraction userInteraction)
{
    this.userInteraction = userInteraction;
}

For determining whether the user has said some variation on yes, a collection-based approach tends to keep things simple:

void IDisplayInstructions.DisplayInstructions()
{
    var displayInstructionsAnswer = this.userInteraction.GetInput(
     "Would you like to learn how to play this game?");

    var positiveResponses = new []
    {
        "YES",
        "Y",
        "YEAH",
        "SURE",
        "WHY NOT"
    }

    var displayInstructions = displayInstructionsAnswer switch
    {
        TextInput ti when positiveResponses.contains(ti.TextFromUser.ToUpper() =>
         true,
        _ => false
    };

    this.userInteraction.WriteMessageConditional(displayInstructions,
            "Martian Trail - Instructions"
            string.Empty,
            "Welcome to the Planet Mars, brave explorer.  Here are the",
            "things you need to know in order to survive here, on your new",
            "homeworld..."
            // Insert the rest of the instructions here...
        );
    }

Now that the player hopefully knows what they’re doing, the next step is to give them their initial bank balance and ask them to buy things for the journey ahead.

We could put that positiveResponses logic into a shared class somewhere, but as it happens there isn’t anywhere else in this codebase that needs to know whether a response was positive, so that logic can simply sit here by itself.

The Inventory Setup

Writing a function to set up the player’s Inventory is going to call for a series of wheels within wheels. We require not only a loop to move from inventory item to item, but also a loop within each item to validate the player’s input. In addition, a bit of overarching logic determines whether the player has overspent.

We’re going to move from inventory item to item, and in each case ask the player what they’d like to spend on it. If their choice is invalid, we’ll ask them to try again until we get an answer we like.

The player has a total of 1,000 Terran credits to play with.³ The only rules for each iteration of the inventory selection are that the spending must be 0 or more, and that it can’t be greater than the current number of credits remaining.

At the end of the entire sequence, we’ll prompt the player with a list of their choices, and ask whether they’re happy. If they are, we can move on. Otherwise, it’s time to loop back to the beginning and try the whole thing again.

The GameState object will have a section for inventory, but this section has its own metadata (a bool that records whether the player is happy with their selection) which is of no use later, so let’s create a state record specifically for this section:

public record InventorySelectionState
{
    public int NumberOfBatteries { get; set; }
    public int Food { get; set; }
    public int LaserCharges { get; set; }
    public int AtmosphereSuits { get; set; }
    public int MediPacks { get; set; }
    public int Credits { get; set; }
    public bool PlayerIsHappyWithSelection { get; set; }
}

We’ll also need a cross-application domain version that doesn’t contain the additional metadata and can be passed around between modules:

public record InventoryState
{
    public int NumberOfBatteries { get; set; }
    public int Food { get; set; }
    public int LaserCharges { get; set; }
    public int AtmosphereSuits { get; set; }
    public int MediPacks { get; set; }
    public int Credits { get; set; }
}

The next step is to set up an indefinite loop that is looking for a happy player to allow the loop to complete. Strictly speaking, the concept of classes isn’t a thing in FP, but in the C# world, we have a few choices.

If you want to go down the more purely functional route, create a static class called InventorySelection and have a static function within that to return an Inventory record. This will be done only after the final selections have been made.

This isn’t conducive to good unit testing, though. It’d need all sorts of User​Interac⁠tion mock setups to be created for every unit test that touches the main game module. It’s less purely functional, but given this is C#, I’d rather continue to use classes and interfaces so that we can more easily provide mocks during unit tests.

The interface for the inventory selection module looks like this:

public interface IInventorySelection
{
 InventoryState SelectInitialInventory(IPlayerInteraction playerInteraction);
}

Next, put the InventorySelectionState record, this interface, and its implementation all together in a folder called InventorySelection in the project. This way, we’re keeping everything grouped together logically.

This approach also allows the InventorySelectionState to be expanded later, if we think of some other metadata we want to throw in after improving the game, but the cross-domain version InventoryState can stay as it is, not needing to know what’s happened internally within this module.

Create a new class in the InventorySelection folder called SelectInitialInventoryClient, which should implement IInventorySelection.

To represent the outcome of each attempt by the player to select a usable value for the current inventory item, let’s create a DU to represent every eventuality:

public InventoryState SelectInitialInventory(IPlayerInteraction pInteract)
{
    throw new NotImplementedException();
}

public abstract class InventorySelectionResult { }

public class InventorySelectionInvalidInput { }

public class InventorySelectionValueTooLow { }

public class InventorySelectionValueTooHigh { }

public class InventorySelectionValid
{
    public int QuantitySelected { get; set; }
    public int UpdatedCreditsAmount { get; set; }
}

We’ve defined this within the SelectInitialInventoryClient class, since it’ll never be used anywhere else. I wouldn’t blame you for wanting to use less verbose class names, but I like my code to be descriptive.

To save effort, we can create a generic function to handle all the inventory selections. We’d just need to pass it the parts of the logic that would change every time:

• The name of the inventory item

• The place within InventorySelectionState to update

• The cost in credits of the items being bought

It might look something like this:

private InventorySelectionState MakeInventorySelection(
    IPlayerInteraction playerInteraction,
    InventorySelectionState oldState,
    string name,
    int costPerItem,
    Func<int, InventorySelectionState, InventorySelectionState> updateFunc)
{
    var numberAffordable = oldState.Credits / costPerItem;
    var validateUserChoice = (int x) => x >= 0 && x <= numberAffordable;

        var userAttempt = playerInteraction.GetInput(
        name + " Selection.  They cost " +
        costPerItem + "per item.  How many would you like? " +
         " You can't afford more than " +
         numberAffordable);

    var validUserInput = userAttempt.IterateUntil(
        x =>
        {
            var userMessage = userAttempt switch
            {
                IntegerInput i when i.IntegerFromUser < 0 =>
                 "That was less than zero",
                IntegerInput i when
                 (i.IntegerFromUser * costPerItem) > oldState.Credits =>
                  "You can't accord that many!",
                IntegerInput _ => "Thank you",
                EmptyInput => "You have to enter a value",
                TextInput => "That wasn't an integer value",
                UserInputError e => "An error occurred: " +
                 e.ExceptionRaised.Message
            };

            playerInteraction.WriteMessage(userMessage);

            return x is IntegerInput ii && validateUserChoice(ii.IntegerFromUser)
                ? x
                : playerInteraction.GetInput("Please try again...");
        }, x => x is IntegerInput ii && validateUserChoice(ii.IntegerFromUser));

    var numberOfItemsBought = (validUserInput as IntegerInput).IntegerFromUser;

    var updatedInventory = updateFunc(numberOfItemsBought, oldState) with
    {
        Credits = oldState.Credits - (numberOfItemsBought * costPerItem)
    };

    return updatedInventory;
}

Let’s consider for a few minutes what this function is doing.

First, we’re including everything it needs in the parameters list to keep it pure. If you want, you could have the constructor to this class contain the IPlayerInteraction instance, and reference that as a property of the class. It would save a bit of code noise, and there’s nothing wrong with doing it that way. I’ll leave the choice to you.

Next, we’re making an initial attempt at getting the player’s choice, and then iterating on that indefinitely until we’re certain it’s a valid choice. We’ve held the logic to validate the number of items bought as a Func delegate, so we can reference it multiple times without repeating the same code.

Inside the indefinite iteration, we’re determining exactly what was entered by the player, determining what to say back to them, and then choosing whether to iterate again.

Figure 13-2 shows what this process looks like in diagram form.

Figure 13-2. The initial purchases process

An interesting phenomenon to note: Visual Studio will complain about the casting of validUserInput into an IntegerInput as a possible null reference exception, even though there is nothing else it could ever logically be. I’d guess that Visual Studio simply can’t see deeply enough into the code to understand that no null value is possible. The compiler warning can be ignored safely in this instance.

Sadly, so far as I’m aware, it’s not currently possible to have lambda expressions in tuples as of .NET 7, so we can create a quick struct to wrap the inventory configurations instead:

public struct InventoryConfiguration
{
    public string Name { get; set; }
    public int CostPerItem { get; set; }
    public Func<int, InventorySelectionState, InventorySelectionState>
     UpdateFunc { get; set; }

    public InventoryConfiguration(
     string name,
     int costPerItem,
     Func<int, InventorySelectionState, InventorySelectionState> updateFunc)
    {
        Name = name;
        CostPerItem = costPerItem;
        UpdateFunc = updateFunc;
    }

}

This is how I created the inventory configurations. The prices I’ve chosen here are a little arbitrary. Feel free to tinker around with them if you want to try developing this game yourself:

private readonly IEnumerable<InventoryConfiguration> _inventorySelections = new[]
{
    new InventoryConfiguration("Batteries", 50, (q, oldState) =>
        oldState with { NumberOfBatteries = q}),
    new InventoryConfiguration("Food Packs", 10, (q, oldState) =>
        oldState with { Food = q}),
    new InventoryConfiguration("Laser Charges ", 40, (q, oldState) =>
        oldState with { LaserCharges = q}),
    new InventoryConfiguration("Atmosphere Suits", 15, (q, oldState) =>
        oldState with { AtmosphereSuits = q}),
    new InventoryConfiguration("MediPacks", 30, (q, oldState) =>
        oldState with { MediPacks = q})
};

I’m aware it’s probably not all that much work to do something clever with reflection and remove this entire array with a few lines of code, but I’m not sure what the benefit is going to be. The code is unlikely to be updated often, if at all, and reflection has a performance cost, as well as potentially giving rise to problems if things don’t match up at runtime.

Here’s a function to display the current state of the inventory:

private void DisplayInventory(IPlayerInteraction playerInteraction,
 InventorySelectionState state) =>
    playerInteraction.WriteMessage(
        "Batteries: " + state.NumberOfBatteries,
        "Food Packs: " + state.Food,
        "Laser Charges: " + state.LaserCharges,
        "Atmosphere Suits: " + state.AtmosphereSuits,
        "MediPacks: " + state.MediPacks,
        "Remaining Credits: " + state.Credits
    );

We’ll use this here and there so the player can make informed choices.

Here’s how we’d code a request to the player to confirm whether they’re happy with the selection of inventory purchases:

private InventorySelectionState UpdateUserIsHappyStatus(
 IPlayerInteraction playerInteraction,
    InventorySelectionState oldState)
{
    var yes = new[]
    {
        "Y",
        "YES",
        "YEP",
        "WHY NOT",
    };

    var no = new[]
    {
        "N",
        "NO",
        "NOPE",
        "ARE YOU JOKING??!??",
    };

    this.DisplayInventory(playerInteraction, oldState);

    bool GetPlayerResponse(string message)
    {
        var playerResponse = playerInteraction.GetInput(message);
        var validatedPlayerResponse = playerResponse switch
        {
            TextInput ti when yes.Contains(ti.TextFromUser.ToUpper()) => true,
            TextInput ti when no.Contains(ti.TextFromUser.ToUpper()) => false,
            _ => GetPlayerResponse("Sorry, could you try again?")
        };
        return validatedPlayerResponse;
    };

    return (oldState with
    {
        PlayerIsHappyWithSelection = GetPlayerResponse(
         "Are you happy with these purchases?")
    }).Map(x => x with
    {
        Credits = x.PlayerIsHappyWithSelection ? x.Credits : 1000
    });
}

Note the use of a recursive function here. It was the simpler choice in this situation, and there are unlikely to be that many wrong attempts at entering some variation on yes or no, so it’s a fairly safe thing to use here.

Finally, we need to make a public implementation of the SelectInitialInventory() function that puts everything together:

public InventoryState SelectInitialInventory(IPlayerInteraction playerInteract)
{
    var initialState = new InventorySelectionState
    {
        Credits = 1000
    };

    var finalState = initialState.IterateUntil(x =>
            this._inventorySelections.Aggregate(x, (acc, y) =>
                    this.MakeInventorySelection(
                     playerInteract, acc, y.Name, y.CostPerItem, y.UpdateFunc)
            ).Map(y => this.UpdateUserIsHappyStatus(playerInteract, y))
        , x => x.PlayerIsHappyWithSelection);

    var returnValue = new InventoryState
    {
        NumberOfBatteries = finalState.NumberOfBatteries,
        Food = finalState.Food,
        LaserCharges = finalState.LaserCharges,
        AtmosphereSuits = finalState.AtmosphereSuits,
        MediPacks = finalState.MediPacks,
        Credits = finalState.Credits
    };
    return returnValue;
}

All done. We now have all the code required to request the player to select how many of each item of inventory they want, along with various bits of validation logic. An overarching loop will allow the player to validate their entire set of choices and decide whether to move on to playing the game.

If you want to give this code a test run quickly now, try changing your program.cs file to the following:

using MartianTrail.InventorySelection;
using MartianTrail.PlayerInteraction;

var inventory = new SelectInitialInventoryClient();
inventory.SelectInitialInventory(new PlayerInteractionClient(new ConsoleShim()));

This will create the class that will create the initial inventory for the player, and also pass in all the real implementations of the interfaces it depends on.

This game is small and simple enough that there’s no real point in creating an IoC container—unless you really want to. It’s your code!

The Game Loop

Now that we have some of the basic structure set, the first thing needed for an actual playable game is a basic loop that represents the player’s turn. These turns consist of a message from the game, prompting the player to make a choice, and the player’s choice and its consequences.

We need an indefinite loop that continues until the game has ended, one way or another. For that, we’ll also need a GameState record. Let’s create it now with a couple of properties:

public record GameState
{
    public bool PlayerIsDead { get; set; }
    public bool ReachedDestination { get; set; }
}

To drive the indefinite loop, use the IterateUntil() extension method from Chapter 9, which we can place in a file called FunctionalExtensions.cs.

Finally, for the loop, we want to keep the code nice and neat when we’re defining the flow of the game turn, so let’s also create an extension method to continue the progress of the turn that will internalize the logic that checks to see whether the game has ended. It’s a technique inspired by the Bind() function attached to some monads:

public static GameState ContinueTurn(
    this GameState @this,
    Func<GameState, GameState> f) =>
    @this.ReachedDestination || @this.PlayerIsDead
        ? @this
        : f(@this);

This means we can chain together many functions that create new instances of the GameState record, but we won’t be required to make a check after every update to see whether the game has ended already. This will act somewhat like a two-state Maybe monad and not execute any functions provided in the event of the game ending.

Each game module after this point takes the form of a function that takes the current instance of the GameState record and returns a new, modified GameState to replace it with.

In fact, it’s easy enough to create a generic interface that represents any given phase of the game. So that’s just what we’ll do:

public interface IGamePhase
{
    GameState DoPhase(IPlayerInteraction playerInteraction, GameState oldState);
}

Consequently, the entirety of the loop that powers the game engine can now be written in a fairly simple bit of code:

public class Game
{
    public GameState Play(
     GameState initialState,
     IPlayerInteraction playerInteraction,
     params IGamePhase[] gamePhases)
    {
        var gp = gamePhases.ToArray();

        var finalState = initialState.IterateUntil(x =>
            gp.Aggregate(x, (acc, y) =>
             acc.ContinueTurn( z => y.DoPhase(playerInteraction, z))),
            x => x.PlayerIsDead || x.ReachedDestination
        );

        return finalState;
    }
}

This class takes the initial state, and a list of all the phases of the game that will update that state. We use Aggregate() to apply the phases one after the other. Note the use of the ContinueTurn() extension method. This has the monad-like short-circuit built in that’ll stop future phases from being executed after the game has already ended.

This indefinite loop will continue to run the turn sequence again and again until either the player dies or the final destination of the expedition is reached. Either would trigger the end of the game.

Let’s define a few game phases now. Then the last job will be to reference the Game class in program.cs and pass it all the phases we’ve defined.

public interface IHttpClient
{
    Task<HttpResponseMessage> GetAsync(string url);
}

public class HttpClientShim : IHttpClient
{
    private readonly HttpClient _httpClient;

    public HttpClientShim(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    public Task<HttpResponseMessage> GetAsync(string url) =>
        _httpClient.GetAsync(url);
}

public interface IFetchWebApiData
{
    Task<Maybe<T>> FetchData<T>(string url);
}

public async Task<Maybe<T>> FetchData<T>(string url)
{
    try
    {
        var response = await this._httpClient.GetAsync(url);
        Maybe<string> data = response.IsSuccessStatusCode
            ? new Something<string>(await response.Content.ReadAsStringAsync())
            : new Nothing<string>();

        var contentStream = await data.BindAsync(x =>
         response.Content.ReadAsStreamAsync());
        var returnValue = await contentStream.BindAsync(x =>
         JsonSerializer.DeserializeAsync<T>(x));
        return returnValue;
    }
    catch (Exception e)
    {
        return new Error<T>(e);
    }
}

public class NasaMarsData
{
    public IEnumerable<NasaSolData> soles { get; set; }
}

public class NasaSolData
{
    public string id { get; set; }
    public string sol { get; set; }
    public string max_temp { get; set; }
    public string min_temp { get; set; }
    public string local_uv_irradiance_index { get; set; }

}

public class DisplayMartianWeather : IGamePhase
{
    private readonly IFetchWebApiData _webApiClient;

    public DisplayMartianWeather(IFetchWebApiData webApiClient)
    {
        _webApiClient = webApiClient;
    }

    private string FormatMarsData(NasaSolData sol) =>
        "Mars Sol " + sol.sol + Environment.NewLine +
        "	Min Temp: " + sol.min_temp + Environment.NewLine +
        "	Max Temp: " + sol.max_temp + Environment.NewLine +
        "	UV Irradiance Index: " + sol.local_uv_irradiance_index +
         Environment.NewLine;


    public GameState DoPhase(
        IPlayerInteraction playerInteraction,
        GameState oldState)
    {

    // I'm calling Result here, which forces this to be synchronous.
    // This isn't a web app, there is only a single user, so I'm not
    // really very concerned.
        var data =
            this._webApiClient.FetchData<NasaMarsData>(
            "https://mars.nasa.gov/rss/api/?" +
            "feed=weather&category=msl&feedtype=json")
             .Result;

        var currentSolData = data.Bind(x => oldState.CurrentSol == 0
            ? x.soles.MaxBy(y => int.Parse(y.sol))
            : x.soles.SingleOrDefault(y =>
                y.sol == oldState.CurrentSol.ToString())
        );

        var formattedData = currentSolData.Bind(FormatMarsData);

        var message = formattedData switch
        {
            Something<string> s => s.Value,
            _ => string.Empty
        };

        playerInteraction.WriteMessage(message);

        return oldState with
        {
            CurrentSol = currentSolData is Something<NasaSolData> s1
             ? int.Parse(s1.Value.sol) + 1
             : 0
        };
    }
}

public interface IRandomNumberGenerator
{
    int BetweenZeroAnd(int input);
}

public class RandomNumberGenerator : IRandomNumberGenerator
{
    public int BetweenZeroAnd(int input) =>
        new Random().Next(0, input);
}

public enum PlayerActions
{
    Unavailable,
    TradeAtOutpost,
    HuntForFood,
    HuntForFurs,
    PushOn
}

public class SelectAction : IGamePhase
{
    private readonly IRandomNumberGenerator _rnd;
    private readonly IPlayerInteraction _playerInteraction;



    public SelectAction(
        IRandomNumberGenerator rnd,
        IPlayerInteraction playerInteraction)
    {
        _rnd = rnd;
        _playerInteraction = playerInteraction;
    }

    public GameState DoPhase(
        IPlayerInteraction playerInteraction,
        GameState oldState)
    {
        // TODO
    }
}

var isWilderness = this._rnd.BetweenZeroAnd(100) > 33;
var isTradingOutpost = this._rnd.BetweenZeroAnd(100) > (isWilderness ? 90 : 10);
var isHuntingArea = this._rnd.BetweenZeroAnd(100) > (isWilderness ? 10 : 20);

var canHuntForFurs = isHuntingArea && this._rnd.BetweenZeroAnd(100) > (33);
var canHuntForFood = isHuntingArea && this._rnd.BetweenZeroAnd(100) > (33);

var options = new[]
    {
        isTradingOutpost
            ? PlayerActions.TradeAtOutpost
            : PlayerActions.Unavailable,
        canHuntForFood ? PlayerActions.HuntForFood : PlayerActions.Unavailable,
        canHuntForFurs ? PlayerActions.HuntForFurs : PlayerActions.Unavailable,
        PlayerActions.PushOn
    }.Where(x => x != PlayerActions.Unavailable)
    .Select((x, i) => (
        Action: x,
        ChoiceNumber: i + 1
    )).ToArray();

var messageToPlayer = string.Join(Environment.NewLine,
    new[]
    {
        "The area you are passing through is " + (isWilderness
         ? " wilderness"
         : "a small settlement"),
        "Here are your options for what you can do:"
    }.Concat(
        options.Select(x => "	" + x.ChoiceNumber + " - " + x.Action switch
        {
            PlayerActions.TradeAtOutpost => "Trade at the nearby outpost",
            PlayerActions.HuntForFood => "Hunt for food",
            PlayerActions.HuntForFurs => "Hunt for Lophroll furs to sell later",
            PlayerActions.PushOn => "Just push on to travel faster"
        })
    )
);

this._playerInteraction.WriteMessage(messageToPlayer);

var playerChoice = this._playerInteraction.GetInput(
     "What would you like to do? ");
var validatedPlayerChoice = playerChoice.IterateUntil(
    x => this._playerInteraction.GetInput(
    "That's not a valid choice.  Please try again."),
    x => x is IntegerInput i && options.Any(y =>
    y.ChoiceNumber == i.IntegerFromUser));

var playerChoiceInt = (validatedPlayerChoice as IntegerInput).IntegerFromUser;
var actionToDo = options.Single(
 x => x.ChoiceNumber == playerChoiceInt).Action;

Func<GameState, GameState> actionFunc = actionToDo switch
{
    PlayerActions.TradeAtOutpost => DoTrading,
    PlayerActions.HuntForFood => DoHuntingForFood,
    PlayerActions.HuntForFurs => DoHuntingForFurs,
    PlayerActions.PushOn => DoPushOn
};

var updatedState = actionFunc(oldState);

return updatedState with
{
  UserActionSelectedThisTurn = actionToDo
};

private GameState DoPushOn(GameState state) => state;

namespace MartianTrail.MiniGame
{
    public interface IPlayMiniGame
    {
        decimal PlayMiniGameForSuccessFactor();
    }
}

public interface ITimeService
{
    DateTime Now();
}

public class TimeService : ITimeService
{
    public DateTime Now() => DateTime.Now;
}

private static decimal RateAccuracy(string expected, string actual)
{
    var charByCharComparison = expected.Zip(actual,
        (x, y) => char.ToUpper(x) == char.ToUpper(y));
    var numberCorrect = charByCharComparison.Sum(x => x ? 1 : 0);
    var accuracyScore = (decimal)numberCorrect / 4;
    return accuracyScore;
}

public decimal PlayMiniGameForSuccessFactor()
{
    // I don't care what the user enters, I'm just getting them ready to
    // play.
    _ = this._playerInteraction.GetInput(
        "Get ready, the mini-game is about to begin.",
        "Press enter to begin....");

    var lettersToSelect = Enumerable.Repeat(0, 4)
        .Select(_ => this._rnd.BetweenZeroAnd(25))
        .Select(x => (char)('A' + x))
        .ToArray();

    var textToSelect = string.Join("", lettersToSelect);

    var timeStart = this._timeService.Now();

    var userAttempt = this._playerInteraction.GetInput(
        "Please enter the following as accurately as you can: " +
        textToSelect);

    var nonErrorInput = userAttempt is not UserInputError
        ? userAttempt
        : userAttempt.IterateUntil(
        x => this._playerInteraction.GetInput(
            "Please enter the following as accurately as you can: " +
            textToSelect),
        x => x is not UserInputError
    );

    var timeEnd = this._timeService.Now();

    var textAccuracy =
        nonErrorInput is TextInput { TextFromUser.Length: 4 } ti
            ? RateAccuracy(textToSelect, ti.TextFromUser)
            : 0M;

    var timeTaken = (timeEnd - timeStart).TotalSeconds;
    var timeAccuracy = 1M - (0.1M * (decimal)timeTaken);

    return textAccuracy * timeAccuracy;
}

private GameState DoHuntingForFood(GameState state)
{
    this._playerInteraction.WriteMessage("You're hunting Vrolids for food.",
        "For that you'll have to play the mini-game...");

    var accuracy = this._playMiniGame.PlayMiniGameForSuccessFactor();

    var message = accuracy switch
    {
       >= 0.9M => new[]
       {
           "Great shot!  You brought down a whole load of the things!",
           "Vrolid burgers are on you today!"
       },
       0 => new[]
       {
           "You missed.  Were you taking a nap?"
       },
       _ => new []
       {
           "Not a bad shot",
           "You brought down at least a couple",
           "Don't go too crazy eating tonight"
       }
    };

    this._playerInteraction.WriteMessage(message);

    var laserChargesUsed = 50 * (1 - accuracy);
    var foodGained = 100 * accuracy;

    return state with
    {
        Inventory = state.Inventory with
        {
            LaserCharges = state.Inventory.LaserCharges - (int)laserChargesUsed,
            Food = state.Inventory.Food + (int)foodGained
        }
    };
}

public GameState DoPhase(
    IPlayerInteraction playerInteraction,
    GameState oldState)
{
    playerInteraction.WriteMessage("End of Sol " + oldState.CurrentSol);
    var distanceTraveled = oldState.Inventory.NumberOfBatteries *
        (oldState.UserActionSelectedThisTurn == PlayerActions.PushOn ? 100 : 50);

    var batteriesUsedUp = this._rnd.BetweenZeroAnd(4);

    var foodUsedUp = this._rnd.BetweenZeroAnd(5) * 20;

    var newState = oldState with
    {
        DistanceTraveled = oldState.DistanceTraveled + distanceTraveled,
        Inventory = oldState.Inventory with
        {
            NumberOfBatteries = (oldState.Inventory.NumberOfBatteries -
             batteriesUsedUp)
                .Map(x => x >= 0 ? x : 0),
            Food = (oldState.Inventory.Food - foodUsedUp)
                .Map(x => x >= 0 ? x : 0)
        }
    };

    playerInteraction.WriteMessage("You have traveled " + distanceTraveled +
        " this Sol.",
    "That's a total distance of " + newState.DistanceTraveled);

    playerInteraction.WriteMessageConditional(batteriesUsedUp > 0,
        "You have " + newState.Inventory.NumberOfBatteries + " remaining");

    playerInteraction.WriteMessageConditional(foodUsedUp > 0,
        "You have " + newState.Inventory.Food + " remaining");

    return newState;
}