CODEWITHSUNDEEP
c#unity-game-engine
notacountry
notacountry

Reputation: 65

Creating AI in c# to work through a simple game

I want to try and get an AI to find a sequence of moves that wins in Marble Solitaire. I've completed the system which moves a random cylinder and also the system which undoes the previous move. All I need to do now is to work out how and when the AI undoes moves. I had no idea what to do so I sort of randomly tried things, and I had enough so I decided to ask here.

Here's the code I think you need to help me solve it - feel free to ask me for more snippets, I don't just want to overload you with meaningless code:

private int index; Increases when a move has been tried my the AI, and said move didn't work. I use it to stop the program from looping over the same move without checking others.

Below is the current code I use to determine whether the AI should undo a move or not, but it doesn't seem to work as I want:

if (possibleMove.Count < index)
{
    index = 0;
    undoMove();
}
else if (possibleMove.Count == 0)
{
    undoMove();
} //possibleMove is a list of all possible Moves the AI has found

The code snippet above activates at the very end of findMove()

The general format of the code goes like this:

private void findEmpty()
{
    findMove();
}
private void findMove()
{
    makeMove();
}
private void makeMove()
{

}
private void undoMove()
{

}

Rules of Marble Solitaire

The player makes successive capturing moves, removing a single piece each turn until is it impossible to make any more capturing moves.

Each turn, the player captures a piece by jumping over that piece in any direction (not diagonally) from two spaces away a vacant point, making sure that there is a piece you can jump over.

Therefore, the first turn can be made only by jumping a piece into the middle hole from one of 4 possible points.

Image of marble solitaire:

enter image description here

Upvotes: 1

Views: 338

Answers (1)

Tankruds
Tankruds

Reputation: 36

You can do this with the BFS method of graph searching. What you can do is find a way to represent the board, it can be an array of booleans to represent marbles or gaps or anything you can think of, so long as it's easy for you to understand and manipulate.

Then you would have a queue that so far only holds the initial state of the board. You then set your current state to the first state in the queue and then remove it from the queue. You can now use findMoves(currentState) to return a list of states that you can access from this current move. Add each of those states to the end of the queue, and then once again set your current state to the first state in the queue and remove it and use findMoves repeatedly until your current state matches some sort of goal state. In your particular problem you can just run this until findMoves(currentState) returns an empty array since that would mean there are no more moves for you to be able to do.

That would get you to a solution, however it wouldn't keep track of the path for you. You can keep track of the path itself in any number of ways, for example instead of adding just the next state to the queue you can add an array of all of the states so far in that path and just use the last value when calculating the next states you can go to. But that's just an example.

Upvotes: 2

Related Questions