def __init__(self, cr):
        NodePath.__init__(self, 'DistributedFindFour')
        DistributedNode.DistributedNode.__init__(self, cr)
        self.cr = cr
        self.reparentTo(render)
        self.boardNode = loader.loadModel('phase_6/models/golf/findfour_game.bam')
        self.boardNode.reparentTo(self)
        self.board = [[0,
          0,
          0,
          0,
          0,
          0,
          0],
         [0,
          0,
          0,
          0,
          0,
          0,
          0],
         [0,
          0,
          0,
          0,
          0,
          0,
          0],
         [0,
          0,
          0,
          0,
          0,
          0,
          0],
         [0,
          0,
          0,
          0,
          0,
          0,
          0],
         [0,
          0,
          0,
          0,
          0,
          0,
          0]]
        self.exitButton = None
        self.inGame = False
        self.waiting = True
        self.startButton = None
        self.playerNum = None
        self.turnText = None
        self.isMyTurn = False
        self.wantTimer = True
        self.leaveButton = None
        self.screenText = None
        self.turnText = None
        self.exitButton = None
        self.numRandomMoves = 0
        self.blinker = Sequence()
        self.playersTurnBlinker = Sequence()
        self.yourTurnBlinker = Sequence()
        self.winningSequence = Sequence()
        self.moveSequence = Sequence()
        self.moveList = []
        self.mySquares = []
        self.playerSeats = None
        self.moveCol = None
        self.move = None
        self.accept('mouse1', self.mouseClick)
        self.traverser = base.cTrav
        self.pickerNode = CollisionNode('mouseRay')
        self.pickerNP = camera.attachNewNode(self.pickerNode)
        self.pickerNode.setFromCollideMask(BitMask32(4096))
        self.pickerRay = CollisionRay()
        self.pickerNode.addSolid(self.pickerRay)
        self.myHandler = CollisionHandlerQueue()
        self.traverser.addCollider(self.pickerNP, self.myHandler)
        self.buttonModels = loader.loadModel('phase_3.5/models/gui/inventory_gui')
        self.upButton = self.buttonModels.find('**//InventoryButtonUp')
        self.downButton = self.buttonModels.find('**/InventoryButtonDown')
        self.rolloverButton = self.buttonModels.find('**/InventoryButtonRollover')
        self.clockNode = ToontownTimer()
        self.clockNode.setPos(1.16, 0, -0.83)
        self.clockNode.setScale(0.3)
        self.clockNode.hide()
        self.tintConstant = Vec4(0.25, 0.25, 0.25, 0)
        self.ghostConstant = Vec4(0, 0, 0, 0.5)
        self.knockSound = base.loadSfx('phase_5/audio/sfx/GUI_knock_1.ogg')
        self.clickSound = base.loadSfx('phase_3/audio/sfx/GUI_balloon_popup.ogg')
        self.moveSound = base.loadSfx('phase_6/audio/sfx/CC_move.ogg')
        self.accept('stoppedAsleep', self.handleSleep)
        from direct.fsm import ClassicFSM, State
        self.fsm = ClassicFSM.ClassicFSM('ChineseCheckers', [State.State('waitingToBegin', self.enterWaitingToBegin, self.exitWaitingToBegin, ['playing', 'gameOver']), State.State('playing', self.enterPlaying, self.exitPlaying, ['gameOver']), State.State('gameOver', self.enterGameOver, self.exitGameOver, ['waitingToBegin'])], 'waitingToBegin', 'waitingToBegin')
        startLoc = self.boardNode.find('**/locators')
        self.locatorList = startLoc.getChildren()
        self.startingPositions = self.locatorList.pop(0)
        self.startingPositions = self.startingPositions.getChildren()
        instancePiece = self.boardNode.find('**/pieces')
        tempList = []
        for x in xrange(7):
            self.startingPositions[x].setTag('StartLocator', '%d' % x)
            collNode = CollisionNode('startpicker%d' % x)
            collNode.setIntoCollideMask(BitMask32(4096))
            tempList.append(self.startingPositions[x].attachNewNode(collNode))
            tempList[x].node().addSolid(CollisionTube(0, 0, 0.23, 0, 0, -.23, 0.2))

        for z in self.startingPositions:
            y = instancePiece.copyTo(z)
            for val in y.getChildren():
                val.hide()

        tempList = []
        for x in xrange(42):
            self.locatorList[x].setTag('GamePeiceLocator', '%d' % x)
            collNode = CollisionNode('startpicker%d' % x)
            collNode.setIntoCollideMask(BitMask32(4096))
            tempList.append(self.locatorList[x].attachNewNode(collNode))
            tempList[x].node().addSolid(CollisionSphere(0, 0, 0, 0.2))

        for z in self.locatorList:
            y = instancePiece.copyTo(z)
            for val in y.getChildren():
                val.hide()

        dummyHide = instancePiece.getParent().attachNewNode('DummyHider')
        instancePiece.reparentTo(dummyHide)
        dummyHide.hide()
        return
Esempio n. 2
0
 def _initTimer(self):
     self._timer = ToontownTimer()
     self._timer.reparentTo(self.root)
     self._timer.posInTopRightCorner()
Esempio n. 3
0
 def _initTimer(self):
     self.timer = ToontownTimer()
     self.timer.hide()
     self.timer.setPos(1.16, 0, -0.83)
Esempio n. 4
0
    def __init__(self, cr):
        NodePath.__init__(self, "DistributedFindFour")
        DistributedNode.DistributedNode.__init__(self, cr)
        self.cr = cr

        self.reparentTo(render)
        self.boardNode = loader.loadModel(
            "phase_6/models/golf/findfour_game.bam")
        self.boardNode.reparentTo(self)
        #self.boardNode.setScale(.05)

        self.board = [[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0],
                      [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0],
                      [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]]

        #game variables
        self.exitButton = None
        self.inGame = False
        self.waiting = True
        self.startButton = None
        self.playerNum = None
        self.turnText = None
        self.isMyTurn = False
        self.wantTimer = True
        self.leaveButton = None
        self.screenText = None
        self.turnText = None
        self.exitButton = None
        self.numRandomMoves = 0
        self.blinker = Sequence()
        self.playersTurnBlinker = Sequence()
        self.yourTurnBlinker = Sequence()
        self.winningSequence = Sequence()
        self.moveSequence = Sequence()
        self.moveList = []
        self.mySquares = []
        self.playerSeats = None
        self.moveCol = None

        self.move = None
        ###self.playerTags = [None, None, None, None, None, None

        #Mouse picking required stuff
        self.accept('mouse1', self.mouseClick)
        self.traverser = base.cTrav
        self.pickerNode = CollisionNode('mouseRay')
        self.pickerNP = camera.attachNewNode(self.pickerNode)
        self.pickerNode.setFromCollideMask(BitMask32(0x1000))
        self.pickerRay = CollisionRay()
        self.pickerNode.addSolid(self.pickerRay)
        self.myHandler = CollisionHandlerQueue()
        self.traverser.addCollider(self.pickerNP, self.myHandler)

        self.buttonModels = loader.loadModel(
            "phase_3.5/models/gui/inventory_gui")
        self.upButton = self.buttonModels.find("**//InventoryButtonUp")
        self.downButton = self.buttonModels.find("**/InventoryButtonDown")
        self.rolloverButton = self.buttonModels.find(
            "**/InventoryButtonRollover")

        self.clockNode = ToontownTimer()
        self.clockNode.setPos(1.16, 0, -0.83)
        self.clockNode.setScale(0.3)
        self.clockNode.hide()

        self.tintConstant = Vec4(.25, .25, .25, 0)
        self.ghostConstant = Vec4(0, 0, 0, .5)

        self.knockSound = base.loader.loadSfx(
            "phase_5/audio/sfx/GUI_knock_1.mp3")
        self.clickSound = base.loader.loadSfx(
            "phase_3/audio/sfx/GUI_balloon_popup.mp3")
        self.moveSound = base.loader.loadSfx("phase_6/audio/sfx/CC_move.mp3")
        self.accept('stoppedAsleep', self.handleSleep)

        #######################
        #Fsm and State Data
        from direct.fsm import ClassicFSM, State
        self.fsm = ClassicFSM.ClassicFSM(
            'ChineseCheckers',
            [
                State.State('waitingToBegin', self.enterWaitingToBegin,
                            self.exitWaitingToBegin, ['playing', 'gameOver']),
                State.State('playing', self.enterPlaying, self.exitPlaying,
                            ['gameOver']),
                State.State('gameOver', self.enterGameOver, self.exitGameOver,
                            ['waitingToBegin'])
            ],
            # Initial State
            'waitingToBegin',
            # Final State
            'waitingToBegin',
        )

        #########################
        #Set up the Board Locators
        ##
        startLoc = self.boardNode.find("**/locators")
        self.locatorList = startLoc.getChildren()

        self.startingPositions = self.locatorList.pop(0)
        self.startingPositions = self.startingPositions.getChildren()

        instancePiece = self.boardNode.find("**/pieces")

        #tag the locators for "picking" ingame
        #also add colision spheres for movement
        tempList = []

        #Start Position locators
        #Up above the board
        for x in range(7):
            self.startingPositions[x].setTag("StartLocator", "%d" % x)
            collNode = CollisionNode("startpicker%d" % x)
            collNode.setIntoCollideMask(BitMask32(0x1000))
            tempList.append(self.startingPositions[x].attachNewNode(collNode))
            tempList[x].node().addSolid(
                CollisionTube(0, 0, .23, 0, 0, -.23, .2))
        for z in self.startingPositions:
            y = instancePiece.copyTo(z)
            for val in y.getChildren():
                val.hide()

        tempList = []
        #the peices themselves inside of the board.
        for x in range(42):
            self.locatorList[x].setTag("GamePeiceLocator", "%d" % x)
            collNode = CollisionNode("startpicker%d" % x)
            collNode.setIntoCollideMask(BitMask32(0x1000))
            tempList.append(self.locatorList[x].attachNewNode(collNode))
            tempList[x].node().addSolid(CollisionSphere(0, 0, 0, .2))
        for z in self.locatorList:
            y = instancePiece.copyTo(z)
            for val in y.getChildren():
                val.hide()

        dummyHide = instancePiece.getParent().attachNewNode("DummyHider")
        instancePiece.reparentTo(dummyHide)
        dummyHide.hide()
    def __init__(self, cr):
        NodePath.__init__(self, 'DistributedChineseCheckers')
        DistributedNode.DistributedNode.__init__(self, cr)
        self.cr = cr
        self.reparentTo(render)
        self.boardNode = loader.loadModel(
            'phase_6/models/golf/checker_game.bam')
        self.boardNode.reparentTo(self)
        self.board = ChineseCheckersBoard()
        self.playerTags = render.attachNewNode('playerTags')
        self.playerTagList = []
        self.exitButton = None
        self.inGame = False
        self.waiting = True
        self.startButton = None
        self.playerNum = None
        self.turnText = None
        self.isMyTurn = False
        self.wantTimer = True
        self.leaveButton = None
        self.screenText = None
        self.turnText = None
        self.exitButton = None
        self.numRandomMoves = 0
        self.blinker = Sequence()
        self.playersTurnBlinker = Sequence()
        self.yourTurnBlinker = Sequence()
        self.moveList = []
        self.mySquares = []
        self.playerSeats = None
        self.accept('mouse1', self.mouseClick)
        self.traverser = base.cTrav
        self.pickerNode = CollisionNode('mouseRay')
        self.pickerNP = camera.attachNewNode(self.pickerNode)
        self.pickerNode.setFromCollideMask(ToontownGlobals.WallBitmask)
        self.pickerRay = CollisionRay()
        self.pickerNode.addSolid(self.pickerRay)
        self.myHandler = CollisionHandlerQueue()
        self.traverser.addCollider(self.pickerNP, self.myHandler)
        self.buttonModels = loader.loadModel(
            'phase_3.5/models/gui/inventory_gui')
        self.upButton = self.buttonModels.find('**//InventoryButtonUp')
        self.downButton = self.buttonModels.find('**/InventoryButtonDown')
        self.rolloverButton = self.buttonModels.find(
            '**/InventoryButtonRollover')
        self.clockNode = ToontownTimer()
        self.clockNode.setPos(1.16, 0, -0.83)
        self.clockNode.setScale(0.3)
        self.clockNode.hide()
        self.playerColors = [
            Vec4(0, 0.9, 0, 1),
            Vec4(0.9, 0.9, 0, 1),
            Vec4(0.45, 0, 0.45, 1),
            Vec4(0.2, 0.4, 0.8, 1),
            Vec4(1, 0.45, 1, 1),
            Vec4(0.8, 0, 0, 1)
        ]
        self.tintConstant = Vec4(0.25, 0.25, 0.25, 0)
        self.ghostConstant = Vec4(0, 0, 0, 0.5)
        self.startingPositions = [
            [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
            [10, 11, 12, 13, 23, 24, 25, 35, 36, 46],
            [65, 75, 76, 86, 87, 88, 98, 99, 100, 101],
            [111, 112, 113, 114, 115, 116, 117, 118, 119, 120],
            [74, 84, 85, 95, 96, 97, 107, 108, 109, 110],
            [19, 20, 21, 22, 32, 33, 34, 44, 45, 55]
        ]
        self.nonOpposingPositions = []
        self.knockSound = base.loadSfx('phase_5/audio/sfx/GUI_knock_1.mp3')
        self.clickSound = base.loadSfx(
            'phase_3/audio/sfx/GUI_balloon_popup.mp3')
        self.moveSound = base.loadSfx('phase_6/audio/sfx/CC_move.mp3')
        self.accept('stoppedAsleep', self.handleSleep)
        from direct.fsm import ClassicFSM, State
        self.fsm = ClassicFSM.ClassicFSM('ChineseCheckers', [
            State.State('waitingToBegin', self.enterWaitingToBegin,
                        self.exitWaitingToBegin, ['playing', 'gameOver']),
            State.State('playing', self.enterPlaying, self.exitPlaying,
                        ['gameOver']),
            State.State('gameOver', self.enterGameOver, self.exitGameOver,
                        ['waitingToBegin'])
        ], 'waitingToBegin', 'waitingToBegin')
        x = self.boardNode.find('**/locators')
        self.locatorList = x.getChildren()
        tempList = []
        for x in range(0, 121):
            self.locatorList[x].setTag('GamePeiceLocator', '%d' % x)
            tempList.append(self.locatorList[x].attachNewNode(
                CollisionNode('picker%d' % x)))
            tempList[x].node().addSolid(CollisionSphere(0, 0, 0, 0.115))

        for z in self.locatorList:
            y = loader.loadModel('phase_6/models/golf/checker_marble.bam')
            z.setColor(0, 0, 0, 0)
            y.reparentTo(z)

        return
Esempio n. 6
0
    def __init__(self, cr):
        NodePath.__init__(self, 'DistributedCheckers')
        DistributedNode.DistributedNode.__init__(self, cr)
        self.cr = cr
        self.reparentTo(render)
        self.boardNode = loader.loadModel(
            'phase_6/models/golf/regular_checker_game.bam')
        self.boardNode.reparentTo(self)
        self.board = CheckersBoard()
        self.exitButton = None
        self.inGame = False
        self.waiting = True
        self.startButton = None
        self.playerNum = None
        self.turnText = None
        self.isMyTurn = False
        self.wantTimer = True
        self.leaveButton = None
        self.screenText = None
        self.turnText = None
        self.exitButton = None
        self.numRandomMoves = 0
        self.blinker = Sequence()
        self.moveList = []
        self.mySquares = []
        self.myKings = []
        self.isRotated = False
        self.accept('mouse1', self.mouseClick)
        self.traverser = base.cTrav
        self.pickerNode = CollisionNode('mouseRay')
        self.pickerNP = camera.attachNewNode(self.pickerNode)
        self.pickerNode.setFromCollideMask(ToontownGlobals.WallBitmask)
        self.pickerRay = CollisionRay()
        self.pickerNode.addSolid(self.pickerRay)
        self.myHandler = CollisionHandlerQueue()
        self.traverser.addCollider(self.pickerNP, self.myHandler)
        self.buttonModels = loader.loadModel(
            'phase_3.5/models/gui/inventory_gui')
        self.upButton = self.buttonModels.find('**//InventoryButtonUp')
        self.downButton = self.buttonModels.find('**/InventoryButtonDown')
        self.rolloverButton = self.buttonModels.find(
            '**/InventoryButtonRollover')
        self.clockNode = ToontownTimer()
        self.clockNode.setPos(1.16, 0, -0.83)
        self.clockNode.setScale(0.3)
        self.clockNode.hide()
        self.playerColors = [Vec4(0, 0, 1, 1), Vec4(0, 1, 0, 1)]
        self.tintConstant = Vec4(0.25, 0.25, 0.25, 0.5)
        self.ghostConstant = Vec4(0, 0, 0, 0.8)
        self.startingPositions = [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
                                  [
                                      20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
                                      30, 31
                                  ]]
        self.knockSound = base.loader.loadSfx(
            'phase_5/audio/sfx/GUI_knock_1.ogg')
        self.clickSound = base.loader.loadSfx(
            'phase_3/audio/sfx/GUI_balloon_popup.ogg')
        self.moveSound = base.loader.loadSfx('phase_6/audio/sfx/CC_move.ogg')
        self.accept('stoppedAsleep', self.handleSleep)
        self.fsm = ClassicFSM.ClassicFSM('ChineseCheckers', [
            State.State('waitingToBegin', self.enterWaitingToBegin,
                        self.exitWaitingToBegin, ['playing', 'gameOver']),
            State.State('playing', self.enterPlaying, self.exitPlaying,
                        ['gameOver']),
            State.State('gameOver', self.enterGameOver, self.exitGameOver,
                        ['waitingToBegin'])
        ], 'waitingToBegin', 'waitingToBegin')
        x = self.boardNode.find('**/locator*')
        self.locatorList = x.getChildren()
        tempList = []
        for x in xrange(0, 32):
            self.locatorList[x].setTag('GamePeiceLocator', '%d' % x)
            tempList.append(self.locatorList[x].attachNewNode(
                CollisionNode('picker%d' % x)))
            tempList[x].node().addSolid(CollisionSphere(0, 0, 0, 0.39))

        for z in self.locatorList:
            y = loader.loadModel(
                'phase_6/models/golf/regular_checker_piecewhite.bam')
            y.find('**/checker_k*').hide()
            zz = loader.loadModel(
                'phase_6/models/golf/regular_checker_pieceblack.bam')
            zz.find('**/checker_k*').hide()
            y.reparentTo(z)
            y.hide()
            zz.reparentTo(z)
            zz.hide()
Esempio n. 7
0
def getNewToontownTimer():
    timer = ToontownTimer()
    timer.hide()
    timer.posInTopRightCorner()
    timer.setColor(1, 1, 1, 0.75)
    return timer
 def _initTimer(self):
     self._timer = ToontownTimer()
     self._timer.hide()
     self._timer.posInTopRightCorner()
Esempio n. 9
0
    def __init__(self, cr):
        self.cr = cr
        NodePath.__init__(self, 'DistributedPicnicTable')
        DistributedNode.DistributedNode.__init__(self, cr)
        self.reparentTo(render)
        self.picnicTable = loader.loadModel(
            'phase_6/models/golf/game_table.bam')
        self.picnicTable.reparentTo(self)
        self.picnicTableSphereNodes = []
        self.numSeats = 6
        self.seats = []
        self.jumpOffsets = []
        self.inGame = False
        self.requestSeat = None
        self.gameState = None
        self.cameraBoardTrack = Func(self.doNothing)
        self.seatBumpForObserve = 0
        self.winTrack = Sequence()
        self.outTrack = Sequence()
        self.joinButton = None
        self.observeButton = None
        self.tutorialButton = None
        self.exitButton = None
        self.isPlaying = False
        self.gameMenu = None
        self.game = None
        self.gameZone = None
        self.tutorial = None
        self.timerFunc = None
        self.gameDoId = None
        self.gameWantTimer = False
        self.tableState = [None, None, None, None, None, None]
        self.haveAnimated = []
        self.winSound = base.loadSfx('phase_6/audio/sfx/KART_Applause_1.mp3')
        self.happyDance = base.loadSfx(
            'phase_5/audio/sfx/AA_heal_happydance.mp3')
        self.accept('stoppedAsleep', self.handleSleep)
        base.localAvatar.startSleepWatch(self.handleSleep)
        self._DistributedPicnicTable__toonTracks = {}
        self.fsm = ClassicFSM.ClassicFSM('PicnicTable', [
            State.State('off', self.enterOff, self.exitOff,
                        ['chooseMode', 'observing']),
            State.State('chooseMode', self.enterChooseMode,
                        self.exitChooseMode, ['sitting', 'off', 'observing']),
            State.State('sitting', self.enterSitting, self.exitSitting,
                        ['off']),
            State.State('observing', self.enterObserving, self.exitObserving,
                        ['off'])
        ], 'off', 'off')
        self.fsm.enterInitialState()
        for i in range(self.numSeats):
            self.seats.append(self.picnicTable.find('**/*seat%d' % (i + 1)))
            self.jumpOffsets.append(
                self.picnicTable.find('**/*jumpOut%d' % (i + 1)))

        self.tableCloth = self.picnicTable.find('**/basket_locator')
        self.tableclothSphereNode = self.tableCloth.attachNewNode(
            CollisionNode('tablecloth_sphere'))
        self.tableclothSphereNode.node().addSolid(
            CollisionSphere(0, 0, -2, 5.5))
        self.clockNode = ToontownTimer()
        self.clockNode.setPos(1.1599999999999999, 0, -0.82999999999999996)
        self.clockNode.setScale(0.29999999999999999)
        self.clockNode.hide()
    def __init__(self, cr):
        NodePath.__init__(self, "DistributedChineseCheckers")
        DistributedNode.DistributedNode.__init__(self, cr)
        self.cr = cr

        self.reparentTo(render)
        self.boardNode = loader.loadModel(
            "phase_6/models/golf/checker_game.bam")
        self.boardNode.reparentTo(self)
        #self.boardNode.setZ(2.85)
        #self.boardNode.setZ(3.5)
        #self.boardNode.setZ(0.3)
        #self.boardNode.setZ(self.getZ())

        self.board = ChineseCheckersBoard()

        self.playerTags = render.attachNewNode("playerTags")
        self.playerTagList = []

        #game variables
        self.exitButton = None
        self.inGame = False
        self.waiting = True
        self.startButton = None
        self.playerNum = None
        self.turnText = None
        self.isMyTurn = False
        self.wantTimer = True
        self.leaveButton = None
        self.screenText = None
        self.turnText = None
        self.exitButton = None
        self.numRandomMoves = 0
        self.blinker = Sequence()
        self.playersTurnBlinker = Sequence()
        self.yourTurnBlinker = Sequence()
        self.moveList = []
        self.mySquares = []
        self.playerSeats = None
        ###self.playerTags = [None, None, None, None, None, None

        #Mouse picking required stuff
        self.accept('mouse1', self.mouseClick)
        self.traverser = base.cTrav
        self.pickerNode = CollisionNode('mouseRay')
        self.pickerNP = camera.attachNewNode(self.pickerNode)
        self.pickerNode.setFromCollideMask(ToontownGlobals.WallBitmask)
        self.pickerRay = CollisionRay()
        self.pickerNode.addSolid(self.pickerRay)
        self.myHandler = CollisionHandlerQueue()
        self.traverser.addCollider(self.pickerNP, self.myHandler)

        self.buttonModels = loader.loadModel(
            "phase_3.5/models/gui/inventory_gui")
        self.upButton = self.buttonModels.find("**//InventoryButtonUp")
        self.downButton = self.buttonModels.find("**/InventoryButtonDown")
        self.rolloverButton = self.buttonModels.find(
            "**/InventoryButtonRollover")

        self.clockNode = ToontownTimer()
        self.clockNode.setPos(1.16, 0, -0.83)
        self.clockNode.setScale(0.3)
        self.clockNode.hide()

        #[0] GREEN [1] YELLOW [2] PURPLE [3] BLUE [4] PINK [5] RED
        self.playerColors = [
            Vec4(0, .90, 0, 1),
            Vec4(.9, .9, 0, 1),
            Vec4(.45, 0, .45, 1),
            Vec4(.2, .4, .8, 1),
            Vec4(1, .45, 1, 1),
            Vec4(.8, 0, 0, 1)
        ]
        self.tintConstant = Vec4(.25, .25, .25, 0)
        self.ghostConstant = Vec4(0, 0, 0, .5)

        #starting positions are used to check and see if a player has gone into
        #his opposing players starting position, thus to tell if he won.
        self.startingPositions = [
            [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
            [10, 11, 12, 13, 23, 24, 25, 35, 36, 46],
            [65, 75, 76, 86, 87, 88, 98, 99, 100, 101],
            [111, 112, 113, 114, 115, 116, 117, 118, 119, 120],
            [74, 84, 85, 95, 96, 97, 107, 108, 109, 110],
            [19, 20, 21, 22, 32, 33, 34, 44, 45, 55]
        ]
        self.nonOpposingPositions = []

        self.knockSound = base.loadSfx("phase_5/audio/sfx/GUI_knock_1.mp3")
        self.clickSound = base.loadSfx(
            "phase_3/audio/sfx/GUI_balloon_popup.mp3")
        self.moveSound = base.loadSfx("phase_6/audio/sfx/CC_move.mp3")
        self.accept('stoppedAsleep', self.handleSleep)

        #base.setCellsAvailable(base.leftCells +
        #[base.bottomCells[0]], 0)

        #base.setCellsAvailable(base.bottomCells,0)

        #######################
        #Fsm and State Data
        from direct.fsm import ClassicFSM, State
        self.fsm = ClassicFSM.ClassicFSM(
            'ChineseCheckers',
            [
                State.State('waitingToBegin', self.enterWaitingToBegin,
                            self.exitWaitingToBegin, ['playing', 'gameOver']),
                State.State('playing', self.enterPlaying, self.exitPlaying,
                            ['gameOver']),
                State.State('gameOver', self.enterGameOver, self.exitGameOver,
                            ['waitingToBegin'])
            ],
            # Initial State
            'waitingToBegin',
            # Final State
            'waitingToBegin',
        )

        #########################
        #Set up the Board Locators
        ##
        x = self.boardNode.find("**/locators")
        #set up the locator list so we can mess with it
        self.locatorList = x.getChildren()
        #tag the locators for "picking" ingame
        #also add colision spheres for movement
        tempList = []
        for x in range(0, 121):
            self.locatorList[x].setTag("GamePeiceLocator", "%d" % x)
            tempList.append(self.locatorList[x].attachNewNode(
                CollisionNode("picker%d" % x)))
            tempList[x].node().addSolid(CollisionSphere(0, 0, 0, .115))
        for z in self.locatorList:
            y = loader.loadModel("phase_6/models/golf/checker_marble.bam")
            z.setColor(0, 0, 0, 0)
            y.reparentTo(z)
Esempio n. 11
0
    def __init__(self, cr):
        self.cr = cr
        NodePath.__init__(self, "DistributedPicnicTable")
        DistributedNode.DistributedNode.__init__(self, cr)

        self.reparentTo(render)
        self.picnicTable = loader.loadModel(
            "phase_6/models/golf/game_table.bam")
        self.picnicTable.reparentTo(self)

        self.picnicTableSphereNodes = []
        self.numSeats = 6
        self.seats = []
        self.jumpOffsets = []
        self.inGame = False
        self.requestSeat = None
        self.gameState = None
        #self.mypos = self.getPos()
        self.cameraBoardTrack = Func(self.doNothing)
        self.seatBumpForObserve = 0
        self.winTrack = Sequence()
        self.outTrack = Sequence()
        self.joinButton = None
        self.observeButton = None
        self.tutorialButton = None
        self.exitButton = None
        self.isPlaying = False
        self.gameMenu = None
        self.game = None
        self.gameZone = None
        self.tutorial = None

        self.timerFunc = None
        self.gameDoId = None
        #self.game = None
        self.gameWantTimer = False

        self.tableState = [None, None, None, None, None, None]
        self.haveAnimated = []
        self.winSound = base.loadSfx("phase_6/audio/sfx/KART_Applause_1.mp3")
        self.happyDance = base.loadSfx(
            "phase_5/audio/sfx/AA_heal_happydance.mp3")

        #Seems like these functions BOTH are required
        #To intercept the sleep event.
        #Important to take action when GUI elements are up to turn
        #them off when the avatar goes to sleep otherwise the wakeup will allow
        #him to run around with the gui up.
        self.accept('stoppedAsleep', self.handleSleep)
        base.localAvatar.startSleepWatch(self.handleSleep)

        self.__toonTracks = {}

        self.fsm = ClassicFSM.ClassicFSM(
            'PicnicTable',
            [
                State.State('off', self.enterOff, self.exitOff,
                            ['chooseMode', 'observing']),
                State.State('chooseMode', self.enterChooseMode,
                            self.exitChooseMode,
                            ['sitting', 'off', 'observing']),
                State.State('sitting', self.enterSitting, self.exitSitting,
                            ['off']),
                State.State('observing', self.enterObserving,
                            self.exitObserving, ['off'])
            ],
            #start state
            'off',
            #final state`
            'off',
        )
        self.fsm.enterInitialState()

        #Go find all of the locators for seats and jumpout locators
        for i in range(self.numSeats):
            self.seats.append(self.picnicTable.find("**/*seat%d" % (i + 1)))
            self.jumpOffsets.append(
                self.picnicTable.find("**/*jumpOut%d" % (i + 1)))
        self.tableCloth = self.picnicTable.find("**/basket_locator")

        #Stops you from walking on the table
        self.tableclothSphereNode = self.tableCloth.attachNewNode(
            CollisionNode('tablecloth_sphere'))
        self.tableclothSphereNode.node().addSolid(
            CollisionSphere(0, 0, -2, 5.5))

        self.clockNode = ToontownTimer()
        self.clockNode.setPos(1.16, 0, -0.83)
        self.clockNode.setScale(0.3)
        self.clockNode.hide()
Esempio n. 12
0
    def __init__(self, cr):
        NodePath.__init__(self, "DistributedCheckers")
        DistributedNode.DistributedNode.__init__(self, cr)
        self.cr = cr

        self.reparentTo(render)
        self.boardNode = loader.loadModel(
            "phase_6/models/golf/regular_checker_game.bam")
        self.boardNode.reparentTo(self)

        self.board = CheckersBoard()

        #game variables
        self.exitButton = None
        self.inGame = False
        self.waiting = True
        self.startButton = None
        self.playerNum = None
        self.turnText = None
        self.isMyTurn = False
        self.wantTimer = True
        self.leaveButton = None
        self.screenText = None
        self.turnText = None
        self.exitButton = None
        self.numRandomMoves = 0
        self.blinker = Sequence()
        self.moveList = []
        self.mySquares = []
        self.myKings = []
        self.isRotated = False

        #Mouse picking required stuff
        self.accept('mouse1', self.mouseClick)
        self.traverser = base.cTrav
        self.pickerNode = CollisionNode('mouseRay')
        self.pickerNP = camera.attachNewNode(self.pickerNode)
        self.pickerNode.setFromCollideMask(ToontownGlobals.WallBitmask)
        self.pickerRay = CollisionRay()
        self.pickerNode.addSolid(self.pickerRay)
        self.myHandler = CollisionHandlerQueue()
        self.traverser.addCollider(self.pickerNP, self.myHandler)

        self.buttonModels = loader.loadModel(
            "phase_3.5/models/gui/inventory_gui")
        self.upButton = self.buttonModels.find("**//InventoryButtonUp")
        self.downButton = self.buttonModels.find("**/InventoryButtonDown")
        self.rolloverButton = self.buttonModels.find(
            "**/InventoryButtonRollover")

        self.clockNode = ToontownTimer()
        self.clockNode.setPos(1.16, 0, -0.83)
        self.clockNode.setScale(0.3)
        self.clockNode.hide()

        #[0] GREEN [1] YELLOW [2] PURPLE [3] BLUE [4] PINK [5] RED
        self.playerColors = [Vec4(0, 0, 1, 1), Vec4(0, 1, 0, 1)]
        self.tintConstant = Vec4(.25, .25, .25, .5)
        self.ghostConstant = Vec4(0, 0, 0, .8)

        #starting positions are used to check and see if a player has gone into
        #his opposing players starting position, thus to tell if he won.
        self.startingPositions = [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
                                  [
                                      20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
                                      30, 31
                                  ]]

        self.knockSound = base.loader.loadSfx(
            "phase_5/audio/sfx/GUI_knock_1.mp3")
        self.clickSound = base.loader.loadSfx(
            "phase_3/audio/sfx/GUI_balloon_popup.mp3")
        self.moveSound = base.loader.loadSfx("phase_6/audio/sfx/CC_move.mp3")
        self.accept('stoppedAsleep', self.handleSleep)

        #######################
        #Fsm and State Data
        # from direct.fsm import ClassicFSM,State
        self.fsm = ClassicFSM.ClassicFSM(
            'ChineseCheckers',
            [
                State.State('waitingToBegin', self.enterWaitingToBegin,
                            self.exitWaitingToBegin, ['playing', 'gameOver']),
                State.State('playing', self.enterPlaying, self.exitPlaying,
                            ['gameOver']),
                State.State('gameOver', self.enterGameOver, self.exitGameOver,
                            ['waitingToBegin'])
            ],
            # Initial State
            'waitingToBegin',
            # Final State
            'waitingToBegin',
        )

        #########################
        #Set up the Board Locators
        ##
        x = self.boardNode.find("**/locator*")
        #set up the locator list so we can mess with it
        self.locatorList = x.getChildren()
        #tag the locators for "picking" ingame
        #also add colision spheres for movement
        tempList = []
        for x in range(0, 32):
            self.locatorList[x].setTag("GamePeiceLocator", "%d" % x)
            tempList.append(self.locatorList[x].attachNewNode(
                CollisionNode("picker%d" % x)))
            tempList[x].node().addSolid(CollisionSphere(0, 0, 0, .39))
        for z in self.locatorList:
            y = loader.loadModel(
                "phase_6/models/golf/regular_checker_piecewhite.bam")
            y.find("**/checker_k*").hide()
            zz = loader.loadModel(
                "phase_6/models/golf/regular_checker_pieceblack.bam")
            zz.find("**/checker_k*").hide()
            y.reparentTo(z)
            y.hide()
            zz.reparentTo(z)
            zz.hide()