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()
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)
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)
def tutorialButtonPushed(self):
self.disableChoiceButtons()
self.gameMenu = GameMenu(self.tutorialFunction,
GameGlobals.TutorialMenu)
return
