zhukovdm/congo

🦁 Multiplatform engine for playing a chess-like strategy game

Congo

The project implements a platform for playing the board game Congo locally or over the network.

Documentation

Read Installation Instruction to find out how to install the application on different operating systems (currently Windows and Linux are supported) or build and run it from source code.

See detailed User's Manual for rules, gameplay and user interface, both graphical and terminal-based.

Consult Programmer's Guide to learn more about application architecture, algorithms and data structures used throughout the Congo project.

Credits

Special thanks to Demian Freeling for inventing the game and to Ihardlythinkso for drawings published on Wikipedia.

congo's Issues

Move generation shall not be interrupted

Lion might not be properly found.

if (piece.IsMonkey()) {
    var monkey = (Monkey)piece;
 
    allMoves.AddRange(monkey.ContinueJump(color, board, e.Current));
    break; // there is only one monkey
}

Use advanced MSTest features

A log of tests have something in common. Remove repeating code via using attributes, fixtures, etc.

Drowning is not yet implemented

Pieces other than crocodile are drown if stayed at the river.

show and exit commands

Good to have. The current player could easily get full overview at any time or exit if got sick of the command line.

Implement simplified FEN parser

Might be needed soon for network version.

8x [row format] 1x [color format] 1x [monkey format]
row format      -> 1p1Pp2p
color format    -> white | black | -
monkey format   -> m | -

Wrong user move is not properly reported

 > show moves

 (a2,a3) (a2,b3) (b2,a3) (b2,b3) (b2,c3)
 (c2,b3) (c2,c3) (c2,d3) (d2,c3) (d2,d3)
 (d2,e3) (e2,d3) (e2,e3) (e2,f3) (f2,e3)
 (f2,f3) (f2,g3) (g2,f3) (g2,g3) (a1,a3)
 (a1,c3) (c1,c3) (e1,e3) (g1,f3)

 > move d3 g4

 > 

Create doxygen documentation

• Add meaningful comments.
• Add Doxyfile for doc generation.
• Remove file assets/api.txt once generated doc is OK.

Implement proper MVC pattern in Congo.Server

Two Ai players cannot be paused

Make Pause button with manual signalling. Ai decision making should be run on parallel thread, aka BackgroundWorker.

Current board/game cannot be saved

Implement Save button with Fen-ish serialization.

Isolate instances of Algorithm

Currently, Algorithm.cs implement

Congo/Congo.Core/Algorithm.cs

Line 12 in 30eb167

public static class Algorithm

Algorithm should be synchronized with the user interface via Disable and Enable methods. The application logic becomes less transparent with a space for bugs. The solution will be to instantiate proper algorithm each time. If cancellation comes first, there will be no GUI update.

Started game can be exited, but not interrupted

Implement some kind of reset menu button.

Player should know its color

Consider different scenarios, With(...) without color, the color will never change (safer usage).

Consider migration from .NET Framework 4.8 to .NET X

Not clear which .NET version is better in terms of stability. This is the reason .NET Framework was chosen as a project basis.

Missing release of possible `Pause`

Congo/Congo.GUI/MainWindow.xaml.cs

Line 193 in 2101d62

job.Cancel();

Accept/visit pattern for getting user input

The goal is to eliminate branching.

do {
    var command = userInterface.GetUserCommand();
    if (command is AdviseCommand) {
        var advice = (AdviseCommand)command;
        move = Algorithm.GetMove(this, advice.Heuristic);
        userInterface.ReportAdvice(move, advice.Heuristic);
        move = null;
    } else if (command is ExitCommand) {
        throw new Exception(" The game has suddenly ended.");
    } else if (command is MoveCommand) {
        var unpack = (MoveCommand)command;
        move = new CongoMove(unpack.Fr, unpack.To);
        if (!isValid(move)) move = null;
    } else if (command is ShowCommand) {
        userInterface.Show(board);
    } else {
        /* do nothing */
    }
} while (move == null);

Reconsider thread-safety of the GUI project

For now, things are not obvious and messy.
Write thoughts down to explain why possible solutions are better than other and why not.

Collect Monkey jumps into chain

Monkey could continue jumping if not captured opponent's piece is near by.

Captured pieces are not necessary

Monkey captures remove opponent pieces immediately.

Method player.GetValidMove() is not general enough

Consider the game main loop from Program.cs.

while (!game.HasEnded()) {
    move = game.ActivePlayer.GetValidMove(ui, game); // <--- this row
    game = game.Transition(move);
    ui.ShowBoard(game);
    game = ui.WaitResponse(game);
}

Currently, two scenarios are possible.

• The user plays via command-line interface.
• The user is an artificial intelligence, decides moves based on an algorithm.

Due to a nature of the terminal-based applications, obtaining next move is a blocking operation. The player opposite to current player should wait until the move is decided and performed.

In the future version of game engine, we implement possibility to play locally and via network, play with terminal-based and WPF-based GUI. Waiting for the move can no longer be blocking. We want GUI to be responding, but with limited capabilities (e.g. user cannot make move before the opponent).

The approach of getting next move shall be redesigned.

Failing reset of ai/ai game

Reset sets game to null. We should follow the strategy:

• signalize stop to the algorithm run,
• wait until worker signalizes it is done,
• remove game and stop timer.

The stopping event ends here. In some next event worker finishes its post processing on null game.

Things are getting messy on waiting and interrupting worker threads. Probably, we should reconsider how to access elements in sync.

Atomic advice release

Congo/Congo.GUI/MainWindow.xaml.cs

Line 242 in b8a8af7

Algorithm.Include();

Think if the statement should happen within lock or not.

Unify interface for auto-generated gRPC `Client` routines

Both terminal-based and graphical interfaces instantiate gRPC interface via referencing congo.proto file. Code is auto-generated and can be used within only one project. This implies that different implementations of wrappers for gRPC calls exist in both Congo.CLI and Congo.GUI projects. Wrappers are easier to work with and hide implementation details.

Congo/Congo.CLI/CommandLine.cs

Lines 253 to 254 in 78ddb71

	private CongoGame getLatestGame()
	=> CongoFen.FromFen(client.GetLatestFen(new GetLatestFenRequest() { GameId = gameId }).Fen);

Congo/Congo.GUI/GrpcRoutines.cs

Lines 19 to 20 in 78ddb71

	public static CongoGame GetLatestGame(CongoGrpc.CongoGrpcClient client, long gameId)
	=> CongoFen.FromFen(getLatestFen(client, gameId));

The goal of this issue is to follow DRY principle. My previous attempts failed.

Rewrite board creation as a for-cycle

Congo/Congo.Core/Game.cs

Line 47 in b8a8af7

board = board.With(color, Giraffe.Piece, rank * board.Size + 0)

Fen format contains player information

Fen should describe only current board / position and should not describe players in any way. Players shall be a part of user interface. Fen for standard board would look like:

gmelecz/ppppppp/7/7/7/PPPPPPP/GMELECZ/w/-1

Rewrite data access layer

Old data access layer uses SQLite with very weird and unsafe approach to access data. New implementation should use Entity Framework Core and store data in a PostgreSQL instance running on the background.

It should be noted, that EF Core is an advanced dependency and the initial intent of the application was to implement a simple game engine and store data somehow.

Advice calculation cannot be interrupted

Implement interruption via (perhaps) global variable or cancellation token.

Pawn -> Superpawn promotion is not yet implemented

Pawn is promoted once reached opposite (according to the color) upper or lower border line.

Negamax uses int.MinValue -> -int.MinValue == int.MinValue

namespace ConsoleApp1 {
    class Program {
        static void Main(string[] args) {
            int a = int.MinValue;
            int b = -a;
            System.Console.WriteLine(a==b);
        }
    }
}

`gRPC` auto-generated code cannot be directly used in `WPF` application

See solution here.

Crocodile does not slide until the river

The issue is due to the new river piece.

Congo CLI and GUI do not make explicit `gRPC` channel shutdown

There are some discrepancies in the library, refer to grpc-dotnet issue #1712. Maybe Congo project should implement resource release via explicit garbage collection. The issue is relevant especially for GUI, because it supports game reset and channel = null might not be enough.

Detect winner by WhitePlayer.HasLion property

Not always opponent is a winner.

var winner = game.ActivePlayer.Color.Invert().IsWhite() ? "white" : "black";
writer.WriteLine($" {winner} wins.");

Set enum MiniMax NegaMax IterDeep lower case

Ex. minimax, negamax, ... Everything is lower case for consistency with command help page

Add better unit tests for `CongoFen` parsing

Currently there are only $9$ tests.

A player gets monkey jumps of the opponent.

newWhitePlayer = whitePlayer.With(White.Color, newBoard, newMonkeyCaptures);
newBlackPlayer = blackPlayer.With(Black.Color, newBoard, newMonkeyCaptures);

Remove unused enum

Congo/Congo.Server/Services/CongoGrpcService.cs

Line 8 in 09a0c82

public enum Color : int { White, Black }

Board.Without() does not reset piece bank

Might be a problem later (overload on board == and != static methods).

public CongoBoard Without(int position) {
    var newOccupied = occupied;
    for (int i = 0; i < 2; i++) {
        newOccupied = newOccupied.SetItem(i, setBitToValue(occupied[i], position, false));
    }
    return new CongoBoard(newOccupied, pieces);
}

Mismatch in csv row representation

Congo/Congo.Server/Services/CongoGrpcService.cs

Line 91 in 09a0c82

sw.Write("fr,to,bt\r\n");

Swap bt and to

`Negamax` evaluation is slow

Negamax fails to be fast on some inputs. Consider to redesign/optimize the existing solution.