# Pieces movements through graphs (Java)

This topic is 1728 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

## Recommended Posts

Hi all,

I'm developing a board game, kind of chess (Cyvasse, for those who know "A Song of Ice and Fire") and I would like the game to highlight valid target cells when the user select a piece.

Ideally, pieces can move a max distance (say 4), where diagonal steps count as 2. Movements are 'free': as long as they are shorter than max allowed length, a piece can reach its target call the way it wants.

Some cells may contain obstacles, the exact behaviour of which also depends upon the piece.

My first idea was to use graphs to compute if a path exists: I build a graph with the cells inside the max distance contraint and then compute the shortest paths between src and target cells. For each of these paths I decide if it is valid (i.e, no obstacles are on the way) and if a valid one is found, I allow the move.

I tried by using the jgrapht library, with the KShortestPaths component. Simply too slow, apparently (several seconds for every target cell).

Better would be to use the Bellman-Ford algo to simply compute the shortest path, but then I should compute valid edges when I build the graph, so tha every path found is a valid move. I'm not sure I can do this though: for example, some pieces cannot cross an obstacle, but they can stop on them. Others can cross an obstacle, but not rest there.

I would rather avoid implementing everything by myself if possible, but this could be my only option. Before taking this route, I would like to hear your opinions.

Thank you.

##### Share on other sites
I would implement something like this myself. The exact way to do it depends on the details of the movement rules, which you haven't given us. But something like breath-first search should be easy to implement. If the board is 8x8 or smaller, bitboards could be an attractive way to do it too.

This code is C++, but perhaps you can get some ideas from it:
typedef unsigned long long u64;

u64 N(u64 x) {
return x << 8;
}

u64 E(u64 x) {
return (x & 0x7f7f7f7f7f7f7f7full) << 1;
}

u64 S(u64 x) {
return x >> 8;
}

u64 W(u64 x) {
return (x & 0xfefefefefefefefeull) >> 1;
}

u64 propagate(u64 x) {
return N(x)|E(x)|S(x)|W(x);
}

u64 targets(int origin, int max_steps, u64 obstacles) {
u64 bb = 1ull << origin;
for (int i=0; i<max_steps; ++i)
bb |= propagate(bb) & ~obstacles;
return bb;
}

Edited by Álvaro

##### Share on other sites

Thank you for the link and the hint: I will certainly look into that bitboards thing to see if it is applicable to my game.