def cutScene(self): self.destroyLevel() self.stopAllSounds() self.cut = OnscreenImage("GUI/bossKilled.png",scale = Vec3(1.6, 0, 1.0),pos = Vec3(0, 0,0)) self.cut.reparentTo(aspect2d) self.cut.setTransparency(1) transition = Transitions(loader) transition.setFadeColor(0, 0, 0) self.cheer.play() if(self.currentLevel=="rainforest"): Sequence(Wait(2.0),Func(transition.fadeOut),Wait(1.0),Func(transition.fadeIn),Func(self.cut.setImage,"GUI/map_11.png"), Wait(1.5),Func(self.cut.setImage, "GUI/map_12.png"),Wait(0.5),Func(self.cut.setImage,"GUI/map_13.png"), Wait(0.5),Func(self.cut.setImage,"GUI/map_14.png"),Wait(0.5),Func(self.cut.setImage,"GUI/map_15.png"), Wait(0.5),Func(self.cut.setImage,"GUI/map_16.png"),Wait(3.5),Func(self.cut.destroy), Func(transition.fadeOut), Func(self.loadingScreen), Wait(1.0),Func(transition.fadeIn)).start() elif(self.currentLevel=="africa"): Sequence(Wait(2.0),Func(transition.fadeOut),Wait(1.0),Func(transition.fadeIn),Func(self.cut.setImage,"GUI/map_21.png"), Wait(1.5),Func(self.cut.setImage, "GUI/map_22.png"),Wait(0.5),Func(self.cut.setImage,"GUI/map_23.png"), Wait(0.5),Func(self.cut.setImage,"GUI/map_24.png"),Wait(0.5),Func(self.cut.setImage,"GUI/map_25.png"), Wait(0.5),Func(self.cut.setImage,"GUI/map_26.png"), Wait(3.5),Func(self.cut.destroy), Func(transition.fadeOut),Func(self.loadingScreen), Wait(1.0),Func(transition.fadeIn)).start() elif(self.currentLevel=="asia"): Sequence(Wait(2.0),Func(transition.fadeOut),Wait(1.0),Func(transition.fadeIn),Func(self.cut.setImage,"GUI/map_31.png"), Wait(1.5),Func(self.cut.setImage, "GUI/map_32.png"),Wait(0.5),Func(self.cut.setImage,"GUI/map_33.png"), Wait(0.5),Func(self.cut.setImage,"GUI/map_34.png"),Wait(0.5),Func(self.cut.setImage,"GUI/map_35.png"), Wait(0.5),Func(self.cut.setImage,"GUI/map_36.png"),Wait(3.5),Func(self.cut.destroy), Func(transition.fadeOut),Func(self.loadingScreen), Wait(1.0),Func(transition.fadeIn)).start() elif(self.currentLevel=="newyork"): Sequence(Wait(2.0),Func(transition.fadeOut),Wait(1.0),Func(transition.fadeIn),Func(self.cut.setImage,"GUI/win.png"), Wait(6.5),Func(self.cut.destroy), Func(transition.fadeOut),Func(self.loadingScreen), Wait(1.0),Func(transition.fadeIn)).start()
def alienDie(self, currLvl): self.alien.stop() self.pause=True temp = NodePath(PandaNode("temp")) base.camera.reparentTo(self.floater) base.camera.setZ(base.camera.getZ()+1) base.camera.setY(base.camera.getY()-25) self.deadSound.play() fall = LerpHprInterval(nodePath=self.alien, duration=1.5, hpr=(self.alien.getH(),self.alien.getP(), self.alien.getR()-80)) fall.start() taskMgr.remove("moveTask") taskMgr.remove("laterFc") transition = Transitions(loader) transition.setFadeColor(0, 0, 0) self.dieImage = OnscreenImage("GUI/died.png",scale = Vec3(0.7, 0, 0.2),pos = Vec3(0, 0,-0.5)) self.dieImage.reparentTo(aspect2d) self.dieImage.setTransparency(1) if(self.currentLevel == "rainforest"): Sequence(Wait(2.0),Func(transition.fadeOut),Wait(2.0),Func(self.destroyLevel),Func(self.loadRainforestLevel),Func(self.dieImage.destroy),Func(transition.fadeIn)).start() elif(self.currentLevel == "africa"): Sequence(Wait(2.0),Func(transition.fadeOut),Wait(2.0),Func(self.destroyLevel),Func(self.loadAfricaLevel),Func(self.dieImage.destroy),Func(transition.fadeIn)).start() elif(self.currentLevel == "asia"): Sequence(Wait(2.0),Func(transition.fadeOut),Wait(2.0),Func(self.destroyLevel),Func(self.loadAsiaLevel),Func(self.dieImage.destroy),Func(transition.fadeIn)).start() elif(self.currentLevel == "newyork"): Sequence(Wait(2.0),Func(transition.fadeOut),Wait(2.0),Func(self.destroyLevel),Func(self.loadNewYorkLevel),Func(self.dieImage.destroy),Func(transition.fadeIn)).start()
def __init__(self): ShowBase.__init__(self) self.disableMouse() props = WindowProperties() props.setTitle('Test') self.win.requestProperties(props) # self.render.setAntiAlias(AntialiasAttrib.MAuto) self.transitions = Transitions(self.loader) self.transitions.setFadeColor(0, 0, 0) self.filters = CommonFilters(self.win, self.cam) # self.filters.setCartoonInk() self.filters.setBlurSharpen(1) # self.filters.setVolumetricLighting(self.render) # self.buffer = self.win.makeTextureBuffer("Post-processing buffer", self.win.getXSize(), self.win.getXSize()) # print self.buffer.getYSize() # self.texture = self.buffer.getTexture() # self.buffer.setSort(-100) # # self.originalCamera = self.camera # self.offScreenCamera = self.makeCamera(self.buffer) # self.camera = self.offScreenCamera # # self.img = OnscreenImage(image=self.texture, pos=(0, 0, 0.5)) self.scene = None self.channel = Channel()
def __init__(self, filename): FSM.__init__(self, 'Game') self.savedGame = PlayerFileParser("save.xml") self.playerData = self.savedGame.playerData self.playerData.setShip(shipDb[self.playerData.ship.name]) self.crosshair = MouseCursor() self.crosshair.setMode(1) self.mainMenu = MainMenu() self.mainMenu.hide() self.mainMenu.buttons[0]["command"] = self.request self.mainMenu.buttons[0]["extraArgs"] = ["Space"] self.mainMenu.buttons[1]["command"] = self.request self.mainMenu.buttons[1]["extraArgs"] = ["Ground"] self.mainMenu.buttons[3]["command"] = self.quit self.mainMenu.buttons[3]["extraArgs"] = [0] #self.groundGui = GroundGui(self.playerData) #self.groundWorldManager = GroundManager(self) #self.spaceWorldManager = SpaceOdeWorldManager(self) self.prevState = None self.trans = Transitions(loader) self.request("IntroMainMenu")
def __init__(self, stage, characters, player, player2): State.__init__(self) # how to know the players that will be in game? a ChoosePlayer screen before the constructor? self.characters = characters self.player = player self.player2 = player2 self.stage = stage self.room = self.stage.start self.isOver = False self.players = [] #print(self.players) self.startMap() self.status = {} posi = 0 for c in self.characters: # initialize character status string self.status[c] = (OnscreenText(mayChange= True , style=2, fg=(1,1,1,1), pos=(1.4*posi - 0.8,-0.83), scale = .07) ) posi += 1 self.transitions = Transitions(GameLoader.loader) self.clock = ClockObject() self.lastTime = 0 GameLoader.music.addSfx('barrel_breaks') GameLoader.music.addSfx('stone','aif')
def goToBoss(self): self.transition = Transitions(loader) self.transition.setFadeColor(0, 0, 0) self.fadeOut = self.transition.fadeOut(2) self.unload(self.levelMap[1]) self.load(self.levelMap[4]) self.currentLevel = 4
def __init__(self): self.trans = Transitions(loader) self.scene = render.getPythonTag('SceneManager').createScene('Make-A-Toon') self.setupEnvironment() self.randomizeData() self.setupHUD() self.bgm = SoundBank.getSound('make_a_toon') self.bgm.setLoop(True) self.bgm.play()
def loadingScreen(self): self.intro.play() transition = Transitions(loader) transition.setFadeColor(0, 0, 0) text = TextNode('node name') dummy = NodePath(PandaNode("dummy")) black = OnscreenImage(image="GUI/black.png",pos=(0,0,0), scale=100) black.reparentTo(dummy) textNodePath = aspect2d.attachNewNode(text) textNodePath.reparentTo(aspect2d, 2) textNodePath.setScale(0.07) text.setTextColor(1, 1, 1, 1) if(self.currentLevel=="newyork"): Sequence(Func(transition.fadeOut),Func(black.reparentTo, aspect2d),Func(transition.fadeIn),Func(textNodePath.reparentTo,aspect2d, 10),Func(text.setText, "loading"),Wait(1.0),Func(text.setText, "loading."), Wait(1.0),Func(text.setText, "loading.."), Wait(1.0), Func(text.setText, "loading..."), Func(self.loadNextLevel),Wait(3.0),Func(transition.fadeIn),Func(textNodePath.remove), Func(black.destroy)).start() elif(self.currentLevel=="asia"): Sequence(Func(transition.fadeOut),Func(black.reparentTo, aspect2d),Func(transition.fadeIn),Func(textNodePath.reparentTo,aspect2d, 10),Func(text.setText, "loading"),Wait(1.0),Func(text.setText, "loading."), Wait(1.0),Func(text.setText, "loading.."), Wait(1.0), Func(text.setText, "loading..."), Func(self.loadNextLevel),Wait(3.0),Func(transition.fadeIn),Func(textNodePath.remove), Func(black.destroy)).start() else: Sequence(Func(transition.fadeOut),Func(black.reparentTo, aspect2d),Func(transition.fadeIn),Func(textNodePath.reparentTo,aspect2d, 10),Func(text.setText, "loading"),Wait(0.5),Func(text.setText, "loading."), Wait(0.5),Func(text.setText, "loading.."), Wait(0.5), Func(text.setText, "loading..."), Func(self.loadNextLevel),Wait(1.5),Func(transition.fadeIn),Func(textNodePath.remove), Func(black.destroy)).start()
def __init__(self): self.notify = DirectNotifyGlobal.directNotify.newCategory("Starting Make A Toon.") self.localAvatar = LocalAvatar.toonBody base.localAvatar = self.localAvatar self.toonColors = Localizer.toonColorDict self.colorNum = randint(0, Localizer.numColors) self.numColors = Localizer.numColors self.goRight() self.MakeAToonText = Localizer.MakeAToonText self.Mickey = Localizer.Mickey self.transition = Transitions(loader) self.transition.irisIn(1) self.transition.fadeIn(5) self.load()
def changeLevel(self, task): if(self.levelComplete == True): self.transition = Transitions(loader) self.transition.setFadeColor(0, 0, 0) self.fadeOut = self.transition.fadeOut(2) #unload the current level and models self.unload(self.levelMap[self.currentLevel]) #load the next level and models self.load(self.levelMap[self.currentLevel + 1]) #self.fadeIn = self.transition.fadeIn(5) base.taskMgr.remove(task) return task.cont
def __init__(self): self.notify = DirectNotifyGlobal.directNotify.newCategory("Starting Make A Toon.") self.localAvatar = LocalAvatar.toonBody base.localAvatar = self.localAvatar self.toonColors = Localizer.toonColorDict self.colorNum = 0 self.numColors = Localizer.numColors self.MakeAToonText = Localizer.MakeAToonText self.Mickey = Localizer.Mickey self.mickeyFont = loader.loadFont('phase_3/models/fonts/MickeyFont.bam') self.Text = OnscreenText(text = "Make A Toon", pos = (0, 0.75), font = self.mickeyFont, fg = (1, 0, 0, 1),scale=(0.2, 0.2, 0.2)) self.gui = loader.loadModel('phase_3/models/gui/tt_m_gui_mat_mainGui.bam') self.gui.flattenMedium() self.gui1 = loader.loadModel('phase_3/models/gui/create_a_toon_gui.bam') self.gui2 = loader.loadModel('phase_3/models/gui/gui_toongen.bam') self.guiNextUp = self.gui.find('**/tt_t_gui_mat_nextUp') self.transition = Transitions(loader) self.transition.irisIn(1) self.transition.fadeIn(5) self.load()
def __init__(self, parent): #Turn off default mouse control base.disableMouse() base.setFrameRateMeter(True) #globalClock = ClockObject.getGlobalClock() #globalClock.setMode(ClockObject.MLimited) #globalClock.setFrameRate(1000) #Set windows properties self.props = WindowProperties() self.props.setCursorHidden(True) #props.setFullscreen(1) #props.setSize(int(base.pipe.getDisplayWidth()), int(base.pipe.getDisplayHeight())) self.props.setMouseMode(WindowProperties.MRelative) base.win.requestProperties(self.props) self.transition = Transitions(loader) self.transition.setFadeColor(0,0,0) self.parent = parent base.accept("escape", self.togglePause) self.setupSounds() self.startLevel(0, True) self.task = taskMgr.add(self.update, "updateTask")
class SMWorld(DirectObject): #------------------------------------------------------------------------------------------------------------------------------------------------------------ # Constructor # (Game state, Map name, Height of death plane) #------------------------------------------------------------------------------------------------------------------------------------------------------------ def __init__(self, mapID, tObj, aObj): self.mapID = mapID # EX: maps/map-1/map-1.yetimap metaFile = open("../maps/map" + str(self.mapID) + "/map" + str(self.mapID) + ".yetimap", 'r') metaLines = metaFile.readlines() lineCount = len(metaLines) self.snowflakeCount = lineCount - 2 self.snowCount = 0 # First Line: Player's starting position # EX: 50,50,50 (NO SPACES) playerLine = metaLines[0] playerPosList = playerLine.split(",") playerInitX = int(playerPosList[0]) playerInitY = int(playerPosList[1]) playerInitZ = int(playerPosList[2]) self.playerStart = Point3(playerInitX, playerInitY, playerInitZ) # 2nd Line: Deathzone Height # ONE INTEGER self.deathHeight = int(metaLines[1]) # Get dem snowflakes self.snowflakePositions = [] print("Snowflake Count: " + str(self.snowflakeCount)) for i in xrange(0, self.snowflakeCount): sfline = metaLines[i+2] sfList = sfline.split(",") sfx = int(sfList[0]) sfy = int(sfList[1]) sfz = int(sfList[2]) self.snowflakePositions.append(Point3(sfx, sfy, sfz)) print("New snowflake to add: (" + str(sfx) + "," + str(sfy) + "," + str(sfz) + ")") #load in controls ctrlFl = open("ctrConfig.txt") #will skip n lines where [n,] #makes a list of controls self.keymap = eval(ctrlFl.read()) #close file ctrlFl.close() # Create new instances of our various objects self.mapName = str(mapID) self.audioMgr = aObj self.worldObj = self.setupWorld() self.heightMap = self.setupHeightmap(self.mapName) self.deathZone = self.setupDeathzone(self.deathHeight) self.debugNode = self.setupDebug() # Player Init self.playerObj = SMPlayer(self.worldBullet, self.worldObj, self, self.playerStart, self.audioMgr) self.playerNP = self.playerObj.getNodePath() self.playerNP.setH(180); self.canUseShift = True self.canAirDash = True # Snowball Init self.ballObj = SMBall(self.worldBullet, self.worldObj, self.playerObj, self.playerNP) self.sbCollideFlag = False self.ballNP = self.ballObj.getNodePath() # Key Handler self.kh = SMKeyHandler() self.lastMousePos = self.kh.getMouse() # Collision Handler self.colObj = self.setupCollisionHandler() # Lighting self.ligObj = SMLighting(Vec4(.4, .4, .4, 1), Vec3(-5, -5, -5), Vec4(2.0, 2.0, 2.0, 1.0)) # Camera self.camObj = SMCamera(self.playerObj, self.worldBullet, self.worldObj) self.cameraControl = False # GUI self.GUI = SMGUI() self.snowflakeCounter = SMGUICounter("snowflake", self.snowflakeCount) # Replace 3 with # of snowflakes in level. self.snowMeter = SMGUIMeter(100) self.GUI.addElement("snowflake", self.snowflakeCounter) self.GUI.addElement("snowMeter", self.snowMeter) #Snowy Outside # base.enableParticles() # self.p = ParticleEffect() # self.p.cleanup() # self.p = ParticleEffect() # self.p.loadConfig('snow.ptf') # self.p.start(self.camObj.getNodePath()) # self.p.setPos(0.00, 0.500, 0.000) # AI # self.goat1 = SMAI("../res/models/goat.egg", 75.0, self.worldBullet, self.worldObj, -70, -95, 5) # self.goat1.setBehavior("flee", self.playerNP) # self.goat2 = SMAI("../res/models/goat.egg", 75.0, self.worldBullet, self.worldObj, -80, -83, 5) # self.goat2.setBehavior("flee", self.playerNP) # print("AI Initialized") # Debug Text self.textObj = tObj self.textObj.addText("yetiPos", "Position: ") self.textObj.addText("yetiVel", "Velocity: ") self.textObj.addText("yetiFric", "Friction: ") self.textObj.addText("onIce", "Ice(%): ") self.textObj.addText("onSnow", "Snow(%): ") self.textObj.addText("terrHeight", "T Height: ") self.textObj.addText("terrSteepness", "Steepness: ") # Pause screen transition self.transition = Transitions(loader) # Method-based keybindings # self.accept('b', self.spawnBall) self.accept('escape', base.userExit) self.accept('enter', self.pauseUnpause) self.accept('f1', self.toggleDebug) self.accept('lshift-up', self.enableShiftActions) self.accept('mouse1', self.enableCameraControl) self.accept('mouse1-up', self.disableCameraControl) self.accept('wheel_up', self.camObj.zoomIn) self.accept('wheel_down', self.camObj.zoomOut) self.pauseUnpause() # Disable the mouse base.disableMouse() props = WindowProperties() props.setCursorHidden(True) base.win.requestProperties(props) # Uncomment this to see everything being rendered. self.printSceneGraph() # Play the BGM self.audioMgr.playBGM("snowmanWind") # Skybox formed skybox = loader.loadModel("../res/models/skybox.egg") # skybox.set_two_sided(true) skybox.setScale(500) skybox.setPos(0, 0, -450) skybox.reparentTo(render) mountain = loader.loadModel("../res/models/mountain.egg") mountain.reparentTo(render) mountain.setPos(650,800,20) mountain.setScale(120) self.colObjects = [] self.caveNew = SMCollide("../res/models/cave_new.egg", self.worldBullet, self.worldObj, Point3(-50, 95, -13), 11, Vec3(0,0,0)) self.colObjects.append(self.caveNew) self.planeFront = SMCollide("../res/models/plane_front", self.worldBullet, self.worldObj, Point3(190, -100, -15), 8, Vec3(190,0,30)) self.colObjects.append(self.planeFront) self.caveModel = SMCollide("../res/models/cave_tunnel.egg", self.worldBullet, self.worldObj, Point3(233, 68, 32), 4, Vec3(135,180,0)) self.colObjects.append(self.caveModel) self.planeTail = SMCollide("../res/models/plane_tail.egg", self.worldBullet, self.worldObj, Point3(-40, -130, -7), 10, Vec3(230,0,0)) self.colObjects.append(self.planeTail) self.ropeBridge = SMCollide("../res/models/rope_bridge.egg", self.worldBullet, self.worldObj, Point3(180, 115, 30), 6, Vec3(50,0,0)) self.colObjects.append(self.ropeBridge) self.colObjectCount = len(self.colObjects) print("World initialized.") #------------------------------------------------------------------------------------------------------------------------------------------------------------ # Enables the camera to be rotated by moving the mouse horizontally. #------------------------------------------------------------------------------------------------------------------------------------------------------------ def enableCameraControl(self): self.cameraControl = True #------------------------------------------------------------------------------------------------------------------------------------------------------------ # Disables the camera control. #------------------------------------------------------------------------------------------------------------------------------------------------------------ def disableCameraControl(self): self.cameraControl = False #------------------------------------------------------------------------------------------------------------------------------------------------------------ # Enables the use of shift actions again. #------------------------------------------------------------------------------------------------------------------------------------------------------------ def enableShiftActions(self): self.canUseShift = True def disableShiftActions(self): self.canUseShift = False #------------------------------------------------------------------------------------------------------------------------------------------------------------ # Respawns the yeti's snowball. #------------------------------------------------------------------------------------------------------------------------------------------------------------ def spawnBall(self): if(not(self.playerObj.getAirborneFlag())): self.ballObj.respawn() #------------------------------------------------------------------------------------------------------------------------------------------------------------ # Toggles the pause screen #------------------------------------------------------------------------------------------------------------------------------------------------------------ def pauseUnpause(self): if taskMgr.hasTaskNamed('UpdateTask'): taskMgr.remove('UpdateTask') self.transition.fadeScreen(0.5) else: taskMgr.add(self.update, 'UpdateTask') self.transition.noFade() #------------------------------------------------------------------------------------------------------------------------------------------------------------ # Sets up the world and returns a NodePath of the BulletWorld #------------------------------------------------------------------------------------------------------------------------------------------------------------ def setupWorld(self): self.worldBullet = BulletWorld() self.worldBullet.setGravity(Vec3(0, 0, -GRAVITY)) self.terrSteepness = -1 wNP = render.attachNewNode('WorldNode') self.audioMgr.loadSFX("snowCrunch01") self.audioMgr.loadBGM("snowmanWind") return wNP #------------------------------------------------------------------------------------------------------------------------------------------------------------ # Prints all nodes that are a child of render. #------------------------------------------------------------------------------------------------------------------------------------------------------------ def printSceneGraph(self): print(render.ls()) #------------------------------------------------------------------------------------------------------------------------------------------------------------ # Initializes and returns a DebugNode NodePath. #------------------------------------------------------------------------------------------------------------------------------------------------------------ def setupDebug(self): debug = BulletDebugNode() debug.showWireframe(False) # Yeah, don't set this to true unless you want to emulate an 80's computer running Crysis on Ultra settings. debug.showConstraints(True) debug.showBoundingBoxes(True) # This is the main use I have for it. debug.showNormals(True) debugNP = render.attachNewNode(debug) self.worldBullet.setDebugNode(debugNP.node()) debugNP.hide() return debugNP #------------------------------------------------------------------------------------------------------------------------------------------------------------ # Initializes and returns a BulletRigidBodyNode of the terrain, which loads the map with the specified name. #------------------------------------------------------------------------------------------------------------------------------------------------------------ def setupHeightmap(self, name): # Automatically generate a heightmap mesh from a monochrome image. self.hmHeight = 120 hmPath = "../maps/map" + name + "/map" + name + "-h.png" imPath = "../maps/map" + name + "/map" + name + "-i.png" smPath = "../maps/map" + name + "/map" + name + "-s.png" scmPath = "../maps/map" + name + "/map" + name + "-sc.png" print(hmPath) print(imPath) print(smPath) print(scmPath) hmImg = PNMImage(Filename(hmPath)) hmShape = BulletHeightfieldShape(hmImg, self.hmHeight, ZUp) hmNode = BulletRigidBodyNode('Terrain') hmNode.addShape(hmShape) hmNode.setMass(0) self.hmNP = render.attachNewNode(hmNode) self.worldBullet.attachRigidBody(hmNode) self.hmOffset = hmImg.getXSize() / 2.0 - 0.5 self.hmTerrain = GeoMipTerrain('gmTerrain') self.hmTerrain.setHeightfield(hmImg) # Optimizations and fixes self.hmTerrain.setBruteforce(True) # I don't think this is actually needed. self.hmTerrain.setMinLevel(3) # THIS is what triangulates the terrain. self.hmTerrain.setBlockSize(128) # This does a pretty good job of raising FPS. # Level-of-detail (not yet working) # self.hmTerrain.setNear(40) # self.hmTerrain.setFar(200) self.hmTerrain.generate() self.hmTerrainNP = self.hmTerrain.getRoot() self.hmTerrainNP.setSz(self.hmHeight) self.hmTerrainNP.setPos(-self.hmOffset, -self.hmOffset, -self.hmHeight / 2.0) self.hmTerrainNP.flattenStrong() # This only reduces the number of nodes; nothing to do with polys. self.hmTerrainNP.analyze() # Here begins the scenery mapping treeModel = loader.loadModel("../res/models/tree_1.egg") rockModel = loader.loadModel("../res/models/rock_1.egg") rock2Model = loader.loadModel("../res/models/rock_2.egg") rock3Model = loader.loadModel("../res/models/rock_3.egg") # caveModel = loader.loadModel("../res/models/cave_new.egg") # planeFrontModel = loader.loadModel("../res/models/plane_front.egg") # planeWingModel = loader.loadModel("../res/models/plane_wing.egg") texpk = loader.loadTexture(scmPath).peek() # GameObject nodepath for flattening self.objNP = render.attachNewNode("gameObjects") self.treeNP = self.objNP.attachNewNode("goTrees") self.rockNP = self.objNP.attachNewNode("goRocks") self.rock2NP = self.objNP.attachNewNode("goRocks2") self.rock3NP = self.objNP.attachNewNode("goRocks3") # self.caveNP = self.objNP.attachNewNode("goCave") # self.planeFrontNP = self.objNP.attachNewNode("goPlaneFront") # self.planeWingNP = self.objNP.attachNewNode("goPlaneWing") for i in range(0, texpk.getXSize()): for j in range(0, texpk.getYSize()): color = VBase4(0, 0, 0, 0) texpk.lookup(color, float(i) / texpk.getXSize(), float(j) / texpk.getYSize()) if(int(color.getX() * 255.0) == 255.0): newTree = self.treeNP.attachNewNode("treeNode") treeModel.instanceTo(newTree) newTree.setPos(i - texpk.getXSize() / 2, j - texpk.getYSize() / 2, self.hmTerrain.get_elevation(i, j) * self.hmHeight - self.hmHeight / 2) # newTree.setScale(randint(0,4)) newTree.setScale(2) if(int(color.getX() * 255.0) == 128): newRock = self.rockNP.attachNewNode("newRock") newRock.setPos(i - texpk.getXSize() / 2, j - texpk.getYSize() / 2, self.hmTerrain.get_elevation(i, j) * self.hmHeight - self.hmHeight / 2) rockModel.instanceTo(newRock) if(int(color.getX() * 255.0) == 77): newRock2 = self.rock2NP.attachNewNode("newRock2") newRock2.setPos(i - texpk.getXSize() / 2, j - texpk.getYSize() / 2, self.hmTerrain.get_elevation(i, j) * self.hmHeight - self.hmHeight / 2) rock2Model.instanceTo(newRock2) if(int(color.getX() * 255.0) == 102): newRock3 = self.rock3NP.attachNewNode("newRock3") newRock3.setPos(i - texpk.getXSize() / 2, j - texpk.getYSize() / 2, self.hmTerrain.get_elevation(i, j) * self.hmHeight - self.hmHeight / 2) rock3Model.instanceTo(newRock3) # if(int(color.getX() * 255.0) == 64): # newCave = self.caveNP.attachNewNode("newCave") # newCave.setPos(i - texpk.getXSize() / 2, j - texpk.getYSize() / 2, self.hmTerrain.get_elevation(i, j) * self.hmHeight - self.hmHeight / 2) # newCave.setScale(5) # newCave.setP(180) # caveModel.instanceTo(newCave) # if(int(color.getX() * 255.0) == 191): # newPlaneFront = self.planeFrontNP.attachNewNode("newPlaneFront") # newPlaneFront.setPos(i - texpk.getXSize() / 2, j - texpk.getYSize() / 2, self.hmTerrain.get_elevation(i, j) * self.hmHeight - self.hmHeight / 2) # newPlaneFront.setScale(6) # planeFrontModel.instanceTo(newPlaneFront) # if(int(color.getX() * 255.0) == 179): # newPlaneWing = self.planeWingNP.attachNewNode("newPlaneWing") # newPlaneWing.setPos(i - texpk.getXSize() / 2, j - texpk.getYSize() / 2, self.hmTerrain.get_elevation(i, j) * self.hmHeight - self.hmHeight / 2) # newPlaneWing.setScale(6) # newPlaneWing.setH(250) # newPlaneWing.setR(180) # newPlaneWing.setP(135) # planeWingModel.instanceTo(newPlaneWing) self.snowflakes = [] for i in xrange(0, self.snowflakeCount): print("Call " + str(i)) sf = SMCollect(self.worldBullet, self.worldObj, self.snowflakePositions[i]) self.snowflakes.append(sf) # render.flattenStrong() self.hmTerrainNP.reparentTo(render) # Here begins the attribute mapping ts = TextureStage("stage-alpha") ts.setSort(0) ts.setPriority(1) ts.setMode(TextureStage.MReplace) ts.setSavedResult(True) self.hmTerrainNP.setTexture(ts, loader.loadTexture(imPath, smPath)) ts = TextureStage("stage-stone") ts.setSort(1) ts.setPriority(1) ts.setMode(TextureStage.MReplace) self.hmTerrainNP.setTexture(ts, loader.loadTexture("../res/textures/stone_tex.png")) self.hmTerrainNP.setTexScale(ts, 32, 32) ts = TextureStage("stage-ice") ts.setSort(2) ts.setPriority(1) ts.setCombineRgb(TextureStage.CMInterpolate, TextureStage.CSTexture, TextureStage.COSrcColor, TextureStage.CSPrevious, TextureStage.COSrcColor, TextureStage.CSLastSavedResult, TextureStage.COSrcColor) self.hmTerrainNP.setTexture(ts, loader.loadTexture("../res/textures/ice_tex.png")) self.hmTerrainNP.setTexScale(ts, 32, 32) ts = TextureStage("stage-snow") ts.setSort(3) ts.setPriority(0) ts.setCombineRgb(TextureStage.CMInterpolate, TextureStage.CSTexture, TextureStage.COSrcColor, TextureStage.CSPrevious, TextureStage.COSrcColor, TextureStage.CSLastSavedResult, TextureStage.COSrcAlpha) self.hmTerrainNP.setTexture(ts, loader.loadTexture("../res/textures/snow_tex_1.png")) self.hmTerrainNP.setTexScale(ts, 32, 32) # print(self.snowflakes) return hmNode #------------------------------------------------------------------------------------------------------------------------------------------------------------ # Sets up and returns the death zone plane (returns its NodePath) with the specified height. #------------------------------------------------------------------------------------------------------------------------------------------------------------ def setupDeathzone(self, height): planeShape = BulletPlaneShape(Vec3(0, 0, 1), 1) planeNode = BulletRigidBodyNode('DeathZone') planeNode.addShape(planeShape) planeNP = render.attachNewNode(planeNode) planeNP.setPos(0, 0, height) self.worldBullet.attachRigidBody(planeNode) return planeNP #------------------------------------------------------------------------------------------------------------------------------------------------------------ # Sets up and returns the collision handler. #------------------------------------------------------------------------------------------------------------------------------------------------------------ def setupCollisionHandler(self): colHand = SMCollisionHandler(self.worldBullet) return colHand #------------------------------------------------------------------------------------------------------------------------------------------------------------ # Toggles showing bounding boxes. #------------------------------------------------------------------------------------------------------------------------------------------------------------ def toggleDebug(self): if self.debugNode.isHidden(): self.debugNode.show() else: self.debugNode.hide() #------------------------------------------------------------------------------------------------------------------------------------------------------------ # Returns the terrain height of the nearest vertical descending raycast from the passed Point3. #------------------------------------------------------------------------------------------------------------------------------------------------------------ def getTerrainHeight(self, pos): result = 0 x = pos.getX() y = pos.getY() z = pos.getZ() rayTerrA = Point3(x, y, z) rayTerrB = Point3(x, y, z - 256) rayTest = self.worldBullet.rayTestClosest(rayTerrA, rayTerrB) rayNode = rayTest.getNode() if (rayTest.hasHit()): rayPos = rayTest.getHitPos() result = rayPos.getZ() else: self.playerObj.respawn() return result # return self.hmTerrain.get_elevation(x + self.hmOffset, y + self.hmOffset) * self.hmHeight #------------------------------------------------------------------------------------------------------------------------------------------------------------ # Handles player movement #------------------------------------------------------------------------------------------------------------------------------------------------------------ def playerMove(self): # Go through the collision and flag tests, and update them self.doPlayerTests() # Rotation and camera movement if self.kh.poll(self.keymap['Left']): self.playerObj.turn(True) elif self.kh.poll(self.keymap['Right']): self.playerObj.turn(False) elif(self.cameraControl): newMousePos = self.kh.getMouse() mx = newMousePos.getX() self.camObj.rotateCamera(mx) self.camObj.calculatePosition() # Movement if self.kh.poll(self.keymap['Forward']): self.playerObj.move(True) self.camObj.rotateTowards(90) elif self.kh.poll(self.keymap['Back']): self.playerObj.move(False) else: self.playerObj.stop() # Jump if(self.kh.poll(self.keymap['Space']) and self.terrSteepness < 0.25): #and not(self.ballObj.isRolling())): self.playerObj.jump() else: self.playerObj.resetJump() # Air Dash if(self.kh.poll(self.keymap['airDash'])): #and self.playerObj.getAirborneFlag() == True and self.canAirDash == True): self.canAirDash = False self.playerObj.airDash() # Shift-based actions if(self.kh.poll("lshift") and not(self.sbCollideFlag) and not(self.playerObj.getAirborneFlag()) and self.canUseShift): # If there's another snowball already placed if(self.ballObj.exists() and not(self.ballObj.isRolling())): self.ballObj.respawn() # If we're rolling a snowball elif(self.ballObj.isRolling()): # Absorb snowball if(self.kh.poll("v")): self.canUseShift = False snowAmt = self.ballObj.getSnowAmount() self.playerObj.addSnow(snowAmt) # self.snowMeter.fillBy(snowAmt) self.ballObj.destroy() # Go to iceball throwing mode elif(self.kh.poll("b")): print("TODO: Ice ball throwing mode.") # Grow the snowball elif(self.kh.poll("w")): self.ballObj.grow() # Spawn a new snowball elif(self.ballObj.exists() == False): self.ballObj.respawn() # If the player is not pressing shift else: if(self.ballObj.isRolling()): self.ballObj.dropBall() base.win.movePointer(0, 400, 300) # So updating the stats is VERY expensive. if (self.debugNode.isHidden() == False): self.updateStats() #------------------------------------------------------------------------------------------------------------------------------------------------------------ # Various tests concerning the player flags and collisions. #------------------------------------------------------------------------------------------------------------------------------------------------------------ def doPlayerTests(self): # Player's position plPos = self.playerObj.getPosition() px = plPos.getX() py = plPos.getY() pz = plPos.getZ() # Raycast directly down for terrain steepness rayYetiA = Point3(px, py, pz) rayYetiB = Point3(px, py, pz - 300) self.downRayTest = self.worldBullet.rayTestClosest(rayYetiA, rayYetiB).getHitNormal() rx = self.downRayTest.getX() ry = self.downRayTest.getY() rz = self.downRayTest.getZ() self.terrSteepness = 1.0 - rz # Redo collision flags later objCollisionFlag = False # Snow/Ice height adjust self.playerObj.updateTerrain() # Collision: Player x Objects for i in xrange(0, self.colObjectCount): if(self.colObj.didCollide(self.playerNP.node(), self.colObjects[i].AINode)): objCollisionFlag = True self.playerObj.setAirborneFlag(False) self.canAirDash = True self.playerObj.setFactor(1,1,1) # Collision: Player x Snowball if(self.ballObj.exists() and self.colObj.didCollide(self.playerNP.node(), self.ballObj.getRigidbody())): self.sbCollideFlag = True self.playerObj.setAirborneFlag(False) self.playerObj.setFactor(1, 1, 1) else: self.sbCollideFlag = False # Collision: Player x Terrain if(self.colObj.didCollide(self.playerNP.node(), self.heightMap)): if(self.playerObj.getAirborneFlag()): self.audioMgr.playSFX("snowCrunch01") self.playerObj.setAirborneFlag(False) self.canAirDash = True self.playerObj.setFactor(1, 1, 1) objCollisionFlag = False # Collision: Player x Death Zone # if(pz - 7 <= self.deathHeight or (self.colObj.didCollide(self.playerNP.node(), self.deathZone.node()))): if(self.colObj.didCollide(self.playerNP.node(), self.deathZone.node())): print("Player confirmed #REKT") self.playerObj.respawn() # Out of bounds checking if(abs(px) > 254 or abs(py) > 254): print("Player out of bounds!") self.playerObj.respawn() # Snap to terrain if... something. I need to restructure this. Don't read it. if(not(self.playerObj.getAirborneFlag()) and not(self.sbCollideFlag) and not(objCollisionFlag)): z = self.getTerrainHeight(Point3(px, py, pz)) self.playerObj.snapToTerrain(z) # self.playerObj.snapToTerrain(th, self.hmHeight) # Collision: Player x Snowflakes for i in xrange(0, self.snowflakeCount): if(self.snowflakes[i].exists() and self.colObj.didCollide(self.playerNP.node(), self.snowflakes[i].getNode())): self.snowflakes[i].destroy() self.snowflakeCounter.increment() self.snowCount += 1 self.snowMeter.updateSnow(self.playerObj) #Check if there is a "next" level. If there is, load it. Otherwise display end game screen. if(self.snowCount >= self.snowflakeCount): file_path="../maps/map" + str(self.mapID+1) + "/map" + str(self.mapID+1) + ".yetimap" if os.path.lexists(file_path): self.snowCount = 0 self.snowflakeCount = 0 self.snowflakeCounter.setValue(0) self.snowflakeCounter.setState(2) #Loading Screen self.transition.fadeScreen(0.7) self.loadingText=OnscreenText("Loading...",1,fg=(1,1,1,0),pos=(0,0),align=TextNode.ACenter,scale=.07,mayChange=1) base.graphicsEngine.renderFrame() base.graphicsEngine.renderFrame() base.graphicsEngine.renderFrame() base.graphicsEngine.renderFrame() self.transition.noFade() #destroy objects self.worldBullet.removeRigidBody(self.heightMap) self.hmTerrainNP.removeNode() self.objNP.removeNode() self.treeNP.removeNode() self.rockNP.removeNode() self.rock2NP.removeNode() self.rock3NP.removeNode() # self.caveNP.removeNode() # self.planeFrontNP.removeNode() # self.planeWingNP.removeNode() self.hmNP.removeNode() if(int(self.mapID) == 1): self.ropeBridge.AIChar.setPos(-200,-300,-200) # self.ropeBridge.AIChar.removeNode() self.planeFront.AIChar.removeNode() self.planeTail.AIChar.setPos(-200,-200,-200) # self.planeTail.AIChar.removeNode() self.caveNew.AIChar.setPos(-1000,-1000,-1000); self.caveModel.AIChar.removeNode() #Added More Props here! self.boulder = SMCollide("../res/models/rock_3.egg", self.worldBullet, self.worldObj, Point3(117, 123, 17), 15, Vec3(0,0,0)) elif(int(self.mapID) == 2): self.boulder.AIChar.setPos(-222,-222,-222) self.caveNew.AIChar.setScale(150) self.caveNew.AIChar.setPos(-50, 95, -50) # self.skybox.setScale(600) # self.caveNew.setH(0) # self.boulder.removeNode() self.mapID += 1 print self.mapID # EX: maps/map-1/map-1.yetimap metaFile = open("../maps/map" + str(self.mapID) + "/map" + str(self.mapID) + ".yetimap", 'r') metaLines = metaFile.readlines() lineCount = len(metaLines) self.snowflakeCount = lineCount - 2 # First Line: Player's starting position # EX: 50,50,50 (NO SPACES) playerLine = metaLines[0] playerPosList = playerLine.split(",") playerInitX = int(playerPosList[0]) playerInitY = int(playerPosList[1]) playerInitZ = int(playerPosList[2]) self.playerObj.playerNP.setPos(playerInitX, playerInitY, playerInitZ) self.playerObj.startX = playerInitX self.playerObj.startY = playerInitY self.playerObj.startZ = playerInitZ # 2nd Line: Deathzone Height # ONE INTEGER self.deathHeight = int(metaLines[1]) self.snowflakePositions = [] print("Snowflake Count: " + str(self.snowflakeCount)) for i in xrange(0, self.snowflakeCount): sfline = metaLines[i+2] sfList = sfline.split(",") sfx = int(sfList[0]) sfy = int(sfList[1]) sfz = int(sfList[2]) self.snowflakePositions.append(Point3(sfx, sfy, sfz)) print("New snowflake to add: (" + str(sfx) + "," + str(sfy) + "," + str(sfz) + ")") self.snowflakeCounter.setMaxValue(self.snowflakeCount) #load new map self.mapName = str(self.mapID) self.heightMap = self.setupHeightmap(self.mapName) self.deathZone = self.setupDeathzone(self.deathHeight) self.loadingText.cleanup() else: taskMgr.remove('UpdateTask') self.endImage=OnscreenImage(image = "../res/icons/endgame1.png", pos = (0.0, 0.0, 0.0), scale = (1.35, 2, 1)) #------------------------------------------------------------------------------------------------------------------------------------------------------------ # Update the debug text. #------------------------------------------------------------------------------------------------------------------------------------------------------------ def updateStats(self): pos = self.playerObj.getPosition() x = pos.getX() y = pos.getY() z = pos.getZ() vel = self.playerObj.getVelocity() vx = str(round(vel.getX(), 1)) vy = str(round(vel.getY(), 1)) vz = str(round(vel.getZ(), 1)) sx = str(round(x, 1)) sy = str(round(y, 1)) sz = str(round(z, 1)) rx = str(round(self.downRayTest.getX(), 2)) ry = str(round(self.downRayTest.getY(), 2)) rz = str(round(self.terrSteepness, 2)) fric = str(round(self.playerObj.getFriction(), 2)) ip = str(round(self.playerObj.getIceCoefficient(), 2)) sp = str(round(self.playerObj.getSnowCoefficient(), 2)) tHeight = str(round(self.getTerrainHeight(Point3(x, y, z)), 1)) self.textObj.editText("yetiPos", "Position: (" + sx + ", " + sy + ", " + sz + ")") self.textObj.editText("yetiVel", "Velocity: (" + vx + ", " + vy + ", " + vz + ")") self.textObj.editText("yetiFric", "Friction: " + fric) self.textObj.editText("onIce", "Ice(%): " + ip) self.textObj.editText("onSnow", "Snow(%): " + sp) self.textObj.editText("terrHeight", "T Height: " + tHeight) self.textObj.editText("terrSteepness", "Steepness: " + rz) #------------------------------------------------------------------------------------------------------------------------------------------------------------ # throw Snowball #------------------------------------------------------------------------------------------------------------------------------------------------------------ def throw(self): self.throwing = True size = self.ballObj.getSize() #zoom camera and grab pos you wish to throw self.camObj.aimMode() taskMgr.add(self.controlCamera, "camera-task") rotation = self.camObj.getH() pitch =self.camObj.getP() self.ballObj.throwBall(size, pitch, rotation) #fix camera #self.throwing = False #------------------------------------------------------------------------------------------------------------------------------------------------------------ # Update the world. Called every frame. #------------------------------------------------------------------------------------------------------------------------------------------------------------ def update(self, task): dt = globalClock.getDt() self.worldBullet.doPhysics(dt) # self.goat1.AIUpdate() # self.goat2.AIUpdate() self.playerMove() return task.cont
class Play(DirectObject): def __init__(self, parent): #Turn off default mouse control base.disableMouse() base.setFrameRateMeter(True) #globalClock = ClockObject.getGlobalClock() #globalClock.setMode(ClockObject.MLimited) #globalClock.setFrameRate(1000) #Set windows properties self.props = WindowProperties() self.props.setCursorHidden(True) #props.setFullscreen(1) #props.setSize(int(base.pipe.getDisplayWidth()), int(base.pipe.getDisplayHeight())) self.props.setMouseMode(WindowProperties.MRelative) base.win.requestProperties(self.props) self.transition = Transitions(loader) self.transition.setFadeColor(0,0,0) self.parent = parent base.accept("escape", self.togglePause) self.setupSounds() self.startLevel(0, True) self.task = taskMgr.add(self.update, "updateTask") def fadeOut(self): self.transition.fadeOut(1) def fadeIn(self): self.transition.irisIn(1) def togglePause(self): if self.parent.paused: self.props.setCursorHidden(True) base.win.requestProperties(self.props) base.win.movePointer(0, base.win.getXSize()/2, base.win.getYSize()/2) taskMgr.add(self.task) self.parent.paused = False self.parent.continueImage.hide() self.parent.restartImage.hide() self.parent.exitImage.hide() self.parent.mainFrame.hide() self.playingBGM.setTime(self.bgmTime) self.playingBGM.play() else: self.props.setCursorHidden(False) base.win.requestProperties(self.props) taskMgr.remove(self.task) self.parent.paused = True self.parent.mainFrame.show() self.parent.continueImage.show() self.parent.restartImage.show() self.parent.exitImage.show() self.bgmTime = self.playingBGM.getTime() self.playingBGM.stop() def chaseBGM(self, chasing = False): if chasing and self.playingBGM != self.bgFast: self.playingBGM.stop() self.playingBGM = self.bgFast self.bgmTime = 0 self.playingBGM.play() elif not chasing and self.playingBGM != self.bgSlow: self.playingBGM.stop() self.playingBGM = self.bgSlow self.bgmTime = 0 self.playingBGM.play() def initModels(self): self.map = MapGen(self) # self.player = Player(self) # self.level = Level() self.enemies = [] def transitionFunc(self, level, next = False): tSequence = Sequence(Func(self.fadeOut), Wait(1), Func(self.startLevel, level, next), Func(self.fadeIn)) tSequence.start() #level number, next = true if next level (false = respawning) def startLevel(self, level, next = False): # per pixel lighting render.clearLight() render.setShaderAuto() try: self.level.initLight() except AttributeError: pass try: self.player.initHandLight() except AttributeError: pass # """ # render.clearLight() # render.setShaderAuto() # """ # self.map = MapGen(self) # self.player = Player(self) # self.level = Level() # self.enemies = [] if next: for node in render.getChildren(): node.removeNode() for node in base.camera.getChildren(): if node.getName() != 'cam': print node.getName() node.removeNode() else: #Clear render self.player.clearItems() #If next level, load level map #and initialize enemies if next: level += 1 for node in render.getChildren(): node.removeNode() self.player = Player(self) self.level = Level() self.enemies = [] self.player.level = level self.level.loadLevel(level) for enemy in self.level.enemies: enemySpawn = Enemy( self, enemy[0], enemy[1] ) self.enemies.append(enemySpawn) playerPos = self.level.playerPos #level.spawnPos walls = self.level.numWalls lights = self.level.numLights #Spawn player using spawn (spawn pos, max walls, max lights) self.player.spawn(playerPos,walls,lights) if not next: for enemy in self.enemies: enemy.respawn() self.playingBGM = self.bgSlow self.playingBGM.play() if next: self.setupCollisions() def die(self, level, next = False): self.transitionFunc(level, next) def setupCollisions(self): #Make a collision traverser, set it to default base.cTrav = CollisionTraverser() base.itemTrav = CollisionTraverser() base.pusher = CollisionHandlerPusher() base.cHandler = CollisionHandlerEvent() base.queue = CollisionHandlerQueue() base.eQueue = CollisionHandlerQueue() #Set the pattern for the event sent on collision base.cHandler.setAgainPattern("%fn-again-%in") base.cHandler.setInPattern("%fn-into-%in") base.cHandler.setOutPattern("%fn-out-%in") self.player.initCollisions() for enemy in self.enemies: enemy.initCollisions(self.player) #base.cTrav.showCollisions(render) #Set up BGM def setupSounds(self): ######################slow music########################## self.bgSlow = base.loadMusic("sounds/slow.ogg") self.bgSlow.setLoopCount(0) ######################fast music############################ self.bgFast = base.loadMusic("sounds/fast.ogg") self.bgFast.setLoopCount(0) self.playingBGM = self.bgSlow def update(self, task): dt = globalClock.getDt() self.player.update(globalClock.getDt()) if self.player.newLevel: return task.cont for enemy in self.enemies: enemy.update(globalClock.getDt(), self.player) return task.cont
class GameManager(FSM): def __init__(self, filename): FSM.__init__(self, 'Game') self.savedGame = PlayerFileParser("save.xml") self.playerData = self.savedGame.playerData self.playerData.setShip(shipDb[self.playerData.ship.name]) self.crosshair = MouseCursor() self.crosshair.setMode(1) self.mainMenu = MainMenu() self.mainMenu.hide() self.mainMenu.buttons[0]["command"] = self.request self.mainMenu.buttons[0]["extraArgs"] = ["Space"] self.mainMenu.buttons[1]["command"] = self.request self.mainMenu.buttons[1]["extraArgs"] = ["Ground"] self.mainMenu.buttons[3]["command"] = self.quit self.mainMenu.buttons[3]["extraArgs"] = [0] #self.groundGui = GroundGui(self.playerData) #self.groundWorldManager = GroundManager(self) #self.spaceWorldManager = SpaceOdeWorldManager(self) self.prevState = None self.trans = Transitions(loader) self.request("IntroMainMenu") #self.request("Space") def quit(self, extraArgs=[]): audio3d.detachListener() sys.exit() def getEscape(self): if self.state == "Space": if self.spaceWorldManager.camHandler.mode == "turret": self.spaceWorldManager.setMode("manual") else: self.prevState = "Space" self.request("IntroMainMenu") elif self.state == "Ground": self.prevState = "Ground" self.request("IntroMainMenu") elif self.state == "IntroMainMenu": if self.prevState is not None: self.request(self.prevState) def saveGame(self): self.savedGame.save() def enterIntroMainMenu(self): #print "we entered intro main menu" self.mainMenu.show() self.trans.fadeIn() def exitIntroMainMenu(self): #print("we exited intro main menu") self.trans.fadeOut() self.mainMenu.hide() def enterSpace(self): #print "we entered space" ''' audio3d = Audio3DManager.Audio3DManager(base.sfxManagerList[0], camera) audio3d.setDistanceFactor(100) audio3d.setListenerVelocityAuto() #audio3d.attachListener(camera) ''' self.trans.fadeIn() self.spaceWorldManager = SpaceOdeWorldManager(self) self.spaceWorldManager.start() def exitSpace(self): #print("we exited space") self.trans.fadeOut() self.spaceWorldManager.destroy() del self.spaceWorldManager def enterGround(self): #print "we entered ground" self.trans.fadeIn() self.groundWorldManager = GroundManager(self) self.groundWorldManager.start() def exitGround(self): #print("we exited ground") self.trans.fadeOut() self.groundWorldManager.destroy() del self.groundWorldManager
def initgame(self): self.transition = Transitions(loader) self.getparameters() self.GameOver = False self.BlackScreen = 0 self.p_ID = self.b.get() self.p_age = self.d.get() self.p_gender = self.f.get() self.file = open( 'logs/Reversal3D_end30_5of6_logfile_' + str(self.p_ID) + '.txt', 'w') # added two extra columns to the log file self.file.write( "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t" % ("pID", "Age", "Gender", "TrialNumber", "Reversal", "Target", "Choice", "Correct", "TotalScore", "RunningTotal", "Last6TrialsTotal", "TrialNumPhase", "Visits0", "Visits1", "Visits2", "Visits3", "ResponseTime")) self.file.close() print "ID:", self.p_ID, "Gender:", self.p_gender, "Age:", self.p_age print "ID:", self.p_ID, "Gender:", self.p_gender, "Age:", self.p_age self.rungame = True self.TotalScore = 0 self.RunningTotal = 0 self.trial_no = -1 self.new_trial = True self.end_aq_after = 30 self.end_rev_after = 30 self.trial_num_phase = 0 self.reverse_now = False self.TrialScoreList = [] self.TrialScoreLastFiveSix = [] self.LastFiveSixCount = 0 # when starting a new trial, pick gender and kiki parameters self.new_trial = True if self.p_gender == "Male": self.kiki = CreateActor("Models/baseboy.x", "textures/baseboy2.png", 0, 0, 0, 0) else: self.kiki = CreateActor("Models/kiki.x", "textures/kiki.jpg", 0, 0, 0, 0) self.kiki.currentframe = 0 self.kiki.reparentTo(self.render) self.isTurning = False self.lag = 0 self.ScoreText = None # how often screen refreshes self.framerate = 30 globalClock.setMode(ClockObject.MLimited) globalClock.setFrameRate(self.framerate) self.frames = [ int(round(i)) for i in np.arange(0, 1200, 60. / self.framerate) ] # creating the boxes self.present1 = CreateActor("Models/test.x", "textures/presentgrey.png", 0, 0, 0, 0) self.present1.reparentTo(self.render) self.present2 = CreateActor("Models/test.x", "textures/presentgrey.png", 0, 0, 0, 0) self.present2.reparentTo(self.render) self.present3 = CreateActor("Models/test.x", "textures/presentgrey.png", 0, 0, 0, 0) self.present3.reparentTo(self.render) self.present4 = CreateActor("Models/test.x", "textures/presentgrey.png", 0, 0, 0, 0) self.present4.reparentTo(self.render) self.presents = [ self.present1, self.present2, self.present3, self.present4 ] self.texgrey = loader.loadTexture("textures/presentgrey.png") if self.boxcol == "A": self.tex1 = loader.loadTexture("textures/presentblue.png") self.tex2 = loader.loadTexture("textures/presentyellow.jpg") self.tex3 = loader.loadTexture("textures/presentpink.jpg") self.tex4 = loader.loadTexture("textures/presentgreen.png") self.tex5 = loader.loadTexture("textures/presentpurple.png") else: self.tex1 = loader.loadTexture("textures/presentbrown.jpg") self.tex2 = loader.loadTexture("textures/presentorange.png") self.tex3 = loader.loadTexture("textures/presentred.png") self.tex4 = loader.loadTexture("textures/presentgreys.png") self.tex5 = loader.loadTexture("textures/presentlightpurple.png") self.textures = [self.tex1, self.tex2, self.tex3, self.tex4] # making the star and positions self.star = self.loader.loadModel("Models/star.x") tex = loader.loadTexture("textures/gold_texture.jpg") self.star.setTexture(tex) self.star.setScale(self.starsize) self.star.setPos(0, 0, 3) # making the black cloud and their positions self.clouds = CreateActor("Models/clouds.x", "textures/cotton.jpg", 0, 0, 0, 0) self.star.setScale(self.cloudsize) # setting up the room environment self.environ = self.loader.loadModel("Models/Room.x") self.environ.reparentTo(self.render) # setting the wall colors - note that Reversal task uses set "A" and # practice task uses set B if self.wallcol == "A": tex = loader.loadTexture("textures/arena.png") else: # set B tex = loader.loadTexture("textures/room2.png") self.environ.setTexture(tex) self.environ.setScale(2, 2, 2) self.environ.setPos(0, 0, 0) self.starLoc = [] for i in range(4): for j in range(10): self.starLoc.append([i, j]) self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(self.kiki) self.floater.setZ(2.0) self.angle = -2 * np.pi * self.kiki.getH() / 360 alight = AmbientLight('alight') alight.setColor(VBase4(2, 2, 2, 1)) alnp = render.attachNewNode(alight) render.setLight(alnp) self.plight = PointLight('plight') self.plight.setColor(VBase4(0, 0, 0, 0)) self.plnp = render.attachNewNode(self.plight) #animation frames: self.runframe = get_frames(1, 40, self.framerate) self.digframe = get_frames(60, 240, self.framerate) self.presentsframe = get_frames(0, 180, self.framerate) self.winframe = get_frames(320, 360, self.framerate) self.losingframe = get_frames(380, 460, self.framerate) self.dragframe = get_frames(242, 302, self.framerate) self.cloudsframe = get_frames(0, 180, self.framerate) # this is the new way to randomize the correct box for each subject # this will also reset for reversal self.correctbox = fluffle([0, 1, 2])[0] #np.random.randint(0,3) self.reversal = 0 self.savelog = False # we don't have the joystick version # will always print error in console self.joystickon = 0 try: if joystick.get_count() > 0: self.joystickon = 1 self.joystick = joystick.Joystick(0) self.joystick.init() except: print "Joystick Error" self.joystickon = 0
class Engine(ShowBase): def __init__(self): ShowBase.__init__(self) self.disableMouse() props = WindowProperties() props.setTitle('Test') self.win.requestProperties(props) # self.render.setAntiAlias(AntialiasAttrib.MAuto) self.transitions = Transitions(self.loader) self.transitions.setFadeColor(0, 0, 0) self.filters = CommonFilters(self.win, self.cam) # self.filters.setCartoonInk() self.filters.setBlurSharpen(1) # self.filters.setVolumetricLighting(self.render) # self.buffer = self.win.makeTextureBuffer("Post-processing buffer", self.win.getXSize(), self.win.getXSize()) # print self.buffer.getYSize() # self.texture = self.buffer.getTexture() # self.buffer.setSort(-100) # # self.originalCamera = self.camera # self.offScreenCamera = self.makeCamera(self.buffer) # self.camera = self.offScreenCamera # # self.img = OnscreenImage(image=self.texture, pos=(0, 0, 0.5)) self.scene = None self.channel = Channel() def set_scene(self, scene_module): # self.transitions.fadeOut(0.2) args = [] if self.scene: args.append(Parallel(Func(self.fade_out), LerpFunc(self.blur_out, duration=0.2))) args.append(Wait(0.2)) args.append(Func(self._set_scene, scene_module)) args.append(Parallel(Func(self.fade_in), LerpFunc(self.blur_in, duration=0.4))) Sequence(*args).start() def blur_out(self, t): # index = int(t) # self.filters.delBlurSharpen() self.filters.setBlurSharpen(1 - t) self.filters.setBloom(intensity=t) def blur_in(self, t): # index = int(t) # self.filters.delBlurSharpen() self.filters.setBlurSharpen(t) self.filters.setBloom(intensity=-t) def fade_out(self): self.transitions.fadeOut(0.2) def fade_in(self): self.transitions.fadeIn(0.2) def _set_scene(self, scene_module): group, class_ = scene_module.split('.') module = importlib.import_module('game.scenes.{}'.format(group)) scene_class = getattr(module, class_) if self.scene: self.scene.destroy() del self.scene self.scene = scene_class(self) # self.transitions.fadeIn(0.2) def start(self): self.channel = Channel() self.channel.connect() self.set_scene('auth.AuthScene') while True: self.taskMgr.step() if self.channel.can_read(): for packet in self.channel.read_packets(): self.scene.on_packet(packet)
class ToonCreator(DirectObject): __module__ = __name__ notify = DirectNotifyGlobal.directNotify.newCategory("ToonCreator") dataCache = { 'Animal' : None, 'Gender' : None, 'Weight' : None, 'Height' : None, 'Color' : None, 'HeadType' : None, 'HeadLength' : None, 'Shirt' : None, 'Bottoms' : None } avatar = Avatar() subject = None def __init__(self): self.trans = Transitions(loader) self.scene = render.getPythonTag('SceneManager').createScene('Make-A-Toon') self.setupEnvironment() self.randomizeData() self.setupHUD() self.bgm = SoundBank.getSound('make_a_toon') self.bgm.setLoop(True) self.bgm.play() def setupHUD(self): gui1 = loader.loadModel('phase_3/models/gui/create_a_toon_gui.bam') gui2 = loader.loadModel('phase_3/models/gui/gui_toongen.bam') mickeyFont = loader.loadFont('MickeyFont.bam') self.guiElements = [ OnscreenImage(image = gui1.find("**/CrtATn_TopBar"), parent=render2d, pos=(0, 0, 0.9), scale=(0.85, 0.85, 1)), OnscreenText(text = "Make Your Toon", pos = (0, 0.85), font = mickeyFont, fg = (1, 0, 0, 1), scale=(0.2, 0.2, 0.2)), DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0.66, 0, 0.4), relief=None, command=self.setData, extraArgs=['Animal', 'prev']), DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0, 0, 0.41), hpr=(0, 0, 180), command=self.setData, extraArgs=['Animal', 'next'], relief=None), OnscreenText(text = "Animal", pos = (0.325, 0.38), font = mickeyFont, fg = (1, 0, 0, 1), scale=(0.08, 0.08, 0.08)), DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0.66, 0, 0.1), relief=None, command=self.setData, extraArgs=['Weight', 'prev']), DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0, 0, 0.11), hpr=(0, 0, 180), command=self.setData, extraArgs=['Weight', 'next'], relief=None), OnscreenText(text = "Body", pos = (0.325, 0.1), font = mickeyFont, fg = (1, 0, 0, 1), scale=(0.08, 0.08, 0.08)), DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0.66, 0, -0.20), relief=None, command=self.setData, extraArgs=['Height', 'prev']), DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0, 0, -0.19), hpr=(0, 0, 180), command=self.setData, extraArgs=['Height', 'next'], relief=None), OnscreenText(text = "Height", pos = (0.325, -0.2), font = mickeyFont, fg = (1, 0, 0, 1), scale=(0.08, 0.08, 0.08)), DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0.66, 0, -0.50), relief=None, command=self.setData, extraArgs=['HeadType', 'prev']), DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0, 0, -0.49), hpr=(0, 0, 180), command=self.setData, extraArgs=['HeadType', 'next'], relief=None), OnscreenText(text = "Head", pos = (0.325, -0.5), font = mickeyFont, fg = (1, 0, 0, 1), scale=(0.08, 0.08, 0.08)), DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0.66, 0, -0.8), relief=None, command=self.setData, extraArgs=['Color', 'prev']), DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0, 0, -0.79), hpr=(0, 0, 180), command=self.setData, extraArgs=['Color', 'next'], relief=None), OnscreenText(text = "Length", pos = (0.328, -0.67), font = mickeyFont, fg = (1, 0, 0, 1), scale=(0.08, 0.08, 0.08)), DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0.57, 0, -0.65), scale = 0.4, relief=None, command=self.setData, extraArgs=['HeadLength', 'short']), DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui1.find("**/CrtATn_R_Arrow_UP"), gui1.find("**/CrtATn_R_Arrow_DN"), gui1.find("**/CrtATn_R_Arrow_RLVR")), pos=(0.11, 0, -0.64), scale = 0.4, hpr=(0, 0, 180), command=self.setData, extraArgs=['HeadLength', 'long'], relief=None), OnscreenText(text = "Color", pos = (0.325, -0.8), font = mickeyFont, fg = (1, 0, 0, 1), scale=(0.08, 0.08, 0.08)), DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui2.find("**/tt_t_gui_mat_girlUp"), gui2.find("**/tt_t_gui_mat_girlDown")), pos=(0.66, 0, 0.68), relief=None, command=self.randomizeData, extraArgs = ['girl'], scale=(0.55, 0.55, 0.55)), DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (gui2.find("**/tt_t_gui_mat_boyUp"), gui2.find("**/tt_t_gui_mat_boyDown")), pos=(0, 0, 0.68), command=self.randomizeData, extraArgs = ['boy'], relief=None, scale=(0.55, 0.55, 0.55)), DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom=(gui2.find("**/tt_t_gui_mat_okUp"), gui2.find("**/tt_t_gui_mat_okDown")), pos=(1, 0, -0.2), relief=None, command=self.done) ] def done(self): self.trans.irisOut() self.bgm.stop() for element in self.guiElements: element.removeNode() base.taskMgr.doMethodLater(0.8, self.cleanUp, 'Cleanup Scene') def cleanUp(self, task): self.bgm.stop() self.scene.delete() ToontownCentral().loadScene() self.trans.irisIn() from doomsday.avatar.LocalAvatar import Player Player(self.avatar).setupToon() return Task.done def setData(self, key, value): attr = AvatarAttributes() tables = {'Animal' : attr.getAnimals(), 'Gender' : ['boy', 'girl'], 'Color' : attr.convertColorDictToTbl(), 'Weight' : attr.getWeights(), 'Height' : attr.getHeights(), 'HeadType' : attr.getHeadTypes(), 'HeadLength' : ['short', 'long']} if(key not in self.dataCache): return if(value == 'prev' or value == 'next'): table = tables[key] index = 0 for i in xrange(len(table)): if(table[i] == self.dataCache[key]): index = i if(value == 'prev'): if(index == 0): self.dataCache[key] = table[(len(table) - 1)] else: self.dataCache[key] = table[index - 1] else: if(index == (len(table) - 1)): self.dataCache[key] = table[0] else: self.dataCache[key] = table[index + 1] else: self.dataCache[key] = value self.generateAvatar() def randomizeData(self, gender = None): def setData(key, value): self.dataCache[key] = value attr = AvatarAttributes() setData('Animal', random.choice(attr.getAnimals())) if(gender == None): setData('Gender', random.choice(['boy', 'girl'])) else: setData('Gender', gender) setData('Weight', random.choice(attr.getWeights())) setData('Height', random.choice(attr.getHeights())) setData('Color', random.choice(attr.convertColorDictToTbl())) setData('HeadType', random.choice(attr.getHeadTypes())) setData('HeadLength', random.choice(['short', 'long'])) self.generateAvatar() def generateAvatar(self): self.cleanupAvatar() for key in self.dataCache.keys(): self.avatar.setData(key, self.dataCache[key]) self.avatar.generate() self.avatar.getAvatar().setPosHprScale(-2, 0, 0, 200, 0, 0, 1, 1, 1) self.avatar.getAvatar().reparentTo(render) self.subject = self.avatar.getAvatar() self.subject.setName("Temp Toon") self.subject.loop('neutral') shirtColor = random.choice(AvatarAttributes().convertColorDictToTbl()) bttColor = random.choice(AvatarAttributes().convertColorDictToTbl()) self.subject.find("**/torso-top").setColor(shirtColor) self.subject.find("**/sleeves").setColor(shirtColor) self.subject.find('**/torso-bot').setColor(bttColor) def cleanupAvatar(self): if(self.subject != None): self.subject.stop('neutral') self.subject.cleanup() self.subject.removeNode() def setupEnvironment(self): self.trans.fadeIn(2) room = loader.loadModel('phase_3/models/gui/create_a_toon.bam') room.find('**/sewing_machine').removeNode() room.find('**/drafting_table').removeNode() room.find("**/wall_floor").setColor(0.7294117647058824, 0.5490196078431373, 0.2392156862745098, 1) room.setName("Room") self.scene.addModel(room)
class LevelChanger(DirectObject): #Use this to handle changing of levels #check the emeny list and if it is empty then change the level #Flag to tell if the level is complete levelComplete = False def __init__(self): #Level map self.level01 = "resources/theSouthBridge" self.level02 = "resources/theSocket" self.level03 = "resources/theDualChannel" self.level04 = "resources/theRoot" self.levelMap = {1:self.level01, 2:self.level02, 3:self.level03, 4:self.level04} self.currentLevel = 1 #Level music map self.level01M = base.loader.loadMusic("resources/sounds/level1.wav") self.level02M = base.loader.loadMusic("resources/sounds/level2.wav") self.level03M = base.loader.loadMusic("resources/sounds/level3.wav") self.level04M = base.loader.loadMusic("resources/sounds/bossMusic.wav") self.musicMap = {1:self.level01M, 2:self.level02M, 3:self.level03M, 4:self.level04M} self.currentMusic = self.musicMap[self.currentLevel] self.currentMusic.setLoop(True) self.currentMusic.play() #Open file to get player spawns self.pSpawnsFile = open("playerSpawns.txt") self.pSpawnsList = self.pSpawnsFile.readlines() self.pSpawnsFile.close() #Set players current spawn self.spawnIndex = 0 base.xPos = float(self.pSpawnsList[self.spawnIndex + 1].split("=")[1].translate(None,"\n")) base.yPos = float(self.pSpawnsList[self.spawnIndex + 2].split("=")[1].translate(None,"\n")) base.zPos = float(self.pSpawnsList[self.spawnIndex + 3].split("=")[1].translate(None,"\n")) base.player.playerNode.setPos(0, 0, 30) #resets height base.player.playerModel.setPos(base.xPos, base.yPos, base.zPos) #resets position #checks the enemy list #if the list is empty, level is complete #set flag to true and change the level. def checkLevel (self, task): enemy = base.spawner.spawnId if(len(base.enemyList) == 0): if enemy > 0: self.levelComplete = True if self.currentLevel == len(self.levelMap): base.player.hide() base.player.canUseWeapons = False base.fsm.request('WinMenu', 1) return task.done else: self.changeLevel(task) return task.cont def changeLevel(self, task): if(self.levelComplete == True): self.transition = Transitions(loader) self.transition.setFadeColor(0, 0, 0) self.fadeOut = self.transition.fadeOut(2) #unload the current level and models self.unload(self.levelMap[self.currentLevel]) #load the next level and models self.load(self.levelMap[self.currentLevel + 1]) #self.fadeIn = self.transition.fadeIn(5) base.taskMgr.remove(task) return task.cont #Unloads current level objects def unload(self, level): for i in base.pickuplist: i.deletePickup = True for i in base.enemyList: i.delFlag = True i.deadFlag = True #stop the music self.currentMusic.stop() #detach playerNode base.player.playerNode.detachNode() #Remove enemies #base.taskMgr.remove("Spawn Enemies") base.taskMgr.remove("enemyCleanup") #unload the env and detach remove the node base.loader.unloadModel(level) base.environ.removeNode() #Load the next level def load(self, level): #Reset player health for the next level base.player.adjustHealth(base.player.maxEnergy) #load Environment - new level base.environ = base.loader.loadModel(level) base.environ.reparentTo(base.render) base.environ.setScale(7, 7, 3) #update the currentLevel. self.currentLevel += 1 #reattach player to render base.player.playerNode.reparentTo(render) #Set the next levels spawn coordinates self.spawnIndex += 4 base.xPos = float(self.pSpawnsList[self.spawnIndex + 1].split("=")[1].translate(None,"\n")) base.yPos = float(self.pSpawnsList[self.spawnIndex + 2].split("=")[1].translate(None,"\n")) base.zPos = float(self.pSpawnsList[self.spawnIndex + 3].split("=")[1].translate(None,"\n")) base.player.playerNode.setPos(0,0,30) #resets height base.player.playerModel.setPos(base.xPos, base.yPos, base.zPos) #resets position #create new spawner on the env base.spawner = Spawner(base.environ, level.split("/")[1].translate(None,"\n")) #Reinit enemies base.spawner.spawn() base.taskMgr.add(self.checkLevel, "checkLevel") base.taskMgr.add(base.enemyCleanUp, "enemyCleanup", taskChain='GameTasks') self.fadeIn = self.transition.fadeIn(2) self.currentMusic = self.musicMap[self.currentLevel] self.currentMusic.setLoop(True) self.currentMusic.play() #Returns the current level def getCurrentLevel(self): return self.currentLevel #Goes direcctly to the boss level def goToBoss(self): self.transition = Transitions(loader) self.transition.setFadeColor(0, 0, 0) self.fadeOut = self.transition.fadeOut(2) self.unload(self.levelMap[1]) self.load(self.levelMap[4]) self.currentLevel = 4 #Resets enemies upon death def resetEnemy(self): base.player.playerModel.setPos(base.xPos, base.yPos, base.zPos) base.player.playerNode.setPos(0,0,30) #resets height for i in base.enemyList: i.delFlag = True i.deadFlag = True for i in base.pickuplist: i.deletePickup = True #create new spawner on the current level base.spawner = Spawner(base.environ, self.levelMap[self.currentLevel].split("/")[1].translate(None,"\n")) #Reinit enemies base.spawner.spawn()
class MakeAToon: def __init__(self): self.notify = DirectNotifyGlobal.directNotify.newCategory("Starting Make A Toon.") self.localAvatar = LocalAvatar.toonBody base.localAvatar = self.localAvatar self.toonColors = Localizer.toonColorDict self.colorNum = 0 self.numColors = Localizer.numColors self.MakeAToonText = Localizer.MakeAToonText self.Mickey = Localizer.Mickey self.mickeyFont = loader.loadFont('phase_3/models/fonts/MickeyFont.bam') self.Text = OnscreenText(text = "Make A Toon", pos = (0, 0.75), font = self.mickeyFont, fg = (1, 0, 0, 1),scale=(0.2, 0.2, 0.2)) self.gui = loader.loadModel('phase_3/models/gui/tt_m_gui_mat_mainGui.bam') self.gui.flattenMedium() self.gui1 = loader.loadModel('phase_3/models/gui/create_a_toon_gui.bam') self.gui2 = loader.loadModel('phase_3/models/gui/gui_toongen.bam') self.guiNextUp = self.gui.find('**/tt_t_gui_mat_nextUp') self.transition = Transitions(loader) self.transition.irisIn(1) self.transition.fadeIn(5) self.load() def load(self): self.Music = loader.loadMusic('phase_3/audio/bgm/create_a_toon.mid') self.Music.setLoop(1) self.MusicVolume = (0.4) self.Music.play() self.Music.setVolume(self.MusicVolume) base.localAvatar.setPos(0.80, 2, 0) base.localAvatar.setHpr(176, 0, 0) LocalAvatar.setMovementAnimation('neutral') self.room = loader.loadModel('phase_3/models/gui/create_a_toon.bam') self.room.reparentTo(render) self.room.find('**/sewing_machine').removeNode() self.room.find('**/drafting_table').removeNode() self.room.find("**/wall_floor").setColor(0.7294117647058824, 0.5490196078431373, 0.2392156862745098, 1) self.room.setName("Room") self.ee = DirectFrame(pos=(-1, 1, 1), frameSize=(-.01, 0.01, -.01, 0.01), frameColor=(0, 0, 0, 0.05), state='normal') self.ee.bind(DGG.B1PRESS, lambda x, ee = self.ee: self.toggleSlide()) self.eee = self.ee self.toonSpin = base.localAvatar.hprInterval(2, Vec3(540, 0, 0)) self.toonSpin2 = base.localAvatar.hprInterval(2, Vec3(180, 0, 0)) self.CameraMove = camera.posInterval(1, Point3(-0.50, -11, 3), startPos=Point3(1, -11, 3)) self.CameraMoveSequence = Sequence(self.CameraMove) self.ToonEnter = base.localAvatar.posInterval(1, Point3(0.60, 2, 0), startPos=Point3(-4, 2, 0)) self.ToonEnterPace = Sequence(self.ToonEnter) self.ToonEnter.start() self.oobeButton = DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (self.gui1.find("**/CrtATn_R_Arrow_UP"), self.gui1.find("**/CrtATn_R_Arrow_DN"), self.gui1.find("**/CrtATn_R_Arrow_RLVR")), relief=None, hpr=(0, 0, 180), command=self.goBack) self.oobeButton.setScale(1) self.oobeButton.setPos(-0.70,3,-0.25) self.goBackButton = DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (self.gui1.find("**/CrtATn_R_Arrow_UP"), self.gui1.find("**/CrtATn_R_Arrow_DN"), self.gui1.find("**/CrtATn_R_Arrow_RLVR")), relief=None, command=self.goRight) self.goBackButton.setScale(1) self.goBackButton.setPos(0.80,3,-0.25) self.spinButton = DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (self.gui1.find("**/CrtATn_R_Arrow_UP"), self.gui1.find("**/CrtATn_R_Arrow_DN"), self.gui1.find("**/CrtATn_R_Arrow_RLVR")), relief=None, command=self.HprToon) self.spinButton.setScale(0.60) self.spinButton.setPos(0.50,2,-0.50) self.spinButton2 = DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom = (self.gui1.find("**/CrtATn_R_Arrow_UP"), self.gui1.find("**/CrtATn_R_Arrow_DN"), self.gui1.find("**/CrtATn_R_Arrow_RLVR")), relief=None, hpr=(0, 0, 180), command=self.HprToon2) self.spinButton2.setScale(0.60) self.spinButton2.setPos(-0.40,2,-0.50) self.OK = DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom=(self.gui2.find("**/tt_t_gui_mat_okUp"), self.gui2.find("**/tt_t_gui_mat_okDown")), pos=(0.90,1,-0.80), relief=None, command=self.CameraButton) def goRight(self): for color in self.toonColors[self.colorNum]: LocalAvatar.bodyNodes[color].setColor(self.toonColors[self.colorNum][color]) self.colorNum += 1 if self.colorNum > self.numColors: self.colorNum = 0 def goBack(self): for color in self.toonColors[self.colorNum]: LocalAvatar.bodyNodes[color].setColor(self.toonColors[self.colorNum][color]) self.colorNum -= 1 if self.colorNum < 0: self.colorNum = self.numColors def HprToon(self): self.toonSpin.start() def HprToon2(self): self.toonSpin2.start() def CameraButton(self): self.transition.irisIn() self.transition.fadeOut(1) self.Music.stop()
class Game(State): mapOffset = {"up": (0,1), "down": (0,-1), "left": (-1,0), "right": (1,0)} def __init__(self, stage, characters, player, player2): State.__init__(self) # how to know the players that will be in game? a ChoosePlayer screen before the constructor? self.characters = characters self.player = player self.player2 = player2 self.stage = stage self.room = self.stage.start self.isOver = False self.players = [] #print(self.players) self.startMap() self.status = {} posi = 0 for c in self.characters: # initialize character status string self.status[c] = (OnscreenText(mayChange= True , style=2, fg=(1,1,1,1), pos=(1.4*posi - 0.8,-0.83), scale = .07) ) posi += 1 self.transitions = Transitions(GameLoader.loader) self.clock = ClockObject() self.lastTime = 0 GameLoader.music.addSfx('barrel_breaks') GameLoader.music.addSfx('stone','aif') def spawnObject(self, ob): ob.setMap(self.currentMap()) ob.getNode().reparentTo(NodePath(self.currentMap().getNode())) x,y = self.currentMap().posToGrid(ob.getPos()) if ob.symbol == 'i': GameLoader.music.addSfx(ob.sfx) try: self.currentMap().tiles[Map.COLLISION][y][x] = ob.symbol except IndexError as e: print('Index error: ' , ob.id, e ) def currentMap(self): return self.stage.maps[self.room] def exitMap(self): for i in range(self.currentMap().width): for j in range(self.currentMap().height): atype = self.currentMap().tileType(1,(i,j)) if atype == 'block' or atype == 'liftable': self.currentMap().tiles[1][j][i] = ' ' for b in self.currentMap().blocks: b.setPos(b.originalPos) x,y = self.currentMap().posToGrid(b.getPos()) self.currentMap().tiles[Map.COLLISION][y][x] = 'b' b.getNode().reparentTo(NodePath(self.currentMap().getNode())) for b in self.currentMap().liftables: b.setPos(b.originalPos) x,y = self.currentMap().posToGrid(b.getPos()) self.currentMap().tiles[Map.COLLISION][y][x] = 'l' b.getNode().reparentTo(NodePath(self.currentMap().getNode())) for d in self.currentMap().doors: if d.permanent: x,y = self.currentMap().posToGrid(d.getPos()) self.currentMap().tiles[Map.COLLISION][y][x] = 'd' d.getNode().reparentTo(NodePath(self.currentMap().getNode())) for char in [self.characters[self.player], self.characters[self.player2]]: char.lifting = None NodePath(self.currentMap().getNode()).detachNode() def startMap(self): if not self.currentMap().started: for obstacle in self.currentMap().obstacles: self.spawnObject(obstacle) for item in self.currentMap().items: self.spawnObject(item) for block in self.currentMap().blocks: self.spawnObject(block) for liftable in self.currentMap().liftables: self.spawnObject(liftable) for switch in self.currentMap().switches: switch.getNode().reparentTo(NodePath(self.currentMap().getNode())) for door in self.currentMap().doors: self.spawnObject(door) self.currentMap().started = True for e in self.currentMap().enemies: self.spawnObject(e) self.characters[self.player].setMap(self.currentMap()) self.characters[self.player2].setMap(self.currentMap()) def changeMap(self,direction,char): self.transitions.fadeOut(1) self.transitions.fadeIn(2) #TODO modularize for more characters self.exitMap() self.room = self.stage.doors[self.room][direction] NodePath(self.currentMap().getNode()).reparentTo(self.node) map = self.stage.maps[self.room] x, y = self.currentMap().posToGrid(char.getPos()) if direction == "right": x = 1 elif direction == "left": x = map.width-2 elif direction == "down": y = 1 elif direction == "up": y = map.height-2 pos = self.currentMap().gridToPos((x,y)) self.characters[self.player].setPos(pos) self.characters[self.player2].setPos(pos) self.characters[self.player2].setDirection(self.characters[self.player].direction) self.startMap() def register(self, render, camera, keys, render2d): State.register(self, render, camera, keys, render2d) self.node.attachNewNode(self.stage.maps[self.room].getNode()) for c in self.characters: self.status[c].reparentTo(self.node2d) for char in self.characters.values(): char.getNode().reparentTo(self.node) char.stunRender = self.node for l in self.stage.getLights(): render.setLight(l) # COWABUNGA test!!! self.hearts = {} numChar=0 self.heartsNode = NodePath(PandaNode('hearts')) self.heartsNode.reparentTo(self.node2d) for char in self.characters: self.hearts[char] = [] for i in range(Character.maxHearts): self.hearts[char].append(Sprite("heart.png", 0.05, 0.05)) self.hearts[char][i].setPos(-0.8 + 1.4*numChar + (i%3)*0.055 , -0.9 - int(i/3)*0.055) self.hearts[char][i].getNode().reparentTo(self.heartsNode) numChar += 1 #COWABUNGA comment this to stop the madness render.setAttrib(LightRampAttrib.makeSingleThreshold(0.1, 1)) # THE TRUE CARTOON SHADER :P # self.separation = 1 # Pixels self.filters = CommonFilters(base.win, self.camera.camera) # cell shading # filterok = self.filters.setCartoonInk(separation=self.separation) # glow filterok = self.filters.setBloom(blend=(0.5,0.5,0.5,1), desat=-0.5, intensity=0.5, size="small") self.camera.setPos(0, -2.5, -2.5) self.camera.lookAt(0, 0, 0) def iterate(self): State.iterate(self) self.camera.look() self.moveObjects() self.doCharActions() self.moveChars() self.buryDeadPeople() self.activateSwitches() self.updateHUD() for c in self.characters: self.characters[c].tryToRecover() if self.isOver: return "GameOver" elif self.keys['start']: return "Paused" def updateHUD(self): for c in self.characters: self.status[c].setText(self.characters[c].getStatus()) if self.characters[c].healthChanged: for heart in self.hearts[c]: heart.getNode().detachNode() for i in range(self.characters[c].hearts): self.hearts[c][i].getNode().reparentTo(self.heartsNode) self.characters[c].healthChanged = False def moveObjects(self): # BLOCK MOVEMENT ACTION for block in self.currentMap().blocks: if block.isMoving: block.move(block.direction) p1, p2 = block.getCollisionPos(block.direction) x1, y1 = self.currentMap().posToGrid(p1) x2, y2 = self.currentMap().posToGrid(p2) try: for x,y in [(x1,y1), (x2,y2)]: if self.stage.maps[self.room].tileType(1, (x,y)) == 'enemy': for enemy in self.currentMap().enemies: lPos = self.currentMap().posToGrid(enemy.getPos()) if tuple(lPos) == (x,y): self.collision(block, enemy) else: for char in self.characters: if (x,y) == self.currentMap().posToGrid(self.characters[char].getPos()): bx,by = self.currentMap().posToGrid(block.getPos()) self.currentMap().tiles[Map.COLLISION][by][bx] = ' ' self.characters[char].stun() block.stop() block.getNode().detachNode() except IndexError: block.stop() # LIFTABLE MOVEMENT ACTION for liftable in self.currentMap().liftables: if liftable.isMoving: liftable.move(liftable.direction) p1, p2 = liftable.getCollisionPos(liftable.direction) x1, y1 = self.currentMap().posToGrid(p1) x2, y2 = self.currentMap().posToGrid(p2) try: for x,y in [(x1,y1), (x2,y2)]: if self.stage.maps[self.room].tileType(1, (x,y)) == 'enemy': for enemy in self.currentMap().enemies: lPos = self.currentMap().posToGrid(enemy.getPos()) if tuple(lPos) == (x,y): self.collision(liftable, enemy) elif self.stage.maps[self.room].tileType(1, (x,y)) != 'free': liftable.stop() liftable.getNode().detachNode() else: for char in self.characters: if (x,y) == self.currentMap().posToGrid(self.characters[char].getPos()): print "Stun nele!" self.characters[char].stun() liftable.stop() liftable.getNode().detachNode() except IndexError: # to do, create a liftable.destroy(), which animates the liftable and do these two actions: liftable.stop() liftable.getNode().detachNode() def doCharActions(self): for char in [self.characters[self.player], self.characters[self.player2]]: add = "1" if char == self.characters[self.player]: add = "" if self.keys['attack'+add]: self.keys['attack'+add] = False print('Using %s' % (char.currentItem()) ) p1, p2 = char.getCollisionPos(char.direction) x1, y1 = self.currentMap().posToGrid(p1) x2, y2 = self.currentMap().posToGrid(p2) for x,y in [(x1,y1), (x2,y2)]: if self.stage.maps[self.room].tileType(Map.COLLISION, (x,y)) == 'door': for d in self.currentMap().doors: if tuple(self.currentMap().posToGrid(d.getPos())) == (x,y): opened = d.open(char.currentItem()) if opened: self.currentMap().tiles[Map.COLLISION][y][x] = ' ' char.destroyCurrentItem() if self.keys['cancel'+add]: self.keys['cancel'+add] = False print('Changing slot') char.changeSlot() if self.keys['action'+add]: self.keys['action'+add] = False if char.lifting: char.lifting.setHeight(0) char.lifting.move(char.direction) char.lifting = None else: p1, p2 = char.getCollisionPos(char.direction) x1, y1 = self.currentMap().posToGrid(p1) x2, y2 = self.currentMap().posToGrid(p2) for x,y in [(x1,y1), (x2,y2)]: if self.stage.maps[self.room].tileType(Map.COLLISION, (x,y)) == 'block': for block in self.currentMap().blocks: if tuple(self.currentMap().posToGrid(block.getPos())) == (x,y): GameLoader.music.playSfx('stone') block.move(char.direction) elif self.stage.maps[self.room].tileType(Map.COLLISION, (x,y)) == 'item': for item in self.currentMap().items: if tuple(self.currentMap().posToGrid(item.getPos())) == (x,y): self.collision(char, item) elif self.currentMap().tileType(Map.COLLISION, (x,y)) == 'liftable': for liftable in self.currentMap().liftables: lPos = self.currentMap().posToGrid(liftable.getPos()) if tuple(lPos) == (x,y): char.pick(liftable) self.currentMap().tiles[1][y][x] = ' ' def moveChars(self): for char in [self.characters[self.player], self.characters[self.player2]]: add = "1" if char == self.characters[self.player]: add = "" directions = [key for key in ["up","down","left","right"] if self.keys[key+add]] if len(directions) == 0: char.stop() for dir in directions: #TODO to be re-refactored p1, p2 = char.getCollisionPos(dir) if self.currentMap().futPosAreFree(p1, p2): char.move(dir) if char.lifting: char.lifting.setPos(char.getPos()) ex = self.stage.maps[self.room].getExit(self.currentMap().posToGrid(p1)) if ex and (ex in self.stage.doors[self.room].keys()): self.changeMap(ex,char) else: char.setDirection(dir) for enemy in self.currentMap().enemies: #TODO actually enemies are still present in the map x,y = self.currentMap().posToGrid(enemy.getPos()) self.currentMap().tiles[Map.COLLISION][y][x] = ' ' # COWABUNGA # se botarmos aqui uma funcao que define como o inimigo anda # vai dar tudo certo # por exemplo ele pode as vezes andar em direcao a um heroi e # as vezes ser random # por enquanto e so random # - OK, agreed dir = ['up','down','left','right'][random.randint(0,3)] p1, p2 = enemy.getCollisionPos(dir) if self.currentMap().futPosAreFree(p1, p2): enemy.enemy_move(dir) else: enemy.setDirection(dir) x,y = self.currentMap().posToGrid(enemy.getPos()) self.currentMap().tiles[Map.COLLISION][y][x] = 'e' p1, p2 = char.getCollisionPos(char.direction) x1, y1 = self.currentMap().posToGrid(p1) x2, y2 = self.currentMap().posToGrid(p2) for x,y in [(x1,y1), (x2,y2)]: collisionTiles = ["enemy"] collisionElements = {"enemy": self.currentMap().enemies} for t in collisionTiles: if self.stage.maps[self.room].tileType(Map.COLLISION, (x,y)) == t: for e in collisionElements[t]: lPos = self.currentMap().posToGrid(e.getPos()) if tuple(lPos) == (x,y): self.collision(char, e) def activateSwitches(self): mp = self.currentMap() for s in mp.switches: x,y = mp.posToGrid(s.getPos()) charPos = [self.currentMap().posToGrid(self.characters[char].getPos()) for char in self.characters] if mp.tiles[Map.COLLISION][y][x] != ' ' or ((x,y) in charPos): #print 'activated!' mp.tiles[Map.GROUND][y][x] = 'S' s.activate() else: #print 'deactivated!' mp.tiles[Map.GROUND][y][x] = 's' s.deactivate() for d in mp.doors: openDoor = True if d.openWith == "switches": for ds in d.switches: for ms in mp.switches: if (ds == ms.name) and (not ms.active): openDoor = False break if openDoor: d.open("switches") x,y = mp.posToGrid(d.getPos()) mp.tiles[Map.COLLISION][y][x] = ' ' def collision(self, a, b): print "Collision: TYPE A:", a.getType(), "TYPE B:", b.getType() if b.getType() == 'item': for i in range(len(self.currentMap().items)): if i < len(self.currentMap().items): #we need this because the size of the list may change if we remove an item if tuple(self.currentMap().items[i].getPos()) == tuple(b.getPos()): # removes the item self.currentMap().items.pop(i) x, y = self.currentMap().posToGrid((NodePath(b.getNode()).getX(), NodePath(b.getNode()).getZ())) # it's not drawed anymore self.currentMap().tiles[Map.COLLISION][y][x] = ' ' NodePath(b.getNode()).detachNode() #it's picked oldItem = a.pickItem(b) if oldItem != None: print oldItem.name oldItem.setPos(self.currentMap().gridToPos((x,y))) oldItem.originalPos = oldItem.getPos() self.spawnObject(oldItem) self.currentMap().items.append(oldItem) if a.getType() == 'liftable' or b.getType() == 'liftable': GameLoader.music.playSfx('barrel_breaks') if a.getType() == 'liftable' and b.getType() == 'enemy': a.stop() a.getNode().detachNode() x,y = self.currentMap().posToGrid(a.getPos()) #nao precisaria self.currentMap().tiles[Map.COLLISION][y][x] = ' ' b.takeDamage(10000) if not b.isAlive(): x, y = self.currentMap().posToGrid(b.getPos()) self.currentMap().tiles[Map.COLLISION][y][x] = ' ' NodePath(b.getNode()).removeNode() self.currentMap().enemies.remove(b) if a.getType() == 'block' and b.getType() == 'enemy': a.stop() a.getNode().detachNode() x,y = self.currentMap().posToGrid(a.getPos()) self.currentMap().tiles[Map.COLLISION][y][x] = ' ' b.takeDamage(10000) if not b.isAlive(): x, y = self.currentMap().posToGrid(b.getPos()) self.currentMap().tiles[Map.COLLISION][y][x] = ' ' NodePath(b.getNode()).removeNode() self.currentMap().enemies.remove(b) if a.getType() == 'Character': print("Character collided with", b.getType()) if b.getType() == 'enemy': a.takeDamage(1) def buryDeadPeople(self): # commented while fixing the bugs for enemy in self.currentMap().enemies: if not enemy.isAlive(): x, y = self.currentMap().posToGrid(enemy.getPos()) self.currentMap().tiles[Map.COLLISION][y][x] = ' ' NodePath(enemy.getNode()).removeNode() self.currentMap().enemies.remove(enemy) #if not self.player.isAlive() : #tratar isso corretamente! for char in self.characters: if not self.characters[char].isAlive(): self.isOver = True def enter(self): State.enter(self) self.stage.playMusic() def exit(self): # self.transitions.fadeOut(2) # self.transitions.fadeIn(3) # self.transitions.noFade() self.stage.stopMusic() # self.heartsNode.removeNode() # for c in self.characters: # NodePath(self.characters[c].getNode()).removeNode() # self.status[c].removeNode() # NodePath(self.currentMap().getNode()).removeNode() State.exit(self)
def __init__(self, mapID, tObj, aObj): self.mapID = mapID # EX: maps/map-1/map-1.yetimap metaFile = open("../maps/map" + str(self.mapID) + "/map" + str(self.mapID) + ".yetimap", 'r') metaLines = metaFile.readlines() lineCount = len(metaLines) self.snowflakeCount = lineCount - 2 self.snowCount = 0 # First Line: Player's starting position # EX: 50,50,50 (NO SPACES) playerLine = metaLines[0] playerPosList = playerLine.split(",") playerInitX = int(playerPosList[0]) playerInitY = int(playerPosList[1]) playerInitZ = int(playerPosList[2]) self.playerStart = Point3(playerInitX, playerInitY, playerInitZ) # 2nd Line: Deathzone Height # ONE INTEGER self.deathHeight = int(metaLines[1]) # Get dem snowflakes self.snowflakePositions = [] print("Snowflake Count: " + str(self.snowflakeCount)) for i in xrange(0, self.snowflakeCount): sfline = metaLines[i+2] sfList = sfline.split(",") sfx = int(sfList[0]) sfy = int(sfList[1]) sfz = int(sfList[2]) self.snowflakePositions.append(Point3(sfx, sfy, sfz)) print("New snowflake to add: (" + str(sfx) + "," + str(sfy) + "," + str(sfz) + ")") #load in controls ctrlFl = open("ctrConfig.txt") #will skip n lines where [n,] #makes a list of controls self.keymap = eval(ctrlFl.read()) #close file ctrlFl.close() # Create new instances of our various objects self.mapName = str(mapID) self.audioMgr = aObj self.worldObj = self.setupWorld() self.heightMap = self.setupHeightmap(self.mapName) self.deathZone = self.setupDeathzone(self.deathHeight) self.debugNode = self.setupDebug() # Player Init self.playerObj = SMPlayer(self.worldBullet, self.worldObj, self, self.playerStart, self.audioMgr) self.playerNP = self.playerObj.getNodePath() self.playerNP.setH(180); self.canUseShift = True self.canAirDash = True # Snowball Init self.ballObj = SMBall(self.worldBullet, self.worldObj, self.playerObj, self.playerNP) self.sbCollideFlag = False self.ballNP = self.ballObj.getNodePath() # Key Handler self.kh = SMKeyHandler() self.lastMousePos = self.kh.getMouse() # Collision Handler self.colObj = self.setupCollisionHandler() # Lighting self.ligObj = SMLighting(Vec4(.4, .4, .4, 1), Vec3(-5, -5, -5), Vec4(2.0, 2.0, 2.0, 1.0)) # Camera self.camObj = SMCamera(self.playerObj, self.worldBullet, self.worldObj) self.cameraControl = False # GUI self.GUI = SMGUI() self.snowflakeCounter = SMGUICounter("snowflake", self.snowflakeCount) # Replace 3 with # of snowflakes in level. self.snowMeter = SMGUIMeter(100) self.GUI.addElement("snowflake", self.snowflakeCounter) self.GUI.addElement("snowMeter", self.snowMeter) #Snowy Outside # base.enableParticles() # self.p = ParticleEffect() # self.p.cleanup() # self.p = ParticleEffect() # self.p.loadConfig('snow.ptf') # self.p.start(self.camObj.getNodePath()) # self.p.setPos(0.00, 0.500, 0.000) # AI # self.goat1 = SMAI("../res/models/goat.egg", 75.0, self.worldBullet, self.worldObj, -70, -95, 5) # self.goat1.setBehavior("flee", self.playerNP) # self.goat2 = SMAI("../res/models/goat.egg", 75.0, self.worldBullet, self.worldObj, -80, -83, 5) # self.goat2.setBehavior("flee", self.playerNP) # print("AI Initialized") # Debug Text self.textObj = tObj self.textObj.addText("yetiPos", "Position: ") self.textObj.addText("yetiVel", "Velocity: ") self.textObj.addText("yetiFric", "Friction: ") self.textObj.addText("onIce", "Ice(%): ") self.textObj.addText("onSnow", "Snow(%): ") self.textObj.addText("terrHeight", "T Height: ") self.textObj.addText("terrSteepness", "Steepness: ") # Pause screen transition self.transition = Transitions(loader) # Method-based keybindings # self.accept('b', self.spawnBall) self.accept('escape', base.userExit) self.accept('enter', self.pauseUnpause) self.accept('f1', self.toggleDebug) self.accept('lshift-up', self.enableShiftActions) self.accept('mouse1', self.enableCameraControl) self.accept('mouse1-up', self.disableCameraControl) self.accept('wheel_up', self.camObj.zoomIn) self.accept('wheel_down', self.camObj.zoomOut) self.pauseUnpause() # Disable the mouse base.disableMouse() props = WindowProperties() props.setCursorHidden(True) base.win.requestProperties(props) # Uncomment this to see everything being rendered. self.printSceneGraph() # Play the BGM self.audioMgr.playBGM("snowmanWind") # Skybox formed skybox = loader.loadModel("../res/models/skybox.egg") # skybox.set_two_sided(true) skybox.setScale(500) skybox.setPos(0, 0, -450) skybox.reparentTo(render) mountain = loader.loadModel("../res/models/mountain.egg") mountain.reparentTo(render) mountain.setPos(650,800,20) mountain.setScale(120) self.colObjects = [] self.caveNew = SMCollide("../res/models/cave_new.egg", self.worldBullet, self.worldObj, Point3(-50, 95, -13), 11, Vec3(0,0,0)) self.colObjects.append(self.caveNew) self.planeFront = SMCollide("../res/models/plane_front", self.worldBullet, self.worldObj, Point3(190, -100, -15), 8, Vec3(190,0,30)) self.colObjects.append(self.planeFront) self.caveModel = SMCollide("../res/models/cave_tunnel.egg", self.worldBullet, self.worldObj, Point3(233, 68, 32), 4, Vec3(135,180,0)) self.colObjects.append(self.caveModel) self.planeTail = SMCollide("../res/models/plane_tail.egg", self.worldBullet, self.worldObj, Point3(-40, -130, -7), 10, Vec3(230,0,0)) self.colObjects.append(self.planeTail) self.ropeBridge = SMCollide("../res/models/rope_bridge.egg", self.worldBullet, self.worldObj, Point3(180, 115, 30), 6, Vec3(50,0,0)) self.colObjects.append(self.ropeBridge) self.colObjectCount = len(self.colObjects) print("World initialized.")
class MakeAToon: def __init__(self): self.notify = DirectNotifyGlobal.directNotify.newCategory( "Starting Make A Toon.") self.localAvatar = LocalAvatar.toonBody base.localAvatar = self.localAvatar self.toonColors = Localizer.toonColorDict self.colorNum = 0 self.numColors = Localizer.numColors self.MakeAToonText = Localizer.MakeAToonText self.Mickey = Localizer.Mickey self.mickeyFont = loader.loadFont( 'phase_3/models/fonts/MickeyFont.bam') self.Text = OnscreenText(text="Make A Toon", pos=(0, 0.75), font=self.mickeyFont, fg=(1, 0, 0, 1), scale=(0.2, 0.2, 0.2)) self.gui = loader.loadModel( 'phase_3/models/gui/tt_m_gui_mat_mainGui.bam') self.gui.flattenMedium() self.gui1 = loader.loadModel( 'phase_3/models/gui/create_a_toon_gui.bam') self.gui2 = loader.loadModel('phase_3/models/gui/gui_toongen.bam') self.guiNextUp = self.gui.find('**/tt_t_gui_mat_nextUp') self.transition = Transitions(loader) self.transition.irisIn(1) self.transition.fadeIn(5) self.load() def load(self): self.Music = loader.loadMusic('phase_3/audio/bgm/create_a_toon.mid') self.Music.setLoop(1) self.MusicVolume = (0.4) self.Music.play() self.Music.setVolume(self.MusicVolume) base.localAvatar.setPos(0.80, 2, 0) base.localAvatar.setHpr(176, 0, 0) LocalAvatar.setMovementAnimation('neutral') self.room = loader.loadModel('phase_3/models/gui/create_a_toon.bam') self.room.reparentTo(render) self.room.find('**/sewing_machine').removeNode() self.room.find('**/drafting_table').removeNode() self.room.find("**/wall_floor").setColor(0.7294117647058824, 0.5490196078431373, 0.2392156862745098, 1) self.room.setName("Room") self.ee = DirectFrame(pos=(-1, 1, 1), frameSize=(-.01, 0.01, -.01, 0.01), frameColor=(0, 0, 0, 0.05), state='normal') self.ee.bind(DGG.B1PRESS, lambda x, ee=self.ee: self.toggleSlide()) self.eee = self.ee self.toonSpin = base.localAvatar.hprInterval(2, Vec3(540, 0, 0)) self.toonSpin2 = base.localAvatar.hprInterval(2, Vec3(180, 0, 0)) self.CameraMove = camera.posInterval(1, Point3(-0.50, -11, 3), startPos=Point3(1, -11, 3)) self.CameraMoveSequence = Sequence(self.CameraMove) self.ToonEnter = base.localAvatar.posInterval(1, Point3(0.60, 2, 0), startPos=Point3( -4, 2, 0)) self.ToonEnterPace = Sequence(self.ToonEnter) self.ToonEnter.start() self.oobeButton = DirectButton( clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom=(self.gui1.find("**/CrtATn_R_Arrow_UP"), self.gui1.find("**/CrtATn_R_Arrow_DN"), self.gui1.find("**/CrtATn_R_Arrow_RLVR")), relief=None, hpr=(0, 0, 180), command=self.goBack) self.oobeButton.setScale(1) self.oobeButton.setPos(-0.70, 3, -0.25) self.goBackButton = DirectButton( clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom=(self.gui1.find("**/CrtATn_R_Arrow_UP"), self.gui1.find("**/CrtATn_R_Arrow_DN"), self.gui1.find("**/CrtATn_R_Arrow_RLVR")), relief=None, command=self.goRight) self.goBackButton.setScale(1) self.goBackButton.setPos(0.80, 3, -0.25) self.spinButton = DirectButton( clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom=(self.gui1.find("**/CrtATn_R_Arrow_UP"), self.gui1.find("**/CrtATn_R_Arrow_DN"), self.gui1.find("**/CrtATn_R_Arrow_RLVR")), relief=None, command=self.HprToon) self.spinButton.setScale(0.60) self.spinButton.setPos(0.50, 2, -0.50) self.spinButton2 = DirectButton( clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom=(self.gui1.find("**/CrtATn_R_Arrow_UP"), self.gui1.find("**/CrtATn_R_Arrow_DN"), self.gui1.find("**/CrtATn_R_Arrow_RLVR")), relief=None, hpr=(0, 0, 180), command=self.HprToon2) self.spinButton2.setScale(0.60) self.spinButton2.setPos(-0.40, 2, -0.50) self.OK = DirectButton(clickSound=Globals.getClickSound(), rolloverSound=Globals.getRlvrSound(), geom=(self.gui2.find("**/tt_t_gui_mat_okUp"), self.gui2.find("**/tt_t_gui_mat_okDown")), pos=(0.90, 1, -0.80), relief=None, command=self.CameraButton) def goRight(self): for color in self.toonColors[self.colorNum]: LocalAvatar.bodyNodes[color].setColor( self.toonColors[self.colorNum][color]) self.colorNum += 1 if self.colorNum > self.numColors: self.colorNum = 0 def goBack(self): for color in self.toonColors[self.colorNum]: LocalAvatar.bodyNodes[color].setColor( self.toonColors[self.colorNum][color]) self.colorNum -= 1 if self.colorNum < 0: self.colorNum = self.numColors def HprToon(self): self.toonSpin.start() def HprToon2(self): self.toonSpin2.start() def CameraButton(self): self.transition.irisIn() self.transition.fadeOut(1) self.Music.stop()