// PseudoEnum of space types.
const SpaceType = Object.freeze({
  Property: 'Property',
  Railroad: 'Railroad',
  Utility:  'Utility',
  Tax:      'Tax',
  Busted:   'Busted',
  Free:     'Free',
  Visiting: 'Visiting',
  Deck:     'Deck',
  Go:       'Go',
}); // end enum SpaceTypes

/**
 * Space classes
 *
 * These represent any of the 40 spaces of the board on which a player can land.
 */

// Base class for all spaces.
class Space {
  // Each child class will populate this value with a SpaceType.
  _type = false;

  // On GameState.init() this will be set [0..39].
  _id  = false;

  constructor(type, name, group) {
    this._type   = type;
    this.name    = name;
    this.groupId = group;
  }

  setId(spaceId) {
    this._id = spaceId;
  }

  getId() {
    return this._id;
  }

  getPlayer() {
    return GameState.getCurrentPlayerObject();
  }

  // Common logic for when player lands on any space.
  onLand() {}

  // Common logic when a player passes any space.
  onPass() {}

  getType() {
    return this._type;
  }

  getName() {
    return this.name;
  }

  // This must be overridden if property, railroad, or utility.
  hasTitleDeed() {
    return false;
  }

  getGroupId() {
    return this.groupId;
  }

} // end class Space

// Property space class for all grouped, purchasable properties.
class PropertySpace extends Space {
  owningPlayerId = false; // unowned

  constructor(name, group, miniName, cost, rents = [], bldgCost) {
    super(SpaceType.Property, name, group);
    this.name2 = miniName;
    this.cost  = cost;
    this.rent  = {
      default:  rents[0],
      colorSet: rents[1],
      houses: {
        1: rents[2],
        2: rents[3],
        3: rents[4],
        4: rents[5],
      },
      hotel: rents[6],
    };
    this.bldgCost = bldgCost;
  }

  // Logic for when player lands on any grouped property.
  onLand() {
    let ownerId = this.owningPlayerId;

    // Check if player owns this property.
    if (ownerId === GameState.getCurrentPlayerIndex()) {
      // Player owns this property; do nothing.
      GameState.showModal({
        text:  'Since you own this property, you pay nothing',
        title: 'Your Property',
        onClosed: _ => {
          // Nothing to do but end the turn.
          GameState.showEndTurn();
        },
      });
      return;
    }

    let space = BoardSpaces[this.getId()];

    // Pay rent if owned, allow purchase if not.
    if (ownerId !== false) {
      // Owned. Look up rents.
      let rent  = space.rent.default;
      let owner = GameState.players[ownerId];
      let currPlayer = this.getPlayer();
      let numHouses = owner.propertiesOwned[this.getId()] || 0;
      if (numHouses == 5) {
        // Get rent with hotel.
        rent = space.rent.hotel;
      }
      else if (numHouses > 0) {
        // Get rents with houses (1-4).
        rent = space.rent.houses[numHouses];
      }
      // Check if player owns entire color set.

      // Pay rent.
      GameState.showModal({
        text:  `You pay rent: $${rent}.`,
        title: 'Pay Rent: Property',
        onClosed: _ => {
          // Subtract rent from player who landed here...
          currPlayer.alterMoney(0 - rent); // must be negative to pay vs. receive
          // ...and give it to the owner.
          owner.alterMoney(rent);
          // Show option to end turn (nothing left to do).
          GameState.showEndTurn();
        },
      });
    }
    else {
      // Unowned. Give player option to purchase.
      // @TODO: Make HTML selector a config option.
      $('.action.purchase .name').text(space.getName());
      $('.action.purchase .cost-amount').text(this.cost);
      GameState.showActionState('purchase');
      // Don't end turn, because player must still respond.
    }
  }

  doesPlayerOwnAllInGroup(player) {
    // Loop through each property in this group.
    let properties = GameState.getAllPropertiesInGroup(this.getGroupId());
    for (let i = 0; i < properties.length; i++) {
      // If player doesn't own it, cancel and report false.
      if (player.checkIfOwnsProperty(properties[i]) !== true) {
        return false;
      }
    }
    // If all checks passed, player owns all in gorup.
    return true;
  }

  hasTitleDeed() {
    return true;
  }

  getMiniName() {
    return this.name2;
  }

} // end class Property

// Railroad space class for all railroads.
class RailroadSpace extends Space {
  owningPlayerId = false; // unowned
  // If [idx] number of R/Rs are owned, rent is $[val].
  rents = [0, 25, 50, 100, 200];

  constructor(name, rrIndex, miniName1, miniName2, cost = 200) {
    super(SpaceType.Railroad, name, rrIndex);
    this.name1 = miniName1;
    this.name2 = miniName2;
    this.cost  = cost;
  }

  // Logic for when player lands on any railroad.
  onLand() {
    let ownerId = this.owningPlayerId;

    // Pay rent if owned, allow purchase if not.
    if (ownerId !== false) {
      // Owned. Determine rent based on # owned by same player as this one.
      let owner = GameState.players[ownerId];
      let numOwned = GameState.getNumSpacesOfTypeOwned(this.getType(), ownerId);
      let rent = this.rents[numOwned];
      let currPlayer = this.getPlayer();
      // Subtract rent from player who landed here...
      GameState.showModal({
        text:  `You pay rent: $${rent}.`,
        title: 'Pay Rent: Railroad',
        onClosed: _ => {
          currPlayer.alterMoney(0 - rent); // must be negative to pay vs. receive
          // ...and give it to the owner.
          owner.alterMoney(rent);
          // Show option to end turn (nothing left to do).
          GameState.showEndTurn();
        },
      });
    }
    else {
      // Unowned. Give player option to purchase.
      let space = BoardSpaces[this.getId()];
      $('button.purchase-property .name').text(space.getName());
      $('.action.purchase .cost-amount').text(this.cost);
      GameState.showActionState('purchase');
      // Don't end turn, because player must still respond.
    }
  }

  getNames() {
    return [
      this.name1,
      this.name2,
    ];
  }

  hasTitleDeed() {
    return true;
  }

} // end class Railroad

// Utility space class for all (both) utilities.
class UtilitySpace extends Space {
  owningPlayerId = false; // unowned
  // If [idx] number of utilities are owned, rent is [val] times dice value.
  rents = [0, 4, 10];

  constructor(name, utilGroup, miniName1, miniName2, icon, cost = 150) {
    super(SpaceType.Utility, name, utilGroup);
    this.name1 = miniName1;
    this.name2 = miniName2;
    this.icon  = icon; // e.g. "lightbulb"
    this.cost  = cost;
  }

  // Logic for when player lands on any utility.
  onLand() {
    let ownerId = this.owningPlayerId;

    // Pay rent if owned, allow purchase if not.
    if (ownerId !== false) {
      // Owned. Determine rent based on # owned by same player as this one.
      let owner = GameState.players[ownerId];
      let numOwned = GameState.getNumSpacesOfTypeOwned(this.getType(), ownerId);
      let rentMultiplier = this.rents[numOwned];
      // Rent is [2 or 10] times total shown on dice.
      let rent = GameState.getDiceTotal() * rentMultiplier;
      let currPlayer = this.getPlayer();
      GameState.showModal({
        text:  `You pay rent: $${rent} (${rentMultiplier} × dice)`,
        title: 'Pay Utility Rent',
        onClosed: _ => {
          // Subtract rent from player who landed here...
          currPlayer.alterMoney(0 - rent);
          // ...and give it to the owner.
          owner.alterMoney(rent);
          // Show option to end turn (nothing left to do).
          GameState.showEndTurn();
        },
      });
    }
    else {
      // Unowned. Give player option to purchase.
      let space = BoardSpaces[this.getId()];
      // @TODO: Make HTML selector a config option (same as above).
      $('button.purchase-property .name').text(space.getName());
      $('.action.purchase .cost-amount').text(this.cost);
      GameState.showActionState('purchase');
      // Don't end turn, because player must still respond.
    }
  }

  getIcon() {
    return `fa-${this.icon}`;
  }

  getNames() {
    return [
      this.name1,
      this.name2,
    ];
  }

  hasTitleDeed() {
    return true;
  }

} // end class Utility

// Tax space class for both Income and Luxury taxes.
class TaxSpace extends Space {

  constructor(name, taxGroup, cost = 200) {
    super(SpaceType.Tax, name, taxGroup);
    this.cost = cost;
  }

  // Logic for when player lands on any Tax space.
  onLand() {
    let currPlayer = this.getPlayer();
    let cost = this.cost;
    GameState.showModal({
      text:  `You landed on ${this.name} and must pay: $${cost}.`,
      title: `Pay ${this.name}`,
      onClosed: _ => {
        // Pay the bank.
        currPlayer.alterMoney(0 - cost);
        // End player turn.
        currPlayer.showEndTurn();
      },
    });
  }

} // end class Tax

// Busted space class for "Go to Jail" space.
class BustedSpace extends Space {

  constructor(name) {
    super(SpaceType.Busted, name, false);
  }

  // Logic for when player lands on "Go to Jail".
  onLand() {
    GameState.showModal({
      text:  'Go directly to Jail!',
      title: 'Busted!',
      onClosed: _ => {
        const player = GameState.getCurrentPlayerObject();
        player.sendToJail();
      }
    });
  }

} // end class Busted

// Free space class for "Free Parking" space.
class FreeSpace extends Space {

  constructor(name) {
    super(SpaceType.Free, name, false);
  }

  // Logic for when player lands on Free Parking (usually nothing).
  onLand() {
    GameState.showEndTurn();
  }

} // end class Free

// Visiting space class for "Just Visiting" Jail space.
class VisitingSpace extends Space {

  constructor(name) {
    super(SpaceType.Visiting, name, false);
  }

  // Logic for when player lands on Just Visiting Jail (usually nothing).
  onLand() {
    GameState.showEndTurn();
  }

} // end space Visiting

// Deck space class for "Community Chest" and "Chance" spaces.
class DeckSpace extends Space {

  constructor(name, deckGroup) {
    super(SpaceType.Deck, name, deckGroup);
  }

  // Logic for when player lands on a "draw card" space (Chest/Chance).
  onLand() {
    // First we need the deck we're drawing from.
    const deck = CardDeck[this.getGroupId()];
    const rIdx = Math.floor(Math.random() * deck.length);
    const card = deck[rIdx];
    // Show card to player.
    card.showToPlayer();
    // Do nothing & let the card's Effect handle ending this turn.
  }

} // end class Deck

// Go space class for "Go" space.
class GoSpace extends Space {
  salary = 200;

  constructor(name) {
    super(SpaceType.Go, name, false);
  }

  // Logic for when player LANDS on GO.
  onLand() {
    let currPlayer = this.getPlayer();
    let salary = this.salary;
    GameState.showModal({
      text:  `For landing on GO, you get $${salary}.`,
      title: 'Landed on GO',
      onClosed: _ => {
        // Award salary.
        currPlayer.alterMoney(salary);
        // End player turn.
        currPlayer.showEndTurn();
      },
    });
  }

  // Logic for when player PASSES GO.
  onPass(fToRunAfter = false) {
    fToRunAfter = (typeof fToRunAfter === 'function') ? fToRunAfter : false;
    let currPlayer = this.getPlayer();
    let salary = this.salary;
    GameState.showModal({
      text:  `For passing GO, you collect $${salary}.`,
      title: 'You Passed GO!',
      onClosed: _ => {
        // Award salary.
        currPlayer.alterMoney(salary);
        // DO NOT end turn, as we merely PASSED this space.
        if (fToRunAfter) {
          // Short delay to avoid breaking dismissal functionality of 2nd modal.
          window.setTimeout(_ => {
            fToRunAfter();
          }, 50);
        }
      },
    });
  }

} // end class Go

// Base class for all card effects that can be applied to players.
class Effect {

  constructor() {
    // this.message = message;
  }

  applyEffect(playerObj) {
    // Placeholder.
  }

} // end class Effect

// Effect for gaining or losing money.
class MoneyEffect extends Effect {

  constructor(moneyAmt, toPlayers = false) {
    super();
    this.money     = moneyAmt;
    this.toPlayers = toPlayers;
  }

  applyEffect(playerObj) {
    playerObj.alterMoney(this.money);
    GameState.showEndTurn();
  }

} // end class MoneyEffect

// Effect for moving player token a certain number of spaces back or forward.
class MoveSpacesEffect extends Effect {

  constructor(numSpaces) {
    super();
    this.numSpaces = numSpaces;
  }

  applyEffect(playerObj) {
    Modal.activate('TODO: Move token ' + this.numSpaces + ' spaces.', 'TO-DO');
    GameState.showEndTurn();
    // Something like: playerObj.moveTokenBy(this.numSpaces);
  }

} // end class MoveSpacesEffect

// Effect for moving player token forward to nearest space of a certain type.
class MoveToTypeEffect extends Effect {

  constructor(spaceType, willRollDice, rentMultiplier) {
    super();
    this.spaceType = spaceType;
  }

  applyEffect(playerObj) {
    Modal.activate('TODO: Move token to nearest ' + this.spaceType + ' space.', 'TO-DO');
    GameState.showEndTurn();
    // Something like: playerObj.moveTokenToType(this.spaceType);
  }

} // end class MoveToTypeEffect

// Effect for moving player token forward to a specific space index.
class MoveToSpaceEffect extends Effect {

  constructor(spaceIndex) {
    super();
    this.spaceIndex = spaceIndex;
  }

  applyEffect(playerObj) {
    Modal.activate('TODO: Move token to space index ' + this.spaceIndex + '.', 'TO-DO');
    GameState.showEndTurn();
    // Something like: playerObj.moveTokenToSpace(this.spaceIndex);
  }

} // end class MoveToSpaceEffect

// Effect for adding a "Get Out of Jail Free" card to player's assets.
class JailbreakEffect extends Effect {

  constructor(deckId = '') {
    super();
    this.deckId = deckId; // 'chest' or 'chance'
  }

  applyEffect(playerObj) {
    Modal.activate('TODO: Add jailbreak card (from ' + this.deckId + ' pile) to assets.', 'TO-DO');
    GameState.refreshBoard();
    GameState.showEndTurn();
    // Something like: playerObj.setJailbreakCard(this.deckId, TRUE);
  }

} // end class JailbreakEffect

// Effect for moving player token directly to Jail.
class BustedEffect extends Effect {

  constructor() {
    super();
  }

  applyEffect(playerObj) {
    Modal.activate('TODO: Move token directly to Jail, etc.', 'TO-DO');
    GameState.refreshBoard();
    GameState.showEndTurn();
    // Something like: playerObj.goToJail();
  }

} // end class BustedEffect

// Effect for assessing repairs on player's properties.
class RepairsEffect extends Effect {

  constructor(costPerHouse, costPerHotel) {
    super();
    this.costPerHouse = costPerHouse;
    this.costPerHotel = costPerHotel;
  }

  applyEffect(playerObj) {
    Modal.activate('TODO: Assess repairs at $' + this.costPerHouse + ' per house and $' + this.costPerHotel + ' per hotel.', 'TO-DO');
    GameState.refreshBoard();
    GameState.showEndTurn();
    // Something like: playerObj.payRepairs(this.costPerHouse, this.costPerHotel);
  }

} // end class RepairsEffect

// Base class for all cards in the Community Chest and Chance decks.
class Card {
  deckTitle = false; // populated in constructor

  constructor(title, message, effect) {
    this.deckTitle = title;
    this.message   = message;
    this.effect    = effect;
  }

  // Alias for Effect.applyEffect()
  applyEffect(playerObj) {
    this.getEffect().applyEffect(playerObj);
  }

  getMessage() {
    return this.message;
  }

  getEffect() {
    return this.effect;
  }

  getPlayer() {
    return GameState.getCurrentPlayerObject();
  }

  showToPlayer() {
    let _this = this;
    let $modal = $('#card-overlay');
    let currPlayer = this.getPlayer();

    // Populate modal with title and message.
    $modal.removeClass('from-chance from-chest').addClass('in-deck');
    $modal.addClass('from-' + DeckType[this.deckTitle]);
    $modal.find('.card-title').text(this.deckTitle);
    $modal.find('.card-content').html(this.message);
    // On OK click, hide modal, waiting for animation, then act.
    $modal.find('.card-action').off('click').on('click', e => {
      $modal.removeClass('show').addClass('hide');
      window.setTimeout(_ => {
        $modal.addClass('hidden');
        // Apply the effect once the card has finished hiding.
        _this.applyEffect(currPlayer);
        // Oh, and refresh the board, too.
        GameState.refreshBoard();
      }, 500);
    });
    // Now show the card modal.
    $modal.removeClass('hidden');
    window.setTimeout(_ => {
      $modal.removeClass('hide').addClass('show');
      // Wait a bit, then remove the in-deck class.
      window.setTimeout(_ => {
        $modal.removeClass('in-deck');
      }, 750);
    }, 50);
  }

} // end class Card

// Pseudo-enum of card deck types.
const DeckType  = Object.freeze({
  CommunityChest:    'chest',
  'Community Chest': 'chest',
  Chance:            'chance',
});
const DeckTitle = Object.freeze({
  CommunityChest: 'Community Chest',
  Chance:         'Chance',
});

// Aliases for deck types.
const chest  = DeckType.CommunityChest;
const chance = DeckType.Chance;

// Definition of all cards in the Community Chest and Chance decks.
const CardDeck = {
  // Community Chest (id 'chest').
  chest: [
    new Card(
      DeckTitle.CommunityChest,
      'Advance to Go. (Collect $200)',
      new MoveToSpaceEffect(0)
    ),
    new Card(
      DeckTitle.CommunityChest,
      'Bank error in your favor. Collect $200.',
      new MoneyEffect(200, false)
    ),
    new Card(
      DeckTitle.CommunityChest,
      'Doctor\'s fee. Pay $50.',
      new MoneyEffect(-50, false)
    ),
    new Card(
      DeckTitle.CommunityChest,
      'From sale of stock you get $50.',
      new MoneyEffect(50, false)
    ),
    new Card(
      DeckTitle.CommunityChest,
      'Get Out of Jail Free. This card may be kept until needed or traded.',
      new JailbreakEffect(DeckType.CommunityChest)
    ),
    new Card(
      DeckTitle.CommunityChest,
      'Go to Jail. Go directly to Jail, do not pass Go, do not collect $200.',
      new BustedEffect()
    ),
    new Card(
      DeckTitle.CommunityChest,
      'Holiday fund matures. Receive $100.',
      new MoneyEffect(100, false)
    ),
    new Card(
      DeckTitle.CommunityChest,
      'Income tax refund. Collect $20.',
      new MoneyEffect(20, false)
    ),
    new Card(
      DeckTitle.CommunityChest,
      'It is your birthday. Collect $10 from every player.',
      new MoneyEffect(10, true)
    ),
    new Card(
      DeckTitle.CommunityChest,
      'Life insurance matures. Collect $100.',
      new MoneyEffect(100, false)
    ),
    new Card(
      DeckTitle.CommunityChest,
      'Pay hospital fees of $100.',
      new MoneyEffect(-100, false)
    ),
    new Card(
      DeckTitle.CommunityChest,
      'Pay school fees of $50.',
      new MoneyEffect(-50, false)
    ),
    new Card(
      DeckTitle.CommunityChest,
      'Receive $25 consultancy fee.',
      new MoneyEffect(25, false)
    ),
    new Card(
      DeckTitle.CommunityChest,
      'You are assessed for street repair. $40 per house. $115 per hotel.',
      new RepairsEffect(40, 115)
    ),
    new Card(
      DeckTitle.CommunityChest,
      'You have won second prize in a beauty contest. Collect $10.',
      new MoneyEffect(10, false)
    ),
    new Card(
      DeckTitle.CommunityChest,
      'You inherit $100.',
      new MoneyEffect(100, false)
    ),
  ],
  // Chance (id 'chance').
  chance: [
    new Card(
      DeckTitle.Chance,
      'Advance to Boardwalk.',
      new MoveToSpaceEffect(39)
    ),
    new Card(
      DeckTitle.Chance,
      'Advance to Go. (Collect $200)',
      new MoveToSpaceEffect(0)
    ),
    new Card(
      DeckTitle.Chance,
      'Advance to Illinois Avenue. If you pass Go, collect $200.',
      new MoveToSpaceEffect(24)
    ),
    new Card(
      DeckTitle.Chance,
      'Advance to St. Charles Place. If you pass Go, collect $200.',
      new MoveToSpaceEffect(11)
    ),
    new Card(
      DeckTitle.Chance,
      'Advance to the nearest Railroad. if unowned, you may buy it from the Bank. If owned, pay owner twice the rental to which they are otherwise entitled.',
      new MoveToTypeEffect(SpaceType.Railroad, false, 2)
    ),
    new Card(
      DeckTitle.Chance,
      'Advance to the nearest Railroad. if unowned, you may buy it from the Bank. If owned, pay owner twice the rental to which they are otherwise entitled.',
      new MoveToTypeEffect(SpaceType.Railroad, false, 2)
    ),
    new Card(
      DeckTitle.Chance,
      'Advance token to nearest Utility. If unowned, you may buy it from the Bank. If owned, throw dice and pay owner a total ten times amount thrown.',
      new MoveToTypeEffect(SpaceType.Utility, true, 10)
    ),
    new Card(
      DeckTitle.Chance,
      'Bank pays you dividend of $50.',
      new MoneyEffect(50, false)
    ),
    new Card(
      DeckTitle.Chance,
      'Get Out of Jail Free. This card may be kept until needed or traded.',
      new JailbreakEffect(DeckType.Chance)
    ),
    new Card(
      DeckTitle.Chance,
      'Go Back 3 Spaces.',
      new MoveSpacesEffect(-3)
    ),
    new Card(
      DeckTitle.Chance,
      'Go to Jail. Go directly to Jail, do not pass Go, do not collect $200.',
      new BustedEffect()
    ),
    new Card(
      DeckTitle.Chance,
      'Make general repairs on all your properties. For each house pay $25. For each hotel pay $100.',
      new RepairsEffect(25, 100)
    ),
    new Card(
      DeckTitle.Chance,
      'Speeding fine $15.',
      new MoneyEffect(-15, false)
    ),
    new Card(
      DeckTitle.Chance,
      'Take a trip to Reading Railroad. If you pass Go, collect $200.',
      new MoveToSpaceEffect(5)
    ),
    new Card(
      DeckTitle.Chance,
      'You have been elected Chairman of the Board. Pay each player $50.',
      new MoneyEffect(-50, true)
    ),
    new Card(
      DeckTitle.Chance,
      'Your building loan matures. Collect $150.',
      new MoneyEffect(150, false)
    ),
  ],
};

// Pseudo-enum of Utility space sub-types.
const UtilityType = Object.freeze({
  Electric: Symbol('electric'),
  Water:    Symbol('water'),
});

// Pseudo-enum of Tax space sub-types.
const TaxType = Object.freeze({
  Income: Symbol('income'),
  Luxury: Symbol('luxury'),
});

// Psuedo-enum of individual Railroad spaces.
const Railroad = {
  Reading:      0,
  Pennsylvania: 1,
  BAndO:        2,
  ShortLine:    3,
};

// Pseudo-enum of Property groups.
const PropertyGroup = {
  Brown:  0,
  Aqua:   1,
  Pink:   2,
  Orange: 3,
  Red:    4,
  Yellow: 5,
  Green:  6,
  Blue:   7,
};

// List of all board spaces (each an instance of a class extending Effect).
const BoardSpaces = [
  // 0 - GO
  new GoSpace('GO'),
  // 1 - Property 0a: Mediterranean Avenue
  new PropertySpace(
    'Mediterranean Avenue', PropertyGroup.Brown, 'MEDIT', 60,
    [2, 4, 10, 30, 90, 160, 250], 50
  ),
  // 2 - Deck: Community Chest 1 of 3
  new DeckSpace('Community Chest', DeckType.CommunityChest),
  // 3 - Property 0b: Baltic Avenue
  new PropertySpace(
    'Baltic Avenue', PropertyGroup.Brown, 'BALT', 60,
    [4, 8, 20, 60, 180, 320, 450], 50
  ),
  // 4 - Tax 1 of 2: Income
  new TaxSpace('Income Tax', TaxType.Income),
  // 5 - Railroad 1 of 4: Reading R/R
  new RailroadSpace('Reading Railroad', Railroad.Reading, 'READ.', 'R / R'),
  // 6 - Property 1a: Oriental Avenue
  new PropertySpace(
    'Oriental Avenue', PropertyGroup.Aqua, 'ORIEN', 100,
    [6, 12, 30, 90, 270, 400, 550], 50
  ),
  // 7 - Deck: Chance 1 of 3
  new DeckSpace('Chance', DeckType.Chance),
  // 8 - Property 1b: Vermont Avenue
  new PropertySpace(
    'Vermont Avenue', PropertyGroup.Aqua, 'VERM', 100,
    [6, 12, 30, 90, 270, 400, 550], 50
  ),
  // 9 - Property 1c: Connecticut Avenue
  new PropertySpace(
    'Connecticut Avenue', PropertyGroup.Aqua, 'CONN', 120,
    [8, 16, 40, 100, 300, 450, 600], 50
  ),
  // 10 - Jail / Just Visiting
  new VisitingSpace('Just Visiting'),
  // 11 - Property 2a: St. Charles Place
  new PropertySpace(
    'St. Charles Place', PropertyGroup.Pink, 'ST.CH', 140,
    [10, 20, 50, 150, 450, 625, 750], 100
  ),
  // 12 - Utility 1 of 2: Electric Company
  new UtilitySpace('Electric Company', UtilityType.Electric, 'ELECT.', 'COMP.', 'lightbulb'),
  // 13 - Property 2b: States Avenue
  new PropertySpace(
    'States Avenue', PropertyGroup.Pink, 'STATE', 140,
    [10, 20, 50, 150, 450, 625, 750], 100
  ),
  // 14 - Property 2c: Virginia Avenue
  new PropertySpace(
    'Virginia Avenue', PropertyGroup.Pink, 'VIRG', 160,
    [12, 24, 60, 180, 500, 700, 900], 100
  ),
  // 15 - Railroad 2 of 4: Pennsylvania
  new RailroadSpace('Pennsylvania Railroad', Railroad.Pennsylvania, 'PENN.', 'R / R'),
  // 16 - Property 3a: St. James Place
  new PropertySpace(
    'St. James Place', PropertyGroup.Orange, 'ST.JM', 180,
    [14, 28, 70, 200, 550, 750, 950], 100
  ),
  // 17 - Deck: Community Chest 2 of 3
  new DeckSpace('Community Chest', DeckType.CommunityChest),
  // 18 - Property 3b: Tennessee Avenue
  new PropertySpace(
    'Tennessee Avenue', PropertyGroup.Orange, 'TENN', 180,
    [14, 28, 70, 200, 550, 750, 950], 100
  ),
  // 19 - Property 2c: New York Avenue
  new PropertySpace(
    'New York Avenue', PropertyGroup.Orange, 'NYRK', 200,
    [16, 32, 80, 220, 600, 800, 1000], 100
  ),
  // 20 - Free Parking
  new FreeSpace('Free Parking'),
  // 21 - Property 4a: Kentucky Avenue
  new PropertySpace(
    'Kentucky Avenue', PropertyGroup.Red, 'KENY', 220,
    [18, 36, 90, 250, 700, 875, 1050], 150
  ),
  // 22 - Property 4b: Indiana Avenue
  new PropertySpace(
    'Indiana Avenue', PropertyGroup.Red, 'INDA', 220,
    [18, 36, 90, 250, 700, 875, 1050], 150
  ),
  // 23 - Deck: Chance 2 of 3
  new DeckSpace('Chance', DeckType.Chance),
  // 24 - Property 4c: Illinois Avenue
  new PropertySpace(
    'Illinois Avenue', PropertyGroup.Red, 'ILLIN', 240,
    [20, 40, 100, 300, 750, 925, 1100], 150
  ),
  // 25 - Railroad 3 of 4: B. & O. R/R
  new RailroadSpace('B. & O. Railroad', Railroad.BAndO, 'B. & O.', 'R / R'),
  // 26 - Property 5a: Atlantic Avenue
  new PropertySpace(
    'Atlantic Avenue', PropertyGroup.Yellow, 'ATLN', 260,
    [22, 44, 110, 330, 800, 975, 1150], 150
  ),
  // 27 - Property 5b: Ventnor Avenue
  new PropertySpace(
    'Ventnor Avenue', PropertyGroup.Yellow, 'VENT', 260,
    [22, 44 ,110, 330, 800, 975, 1150], 150
  ),
  // 28 - Utility 2 of 2: Water Works
  new UtilitySpace('Water Works', UtilityType.Water, 'WATER', 'WORKS', 'tint'),
  // 29 - Property 5c: Marvin Gardens
  new PropertySpace(
    'Marvin Gardens', PropertyGroup.Yellow, 'MARV', 280,
    [24, 48, 120, 360, 850, 1025, 1200], 150
  ),
  // 30 - GO TO JAIL
  new BustedSpace('Go to Jail'),
  // 31 - Property 6a: Pacific Avenue
  new PropertySpace(
    'Pacific Avenue', PropertyGroup.Green, 'PACIF', 300,
    [26, 52, 130, 390, 900, 1100, 1275], 200
  ),
  // 32 - Property 6b: North Carolina Avenue
  new PropertySpace(
    'North Carolina Avenue', PropertyGroup.Green, 'N.CRL', 300,
    [26, 52, 130, 390, 900, 1100, 1275], 200
  ),
  // 33 - Deck: Community Chest 3 of 3
  new DeckSpace('Community Chest', DeckType.CommunityChest),
  // 34 - Property 6c: Pennsylvania Avenue
  new PropertySpace(
    'Pennsylvania Avenue', PropertyGroup.Green, 'PENN', 320,
    [28, 56, 150, 450, 1000, 1200, 1400], 200
  ),
  // 35 - Railroad 4 of 4: Short Line
  new RailroadSpace('Short Line', Railroad.ShortLine, 'SHORT', 'LINE'),
  // 36 - Deck: Chance 3 of 3
  new DeckSpace('Chance', DeckType.Chance),
  // 37 - Property 7a: Park Place
  new PropertySpace(
    'Park Place', PropertyGroup.Blue, 'PARK', 350,
    [35, 70, 175, 500, 1100, 1300, 1500], 200
  ),
  // 38 - Tax 2 of 2: Luxury
  new TaxSpace('Luxury Tax', TaxType.Luxury),
  // 39 - Property 7b: Boardwalk
  new PropertySpace(
    'Boardwalk', PropertyGroup.Blue, 'BDWK', 400,
    [50, 100, 200, 600, 1400, 1700, 2000], 200
  ),
];

// Singleton class for managing game state and player turns.
let GameState = {
  // Stores the singleton instance of this GameState.
  instance: false,
  // Each element of `players` is a Player instance.
  players: [],
  // Current player id (false = no players).
  currentPlayer: false,
  // Dice values.
  dice: [0, 0],
  // Milliseconds to wait between space-by-space moves of player token.
  tokenMoveDelay: 500,
  // Amount of money player pays to be freed from Jail.
  bailAmount: 50,
  // Number of in-jail dice rolls a player gets after being thrown in Jail before they are forced to pay the .
  numDoubleTries: 3,

  init(players = []) {
    // Set each player's playerNumber (0..) and add to list.
    players.forEach((player, index) => {
      player.playerNumber = index;
      this.players.push(player);
    });

    // Go through each BoardSpace and set its internal ID (0..39).
    BoardSpaces.forEach((space, index) => {
      space.setId(index);
    });

    // Show "Start Game" state.
    $('button.start-game').attr('disabled', false);
    $('.player-selection').remove();
    $('.tabletop > h1').text('Ready!');
    $('.tabletop .players-list h2').text('Click “Start Game” to begin.');
    this.showActionState('start');
  },

  getBailAmount() {
    return this.bailAmount;
  },

  getBoard() {
    return $('#board');
  },

  getCurrentPlayerDisplay() {
    // Player 0 is displayed as Player 1, and so on.
    return this.currentPlayer + 1;
  },

  getCurrentPlayerIndex() {
    return this.currentPlayer;
  },

  getCurrentPlayerObject() {
    return this.players[this.currentPlayer];
  },

  showActionState(state = 'start') {
    // Hide all actions.
    this.getBoard().find('.action').addClass('hidden');
    // Find specified action.
    let $action = this.getBoard().find('.action.' + state);
    // Check if action exists.
    if (!$action.length) {
      GameState.showModal({
        text:  `Action state "${state}" does not exist.`,
        title: 'ERROR',
      });
      return;
    }
    // Show specified action.
    $action.removeClass('hidden');
  },

  // Refresh game board and tabletop contents.
  refreshBoard() {
    /// BOARD ///

    // First, populate current player number and balance, then show them.
    const playerNbr = this.currentPlayer + 1;
    let B = this.getBoard();
    let currPlayer = this.getCurrentPlayerObject();
    B.find('.player-info .current .value').text(currPlayer.getName());
    B.find('.player-info .player-money .money').text(currPlayer.getMoney());
    B.find('.player-info').removeClass('hidden');
    // Place all tokens in their respective spaces.
    this.players.forEach(player => {
      player.updateToken();
    });

    /// TABLETOP ///

    // Change tabletop title to reflect current status of gameplay.
    $('.tabletop h1').text('Game Status');
    // Define a template we can re-use for each player's status line.
    const tpl =
      `<div class="player-line player-[index]">
        <div class="token color-[color]">[num]</div>
        <div class="name">[name]</div>
        <div class="indicator hidden">Current Turn</div>
      </div>`;
    let $list = $('.tabletop .players-list');
    // Reset player list contents.
    $list.html('');
    // Add each player's token, number, name, turn indicator (if applicable).
    this.players.forEach(player => {
      // Generate player line HTML from template above.
      let playerHtml = tpl
        .replaceAll('[color]', player.tokenColorNum)
        .replaceAll('[name]',  player.name)
        .replaceAll('[num]',   player.playerNumber + 1)
        .replaceAll('[index]', player.playerNumber);
      // Un-hide turn indicator if this is current player.
      if (this.currentPlayer == player.playerNumber) {
        playerHtml = playerHtml.replaceAll('hidden', '');
      }
      // Add player line HTML to player-list.
      $list.append(playerHtml);
    });
    // Now un-hide the player list.
    $list.removeClass('hidden');
    // Store reference to cards list where each stack will be placed.
    let $assets = $('.your-assets .cards');
    // Completely empty out list of asset cards before [re-]adding them in.
    $assets.html('');
    // Next, gather and show current player's assets, starting with Properties.
    for (let color in PropertyGroup) {
      // Go through each color group and check if player owns properties in any.
      if (PropertyGroup.hasOwnProperty(color)) {
        let groupId = PropertyGroup[color];
        let propsInGroup = this.getAllPropertiesInGroup(groupId);
        let ownedProps = [];
        // Go through each property in color group and check if player owns any.
        propsInGroup.forEach(thisProperty => {
          // Does player own this?
          if (thisProperty.owningPlayerId === currPlayer.playerNumber) {
            // Yes, add spaceId to the list.
            let spaceId = thisProperty.getId();
            ownedProps.push(thisProperty);
          }
        });
        // Does player own any spaces in this color group?
        if (ownedProps.length) {
          // They do, so start a new card stack.
          let $propStack = $('<div />').addClass('stack');
          // Populate stack with a minicard for each Property.
          ownedProps.forEach(thisProperty => {
            // Clone another minicard.
            let $propMinicard = $('#templates .minicard.property').clone();
            // Populate color group number and Property name.
            $propMinicard.find('.color-bar.name')
              .addClass('group-' + thisProperty.getGroupId())
              .text(thisProperty.getMiniName());
            // Populate space ID/index.
            $propMinicard.attr('data-space-id', thisProperty.getId());
            // Add the constructed minicard to the stack.
            $propStack.append($propMinicard);
            // Let's save some memory here.
            $propMinicard = null;
          });
          // Now that the stack's been...uh, stacked, we add it to the tabletop.
          $assets.append($propStack);
          $propStack = null;
        }
      }
    }
    // Next, gather Railroads.
    let railroadSpaces = this.getAllSpacesOfType(SpaceType.Railroad);
    if (railroadSpaces.length) {
      // Player owns at least one Railroad.
      let $rrStack = $('<div />').addClass('stack');
      let hasRailroads = false;
      // Populate stack with a minicard for each Railroad.
      railroadSpaces.forEach(thisSpace => {
        if (thisSpace.owningPlayerId === currPlayer.playerNumber) {
          hasRailroads = true;
          // Populate minicard with Railroad name.
          let $rrMinicard = $('#templates .minicard.railroad').clone();
          $rrMinicard.attr('data-space-id', thisSpace.getId());
          let rrNames = thisSpace.getNames();
          $rrMinicard.find('.name1').text(rrNames[0]);
          $rrMinicard.find('.name2').text(rrNames[1]);
          // Add the constructed minicard to the stack.
          $rrStack.append($rrMinicard);
        }
      });
      // Check if stack has anything.
      if (hasRailroads) {
        // Add stack to tabletop.
        $assets.append($rrStack);
      }
      // Clear from memory.
      $rrStack = null;
    }
    // Finally, gather Utilities.
    let utilitySpaces = this.getAllSpacesOfType(SpaceType.Utility);
    if (utilitySpaces.length) {
      // Player owns at least one Utility.
      let $utilStack = $('<div />').addClass('stack');
      let hasUtilities = false;
      // Populate stack with a minicard for each Utility.
      utilitySpaces.forEach(thisSpace => {
        if (thisSpace.owningPlayerId === currPlayer.playerNumber) {
          hasUtilities = true;
          // Populate minicard with Utility icon and name.
          let $utilMinicard = $('#templates .minicard.utility').clone();
          $utilMinicard.attr('data-space-id', thisSpace.getId());
          $utilMinicard.find('i.fa').addClass(thisSpace.getIcon());
          let utilNames = thisSpace.getNames();
          $utilMinicard.find('.name1').text(utilNames[0]);
          $utilMinicard.find('.name2').text(utilNames[1]);
          // Add the constructed minicard to the stack.
          $utilStack.append($utilMinicard);
        }
      });
      // Check if stack has anything.
      if (hasUtilities) {
        // Add stack to tabletop.
        $assets.append($utilStack);
      }
      // Clear from memory.
      $utilStack = null;
    }
    // Show the assets panel, even if empty.
    let $container = $assets.parents('.your-assets');
    $container.find('h3 .name').text(currPlayer.getName());
    $container.removeClass('hidden');
  },

  start() {
    // Randomize starting player index.
    this.currentPlayer = Math.floor(Math.random() * this.players.length);
    // Create a new token for each player.
    this.players.forEach((player, index) => {
      // Set player's token color number internally.
      let colorNum = index + 1;
      player.tokenColorNum = colorNum;
      // Determine player's token color (TODO: make this a user selection).
      let playerColor = 'color-' + colorNum;
      // Create token HTML object.
      let $token = $('<div />')
        .addClass('token ' + playerColor)
        .attr('data-player', index);
      // Add token HTML to the board.
      this.getBoard().append($token);
    });

    // Refresh board and tabletop with new data.
    this.refreshBoard();

    // Begin starting player's turn.
    let currPlayer = this.getCurrentPlayerObject();
    currPlayer.beginTurn();
  },

  rollDice() {
    let player = this.getCurrentPlayerObject();
    // Randomly generate two integers, 1..6
    let die1 = Math.floor(Math.random() * 6) + 1;
    let die2 = Math.floor(Math.random() * 6) + 1;
    // Show numberes on dice.
    $('#die-1').attr('data-value', die1);
    $('#die-2').attr('data-value', die2);
    // Store and show total value.
    this.dice = [die1, die2];
    const diceTotal = die1 + die2;
    this.getBoard().find('.dice-value').text(diceTotal).removeClass('hidden');
    this.getBoard().find('.dice-status').removeClass('hidden');
    // Check if player is rolling for doubles from within Jail.
    if (player.inJail) {
      if (die1 != die2) {
        // No doubles, no go. Decrement tries and check if player is out of tries.
        player.numDoubleTriesLeft--;
        if (player.numDoubleTriesLeft == 0) {
          // Out of tries, so show the "Pay Bail" action state.
          GameState.showActionState('pay-bail');
          // Relinquish control to player to pay bail.
          return;
        }
        this.showModal({
          title: 'Still In Jail',
          text:  'You failed to roll doubles! Number of tries left: ' + player.numDoubleTriesLeft + '. End of turn.',
          onClosed: _ => {
            // End turn.
            GameState.showEndTurn();
          },
        });
      }
      else {
        // Doubles! Free player and move.
        this.showModal({
          title: 'You are Free!',
          text:  'You rolled doubles, so you have been freed from Jail! You will now move the number of spaces shown on the dice.',
          onClosed: _ => {
            // Move player token to Visiting part of space.
            player.freeFromJail();
            // Hide "Roll Dice" to avoid premature re-roll.
            GameState.showActionState('moving');
            // Advance active player's token to space.
            let targetSpace = player.getCurrentSpaceId() + diceTotal;
            player.advanceTokenToSpace(targetSpace);
          },
        });
      }
    }
    else {
      // Hide "Roll Dice" action state to avoid premature re-roll.
      this.showActionState('moving');
      // Advance active player's token to space.
      let targetSpace = player.getCurrentSpaceId() + diceTotal;
      player.advanceTokenToSpace(targetSpace);
    }
  },

  clearDice() {
    // Clear individual dice values internally.
    this.dice = [0, 0];
    // Clear values of each die on board.
    $('#die-1').attr('data-value', '0');
    $('#die-2').attr('data-value', '0');
    // Hide dice status and total value.
    this.getBoard().find('.dice-value').text('');
    this.getBoard().find('.dice-status, .dice-value').addClass('hidden');
  },

  showDice() {
    this.getBoard().find('.dice').removeClass('hidden');
  },

  hideDice() {
    this.getBoard().find('.dice').addClass('hidden');
  },

  getDiceTotal() {
    return this.dice.reduce((sum, val) => sum + val, 0);
  },

  purchaseProperty() {
    // Get space ID and current player.
    let player = this.getCurrentPlayerObject();
    let spaceId = player.getCurrentSpaceId();
    let currSpace = BoardSpaces[spaceId];
    let cost = currSpace.cost;
    // Add space ID to player's list of owned properties.
    player.setPropertyOwned(spaceId);
    // Subtract cost from player's money.
    player.alterMoney(0 - cost);
    // Notify player.
    this.showModal({
      text:  `You have purchased ${currSpace.name} for $${cost}`,
      title: 'Purchase Property',
      onClosed: _ => {
        // End turn.
        GameState.showEndTurn();
      }
    });
  },

  getAllPropertiesInGroup(groupId) {
    let matches = [];
    // Go through each board space, checking for match.
    BoardSpaces.forEach(space => {
      if (
        space.hasTitleDeed() &&
        space.getType()    == SpaceType.Property &&
        space.getGroupId() == groupId
      ) {
        matches.push(space);
      }
    });
    return matches;
  },

  getAllSpacesOfType(spaceType) {
    let matches = [];
    // Go through each board space, checking for match.
    BoardSpaces.forEach(space => {
      if (space.getType() == spaceType) {
        matches.push(space);
      }
    });
    return matches;
  },

  showEndTurn() {
    this.clearDice();
    this.hideDice();
    this.showActionState('end');
  },

  getNumSpacesOfTypeOwned(spaceType, ownerId) {
    let numMatches = 0;
    // Go through each board space, checking for match.
    BoardSpaces.forEach(space => {
      if (
        space.hasTitleDeed() &&
        space.getType() == spaceType &&
        space.owningPlayerId === ownerId
      ) {
        numMatches++;
      }
    });
    return numMatches;
  },

  // Alias for Modal.activate()
  showModal(options = false) {
    if (!options || typeof options !== 'object') return;
    Modal.activate(
      options.text     || 'Unknown error.',
      options.title    || 'Attention',
      options.html     || false,
      options.buttons  || [],
      options.onClosed || false,
    );
  },

}; // end GameState

// Definition of the Player class.
class Player {
  // Whether player is in jail (obviously not true at start).
  inJail = false;

  // How many times a player has left to try rolling doubles to escape jail.
  numDoubleTriesLeft = 0;

  // Whether player has failed all attempts to roll doubles in jail.
  // Used to determine whether or not player must then roll dice before moving.
  failedAllDoublesAttempts = false;

  // How many doubles player has rolled in current turn (3 = Go to Jail).
  numDoublesThisTurn = 0;

  // JSON of `spaceId`s => # houses/hotels (5 = hotel).
  propertiesOwned = {};

  // Current turn position among all players.
  playerNumber = false; // set to int on GameState.init()

  // Current space that this player occupies.
  currentSpaceId = 0;

  // Array of booleans for each deck's "Get Out of Jail Free" card.
  jailbreakCards = {
    chest:  false,
    chance: false,
  };

  // Color number of player token (1..12).
  tokenColorNum = 0;

  constructor(name, money = 1500) {
    this.name  = name;
    this.money = money;
  }

  // Change player's money by given amount.
  alterMoney(amount) {
    this.money += amount;
    this.updateBoardMoneyShown();
    GameState.refreshBoard();
  }

  getName() {
    return this.name;
  }

  getMoney() {
    return this.money;
  }

  getCurrentSpaceId() {
    return this.currentSpaceId;
  }

  // Update money shown on board.
  updateBoardMoneyShown() {
    // Update money displayed.
    $('#board .player-money .money').val(this.money);
  }

  // Set given property as owned by player.
  setPropertyOwned(spaceId) {
    // Add space ID to list of properties owned by player.
    this.propertiesOwned[spaceId] = 0;
    // Set space's owning player to current player index (0..n)
    let space = BoardSpaces[spaceId];
    space.owningPlayerId = this.playerNumber;
  }

  // Check if player owns a property by space ID.
  checkIfOwnsProperty(spaceId) {
    return this.propertiedOwned.include(spaceId);
  }

  // Refresh player token position on board based on currently occupied space.
  updateToken() {
    // Find player token
    let $board = GameState.getBoard();
    let $token = $board.find('.token[data-player="' + this.playerNumber + '"]');
    // Get center of current space.
    let $space = $board.find('.space[data-pos="'  + this.currentSpaceId + '"]');
    let spaceCenter = {
      x: $space.offset().left + $space.width()  / 2 - $board.offset().left,
      y: $space.offset().top  + $space.height() / 2 - $board.offset().top,
    };
    // Update token position.
    $token.css({
      left: `${spaceCenter.x}px`,
      top:  `${spaceCenter.y}px`,
    });
  }

  // Advance token to a target space, one space at a time.
  advanceTokenToSpace(targetSpaceId) {
    let _this = this;
    let moveDelay = GameState.tokenMoveDelay;
    let currSpaceId = this.currentSpaceId;
    // If this is the same space, do nothing.
    if (currSpaceId == targetSpaceId) return;
    // Move to target, one space at a time.
    let thisSpaceId = currSpaceId + 1;
    let didWePassGo = false;
    let intervalId = window.setInterval(_ => {
      let realSpaceId;
      // Are we at or past GO?
      if (thisSpaceId >= BoardSpaces.length) {
        // Check to see if we marked player as passing GO yet.
        if (thisSpaceId > BoardSpaces.length && !didWePassGo) {
          // To prevent multiple triggers, set flag to true.
          didWePassGo = true;
        }
        // Either way, get the REAL space index (0..39).
        realSpaceId = thisSpaceId % BoardSpaces.length;
      }
      else {
        // We're within range, this is already the real space index.
        realSpaceId = thisSpaceId;
      }
      // Move player to this new space and update token.
      this.currentSpaceId = realSpaceId;
      this.updateToken();
      // If we've arrived, clear interval and react to landing on space.
      if (thisSpaceId == targetSpaceId) {
        window.clearInterval(intervalId);
        window.setTimeout(_ => {
          _this.reactToLandOnSpace(didWePassGo);
        }, moveDelay);
      }
      thisSpaceId++;
    }, moveDelay);
  }

  // React to player landing on current space by triggering its onLand() logic.
  reactToLandOnSpace(passedGo) {
    // Run onLand() logic on this space.
    let spaceId = this.getCurrentSpaceId();
    let space = BoardSpaces[spaceId];
    if (passedGo) {
      // Trigger the GO space's onPass() functionality.
      BoardSpaces[0].onPass(_ => {
        // Trigger this space's onLand() functionality after "passed go" message.
        space.onLand();
      });
    }
    else {
      // Otherwise, just trigger this space's onLand() functionality.
      space.onLand();
    }
  }

  // Send player to jail and end turn.
  sendToJail() {
    let $board = GameState.getBoard();
    let $token = $board.find('.token[data-player="' + this.playerNumber + '"]');
    // Get center of "In Jail" portion of Visiting space.
    let jailXY = this.getJailCoords();
    // Set internal flag.
    this.inJail = true;
    // Reset flag for whether player failed all doubles attempts.
    this.failedAllDoublesAttempts = false;
    // Reset player counter for doubles attempts.
    this.numDoubleTriesLeft = GameState.numDoubleTries;
    // Update actual token element.
    $token.css({
      left: `${jailXY.x}px`,
      top:  `${jailXY.y}px`,
    });
    // Show end turn.
    this.showEndTurn();
  }

  // Get center coordinates of the "In Jail" portion of the Jail/Visiting space.
  getJailCoords() {
    let $jail = GameState.getBoard().find('#corner-visiting .subcorner');
    return {
      x: $jail.offset().left + $jail.width()  / 2 - $board.offset().left,
      y: $jail.offset().top  + $jail.height() / 2 - $board.offset().top,
    };
  }

  // Set player free from jail.
  freeFromJail() {
    // Set flag to false.
    this.inJail = false;
    // Reset number of doubles tries left.
    this.numDoubleTriesLeft = 0;
    // Reset flag for whether player failed all doubles attempts.
    this.failedAllDoublesAttempts = false;
    // Move player to actual space ID of Just Visiting space.
    this.currentSpaceId = 10; // TODO: codify this value
    // Update token so it appears in proper place.
    this.updateToken();
  }

  // Pay bail to get out of jail.
  payBail() {
    // Player has chosen to pay bail.
    let bail = GameState.getBailAmount();
    // So pay the bail to the bank.
    this.alterMoney(0 - bail);
    // Now, free the player!
    this.freeFromJail();
    if (this.failedAllDoublesAttempts) {
      // Player must now move number of spaces already shown on dice.
      this.advanceTokenToSpace(this.getCurrentSpaceId() + GameState.getDiceTotal());
    } else {
      // Let player roll dice since they opted to pay bail instead of rolling.
      GameState.showActiveState('roll');
    }
  }

  // Return the player's token element.
  getToken() {
    return $('#board .token[data-player="' + this.playerNumber + '"]');
  }

  // Begin player's turn.
  beginTurn() {
    // Set current player as, well, current.
    GameState.currentPlayer = this.playerNumber;
    // Refresh tabletop to show current player turn and info.
    GameState.refreshBoard();
    // Add active class to token.
    this.getToken().addClass('active');
    // Check if player is in jail.
    if (this.inJail) {
      // In jail. Show pay/roll action state.
      // TODO: Show game state with options to pay bail or roll dice.
    }
    // Not in jail. Let player roll dice.
    else {
      // Switch to "Roll Dice" action state.
      GameState.showActionState('roll');
      // Show blank dice for a fresh roll.
      GameState.clearDice();
      GameState.showDice();
    }
  }

  // Show the "End Turn" action state.
  showEndTurn() {
    GameState.clearDice();
    GameState.hideDice();
    GameState.showActionState('end');
  }

  // End player's turn and begin next player's turn.
  endTurn() {
    let nextPlayer;
    // Increment turn #, reseting to 0 after reaching max.
    let currPlayerId = GameState.getCurrentPlayerIndex()
    let nextPlayerId = (currPlayerId + 1) % GameState.players.length;
    // Clear active class for token.
    this.getToken().removeClass('active');
    // Begin turn for next player.
    nextPlayer = GameState.players[nextPlayerId];
    nextPlayer.beginTurn();
  }

} // end class Player

// Singleton class for managing modal dialogs and actions.
const Modal = {

  // Reference to modal element itself, for showing/hiding & finding child elements.
  getElement: () => $('#modal-overlay'),

  // MUST be run before doing anything with Modal object.
  init() {
    let _this = this;
    // Clear all contents.
    this.clearAll();
    // Assign functionality to close button click event.
    this.get('close').off('click').on('click', e => {
      _this.deactivate();
    });
  },

  // Returns element(s) within the modal matching the given class name.
  get: className => Modal.getElement().find(`.${className}`),

  // Shows modal. Should be run last after loading content & buttons.
  show() {
    let _this = this;
    let $elem = this.getElement();
    $elem.removeClass('hidden');
    // Wait a split-second to ensure animation plays.
    window.setTimeout(_ => {
      // Transition opacity via classes so that it animates.
      $elem.removeClass('hide').addClass('show');
    }, 20);
  },

  // Hides modal. Should be run last after any action btn click events.
  hide() {
    let $elem = this.getElement();
    $elem.removeClass('show').addClass('hide');
    // Wait for fade effect to finish.
    window.setTimeout(_ => {
      // Hide completely, so we can interact with the board again.
      $elem.addClass('hidden');
    }, 250);
  },

  // Loads given content (assumed to be HTML) into modal body.
  loadHtml(contentHtml, title = 'Modal dialog') {
    this.get('modal-content').html('').append(contentHtml);
    this.get('modal-title').text(title);
  },

  // Loads given content (assumed to be plaintext) into modal body.
  loadText(contentText, title = 'Modal dialog', contentElem = false) {
    // If content element given (e.g. 'p'), wrap this around text.
    if (contentElem) {
      let contentHtml = $(`<${contentElem} />`).text(contentText);
      this.loadHtml(contentHtml, title);
      return;
    }
    // No content element given, so just load plaintext as-is.
    this.get('modal-content').text(contentText);
    this.get('modal-title').text(title);
  },

  createButton(className = 'dismiss', btnText = 'Close', onClick = false, consume = false) {
    let _this = this;
    let $btn = $('<button />').text(btnText);
    $btn.addClass('modal-action ' + className);
    // Attach onClick functionality, if any.
    if (typeof onClick === 'function') {
      $btn.on('click', onClick);
    }
    // Check if explicitly TRUE for whether button consumes input.
    if (consume !== true) {
      // We're not consuming input, so trigger dismissal as well.
      $btn.on('click', e => {
        _this.deactivate();
      });
    }
    // Add button to footer.
    this.get('modal-footer').append($btn);
    // Return button itself.
    return $btn;
  },

  activate(content, title = '', isContentHtml = false, buttons = [], onModalClosed = false) {
    let _this = this;
    this.onModalClosed = (typeof onModalClosed === 'function')
      ? onModalClosed : false;
    // Load content and title.
    if (isContentHtml) {
      this.loadHtml(content, title);
    }
    else {
      this.loadText(content, title);
    }
    // Build all buttons.
    if (buttons.length) {
      // Example btnData: {type: 'confirm', text: 'OK', action: FUNC, consume: true}
      buttons.forEach(btnData => {
        // Pass a function, or false to omit.
        let onClickEvent = (typeof btnData.action === 'function')
          ? btnData.action : false;
        // Create button with given data (use defaults where data omitted).
        _this.createButton(
          btnData.type || null,
          btnData.text || null,
          onClickEvent,
          btnData.consume
        );
      });
    }
    else {
      // Create default dismissal "OK" button.
      this.createButton();
    }
    // Show modal.
    this.show();
  },

  // Clear all modal contents.
  clearAll() {
    this.get('modal-title').html('');
    this.get('modal-content').html('');
    this.get('modal-footer').html('');
  },

  deactivate() {
    let _this = this;
    // Hide the modal.
    this.hide();
    // Wait out animation, then clear modal and trigger onModalClosed (if any).
    let onClosed = this.onModalClosed;
    window.setTimeout(_ => {
      _this.clearAll();
      if (onClosed && typeof onClosed === 'function') {
        onClosed();
      }
      // Reset after running once.
      _this.onModalClosed = false;
    }, 250);
  },

}; // end Modal

// Click a title deed card to show a close-up below it.
$('body').on('click', '.minicard a.overlay', e => {
  e.preventDefault();
  let $closeup  = $('.card-closeup');
  let $minicard = $(e.target).parents('.minicard');

  // Remove active class from all other minicards first.
  $('.tabletop .cards .minicard').removeClass('active');
  // And hide all other card close-ups.
  $closeup.find('.card').addClass('hidden');

  // If minicard is already active, hide close-up and deactivate.
  if ($minicard.hasClass('active')) {
    // WHY DOES THIS NEVER GET TRIGGERED?!?!?!
    $closeup.addClass('hidden');
    $minicard.removeClass('active');
    return;
  }

  $minicard.addClass('active');

  const spaceId = $minicard.attr('data-space-id');
  const boardSpace = BoardSpaces[spaceId];

  // Sanity check.
  if (!boardSpace) return;

  const spaceType = boardSpace.getType();
  // If this is still false after switch, there's no deed to show.
  let $card = false;
  // Determine which title deed type we're showing.
  switch (spaceType) {
    case SpaceType.Property:
      $card = $closeup.find('.card.deed.property');
      break;
    case SpaceType.Railroad:
      $card = $closeup.find('.card.deed.railroad');
      break;
    case SpaceType.Utility:
      $card = $closeup.find('.card.deed.utility');
      break;
    default:
      console.error('No title deed to show!');
      return false;
  }

  // Populate appropriate card with property data.
  const propName = boardSpace.getName();
  $card.find('h2 span').text(propName);
  switch (spaceType) {
    case SpaceType.Property:
      // Populate rents.
      const propRents = boardSpace.rent;
      $card.find('.rent-default').text(propRents.default);
      $card.find('.rent-colorset').text(propRents.colorSet);
      $card.find('.rent-1house').text(propRents.houses[1]);
      $card.find('.rent-2house').text(propRents.houses[2]);
      $card.find('.rent-3house').text(propRents.houses[3]);
      $card.find('.rent-4house').text(propRents.houses[4]);
      $card.find('.rent-hotel').text(propRents.hotel);
      $card.find('.cost-building').text(boardSpace.bldgCost);
      // Set color group.
      $card.find('.color-bar')
        .removeClass() // wipe all classes (re-add default class next)
        .addClass('color-bar group-' + boardSpace.groupId);
      break;
    case SpaceType.Railroad:
      // We really don't need to do anything here as there's no data to transfer over.
      break;
    case SpaceType.Utility:
      let $icon = $card.find('i.fa');
      // Reset classes to just base .fa, and add utility icon.
      $icon.removeClass().addClass('fa fa-' + boardSpace.icon);
      break;
  }

  // Show close-up card.
  $card.removeClass('hidden');
  $closeup.removeClass('hidden');
});

// Click Close button in card close-up to close the close-up.
$('body').on('click', '.card-closeup button.close', e => {
  let $container = $(e.target).parents('.card-closeup');
  if (!$container.length) {
    return;
  }
  $('.tabletop .cards .minicard').removeClass('active');
  $container.find('.card').addClass('hidden');
  $container.addClass('hidden');
});

// Click "OK" to confirm # of players and determine how many rows show up.
$('body').on('click', 'button#set-num-players', e => {
  // The """+ converts the value to an int.
  let numPlayers = +$('#num-players').val();
  // Can't have fewer than 2 players, and no more than 12.
  if (numPlayers < 2 || numPlayers > 12) return;
  // Change the subtitle to instruct players to enter their names.
  $('.players-list h2').text('Please enter your names');
  // Set the template HTML for each player name input entry line.
  let $html = `<div class="line">
    <label for="player-name-[NBR]">Player <span class="player-idx">[NBR]</span>&rsquo;s name:</label>
    <input type="text" id="player-name-[NBR]" class="player-name-input" size="15" maxlength="20">
  </div>`;
  let $names = $('.player-selection .player-names');
  // Clear player name input entries.
  $names.find('.line').remove();
  for (let playerNbr = 1; playerNbr <= numPlayers; playerNbr++) {
    let $thisHtml = $html.replaceAll('[NBR]', playerNbr);
    $names.append($thisHtml);
  }
  // Get rid of the selection for number of players.
  $('.player-selection .player-qty').remove();
  // And show the confirm button (disabled at first).
  $('.player-selection .player-confirm').removeClass('hidden');
  // Finally, place focus on the first input element.
  $('.player-selection .player-name-input').first().focus();
});

// Update any player name input field to enable button if all names entered.
$('body').on('keyup', 'input.player-name-input', e => {
  // Start off true. If any field is empty, make false, break, return. Else, enable.
  let showButton = true;
  // Go through each player name input.
  $('input.player-name-input').each((idx, elm) => {
    let $this = $(elm);
    // Remove trailing whitespace, just in case.
    $this.val(
      $.trim( $this.val() )
    );
    // If this is empty, we need to get out of here.
    if ($this.val().length == 0) {
      showButton = false;
    }
  });
  // Set the disabled attribute to the opposite of whether or not we SHOW the button.
  $('button#confirm-players').attr('disabled', !showButton);
});

// Click "Confirm" to confirm players, which initializes GameState with data.
$('body').on('click', 'button#confirm-players', e => {
  // Build the player array first.
  let players = [];

  // Go through each player name input and compile the list of Player objects.
  $('.player-selection input.player-name-input').each((idx, elm) => {
    let $this = $(elm);
    let playerName = $.trim( $this.val() );
    // Create a new Player instance for each name entered.
    players.push( new Player(playerName) );
  });
  // Sanity check.
  if (players.length < 2) return;

  // Initialize game.
  GameState.init(players);
});

// Click "Start Game" to randomize first player & switch to Roll Dice state.
$('body').on('click', 'button.start-game', e => {
  GameState.start();
});

// Click "Roll Dice" to generate random dice values, then move to new space.
$('body').on('click', 'button.roll-dice', e => {
  GameState.rollDice();
});

// Click "Purchase [Property]" to add property to player's list & end turn.
$('body').on('click', 'button.purchase-property', e => {
  GameState.purchaseProperty();
});

// Click "Pay Bail" button to pay and release player from jail.
$('body').on('click', 'button.pay-bail', e => {
  let currPlayer = GameState.getCurrentPlayerObject();
  currPlayer.payBail();
});

// Click "Pass" to show "End Turn" button/state.
$('body').on('click', 'button.skip-property', e => {
  let currPlayer = GameState.getCurrentPlayerObject();
  currPlayer.showEndTurn();
});

// Click "End turn" to end player's turn and begin next one.
$('body').on('click', 'button.end-turn', e => {
  let currPlayer = GameState.getCurrentPlayerObject();
  currPlayer.endTurn();
});

/**
 * On page load...
 */
$(function() {

  // Initialize the Modal object.
  Modal.init();

}); // end docready