Pausing a program to allow user to interact in wpf

Question

Ok, so this is a kind of general program. I am trying to write a poker program where the user can interact against computer players. However, in order to simplify it I am testing with a much simpler program where two players are trying to guess a number from the computer. One is a human player and the other is a computer player.

In the game, the players take turn to guess the number beeing set by the program. The computer player just randomizes numbers, where as the user should input a number and press a guess button (or have the option to quit).

My problem is that when it is the humans players turn to act, how can I pause the excecution of the game in order for the human to respond by pressing a button or enter text?

I have tried with using Timer and starting it and waiting for the thread to end but it seems as if that still freezes the gui.

I have also tried to send messages from a background worker thread to update the gui but that gives me an error about not beeing able to access the gui elements from another thread.

Does anyone have any suggestions on how to implement this?

Note that this is not a complete program, since I just made this to understand how to interact with the gui during execution.

The number guesser class:

public class NumberGuesser {

    public Player HumanPlayer { get; private set; }

    public Player ComputerPlayer { get; private set;}

    private Player[] _players = new Player[2];

    private int _maxNumber = 20;

    private bool _done = false;

    private Random random;

    public NumberGuesser() {

        HumanPlayer = new HumanPlayer("Me");

        ComputerPlayer = new ComputerPlayer("HAL9000");

        _players[0] = HumanPlayer;
        _players[1] = ComputerPlayer;

        random = new Random((int) DateTime.Now.Ticks);

    }

    public void Play() {

        var myNumber = random.Next(_maxNumber);
        var index = 0;
        while (!_done) {

            var currentPlayer = _players[index];

            var guess = currentPlayer.Act(_maxNumber);
            if (guess == myNumber) {
                currentPlayer.Score++;
            }

            index = (1 + index)%2;
        }

    }
}

The computer player:

public class ComputerPlayer : Player {

    private readonly Random _random = new Random((int)DateTime.Now.Ticks);

    public ComputerPlayer(string name) : base(name) {
    }

    public override int Act(int max) {

        return _random.Next(max);

    }
}

The human player:

public class HumanPlayer : Player {

    public HumanPlayer(string name) : base(name) {

    }

    public override int Act(int max) {

        return UserGuess();

    }

    private int UserGuess() {


        return 0;

    }
}

The player class:

public class Player {
    public string Name { get; private set; }
    public int Score { get; set; }

    public Player(string name) {
        Name = name;
    }


    public virtual int Act(int max) {
        // How should the human enter the guess here???
        return 0;
    }
}

My main window:

And the code behind:

/// 
/// Interaction logic for MainWindow.xaml
/// 
public partial class MainWindow : Window {

    private readonly NumberGuesser _numberGuesser;

    public MainWindow() {
        InitializeComponent();
        _numberGuesser = new NumberGuesser();
        DataContext = _numberGuesser;

    }

    private void buttonStartPlay_Click(object sender, RoutedEventArgs e) {

        _numberGuesser.Play();

    }

}

Tim S. · Accepted Answer

You have to approach the problem from a different perspective. Instead of having a method that runs synchronously which asks the user to act, like you might interact with your local computer, you need to request it, and then wait asynchronously for something (e.g. an event) to tell you the user has finished. (more similar to requesting something of a remote computer)

Here's something to get you started:

public abstract class Player
{
    public string Name { get; private set; }
    public int Score { get; set; }

    public Player(string name)
    {
        Name = name;
    }

    public abstract void ActAsync(int max);

    public virtual event EventHandler ActComplete;
}
public class ActEventArgs : EventArgs
{
    public int Result { get; private set; }
    public ActEventArgs(int result)
    {
        this.Result = result;
    }
}
public class HumanPlayer : Player
{
    public HumanPlayer(string name)
        : base(name)
    {
    }

    public override void ActAsync(int max)
    {
        // button1 should be the user's guess button; anything else you need to do to allow them to interact should be done here
        button1.IsEnabled = true;
        // this will result in a handler being added each time the user is asked to act; you'll actually want to attach just once
        button1.Click += (s, e) =>
            {
                button1.IsEnabled = false;
                if (ActComplete != null)
                    ActComplete(this, new ActEventArgs(int.Parse(data.HumanGuess))); // data.HumanGuess is their input, as a string
            };
    }

    public override event EventHandler ActComplete;
}
public class ComputerPlayer : Player
{
    private readonly Random _random = new Random((int)DateTime.Now.Ticks);

    public ComputerPlayer(string name)
        : base(name)
    {
    }

    public override void ActAsync(int max)
    {
        if (ActComplete != null)
            ActComplete(this, new ActEventArgs(_random.Next(max)));
    }
    public override event EventHandler ActComplete;
}

Edit: Compared to Jmyster's solution (IMHO): his is better for simple interactions, i.e. local-user-to-local-computer, but if you're planning on expanding this into multi-user scenarios, events will be better.

Pausing a program to allow user to interact in wpf

Answers (2)

Related Questions