def _initVisuals(self):
     RepairMincroGame._initVisuals(self)
     self.setBin('fixed', 36)
     self.model = loader.loadModel('models/gui/pir_m_gui_srp_sawing_main')
     sawModel = self.model.find('**/saw')
     sawModel.setR(193)
     sawModel.setPos(0.9, 0.0, -0.165)
     sawModel.setBin('gui-popup', 0)
     self.sawButton = RepairSaw(parent=self,
                                clickDownCommand=self.sawAttachedToMouse,
                                clickUpCommand=self.sawRemovedFromMouse,
                                geom=sawModel,
                                text_pos=(0.2, -0.3),
                                text_fg=(1, 0, 0, 1),
                                scale=(0.3, 0.3, 0.3),
                                relief=None,
                                pressEffect=0,
                                frameSize=(-0.05, 1.05, -0.3, 0.05),
                                rolloverSound=None,
                                clickSound=None)
     self.sawingLine = RepairSawingLine(self,
                                        self.config.sawlineLineThickness,
                                        self.config.sawlineColor,
                                        self.config.sawlineLinespawnDist)
     self.progressDescriptionLabel = DirectLabel(
         text=PLocalizer.Minigame_Repair_Sawing_Description,
         text_fg=(1.0, 1.0, 1.0, 1.0),
         text_pos=(0.0, 0.0),
         text_shadow=(0.0, 0.0, 0.0, 1.0),
         text_font=PiratesGlobals.getPirateFont(),
         text_align=TextNode.ARight,
         relief=None,
         scale=(0.08, 0.08, 0.08),
         pos=(-0.2, 0.0, 0.5),
         parent=self)
     self.progressLabel = DirectLabel(
         text=PLocalizer.Minigame_Repair_Sawing_Thresholds[3],
         text_fg=(1.0, 1.0, 1.0, 1.0),
         text_pos=(0.0, 0.0),
         text_shadow=(0.0, 0.0, 0.0, 1.0),
         text_font=PiratesGlobals.getPirateFont(),
         text_align=TextNode.ALeft,
         relief=None,
         scale=(0.08, 0.08, 0.08),
         pos=(-0.18, 0.0, 0.5),
         parent=self)
     self.boardDestroyedLabel = DirectLabel(
         text=PLocalizer.Minigame_Repair_Sawing_Board_Destroyed,
         text_fg=(1.0, 0.0, 0.0, 1.0),
         text_pos=(0.0, 0.0),
         text_font=PiratesGlobals.getPirateFont(),
         text_shadow=(0.0, 0.0, 0.0, 1.0),
         relief=None,
         scale=(0.1, 0.1, 0.1),
         pos=(0.0, 0.0, 0.1),
         parent=self)
     self.boardDestroyedLabel.setBin('fixed', 38)
     self.boardDestroyedLabel.stash()
     return
 def _initVisuals(self):
     RepairMincroGame._initVisuals(self)
     self.setBin('fixed', 36)
     self.model = loader.loadModel('models/gui/pir_m_gui_srp_sawing_main')
     sawModel = self.model.find('**/saw')
     sawModel.setR(193)
     sawModel.setPos(0.90000000000000002, 0.0, -0.16500000000000001)
     sawModel.setBin('gui-popup', 0)
     self.sawButton = RepairSaw(parent = self, clickDownCommand = self.sawAttachedToMouse, clickUpCommand = self.sawRemovedFromMouse, geom = sawModel, text_pos = (0.20000000000000001, -0.29999999999999999), text_fg = (1, 0, 0, 1), scale = (0.29999999999999999, 0.29999999999999999, 0.29999999999999999), relief = None, pressEffect = 0, frameSize = (-0.050000000000000003, 1.05, -0.29999999999999999, 0.050000000000000003), rolloverSound = None, clickSound = None)
     self.sawingLine = RepairSawingLine(self, self.config.sawlineLineThickness, self.config.sawlineColor, self.config.sawlineLinespawnDist)
     self.progressDescriptionLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Sawing_Description, text_fg = (1.0, 1.0, 1.0, 1.0), text_pos = (0.0, 0.0), text_shadow = (0.0, 0.0, 0.0, 1.0), text_font = PiratesGlobals.getPirateFont(), text_align = TextNode.ARight, relief = None, scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.20000000000000001, 0.0, 0.5), parent = self)
     self.progressLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Sawing_Thresholds[3], text_fg = (1.0, 1.0, 1.0, 1.0), text_pos = (0.0, 0.0), text_shadow = (0.0, 0.0, 0.0, 1.0), text_font = PiratesGlobals.getPirateFont(), text_align = TextNode.ALeft, relief = None, scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.17999999999999999, 0.0, 0.5), parent = self)
     self.boardDestroyedLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Sawing_Board_Destroyed, text_fg = (1.0, 0.0, 0.0, 1.0), text_pos = (0.0, 0.0), text_font = PiratesGlobals.getPirateFont(), text_shadow = (0.0, 0.0, 0.0, 1.0), relief = None, scale = (0.10000000000000001, 0.10000000000000001, 0.10000000000000001), pos = (0.0, 0.0, 0.10000000000000001), parent = self)
     self.boardDestroyedLabel.setBin('fixed', 38)
     self.boardDestroyedLabel.stash()
Exemple #3
0
class RepairSawingGame(RepairMincroGame):
    sawSounds = None
    boardComplet = None
    boardDestroyed = None

    def __init__(self, repairGame):
        self.config = RepairGlobals.Sawing
        notify = DirectNotifyGlobal.directNotify.newCategory(
            'RepairSawingGame')
        RepairMincroGame.__init__(self, repairGame, 'sawing',
                                  PLocalizer.Minigame_Repair_Sawing_Start)

    def _initVars(self):
        RepairMincroGame._initVars(self)
        self.boardsPool = {}
        self.currentBoard = None
        self.currentBoardIndex = 0
        self.onDeckBoard = None
        self.onDeckBoardIndex = 0
        self.totalScore = 0.0
        self.hitZone1Penalty = False
        self.hitZone2Penalty = False
        self.hitBoardPenalty = False
        self.moveDiffForSound = 0.0
        self.startPositions = (Point3(0.0, 0.0, 0.0), )
        self.currentStartIndex = 0
        self.lastMousePos = None
        self.board_left = None
        self.board_right = None
        self.cut = None
        self.zone1_right = None
        self.zone1_left = None
        self.zone2_right = None
        self.zone2_left = None
        self.piece1 = None
        self.piece2 = None
        self.lastHitIndex = -1
        self.sawWaypoints = []

    def _initAudio(self):
        RepairMincroGame._initAudio(self)
        if not self.sawSounds:
            RepairSawingGame.sawSounds = (
                loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT01),
                loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT02),
                loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT03),
                loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT04))
            RepairSawingGame.boardComplete = loadSfx(
                SoundGlobals.SFX_MINIGAME_REPAIR_SAW_COMPLETE)
            RepairSawingGame.boardDestroyed = loadSfx(
                SoundGlobals.SFX_MINIGAME_REPAIR_SAW_FAIL)

    def _initVisuals(self):
        RepairMincroGame._initVisuals(self)
        self.setBin('fixed', 36)
        self.model = loader.loadModel('models/gui/pir_m_gui_srp_sawing_main')
        sawModel = self.model.find('**/saw')
        sawModel.setR(193)
        sawModel.setPos(0.90000000000000002, 0.0, -0.16500000000000001)
        sawModel.setBin('gui-popup', 0)
        self.sawButton = RepairSaw(
            parent=self,
            clickDownCommand=self.sawAttachedToMouse,
            clickUpCommand=self.sawRemovedFromMouse,
            geom=sawModel,
            text_pos=(0.20000000000000001, -0.29999999999999999),
            text_fg=(1, 0, 0, 1),
            scale=(0.29999999999999999, 0.29999999999999999,
                   0.29999999999999999),
            relief=None,
            pressEffect=0,
            frameSize=(-0.050000000000000003, 1.05, -0.29999999999999999,
                       0.050000000000000003),
            rolloverSound=None,
            clickSound=None)
        self.sawingLine = RepairSawingLine(self,
                                           self.config.sawlineLineThickness,
                                           self.config.sawlineColor,
                                           self.config.sawlineLinespawnDist)
        self.progressDescriptionLabel = DirectLabel(
            text=PLocalizer.Minigame_Repair_Sawing_Description,
            text_fg=(1.0, 1.0, 1.0, 1.0),
            text_pos=(0.0, 0.0),
            text_shadow=(0.0, 0.0, 0.0, 1.0),
            text_font=PiratesGlobals.getPirateFont(),
            text_align=TextNode.ARight,
            relief=None,
            scale=(0.080000000000000002, 0.080000000000000002,
                   0.080000000000000002),
            pos=(-0.20000000000000001, 0.0, 0.5),
            parent=self)
        self.progressLabel = DirectLabel(
            text=PLocalizer.Minigame_Repair_Sawing_Thresholds[3],
            text_fg=(1.0, 1.0, 1.0, 1.0),
            text_pos=(0.0, 0.0),
            text_shadow=(0.0, 0.0, 0.0, 1.0),
            text_font=PiratesGlobals.getPirateFont(),
            text_align=TextNode.ALeft,
            relief=None,
            scale=(0.080000000000000002, 0.080000000000000002,
                   0.080000000000000002),
            pos=(-0.17999999999999999, 0.0, 0.5),
            parent=self)
        self.boardDestroyedLabel = DirectLabel(
            text=PLocalizer.Minigame_Repair_Sawing_Board_Destroyed,
            text_fg=(1.0, 0.0, 0.0, 1.0),
            text_pos=(0.0, 0.0),
            text_font=PiratesGlobals.getPirateFont(),
            text_shadow=(0.0, 0.0, 0.0, 1.0),
            relief=None,
            scale=(0.10000000000000001, 0.10000000000000001,
                   0.10000000000000001),
            pos=(0.0, 0.0, 0.10000000000000001),
            parent=self)
        self.boardDestroyedLabel.setBin('fixed', 38)
        self.boardDestroyedLabel.stash()

    def _initIntervals(self):
        RepairMincroGame._initIntervals(self)
        self.newBoardSequence = Sequence(
            name='RepairSawingGame.newBoardSequence')
        self.splitBoardSequence = Sequence(
            name='RepairSawGame.splitBoardSequence')
        self.dropBoardSequence = Sequence(
            name='RepairSawGame.dropBoardSequence')

    def getNewBoard(self, boardIndex):
        board = self.model.find('**/wood%i' % boardIndex).copyTo(
            NodePath('board%i' % len(self.boardsPool)))
        board.reparentTo(self)
        piece1 = board.find('**/piece_1')
        piece1.setPythonTag('piece_1', self.piece1)
        piece1.setY(self.config.boardYDist)
        piece2 = board.find('**/piece_2')
        piece2.setPythonTag('piece_2', self.piece2)
        piece2.setY(self.config.boardYDist)
        pieceCut = board.find('**/piece_cut')
        pieceCut.setPythonTag('cut', self.cut)
        pieceCut.setColor(self.config.cutColor)
        pieceCut.setY(self.config.boardYDist)
        board_left = piece1.find('**/board')
        board_left.setPythonTag('left', self.board_left)
        board_right = piece2.find('**/board')
        board_right.setPythonTag('right', self.board_right)
        zone1_right = piece2.find('**/zone_1')
        zone1_right.setPythonTag('zone1_right', self.zone1_right)
        zone1_right.setColor(self.config.zone1Color)
        zone1_left = piece1.find('**/zone_1')
        zone1_left.setPythonTag('zone1_left', self.zone1_left)
        zone1_left.setColor(self.config.zone1Color)
        zone2_right = piece2.find('**/zone_2')
        zone2_right.setPythonTag('zone2_right', self.zone2_right)
        zone2_right.setColor(self.config.zone2Color)
        zone2_left = piece1.find('**/zone_2')
        zone2_left.setPythonTag('zone2_left', self.zone2_left)
        zone2_left.setColor(self.config.zone2Color)
        board.stash()
        return board

    def reset(self):
        for key in self.boardsPool.keys():
            board = self.boardsPool[key]
            board.removeNode()

        self.boardsPool.clear()
        if self.currentBoard:
            self.currentBoard.removeNode()
            self.currentBoard = None

        if self.onDeckBoard:
            self.onDeckBoard.removeNode()
            self.onDeckBoard = None

        for boardIndex in self.currentDifficultySet:
            boardIndex -= 1
            if 'copy1_%s' % boardIndex not in self.boardsPool:
                board = self.getNewBoard(boardIndex)
                self.boardsPool['copy1_%s' % boardIndex] = board

            if 'copy2_%s' % boardIndex not in self.boardsPool:
                board = self.getNewBoard(boardIndex)
                self.boardsPool['copy2_%s' % boardIndex] = board
                continue

        self.currentBoardIndex = 0
        self.currentBoard = None
        self.moveNewBoardOnDeck()
        self.onDeckBoard.unstash()
        self.totalScore = 0
        self.startPositions = (Point3(0.0, 0.0, 0.0), )
        self.sawButton.stash()
        self.sawButton.reparentTo(self)
        self.lastHitIndex = -1
        self.moveDiffForSound = 0.0
        RepairMincroGame.reset(self)
        self.repairGame.gui.setTutorial(self.name)
        self.repairGame.gui.setTitle(self.name)

    def destroy(self):
        RepairMincroGame.destroy(self)
        taskMgr.remove('SawingGame.updateSawTask')
        self.sawButton.destroy()
        self.sawButton.removeNode()
        del self.sawButton
        if self.currentBoard:
            self.currentBoard.removeNode()
            self.currentBoard = None

        if self.onDeckBoard:
            self.onDeckBoard.removeNode()
            self.onDeckBoard = None

        self.sawingLine = None
        self.progressDescriptionLabel.destroy()
        self.progressDescriptionLabel = None
        self.progressLabel.destroy()
        self.progressLabel = None
        self.boardDestroyedLabel.destroy()
        self.boardDestroyedLabel = None
        for key in self.boardsPool.keys():
            board = self.boardsPool[key]
            if not board.isEmpty():
                board.removeNode()
                continue

        self.boardsPool.clear()
        self.newBoardSequence.clearToInitial()
        del self.newBoardSequence
        self.splitBoardSequence.clearToInitial()
        del self.splitBoardSequence
        self.dropBoardSequence.clearToInitial()
        del self.dropBoardSequence

    def setDifficulty(self, difficulty):
        RepairMincroGame.setDifficulty(self, difficulty)
        percent = difficulty / self.repairGame.difficultyMax
        difIndex = int(
            math.floor(percent * (len(self.config.difficultySets) - 1)))
        self.currentDifficultySet = self.config.difficultySets[difIndex]

    def splitBoard(self):
        self.sawingLine.reset()
        board = self.currentBoard
        boardIndex = self.currentBoardIndex
        if self.hitZone2Penalty:
            boardSplitAnim = Parallel(
                LerpPosInterval(self.board_left,
                                duration=self.config.splitBoardAnimTime,
                                pos=Point3(-2.0, 0.0, 0.0)),
                LerpPosInterval(self.board_right,
                                duration=self.config.splitBoardAnimTime,
                                pos=Point3(2.0, 0.0, 0.0)),
                LerpFunc(self.zone2_left.setSa,
                         duration=self.config.splitBoardAnimTime / 2.0,
                         fromData=1.0,
                         toData=0.0),
                LerpFunc(self.zone2_right.setSa,
                         duration=self.config.splitBoardAnimTime / 2.0,
                         fromData=1.0,
                         toData=0.0),
                LerpFunc(self.zone1_left.setSa,
                         duration=self.config.splitBoardAnimTime / 2.0,
                         fromData=1.0,
                         toData=0.0),
                LerpFunc(self.zone1_right.setSa,
                         duration=self.config.splitBoardAnimTime / 2.0,
                         fromData=1.0,
                         toData=0.0),
                LerpFunc(self.cut.setSa,
                         duration=self.config.splitBoardAnimTime / 2.0,
                         fromData=1.0,
                         toData=0.0))
        elif self.hitZone1Penalty:
            boardSplitAnim = Parallel(
                LerpPosInterval(self.board_left,
                                duration=self.config.splitBoardAnimTime,
                                pos=Point3(-2.0, 0.0, 0.0)),
                LerpPosInterval(self.board_right,
                                duration=self.config.splitBoardAnimTime,
                                pos=Point3(2.0, 0.0, 0.0)),
                LerpPosInterval(self.zone2_left,
                                duration=self.config.splitBoardAnimTime,
                                pos=Point3(-2.0, 0.0, 0.0)),
                LerpPosInterval(self.zone2_right,
                                duration=self.config.splitBoardAnimTime,
                                pos=Point3(2.0, 0.0, 0.0)),
                LerpFunc(self.zone1_left.setSa,
                         duration=self.config.splitBoardAnimTime / 2.0,
                         fromData=1.0,
                         toData=0.0),
                LerpFunc(self.zone1_right.setSa,
                         duration=self.config.splitBoardAnimTime / 2.0,
                         fromData=1.0,
                         toData=0.0),
                LerpFunc(self.cut.setSa,
                         duration=self.config.splitBoardAnimTime / 2.0,
                         fromData=1.0,
                         toData=0.0))
        else:
            boardSplitAnim = Parallel(
                LerpPosInterval(self.piece1,
                                duration=self.config.splitBoardAnimTime,
                                pos=Point3(-2.0, self.config.boardYDist, 0.0)),
                LerpPosInterval(self.piece2,
                                duration=self.config.splitBoardAnimTime,
                                pos=Point3(2.0, self.config.boardYDist, 0.0)),
                LerpFunc(self.cut.setSa,
                         duration=self.config.splitBoardAnimTime / 2.0,
                         fromData=1.0,
                         toData=0.0))
        self.splitBoardSequence = Sequence(
            Func(self.updateScore),
            Func(self.boardComplete.play),
            boardSplitAnim,
            Func(board.stash),
            Func(self.piece1.setPos, self.piece1.getPos()),
            Func(self.piece2.setPos, self.piece2.getPos()),
            Func(self.board_right.setPos, self.board_right.getPos()),
            Func(self.board_left.setPos, self.board_left.getPos()),
            Func(self.zone2_right.setPos, self.zone2_right.getPos()),
            Func(self.zone2_left.setPos, self.zone2_left.getPos()),
            Func(self.zone1_right.setPos, self.zone1_right.getPos()),
            Func(self.zone1_left.setPos, self.zone1_left.getPos()),
            Func(self.cut.setSa, 1.0),
            Func(self.zone1_right.setSa, 1.0),
            Func(self.zone1_left.setSa, 1.0),
            Func(self.zone2_right.setSa, 1.0),
            Func(self.zone2_left.setSa, 1.0),
            Func(self.board_right.setSa, 1.0),
            Func(self.board_left.setSa, 1.0),
            Func(self.loadNewBoard),
            Func(self.addBoardBackToPool, board, boardIndex),
            name='RepairSawGame.splitBoardSequence')
        self.splitBoardSequence.start()

    def dropBoard(self):
        board = self.currentBoard
        boardIndex = self.currentBoardIndex
        self.dropBoardSequence = Sequence(
            Parallel(
                Sequence(Func(self.boardDestroyedLabel.unstash), Wait(1.5),
                         Func(self.boardDestroyedLabel.stash)),
                Sequence(
                    Wait(0.5), Func(self.boardDestroyed.play),
                    Func(self.sawingLine.reset),
                    LerpPosInterval(board,
                                    duration=self.config.splitBoardAnimTime,
                                    pos=Point3(0.0, 0.0, -2.0)),
                    Func(board.stash), Wait(0.5), Func(self.loadNewBoard),
                    Func(self.addBoardBackToPool, board, boardIndex))),
            name='RepairSawGame.dropBoardSequence')
        self.dropBoardSequence.start()

    def addBoardBackToPool(self, board, boardIndex):
        if 'copy1_%s' % boardIndex not in self.boardsPool:
            self.boardsPool['copy1_%s' % boardIndex] = board
        elif 'copy2_%s' % boardIndex not in self.boardsPool:
            self.boardsPool['copy2_%s' % boardIndex] = board
        else:
            self.notify.error(
                'Two copies of board type %i already in the boardsPool!' %
                boardIndex)

    def updateScoreText(self):
        self.progressLabel.unstash()
        self.progressDescriptionLabel.unstash()
        if self.hitBoardPenalty:
            self.progressLabel[
                'text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[0]
            self.progressLabel['text_fg'] = Vec4(1.0, 0.0, 0.0, 1.0)
            self.progressLabel.setText()
        elif self.hitZone2Penalty:
            self.progressLabel[
                'text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[1]
            self.progressLabel['text_fg'] = Vec4(1.0, 0.5, 0.0, 1.0)
            self.progressLabel.setText()
        elif self.hitZone1Penalty:
            self.progressLabel[
                'text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[2]
            self.progressLabel['text_fg'] = Vec4(1.0, 1.0, 0.0, 1.0)
            self.progressLabel.setText()
        else:
            self.progressLabel[
                'text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[3]
            self.progressLabel['text_fg'] = Vec4(0.0, 1.0, 0.0, 1.0)
            self.progressLabel.setText()

    def moveNewBoardOnDeck(self):
        boardIndex = random.randint(0, len(self.currentDifficultySet) - 1)
        boardType = self.currentDifficultySet[boardIndex]
        boardType -= 1
        if 'copy1_%s' % boardType in self.boardsPool:
            self.onDeckBoard = self.boardsPool['copy1_%s' % boardType]
            del self.boardsPool['copy1_%s' % boardType]
        elif 'copy2_%s' % boardType in self.boardsPool:
            self.onDeckBoard = self.boardsPool['copy2_%s' % boardType]
            del self.boardsPool['copy2_%s' % boardType]
        else:
            self.notify.error('No copies of board type %i in the boardsPool!' %
                              boardType)
        self.onDeckBoardIndex = boardType
        self.onDeckBoard.setScale(0.25)
        self.onDeckBoard.setPos(0.5, -2.0, 0.56000000000000005)
        self.onDeckBoard.unstash()

    def loadNewBoard(self):
        self.progressLabel.stash()
        self.progressDescriptionLabel.stash()
        if self.totalScore >= self.config.totalPoints:
            if self.onDeckBoard:
                self.onDeckBoard.stash()

            self.progressDescriptionLabel.stash()
            taskMgr.remove('SawingGame.updateSawTask')
            self.request('Outro')
            return None

        self.currentBoard = self.onDeckBoard
        self.currentBoardIndex = self.onDeckBoardIndex
        self.piece1 = self.currentBoard.find('**/piece_1')
        self.piece1.setTransparency(1)
        self.piece2 = self.currentBoard.find('**/piece_2')
        self.piece2.setTransparency(1)
        self.cut = self.currentBoard.find('**/piece_cut')
        self.cut.setColor(self.config.cutColor)
        self.cut.setTransparency(1)
        self.board_left = self.piece1.find('**/board')
        self.board_left.setTransparency(1)
        self.zone1_left = self.piece1.find('**/zone_1')
        self.zone1_left.setTransparency(1)
        self.zone2_left = self.piece1.find('**/zone_2')
        self.zone2_left.setTransparency(1)
        self.board_right = self.piece2.find('**/board')
        self.board_right.setTransparency(1)
        self.zone1_right = self.piece2.find('**/zone_1')
        self.zone1_right.setTransparency(1)
        self.zone2_right = self.piece2.find('**/zone_2')
        self.zone2_right.setTransparency(1)
        self.board_left.setCollideMask(SAW_COLLIDE_MASK)
        self.board_right.setCollideMask(SAW_COLLIDE_MASK)
        self.cut.setCollideMask(SAW_COLLIDE_MASK)
        self.zone1_right.setCollideMask(SAW_COLLIDE_MASK)
        self.zone1_left.setCollideMask(SAW_COLLIDE_MASK)
        self.zone2_right.setCollideMask(SAW_COLLIDE_MASK)
        self.zone2_left.setCollideMask(SAW_COLLIDE_MASK)
        self.startPositions = (
            self.currentBoard.find('**/locator_start_0').getPos() +
            Point3(*self.config.activeBoardPosition),
            self.currentBoard.find('**/locator_start_1').getPos() +
            Point3(*self.config.activeBoardPosition))
        self.currentStartIndex = 0
        for waypoint in self.sawWaypoints:
            waypoint.removeNode()

        self.sawWaypoints = []
        locator = self.currentBoard.find('**/locator_0')
        index = 0
        while not locator.isEmpty():
            self.sawWaypoints.append(
                SawWaypoint(index, self.currentBoard, locator.getPos()))
            locator = self.currentBoard.find('**/locator_%i' % (index + 1))
            index += 1
        self.sawButton.deactivate()
        self.sawButton.setPos(self.startPositions[self.currentStartIndex])
        self.hitBoardPenalty = False
        self.hitZone1Penalty = False
        self.hitZone2Penalty = False
        self.lastMousePos = None
        self.moveDiffForSound = self.config.playSawingSoundDelta + 0.10000000000000001
        self.newBoardSequence = Sequence(
            Parallel(
                self.currentBoard.posInterval(
                    self.config.newBoardAnimTime,
                    Point3(*self.config.activeBoardPosition)),
                self.currentBoard.scaleInterval(self.config.newBoardAnimTime,
                                                1.0)),
            name='RepairSawingGame.newBoardSequence')
        if self.state in ['Game']:
            self.newBoardSequence.append(Func(self.sawButton.activate))

        self.newBoardSequence.append(Wait(0.5))
        self.newBoardSequence.append(Func(self.moveNewBoardOnDeck))
        self.newBoardSequence.start()

    def updateSawTask(self, task):
        if base.mouseWatcherNode.hasMouse():
            mpos = base.mouseWatcherNode.getMouse()
            relative = Point3(mpos.getX(), 0.0, mpos.getY())
            relative = self.getRelativePoint(render2d, relative)
            moveDiff = 0.0
            if self.lastMousePos != None:
                moveDiff = (relative - self.lastMousePos).length()

            pickedObjects = self.repairGame.mousePicker.getCollisions(
                self.currentBoard, useIntoNodePaths=True)
            self.updateWaypoints()
            if len(pickedObjects) > 0:
                self.moveDiffForSound += moveDiff
                if self.moveDiffForSound > self.config.playSawingSoundDelta:
                    sawSoundPlaying = False
                    for sound in self.sawSounds:
                        if sound.status() == 2:
                            sawSoundPlaying = True
                            break
                            continue

                    if sawSoundPlaying == False:
                        sound = random.choice(self.sawSounds)
                        sound.play()
                        self.moveDiffForSound = 0.0

                if self.board_right in pickedObjects or self.board_left in pickedObjects:
                    for waypoint in self.sawWaypoints:
                        waypoint.hit = False

                    self.hitBoardPenalty = True
                    self.dropBoard()
                    self.sawButton.deactivate()
                elif self.cut in pickedObjects:
                    self.updateWaypoints()
                elif self.zone1_right in pickedObjects or self.zone1_left in pickedObjects:
                    self.updateWaypoints()
                    if self.hitZone1Penalty == False:
                        self.hitZone1Penalty = True

                elif self.zone2_right in pickedObjects or self.zone2_left in pickedObjects:
                    self.updateWaypoints()
                    if self.hitZone2Penalty == False:
                        self.hitZone2Penalty = True

                self.updateScoreText()
            else:
                boardComplete = True
                for waypoint in self.sawWaypoints:
                    if not waypoint.hit:
                        boardComplete = False
                        break
                        continue

                if boardComplete:
                    self.splitBoard()
                    self.sawButton.deactivate()

            self.lastMousePos = self.sawButton.getPos()

        return Task.cont

    def updateScore(self):
        if not self.hitBoardPenalty:
            currBoardScore = self.config.pointsPerBoard
            if not self.hitZone1Penalty:
                pass
            currBoardScore -= self.config.pointsLostForZone1 * self.hitZone2Penalty
            currBoardScore -= self.config.pointsLostForZone2 * self.hitZone2Penalty
            rating = 4 - 1 * self.hitZone2Penalty - 3 * self.hitZone1Penalty
            self.totalScore += currBoardScore
            self.totalScore = min(self.totalScore, self.config.totalPoints)
            percent = int((self.totalScore / self.config.totalPoints) * 100.0)
            self.repairGame.d_reportMincroGameProgress(percent, rating)

    def resetWaypoints(self):
        for waypoint in self.sawWaypoints:
            waypoint.hit = False

    def updateWaypoints(self):
        waypointList = self.getHitWaypoints()
        for waypointIndex in waypointList:
            self.lastHitIndex = waypointIndex
            self.sawWaypoints[waypointIndex].hit = True
            if waypointIndex == 0 and not (self.sawWaypoints[-1].hit):
                self.currentStartIndex = 0
                continue
            if waypointIndex == len(
                    self.sawWaypoints) - 1 and not (self.sawWaypoints[0].hit):
                self.currentStartIndex = 1
                continue

    def getHitWaypoints(self):
        waypointsHit = []
        testDelta = self.config.testWaypointDelta
        for i in range(len(self.sawWaypoints)):
            waypointPos = self.sawWaypoints[i].getPos(self)
            closestDistance = 9999
            if self.lastMousePos != None:
                currMousePos = self.sawButton.getPos()
                lastMousePos = self.lastMousePos
                totalLength = (currMousePos - lastMousePos).length()
                testLength = testDelta
                while testLength < totalLength:
                    testPos = (currMousePos - lastMousePos) * (
                        testLength / totalLength) + lastMousePos
                    self.updateSawLine(testPos)
                    testDistance = (testPos - waypointPos).length()
                    closestDistance = min(testDistance, closestDistance)
                    testLength += testDelta

            self.updateSawLine(self.sawButton.getPos())
            testDistance = (self.sawButton.getPos() - waypointPos).length()
            closestDistance = min(testDistance, closestDistance)
            if closestDistance < self.config.waypointRange[
                    self.currentBoardIndex]:
                waypointsHit.append(i)
                continue

        return waypointsHit

    def updateSawLine(self, pos):
        if pos.getX() < -0.63300000000000001 or pos.getX(
        ) > 0.63300000000000001:
            self.sawingLine.reset()
            return None

        if pos.getZ() < -0.183 or pos.getZ() > 0.375:
            self.sawingLine.reset()
            return None

        self.sawingLine.update(pos)

    def getClosestPosition(self, positions):
        closestIndex = -1
        if base.mouseWatcherNode.hasMouse():
            mpos = base.mouseWatcherNode.getMouse()
            relative = Point3(mpos.getX(), 0.0, mpos.getY())
            relative = self.getRelativePoint(base.a2dBackground, relative)
            bestDistance = 99999.0
            for i in range(len(positions)):
                dX = relative.getX() - positions[i].getX()
                dZ = relative.getZ() - positions[i].getZ()
                newDistance = dX * dX + dZ * dZ
                if newDistance < bestDistance:
                    bestDistance = newDistance
                    closestIndex = i
                    continue

        return closestIndex

    def sawAttachedToMouse(self):
        self.lastHitIndex = -1
        if not taskMgr.hasTaskNamed('SawingGame.updateSawTask'):
            taskMgr.add(self.updateSawTask,
                        'SawingGame.updateSawTask',
                        priority=2)

    def sawRemovedFromMouse(self):
        if not self.sawButton.isStashed():
            self.sawButton.setPos(self.startPositions[self.currentStartIndex])
            self.lastHitIndex = -1
            self.resetWaypoints()
            self.lastMousePos = None
            self.progressLabel.stash()
            self.progressDescriptionLabel.stash()
            self.sawingLine.reset()
            self.hitBoardPenalty = False
            self.hitZone1Penalty = False
            self.hitZone2Penalty = False

        taskMgr.remove('SawingGame.updateSawTask')

    def enterIntro(self):
        RepairMincroGame.enterIntro(self)
        self.loadNewBoard()

    def enterGame(self):
        RepairMincroGame.enterGame(self)
        self.repairGame.mousePicker.setCollisionMask(SAW_COLLIDE_MASK)
        self.sawButton.activate()

    def exitGame(self):
        RepairMincroGame.exitGame(self)
        self.sawButton.deactivate()
        self.repairGame.mousePicker.clearCollisionMask()
        taskMgr.remove('SawingGame.updateSawTask')
        self.splitBoardSequence.clearToInitial()
        self.dropBoardSequence.clearToInitial()
        localAvatar.guiMgr._showCursor()

    def enterOutro(self):
        RepairMincroGame.enterOutro(self)
        self.repairGame.d_reportMincroGameScore(150)
class RepairSawingGame(RepairMincroGame):
    sawSounds = None
    boardComplet = None
    boardDestroyed = None
    
    def __init__(self, repairGame):
        self.config = RepairGlobals.Sawing
        notify = DirectNotifyGlobal.directNotify.newCategory('RepairSawingGame')
        RepairMincroGame.__init__(self, repairGame, 'sawing', PLocalizer.Minigame_Repair_Sawing_Start)

    
    def _initVars(self):
        RepairMincroGame._initVars(self)
        self.boardsPool = { }
        self.currentBoard = None
        self.currentBoardIndex = 0
        self.onDeckBoard = None
        self.onDeckBoardIndex = 0
        self.totalScore = 0.0
        self.hitZone1Penalty = False
        self.hitZone2Penalty = False
        self.hitBoardPenalty = False
        self.moveDiffForSound = 0.0
        self.startPositions = (Point3(0.0, 0.0, 0.0),)
        self.currentStartIndex = 0
        self.lastMousePos = None
        self.board_left = None
        self.board_right = None
        self.cut = None
        self.zone1_right = None
        self.zone1_left = None
        self.zone2_right = None
        self.zone2_left = None
        self.piece1 = None
        self.piece2 = None
        self.lastHitIndex = -1
        self.sawWaypoints = []

    
    def _initAudio(self):
        RepairMincroGame._initAudio(self)
        if not self.sawSounds:
            RepairSawingGame.sawSounds = (loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT01), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT02), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT03), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT04))
            RepairSawingGame.boardComplete = loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_COMPLETE)
            RepairSawingGame.boardDestroyed = loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_FAIL)
        

    
    def _initVisuals(self):
        RepairMincroGame._initVisuals(self)
        self.setBin('fixed', 36)
        self.model = loader.loadModel('models/gui/pir_m_gui_srp_sawing_main')
        sawModel = self.model.find('**/saw')
        sawModel.setR(193)
        sawModel.setPos(0.90000000000000002, 0.0, -0.16500000000000001)
        sawModel.setBin('gui-popup', 0)
        self.sawButton = RepairSaw(parent = self, clickDownCommand = self.sawAttachedToMouse, clickUpCommand = self.sawRemovedFromMouse, geom = sawModel, text_pos = (0.20000000000000001, -0.29999999999999999), text_fg = (1, 0, 0, 1), scale = (0.29999999999999999, 0.29999999999999999, 0.29999999999999999), relief = None, pressEffect = 0, frameSize = (-0.050000000000000003, 1.05, -0.29999999999999999, 0.050000000000000003), rolloverSound = None, clickSound = None)
        self.sawingLine = RepairSawingLine(self, self.config.sawlineLineThickness, self.config.sawlineColor, self.config.sawlineLinespawnDist)
        self.progressDescriptionLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Sawing_Description, text_fg = (1.0, 1.0, 1.0, 1.0), text_pos = (0.0, 0.0), text_shadow = (0.0, 0.0, 0.0, 1.0), text_font = PiratesGlobals.getPirateFont(), text_align = TextNode.ARight, relief = None, scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.20000000000000001, 0.0, 0.5), parent = self)
        self.progressLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Sawing_Thresholds[3], text_fg = (1.0, 1.0, 1.0, 1.0), text_pos = (0.0, 0.0), text_shadow = (0.0, 0.0, 0.0, 1.0), text_font = PiratesGlobals.getPirateFont(), text_align = TextNode.ALeft, relief = None, scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.17999999999999999, 0.0, 0.5), parent = self)
        self.boardDestroyedLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Sawing_Board_Destroyed, text_fg = (1.0, 0.0, 0.0, 1.0), text_pos = (0.0, 0.0), text_font = PiratesGlobals.getPirateFont(), text_shadow = (0.0, 0.0, 0.0, 1.0), relief = None, scale = (0.10000000000000001, 0.10000000000000001, 0.10000000000000001), pos = (0.0, 0.0, 0.10000000000000001), parent = self)
        self.boardDestroyedLabel.setBin('fixed', 38)
        self.boardDestroyedLabel.stash()

    
    def _initIntervals(self):
        RepairMincroGame._initIntervals(self)
        self.newBoardSequence = Sequence(name = 'RepairSawingGame.newBoardSequence')
        self.splitBoardSequence = Sequence(name = 'RepairSawGame.splitBoardSequence')
        self.dropBoardSequence = Sequence(name = 'RepairSawGame.dropBoardSequence')

    
    def getNewBoard(self, boardIndex):
        board = self.model.find('**/wood%i' % boardIndex).copyTo(NodePath('board%i' % len(self.boardsPool)))
        board.reparentTo(self)
        piece1 = board.find('**/piece_1')
        piece1.setPythonTag('piece_1', self.piece1)
        piece1.setY(self.config.boardYDist)
        piece2 = board.find('**/piece_2')
        piece2.setPythonTag('piece_2', self.piece2)
        piece2.setY(self.config.boardYDist)
        pieceCut = board.find('**/piece_cut')
        pieceCut.setPythonTag('cut', self.cut)
        pieceCut.setColor(self.config.cutColor)
        pieceCut.setY(self.config.boardYDist)
        board_left = piece1.find('**/board')
        board_left.setPythonTag('left', self.board_left)
        board_right = piece2.find('**/board')
        board_right.setPythonTag('right', self.board_right)
        zone1_right = piece2.find('**/zone_1')
        zone1_right.setPythonTag('zone1_right', self.zone1_right)
        zone1_right.setColor(self.config.zone1Color)
        zone1_left = piece1.find('**/zone_1')
        zone1_left.setPythonTag('zone1_left', self.zone1_left)
        zone1_left.setColor(self.config.zone1Color)
        zone2_right = piece2.find('**/zone_2')
        zone2_right.setPythonTag('zone2_right', self.zone2_right)
        zone2_right.setColor(self.config.zone2Color)
        zone2_left = piece1.find('**/zone_2')
        zone2_left.setPythonTag('zone2_left', self.zone2_left)
        zone2_left.setColor(self.config.zone2Color)
        board.stash()
        return board

    
    def reset(self):
        for key in self.boardsPool.keys():
            board = self.boardsPool[key]
            board.removeNode()
        
        self.boardsPool.clear()
        if self.currentBoard:
            self.currentBoard.removeNode()
            self.currentBoard = None
        
        if self.onDeckBoard:
            self.onDeckBoard.removeNode()
            self.onDeckBoard = None
        
        for boardIndex in self.currentDifficultySet:
            boardIndex -= 1
            if 'copy1_%s' % boardIndex not in self.boardsPool:
                board = self.getNewBoard(boardIndex)
                self.boardsPool['copy1_%s' % boardIndex] = board
            
            if 'copy2_%s' % boardIndex not in self.boardsPool:
                board = self.getNewBoard(boardIndex)
                self.boardsPool['copy2_%s' % boardIndex] = board
                continue
        
        self.currentBoardIndex = 0
        self.currentBoard = None
        self.moveNewBoardOnDeck()
        self.onDeckBoard.unstash()
        self.totalScore = 0
        self.startPositions = (Point3(0.0, 0.0, 0.0),)
        self.sawButton.stash()
        self.sawButton.reparentTo(self)
        self.lastHitIndex = -1
        self.moveDiffForSound = 0.0
        RepairMincroGame.reset(self)
        self.repairGame.gui.setTutorial(self.name)
        self.repairGame.gui.setTitle(self.name)

    
    def destroy(self):
        RepairMincroGame.destroy(self)
        taskMgr.remove('SawingGame.updateSawTask')
        self.sawButton.destroy()
        self.sawButton.removeNode()
        del self.sawButton
        if self.currentBoard:
            self.currentBoard.removeNode()
            self.currentBoard = None
        
        if self.onDeckBoard:
            self.onDeckBoard.removeNode()
            self.onDeckBoard = None
        
        self.sawingLine = None
        self.progressDescriptionLabel.destroy()
        self.progressDescriptionLabel = None
        self.progressLabel.destroy()
        self.progressLabel = None
        self.boardDestroyedLabel.destroy()
        self.boardDestroyedLabel = None
        for key in self.boardsPool.keys():
            board = self.boardsPool[key]
            if not board.isEmpty():
                board.removeNode()
                continue
        
        self.boardsPool.clear()
        self.newBoardSequence.clearToInitial()
        del self.newBoardSequence
        self.splitBoardSequence.clearToInitial()
        del self.splitBoardSequence
        self.dropBoardSequence.clearToInitial()
        del self.dropBoardSequence

    
    def setDifficulty(self, difficulty):
        RepairMincroGame.setDifficulty(self, difficulty)
        percent = difficulty / self.repairGame.difficultyMax
        difIndex = int(math.floor(percent * (len(self.config.difficultySets) - 1)))
        self.currentDifficultySet = self.config.difficultySets[difIndex]

    
    def splitBoard(self):
        self.sawingLine.reset()
        board = self.currentBoard
        boardIndex = self.currentBoardIndex
        if self.hitZone2Penalty:
            boardSplitAnim = Parallel(LerpPosInterval(self.board_left, duration = self.config.splitBoardAnimTime, pos = Point3(-2.0, 0.0, 0.0)), LerpPosInterval(self.board_right, duration = self.config.splitBoardAnimTime, pos = Point3(2.0, 0.0, 0.0)), LerpFunc(self.zone2_left.setSa, duration = self.config.splitBoardAnimTime / 2.0, fromData = 1.0, toData = 0.0), LerpFunc(self.zone2_right.setSa, duration = self.config.splitBoardAnimTime / 2.0, fromData = 1.0, toData = 0.0), LerpFunc(self.zone1_left.setSa, duration = self.config.splitBoardAnimTime / 2.0, fromData = 1.0, toData = 0.0), LerpFunc(self.zone1_right.setSa, duration = self.config.splitBoardAnimTime / 2.0, fromData = 1.0, toData = 0.0), LerpFunc(self.cut.setSa, duration = self.config.splitBoardAnimTime / 2.0, fromData = 1.0, toData = 0.0))
        elif self.hitZone1Penalty:
            boardSplitAnim = Parallel(LerpPosInterval(self.board_left, duration = self.config.splitBoardAnimTime, pos = Point3(-2.0, 0.0, 0.0)), LerpPosInterval(self.board_right, duration = self.config.splitBoardAnimTime, pos = Point3(2.0, 0.0, 0.0)), LerpPosInterval(self.zone2_left, duration = self.config.splitBoardAnimTime, pos = Point3(-2.0, 0.0, 0.0)), LerpPosInterval(self.zone2_right, duration = self.config.splitBoardAnimTime, pos = Point3(2.0, 0.0, 0.0)), LerpFunc(self.zone1_left.setSa, duration = self.config.splitBoardAnimTime / 2.0, fromData = 1.0, toData = 0.0), LerpFunc(self.zone1_right.setSa, duration = self.config.splitBoardAnimTime / 2.0, fromData = 1.0, toData = 0.0), LerpFunc(self.cut.setSa, duration = self.config.splitBoardAnimTime / 2.0, fromData = 1.0, toData = 0.0))
        else:
            boardSplitAnim = Parallel(LerpPosInterval(self.piece1, duration = self.config.splitBoardAnimTime, pos = Point3(-2.0, self.config.boardYDist, 0.0)), LerpPosInterval(self.piece2, duration = self.config.splitBoardAnimTime, pos = Point3(2.0, self.config.boardYDist, 0.0)), LerpFunc(self.cut.setSa, duration = self.config.splitBoardAnimTime / 2.0, fromData = 1.0, toData = 0.0))
        self.splitBoardSequence = Sequence(Func(self.updateScore), Func(self.boardComplete.play), boardSplitAnim, Func(board.stash), Func(self.piece1.setPos, self.piece1.getPos()), Func(self.piece2.setPos, self.piece2.getPos()), Func(self.board_right.setPos, self.board_right.getPos()), Func(self.board_left.setPos, self.board_left.getPos()), Func(self.zone2_right.setPos, self.zone2_right.getPos()), Func(self.zone2_left.setPos, self.zone2_left.getPos()), Func(self.zone1_right.setPos, self.zone1_right.getPos()), Func(self.zone1_left.setPos, self.zone1_left.getPos()), Func(self.cut.setSa, 1.0), Func(self.zone1_right.setSa, 1.0), Func(self.zone1_left.setSa, 1.0), Func(self.zone2_right.setSa, 1.0), Func(self.zone2_left.setSa, 1.0), Func(self.board_right.setSa, 1.0), Func(self.board_left.setSa, 1.0), Func(self.loadNewBoard), Func(self.addBoardBackToPool, board, boardIndex), name = 'RepairSawGame.splitBoardSequence')
        self.splitBoardSequence.start()

    
    def dropBoard(self):
        board = self.currentBoard
        boardIndex = self.currentBoardIndex
        self.dropBoardSequence = Sequence(Parallel(Sequence(Func(self.boardDestroyedLabel.unstash), Wait(1.5), Func(self.boardDestroyedLabel.stash)), Sequence(Wait(0.5), Func(self.boardDestroyed.play), Func(self.sawingLine.reset), LerpPosInterval(board, duration = self.config.splitBoardAnimTime, pos = Point3(0.0, 0.0, -2.0)), Func(board.stash), Wait(0.5), Func(self.loadNewBoard), Func(self.addBoardBackToPool, board, boardIndex))), name = 'RepairSawGame.dropBoardSequence')
        self.dropBoardSequence.start()

    
    def addBoardBackToPool(self, board, boardIndex):
        if 'copy1_%s' % boardIndex not in self.boardsPool:
            self.boardsPool['copy1_%s' % boardIndex] = board
        elif 'copy2_%s' % boardIndex not in self.boardsPool:
            self.boardsPool['copy2_%s' % boardIndex] = board
        else:
            self.notify.error('Two copies of board type %i already in the boardsPool!' % boardIndex)

    
    def updateScoreText(self):
        self.progressLabel.unstash()
        self.progressDescriptionLabel.unstash()
        if self.hitBoardPenalty:
            self.progressLabel['text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[0]
            self.progressLabel['text_fg'] = Vec4(1.0, 0.0, 0.0, 1.0)
            self.progressLabel.setText()
        elif self.hitZone2Penalty:
            self.progressLabel['text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[1]
            self.progressLabel['text_fg'] = Vec4(1.0, 0.5, 0.0, 1.0)
            self.progressLabel.setText()
        elif self.hitZone1Penalty:
            self.progressLabel['text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[2]
            self.progressLabel['text_fg'] = Vec4(1.0, 1.0, 0.0, 1.0)
            self.progressLabel.setText()
        else:
            self.progressLabel['text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[3]
            self.progressLabel['text_fg'] = Vec4(0.0, 1.0, 0.0, 1.0)
            self.progressLabel.setText()

    
    def moveNewBoardOnDeck(self):
        boardIndex = random.randint(0, len(self.currentDifficultySet) - 1)
        boardType = self.currentDifficultySet[boardIndex]
        boardType -= 1
        if 'copy1_%s' % boardType in self.boardsPool:
            self.onDeckBoard = self.boardsPool['copy1_%s' % boardType]
            del self.boardsPool['copy1_%s' % boardType]
        elif 'copy2_%s' % boardType in self.boardsPool:
            self.onDeckBoard = self.boardsPool['copy2_%s' % boardType]
            del self.boardsPool['copy2_%s' % boardType]
        else:
            self.notify.error('No copies of board type %i in the boardsPool!' % boardType)
        self.onDeckBoardIndex = boardType
        self.onDeckBoard.setScale(0.25)
        self.onDeckBoard.setPos(0.5, -2.0, 0.56000000000000005)
        self.onDeckBoard.unstash()

    
    def loadNewBoard(self):
        self.progressLabel.stash()
        self.progressDescriptionLabel.stash()
        if self.totalScore >= self.config.totalPoints:
            if self.onDeckBoard:
                self.onDeckBoard.stash()
            
            self.progressDescriptionLabel.stash()
            taskMgr.remove('SawingGame.updateSawTask')
            self.request('Outro')
            return None
        
        self.currentBoard = self.onDeckBoard
        self.currentBoardIndex = self.onDeckBoardIndex
        self.piece1 = self.currentBoard.find('**/piece_1')
        self.piece1.setTransparency(1)
        self.piece2 = self.currentBoard.find('**/piece_2')
        self.piece2.setTransparency(1)
        self.cut = self.currentBoard.find('**/piece_cut')
        self.cut.setColor(self.config.cutColor)
        self.cut.setTransparency(1)
        self.board_left = self.piece1.find('**/board')
        self.board_left.setTransparency(1)
        self.zone1_left = self.piece1.find('**/zone_1')
        self.zone1_left.setTransparency(1)
        self.zone2_left = self.piece1.find('**/zone_2')
        self.zone2_left.setTransparency(1)
        self.board_right = self.piece2.find('**/board')
        self.board_right.setTransparency(1)
        self.zone1_right = self.piece2.find('**/zone_1')
        self.zone1_right.setTransparency(1)
        self.zone2_right = self.piece2.find('**/zone_2')
        self.zone2_right.setTransparency(1)
        self.board_left.setCollideMask(SAW_COLLIDE_MASK)
        self.board_right.setCollideMask(SAW_COLLIDE_MASK)
        self.cut.setCollideMask(SAW_COLLIDE_MASK)
        self.zone1_right.setCollideMask(SAW_COLLIDE_MASK)
        self.zone1_left.setCollideMask(SAW_COLLIDE_MASK)
        self.zone2_right.setCollideMask(SAW_COLLIDE_MASK)
        self.zone2_left.setCollideMask(SAW_COLLIDE_MASK)
        self.startPositions = (self.currentBoard.find('**/locator_start_0').getPos() + Point3(*self.config.activeBoardPosition), self.currentBoard.find('**/locator_start_1').getPos() + Point3(*self.config.activeBoardPosition))
        self.currentStartIndex = 0
        for waypoint in self.sawWaypoints:
            waypoint.removeNode()
        
        self.sawWaypoints = []
        locator = self.currentBoard.find('**/locator_0')
        index = 0
        while not locator.isEmpty():
            self.sawWaypoints.append(SawWaypoint(index, self.currentBoard, locator.getPos()))
            locator = self.currentBoard.find('**/locator_%i' % (index + 1))
            index += 1
        self.sawButton.deactivate()
        self.sawButton.setPos(self.startPositions[self.currentStartIndex])
        self.hitBoardPenalty = False
        self.hitZone1Penalty = False
        self.hitZone2Penalty = False
        self.lastMousePos = None
        self.moveDiffForSound = self.config.playSawingSoundDelta + 0.10000000000000001
        self.newBoardSequence = Sequence(Parallel(self.currentBoard.posInterval(self.config.newBoardAnimTime, Point3(*self.config.activeBoardPosition)), self.currentBoard.scaleInterval(self.config.newBoardAnimTime, 1.0)), name = 'RepairSawingGame.newBoardSequence')
        if self.state in [
            'Game']:
            self.newBoardSequence.append(Func(self.sawButton.activate))
        
        self.newBoardSequence.append(Wait(0.5))
        self.newBoardSequence.append(Func(self.moveNewBoardOnDeck))
        self.newBoardSequence.start()

    
    def updateSawTask(self, task):
        if base.mouseWatcherNode.hasMouse():
            mpos = base.mouseWatcherNode.getMouse()
            relative = Point3(mpos.getX(), 0.0, mpos.getY())
            relative = self.getRelativePoint(render2d, relative)
            moveDiff = 0.0
            if self.lastMousePos != None:
                moveDiff = (relative - self.lastMousePos).length()
            
            pickedObjects = self.repairGame.mousePicker.getCollisions(self.currentBoard, useIntoNodePaths = True)
            self.updateWaypoints()
            if len(pickedObjects) > 0:
                self.moveDiffForSound += moveDiff
                if self.moveDiffForSound > self.config.playSawingSoundDelta:
                    sawSoundPlaying = False
                    for sound in self.sawSounds:
                        if sound.status() == 2:
                            sawSoundPlaying = True
                            break
                            continue
                    
                    if sawSoundPlaying == False:
                        sound = random.choice(self.sawSounds)
                        sound.play()
                        self.moveDiffForSound = 0.0
                    
                
                if self.board_right in pickedObjects or self.board_left in pickedObjects:
                    for waypoint in self.sawWaypoints:
                        waypoint.hit = False
                    
                    self.hitBoardPenalty = True
                    self.dropBoard()
                    self.sawButton.deactivate()
                elif self.cut in pickedObjects:
                    self.updateWaypoints()
                elif self.zone1_right in pickedObjects or self.zone1_left in pickedObjects:
                    self.updateWaypoints()
                    if self.hitZone1Penalty == False:
                        self.hitZone1Penalty = True
                    
                elif self.zone2_right in pickedObjects or self.zone2_left in pickedObjects:
                    self.updateWaypoints()
                    if self.hitZone2Penalty == False:
                        self.hitZone2Penalty = True
                    
                
                self.updateScoreText()
            else:
                boardComplete = True
                for waypoint in self.sawWaypoints:
                    if not waypoint.hit:
                        boardComplete = False
                        break
                        continue
                
                if boardComplete:
                    self.splitBoard()
                    self.sawButton.deactivate()
                
            self.lastMousePos = self.sawButton.getPos()
        
        return Task.cont

    
    def updateScore(self):
        if not self.hitBoardPenalty:
            currBoardScore = self.config.pointsPerBoard
            if not self.hitZone1Penalty:
                pass
            currBoardScore -= self.config.pointsLostForZone1 * self.hitZone2Penalty
            currBoardScore -= self.config.pointsLostForZone2 * self.hitZone2Penalty
            rating = 4 - 1 * self.hitZone2Penalty - 3 * self.hitZone1Penalty
            self.totalScore += currBoardScore
            self.totalScore = min(self.totalScore, self.config.totalPoints)
            percent = int((self.totalScore / self.config.totalPoints) * 100.0)
            self.repairGame.d_reportMincroGameProgress(percent, rating)
        

    
    def resetWaypoints(self):
        for waypoint in self.sawWaypoints:
            waypoint.hit = False
        

    
    def updateWaypoints(self):
        waypointList = self.getHitWaypoints()
        for waypointIndex in waypointList:
            self.lastHitIndex = waypointIndex
            self.sawWaypoints[waypointIndex].hit = True
            if waypointIndex == 0 and not (self.sawWaypoints[-1].hit):
                self.currentStartIndex = 0
                continue
            if waypointIndex == len(self.sawWaypoints) - 1 and not (self.sawWaypoints[0].hit):
                self.currentStartIndex = 1
                continue
        

    
    def getHitWaypoints(self):
        waypointsHit = []
        testDelta = self.config.testWaypointDelta
        for i in range(len(self.sawWaypoints)):
            waypointPos = self.sawWaypoints[i].getPos(self)
            closestDistance = 9999
            if self.lastMousePos != None:
                currMousePos = self.sawButton.getPos()
                lastMousePos = self.lastMousePos
                totalLength = (currMousePos - lastMousePos).length()
                testLength = testDelta
                while testLength < totalLength:
                    testPos = (currMousePos - lastMousePos) * (testLength / totalLength) + lastMousePos
                    self.updateSawLine(testPos)
                    testDistance = (testPos - waypointPos).length()
                    closestDistance = min(testDistance, closestDistance)
                    testLength += testDelta
            
            self.updateSawLine(self.sawButton.getPos())
            testDistance = (self.sawButton.getPos() - waypointPos).length()
            closestDistance = min(testDistance, closestDistance)
            if closestDistance < self.config.waypointRange[self.currentBoardIndex]:
                waypointsHit.append(i)
                continue
        
        return waypointsHit

    
    def updateSawLine(self, pos):
        if pos.getX() < -0.63300000000000001 or pos.getX() > 0.63300000000000001:
            self.sawingLine.reset()
            return None
        
        if pos.getZ() < -0.183 or pos.getZ() > 0.375:
            self.sawingLine.reset()
            return None
        
        self.sawingLine.update(pos)

    
    def getClosestPosition(self, positions):
        closestIndex = -1
        if base.mouseWatcherNode.hasMouse():
            mpos = base.mouseWatcherNode.getMouse()
            relative = Point3(mpos.getX(), 0.0, mpos.getY())
            relative = self.getRelativePoint(base.a2dBackground, relative)
            bestDistance = 99999.0
            for i in range(len(positions)):
                dX = relative.getX() - positions[i].getX()
                dZ = relative.getZ() - positions[i].getZ()
                newDistance = dX * dX + dZ * dZ
                if newDistance < bestDistance:
                    bestDistance = newDistance
                    closestIndex = i
                    continue
            
        
        return closestIndex

    
    def sawAttachedToMouse(self):
        self.lastHitIndex = -1
        if not taskMgr.hasTaskNamed('SawingGame.updateSawTask'):
            taskMgr.add(self.updateSawTask, 'SawingGame.updateSawTask', priority = 2)
        

    
    def sawRemovedFromMouse(self):
        if not self.sawButton.isStashed():
            self.sawButton.setPos(self.startPositions[self.currentStartIndex])
            self.lastHitIndex = -1
            self.resetWaypoints()
            self.lastMousePos = None
            self.progressLabel.stash()
            self.progressDescriptionLabel.stash()
            self.sawingLine.reset()
            self.hitBoardPenalty = False
            self.hitZone1Penalty = False
            self.hitZone2Penalty = False
        
        taskMgr.remove('SawingGame.updateSawTask')

    
    def enterIntro(self):
        RepairMincroGame.enterIntro(self)
        self.loadNewBoard()

    
    def enterGame(self):
        RepairMincroGame.enterGame(self)
        self.repairGame.mousePicker.setCollisionMask(SAW_COLLIDE_MASK)
        self.sawButton.activate()

    
    def exitGame(self):
        RepairMincroGame.exitGame(self)
        self.sawButton.deactivate()
        self.repairGame.mousePicker.clearCollisionMask()
        taskMgr.remove('SawingGame.updateSawTask')
        self.splitBoardSequence.clearToInitial()
        self.dropBoardSequence.clearToInitial()
        localAvatar.guiMgr._showCursor()

    
    def enterOutro(self):
        RepairMincroGame.enterOutro(self)
        self.repairGame.d_reportMincroGameScore(150)