bakkes/karo

Karo engine in c++ with XNA frontend

karo's Issues

Simple AI with mini-max algorithm

Create an AI player that uses the mini-max algorithm. Plus points if depth level is easily changed.
Also create an interface for the computer player (so we could easily add other AI implementations).

Create a 3D frontend with XNA

Memory leak with GetLegalMoves

GetLegalMoves in MoveFinder creates a new vector, but the classes that use this method don't delete this vector.

Create XNA project

Sounds simple, but it'll need to work with the Engine project and the Wrapper project. This caused some problems with the 2D frontend.

Move diff of 19 should be -1

our relatavie absolute converter can't detect negative moves, so it will return -1+width or height. these are always 20 so to the result is 19.

the easiest way to fix this is in the move constructor, detect the difference between from and to, if its 19 it should be -1

Show possible moves in 2d frontend

The following stuff should be shown in the 2d frontend:

• The current player
• The current clickable tiles

This makes debugging easier.

Interface for the computer player (AI)

Create a generic interface that can create a move.

The AI and front end need to be able to determine a win state

Integrate loading beachball with the game

The beachball is added as a service (ILoadingComponent) and can be used (see #42). When #41 is done the beachball can be implemented.

After the insert state during a player vs computer game, you will be able to control both players.

This probably was introduced with the WaitForUndo state.

Interface for static evaluation function.

Create an interface that takes a board and returns a value representing the state of the game.

Heap corruptions and access violations appear after some time

The XNA frontend should have a clearly defined 3D board.

There should be a loading screen (showing a beachball)

It's impossible to select tiles that currently dont exist in the XNA Frontend.

This should be possible, otherwise you cant make moves that go out the board.

Create a simple static evaluation function

Nothing too fancy. We could create better ones/improve this one in a later stage of the project.

Create a managed C++/CLR wrapper for our engine we can use in C#.

See #14

XNA Frontend will show the correct pieces on the correct position.

Includes flipped pieces, max and min pieces, etc. Does not include animations.

There should be a 2D test frontend in C#

This frontend could be made in C#. It is only useful for testing and is not part of the end product, so it shouldn't be too complicated. C# with winforms maybe?

Implement the communicationprotocol in the 3D frontend

Our frontend should be able to communicate with those from other projects. Our XNA frontend must therefore use the communicationprotocol.

The communicationprotocol itself should not be changed. If we change it, we might break compatibility with the applications of other projects in our class.

After move execution from and to cells should be yellow

Interface for the Board class.

Implement camera movement as specified in requirements

Board/moves must be exposed with relative positions instead of absolute

Implement clicking on tiles in 3D frontend

The user wants to be able to click on objects in the 3d world.

Add classdiagram in visual studio UML project/technical document.

There's a picture on dropbox of the class diagram.

Implement the communicationprotocol in the 2D frontend

GetLegalMoves() creates moves that create islands.

Relative absolute converter track topleft tile, not cell it should be cell

Beachball doesn't appear after the place state.

Player vs computer blocks the UI

Solution: Make GetBestMove() in KaroComputerManager run in a seperate thread.

When holding the right mouse button down, the "error" sound starts playing a lot.

...which is incredibly painful to listen to. I assume @Bakkes introduced this bug with the WaitForUndo state.

Improve our computer AI with a transposition table & zobrist hashing

Create a method that returns all currently possible moves

Move invertion is broken with relative boards

Player vs Computer is buggy

Computer player eats up tiles and adds new tiles to board (shouldnt) work.

Implement the background in the 3D front end

Designations to the board

Board gets weird (sometimes)

When playing a player vs computer game, the board state gets screwed up. I do not know when or why this happens.

Player vs computer win

Currently, you can't win while playing player vs computer. We should probably have some kind of win screen/message to indicate that we won.

Improve mini-max AI with alpha-beta pruning

Research how to use native DLL's in a managed C# environment

Technical documentation

The current state of the technical documentation is not good enough. According to the documents on n@tschool, we need the following:

• Class diagram showing architecture (current one is out of date and incomplete)
• Technical choices, motivation and consequences (out of date and incomplete as well)
• Algorithms used and implementation details (same here)
• Are there any features that are not implemented or incomplete? (Don't think there are. If we end up not finishing something we'll have to add it in here.)

Improve our computer AI with killer heuristics

This is an optional requirement and does not have a high priority.

A relative wrapper for cells

to expose board entirly relative the cells should return a relative position. because we choiche to write a wrapper, this wrapper can also contain the bulk of the bitwise operations

Relative board

all the input for the board should be relative

GetLegalMoves does not comply with the rule amendment

The clarification on the moves which used a tile which temporarily creates a disconnected board is not correctly implemented in the move finder.
The unit test (Added in commit a6f413b) "RulesAmendment" checks a board which could return this move.

A board for the game

there should be a board (datastructure) to contain tiles and determine what is on the board. It also should be resizeable in all directions.

Improve our computer AI with move ordering

UndoMove doesn't work as expected.

I wrote a unit test that proves this, see the test named InvertBoardShiftingStepFromBug in MoveInvertionTest.cpp in the branch islands_30.