Token Properties Brainstorming Discussion

I see no reason why the token should have anything more than a color property. The token is placed by the player so the method is in the player class. Its position will be determined by the board and it doesn't really need an ID. There are two players and both have a color that clearly determines who this token belongs to.

I had similar ideas..

Properties: color, player, and array of tokens connected to the player

Struggled to think of what properties the token should have. I just attached the player to it where it can access the colour which is the only thing I think it important in this case.

Two interesting thoughts I had was:

1. We could pass player object into Token constructor to have access to player.color
2. Also, it felt like each time we instantiated a new token, we should push in on to that player's token array with player.token.push(this)?

Questions:

1. Type of Coordinate System - (x,y) vs id-based coordinate system
   • For the board, I really wanted to use an (x,y) coordinate system for the board, but I've seen chess, snake, and other grid based games translated into 1-D with each position having a unique ID versus and (x,y) coordinate.
     
     1. Here's an example of a 1-d coordinate system.
        • row or y: A floor division would give which row of the board you're on
        • col or x: A modulus would give which column.
        • For (2,3) and 7x7 grid, position = 17 I think bc Math.floor(17/7) = 2 for row and 17%7 = 3 for col
     2. Here's an example of a 2-d or x,y coordinate system. I've also seen a few options:
        1. Using an Object - { x : 2, y : 3 }
           
        2. Using an Array - [2,3]
        3. Using an String - "2,3" with comma-separated value
   • Still interested to see which direction this project takes!
2. ID - Do we really need an id for each token?
   • Wondering about when you would use the id for each token! Interested to see what way the project goes!

Class implementation

class Token {
  constructor(id, player, played = false, coordinates={}) {
    this.id = id;  
    this.color = player.color;  // pass in player object, use player's color property to assign token's color property
    this.coordinates = coordinates  

   player.tokens.push(this)  // push token to player's token array each time a token is instantiated?
  }
}

class Token {

constructor(id, color, used=false){
this.id = id;
this.color;
this.used = used;
}}

Question: How can I make sure the ID matches the player ID? Maybe with Jeffrey's approach?

We could use the following properties: color, an id set to which player id used it, and a boolean value to determine if it has been played.

class token{ constructor(id, color, isPlay=false){ this.id= id; this.color= color; this.isPlay= isPlay }

}

My initial thoughts

class Token {
    constructor (tokenColour, tokenID, playerID, boardLocation, usedToken = false) {
        this.colour = tokenColour;
        this.tokenID = tokenID;
        this.assignedTo = playerID;
        this.boardLocation = boardLocation;
        this.usedToken = usedToken;

    }
}

Utilise the playerID from the Player class as parameter to determine who the token is assigned to.

class Token {
  constructor (playerid, color) {
    this.playerid = playerid;
    this.color = color;
  }
}

How will you differentiate between token objects? How can you use the Player ID to create a token identifier?

• I wouldn't. I would just generate a new token every time a Player is about to take a turn. The player takes their turn, the token would then occupy a space on the game board, and that's it.

How will you keep track of which player an individual token belongs to?

• By its playerid, which be used to automatically determine the token's color

How will you know if a token has been played or not?

• If it exists, it's been played. I don't believe in creating a cache of Tokens for each player and tracking how many tokens were played so far.

I'm wondering if all is needed is that the token has the color of the player who is active. set token (this.player.color){ this._tokenColor = this.player.color; } get token() { return this._tokenColor; } Nope - scratch that. I'm not quite there.

If the position of the token is to be handled in the board class, as well as the number of tokens available then what else does the token do? Ashley does create an array for tokens in her Player class. So, that would lead me to believe that I need to have a unique identifier for each token. the player chooses the column into which to drop the token, but the board determines how far down that token falls. (If there are already tokens in that column). So -

class Token{
   constructor (TokenID, player.color, TokenColumn) {
   this.TokenID = TokenID;
   this.TokenColor = player.color;
   this.TokenColumn = TokenColumn; // the board probably takes care of positions.
   }
}

My thinking for the Token class object:

1. It needs to be associated with a player or owner.
2. It needs to be associated with a specific colour.
3. It needs to be associated with a specific position on the board.
4. It needs to have a status identifying whether the token has been used or not.

class Token {
     constructor(ownerID, colour, position = null, tokenUsed = false) {
          this.ownerID = ownerID;     // to reference the ID of the player that owns that token
          this.colour = colour;     // to reference the colour of the token piece
          this.position = position;     // to reference the cell position on the board;
          this.tokenUsed = tokenUsed;     // to reference whether the token has been used or not. 
     }
}

I've set the tokenUsed status to false per the example provided for the Player class. Position is set to null to ensure it's not already placed anywhere, but not sure if that is necessary!

For token class, below are the constructor properties

• color
• number
• player id
• play

class Token { constructor(color, amount, leftOver, ){ this.color = color // color of the token this.amount = amount // how many token a p/ayer should have this.leftOver = leftOver // how many token is left well the player is playing } }

Hmm... I am not sure, but I think it should inherit the color property from the Player class. We can associate the player's id to the token as a property, so we could know which token belongs to whom. A token could have a Boolean value to check whether it has been played or not.