class MyApp(ShowBase): def __init__(self): ShowBase.__init__(self) # Turn Auto Shaders and Antialiasing self.render.setShaderAuto() self.render.setAntialias(AntialiasAttrib.MAuto) # Setup Bloom and Blur Filters self.filters = CommonFilters(base.win, base.cam) self.filters.setBloom(blend=(1,0,0,1), desat=-0.5, intensity=6.0, size=2) #self.filters.setBlurSharpen(amount=0.5) # Create Ambient Lighting alight = AmbientLight('alight') alight.setColor(VBase4(1, 1, 1, 1)) alnp = render.attachNewNode(alight) self.render.setLight(alnp) # Load Model and Add it to Scene self.environ = self.loader.loadModel("untitled.egg") self.environ.reparentTo(self.render) self.environ.setTransparency(TransparencyAttrib.MAlpha)
class MyApp(ShowBase): def __init__(self): ShowBase.__init__(self) # Turn Auto Shaders and Antialiasing self.render.setShaderAuto() self.render.setAntialias(AntialiasAttrib.MAuto) # Setup Bloom and Blur Filters self.filters = CommonFilters(base.win, base.cam) self.filters.setBloom(blend=(1, 0, 0, 1), desat=-0.5, intensity=6.0, size=2) #self.filters.setBlurSharpen(amount=0.5) # Create Ambient Lighting alight = AmbientLight('alight') alight.setColor(VBase4(1, 1, 1, 1)) alnp = render.attachNewNode(alight) self.render.setLight(alnp) # Load Model and Add it to Scene self.environ = self.loader.loadModel("untitled.egg") self.environ.reparentTo(self.render) self.environ.setTransparency(TransparencyAttrib.MAlpha)
class GlowDemo(ShowBase): def __init__(self): ShowBase.__init__(self) base.setBackgroundColor(0, 0, 0) # render.setShaderAuto() # Load the Lights ambilight = AmbientLight('ambilight') ambilight.setColor(VBase4(1, 1, 1, 1)) render.setLight(render.attachNewNode(ambilight)) self.filters = CommonFilters(base.win, base.cam) self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.8, intensity=4.0, size="big") # self.glowSize=4 # ts = TextureStage('ts') # ts.setMode(TextureStage.MGlow) self.tron = loader.loadModel("data/models/vehicles/vehicle01") self.tron.reparentTo(render) self.tron2 = loader.loadModel("data/models/vehicles/vehicle02") self.tron2.reparentTo(render) self.tron2.setX(5) self.tron3 = loader.loadModel("data/models/vehicles/vehicle03") self.tron3.reparentTo(render) self.tron3.setX(-5)
class BurdenOfProof(ShowBase): def __init__(self): ShowBase.__init__(self) self.useAdvancedVisualEffects = ConfigVariableBool( "use-advanced-visual-effects", True) self.game = Game() self.setupFilters() self.setupModels() self.setupKeyboardControl() self.motionController = MotionController(self) self.camera.setPos(0.0, 0.0, 1.7) def setupKeyboardControl(self): self.accept("escape", sys.exit) def setupFilters(self): if (self.useAdvancedVisualEffects): self.filters = CommonFilters(self.win, self.cam) self.filters.setBloom() def setupModels(self): self.cityModel = self.loader.loadModel("data/models/city") self.cityModel.reparentTo(self.render) self.cityModel.setP(-90.0) self.pandaActor = Actor("models/panda-model", {"walk": "models/panda-walk4"}) self.pandaActor.setScale(0.005, 0.005, 0.005) self.pandaActor.loop("walk") population = self.game.getPopulation() self.characterInstances = [] for i in range(1, population.getCharacterCount()): instance = self.render.attachNewNode("characterInstance") instance.setPos( population.getCharacter(i).getPosition(self.game.getTime())) self.pandaActor.instanceTo(instance) self.characterInstances.append(instance) self.taskMgr.add(self.update, "updateTask") def update(self, task): self.game.update(oneMinute) # TODO(?) compute actual milliseconds population = self.game.getPopulation() for i in range(1, population.getCharacterCount()): self.characterInstances[i - 1].setPos( population.getCharacter(i).getPosition(self.game.getTime())) return Task.cont
class BurdenOfProof(ShowBase): def __init__(self): ShowBase.__init__(self) self.useAdvancedVisualEffects = ConfigVariableBool( "use-advanced-visual-effects", True) self.game = Game() self.setupFilters() self.setupModels() self.setupKeyboardControl() self.motionController = MotionController(self) self.camera.setPos(0.0, 0.0, 1.7) def setupKeyboardControl(self): self.accept("escape", sys.exit) def setupFilters(self): if (self.useAdvancedVisualEffects): self.filters = CommonFilters(self.win, self.cam) self.filters.setBloom() def setupModels(self): self.cityModel = self.loader.loadModel("data/models/city") self.cityModel.reparentTo(self.render) self.cityModel.setP(-90.0) self.pandaActor = Actor("models/panda-model", {"walk": "models/panda-walk4"}) self.pandaActor.setScale(0.005, 0.005, 0.005) self.pandaActor.loop("walk") population = self.game.getPopulation() self.characterInstances = [] for i in range(1, population.getCharacterCount()): instance = self.render.attachNewNode("characterInstance") instance.setPos( population.getCharacter(i).getPosition(self.game.getTime())) self.pandaActor.instanceTo(instance) self.characterInstances.append(instance) self.taskMgr.add(self.update, "updateTask") def update(self, task): self.game.update(oneMinute) # TODO(?) compute actual milliseconds population = self.game.getPopulation() for i in range(1, population.getCharacterCount()): self.characterInstances[i - 1].setPos( population.getCharacter(i).getPosition(self.game.getTime())) return Task.cont
def postProcessingChanged(): global filters if enablePostProcessing: if filters == None: filters = CommonFilters(base.win, base.cam) render.setAttrib(LightRampAttrib.makeHdr1()) filters.setBloom(intensity = 1, size = 2) else: if filters != None: filters.delBloom() saveConfigFile()
def __init__(self): ShowBase.__init__(self) # Gui #gui = GUI(self) render.setShaderAuto() self.game = Game(self) filters = CommonFilters(base.win, base.cam) filters.setBloom() filters.setCartoonInk()
def __init__(self): super().__init__(self) self.var1 = 0 self.scene = loader.loadModel("models/world") playerTexture = loader.loadTexture("models/starfoxShip.jpg") self.player = self.scene.find("player") self.player.setTexture(playerTexture) base.setBackgroundColor(0.1, 0.1, 0.1, 1) enemyTexture = loader.loadTexture("models/enemyShip.jpg") self.enemy = self.scene.find("enemy1") self.enemy.setTexture(enemyTexture) self.basePlane = self.scene.find("basePlane") self.scene.reparentTo(self.render) self.player.setPos(50, 50, 3) self.enemy.setPos(50, 55, 0) self.ambient = AmbientLight("ambient") self.ambient.color = (0.1, 0.1, 0.1, 1) self.ambientPath = self.render.attachNewNode(self.ambient) render.setLight(self.ambientPath) self.dirLight = DirectionalLight("dir light") self.dirLight.color = (1, 1, 1, 1) self.dirLightPath = self.render.attachNewNode(self.dirLight) self.dirLightPath.setHpr(0, -90, 0) self.dirLight.setShadowCaster(True, 512, 512) render.setLight(self.dirLightPath) self.pointLight = PointLight("point light") self.pointLight.color = (1, 1, 1, 1) self.pointLightPath = self.render.attachNewNode(self.pointLight) self.pointLightPath.setPos(50, 52.5, 4) self.pointLight.attenuation = (.5, 0, 0) self.pointLight.setShadowCaster(True, 1024, 1024) self.render.setLight(self.pointLightPath) self.fog = Fog("fog") self.fog.setColor(0.1, 0.1, 0.1) self.fog.setExpDensity(.3) self.fog.setLinearRange(150, 300) self.fog.setLinearFallback(45, 160, 320) self.render.setFog(self.fog) self.render.setShaderAuto() self.render.setAntialias(AntialiasAttrib.MAuto) filters = CommonFilters(base.win, base.cam) filters.setBloom(size="large") filters.setAmbientOcclusion(strength=0.6, falloff=0.0005, radius=0.1) filters.setCartoonInk(separation=2, color=(0, 0, 0, 1)) self.taskMgr.add(self.update, "update")
def postProcessingChanged(): global filters if enablePostProcessing: if filters == None: filters = CommonFilters(base.win, base.cam) render.setAttrib(LightRampAttrib.makeHdr1()) filters.setBloom(intensity=1, size=2) else: if filters != None: filters.delBloom() saveConfigFile()
def _loadFilters(self): self.terrain.setShaderInput('waterlevel', self._water_level) # load default shaders cf = CommonFilters(base.win, base.cam) # bloomSize cf.setBloom(size='small', desat=0.7, intensity=1.5, mintrigger=0.6, maxtrigger=0.95) # hdrtype: render.setAttrib(LightRampAttrib.makeHdr1()) # perpixel: render.setShaderAuto()
def _loadFilters(self): self.terrain.setShaderInput('waterlevel', self._water_level) # load default shaders cf = CommonFilters(base.win, base.cam) #bloomSize cf.setBloom(size='small', desat=0.7, intensity=1.5, mintrigger=0.6, maxtrigger=0.95) #hdrtype: render.setAttrib(LightRampAttrib.makeHdr1()) #perpixel: render.setShaderAuto()
class Filters: """Class handles postprocessing filters and effects""" def __init__(self,manager,xml): self.cf = CommonFilters(base.win,base.cam) self.reload(manager,xml) def reload(self,manager,xml): hdr = xml.find('hdr') if hdr!=None: self.hdrtype = hdr.get('type') assert self.hdrtype in ['0', '1', '2'] else: self.hdrtype = None self.perpixel = xml.find('perpixel')!=None bloom = xml.find('bloom') if bloom!=None: self.bloomSize = bloom.get('size', 'medium') else: self.bloomSize = None self.showbuffers = xml.find('showbuffers')!=None def start(self): if self.hdrtype!=None: render.setAttrib(getattr(LightRampAttrib, "makeHdr" + self.hdrtype)()) if self.perpixel: render.setShaderAuto() if self.bloomSize!=None: self.cf.setBloom(size=self.bloomSize) if self.showbuffers: base.bufferViewer.toggleEnable() def stop(self): if self.hdrtype!=None: render.clearAttrib(LightRampAttrib.getClassType()) if self.perpixel: render.setShaderOff() if self.bloomSize!=None: self.cf.delBloom() if self.showbuffers: base.bufferViewer.toggleEnable()
class ShaderManager(): def __init__(self): #needed for physics and particle system base.enableParticles() render.setShaderAuto() def setBloomed(self): #setupfilters and shaders self.filters = CommonFilters(base.win, base.cam) #self.filters.setCartoonInk(separation=1.0) self.filters.setBloom(size="small") #self.filters.setVolumetricLighting(myCamera.cameraLightNode) render.setAttrib(LightRampAttrib.makeHdr0()) pass
def __init__(self): base.enableParticles() # noqa: F821 render.setShaderAuto() # noqa: F821 self._explosion_lights = self._set_explosion_lights() self._transition = Transitions(loader) # noqa: F821 self._transition.setFadeColor(0, 0, 0) self.stench_effect = Stench() self.love_fog = LoveFog() filters = CommonFilters(base.win, base.cam) # noqa: F821 filters.setBloom(size="large", mintrigger=0.8, intensity=2.1)
def __init__(self): super().__init__() self.set_background_color(0, 0, 0, 1) self.cam.setPos(0, -12, 0) self.trees = NodePath("trees") self.tree1 = self.loader.loadModel('my-models/christmas_tree') self.tree1.setPos(0, 0, -2.5) self.tree1.reparentTo(self.trees) self.tree2 = self.loader.loadModel('my-models/christmas_tree') self.tree2.setPos(4, 5, -2.5) self.tree2.reparentTo(self.trees) self.tree3 = self.loader.loadModel('my-models/christmas_tree') self.tree3.setPos(-4, 7, -2.5) self.tree3.reparentTo(self.trees) self.trees.reparentTo(self.render) self.floor = self.loader.loadModel('my-models/floor') self.floor.setPos(0, 0, -2.5) self.floor.reparentTo(self.render) self.light_model = self.loader.loadModel('models/misc/sphere') self.light_model.setScale(0.2, 0.2, 0.2) # self.light_model.setPos(4, -4, 0) self.light_model.reparentTo(self.render) plight = PointLight("plight") plight.setShadowCaster(True, 1024, 1024) self.render.setShaderAuto() plnp = self.light_model.attachNewNode(plight) # plight.setAttenuation((1, 0, 0)) # constant, linear, and quadratic. self.trees.setLight(plnp) alight = AmbientLight("alight") alight.setColor((0.04, 0.04, 0.04, 1)) alnp = self.render.attachNewNode(alight) self.trees.setLight(alnp) self.floor.setLight(plnp) self.floor.setLight(alnp) filters = CommonFilters(self.win, self.cam) filters.setBloom(size="large") self.taskMgr.add(self.move_light, "move-light")
class World: def __init__(self): base.disableMouse() # Turns off the default mouse-camera controls in Panda3D. base.setBackgroundColor(0, 0, 0) # Sets the background to black. self.inputManager = InputManager() # Creates an InputManager to handle all of the user input in the game. self.track = Track() # Creates the track the cycles will race on. self.cycle1 = Cycle(self.inputManager, self.track, 1, "Bert", ai=False) self.cycle2 = Cycle(self.inputManager, self.track, 2, "Ernie") # Creates one uncontrolled cycle, and one player controlled cycle. taskMgr.doMethodLater(10, self.debugTask, "Debug Task") # Tells the debugTask to run once every ten seconds. The debug task is a good # place to put various data print outs about the game to help with debugging. self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size=2) render.setShaderAuto() # Turns on Panda3D's automatic shader generation. def debugTask(self, task): print(taskMgr) # prints all of the tasks in the task manager. return task.again
class World: def __init__(self): base.disableMouse() # Turns off the default mouse-camera controls in Panda3D. base.setBackgroundColor(0, 0, 0) # Sets the background to black. self.inputManager = InputManager() # Creates an InputManager to handle all of the user input in the game. taskMgr.doMethodLater(10, self.debugTask, "Debug Task") # Tells the debugTask to run once every ten seconds. The debug task is a good # place to put various data print outs about the game to help with debugging. self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size=2) render.setShaderAuto() # Turns on Panda3D's automatic shader generation. self.menuGraphics = loader.loadModel("../Models/MenuGraphics.egg") self.fonts = { "silver": loader.loadFont("../Fonts/LuconSilver.egg"), "blue": loader.loadFont("../Fonts/LuconBlue.egg"), "orange": loader.loadFont("../Fonts/LuconOrange.egg") } self.race = Race(self.inputManager) self.race.createDemoRace() self.createStartMenu() def createStartMenu(self): menu = Menu(self.menuGraphics, self.fonts, self.inputManager) menu.initMenu([ 0, None, ["New Game", "Quit Game"], [[self.race.createRace, self.createReadyDialogue], [base.userExit]], [[None, None], [None]] ]) def createReadyDialogue(self): menu = Menu(self.menuGraphics, self.fonts, self.inputManager) menu.initMenu([ 3, "Are you ready?", ["Yes", "Exit"], [[self.race.startRace], [self.race.createDemoRace]], [[3], [None]] ]) def debugTask(self, task): print(taskMgr) # prints all of the tasks in the task manager. return task.again
class Filters(): def __init__(self): self.filters = CommonFilters(base.win, base.cam) self.glowShader = loader.loadShader("./shaders/glowShader.sha") def enableFilters(self, player): #self.filters.setBloom(mintrigger=.35) self.filters.setBloom(blend=(1, 0, .2, 1), desat=-1, intensity=10, size="small") #self.filters.setCartoonInk(separation=-5) self.filters.setAmbientOcclusion(numsamples = 2, radius = 0.0025, amount = 2, strength = 0.001, falloff = 0.01) player.setShader(self.glowShader) player.setShaderInput("scale",4,4) path = render.find("renderDummy") path.setShader(self.glowShader) path.setShaderInput("scale",1,1,1)
def __init__(self, app_object): self.app = app_object self.n = 0 cmnd = "" self.commandBox = "" self.store = ["","","",""] ShowBase.__init__(self) self.title1 = self.AddTitle(-0.65, "Type your commands here:") self.title2 = self.AddTitle(0.90, "You have entered:") self.instArea = self.AddInstructions(0.82, cmnd) self.cmndArea = self.AddArea() base.setFrameRateMeter(True) base.setBackgroundColor(0,0,0) self.cube = loader.loadModel("models/cube") self.cube.setPos(0, 0, 0) self.cube.reparentTo(self.render) self.cube.setScale((cx), 3, 1) # cam self.cam.setPos(60, -80, 22) light = PointLight('light') self.render.setLight(self.cam.attachNewNode(light)) self.cam.lookAt(self.cube) self.i = 1 self.sy = 1 self.sx = 1 self.sz = 1 self.addx =1 self.addy =1 self.addz =1 #self.negy = -7 #self.posy = 7 #CENTER #setting up the bloom effect filters = CommonFilters(base.win, base.cam) filters.setBloom(blend=(0.0,0.0,0.0,1.0), mintrigger = 0.9, desat=-0.5, intensity=8.0, size="small") rootDir = os.path.abspath(os.path.dirname(sys.argv[0])) loadPrcFile(os.path.join(rootDir, "config.prc"))
def __init__(self): super().__init__() self.set_background_color(0, 0, 0, 1) self.cam.setPos(0, -80, 0) self.sphere = self.loader.loadModel('models/misc/sphere') self.sphere.setScale(0.5) self.sphere.reparentTo(self.render) my_curve = Mopath.Mopath() my_curve.loadFile("my-models/curvey") my_interval = MopathInterval(my_curve, self.sphere, name="my-path", duration=8) # my_interval.start() my_interval.loop() filters = CommonFilters(self.win, self.cam) filters.setBloom(size="medium") print(my_curve.xyzNurbsCurve.getNumKnots()) print(my_curve.xyzNurbsCurve.getOrder()) print(my_curve.xyzNurbsCurve.getNumCvs()) print(my_curve.xyzNurbsCurve.getKnots())
def runConfiguration(): #Grundeinstellungen base.setFrameRateMeter(True) base.setBackgroundColor(0, 0, 0) #Bloom Filter CFilters = CommonFilters(base.win, base.cam) filterok = CFilters.setBloom(blend=(0, 0, 0, 1), desat=-0.1, mintrigger=0.0, intensity=6.0, size="small") if filterok == 0: print "Deine Grafikkarte unterstuetzt kein Bloom Filter: Shader Error"
class World: def __init__(self): base.disableMouse() base.setBackgroundColor(0.52, 0.80, 0.99) self.inputManager = InputManager() self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size=2) render.setShaderAuto() self.menuGraphics = loader.loadModel("Models/MenuGraphics.egg") self.fonts = { "silver": loader.loadFont("Fonts/LuconSilver.egg"), "blue": loader.loadFont("Fonts/LuconBlue.egg"), "orange": loader.loadFont("Fonts/LuconOrange.egg") } gui = Gui(self.fonts) self.race = Race(self.inputManager, gui) self.race.createDemoRace() self.createStartMenu() musicMgr = base.musicManager self.music = musicMgr.getSound("Sound/music_1.wav") self.music.setLoop(True) self.music.setVolume(.5) self.music.play() def createStartMenu(self): menu = Menu(self.menuGraphics, self.fonts, self.inputManager) menu.initMenu([0, None, ["New Game", "Quit Game"], [[self.race.createRace, self.createReadyDialogue], [base.userExit]], [[None, None], [None]]]) def createReadyDialogue(self): menu = Menu(self.menuGraphics, self.fonts, self.inputManager) menu.initMenu([3, "Ready?", ["Yes", "Exit"], [[self.race.startRace], [self.race.createDemoRace]], [[3], [None]]]) def debugTask(self, task): print(taskMgr) return task.again
class World(ShowBase): # CONDISER: change to DirectObject/FSM def __init__(self): ShowBase.__init__(self) self.createLoadScreen('./LEGameAssets/Textures/title_screen.png') base.graphicsEngine.renderFrame() #== Environment and Rendering Settings == base.setFrameRateMeter(FLAG_SHOW_FRAMES_PER_SECOND) if FLAG_USE_AUTOSHADER: render.setShaderAuto() self.filters = CommonFilters(base.win, self.cam) # NEW if FLAG_SHOW_GLOW: bloomSize = 4#'small' filterok = self.filters.setBloom(blend=(0,0,0,1), desat=-0.5, intensity=3.0, size=bloomSize) if (filterok == False): print 'WARNING:Video card not powerful enough to do image postprocessing' #tex = loader.loadTexture("./LEGameAssets/Textures/loadbar_tray.png") self.loadBar = DirectWaitBar(text = "", value = 0, scale =(.35,.5,.5), pos = (0.006,.83,.83)) #self.loadBar['barRelief'] = DirectWaitBar.GROOVE #self.loadBar['scale'] = 0.05 #self.loadBar['barTexture'] = tex self.loadBar['barColor'] = (6.0/255.0, 11.0/255, 28.0/255.0, 1) self.loadBar.reparentTo(render2d) self.loadBar.hide() base.graphicsEngine.renderFrame() self.setBackgroundColor(166.0/255.0,207.0/255.0,240.0/255.0,1) self.skybox = self.loader.loadModel("LEGameAssets/Models/skybox_final.egg") self.skybox.setScale(50) self.skybox.reparentTo(render) #== Load the level and the managers == self.assets, self.objects, self.gameObjects, self.sounds, self.sequences= loadWorld(SCENE_FILE, LIBRARY_INDEX) self.loadBar['value'] += 5 base.graphicsEngine.renderFrame() self.conversations = loadConversations(SCENE_FILE, LIBRARY_INDEX) self.scenes = {} self.loadScenes() self.loadBar['value'] += 5 base.graphicsEngine.renderFrame() self.journalMgr = JournalMgr(self) self.loadJournal(self.journalMgr,JOURNAL_FILE) self.conversationMgr = ConversationMgr(self, self.conversations) self.scriptMgr = ScriptMgr(self) self.scriptMgr.loadScripts(SCRIPTS_LIST) self.scriptInterface = ScriptInterface(self) self.inventoryMgr = InventoryMgr(self) loadInventory(self.inventoryMgr,INVENTORY_FILE) self.loadBar['value'] += 5 base.graphicsEngine.renderFrame() self.ranSequences = [] #== Main Character == self.hero = None for name, gameObj in self.gameObjects.iteritems(): if gameObj.getNP().hasTag('LE-mainChar'): self.hero = gameObj break else: # make a default hero defaultHeroNP = loader.loadModel("panda") self.hero = GameObject(defaultHeroNP) self.hero.reparentTo(render) self.hero.setPos(0, 0, 0) self.hero.setTag('LE-mainChar', '180') self.gameObjects[self.hero.getName()] = self.hero self.setCollideMasks(self.gameObjects) # remove the hero from the objects dict so it cannot be clicked by player if self.hero.getName() in self.objects: del self.objects[self.hero.getName()] #== Camera == camHeightFactor = CAMERA_HEIGHT camTrailFactor = -CAMERA_TRAIL # careful of +/- distinction self.heroHeight = self.getModelHeight(self.hero) self.heroHeadingOffset = float(self.hero.getTag('LE-mainChar')) self.lastHeroH = self.hero.getH(render) + self.heroHeadingOffset # setup the camera pivot, which will follow the main character model and anchor the camera self.camPivot = NodePath('camPivot') self.camPivot.reparentTo(render) self.camHeight = camHeightFactor*self.heroHeight self.camTrail = camTrailFactor*self.heroHeight self.cam.setPos(self.camPivot.getPos() + (0, self.camTrail, self.camHeight)) self.cam.wrtReparentTo(self.camPivot) self.placeCamera(self.hero) # match X and Y to main character self.alignCamera(self.hero) # match heading to main character #self.camPivot.setH(render, self.hero.getH(render) + self.heroHeadingOffset) self.gameCam = self.cam #== Collisions == self.setupCollisions() #== Controls == self.disableMouse() self.keyMap = { 'w':False, 'a':False, 's':False, 'd':False } self.enableMovement(self.hero) self.accept("mouse1", self.onClickin3D) self.accept('escape', sys.exit) self.accept('z', render.place) #== UI and Combat == self.gameplayUI = GameplayUI(self) self.gameplayUI.hideAll() # for health bars and on screen UI self.overlayAmbientLight = AmbientLight('overlayAmbientLight') self.overlayAmbientLight.setColor(VBase4(1.0, 1.0, 1.0, 1.0)) self.overlayAmbientLightNP = render.attachNewNode(self.overlayAmbientLight) # initialize the combat manager (which includes AI) now that a main character and gameplayUI instance and overlay light is established self.combatMgr = CombatMgr(self) # initialize player's spells self.heroSpells = [] for properties in PLAYER_SPELLS: spell = Spell(self.hero, properties) self.heroSpells.append(spell) #== Start Tasks taskMgr.add(self.moveHeroTask, 'moveHeroTask', appendTask=True) taskMgr.add(self.cameraFollowTask, 'cameraFollowTask', appendTask=True) taskMgr.add(self.processHeroCollisions, 'processHeroCollisions') taskMgr.add(self.updateHeroHeight, 'updateHeroHeight') self.combatMgr.startTasks() self.accept('enter', self.destroyLoadScreen) self.destroyLoadScreen() ##== Utility and World Initialization functions =============================## def loadJournal(self,journalMgr,journalFile): f = open(Filename(journalFile).toOsSpecific()) doc = xml.dom.minidom.parse(f) root = doc.childNodes[0] for n in root.childNodes: if n.localName == "journalEntries": journalMgr.decode(n) f.close() def getModelHeight(self, model): min, max = Point3(), Point3() model.calcTightBounds(min, max) return max.getZ() - min.getZ() def createLoadScreen(self, imageFile='./LEGameAssets/Textures/load_screen.png'): self.loadScreen = OnscreenImage(image=imageFile) aspect2d.hide() self.loadScreen.reparentTo(render2d) if(hasattr(self, "gameplayUI")): self.gameplayUI.hideAll() def destroyLoadScreen(self): self.loadBar.hide() self.loadScreen.detachNode() self.loadScreen.destroy() aspect2d.show() self.ignore('enter') self.gameplayUI.showAll() for name, gameObj in self.gameObjects.iteritems(): gameObj.callTrigger(self, 'LE-trigger-onScene') def startLoadBar(self, range=100): self.loadBar.show() self.loadBar['range'] = range self.loadBar['value'] = 0 base.graphicsEngine.renderFrame() def increaseLoadBar(self, value): self.loadBar['value'] += value base.graphicsEngine.renderFrame() ##== Collisions =============================================================## def setupCollisions(self): self.cTrav = CollisionTraverser('mainTraverser') self.cTrav.setRespectPrevTransform(True) # Line collider for setting hero height based on ground geometry heroLine = CollisionNode('heroLine') heroLine.addSolid(CollisionRay(Point3(0,0,self.heroHeight), Vec3(0,0,-1))) heroLine.setFromCollideMask(BITMASK_GROUND) heroLine.setIntoCollideMask(BitMask32.allOff()) self.heroGroundCollide = render.attachNewNode(heroLine) self.heroGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.heroGroundCollide, self.heroGroundHandler) # cameraSphere = CollisionNode('cameraSphere') # cameraSphere.addSolid(CollisionSphere(0,0,0,10)) # cameraSphere.setFromCollideMask(BITMASK_CAMERA) # cameraSphere.setIntoCollideMask(BitMask32.allOff()) # self.cameraSphereCollide = self.cam.attachNewNode(cameraSphere) # self.cameraSphereQueue = CollisionHandlerQueue() # self.cTrav.addCollider(self.cameraSphereCollide, self.cameraSphereQueue) self.herowallcollision = False self.heroWallCollideX = render.attachNewNode("heroWallX") self.heroWallCollideY = render.attachNewNode("heroWallY") self.heroWallCollideZ = render.attachNewNode("heroWallZ") # Line collider for running into obstacles and walls in X direction heroLineX = CollisionNode('heroLineX') heroLineX.addSolid(CollisionRay(Point3(0,0,0), Vec3(0,0,1))) self.heroWallCollideLineX = self.heroWallCollideX.attachNewNode(heroLineX) self.heroWallCollideLineX.node().setFromCollideMask(BITMASK_WALL_TERRAIN) self.heroWallCollideLineX.node().setIntoCollideMask(BitMask32.allOff()) self.heroWallQueueX = CollisionHandlerQueue() self.cTrav.addCollider(self.heroWallCollideLineX, self.heroWallQueueX) # Line collider for running into obstacles and walls in Y direction heroLineY = CollisionNode('heroLineY') heroLineY.addSolid(CollisionRay(Point3(0,0,0), Vec3(0,0,1))) self.heroWallCollideLineY = self.heroWallCollideY.attachNewNode(heroLineY) self.heroWallCollideLineY.node().setFromCollideMask(BITMASK_WALL_TERRAIN) self.heroWallCollideLineY.node().setIntoCollideMask(BitMask32.allOff()) self.heroWallQueueY = CollisionHandlerQueue() self.cTrav.addCollider(self.heroWallCollideLineY, self.heroWallQueueY) # Line collider for running into obstacles and walls in Z direction heroLineZ = CollisionNode('heroLineZ') heroLineZ.addSolid(CollisionRay(Point3(0,0,0), Vec3(0,0,1))) self.heroWallCollideLineZ = self.heroWallCollideZ.attachNewNode(heroLineZ) self.heroWallCollideLineZ.node().setFromCollideMask(BITMASK_WALL_TERRAIN) self.heroWallCollideLineZ.node().setIntoCollideMask(BitMask32.allOff()) self.heroWallQueueZ = CollisionHandlerQueue() self.cTrav.addCollider(self.heroWallCollideLineZ, self.heroWallQueueZ) # # Sphere collider for running into obstacles and walls # heroSphere = CollisionNode('heroSphere') # heroSphere.addSolid(CollisionSphere(0,0,0,7)) # self.heroWallCollide = render.attachNewNode(heroSphere) # self.heroWallCollide.node().setFromCollideMask(BITMASK_WALL) # self.heroWallCollide.node().setIntoCollideMask(BitMask32.allOff()) # self.heroWallQueue = CollisionHandlerQueue() # self.cTrav.addCollider(self.heroWallCollide, self.heroWallQueue) # self.herowallcollision = False # Sphere collider for running into obstacles and walls in X direction heroSphereX = CollisionNode('heroSphereX') heroSphereX.addSolid(CollisionSphere(0,0,0,7)) self.heroWallCollideSphereX = self.heroWallCollideX.attachNewNode(heroSphereX) self.heroWallCollideSphereX.node().setFromCollideMask(BITMASK_WALL) self.heroWallCollideSphereX.node().setIntoCollideMask(BitMask32.allOff()) #self.heroWallQueueX = CollisionHandlerQueue() self.cTrav.addCollider(self.heroWallCollideSphereX, self.heroWallQueueX) self.herowallcollision = False # Sphere collider for running into obstacles and walls in Y direction heroSphereY = CollisionNode('heroSphereY') heroSphereY.addSolid(CollisionSphere(0,0,0,7)) self.heroWallCollideSphereY = self.heroWallCollideY.attachNewNode(heroSphereY) self.heroWallCollideSphereY.node().setFromCollideMask(BITMASK_WALL) self.heroWallCollideSphereY.node().setIntoCollideMask(BitMask32.allOff()) #self.heroWallQueueY = CollisionHandlerQueue() self.cTrav.addCollider(self.heroWallCollideSphereY, self.heroWallQueueY) # Sphere collider for running into obstacles and walls in Z direction heroSphereZ = CollisionNode('heroSphereZ') heroSphereZ.addSolid(CollisionSphere(0,0,0,7)) self.heroWallCollideSphereZ = self.heroWallCollideZ.attachNewNode(heroSphereZ) self.heroWallCollideSphereZ.node().setFromCollideMask(BITMASK_WALL) self.heroWallCollideSphereZ.node().setIntoCollideMask(BitMask32.allOff()) #self.heroWallQueueZ = CollisionHandlerQueue() self.cTrav.addCollider(self.heroWallCollideSphereZ, self.heroWallQueueZ) # Ray collider for clicking on objects in the game self.pickerCollisionQueue = CollisionHandlerQueue() self.pickerCN = CollisionNode('pickerRayCN') self.pickerCNP = self.cam.attachNewNode(self.pickerCN) self.pickerCN.setFromCollideMask(BITMASK_CLICK) self.pickerCN.setIntoCollideMask(BitMask32.allOff()) self.pickerRay = CollisionRay() self.pickerCN.addSolid(self.pickerRay) self.cTrav.addCollider(self.pickerCNP, self.pickerCollisionQueue) # Sphere collider for triggering scripts self.heroCN = CollisionNode('heroCN') self.heroCN.addSolid(CollisionSphere(0, 0, 0, 5)) # TODO: find good radius self.heroCNP = self.hero.attachNewNode(self.heroCN) self.heroCN.setFromCollideMask(BITMASK_HERO_COLLIDE) self.heroCN.setIntoCollideMask(BitMask32.allOff()) self.heroCollisionQueue = CollisionHandlerQueue() self.cTrav.addCollider(self.heroCNP, self.heroCollisionQueue) # Line collider for transparency self.cameraEntriesPre = [] radius = self.getModelHeight(self.hero)*CAMERA_TRAIL/2 self.cameraCollisionQueue = CollisionHandlerQueue() self.cameraHero = CollisionNode('cameraHero') self.cameraHeroLine = CollisionSegment(self.hero.getPos(render), self.cam.getPos(render)) self.cameraHero.addSolid(self.cameraHeroLine) self.cameraHero.setFromCollideMask(BITMASK_CAMERA) self.cameraHero.setIntoCollideMask(BitMask32.allOff()) self.cameraHeroP = self.render.attachNewNode(self.cameraHero) self.cTrav.addCollider(self.cameraHeroP, self.cameraCollisionQueue) #self.cameraHeroP.show() if FLAG_SHOW_COLLISIONS: self.cTrav.showCollisions(render) # TODO: show specific collision nodepaths def setCollideMasks(self, gameObjDict): for name, obj in gameObjDict.iteritems(): bitmask = obj.getCollideMask() if obj.hasTag('LE-ground'): bitmask |= BITMASK_GROUND #obj.getNP().setCollideMask(bitmask) # TODO: remove if obj.hasTag('LE-attackable'): bitmask |= BITMASK_CLICK if obj.hasTag('LE-wall'): if(isinstance(obj.getNP(), GeoMipTerrain)): bitmask |= BITMASK_TERRAIN else: bitmask |= BITMASK_WALL if obj.scripts.has_key('LE-trigger-onClick'): bitmask |=BITMASK_CLICK if obj.scripts.has_key('LE-trigger-onCollision'): bitmask |=BITMASK_HERO_COLLIDE if obj.hasTag('OBJRoot'): if obj.hasTag('LE-ground') or obj.hasTag('LE-mainChar'): pass else: bitmask |= BITMASK_CAMERA obj.setCollideMask(bitmask) def onClickin3D(self): pickedObj = None if self.conversationMgr.isConversationOpen(): return if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() else: return self.cTrav.addCollider(self.pickerCNP, self.pickerCollisionQueue) self.pickerRay.setFromLens(self.cam.node(), mpos.getX(), mpos.getY()) self.cTrav.traverse(render) if(self.pickerCollisionQueue.getNumEntries() > 0): self.pickerCollisionQueue.sortEntries() for i in range(self.pickerCollisionQueue.getNumEntries()): parent = self.pickerCollisionQueue.getEntry(i).getIntoNodePath().getParent() while not self.objects.has_key(parent.getName()): if(parent.getName() == "render"): return parent = parent.getParent() pickedObj = parent if(pickedObj == None): continue else: break #if pickedObj.hasTag("LE-trigger-onClick"): # TODO: needed, or is having key in self.objects enough? if (pickedObj == None): return self.pickerCollisionQueue.clearEntries() self.cTrav.removeCollider(self.pickerCNP) gameObj = self.gameObjects[pickedObj.getName()] distToTarget = self.hero.getDistance(gameObj) if self.combatMgr.checkCanAttack(self.hero, gameObj): if distToTarget <= self.heroSpells[self.curSpellIndex].getAttackRange(): self.combatMgr.queueAttack(self.hero, self.heroSpells[self.curSpellIndex], gameObj) else: textObject = OnscreenText(text = 'The target is out of range!',fg =(1,0,0,1), pos = (0, 0), scale = 0.09, align = TextNode.ACenter ) def destroyWarning1(): textObject.destroy() sequence =Sequence(Wait(2), Func(destroyWarning1)) sequence.start() return elif(distToTarget > CLICK_RANGE): textObject = OnscreenText(text = 'The target is out of range!',fg =(1,0,0,1), pos = (0, 0), scale = 0.09, align = TextNode.ACenter ) def destroyWarning2(): textObject.destroy() sequence =Sequence(Wait(2), Func(destroyWarning2)) sequence.start() return gameObj.callTrigger(self, 'LE-trigger-onClick') # Task for processing hero's collisions with GameObjects, triggering OnCollision scripts def processHeroCollisions(self, task): #self.cTrav.traverse(render) debug("processHeroCollisions") # CONSIDER: may not be necessary to sort if(self.heroCollisionQueue.getNumEntries() > 0): self.heroCollisionQueue.sortEntries() debug("queue size: "+str(self.heroCollisionQueue.getNumEntries())) for i in range(self.heroCollisionQueue.getNumEntries()): # CONSIDER: if entry.hasInto(): for efficiency debug("i: "+str(i)) # TODO: check if GameObject is passable, and react accordingly (store old position, revert to it) if(self.heroCollisionQueue.getNumEntries() <= 0): return entry = self.heroCollisionQueue.getEntry(i) debug("entry: "+str(entry)) if(entry): intoNP = entry.getIntoNodePath() else: continue if (intoNP != None) or (not intoNP.isEmpty()): while not self.objects.has_key(intoNP.getName()): if(intoNP.getName() == "render"): return task.cont intoNP = intoNP.getParent() pickedObj = intoNP if pickedObj == None: continue gameObj = self.gameObjects[pickedObj.getName()] gameObj.callTrigger(self, 'LE-trigger-onCollision') return task.cont ##== Camera Movement ========================================================## # places the camera pivot to match the position of the node path parameter # used to have the camera pivot match the main character's position as he moves def placeCamera(self, np): self.camPivot.setX(render, np.getX(render)) self.camPivot.setY(render, np.getY(render)) def alignCamera(self, np): self.camPivot.setH(render, self.hero.getH(render) + self.heroHeadingOffset) self.cam.setP(CAMERA_PITCH) def cameraFollowTask(self, task): heroH = self.hero.getH(render) + self.heroHeadingOffset camPivotH = self.camPivot.getH(render) # normalizes the headings to avoid jumps in the difference # which could come from passing 360 and going back to 0, for example # TODO: stress test, esp. with different values of self.heroHeadingOffset while heroH + 180 < camPivotH: heroH += 360 while camPivotH + 180 < heroH: camPivotH += 360 self.lastHeroH = heroH rotateLeft = (heroH >= camPivotH) rotateRight = not rotateLeft diff = math.fabs(heroH - camPivotH) if diff > CAMERA_TURN_THRESHOLD: if rotateLeft: self.camPivot.setH(self.camPivot.getH() + CAMERA_TURN_SPEED) elif rotateRight: self.camPivot.setH(self.camPivot.getH() - CAMERA_TURN_SPEED) # if(len(self.cameraEntriesPre)>0): # #print self.cameraEntriesPre # if(self.hero.getDistance(self.cam) > 5): # moveAmount = min(globalClock.getDt()*200,5.0) # pos = self.cam.getQuat().getForward()*moveAmount # newpos = self.cam.getPos() + pos # self.oldCameraEntriesPre = [] # for e in self.cameraEntriesPre: # self.oldCameraEntriesPre.append(e) # self.cam.setFluidPos(newpos) # # else: # if(self.hero.getDistance(self.cam) < 100): # moveAmount = min(globalClock.getDt()*200,5.0) # pos = self.cam.getQuat().getForward()*(-moveAmount) # oldpos = self.cam.getPos() # newpos = self.cam.getPos() + pos # self.cam.setFluidPos(newpos) # for e in self.oldCameraEntriesPre: # #print e.getIntoNodePath() # self.cTrav.traverse(e.getIntoNodePath()) # #self.cTrav.traverse(render) # if(len(self.cameraSphereQueue.getEntries())>0): # self.cam.setFluidPos(oldpos) return task.cont def runCamera(self, cameraName, sequence, isLoop = False): debug("Running the camera") #debug(str(self.sequences)) self.oldCamera = self.cam self.dr = self.win.makeDisplayRegion() dr2 = self.cam.node().getDisplayRegion(0)# self.objects[cameraName].node().setLens(base.camLens) parent = self.cam.getParent() self.cam.detachNode() self.dr.setCamera(self.objects[cameraName]) def temp(): dr2.setCamera(self.oldCamera) self.oldCamera.reparentTo(parent) self.dr.setActive(False) del self.dr self.dr = None self.accept("mouse1", self.onClickin3D) debug("Ran") if(isLoop): newSequence = Sequence(sequence) self.addSequence(newSequence) def stopCameraFromLoop(): newSequence.finish() temp() self.accept("mouse1", stopCameraFromLoop) self.addSequence(newSequence) newSequence.loop() else: newSequence = Sequence(sequence,Func(temp)) def stopCamera(): newSequence.finish() self.accept("mouse1", stopCamera) self.addSequence(newSequence) newSequence.start() ##== Character Movement =====================================================## def moveHeroTo(self, destinationObj): pos = destinationObj.getPos(render) hpr = destinationObj.getHpr(render) self.hero.setPosHpr(render, pos, hpr) self.placeCamera(self.hero) self.alignCamera(self.hero) def updateHeroHeight(self, task=None): groundEntries = [] #move the collision line to the hero position self.heroGroundCollide.setPos(self.hero.getPos(render)) #loop through every collision entry for the line for e in self.heroGroundHandler.getEntries(): if e.getIntoNodePath().hasNetTag('OBJRoot'): #find the actual root of the object np = e.getIntoNodePath().findNetTag('OBJRoot') #only react to objects that are tagged as the ground if np.hasTag('LE-ground'): groundEntries.append(e) if groundEntries: #sort the collision entries based on height groundEntries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),\ x.getSurfacePoint(render).getZ())) #set hero height and pivot height self.hero.setZ(groundEntries[0].getSurfacePoint(render).getZ() + MAIN_CHAR_GROUND_OFFSET) self.camPivot.setZ(groundEntries[0].getSurfacePoint(render).getZ() + MAIN_CHAR_GROUND_OFFSET) # TODO: unlink these from being in the same task in case we want pivot to not be linked to hero (ex. cutscene) self.heroGroundHandler.clearEntries() return task.cont def updateHeroPos(self, queue, stepSize): wallEntries = [] for w in queue.getEntries(): np = w.getIntoNodePath().findNetTag('OBJRoot') if np.hasTag('LE-wall'): if self.isInObstacleRange(self.hero, w, stepSize): wallEntries.append(w) if len(wallEntries) > 0: self.herowallcollision = True #self.collisionsurfaceP = wallEntries[0].getSurfacePoint(render) else: self.herowallcollision = False def updateCameraCollision(self): self.cameraHeroLine.setPointA(self.cam.getPos(render)) self.cameraHeroLine.setPointB(self.hero.getPos(render)) if(self.cameraEntriesPre): for i in self.cameraEntriesPre: i.getIntoNodePath().setTransparency(TransparencyAttrib.MAlpha) i.getIntoNodePath().setAlphaScale(1.0) del self.cameraEntriesPre[:] for i in self.cameraCollisionQueue.getEntries(): i.getIntoNodePath().setAlphaScale(0.5) self.cameraEntriesPre.append(i) def moveHero(self,direction, dt): temp = render.attachNewNode("Dummy")#NodePath() moveStep = MAIN_CHAR_MOVE_SPEED*dt if moveStep > MAIN_CHAR_MAX_STEP: moveStep = MAIN_CHAR_MAX_STEP temp.setPos(self.camPivot, 0,direction*moveStep, 0) #oldPos = self.heroWallCollideX.getPos() self.heroWallCollideX.setX(temp.getX()) self.heroWallCollideY.setY(temp.getY()) self.heroWallCollideZ.setZ(temp.getZ())#+10) self.cTrav.traverse(render) #check on X direction self.updateHeroPos(self.heroWallQueueX, moveStep) self.moveHeroToWallCollide(Point3(temp.getX(),self.hero.getY(),self.hero.getZ())) #check on Y direction self.updateHeroPos(self.heroWallQueueY, moveStep) self.moveHeroToWallCollide(Point3(self.hero.getX(),temp.getY(),self.hero.getZ())) #check on Z direction self.updateHeroPos(self.heroWallQueueZ, moveStep) self.moveHeroToWallCollide(Point3(self.hero.getX(),self.hero.getY(),temp.getZ())) self.heroWallCollideX.setPos(self.hero.getPos()) self.heroWallCollideY.setPos(self.hero.getPos()) self.heroWallCollideZ.setPos(self.hero.getPos()) self.placeCamera(self.hero) self.updateCameraCollision() temp.detachNode() def moveHeroToWallCollide(self,pos): if self.herowallcollision==False: self.hero.setPos(pos)#self.camPivot, 0, MAIN_CHAR_MOVE_SPEED, 0) def isInObstacleRange(self, mover, colEntry, stepSize): colPoint = colEntry.getSurfacePoint(render) if colPoint[2] >= mover.getZ(render): dist = findDistance3D(mover.getX(), mover.getY(), mover.getZ(), colPoint[0], colPoint[1], colPoint[2]) obstacleThreshold = self.heroHeight*self.heroHeight + stepSize*stepSize if dist*dist <= obstacleThreshold: return True return False def turnHeroLeft(self): up = render.getRelativeVector(base.cam, Vec3(0, 0, 1)) up.normalize() curHeroQuat = self.hero.getQuat() newHeroQuat = Quat() newHeroQuat.setFromAxisAngle(MAIN_CHAR_ROTATE_SPEED, up) self.hero.setQuat(curHeroQuat*newHeroQuat) self.hero.setR(0) self.hero.setP(0) self.updateCameraCollision() def turnHeroRight(self): up = render.getRelativeVector(base.cam, Vec3(0, 0, 1)) up.normalize() curHeroQuat = self.hero.getQuat() newHeroQuat = Quat() newHeroQuat.setFromAxisAngle(-MAIN_CHAR_ROTATE_SPEED, up) self.hero.setQuat(curHeroQuat*newHeroQuat) self.hero.setR(0) self.hero.setP(0) self.updateCameraCollision() def disableMovement(self, gameObj): if gameObj.getName() == self.hero.getName(): self.ignore('w') self.ignore('w-up') self.ignore('a') self.ignore('a-up') self.ignore('s') self.ignore('s-up') self.ignore('d') self.ignore('d-up') else: if gameObj.getAIBehaviorsHandle().behaviorStatus('pursue') != -1: gameObj.getAIBehaviorsHandle().pauseAi('pursue') def enableMovement(self, gameObj): if gameObj.getName() == self.hero.getName(): self.accept('w', self.setKeyStatus, extraArgs=['w', True]) self.accept('w-up', self.setKeyStatus, extraArgs=['w', False]) self.accept('a', self.setKeyStatus, extraArgs=['a', True]) self.accept('a-up', self.setKeyStatus, extraArgs=['a', False]) self.accept('s', self.setKeyStatus, extraArgs=['s', True]) self.accept('s-up', self.setKeyStatus, extraArgs=['s', False]) self.accept('d', self.setKeyStatus, extraArgs=['d', True]) self.accept('d-up', self.setKeyStatus, extraArgs=['d', False]) else: if gameObj.getAIBehaviorsHandle().behaviorStatus('pursue') == 'paused': gameObj.getAIBehaviorsHandle().resumeAi('pursue') def setKeyStatus(self, key, isDown): self.keyMap[key] = isDown print self.hero.getName() ###################################################################### ## # ZJC - 07/29/2011: THIS CODE WAS COMMENTED OUT BECAUSE A MORE EFFICIENT WAY WAS FOUND ## ## prefixList = [] ## #NEXT LINE- ZJC - 07/29/2011: This line is used to mark where to import the array used to deal with import flags. ## #LoaderFlagImportArray ## name = self.hero.getName().split('_')[0] # ZJC - 07/29/2011: name is assumed to be formatted NAME_otherstuff ## name2 = self.hero.getName().split('_')[1] # ZJC - 07/29/2011: name2 is assumed to be PREFIX_NAME_otherstuff ## if name in prefixList: # ZJC - 07/29/2011: Checks if the name is in the array, if it is name is not formatted as assumed ## name = name2 # ZJC - 07/29/2011: Use the second format if the first name is in the list ## print name ###################################################################### name = self.hero.getName().split('_')[0] # ZJC - 07/29/2011: Assumes format is Name_mod:# ## print name for i in range(len(self.here.getName().split('_'))): # ZJC - 07/29/2011: Loop will check every possibility in the name string for any level of merges/imports name2 = self.hero.getName().split('_')[i] # ZJC - 07/29/2011: name2 holds the current piece of the name string if ("mod:" in name2) and (name != name2): # ZJC - 07/29/2011: This means the name format is Prefix(es)_Name_mod:# name = self.hero.getName().split('_')[i-1] # ZJC - 07/29/2011: Assigns correct model name, the one just before mod:# if isDown: if key == 'w': if self.hero.getActorHandle() != None: self.hero.getActorHandle().stop(name + '_ani_idle') # ZJC - 07/26/2011: Stop the 'name' specific idle animation self.hero.getActorHandle().setPlayRate(1.0, name + '_ani_run') # ZJC - 07/26/2011: Set play rate for the 'name' specific run animation self.hero.getActorHandle().loop(name + '_ani_run') # ZJC - 07/26/2011: Run the 'name' specific run animation self.keyMap['s'] = False elif key == 's': if self.hero.getActorHandle() != None: self.hero.getActorHandle().stop(name + '_ani_idle') # ZJC - 07/26/2011: Stop the 'name' specific idle animation self.hero.getActorHandle().setPlayRate(-0.7, name + '_ani_run') # ZJC - 07/26/2011: Set play rate for the 'name' specific run animation self.hero.getActorHandle().loop(name + '_ani_run') # ZJC - 07/26/2011: Run the 'name' specific run animation self.keyMap['w'] = False elif key == 'a': self.keyMap['d'] = False elif key == 'd': self.keyMap['a'] = False elif not isDown: if key == 'w': if not self.keyMap['s']: if self.hero.getActorHandle() != None: self.hero.getActorHandle().stop(name + '_ani_run') # ZJC - 07/26/2011: Stop the 'name' specific run animation self.hero.getActorHandle().loop(name + '_ani_idle') # ZJC - 07/26/2011: Run the 'name' specific idle animation elif key == 's': if not self.keyMap['w']: if self.hero.getActorHandle() != None: self.hero.getActorHandle().stop(name + '_ani_run') # ZJC - 07/26/2011: Stop the 'name' specific run animation self.hero.getActorHandle().loop(name + '_ani_idle') # ZJC - 07/26/2011: Run the 'name' specific idle animation elif key == 'a': pass elif key == 'd': pass ## ZJC - 07/26/2011: This was the previous version of the code, it has been commented out and left as ## a reference. The changes made are defined in the comments above. ## if isDown: ## if key == 'w': ## if self.hero.getActorHandle() != None: ## self.hero.getActorHandle().stop('anim_idleFemale') # TODO: make a constant / set in LE ## self.hero.getActorHandle().setPlayRate(1.0, 'anim_jogFemale') ## self.hero.getActorHandle().loop('anim_jogFemale') ## self.keyMap['s'] = False ## elif key == 's': ## if self.hero.getActorHandle() != None: ## self.hero.getActorHandle().stop('anim_idleFemale') # TODO: make a constant / set in LE ## self.hero.getActorHandle().setPlayRate(-0.7, 'anim_jogFemale') ## self.hero.getActorHandle().loop('anim_jogFemale') ## self.keyMap['w'] = False ## elif key == 'a': ## self.keyMap['d'] = False ## elif key == 'd': ## self.keyMap['a'] = False ## elif not isDown: ## if key == 'w': ## if not self.keyMap['s']: ## if self.hero.getActorHandle() != None: ## self.hero.getActorHandle().stop('anim_jogFemale') ## self.hero.getActorHandle().loop('anim_idleFemale') ## elif key == 's': ## if not self.keyMap['w']: ## if self.hero.getActorHandle() != None: ## self.hero.getActorHandle().stop('anim_jogFemale') ## self.hero.getActorHandle().loop('anim_idleFemale') ## elif key == 'a': ## pass ## elif key == 'd': ## pass def moveHeroTask(self, task): dt = globalClock.getDt() direction = int(self.keyMap['w'])-int(self.keyMap['s']) self.moveHero(direction, dt) if self.keyMap['a']: self.turnHeroLeft() elif self.keyMap['d']: self.turnHeroRight() return task.cont ##== Scene Handling =========================================================## def loadScenes(self): # NOTE: Do not remove! This function is populated by StandaloneExporter pass def addSequence(self, sequence): self.ranSequences.append(sequence) #this is for changing scenes def resetAllSequences(self): for seq in self.ranSequences: seq.finish() dr = self.cam.node().getDisplayRegion(0) dr.setCamera(self.gameCam) self.ranSequences = [] def openScene(self, sceneName): if (self.scenes.has_key(sceneName)==False): print "ERROR:There is no scene under the name ", sceneName,"." return self.startLoadBar(12) self.createLoadScreen() #Part2:Clear all of the collision lists self.cTrav.removeCollider(self.heroCNP) self.heroGroundHandler.clearEntries() self.heroCollisionQueue.clearEntries() self.resetAllSequences() self.increaseLoadBar(1) #Part3: stop all of the tasks taskMgr.remove('processHeroCollisions') taskMgr.remove('updateHeroHeight') taskMgr.remove('moveHeroTask') taskMgr.remove('cameraFollowTask') taskMgr.remove("updateShaders") # ? self.combatMgr.stopTasks() self.gameplayUI.stop() self.gameplayUI.removeAllHealthBars() self.increaseLoadBar(1) #Part1.1: Stop currently running parts like conversations or camera if(self.conversationMgr.isConversationOpen()): self.conversationMgr.closeConversation() #Part 1.2: stop the camera self.increaseLoadBar(1) #Part4: Turn-Off all of the player controls self.ignore("mouse1") self.increaseLoadBar(1) #Part5: Remove all of the game elements that are related with the current scene del self.combatMgr self.increaseLoadBar(1) #Part6: Remove all of the children and the lights from the render render.getChildren().detach() render.clearLight() self.increaseLoadBar(1) #Part7:Add the camera and hero or any game element that should be exist in any scene back self.camPivot.reparentTo(render) self.hero.reparentTo(render) #self.heroWallCollide.reparentTo(render) self.heroWallCollideX.reparentTo(render) self.heroWallCollideY.reparentTo(render) self.heroWallCollideZ.reparentTo(render) self.heroGroundCollide.reparentTo(render) self.cameraHeroP.reparentTo(render) self.overlayAmbientLightNP.reparentTo(render) self.increaseLoadBar(1) #Part8:Add the new objects from the new scene self.assets, self.objects, self.gameObjects, self.sounds, self.sequences = loadWorld(self.scenes[sceneName], LIBRARY_INDEX) self.increaseLoadBar(1) #Part9:Add the hero to the new gameObject list and remove the duplicates of the hero self.gameObjects[self.hero.getName()] = self.hero if(self.objects.has_key(self.hero.getName())): object = self.objects[self.hero.getName()] if(object.hasTag('LE-mainChar')): object.detachNode() del self.objects[self.hero.getName()] for name, gameObj in self.gameObjects.iteritems(): if gameObj.getNP().hasTag('LE-ground'): #debug("is Ground") bitmask = gameObj.getNP().getCollideMask() bitmask |= BITMASK_GROUND gameObj.getNP().setCollideMask(bitmask) self.increaseLoadBar(1) #Part10:Restart the tasks. self.combatMgr = CombatMgr(self) taskMgr.add(self.processHeroCollisions, 'processHeroCollisions') taskMgr.add(self.updateHeroHeight, 'updateHeroHeight') taskMgr.add(self.moveHeroTask, 'moveHeroTask') taskMgr.add(self.cameraFollowTask, 'cameraFollowTask') self.combatMgr.startTasks() self.gameplayUI.start() self.increaseLoadBar(1) self.setCollideMasks(self.gameObjects) self.increaseLoadBar(1) #Part11: Change the color of the sky if(sceneName.startswith("interior") or sceneName.startswith("Interior")): self.setBackgroundColor(BGC_DARK_GREY) else: self.skybox.reparentTo(render) self.setBackgroundColor(BGC_LIGHT_BLUE) self.increaseLoadBar(1) #Part12: Restart the player controls self.accept("mouse1", self.onClickin3D) self.increaseLoadBar(1) self.accept("enter",self.destroyLoadScreen) debug("After open Scene: "+str(self.heroCollisionQueue.getNumEntries())) self.heroCollisionQueue.clearEntries() self.cTrav.addCollider(self.heroCNP, self.heroCollisionQueue) self.destroyLoadScreen()
def __init__(self): super().__init__(self) self.scene = loader.loadModel("models/world") self.player = self.scene.find("player") self.basePlane = self.scene.find("basePlane") self.player.reparentTo(self.render) self.basePlane.reparentTo(self.render) self.scene.remove_node() self.taskMgr.add(self.update, "update") self.camera.setPos(self.render, 0, -100, 70) base.setBackgroundColor(0.1, 0.1, 0.1, 1) self.dirLight = DirectionalLight("dir light") self.dirLight.setShadowCaster(True, 512, 512) self.dirLight.color = (1, 0, 1, 1) self.dirLightPath = self.render.attachNewNode(self.dirLight) self.dirLightPath.setHpr(45, -60, 0) render.setLight(self.dirLightPath) self.angleTime = 0.0 self.totalAngleTime = 10.0 self.hAngle = 0 self.ambientLight = AmbientLight("ambient") self.ambientLight.color = (0.1, 0.1, 0.1, 1) self.ambLightPath = self.render.attachNewNode(self.ambientLight) render.setLight(self.ambLightPath) self.pointLight = PointLight("point") self.pointLight.color = (1, 1, 1, 1) self.pointLightPath = self.render.attachNewNode(self.pointLight) self.pointLightPath.setPos(0, 5, 5) self.pointLight.setShadowCaster(True, 512, 512) self.render.setLight(self.pointLightPath) self.fog = Fog("fog") self.fog.setColor(.1, .1, .1) self.fog.setExpDensity(.3) self.fog.setLinearRange(150, 200) self.fog.setLinearFallback(45, 160, 320) render.setFog(self.fog) self.render.setShaderAuto() self.p = self.render.attachNewNode("particles") base.enableParticles() p = ParticleEffect() p.loadConfig('./mysmoke.ptf') p.start(parent=self.p, renderParent=render) self.p.setPos(self.player, 0, 0, 2) self.font = loader.loadFont('./fonts/Magenta.ttf') self.sceneName = DirectLabel(text="Starfox visual test", parent=self.aspect2d, scale=0.07, pos=(-1.2, 0, 0.85), text_font=self.font, relief=None, text_fg=(1, 1, 1, 1), textMayChange=True, text_align=TextNode.ALeft) self.foxy = OnscreenImage(image='./UI/fox-icon-png-8.png', pos=(1.2, 9, 0.85), scale=0.1) self.foxy.setTransparency(True) self.controlsPanel = DirectDialog(frameSize=(-1.1, 1.1, -0.9, -0.7), relief=DGG.FLAT) btn = DirectButton(text="Rotate", command=self.doRotate, image='./UI/fox-icon-png-8.png', pos=(-0.9, 0, -0.8), parent=self.controlsPanel, scale=0.07, relief=None) btn2 = DirectButton(text="Anin Light", command=self.doLight, image='./UI/fox-icon-png-8.png', pos=(-0.7, 0, -0.8), parent=self.controlsPanel, scale=0.07, relief=None) self.camera.lookAt(self.player) self.makeRotation = False self.rotateAngles = 0 self.animLight = False filter = CommonFilters(base.win, base.cam) filter.setBloom(size="large", intensity=2) #filter.setAmbientOcclusion(strength = 5, radius = 3) filter.setCartoonInk(separation=4)
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)
class MyApp(ShowBase): def __init__(self): ShowBase.__init__(self) self.useAdvancedVisualEffects =\ ConfigVariableBool("use-advanced-visual-effects", True) and\ base.win.getGsg().getSupportsBasicShaders() and\ base.win.getGsg().getSupportsGlsl() and\ base.win.getGsg().getSupportsDepthTexture() self.debug = DirectNotify().newCategory("Debug") self.phoneState = PhoneState(self) self.setupFilters() self.setupModels() self.setupKeyboardControl() self.camera.setPos(0, 0, 2) self.setupMouseControl() self.phoneState.request("Hidden") def setupFilters(self): if (self.useAdvancedVisualEffects): self.filters = CommonFilters(self.win, self.cam) self.filters.setBloom() def setupKeyboardControl(self): self.accept("escape", sys.exit) def setupMouseControl(self): self.disableMouse() self.mousex = 0 self.mousey = 0 self.last = 0 self.mousebtn = [0,0,0] self.accept("mouse1", self.setMouseBtn, [0, 1]) self.accept("mouse1-up", self.setMouseBtn, [0, 0]) self.taskMgr.add(self.controlCamera, "cameraTask") def setupModels(self): self.setupLights() self.loadSky() self.loadTerrain() self.setupBuildings() self.phoneState.setupPhone() def setupLights(self): self.sunLight = self.render.attachNewNode(DirectionalLight("sunLight")) self.sunLight.setColor(Vec4(0.8, 0.8, 0.8, 1)) self.sunLight.node().getLens().setFilmSize(128, 64) self.sunLight.node().getLens().setNearFar(20,2000) self.sunLight.setPos(60, 30, 50) self.sunLight.lookAt(0, 0, 0) self.render.setLight(self.sunLight) # self.sunLight.node().showFrustum() if self.useAdvancedVisualEffects: self.sunLight.node().setShadowCaster(True, 256, 256) self.render.setShaderAuto() self.ambientLight = self.render.attachNewNode(AmbientLight("ambientLight")) self.ambientLight.node().setColor(Vec4(0.2, 0.2, 0.2, 1)) self.render.setLight(self.ambientLight) def loadSky(self): self.sky = self.loader.loadModel("models/sky") self.sky.reparentTo(self.camera) self.sky.setScale(base.camLens.getNear() * 1.1) self.sky.setBin("background", 0) self.sky.setDepthWrite(False) self.sky.setCompass() self.sky.setLightOff() def loadTerrain(self): self.terrain = self.loader.loadModel("models/terrain") self.terrain.reparentTo(self.render) self.teapot = self.loader.loadModel("teapot") def setupBuildings(self): # Load building prototypes self.buildingPadPrototype = self.loader.loadModel("models/building_pad") self.policeBuildingPrototype = self.loader.loadModel("models/police_building") self.tribunalPrototype = self.loader.loadModel("models/tribunal") self.officeBuildingPrototype = self.loader.loadModel("models/office_building") self.housePrototype = self.loader.loadModel("models/House/CasaSimples") self.housePrototype.setPos(5, 5, 2.1) self.buildCity() def buildCity(self): # Define city blueprint city = [ "PSOSHS_", "SSSSSSS", "OSHHHHH", "_SSSSSS", "_SHHHHH", "_SSSSSS", "_SHHHHH", "_SSSSSS", "_SHHHHH" ] blockSize = 10 cityWESize = len(city[0]) * blockSize cityNSSize = len(city) * blockSize self.maxX = cityWESize / 2.0 self.maxY = cityNSSize / 2.0 buildingOutline = LineSegs("building") buildingSize = 8 buildingPadding = 1 buildingOutline.setColor(0, 0, 0, 1) buildingOutline.moveTo(buildingPadding, buildingPadding, 0) buildingOutline.drawTo(buildingPadding + buildingSize, buildingPadding, 0) buildingOutline.drawTo(buildingPadding + buildingSize, buildingPadding + buildingSize, 0) buildingOutline.drawTo(buildingPadding, buildingPadding + buildingSize, 0) buildingOutline.drawTo(buildingPadding, buildingPadding, 0) buildingOutlinePrototype = NodePath(buildingOutline.create()) # Create buildings from city blueprint for rowIndex, row in enumerate(city): for columnIndex, buildingType in enumerate(row): # Get building data from city blueprint buildingInstanceName, buildingPrototype = self.buildingInstanceNameAndPrototypeFromType(buildingType) if (not (buildingInstanceName is None or buildingPrototype is None)): # Compute building position buildingX, buildingY, buildingZ = columnIndex * blockSize - cityWESize / 2, cityNSSize / 2 - (rowIndex + 1) * blockSize, 0 # Create building pad buildingPadInstance = self.render.attachNewNode("buildingPadInstance") buildingPadInstance.setPos(buildingX, buildingY, buildingZ) self.buildingPadPrototype.instanceTo(buildingPadInstance) # Create building buildingInstance = self.render.attachNewNode(buildingInstanceName) buildingInstance.setPos(buildingX, buildingY, buildingZ) buildingPrototype.instanceTo(buildingInstance) # Create building outline in minimap buildingOutlineInstance = self.phoneState.minimap.attachNewNode("buildingOutline") buildingOutlineInstance.setPos(buildingX, buildingY, buildingZ) buildingOutlinePrototype.instanceTo(buildingOutlineInstance) def setMouseBtn(self, btn, value): self.mousebtn[btn] = value if (btn == 0 and value == 1 and self.phoneState.state == "Center"): phoneDisplayRegionCenterX = self.win.getXSize() * (self.phoneState.phoneDisplayRegion.getLeft() + self.phoneState.phoneDisplayRegion.getRight()) / 2.0 phoneDisplayRegionCenterY = self.win.getYSize() * (1.0 - (self.phoneState.phoneDisplayRegion.getBottom() + self.phoneState.phoneDisplayRegion.getTop()) / 2.0) mouse = self.win.getPointer(0) s = 2 ** self.phoneState.minimapZoom x = clamp(self.camera.getX() + (mouse.getX() - phoneDisplayRegionCenterX) / s, -self.maxX, self.maxX) y = clamp(self.camera.getY() + (phoneDisplayRegionCenterY - mouse.getY()) / s, -self.maxY, self.maxY) previousHeading = self.camera.getH() % 360.0 heading = (rad2Deg(atan2(y - self.camera.getY(), x - camera.getX())) - 90.0) % 360.0 if (180.0 < abs(heading - previousHeading)): if (previousHeading < heading): heading -= 360.0 else: heading += 360.0 self.camera.setH(previousHeading) self.phoneState.orientationTriangle.setH(previousHeading) Parallel( self.camera.posInterval(0.5, Vec3(x, y, self.camera.getZ())), self.phoneState.minimapCamera.posInterval(0.5, Vec3(x, y, self.phoneState.minimapCamera.getZ())), self.phoneState.orientationTriangle.posInterval(0.5, Vec3(x, y, self.phoneState.orientationTriangle.getZ())), self.camera.hprInterval(0.5, Vec3(heading, self.camera.getP(), self.camera.getR())), self.phoneState.orientationTriangle.hprInterval(0.5, Vec3(heading, self.phoneState.orientationTriangle.getP(), self.phoneState.orientationTriangle.getR())) ).start() def buildingInstanceNameAndPrototypeFromType(self, buildingType): return { 'S' : ( None, None ), 'P' : ( "policeBuildingInstance", self.policeBuildingPrototype ), 'T' : ( "tribunalInstance", self.tribunalPrototype ), 'O' : ( "officeBuildingInstance", self.officeBuildingPrototype ), 'H' : ( "houseInstance", self.housePrototype ), }.get(buildingType, ( None, None )) def setBlurSharpen(self, amount): if (not self.useAdvancedVisualEffects): return if (amount == 1.0): self.filters.delBlurSharpen() else: self.filters.setBlurSharpen(amount=amount) def controlCamera(self, task): if (self.phoneState.state == "Center"): return Task.cont # figure out how much the mouse has moved (in pixels) mouse = self.win.getPointer(0) x = mouse.getX() y = mouse.getY() windowCenterX = self.win.getXSize() / 2 windowCenterY = self.win.getYSize() / 2 heading = self.camera.getH() pitch = self.camera.getP() if self.win.movePointer(0, windowCenterX, windowCenterY): heading -= (x - windowCenterX) * 0.2 pitch = clamp(pitch - (y - windowCenterY) * 0.2, -45, 45) self.camera.setHpr(heading, pitch, 0) elapsed = task.time - self.last if (self.last == 0): elapsed = 0 if (self.mousebtn[0]): direction = self.camera.getMat().getRow3(1) self.camera.setPos(self.camera.getPos() + direction * elapsed*30) clampX(self.camera, -self.maxX, self.maxX) clampY(self.camera, -self.maxY, self.maxY) self.camera.setZ(2) self.phoneState.minimapCamera.setX(self.camera.getX()) self.phoneState.minimapCamera.setY(self.camera.getY()) self.phoneState.orientationTriangle.setX(self.camera.getX()) self.phoneState.orientationTriangle.setY(self.camera.getY()) self.phoneState.orientationTriangle.setHpr(heading, -90, 0) self.last = task.time return Task.cont
base.disableMouse() base.setFrameRateMeter(True) color = (0,0,0,1) #color = (1,1,1,1) expfog = Fog("Scene-wide exponential Fog object") expfog.setColor(color) expfog.setExpDensity(0.02) #render.setFog(expfog) base.setBackgroundColor(color) #render.setAntialias(AntialiasAttrib.MMultisample) #render.setAntialias(AntialiasAttrib.MAuto) #render.setAttrib(LightRampAttrib.makeHdr0()) #render.setAttrib(LightRampAttrib.makeHdr1()) #render.setAttrib(LightRampAttrib.makeHdr2()) #render.setAttrib(LightRampAttrib.makeSingleThreshold(0.5, 0.5)) #render.setAttrib(LightRampAttrib.makeDoubleThreshold(0.5, 0.5, 0.5, 0.5)) filters = CommonFilters(base.win, base.cam) #filters.setCartoonInk(separation=0.5) #filters.setViewGlow() #filters.setVolumetricLighting(caster=game.mapManager.player.model) filters.setBloom() #PStatClient.connect() #loadPrcFileData('setup', 'dump-generated-shaders #t') run()
class World: def __init__(self): base.disableMouse() # Turns off the default mouse-camera controls in Panda3D. base.setBackgroundColor(0, 0, 0) # Sets the background to black. self.inputManager = InputManager() # Creates an InputManager to handle all of the user input in the game. #taskMgr.doMethodLater(10, self.debugTask, "Debug Task") # Tells the debugTask to run once every ten seconds. The debug task is a good # place to put various data print outs about the game to help with debugging. self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size=2) render.setShaderAuto() # Turns on Panda3D's automatic shader generation. self.menuGraphics = loader.loadModel("../Models/MenuGraphics.egg") # Loads the egg that contains all the menu graphics. self.fonts = { "silver": loader.loadFont("../Fonts/LuconSilver.egg"), "blue": loader.loadFont("../Fonts/LuconBlue.egg"), "orange": loader.loadFont("../Fonts/LuconOrange.egg") } # Loads the three custom fonts our game will use. hud = HUD(self.fonts) # Creates the HUD. self.race = Race(self.inputManager, hud) self.race.createDemoRace() # creates an instance of the race class and tells it to # start a demo race. self.createStartMenu() # creates the start menu. musicMgr = base.musicManager self.music = musicMgr.getSound( "../Sound/Loveshadow-Takin_Yo_Time_(The_Wingman_Mix).wav") self.music.setLoop(True) self.music.play() def createStartMenu(self): menu = Menu(self.menuGraphics, self.fonts, self.inputManager) menu.initMenu([ 0, None, ["New Game", "Quit Game"], [[self.race.createRace, self.createReadyDialogue], [base.userExit]], [[None, None], [None]] ]) def createReadyDialogue(self): menu = Menu(self.menuGraphics, self.fonts, self.inputManager) menu.initMenu([ 3, "Are you ready?", ["Yes", "Exit"], [[self.race.startRace], [self.race.createDemoRace]], [[3], [None]] ]) def debugTask(self, task): print(taskMgr) # prints all of the tasks in the task manager. return task.again
def __init__(self): ShowBase.__init__(self) self.cfg = cfgdict("data/default_config.cfg") globalClock.setMode(ClockObject.MLimited) globalClock.setFrameRate(int(self.cfg["general"]["framerate"])) #base.setFrameRateMeter(int(self.cfg["general"]["debug"])) self.props = WindowProperties() self.props.setSize(tuple(self.cfg["general"]["resolution"])) self.props.setFullscreen(int(self.cfg["general"]["fullscreen"])) self.props.setCursorHidden(True) self.fullscreen = int(self.cfg["general"]["fullscreen"]) #props.setMouseMode(WindowProperties.M_relative) base.win.requestProperties(self.props) base.disableMouse() base.win.setClearColor((0, 0, 0, 0)) self.inputs = Inputs(self.cfg["key"]) #cats=["mainmenu", "parts", "enemies", "items"] #for cat in cats: makeWireframe(cat) self.hud = HUD(self) self.transition = Transitions(loader) self.parts_models = getParts("data/models/egg/parts/parts") self.enemy_models = getParts("data/models/egg/enemies/enemies") self.item_models = getParts("data/models/egg/items/items") sounds = [ "break", "error", "explosion", "hit_a", "hit_b", "hit_c", "scare", "select_a", "select_b", "splurt_a", "splurt_b", "swallow", "step_enemy_a", "step_enemy_b", "step_enemy_c", "step_player", "turn", "projectile_a", "projectile_b", "projectile_c", ] self.sounds = {} for sound in sounds: self.sounds[sound] = loader.loadSfx("data/sound/" + sound + ".wav") self.sounds["step_player"].setVolume(0.3) self.act = False if self.cfg["general"]["fx"] == 1: render.setShaderAuto() aspect2d.setShaderAuto() filters = CommonFilters(base.win, base.cam) filters.setBloom(blend=(0.1, 0.1, 0.1, 0.0), mintrigger=0.0, maxtrigger=0.1, desat=0.0, intensity=0.6, size="small")
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 Universe(DirectObject, EoAUniverse): """Universe ----------- Out main class, the Universe""" def __init__(self): """Initialize our world Our game loop looks a little different than the standard -do logic -render because Panda3d's tasks are being used. The basic idea still carries over though, and we'll try to follow the same logic by storing states in our Universe class then calling a task to render everything (this is a TODO) Set up environment Set up lighting Set up physics Set up actors Set up collisions Run tasks """ """------------INIT---------------------------------------""" """Set up input""" self.init_controls() """Set up environment""" self.init_environment() """Set up lights""" self.init_lights() """Set up physics""" self.init_physics() """Set up collisions""" self.init_collisions() """Set up actors""" self.init_actors() """Set up camera""" self.init_camera() """Set up GUI""" self.init_gui() """------------TASKS---------------------------------------""" self.elapsed = 0.0 self.prev_time = 0.0 """Set up tasks""" #Set up lighting updates base.taskMgr.add(self.update_lighting, 'update_lighting') #Set up movement updates base.taskMgr.add(self.update_movement, 'update_movement') #Set up camera updates base.taskMgr.add(self.update_camera, 'update_camera') #Keep track of entities, update animation if they are moving base.taskMgr.add(self.update_entity_animations, 'update_entity_animations') #Setup mouse collision test base.taskMgr.add(self.update_mouse_collisions, 'update_mouse_collisions') """Set up skydome""" #self.init_skydome() #Skydome task #base.taskMgr.add(self.cameraUpdated, "camupdate") """--------------------------------------------------------""" """------------------initial setup functions------------------------------- INITIAL SETUP FUNCTIONS --------------------------------------------------------------------""" """=======Controls=============================================""" def init_controls(self): """Set up controls. Use direct input and keymaps TODO -Allow user to control keys from config settings """ # Now, assign some controls to the events that the GravityWalker will #watch for #Create a dictionary to save controls """WASD Settings""" self.controls = {} self.controls['forwardControl'] = inputState.watch('forward', 'w', 'w-up', inputSource=inputState.WASD) self.controls['reverseControl'] = inputState.watch('reverse', 's', 's-up', inputSource=inputState.WASD) self.controls['turnLeftControl'] = inputState.watch('turnLeft', 'a', 'a-up', inputSource=inputState.WASD) self.controls['turnRightControl'] = inputState.watch('turnRight', 'd', 'd-up', inputSource=inputState.WASD) self.controls['jumpControl'] = inputState.watch('jump', 'space', 'space-up', inputSource=inputState.Keyboard) self.controls['isMoving'] = False """Key map settings""" self.controls['key_map'] = {"cam_left":0, "cam_right":0, "cam_up":0, "cam_down":0, "mouse1":0, "mouse2": 0, "mouse3": 0, "scroll_up":0, "scroll_down":0} #Camera Control Keys self.accept("arrow_left", self.controls_set_key, ["cam_left",1]) self.accept("arrow_right", self.controls_set_key, ["cam_right",1]) self.accept("arrow_left-up", self.controls_set_key, ["cam_left",0]) self.accept("arrow_right-up", self.controls_set_key, ["cam_right",0]) self.accept("arrow_up", self.controls_set_key, ["cam_up",1]) self.accept("arrow_down", self.controls_set_key, ["cam_down",1]) self.accept("arrow_up-up", self.controls_set_key, ["cam_up",0]) self.accept("arrow_down-up", self.controls_set_key, ["cam_down",0]) """Mouse settings""" #Previous mouse coordinates, used for camera and dragging elements self.controls['mouse_prev_x'] = 0 self.controls['mouse_prev_y'] = 0 self.controls['mouse_camera_dragging'] = False #mouse keys #mouse1 is left click #Call function to set the player's target #set_target_on_mouseclick also sets the mouse1 key value...need to make # this more extensible self.accept("mouse1", self.set_target_on_mouseclick) self.accept("mouse1-up", self.controls_set_key, ["mouse1", 0]) #mouse3 is right click self.accept("mouse3", self.controls_set_key, ["mouse3", 1]) self.accept("mouse3-up", self.controls_set_key, ["mouse3", 0]) #mouse2 is scroll wheel click self.accept("mouse2", self.controls_set_key, ["mouse2", 1]) self.accept("mouse2-up", self.controls_set_key, ["mouse2", 0]) #mouse scroll self.accept('wheel_up', self.controls_set_key,["scroll_up", 1 ]) self.accept('wheel_down', self.controls_set_key, ["scroll_down", 1]) self.accept ('escape', sys.exit) # hit escape to quit! def controls_set_key(self, key, value): """Set up keyboard keys Create a key_map dictionary to store the key being pressed and the value (which will be either 1 for on or 0 for off) """ self.controls['key_map'][key] = value """=======Lights===============================================""" def init_lights(self): """init_lights Set up light system """ self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom(blend=(0,0,0,.5), desat=-0.5, intensity=1.0, size="small") if filterok == False: print "Your video card cannot handle this" return self.glowSize=.2 # Create a simple directional light self.lights = {} #Set up directional light self.lights['dlight'] = render.attachNewNode (DirectionalLight\ ('DirectionalLight')) self.lights['dlight'].setColor(VBase4(1, 1, 1, 1)) render.setLight(self.lights['dlight']) self.lights['dlight'].setPos(50,50,50) self.lights['dlight'].lookAt(0,0,0) #Sun position self.lights['sunPos'] = 0 # Create an ambient light self.lights['alight'] = AmbientLight('AmbientLight') self.lights['alight'].setColor(VBase4(0.1, 0.1, 0.1, 0.1)) self.lights['alnp'] = render.attachNewNode(self.lights['alight']) render.setLight(self.lights['alnp']) #Create an invisible "sun" node which the dlight will lookAt() self.lights['sun_node'] = render.attachNewNode("sun_node") self.lights['sun_node'].setPos(10,10,10) self.lights['sun_node'].setScale(2) #Create a sun model that will be a visual representation of where the # sun is. Will be, essentially, in the opposite position of the # fake sun node self.lights['sun_model'] = loader.loadModel(target_dir+'/models/sphere.egg') self.lights['sun_model'].reparentTo(render) self.lights['sun_model'].setPos(10,10,10) self.lights['sun_model'].setScale(2) self.lights['sky_box'] = loader.loadModel(target_dir+'/models/skybox.egg') self.lights['sky_box'].reparentTo(render) self.lights['sky_box'].setScale(5) sky_tex = loader.loadTexture(\ target_dir+'/models/textures/clouds_bw.png') sky_tex.setWrapU(Texture.WMRepeat) sky_tex.setWrapV(Texture.WMRepeat) self.lights['sky_box'].setTexture(sky_tex,1) """=======Actors===============================================""" def init_actors(self): """init_actors Setup actors""" #Setup the PC entity self.entities['PC'] = EoAEntity(gravity_walker=True,modelName="boxman", name='PC', startPos=(0,0,5), max_health=521, max_power=82, stats={'agi':10, 'dex':19, 'int':19, 'sta':15, 'str':14, 'wis':18}) for i in range(5): self.entities['NPC_'+str(i)] = EoAEntity(modelName="boxman", max_health=100, name='NPC_'+str(i),startPos=(random()*i+i, random()*i+i,80)) """=======Camera===============================================""" def init_camera(self): """init_camera Set up the camera. Allow for camera autofollow, freemove, etc""" base.disableMouse() base.camera.reparentTo(self.entities['PC'].Actor) base.camera.setPos(0, -15, 25) base.camera.lookAt(self.entities['PC'].Actor) angledegrees = 2 angleradians = angledegrees * (math.pi / 180.0) base.camera.setPos(20*math.sin(angleradians),-20.0*\ math.cos(angleradians),3) base.camera.setHpr(angledegrees, 0, 0) """Set up some camera controls""" self.controls['camera_settings'] = {} #Camera timer is used to control how long a button is being held #to control the camera self.controls['camera_settings']['timer'] = 0 self.controls['camera_settings']['zoom'] = 20 """=======Skydome==============================================""" def init_skydome(self): #SKYBOX self.skybox = loader.loadModel(target_dir+'/models/dome2') self.skybox.reparentTo(render) self.skybox.setScale(4000,4000,1000) #self.skybox.setLightOff() texturefile = target_dir + "/models/textures/clouds_bw.png" texture = loader.loadTexture(texturefile) self.textureStage0 = TextureStage("stage0") self.textureStage0.setMode(TextureStage.MReplace) self.skybox.setTexture(self.textureStage0,texture,.2) self.rate = Vec4(0.004, 0.002, 0.008, 0.010) self.textureScale = Vec4(1,1,1,1) self.skycolor = Vec4(.1, .1, .1, 0) self.skybox.setShader( loader.loadShader(target_dir+\ '/shaders/skydome2.sha' ) ) self.skybox.setShaderInput("sky", self.skycolor) self.skybox.setShaderInput("clouds", self.rate) self.skybox.setShaderInput("ts", self.textureScale) """-----------------tasks-------------------------------------------------- TASKS --------------------------------------------------------------------""" """=======Update character movement============================""" def update_movement(self,task): """Task that updates the walking animation on our GravityWalker TODO - Stop using gravity walker and implement ODE physics? If using ODE or something other than gravitywalker, handle controls for movement here """ # Adjust to match the walkcycle, to minimize sliding self.entities['PC'].Actor.setPlayRate(0.5 * \ self.entities['PC'].physics['playerWalker'].speed, 'walk') #Check if the player is moving. If so, play walk animation if inputState.isSet('forward') or inputState.isSet('reverse') or \ inputState.isSet('turnLeft') or inputState.isSet('turnRight'): if self.controls['isMoving'] is False: self.entities['PC'].Actor.loop('walk') self.controls['isMoving'] = True else: if self.controls['isMoving']: print 'stopped' self.entities['PC'].Actor.stop() self.entities['PC'].Actor.loop('idle') self.controls['isMoving'] = False #Done here return Task.cont """======Update camera=========================================""" def update_camera(self,task): """Check for camera control input and update accordingly""" # Get the time self.elapsed since last frame. We need this # for framerate-independent movement. self.elapsed = globalClock.getDt() """---------Keyboard movement-------------------""" """Rotate Camera left / right""" if self.controls['key_map']['cam_left'] !=0: """Rotate the camera to the left""" #increment the camera timer, determines speed of camera rotation self.controls['camera_settings']['timer'] += .1 angledegrees = self.controls['camera_settings']['timer'] * 50 angleradians = angledegrees * (math.pi / 180.0) #Set the X, Y as the zoom value * sine or cosine (respectively) of # angle radians, which is determined by rotating the camera left # or right around the character. The zoom variable determines # in essence, the zoom level which is calcuated simply as # self.elapsed * 20. Notice this is also the value we use to # setY when we zoom in or out - no coincidence, these numbers # are the same because we want to know the location of the # camera when we pan around the character (this location is # multiplied by sin or cos of angleradians base.camera.setPos(self.controls['camera_settings']['zoom']*\ math.sin(angleradians), -self.controls['camera_settings']['zoom']*\ math.cos(angleradians), base.camera.getZ()) #Set the heading / yaw (h) of the camera to point at the character base.camera.setHpr(angledegrees, 0, 0) if self.controls['key_map']['cam_right'] !=0: """Rotate the camera to the right""" #increment the camera timer self.controls['camera_settings']['timer'] -= .1 angledegrees = self.controls['camera_settings']['timer'] * 50 angleradians = angledegrees * (math.pi / 180.0) base.camera.setPos(self.controls['camera_settings']['zoom']*\ math.sin(angleradians), -self.controls['camera_settings']['zoom']*\ math.cos(angleradians), base.camera.getZ()) base.camera.setHpr(angledegrees, 0, 0) """Zoom camera in / out""" #ZOOM IN if self.controls['key_map']['cam_up'] !=0: #Zoom in base.camera.setY(base.camera, +(self.elapsed*20)) #Store the camera position self.controls['camera_settings']['zoom'] -= self.elapsed*20 #ZOOM OUT if self.controls['key_map']['cam_down'] !=0: #Zoom out base.camera.setY(base.camera, -(self.elapsed*20)) #Store the camera position self.controls['camera_settings']['zoom'] += self.elapsed*20 """---------Mouse movement-------------------""" #Zoom in on mouse scroll forward if self.controls['key_map']['scroll_up'] !=0: #Zoom in base.camera.setY(base.camera, +(self.elapsed*20)) #Store the camera position self.controls['camera_settings']['zoom'] -= .1 #Reset the scroll state to off self.controls['key_map']['scroll_up'] = 0 #Zoom in on mouse scroll forward if self.controls['key_map']['scroll_down'] !=0: #Zoom in base.camera.setY(base.camera, -(self.elapsed*20)) #Store the camera position self.controls['camera_settings']['zoom'] -= .1 #Reset the scroll state to off self.controls['key_map']['scroll_down'] = 0 #Move camera left / right by mouseclick #mous3 is right click button if self.controls['key_map']['mouse3'] != 0: """Rotate the camera to the left or right""" #We know right click is being held, checked to see if it's moving # left or right if base.mouseWatcherNode.hasMouse(): cur_mouse_x=base.mouseWatcherNode.getMouseX() cur_mouse_y=base.mouseWatcherNode.getMouseY() else: #The base does not have the mouse watcher node, meaning the # mouse is probably outside the game window. If this is # the case, set the cur mouse x and y to the prev coords cur_mouse_x = self.controls['mouse_prev_x'] cur_mouse_y = self.controls['mouse_prev_y'] #Check to see if the camera is being dragged. This ensures that # the camera won't move when the mouse is first clicked if self.controls['mouse_camera_dragging'] is True: #compare the previous mouse x position (if it exists). If the # cur position is greater, it means the mouse has moved to the # left side of the screen, so update the camera position if cur_mouse_x > self.controls['mouse_prev_x']: #Camera will be moving to the right self.controls['camera_settings']['timer'] -= .1 elif cur_mouse_x < self.controls['mouse_prev_x']: #Camera will be moving to the left self.controls['camera_settings']['timer'] += .1 #Move the camera angledegrees = self.controls['camera_settings']['timer'] * 50 angleradians = angledegrees * (math.pi / 180.0) #Set the X, Y as the zoom value ... see camera rotation code # above for more details base.camera.setPos(self.controls['camera_settings']['zoom']*\ math.sin(angleradians), -self.controls['camera_settings']['zoom']*\ math.cos(angleradians), base.camera.getZ()) #Set the yaw of the camera to point at the character base.camera.setHpr(angledegrees, 0, 0) #Set current x,y mouse coordinates as previous coordinates so we # can do comparisons the next time the function is called self.controls['mouse_prev_x'] = cur_mouse_x self.controls['mouse_prev_y'] = cur_mouse_y self.controls['mouse_camera_dragging'] = True elif self.controls['key_map']['mouse3'] == 0: #The right click button has been depressed, so the camera is # no longer being dragged self.controls['mouse_camera_dragging'] = False #self.entities['PC'].physics['playerWalker'].getCollisionsActive() return Task.cont """======Update lighting=========================================""" def update_lighting(self, task): #Update the Sun's position. #TODO - tie this in with day/night/time system #Move the sun angleDegrees = task.time * 100.0 angleRadians = angleDegrees * (math.pi / 180.0) self.lights['sun_node'].setPos(75*math.sin(angleRadians), 0,-75.0*math.cos(angleRadians)) #Set the sun model's position based on the sun node. Will be reversed # in the X direction self.lights['sun_model'].setPos(-self.lights['sun_node'].getX(), 3, -self.lights['sun_node'].getZ()) #self.lights['dlight'].setHpr(0,angleDegrees,0) self.lights['dlight'].lookAt(self.lights['sun_node']) #self.lights['sky_box'].setHpr(0,angleDegrees,0) #Set the skybox's position to the camera's position so the camera # never touches the skybox, makes the skybox appear to never move self.lights['sky_box'].setPos(base.camera.getPos()) return Task.cont """=======update_entity_animations=============================""" def update_entity_animations(self, task): """Check to see if any entities have moved since the last check If entity d(xyz) has changed, play animation Better way to handle this? Every entity could have a task to update its animation based on its state. """ #Loop through all entities and animate them for i in self.entities: if i != "PC": #Get the entity's current position test_pos = self.entities[i].getPos() #Turn it into an integer for checking test_pos_int = [float("%.2f" % j) for j in test_pos] #See if the current position matches the previous position if test_pos_int != self.entities[i].prevPos: #Check to see if the entity has been moving if self.entities[i].is_moving is False and \ self.entities[i].moving_buffer > 20: #Play the walk animation self.entities[i].Actor.loop('walk') #The entity is moving now self.entities[i].is_moving = True #Reset the moving buffer self.entities[i].moving_buffer = 0 #Increment the moving buffer by one to help reduce #skittering self.entities[i].moving_buffer += 1 else: #else, the previous and current position is the same if self.entities[i].is_moving: #Check to see if entity is set as moving to ensure we #don't do this loop the idle animation every frame self.entities[i].Actor.stop() self.entities[i].Actor.loop('idle') self.entities[i].is_moving = False #Set the entity's previous position self.entities[i].prevPos = test_pos_int """to update NPC's location pos = self.entities['NPC_0'].getPos() self.entities['NPC_0'].setPos(x,y,z) """ return Task.cont """=======update_mouse_collisions==============================""" def update_mouse_collisions(self, task): """Handle muse collisions for hover and click""" #TODO - optimize? Does this provide an advatge? #Task.time returns a float with many digits, so doing all these checks #per iteration is a little time consuming. Let's compare only the first #digit of task.time to see if we should do the mouse collisions checks #or not. Since the timing does not have to be 100% perfect as we're #checking for mouse interactions, we can afford not to be as exact #as possible. Need to check if following test saves any FPS #normal test #if self.prev_time != task.time: #optimized test #if float("%.1f" % self.prev_time) != float("%.1f" % task.time): #Check to see if we can access the mouse if base.mouseWatcherNode.hasMouse(): #get the mouse position mpos = base.mouseWatcherNode.getMouse() #Set the position of the ray based on the mouse position self.physics['collisions']['mouse']['picker_ray'].setFromLens(\ base.camNode, mpos.getX(), mpos.getY()) #Do the actual collision pass (Do it only on the squares for #efficiency purposes) base.cTrav.traverse(EoAUniverse.nodes['entity_root']) #Get number of entries in the collision handler if self.physics['collisions']['mouse']['cHandler'].\ getNumEntries() > 0: #Get the closest object self.physics['collisions']['mouse']['cHandler'].sortEntries() #Store the picked object self.physics['collisions']['mouse']['current_node'] = self.\ physics['collisions']['mouse']['cHandler'].\ getEntry(0).getIntoNodePath() self.physics['collisions']['mouse']['current_node'] = self.\ physics['collisions']['mouse']['current_node'].\ findNetTag('mouse_obj_tag') try: if not self.physics['collisions']['mouse']\ ['current_node'].isEmpty(): #Get the entity from the python tag """Check for mouse hopping from object to object, mouse might hover over NPC_1 to NPC_2. If we don't check for this, a node may stay highlighted if the mouse collides from NPC to NPC""" #Check if the current picked object is equal to the #previous picked object (and that it isn't none) if self.physics['collisions']['mouse']['prev_node'] !=\ self.physics['collisions']['mouse']['current_node'] \ and self.physics['collisions']['mouse']\ ['prev_node'] is not None: #Turn off the highlight light self.physics['collisions']['mouse']['prev_node'].\ setLightOff() #Turn back on the default lights self.physics['collisions']['mouse']['prev_node'].\ setLight(self.lights['alnp']) self.physics['collisions']['mouse']['prev_node'].\ setLight(self.lights['dlight']) #We don't set the previously picked node object #here because we don't want to set the previous #node to the current node if the previous node #is equal to none """If the hovered over node is not the curret node, set light""" #Add an effect #Create an ambient light so the name node will be #one uniform light ambient = AmbientLight('ambient') ambient.setColor(Vec4(.5,.7,.7,.1)) ambientNP = self.physics['collisions']['mouse']\ ['current_node'].attachNewNode(\ ambient.upcastToPandaNode()) # If we did not call setLightOff() first, the green #light would add to the total set of lights on this #object. Since we do call setLightOff(), we are #turning off all the other lights on this object first, #and then turning on only the green light. self.physics['collisions']['mouse']['current_node'].\ setLightOff() self.physics['collisions']['mouse']['current_node'].\ setLight(ambientNP) #We set the highlighting for the moused over node, #now set the previous node to the current selected node if self.physics['collisions']['mouse']['prev_node'] !=\ self.physics['collisions']['mouse']['current_node']: self.physics['collisions']['mouse']['prev_node'] =\ self.physics['collisions']['mouse']['current_node'] except: print "Error on mouse over node " + str(self.physics\ ['collisions']['mouse']['current_node']) else: #The mouse isn't over anything, check to see if the previous #node is set if self.physics['collisions']['mouse']['prev_node'] \ is not None: if self.entities['PC'].target != \ self.physics['collisions']['mouse']['prev_node'].\ getPythonTag('entity'): #Turn off the highlight light self.physics['collisions']['mouse']['prev_node'].\ setLightOff() #Turn back on the default lights self.physics['collisions']['mouse']['prev_node'].\ setLight(self.lights['alnp']) self.physics['collisions']['mouse']['prev_node'].\ setLight(self.lights['dlight']) #Set the previous node to none self.physics['collisions']['mouse']['prev_node'] = None self.physics['collisions']['mouse']['current_node'] = None #self.prev_time = task.time return Task.cont """=======Update skybox========================================""" def cameraUpdated(self, task): #self.lights['sunPos'] self.skycolor = Vec4( (self.lights['sunPos'] % 360.0) / 360, (self.lights['sunPos'] % 360.0) / 360, (self.lights['sunPos'] % 360.0) / 360 ,0 ) self.skybox.setShaderInput("sky", self.skycolor) render.setShaderInput('time', task.time) return Task.cont """-----------------EoA Universe Functions--------------------------------- EoA Universe Functions --------------------------------------------------------------------""" """=======Set PC's target======================================""" def set_target_on_mouseclick(self): """Set the player's target to an entity based on mouse click""" #Set update mouse1 key values self.controls_set_key("mouse1", 1) #Set the target if a node is under the mouse if self.physics['collisions']['mouse']['current_node'] is not None: """If something was clicked""" picked_entity = self.physics['collisions']['mouse']\ ['current_node'].getPythonTag('entity') #print 'clicked' + str(picked_entity.name) self.entities['PC'].set_target(target=picked_entity) if self.physics['collisions']['mouse']['prev_target'] is not None \ and self.physics['collisions']['mouse']['prev_target'] != \ self.physics['collisions']['mouse']['current_node']: self.physics['collisions']['mouse']['prev_target'].\ setLightOff() #Turn back on the default lights self.physics['collisions']['mouse']['prev_target'].\ setLight(self.lights['alnp']) self.physics['collisions']['mouse']['prev_target'].\ setLight(self.lights['dlight']) #Set previous target to the current node (set the last clicked on #node equal to the node the mouse is over) self.physics['collisions']['mouse']['prev_target'] = \ self.physics['collisions']['mouse']['current_node'] else: """No entities are under the click, so clear the target and any lighting on the previously selected node""" try: #Turn off the previous selected node's lights self.physics['collisions']['mouse']['prev_target'].\ setLightOff() #Turn back on the default lights self.physics['collisions']['mouse']['prev_target'].\ setLight(self.lights['alnp']) self.physics['collisions']['mouse']['prev_target'].\ setLight(self.lights['dlight']) except: print "Could not turn off node's lighting" #Clear the PC's current target self.entities['PC'].set_target(target=None) #Clear the target text """TODO create a set_target_on_mouseclick method that updates targetbox""" self.GUI.target_box['target_text'].setText("")
class World(ShowBase): # CONDISER: change to DirectObject/FSM def __init__(self): ShowBase.__init__(self) self.createLoadScreen('./LEGameAssets/Textures/title_screen.png') base.graphicsEngine.renderFrame() #== Environment and Rendering Settings == base.setFrameRateMeter(FLAG_SHOW_FRAMES_PER_SECOND) if FLAG_USE_AUTOSHADER: render.setShaderAuto() self.filters = CommonFilters(base.win, self.cam) # NEW if FLAG_SHOW_GLOW: bloomSize = 4 #'small' filterok = self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size=bloomSize) if (filterok == False): print 'WARNING:Video card not powerful enough to do image postprocessing' #tex = loader.loadTexture("./LEGameAssets/Textures/loadbar_tray.png") self.loadBar = DirectWaitBar(text="", value=0, scale=(.35, .5, .5), pos=(0.006, .83, .83)) #self.loadBar['barRelief'] = DirectWaitBar.GROOVE #self.loadBar['scale'] = 0.05 #self.loadBar['barTexture'] = tex self.loadBar['barColor'] = (6.0 / 255.0, 11.0 / 255, 28.0 / 255.0, 1) self.loadBar.reparentTo(render2d) self.loadBar.hide() base.graphicsEngine.renderFrame() self.setBackgroundColor(166.0 / 255.0, 207.0 / 255.0, 240.0 / 255.0, 1) self.skybox = self.loader.loadModel( "LEGameAssets/Models/skybox_final.egg") self.skybox.setScale(50) self.skybox.reparentTo(render) #== Load the level and the managers == self.assets, self.objects, self.gameObjects, self.sounds, self.sequences = loadWorld( SCENE_FILE, LIBRARY_INDEX) self.loadBar['value'] += 5 base.graphicsEngine.renderFrame() self.conversations = loadConversations(SCENE_FILE, LIBRARY_INDEX) self.scenes = {} self.loadScenes() self.loadBar['value'] += 5 base.graphicsEngine.renderFrame() self.journalMgr = JournalMgr(self) self.loadJournal(self.journalMgr, JOURNAL_FILE) self.conversationMgr = ConversationMgr(self, self.conversations) self.scriptMgr = ScriptMgr(self) self.scriptMgr.loadScripts(SCRIPTS_LIST) self.scriptInterface = ScriptInterface(self) self.inventoryMgr = InventoryMgr(self) loadInventory(self.inventoryMgr, INVENTORY_FILE) self.loadBar['value'] += 5 base.graphicsEngine.renderFrame() self.ranSequences = [] #== Main Character == self.hero = None for name, gameObj in self.gameObjects.iteritems(): if gameObj.getNP().hasTag('LE-mainChar'): self.hero = gameObj break else: # make a default hero defaultHeroNP = loader.loadModel("panda") self.hero = GameObject(defaultHeroNP) self.hero.reparentTo(render) self.hero.setPos(0, 0, 0) self.hero.setTag('LE-mainChar', '180') self.gameObjects[self.hero.getName()] = self.hero self.setCollideMasks(self.gameObjects) # remove the hero from the objects dict so it cannot be clicked by player if self.hero.getName() in self.objects: del self.objects[self.hero.getName()] #== Camera == camHeightFactor = CAMERA_HEIGHT camTrailFactor = -CAMERA_TRAIL # careful of +/- distinction self.heroHeight = self.getModelHeight(self.hero) self.heroHeadingOffset = float(self.hero.getTag('LE-mainChar')) self.lastHeroH = self.hero.getH(render) + self.heroHeadingOffset # setup the camera pivot, which will follow the main character model and anchor the camera self.camPivot = NodePath('camPivot') self.camPivot.reparentTo(render) self.camHeight = camHeightFactor * self.heroHeight self.camTrail = camTrailFactor * self.heroHeight self.cam.setPos(self.camPivot.getPos() + (0, self.camTrail, self.camHeight)) self.cam.wrtReparentTo(self.camPivot) self.placeCamera(self.hero) # match X and Y to main character self.alignCamera(self.hero) # match heading to main character #self.camPivot.setH(render, self.hero.getH(render) + self.heroHeadingOffset) self.gameCam = self.cam #== Collisions == self.setupCollisions() #== Controls == self.disableMouse() self.keyMap = {'w': False, 'a': False, 's': False, 'd': False} self.enableMovement(self.hero) self.accept("mouse1", self.onClickin3D) self.accept('escape', sys.exit) self.accept('z', render.place) #== UI and Combat == self.gameplayUI = GameplayUI(self) self.gameplayUI.hideAll() # for health bars and on screen UI self.overlayAmbientLight = AmbientLight('overlayAmbientLight') self.overlayAmbientLight.setColor(VBase4(1.0, 1.0, 1.0, 1.0)) self.overlayAmbientLightNP = render.attachNewNode( self.overlayAmbientLight) # initialize the combat manager (which includes AI) now that a main character and gameplayUI instance and overlay light is established self.combatMgr = CombatMgr(self) # initialize player's spells self.heroSpells = [] for properties in PLAYER_SPELLS: spell = Spell(self.hero, properties) self.heroSpells.append(spell) #== Start Tasks taskMgr.add(self.moveHeroTask, 'moveHeroTask', appendTask=True) taskMgr.add(self.cameraFollowTask, 'cameraFollowTask', appendTask=True) taskMgr.add(self.processHeroCollisions, 'processHeroCollisions') taskMgr.add(self.updateHeroHeight, 'updateHeroHeight') self.combatMgr.startTasks() self.accept('enter', self.destroyLoadScreen) self.destroyLoadScreen() ##== Utility and World Initialization functions =============================## def loadJournal(self, journalMgr, journalFile): f = open(Filename(journalFile).toOsSpecific()) doc = xml.dom.minidom.parse(f) root = doc.childNodes[0] for n in root.childNodes: if n.localName == "journalEntries": journalMgr.decode(n) f.close() def getModelHeight(self, model): min, max = Point3(), Point3() model.calcTightBounds(min, max) return max.getZ() - min.getZ() def createLoadScreen(self, imageFile='./LEGameAssets/Textures/load_screen.png'): self.loadScreen = OnscreenImage(image=imageFile) aspect2d.hide() self.loadScreen.reparentTo(render2d) if (hasattr(self, "gameplayUI")): self.gameplayUI.hideAll() def destroyLoadScreen(self): self.loadBar.hide() self.loadScreen.detachNode() self.loadScreen.destroy() aspect2d.show() self.ignore('enter') self.gameplayUI.showAll() for name, gameObj in self.gameObjects.iteritems(): gameObj.callTrigger(self, 'LE-trigger-onScene') def startLoadBar(self, range=100): self.loadBar.show() self.loadBar['range'] = range self.loadBar['value'] = 0 base.graphicsEngine.renderFrame() def increaseLoadBar(self, value): self.loadBar['value'] += value base.graphicsEngine.renderFrame() ##== Collisions =============================================================## def setupCollisions(self): self.cTrav = CollisionTraverser('mainTraverser') self.cTrav.setRespectPrevTransform(True) # Line collider for setting hero height based on ground geometry heroLine = CollisionNode('heroLine') heroLine.addSolid( CollisionRay(Point3(0, 0, self.heroHeight), Vec3(0, 0, -1))) heroLine.setFromCollideMask(BITMASK_GROUND) heroLine.setIntoCollideMask(BitMask32.allOff()) self.heroGroundCollide = render.attachNewNode(heroLine) self.heroGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.heroGroundCollide, self.heroGroundHandler) # cameraSphere = CollisionNode('cameraSphere') # cameraSphere.addSolid(CollisionSphere(0,0,0,10)) # cameraSphere.setFromCollideMask(BITMASK_CAMERA) # cameraSphere.setIntoCollideMask(BitMask32.allOff()) # self.cameraSphereCollide = self.cam.attachNewNode(cameraSphere) # self.cameraSphereQueue = CollisionHandlerQueue() # self.cTrav.addCollider(self.cameraSphereCollide, self.cameraSphereQueue) self.herowallcollision = False self.heroWallCollideX = render.attachNewNode("heroWallX") self.heroWallCollideY = render.attachNewNode("heroWallY") self.heroWallCollideZ = render.attachNewNode("heroWallZ") # Line collider for running into obstacles and walls in X direction heroLineX = CollisionNode('heroLineX') heroLineX.addSolid(CollisionRay(Point3(0, 0, 0), Vec3(0, 0, 1))) self.heroWallCollideLineX = self.heroWallCollideX.attachNewNode( heroLineX) self.heroWallCollideLineX.node().setFromCollideMask( BITMASK_WALL_TERRAIN) self.heroWallCollideLineX.node().setIntoCollideMask(BitMask32.allOff()) self.heroWallQueueX = CollisionHandlerQueue() self.cTrav.addCollider(self.heroWallCollideLineX, self.heroWallQueueX) # Line collider for running into obstacles and walls in Y direction heroLineY = CollisionNode('heroLineY') heroLineY.addSolid(CollisionRay(Point3(0, 0, 0), Vec3(0, 0, 1))) self.heroWallCollideLineY = self.heroWallCollideY.attachNewNode( heroLineY) self.heroWallCollideLineY.node().setFromCollideMask( BITMASK_WALL_TERRAIN) self.heroWallCollideLineY.node().setIntoCollideMask(BitMask32.allOff()) self.heroWallQueueY = CollisionHandlerQueue() self.cTrav.addCollider(self.heroWallCollideLineY, self.heroWallQueueY) # Line collider for running into obstacles and walls in Z direction heroLineZ = CollisionNode('heroLineZ') heroLineZ.addSolid(CollisionRay(Point3(0, 0, 0), Vec3(0, 0, 1))) self.heroWallCollideLineZ = self.heroWallCollideZ.attachNewNode( heroLineZ) self.heroWallCollideLineZ.node().setFromCollideMask( BITMASK_WALL_TERRAIN) self.heroWallCollideLineZ.node().setIntoCollideMask(BitMask32.allOff()) self.heroWallQueueZ = CollisionHandlerQueue() self.cTrav.addCollider(self.heroWallCollideLineZ, self.heroWallQueueZ) # # Sphere collider for running into obstacles and walls # heroSphere = CollisionNode('heroSphere') # heroSphere.addSolid(CollisionSphere(0,0,0,7)) # self.heroWallCollide = render.attachNewNode(heroSphere) # self.heroWallCollide.node().setFromCollideMask(BITMASK_WALL) # self.heroWallCollide.node().setIntoCollideMask(BitMask32.allOff()) # self.heroWallQueue = CollisionHandlerQueue() # self.cTrav.addCollider(self.heroWallCollide, self.heroWallQueue) # self.herowallcollision = False # Sphere collider for running into obstacles and walls in X direction heroSphereX = CollisionNode('heroSphereX') heroSphereX.addSolid(CollisionSphere(0, 0, 0, 7)) self.heroWallCollideSphereX = self.heroWallCollideX.attachNewNode( heroSphereX) self.heroWallCollideSphereX.node().setFromCollideMask(BITMASK_WALL) self.heroWallCollideSphereX.node().setIntoCollideMask( BitMask32.allOff()) #self.heroWallQueueX = CollisionHandlerQueue() self.cTrav.addCollider(self.heroWallCollideSphereX, self.heroWallQueueX) self.herowallcollision = False # Sphere collider for running into obstacles and walls in Y direction heroSphereY = CollisionNode('heroSphereY') heroSphereY.addSolid(CollisionSphere(0, 0, 0, 7)) self.heroWallCollideSphereY = self.heroWallCollideY.attachNewNode( heroSphereY) self.heroWallCollideSphereY.node().setFromCollideMask(BITMASK_WALL) self.heroWallCollideSphereY.node().setIntoCollideMask( BitMask32.allOff()) #self.heroWallQueueY = CollisionHandlerQueue() self.cTrav.addCollider(self.heroWallCollideSphereY, self.heroWallQueueY) # Sphere collider for running into obstacles and walls in Z direction heroSphereZ = CollisionNode('heroSphereZ') heroSphereZ.addSolid(CollisionSphere(0, 0, 0, 7)) self.heroWallCollideSphereZ = self.heroWallCollideZ.attachNewNode( heroSphereZ) self.heroWallCollideSphereZ.node().setFromCollideMask(BITMASK_WALL) self.heroWallCollideSphereZ.node().setIntoCollideMask( BitMask32.allOff()) #self.heroWallQueueZ = CollisionHandlerQueue() self.cTrav.addCollider(self.heroWallCollideSphereZ, self.heroWallQueueZ) # Ray collider for clicking on objects in the game self.pickerCollisionQueue = CollisionHandlerQueue() self.pickerCN = CollisionNode('pickerRayCN') self.pickerCNP = self.cam.attachNewNode(self.pickerCN) self.pickerCN.setFromCollideMask(BITMASK_CLICK) self.pickerCN.setIntoCollideMask(BitMask32.allOff()) self.pickerRay = CollisionRay() self.pickerCN.addSolid(self.pickerRay) self.cTrav.addCollider(self.pickerCNP, self.pickerCollisionQueue) # Sphere collider for triggering scripts self.heroCN = CollisionNode('heroCN') self.heroCN.addSolid(CollisionSphere(0, 0, 0, 5)) # TODO: find good radius self.heroCNP = self.hero.attachNewNode(self.heroCN) self.heroCN.setFromCollideMask(BITMASK_HERO_COLLIDE) self.heroCN.setIntoCollideMask(BitMask32.allOff()) self.heroCollisionQueue = CollisionHandlerQueue() self.cTrav.addCollider(self.heroCNP, self.heroCollisionQueue) # Line collider for transparency self.cameraEntriesPre = [] radius = self.getModelHeight(self.hero) * CAMERA_TRAIL / 2 self.cameraCollisionQueue = CollisionHandlerQueue() self.cameraHero = CollisionNode('cameraHero') self.cameraHeroLine = CollisionSegment(self.hero.getPos(render), self.cam.getPos(render)) self.cameraHero.addSolid(self.cameraHeroLine) self.cameraHero.setFromCollideMask(BITMASK_CAMERA) self.cameraHero.setIntoCollideMask(BitMask32.allOff()) self.cameraHeroP = self.render.attachNewNode(self.cameraHero) self.cTrav.addCollider(self.cameraHeroP, self.cameraCollisionQueue) #self.cameraHeroP.show() if FLAG_SHOW_COLLISIONS: self.cTrav.showCollisions(render) # TODO: show specific collision nodepaths def setCollideMasks(self, gameObjDict): for name, obj in gameObjDict.iteritems(): bitmask = obj.getCollideMask() if obj.hasTag('LE-ground'): bitmask |= BITMASK_GROUND #obj.getNP().setCollideMask(bitmask) # TODO: remove if obj.hasTag('LE-attackable'): bitmask |= BITMASK_CLICK if obj.hasTag('LE-wall'): if (isinstance(obj.getNP(), GeoMipTerrain)): bitmask |= BITMASK_TERRAIN else: bitmask |= BITMASK_WALL if obj.scripts.has_key('LE-trigger-onClick'): bitmask |= BITMASK_CLICK if obj.scripts.has_key('LE-trigger-onCollision'): bitmask |= BITMASK_HERO_COLLIDE if obj.hasTag('OBJRoot'): if obj.hasTag('LE-ground') or obj.hasTag('LE-mainChar'): pass else: bitmask |= BITMASK_CAMERA obj.setCollideMask(bitmask) def onClickin3D(self): pickedObj = None if self.conversationMgr.isConversationOpen(): return if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() else: return self.cTrav.addCollider(self.pickerCNP, self.pickerCollisionQueue) self.pickerRay.setFromLens(self.cam.node(), mpos.getX(), mpos.getY()) self.cTrav.traverse(render) if (self.pickerCollisionQueue.getNumEntries() > 0): self.pickerCollisionQueue.sortEntries() for i in range(self.pickerCollisionQueue.getNumEntries()): parent = self.pickerCollisionQueue.getEntry( i).getIntoNodePath().getParent() while not self.objects.has_key(parent.getName()): if (parent.getName() == "render"): return parent = parent.getParent() pickedObj = parent if (pickedObj == None): continue else: break #if pickedObj.hasTag("LE-trigger-onClick"): # TODO: needed, or is having key in self.objects enough? if (pickedObj == None): return self.pickerCollisionQueue.clearEntries() self.cTrav.removeCollider(self.pickerCNP) gameObj = self.gameObjects[pickedObj.getName()] distToTarget = self.hero.getDistance(gameObj) if self.combatMgr.checkCanAttack(self.hero, gameObj): if distToTarget <= self.heroSpells[ self.curSpellIndex].getAttackRange(): self.combatMgr.queueAttack(self.hero, self.heroSpells[self.curSpellIndex], gameObj) else: textObject = OnscreenText(text='The target is out of range!', fg=(1, 0, 0, 1), pos=(0, 0), scale=0.09, align=TextNode.ACenter) def destroyWarning1(): textObject.destroy() sequence = Sequence(Wait(2), Func(destroyWarning1)) sequence.start() return elif (distToTarget > CLICK_RANGE): textObject = OnscreenText(text='The target is out of range!', fg=(1, 0, 0, 1), pos=(0, 0), scale=0.09, align=TextNode.ACenter) def destroyWarning2(): textObject.destroy() sequence = Sequence(Wait(2), Func(destroyWarning2)) sequence.start() return gameObj.callTrigger(self, 'LE-trigger-onClick') # Task for processing hero's collisions with GameObjects, triggering OnCollision scripts def processHeroCollisions(self, task): #self.cTrav.traverse(render) debug("processHeroCollisions") # CONSIDER: may not be necessary to sort if (self.heroCollisionQueue.getNumEntries() > 0): self.heroCollisionQueue.sortEntries() debug("queue size: " + str(self.heroCollisionQueue.getNumEntries())) for i in range(self.heroCollisionQueue.getNumEntries()): # CONSIDER: if entry.hasInto(): for efficiency debug("i: " + str(i)) # TODO: check if GameObject is passable, and react accordingly (store old position, revert to it) if (self.heroCollisionQueue.getNumEntries() <= 0): return entry = self.heroCollisionQueue.getEntry(i) debug("entry: " + str(entry)) if (entry): intoNP = entry.getIntoNodePath() else: continue if (intoNP != None) or (not intoNP.isEmpty()): while not self.objects.has_key(intoNP.getName()): if (intoNP.getName() == "render"): return task.cont intoNP = intoNP.getParent() pickedObj = intoNP if pickedObj == None: continue gameObj = self.gameObjects[pickedObj.getName()] gameObj.callTrigger(self, 'LE-trigger-onCollision') return task.cont ##== Camera Movement ========================================================## # places the camera pivot to match the position of the node path parameter # used to have the camera pivot match the main character's position as he moves def placeCamera(self, np): self.camPivot.setX(render, np.getX(render)) self.camPivot.setY(render, np.getY(render)) def alignCamera(self, np): self.camPivot.setH(render, self.hero.getH(render) + self.heroHeadingOffset) self.cam.setP(CAMERA_PITCH) def cameraFollowTask(self, task): heroH = self.hero.getH(render) + self.heroHeadingOffset camPivotH = self.camPivot.getH(render) # normalizes the headings to avoid jumps in the difference # which could come from passing 360 and going back to 0, for example # TODO: stress test, esp. with different values of self.heroHeadingOffset while heroH + 180 < camPivotH: heroH += 360 while camPivotH + 180 < heroH: camPivotH += 360 self.lastHeroH = heroH rotateLeft = (heroH >= camPivotH) rotateRight = not rotateLeft diff = math.fabs(heroH - camPivotH) if diff > CAMERA_TURN_THRESHOLD: if rotateLeft: self.camPivot.setH(self.camPivot.getH() + CAMERA_TURN_SPEED) elif rotateRight: self.camPivot.setH(self.camPivot.getH() - CAMERA_TURN_SPEED) # if(len(self.cameraEntriesPre)>0): # #print self.cameraEntriesPre # if(self.hero.getDistance(self.cam) > 5): # moveAmount = min(globalClock.getDt()*200,5.0) # pos = self.cam.getQuat().getForward()*moveAmount # newpos = self.cam.getPos() + pos # self.oldCameraEntriesPre = [] # for e in self.cameraEntriesPre: # self.oldCameraEntriesPre.append(e) # self.cam.setFluidPos(newpos) # # else: # if(self.hero.getDistance(self.cam) < 100): # moveAmount = min(globalClock.getDt()*200,5.0) # pos = self.cam.getQuat().getForward()*(-moveAmount) # oldpos = self.cam.getPos() # newpos = self.cam.getPos() + pos # self.cam.setFluidPos(newpos) # for e in self.oldCameraEntriesPre: # #print e.getIntoNodePath() # self.cTrav.traverse(e.getIntoNodePath()) # #self.cTrav.traverse(render) # if(len(self.cameraSphereQueue.getEntries())>0): # self.cam.setFluidPos(oldpos) return task.cont def runCamera(self, cameraName, sequence, isLoop=False): debug("Running the camera") #debug(str(self.sequences)) self.oldCamera = self.cam self.dr = self.win.makeDisplayRegion() dr2 = self.cam.node().getDisplayRegion(0) # self.objects[cameraName].node().setLens(base.camLens) parent = self.cam.getParent() self.cam.detachNode() self.dr.setCamera(self.objects[cameraName]) def temp(): dr2.setCamera(self.oldCamera) self.oldCamera.reparentTo(parent) self.dr.setActive(False) del self.dr self.dr = None self.accept("mouse1", self.onClickin3D) debug("Ran") if (isLoop): newSequence = Sequence(sequence) self.addSequence(newSequence) def stopCameraFromLoop(): newSequence.finish() temp() self.accept("mouse1", stopCameraFromLoop) self.addSequence(newSequence) newSequence.loop() else: newSequence = Sequence(sequence, Func(temp)) def stopCamera(): newSequence.finish() self.accept("mouse1", stopCamera) self.addSequence(newSequence) newSequence.start() ##== Character Movement =====================================================## def moveHeroTo(self, destinationObj): pos = destinationObj.getPos(render) hpr = destinationObj.getHpr(render) self.hero.setPosHpr(render, pos, hpr) self.placeCamera(self.hero) self.alignCamera(self.hero) def updateHeroHeight(self, task=None): groundEntries = [] #move the collision line to the hero position self.heroGroundCollide.setPos(self.hero.getPos(render)) #loop through every collision entry for the line for e in self.heroGroundHandler.getEntries(): if e.getIntoNodePath().hasNetTag('OBJRoot'): #find the actual root of the object np = e.getIntoNodePath().findNetTag('OBJRoot') #only react to objects that are tagged as the ground if np.hasTag('LE-ground'): groundEntries.append(e) if groundEntries: #sort the collision entries based on height groundEntries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),\ x.getSurfacePoint(render).getZ())) #set hero height and pivot height self.hero.setZ(groundEntries[0].getSurfacePoint(render).getZ() + MAIN_CHAR_GROUND_OFFSET) self.camPivot.setZ( groundEntries[0].getSurfacePoint(render).getZ() + MAIN_CHAR_GROUND_OFFSET) # TODO: unlink these from being in the same task in case we want pivot to not be linked to hero (ex. cutscene) self.heroGroundHandler.clearEntries() return task.cont def updateHeroPos(self, queue, stepSize): wallEntries = [] for w in queue.getEntries(): np = w.getIntoNodePath().findNetTag('OBJRoot') if np.hasTag('LE-wall'): if self.isInObstacleRange(self.hero, w, stepSize): wallEntries.append(w) if len(wallEntries) > 0: self.herowallcollision = True #self.collisionsurfaceP = wallEntries[0].getSurfacePoint(render) else: self.herowallcollision = False def updateCameraCollision(self): self.cameraHeroLine.setPointA(self.cam.getPos(render)) self.cameraHeroLine.setPointB(self.hero.getPos(render)) if (self.cameraEntriesPre): for i in self.cameraEntriesPre: i.getIntoNodePath().setTransparency(TransparencyAttrib.MAlpha) i.getIntoNodePath().setAlphaScale(1.0) del self.cameraEntriesPre[:] for i in self.cameraCollisionQueue.getEntries(): i.getIntoNodePath().setAlphaScale(0.5) self.cameraEntriesPre.append(i) def moveHero(self, direction, dt): temp = render.attachNewNode("Dummy") #NodePath() moveStep = MAIN_CHAR_MOVE_SPEED * dt if moveStep > MAIN_CHAR_MAX_STEP: moveStep = MAIN_CHAR_MAX_STEP temp.setPos(self.camPivot, 0, direction * moveStep, 0) #oldPos = self.heroWallCollideX.getPos() self.heroWallCollideX.setX(temp.getX()) self.heroWallCollideY.setY(temp.getY()) self.heroWallCollideZ.setZ(temp.getZ()) #+10) self.cTrav.traverse(render) #check on X direction self.updateHeroPos(self.heroWallQueueX, moveStep) self.moveHeroToWallCollide( Point3(temp.getX(), self.hero.getY(), self.hero.getZ())) #check on Y direction self.updateHeroPos(self.heroWallQueueY, moveStep) self.moveHeroToWallCollide( Point3(self.hero.getX(), temp.getY(), self.hero.getZ())) #check on Z direction self.updateHeroPos(self.heroWallQueueZ, moveStep) self.moveHeroToWallCollide( Point3(self.hero.getX(), self.hero.getY(), temp.getZ())) self.heroWallCollideX.setPos(self.hero.getPos()) self.heroWallCollideY.setPos(self.hero.getPos()) self.heroWallCollideZ.setPos(self.hero.getPos()) self.placeCamera(self.hero) self.updateCameraCollision() temp.detachNode() def moveHeroToWallCollide(self, pos): if self.herowallcollision == False: self.hero.setPos(pos) #self.camPivot, 0, MAIN_CHAR_MOVE_SPEED, 0) def isInObstacleRange(self, mover, colEntry, stepSize): colPoint = colEntry.getSurfacePoint(render) if colPoint[2] >= mover.getZ(render): dist = findDistance3D(mover.getX(), mover.getY(), mover.getZ(), colPoint[0], colPoint[1], colPoint[2]) obstacleThreshold = self.heroHeight * self.heroHeight + stepSize * stepSize if dist * dist <= obstacleThreshold: return True return False def turnHeroLeft(self): up = render.getRelativeVector(base.cam, Vec3(0, 0, 1)) up.normalize() curHeroQuat = self.hero.getQuat() newHeroQuat = Quat() newHeroQuat.setFromAxisAngle(MAIN_CHAR_ROTATE_SPEED, up) self.hero.setQuat(curHeroQuat * newHeroQuat) self.hero.setR(0) self.hero.setP(0) self.updateCameraCollision() def turnHeroRight(self): up = render.getRelativeVector(base.cam, Vec3(0, 0, 1)) up.normalize() curHeroQuat = self.hero.getQuat() newHeroQuat = Quat() newHeroQuat.setFromAxisAngle(-MAIN_CHAR_ROTATE_SPEED, up) self.hero.setQuat(curHeroQuat * newHeroQuat) self.hero.setR(0) self.hero.setP(0) self.updateCameraCollision() def disableMovement(self, gameObj): if gameObj.getName() == self.hero.getName(): self.ignore('w') self.ignore('w-up') self.ignore('a') self.ignore('a-up') self.ignore('s') self.ignore('s-up') self.ignore('d') self.ignore('d-up') else: if gameObj.getAIBehaviorsHandle().behaviorStatus('pursue') != -1: gameObj.getAIBehaviorsHandle().pauseAi('pursue') def enableMovement(self, gameObj): if gameObj.getName() == self.hero.getName(): self.accept('w', self.setKeyStatus, extraArgs=['w', True]) self.accept('w-up', self.setKeyStatus, extraArgs=['w', False]) self.accept('a', self.setKeyStatus, extraArgs=['a', True]) self.accept('a-up', self.setKeyStatus, extraArgs=['a', False]) self.accept('s', self.setKeyStatus, extraArgs=['s', True]) self.accept('s-up', self.setKeyStatus, extraArgs=['s', False]) self.accept('d', self.setKeyStatus, extraArgs=['d', True]) self.accept('d-up', self.setKeyStatus, extraArgs=['d', False]) else: if gameObj.getAIBehaviorsHandle().behaviorStatus( 'pursue') == 'paused': gameObj.getAIBehaviorsHandle().resumeAi('pursue') def setKeyStatus(self, key, isDown): self.keyMap[key] = isDown print self.hero.getName() ###################################################################### ## # ZJC - 07/29/2011: THIS CODE WAS COMMENTED OUT BECAUSE A MORE EFFICIENT WAY WAS FOUND ## ## prefixList = [] ## #NEXT LINE- ZJC - 07/29/2011: This line is used to mark where to import the array used to deal with import flags. ## #LoaderFlagImportArray ## name = self.hero.getName().split('_')[0] # ZJC - 07/29/2011: name is assumed to be formatted NAME_otherstuff ## name2 = self.hero.getName().split('_')[1] # ZJC - 07/29/2011: name2 is assumed to be PREFIX_NAME_otherstuff ## if name in prefixList: # ZJC - 07/29/2011: Checks if the name is in the array, if it is name is not formatted as assumed ## name = name2 # ZJC - 07/29/2011: Use the second format if the first name is in the list ## print name ###################################################################### name = self.hero.getName().split('_')[ 0] # ZJC - 07/29/2011: Assumes format is Name_mod:# ## print name for i in range( len(self.here.getName().split('_')) ): # ZJC - 07/29/2011: Loop will check every possibility in the name string for any level of merges/imports name2 = self.hero.getName().split( '_' )[i] # ZJC - 07/29/2011: name2 holds the current piece of the name string if ("mod:" in name2) and ( name != name2 ): # ZJC - 07/29/2011: This means the name format is Prefix(es)_Name_mod:# name = self.hero.getName().split( '_' )[i - 1] # ZJC - 07/29/2011: Assigns correct model name, the one just before mod:# if isDown: if key == 'w': if self.hero.getActorHandle() != None: self.hero.getActorHandle().stop( name + '_ani_idle' ) # ZJC - 07/26/2011: Stop the 'name' specific idle animation self.hero.getActorHandle().setPlayRate( 1.0, name + '_ani_run' ) # ZJC - 07/26/2011: Set play rate for the 'name' specific run animation self.hero.getActorHandle().loop( name + '_ani_run' ) # ZJC - 07/26/2011: Run the 'name' specific run animation self.keyMap['s'] = False elif key == 's': if self.hero.getActorHandle() != None: self.hero.getActorHandle().stop( name + '_ani_idle' ) # ZJC - 07/26/2011: Stop the 'name' specific idle animation self.hero.getActorHandle().setPlayRate( -0.7, name + '_ani_run' ) # ZJC - 07/26/2011: Set play rate for the 'name' specific run animation self.hero.getActorHandle().loop( name + '_ani_run' ) # ZJC - 07/26/2011: Run the 'name' specific run animation self.keyMap['w'] = False elif key == 'a': self.keyMap['d'] = False elif key == 'd': self.keyMap['a'] = False elif not isDown: if key == 'w': if not self.keyMap['s']: if self.hero.getActorHandle() != None: self.hero.getActorHandle().stop( name + '_ani_run' ) # ZJC - 07/26/2011: Stop the 'name' specific run animation self.hero.getActorHandle().loop( name + '_ani_idle' ) # ZJC - 07/26/2011: Run the 'name' specific idle animation elif key == 's': if not self.keyMap['w']: if self.hero.getActorHandle() != None: self.hero.getActorHandle().stop( name + '_ani_run' ) # ZJC - 07/26/2011: Stop the 'name' specific run animation self.hero.getActorHandle().loop( name + '_ani_idle' ) # ZJC - 07/26/2011: Run the 'name' specific idle animation elif key == 'a': pass elif key == 'd': pass ## ZJC - 07/26/2011: This was the previous version of the code, it has been commented out and left as ## a reference. The changes made are defined in the comments above. ## if isDown: ## if key == 'w': ## if self.hero.getActorHandle() != None: ## self.hero.getActorHandle().stop('anim_idleFemale') # TODO: make a constant / set in LE ## self.hero.getActorHandle().setPlayRate(1.0, 'anim_jogFemale') ## self.hero.getActorHandle().loop('anim_jogFemale') ## self.keyMap['s'] = False ## elif key == 's': ## if self.hero.getActorHandle() != None: ## self.hero.getActorHandle().stop('anim_idleFemale') # TODO: make a constant / set in LE ## self.hero.getActorHandle().setPlayRate(-0.7, 'anim_jogFemale') ## self.hero.getActorHandle().loop('anim_jogFemale') ## self.keyMap['w'] = False ## elif key == 'a': ## self.keyMap['d'] = False ## elif key == 'd': ## self.keyMap['a'] = False ## elif not isDown: ## if key == 'w': ## if not self.keyMap['s']: ## if self.hero.getActorHandle() != None: ## self.hero.getActorHandle().stop('anim_jogFemale') ## self.hero.getActorHandle().loop('anim_idleFemale') ## elif key == 's': ## if not self.keyMap['w']: ## if self.hero.getActorHandle() != None: ## self.hero.getActorHandle().stop('anim_jogFemale') ## self.hero.getActorHandle().loop('anim_idleFemale') ## elif key == 'a': ## pass ## elif key == 'd': ## pass def moveHeroTask(self, task): dt = globalClock.getDt() direction = int(self.keyMap['w']) - int(self.keyMap['s']) self.moveHero(direction, dt) if self.keyMap['a']: self.turnHeroLeft() elif self.keyMap['d']: self.turnHeroRight() return task.cont ##== Scene Handling =========================================================## def loadScenes(self): # NOTE: Do not remove! This function is populated by StandaloneExporter pass def addSequence(self, sequence): self.ranSequences.append(sequence) #this is for changing scenes def resetAllSequences(self): for seq in self.ranSequences: seq.finish() dr = self.cam.node().getDisplayRegion(0) dr.setCamera(self.gameCam) self.ranSequences = [] def openScene(self, sceneName): if (self.scenes.has_key(sceneName) == False): print "ERROR:There is no scene under the name ", sceneName, "." return self.startLoadBar(12) self.createLoadScreen() #Part2:Clear all of the collision lists self.cTrav.removeCollider(self.heroCNP) self.heroGroundHandler.clearEntries() self.heroCollisionQueue.clearEntries() self.resetAllSequences() self.increaseLoadBar(1) #Part3: stop all of the tasks taskMgr.remove('processHeroCollisions') taskMgr.remove('updateHeroHeight') taskMgr.remove('moveHeroTask') taskMgr.remove('cameraFollowTask') taskMgr.remove("updateShaders") # ? self.combatMgr.stopTasks() self.gameplayUI.stop() self.gameplayUI.removeAllHealthBars() self.increaseLoadBar(1) #Part1.1: Stop currently running parts like conversations or camera if (self.conversationMgr.isConversationOpen()): self.conversationMgr.closeConversation() #Part 1.2: stop the camera self.increaseLoadBar(1) #Part4: Turn-Off all of the player controls self.ignore("mouse1") self.increaseLoadBar(1) #Part5: Remove all of the game elements that are related with the current scene del self.combatMgr self.increaseLoadBar(1) #Part6: Remove all of the children and the lights from the render render.getChildren().detach() render.clearLight() self.increaseLoadBar(1) #Part7:Add the camera and hero or any game element that should be exist in any scene back self.camPivot.reparentTo(render) self.hero.reparentTo(render) #self.heroWallCollide.reparentTo(render) self.heroWallCollideX.reparentTo(render) self.heroWallCollideY.reparentTo(render) self.heroWallCollideZ.reparentTo(render) self.heroGroundCollide.reparentTo(render) self.cameraHeroP.reparentTo(render) self.overlayAmbientLightNP.reparentTo(render) self.increaseLoadBar(1) #Part8:Add the new objects from the new scene self.assets, self.objects, self.gameObjects, self.sounds, self.sequences = loadWorld( self.scenes[sceneName], LIBRARY_INDEX) self.increaseLoadBar(1) #Part9:Add the hero to the new gameObject list and remove the duplicates of the hero self.gameObjects[self.hero.getName()] = self.hero if (self.objects.has_key(self.hero.getName())): object = self.objects[self.hero.getName()] if (object.hasTag('LE-mainChar')): object.detachNode() del self.objects[self.hero.getName()] for name, gameObj in self.gameObjects.iteritems(): if gameObj.getNP().hasTag('LE-ground'): #debug("is Ground") bitmask = gameObj.getNP().getCollideMask() bitmask |= BITMASK_GROUND gameObj.getNP().setCollideMask(bitmask) self.increaseLoadBar(1) #Part10:Restart the tasks. self.combatMgr = CombatMgr(self) taskMgr.add(self.processHeroCollisions, 'processHeroCollisions') taskMgr.add(self.updateHeroHeight, 'updateHeroHeight') taskMgr.add(self.moveHeroTask, 'moveHeroTask') taskMgr.add(self.cameraFollowTask, 'cameraFollowTask') self.combatMgr.startTasks() self.gameplayUI.start() self.increaseLoadBar(1) self.setCollideMasks(self.gameObjects) self.increaseLoadBar(1) #Part11: Change the color of the sky if (sceneName.startswith("interior") or sceneName.startswith("Interior")): self.setBackgroundColor(BGC_DARK_GREY) else: self.skybox.reparentTo(render) self.setBackgroundColor(BGC_LIGHT_BLUE) self.increaseLoadBar(1) #Part12: Restart the player controls self.accept("mouse1", self.onClickin3D) self.increaseLoadBar(1) self.accept("enter", self.destroyLoadScreen) debug("After open Scene: " + str(self.heroCollisionQueue.getNumEntries())) self.heroCollisionQueue.clearEntries() self.cTrav.addCollider(self.heroCNP, self.heroCollisionQueue) self.destroyLoadScreen()
class World: def __init__(self): base.disableMouse() # Turns off the default mouse-camera controls in Panda3D. base.setBackgroundColor(0, 0, 0) # Sets the background to black. self.inputManager = InputManager() # Creates an InputManager to handle all of the user input in the game. #taskMgr.doMethodLater(10, self.debugTask, "Debug Task") # Tells the debugTask to run once every ten seconds. The debug task is a good # place to put various data print outs about the game to help with debugging. self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size=2) # Creates a bloom filter that will integrate with the Glow maps applied to objects to create # the halos around glowing objects. render.setShaderAuto() # Turns on Panda3D's automatic shader generation. self.menuGraphics = loader.loadModel("../Models/MenuGraphics.egg") # Loads the egg that contains all the menu graphics. self.fonts = { "silver": loader.loadFont("../Fonts/LuconSilver.egg"), "blue": loader.loadFont("../Fonts/LuconBlue.egg"), "orange": loader.loadFont("../Fonts/LuconOrange.egg") } # Loads the three custom fonts our game will use. preloader = Preloader(self.fonts) hud = HUD(self.fonts) # Creates the HUD. self.race = Race(self.inputManager, hud) self.race.createDemoRace() # creates an instance of the race class and tells it to # start a demo race. self.createStartMenu() # creates the start menu. musicMgr = base.musicManager self.music = musicMgr.getSound( "../Sound/Loveshadow-Takin_Yo_Time_(The_Wingman_Mix).wav") self.music.setLoop(True) self.music.setVolume(.5) self.music.play() # loads a sound file for the background music, sets it to loop, and plays it. def createStartMenu(self): menu = Menu(self.menuGraphics, self.fonts, self.inputManager) menu.initMenu([ 0, None, ["New Game", "Quit Game"], # The two options the menu will have. [ [self.race.createRace, self.createReadyDialogue ], # functions executed by the first option. [base.userExit] ], # function executed by the second option. [[None, None], [None]] ]) # The arguments to be passed to the functions. # createStartMenu: Creates a new menu to be used as the start menu. def createReadyDialogue(self): menu = Menu(self.menuGraphics, self.fonts, self.inputManager) menu.initMenu([ 3, "Are you ready?", ["Yes", "Exit"], # The two options the menu will have. [[self.race.startRace], [self.race.createDemoRace]], # functions executed by the options. [[3], [None]] ]) # The arguments to be passed to the functions. # createReadyDialogue: Creates a new menu to be used as dialogue box that querries if the player is ready or not. def debugTask(self, task): print(taskMgr) # prints all of the tasks in the task manager. return task.again
class GlowDemo(ShowBase): def __init__(self): # Initialize the ShowBase class from which we inherit, which will # create a window and set up everything we need for rendering into it. ShowBase.__init__(self) base.disableMouse() base.setBackgroundColor(0, 0, 0) camera.setPos(0, -50, 0) # Check video card capabilities. if not base.win.getGsg().getSupportsBasicShaders(): addTitle( "Glow Filter: Video driver reports that Cg shaders are not supported.") return # Use class 'CommonFilters' to enable a bloom filter. # The brightness of a pixel is measured using a weighted average # of R,G,B,A. We put all the weight on Alpha, meaning that for # us, the framebuffer's alpha channel alpha controls bloom. self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom( blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size="small") if (filterok == False): addTitle( "Toon Shader: Video card not powerful enough to do image postprocessing") return self.glowSize = 1 # Post the instructions self.title = addTitle("Panda3D: Tutorial - Glow Filter") self.inst1 = addInstructions(0.06, "ESC: Quit") self.inst2 = addInstructions(0.12, "Space: Toggle Glow Filter Small/Med/Large/Off") self.inst3 = addInstructions(0.18, "Enter: Toggle Running/Spinning") self.inst4 = addInstructions(0.24, "V: View the render-to-texture results") # load our model self.tron = Actor() self.tron.loadModel("models/tron") self.tron.loadAnims({"running": "models/tron_anim"}) self.tron.reparentTo(render) self.interval = self.tron.hprInterval(60, LPoint3(360, 0, 0)) self.interval.loop() self.isRunning = False # put some lighting on the model dlight = DirectionalLight('dlight') alight = AmbientLight('alight') dlnp = render.attachNewNode(dlight) alnp = render.attachNewNode(alight) dlight.setColor((1.0, 0.7, 0.2, 1)) alight.setColor((0.2, 0.2, 0.2, 1)) dlnp.setHpr(0, -60, 0) render.setLight(dlnp) render.setLight(alnp) # Panda contains a built-in viewer that lets you view the results of # your render-to-texture operations. This code configures the viewer. self.accept("v", base.bufferViewer.toggleEnable) self.accept("V", base.bufferViewer.toggleEnable) base.bufferViewer.setPosition("llcorner") base.bufferViewer.setLayout("hline") # base.camLens.setFov(100) # event handling self.accept("space", self.toggleGlow) self.accept("enter", self.toggleDisplay) self.accept("escape", sys.exit, [0]) def toggleGlow(self): self.glowSize = self.glowSize + 1 if self.glowSize == 4: self.glowSize = 0 self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size=self.glowSize) def toggleDisplay(self): self.isRunning = not self.isRunning if not self.isRunning: camera.setPos(0, -50, 0) self.tron.stop("running") self.tron.pose("running", 0) self.interval.loop() else: camera.setPos(0, -170, 3) self.interval.finish() self.tron.setHpr(0, 0, 0) self.tron.loop("running")
class MainApp(ShowBase): def __init__(self): ShowBase.__init__(self) # Load shaders. If this fails, quit. if(not self.loadShaders()): return #Make some floors for us :) floorTex=loader.loadTexture('maps/envir-ground.jpg') cm=CardMaker('') cm.setFrame(-2,2,-2,2) floor = render.attachNewNode(PandaNode("floor")) for y in range(12): for x in range(12): nn = floor.attachNewNode(cm.generate()) nn.setP(-90) nn.setPos((x-6)*4, (y-6)*4, 0) floor.setTexture(floorTex) floor.flattenStrong() # set up shaders and anti alias self.render.setShaderAuto() self.render.setAntialias(AntialiasAttrib.MAuto) # set up lights dlight = DirectionalLight('dlight') alight = AmbientLight('alight') dlnp = render.attachNewNode(dlight) alnp = render.attachNewNode(alight) dlight.setColor(Vec4(1.0, 0.7, 0.2, 1)) alight.setColor(Vec4(0.2, 0.2, 0.2, 1)) dlnp.setHpr(0, -60, 0) render.setLight(dlnp) render.setLight(alnp) # Models #Tron self.pandaActor = Actor("models/tron") self.pandaActor.setScale(0.3, 0.3, 0.3) self.pandaActor.reparentTo(self.render) self.pandaActor.setPos(10, 0, 4.2) #Panda # Load the "panda" model. Loading a model returns a # NodePath object. ##self.panda = loader.loadModel("panda") # Remember, loaded objects start out hidden! If we want to # see the panda, it must be reparented to the "render" node. ##self.panda.reparentTo(render) # By default, position is specified relative to a node's # parent.Position is specified as "x,y,z" or "right, forward, up" # Since panda's parent is the root node (render), # this command moves panda to the global position (0, 30, -5). ##self.panda.setPos(0, 0, 0) # Alternately, the position can be given relative to any other # NodePath. Here, we set the position to be 30 feet in front # of the camera, and slightly to the right. Note the use of # 'camera', another pre-defined NodePath object. ##self.panda.setX(camera, 10) # Text self.text = TextNode('node name') self.textNodePath = aspect2d.attachNewNode(self.text) self.textNodePath.setScale(0.05) self.text.setTextColor(1, 1, 1, 1) # enable physics base.enableParticles() self.physicsNode=NodePath(PandaNode("PhysicsNode")) self.physicsNode.reparentTo(render) # set up camera with physics self.cameraActorNode=ActorNode("camera-physics") self.cameraActorNodeParent=self.physicsNode.attachNewNode(self.cameraActorNode) base.physicsMgr.attachPhysicalNode(self.cameraActorNode) self.camera.reparentTo(self.cameraActorNodeParent) # set up camera and mouse settings self.camera.setPos(6.27662, -48.9656, 26.0119) self.camera.setHpr(7.30458, -27.7855, 3.34447) self.cameraInterval = self.camera.posInterval(10, Point3(10,10,20), startPos=Point3(camera.getPos())) self.cameraPace = Sequence(self.cameraInterval) self.cameraForwardThrottleEnabled = False #self.cameraPace.start() # disable debug mode for starters self.setDebugMode(False) # event handling self.accept("space", self.toggleGlow) self.accept("escape", sys.exit, [0]) self.accept('o', self.toggleDebugMode) self.accept('p', self.pauseSequence) self.accept('w', self.moveForward) self.accept('a', self.moveLeft) self.accept('d', self.moveRight) self.accept('s', self.moveBack) self.accept('arrow_up', self.enableCameraForwardThrottle) self.accept('arrow_up-up', self.disableCameraForwardThrottle) # add tasks self.taskMgr.add(self.doLogic, "DoLogic") # self.taskMgr.add(self.refreshGUI, "RefreshGUI") def enableCameraForwardThrottle(self): self.cameraForwardThrottleEnabled = True def disableCameraForwardThrottle(self): self.cameraForwardThrottleEnabled = False def refreshGUI(self, task): string = str(self.pandaActor.getPos()) self.text.setText(string) self.text.setCardColor(0, 0, 0, 0.5) self.text.setCardAsMargin(0, 0, 0, 0) return task.cont def moveForward(self): currentPosition = self.pandaActor.getPos() newPosition = Point3(0,2,0) + currentPosition pandaMoveForwardInterval = self.pandaActor.posInterval(0.1, Point3(newPosition), startPos=Point3(currentPosition)) self.pandaPace = Sequence(pandaMoveForwardInterval) self.pandaPace.start() return currentPosition def moveBack(self): currentPosition = self.pandaActor.getPos() newPosition = Point3(0,-2,0) + currentPosition pandaMoveForwardInterval = self.pandaActor.posInterval(0.1, Point3(newPosition), startPos=Point3(currentPosition)) self.pandaPace = Sequence(pandaMoveForwardInterval) self.pandaPace.start() return currentPosition def moveLeft(self): currentPosition = self.pandaActor.getPos() newPosition = Point3(-2,0,0) + currentPosition pandaMoveForwardInterval = self.pandaActor.posInterval(0.1, Point3(newPosition), startPos=Point3(currentPosition)) self.pandaPace = Sequence(pandaMoveForwardInterval) self.pandaPace.start() return currentPosition def moveRight(self): currentPosition = self.pandaActor.getPos() newPosition = Point3(2,0,0) + currentPosition pandaMoveForwardInterval = self.pandaActor.posInterval(0.1, Point3(newPosition), startPos=Point3(currentPosition)) self.pandaPace = Sequence(pandaMoveForwardInterval) self.pandaPace.start() return currentPosition def pauseSequence(self): self.pandaPace.pause() def doLogic(self, task): dt = globalClock.getDt() # this method is a placeholder to test if differnt stuff has occured # like checking wether the robot is ready for a new command, etc. if self.cameraForwardThrottleEnabled: currentVelocity = self.cameraActorNode.getPhysicsObject().getVelocity() newVelocity = currentVelocity + Vec3(dt*250,0,0) self.cameraActorNode.getPhysicsObject().setVelocity(newVelocity) # slow down camera ("friction") self.cameraActorNode.getPhysicsObject().setVelocity(self.cameraActorNode.getPhysicsObject().getVelocity() * 0.92) return Task.cont def toggleGlow(self): self.glowSize = self.glowSize + 1 if (self.glowSize == 4): self.glowSize = 0 self.filters.setBloom(blend=(0,0,0,1), desat=-0.5, intensity=3.0, size=self.glowSize) print "Glow size set to", self.glowSize def printCameraPosition(self): print self.camera.getPos() print self.camera.getHpr() def toggleDebugMode(self): if(self.debugMode): self.setDebugMode(False) else: self.setDebugMode(True) def setDebugMode(self, enabled): self.debugMode = enabled if(enabled): self.enableMouse() self.accept('c', self.printCameraPosition) else: self.disableMouse() self.ignore('c') def loadShaders(self): # Check video card capabilities for shaders. if (base.win.getGsg().getSupportsBasicShaders() == 0): addTitle("Glow Filter: Video driver reports that shaders are not supported.") return False # Load filters self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom(blend=(0,0,0,1), desat=-0.5, intensity=3.0, size="small") if (filterok == False): addTitle("Toon Shader: Video card not powerful enough to do image postprocessing") return False self.glowSize=1 # Shadow shaders # TODO: Implement shadows return True
def __init__(self): self.height = 500 super().__init__(self) self.scene = self.loader.loadModel("./models/world.egg") playerTexture = loader.loadTexture("models/starfoxShip.jpg") enemyTexture = loader.loadTexture("models/enemyShip.jpg") bulletTexture = loader.loadTexture("models/shot.png") self.scene.reparentTo(self.render) base.setBackgroundColor(0.1, 0.1, 0.1, 1) self.player = self.scene.find("player") self.player.setPythonTag("ObjectController", Player(self.player)) self.player.setTexture(playerTexture) self.building_enemy = self.scene.find("building_enemy") self.dynamic_enemy = self.scene.find("enemy1") self.dynamic_enemy.setTexture(enemyTexture) self.bullet = self.scene.find("bullet") self.bullet.setTexture(bulletTexture) base.cTrav = CollisionTraverser() self.CollisionHandlerEvent = CollisionHandlerEvent() base.enableParticles() self.CollisionHandlerEvent.addInPattern('into-%in') self.CollisionHandlerEvent.addOutPattern('out-%in') self.accept('into-collision_player', self.crash) self.accept('into-collision_plane', self.crash) self.accept('into-collision_enemy', self.crash) base.cTrav.addCollider(self.scene.find("player/collision**"), self.CollisionHandlerEvent) base.cTrav.addCollider(self.scene.find("basePlane/collision**"), self.CollisionHandlerEvent) self.player.find("**collision**").node().setFromCollideMask(0x3) self.player.find("**collision**").node().setIntoCollideMask(0x3) self.dynamic_enemy.find("**collision**").node().setFromCollideMask(0x5) self.dynamic_enemy.find("**collision**").node().setIntoCollideMask(0x5) self.building_enemy.find("**collision**").node().setFromCollideMask( 0x5) self.building_enemy.find("**collision**").node().setIntoCollideMask( 0x5) #base.cTrav.showCollisions(self.render) self.taskMgr.add(self.update, "update") InputManager.initWith(self, [ InputManager.arrowUp, InputManager.arrowDown, InputManager.arrowLeft, InputManager.arrowRight, InputManager.space, InputManager.keyX, InputManager.keyV ]) self.rails = self.scene.attachNewNode("rails") self.scene.find("basePlane").setHpr(70, 0, 0) self.rails.setPos(self.scene, 0, 0, 0) self.player.reparentTo(self.rails) self.player.setPos(self.rails, 0, 0, 0) self.rails_y = -50 self.createStaticEnemy(self.building_enemy, 0, 50, 0) self.createStaticEnemy(self.building_enemy, -50, 50, 0) self.createStaticEnemy(self.building_enemy, -100, 50, 0) self.createStaticEnemy(self.building_enemy, -70, 130, 0) self.createStaticEnemy(self.building_enemy, -120, 80, 0) self.createStaticEnemy(self.building_enemy, -220, 130, 0) DynamicEnemy(self.dynamic_enemy, self.scene, Vec3(-230, 140, 10), base.cTrav, self.CollisionHandlerEvent, type=ENEMY_TYPE.CHASER) #DynamicEnemy(self.dynamic_enemy, self.scene, Vec3(-240,160,10) , base.cTrav, self.CollisionHandlerEvent) #DynamicEnemy(self.dynamic_enemy, self.scene, Vec3(-250,200,10) , base.cTrav, self.CollisionHandlerEvent) #DynamicEnemy(self.dynamic_enemy, self.scene, Vec3(-270,160,10) , base.cTrav, self.CollisionHandlerEvent) #DynamicEnemy(self.dynamic_enemy, self.scene, Vec3(-250,200,10) , base.cTrav, self.CollisionHandlerEvent) self.building_enemy.hide() self.dynamic_enemy.hide() self.fog = Fog("fog") self.fog.setColor(0.1, 0.1, 0.1) self.fog.setExpDensity(.3) self.fog.setLinearRange(50, 150) self.fog.setLinearFallback(45, 160, 320) self.render.setFog(self.fog) self.dirLight = DirectionalLight("dir light") self.dirLight.color = (0.7, 0.7, 1, 1) self.dirLightPath = self.render.attachNewNode(self.dirLight) self.dirLightPath.setHpr(45, -45, 0) self.dirLight.setShadowCaster(True, 512, 512) render.setLight(self.dirLightPath) filters = CommonFilters(base.win, base.cam) filters.setBloom(size="large", mintrigger=0.2) self.render.setShaderAuto() self.initSounds() self.initUI() self.onGame = False
class Engine(ShowBase): def __init__(self, mouse): ShowBase.__init__(self) self.mouse = mouse self.joy_x = None self.joy_y = None props = WindowProperties() props.setMouseMode(WindowProperties.MRelative) # keep mouse in screen self.disableMouse() self.win.requestProperties(props) self.setBackgroundColor(0, 0, 0) # Make missiles glow self.filters = CommonFilters(self.win, self.cam) self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size="large") self.screen_width = self.win.getXSize() self.screen_height = self.win.getYSize() self.center_x = self.screen_width/2 self.center_y = self.screen_height/2 # self.win.movePointer(0, self.center_x, self.center_y) self.enableParticles() self.cTrav = CollisionTraverser() # self.cTrav.setRespectPrevTransform(True) self.pusher = PhysicsCollisionHandler() self.pusher.addInPattern('%fn-into-%in') self.target = None self.maxvel = 50 self.roll_time = 0 self.fuel = 1000 self.ship() self.sounds() self.hud() self.part = Spacedust(self) self.events() self.camLens.setFov(70) self.camLens.setNear(1) self.camLens.setFar(500) self.get_key = { "ACCEL": False, "DECEL": False, "FORWARD_THRUST": False, "REVERSE_THRUST": False, "ROLL_LEFT": False, "ROLL_RIGHT": False, "ROLL_LEFT_BEG": False, "ROLL_RIGHT_BEG": False, "FIRE": False, "FIRING": False, "LOCK": False, "LOCKING": False, } self.AIworld = AIWorld(self.render) self.taskMgr.add(self.update, "task-update") self.taskMgr.doMethodLater(1, self.fuel_usage, "task-fuel-usage") self.taskMgr.add(self.AI_update, "AI-update") self.gen_enemy() def gen_enemy(self): x = randint(-1000, 1000) y = randint(-1000, 1000) z = randint(-1000, 1000) Enemy(self, 0, x, y, z) def AI_update(self, task): self.AIworld.update() return task.cont def hud(self): self.font = self.loader.loadFont("./fnt/subatomic.tsoonami.ttf") self.aim = OnscreenImage(image="./png/ring.png", pos=Vec3(0), scale=0.02) self.aim.setTransparency(TransparencyAttrib.MAlpha) self.locker = OnscreenImage(image="./png/ring.png", pos=Vec3(0), scale=0.12) self.locker.setTransparency(TransparencyAttrib.MAlpha) self.locker.hide() self.txtFuel = OnscreenText(parent=self.render2d, align=TextNode.ALeft, pos=(-0.95, 0.8), text='FUEL', fg=(1, 1, 1, 0.5), scale=0.05, font=self.font, mayChange=True) self.txtSpeed = OnscreenText(parent=self.render2d, align=TextNode.ALeft, pos=(-0.95, 0.7), text='SPEED', fg=(1, 1, 1, 0.5), scale=0.05, font=self.font, mayChange=True) self.txtDist = OnscreenText(parent=self.render2d, align=TextNode.ALeft, pos=(-0.95, 0.6), text='DIST', fg=(1, 1, 1, 0.5), scale=0.05, font=self.font, mayChange=True) self.txtCoord = OnscreenText(parent=self.render2d, align=TextNode.ALeft, pos=(-0.95, 0.5), text='COORD', fg=(1, 1, 1, 0.5), scale=0.05, font=self.font, mayChange=True) self.taskMgr.doMethodLater(1, self.instruments, "task-instruments") def instruments(self, task): self.txtSpeed.setText("SPEED: %s" % str(int(self.mvel))) self.txtFuel.setText("FUEL: %s" % str(self.fuel)) if self.target is not None: self.txtDist.setText("DISTANCE: %s" % str(round(self.dist, 1))) else: self.txtDist.setText("DISTANCE: ---") self.txtCoord.setText("COORD: %s %s %s" % (str(round(self.fighter.getX(), 1)), str(round(self.fighter.getY(), 1)), str(round(self.fighter.getZ(), 1)))) return task.again def set_key(self, key, value): self.get_key[key] = value def toggle_key(self, key): self.set_key(key, not self.get_key[key]) def init_roll(self, a, task): if task.time <= 2: if self.roll_time <= task.time: self.roll_time = task.time else: self.roll_time += task.time if self.roll_time > 2: self.roll_time = 2 self.fighter.setR(self.fighter.getR() + a * self.roll_time) else: self.fighter.setR(self.fighter.getR() + a * 2) return task.cont def end_roll(self, a, b, task): if task.time < b: self.roll_time -= task.time if self.roll_time < 0: self.roll_time = 0 self.fighter.setR(self.fighter.getR() + a * (b - task.time)) return task.cont else: return task.done def roll(self, a): if a > 0: self.set_key("ROLL_RIGHT_BEG", True) else: self.set_key("ROLL_LEFT_BEG", True) self.taskMgr.add(self.init_roll, "task-init-roll", extraArgs=[a], appendTask=True) def unroll(self, a): if a > 0: self.set_key("ROLL_RIGHT_BEG", False) else: self.set_key("ROLL_LEFT_BEG", False) self.taskMgr.remove("task-init-roll") self.taskMgr.add(self.end_roll, "task-end-roll", extraArgs=[a, self.roll_time], appendTask=True) def to_roll(self): if self.get_key["ROLL_LEFT"]: if not self.get_key["ROLL_LEFT_BEG"]: if self.fuel > 5: self.roll(-1) self.snd_roller.play() else: if self.get_key["ROLL_LEFT_BEG"]: self.unroll(-1) self.snd_roller.stop() if self.get_key["ROLL_RIGHT"]: if not self.get_key["ROLL_RIGHT_BEG"]: if self.fuel > 5: self.roll(+1) self.snd_roller.play() else: if self.get_key["ROLL_RIGHT_BEG"]: self.unroll(+1) self.snd_roller.stop() def fuel_usage(self, task): if self.get_key["FORWARD_THRUST"] or self.get_key["REVERSE_THRUST"]: self.fuel -= 9 if self.get_key["ROLL_LEFT_BEG"] or self.get_key["ROLL_RIGHT_BEG"]: self.fuel -= 4 self.fuel -= 1 if self.fuel < 0: self.fuel = 0 return task.again def chk_speed(self, mvel): if mvel < 0.01: # stop fighter dead if self.prt.getActive(): self.set_key("DECEL", False) mvel = 0 if mvel > self.maxvel: # stop fighter accelerating if self.pft.getActive(): self.set_key("ACCEL", False) mvel = self.maxvel self.part.p.renderer.setLineScaleFactor(mvel*2) self.part.pn.setPos(self.fighter, 0, 10, 0) return mvel def thrust_shake(self, task): x = uniform(-1000, 1000) y = uniform(-1000, 1000) self.repos(x, y, 0.001) return task.cont def thrust_end(self, task): if task.time < 5: f = (5. - task.time) / 5. s = 1000.*f x = uniform(-s, s) y = uniform(-s, s) self.repos(x, y, 0.001) self.snd_thrust.setVolume(f) return task.cont self.snd_thrust.stop() return task.done def thrust(self, a): if a > 0: self.set_key("FORWARD_THRUST", True) else: self.set_key("REVERSE_THRUST", True) self.taskMgr.remove("task-thrust-end") self.snd_thrust.setVolume(1) self.snd_thrust.play() self.taskMgr.add(self.thrust_shake, "task-thrust-shake") def unthrust(self, a): if a > 0: self.set_key("FORWARD_THRUST", False) else: self.set_key("REVERSE_THRUST", False) self.taskMgr.remove("task-thrust-shake") self.taskMgr.add(self.thrust_end, "task-thrust-end") def to_thrust(self): if self.get_key["ACCEL"]: if self.mvel < self.maxvel - 1: if not self.get_key["FORWARD_THRUST"]: if self.fuel > 10: self.pft.setActive(True) self.thrust(+1) else: if self.get_key["FORWARD_THRUST"]: self.pft.setActive(False) self.unthrust(+1) if self.get_key["DECEL"]: if self.mvel > 0: if not self.get_key["REVERSE_THRUST"]: if self.fuel > 10: self.prt.setActive(True) self.thrust(-1) else: if self.get_key["REVERSE_THRUST"]: self.prt.setActive(False) self.unthrust(-1) def events(self): self.accept("escape", self.quit) self.accept('mouse1', self.set_key, ["FIRE", True]) self.accept('mouse1-up', self.set_key, ["FIRE", False]) self.accept('mouse3', self.set_key, ["LOCK", True]) self.accept('mouse3-up', self.set_key, ["LOCK", False]) self.accept("w", self.set_key, ["ACCEL", True]) self.accept("w-up", self.set_key, ["ACCEL", False]) self.accept("s", self.set_key, ["DECEL", True]) self.accept("s-up", self.set_key, ["DECEL", False]) self.accept("a", self.set_key, ["ROLL_LEFT", True]) self.accept("a-up", self.set_key, ["ROLL_LEFT", False]) self.accept("d", self.set_key, ["ROLL_RIGHT", True]) self.accept("d-up", self.set_key, ["ROLL_RIGHT", False]) def update(self, task): self.pos() self.speed() if self.fuel > 0: self.to_roll() self.to_thrust() self.to_fire() self.to_lock() self.rehud() return task.cont def rehud(self): if self.target is not None: c = self.target.np.getPos(self.fighter) self.dist = c.length() c.normalize() self.d2 = c - Vec3(0, 1, 0)*c.dot(Vec3(0, 1, 0)) self.target.radar.setPos(self.d2.getX(), 1, self.d2.getZ()) def sounds(self): self.audio3d = Audio3DManager.Audio3DManager(self.sfxManagerList[0], self.camera) self.audio3d.setListenerVelocityAuto() self.snd_space = self.loader.loadSfx("./snd/space.flac") self.snd_space.setLoop(True) self.snd_thrust = self.loader.loadSfx("./snd/thrust.flac") self.snd_thrust.setLoop(True) self.snd_roller = self.loader.loadSfx("./snd/roller.flac") self.snd_roller.setLoop(True) self.snd_launch = self.loader.loadSfx("./snd/launch.flac") self.snd_lock = self.loader.loadSfx("./snd/lock.flac") self.snd_space.play() def quit(self): self.taskMgr.running = False def repos(self, x, y, d): player_q = self.fighter.getQuat() up = player_q.getUp() right = player_q.getRight() up.normalize() right.normalize() up_q = copy(player_q) right_q = copy(player_q) up_q.setFromAxisAngle(-(x * d), up) right_q.setFromAxisAngle(y * d, right) self.fighter.setQuat(player_q.multiply(up_q.multiply(right_q))) def move_end(self, x, y, task): if task.time <= 1: d = 0.002*(1 - task.time) self.repos(x, y, d) return task.cont return task.done def pos(self): if self.mouse: md = self.win.getPointer(0) x = md.getX() y = md.getY() else: x = self.joy_x y = self.joy_y if self.win.movePointer(0, self.center_x, self.center_y): x -= self.center_x y -= self.center_y if x != 0 or y != 0: self.taskMgr.add(self.move_end, 'task-move-end', extraArgs=[x, y], appendTask=True) def speed(self): fwd = self.fighter.getQuat().getForward() fwd.normalize() self.mvel = self.anpo.getVelocity().length() # speed control self.mvel = self.chk_speed(self.mvel) self.anpo.setVelocity(fwd * self.mvel) def ship(self): an = ActorNode() an.getPhysicsObject().setMass(100) self.fighter = self.render.attachNewNode(an) self.physicsMgr.attachPhysicalNode(an) self.anpo = an.getPhysicsObject() fn = ForceNode("force-node-fighter") self.fighter.attachNewNode(fn) self.pft = LinearVectorForce(Vec3(0, +1, 0) * 500) # forward thrust self.prt = LinearVectorForce(Vec3(0, -1, 0) * 500) # reverse thrust self.pft.setMassDependent(1) self.prt.setMassDependent(1) self.pft.setActive(False) self.prt.setActive(False) fn.addForce(self.pft) fn.addForce(self.prt) an.getPhysical(0).addLinearForce(self.pft) an.getPhysical(0).addLinearForce(self.prt) self.camera.reparentTo(self.fighter) from_obj = self.fighter.attachNewNode(CollisionNode('fighter')) from_obj.node().setFromCollideMask(BitMask32(0x1)) from_obj.setCollideMask(BitMask32(0x1)) from_obj.node().addSolid(CollisionSphere(0, 0, 0, 1)) # from_obj.show() self.pusher.addCollider(from_obj, self.fighter) self.cTrav.addCollider(from_obj, self.pusher) def launch_bullet(self): speed = 500. scale = Vec3(0.05) color = Vec4(0, 1, 0, 1) mask = BitMask32(0x2) lookat = Vec3(0, 100, 0) Missile(self, "bullet", speed, scale, color, mask, self.fighter, Vec3(-0.5, 0, 0), self.fighter, lookat, 0.5) Missile(self, "bullet", speed, scale, color, mask, self.fighter, Vec3(+0.5, 0, 0), self.fighter, lookat, 0.5) self.snd_launch.play() def to_fire(self): if self.get_key["FIRE"]: if not self.get_key["FIRING"]: self.set_key("FIRING", True) self.taskMgr.doMethodLater(0.16, self.fire_bullet, "task-fire-bullet") else: if self.get_key["FIRING"]: self.set_key("FIRING", False) self.taskMgr.remove("task-fire-bullet") def fire_bullet(self, task): if self.fuel >= 5: self.fuel -= 5 self.launch_bullet() return task.again def launch_missile(self): speed = 100 scale = Vec3(0.2) color = Vec4(1, 0, 0, 1) mask = BitMask32(0x2) lookat = Vec3(0, 0, 0) self.missile = Missile(self, "missile", speed, scale, color, mask, self.fighter, Vec3(0, 0, -2), self.target.np, lookat, 3) self.snd_launch.play() self.taskMgr.add(self.guide_missile, "task-guide-missile") def guide_missile(self, task): try: quat = Quat() lookAt(quat, self.target.np.getPos() - self.missile.anp.getPos(), Vec3.up()) self.missile.anp.setQuat(quat) fwd = quat.getForward() fwd.normalize() mvel = self.missile.anpo.getVelocity().length() self.missile.anpo.setVelocity(fwd*mvel) except: return task.done return task.cont def can_lock(self): if self.dist >= 30 and self.dist <= 300 and abs(self.d2.getX()) <= 0.1 and abs(self.d2.getZ()) <= 0.1: return True else: return False def remove_lock(self): if self.get_key["LOCKING"]: self.set_key("LOCKING", False) self.locker.hide() self.snd_lock.stop() self.taskMgr.remove("task-fire-missile") def to_lock(self): if self.get_key["LOCK"]: if self.can_lock(): if self.fuel >= 100: if not self.get_key["LOCKING"]: self.set_key("LOCKING", True) self.locker.setScale(0.12) self.locker.setColor(1, 0, 0, 0.5) self.locker.show() self.snd_lock.play() self.taskMgr.add(self.fire_missile, "task-fire-missile") else: self.remove_lock() else: self.remove_lock() else: self.remove_lock() def fire_missile(self, task): if self.fuel >= 100: if task.time < 3.6: e = (3.6 - task.time)/3.6 f = 0.02 + e*0.1 self.locker.setScale(f) self.locker.setColor(e, 1-e, 0, 0.5) return task.cont else: self.fuel -= 100 self.launch_missile() return task.done
class Universe(DirectObject): def __init__(self, neweval, starList=[]):#, console=[]): #messenger.toggleVerbose() self.stars=starList self.mouselook=True self.zoom = .33 self.mapMode = False self.evaluator = neweval self.hudScale = 1 self.objectScale=.01 self.starScale = .1 self.skyScale=40000 self.dt=.02 self.starting=True self.mouseX = 0 self.mouseY = 0 self.dX=0 self.dY=0 self.dZ=0 self.player = Body() ## self.mouseBody = Body() ## self.mouseBody.name = "mouse" self.player.name = "player" self.player.mass = 0 self.player.position.x=0 self.player.position.y=0 self.player.position.z=-0.04 self.player.orientation.y=90 self.accRate =2 # self.player.bodies=[] # self.evaluator.system.bodies.append(self.player) neweval.system.bodies.append(self.player) self.evaluator= soPhysics.soPhysics(neweval.system) self.evaluator.system.moveToStar() self.filters = CommonFilters(base.win, base.cam) self.filterok = self.filters.setBloom(blend=(1,1,1,1), desat=-0.5, intensity=1.0, size="small") self.glowSize=1 #base.enableParticles() #self.p = ParticleEffect() #self.p.loadConfig("sun2.ptf") self.loadPlanets() #self.console = console self.toggleConsole() if len(starList)>0: self.loadStars() base.camLens.setNear(0.01) base.camLens.setFar(100000) # base.camLens.setFar(170000000000000000000000000000000000000) self.mouselook=False #render.setShaderAuto() self.loadLights() taskMgr.add(self.move,"move") def loadLights(self): plight = PointLight('plight') plight.setColor(VBase4(1, 1, 1, 1)) self.plnp = render.attachNewNode(plight) self.plnp.setPos(0, 0, 0) render.setLight(self.plnp) self.ambientLight = AmbientLight( 'ambientLight' ) self.ambientLight.setColor( Vec4( 0.1, 0.1, 0.1, 1 ) ) self.ambientLightNP = render.attachNewNode( self.ambientLight.upcastToPandaNode() ) render.setLight(self.ambientLightNP) def loadStars(self): print "loading stars" for star in self.stars: star.body.node = render.attachNewNode(star.body.name) star.body.sphere = loader.loadModelCopy("models/dodecahedron") sunMaterial =Material() #sunMaterial.setEmission(VBase4(1,1,1,1)) sunMaterial.setEmission(VBase4(star.color[0],star.color[1],star.color[2], 1)) star.body.node.setMaterial(sunMaterial) star.body.sphere.reparentTo(star.body.node) star.body.sphere.setScale(self.starScale * star.radius) star.body.node.setPos(star.body.position.x,star.body.position.y,star.body.position.z) def setTexture(self, body, i): if body.mass< 0.001: body.texture = loader.loadTexture("models/earthmoon.jpg") elif body.mass >= 0.001 and body.mass < .002: body.texture = loader.loadTexture("models/mars.jpg") elif body.mass >= .002 and body.mass < .003: body.texture = loader.loadTexture("models/venus.jpg") elif body.mass >= .003 and body.mass < .006: body.texture = loader.loadTexture("models/mercury.jpg") elif body.mass >= .006 and body.mass < .009: body.texture = loader.loadTexture("models/pluto.jpg") elif body.mass >= .009 and body.mass < .01: body.texture = loader.loadTexture("models/uranus.jpg") elif body.mass >= .01 and body.mass < .03: body.texture = loader.loadTexture("models/saturn.jpg") elif body.mass >= .03 and body.mass < .05: body.texture = loader.loadTexture("models/neptune.jpg") elif body.mass >= .05 and body.mass < .1: body.texture = loader.loadTexture("models/saturn.jpg") elif body.mass >= .1 and body.mass < .2: body.texture = loader.loadTexture("models/jupiter.jpg") else : print body.mass sunMaterial =Material() sunMaterial.setTwoside(True) body.name = "star" #body.setColor(VBase4(1,1,1,1)) #self.p.start(parent = body.node, renderParent = body.node) if body.mass >=.7 and body.mass < 1.0: #M type body.texture = loader.loadTexture("models/Mstar.jpg") sunMaterial.setEmission(VBase4(1,.6,.6,1)) elif body.mass >= 1.0 and body.mass < 1.5: #K type body.texture = loader.loadTexture("models/Kstar.jpg") sunMaterial.setEmission(VBase4(1,.6,.6,1)) elif body.mass >= 1.0 and body.mass < 1.5: #G type body.texture = loader.loadTexture("models/GMstar.jpg") sunMaterial.setEmission(VBase4(1,.6,.6,1)) #elif body.mass >= 1.5 and body.mass < 1.5: #G type #body.texture = loader.loadTexture("models/Mstar.jpg") #sunMaterial.setEmission(VBase4(1,.6,.6,1)) else: body.texture = loader.loadTexture("models/Ostar.jpg") sunMaterial.setEmission(VBase4(.8,.8,1,1)) body.node.setShaderAuto() body.node.setMaterial(sunMaterial) body.sphere.setTexture(body.texture,1) def loadSinglePlanet(self, body,i): body.node = render.attachNewNode(body.name) if self.evaluator.gridSystem.names[i]!="player" and body.name != "player": body.sphere = loader.loadModelCopy("models/planet_sphere") body.sphere.reparentTo(body.node) self.scalebody( i) ## scaleRate = ((math.sqrt(self.evaluator.gridSystem.mass[i]))/100)+.01 ## body.sphere.setScale(scaleRate) ## self.evaluator.gridSystem.rad[i]=scaleRate ## body.mass=self.evaluator.gridSystem.mass[i] ## self.setTexture(body, i) body.node.setPos(self.evaluator.gridSystem.pos[i][0], self.evaluator.gridSystem.pos[i][1], self.evaluator.gridSystem.pos[i][2]) else: self.loadPlayer(body) def detachNode(self, i): #count = len(self.evaluator.system.bodies)-1 print "detaching node: ",i#count self.evaluator.system.bodies[i].node.detachNode() def loadPlanets(self): pval = self.evaluator.gridSystem.player print "player: ",pval print self.evaluator.gridSystem.getPlayerIndex() i=0 for body in self.evaluator.system.bodies: if i ==pval: print "player at: ",i self.loadPlayer(self.player) if i != pval: self.loadSinglePlanet(body,i) i+=1 self.sky = loader.loadModel("models/solar_sky_sphere") self.sky_tex = loader.loadTexture("models/startex.jpg") self.sky.setTexture(self.sky_tex, 1) self.sky.setScale(self.skyScale) self.sky.reparentTo(render) def scaleUp(self): self.accRate*= 1.01 print "accRate increasing",self.accRate ## print self.starScale ## for star in self.stars: ## star.body.sphere.setScale(self.starScale) def scaleDown(self): self.accRate*= .99 print "accRate decreasing",self.accRate ## print self.starScale ## for star in self.stars: ## star.body.sphere.setScale(self.starScale) def toggleConsole(self): print "toggle console" #self.console.toggle() def addPlanet(self): self.loadSinglePlanet(self.evaluator.system.addSinglePlanet()) return def loadRoid(self, abody): if(len(self.player.bodies)<10): self.player.bodies.append(abody) self.evaluator.system.bodies.append(abody) self.evaluator.accelerateCuda() abody.node = render.attachNewNode(abody.name) abody.model = loader.loadModelCopy("models/planet_sphere") abody.model.reparentTo(abody.node) abody.texture = loader.loadTexture("models/pluto.jpg") abody.model.setScale(.01) abody.node.setPos(abody.position.x ,abody.position.y ,abody.position.z) return def deloadRoid(self): if(len(self.player.bodies) >0): abody = self.player.bodies.pop() self.evaluator.system.bodies.pop() abody.node.detachNode() return def loadPlayer(self, abody): abody.node = render.attachNewNode(abody.name) abody.model = loader.loadModelCopy("models/fighter") abody.model.reparentTo(abody.node) if abody.name == "player": abody.texture = loader.loadTexture("models/texturemap.png") elif abody.name == "mouse": abody.texture = loader.loadTexture("models/sun.jpg") abody.model.setScale(.00005) abody.radius=.00005 i = self.evaluator.gridSystem.getPlayerIndex() self.evaluator.gridSystem.rad[i]=0.01 abody.node.setPos(self.evaluator.gridSystem.pos[i][0], self.evaluator.gridSystem.pos[i][1], self.evaluator.gridSystem.pos[i][2]) def exit(self): quit() return def fullscreen(self): print "doh" def move(self,task): # self.accept("p", self.addPlanet) self.accept("`", self.toggleConsole) self.accept("wheel_right", self.tiltLeft) self.accept("wheel_left", self.tiltRight) # self.accept("mouse6", self.tiltLeft) # self.accept("mouse7", self.tiltRight) #self.accept("w", self.tiltLeft) #self.accept("r", self.tiltRight) self.accept("mouse2", self.handlemouse2Click) #self.accept("mouse3", self.handleRightMouseClick) #self.accept("mouse1", self.handleLeftMouseClick) self.accept("wheel_up", self.zoomIn) self.accept("wheel_down", self.zoomOut) self.accept("escape", self.exit) self.accept("space",self.stop) self.accept("s",self.brake) self.accept("w",self.accelerate) self.accept("f",self.fullscreen) self.accept("m",self.togglemap) self.accept("[",self.scaleDown) self.accept("]",self.scaleUp) self.accept("l",self.togglemouselook) dt = self.dt if not self.mapMode: self.evaluator.accelerateCuda() self.updateMouse(self.player) if self.starting: dt=dt/2.0 self.starting=False #self.reloadPlanets() self.setAllPositions() return Task.cont def tiltLeft(self): print "left" self.player.orientation.z-=10 def tiltRight(self): print "right" self.player.orientation.z+=10 def togglemouselook(self): print "toggling mouselook" if self.mouselook: self.mouselook = False else: self.mouselook = True def togglemap(self): print "toggling map" if (self.mapMode): self.mapMode=False self.zoom=1.1 else: self.mapMode=True self.zoom = 59000 def accelerate(self): print "accelerating ship" i = self.evaluator.gridSystem.getPlayerIndex() self.evaluator.gridSystem.acc[i][0]+=self.dX*8 self.evaluator.gridSystem.acc[i][1]+=self.dY*8 self.evaluator.gridSystem.acc[i][2]+=self.dZ*8 #self.evaluator.gridSystem.printBody(i) return def stop(self): i = self.evaluator.gridSystem.player print "stopping ship", i self.evaluator.gridSystem.printBody(i) self.evaluator.gridSystem.vel[i][0]=0.0 self.evaluator.gridSystem.vel[i][1]=0.0 self.evaluator.gridSystem.vel[i][2]=0.0 return def brake(self): print "slowing ship" i = self.evaluator.gridSystem.player self.evaluator.gridSystem.printBody(i) self.evaluator.gridSystem.acc[i][0]-=self.dX self.evaluator.gridSystem.acc[i][1]-=self.dY self.evaluator.gridSystem.acc[i][2]-=self.dZ def handleMouse2(self): print "deccelerating ship" self.player.acceleration.x-=self.dX/10 self.player.acceleration.y-=self.dY/10 self.player.acceleration.z-=self.dZ/10 def handlemouse2Click(self): print "mouse2" self.togglemouselook() def handlemouseLeftClick(self): print "mouseLeft" def handlemouseRightClick(self): print "mouseRight" def handleLeftMouseClick(self): print "impactor deployed" abody=Body() abody.velocity.x = self.player.velocity.x abody.velocity.y = self.player.velocity.y abody.velocity.z = self.player.velocity.z abody.position.x = self.player.position.x abody.position.y = self.player.position.y abody.position.z = self.player.position.z abody.acceleration.x += self.dX/15 abody.acceleration.y += self.dY/15 abody.acceleration.z += self.dZ/15 abody.mass =0.00000001 self.loadRoid(abody) return def handleRightMouseClick(self): print "removing impactor" self.deloadRoid() def zoomIn(self): self.zoom*=0.9 print self.zoom #self.scaleDown() return def zoomOut(self): self.zoom*=1.1 print self.zoom #self.scaleUp() if self.zoom > 60000: self.zoomIn() return def updateMouse(self, abody): if (True): newX=self.mouseX newY=self.mouseY if self.mouselook and base.mouseWatcherNode.hasMouse(): newX = base.mouseWatcherNode.getMouseX() newY = base.mouseWatcherNode.getMouseY() deltaX = self.mouseX - newX deltaY = self.mouseY - newY self.mouseX = newX self.mouseY = newY if abody.orientation.y >360: abody.orientation.y -=360 if abody.orientation.x >360: abody.orientation.x -=360 if abody.orientation.y > 180: abody.orientation.y += (360*deltaY) else: abody.orientation.y -= (360*deltaY) if abody.orientation.y > 180: abody.orientation.x -= (360*deltaX) else: abody.orientation.x += (360*deltaX) self.dZ = self.zoom*math.sin((-abody.orientation.y+180)*(math.pi / 180.0)) hyp = self.zoom*math.cos((-abody.orientation.y+180)*(math.pi / 180.0)) self.dX = hyp * math.sin((-abody.orientation.x+180)*(math.pi / 180.0)) self.dY = hyp * math.cos((-abody.orientation.x+180)*(math.pi / 180.0)) base.camera.setHpr(abody.orientation.x, abody.orientation.y,abody.orientation.z) cpos=self.evaluator.gridSystem.getPlayerIndex() #base.camera.printPos() base.camera.setPos(self.evaluator.gridSystem.pos[cpos][0]-self.dX, self.evaluator.gridSystem.pos[cpos][1]-self.dY, self.evaluator.gridSystem.pos[cpos][2]-self.dZ) def setAllPositions(self): for j in self.evaluator.gridSystem.collisions: self.scalebody(j) self.evaluator.gridSystem.collisoins=[] for k in self.evaluator.gridSystem.removed: self.detachNode(k) ## abody = Body(self.evaluator.system.getDirectedPlanet()) ## self.evaluator.gridSystem.insertBody(abody,k) ## self.loadSinglePlanet(abody, k) self.evaluator.gridSystem.removed=[] i=0 for body in self.evaluator.system.bodies: self.set_body_position(body, self.evaluator.gridSystem.pos[i][0], self.evaluator.gridSystem.pos[i][1], self.evaluator.gridSystem.pos[i][2]) i+=1 def scalebody(self, i): body = self.evaluator.system.bodies[i] if body.name == "player": print "rescaling: ",i," ",body.name raw_input() scaleRate = ((math.sqrt(self.evaluator.gridSystem.mass[i]))/50)+.001 body.sphere.setScale(scaleRate) self.evaluator.gridSystem.rad[i]=scaleRate body.mass=self.evaluator.gridSystem.mass[i] self.setTexture(body, i) def set_body_position(self,body,x,y,z): if body.name == "star": #print "moving light" self.plnp.setPos(x,y,z) body.node.setPos(x,y,z) body.node.setHpr(body.orientation.x, body.orientation.y, body.orientation.z)
class Landwalker(ShowBase): def __init__(self): #loadPrcFile("Config.prc") ShowBase.__init__(self) self.config = ConfigManager.loadSettings() #Config stuff here self.filters = CommonFilters(base.win, base.cam) self.AOEnabled = False self.bloomEnabled = False self.invertEnabled = False self.OSD = True self.shadersLoaded = False self.xray_mode = False self.show_model_bounds = False self.fogEnabled = True self.mouseEnabled = False #Store which keys are currently pressed self.keyMap = { "1": 0, "escape": 0, "left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0, "cam-right": 0, } self.ButtonImage = loader.loadModel( "phase_3/models/gui/quit_button.bam") self.introButtons() def introButtons(self): def loadGame(): print("Loading game...") Button1.removeNode() Button2.removeNode() imageObject.destroy() self.loadGame() imageObject = OnscreenImage(image='stat_board.png', pos=(0, 0, 0)) imageObject.setTransparency(TransparencyAttrib.MAlpha) Button1 = DirectButton( frameSize=None, text="Load Game", image=(self.ButtonImage.find('**/QuitBtn_UP'), self.ButtonImage.find('**/QuitBtn_DN'), self.ButtonImage.find('**/QuitBtn_RLVR')), relief=None, command=loadGame, text_pos=(0, -0.015), geom=None, pad=(0.01, 0.01), suppressKeys=0, pos=(-.85, -0, -.93), text_scale=0.059999999999999998, borderWidth=(0.015, 0.01), scale=.7) Button1.setPosHprScale(0.00, 0.00, 0.30, 0.00, 0.00, 0.00, 2.53, 2.53, 2.53) Button2 = DirectButton( frameSize=None, text="Customize", image=(self.ButtonImage.find('**/QuitBtn_UP'), self.ButtonImage.find('**/QuitBtn_DN'), self.ButtonImage.find('**/QuitBtn_RLVR')), relief=None, command=loadGame, text_pos=(0, -0.015), geom=None, pad=(0.01, 0.01), suppressKeys=0, pos=(-.85, -0, -.93), text_scale=0.059999999999999998, borderWidth=(0.015, 0.01), scale=.7) Button2.setPosHprScale(0.00, 0.00, -0.30, 0.00, 0.00, 0.00, 2.53, 2.53, 2.53) def loadGame(self): # Adding onscreen text here self.inst1 = addInstructions(0.06, "Press F to toggle wireframe") self.inst2 = addInstructions(0.12, "Press X to toggle xray") self.inst3 = addInstructions(0.18, "Press 1 to activate cartoon shading") self.inst4 = addInstructions(0.24, "Press 2 to deactivate cartoon shading") self.inst4 = addInstructions(0.30, "Press 3 to toggle fog") self.inst4 = addInstructions(0.36, "Press 4 to toggle free camera") self.inst4 = addInstructions(0.42, "Press 5 to toggle bloom") self.inst4 = addInstructions(0.48, "Press 6 to toggle Ambient Occlusion") self.inst4 = addInstructions( 0.54, "Press Escape to toggle the onscreen debug") #Loading required modules... self.loadWorld() localAvatar = self.getActor() base.localAvatar = localAvatar self.LoadButtons() self.loadShaders() self.FogDensity = self.loadFog() self.objectList = list() self.objectList.append(self.scene) # Floater Object (For camera) self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(self.actorBody) self.floater.setY(-10) self.floater.setZ(8.5) self.floater.setHpr(0, -10, 0) # Set Camera self.camera.reparentTo(self.floater) # Accept the control keys for movement and rotation self.accept('f', self.toggleWireframe) self.accept('x', self.toggle_xray_mode) self.accept('b', self.toggle_model_bounds) self.accept("escape", self.toggle_osd) self.accept("1", self.loadCartoonShaders) self.accept("2", self.unloadShaders) self.accept("3", self.toggleFog) self.accept("4", self.toggleCamera) self.accept("5", self.toggleBloom) self.accept("6", self.toggleAmbientOcclusion) #warning: bright! self.accept("6", self.toggleInvert) self.accept("arrow_left", self.setKey, ["left", True]) self.accept("arrow_right", self.setKey, ["right", True]) self.accept("arrow_up", self.setKey, ["forward", True]) self.accept("arrow_down", self.setKey, ["backward", True]) self.accept("arrow_left-up", self.setKey, ["left", False]) self.accept("arrow_right-up", self.setKey, ["right", False]) self.accept("arrow_up-up", self.setKey, ["forward", False]) self.accept("arrow_down-up", self.setKey, ["backward", False]) self.taskMgr.add(self.move, "moveTask") self.offset = 3.2375 wallBitmask = BitMask32(1) floorBitmask = BitMask32(2) base.cTrav = CollisionTraverser() walkControls = GravityWalker(legacyLifter=True) walkControls.setWallBitMask(wallBitmask) walkControls.setFloorBitMask(floorBitmask) walkControls.setWalkSpeed(16.0, 24.0, 8.0, 80.0) walkControls.initializeCollisions(base.cTrav, self.actorBody, floorOffset=0.025, reach=4.0) walkControls.setAirborneHeightFunc(self.getAirborneHeight()) walkControls.enableAvatarControls() # self.controlManager.add(walkControls, 'walk') self.actorBody.physControls = walkControls localAvatar.physControls.placeOnFloor() # problem: onScreenDebug.enabled = self.toggle # print(updateOnScreenDebug.enabled) onScreenDebug.enabled = True base.setFrameRateMeter(True) PStatClient.connect() base.taskMgr.add(self.updateOnScreenDebug, 'UpdateOSD') def loadWorld(self): #Loading our Scene self.scene = loader.loadModel("models/world.egg.pz") self.scene.reparentTo(self.render) self.setBackgroundColor(0.53, 0.80, 0.92, 1) def removeWorld(self): self.scene.removeNode() def getActor(self): # Loading our Actor actorStartPos = self.scene.find("**/start_point").getPos() self.actorBody = ActorDict.playerBody self.actorBody.reparentTo(self.render) self.actorBody.loop('neutral') self.actorBody.setPos(actorStartPos + (0, 0, 1.5)) self.actorBody.setScale(0.3) self.actorBody.setH(-180) def ActorHead(): actorHead = loader.loadModel("custom/def_m.bam") actorHead.reparentTo(self.actorBody.find('**/to_head')) actorHead.setScale(0.20) actorHead.setZ(0) actorHead.setH(-180) ActorHead() return self.actorBody def LoadButtons(self): Button_Up = loader.loadModel( 'phase_3/models/gui/quit_button.bam').find('**/QuitBtn_UP') Button_Down = loader.loadModel( 'phase_3/models/gui/quit_button.bam').find('**/QuitBtn_DN') Button_Rlvr = loader.loadModel( 'phase_3/models/gui/quit_button.bam').find('**/QuitBtn_RLVR') # https://pastebin.com/agdb8260 Arrow_Up = loader.loadModel( 'phase_3/models/gui/nameshop_gui.bam').find('**/triangleButtonUp') Arrow_Down = loader.loadModel( 'phase_3/models/gui/nameshop_gui.bam').find('**/triangleButtonDwn') Arrow_Rlvr = loader.loadModel('phase_3/models/gui/nameshop_gui.bam' ).find('**/triangleButtonRllvr') Buttons = [Button_Up, Button_Down, Button_Rlvr] numItemsVisible = 4 itemHeight = 0.11 myScrolledList = DirectScrolledList( decButton_pos=(0.35, 0, 0.54), decButton_text_scale=0.04, decButton_relief=None, decButton_image=(Arrow_Up, Arrow_Down, Arrow_Rlvr), incButton_pos=(0.35, 0, -0.01), incButton_hpr=(0, 0, 180), incButton_text_scale=0.04, incButton_relief=None, incButton_image=(Arrow_Up, Arrow_Down, Arrow_Rlvr), pos=(0.74, 0, 0.4), numItemsVisible=numItemsVisible, forceHeight=itemHeight, itemFrame_pos=(0.35, 0, 0.43)) modelArray = [ 'phase_4/models/neighborhoods/toontown_central.bam', 'phase_13/models/parties/partyGrounds.bam', 'models/world.egg.pz', 'custom/ship/ship.egg' ] nameArray = [ 'Toontown Central', 'Party Grounds', 'Default World', 'Ship Test' ] for index, name in enumerate(nameArray): l = DirectButton(text=name, image=(Buttons), extraArgs=[modelArray[index]], command=self.spawnObject, text_scale=0.045, text_pos=(0, -0.007, 0), relief=None) myScrolledList.addItem(l) #will be used to spawn objects def spawnObject(self, modelName): #if spawned object already exists, we're gonna need to remove it while len(self.objectList) >= 1: for world in self.objectList: world.removeNode() self.objectList.pop(0) spawnedObject = loader.loadModel(modelName) spawnedObject.reparentTo(render) spawnedObject.setPos(base.localAvatar.getPos()) #spawnedObject = self.scene #self.removeWorld(self.objectList.find(spawnedObject)) self.objectList.append(spawnedObject) print("Model Name: " + repr(modelName)) print("Spawned Object: " + repr(spawnedObject)) testobjectindex = len(self.objectList) print(testobjectindex) print(self.objectList) #self.removeWorld() def loadPStats(self): os.system("pstats.exe") def loadFog(self): self.fog = Fog('distanceFog') self.fog.setColor(0, 0, 0) self.fog.setExpDensity(.01) self.render.setFog(self.fog) self.fog.setOverallHidden(False) return self.fog.getExpDensity() def loadShaders(self): normalsBuffer = self.win.makeTextureBuffer("normalsBuffer", 0, 0) normalsBuffer.setClearColor(LVecBase4(0.5, 0.5, 0.5, 1)) self.normalsBuffer = normalsBuffer normalsCamera = self.makeCamera(normalsBuffer, lens=self.cam.node().getLens()) normalsCamera.node().setScene(self.render) drawnScene = self.normalsBuffer.getTextureCard() drawnScene.setTransparency(1) drawnScene.setColor(1, 1, 1, 0) drawnScene.reparentTo(self.render2d) self.drawnScene = drawnScene def toggleAmbientOcclusion(self): if not self.AOEnabled: self.filters.setAmbientOcclusion() self.AOEnabled = True else: self.filters.delAmbientOcclusion() self.AOEnabled = False def toggleInvert(self): if not self.invertEnabled: self.filters.setInverted() self.invertEnabled = True else: self.filters.delInverted() self.invertEnabled = False def toggleBloom(self): if not self.bloomEnabled: self.filters.setBloom() self.bloomEnabled = True else: self.filters.delBloom() self.bloomEnabled = False def toggleCamera(self): if not self.mouseEnabled: base.enableMouse() self.mouseEnabled = True else: base.disableMouse() self.camera.setPosHpr(0, 0, 0, 0, 0, 0) self.mouseEnabled = False def toggleFog(self): if not self.fogEnabled: self.fog.setExpDensity(self.FogDensity) self.fogEnabled = True else: self.fog.setExpDensity(0) self.fogEnabled = False def toggle_xray_mode(self): """Toggle X-ray mode on and off. This is useful for seeing the effectiveness of the portal culling.""" self.xray_mode = not self.xray_mode if self.xray_mode: self.scene.setColorScale((1, 1, 1, 0.5)) self.scene.setTransparency(TransparencyAttrib.MDual) else: self.scene.setColorScaleOff() self.scene.setTransparency(TransparencyAttrib.MNone) def toggle_model_bounds(self): """Toggle bounding volumes on and off on the models.""" self.show_model_bounds = not self.show_model_bounds if self.show_model_bounds: for model in self.objectList: model.showBounds() else: for model in self.objectList: model.hideBounds() def toggle_osd(self): self.OSD = not self.OSD if self.OSD: self.onScreenDebug.enabled = True else: self.onScreenDebug.enabled = False def getAirborneHeight(self): return self.offset + 0.025000000000000001 def updateOnScreenDebug(self, task): if (onScreenDebug.enabled): onScreenDebug.add('Avatar Position', base.localAvatar.getPos()) onScreenDebug.add('Avatar Angle', base.localAvatar.getHpr()) onScreenDebug.add('Camera Position', base.camera.getPos()) onScreenDebug.add('Camera Angle', base.camera.getHpr()) return Task.cont def unloadShaders(self): if self.shadersLoaded: self.drawnScene.hide() self.shadersLoaded = False def loadCartoonShaders(self): if not self.shadersLoaded: self.separation = 0.0015 self.cutoff = 0.35 inkGen = loader.loadShader("shaders/inkGen.sha") self.drawnScene.setShader(inkGen) self.drawnScene.setShaderInput( "separation", LVecBase4(self.separation, 0, self.separation, 0)) self.drawnScene.setShaderInput("cutoff", LVecBase4(self.cutoff)) self.drawnScene.show() self.shadersLoaded = True # Records the state of the arrow keys def setKey(self, key, value): self.keyMap[key] = value # Accepts arrow keys to move either the player or the menu cursor, # Also deals with grid checking and collision detection def move(self, task): dt = globalClock.getDt() if self.keyMap["forward"]: self.localAvatar.setY(self.localAvatar, 20 * dt) elif self.keyMap["backward"]: self.localAvatar.setY(self.localAvatar, -20 * dt) if self.keyMap["left"]: self.localAvatar.setHpr(self.localAvatar.getH() + 1.5, self.localAvatar.getP(), self.localAvatar.getR()) elif self.keyMap["right"]: self.localAvatar.setHpr(self.localAvatar.getH() - 1.5, self.localAvatar.getP(), self.localAvatar.getR()) currentAnim = self.actorBody.getCurrentAnim() if self.keyMap["forward"]: if currentAnim != "walk": self.localAvatar.loop("walk") elif self.keyMap["backward"]: # Play the walk animation backwards. if currentAnim != "walk": self.localAvatar.loop("walk") self.localAvatar.setPlayRate(-1.0, "walk") elif self.keyMap["left"] or self.keyMap["right"]: if currentAnim != "walk": self.localAvatar.loop("walk") self.localAvatar.setPlayRate(1.0, "walk") else: if currentAnim is not None: self.localAvatar.stop() self.localAvatar.loop("neutral") self.isMoving = False return task.cont
class World(DirectObject): global traverser, queue def __init__(self): startMenu = menu.Menu(self) #Please do not remove this function, it makes the menu work. def beginGame(self): """beginGame parameters: self returns: none Description: What would normalley be the contants of __init__. Called only after the menu. """ self.configurePanda() camera.setPosHpr(0, -15, 0, 0, 0, 0) # x,y,z,heading, pitch, roll #world init self.setupBullet() self.loadModels() self.setupLights() #self.initMove() self.accept("escape",sys.exit) self.overlay = overlay.Overlay(self) #self.ball = ball.Ball(self) self.onRay = list() self.offRay = list() self.activeRay = list() def configurePanda(self): """configurePanda parameters: self returns: none Description: Set the rendering and display options for panda. """ props = WindowProperties() props.setCursorHidden(True) #props.setSize(1440, 900) #props.setFullscreen(1) base.win.requestProperties(props) render.setShaderAuto() base.disableMouse() base.setFrameRateMeter(True) #render.setAntialias(AntialiasAttrib.MAuto) #render.setAntialias(AntialiasAttrib.MMultisample,4) self.filters = CommonFilters(base.win, base.cam) self.filters.setBloom(blend=(1,0,0,1), desat=-0.5, intensity=6.0, size=2) #self.filters.setAmbientOcclusion() #self.filters.setCartoonInk() def setupBullet(self): """setupBullet parameters: self returns: none Description: Initialize bullet and (if needed) the bullet debug renderer. """ taskMgr.add(self.update, 'updateWorld') self.worldNP = render.attachNewNode('World') # World #self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug')) #self.debugNP.show() #self.debugNP.node().showWireframe(True) #self.debugNP.node().showConstraints(False) #self.debugNP.node().showBoundingBoxes(False) #self.debugNP.node().showNormals(False) self.world = BulletWorld() self.world.setGravity(Vec3(0, 0, 0)) #self.world.setDebugNode(self.debugNP.node()) def loadModels(self): """loadModels parameters: self returns: none Description: Loads the models and related collisions. Most game init goes here. """ # create the environment self.env = collision.loadAndPositionModelFromFile("../assets/3d/mayaActors/arena_collisions_nogrid.egg") self.envBoxes = objects.genBulletBoxes(self.env,self.world) #load objects out of the environment #human self.mover = Human(self,self.world,self.worldNP) tmp = self.env.find("**/PlayerSpawn1") self.mover.bulletInit(self.world,tmp.getPos()) tmp.detachNode() #AI players self.players = objects.loadPlayers(self.env,self.world,self.worldNP) for i in range(0,5): self.players[i].bulletInit(self.world,self.players[i].instance.getPos()) #Spawners collisionHandler=0 self.aTrapSpawn = objects.loadTrapAs(self.env, self.world, self.worldNP) self.bTrapSpawn = objects.loadTrapBs(self.env, self.world, self.worldNP) self.ammoSpawn = objects.loadAmmo(self.env, self.world, self.worldNP) #optimization self.env.flattenStrong() render.analyze() self.crowd = loader.loadModel("../assets/3d/Actors/crowd.egg") self.crowd.reparentTo(render) self.crowd.setScale(10) self.crowd.setPos(0,0,-1000) def setupLights(self): """setupLights parameters: self returns: none Description: Stick in some general lights. """ self.ambientLight = lights.setupAmbientLight() self.dirLight = DirectionalLight("dirLight") self.dirLight.setColor((.4,.4,.4,1)) self.dirLightNP = render.attachNewNode(self.dirLight) self.dirLightNP.setHpr(0,-25,0) render.setLight(self.dirLightNP) #self.light = lights.loadModelSpotlightByName(self.human,"humanlight","humanlight1","segwaLight") #panda2 = collision.loadAndPositionModelFromFile("panda-model",scale=.005,pos=tifLeftLight.getPos()) def update(self, task): """update parameters: self returns: none Description: Game Loop """ dt = globalClock.getDt() # Update the spawners for i in self.aTrapSpawn: contacts = self.world.contactTest(i.sphere).getContacts() if len(contacts)>0: i.trap1Collide(contacts,self.mover) for i in self.bTrapSpawn: contacts = self.world.contactTest(i.sphere).getContacts() if len(contacts)>0: i.trap2Collide(contacts,self.mover) for i in self.ammoSpawn: contacts = self.world.contactTest(i.sphere).getContacts() if len(contacts)>0: i.ammoCollide(contacts,self.mover) # update the traps and projectiles for i in human.floatTrap.traps: contacts = self.world.contactTest(i.sphere).getContacts() if len(contacts)>0: i.check(contacts,self.mover,self.players) for i in human.clawTrap.traps: contacts = self.world.contactTest(i.sphere).getContacts() if len(contacts)>0: i.check(contacts,self.mover,self.players) for i in Projectile.projectiles: contacts = self.world.contactTest(i.sphere).getContacts() if len(contacts)>0: i.check(contacts,self.mover,self.players) # step forward the physics simulation self.world.doPhysics(dt,1) return task.cont
class Application(ShowBase): def __init__(self): ShowBase.__init__(self) self.useAdvancedVisualEffects =\ ConfigVariableBool("use-advanced-visual-effects", True) and\ base.win.getGsg().getSupportsBasicShaders() and\ base.win.getGsg().getSupportsGlsl() and\ base.win.getGsg().getSupportsDepthTexture() self.game = Game(scriptPath) self.phoneState = PhoneState(self) self.setupFilters() self.setupModels() self.setupLighting() self.setupKeyboardControl() self.camera.setPos(0.0, 0.0, 1.7) self.setupMouseControl() self.phoneState.request("Hidden") blockSize = 10.0 self.maxX = self.game.getCityBlueprint().getSizeWE() * blockSize / 2.0 self.maxY = self.game.getCityBlueprint().getSizeNS() * blockSize / 2.0 self.setBackgroundColor(0.2, 0.4, 1.0, 1.0) def setupFilters(self): if (self.useAdvancedVisualEffects): self.filters = CommonFilters(self.win, self.cam) self.filters.setBloom() def setupKeyboardControl(self): self.accept("escape", sys.exit) def setupMouseControl(self): self.disableMouse() self.mousex = 0 self.mousey = 0 self.last = 0 self.mousebtn = [0,0,0] self.accept("mouse1", self.setMouseBtn, [0, 1]) self.accept("mouse1-up", self.setMouseBtn, [0, 0]) self.taskMgr.add(self.controlCamera, "cameraTask") def setupLights(self): self.sunLight = self.render.attachNewNode(DirectionalLight("sunLight")) self.sunLight.setColor(Vec4(0.8, 0.8, 0.8, 1)) self.sunLight.node().getLens().setFilmSize(128, 64) self.sunLight.node().getLens().setNearFar(20,2000) self.sunLight.setPos(60, 30, 50) self.sunLight.lookAt(0, 0, 0) self.render.setLight(self.sunLight) # self.sunLight.node().showFrustum() if self.useAdvancedVisualEffects: self.sunLight.node().setShadowCaster(True, 256, 256) self.render.setShaderAuto() self.ambientLight = self.render.attachNewNode(AmbientLight("ambientLight")) self.ambientLight.node().setColor(Vec4(0.2, 0.2, 0.2, 1)) self.render.setLight(self.ambientLight) def setupModels(self): self.city = self.loader.loadModel("models/city") self.city.reparentTo(self.render) self.phoneState.setupPhone() self.cityOutline = self.loader.loadModel("models/city_outline") self.cityOutline.reparentTo(self.phoneState.minimap) def setupLighting(self): self.ambientLight = self.render.attachNewNode(AmbientLight("ambientLight")) self.ambientLight.node().setColor(Vec4(1, 1, 1, 1)) self.render.setLight(self.ambientLight) def setMouseBtn(self, btn, value): self.mousebtn[btn] = value if (btn == 0 and value == 1 and self.phoneState.state == "Center"): phoneDisplayRegionCenterX = self.win.getXSize() * (self.phoneState.phoneDisplayRegion.getLeft() + self.phoneState.phoneDisplayRegion.getRight()) / 2.0 phoneDisplayRegionCenterY = self.win.getYSize() * (1.0 - (self.phoneState.phoneDisplayRegion.getBottom() + self.phoneState.phoneDisplayRegion.getTop()) / 2.0) mouse = self.win.getPointer(0) s = 2 ** self.phoneState.minimapZoom x = clamp(self.camera.getX() + (mouse.getX() - phoneDisplayRegionCenterX) / s, -self.maxX, self.maxX) y = clamp(self.camera.getY() + (phoneDisplayRegionCenterY - mouse.getY()) / s, -self.maxY, self.maxY) previousHeading = self.camera.getH() % 360.0 heading = (rad2Deg(atan2(y - self.camera.getY(), x - camera.getX())) - 90.0) % 360.0 if (180.0 < abs(heading - previousHeading)): if (previousHeading < heading): heading -= 360.0 else: heading += 360.0 self.camera.setH(previousHeading) self.phoneState.orientationTriangle.setH(previousHeading) Parallel( self.camera.posInterval(0.5, Vec3(x, y, self.camera.getZ())), self.phoneState.minimapCamera.posInterval(0.5, Vec3(x, y, self.phoneState.minimapCamera.getZ())), self.phoneState.orientationTriangle.posInterval(0.5, Vec3(x, y, self.phoneState.orientationTriangle.getZ())), self.camera.hprInterval(0.5, Vec3(heading, self.camera.getP(), self.camera.getR())), self.phoneState.orientationTriangle.hprInterval(0.5, Vec3(heading, self.phoneState.orientationTriangle.getP(), self.phoneState.orientationTriangle.getR())) ).start() def setBlurSharpen(self, amount): if (not self.useAdvancedVisualEffects): return if (amount == 1.0): self.filters.delBlurSharpen() else: self.filters.setBlurSharpen(amount=amount) def controlCamera(self, task): if (self.phoneState.state == "Center"): return Task.cont # figure out how much the mouse has moved (in pixels) mouse = self.win.getPointer(0) x = mouse.getX() y = mouse.getY() windowCenterX = self.win.getXSize() / 2 windowCenterY = self.win.getYSize() / 2 heading = self.camera.getH() pitch = self.camera.getP() if self.win.movePointer(0, windowCenterX, windowCenterY): heading -= (x - windowCenterX) * 0.2 pitch = clamp(pitch - (y - windowCenterY) * 0.2, -45, 45) self.camera.setHpr(heading, pitch, 0) elapsed = task.time - self.last if (self.last == 0): elapsed = 0 if (self.mousebtn[0]): direction = self.camera.getMat().getRow3(1) self.camera.setPos(self.camera.getPos() + direction * elapsed*30) clampX(self.camera, -self.maxX, self.maxX) clampY(self.camera, -self.maxY, self.maxY) self.camera.setZ(2) self.phoneState.minimapCamera.setX(self.camera.getX()) self.phoneState.minimapCamera.setY(self.camera.getY()) self.phoneState.orientationTriangle.setX(self.camera.getX()) self.phoneState.orientationTriangle.setY(self.camera.getY()) self.phoneState.orientationTriangle.setHpr(heading, -90, 0) self.last = task.time return Task.cont
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 Arena(DirectObject): collshow = False def initShader(self): tempnode = NodePath(PandaNode("temp node")) tempnode.setAttrib(LightRampAttrib.makeSingleThreshold(0.5, 0.9)) tempnode.setShaderAuto() base.cam.node().setInitialState(tempnode.getState()) self.separation = 1 # Pixels self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom() if (filterok == False): addTitle("Toon Shader: Video card not powerful enough to do image postprocessing") sys.exit def initCollision(self): base.cTrav = CollisionTraverser() base.collisionHandlerEvent = CollisionHandlerEvent() base.collisionHandlerEvent.addInPattern('%fn-i-%in') base.collisionHandlerEvent.addOutPattern('%fn-o-%in') base.collisionHandlerEvent.addAgainPattern('%fn-a-%in') self.accept('mouseray-a-ground',self.collideGroundAgain) self.lastX = 0 self.lastDirection = 0 def collideGroundAgain(self,entry): np_into=entry.getIntoNodePath() pos = entry.getSurfacePoint(np_into) pos.setZ(1) x = pos.getX() if(x == self.lastX): return if(x < self.lastX): direction = -1 else: direction = 1 if(direction != self.lastDirection): if(direction == -1): self.sonic.left() self.tails.left() else: self.sonic.right() self.tails.right() self.lastDirection = direction self.lastX = x if (x < -7 ) : pos.setX(-7) if (x > 7 ) : pos.setX(7) pos.setY(-7) self.sonic.collisionNodePath.setPos(pos) pos.setY(-5) self.tails.collisionNodePath.setPos(pos) # self.pandaActor.setPos(pos) def updateMouseTask(self, task): if base.mouseWatcherNode.hasMouse(): mpos=base.mouseWatcherNode.getMouse() self.mouse.collisionRay.setFromLens(base.camNode, mpos.getX(),mpos.getY()) return task.cont def mouseClick(self): messenger.send("Spider") print 'click' def toggle_collisions(self): self.collshow = not self.collshow if self.collshow: self.collisionTraverser.showCollisions(base.render) l=base.render.findAllMatches("**/+CollisionNode") for cn in l: cn.show() else: self.collisionTraverser.hideCollisions() l=base.render.findAllMatches("**/+CollisionNode") for cn in l: cn.hide() def toggle_wire(self): base.toggleWireframe() base.toggleTexture() def __init__(self): base.audio = Audio() base.audio.play('complex') self.initShader() self.initCollision() self.camera = Camera() self.mouse = Mouse() self.ground = Ground() self.smiley = Smiley() self.frowney = Frowney() self.gorrila = Gorrila() self.sonic = Sonic() self.tails = Tails() self.monster = Monster() base.arrow = Arrow() self.dragon = Dragon() self.panda = Panda() self.pandaren = Pandaren() self.tombstone = Tombstone() self.tombstone.spiders = [] for i in range(50): self.tombstone.spiders.append(Spider(str(i))) self.tombstone.batch() taskMgr.add(self.updateMouseTask, "updatePicker") self.accept('escape',sys.exit) self.accept('mouse1',self.mouseClick)
def __init__(self): """Start the app.""" self.base = ShowBase() self.base.disableMouse() filters = CommonFilters(self.base.win, self.base.cam) filters.setBloom(blend=(0, 0, 0, 1)) self.base.render.setShaderAuto( BitMask32.allOn() & ~BitMask32.bit(Shader.BitAutoShaderGlow)) ts = TextureStage('ts') ts.setMode(TextureStage.MGlow) tex = self.base.loader.loadTexture('models/black.png') self.base.render.setTexture(ts, tex) self.terrain = Terrain(self.base.render, self.base.loader) minimap_size = 200 self.minimap = Minimap( self.base.win.makeDisplayRegion( 1 - minimap_size / self.base.win.getProperties().getXSize(), 1, 1 - minimap_size / self.base.win.getProperties().getYSize(), 1)) self.minimap.node_path.reparentTo(self.base.render) # self.light_nodes = self.set_lights() self.set_fog() self.key_state = dict.fromkeys(Object.values(config.key_map.character), False) self.set_key_state_handler() self.game_state = "pause" self.toggle_pause() self.selection = Selection(self.base.loader, self.terrain.geom_node) self.selection_text = OnscreenText( mayChange=True, scale=0.07, align=TextNode.ALeft, pos=(0.02 - self.base.getAspectRatio(), 1 - 0.07)) self.timer_text = OnscreenText(mayChange=True, scale=0.07, align=TextNode.ALeft, pos=(0.02 - self.base.getAspectRatio(), -1 + 0.02 + 0.07)) self.enemies = set() self.base.accept(config.key_map.utility.pause, self.toggle_pause) self.base.accept( "q", lambda: self.selection.advance_tower(self.base.loader)) self.base.accept("mouse1", self.player_click) self.base.cam.node().setCameraMask(BitMask32.bit(0)) self.base.setBackgroundColor(*config.map_params.colors.sky) self.player = Player() self.base.taskMgr.add(lambda task: self.terrain.start_up(), "start up") self.mouse_pos = (0.0, 0.0) self.base.taskMgr.add(self.move_player_task, "move_player_task") self.base.taskMgr.add(self.move_enemies_task, "move_enemies_task") self.base.taskMgr.add(self.player_select_task, "player_select_task") self.base.taskMgr.add(self.tower_task, "tower_task") self.base.taskMgr.add(self.check_end_game, "check_end_game_task") rand = Random() rand.seed(config.map_params.seed) self.base.taskMgr.doMethodLater(1, self.clock_task, 'clock_task', extraArgs=[rand]) self.rounds = 0 self.coin = 40
class MyApp(ShowBase): def __init__(self): ShowBase.__init__(self) # Disable the camera trackball controls. self.disableMouse() # Load the environment model. self.environ = self.loader.loadModel("models/environment") # Reparent the model to render. self.environ.reparentTo(self.render) # Apply scale and position transforms on the model. self.environ.setScale(0.25, 0.25, 0.25) self.environ.setPos(-8, 42, 0) # Add the spinCameraTask procedure to the task manager. self.taskMgr.add(self.spinCameraTask, "SpinCameraTask") # Load and transform the panda actor. self.pandaActor = Actor(models="models/panda-model", anims={"walk": "models/panda-walk4"}) self.pandaActor.setScale(0.005, 0.005, 0.005) self.pandaActor.reparentTo(self.render) # Loop its animation. self.pandaActor.loop("walk") # Create the four lerp intervals needed for the panda to # walk back and forth. A = Point3(0, 10, 0) B = Point3(0, -10, 0) pandaPosInterval1 = self.pandaActor.posInterval(13, B, startPos=A) pandaPosInterval2 = self.pandaActor.posInterval(13, A, startPos=B) pandaHprInterval1 = self.pandaActor.hprInterval(3, Point3(180, 0, 0), startHpr=Point3( 0, 0, 0)) pandaHprInterval2 = self.pandaActor.hprInterval(3, Point3(0, 0, 0), startHpr=Point3( 180, 0, 0)) # Create and play the sequence that coordinates the intervals. self.pandaPace = Sequence(pandaPosInterval1, pandaHprInterval1, pandaPosInterval2, pandaHprInterval2, name="pandaPace") self.pandaPace.loop() self.teapot = self.loader.loadModel('models/teapot') self.teapot.reparentTo(self.render) self.console = Console(self) self.filters = CommonFilters(self.win, self.cam) self.filters.setCartoonInk() self.filters.setAmbientOcclusion() self.filters.setBloom() # Define a procedure to move the camera. def spinCameraTask(self, task): angleDegrees = task.time * 6.0 angleRadians = angleDegrees * (pi / 180.0) self.camera.setPos(20 * sin(angleRadians), -20.0 * cos(angleRadians), 3) self.camera.setHpr(angleDegrees, 0, 0) return Task.cont
class ConfigRender: def __init__(self): render.setAntialias(AntialiasAttrib.MAuto) # render.setRenderModeWireframe() DGG.getDefaultFont().setPixelsPerUnit(100) self.setShaders() self.initLights() self.initTransitions() self.setFPS() self.setCam() def setCam(self): base.camLens.setNearFar(10, 500) # base.camLens.setFov(40) def setShaders(self): if not base.win.getGsg().getSupportsBasicShaders(): print( "Toon Shader: Video driver reports that Cg shaders are not supported." ) return tempnode = NodePath(PandaNode("temp node")) tempnode.setAttrib(LightRampAttrib.makeHdr0()) self.filters = CommonFilters(base.win, base.cam) # GLOW self.filters.setBloom(blend=(0.3, 0.4, 0.3, 0.0), mintrigger=0.6, maxtrigger=1.0, desat=0.6, intensity=1.0, size="medium") tempnode.setShaderAuto() base.cam.node().setInitialState(tempnode.getState()) def initLights(self): ambientLight = AmbientLight("ambient_light") ambientLight.setColor((0.2, 0.2, 0.2, 1)) self.alnp = render.attachNewNode(ambientLight) sunLens = PerspectiveLens() sunLens.setFilmSize(50) sun = DirectionalLight("sun") sun.setColor((1, 1, 1, 1)) # sun.setShadowCaster(True, 4096, 4096) # highest working value sun.setScene(render) # sun.showFrustum() sunLens.setFov(120, 40) sunLens.setNearFar(2, 100) sun.setLens(sunLens) self.sunNp = render.attachNewNode(sun) def setFPS(self): FPS = 30 globalClock = ClockObject.getGlobalClock() globalClock.setMode(ClockObject.MLimited) globalClock.setFrameRate(FPS) def initTransitions(self): self.transitions = Transitions(loader) self.transitions.setFadeColor(0, 0, 0) self.transitionTime = 0.2 base.accept("fadeOut", self.transitions.fadeOut, [self.transitionTime]) base.accept("fadeIn", self.transitions.fadeIn, [self.transitionTime]) base.accept("noFade", self.transitions.noFade) def fadeInOutSequence(self, callback, callbackArgs=None): if callbackArgs: seq = Sequence( Func(base.messenger.send, 'fadeOut'), Wait(self.transitionTime), Func(callback, callbackArgs), Wait(self.transitionTime), Func(base.messenger.send, 'fadeIn'), ) else: seq = Sequence( Func(base.messenger.send, 'fadeOut'), Wait(self.transitionTime), Func(callback), Wait(self.transitionTime), Func(base.messenger.send, 'fadeIn'), ) seq.start()
class Quantus( DirectObject ): def __init__( self ): #render.setShaderAuto() self.perPixelEnabled = False PStatClient.connect() base.disableMouse() base.enableParticles() render.setAttrib(LightRampAttrib.makeHdr2()) self.input = KeymapController() self.input.setCurrentBranch("general.god_mode") self.dlight = DirectionalLight('dlight') self.dlight.setColor(VBase4(0.8, 0.8, 0.5, 1)) self.dlnp = render.attachNewNode(self.dlight.upcastToPandaNode()) self.dlnp.setHpr(0, -30, 0) render.setLight(self.dlnp) self.alight = AmbientLight('alight') self.alight.setColor(VBase4(0.1, 0.1, 0.1, 1)) self.alnp = render.attachNewNode(self.alight) render.setLight(self.alnp) self.filters = CommonFilters(base.win, base.cam) self.filters.setBloom() #self.filters.setVolumetricLighting(caster=self.dlnp) render.setAntialias(AntialiasAttrib.MAuto) traverser = CollisionTraverser('traverser name') base.cTrav = traverser base.cTrav.setRespectPrevTransform(True) #self.tank = Tank() gravityFN = ForceNode('world-forces') gravityFNP = render.attachNewNode(gravityFN) gravityForce = LinearVectorForce(0,0,-9.81) #gravity acceleration gravityFN.addForce(gravityForce) base.physicsMgr.addLinearForce(gravityForce) team = Team(0, None, "This team rules!") self.player = Human(0,0,"ME!!11!!!") self.tank = Vehicle(0, 100, "tank.x", 1, self.input) self.tank.addController(self.player, 0) self.tank.enable() mapLoader = MapLoader() self.map = mapLoader.load("Awesome Cool Map.map") self.map.getRoot().reparentTo(render) self.tank.create(Vec3(0,0,5000), self.map.getCurrentSector()) self.godMode = GodMode(self.map, self.input) #self.godMode.enable() self.accept( "switch_sector", self.switchSector ) self.accept( "god_mode", self.godMode.toggleEnabled ) self.accept( "menu", sys.exit) self.accept( "per_pixel_lighting", self.togglePerPixelLighting ) self.step() def switchSector(self): sectors = self.map.getSectors() numSectors = len(sectors) for sectorNum in range(0,numSectors): if self.map.getCurrentSector() == sectors[sectorNum]: self.map.setCurrentSector(sectors[(sectorNum+1)%numSectors]) break def togglePerPixelLighting( self ): if self.perPixelEnabled: self.perPixelEnabled = False render.clearShader() else: self.perPixelEnabled = True render.setShaderAuto() def step( self ): # render next frame taskMgr.step()
alight = AmbientLight('amibent') alight.setColor(VBase4(3, 3, 3, 1)) alnp = render.attachNewNode(alight) plight = PointLight('point') plight.setColor(VBase4(0.8, 0.8, 0.8, 1)) plnp = render.attachNewNode(plight) plnp.setPos(0, 0, 1) render.setLight(alnp) pnda = loader.loadModel("panda") pnda.reparentTo(plnp) pnda2 = loader.loadModel("panda") pnda2.reparentTo(render) pnda2.setPos(0,0,-10) base.camera.lookAt(pnda) fltr = CommonFilters(base.win, base.cam) fltr.setBloom() #fltr.setGammaAdjust(1.5) #fltr.setAmbientOcclusion() #fltr.setBlurSharpen(2) #fltr.setInverted() #fltr.setCartoonInk(separation=1, color=(0, 0, 0, 1)) #fltr.setVolumetricLighting(pnda, 32, 5.0, 0.1, 0.1) run() # from direct.showbase.ShowBase import ShowBase # from panda3d.core import Plane, Vec3, Point3, CardMaker # from panda3d.core import WindowProperties # from panda3d.core import LPoint2f # class YourClass(ShowBase): # def __init__(self):
class GlowDemo(ShowBase): def __init__(self): # Initialize the ShowBase class from which we inherit, which will # create a window and set up everything we need for rendering into it. ShowBase.__init__(self) base.disableMouse() base.setBackgroundColor(0, 0, 0) camera.setPos(0, -50, 0) # Check video card capabilities. if not base.win.getGsg().getSupportsBasicShaders(): addTitle( "Glow Filter: Video driver reports that Cg shaders are not supported." ) return # Use class 'CommonFilters' to enable a bloom filter. # The brightness of a pixel is measured using a weighted average # of R,G,B,A. We put all the weight on Alpha, meaning that for # us, the framebuffer's alpha channel alpha controls bloom. self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size="small") if (filterok == False): addTitle( "Toon Shader: Video card not powerful enough to do image postprocessing" ) return self.glowSize = 1 # Post the instructions self.title = addTitle("Panda3D: Tutorial - Glow Filter") self.inst1 = addInstructions(0.06, "ESC: Quit") self.inst2 = addInstructions( 0.12, "Space: Toggle Glow Filter Small/Med/Large/Off") self.inst3 = addInstructions(0.18, "Enter: Toggle Running/Spinning") self.inst4 = addInstructions(0.24, "V: View the render-to-texture results") # load our model self.tron = Actor() self.tron.loadModel("models/tron") self.tron.loadAnims({"running": "models/tron_anim"}) self.tron.reparentTo(render) self.interval = self.tron.hprInterval(60, LPoint3(360, 0, 0)) self.interval.loop() self.isRunning = False # put some lighting on the model dlight = DirectionalLight('dlight') alight = AmbientLight('alight') dlnp = render.attachNewNode(dlight) alnp = render.attachNewNode(alight) dlight.setColor((1.0, 0.7, 0.2, 1)) alight.setColor((0.2, 0.2, 0.2, 1)) dlnp.setHpr(0, -60, 0) render.setLight(dlnp) render.setLight(alnp) # Panda contains a built-in viewer that lets you view the results of # your render-to-texture operations. This code configures the viewer. self.accept("v", base.bufferViewer.toggleEnable) self.accept("V", base.bufferViewer.toggleEnable) base.bufferViewer.setPosition("llcorner") base.bufferViewer.setLayout("hline") # base.camLens.setFov(100) # event handling self.accept("space", self.toggleGlow) self.accept("enter", self.toggleDisplay) self.accept("escape", sys.exit, [0]) def toggleGlow(self): self.glowSize = self.glowSize + 1 if self.glowSize == 4: self.glowSize = 0 self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size=self.glowSize) def toggleDisplay(self): self.isRunning = not self.isRunning if not self.isRunning: camera.setPos(0, -50, 0) self.tron.stop("running") self.tron.pose("running", 0) self.interval.loop() else: camera.setPos(0, -170, 3) self.interval.finish() self.tron.setHpr(0, 0, 0) self.tron.loop("running")