Access the 'seating' subcontrol. Note that this will be null in "party" games, because there's no such thing as seats.

Returns true if we are in control of this game. False if another client is in control. Always returns false when called from the game's server agent.

Returns true if this control is connected to a server agent.

A convenience function for ending a single player game with the supplied score. This is equivalent to: endGameWithScores([ getMyId() ], [ score ], TO_EACH_THEIR_OWN). Please read the endGameWithScores documentation for information on the range of allowable scores.

Note that if a single player game is ended with a score of zero, it will be assumed that the player in question abandoned the game and no coins will be paid out, nor will their rating be updated.

Ends the game, reporting the scores earned by each player in the game, awarding coins according to the specified strategy and updating player ratings.

Coins are awarded based on the supplied payout type, either CASCADING_PAYOUT, WINNERS_TAKE_ALL or TO_EACH_THEIR_OWN. In the case of WINNERS_TAKE_CALL, the highest scoring player or players will be considered the winner(s) and in the case of CASCADING_PAYOUT, players will be ranked according to their scores, higher scores being considered better.

If coins are awarded, a COINS_AWARDED event will be dispatched before the GAME_ENDED event is dispatched informing the client that the game has ended.

Both rating and a player's coin payout will be adjusted based on their score. Whirled will track every score reported by your game for its entire existence and will convert newly reported scores to a percentile value between 0 and 99 (inclusive) indicating the percentage of scores in the entire score history that are below the reported score. That percentile ranking will be used to adjust the players rating as well as to determine their individual coin payout.

Note that scores must be positive integers between 0 and 2^30 (1073741824) and higher scores are considered better, so if your game naturally operates with scores where lower is better (elapsed time in a racing game, for example), then you must convert your score to a positive integer by, for example, subtracting your score from a hypothentical worse possible score. For example:

score = Math.max(WORST_POSSIBLE_TIME - actualTime, 1)

Note that if a game is ended with all players scores equal of zero, it will be assumed that the players in question abandoned the game and no coins will be paid out, nor will their ratings be updated.

The gameMode parameter allows you to maintain separate score distributions for different game modes. If your game contains different modes which use scores that are not comparable to one another, or you have various game levels for which you would like to track individual score distributions, you can assign each an integer value between 0 and 99. Only 100 game modes are allowed.

Ends the game, declaring which players are the winners (if players tie, more than one player can be declared a winner. In addition to ending the game, this method awards coins and updates players ratings.

Coins are awarded based on the supplied payout type, either CASCADING_PAYOUT or WINNERS_TAKE_ALL. In the case of WINNERS_TAKE_ALL, the losers will have all of their individual coin payouts combined into a pool and that pool will be evenly divided among the winners and added to their respective individual coin payouts. In the case of CASCADING_PAYOUT, the losers will only have 50% of their individual coin payouts given to the winners.

If coins are awarded, a COINS_AWARDED event will be dispatched before the GAME_ENDED event is dispatched informing the client that the game has ended.

Players' ratings will also be updated using the Elo algorigthm wherein each player is rated against the average ratings of the players that the defeated or were defeated by. In a two player game this degenerates into the standard Elo algorithm.

See also

Ends the current round. If nextRoundDelay is greater than zero, the next round will be started in the specified number of seconds, otherwise no next round will be started. This method should not be called at the end of the last round, instead endGame() should be called.

Get any game-specific configurations that were set up in the lobby.

Returns the player id of the client that is in control of this game.

Returns the set of all item packs available to this game as an array of objects with the following properties:

     ident - string identifier of item pack
     name - human readable name of item pack
     mediaURL - URL for item pack content
     

Returns the set of all level packs available to this game as an array of objects with the following properties:

     ident - string identifier of item pack
     name - human readable name of item pack
     mediaURL - URL for item pack content
     premium - boolean indicating that content is premium or not
     

Returns this client's player id. If this method is called from the game's server agent, the result is SERVER_AGENT_ID. The method amServerAgent can be used to explicitly test for this case.

See also

Returns the player ids of all occupants in the game room: players and watchers. The occupants will be returned in no particular order, and unlike getPlayerIds() there will never be any zeros in the array.

Get the display name of the specified occupant. Two players may have the same name: always use playerId to purposes of identification and comparison. The name is for display only. Will be null is the specified playerId is not present.

Get the party control for the specified party. Note that this will always return a PartySubControl, even for partyIds that are not present in the game. Be careful.

Return the ids of all parties presently in this game.

Returns the current round number. Rounds start at 1 and increase if the game calls endRound with a next round timeout. Between rounds, it returns a negative number, corresponding to the negation of the round that just ended.

See also

Returns the player id of the current turn holder, or 0 if it's nobody's turn.

Is the game currently in play?

A convenience method to just check if it's our turn.

Loads the binary data for the item pack with the specified ident.

Loads the binary data for the level pack with the specified ident.

If the game was not configured to auto-start, which is determined by the 2nd parameter to the GameControl constructor, then all player clients must call this function to let the server know that they are ready, at which point the game will be started.

This method is also used for rematches: once a game has started and finished, all clients can call this function again to start a new game.

Requests to start the game again in the specified number of seconds. This should only be used for party games. Seated table games (including single player games) should have each player report that they are ready again and the game will automatically start.

Start the next player's turn. If a playerId is specified, that player's turn will be next. Otherwise the turn will be assigned randomly the first time, after that following the "natural" turn order. In a seated game, the natural order follows the seating order. In a party game, the natural order is to give the turn to the player that has been around the longest without getting a turn.

Send a system chat message that will be seen by everyone in the game room, even observers.

Tells the system that the server agent will take over for the specified player. If a game wishes the take over the control for a departed player to allow the other players to continue to play with an AI in that player's position or without the player entirely, this method can be used. Only call this method for players that have left the game.

Note: this method can only be called by the server agent. Parameters

Dispatched when the controller changes for the game.

Indicates that a new controller has been assigned.

Dispatched when the game ends.

Indicates that the game has transitioned to a ended state.

Dispatched when the game starts, usually after all players are present.

Indicates that the game has transitioned to a started state.

Dispatched when an occupant enters the game.

Dispatched when an occupant leaves the game.

Dispatched when a party arrives in the game.

An event type dispatched on the GameSubControl when a party joins the game.
name - not used
value - partyId

Dispatched when a party leaves the game.

An event type dispatched on the GameSubControl when a party leaves the game.
name - not used
value - partyId

Dispatched when a round ends.

Indicates that the current round has ended.

Dispatched when a round starts.

Indicates that a round has started. Games that do not require multiple rounds can ignore this event.

Dispatched when the turn changes in a turn-based game.

Indicates that the turn has changed.

Dispatched when a user chats.

The type of a property change event.

Cascading payout skews awards toward the winners by giving 50% of last place's payout to first place, 25% to the next inner pair of opponents (third to second in a four player game, for example), and so on. It is very similar overall to WINNERS_TAKE_ALL, only it rewards everyone at least a little bit.

Proportional is used for games where there is no way to measure player's performance against a global standard, but where the scores are subjective to the particular players currently playing. Each player vies to get their score the highest, and the coins are split up according to the relative scores.

ID constant returned by getMyId when called by a game's server agent.

See also

Each player receives a payout based only on their score and not influenced by the scores of any other player.

Winner takes all splits the total coins available to award to all players in the game among those identified as winners at the end of the game. When used with endGameWithScores, it is intended for games where each player's performance is independant of the others and can be measured against a global standard. The winner(s) will get more coins if they beat someone else who played well than if they beat someone who played poorly. Using it with endGameWithWinners() is intended for games in which there is no per-player score, just some player(s) defeating others. In this case, the game is stating that it cannot distinguish between an excellent player and a poor player, just one won over the others.