2

I'm not sure if I will able to put it in a sensible way.

I'm trying to write an easy non-graphical game. User will play a dice game against the computer.

(To be more specific, this game: The object of the jeopardy dice game Pig is to be the first player to reach 100 points. Each player’s turn consists of repeatedly rolling a die. After each roll, the player is faced with two choices: roll again, or hold (decline to roll again).

  • If the player rolls a 1, the player scores nothing and it becomes the opponent’s turn.
  • If the player rolls a number other than 1, the number is added to the player’s turn total and the player’s turn continues.
  • If the player holds, the turn total, the sum of the rolls during the turn, is added to the player’s score, and it becomes the opponent’s turn.)

I wrote the program but now I want to do it in object-oriented way. This is my problem:

I have an abstract Player class. Human_player class and Computer_player class extend the Player class. Another class, called Game_Controller, controls the flow the game. Say that Computer_Player has a certain strategy, that unless the "initial total" is less than 20, he keeps rolling the dice (which means that he is in a certain loop). On the other hand, the Game_Controller keeps rolling the dice for the Computer_Player as long as he wishes and as long as he can (which means that that part of the program is in a certain loop). So when Computer_Player rolls "1", Game_Controller gives the turn to Human_Player. How do I make the Compter_Player end his loop?

Moreover, I'm having difficulty at implementing the Computer_Player as a concrete player (because I'm new at programming, and I'm especially new at this kind of interaction). What's the proper way of handling this?---That is, the Game-Controller class interacts with Computer_Player class and Computer_Player class interacts with Game_Controller class.

Thanks for sparing your time.

Edit 1: Is there good source (website, book) on this type of stuff? I'm not looking for those advanced game-programming sources, just easy and fundamental stuff.

Improve this question

2 Answers 2

Reset to default
3

A player is either active or inactive. Once he is active, he has to make a decision to roll() or to hold(). Each player has a strategy for this decision making process - a human player has the strategy in mind, the computer player needs a strategy implemented in code. This strategy could offer on method: decide(int myScore, int oppenentsScorce) and produce a result: to roll or not to roll.

The Player class could look like this:

 public class Player {
   enum Decision { ROLL, HOLD }
   private Controller gameController;
   public Player(Controller gameController) {
      this.gameController = gameController;
   }

   // this is the real players strategy (-> Strategy pattern)
   abstract Decision decide(int myScore, int opponentsScore); 

   // this method is called by the controller
   public void doTurn() {
     Decision decision = decide(gameController.getScore(this), gameControlle.getOpponentsScore(this);
     if (decision == ROLL)
        gameController.roll(this);
     if (decision == HOLD)
        gameController.hold(this);
   }
 }

The HumanPlayer subclass could open a dialog for the human player, which shows the actual results and offers two buttons: roll / hold. The ComputerPlayers implementation would use an algorithm for the decision.

The Controller controls the game, rolls the dice and keeps the score. And the controller checks after each turn, if there's a winner.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

0

If the Player exposes a DoYouWantToThrow method, the concrete classes can implement this with a decision to return true or false. If a throw results in 1, the game controller won't call this method at all. For any other value, the score is calculated and the question is presented to the player. If the player is a human player, this method implements a question dialog to the user. For a computer player, the question is implemented as a piece of logic that looks like this (pseudo code).

return 
  (self.TurnScore < 20) or // Always throw again if under 20.
  (self.Bravery <= 1 and self.TurnScore < 25) or // Scared
  (self.Bravery = 2 and self.TurnScore < 40) or // Moderate
  (self.Bravery = 3 and self.TurnScore < 70) or // Gambler
  (self.Bravery = 4); // All or nothing

So the computer player doesn't actually have a loop. It is only asked if it wants to throw again. The loop is actually in the game controller and is broken if the throw results in 1 or ThrowAgain returns False or when the last throw makes the player reach 100. In the example I added some simple level of bravery. You can add some randomness too, but the essence is the same: the computer only decides whether to throw again or hand over the turn. The loop is in the game controller.

Improve this answer

6 Comments

Thanks, GolezTrol. But is your suggestion just to keep it simple, or is it the proper way in this type of program?
Well, there are probably thousands of proper ways, but I based this on my interpretation of your description of your current structure, which I think is okay. You could build the loop in the Player base class instead of the game controller, but it is arguable if that is better. It makes sense that the game controller implements the rules and the player is only to make choices within those rules, so yeah, I think this is the/a proper way. And it is simple too, which is good. :)
The solution suggested by Andreas_D is very similar, only it sends the score in parameters. That means not the player, but the game controller holds the scores for the players. That makes sense too, although I wouldn't use parameters. You can just make the computer player loop through the players the get the score of each player. That will allow you to have a variable number of players without you needing to add paramters.
It seems a good thing though if the player is not able to modify his own score. In the hypothetical situation where you allow other programmers to implement additional AI players, you wouldn't want them to be able to cheat. So as a solution, you want the game controller to have a list of Players (each holding their score etc), and each player having a PlayerController, which can be a human or an AI controller. You only implement descendants of PlayerController, which implements only the decision whether to roll again or not.
But splitting your current player class into two (as well as other refactoring) is something you can do as you go. It is better to build it simple and not be afraid to refactor pieces of your program than to start by thinking of the whole structure in detail. Refactoring as you see fit will result in better code (eventually) and will give you a lot of practise to allow you to develop a Fingerspitzengefühl for working with classes.
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.