Jump to content

  • Log In with Google      Sign In   
  • Create Account

Pieces movements through graphs (Java)


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
2 replies to this topic

#1 cignox1   Members   -  Reputation: 723

Like
0Likes
Like

Posted 26 April 2013 - 03: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.



Sponsor:

#2 Álvaro   Crossbones+   -  Reputation: 13311

Like
1Likes
Like

Posted 27 April 2013 - 03: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;
}

Edited by Álvaro, 28 April 2013 - 12:53 PM.


#3 cignox1   Members   -  Reputation: 723

Like
0Likes
Like

Posted 28 April 2013 - 05:31 AM

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.






Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS