def tutorialButtonPushed(self): #print "GETTING HERE!!!" self.disableChoiceButtons() #self.tutorial = ChineseTutorial(self.tutorialDone) self.gameMenu = GameMenu(self.tutorialFunction, 1) # 1 == Tutorial Num #self.tutorialFunction(1) self.tutorialButton.destroy() self.tutorialButton = None
def reload(self): global winner, p1_hp_pos, p1_total_life, p1_hp_size, p1_hp_score, p2_hp_pos, \ p2_hp_size, p2_total_life, p2_hp_score, explosion_time, p1_gaurd_size, p2_gaurd_pos, p1_dhp_pos, p1_dhp_size, p2_dhp_pos, p2_dhp_size # GAME DETAILS winner = None # PLAYER 1 DETAILS p1_total_life = resx(550) p1_hp_pos = [0, resy(1000)] p1_hp_size = [p1_total_life, resy(20)] p1_hp_score = 0 p1_gaurd_size = [p1_total_gaurd, resy(20)] p1_dhp_pos = p1_hp_pos.copy() p1_dhp_size = p1_hp_size.copy() # PLAYER 2 DETAILS p2_total_life = resx(550) p2_hp_pos = [resolution[0] - p2_total_life, resy(1000)] p2_hp_size = [p2_total_life, resy(20)] p2_hp_score = 0 p2_gaurd_pos = [resolution[0] - p2_total_gaurd, resy(970)] p2_dhp_pos = p2_hp_pos.copy() p2_dhp_size = p2_hp_size.copy() # OTHER DETAILS explosion_time = 15 # in ms self.status = GameStatus() self.menu = GameMenu(resolution, self.status.game_menu_text) self.smenu = SelectionMenu(resolution, self.status.game_selection_text) # PLAYER INITIALIZATIONS self.player1 = DisplayPlayers(p1_pos_x, p1_pos_y, p1_fire_type) self.player2 = DisplayPlayers(p2_pos_x, p2_pos_y, p2_fire_type) # self.player1.laser_sound.play() self.player1.hp = Quad(p1_hp_pos, p1_hp_size, p1_hp_color, 'p1') self.player2.hp = Quad(p2_hp_pos, p2_hp_size, p2_hp_color, 'p2') self.player1.dhp = Quad(p1_dhp_pos, p1_dhp_size, p1_dhp_color, 'p1') self.player2.dhp = Quad(p2_dhp_pos, p2_dhp_size, p2_dhp_color, 'p2') self.player1.gaurd = Quad(p1_gaurd_pos, p1_gaurd_size, p1_gaurd_color, 'p1') self.player2.gaurd = Quad(p2_gaurd_pos, p2_gaurd_size, p2_gaurd_color, 'p2') self.menu = GameMenu(resolution, self.status.game_menu_text)
def __init__(self, *args, **kwargs): # WINDOW INITIALIZATIONS super().__init__(*args, **kwargs) self.frame_rate = 1 / 60.0 self.fps_display = FPSDisplay(self) self.fps_display.label.font_size = 50 # MAKING THE PRIMITIVE DRAWINGS TRANSPARENT glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) # GAME MENU INITIALIZATIONS self.status = GameStatus() self.menu = GameMenu(resolution, self.status.game_menu_text) self.smenu = SelectionMenu(resolution, self.status.game_selection_text) self.cmenu = ControlsMenu() self.amenu = AboutMenu() self.start_time = time.time() # INITIALLY PLAYING THE MENU BG SONG bg_player.play() # SPACE BG INITIALIZATIONS self.space_list = [] self.space_img = preload_image(space_bg_img) for i in range(2): self.space_list.append( DisplayObjects(0, i * 1080, Sprite(self.space_img))) for space in self.space_list: space.vel_y = -space_scroll_speed # PLAYER INITIALIZATIONS # CREATING PLAYER OBJECTS self.player1 = DisplayPlayers(p1_pos_x, p1_pos_y, p1_fire_type) self.player2 = DisplayPlayers(p2_pos_x, p2_pos_y, p2_fire_type) # PLAYER HP QUAD CREATION self.player1.hp = Quad(p1_hp_pos, p1_hp_size, p1_hp_color, 'p1') self.player2.hp = Quad(p2_hp_pos, p2_hp_size, p2_hp_color, 'p2') # PLAYER GAURD QUAD CREATION self.player1.gaurd = Quad(p1_gaurd_pos, p1_gaurd_size, p1_gaurd_color, 'p1') self.player2.gaurd = Quad(p2_gaurd_pos, p2_gaurd_size, p2_gaurd_color, 'p2') # PLAYER DAMAGE HP QUAD CREATION self.player1.dhp = Quad(p1_dhp_pos, p1_dhp_size, p1_dhp_color, 'p1') self.player2.dhp = Quad(p2_dhp_pos, p2_dhp_size, p2_dhp_color, 'p2')
def __init__(self): # initialize game settings # os.environ['SDL_VIDEO_CENTERED'] = '1' # os.environ['SDL_VIDEO_WINDOW_POS'] = '0,0' pygame.init() # pygame.mixer.init() flags = pygame.DOUBLEBUF | pygame.HWSURFACE # | pygame.FULLSCREEN self.screen = pygame.display.set_mode((WIDTH, HEIGHT), flags) pygame.display.set_caption("My Game") self.clock = pygame.time.Clock() self.load_data() font = pygame.font.match_font("Ubuntu Mono") self.menu = GameMenu(self, "Dash!", ["Play", "Options", "Quit"], font=font, font_size=30, padding=20)
def __init__(self, master): master.title("Checkers Game - Eden Todosi") self.BoardPixelSize = 600 self.NumberOfCellsInAxis = 8 self.master = master self.SizeOfCell = (int)(self.BoardPixelSize / self.NumberOfCellsInAxis) self.UiAdvancedOptions = [] self.lastSoliderClicked = None self.gameMenu = GameMenu(master, "", 0, 0, self.ResetGame) self.BoardUi = Frame(self.master, borderwidth=2, background="#080808") self.BoardUi.place(x=75, y=140) self.DrawBackgroundBoard() # init the board self.BoardState = [[None for i in range(self.NumberOfCellsInAxis)] for j in range(self.NumberOfCellsInAxis)] self.ResetGame()
class DistributedPicnicTable(DistributedNode.DistributedNode): 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') 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.ogg') self.happyDance = base.loadSfx('phase_5/audio/sfx/AA_heal_happydance.ogg') 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'])], '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.16, 0, -0.83) self.clockNode.setScale(0.3) self.clockNode.hide() def announceGenerate(self): DistributedNode.DistributedNode.announceGenerate(self) for i in range(self.numSeats): self.picnicTableSphereNodes.append(self.seats[i].attachNewNode(CollisionNode('picnicTable_sphere_%d_%d' % (self.getDoId(), i)))) self.picnicTableSphereNodes[i].node().addSolid(CollisionSphere(0, 0, 0, 2)) self.tableState = [None, None, None, None, None, None] self.requestTableState() 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') angle = self.getH() angle -= 90 radAngle = deg2Rad(angle) unitVec = Vec3(math.cos(radAngle), math.sin(radAngle), 0) unitVec *= 30.0 self.endPos = self.getPos() + unitVec dist = Vec3(self.endPos - self.getPos()).length() wheelAngle = dist / (0.7 * math.pi) * 360 self.__enableCollisions() def handleSleep(self, task = None): if self.fsm.getCurrentState().getName() == 'chooseMode': self.cancelButtonPushed() elif self.fsm.getCurrentState().getName() == 'sitting': self.sendUpdate('requestExit', []) if self.gameMenu != None: self.gameMenu.removeButtons() self.gameMenu.picnicFunction = None self.gameMenu = None if task != None: task.done def disable(self): DistributedNode.DistributedNode.disable(self) self.ignore('stoppedAsleep') self.clearToonTracks() self.__disableCollisions() self.disableChoiceButtons() self.picnicTable.removeNode() self.cameraBoardTrack = None def delete(self): self.__disableCollisions() self.ignore('stoppedAsleep') DistributedNode.DistributedNode.delete(self) self.disableChoiceButtons() self.cameraBoardTrack = None del self.winTrack del self.outTrack self.fsm = None self.gameZone = None self.clearToonTracks() self.cameraBoardTrack = None def setName(self, name): self.name = name def setGameDoId(self, doId): self.gameDoId = doId self.game = self.cr.doId2do[doId] self.game.setHpr(self.getHpr()) self.gameWantTimer = self.game.wantTimer if self.gameState == 1: self.game.fsm.request('playing') def setTimerFunc(self, function): self.timerFunc = function def setTimer(self, timerEnd): self.clockNode.stop() time = globalClockDelta.networkToLocalTime(timerEnd) self.timeLeft = int(time - globalClock.getRealTime()) if self.gameWantTimer and self.game != None: self.showTimer() def showTimer(self): self.clockNode.stop() self.clockNode.countdown(self.timeLeft, self.timerFunc) self.clockNode.show() def requestTableState(self): self.sendUpdate('requestTableState', []) def setTableState(self, tableStateList, isplaying): y = 0 print 'SET TABLE STATE' if isplaying == 0: self.isPlaying = False else: self.isPlaying = True for x in tableStateList: if x != 0: if x not in self.tableState and self.cr.doId2do.has_key(x) and x not in self.haveAnimated: seatIndex = tableStateList.index(x) toon = self.cr.doId2do[x] toon.stopSmooth() toon.setAnimState('Sit', 1.0) dest = self.seats[seatIndex].getPos(self.tableCloth) hpr = self.seats[seatIndex].getHpr(render) toon.setHpr(hpr) if seatIndex > 2: toon.setH(self.getH() + 180) toon.wrtReparentTo(self) toon.setPos(dest) toon.setZ(toon.getZ() + 1.35) if seatIndex > 2: toon.setY(toon.getY() - 1.0) else: toon.setY(toon.getY() + 1.0) if x != 0: self.tableState[y] = x else: self.tableState[y] = None y += 1 numPlayers = 0 for x in self.tableState: if x != None: numPlayers += 1 print ' GETTING 2', self.gameMenu, numPlayers if self.gameMenu: if numPlayers > 2: print ' GETTING HERE!!' self.gameMenu.FindFour.setColor(0.7, 0.7, 0.7, 0.7) self.gameMenu.FindFour['command'] = self.doNothing self.gameMenu.findFourText['fg'] = (0.7, 0.7, 0.7, 0.7) self.gameMenu.Checkers.setColor(0.7, 0.7, 0.7, 0.7) self.gameMenu.Checkers['command'] = self.doNothing self.gameMenu.checkersText['fg'] = (0.7, 0.7, 0.7, 0.7) def setIsPlaying(self, isPlaying): if isPlaying == 0: self.isPlaying = False elif isPlaying == 1: self.isPlaying = True def announceWinner(self, winString, avId): if avId == base.localAvatar.getDoId(): sound = Sequence(Wait(2.0), Parallel(SoundInterval(self.winSound), SoundInterval(self.happyDance))) sound.start() base.cr.playGame.getPlace().setState('walk') if winString == 'Chinese Checkers': whisper = WhisperPopup(TTLocalizer.ChineseCheckersYouWon, OTPGlobals.getInterfaceFont(), WhisperPopup.WTNormal) elif winString == 'Checkers': whisper = WhisperPopup(TTLocalizer.RegularCheckersYouWon, OTPGlobals.getInterfaceFont(), WhisperPopup.WTNormal) elif winString == 'Find Four': whisper = WhisperPopup('You won a game of Find Four!', OTPGlobals.getInterfaceFont(), WhisperPopup.WTNormal) elif self.cr.doId2do.has_key(avId): stateString = self.fsm.getCurrentState().getName() if stateString == 'sitting' or stateString == 'observing': base.cr.playGame.getPlace().setState('walk') av = self.cr.doId2do[avId] if winString == 'Chinese Checkers': whisper = WhisperPopup(av.getName() + TTLocalizer.ChineseCheckersGameOf + TTLocalizer.ChineseCheckers, OTPGlobals.getInterfaceFont(), WhisperPopup.WTNormal) elif winString == 'Checkers': whisper = WhisperPopup(av.getName() + TTLocalizer.RegularCheckersGameOf + TTLocalizer.RegularCheckers, OTPGlobals.getInterfaceFont(), WhisperPopup.WTNormal) elif winString == 'Find Four': whisper = WhisperPopup(av.getName() + ' has won a game of' + ' Find Four!', OTPGlobals.getInterfaceFont(), WhisperPopup.WTNormal) if self.cr.doId2do.has_key(avId): toon = self.cr.doId2do[avId] self.winTrack = Sequence(autoFinish=1) if self.outTrack.isPlaying(): self.winTrack.append(Wait(2.0)) if avId == base.localAvatar.getDoId(): self.winTrack.append(Func(self.stopToWalk)) self.winTrack.append(ActorInterval(toon, 'happy-dance')) if avId == base.localAvatar.getDoId(): self.winTrack.append(Func(self.allowToWalk)) self.winTrack.start() whisper.manage(base.marginManager) def handleEnterPicnicTableSphere(self, i, collEntry): self.notify.debug('Entering Picnic Table Sphere.... %s' % self.getDoId()) self.requestSeat = i self.seatBumpForObserve = i self.fsm.request('chooseMode') def enableChoiceButtons(self): if self.tableState[self.seatBumpForObserve] == None and self.isPlaying == False: self.joinButton = DirectButton(relief=None, text=TTLocalizer.PicnicTableJoinButton, text_fg=(1, 1, 0.65, 1), text_pos=(0, -0.23), text_scale=0.8, image=(self.upButton, self.downButton, self.rolloverButton), image_color=(1, 0, 0, 1), image_scale=(20, 1, 11), pos=(0, 0, 0.8), scale=0.15, command=lambda self = self: self.joinButtonPushed()) if self.isPlaying: self.observeButton = DirectButton(relief=None, text=TTLocalizer.PicnicTableObserveButton, text_fg=(1, 1, 0.65, 1), text_pos=(0, -0.23), text_scale=0.8, image=(self.upButton, self.downButton, self.rolloverButton), image_color=(1, 0, 0, 1), image_scale=(20, 1, 11), pos=(0, 0, 0.6), scale=0.15, command=lambda self = self: self.observeButtonPushed()) self.exitButton = DirectButton(relief=None, text=TTLocalizer.PicnicTableCancelButton, text_fg=(1, 1, 0.65, 1), text_pos=(0, -0.23), text_scale=0.8, image=(self.upButton, self.downButton, self.rolloverButton), image_color=(1, 0, 0, 1), image_scale=(20, 1, 11), pos=(1, 0, 0.6), scale=0.15, command=lambda self = self: self.cancelButtonPushed()) self.tutorialButton = DirectButton(relief=None, text=TTLocalizer.PicnicTableTutorial, text_fg=(1, 1, 0.65, 1), text_pos=(-0.05, -0.13), text_scale=0.55, image=(self.upButton, self.downButton, self.rolloverButton), image_color=(1, 0, 0, 1), image_scale=(20, 1, 11), pos=(-1, 0, 0.6), scale=0.15, command=lambda self = self: self.tutorialButtonPushed()) base.cr.playGame.getPlace().setState('stopped') def tutorialButtonPushed(self): self.disableChoiceButtons() self.gameMenu = GameMenu(self.tutorialFunction, 1) self.tutorialButton.destroy() self.tutorialButton = None def tutorialFunction(self, tutVal): if tutVal == 1: self.tutorial = ChineseTutorial(self.tutorialDone) elif tutVal == 2: self.tutorial = CheckersTutorial(self.tutorialDone) self.gameMenu.picnicFunction = None self.gameMenu = None def tutorialDone(self): self.requestSeat = None self.fsm.request('off') self.tutorial = None def joinButtonPushed(self): toon = base.localAvatar self.sendUpdate('requestJoin', [self.requestSeat, toon.getX(), toon.getY(), toon.getZ(), toon.getH(), toon.getP(), toon.getR()]) self.requestSeat = None self.fsm.request('sitting') def rejectJoin(self): self.fsm.request('off') self.allowToWalk() def cancelButtonPushed(self): base.cr.playGame.getPlace().setState('walk') self.requestSeat = None self.fsm.request('off') def disableChoiceButtons(self): if self.joinButton: self.joinButton.destroy() if self.observeButton: self.observeButton.destroy() if self.exitButton: self.exitButton.destroy() if self.tutorialButton: self.tutorialButton.destroy() def pickFunction(self, gameNum): if gameNum == 1: self.sendUpdate('requestPickedGame', [gameNum]) elif gameNum == 2: self.sendUpdate('requestPickedGame', [gameNum]) elif gameNum == 3: self.sendUpdate('requestPickedGame', [gameNum]) def allowPick(self): self.gameMenu = GameMenu(self.pickFunction, 2) def setZone(self, zoneId): if self.fsm.getCurrentState().getName() == 'sitting' or self.fsm.getCurrentState().getName() == 'observing': if self.tutorial == None: self.gameZone = base.cr.addInterest(base.localAvatar.defaultShard, zoneId, 'gameBoard') if self.gameMenu != None: self.gameMenu.removeButtons() self.gameMenu.picnicFunction = None self.gameMenu = None def fillSlot(self, avId, index, x, y, z, h, p, r, timestamp, parentDoId): self.notify.debug('fill Slot: %d for %d' % (index, avId)) if avId not in self.haveAnimated: self.haveAnimated.append(avId) if avId == base.localAvatar.getDoId(): if self.inGame: return self.inGame = True self.seatPos = index if self.cr.doId2do.has_key(avId): toon = self.cr.doId2do[avId] toon.stopSmooth() toon.wrtReparentTo(self.tableCloth) sitStartDuration = toon.getDuration('sit-start') jumpTrack = self.generateToonJumpTrack(toon, index) track = Sequence(autoFinish=1) if avId == base.localAvatar.getDoId(): if not base.cr.playGame.getPlace() == None: self.moveCamera(index) track.append(Func(self.__disableCollisions)) track.append(jumpTrack) track.append(Func(toon.setAnimState, 'Sit', 1.0)) track.append(Func(self.clearToonTrack, avId)) self.storeToonTrack(avId, track) track.start() def emptySlot(self, avId, index, timestamp): self.notify.debug('### seat %s now empty' % index) if index == 255 and self.game != None: self.stopObserveButtonPushed() return if avId in self.haveAnimated: self.haveAnimated.remove(avId) if self.cr.doId2do.has_key(avId): if avId == base.localAvatar.getDoId(): if self.gameZone: base.cr.removeInterest(self.gameZone) if self.inGame: self.inGame = False else: return toon = self.cr.doId2do[avId] toon.stopSmooth() sitStartDuration = toon.getDuration('sit-start') jumpOutTrack = self.generateToonReverseJumpTrack(toon, index) self.outTrack = Sequence(jumpOutTrack) if base.localAvatar.getDoId() == avId: self.outTrack.append(Func(self.__enableCollisions)) self.outTrack.append(Func(self.allowToWalk)) self.fsm.request('off') val = self.jumpOffsets[index].getPos(render) self.outTrack.append(Func(toon.setPos, val)) self.outTrack.append(Func(toon.startSmooth)) self.outTrack.start() def stopToWalk(self): base.cr.playGame.getPlace().setState('stopped') def allowToWalk(self): base.cr.playGame.getPlace().setState('walk') def moveCamera(self, seatIndex): self.oldCameraPos = camera.getPos() self.oldCameraHpr = camera.getHpr() camera.wrtReparentTo(self.picnicTable) heading = PythonUtil.fitDestAngle2Src(camera.getH(), 90) if seatIndex < 3: self.cameraBoardTrack = LerpPosHprInterval(camera, 2.0, Point3(0, 0, 17), Point3(0, -90, 0)) elif camera.getH() < 0: self.cameraBoardTrack = LerpPosHprInterval(camera, 2.0, Point3(0, 0, 17), Point3(-180, -90, 0)) else: self.cameraBoardTrack = LerpPosHprInterval(camera, 2.0, Point3(0, 0, 17), Point3(180, -90, 0)) self.cameraBoardTrack.start() def moveCameraBack(self): self.cameraBoardTrack = LerpPosHprInterval(camera, 2.5, self.oldCameraPos, self.oldCameraHpr) self.cameraBoardTrack.start() def __enableCollisions(self): for i in range(self.numSeats): self.accept('enterpicnicTable_sphere_%d_%d' % (self.getDoId(), i), self.handleEnterPicnicTableSphere, [i]) self.picnicTableSphereNodes[i].setCollideMask(ToontownGlobals.WallBitmask) self.tableclothSphereNode.setCollideMask(ToontownGlobals.WallBitmask) def __disableCollisions(self): for i in range(self.numSeats): self.ignore('enterpicnicTable_sphere_%d_%d' % (self.getDoId(), i)) self.ignore('enterPicnicTableOK_%d_%d' % (self.getDoId(), i)) for i in range(self.numSeats): self.picnicTableSphereNodes[i].setCollideMask(BitMask32(0)) self.tableclothSphereNode.setCollideMask(BitMask32(0)) def enterOff(self): base.setCellsAvailable(base.leftCells + base.bottomCells, 0) def exitOff(self): base.setCellsAvailable(base.bottomCells, 0) def enterChooseMode(self): self.winTrack = Sequence(autoFinish=1) self.enableChoiceButtons() def exitChooseMode(self): self.disableChoiceButtons() def enterObserving(self): self.enableStopObserveButton() self.moveCamera(self.seatBumpForObserve) self.sendUpdate('requestGameZone') def exitObserving(self): if self.cameraBoardTrack.isPlaying(): self.cameraBoardTrack.pause() self.allowToWalk() self.stopObserveButton.destroy() def enterSitting(self): pass def exitSitting(self): self.gameMenu = None def setGameZone(self, zoneId, gamestate): self.gameZone = base.cr.addInterest(base.localAvatar.defaultShard, zoneId, 'gameBoard') self.gameState = gamestate def observeButtonPushed(self): self.requestSeat = None self.fsm.request('observing') def enableStopObserveButton(self): self.stopObserveButton = DirectButton(relief=None, text='Stop Observing', text_fg=(1, 1, 0.65, 1), text_pos=(0, -0.23), text_scale=0.45, image=(self.upButton, self.downButton, self.rolloverButton), image_color=(1, 0, 0, 1), image_scale=(20, 1, 11), pos=(0.92, 0, 0.4), scale=0.15, command=lambda self = self: self.stopObserveButtonPushed()) def stopObserveButtonPushed(self): self.sendUpdate('leaveObserve', []) self.gameState = None if self.game: self.game.fsm.request('gameOver') base.cr.removeInterest(self.gameZone) self.fsm.request('off') def generateToonReverseJumpTrack(self, av, seatIndex): self.notify.debug('av.getH() = %s' % av.getH()) def getToonJumpTrack(av, destNode): def getJumpDest(av = av, node = destNode): dest = node.getPos(self.tableCloth) dest += self.jumpOffsets[seatIndex].getPos(self.tableCloth) return dest def getJumpHpr(av = av, node = destNode): hpr = node.getHpr(av.getParent()) hpr.setX(hpr.getX() + 180) angle = PythonUtil.fitDestAngle2Src(av.getH(), hpr.getX()) hpr.setX(angle) return hpr toonJumpTrack = Parallel(ActorInterval(av, 'jump'), Sequence(Wait(0.1), Parallel(ProjectileInterval(av, endPos=getJumpDest, duration=0.9)))) return toonJumpTrack toonJumpTrack = getToonJumpTrack(av, self.tableCloth) jumpTrack = Sequence(toonJumpTrack, Func(av.loop, 'neutral'), Func(av.wrtReparentTo, render)) return jumpTrack def generateToonJumpTrack(self, av, seatIndex): av.pose('sit', 47) hipOffset = av.getHipsParts()[2].getPos(av) def getToonJumpTrack(av, seatIndex): def getJumpDest(av = av, node = self.tableCloth): dest = Vec3(self.tableCloth.getPos(av.getParent())) seatNode = self.picnicTable.find('**/seat' + str(seatIndex + 1)) dest += seatNode.getPos(self.tableCloth) dna = av.getStyle() dest -= hipOffset if seatIndex > 2: dest.setY(dest.getY() - 2.0) if seatIndex == 1: dest.setY(dest.getY() - 0.5) dest.setZ(dest.getZ() + 0.2) return dest def getJumpHpr(av = av, node = self.tableCloth): hpr = self.seats[seatIndex].getHpr(av.getParent()) if seatIndex < 3: hpr.setX(hpr.getX()) elif av.getH() < 0: hpr.setX(hpr.getX() - 180) else: hpr.setX(hpr.getX() + 180) return hpr toonJumpTrack = Parallel(ActorInterval(av, 'jump'), Sequence(Wait(0.43), Parallel(LerpHprInterval(av, hpr=getJumpHpr, duration=1), ProjectileInterval(av, endPos=getJumpDest, duration=1)))) return toonJumpTrack def getToonSitTrack(av): toonSitTrack = Sequence(ActorInterval(av, 'sit-start'), Func(av.loop, 'sit')) return toonSitTrack toonJumpTrack = getToonJumpTrack(av, seatIndex) toonSitTrack = getToonSitTrack(av) jumpTrack = Sequence(Parallel(toonJumpTrack, Sequence(Wait(1), toonSitTrack)), Func(av.wrtReparentTo, self.tableCloth)) return jumpTrack def storeToonTrack(self, avId, track): self.clearToonTrack(avId) self.__toonTracks[avId] = track def clearToonTrack(self, avId): oldTrack = self.__toonTracks.get(avId) if oldTrack: oldTrack.pause() DelayDelete.cleanupDelayDeletes(oldTrack) def clearToonTracks(self): keyList = [] for key in self.__toonTracks: keyList.append(key) for key in keyList: if self.__toonTracks.has_key(key): self.clearToonTrack(key) def doNothing(self): pass
def tutorialButtonPushed(self): self.disableChoiceButtons() self.gameMenu = GameMenu(self.tutorialFunction, GameGlobals.TutorialMenu) return
def on_key_press(self, symbol, modifiers): if symbol == key.ESCAPE: # GETTING BACK FROM OPTIONS AND CREDITS MENU TO MAIN MENU if self.status.game_menu: if self.status.game_controls: self.status.game_controls = False if self.status.game_about: self.status.game_about = False # GETTING BACK FROM SELECTION MENU TO MAIN MENU AND SETTING THE REQUIRED VARIABLES TO DEFAULT if self.status.game_selection: self.status.game_selection = False self.status.game_menu = True self.status.player1_selected = False self.status.player2_selected = False self.smenu.update_p1(-self.smenu.p1_nav_ofs) self.smenu.p1_nav_ofs = 0 self.smenu.update_p2(-self.smenu.p2_nav_ofs) self.smenu.p2_nav_ofs = 0 # FOR PAUSING THE GAME if self.status.game_running and not self.status.game_paused: self.status.game_paused = True self.status.game_running = False self.status.game_menu = True self.menu = GameMenu(resolution, self.status.pause_menu_text) # PAUSING THE GAME MUSIC AND PLAYING THE MENU MUSIC game_player.pause() bg_player.play() if symbol == key.ENTER and time.time( ) - self.start_time > starting_screen_timeout + 1: # IN GAME MAIN MENU if self.status.game_menu: # FOR ENTERING INTO THE SELECTION MENU if not self.status.game_started and self.menu.nav_ofs == 0: self.status.game_selection = True self.status.game_menu = False # FOR RESUMING THE GAME WHILE PAUSED elif self.status.game_paused and self.menu.nav_ofs == 0: self.status.game_running = True self.status.game_paused = False self.status.game_menu = False # PAUSING THE MENU MUSIC AND PLAYING THE GAME MUSIC bg_player.pause() game_player.play() # FOR ENTERING THE CONTROLS MENU elif (not self.status.game_started or self.status.game_paused) and self.menu.nav_ofs == 100: self.status.game_controls = True # FOR ENTERING THE CREDITS MENU elif (not self.status.game_started or self.status.game_paused) and self.menu.nav_ofs == 200: self.status.game_about = True # FOR EXITING THE GAME AND ENTERING MAIN MENU elif self.status.game_paused and self.menu.nav_ofs == 300: self.reload() # FOR EXITING THE GAME elif not self.status.game_started and self.menu.nav_ofs == 300: pyglet.app.exit() # FOR RELOADING THE GAME AFTER GAME OVER if self.status.game_over: self.reload() # PLAYER 1 KEY PRESS EVENTS if symbol == key.D: self.player1.right = True if symbol == key.A: self.player1.left = True if symbol == key.W: self.player1.up = True # IN GAME MAIN MENU if self.status.game_menu: # FOR NAVIGATING UP IN GAME MENU if not self.status.game_running and not self.status.game_over and not self.status.game_controls and not self.status.game_about: if self.menu.nav_ofs > 0: self.menu.update(-self.menu.nav_step) self.menu.nav_ofs -= self.menu.nav_step elif self.menu.nav_ofs == 0: self.menu.nav_ofs = (len(self.status.game_menu_text) - 1) * self.menu.nav_step self.menu.update( ((len(self.status.game_menu_text) - 1) * self.menu.nav_step)) # IN GAME SELECTION MENU if self.status.game_selection: # FOR NAVIGATING UP IN SELECTION MENU if self.smenu.p1_nav_ofs > 0: self.smenu.update_p1(-self.smenu.nav_step) self.smenu.p1_nav_ofs -= self.smenu.nav_step elif self.smenu.p1_nav_ofs == 0: self.smenu.p1_nav_ofs = ( len(self.status.game_selection_text) - 1) * self.smenu.nav_step self.smenu.update_p1( ((len(self.status.game_selection_text) - 1) * self.smenu.nav_step)) if symbol == key.S: self.player1.down = True # IN GAME MAIN MENU if self.status.game_menu: # FOR NAVIGATING DOWN IN GAME MENU if not self.status.game_running and not self.status.game_over and not self.status.game_controls and not self.status.game_about: if self.menu.nav_ofs < (len(self.status.game_menu_text) - 1) * self.menu.nav_step: self.menu.update(self.menu.nav_step) self.menu.nav_ofs += self.menu.nav_step elif self.menu.nav_ofs == (len(self.status.game_menu_text) - 1) * self.menu.nav_step: self.menu.nav_ofs = 0 self.menu.update(-( (len(self.status.game_menu_text) - 1) * self.menu.nav_step)) # IN GAME SELECTION MENU if self.status.game_selection: # FOR NAVIGATING DOWN IN SELECTION MENU if self.smenu.p1_nav_ofs < ( len(self.status.game_selection_text) - 1) * self.smenu.nav_step: self.smenu.update_p1(self.menu.nav_step) self.smenu.p1_nav_ofs += self.menu.nav_step elif self.smenu.p1_nav_ofs == ( len(self.status.game_selection_text) - 1) * self.smenu.nav_step: self.smenu.p1_nav_ofs = 0 self.smenu.update_p1(-( (len(self.status.game_selection_text) - 1) * self.smenu.nav_step)) if symbol == key.F and self.status.game_running: # TOGGLE FIRE (MANUAL/AUTO) if self.player1.fire_type == "auto": self.player1.fire_type = "manual" else: self.player1.fire_type = "auto" if symbol == key.SPACE: global p1_hp_score, p1_ship # FOR FIRING THE LASERS WHILE GAME RUNNING if self.status.game_running: if self.player1.fire_type == "auto": self.player1.fire = True else: self.player1.laser_list.append( Lasers(self.player1.pos_x + 96, self.player1.pos_y + 34, [20, 5], p1_dhp_color)) self.player1.laser_sound.play() # IN GAME SELECTION MENU if self.status.game_selection: # FOR SELECTING THE SHIP OF PLAYER 1 AND SETTING THE SELECTED SHIP STATS TO THE PLAYER OBJECT if self.smenu.p1_nav_ofs == 0: self.player1.set_stats(p1_ship1_stats) p1_ship = self.status.game_selection_text[0] elif self.smenu.p1_nav_ofs == 100: self.player1.set_stats(p1_ship2_stats) p1_ship = self.status.game_selection_text[1] elif self.smenu.p1_nav_ofs == 200: self.player1.set_stats(p1_ship3_stats) p1_ship = self.status.game_selection_text[2] # CALCULATING THE PLAYER 1 SHIP HP SCORE BASED ON SELECTED SHIP STAT p1_hp_score = p1_total_life / self.player1.damage_taken # CHECKING FOR PLAYER 2 SHIP SELECTION // IF TRUE START THE GAME self.status.player1_selected = True if self.status.player2_selected: self.status.game_started = True self.status.game_running = True self.status.game_selection = False # FOR PAUSING THE MENU MUSIC AND PLAYING THE GAME MUSIC bg_player.pause() game_player.play() # PLAYER SPECIAL FIRE if symbol == key.G and self.status.game_running: self.player1.sp_fire = True if len(self.player1.sp_laser_list) < 3: self.player1.sp_laser_list.append( Lasers(self.player1.pos_x + 96, self.player1.pos_y + 34, [50, 50], [255, 0, 0, 255] * 4)) # PLAYER 1 GAURDING if symbol == key.LSHIFT and self.status.game_running: self.player1.gaurding = True # PLAYER 2 KEY PRESS EVENTS if symbol == key.RIGHT: self.player2.right = True if symbol == key.LEFT: self.player2.left = True if symbol == key.UP: self.player2.up = True # IN GAME SELECTION MENU if self.status.game_selection: # FOR NAVIGATING UP IN SELECTION MENU if self.smenu.p2_nav_ofs > 0: self.smenu.update_p2(-self.smenu.nav_step) self.smenu.p2_nav_ofs -= self.smenu.nav_step elif self.smenu.p2_nav_ofs == 0: self.smenu.p2_nav_ofs = ( len(self.status.game_selection_text) - 1) * self.smenu.nav_step self.smenu.update_p2( ((len(self.status.game_selection_text) - 1) * self.smenu.nav_step)) if symbol == key.DOWN: self.player2.down = True # IN GAME SELECTION MENU if self.status.game_selection: # FOR NAVIGATING DOWN IN SELECTION MENU if self.smenu.p2_nav_ofs < ( len(self.status.game_selection_text) - 1) * self.smenu.nav_step: self.smenu.update_p2(self.menu.nav_step) self.smenu.p2_nav_ofs += self.menu.nav_step elif self.smenu.p2_nav_ofs == ( len(self.status.game_selection_text) - 1) * self.smenu.nav_step: self.smenu.p2_nav_ofs = 0 self.smenu.update_p2(-( (len(self.status.game_selection_text) - 1) * self.smenu.nav_step)) if symbol == key.NUM_0 and self.status.game_running: # TOGGLE FIRE (MANUAL/AUTO) if self.player2.fire_type == "auto": self.player2.fire_type = "manual" else: self.player2.fire_type = "auto" if symbol == key.P: global p2_hp_score, p2_ship # FOR FIRING THE LASERS WHILE GAME RUNNING if self.status.game_running: if self.player2.fire_type == "auto": self.player2.fire = True else: self.player2.laser_list.append( Lasers(self.player2.pos_x - 17, self.player2.pos_y + 34, [20, 5], p2_hp_color)) self.player2.laser_sound.play() # IN GAME SELECTION MENU if self.status.game_selection: # FOR SELECTING THE SHIP OF PLAYER 2 AND SETTING THE SELECTED SHIP STATS TO THE PLAYER OBJECT if self.smenu.p2_nav_ofs == 0: self.player2.set_stats(p2_ship1_stats) p2_ship = self.status.game_selection_text[0] elif self.smenu.p2_nav_ofs == 100: self.player2.set_stats(p2_ship2_stats) p2_ship = self.status.game_selection_text[1] elif self.smenu.p2_nav_ofs == 200: self.player2.set_stats(p2_ship3_stats) p2_ship = self.status.game_selection_text[2] # CALCULATING THE PLAYER 2 SHIP HP SCORE BASED ON SELECTED SHIP STAT p2_hp_score = p2_total_life / self.player2.damage_taken self.status.player2_selected = True if self.status.player1_selected: self.status.game_started = True self.status.game_running = True self.status.game_selection = False # FOR PAUSING THE MENU MUSIC AND PLAYING THE GAME MUSIC bg_player.pause() game_player.play() # PLAYER 1 GAURDING if symbol == key.RALT and self.status.game_running: self.player2.gaurding = True
class DistributedPicnicTable(DistributedNode.DistributedNode): 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() def announceGenerate(self): DistributedNode.DistributedNode.announceGenerate(self) #Set up the collision spheres for the seats for i in range(self.numSeats): self.picnicTableSphereNodes.append(self.seats[i].attachNewNode( CollisionNode('picnicTable_sphere_%d_%d' % (self.getDoId(), i)))) self.picnicTableSphereNodes[i].node().addSolid( CollisionSphere(0, 0, 0, 2)) #sit everyone down self.tableState = [None, None, None, None, None, None] self.requestTableState() 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.picnicTable.setScale(.030) #Preprocessing for Jump into seat Arcs (bad to do at runtime) angle = self.getH() angle -= 90 radAngle = deg2Rad(angle) unitVec = Vec3(math.cos(radAngle), math.sin(radAngle), 0) unitVec *= 30.0 self.endPos = self.getPos() + unitVec dist = Vec3(self.endPos - self.getPos()).length() wheelAngle = dist / (0.5 * 1.4 * math.pi) * 360 self.__enableCollisions() def handleSleep(self, task=None): #print "GETTING TO SLEEP!!!" if self.fsm.getCurrentState().getName() == "chooseMode": self.cancelButtonPushed() elif self.fsm.getCurrentState().getName() == "sitting": self.sendUpdate("requestExit", []) if self.gameMenu != None: self.gameMenu.removeButtons() self.gameMenu.picnicFunction = None self.gameMenu = None if task != None: task.done #task.done def disable(self): DistributedNode.DistributedNode.disable(self) self.ignore('stoppedAsleep') self.clearToonTracks() self.__disableCollisions() self.disableChoiceButtons() #del self.picnicTableSphereNodes self.picnicTable.removeNode() self.cameraBoardTrack = None #self.fsm = None #self.winTrack.finish() #self.outTrack.finish() #self.outTrack = None def delete(self): self.__disableCollisions() self.ignore('stoppedAsleep') DistributedNode.DistributedNode.delete(self) self.disableChoiceButtons() self.cameraBoardTrack = None #self.winTrack.finish() #self.outTrack.finish() #self.winTrack = None #self.outTrack = None del self.winTrack del self.outTrack self.fsm = None self.gameZone = None self.clearToonTracks() self.cameraBoardTrack = None #self.clearToonTrack() #print " I AM DELETEING \n\n\n\n\n\n\n\n\n" #self.outTrack = None #del self def setName(self, name): self.name = name ################ ##SetGameDoID - # This function is called by the child game after it is generated, in order #to set up the cross references that are needed to handle certain events #IE (getting up, erroneous disconnects ect.) def setGameDoId(self, doId): self.gameDoId = doId self.game = self.cr.doId2do[doId] self.game.setHpr(self.getHpr()) self.gameWantTimer = self.game.wantTimer if self.gameState == 1: self.game.fsm.request('playing') ########## ##Timer Functions #setTimer (required broadcast ram) # #These are the timer functions that dictate movement and visual timer #feedback in the game table and chinese checkers. # ########## def setTimerFunc(self, function): self.timerFunc = function def setTimer(self, timerEnd): self.clockNode.stop() time = globalClockDelta.networkToLocalTime(timerEnd) self.timeLeft = int(time - globalClock.getRealTime()) if self.gameWantTimer and self.game != None: self.showTimer() def showTimer(self): #important to stop the timer before you reset it, otherwise it may still be running self.clockNode.stop() self.clockNode.countdown(self.timeLeft, self.timerFunc) self.clockNode.show() ########## #setTableState (required ram broadcast) # #This functions primary purpose is to handle asynchrinous joins of the zone #if an avatar teleports in, he needs to have a state of the table so he #can animate the toons to be sitting down in their corresponding seats ########## def requestTableState(self): self.sendUpdate("requestTableState", []) def setTableState(self, tableStateList, isplaying): y = 0 print "SET TABLE STATE" if isplaying == 0: self.isPlaying = False else: self.isPlaying = True for x in tableStateList: if x != 0: # If we are to sit him down, make sure that he has not already been animated by fillslot # (deltas are handled by that function) if not x in self.tableState and self.cr.doId2do.has_key( x) and x not in self.haveAnimated: seatIndex = tableStateList.index(x) toon = self.cr.doId2do[x] toon.stopSmooth() toon.setAnimState("Sit", 1.0) dest = self.seats[seatIndex].getPos(self.tableCloth) hpr = self.seats[seatIndex].getHpr(render) toon.setHpr(hpr) if (seatIndex > 2): toon.setH(self.getH() + 180) toon.wrtReparentTo(self) toon.setPos(dest) toon.setZ(toon.getZ() + 1.35) if (seatIndex > 2): toon.setY(toon.getY() - 1.0) else: toon.setY(toon.getY() + 1.0) if x != 0: self.tableState[y] = x else: self.tableState[y] = None y = y + 1 ###Handle the game menu stuffs numPlayers = 0 for x in self.tableState: if x != None: numPlayers += 1 #check for a game menu up print " GETTING 2", self.gameMenu, numPlayers if self.gameMenu: if numPlayers > 2: print " GETTING HERE!!" self.gameMenu.FindFour.setColor(.7, .7, .7, .7) self.gameMenu.FindFour['command'] = self.doNothing self.gameMenu.findFourText['fg'] = (.7, .7, .7, .7) self.gameMenu.Checkers.setColor(.7, .7, .7, .7) self.gameMenu.Checkers['command'] = self.doNothing self.gameMenu.checkersText['fg'] = (.7, .7, .7, .7) def setIsPlaying(self, isPlaying): if isPlaying == 0: self.isPlaying = False elif isPlaying == 1: self.isPlaying = True ########## ##announceWinner (broadcast) # #Obvious, simply just sets the whisper message ########## def announceWinner(self, winString, avId): if avId == base.localAvatar.getDoId(): sound = Sequence( Wait(2.0), Parallel(SoundInterval(self.winSound), SoundInterval(self.happyDance))) sound.start() base.cr.playGame.getPlace().setState( 'walk') #To stop Cohesion between EmptySlot and AnnounceWin if winString == "Chinese Checkers": whisper = WhisperPopup(TTLocalizer.ChineseCheckersYouWon, OTPGlobals.getInterfaceFont(), WhisperPopup.WTNormal) elif winString == "Checkers": whisper = WhisperPopup(TTLocalizer.RegularCheckersYouWon, OTPGlobals.getInterfaceFont(), WhisperPopup.WTNormal) elif winString == "Find Four": whisper = WhisperPopup("You won a game of Find Four!", OTPGlobals.getInterfaceFont(), WhisperPopup.WTNormal) else: if self.cr.doId2do.has_key(avId): stateString = self.fsm.getCurrentState().getName() if stateString == "sitting" or stateString == "observing": base.cr.playGame.getPlace().setState( 'walk' ) #To stop Cohesion between EmptySlot and AnnounceWin av = self.cr.doId2do[avId] if winString == "Chinese Checkers": whisper = WhisperPopup( av.getName() + TTLocalizer.ChineseCheckersGameOf + TTLocalizer.ChineseCheckers, OTPGlobals.getInterfaceFont(), WhisperPopup.WTNormal) elif winString == "Checkers": whisper = WhisperPopup( av.getName() + TTLocalizer.RegularCheckersGameOf + TTLocalizer.RegularCheckers, OTPGlobals.getInterfaceFont(), WhisperPopup.WTNormal) elif winString == "Find Four": whisper = WhisperPopup( av.getName() + " has won a game of" + " Find Four!", OTPGlobals.getInterfaceFont(), WhisperPopup.WTNormal) if self.cr.doId2do.has_key(avId): # If the toon exists, look it up toon = self.cr.doId2do[avId] #self.winTrack.finish() self.winTrack = Sequence(autoFinish=1) if self.outTrack.isPlaying(): #If toon is jumping out Wait a self.winTrack.append( Wait(2.0)) # duration till his anim is over to begin if avId == base.localAvatar.getDoId(): #stop him from walking locally #otherwise he will animate around while moving on other clients self.winTrack.append(Func(self.stopToWalk)) self.winTrack.append(ActorInterval(toon, 'happy-dance')) if avId == base.localAvatar.getDoId(): self.winTrack.append(Func(self.allowToWalk)) self.winTrack.start() #Display the whisper message whisper.manage(base.marginManager) ########## #handleEnterPicnicTableSphere # #This is the function that via the messenger, handles the collision #with one of the six collision spheres on a picnic table ########## def handleEnterPicnicTableSphere(self, i, collEntry): assert self.notify.debugStateCall(self) #print "COLLISION!!!" self.notify.debug("Entering Picnic Table Sphere.... %s" % self.getDoId()) #if self.requestSeat == None: self.requestSeat = i self.seatBumpForObserve = i self.fsm.request('chooseMode') ########## #Button Logic (handled by handleEnterPicnicTableSphere, and self.fsm ### def enableChoiceButtons(self): if self.tableState[ self.seatBumpForObserve] == None and self.isPlaying == False: self.joinButton = DirectButton( relief=None, text=TTLocalizer.PicnicTableJoinButton, text_fg=(1, 1, 0.65, 1), text_pos=(0, -.23), text_scale=0.8, image=(self.upButton, self.downButton, self.rolloverButton), image_color=(1, 0, 0, 1), image_scale=(20, 1, 11), pos=(0, 0, .8), scale=0.15, command=lambda self=self: self.joinButtonPushed(), ) if self.isPlaying == True: self.observeButton = DirectButton( relief=None, text=TTLocalizer.PicnicTableObserveButton, text_fg=(1, 1, 0.65, 1), text_pos=(0, -.23), text_scale=0.8, image=(self.upButton, self.downButton, self.rolloverButton), image_color=(1, 0, 0, 1), image_scale=(20, 1, 11), pos=(0, 0, 0.6), scale=0.15, command=lambda self=self: self.observeButtonPushed(), ) self.exitButton = DirectButton( relief=None, text=TTLocalizer.PicnicTableCancelButton, text_fg=(1, 1, 0.65, 1), text_pos=(0, -.23), text_scale=0.8, image=(self.upButton, self.downButton, self.rolloverButton), image_color=(1, 0, 0, 1), image_scale=(20, 1, 11), pos=(1, 0, 0.6), scale=0.15, command=lambda self=self: self.cancelButtonPushed(), ) self.tutorialButton = DirectButton( relief=None, text=TTLocalizer.PicnicTableTutorial, text_fg=(1, 1, 0.65, 1), text_pos=(-.05, -.13), text_scale=0.55, image=(self.upButton, self.downButton, self.rolloverButton), image_color=(1, 0, 0, 1), image_scale=(20, 1, 11), pos=(-1, 0, 0.6), scale=0.15, command=lambda self=self: self.tutorialButtonPushed(), ) base.cr.playGame.getPlace().setState('stopped') def tutorialButtonPushed(self): #print "GETTING HERE!!!" self.disableChoiceButtons() #self.tutorial = ChineseTutorial(self.tutorialDone) self.gameMenu = GameMenu(self.tutorialFunction, 1) # 1 == Tutorial Num #self.tutorialFunction(1) self.tutorialButton.destroy() self.tutorialButton = None def tutorialFunction(self, tutVal): if tutVal == 1: self.tutorial = ChineseTutorial(self.tutorialDone) elif tutVal == 2: self.tutorial = CheckersTutorial(self.tutorialDone) self.gameMenu.picnicFunction = None self.gameMenu = None def tutorialDone(self): #del self.tutorial self.requestSeat = None self.fsm.request('off') self.tutorial = None #del self.tutorial def joinButtonPushed(self): toon = base.localAvatar self.sendUpdate("requestJoin", [ self.requestSeat, toon.getX(), toon.getY(), toon.getZ(), toon.getH(), toon.getP(), toon.getR() ]) self.requestSeat = None self.fsm.request('sitting') def rejectJoin(self): self.fsm.request('off') self.allowToWalk() def cancelButtonPushed(self): base.cr.playGame.getPlace().setState('walk') self.requestSeat = None self.fsm.request('off') def disableChoiceButtons(self): if self.joinButton: self.joinButton.destroy() if self.observeButton: self.observeButton.destroy() if self.exitButton: self.exitButton.destroy() if self.tutorialButton: self.tutorialButton.destroy() ########## #Distributed fillSlot Functions (broadcasT) # #These functions are the distributed functions that the ai sends to tell #the client if its ok for people to picnic table, and then animates them ########## def pickFunction(self, gameNum): #print "SENDING PICK!" if gameNum == 1: #Chinese Checkers self.sendUpdate('requestPickedGame', [gameNum]) elif gameNum == 2: self.sendUpdate('requestPickedGame', [gameNum]) elif gameNum == 3: self.sendUpdate('requestPickedGame', [gameNum]) def allowPick(self): self.gameMenu = GameMenu(self.pickFunction, 2) # 2 == pick Num for TTlocalizer #elf.pickFunction(1) def setZone(self, zoneId): #import pdb; pdb.set_trace() #print "ZONE iD == " , zoneId #print "CURRENT SATE?!?!? == ", self.fsm.getCurrentState().getName() #if self.fsm.getCurrentState().getName() == "chooseMode" or self.fsm.getCurrentState().getName() == "sitting": if self.fsm.getCurrentState().getName( ) == "sitting" or self.fsm.getCurrentState().getName() == "observing": if self.tutorial == None: self.gameZone = base.cr.addInterest( base.localAvatar.defaultShard, zoneId, 'gameBoard') if self.gameMenu != None: self.gameMenu.removeButtons() self.gameMenu.picnicFunction = None self.gameMenu = None def fillSlot(self, avId, index, x, y, z, h, p, r, timestamp, parentDoId): assert self.notify.debugStateCall(self) self.notify.debug("fill Slot: %d for %d" % (index, avId)) if not avId in self.haveAnimated: self.haveAnimated.append(avId) if avId == base.localAvatar.getDoId(): if self.inGame == True: return #in a game therefore we dont animate else: self.inGame = True self.seatPos = index pass #not in a game but need to animate into the game if self.cr.doId2do.has_key(avId): toon = self.cr.doId2do[avId] toon.stopSmooth() toon.wrtReparentTo(self.tableCloth) sitStartDuration = toon.getDuration("sit-start") jumpTrack = self.generateToonJumpTrack(toon, index) track = Sequence(autoFinish=1) if avId == base.localAvatar.getDoId(): if not base.cr.playGame.getPlace() == None: self.moveCamera(index) track.append(Func(self.__disableCollisions)) #self.gameZone = base.cr.addInterest(base.localAvatar.defaultShard, boardZoneId, 'chineseBoard') track.append(jumpTrack) track.append(Func(toon.setAnimState, "Sit", 1.0)) track.append(Func(self.clearToonTrack, avId)) self.storeToonTrack(avId, track) track.start() ########## #Empty Slot Distributed Functions (broadcast) # #Distributed functions that manage the toons getting off of the picnic #tables ########## def emptySlot(self, avId, index, timestamp): self.notify.debug("### seat %s now empty" % index) ##Player told to exit is an OBSERVER if index == 255 and self.game != None: self.stopObserveButtonPushed() return #self.fullSeat[index] = self.seatState.Empty if avId in self.haveAnimated: self.haveAnimated.remove(avId) # self.fullSeat[index] = self.seatState.Empty if self.cr.doId2do.has_key(avId): if avId == base.localAvatar.getDoId(): if self.gameZone: base.cr.removeInterest(self.gameZone) if self.inGame == True: #are in a game self.inGame = False else: return #dont animate because we are NOT in a game toon = self.cr.doId2do[avId] toon.stopSmooth() sitStartDuration = toon.getDuration("sit-start") jumpOutTrack = self.generateToonReverseJumpTrack(toon, index) #self.outTrack.finish() self.outTrack = Sequence(jumpOutTrack) if base.localAvatar.getDoId() == avId: self.outTrack.append(Func(self.__enableCollisions)) self.outTrack.append(Func( self.allowToWalk)) #temp until i can stop the #camera from jerking #self.outTrack.append(Func(self.fsm.request, 'off')) self.fsm.request('off') #self.outTrack.append(Func(self.tempCheckers.setHpr, 0, self.tempCheckers.getP(), self.tempCheckers.getR())) val = self.jumpOffsets[index].getPos(render) #self.storeToonTrack(avId, self.outTrack) self.outTrack.append(Func(toon.setPos, val)) self.outTrack.append(Func(toon.startSmooth)) self.outTrack.start() #self.outTrack = Sequence() def stopToWalk(self): base.cr.playGame.getPlace().setState("stopped") def allowToWalk(self): #if not self.winTrack.isPlaying(): base.cr.playGame.getPlace().setState("walk") #self.winTrack.finish() #self.winTrack = None ########## #Camera manipulations ########## def moveCamera(self, seatIndex): self.oldCameraPos = camera.getPos() self.oldCameraHpr = camera.getHpr() camera.wrtReparentTo(self.picnicTable) heading = PythonUtil.fitDestAngle2Src(camera.getH(), 90) #Need to check the seat index so the cameras *down #is towards the player so he is not facing his own character #rather he feels he is a bit above him if seatIndex < 3: self.cameraBoardTrack = LerpPosHprInterval(camera, 2.0, Point3(0, 0, 17), Point3(0, -90, 0)) else: #needed for camera orientation #If test is not here, the camera may often flip around #spinning ~340 degrees to the destination #instead of turning the 20 degrees towards the table if (camera.getH() < 0): #(turned left) self.cameraBoardTrack = LerpPosHprInterval( camera, 2.0, Point3(0, 0, 17), Point3(-180, -90, 0)) else: #(turned right) self.cameraBoardTrack = LerpPosHprInterval( camera, 2.0, Point3(0, 0, 17), Point3(180, -90, 0)) self.cameraBoardTrack.start() def moveCameraBack(self): self.cameraBoardTrack = LerpPosHprInterval(camera, 2.5, self.oldCameraPos, self.oldCameraHpr) self.cameraBoardTrack.start() ########## # Enable and Disable Collisions # #Turn on and off the collisions for the seat and table collision spheres for #boarding and unboarding, thus to actaully allow the toons to sit down, animate ect. ########## def __enableCollisions(self): # start listening for toons to enter. assert self.notify.debugStateCall(self) for i in range(self.numSeats): self.accept('enterpicnicTable_sphere_%d_%d' % (self.getDoId(), i), self.handleEnterPicnicTableSphere, [i]) #self.accept('enterPicnicTableOK_%d_%d' % (self.getDoId(), i), self.handleEnterPicnicTable, [i]) self.picnicTableSphereNodes[i].setCollideMask( ToontownGlobals.WallBitmask) self.tableclothSphereNode.setCollideMask(ToontownGlobals.WallBitmask) def __disableCollisions(self): assert self.notify.debugStateCall(self) #self.ignore('tableClothSphereNode') for i in range(self.numSeats): self.ignore('enterpicnicTable_sphere_%d_%d' % (self.getDoId(), i)) self.ignore('enterPicnicTableOK_%d_%d' % (self.getDoId(), i)) for i in range(self.numSeats): self.picnicTableSphereNodes[i].setCollideMask(BitMask32(0)) self.tableclothSphereNode.setCollideMask(BitMask32(0)) ########## #FSM stuff ########## def enterOff(self): base.setCellsAvailable(base.leftCells + base.bottomCells, 0) def exitOff(self): base.setCellsAvailable(base.bottomCells, 0) def enterChooseMode(self): #self.requestTableState() self.winTrack = Sequence(autoFinish=1) self.enableChoiceButtons() def exitChooseMode(self): self.disableChoiceButtons() def enterObserving(self): self.enableStopObserveButton() self.moveCamera(self.seatBumpForObserve) #track.append(Func(self.__disableCollisions)) self.sendUpdate('requestGameZone') #self.gameZone = base.cr.addInterest(base.localAvatar.defaultShard, boardZoneId, 'chineseBoard') def exitObserving(self): #self.__enableCollisions if self.cameraBoardTrack.isPlaying(): self.cameraBoardTrack.pause() self.allowToWalk() #temp until i can stop the #camera from jerking self.stopObserveButton.destroy() def enterSitting(self): pass #self.tempCheckers.hide() def exitSitting(self): self.gameMenu = None #self.winTrack = None #self.tempCheckers.show() #self.suxButton.destroy() #self.sendUpdate('requestExit', []) ########## #Observer Functions setGameZone (broadcast) # #Need these because you are not "filling" a slot by observing # #For this case - When it sends a 1 or a zero with the setGameZone, This is to account for the fact #an observer can (and will) come into games halfway through, somehow that client needs to know #about the current state of the game. # # #1 == Playing #0 == Not Playing ########## def setGameZone(self, zoneId, gamestate): self.gameZone = base.cr.addInterest(base.localAvatar.defaultShard, zoneId, 'gameBoard') self.gameState = gamestate def observeButtonPushed(self): #base.cr.playGame.getPlace().setState('walk') self.requestSeat = None self.fsm.request('observing') def enableStopObserveButton(self): self.stopObserveButton = DirectButton( relief=None, text="Stop Observing", text_fg=(1, 1, 0.65, 1), text_pos=(0, -.23), text_scale=0.45, image=(self.upButton, self.downButton, self.rolloverButton), image_color=(1, 0, 0, 1), image_scale=(20, 1, 11), pos=(.92, 0, 0.4), scale=0.15, command=lambda self=self: self.stopObserveButtonPushed(), ) def stopObserveButtonPushed(self): self.sendUpdate("leaveObserve", []) self.gameState = None if self.game: self.game.fsm.request('gameOver') base.cr.removeInterest(self.gameZone) self.fsm.request('off') ########## #Generators for jumps # #And the storage/deletion functions for #handling them. ########## def generateToonReverseJumpTrack(self, av, seatIndex): """Return an interval of the toon jumping out of the golf kart.""" self.notify.debug("av.getH() = %s" % av.getH()) def getToonJumpTrack(av, destNode): # using a local func allows the ProjectileInterval to # calculate this pos at run-time def getJumpDest(av=av, node=destNode): dest = node.getPos(self.tableCloth) dest += self.jumpOffsets[seatIndex].getPos(self.tableCloth) return dest def getJumpHpr(av=av, node=destNode): hpr = node.getHpr(av.getParent()) hpr.setX(hpr.getX() + 180) angle = PythonUtil.fitDestAngle2Src(av.getH(), hpr.getX()) hpr.setX(angle) return hpr toonJumpTrack = Parallel( ActorInterval(av, 'jump'), Sequence( Wait(0.1), #43 ), Parallel( #LerpHprInterval( av, # hpr = getJumpHpr, # duration = .9 ), ProjectileInterval(av, endPos=getJumpDest, duration=.9)))) return toonJumpTrack toonJumpTrack = getToonJumpTrack(av, self.tableCloth) #self.seats[seatIndex]) jumpTrack = Sequence( toonJumpTrack, Func(av.loop, 'neutral'), Func(av.wrtReparentTo, render), #Func( self.av.setPosHpr, self.exitMovieNode, 0,0,0,0,0,0 ), ) return jumpTrack def generateToonJumpTrack(self, av, seatIndex): """Return an interval of the toon jumping into the golf kart.""" # Maintain a reference to Parent and Scale of avatar in case they # exit from the kart. #base.sb = self av.pose('sit', 47) hipOffset = av.getHipsParts()[2].getPos(av) def getToonJumpTrack(av, seatIndex): # using a local func allows the ProjectileInterval to # calculate this pos at run-time def getJumpDest(av=av, node=self.tableCloth): dest = Vec3(self.tableCloth.getPos(av.getParent())) seatNode = self.picnicTable.find("**/seat" + str(seatIndex + 1)) dest += seatNode.getPos(self.tableCloth) dna = av.getStyle() dest -= hipOffset if (seatIndex > 2): dest.setY(dest.getY() - 2.0) if (seatIndex == 1): dest.setY(dest.getY() - .5) #dest.setY( dest.getY() + 2 * hipOffset.getY()) #dest.setY(dest.getY()) dest.setZ(dest.getZ() + 0.2) return dest def getJumpHpr(av=av, node=self.tableCloth): hpr = self.seats[seatIndex].getHpr(av.getParent()) if (seatIndex < 3): hpr.setX(hpr.getX()) else: if (av.getH() < 0): hpr.setX(hpr.getX() - 180) else: hpr.setX(hpr.getX() + 180) return hpr toonJumpTrack = Parallel( ActorInterval(av, 'jump'), Sequence( Wait(0.43), Parallel( LerpHprInterval(av, hpr=getJumpHpr, duration=1), ProjectileInterval(av, endPos=getJumpDest, duration=1)), )) return toonJumpTrack def getToonSitTrack(av): toonSitTrack = Sequence(ActorInterval(av, 'sit-start'), Func(av.loop, 'sit')) return toonSitTrack toonJumpTrack = getToonJumpTrack(av, seatIndex) toonSitTrack = getToonSitTrack(av) jumpTrack = Sequence( Parallel( toonJumpTrack, Sequence( Wait(1), toonSitTrack, ), ), Func(av.wrtReparentTo, self.tableCloth), ) return jumpTrack def storeToonTrack(self, avId, track): # Clear out any currently playing tracks on this toon self.clearToonTrack(avId) # Store this new one self.__toonTracks[avId] = track def clearToonTrack(self, avId): # Clear out any currently playing tracks on this toon oldTrack = self.__toonTracks.get(avId) if oldTrack: oldTrack.pause() cleanupDelayDeletes(oldTrack) #del self.__toonTracks[avId] def clearToonTracks(self): #We can't use an iter because we are deleting keys keyList = [] for key in self.__toonTracks: keyList.append(key) for key in keyList: if self.__toonTracks.has_key(key): self.clearToonTrack(key) def doNothing(self): pass
class Board: def __init__(self, master): master.title("Checkers Game - Eden Todosi") self.BoardPixelSize = 600 self.NumberOfCellsInAxis = 8 self.master = master self.SizeOfCell = (int)(self.BoardPixelSize / self.NumberOfCellsInAxis) self.UiAdvancedOptions = [] self.lastSoliderClicked = None self.gameMenu = GameMenu(master, "", 0, 0, self.ResetGame) self.BoardUi = Frame(self.master, borderwidth=2, background="#080808") self.BoardUi.place(x=75, y=140) self.DrawBackgroundBoard() # init the board self.BoardState = [[None for i in range(self.NumberOfCellsInAxis)] for j in range(self.NumberOfCellsInAxis)] self.ResetGame() def DrawBackgroundBoard(self): self.background = [] self.whiteBg = PhotoImage(file="Assets/whitebg.gif") self.blackBg = PhotoImage(file="Assets/blackbg.gif") for i in range(self.NumberOfCellsInAxis): for j in range(self.NumberOfCellsInAxis): if ((i + j) % 2 == 0): whiteBg = Label(self.BoardUi, image=self.whiteBg, borderwidth=0) whiteBg.grid(row=i, column=j) self.background.append(whiteBg) else: blackBg = Label(self.BoardUi, image=self.blackBg, borderwidth=0) blackBg.grid(row=i, column=j) self.background.append(blackBg) def ResetGame(self): for option in self.UiAdvancedOptions: option.Delete() self.UiAdvancedOptions = [] self.InAMiddleOfEating = False self.someoneWin = False self.justEat = False for i in range(self.NumberOfCellsInAxis): for j in range(self.NumberOfCellsInAxis): if (self.BoardState[i][j] is not None): self.BoardState[i][j].Delete() self.BoardState[i][j] = None if ((i + j) % 2 == 0): if (i < 3): self.BoardState[i][j] = Solider( self.BoardUi, "black", Position(i, j), False, self.OnSoliderPressed) elif (i > 4): self.BoardState[i][j] = Solider( self.BoardUi, "white", Position(i, j), False, self.OnSoliderPressed) else: self.BoardState[i][j] = None else: self.BoardState[i][j] = None self.playerTurn = "white" self.whitePlayersCount = 12 self.blackPlayersCount = 12 self.gameMenu.UpdateBlackSoliderCounter(self.blackPlayersCount) self.gameMenu.UpdateWhiteSoliderCounter(self.whitePlayersCount) self.gameMenu.UpdatePlayerTurn(self.playerTurn) def OnSoliderPressed(self, solider): if (self.playerTurn != solider.Color or self.someoneWin): return if (self.InAMiddleOfEating and solider != self.lastSoliderClicked): return for option in self.UiAdvancedOptions: option.Delete() self.UiAdvancedOptions = [] self.lastSoliderClicked = solider advancedPositions = self.GetAdvancedPositionsForSolider(solider) for newPosition in advancedPositions: if (self.InAMiddleOfEating or self.justEat): if (abs(newPosition.Row - self.lastSoliderClicked.Position.Row) == 2): self.UiAdvancedOptions.append( AdvanceOption(self.BoardUi, newPosition, self.OnPositionOptionPress)) else: self.UiAdvancedOptions.append( AdvanceOption(self.BoardUi, newPosition, self.OnPositionOptionPress)) def GetAdvancedPositionsForSolider(self, solider): advancedPositions = [] if (solider.Color == "white" or solider.IsKing): rightOption = self.GetAdvancePositionForSpecificDirection( solider, -1, 1) if (rightOption is not None): advancedPositions.append(rightOption) leftOption = self.GetAdvancePositionForSpecificDirection( solider, -1, -1) if (leftOption is not None): advancedPositions.append(leftOption) if (solider.Color == "black" or solider.IsKing): rightOption = self.GetAdvancePositionForSpecificDirection( solider, 1, 1) if (rightOption is not None): advancedPositions.append(rightOption) leftOption = self.GetAdvancePositionForSpecificDirection( solider, 1, -1) if (leftOption is not None): advancedPositions.append(leftOption) return advancedPositions def GetAdvancePositionForSpecificDirection(self, solider, verticalDirection, horizontalDirection): try: if (solider.Position.Row + verticalDirection < 0 or solider.Position.Column + horizontalDirection < 0): return None if (self.BoardState[solider.Position.Row + verticalDirection][ solider.Position.Column + horizontalDirection] == None): return Position(solider.Position.Row + verticalDirection, solider.Position.Column + horizontalDirection) if (solider.Position.Row + 2 * verticalDirection < 0 or solider.Position.Column + 2 * horizontalDirection < 0): return None if (solider.color != self.BoardState[solider.Position.Row + verticalDirection][ solider.Position.Column + horizontalDirection].Color): if (self.BoardState[solider.Position.Row + verticalDirection * 2][solider.Position.Column + 2 * horizontalDirection] == None): return Position( solider.Position.Row + verticalDirection * 2, solider.Position.Column + 2 * horizontalDirection) except IndexError: return None def CheckIfNotMovesLeft(self): noMoves = True for i in range(self.NumberOfCellsInAxis): for j in range(self.NumberOfCellsInAxis): if (self.BoardState[i][j] is not None): if (self.BoardState[i][j].Color == self.playerTurn): advancedOptions = self.GetAdvancedPositionsForSolider( self.BoardState[i][j]) if (len(advancedOptions) > 0): noMoves = False for option in advancedOptions: # can we eat again ? if (abs(option.Row - self.BoardState[i][j].Position.Row) == 2): self.justEat = True return False return noMoves def OnPositionOptionPress(self, position): for option in self.UiAdvancedOptions: option.Delete() self.UiAdvancedOptions = [] previousPosition = self.lastSoliderClicked.Position self.BoardState[position.Row][ position.Column] = self.lastSoliderClicked self.BoardState[previousPosition.Row][previousPosition.Column] = None self.lastSoliderClicked.UpdatePosition(position) # make someone a king if self.lastSoliderClicked.color == "black" and self.lastSoliderClicked.Position.Row == 7: self.lastSoliderClicked.MakeAKing() if self.lastSoliderClicked.color == "white" and self.lastSoliderClicked.Position.Row == 0: self.lastSoliderClicked.MakeAKing() # if we ate a solider if (abs(previousPosition.Row - position.Row) == 2): middlePosition = Position( (previousPosition.Row + position.Row) / 2, (previousPosition.Column + position.Column) / 2) self.BoardState[middlePosition.Row][middlePosition.Column].Delete() self.BoardState[middlePosition.Row][middlePosition.Column] = None if self.playerTurn == "white": self.DecrementCounter("black") else: self.DecrementCounter("white") advancedOptions = self.GetAdvancedPositionsForSolider( self.lastSoliderClicked) for option in advancedOptions: # can we eat again ? if (abs(option.Row - self.lastSoliderClicked.Position.Row) == 2): self.InAMiddleOfEating = True self.OnSoliderPressed(self.lastSoliderClicked) return self.playerTurn = "black" if self.playerTurn == "white" else "white" self.InAMiddleOfEating = False self.justEat = False if (self.CheckIfNotMovesLeft()): self.Winning("black" if self.playerTurn == "white" else "white") self.gameMenu.UpdatePlayerTurn(self.playerTurn) def DecrementCounter(self, color): if (color == "white"): self.whitePlayersCount -= 1 self.gameMenu.UpdateWhiteSoliderCounter(self.whitePlayersCount) if (self.whitePlayersCount == 0): self.Winning("black") elif (color == "black"): self.blackPlayersCount -= 1 self.gameMenu.UpdateBlackSoliderCounter(self.blackPlayersCount) if (self.blackPlayersCount == 0): self.Winning("white") def Winning(self, color): self.someoneWin = True window = Toplevel(self.master, background="#f0e5df") window.attributes('-topmost', True) window.title("we have a winner!") window.geometry("300x200") message = Label(window, text="The winner is \n" + str(color), background="#f0e5df", font=("Courier", 20)) message.place(x=150, y=80, anchor="center") resetButton = Button(window, text="Reset Game", command=lambda: ((self.ResetGame()), (window.destroy()), (self.master.attributes('-topmost', True))), height=2, width=15) resetButton.place(x=150, y=160, anchor="center") center(window)
class Game: def __init__(self): # initialize game settings # os.environ['SDL_VIDEO_CENTERED'] = '1' # os.environ['SDL_VIDEO_WINDOW_POS'] = '0,0' pygame.init() # pygame.mixer.init() flags = pygame.DOUBLEBUF | pygame.HWSURFACE # | pygame.FULLSCREEN self.screen = pygame.display.set_mode((WIDTH, HEIGHT), flags) pygame.display.set_caption("My Game") self.clock = pygame.time.Clock() self.load_data() font = pygame.font.match_font("Ubuntu Mono") self.menu = GameMenu(self, "Dash!", ["Play", "Options", "Quit"], font=font, font_size=30, padding=20) def new(self): # initialize all your variables and do all the setup for a new game self.speed = WORLD_SPEED self.all_sprites = pygame.sprite.LayeredUpdates() self.backgrounds = pygame.sprite.Group() self.obstacles = pygame.sprite.Group() self.level = 1 # TODO: add per-level loading of tmx self.map_surface = self.tile_renderer.make_map() self.map_surface.set_colorkey(BLACK) self.map_rect = self.map_surface.get_rect() for tile_object in self.tile_renderer.tmxdata.objects: properties = tile_object.__dict__ if properties['type'] in ['platform', 'spike']: x = properties['x'] y = properties['y'] w = properties['width'] h = properties['height'] Blocker(self, x, y, w, h, properties['type'], [self.obstacles]) self.bg1 = Background(self, self.background, 0, self.backgrounds) self.bg2 = Background(self, self.background, self.background.get_width(), self.backgrounds) self.player = Player(self, self.all_sprites) def draw_text(self, text, size, x, y, center=True): # utility function to draw text at a given location # TODO: move font matching to beginning of file (don't repeat) font_name = pygame.font.match_font('arial') font = pygame.font.Font(font_name, size) text_surface = font.render(text, True, (255, 255, 255)) text_rect = text_surface.get_rect() if center: text_rect.midtop = (x, y) else: text_rect.topleft = (x, y) return self.screen.blit(text_surface, text_rect) def load_data(self): # load all your assets (sound, images, etc.) game_dir = path.dirname(__file__) img_dir = path.join(game_dir, "img") self.background = pygame.image.load(path.join(img_dir, 'game_bg_01_001.png')).convert() self.background = pygame.transform.scale(self.background, [640, 640]) self.sprite_sheet = SpriteSheet(path.join(img_dir, "sprites.png")) self.tile_renderer = TileRenderer(path.join(img_dir, 'dash2.tmx')) def run(self): # The Game Loop self.running = True while self.running: self.clock.tick(FPS) self.events() self.update() self.draw() def quit(self): pygame.quit() sys.exit() def update(self): # the update part of the game loop if self.bg1.rect.right <= 0: self.bg1.rect.left = self.bg2.rect.right if self.bg2.rect.right <= 0: self.bg2.rect.left = self.bg1.rect.right self.backgrounds.update() self.all_sprites.update() self.map_rect.x -= self.speed self.obstacles.update() def draw(self): # draw everything to the screen fps_txt = "FPS: {:.2f}".format(self.clock.get_fps()) pygame.display.set_caption(fps_txt) # self.screen.fill(GREEN) self.backgrounds.draw(self.screen) self.screen.blit(self.map_surface, self.map_rect) self.all_sprites.draw(self.screen) pygame.display.flip() def events(self): # catch all events here for event in pygame.event.get(): # this one checks for the window being closed if event.type == pygame.QUIT: self.quit() # now check for keypresses elif event.type == pygame.KEYDOWN: # this one quits if the player presses Esc if event.key == pygame.K_ESCAPE: self.quit() # add any other key events here def show_start_screen(self): # show the start screen self.menu.run() def show_go_screen(self): # show the game over screen pass
class Game: def __init__(self): # initialize game settings # os.environ['SDL_VIDEO_CENTERED'] = '1' # os.environ['SDL_VIDEO_WINDOW_POS'] = '0,0' pygame.init() # pygame.mixer.init() flags = pygame.DOUBLEBUF | pygame.HWSURFACE # | pygame.FULLSCREEN self.screen = pygame.display.set_mode((WIDTH, HEIGHT), flags) pygame.display.set_caption("My Game") self.clock = pygame.time.Clock() self.load_data() font = pygame.font.match_font("Ubuntu Mono") self.menu = GameMenu(self, "Dash!", ["Play", "Options", "Quit"], font=font, font_size=30, padding=20) def new(self): # initialize all your variables and do all the setup for a new game self.speed = WORLD_SPEED self.all_sprites = pygame.sprite.LayeredUpdates() self.backgrounds = pygame.sprite.Group() self.obstacles = pygame.sprite.Group() self.level = 1 # TODO: add per-level loading of tmx self.map_surface = self.tile_renderer.make_map() self.map_surface.set_colorkey(BLACK) self.map_rect = self.map_surface.get_rect() for tile_object in self.tile_renderer.tmxdata.objects: properties = tile_object.__dict__ if properties['type'] in ['platform', 'spike']: x = properties['x'] y = properties['y'] w = properties['width'] h = properties['height'] Blocker(self, x, y, w, h, properties['type'], [self.obstacles]) self.bg1 = Background(self, self.background, 0, self.backgrounds) self.bg2 = Background(self, self.background, self.background.get_width(), self.backgrounds) self.player = Player(self, self.all_sprites) def draw_text(self, text, size, x, y, center=True): # utility function to draw text at a given location # TODO: move font matching to beginning of file (don't repeat) font_name = pygame.font.match_font('arial') font = pygame.font.Font(font_name, size) text_surface = font.render(text, True, (255, 255, 255)) text_rect = text_surface.get_rect() if center: text_rect.midtop = (x, y) else: text_rect.topleft = (x, y) return self.screen.blit(text_surface, text_rect) def load_data(self): # load all your assets (sound, images, etc.) game_dir = path.dirname(__file__) img_dir = path.join(game_dir, "img") self.background = pygame.image.load( path.join(img_dir, 'game_bg_01_001.png')).convert() self.background = pygame.transform.scale(self.background, [640, 640]) self.sprite_sheet = SpriteSheet(path.join(img_dir, "sprites.png")) self.tile_renderer = TileRenderer(path.join(img_dir, 'dash2.tmx')) def run(self): # The Game Loop self.running = True while self.running: self.clock.tick(FPS) self.events() self.update() self.draw() def quit(self): pygame.quit() sys.exit() def update(self): # the update part of the game loop if self.bg1.rect.right <= 0: self.bg1.rect.left = self.bg2.rect.right if self.bg2.rect.right <= 0: self.bg2.rect.left = self.bg1.rect.right self.backgrounds.update() self.all_sprites.update() self.map_rect.x -= self.speed self.obstacles.update() def draw(self): # draw everything to the screen fps_txt = "FPS: {:.2f}".format(self.clock.get_fps()) pygame.display.set_caption(fps_txt) # self.screen.fill(GREEN) self.backgrounds.draw(self.screen) self.screen.blit(self.map_surface, self.map_rect) self.all_sprites.draw(self.screen) pygame.display.flip() def events(self): # catch all events here for event in pygame.event.get(): # this one checks for the window being closed if event.type == pygame.QUIT: self.quit() # now check for keypresses elif event.type == pygame.KEYDOWN: # this one quits if the player presses Esc if event.key == pygame.K_ESCAPE: self.quit() # add any other key events here def show_start_screen(self): # show the start screen self.menu.run() def show_go_screen(self): # show the game over screen pass
def allowPick(self): self.gameMenu = GameMenu(self.pickFunction, 2) # 2 == pick Num for TTlocalizer
def tutorialButtonPushed(self): self.disableChoiceButtons() self.gameMenu = GameMenu(self.tutorialFunction, 1) self.tutorialButton.destroy() self.tutorialButton = None
def allowPick(self): self.gameMenu = GameMenu(self.pickFunction, 2)
def new_game(): # creating variables player_board = Sea() computer_board = Sea() guess_board = Sea() user_hits = 0 computer_hits = 0 # placing ships player_placement(player_board) computer_placement(computer_board) print("Good you are ready. Now lets begin.\n") input("press enter to start") # starting rounds while user_hits < 6 and computer_hits < 6: # players turn while user_hits < 6: print(player_board._top) guess_board.show_sea_board() print(player_board._middle) player_board.show_sea_board() print(player_board._bottom) try: y_guess = int(input("please enter the row to target or enter 0 to see in game menu\n")) while y_guess == 0: i = GameMenu() i.show_menu() i.select_menu_option() y_guess = int(input("please enter the row to target or enter 0 to see in game menu\n")) x_guess = int(input("please enter the column to target or enter 0 to see in game menu\n")) while x_guess == 0: i = GameMenu() i.show_menu() i.select_menu_option() x_guess = int(input("please enter the column to target or enter 0 to see in game menu\n")) if computer_board.get_guess_is_valid(y_guess, x_guess) == True: result = computer_board.update_result(y_guess, x_guess) print("Your shot was a {0}".format(result)) if result == "Hit": user_hits += 1 guess_board.board[y_guess][x_guess] = "X" else: guess_board.board[y_guess][x_guess] = "M" break else: print("that is not a valid location. try again\n") except ValueError: print("That is not a valid entry, please try again.") if user_hits == 6: print("You Won!") computer_hits = 7 # computers turn while computer_hits < 6: x_guess_2 = random.randint(1, 5) y_guess_2 = random.randint(1, 5) print("\nThe computer shot at {0},{1}".format(x_guess_2, y_guess_2)) if player_board.get_guess_is_valid(y_guess_2, x_guess_2) == True: result = player_board.update_result(y_guess_2, x_guess_2) print("It's shot was a {0}".format(result)) if result == "Hit": computer_hits += 1 break if computer_hits == 6: print("You Lost!")
class MyWindow(pyglet.window.Window): def __init__(self, *args, **kwargs): # WINDOW INITIALIZATIONS super().__init__(*args, **kwargs) self.frame_rate = 1 / 60.0 self.fps_display = FPSDisplay(self) self.fps_display.label.font_size = 50 # MAKING THE PRIMITIVE DRAWINGS TRANSPARENT glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) # GAME MENU INITIALIZATIONS self.status = GameStatus() self.menu = GameMenu(resolution, self.status.game_menu_text) self.smenu = SelectionMenu(resolution, self.status.game_selection_text) self.cmenu = ControlsMenu() self.amenu = AboutMenu() self.start_time = time.time() # INITIALLY PLAYING THE MENU BG SONG bg_player.play() # SPACE BG INITIALIZATIONS self.space_list = [] self.space_img = preload_image(space_bg_img) for i in range(2): self.space_list.append( DisplayObjects(0, i * 1080, Sprite(self.space_img))) for space in self.space_list: space.vel_y = -space_scroll_speed # PLAYER INITIALIZATIONS # CREATING PLAYER OBJECTS self.player1 = DisplayPlayers(p1_pos_x, p1_pos_y, p1_fire_type) self.player2 = DisplayPlayers(p2_pos_x, p2_pos_y, p2_fire_type) # PLAYER HP QUAD CREATION self.player1.hp = Quad(p1_hp_pos, p1_hp_size, p1_hp_color, 'p1') self.player2.hp = Quad(p2_hp_pos, p2_hp_size, p2_hp_color, 'p2') # PLAYER GAURD QUAD CREATION self.player1.gaurd = Quad(p1_gaurd_pos, p1_gaurd_size, p1_gaurd_color, 'p1') self.player2.gaurd = Quad(p2_gaurd_pos, p2_gaurd_size, p2_gaurd_color, 'p2') # PLAYER DAMAGE HP QUAD CREATION self.player1.dhp = Quad(p1_dhp_pos, p1_dhp_size, p1_dhp_color, 'p1') self.player2.dhp = Quad(p2_dhp_pos, p2_dhp_size, p2_dhp_color, 'p2') def on_resize(self, width, height): # CODE FOR SETTING THE ORIGIN TO THE BOTTOM LEFT CORNER width = max(1, width) height = max(1, height) glViewport(0, 0, width, height) glMatrixMode(GL_PROJECTION) glLoadIdentity() glOrtho(0, width, 0, height, -1, 1) glMatrixMode(GL_MODELVIEW) def on_key_press(self, symbol, modifiers): if symbol == key.ESCAPE: # GETTING BACK FROM OPTIONS AND CREDITS MENU TO MAIN MENU if self.status.game_menu: if self.status.game_controls: self.status.game_controls = False if self.status.game_about: self.status.game_about = False # GETTING BACK FROM SELECTION MENU TO MAIN MENU AND SETTING THE REQUIRED VARIABLES TO DEFAULT if self.status.game_selection: self.status.game_selection = False self.status.game_menu = True self.status.player1_selected = False self.status.player2_selected = False self.smenu.update_p1(-self.smenu.p1_nav_ofs) self.smenu.p1_nav_ofs = 0 self.smenu.update_p2(-self.smenu.p2_nav_ofs) self.smenu.p2_nav_ofs = 0 # FOR PAUSING THE GAME if self.status.game_running and not self.status.game_paused: self.status.game_paused = True self.status.game_running = False self.status.game_menu = True self.menu = GameMenu(resolution, self.status.pause_menu_text) # PAUSING THE GAME MUSIC AND PLAYING THE MENU MUSIC game_player.pause() bg_player.play() if symbol == key.ENTER and time.time( ) - self.start_time > starting_screen_timeout + 1: # IN GAME MAIN MENU if self.status.game_menu: # FOR ENTERING INTO THE SELECTION MENU if not self.status.game_started and self.menu.nav_ofs == 0: self.status.game_selection = True self.status.game_menu = False # FOR RESUMING THE GAME WHILE PAUSED elif self.status.game_paused and self.menu.nav_ofs == 0: self.status.game_running = True self.status.game_paused = False self.status.game_menu = False # PAUSING THE MENU MUSIC AND PLAYING THE GAME MUSIC bg_player.pause() game_player.play() # FOR ENTERING THE CONTROLS MENU elif (not self.status.game_started or self.status.game_paused) and self.menu.nav_ofs == 100: self.status.game_controls = True # FOR ENTERING THE CREDITS MENU elif (not self.status.game_started or self.status.game_paused) and self.menu.nav_ofs == 200: self.status.game_about = True # FOR EXITING THE GAME AND ENTERING MAIN MENU elif self.status.game_paused and self.menu.nav_ofs == 300: self.reload() # FOR EXITING THE GAME elif not self.status.game_started and self.menu.nav_ofs == 300: pyglet.app.exit() # FOR RELOADING THE GAME AFTER GAME OVER if self.status.game_over: self.reload() # PLAYER 1 KEY PRESS EVENTS if symbol == key.D: self.player1.right = True if symbol == key.A: self.player1.left = True if symbol == key.W: self.player1.up = True # IN GAME MAIN MENU if self.status.game_menu: # FOR NAVIGATING UP IN GAME MENU if not self.status.game_running and not self.status.game_over and not self.status.game_controls and not self.status.game_about: if self.menu.nav_ofs > 0: self.menu.update(-self.menu.nav_step) self.menu.nav_ofs -= self.menu.nav_step elif self.menu.nav_ofs == 0: self.menu.nav_ofs = (len(self.status.game_menu_text) - 1) * self.menu.nav_step self.menu.update( ((len(self.status.game_menu_text) - 1) * self.menu.nav_step)) # IN GAME SELECTION MENU if self.status.game_selection: # FOR NAVIGATING UP IN SELECTION MENU if self.smenu.p1_nav_ofs > 0: self.smenu.update_p1(-self.smenu.nav_step) self.smenu.p1_nav_ofs -= self.smenu.nav_step elif self.smenu.p1_nav_ofs == 0: self.smenu.p1_nav_ofs = ( len(self.status.game_selection_text) - 1) * self.smenu.nav_step self.smenu.update_p1( ((len(self.status.game_selection_text) - 1) * self.smenu.nav_step)) if symbol == key.S: self.player1.down = True # IN GAME MAIN MENU if self.status.game_menu: # FOR NAVIGATING DOWN IN GAME MENU if not self.status.game_running and not self.status.game_over and not self.status.game_controls and not self.status.game_about: if self.menu.nav_ofs < (len(self.status.game_menu_text) - 1) * self.menu.nav_step: self.menu.update(self.menu.nav_step) self.menu.nav_ofs += self.menu.nav_step elif self.menu.nav_ofs == (len(self.status.game_menu_text) - 1) * self.menu.nav_step: self.menu.nav_ofs = 0 self.menu.update(-( (len(self.status.game_menu_text) - 1) * self.menu.nav_step)) # IN GAME SELECTION MENU if self.status.game_selection: # FOR NAVIGATING DOWN IN SELECTION MENU if self.smenu.p1_nav_ofs < ( len(self.status.game_selection_text) - 1) * self.smenu.nav_step: self.smenu.update_p1(self.menu.nav_step) self.smenu.p1_nav_ofs += self.menu.nav_step elif self.smenu.p1_nav_ofs == ( len(self.status.game_selection_text) - 1) * self.smenu.nav_step: self.smenu.p1_nav_ofs = 0 self.smenu.update_p1(-( (len(self.status.game_selection_text) - 1) * self.smenu.nav_step)) if symbol == key.F and self.status.game_running: # TOGGLE FIRE (MANUAL/AUTO) if self.player1.fire_type == "auto": self.player1.fire_type = "manual" else: self.player1.fire_type = "auto" if symbol == key.SPACE: global p1_hp_score, p1_ship # FOR FIRING THE LASERS WHILE GAME RUNNING if self.status.game_running: if self.player1.fire_type == "auto": self.player1.fire = True else: self.player1.laser_list.append( Lasers(self.player1.pos_x + 96, self.player1.pos_y + 34, [20, 5], p1_dhp_color)) self.player1.laser_sound.play() # IN GAME SELECTION MENU if self.status.game_selection: # FOR SELECTING THE SHIP OF PLAYER 1 AND SETTING THE SELECTED SHIP STATS TO THE PLAYER OBJECT if self.smenu.p1_nav_ofs == 0: self.player1.set_stats(p1_ship1_stats) p1_ship = self.status.game_selection_text[0] elif self.smenu.p1_nav_ofs == 100: self.player1.set_stats(p1_ship2_stats) p1_ship = self.status.game_selection_text[1] elif self.smenu.p1_nav_ofs == 200: self.player1.set_stats(p1_ship3_stats) p1_ship = self.status.game_selection_text[2] # CALCULATING THE PLAYER 1 SHIP HP SCORE BASED ON SELECTED SHIP STAT p1_hp_score = p1_total_life / self.player1.damage_taken # CHECKING FOR PLAYER 2 SHIP SELECTION // IF TRUE START THE GAME self.status.player1_selected = True if self.status.player2_selected: self.status.game_started = True self.status.game_running = True self.status.game_selection = False # FOR PAUSING THE MENU MUSIC AND PLAYING THE GAME MUSIC bg_player.pause() game_player.play() # PLAYER SPECIAL FIRE if symbol == key.G and self.status.game_running: self.player1.sp_fire = True if len(self.player1.sp_laser_list) < 3: self.player1.sp_laser_list.append( Lasers(self.player1.pos_x + 96, self.player1.pos_y + 34, [50, 50], [255, 0, 0, 255] * 4)) # PLAYER 1 GAURDING if symbol == key.LSHIFT and self.status.game_running: self.player1.gaurding = True # PLAYER 2 KEY PRESS EVENTS if symbol == key.RIGHT: self.player2.right = True if symbol == key.LEFT: self.player2.left = True if symbol == key.UP: self.player2.up = True # IN GAME SELECTION MENU if self.status.game_selection: # FOR NAVIGATING UP IN SELECTION MENU if self.smenu.p2_nav_ofs > 0: self.smenu.update_p2(-self.smenu.nav_step) self.smenu.p2_nav_ofs -= self.smenu.nav_step elif self.smenu.p2_nav_ofs == 0: self.smenu.p2_nav_ofs = ( len(self.status.game_selection_text) - 1) * self.smenu.nav_step self.smenu.update_p2( ((len(self.status.game_selection_text) - 1) * self.smenu.nav_step)) if symbol == key.DOWN: self.player2.down = True # IN GAME SELECTION MENU if self.status.game_selection: # FOR NAVIGATING DOWN IN SELECTION MENU if self.smenu.p2_nav_ofs < ( len(self.status.game_selection_text) - 1) * self.smenu.nav_step: self.smenu.update_p2(self.menu.nav_step) self.smenu.p2_nav_ofs += self.menu.nav_step elif self.smenu.p2_nav_ofs == ( len(self.status.game_selection_text) - 1) * self.smenu.nav_step: self.smenu.p2_nav_ofs = 0 self.smenu.update_p2(-( (len(self.status.game_selection_text) - 1) * self.smenu.nav_step)) if symbol == key.NUM_0 and self.status.game_running: # TOGGLE FIRE (MANUAL/AUTO) if self.player2.fire_type == "auto": self.player2.fire_type = "manual" else: self.player2.fire_type = "auto" if symbol == key.P: global p2_hp_score, p2_ship # FOR FIRING THE LASERS WHILE GAME RUNNING if self.status.game_running: if self.player2.fire_type == "auto": self.player2.fire = True else: self.player2.laser_list.append( Lasers(self.player2.pos_x - 17, self.player2.pos_y + 34, [20, 5], p2_hp_color)) self.player2.laser_sound.play() # IN GAME SELECTION MENU if self.status.game_selection: # FOR SELECTING THE SHIP OF PLAYER 2 AND SETTING THE SELECTED SHIP STATS TO THE PLAYER OBJECT if self.smenu.p2_nav_ofs == 0: self.player2.set_stats(p2_ship1_stats) p2_ship = self.status.game_selection_text[0] elif self.smenu.p2_nav_ofs == 100: self.player2.set_stats(p2_ship2_stats) p2_ship = self.status.game_selection_text[1] elif self.smenu.p2_nav_ofs == 200: self.player2.set_stats(p2_ship3_stats) p2_ship = self.status.game_selection_text[2] # CALCULATING THE PLAYER 2 SHIP HP SCORE BASED ON SELECTED SHIP STAT p2_hp_score = p2_total_life / self.player2.damage_taken self.status.player2_selected = True if self.status.player1_selected: self.status.game_started = True self.status.game_running = True self.status.game_selection = False # FOR PAUSING THE MENU MUSIC AND PLAYING THE GAME MUSIC bg_player.pause() game_player.play() # PLAYER 1 GAURDING if symbol == key.RALT and self.status.game_running: self.player2.gaurding = True def on_key_release(self, symbol, modifiers): # PLAYER 1 KEY RELEASE EVENTS if symbol == key.D: self.player1.right = False if symbol == key.A: self.player1.left = False if symbol == key.W: self.player1.up = False if symbol == key.S: self.player1.down = False if symbol == key.SPACE and self.status.game_running: if self.player1.fire_type == "auto": self.player1.fire = False if symbol == key.LSHIFT and self.status.game_running: self.player1.gaurding = False if symbol == key.G and self.status.game_running: self.player1.sp_fire = False # PLAYER 1=2 KEY RELEASE EVENTS if symbol == key.RIGHT: self.player2.right = False if symbol == key.LEFT: self.player2.left = False if symbol == key.UP: self.player2.up = False if symbol == key.DOWN: self.player2.down = False if symbol == key.P: if self.player2.fire_type == "auto": self.player2.fire = False if symbol == key.RALT and self.status.game_running: self.player2.gaurding = False def on_draw(self): self.clear() # SPACE BG DRAWING for space in self.space_list: space.draw() if time.time() - self.start_time < starting_screen_timeout + 1: draw_start_page(time.time() - self.start_time, starting_screen_timeout) # GAME MENU DRAWINGS elif self.status.game_controls: self.cmenu.draw() elif self.status.game_about: self.amenu.draw() elif not self.status.game_running and not self.status.game_over and not self.status.game_selection: self.menu.draw() # SELECTION MENU DRAWINGS if self.status.game_selection: self.smenu.draw() if self.status.player1_selected: pyglet.text.Label("PLAYER 1 SELECTED " + p1_ship, font_name="Tempus Sans ITC", font_size=30, x=300, y=100, anchor_x="center", anchor_y="center", color=[200, 255, 255, 255], bold=True).draw() if self.status.player2_selected: pyglet.text.Label("PLAYER 2 SELECTED " + p2_ship, font_name="Tempus Sans ITC", font_size=30, x=1620, y=100, anchor_x="center", anchor_y="center", color=[200, 255, 255, 255], bold=True).draw() # DRAWINGS WHILE GAME IS RUNNING if self.status.game_running: # PLAYER LASER DRAWINGS for lsr in self.player1.laser_list: lsr.draw() for lsr in self.player2.laser_list: lsr.draw() # PLAYER DRAWINGS self.player1.draw(self.status.game_started) self.player2.draw(self.status.game_started) # PLAYER ENERGY SHIELD DRAWINGS if self.player1.gaurding and p1_gaurd_size[0] > 2: self.player1.draw_shield(self.player1.sprite.x - 40, self.player1.sprite.y - 40) if self.player2.gaurding and p2_gaurd_pos[0] + 1 < resolution[0]: self.player2.draw_shield(self.player2.sprite.x - 20, self.player2.sprite.y - 40) xy = draw_line(self.player1.sprite.x + self.player1.width, self.player2.sprite.x, self.player1.sprite.y + (self.player1.height / 2), self.player2.sprite.y + (self.player2.height / 2)) for splsr in self.player1.sp_laser_list: splsr.draw() # PLAYER EXPLOSION DRAWINGS for explosion in self.player1.exp_list: explosion.draw() for explosion in self.player2.exp_list: explosion.draw() # GAME OVER MENU DRAWINGS if self.status.game_over: self.menu.menu_bg.draw() pyglet.text.Label("GAME OVER", font_name="Tempus Sans ITC", font_size=resx(200), x=resolution[0] / 2, y=resy(resolution[1] / 2) + resy(400), anchor_x="center", anchor_y="center", color=[255, 255, 255, 255], bold=True).draw() pyglet.text.Label(winner + " WINS", font_name="Tempus Sans ITC", font_size=resx(100), x=resolution[0] / 2, y=(resolution[1] / 2), anchor_x="center", anchor_y="center", color=[255, 255, 255, 255], bold=True).draw() pyglet.text.Label("PRESS ENTER TO RELOAD", font_name="Tempus Sans ITC", font_size=resx(30), x=resolution[0] / 2, y=(resolution[1] / 2) - resy(500), anchor_x="center", anchor_y="center", color=[255, 255, 255, 255], bold=True).draw() # FPS LABEL DRAWING self.fps_display.draw() def update(self, dt): # UPDATE SPACE BG self.update_space(dt) # UPADTE DRAWINGS WHILE GAME IS RUNNING if self.status.game_running and not self.status.game_paused: self.update_player(self.player1, p1_base, dt) self.update_player(self.player2, p2_base, dt) self.player_auto_fire(dt) self.update_player_laser(dt) self.update_explosion(self.player1) self.update_explosion(self.player2) self.update_special_laser() def update_space(self, dt): # FOR SCROLLING SPACE BG for space in self.space_list: space.update(dt) # CHECKING IF THE IMAGE HAS REACHED ITS END BY SCROLLING // IF TRUE THEN REMOVE THE IMAGE FROM THE LIST AND ADD NEW IMAGE ON TOP OF PREVIOUS if space.pos_y <= -1080: self.space_list.remove(space) self.space_list.append( DisplayObjects(0, 1080, Sprite(self.space_img))) space.vel_y = -space_scroll_speed def update_player(self, player, player_base, dt): # PLAYER MOVEMENTS INSIDE PLAYER BASE if player.right and player.pos_x < player_base[1] - player.width: player.pos_x += player.speed * dt if player.left and player.pos_x > player_base[0]: player.pos_x -= player.speed * dt if player.up and player.pos_y < resolution[1] - player.height - 150: player.pos_y += player.speed * dt if player.down and player.pos_y > 0: player.pos_y -= player.speed * dt # PLAYER HP CHECKING AND UPDATING self.player1.hp.update(p1_hp_pos, p1_hp_size) self.player2.hp.update(p2_hp_pos, p2_hp_size) # PLAYER GAURD UPDATING self.update_gaurd() # PLAYER DAMAGE HP UPDATING self.update_dhp() # UPDATING PLAYER MOVEMENTS player.update(dt) def player_auto_fire(self, dt): # ADDING LASERS TO THE LASER LIST IIF THE FIRE TYPE IS AUTO if self.player1.fire and self.player1.fire_type == "auto": self.player1.fire_rate -= dt if self.player1.fire_rate <= 0: self.player1.laser_list.append( Lasers(self.player1.pos_x + 96, self.player1.pos_y + 34, [20, 5], p1_dhp_color)) self.player1.laser_sound.play() self.player1.fire_rate += 1 - p1_fire_rate if self.player2.fire and self.player2.fire_type == "auto": self.player2.fire_rate -= dt if self.player2.fire_rate <= 0: self.player2.laser_list.append( Lasers(self.player2.pos_x - 17, self.player2.pos_y + 34, [20, 5], p2_hp_color)) self.player2.laser_sound.play() self.player2.fire_rate += 1 - p2_fire_rate def update_player_laser(self, dt): global p2_hp_score, p1_hp_score sp = 15 # UPDATING LASER POSITIONS OF PLAYER 1 for lsr in self.player1.laser_list: lsr.update() lsr.pos_x += self.player1.laser_speed * dt if lsr.pos_x > lsr.initial_pos_x + self.player1.laser_range: self.player1.laser_list.remove(lsr) elif self.player2.pos_x + self.player2.width > lsr.pos_x + lsr.size[ 0] > self.player2.pos_x + sp: if self.player2.pos_y < lsr.pos_y + lsr.size[ 1] and lsr.pos_y < self.player2.pos_y + self.player2.height: if not self.player2.gaurding or ( self.player2.gaurding and p2_gaurd_pos[0] >= resolution[0]): self.player1.laser_list.remove(lsr) p2_hp_pos[0] += self.player2.damage_taken self.check_game_status() self.player1.exp_list.append( SpriteAnimation( explosion_img, [4, 5], [480, 384], 0.1, [lsr.pos_x + lsr.size[0] - 48, lsr.pos_y - 48 ]).get_sprite()) self.player1.exp_timer.append(explosion_time) exp_sound.play() # UPDATING LASER POSITIONS OF PLAYER 2 for lsr in self.player2.laser_list: lsr.update() lsr.pos_x -= self.player2.laser_speed * dt if lsr.pos_x < lsr.initial_pos_x - self.player2.laser_range: self.player2.laser_list.remove(lsr) elif self.player1.pos_x < lsr.pos_x < self.player1.pos_x + self.player1.width - sp: if self.player1.pos_y < lsr.pos_y < self.player1.pos_y + self.player1.height: if not self.player1.gaurding or (self.player1.gaurding and p1_gaurd_size[0] <= 0): self.player2.laser_list.remove(lsr) p1_hp_size[0] -= self.player1.damage_taken self.check_game_status() self.player2.exp_list.append( SpriteAnimation( explosion_img, [4, 5], [480, 384], 0.1, [lsr.pos_x + lsr.size[0] - 48, lsr.pos_y - 48 ]).get_sprite()) self.player2.exp_timer.append(explosion_time) exp_sound.play() def update_explosion(self, player): exploded = False for i in range(len(player.exp_timer)): player.exp_timer[i] -= 1 if player.exp_timer[i] <= 0: exploded = True if exploded: player.exp_list.pop(0) player.exp_timer.pop(0) def update_gaurd(self): global p1_gaurd_size, p2_gaurd_size # UPADTING GAURD self.player1.gaurd.update(p1_gaurd_pos, p1_gaurd_size) self.player2.gaurd.update(p2_gaurd_pos, p2_gaurd_size) # CHECKING IF PLAYER IS GUARDING // IF TRUE DEPLETE THE GAURD QUAD // ELSE REPLENISH THE GAURD QUAD if self.player1.gaurding and p1_gaurd_size[0] > 0: p1_gaurd_size[0] -= p1_guard_consumption_rate elif p1_gaurd_size[0] < p1_total_gaurd: p1_gaurd_size[0] += self.player1.gaurd_regen_rate if self.player2.gaurding and p2_gaurd_pos[0] < resolution[0]: p2_gaurd_pos[0] += p2_guard_consumption_rate elif p2_gaurd_pos[0] > resolution[0] - p2_total_gaurd: p2_gaurd_pos[0] -= self.player2.gaurd_regen_rate def check_game_status(self): global winner, explosion_time # CHECKING IF ANY PLAYER HAS WON THE GAME if p1_hp_size[0] <= 0: self.status.game_running = False self.status.game_over = True winner = "PLAYER 2" self.player1.lost = True explosion_time = 25 if p2_hp_pos[0] >= resolution[0]: self.status.game_running = False self.status.game_over = True winner = "PLAYER 1" self.player2.lost = True explosion_time = 25 def reload(self): global winner, p1_hp_pos, p1_total_life, p1_hp_size, p1_hp_score, p2_hp_pos, \ p2_hp_size, p2_total_life, p2_hp_score, explosion_time, p1_gaurd_size, p2_gaurd_pos, p1_dhp_pos, p1_dhp_size, p2_dhp_pos, p2_dhp_size # GAME DETAILS winner = None # PLAYER 1 DETAILS p1_total_life = resx(550) p1_hp_pos = [0, resy(1000)] p1_hp_size = [p1_total_life, resy(20)] p1_hp_score = 0 p1_gaurd_size = [p1_total_gaurd, resy(20)] p1_dhp_pos = p1_hp_pos.copy() p1_dhp_size = p1_hp_size.copy() # PLAYER 2 DETAILS p2_total_life = resx(550) p2_hp_pos = [resolution[0] - p2_total_life, resy(1000)] p2_hp_size = [p2_total_life, resy(20)] p2_hp_score = 0 p2_gaurd_pos = [resolution[0] - p2_total_gaurd, resy(970)] p2_dhp_pos = p2_hp_pos.copy() p2_dhp_size = p2_hp_size.copy() # OTHER DETAILS explosion_time = 15 # in ms self.status = GameStatus() self.menu = GameMenu(resolution, self.status.game_menu_text) self.smenu = SelectionMenu(resolution, self.status.game_selection_text) # PLAYER INITIALIZATIONS self.player1 = DisplayPlayers(p1_pos_x, p1_pos_y, p1_fire_type) self.player2 = DisplayPlayers(p2_pos_x, p2_pos_y, p2_fire_type) # self.player1.laser_sound.play() self.player1.hp = Quad(p1_hp_pos, p1_hp_size, p1_hp_color, 'p1') self.player2.hp = Quad(p2_hp_pos, p2_hp_size, p2_hp_color, 'p2') self.player1.dhp = Quad(p1_dhp_pos, p1_dhp_size, p1_dhp_color, 'p1') self.player2.dhp = Quad(p2_dhp_pos, p2_dhp_size, p2_dhp_color, 'p2') self.player1.gaurd = Quad(p1_gaurd_pos, p1_gaurd_size, p1_gaurd_color, 'p1') self.player2.gaurd = Quad(p2_gaurd_pos, p2_gaurd_size, p2_gaurd_color, 'p2') self.menu = GameMenu(resolution, self.status.game_menu_text) def update_dhp(self): global p1_dhp_size, p2_dhp_pos self.player1.dhp.update(p1_dhp_pos, p1_dhp_size) self.player2.dhp.update(p2_dhp_pos, p2_dhp_size) if p1_hp_size[0] < p1_dhp_size[0]: p1_dhp_size[0] -= 1.5 if p2_hp_pos[0] > p2_dhp_pos[0]: p2_dhp_pos[0] += 1.5 def track_enemy(self, obj, dest_pos, speed=5): x = dest_pos[0] - obj.pos_x y = dest_pos[1] - obj.pos_y hyp = sqrt((x * x) + (y * y)) if hyp != 0: x /= hyp y /= hyp obj.pos_x += x * speed obj.pos_y += y * speed obj.update() def update_special_laser(self): global p2_hp_score, p1_hp_score for splsr in self.player1.sp_laser_list: self.track_enemy(splsr, [self.player2.sprite.x, self.player2.sprite.y]) if self.player2.pos_x + self.player2.width > splsr.pos_x + splsr.size[ 0] > self.player2.pos_x: if self.player2.pos_y < splsr.pos_y + splsr.size[ 1] and splsr.pos_y < self.player2.pos_y + self.player2.height: if not self.player2.gaurding or ( self.player2.gaurding and p2_gaurd_pos[0] >= resolution[0]): self.player1.sp_laser_list.remove(splsr) p2_hp_pos[0] += self.player2.sp_damage_taken self.check_game_status() self.player1.exp_list.append( SpriteAnimation( explosion_img, [4, 5], [480, 384], 0.1, [ splsr.pos_x + splsr.size[0] - 48, splsr.pos_y - 48 ]).get_sprite()) self.player1.exp_timer.append(explosion_time) exp_sound.play() else: self.player1.sp_laser_list.remove(splsr)