Player Properties Brainstorming Discussion

I tried to keep my quite simple and easy for me to follow.

I would start with something like this....

class Player {
    constructor (playerName, tokensRemaining, tokenColor, isTurn ) {

    }
}

I would probably then have a method that counts down the tokensRemaining (taking 1 off for each turn), and isTurn would be a boolean.

The playerName and tokenColor, however, would not change after they are set.

turn: boolean color: red || yellow name: string tokenCount: 21

I think we need: an id with an int value (either 1 or 2); isTurn with a boolean value (I'm not sure if the game class is for running the game, or a game helper. If its a game helper it can have a setter method on it to set the isTurn value to either true or false when necessary); tokensRemaining with an int value; token (an instance of the token class, which will have a colour parameter in its constructor.) Somewhere in the program we need a MAX_TURNS const, possibly in the player class.

1. How to differentiate between players - use either their first name (that they enter and is stored as a variable) or use a default player ID that is assigned - player 1 or player 2.

2. Number of tokens/pieces - Players tokens will be stored in a variable that will be decremented with every turn. The number of tokens will be declared as a variable and decremented with each turn.

3. Each player's tokens will be differentiated by an assigned color.

4. You can keep track of turns using game cycles or sessions. The cycles or sessions (turns) are the same number as the maximum number of tokens that a player has unless someone has gotten four in a row of course.

Here are some ideas I found:

Properties

Players: score: turn: boolean (true or false)

To the 'turn' propriety can help toggling between the two players by setting it to "true" or "false"

Here are properties I thought of:

• name (string)
• id (integer)
• tokenColor (string)
• isTurn (boolean)

As for the token amount, I'm thinking Player is set with an amount of tokens half the amount of spaces available on the board. So if there are 42 spaces, then 21 for each player.

I think there are not many properties necessary for the player. He needs an ID to identify him, his chosen color and a value that determines if it's his turn. A necessary method would be placing the token. I think it is possible to cut this down even further by setting the user ID to the string of the players color. There are after all only two colors. The turn could be tracked in the Game class as the player only plays every second turn and the method could use the color string in the id to give the token it's color.

constructor(name){ this.name = name; this.token = null; this.isTurn = false; } }

My plan for the Player Object. I don't think it's necessary to set a number of tokens as the game is supposed to end when the board is filled up or someone wins. The colour of the token will be set by the token class I believe and the turn state set to false by default then determined by the game?

Players name - player1 and player2 in constructor

tokens stored in this.tokens = 13 considering a 5x5 player grid board or just tokens

represent colored tokens with style property, red, yellow?

true/false for player's turn

I could think of : isTurn: Method as Getter/setter since it is an excellent way to express logic here name: as a property player 1 player 2 Id: as a property token: as a property win: as a method Getter/setter Game: as a method maybe it can be 2/3 game picture: as a property color: as a property

Here are some of my brainstorming notes in preparation for the game:

/*
class Player {
  constructor  ()
    player: [1 or 2]
    turns_remaining: [turns remaining]
    player_turn: (true/false)

    if (player_turn === true)
      it's player1's turn
    } else {
      it's player2's turn
  }
}
*/

Not sure it makes sense for the player to know about the turn. If the turn flipping is reliant on the other player, it seems some other class would need to coordinate. I guess you could actually assign a player to a collection of tokens such that the initial order implicitly has a sense of whose turn it is (and also access to player color). I'm sure I'm going to see the solution and think "oh, of course!". So for now, I'd just have name.

Here is what I would include in my Player constructor

  constructor (name, id) {
    this.name = name;
    this.id = id;
  }

I include the name attribute for aesthetic appeal, as it's more fun to play against a human being than "Player1". As for distinguishing between players for the purposes of gameplay and turn-taking, providing a unique ID should be sufficient (elsewhere you can maintain the map between id and token color). The id for the player (and thus their color and turn order) can be chosen randomly, or based on the turn order of the previous game.

I don't believe you need to worry about the number of tokens a player "has". The player need not worry how many tokens they still possess, nor how many they played...all that matters is whether the played tokens currently form a winning line.

The player's tokens will be distinguished visually from the other player by mapping the player's ID to a color (black/white, blue/red, whatever pair of colors you want)

I would keep track of the player's turn in the Game object rather than in the player objects. That way you only need one attribute, this.activePlayer, rather than an attribute per-player, this.isMyTurn.

If we assign 21 tokens to each player (7x6 game board = 42 spaces/2 = 21 tokens per player) then we can use this information to generate a method to determine whose turn it is.

If Player1's tokens are equal to Player2's tokens then it's Player1's turn. If Player1's tokens are fewer than Player2's tokens then it's Player2's turn.

Keeping it simple

playerID = assign user to player 1 or player 2 tokens = a set amount of tokens

class Player {
    constructor(playerID, tokens) {
        this.playerID = playerID; ///String
        this.tokens = tokens; /// number
    }
}

I believe it is sufficient to have name property only (if allowing players to personalize or simply Player1 || Player 2 if not) and not id as well. I can't see needing both. You just need one property name to identify which player. Note: This assumption was wrong. She recommends both name and id. Time will tell. A boolean "Is Turn" to identify the active player and prevent the inactive player from pitching a token or whatever. I'm still leaning toward a property for Tokens Remaining which may trigger the end of the game. However, "Total Tokens Used" could be included in the Game class instead. The other reason for having tokens, is somewhere, maybe the board, you have to record the position of the tokens and color to identify a winner should there be four in a row. To summarize: name id color is Turn tokens

Taking my turn at brainstorming properties for the Player class!

class Player {
     constructor(playerName,  playerColour) {
          this.playerName = playerName ; 
          this.playerColour = playerColour ;
          this.playerTurn = false;
          this.playerTokens =  //an integer representing the total number of tokens;
          this.playerWinHistory = 0;
     }
}

So the Player class will create a Player object. Users will enter a name and select a colour, which is fed into the constructor. The object is instantiated with the playerTurn set to false to avoid conflict with the second player. The playerToken count is generated based on the board size (I'm guess, I don't know this game). Win history is set to 0.

For player class, I think we should have the below properties

• Player 1 (red)
• Player 2 (yellow)
• Turns
  
• Tokens

I think the players can be differentiated by name (i.e. 'Player 1','Player 2') Visually I think they should be distinguished by the color of the tokens. For each player, I think they should have a number of tokens equal to half of the total number of spaces. These can be stored in a property and use a setter method to reduce the number as game play continues. I think knowing whose turn it is can be a global property or variable of the Game object. Or it could be a property of the Player object, but I think it is slightly more complex than necessary.