How can I wait for another method to be triggered before continuing the current method while still displaying the UI

I am trying to write a chess program in C# Windows Forms and I am writing a method GetMove() in this HumanPlayer class I have, which will return the Move from a player input of two clicks on separate squares on the board UI.

Could I have some help / advice on what I should use to implement this or if I am misunderstanding something else, explain that to me.

I've tried to add code snippets, but please let me know if I've done them wrong.

    class HumanPlayer : Player
    {
        private Coords _selected;
        public HumanPlayer(PieceColour colour) : base(colour) 
        {
            _selected = new Coords();
        }

        public override ChessMove GetMove(Board board) 
        {
            Coords Start = new Coords();
            board.RaiseSquareClicked += ReceiveStartSquareClickInfo;
            // Want to wait until that function is triggered by the event until continuing
            Start = _selected;
            board.RaiseSquareClicked -= ReceiveStartSquareClickInfo;

            Coords End = new Coords();
            board.RaiseSquareClicked += ReceiveEndSquareClickInfo;
            // Want to wait until that function is triggered by the event until continuing
            End =  _selected;
            board.RaiseSquareClicked -= ReceiveEndSquareClickInfo;
            return new ChessMove(Start, End);
        }

        public void ReceiveStartSquareClickInfo(object sender, SquareClickedEventArgs e)
        {
            _selected = e.Square.Coords;
        }

        public void ReceiveEndSquareClickInfo(object sender, SquareClickedEventArgs e)
        {
            _selected = e.Square.Coords;
        }
    }

One thing I tried was using AutoResetEvent and WaitOne() and Set(), but this caused the UI to stop displaying.

I also tried to understand and use await and async, but I just confused myself and overcomplicated it and didn't get anywhere with it. So it might just be that I need someone to explain it to me.

This code that doesn't work might help someone understand what I misunderstand about asynchronous functions etc.

    public async void Play()
    {
        _currentPlayer = _players[0];
        _currentTurn = 1;
        while (!GameOver())
        {
            ChessMove move= await _currentPlayer.GetMove(_board);
            if (_currentPlayer == _players[1])
            {
                _currentTurn += 1;
                _currentPlayer = _players[0];
            }
            else
            {
                _currentPlayer = _players[1];
            }
        }
    }

    class HumanPlayer : Player
    {
        private Coords _selected;
        private TaskCompletionSource<bool> _squareClicked;
        public HumanPlayer(PieceColour colour) : base(colour) 
        {
            _selected = new Coords();
        }

        public override async Task<ChessMove> GetMove(Board board) 
        {
            Coords Start = new Coords();
            _squareClicked = new TaskCompletionSource<bool>();
            board.RaiseSquareClicked += ReceiveStartSquareClickInfo;
            _squareClicked.Task.Wait();
            Start = _selected;
            board.RaiseSquareClicked -= ReceiveStartSquareClickInfo;

            Coords End = new Coords();
            _squareClicked = new TaskCompletionSource<bool>();
            board.RaiseSquareClicked += ReceiveEndSquareClickInfo;
            _squareClicked.Task.Wait();
            End =  _selected;
            board.RaiseSquareClicked -= ReceiveEndSquareClickInfo;
            return new ChessMove(Start, End);
        }
        public async void ReceiveStartSquareClickInfo(object sender, SquareClickedEventArgs e)
        {
            _squareClicked.SetResult(true);
            _selected = e.Square.Coords;
        }

        public async void ReceiveEndSquareClickInfo(object sender, SquareClickedEventArgs e)
        {
            _squareClicked.SetResult(true);
            _selected = e.Square.Coords;
        }
    }

I've kinda been hesitant / nervous to post this question because I don't want people to get annoyed at me for posting a "duplicate question". Even though I've looked through several of the questions, it is confusing and frustrating not knowing whether the solution just doesn't apply to my situation or if I've added it in wrong. I'm sure I could find my solution answered in another question, but I feel it would take me a lot longer to find it and understand it than posting my own question.

Sorry if I've posted this question wrong or not followed the guidelines, this is my first post here.
If I've done anything wrong in formatting / communicating through this post, let me know and I'll try to fix it.

Good question, from what I can understand, your wanting to wait on a response from another method before executing yours.

Using async/await is the best option for this, if your getting confused at that, there are some tutorials and such you can follow

• https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/await
• https://learn.microsoft.com/en-us/dotnet/csharp/asynchronous-programming/
• https://dotnettutorials.net/lesson/async-and-await-operator-in-csharp/

TaskCompletionSource is a class in C# that enables creating a Task object which can be manually completed with a result or exception.

class Example
{
    TaskCompletionSource<string> taskCompletionSource = new();
    
    public async Task DoStuff()
    {
        // Wait for the result of the TaskCompletionSource
        var result = await taskCompletionSource.Task;

        Console.WriteLine(result);
    }

    public void SetResult(){
        taskCompletionSource.SetResult("Hello World!");
    }

}

In this example, calling to DoStuff method will wait until the SetResult method is called, which will then set the result variable to "Hello World!"

Your post states that you want to wait for another method to be triggered before continuing and then describes three "states of play" so my first suggestion is to identify in code exactly the things we need to wait for in the chess game loop.

enum StateOfPlay
{
    PlayerChooseFrom,
    PlayerChooseTo,
    OpponentTurn,
}

Game Loop

The goal is to run a loop that cycles these three states continuously, waiting at each step. However, the main Form is always running its own Message Loop to detect mouse clicks and key presses and it's important not to block that loop with our own.

The await keyword causes a waiting method to return immediately which allows the UI loop to keep running. But when "something happens" that we're waiting for, the execution of this method will resume on the next line after the await. A semaphore object says when to stop or go and is initialized here in the waiting state.

SemaphoreSlim _semaphoreClick= new SemaphoreSlim(0, 1); 

When the game board is clicked during the players turn then the Release() method will be called on the semaphore, allowing things to resume. In terms of the specific question that you asked, this code snippet shows how to use the await keyword in your chess game loop.

private async Task playGameAsync(PlayerColor playerColor)
{
    StateOfPlay = 
        playerColor.Equals(PlayerColor.White) ?
            StateOfPlay.PlayerChooseFrom :
            StateOfPlay.OpponentTurn;

    while(!_checkmate)
    {
        switch (StateOfPlay)
        {
            case StateOfPlay.PlayerChooseFrom:
                await _semaphoreClick.WaitAsync();
                StateOfPlay = StateOfPlay.PlayerChooseTo;
                break;
            case StateOfPlay.PlayerChooseTo:
                await _semaphoreClick.WaitAsync();
                StateOfPlay = StateOfPlay.OpponentTurn;
                break;
            case StateOfPlay.OpponentTurn:
                await opponentMove();
                StateOfPlay = StateOfPlay.PlayerChooseFrom;
                break;
        }
    }
}

Player's turn

Here we have to wait for each square to get clicked. A straightforward way to do this is with a SemaphoreSlim object and call Release() when the game board is clicked during the player's turn.

Square _playerFrom, _playerTo, _opponentFrom, _opponentTo;

private void onSquareClicked(object sender, EventArgs e)
{
    if (sender is Square square)
    {
        switch (StateOfPlay)
        {
            case StateOfPlay.OpponentTurn:
                // Disabled for opponent turn
                return;
            case StateOfPlay.PlayerChooseFrom:
                _playerFrom = square;
                Text = $"Player {_playerFrom.Notation} : _";
                break;
            case StateOfPlay.PlayerChooseTo:
                _playerTo = square;
                Text = $"Player {_playerFrom.Notation} : {_playerTo.Notation}";
                richTextBox.SelectionColor = Color.DarkGreen;
                richTextBox.AppendText($"{_playerFrom.Notation} : {_playerTo.Notation}{Environment.NewLine}");
                break;
        }
        _semaphoreClick.Release();
    }
}

Opponents turn

This simulates a computer opponent processing an algorithm to determine its next move.

private async Task opponentMove()
{
    Text = "Opponent thinking";
        
    for (int i = 0; i < _rando.Next(5, 10); i++)
    {
        Text += ".";
        await Task.Delay(1000);
    }
    string opponentMove = "xx : xx";
    Text = $"Opponent Moved {opponentMove}";
    richTextBox.SelectionColor = Color.DarkBlue;
    richTextBox.AppendText($"{opponentMove}{Environment.NewLine}");
}

It might be helpful to look at another answer I wrote that describes how to create the game board with a TableLayoutPanel and how to interact with mouse to determine the square that's being clicked on.