I'm making a board game: who should manage the player move if the board has specific locations for the players?

Question

I know this is very specific question but imagine I have a board with spaces (like Monopoly) and a player that must go from one space to another after the dice are thrown.

So my workflow:

• Player roll dice
• After the player rolled dice
  • (from player class) space = board.getNextSpaceFromPlayer(player)
  • Move the player each step until it reach the destination
    • board.movePlayerToNextSpace(player);
    • OR
    • player.moveToSpace(space);

But how exactly do I move the player?

The board must move the player or the player move itself?

I'm trying hard to reflect how the things are in the real world but I find very hard to do so in this context.

Thanks for your help.

Answer 1

The board must move the player or the player move itself?

I would say neither. The board and player are 2 objects managed by a different object that runs logic depending on the information given by the board and applied onto the player. So you move the player by the "game logic". Which depends on the information returned by the board. Which in this scenario could be the cell(A space on your board) relatively from the players current position to the next calculated cell determined by the die. A Cell holds various information, like which player owns it ( if we are talking about monopoly) trough id. The condition the player must meet before progressing any further etc.

Your player could simply be a sprite, and by using an additional object you can keep track of stats like id and position. ( although you could just program the sprite and the stats into one object) This information is passed onto the board itself and processed internally to handle its own information. It then gives information back to the "game logic" and the player is moved by the conditions that are given.

So basically :

GameLogicObject ( or simply put BoardGame)
    |
    \-->Board //contains position grid, etc.
    |
    \-->playerList[] ( using id 0, 1 , 2 and 3 to access the right player 
        information in combination with currentPlayer++ after each 
        round depending on the amount of players and looped back to 0)
    |
    \-->Other properties
       Game stats like current gameState, Time etc.

Answer 2

Some times it is hard to determine who is the real actor.

Why not saving the players tokens in the player itself so that each player has a reference to it's tokens (even if you only have one) then let the board roll a dice.

The board itself (being a representation of the actual game rules) should be called to move a specific token (by players choice if there are more than one) with a specific dice roll.

So in a monopoly style game it would be the only token a player has wich is moved forward for a given ammount of fields. In a Ludo game the player would chose wich token is is, that he wants to move and submit it to the board class.

Why do I put the dice roll into the board? Because it depends on the boardgame itself what dice is it to use or if the actual player has to roll the dice more than once (because of special game rules (e.g. prison in monopoly)

So your Player would actually be a class that holds every information about a player. Name, Points, Money, game tokens that belong to him etc. . While the board says whose turn it is and what options are open to that player.

How you move your game tokens is up to the game rules. Is it important that a player cant cross specific fields without stopping, then you should have a method that moves that token only one field at a time to check if such a field has been crossed.

If it isn't that important you could just say "move my game token for 4 fields in that direction".

You could even go all the way down to writing a standard board game Interface that you can use to implement several different board games wich have a more or less linear game plan layout (monopoly, ludo, game of life).

Answer 3

It is a rather unique relationship between the board and the player, isn't it?

In this case, it seems that the Board contains Spaces, and the Player can inhabit a particular Space on the Board.

I'd think it makes more sense for the Player to move itself, because the Player is the one that contains the reference to the particular Space that it inhabits.

However, that also means that the Player will need to ask either the Space it currently inhabits or the Board for a reference to the next Space on the Board.

Answer 4

In order to not limit yourself in the future, you may wish to trigger a move of the piece from the players action.

However, a player class should not contain any methods such as "movePiece", but instead they should have methods like "clickedGameSpace", or something more player-centric.

It's your board class that should be acting upon the board, not the player. However, the player would probably be best as the initiator of the move, even if that requires some abstraction to convert from a "gamespace click" to a "piece move"

You may even wish to have the Player class be completely uncoupled from the board. Instead of clicking "spaces", it simply picks options... but there are many ways to implement this which could be considered good practice.