""" *==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.

Additional permissions under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

 *==LICENSE==* """
def PtCreateMarkerGame(callbackKey, gameType, gameName = "", timeLimit = 0, templateId = ""):
    """Creates a new Marker game with the specified callback key, game type (from PtMarkerGameTypes), time limit (in ms), and template id (guid string)"""
    pass

def PtCreateTTTGame(callbackKey, numPlayers):
    """Creates a new TicTacToe game with the specified callback key and number of players (1 or 2)"""
    pass

def PtGetGameCli(gameID):
    """Returns a ptGameCli associated with the specified id"""
    pass

def PtGetGameIDs():
    """Returns a list of game IDs that the player is currently joined to"""
    pass

def PtGetGameNameByTypeID(guid):
    """Returns the name of the game represented by guid passed in as a string"""
    pass

def PtIsBlueSpiralGame(typeID):
    """Returns true if the specifed typeID (guid as a string) is a BlueSpiral game"""
    pass

def PtIsClimbingWallGame(typeID):
    """Returns true if the specifed typeID (guid as a string) is a ClimbingWall game"""
    pass

def PtIsHeekGame(typeID):
    """Returns true if the specifed typeID (guid as a string) is a Heek game"""
    pass

def PtIsMarkerGame(typeID):
    """Returns true if the specifed typeID (guid as a string) is a Marker game"""
    pass

def PtIsTTTGame(typeID):
    """Returns true if the specifed typeID (guid as a string) is a TicTacToe game"""
    pass

def PtIsVarSyncGame(typeID):
    """Returns true if the specifed typeID (guid as a string) is a VarSync game"""
    pass

def PtJoinCommonBlueSpiralGame(callbackKey, gameID):
    """Joins a common BlueSpiral game with the specified ID. If one doesn't exist, it creates it"""
    pass

def PtJoinCommonClimbingWallGame(callbackKey, gameID):
    """Joins a common ClimbingWall game with the specified ID. If one doesn't exist, it creates it"""
    pass

def PtJoinCommonHeekGame(callbackKey, gameID):
    """Joins a common Heek game with the specified ID. If one doesn't exist, it creates it"""
    pass

def PtJoinCommonTTTGame(callbackKey, gameID, numPlayers):
    """Joins a common TicTacToe game with the specified ID. If one doesn't exist, it creates it with the specified number of players"""
    pass

def PtJoinCommonVarSyncGame(callbackKey):
    """Joins the common VarSync game. If one doesn't exist, it creates it"""
    pass

def PtJoinGame(callbackKey, gameID):
    """Sends a join request to the specified game. Messages are sent to the callback key"""
    pass

class ptGameCliMsg:
    """Message from the game server from a game"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptBlueSpiralMsg(ptGameCliMsg):
    """Base class for BlueSpiral game messages"""
    def __init__(self):
        """None"""
        pass

    def getBlueSpiralMsgType(self):
        """Returns the type of the BlueSpiral message (see PtBlueSpiralMsgTypes)"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalBlueSpiralMsg(self):
        """Returns this message as the BlueSpiral message it really is"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptBlueSpiralClothOrderMsg(ptBlueSpiralMsg):
    """BlueSpiral message received when the game is started and the cloth order is set"""
    def __init__(self):
        """None"""
        pass

    def getBlueSpiralMsgType(self):
        """Returns the type of the BlueSpiral message (see PtBlueSpiralMsgTypes)"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def order(self):
        """Returns a list of numbers indicating the correct order to hit the clothes in"""
        pass

    def upcastToFinalBlueSpiralMsg(self):
        """Returns this message as the BlueSpiral message it really is"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptGameCli:
    """Base class for all game client interfaces"""
    def __init__(self):
        """None"""
        pass

    def gameID(self):
        """Returns the ID number for this game"""
        pass

    def gameTypeID(self):
        """Returns the game type ID for this game (as a guid string)"""
        pass

    def invitePlayer(self,playerID):
        """Invites the specified player to join the game"""
        pass

    def leaveGame(self):
        """Leaves this game"""
        pass

    def name(self):
        """Returns the name of the game"""
        pass

    def playerCount(self):
        """Returns the current number of players"""
        pass

    def uninvitePlayer(self,playerID):
        """Revokes the invitation for the specified player"""
        pass

    def upcastToBlueSpiralGame(self):
        """Returns this game client as a ptBlueSpiralGame"""
        pass

    def upcastToClimbingWallGame(self):
        """Returns this game client as a ptClimbingWallGame"""
        pass

    def upcastToHeekGame(self):
        """Returns this game client as a ptHeekGame"""
        pass

    def upcastToMarkerGame(self):
        """Returns this game client as a ptMarkerGame"""
        pass

    def upcastToTTTGame(self):
        """Returns this game client as a ptTTTGame"""
        pass

    def upcastToVarSyncGame(self):
        """Returns this game client as a ptVarSyncGame"""
        pass

class ptBlueSpiralGame(ptGameCli):
    """Game client for the BlueSpiral game"""
    def __init__(self):
        """None"""
        pass

    def gameID(self):
        """Returns the ID number for this game"""
        pass

    def gameTypeID(self):
        """Returns the game type ID for this game (as a guid string)"""
        pass

    def hitCloth(self,clothNum):
        """Tells the server you hit the specified cloth"""
        pass

    def invitePlayer(self,playerID):
        """Invites the specified player to join the game"""
        pass

    def leaveGame(self):
        """Leaves this game"""
        pass

    def name(self):
        """Returns the name of the game"""
        pass

    def playerCount(self):
        """Returns the current number of players"""
        pass

    def startGame(self):
        """Starts a new game"""
        pass

    def uninvitePlayer(self,playerID):
        """Revokes the invitation for the specified player"""
        pass

    def upcastToBlueSpiralGame(self):
        """Returns this game client as a ptBlueSpiralGame"""
        pass

    def upcastToClimbingWallGame(self):
        """Returns this game client as a ptClimbingWallGame"""
        pass

    def upcastToHeekGame(self):
        """Returns this game client as a ptHeekGame"""
        pass

    def upcastToMarkerGame(self):
        """Returns this game client as a ptMarkerGame"""
        pass

    def upcastToTTTGame(self):
        """Returns this game client as a ptTTTGame"""
        pass

    def upcastToVarSyncGame(self):
        """Returns this game client as a ptVarSyncGame"""
        pass

class ptBlueSpiralGameOverMsg(ptBlueSpiralMsg):
    """BlueSpiral message received when the timer runs out, someone hits the wrong cloth, or the game is restarted (before a game start msg in that last case)"""
    def __init__(self):
        """None"""
        pass

    def getBlueSpiralMsgType(self):
        """Returns the type of the BlueSpiral message (see PtBlueSpiralMsgTypes)"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalBlueSpiralMsg(self):
        """Returns this message as the BlueSpiral message it really is"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptBlueSpiralGameStartedMsg(ptBlueSpiralMsg):
    """BlueSpiral message received when someone starts the game (or when you join a game that is running)"""
    def __init__(self):
        """None"""
        pass

    def getBlueSpiralMsgType(self):
        """Returns the type of the BlueSpiral message (see PtBlueSpiralMsgTypes)"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def startSpin(self):
        """Returns true if you are supposed to start spinning the door thingy"""
        pass

    def upcastToFinalBlueSpiralMsg(self):
        """Returns this message as the BlueSpiral message it really is"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptBlueSpiralGameWonMsg(ptBlueSpiralMsg):
    """BlueSpiral message received when the last cloth is successfully hit"""
    def __init__(self):
        """None"""
        pass

    def getBlueSpiralMsgType(self):
        """Returns the type of the BlueSpiral message (see PtBlueSpiralMsgTypes)"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalBlueSpiralMsg(self):
        """Returns this message as the BlueSpiral message it really is"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptBlueSpiralSuccessfulHitMsg(ptBlueSpiralMsg):
    """BlueSpiral message received when a cloth is hit in the correct order"""
    def __init__(self):
        """None"""
        pass

    def getBlueSpiralMsgType(self):
        """Returns the type of the BlueSpiral message (see PtBlueSpiralMsgTypes)"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalBlueSpiralMsg(self):
        """Returns this message as the BlueSpiral message it really is"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptClimbingWallMsg(ptGameCliMsg):
    """Base class for ClimbingWall game messages"""
    def __init__(self):
        """None"""
        pass

    def getClimbingWallMsgType(self):
        """Returns the type of the ClimbingWall message (see PtClimbingWallMsgTypes)"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalClimbingWallMsg(self):
        """Returns this message as the ClimbingWall msg it is"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptClimbingWallBlockersChangedMsg(ptClimbingWallMsg):
    """ClimbingWall message received when the blocker state changes"""
    def __init__(self):
        """None"""
        pass

    def blockersSet(self):
        """Returns an array of blocker indicies denoting which blockers are set"""
        pass

    def getClimbingWallMsgType(self):
        """Returns the type of the ClimbingWall message (see PtClimbingWallMsgTypes)"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def localOnly(self):
        """Returns true if we are only supposed to adjust our stuff locally, and not net-prop it"""
        pass

    def teamNumber(self):
        """The team that this message is for"""
        pass

    def upcastToFinalClimbingWallMsg(self):
        """Returns this message as the ClimbingWall msg it is"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptClimbingWallGame(ptGameCli):
    """Game client for the ClimbingWall game"""
    def __init__(self):
        """None"""
        pass

    def changeBlocker(self,teamNumber, blockerNumber, added):
        """Changes the specified marker's state for the specified team"""
        pass

    def changeNumBlockers(self,amountToAdjust):
        """Adjusts the number of blockers we are playing with"""
        pass

    def finishedGame(self):
        """Tells the server you reached the top of the wall"""
        pass

    def gameID(self):
        """Returns the ID number for this game"""
        pass

    def gameTypeID(self):
        """Returns the game type ID for this game (as a guid string)"""
        pass

    def invitePlayer(self,playerID):
        """Invites the specified player to join the game"""
        pass

    def leaveGame(self):
        """Leaves this game"""
        pass

    def name(self):
        """Returns the name of the game"""
        pass

    def panic(self):
        """Tells the server you are panicking and want your blockers reset"""
        pass

    def playerCount(self):
        """Returns the current number of players"""
        pass

    def playerEntered(self,teamNumber):
        """Tells the server that you are trying to play the game for the specified team"""
        pass

    def ready(self,readyType, teamNumber):
        """Marks the specified team as ready for the specified type (See PtClimbingWallReadyTypes)"""
        pass

    def reset(self):
        """Attempts to reset the game's control panel"""
        pass

    def uninvitePlayer(self,playerID):
        """Revokes the invitation for the specified player"""
        pass

    def upcastToBlueSpiralGame(self):
        """Returns this game client as a ptBlueSpiralGame"""
        pass

    def upcastToClimbingWallGame(self):
        """Returns this game client as a ptClimbingWallGame"""
        pass

    def upcastToHeekGame(self):
        """Returns this game client as a ptHeekGame"""
        pass

    def upcastToMarkerGame(self):
        """Returns this game client as a ptMarkerGame"""
        pass

    def upcastToTTTGame(self):
        """Returns this game client as a ptTTTGame"""
        pass

    def upcastToVarSyncGame(self):
        """Returns this game client as a ptVarSyncGame"""
        pass

class ptClimbingWallGameOverMsg(ptClimbingWallMsg):
    """ClimbingWall message received when the game is over"""
    def __init__(self):
        """None"""
        pass

    def getClimbingWallMsgType(self):
        """Returns the type of the ClimbingWall message (see PtClimbingWallMsgTypes)"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def localOnly(self):
        """Returns true if we are only supposed to adjust our stuff locally, and not net-prop it"""
        pass

    def team1Blockers(self):
        """Returns an array of blocker indicies denoting which blockers team 1 set"""
        pass

    def team2Blockers(self):
        """Returns an array of blocker indicies denoting which blockers team 2 set"""
        pass

    def teamWon(self):
        """The team that won the game"""
        pass

    def upcastToFinalClimbingWallMsg(self):
        """Returns this message as the ClimbingWall msg it is"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptClimbingWallNumBlockersChangedMsg(ptClimbingWallMsg):
    """ClimbingWall message received when the number of blockers is changed"""
    def __init__(self):
        """None"""
        pass

    def getClimbingWallMsgType(self):
        """Returns the type of the ClimbingWall message (see PtClimbingWallMsgTypes)"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def localOnly(self):
        """Returns true if we are only supposed to adjust our stuff locally, and not net-prop it"""
        pass

    def newBlockerCount(self):
        """Returns the number of blockers this game is current running with"""
        pass

    def upcastToFinalClimbingWallMsg(self):
        """Returns this message as the ClimbingWall msg it is"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptClimbingWallPlayerEnteredMsg(ptClimbingWallMsg):
    """ClimbingWall message received when you successfully enter the suit machine"""
    def __init__(self):
        """None"""
        pass

    def getClimbingWallMsgType(self):
        """Returns the type of the ClimbingWall message (see PtClimbingWallMsgTypes)"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalClimbingWallMsg(self):
        """Returns this message as the ClimbingWall msg it is"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptClimbingWallReadyMsg(ptClimbingWallMsg):
    """ClimbingWall message received when the ready state of the teams is changed"""
    def __init__(self):
        """None"""
        pass

    def getClimbingWallMsgType(self):
        """Returns the type of the ClimbingWall message (see PtClimbingWallMsgTypes)"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def localOnly(self):
        """Returns true if we are only supposed to adjust our stuff locally, and not net-prop it"""
        pass

    def readyType(self):
        """The type of ready message this represents (see PtClimbingWallReadyTypes)"""
        pass

    def team1Ready(self):
        """Whether team 1 is ready or not"""
        pass

    def team2Ready(self):
        """Whether team 2 is ready or not"""
        pass

    def upcastToFinalClimbingWallMsg(self):
        """Returns this message as the ClimbingWall msg it is"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptClimbingWallSuitMachineLockedMsg(ptClimbingWallMsg):
    """ClimbingWall message received when the locked state of the suit machines is changed"""
    def __init__(self):
        """None"""
        pass

    def getClimbingWallMsgType(self):
        """Returns the type of the ClimbingWall message (see PtClimbingWallMsgTypes)"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def localOnly(self):
        """Returns true if we are only supposed to adjust our stuff locally, and not net-prop it"""
        pass

    def team1MachineLocked(self):
        """Whether team 1's suit machine is locked or not"""
        pass

    def team2MachineLocked(self):
        """Whether team 2's suit machine is locked or not"""
        pass

    def upcastToFinalClimbingWallMsg(self):
        """Returns this message as the ClimbingWall msg it is"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptGameCliInviteFailedMsg(ptGameCliMsg):
    """Game client message when an invite failed message is received"""
    def __init__(self):
        """None"""
        pass

    def error(self):
        """Returns the error value (See PtGameCliInviteErrors)"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def inviteeID(self):
        """Returns the invitee's ID number"""
        pass

    def operationID(self):
        """Returns the operation's ID number"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptGameCliOwnerChangeMsg(ptGameCliMsg):
    """Game client message when a owner change message is received"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def ownerID(self):
        """Returns the owner's ID number"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptGameCliPlayerJoinedMsg(ptGameCliMsg):
    """Game client message when a player joined message is received"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def playerID(self):
        """Returns the player's ID number"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptGameCliPlayerLeftMsg(ptGameCliMsg):
    """Game client message when a player left message is received"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def playerID(self):
        """Returns the player's ID number"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptGameMgrMsg:
    """Message from the game manager"""
    def __init__(self):
        """None"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameMgrMsgTypes)"""
        pass

    def upcastToInviteReceivedMsg(self):
        """Returns this message as a ptGameMgrInviteReceivedMsg"""
        pass

    def upcastToInviteRevokedMsg(self):
        """Returns this message as a ptGameMgrInviteRevokedMsg"""
        pass

class ptGameMgrInviteReceivedMsg(ptGameMgrMsg):
    """Game manager message when an invite is received"""
    def __init__(self):
        """None"""
        pass

    def gameTypeID(self):
        """Returns the game type ID (as a guid string)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameMgrMsgTypes)"""
        pass

    def inviterID(self):
        """Returns the inviter's ID number"""
        pass

    def newGameID(self):
        """Returns the new game's ID number"""
        pass

    def upcastToInviteReceivedMsg(self):
        """Returns this message as a ptGameMgrInviteReceivedMsg"""
        pass

    def upcastToInviteRevokedMsg(self):
        """Returns this message as a ptGameMgrInviteRevokedMsg"""
        pass

class ptGameMgrInviteRevokedMsg(ptGameMgrMsg):
    """Game manager message when an invite is received"""
    def __init__(self):
        """None"""
        pass

    def gameTypeID(self):
        """Returns the game type ID (as a guid string)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameMgrMsgTypes)"""
        pass

    def inviterID(self):
        """Returns the inviter's ID number"""
        pass

    def newGameID(self):
        """Returns the new game's ID number"""
        pass

    def upcastToInviteReceivedMsg(self):
        """Returns this message as a ptGameMgrInviteReceivedMsg"""
        pass

    def upcastToInviteRevokedMsg(self):
        """Returns this message as a ptGameMgrInviteRevokedMsg"""
        pass

class ptHeekMsg(ptGameCliMsg):
    """Base class for Heek game messages"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getHeekMsgType(self):
        """Returns the type of the Heek message (see PtHeekMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalHeekMsg(self):
        """Returns this message as the Heek message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptHeekCountdownStateMsg(ptHeekMsg):
    """Heek message received by game admin when the countdown state needs to change"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getHeekMsgType(self):
        """Returns the type of the Heek message (see PtHeekMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def state(self):
        """Returns state the countdown should be switched to (see PtHeekCountdownStates)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalHeekMsg(self):
        """Returns this message as the Heek message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptHeekDropMsg(ptHeekMsg):
    """Heek message received when another player's position needs to be reset/modified"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getHeekMsgType(self):
        """Returns the type of the Heek message (see PtHeekMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def position(self):
        """Returns player position to cleanup and dump"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalHeekMsg(self):
        """Returns this message as the Heek message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptHeekGame(ptGameCli):
    """Game client for the Heek game"""
    def __init__(self):
        """None"""
        pass

    def choose(self,choice):
        """Makes the specified move (see PtHeekGameChoice)"""
        pass

    def gameID(self):
        """Returns the ID number for this game"""
        pass

    def gameTypeID(self):
        """Returns the game type ID for this game (as a guid string)"""
        pass

    def invitePlayer(self,playerID):
        """Invites the specified player to join the game"""
        pass

    def leaveGame(self):
        """Leaves this game (puts us into "observer" mode"""
        pass

    def name(self):
        """Returns the name of the game"""
        pass

    def playGame(self,position, points, name):
        """Requests to start playing the game in the specified position"""
        pass

    def playerCount(self):
        """Returns the current number of players"""
        pass

    def sequenceFinished(self,sequence):
        """Tells the server that the specified animation finished (see PtHeekGameSeq)"""
        pass

    def uninvitePlayer(self,playerID):
        """Revokes the invitation for the specified player"""
        pass

    def upcastToBlueSpiralGame(self):
        """Returns this game client as a ptBlueSpiralGame"""
        pass

    def upcastToClimbingWallGame(self):
        """Returns this game client as a ptClimbingWallGame"""
        pass

    def upcastToHeekGame(self):
        """Returns this game client as a ptHeekGame"""
        pass

    def upcastToMarkerGame(self):
        """Returns this game client as a ptMarkerGame"""
        pass

    def upcastToTTTGame(self):
        """Returns this game client as a ptTTTGame"""
        pass

    def upcastToVarSyncGame(self):
        """Returns this game client as a ptVarSyncGame"""
        pass

class ptHeekGameWinMsg(ptHeekMsg):
    """Heek message received by game admin when a game is won"""
    def __init__(self):
        """None"""
        pass

    def choice(self):
        """Returns the choice that won (see PtHeekGameChoice)"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getHeekMsgType(self):
        """Returns the type of the Heek message (see PtHeekMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalHeekMsg(self):
        """Returns this message as the Heek message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptHeekGoodbyeMsg(ptHeekMsg):
    """Heek message received when the server processes leave request"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getHeekMsgType(self):
        """Returns the type of the Heek message (see PtHeekMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalHeekMsg(self):
        """Returns this message as the Heek message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptHeekInterfaceStateMsg(ptHeekMsg):
    """Heek message received when your interface buttons need to enable or disable"""
    def __init__(self):
        """None"""
        pass

    def buttonsEnabled(self):
        """Returns whether your buttons should be enabled"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getHeekMsgType(self):
        """Returns the type of the Heek message (see PtHeekMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalHeekMsg(self):
        """Returns this message as the Heek message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptHeekLightStateMsg(ptHeekMsg):
    """Heek message received when one of your local lights needs to change state"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getHeekMsgType(self):
        """Returns the type of the Heek message (see PtHeekMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def lightNum(self):
        """Returns the index of the light this refers to"""
        pass

    def state(self):
        """Returns state the light should be switched to (see PtHeekLightStates)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalHeekMsg(self):
        """Returns this message as the Heek message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptHeekPlayGameMsg(ptHeekMsg):
    """Heek message received when the server processes your play game request"""
    def __init__(self):
        """None"""
        pass

    def enableButtons(self):
        """Returns true if we should enable the buttons at the place we sat down"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getHeekMsgType(self):
        """Returns the type of the Heek message (see PtHeekMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def isPlaying(self):
        """Returns true if the server accepted the play game request"""
        pass

    def isSinglePlayer(self):
        """Returns true if you are the only player at the table"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalHeekMsg(self):
        """Returns this message as the Heek message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptHeekPointUpdateMsg(ptHeekMsg):
    """Heek message received when the number of points you have needs to be changed"""
    def __init__(self):
        """None"""
        pass

    def displayUpdate(self):
        """Returns whether you should display a message to the user"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getHeekMsgType(self):
        """Returns the type of the Heek message (see PtHeekMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def points(self):
        """Returns your new amount of points"""
        pass

    def rank(self):
        """Returns your new rank"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalHeekMsg(self):
        """Returns this message as the Heek message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptHeekSetupMsg(ptHeekMsg):
    """Heek message for setting up each position's state"""
    def __init__(self):
        """None"""
        pass

    def buttonState(self):
        """Returns whether the buttons are enabled or not"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getHeekMsgType(self):
        """Returns the type of the Heek message (see PtHeekMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def lightOn(self):
        """Returns a list of bools representing lights on or off"""
        pass

    def position(self):
        """Returns the position this message is for"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalHeekMsg(self):
        """Returns this message as the Heek message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptHeekWelcomeMsg(ptHeekMsg):
    """Heek message received when a new player sits down"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getHeekMsgType(self):
        """Returns the type of the Heek message (see PtHeekMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def name(self):
        """Returns the new player's name"""
        pass

    def points(self):
        """Returns the new player's points"""
        pass

    def rank(self):
        """Returns the new player's rank"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalHeekMsg(self):
        """Returns this message as the Heek message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptHeekWinLoseMsg(ptHeekMsg):
    """Heek message received when the round is over and you won or lost"""
    def __init__(self):
        """None"""
        pass

    def choice(self):
        """Returns the choice that won or lost (see PtHeekGameChoice)"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getHeekMsgType(self):
        """Returns the type of the Heek message (see PtHeekMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalHeekMsg(self):
        """Returns this message as the Heek message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

    def win(self):
        """Returns true if you won"""
        pass

class ptMarkerGame(ptGameCli):
    """Game client for the Marker game"""
    def __init__(self):
        """None"""
        pass

    def addMarker(self,x, y, z, name = "", age = ""):
        """Adds a marker to the game. Age is ignored in a non-quest game. Won't work if you're not the owner/creator"""
        pass

    def captureMarker(self,markerId):
        """Captures the specified marker"""
        pass

    def changeGameName(self,newName):
        """Changes the name of the game. Won't work if you're not the game owner/creator"""
        pass

    def changeMarkerName(self,markerId, newName):
        """Changes the name of the specified marker. Won't work if you're not the game owner/creator"""
        pass

    def changeTimeLimit(self,newTimeLimit):
        """Changes the time limit on the game (in ms). Won't work if you're not the game owner/creator, or if it's a quest game"""
        pass

    def deleteGame(self):
        """Tells the server to delete the game. Won't work if you're not the game owner/creator"""
        pass

    def deleteMarker(self,markerId):
        """Deletes the specified marker from the game. Won't work if you're not the game owner/creator"""
        pass

    def gameID(self):
        """Returns the ID number for this game"""
        pass

    def gameTypeID(self):
        """Returns the game type ID for this game (as a guid string)"""
        pass

    def invitePlayer(self,playerID):
        """Invites the specified player to join the game"""
        pass

    def leaveGame(self):
        """Leaves this game"""
        pass

    def name(self):
        """Returns the name of the game"""
        pass

    def pauseGame(self):
        """Pauses the game. Won't work on MP games if you're not the owner/creator"""
        pass

    def playerCount(self):
        """Returns the current number of players"""
        pass

    def resetGame(self):
        """Resets the game. Won't work on MP games if you're not the owner/creator"""
        pass

    def startGame(self):
        """Starts the game. Won't work on MP games if you're not the owner/creator"""
        pass

    def uninvitePlayer(self,playerID):
        """Revokes the invitation for the specified player"""
        pass

    def upcastToBlueSpiralGame(self):
        """Returns this game client as a ptBlueSpiralGame"""
        pass

    def upcastToClimbingWallGame(self):
        """Returns this game client as a ptClimbingWallGame"""
        pass

    def upcastToHeekGame(self):
        """Returns this game client as a ptHeekGame"""
        pass

    def upcastToMarkerGame(self):
        """Returns this game client as a ptMarkerGame"""
        pass

    def upcastToTTTGame(self):
        """Returns this game client as a ptTTTGame"""
        pass

    def upcastToVarSyncGame(self):
        """Returns this game client as a ptVarSyncGame"""
        pass

class ptMarkerMsg(ptGameCliMsg):
    """Base class for Marker game messages"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getMarkerMsgType(self):
        """Returns the type of the Marker message (see PtMarkerMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalMarkerMsg(self):
        """Returns this message as the Marker message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptMarkerGameDeletedMsg(ptMarkerMsg):
    """Marker message received when the game is deleted"""
    def __init__(self):
        """None"""
        pass

    def failed(self):
        """Returns whether the delete succeeded or not"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getMarkerMsgType(self):
        """Returns the type of the Marker message (see PtMarkerMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalMarkerMsg(self):
        """Returns this message as the Marker message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptMarkerGameNameChangedMsg(ptMarkerMsg):
    """Marker message received when the game name is changed"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getMarkerMsgType(self):
        """Returns the type of the Marker message (see PtMarkerMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def name(self):
        """Returns the new game name"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalMarkerMsg(self):
        """Returns this message as the Marker message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptMarkerGameOverMsg(ptMarkerMsg):
    """Marker message received when the server determines the game is over (usually via timeout)"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getMarkerMsgType(self):
        """Returns the type of the Marker message (see PtMarkerMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalMarkerMsg(self):
        """Returns this message as the Marker message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptMarkerGamePausedMsg(ptMarkerMsg):
    """Marker message received when the game is paused by the owner"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getMarkerMsgType(self):
        """Returns the type of the Marker message (see PtMarkerMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def timeLeft(self):
        """Returns the amount of time left on the server clock"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalMarkerMsg(self):
        """Returns this message as the Marker message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptMarkerGameResetMsg(ptMarkerMsg):
    """Marker message received when the game is reset by the owner"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getMarkerMsgType(self):
        """Returns the type of the Marker message (see PtMarkerMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalMarkerMsg(self):
        """Returns this message as the Marker message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptMarkerGameStartedMsg(ptMarkerMsg):
    """Marker message received when the game is started by the owner"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getMarkerMsgType(self):
        """Returns the type of the Marker message (see PtMarkerMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalMarkerMsg(self):
        """Returns this message as the Marker message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptMarkerGameTypeMsg(ptMarkerMsg):
    """Marker message received when you are assigned a team number"""
    def __init__(self):
        """None"""
        pass

    def gameType(self):
        """Returns the type of the game you just joined"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getMarkerMsgType(self):
        """Returns the type of the Marker message (see PtMarkerMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalMarkerMsg(self):
        """Returns this message as the Marker message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptMarkerMarkerAddedMsg(ptMarkerMsg):
    """Marker message received when a marker is added to the game"""
    def __init__(self):
        """None"""
        pass

    def age(self):
        """Returns the age the marker was created in"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getMarkerMsgType(self):
        """Returns the type of the Marker message (see PtMarkerMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def markerId(self):
        """Returns the id number of the marker"""
        pass

    def name(self):
        """Returns the name of the marker"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalMarkerMsg(self):
        """Returns this message as the Marker message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

    def x(self):
        """Returns x coord of the marker"""
        pass

    def y(self):
        """Returns y coord of the marker"""
        pass

    def z(self):
        """Returns z coord of the marker"""
        pass

class ptMarkerMarkerCapturedMsg(ptMarkerMsg):
    """Marker message received when a marker is captured"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getMarkerMsgType(self):
        """Returns the type of the Marker message (see PtMarkerMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def markerId(self):
        """Returns id of the marker which was captured"""
        pass

    def team(self):
        """Returns the team number of the team that captured it (0 for no team, or a quest game)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalMarkerMsg(self):
        """Returns this message as the Marker message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptMarkerMarkerDeletedMsg(ptMarkerMsg):
    """Marker message received when a marker is deleted"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getMarkerMsgType(self):
        """Returns the type of the Marker message (see PtMarkerMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def markerId(self):
        """Returns id of the marker that was deleted"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalMarkerMsg(self):
        """Returns this message as the Marker message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptMarkerMarkerNameChangedMsg(ptMarkerMsg):
    """Marker message received when the name of a marker is changed"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getMarkerMsgType(self):
        """Returns the type of the Marker message (see PtMarkerMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def markerId(self):
        """Returns id of the marker who's name was changed"""
        pass

    def name(self):
        """Returns the new name"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalMarkerMsg(self):
        """Returns this message as the Marker message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptMarkerTeamAssignedMsg(ptMarkerMsg):
    """Marker message received when you are assigned a team number"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getMarkerMsgType(self):
        """Returns the type of the Marker message (see PtMarkerMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def teamNumber(self):
        """Returns the number of the team you were assigned to"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalMarkerMsg(self):
        """Returns this message as the Marker message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptMarkerTemplateCreatedMsg(ptMarkerMsg):
    """Marker message received when a quest game template is created"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getMarkerMsgType(self):
        """Returns the type of the Marker message (see PtMarkerMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def templateID(self):
        """Returns the ID number of the template that was created"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalMarkerMsg(self):
        """Returns this message as the Marker message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptMarkerTimeLimitChangedMsg(ptMarkerMsg):
    """Marker message received when the game name is changed"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getMarkerMsgType(self):
        """Returns the type of the Marker message (see PtMarkerMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def timeLimit(self):
        """Returns the new time limit (in ms)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalMarkerMsg(self):
        """Returns this message as the Marker message it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptTTTGame(ptGameCli):
    """Game client for the TicTacToe game"""
    def __init__(self):
        """None"""
        pass

    def gameID(self):
        """Returns the ID number for this game"""
        pass

    def gameTypeID(self):
        """Returns the game type ID for this game (as a guid string)"""
        pass

    def invitePlayer(self,playerID):
        """Invites the specified player to join the game"""
        pass

    def leaveGame(self):
        """Leaves this game"""
        pass

    def makeMove(self,row, col):
        """Makes a move in the specified spot"""
        pass

    def name(self):
        """Returns the name of the game"""
        pass

    def playerCount(self):
        """Returns the current number of players"""
        pass

    def showBoard(self):
        """Prints the current board layout to the console"""
        pass

    def uninvitePlayer(self,playerID):
        """Revokes the invitation for the specified player"""
        pass

    def upcastToBlueSpiralGame(self):
        """Returns this game client as a ptBlueSpiralGame"""
        pass

    def upcastToClimbingWallGame(self):
        """Returns this game client as a ptClimbingWallGame"""
        pass

    def upcastToHeekGame(self):
        """Returns this game client as a ptHeekGame"""
        pass

    def upcastToMarkerGame(self):
        """Returns this game client as a ptMarkerGame"""
        pass

    def upcastToTTTGame(self):
        """Returns this game client as a ptTTTGame"""
        pass

    def upcastToVarSyncGame(self):
        """Returns this game client as a ptVarSyncGame"""
        pass

class ptTTTMsg(ptGameCliMsg):
    """Base class for TicTacToe game messages"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getTTTMsgType(self):
        """Returns the type of the TTT message (see PtTTTMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalTTTMsg(self):
        """Returns this message as the TTT msg it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptTTTGameOverMsg(ptTTTMsg):
    """TicTacToe message received when the game is over"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getTTTMsgType(self):
        """Returns the type of the TTT message (see PtTTTMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def result(self):
        """Returns the result of the game (see PtTTTGameResult)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalTTTMsg(self):
        """Returns this message as the TTT msg it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

    def winnerID(self):
        """Returns the winner's ID"""
        pass

class ptTTTGameStartedMsg(ptTTTMsg):
    """TicTacToe message received when the game is started"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getTTTMsgType(self):
        """Returns the type of the TTT message (see PtTTTMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalTTTMsg(self):
        """Returns this message as the TTT msg it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

    def yourTurn(self):
        """Returns true if you are the first player (and therefore it's your turn)"""
        pass

class ptTTTMoveMadeMsg(ptTTTMsg):
    """TicTacToe message received when someone makes a move"""
    def __init__(self):
        """None"""
        pass

    def col(self):
        """Returns the col index of the move (1..3)"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getTTTMsgType(self):
        """Returns the type of the TTT message (see PtTTTMsgTypes)"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def playerID(self):
        """Returns the the ID of the player that just moved"""
        pass

    def row(self):
        """Returns the row index of the move (1..3)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalTTTMsg(self):
        """Returns this message as the TTT msg it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptVarSyncMsg(ptGameCliMsg):
    """Base class for VarSync game messages"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def getVarSyncMsgType(self):
        """Returns the type of the VarSync message (see PtVarSyncMsgTypes)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalVarSyncMsg(self):
        """Returns this message as the VarSync msg it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptVarSyncAllVarsSentMsg(ptVarSyncMsg):
    """VarSync message received after the last var is sent to you when you join the game, or request a list of vars"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def getVarSyncMsgType(self):
        """Returns the type of the VarSync message (see PtVarSyncMsgTypes)"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalVarSyncMsg(self):
        """Returns this message as the VarSync msg it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

class ptVarSyncGame(ptGameCli):
    """Game client for the VarSync game"""
    def __init__(self):
        """None"""
        pass

    def createNumericVar(self,varName, value):
        """Attempts to create a new numeric variable and set it to the specified number (clipped to double)"""
        pass

    def createStringVar(self,varName, value):
        """Attempts to create a new string variable and set it to the specified string (clipped to 255 chars)"""
        pass

    def gameID(self):
        """Returns the ID number for this game"""
        pass

    def gameTypeID(self):
        """Returns the game type ID for this game (as a guid string)"""
        pass

    def invitePlayer(self,playerID):
        """Invites the specified player to join the game"""
        pass

    def leaveGame(self):
        """Leaves this game"""
        pass

    def name(self):
        """Returns the name of the game"""
        pass

    def playerCount(self):
        """Returns the current number of players"""
        pass

    def requestAllVars(self):
        """Requests all the vars the server knows about"""
        pass

    def setNumericVar(self,varID, value):
        """Attempts to set a numeric variable to the specified number (clipped to double)"""
        pass

    def setStringVar(self,varID, value):
        """Attempts to set a string variable to the specified string (clipped to 255 chars)"""
        pass

    def uninvitePlayer(self,playerID):
        """Revokes the invitation for the specified player"""
        pass

    def upcastToBlueSpiralGame(self):
        """Returns this game client as a ptBlueSpiralGame"""
        pass

    def upcastToClimbingWallGame(self):
        """Returns this game client as a ptClimbingWallGame"""
        pass

    def upcastToHeekGame(self):
        """Returns this game client as a ptHeekGame"""
        pass

    def upcastToMarkerGame(self):
        """Returns this game client as a ptMarkerGame"""
        pass

    def upcastToTTTGame(self):
        """Returns this game client as a ptTTTGame"""
        pass

    def upcastToVarSyncGame(self):
        """Returns this game client as a ptVarSyncGame"""
        pass

class ptVarSyncNumericVarChangedMsg(ptVarSyncMsg):
    """VarSync message received when a numeric variable's value changes"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def getVarSyncMsgType(self):
        """Returns the type of the VarSync message (see PtVarSyncMsgTypes)"""
        pass

    def id(self):
        """Returns the id of the var that changed"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalVarSyncMsg(self):
        """Returns this message as the VarSync msg it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

    def value(self):
        """Returns the variable's new value"""
        pass

class ptVarSyncNumericVarCreatedMsg(ptVarSyncMsg):
    """VarSync message received when a numeric variable is created and assigned an id"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def getVarSyncMsgType(self):
        """Returns the type of the VarSync message (see PtVarSyncMsgTypes)"""
        pass

    def id(self):
        """Returns the id assigned to this variable"""
        pass

    def name(self):
        """Returns the name of the var that was created"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalVarSyncMsg(self):
        """Returns this message as the VarSync msg it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

    def value(self):
        """Returns the variable's new value"""
        pass

class ptVarSyncStringVarChangedMsg(ptVarSyncMsg):
    """VarSync message received when a string variable's value changes"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def getVarSyncMsgType(self):
        """Returns the type of the VarSync message (see PtVarSyncMsgTypes)"""
        pass

    def id(self):
        """Returns the id of the var that changed"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalVarSyncMsg(self):
        """Returns this message as the VarSync msg it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

    def value(self):
        """Returns the variable's new value"""
        pass

class ptVarSyncStringVarCreatedMsg(ptVarSyncMsg):
    """VarSync message received when a string variable is created and assigned an id"""
    def __init__(self):
        """None"""
        pass

    def getGameCli(self):
        """Returns the game client associated with this message"""
        pass

    def getType(self):
        """Returns the type of the message (see PtGameCliMsgTypes)"""
        pass

    def getVarSyncMsgType(self):
        """Returns the type of the VarSync message (see PtVarSyncMsgTypes)"""
        pass

    def id(self):
        """Returns the id that was assigned to this variable"""
        pass

    def name(self):
        """Returns the name of the var that was created"""
        pass

    def upcastToFinalGameCliMsg(self):
        """Returns this message as the game client message it is (player joined, player left, invite failed, or owner change)"""
        pass

    def upcastToFinalVarSyncMsg(self):
        """Returns this message as the VarSync msg it is"""
        pass

    def upcastToGameMsg(self):
        """Returns this message as the base class of message for the game it is associated with (ttt, heek, marker, etc)"""
        pass

    def value(self):
        """Returns the variable's new value"""
        pass