Back to General and Gameplay Programming

Pieces movements through graphs (Java)

General and Gameplay Programming Programming

Started by cignox1 April 26, 2013 09:40 PM

1 comment, last by cignox1 10 years, 12 months ago

cignox1

736

Author

April 26, 2013 09:40 PM

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.

First question: is that a good approach to start with?

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.

Quarklight Blog<br/>My Site

alvaro

21,604

April 27, 2013 09:33 PM

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;
}