Removed yourPlayerId from VerifyMove, Viewing a match, Turn-base
support, and  Betting support

Some fixes in GameAPI:
1) Removed yourPlayerId from VerifyMove
(this should only be used in UpdateUI to determine the graphics. You
shouldn't use it when verifying an opponent move :))

I've decided to just go ahead and implement in GameAPI the extensions
that I wanted the students to build
(https://docs.google.com/document/d/15U_p6d901fov1rxNCyuZmOVF9NavASEuGIMf5AIGHTU/edit#heading=h.iynw3iftc259).
Whoever picks up these assignments will still need to implement it in
the emulator, container and server (so still lots of work :))
I decided to do it because some games (Poker) could use the betting
functionality, and all our other games could use the turn-based
functionality.
(So instead of modifying your games in lesson 8/9 to use that
functionality, it's better to do it from the beginning).
These are the things I added to GameAPI:

2) Viewing a match
Some user (not one of the players) could VIEW an ongoing match.
When you'll build the UI (in HW3) you will need to make sure that a
viewer cannot make moves:

    /** 
     * yourPlayerId can either be the ID of a player in playersInfo, 
     * or 0 for the Artificial Intelligence (AI) player,
     * or -1 to represent that you're VIEWING a match (i.e., you're not
one of the players and 
     * therefore you cannot make moves).
     */
    protected final int yourPlayerId;

3) Turn-base support
Most of our games are turn-based, i.e., we know exactly which player
should make the next move.
Some games could have a mixture of moves that can be done in turn or
simultaneously, 
e.g., the first two MakeMove in battleships (to set your hidden ship
positions) can be done simultaneously, and the later MakeMove have to be
done in turn.
The benefit of having explicit support for turns is that our platform
could support asynchronous play, the container could display who has the
turn, and the platform could automatically set time limits per move.
So I added an operation:
SetTurn(int playerId)
If someone sent SetTurn(playerId) then only playerId could send the
following MakeMove.
There is nothing to change in VerifyMove and UpdateUI because they have
"int lastMovePlayerId", so you know what was the value of the turn.
Please use SetTurn in your games (see how I changed my Cheat game to use
it), basically I replaced all:
      new Set("turn", "W")
with
      new SetTurn(whitePlayerId)


4) Betting support: That was a hard one :)
See the class 
  AttemptChangeTokens(Map playerIdToTokenChange)
and the changes I did to VerifyMove and UpdateUI.
I also added tokens:int to PlayerInfo.

Your poker game should change the tokens by a given amount (you can ask
in HW3 in the UI, how much the player want to "buy-in" based on the
number of tokens they have), and you will the
playerIdToNumberOfTokensInPot updated (based if the player had enough
tokens on the server).
E.g.,
suppose that first player (id=42) gets an empty state, and they have in
playersInfo 5000 tokens, then you can ask in the UI in HW3 how much they
want to buy in, and then they make this move:
[AttemptChangeTokens({42: -2400}, {42: 2400})]
if they had enough tokens on the server, you will get 
UpdateUI(..., playerIdToNumberOfTokensInPot={42: 2400})
(Similarly for the other player)
That's how much money (tokens) the player replaced with poker chips :)
Then in the state you need to keep track of where these chips are, and
when the match ends you should do another call to changes the player
tokens on the server (that one should always succeed because you're
distributing the pot).
E.g., suppose the pot was:
UpdateUI(..., playerIdToNumberOfTokensInPot={42: 2400, 43: 1000})
and 42 and 43 had a poker round where each put 200 chips,
and 42 won the 400 chips,
then when the game ends you should do:
[AttemptChangeTokens({42: 2600, 43: 800}, {42: 0, 43: 0)]