Algorithm Trax Winning Condition

问题

I tried to implement the game Trax in C++. For those who do not know: http://www.traxgame.com/about_rules.php

I have built the board so far and created the rules where I can put my next Tile and which one I am allowed to set. But now, I am struggling with the winning conditions. As you can see, I need a line of at least 8 tiles..

My first solution attempt had included way to many if-conditions. That is simply not possible. So i need to implement a proper algorithm..

My secong attempt using a bitboard is getting atm quite complicated, so my question would be if there is an easier way, I am simply missing at the moment.

Greets, MC

回答1:

I can propose you to use recursion. I can misunderstand your, but anyway:

bool isWin(int i, int j, int length) {
    if (length >= 8)
        return true;

    if (canMoveTo(i + 1, j)) {
        if (isWin(i + 1, j, length + 1))
            return true;
    }
    if (canMoveTo(i - 1, j)) {
        if (isWin(i - 1, j, length + 1))
            return true;
    }
    if (canMoveTo(i, j + 1)) {
        if (isWin(i, j + 1, length + 1))
            return true;
    }    
    if (canMoveTo(i, j - 1)) {
        if (isWin(i, j - 1, length + 1))
            return true;
    }      
    return false;
}

bool isWin(int i, int j) {
    int length = 0;
    isWin(i, j, length);
}

..

main() {
    for (int i = 0; i < HEIGHT; ++i) {
        for (int j = 0; j < WIDTH; ++j) {
            if (isTilePresent(i, j)) {
                if (isWin(i, j)) {
                    if (isRed(i, j))
                        std::cout << "Red is won!" << std::endl;
                    else
                        std::cout << "White is won!" << std::endl;
                }
            }
        }
    }
}

回答2:

For this kind of game stuff To make things easy I would add a small bitmap to tile representation

create tile maps

smallest resolution able to represent all tiles like this

I think may be also 3x3 resolution will be doable. You need 4 colors:
- Gray - wall
- Red - path plr1
- White - path plr2
- Magenta - path plr1,plr2
after each turn

create board bitmap from tiles bitmaps and use A* start with last edited tile (and may be also 4 neighbors) and do path for each player/path start point (Yellow). When A* is done then analyze the map data (orange) so find the biggest number in map (green mid point). It is point where A* filling stops (no need to searching for it). Then reconstruct shortest path back to start point (brown) setting used map points as unusable. Then try to reconstruct path again if you can then closed loop is present
while reconstructing path

compute bounding box of used points so you will need min,max x,y coordinates x0,x1,y0,y1 (in tiles). From this if loop found you know:
```
columns = x1-x0+1
rows = y1-y0+1
```
so the win condition is just single if from this

Hope this helps, I developed this technique for closed loop path finding/counting in my Carcassonne game

来源：https://stackoverflow.com/questions/29759873/algorithm-trax-winning-condition

标签

c++

algorithm

bitboard