class BRHood(ToonHood): notify = directNotify.newCategory('BRHood') ID = ToontownGlobals.TheBrrrgh TOWNLOADER_CLASS = BRTownLoader SAFEZONELOADER_CLASS = BRSafeZoneLoader STORAGE_DNA = 'phase_8/dna/storage_BR.pdna' SKY_FILE = 'phase_3.5/models/props/BR_sky' SPOOKY_SKY_FILE = 'phase_3.5/models/props/BR_sky' TITLE_COLOR = (0.3, 0.6, 1.0, 1.0) HOLIDAY_DNA = { ToontownGlobals.WINTER_DECORATIONS: ['phase_8/dna/winter_storage_BR.pdna'], ToontownGlobals.WACKY_WINTER_DECORATIONS: ['phase_8/dna/winter_storage_BR.pdna'], ToontownGlobals.HALLOWEEN_PROPS: ['phase_8/dna/halloween_props_storage_BR.pdna'], ToontownGlobals.SPOOKY_PROPS: ['phase_8/dna/halloween_props_storage_BR.pdna'] } def load(self): ToonHood.load(self) self.fog = Fog('BRFog') def setFog(self): if base.wantFog: self.fog.setColor(0.9, 0.9, 0.9) self.fog.setExpDensity(0.004) render.clearFog() render.setFog(self.fog) self.sky.clearFog() self.sky.setFog(self.fog)
def loadFog(self): fog = Fog('distanceFog') fog.setColor(0, 0, 0) fog.setExpDensity(.07) render.setFog(fog) fog.setOverallHidden(False) return fog.getExpDensity()
def createEnvironment(self): # Fog to hide a performance tweak: colour = (0.0, 0.0, 0.0) expfog = Fog("scene-wide-fog") expfog.setColor(*colour) expfog.setExpDensity(0.001) # original : 0.004 render.setFog(expfog) base.setBackgroundColor(*colour) # Our sky skydome = loader.loadModel('sky.egg') skydome.setEffect(CompassEffect.make(self.render)) skydome.setScale(self.maxdistance / 2) # bit less than "far" skydome.setZ(-65) # sink it # NOT render - you'll fly through the sky!: skydome.reparentTo(self.camera) # Our lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(.6, .6, .6, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(Vec3(0, -10, -10)) directionalLight.setColor(Vec4(1, 1, 1, 1)) directionalLight.setSpecularColor(Vec4(1, 1, 1, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight))
def begin(self): base.setBackgroundColor( self.environment['colourBackground'] ) alight = AmbientLight('AmbientLight') alight.setColor(self.environment['colourAmbient'] ) alnp = self.sceneNode.attachNewNode(alight) self.sceneNode.setLight(alnp) if self.environment['fog']: fog = Fog( 'sceneName' ) fog.setColor( self.environment['fog']['color'] ) if self.environment['fog']['mode'] == "linear": fog.setLinearRange(self.environment['fog']['linearStart']*1000,self.environment['fog']['linearEnd']*1000) else: fog.setExpDensity( self.environment['fog']['expDensity'] ) self.sceneNode.setFog(fog) [self.createNode(props) for props in self.nodes] [self.createLight(props) for props in self.lights] [self.createCamera(props) for props in self.cameras] [self.createEntity(props) for props in self.entities] # [self.createStaticGeoms(props) for props in self.staticGeoms] self.sceneNode.clearModelNodes() self.sceneNode.flattenStrong() self.sceneNode.setShaderAuto()
def __init__(self): super().__init__() self.controller = inputs.devices.gamepads[0] self.cur_track_segment = 0 track_f = open("track.json") track_data = json.load(track_f) track_f.close() self.track = track.Track(track_data, world) self.car = car.Car(base, world, self.track) dlight = DirectionalLight('dlight') dlnp = render.attachNewNode(dlight) dlnp.setHpr(0, -80, 0) render.setLight(dlnp) alight = AmbientLight('alight') alight.setColor(Vec4(0.2, 0.2, 0.2, 1)) alnp = render.attachNewNode(alight) render.setLight(alnp) myFog = Fog("Fog") myFog.setColor(0.2, 0.2, 0.2) myFog.setExpDensity(0.005) render.setFog(myFog) taskMgr.add(self.update, 'update') self.controller_t = threading.Thread(target=self.controller_tf, daemon=True) self.controller_t.start()
def init(self): """setup calls that can be repeated on code reload""" self.resetNodes() self.base.setBackgroundColor(0, 0, 0) self.base.render.setShaderAuto() # pp shading self.base.render.setAttrib( AntialiasAttrib.make(AntialiasAttrib.MMultisample)) if 1: cam = self.base.render.find("camera") # I don't know how to set cam position f = Fog("fog") f.setColor(0, 0, 0) f.setLinearRange(18, 25) self.base.render.setFog(f) import videowall reload(videowall) self.videoWall = videowall.VideoWall(self.base.loader, self.base.render) self.cubes = self.base.render.attachNewNode(ModelNode("cubes")) self.cubes.setPos(-4.3, 18, -3) ground = self.makeGround(self.cubes) lights = self.base.render.attachNewNode("lights") self.makeLights(lights) self.centerMessageNode, self.cornerMessageNode = self.makeMessages() self.setLighting(self.currentLighting) self.base.render.ls()
class CogdoFlyingLevelFog: def __init__(self, level, color=Globals.Level.FogColor): self._level = level self.color = color fogDistance = self._level.quadLengthUnits * max( 1, self._level.quadVisibiltyAhead * 0.2) self.fog = Fog('RenderFog') self.fog.setColor(self.color) self.fog.setLinearRange( fogDistance * Globals.Level.RenderFogStartFactor, fogDistance) self._visible = False self._clearColor = Vec4(base.win.getClearColor()) self._clearColor.setW(1.0) def destroy(self): self.setVisible(False) if hasattr(self, 'fog'): del self.fog def isVisible(self): return self._visible def setVisible(self, visible): self._visible = visible if self._visible: base.win.setClearColor(self.color) render.setFog(self.fog) else: base.win.setClearColor(self._clearColor) render.clearFog()
class LinearFog(object): def __init__(self, r, g, b, min_dist, max_dist): self.fog = Fog("GlobalFog") self.fog.setColor(r, g, b) dist_base = 100 if G.debug else 0 min_dist += dist_base max_dist += dist_base assert min_dist < max_dist self.fog.set_linear_range(min_dist, max_dist) self.fog.setLinearFallback(15, min_dist, max_dist) G.setBackgroundColor(r, g, b, 1) G.render.setFog(self.fog) self._enabled = True def switch(self): self._enabled = not self._enabled self.set_enabled(self._enabled) def set_enabled(self, enabled): self._enabled = enabled if enabled: G.render.setFog(self.fog) else: G.render.clear_fog() def destory(self): G.render.clear_fog()
def loadPrisonCrater(): ## Sky color base.win.setClearColor(Vec4(.46,.824,.904,1)) ## Load Ground sand = loader.loadModel("data/models/sand.bam") sand.reparentTo(render) sand.setTexScale(TextureStage.getDefault(),5000,5000) craterwalls = loader.loadModel("data/models/craterwalls.bam") craterwalls.reparentTo(render) craterwalls.setTexScale(TextureStage.getDefault(),500,50) ## World Effects fog = Fog("Fog") fog.setColor(255,215,143) fog.setExpDensity(.0000001) render.setFog(fog) alight = render.attachNewNode(AmbientLight("Abient")) alight.node().setColor(Vec4(.9,.9,.9,1)) render.setLight(alight) sun = DirectionalLight('Sun') sun.setColor(Vec4(1,1,1,1)) sunNP = render.attachNewNode(sun) sunNP.setPos(0,0,4000) sunNP.setHpr(0,-90,0) render.setLight(sunNP)
class BRHood(ToonHood): notify = directNotify.newCategory("BRHood") ID = ToontownGlobals.TheBrrrgh TOWNLOADER_CLASS = BRTownLoader SAFEZONELOADER_CLASS = BRSafeZoneLoader STORAGE_DNA = "phase_8/dna/storage_BR.pdna" SKY_FILE = "phase_3.5/models/props/BR_sky" SPOOKY_SKY_FILE = "phase_3.5/models/props/BR_sky" TITLE_COLOR = (0.3, 0.6, 1.0, 1.0) HOLIDAY_DNA = { ToontownGlobals.WINTER_DECORATIONS: ["phase_8/dna/winter_storage_BR.pdna"], ToontownGlobals.WACKY_WINTER_DECORATIONS: ["phase_8/dna/winter_storage_BR.pdna"], ToontownGlobals.HALLOWEEN_PROPS: ["phase_8/dna/halloween_props_storage_BR.pdna"], ToontownGlobals.SPOOKY_PROPS: ["phase_8/dna/halloween_props_storage_BR.pdna"], } def load(self): ToonHood.load(self) self.fog = Fog("BRFog") def setFog(self): if base.wantFog: self.fog.setColor(0.9, 0.9, 0.9) self.fog.setExpDensity(0.004) render.clearFog() render.setFog(self.fog) self.sky.clearFog() self.sky.setFog(self.fog)
def init(self): """setup calls that can be repeated on code reload""" self.resetNodes() self.base.setBackgroundColor(0, 0, 0) self.base.render.setShaderAuto() # pp shading self.base.render.setAttrib( AntialiasAttrib.make(AntialiasAttrib.MMultisample)) if 1: cam = self.base.render.find("camera") # I don't know how to set cam position f = Fog("fog") f.setColor(0,0,0) f.setLinearRange(18, 25) self.base.render.setFog(f) import videowall reload(videowall) self.videoWall = videowall.VideoWall(self.base.loader, self.base.render) self.cubes = self.base.render.attachNewNode(ModelNode("cubes")) self.cubes.setPos(-4.3, 18, -3) ground = self.makeGround(self.cubes) lights = self.base.render.attachNewNode("lights") self.makeLights(lights) self.centerMessageNode, self.cornerMessageNode = self.makeMessages() self.setLighting(self.currentLighting) self.base.render.ls()
def __init__(self): ShowBase.__init__(self) self.camera.setPos(0, 0, 3) self.fm = FlyMove(self) self.scene = self.loader.loadModel('models/environment') self.disable_mouse() self.scene.reparentTo(self.render) self.scene.setScale(0.25, 0.25, 0.25) self.scene.setPos(-8, 42, 0) pandaMat = Material() pandaMat.setEmission((1, 0.4, 0, 1)) colour = (0.5, 0.8, 0.8) expfog = Fog("Scene-wide exponential Fog object") expfog.setColor(*colour) expfog.setExpDensity(0.005) self.render.setFog(expfog) self.pandaActor = Actor('models/panda-model', {'walk': 'models/panda-walk4'}) self.pandaActor.set_material(pandaMat) self.pandaActor.setScale(0.005, 0.005, 0.005) self.pandaActor.loop('walk') line = NodePath('pandaline') for i in range(50): placeholder = line.attachNewNode('line-panda') placeholder.setPos(i * 2, 0, 0) self.pandaActor.instanceTo(placeholder) line.reparentTo(self.render) pandaPosIntervalInterval1 = self.pandaActor.posInterval( 13, Point3(0, -10, 0), startPos=Point3(0, 10, 0)) pandaPosIntervalInterval2 = self.pandaActor.posInterval( 13, Point3(0, 10, 0), startPos=Point3(0, -10, 0)) pandaHprIntervalInterval1 = self.pandaActor.hprInterval( 2, Point3(180, 0, 0), startHpr=Point3(0, 0, 0)) pandaHprIntervalInterval2 = self.pandaActor.hprInterval( 2, Point3(0, 0, 0), startHpr=Point3(180, 0, 0)) self.pandaPace = Sequence(pandaPosIntervalInterval1, pandaHprIntervalInterval1, pandaPosIntervalInterval2, pandaHprIntervalInterval2) self.pandaPace.loop() light = DirectionalLight('pl') light.set_color_temperature(2000) np = self.render.attachNewNode(light) np.set_pos(0, 0, 5) light.set_shadow_caster(True, 512, 512) self.render.setLight(np) # np.place() alight = AmbientLight('alight') alight.setColor(VBase4(0.3, 0.1, 0.1, 1)) alnp = self.render.attachNewNode(alight) self.render.setLight(alnp)
class CogdoFlyingLevelFog: def __init__(self, level, color = Globals.Level.FogColor): self._level = level self.color = color fogDistance = self._level.quadLengthUnits * max(1, self._level.quadVisibiltyAhead * 0.2) self.fog = Fog('RenderFog') self.fog.setColor(self.color) self.fog.setLinearRange(fogDistance * Globals.Level.RenderFogStartFactor, fogDistance) self._visible = False self._clearColor = Vec4(base.win.getClearColor()) self._clearColor.setW(1.0) def destroy(self): self.setVisible(False) if hasattr(self, 'fog'): del self.fog def isVisible(self): return self._visible def setVisible(self, visible): self._visible = visible if self._visible: base.win.setClearColor(self.color) render.setFog(self.fog) else: base.win.setClearColor(self._clearColor) render.clearFog()
class Scene(NodePath): def __init__(self): super().__init__('scene') self.render = None self.world = None self.camera = None self.ui_camera = None self.entities = [] self.hidden = NodePath('hidden') self.reflection_map = 'reflection_map_3' def set_up(self): from ursina.entity import Entity self.reparent_to(render) self.reflection_map = load_texture(self.reflection_map) self.fog = Fog('fog') self.setFog(self.fog) self.fog_color = color.light_gray self.fog_density = 0 def clear(self): from ursina.ursinastuff import destroy to_destroy = [e for e in self.entities if not e.eternal] to_keep = [e for e in self.entities if e.eternal] for d in to_destroy: try: print('destroying:', d.name) destroy(d) except Exception as e: print('failed to destroy entity', e) self.entities = to_keep from ursina import application application.sequences.clear() @property def fog_color(self): return self.fog.getColor() @fog_color.setter def fog_color(self, value): self.fog.setColor(value) @property def fog_density(self): return self._fog_density @fog_density.setter # set to a number for exponential density or (start, end) for linear. def fog_density(self, value): self._fog_density = value if isinstance(value, tuple): # linear fog self.fog.setLinearRange(value[0], value[1]) else: self.fog.setExpDensity(value)
def set_fog(self): """Set render distance of camera.""" fog = Fog("Scene fog") fog.setColor(0.7, 0.7, 0.7) fog.setExpDensity(0.01) # self.terrain.geom_node.setFog(fog) self.base.camLens.setFar(4000.0) return fog
def toggle_smoke(self): from panda3d.core import Fog if self.render.getFog(): self.render.clearFog() else: smoke = Fog("smoke") smoke.setColor(config.smoke_color) smoke.setExpDensity(config.smoke_exp_density) render.setFog(smoke)
def setFogOn(self, fog): self.fogOn = fog if self.fogOn: myFog = Fog('Fog Rendering Fog of Rendering') myFog.setColor(1.0, 0.0, 0.0) myFog.setExpDensity(0.5) self.setFog(myFog) else: self.clearFog()
def setFogOn(self, fog): self.fogOn = fog if self.fogOn: myFog = Fog('Fog Rendering Fog of Rendering') myFog.setColor(1.0, 0.0, 0.0) myFog.setExpDensity(0.5) self.setFog(myFog) else: self.clearFog()
def loadFog(self, fogDensity): fog = Fog('distanceFog') fog.setColor(0, 0, 0) fog.setExpDensity(fogDensity * (math.pow(10, -2))) render.setFog(fog) fog.setOverallHidden(False) #fog.getExpDensity() print(fog.getExpDensity()) print("tried to load fog") return fog
def createEnvironment(self): # Fog to hide a performance tweak exp_fog = Fog("scene-wide-fog") exp_fog.setColor(1, 0.8, 0.8) exp_fog.setExpDensity(0.002) render.setFog(exp_fog) # base.setBackgroundColor(*colour) # Sky Dome ''' sky_dome = loader.loadModel("models/sky") # sky_sphere.egg by default sky_dome.setEffect(CompassEffect.make(self.render)) sky_dome.setScale(self.max_distance / 2) sky_dome.setZ(-65) # sink it # NOT render - you'll fly through the sky! sky_dome.reparentTo(self.camera) ''' # Sky Sphere sky_sphere = self.loader.loadModel("models/sky_sphere") sky_sphere.setEffect(CompassEffect.make(self.render)) sky_sphere.setScale(0.08) sky_sphere.reparentTo(self.camera) # Lighting ambient_light = AmbientLight("ambientLight") ambient_colour = Vec4(0.6, 0.6, 0.6, 1) ambient_light.setColor(ambient_colour) self.render.setLight(self.render.attachNewNode(ambient_light)) directional_light = DirectionalLight("directionalLight") # direction = Vec3(0, -10, -10) # directional_light.setDirection(direction) directional_colour = Vec4(0.8, 0.8, 0.5, 1) directional_light.setColor(directional_colour) # directional_specular = Vec4(1, 1, 1, 1) # directional_light.setSpecularColor(directional_specular) dir_light_np = self.render.attachNewNode(directional_light) dir_light_np.setPos(0, 0, 260) dir_light_np.lookAt(self.player) self.render.setLight(dir_light_np) # Water self.water = self.loader.loadModel("models/square") self.water.setSx(self.world_size*2) self.water.setSy(self.world_size*2) self.water.setPos(self.world_size/2, self.world_size/2, 25) # z is sea level self.water.setTransparency(TransparencyAttrib.MAlpha) newTS = TextureStage("1") self.water.setTexture(newTS, self.loader.loadTexture("models/water.png")) self.water.setTexScale(newTS, 4) self.water.reparentTo(self.render) LerpTexOffsetInterval(self.water, 200, (1,0), (0,0), textureStage=newTS).loop()
class BossbotHQ(CogHood.CogHood): def __init__(self, parentFSM, doneEvent, dnaStore, hoodId): CogHood.CogHood.__init__(self, parentFSM, doneEvent, dnaStore, hoodId) self.id = ToontownGlobals.BossbotHQ self.cogHQLoaderClass = BossbotCogHQLoader.BossbotCogHQLoader self.storageDNAFile = None self.skyFile = 'phase_9/models/cogHQ/cog_sky' self.titleColor = (0.5, 0.5, 0.5, 1.0) return def load(self): CogHood.CogHood.load(self) self.sky.hide() self.fog = Fog('BossbotHQFog') self.sky.hide() self.parentFSM.getStateNamed('BossbotHQ').addChild(self.fsm) def unload(self): self.parentFSM.getStateNamed('BossbotHQ').removeChild(self.fsm) del self.cogHQLoaderClass CogHood.CogHood.unload(self) self.fog = None def enter(self, *args): CogHood.CogHood.enter(self, *args) localAvatar.setCameraFov(ToontownGlobals.CogHQCameraFov) base.camLens.setNearFar(ToontownGlobals.BossbotHQCameraNear, ToontownGlobals.BossbotHQCameraFar) self.setFog() def exit(self): localAvatar.setCameraFov(settings['fieldofview']) base.camLens.setNearFar(ToontownGlobals.DefaultCameraNear, ToontownGlobals.DefaultCameraFar) CogHood.CogHood.exit(self) def spawnTitleText(self, zoneId, floorNum=None): if ZoneUtil.isMintInteriorZone(zoneId): text = '%s\n%s' % (ToontownGlobals.StreetNames[zoneId][-1], TTLocalizer.MintFloorTitle % (floorNum + 1)) self.doSpawnTitleText(text) else: CogHood.CogHood.spawnTitleText(self, zoneId) def setFog(self): if base.wantFog: self.fog.setColor(0.1, 0.1, 0.1) self.fog.setExpDensity(0.004) render.clearFog() render.setFog(self.fog) self.sky.clearFog() self.sky.setFog(self.fog)
class EnvFog(DistributedEntity): FadeInDuration = 0.5 FadeOutDuration = 0.5 NeedNode = False def __init__(self, cr): DistributedEntity.__init__(self, cr) self.fogNode = None self.fogDensity = 0.0 def load(self): DistributedEntity.load(self) density = self.getEntityValueFloat("fogdensity") self.fogDensity = density color = self.getEntityValueColor("fogcolor") self.fogNode = Fog('env_fog') self.fogNode.setExpDensity(density) self.fogNode.setColor(color) base.shaderGenerator.setFog(self.fogNode) def think(self): elapsed = self.getEntityStateElapsed() state = self.getEntityState() if state == 1: if elapsed < self.FadeInDuration: self.fogNode.setExpDensity(CIGlobals.lerp2(0.0, self.fogDensity, elapsed / self.FadeInDuration)) else: self.fogNode.setExpDensity(self.fogDensity) elif state == 0: if elapsed < self.FadeOutDuration: self.fogNode.setExpDensity(CIGlobals.lerp2(self.fogDensity, 0.0, elapsed / self.FadeOutDuration)) else: self.fogNode.setExpDensity(0.0) def disable(self): self.fogNode = None self.fogDensity = None base.shaderGenerator.clearFog() DistributedEntity.disable(self)
def createEnviroment(self): # Fog to hide performance tweak: colour = (0.5, 0.5, 0.5) expfog = Fog("scene-wide-fog") expfog.setColor(*colour) expfog.setExpDensity(0.002) self.render.setFog(expfog) base.setBackgroundColor(*colour) # Our sky skydome = self.loader.loadModel('blue-sky-sphere') skydome.setEffect(CompassEffect.make(self.render)) skydome.setScale(0.08) # bit less than "far" # NOT render - you`ll fly through the sky!: skydome.reparentTo(self.camera) # Our lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(.6, .6, .6, 1)) render.setLight(render.attachNewNode(ambientLight)) directionalLight = DirectionalLight("directionalLight") directionalLight.setColor(Vec4(0.8, 0.8, 0.5, 1)) dlnp = self.render.attachNewNode(directionalLight) dlnp.setPos(0, 0, 260) dlnp.lookAt(self.player) self.render.setLight(dlnp) self.render2d = render2d # image scale of 1 fills screen, position defaults to central Scale = 1.0 / 2.5 # decimal point is VITAL self.radar = OnscreenImage(image='radar.png', scale=Scale, \ parent=self.render2d, pos=(-0.95,0,-0.95)) self.radar.setTransparency(TransparencyAttrib.MAlpha) # note the image itself and how it is centered hud = OnscreenImage(image='hud1.png', scale=1, \ parent=self.render2d, pos=(0,0,0)) hud.setTransparency(TransparencyAttrib.MAlpha) self.dots = list() self.playerobj = OnscreenImage(image='playerdot.png', \ scale=1.0/20.0,parent=self.radar) self.playerobj.setTransparency(TransparencyAttrib.MAlpha)
def createEnvironment(self): # Fog to hide a performance tweak: colour = (0.5, 0.5, 0.5) expfog = Fog("scene-wide-fog") expfog.setColor(*colour) expfog.setExpDensity(0.001) # original : 0.004 render.setFog(expfog) base.setBackgroundColor(*colour) # Our sky skysphere = self.loader.loadModel('blue-sky-sphere') skysphere.setEffect(CompassEffect.make(self.render)) skysphere.setScale(0.08) # NOT render or you'll fly through the sky!: skysphere.reparentTo(self.camera) # Our lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(.6, .6, .6, 1)) self.render.setLight(self.render.attachNewNode(ambientLight)) directionalLight = DirectionalLight("directionalLight") directionalLight.setColor(VBase4(0.8, 0.8, 0.5, 1)) dlnp = self.render.attachNewNode(directionalLight) dlnp.setPos(0, 0, 260) dlnp.lookAt(self.player) self.render.setLight(dlnp) # water self.water = self.loader.loadModel('square.egg') self.water.setSx(self.worldsize * 2) self.water.setSy(self.worldsize * 2) self.water.setPos(self.worldsize / 2, self.worldsize / 2, 2) # sea level self.water.setTransparency(TransparencyAttrib.MAlpha) newTS = TextureStage('1') self.water.setTexture(newTS, self.loader.loadTexture('water.png')) self.water.setTexScale(newTS, 4) self.water.reparentTo(self.render) LerpTexOffsetInterval(self.water, 200, (1, 0), (0, 0), textureStage=newTS).loop()
def __createEnvironment(self): # Fog expfog = Fog("scene-wide-fog") expfog.setColor(0.5, 0.5, 0.5) expfog.setExpDensity(0.002) self.render.setFog(expfog) # Our sky skysphere = self.loader.loadModel('volume1/models/blue-sky-sphere') skysphere.setEffect(CompassEffect.make(self.render)) skysphere.setScale(0.08) # NOT render or you'll fly through the sky!: skysphere.reparentTo(self.camera) # Our lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(.6, .6, .6, 1)) self.render.setLight(self.render.attachNewNode(ambientLight)) directionalLight = DirectionalLight("directionalLight") directionalLight.setColor(VBase4(0.8, 0.8, 0.5, 1)) dlnp = self.render.attachNewNode(directionalLight) dlnp.setPos(0, 0, 260) dlnp.setHpr(225, -60, 0) #lookAt(self.player) self.render.setLight(dlnp) # water self.water = self.loader.loadModel('volume1/models/square.egg') self.water.setSx(self.worldsize * 2) self.water.setSy(self.worldsize * 2) self.water.setPos(self.worldsize / 2, self.worldsize / 2, 18) # sea level self.water.setTransparency(TransparencyAttrib.MAlpha) nTS = TextureStage('1') self.water.setTexture( nTS, self.loader.loadTexture('volume1/models/water.png')) self.water.setTexScale(nTS, 4) self.water.reparentTo(self.render) LerpTexOffsetInterval(self.water, 200, (1, 0), (0, 0), textureStage=nTS).loop()
def __init__(self): ShowBase.__init__(self) self.setBackgroundColor(0.8, 0.8, 0.8) fog = Fog("Fog Name") fog.setColor(0.6, 0.6, 0.6) fog.setExpDensity(0.001) self.render.setFog(fog) # Terrain terarin = Terrain() nodePath = self.render.attachNewNode(terarin.node()) # Landmarks landmarks = Landmarks(8000, 2.5 / 1000000) nodePath = self.render.attachNewNode(landmarks.node()) nodePath.setRenderModeThickness(1) # Box for i in range(50): x, y = random_in_circle() x *= 5000 y *= 5000 z = elevation(x, y) - 10 border = ( Vec3(x, y, z), Vec3(x, y + 50.0, z), Vec3(x + 50.0, y + 50.0, z), Vec3(x + 50.0, y, z), ) tops = [i * 2.5 for i in range(int(40 + random() * 60))] building = Building(border=border, tops=tops) nodePath = self.render.attachNewNode(building.node()) nodePath.setTwoSided(True) self.disableMouse() self.taskMgr.add(self.camera_task, "CameraTask") self.height = 100 self.accept('wheel_up', self.wheel_up) self.accept('wheel_down', self.wheel_down) self.accept('w-repeat', self.advance) # self.accept('a', self.left) self.accept('s-repeat', self.retreat) # self.accept('d', self.right) self.position = Vec3(0.0, 0.0, 0.0) self.movement = Vec3(0.0, 0.0, 2.0)
class LoveFog: """St. Valentines Day mode effect.""" def __init__(self): self.is_on = False self._love_fog = Fog("Love") self._love_fog.setColor(0.7, 0.42, 0.49) self._love_fog.setExpDensity(0.25) def switch(self): """Switch on/off the effect.""" if self.is_on: render.clearFog() # noqa: F821 base.train.love_particles(False) # noqa: F821 if base.effects_mgr.stench_effect.is_playing: # noqa: F821 base.effects_mgr.stench_effect.set_fog() # noqa: F821 else: render.setFog(self._love_fog) # noqa: F821 base.train.love_particles(True) # noqa: F821 self.is_on = not self.is_on
def __init__(self, *args, **kwargs): template.Panda.__init__(self, *args, **kwargs) print "Hurray!" self.cube = self.loader.loadModel("models/low-cube") self.cube.reparentTo(self.render) self.cube2 = self.loader.loadModel("models/low-cube") self.cube2.reparentTo(self.render) self.cube2.setPos(self.cube, 10,20,30) self.cube2.setHpr(175,3,45) self.taskMgr.add(self.update, "update") self.taskMgr.add(self.move, "move") self._dir = 1 colour = (0.5,0.8,0.8) linfog = Fog("A linear-mode Fog node") linfog.setColor(*colour) linfog.setLinearRange(0,320) linfog.setLinearFallback(45,160,320) render.attachNewNode(linfog) render.setFog(linfog)
class BossbotHQ(CogHood): notify = directNotify.newCategory('BossbotHQ') ID = ToontownGlobals.BossbotHQ LOADER_CLASS = BossbotCogHQLoader def load(self): CogHood.load(self) self.fog = Fog('BossbotHQFog') self.sky.hide() def enter(self, requestStatus): CogHood.enter(self, requestStatus) base.localAvatar.setCameraFov(ToontownGlobals.CogHQCameraFov) base.camLens.setNearFar(ToontownGlobals.BossbotHQCameraNear, ToontownGlobals.BossbotHQCameraFar) self.setFog() def spawnTitleText(self, zoneId, floorNum=None): if ZoneUtil.isMintInteriorZone(zoneId): text = '%s\n%s' % (ToontownGlobals.StreetNames[zoneId][-1], TTLocalizer.MintFloorTitle % (floorNum + 1)) self.doSpawnTitleText(text) else: CogHood.spawnTitleText(self, zoneId) def setFog(self): if base.wantFog: self.fog.setColor(0.1, 0.1, 0.1) self.fog.setExpDensity(0.004) render.clearFog() render.setFog(self.fog) self.sky.clearFog() self.sky.setFog(self.fog)
def test2(): startup = PandaStartup() PLight(color=(1, 1, 1, 1), position=vec3(3, -1, 4), size=0.1).apply(startup.render) PLight(color=(1, 1, 1, 1), position=vec3(0, -1, 4), size=0.1).apply(startup.render) fog = Fog('Fog') fog.setColor(0.2, 0.2, 0.2) fog.setLinearRange(0, 30) startup.render.setFog(fog) size = nar([7, 7, 0.01]) ModelBox("floorBox", nar([-0.5, -2, -size[2]]), size, (0.4, 0.4, 0.4, 1), startup.render) models = world_model() for data in models: if 'box' in data['tag']: model = data['model'] # type: CollideBox ModelBox(data['id'], model.org, model.size, (0.7, 0.7, 0.7, 1), startup.render) def spinCameraTask(task): self = startup angleDegrees = task.time * 30.0 angleRadians = angleDegrees * (pi / 180.0) self.camera.setPos(40 * sin(angleRadians), -40.0 * cos(angleRadians), 3) self.camera.setHpr(angleDegrees, 0, 0) self.camera.look_at(0, 0, 3) # self.plight.setPos(10*sin(angleRadians), -10.0*cos(angleRadians), 3) time.sleep(1.0 / 80.0) return Task.cont # startup.task_mgr.add(spinCameraTask, 'spinCameraTask') startup.run()
class BossbotHQ(CogHood): notify = directNotify.newCategory("BossbotHQ") ID = ToontownGlobals.BossbotHQ LOADER_CLASS = BossbotCogHQLoader def load(self): CogHood.load(self) self.fog = Fog("BossbotHQFog") self.sky.hide() def enter(self, requestStatus): CogHood.enter(self, requestStatus) base.localAvatar.setCameraFov(ToontownGlobals.CogHQCameraFov) base.camLens.setNearFar(ToontownGlobals.BossbotHQCameraNear, ToontownGlobals.BossbotHQCameraFar) self.setFog() def spawnTitleText(self, zoneId, floorNum=None): if ZoneUtil.isMintInteriorZone(zoneId): text = "%s\n%s" % (ToontownGlobals.StreetNames[zoneId][-1], TTLocalizer.MintFloorTitle % (floorNum + 1)) self.doSpawnTitleText(text) else: CogHood.spawnTitleText(self, zoneId) def setFog(self): if base.wantFog: self.fog.setColor(0.1, 0.1, 0.1) self.fog.setExpDensity(0.004) render.clearFog() render.setFog(self.fog) self.sky.clearFog() self.sky.setFog(self.fog)
def __init__(self): ShowBase.__init__(self) # Disable the camera trackball controls. self.disableMouse() self.setBackgroundColor(0.5,0.5,0.5) self.terrain = Terrain(self) # Add a fog fog = Fog("A linear-mode Fog node") fog.setMode(Fog.MExponential) fog.setColor(0.5,0.5,0.5) fog.setExpDensity(0.01) self.render.setFog(fog) # helper maps for storing times self.lastPositioningTime = {} self.lastTurningTime = {} # Load and transform the panda actor. self.pandaActor = Actor("models/panda-model", {"walk": "models/panda-walk4"}) self.pandaActor.setScale(0.005, 0.005, 0.005) self.pandaActor.reparentTo(self.render) # setup keyboard events self.accept('arrow_up', self.pandaGo, [1]) self.accept('arrow_up-up', self.pandaStop, [1]) self.accept('arrow_down', self.pandaGo, [-1]) self.accept('arrow_down-up', self.pandaStop, [-1]) self.accept('arrow_left', self.pandaTurn, [-1]) self.accept('arrow_left-up', self.pandaStopTurning, [-1]) self.accept('arrow_right', self.pandaTurn, [1]) self.accept('arrow_right-up', self.pandaStopTurning, [1]) # add task for moving the camera self.taskMgr.add(self.spinCameraByPanda, "SpinCameraTask")
def createEnvironment(self): # Fog expfog = Fog("scene-wide-fog") expfog.setColor(0.5, 0.5, 0.5) expfog.setExpDensity(0.002) self.render.setFog(expfog) # Sky skysphere = self.loader.loadModel("assets/blue-sky-sphere") skysphere.setEffect(CompassEffect.make(self.render)) skysphere.setScale(0.08) skysphere.reparentTo(self.camera) # Lights ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(0.6, 0.6, 0.6, 1)) self.render.setLight(self.render.attachNewNode(ambientLight)) directionalLight = DirectionalLight("directionalLight") directionalLight.setColor(VBase4(0.8, 0.8, 0.5, 1)) dlnp = self.render.attachNewNode(directionalLight) dlnp.setPos(0, 0, 260) dlnp.lookAt(self.player) self.render.setLight(dlnp) # Water self.water = self.loader.loadModel("assets/square.egg") self.water.setSx(self.worldsize * 2) self.water.setSy(self.worldsize * 2) self.water.setPos(self.worldsize / 2, self.worldsize / 2, 25) self.water.setTransparency(TransparencyAttrib.MAlpha) newTS = TextureStage("1") self.water.setTexture(newTS, self.loader.loadTexture("assets/water.png")) self.water.setTexScale(newTS, 4) self.water.reparentTo(self.render) LerpTexOffsetInterval(self.water, 200, (1, 0), (0, 0), textureStage=newTS).loop()
def gameLoop(self, task): #Compensate for inconsistent update intervals dt = globalClock.getDt() if self.GAME_MODE == MAIN_MENU: if not self.mode_initialized: self.buildMainMenu() self.mode_initialized = True if self.GAME_MODE == IN_GAME_MENU: if not self.mode_initialized: #Fog out background inGameMenuFogColor = (50, 150, 50) inGameMenuFog = Fog("inGameMenuFog") inGameMenuFog.setMode(Fog.MExponential) inGameMenuFog.setColor(*inGameMenuFogColor) inGameMenuFog.setExpDensity(.01) render.setFog(inGameMenuFog) self.buildInGameMenu() self.mode_initialized = True if self.GAME_MODE == PLAY: if not self.mode_initialized: props = WindowProperties() props.setCursorHidden(True) base.win.requestProperties(props) self.last_mouse_x = self.win.getPointer(0).getX() self.last_mouse_y = self.win.getPointer(0).getY() self.mode_initialized = True if self.play_mode == TERRAIN: self.maintainTurrets() self.avatar.move(dt) elif self.play_mode == SPACE: self.asteroidManager.maintainAsteroidField(self.avatar.objectNP.getPos(), self.avatar.speed, dt) #Handle keyboard input self.avatar.handleKeys(self.keys, self.play_mode) ########## Mouse-based viewpoint rotation ########## mouse_pos = self.win.getPointer(0) current_mouse_x = mouse_pos.getX() current_mouse_y = mouse_pos.getY() #Side to side if self.play_mode == TERRAIN: mouse_shift_x = current_mouse_x - self.last_mouse_x self.last_mouse_x = current_mouse_x if current_mouse_x < 5 or current_mouse_x >= (self.win_center_x * 1.5): base.win.movePointer(0, self.win_center_x, current_mouse_y) self.last_mouse_x = self.win_center_x yaw_shift = -((mouse_shift_x) * Camera.ROT_RATE[0]) self.avatar.yawRot += yaw_shift self.avatar.objectNP.setH(self.avatar.yawRot) #Up and down mouse_shift_y = current_mouse_y - self.last_mouse_y self.last_mouse_y = current_mouse_y if current_mouse_y < 5 or current_mouse_y >= (self.win_center_y * 1.5): base.win.movePointer(0, current_mouse_x, self.win_center_y) self.last_mouse_y = self.win_center_y pitch_shift = -((mouse_shift_y) * Camera.ROT_RATE[1]) self.mainCamera.pitchRot += pitch_shift if self.mainCamera.pitchRot > Camera.FLEX_ROT_MAG[0]: self.mainCamera.pitchRot = Camera.FLEX_ROT_MAG[0] elif self.mainCamera.pitchRot < -Camera.FLEX_ROT_MAG[0]: self.mainCamera.pitchRot = -Camera.FLEX_ROT_MAG[0] xy_plane_cam_dist = Camera.AVATAR_DIST cam_x_adjust = xy_plane_cam_dist*sin(radians(self.avatar.yawRot)) cam_y_adjust = xy_plane_cam_dist*cos(radians(self.avatar.yawRot)) cam_z_adjust = Camera.ELEVATION self.mainCamera.camObject.setH(self.avatar.yawRot) self.mainCamera.camObject.setP(self.mainCamera.pitchRot) self.mainCamera.camObject.setPos(self.avatar.objectNP.getX() + cam_x_adjust, self.avatar.objectNP.getY() - cam_y_adjust, self.avatar.objectNP.getZ() + cam_z_adjust) #Find collisions #self.cTrav.traverse(render) #print self.environ.getBounds() return Task.cont
class CogdoBarrelRoom: notify = DirectNotifyGlobal.directNotify.newCategory('DistributedCogdoBarrelRoom') def __init__(self): self.timer = None self.model = None self._isLoaded = False self.dummyElevInNode = None self.cogdoBarrelsNode = None self.entranceNode = None self.nearBattleNode = None self.rewardUi = None self.rewardUiTaskName = 'CogdoBarrelRoom-RewardUI' self.rewardCameraTaskName = 'CogdoBarrelRoom-RewardCamera' self.fog = None self.defaultFar = None self.stomperSfx = None return def destroy(self): self.unload() def load(self): if self._isLoaded: return self.timer = ToontownTimer.ToontownTimer() self.timer.stash() self.model = loader.loadModel(CogdoBarrelRoomConsts.BarrelRoomModel) self.model.setPos(*CogdoBarrelRoomConsts.BarrelRoomModelPos) self.model.reparentTo(render) self.model.stash() self.dummyElevInNode = self.model.attachNewNode('elevator-in') self.dummyElevInNode.hide() self.entranceNode = self.model.attachNewNode('door-entrance') self.entranceNode.setPos(0, -65, 0) self.nearBattleNode = self.model.attachNewNode('near-battle') self.nearBattleNode.setPos(0, -25, 0) self.rewardUi = CogdoBarrelRoomRewardPanel.CogdoBarrelRoomRewardPanel() self.hideRewardUi() self.stomperSfx = base.loadSfx(CogdoBarrelRoomConsts.StomperSound) self.fog = Fog('barrel-room-fog') self.fog.setColor(CogdoBarrelRoomConsts.BarrelRoomFogColor) self.fog.setLinearRange(*CogdoBarrelRoomConsts.BarrelRoomFogLinearRange) self._isLoaded = True def unload(self): if self.model: self.model.removeNode() self.model = None if self.timer: self.timer.destroy() self.timer = None if self.rewardUi: self.rewardUi.destroy() self.rewardUi = None if self.fog: render.setFogOff() del self.fog taskMgr.remove(self.rewardUiTaskName) taskMgr.remove(self.rewardCameraTaskName) self._isLoaded = False return def isLoaded(self): return self._isLoaded def show(self): if not self.cogdoBarrelsNode: self.cogdoBarrelsNode = render.find('**/@@CogdoBarrels') self.cogdoBarrelsNode.reparentTo(self.model) self.cogdoBarrelsNode.unstash() self.defaultFar = base.camLens.getFar() base.camLens.setFar(CogdoBarrelRoomConsts.BarrelRoomCameraFar) self.showBattleAreaLight(True) render.setFog(self.fog) self.model.unstash() def hide(self): self.model.stash() render.setFogOff() if self.defaultFar is not None: base.camLens.setFar(self.defaultFar) return def activate(self): self.notify.info('Activating barrel room: %d sec timer.' % CogdoBarrelRoomConsts.CollectionTime) self.timer.unstash() self.timer.posAboveShtikerBook() self.timer.countdown(CogdoBarrelRoomConsts.CollectionTime) base.cr.playGame.getPlace().fsm.request('walk') def deactivate(self): self.notify.info('Deactivating barrel room.') self.timer.stop() self.timer.stash() def placeToonsAtEntrance(self, toons): for i in xrange(len(toons)): toons[i].setPosHpr(self.entranceNode, *CogdoBarrelRoomConsts.BarrelRoomPlayerSpawnPoints[i]) def placeToonsNearBattle(self, toons): for i in xrange(len(toons)): toons[i].setPosHpr(self.nearBattleNode, *CogdoBarrelRoomConsts.BarrelRoomPlayerSpawnPoints[i]) def showBattleAreaLight(self, visible = True): lightConeNode = self.model.find('**/battleCone') if lightConeNode != None and not lightConeNode.isEmpty(): if visible: lightConeNode.show() else: lightConeNode.hide() return def getIntroInterval(self): avatar = base.localAvatar trackName = '__introBarrelRoom-%d' % avatar.doId track = Parallel(name=trackName) track.append(self.__stomperIntervals()) track.append(Sequence(Func(base.camera.reparentTo, render), Func(base.camera.setPosHpr, self.model, -20.0, -87.9, 12.0, -30, 0, 0), Func(base.transitions.irisIn, 0.5), Wait(1.0), LerpHprInterval(base.camera, duration=2.0, startHpr=Vec3(-30, 0, 0), hpr=Vec3(0, 0, 0), blendType='easeInOut'), Wait(2.5), LerpHprInterval(base.camera, duration=3.0, startHpr=Vec3(0, 0, 0), hpr=Vec3(-45, 0, 0), blendType='easeInOut'), Wait(2.5))) track.delayDelete = DelayDelete.DelayDelete(avatar, 'introBarrelRoomTrack') track.setDoneEvent(trackName) return (track, trackName) def __stomperIntervals(self): ivals = [SoundInterval(self.stomperSfx)] i = 0 for stomperDef in CogdoBarrelRoomConsts.StomperProps: stomperNode = render.find(stomperDef['path']) if stomperNode: maxZ = random.uniform(10, 20) minZ = maxZ - 10 if stomperDef['motion'] == 'up': startZ, destZ = minZ, maxZ else: startZ, destZ = maxZ, minZ stomperNode.setPos(Point3(0, 0, startZ)) ivals.append(LerpPosInterval(stomperNode, CogdoBarrelRoomConsts.StomperHaltTime, Point3(0, 0, destZ), blendType='easeOut')) i += 1 return Parallel(*tuple(ivals)) def __rewardUiTimeout(self, callback): self.hideRewardUi() if callback is not None: callback() return def __rewardCamera(self): trackName = 'cogdoBarrelRoom-RewardCamera' track = Sequence(Func(base.camera.reparentTo, render), Func(base.camera.setPosHpr, self.model, 0, 0, 11.0, 0, -14, 0), Func(self.showBattleAreaLight, False), name=trackName) return (track, trackName) def showRewardUi(self, results, callback = None): track, trackName = self.__rewardCamera() if CogdoBarrelRoomConsts.ShowRewardUI: self.rewardUi.setRewards(results) self.rewardUi.unstash() taskMgr.doMethodLater(CogdoBarrelRoomConsts.RewardUiTime, self.__rewardUiTimeout, self.rewardUiTaskName, extraArgs=[callback]) return (track, trackName) def setRewardResults(self, results): self.rewardUi.setRewards(results) def hideRewardUi(self): self.rewardUi.stash() taskMgr.remove(self.rewardUiTaskName)
class Arena: def __init__(self, arenaNr): arenaPath = "levels/arena{}/".format(arenaNr) self.arena = loader.loadModel(arenaPath + "arena") self.arena.setScale(2) self.arena.reparentTo(render) self.arena.hide() 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, 2048, 2048) sun.setScene(render) #sun.showFrustum() self.ambientSound = None self.levelParticles = None if arenaNr == 1: sunLens.setNearFar(25, 45) sun.setLens(sunLens) self.sunNp = render.attachNewNode(sun) self.sunNp.setPos(-10, -10, 30) self.sunNp.lookAt(0, 0, 0) self.ambientSound = loader.loadSfx( "assets/audio/ambientLevel1.ogg") self.ambientSound.setLoop(True) self.fog = Fog("Outside Fog") self.fog.setColor(0.3, 0.3, 0.5) self.fog.setExpDensity(0.025) self.levelParticles = ParticleEffect() self.levelParticles.loadConfig("assets/fx/Leafs.ptf") self.levelParticles.start(parent=render2d, renderParent=render2d) elif arenaNr == 2: sunLens.setFov(120, 40) sunLens.setNearFar(2, 10) sun.setLens(sunLens) self.sunNp = render.attachNewNode(sun) self.sunNp.setPos(0, 0, 5) self.sunNp.lookAt(0, 0, 0) self.fog = Fog("Temple Fog") self.fog.setColor(0, 0, 0) self.fog.setExpDensity(0.065) def start(self): self.arena.show() render.setLight(self.alnp) render.setLight(self.sunNp) if self.ambientSound != None: self.ambientSound.play() render.setFog(self.fog) def stop(self): self.arena.hide() render.clearLight() if self.ambientSound != None: self.ambientSound.stop() render.clearFog() if self.levelParticles != None: self.levelParticles.cleanup() def getStartPos(self, charNr): if charNr == 1: return self.arena.find("**/StartPosA").getPos() * 2 elif charNr == 2: return self.arena.find("**/StartPosB").getPos() * 2 else: return (0, 0, 0)
class SpaceFlight(ShowBase): def __init__(self): ShowBase.__init__(self) self.text = OnscreenText \ ( parent = base.a2dBottomCenter, align=TextNode.ARight, fg=(1, 1, 1, 1), pos=(0.2, 1.), scale=0.1, shadow=(0, 0, 0, 0.5) ) self.setBackgroundColor(0, 0, 0) self.disableMouse() self.fog = Fog('distanceFog') self.fog.setColor(0, 0, 0) self.fog.setExpDensity(.002) # self.queue = CollisionHandlerQueue() self.trav = CollisionTraverser('traverser') base.cTrav = self.trav self.loadSky() self.reloadGame() self.keyMap = {'left' : 0, 'right' : 0, 'up' : 0, 'down' : 0} self.gamePause = False # self.accept('escape', sys.exit) self.accept('p', self.pause) self.accept('r', self.reloadGame) self.accept('arrow_left', self.setKey, ['left', True]) self.accept('arrow_right', self.setKey, ['right', True]) self.accept('arrow_up', self.setKey, ['up', True]) self.accept('arrow_down', self.setKey, ['down', 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, ['up', False]) self.accept('arrow_down-up', self.setKey, ['down', False]) # taskMgr.add(self.moveShip, 'moveShip') taskMgr.add(self.moveAsteroids, 'moveAsteroids') taskMgr.add(self.handleCollisions, 'handleCollisions') # if DEBUG: self.trav.showCollisions(render) render.find('**/ship_collision').show() for asteroid in render.findAllMatches('**/asteroid_collision*'): asteroid.show() def loadSky(self): self.sky = loader.loadModel('models/solar_sky_sphere.egg.pz') self.sky_tex = loader.loadTexture('models/stars_1k_tex.jpg') self.sky.setTexture(self.sky_tex, 1) self.sky.reparentTo(render) self.sky.setScale(500) def loadShip(self): self.ship = loader.loadModel('models/alice-scifi--fighter/fighter.egg') self.ship.reparentTo(render) self.ship.setPos(START_X, START_Y, START_Z) self.ship.setScale(0.25) # add some physics ship_col = self.ship.attachNewNode(CollisionNode('ship_collision')) col_sphere = CollisionSphere(START_X, START_Y, 0, SHIP_SPHERE_RADIUS) ship_col.node().addSolid(col_sphere) self.trav.addCollider(ship_col, self.queue) def spawnAsteroid(self): asteroid = loader.loadModel(choice(ASTEROID_SHAPES)) asteroid_tex = loader.loadTexture('models/rock03.jpg') asteroid.setTexture(asteroid_tex, 1) asteroid.reparentTo(render) asteroid.setFog(self.fog) self.asteroids.append(asteroid) self.asteroids_rotation.append(randint(ASTEROID_ROTATE_MIN, ASTEROID_ROTATE_MAX)) # num = len(self.asteroids) - 1 asteroid_col = asteroid.attachNewNode(CollisionNode('asteroid_collision_%d' % num)) col_sphere = CollisionSphere(0, 0, 0, ASTEROID_SPHERE_RADIUS) asteroid_col.node().addSolid(col_sphere) # asteroid.setX(randint(MIN_X, MAX_X)) asteroid.setY(randint(ASTEROID_SPAWN_MIN_Y, ASTEROID_SPAWN_MAX_Y)) asteroid.setZ(randint(MIN_Z, MAX_Z)) def setKey(self, key, value): self.keyMap[key] = value if key in ['left', 'right'] and value == False: self.ship.setH(0) if key in ['up', 'down'] and value == False: self.ship.setP(0) def updateCamera(self): x, y, z = self.ship.getPos() self.camera.setPos(x, y - 40, z + 25) self.camera.lookAt(x, y, z + 10) def moveAsteroids(self, task): dt = globalClock.getDt() if not self.gamePause: for num, asteroid in enumerate(self.asteroids): asteroid.setY(asteroid.getY() - ASTEROID_SPEED * dt) rotation = self.asteroids_rotation[num] asteroid.setH(asteroid.getH() - rotation * ASTEROID_SPEED * dt) if asteroid.getY() < self.camera.getY() + 10: asteroid.setX(randint(MIN_X, MAX_X)) asteroid.setY(randint(ASTEROID_SPAWN_MIN_Y, ASTEROID_SPAWN_MAX_Y)) asteroid.setZ(randint(MIN_Z, MAX_Z)) return task.cont def rollbackOnBoard(self, minPos, maxPos, getFunc, setFunc): if getFunc() < minPos: setFunc(minPos) if getFunc() > maxPos: setFunc(maxPos) def applyBound(self): self.rollbackOnBoard(MIN_X, MAX_X, self.ship.getX, self.ship.setX) self.rollbackOnBoard(MIN_Z, MAX_Z, self.ship.getZ, self.ship.setZ) def moveShip(self, task): dt = globalClock.getDt() if not self.gamePause: if self.keyMap['left']: self.ship.setX(self.ship.getX() - SHIP_SPEED * dt) self.ship.setH(TURN_SPEED) elif self.keyMap['right']: self.ship.setX(self.ship.getX() + SHIP_SPEED * dt) self.ship.setH(-TURN_SPEED) elif self.keyMap['up']: self.ship.setZ(self.ship.getZ() + SHIP_SPEED * dt) self.ship.setP(TURN_SPEED) elif self.keyMap['down']: self.ship.setZ(self.ship.getZ() - 5 * SHIP_SPEED * dt) self.ship.setP(-TURN_SPEED) self.sky.setP(self.sky.getP() - dt * 10) self.applyBound() self.updateCamera() return task.cont def handleCollisions(self, task): if not self.gamePause: for entry in self.queue.getEntries(): node = entry.getFromNodePath() if node.getName() == 'ship_collision': self.gamePause = True self.text.setText('You lose :(') return task.cont def pause(self): self.gamePause = not self.gamePause def reloadGame(self): self.gamePause = False self.text.clearText() if hasattr(self, 'asteroids'): for asteroid in self.asteroids: asteroid.removeNode() self.asteroids = [] self.asteroids_rotation = [] if hasattr(self, 'ship'): self.ship.removeNode() self.loadShip() for _ in xrange(ASTEROID_MAX_CNT): self.spawnAsteroid()
class Tunnel(ShowBase): def __init__(self): ShowBase.__init__(self) base.disableMouse() self.camera.setPosHpr(0, 0, 10, 0, -90, 0) self.setBackgroundColor(0, 0, 0) self.fog = Fog('distanceFog') self.fog.setColor(0, 0, 0) self.fog.setExpDensity(.08) render.setFog(self.fog) self.keyMap = {'left' : 0, 'right' : 0, 'up' : 0, 'down' : 0} # self.accept('escape', sys.exit) self.accept('arrow_left', self.setKey, ['left', True]) self.accept('arrow_right', self.setKey, ['right', True]) self.accept('arrow_up', self.setKey, ['up', True]) self.accept('arrow_down', self.setKey, ['down', 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, ['up', False]) self.accept('arrow_down-up', self.setKey, ['down', False]) self.queue = CollisionHandlerQueue() self.trav = CollisionTraverser('traverser') base.cTrav = self.trav # self.makeTunnel() self.makeSphere() self.continueTunnel() # self.crystals = [] for _ in xrange(CRYSTALS_CNT): self.makeRandomCrystal(randint(1, TUNNEL_CNT - 1)) self.collisionCnt = 0 # taskMgr.add(self.moveSphere, 'moveSphere') taskMgr.add(self.handleCollisions, 'handleCollisions') # if DEBUG: self.trav.showCollisions(render) render.find('**/sphere_collision').show() def makeTunnel(self): self.tunnel = [None] * TUNNEL_CNT for x in range(TUNNEL_CNT): self.tunnel[x] = loader.loadModel('models/tunnel') if x == 0: self.tunnel[x].reparentTo(render) else: self.tunnel[x].reparentTo(self.tunnel[x - 1]) self.tunnel[x].setPos(0, 0, -TUNNEL_SEGMENT_LENGTH) def makeSphere(self): self.sphere = loader.loadModel('models/alice-shapes--sphere-highpoly/sphere-highpoly.egg') self.sphere.reparentTo(render) self.sphere.setScale(0.07) self.sphere.setZ(2) # col_node = self.sphere.attachNewNode(CollisionNode('sphere_collision')) col_sphere = CollisionSphere(0, 0, 2, SPHERE_RADIUS) col_node.node().addSolid(col_sphere) self.trav.addCollider(col_node, self.queue) def makeRandomCrystal(self, tun): crystal = loader.loadModel('models/bvw-f2004--purplecrystal/purplecrystal.egg') crystal.reparentTo(self.tunnel[tun]) # pMin, pMax = LPoint3f(), LPoint3f() crystal.calcTightBounds(pMin, pMax) col_node = crystal.attachNewNode(CollisionNode('crystal_collision')) col_box = CollisionBox(pMin, pMax) col_node.node().addSolid(col_box) crystal.setScale(0.1) if DEBUG: col_node.show() pos = ['rx', '-rx', 'ry', 'down', 'up'] rnd = choice(pos) Z = randint(0, 10) if rnd == 'rx': R = randint(45, 90) X = uniform(-2, 6) crystal.setR(R) crystal.setX(X) elif rnd == '-rx': R = randint(45, 90) X = uniform(-2, 8) crystal.setR(-R) crystal.setX(-X) elif rnd == 'ry': R = randint(45, 120) Y = uniform(2, 6) crystal.setR(R) crystal.setY(Y) elif rnd == '-py': R = randint(45, 120) Y = uniform(3, 8) crystal.setR(-R) crystal.setY(-Y) elif rnd == 'down': Y = uniform(1, 6) P = randint(70, 120) crystal.setY(-Y) crystal.setP(P) elif rnd == 'up': Y = uniform(-1, 6) P = randint(-130, -60) crystal.setY(Y) crystal.setP(P) crystal.setZ(Z) self.crystals.append(crystal) def continueTunnel(self): self.tunnel = self.tunnel[1:] + self.tunnel[0:1] self.tunnel[0].setZ(0) self.tunnel[0].reparentTo(render) self.tunnel[0].setScale(.155, .155, .305) self.tunnel[3].reparentTo(self.tunnel[2]) self.tunnel[3].setZ(-TUNNEL_SEGMENT_LENGTH) self.tunnel[3].setScale(1) for child in self.tunnel[3].getChildren(): if child.getName() == 'purplecrystal.egg': self.crystals.remove(child) child.removeNode() self.makeRandomCrystal(3) self.tunnelMove = Sequence \ ( LerpFunc \ ( self.tunnel[0].setZ, duration=TUNNEL_TIME, fromData=0, toData=TUNNEL_SEGMENT_LENGTH * .305 ), Func(self.continueTunnel) ) self.tunnelMove.start() def setKey(self, key, value): self.keyMap[key] = value def moveSphere(self, task): dt = globalClock.getDt() addVec = LVector3f(0, 0, 0) if self.keyMap['left']: addVec[0] -= SPHERE_SPEED * dt elif self.keyMap['right']: addVec[0] += SPHERE_SPEED * dt elif self.keyMap['up']: addVec[1] += SPHERE_SPEED * dt elif self.keyMap['down']: addVec[1] -= SPHERE_SPEED * dt if ((self.sphere.getPos() + addVec) - LPoint3f(TUNNEL_CENTER)).length() < TUNNEL_RADIUS: self.sphere.setPos(self.sphere.getPos() + addVec) return task.cont def handleCollisions(self, task): for entry in self.queue.getEntries(): node = entry.getFromNodePath() if node.getName() == 'sphere_collision': self.collisionCnt += 1 print 'Oops! Collision counter: %d' % self.collisionCnt return task.cont
class CharSelection: notify = directNotify.newCategory('CharSelection') STAGE_TOON_POS = (66.4, 74.47, -25) STAGE_TOON_HPR = (227.73, 0, 0) NO_TOON = 'Empty Slot' PLAY = 'Play' CREATE = 'Create' TITLE = 'Pick A Toon To Play' def __init__(self, avChooser): self.avChooser = avChooser self.choice = None self.charList = None self.charNameLabel = None self.charButtons = [] self.playOrCreateButton = None self.deleteButton = None self.quitButton = None self.world = None self.sky = None self.fog = None self.title = None self.stageToon = None self.selectionFSM = ClassicFSM.ClassicFSM('CharSelection', [State.State('off', self.enterOff, self.exitOff), State.State('character', self.enterCharSelected, self.exitCharSelected), State.State('empty', self.enterEmptySelected, self.exitEmptySelected)], 'off', 'off') self.selectionFSM.enterInitialState() return def __setupStageToon(self): self.stageToon = Toon(base.cr) self.stageToon.setPos(self.STAGE_TOON_POS) self.stageToon.setHpr(self.STAGE_TOON_HPR) def cleanupStageToon(self): if self.stageToon != None: self.stageToon.disable() self.stageToon.delete() self.stageToon = None return def enterOff(self): pass def exitOff(self): pass def enterCharSelected(self, slot): self.choice = self.avChooser.getAvChoiceBySlot(slot) dna = self.choice.dna name = self.choice.name self.stageToon.setName(name) self.stageToon.setDNAStrand(dna) self.stageToon.nameTag.setColorLocal() self.stageToon.animFSM.request('neutral') self.stageToon.reparentTo(base.render) self.charNameLabel.setText(name) self.playOrCreateButton['text'] = self.PLAY self.playOrCreateButton['extraArgs'] = ['play'] self.playOrCreateButton.show() self.deleteButton.show() def exitCharSelected(self): self.stageToon.animFSM.requestFinalState() self.stageToon.deleteCurrentToon() self.stageToon.reparentTo(base.hidden) self.playOrCreateButton.hide() self.deleteButton.hide() self.choice = None return def enterEmptySelected(self): self.charNameLabel.setText(self.NO_TOON) self.playOrCreateButton['text'] = self.CREATE self.playOrCreateButton['extraArgs'] = ['create'] self.playOrCreateButton.show() def exitEmptySelected(self): self.playOrCreateButton.hide() def __action(self, action): for btn in self.charButtons: if btn['state'] == DGG.DISABLED: self.slot = btn.getPythonTag('slot') break func = None arg = None if action == 'delete': func = self.deleteToon arg = self.choice.avId elif action == 'play': func = self.playGame arg = self.choice.slot elif action == 'create': func = self.enterMAT elif action == 'quit': func = sys.exit base.transitions.fadeOut(0.3) if arg != None: Sequence(Wait(0.31), Func(func, arg)).start() else: Sequence(Wait(0.31), Func(func)).start() return def playGame(self, slot): messenger.send('avChooseDone', [self.avChooser.getAvChoiceBySlot(slot)]) def enterMAT(self): messenger.send('enterMakeAToon', [self.slot]) def deleteToon(self, avId): self.avChooser.avChooseFSM.request('waitForToonDelResponse', [avId]) def __handleCharButton(self, slot): for btn in self.charButtons: if btn.getPythonTag('slot') == slot: btn['state'] = DGG.DISABLED else: btn['state'] = DGG.NORMAL if self.avChooser.hasToonInSlot(slot): self.selectionFSM.request('character', [slot]) else: self.selectionFSM.request('empty') def load(self): base.cr.renderFrame() base.camLens.setMinFov(CIGlobals.DefaultCameraFov / (4.0 / 3.0)) self.__setupStageToon() self.world = loader.loadModel('phase_9/models/cogHQ/SellbotHQExterior.bam') self.world.reparentTo(base.render) self.world.setPos(0, 227.09, -25.36) self.sky = loader.loadModel('phase_9/models/cogHQ/cog_sky.bam') self.sky.setScale(1) self.sky.reparentTo(base.render) self.sky.find('**/InnerGroup').removeNode() self.fog = Fog('charSelectFog') self.fog.setColor(0.2, 0.2, 0.2) self.fog.setExpDensity(0.003) base.render.setFog(self.fog) self.title = DirectLabel(text=self.TITLE, text_font=CIGlobals.getMickeyFont(), text_fg=(1, 0.9, 0.1, 1), relief=None, text_scale=0.13, pos=(0, 0, 0.82)) self.charNameLabel = OnscreenText(text='', font=CIGlobals.getMickeyFont(), pos=(-0.25, 0.5, 0), fg=(1, 0.9, 0.1, 1.0)) self.charNameLabel.hide() self.playOrCreateButton = DirectButton(text='', pos=(0.8125, 0, -0.735), command=self.__action, geom=CIGlobals.getDefaultBtnGeom(), text_scale=0.06, relief=None, text_pos=(0, -0.01)) self.playOrCreateButton.hide() self.deleteButton = DirectButton(text='Delete', pos=(0.8125, 0, -0.835), command=self.__action, extraArgs=['delete'], geom=CIGlobals.getDefaultBtnGeom(), text_scale=0.06, relief=None, text_pos=(0, -0.01)) self.deleteButton.hide() self.quitButton = DirectButton(text='Quit', pos=(-1.1, 0, -0.925), command=self.__action, extraArgs=['quit'], text_scale=0.06, geom=CIGlobals.getDefaultBtnGeom(), relief=None, text_pos=(0, -0.01)) textRolloverColor = Vec4(1, 1, 0, 1) textDownColor = Vec4(0.5, 0.9, 1, 1) textDisabledColor = Vec4(0.4, 0.8, 0.4, 1) for slot in range(6): if self.avChooser.hasToonInSlot(slot): choice = self.avChooser.getAvChoiceBySlot(slot) text = choice.name else: text = self.NO_TOON btn = DirectButton(relief=None, text=text, text_scale=0.06, text_align=TextNode.ALeft, text1_bg=textDownColor, text2_bg=textRolloverColor, text3_fg=textDisabledColor, textMayChange=0, command=self.__handleCharButton, extraArgs=[slot], text_pos=(0, 0, 0.0)) btn.setPythonTag('slot', slot) self.charButtons.append(btn) btn['state'] = DGG.NORMAL gui = loader.loadModel('phase_3.5/models/gui/friendslist_gui.bam') listXorigin = -0.02 listFrameSizeX = 0.625 listZorigin = -0.96 listFrameSizeZ = 1.04 arrowButtonScale = 1.3 itemFrameXorigin = -0.237 itemFrameZorigin = 0.365 buttonXstart = itemFrameXorigin + 0.293 self.charList = DirectScrolledList(relief=None, pos=(0.75, 0, 0.08), incButton_image=(gui.find('**/FndsLst_ScrollUp'), gui.find('**/FndsLst_ScrollDN'), gui.find('**/FndsLst_ScrollUp_Rllvr'), gui.find('**/FndsLst_ScrollUp')), incButton_relief=None, incButton_scale=(arrowButtonScale, arrowButtonScale, -arrowButtonScale), incButton_pos=(buttonXstart, 0, itemFrameZorigin - 0.999), incButton_image3_color=Vec4(1, 1, 1, 0.2), decButton_image=(gui.find('**/FndsLst_ScrollUp'), gui.find('**/FndsLst_ScrollDN'), gui.find('**/FndsLst_ScrollUp_Rllvr'), gui.find('**/FndsLst_ScrollUp')), decButton_relief=None, decButton_scale=(arrowButtonScale, arrowButtonScale, arrowButtonScale), decButton_pos=(buttonXstart, 0, itemFrameZorigin + 0.125), decButton_image3_color=Vec4(1, 1, 1, 0.2), itemFrame_pos=(itemFrameXorigin, 0, itemFrameZorigin), itemFrame_scale=1.0, itemFrame_relief=DGG.SUNKEN, itemFrame_frameSize=(listXorigin, listXorigin + listFrameSizeX, listZorigin, listZorigin + listFrameSizeZ), itemFrame_frameColor=(0.85, 0.95, 1, 1), itemFrame_borderWidth=(0.01, 0.01), numItemsVisible=15, forceHeight=0.075, items=self.charButtons) base.camera.setPos(75.12, 63.22, -23) base.camera.setHpr(26.57, 9.62, 0) return def unload(self): self.selectionFSM.requestFinalState() self.cleanupStageToon() self.choice = None if self.charButtons: for btn in self.charButtons: btn.destroy() self.charButtons = None if self.charList: self.charList.destroy() self.charList = None if self.charNameLabel: self.charNameLabel.destroy() self.charNameLabel = None if self.playOrCreateButton: self.playOrCreateButton.destroy() self.playOrCreateButton = None if self.deleteButton: self.deleteButton.destroy() self.deleteButton = None if self.quitButton: self.quitButton.destroy() self.quitButton = None if self.sky: self.sky.removeNode() self.sky = None if self.world: self.world.removeNode() self.world = None if self.title: self.title.destroy() self.title = None base.render.clearFog() self.fog = None base.camera.setPos(0, 0, 0) base.camera.setHpr(0, 0, 0) base.transitions.noTransitions() del self.selectionFSM return
def init_nodepath(self): # Load the environment model. self.environ = loader.loadModel("models/env03") # water self.water = loader.loadModel('models/square') self.water.setSx(400*2) self.water.setSy(400*2) self.water.setPos(0, 80, -1) # sea level self.water.setTransparency(TransparencyAttrib.MAlpha) newTS = TextureStage('1') self.water.setTexture(newTS, loader.loadTexture('models/water.png')) self.water.setTexScale(newTS, 4) self.water.reparentTo(render) LerpTexOffsetInterval(self.water, 50, (1, 0), (0, 0), textureStage=newTS).loop() # Our sky self.skysphere = loader.loadModel('models/blue-sky-sphere') self.skysphere.setEffect(CompassEffect.make(render)) self.skysphere.setScale(0.05) # NOT render or you'll fly through the sky!: self.skysphere.reparentTo(base.camera) # Reparent the model to render. self.environ.reparentTo(render) # Apply scale and position transforms on the model. self.environ.setScale(1, 1, 1) self.environ.setPos(37, 48, 0) self.environ.setHpr(270, 0, 0) self.environ.setTwoSided(True) # fog colour = (0.1, 0.1, 0.1) expfog = Fog("scene-wide-fog") expfog.setColor(*colour) expfog.setExpDensity(0.01) render.setFog(expfog) # Set Rain Boundaries mapCollision = CollisionNode('mapcnode') mapCollision.setTag('INTO', 'map') self.pt1, self.pt2 = self.environ.getTightBounds() self.deltaX = self.pt2.x - self.pt1.x self.deltaY = self.pt2.y - self.pt1.y self.deltaZ = 1000 # Set up rain effect initialization self.spawnEveryXSeconds = .001 self.spawnXDrops = 4 self.dropDuration = .2 self.percentChanceOfImpactCircle = .8 self.percentChanceOfImpactFog = .5 self.percentChanceOfDoubleDrop = .8 self.percentChanceOfTripleDrop = .2 # base.setBackgroundColor(*colour) self.nodePath = render.attachNewNode('World') self.init_lights() self.init_camera() self.terrain.init_nodepath() for team in self.teams: for character in team.characters: character.init_nodepath() # create rain taskMgr.doMethodLater(0, self.makeItRain, 'make-it-rain')
class Level(): def __init__(self, player): self.player = player loader.loadModel("skybox/Skybox", callback=self.skyBoxDone) # Visual model "Ground" loader.loadModel("forest/Forest", callback=self.levelDone) def skyBoxDone(self, model): self.skybox = model self.skybox.setScale(0.8) self.skybox.setPos(0, 0, 0.5) self.skybox.setDepthTest(False) self.skybox.setAttrib(CullBinAttrib.make("skyboxBin", 1000)) self.skybox.reparentTo(camera) taskMgr.add(self.skyboxTask, "forestsky") def levelDone(self, model): self.level = model self.level.hide() self.level.reparentTo(render) self.level.setPos(0, 0, -2) # lights for this world directLight = DirectionalLight("directLight") directLightNP = self.level.attachNewNode(directLight) directLightNP.setHpr(0, -60, 0) render.setLight(directLightNP) ambientLight = AmbientLight("ambientLight") ambientLight.setColor(VBase4(0.2, 0.2, 0.2, 1)) ambientLightNP = self.level.attachNewNode(ambientLight) render.setLight(ambientLightNP) # spawn NPCs self.numNPCs = 15 self.npcList = [] for i in range(self.numNPCs): npc = Actor( "character/character", {"Idle": "character/character-Idle"}) npc.setBlend(frameBlend=True) npc.setScale(random.uniform(0.4, 1.0)) npc.loop("Idle") point = self.level.find("**/NPC.%03d"%i) npc.reparentTo(point) self.npcList.append(npc) # # Fix alpha problems # alphaSettings = ColorBlendAttrib.make( ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne, (0, 0, 0, 0)) for np in self.level.findAllMatches("**/Godray*"): np.setAttrib(alphaSettings) np.setBin("fixed", 10) np.setDepthWrite(False) water = self.level.find("**/Water") water.setAttrib(alphaSettings) water.setBin("fixed", 11) water.setDepthWrite(False) # Extra Collision solids loader.loadModel("forest/Bridge1", callback=self.bridge1Done) loader.loadModel("forest/Bridge2", callback=self.bridge2Done) loader.loadModel("forest/Bridge3", callback=self.bridge3Done) loader.loadModel("forest/Bridge4", callback=self.bridge4Done) loader.loadModel("forest/Plant1", callback=self.plant1Done) loader.loadModel("forest/Plant2", callback=self.plant2Done) # some light green fog self.fog = Fog("Forest Fog") self.fog.setColor(0.0, 0.9, 0.7) self.fog.setExpDensity(0.01) render.setFog(self.fog) ## Seeds ## self.numSeedPositions = 20 self.tutorialSeed = None self.spawnedSeeds = {} self.spawnSeeds(15) base.messenger.send("LevelLoaded") def bridge1Done(self, model): self.bridge1 = model def bridge2Done(self, model): self.bridge2 = model def bridge3Done(self, model): self.bridge3 = model def bridge4Done(self, model): self.bridge4 = model def plant1Done(self, model): self.plant1 = model def plant2Done(self, model): self.plant2 = model def stop(self): self.clearSeeds() self.level.clearLight() self.level.removeNode() render.clearLight() render.clearFog() taskMgr.remove("forestsky") self.skybox.removeNode() for npc in self.npcList: npc.cleanup() npc.removeNode() self.npcList = None def show(self): self.level.show() def hide(self): self.level.hide() def clearSeeds(self): for seed in self.spawnedSeeds.values(): seed.Destroy() self.tutorialSeed.Destroy() self.seedSpawnPositions = [] self.spawnedSeeds = {} def getStartPoint(self): startPosNode = self.level.find("**/StartPos") if startPosNode: return startPosNode return None def getEndPoint(self): endPosNode = self.level.find("**/EndPos") if endPosNode: return endPosNode return None def skyboxTask(self, task): self.skybox.setHpr(render, 0, 0, 0) return task.cont def spawnSeeds(self, numOfSeeds): self.seedSpawnPositions = self.getSeedSpawnPoints() self.usedPositions = [] for idx in range(numOfSeeds): if idx == 0: spawnPos = self.seedSpawnPositions[0] self.spawnedSeeds[spawnPos.getName()] = Seed() self.spawnedSeeds[spawnPos.getName()].OnSpawn(spawnPos)#.getPos(), self.level) self.tutorialSeed = self.spawnedSeeds[spawnPos.getName()] else: randPos = random.randint(1, len(self.seedSpawnPositions)-1) if randPos in self.usedPositions: while randPos in self.usedPositions: randPos = random.randint(1, len(self.seedSpawnPositions)-1) self.usedPositions.append(randPos) spawnPos = self.seedSpawnPositions[randPos] self.spawnedSeeds[spawnPos.getName()] = Seed() self.spawnedSeeds[spawnPos.getName()].OnSpawn(spawnPos)#.getPos(), self.level) def getSeedSpawnPoints(self): points = [] for idx in range(self.numSeedPositions): points.append(self.level.find("**/SeedPos.%03d"%idx)) return points def doPickupSeed(self, args): if self.player.carry_seed == True: return self.player.carry_seed = True seedName = args.getIntoNode().getName() for seed in self.spawnedSeeds: cid = "seedSphere-" + self.spawnedSeeds[seed].id if cid == seedName: # and self.spawnedSeeds[seed].seedState == 0: self.spawnedSeeds[seed].DoPickup(self.player) def doPlantSeed(self, plantGround): if self.player.carry_seed == False: return self.player.carry_seed = False for seed in self.spawnedSeeds: if self.spawnedSeeds[seed].seedState == 1: self.spawnedSeeds[seed].DoPlantSeed(plantGround.getIntoNodePath().getParent()) playerPlantPoint = plantGround.getIntoNodePath().getParent().find("**/PlayerPlantingPos") self.player.setStartHpr(playerPlantPoint.getHpr(render)) self.player.setStartPos(playerPlantPoint.getPos(render)) plantGroundNP = plantGround.getIntoNodePath().getParent().getParent() plantGroundName = plantGroundNP.getName() base.cTrav.removeCollider(plantGround.getIntoNodePath()) if plantGroundName == "PlantGround.000": #Bridge 1 def buildBridge1(task): plantGroundNP.removeNode() self.bridge1.reparentTo(self.level) base.messenger.send("Bridge1_Built") base.messenger.send("addPoints", [200]) base.messenger.send("drawPlayerWater", [10]) taskMgr.doMethodLater(3.0, buildBridge1, "Build 1st Bridge") elif plantGroundName == "PlantGround.001": #Bridge 2 def buildBridge2(task): plantGroundNP.removeNode() self.bridge2.reparentTo(self.level) base.messenger.send("addPoints", [300]) base.messenger.send("drawPlayerWater", [10]) taskMgr.doMethodLater(3.0, buildBridge2, "Build 2nd Bridge") elif plantGroundName == "PlantGround.002": #Bridge 3 def buildBridge3(task): plantGroundNP.removeNode() self.bridge3.reparentTo(self.level) base.messenger.send("addPoints", [400]) base.messenger.send("drawPlayerWater", [15]) taskMgr.doMethodLater(3.0, buildBridge3, "Build 3rd Bridge") elif plantGroundName == "PlantGround.003": #Bridge 4 def buildBridge4(task): plantGroundNP.removeNode() self.bridge4.reparentTo(self.level) base.messenger.send("addPoints", [500]) base.messenger.send("drawPlayerWater", [20]) taskMgr.doMethodLater(3.0, buildBridge4, "Build 4th Bridge") else: def growPlant(task): if random.choice([True, False]): self.plant1.setPos(plantGroundNP.getPos(render)) self.plant1.setZ(self.plant1, 2) self.plant1.setH(random.uniform(0.0, 360.0)) self.plant1.copyTo(self.level) else: self.plant2.setPos(plantGroundNP.getPos(render)) self.plant2.setZ(self.plant2, 2) self.plant2.setH(random.uniform(0.0, 360.0)) self.plant2.copyTo(self.level) plantGroundNP.removeNode() base.messenger.send("addPoints", [100]) base.messenger.send("drawPlayerWater", [5]) taskMgr.doMethodLater(5, growPlant, "Grow normal plant") plantGround.getIntoNodePath().removeNode() break
def __init__(self): ShowBase.__init__(self) wp = WindowProperties() wp.setSize(1024, 768) base.win.requestProperties(wp) #Environment self.setBackgroundColor(0.3,0.3,1,1) # blue sky fog = Fog("fog") fog.setColor(0.75,0.75,0.75) fog.setExpDensity(0.016) self.render.setFog(fog) # Controls self.add_move_key("w", lambda: self.move(y=1)) self.add_move_key("a", lambda: self.move(x=-1)) self.add_move_key("d", lambda: self.move(x=1)) self.add_move_key("s", lambda: self.move(y=-1)) # Camera self.disableMouse() self.camera.setPos(12.6694, 16.5869, 2.23608) self.camera.setHpr(-5.44159, 7.59898, -0.084791) self.taskMgr.add(self.handleMouse, 'mouseStuff') self.taskMgr.add(self.rotateBuildingColors, 'buildingColors') self.cube = loader.loadModel(path_of_local_file("models/cube/cube.egg")) self.cube.setScale(0.3,0.3,0.3) # Floor floor_plane = self.cube.copyTo(self.render) floor_plane.setScale(100,100,1) floor_plane.setColor(0.1,0.75,0.1,1) # Buildings self.buildings = [] for start_x in range(0,100,20): for start_y in range(0,100,25): height = random.randrange(5,25) color = (random.uniform(0,1),random.uniform(0,1),random.uniform(0,1)) building = self.render.attachNewNode("building") for y in range(0,10): # west wall for z in range(1,height): self.add_cube(start_x, start_y + y, z,parent=building) for y in range(0,10): # east wall for z in range(1,height): self.add_cube(start_x + 10, start_y + y, z, parent=building) for x in range(0,11): # north wall for z in range(1,height): self.add_cube(start_x + x, start_y + 10, z, parent=building) for x in range(0,11): # south wall for z in range(1,height): self.add_cube(start_x + x, start_y, z, parent=building) for c in building.getChildren(): gray = random.uniform(0.1,0.4) c.setColor(color[0] - gray,color[1] - gray,color[2] - gray,1) self.buildings.append(building) # Trees self.tree_model = loader.loadModel(path_of_local_file("models/plants6/plants6.egg")) self.tree_model.setScale(0.25,0.25,0.25) for x in range(15,100,20): for y in range (15,100,20): tree = self.tree_model.copyTo(self.render) tree.setPos(x,y,0) # Roads for y in range(15, 100, 20): road = self.cube.copyTo(self.render) road.setScale(10,100,0.1) road.setPos(0,y,0.1)
def __init__(self): ShowBase.__init__(self) #Setup scene = BulletWorld() scene.setGravity(Vec3(0, 0, -9.81)) base.setBackgroundColor(0.6,0.9,0.9) fog = Fog("The Fog") fog.setColor(0.9,0.9,1.0) fog.setExpDensity(0.003) render.setFog(fog) #Lighting #Sun light sun = DirectionalLight("The Sun") sun_np = render.attachNewNode(sun) sun_np.setHpr(0,-60,0) render.setLight(sun_np) #Ambient light amb = AmbientLight("The Ambient Light") amb.setColor(VBase4(0.39,0.39,0.39, 1)) amb_np = render.attachNewNode(amb) render.setLight(amb_np) #Variables self.gear = 0 self.start = 0 self.Pbrake = 0 self.terrain_var = 1 self.time = 0 self.headlight_var = 0 self.RPM = 0 self.clutch = 0 self.carmaxspeed = 100 #KPH self.carmaxreversespeed = -40 #KPH self.steering = 0 #Functions def V1(): camera.setPos(0.25,-1.2,0.5) camera.setHpr(0,-13,0) def V2(): camera.setPos(0,-15,3) camera.setHpr(0,-10,0) def V3(): camera.setPos(0,0,9) camera.setHpr(0,-90,0) def up(): self.gear = self.gear -1 if self.gear < -1: self.gear = -1 def down(): self.gear = self.gear +1 if self.gear > 1: self.gear = 1 def start_function(): self.start = 1 self.start_sound.play() self.engine_idle_sound.play() self.RPM = 1000 def stop_function(): self.start = 0 self.engine_idle_sound.stop() def parkingbrake(): self.Pbrake = (self.Pbrake + 1) % 2 def rotate(): Car_np.setHpr(0, 0, 0) def horn(): self.horn_sound.play() def set_time(): if self.time == -1: sun.setColor(VBase4(0.4, 0.3, 0.3, 1)) base.setBackgroundColor(0.8,0.7,0.7) if self.time == 0: sun.setColor(VBase4(0.7, 0.7, 0.7, 1)) base.setBackgroundColor(0.6,0.9,0.9) if self.time == 1: sun.setColor(VBase4(0.2, 0.2, 0.2, 1)) base.setBackgroundColor(0.55,0.5,0.5) if self.time == 2: sun.setColor(VBase4(0.02, 0.02, 0.05, 1)) base.setBackgroundColor(0.3,0.3,0.3) if self.time == -2: self.time = -1 if self.time == 3: self.time = 2 def time_forward(): self.time = self.time + 1 def time_backward(): self.time = self.time -1 def set_terrain(): if self.terrain_var == 1: self.ground_model.setTexture(self.ground_tex, 1) self.ground_model.setScale(3) if self.terrain_var == 2: self.ground_model.setTexture(self.ground_tex2, 1) self.ground_model.setScale(3) if self.terrain_var == 3: self.ground_model.setTexture(self.ground_tex3, 1) self.ground_model.setScale(4) if self.terrain_var == 4: self.terrain_var = 1 if self.terrain_var == 0: self.terrain_var = 3 def next_terrain(): self.terrain_var = self.terrain_var + 1 def previous_terrain(): self.terrain_var = self.terrain_var - 1 def show_menu(): self.menu_win.show() self.a1.show() self.a2.show() self.a3.show() self.a4.show() self.t1.show() self.t2.show() self.ok.show() self.exit_button.show() def hide_menu(): self.menu_win.hide() self.a1.hide() self.a2.hide() self.a3.hide() self.a4.hide() self.ok.hide() self.t1.hide() self.t2.hide() self.exit_button.hide() def Menu(): self.menu_win = OnscreenImage(image = "Textures/menu.png", pos = (0.9,0,0), scale = (0.5)) self.menu_win.setTransparency(TransparencyAttrib.MAlpha) #The Arrow Buttons self.a1 = DirectButton(text = "<", scale = 0.2, pos = (0.55,0,0.25), command = previous_terrain) self.a2 = DirectButton(text = ">", scale = 0.2, pos = (1.15,0,0.25), command = next_terrain) self.a3 = DirectButton(text = "<", scale = 0.2, pos = (0.55,0,0.0), command = time_backward) self.a4 = DirectButton(text = ">", scale = 0.2, pos = (1.15,0,0.0), command = time_forward) #The Text self.t1 = OnscreenText(text = "Terrain", pos = (0.85,0.25,0), scale = 0.1, fg = (0.4,0.4,0.5,1)) self.t2 = OnscreenText(text = "Time", pos = (0.85,0,0), scale = 0.1, fg = (0.4,0.4,0.5,1)) #The Buttons self.ok = DirectButton(text = "Okay", scale = 0.11, pos = (0.87,0,-0.25), command = hide_menu) self.exit_button = DirectButton(text = "Quit", scale = 0.11, pos = (0.87,0,-0.42), command = sys.exit) Menu() def take_screenshot(): base.screenshot("Screenshot") def set_headlights(): if self.headlight_var == 1: Headlight1.setColor(VBase4(9.0,8.9,8.9,1)) Headlight2.setColor(VBase4(9.0,8.9,8.9,1)) if self.headlight_var == 0: Headlight1.setColor(VBase4(0,0,0,1)) Headlight2.setColor(VBase4(0,0,0,1)) def headlights(): self.headlight_var = (self.headlight_var + 1) % 2 def update_rpm(): #Simulate RPM if self.start == 1: if self.gear == 0: self.RPM = self.RPM - self.RPM / 400 else: self.RPM = self.RPM + self.carspeed / 9 self.RPM = self.RPM - self.RPM / 200 #Reset RPM to 0 when engine is off if self.start == 0: if self.RPM > 0.0: self.RPM = self.RPM - 40 if self.RPM < 10: self.RPM = 0.0 #Idle RPM power if self.start == 1: if self.RPM < 650: self.RPM = self.RPM + 4 if self.RPM < 600: self.clutch = 1 else: self.clutch = 0 #RPM limit if self.RPM > 6000: self.RPM = 6000 #Controls inputState.watchWithModifiers("F", "arrow_up") inputState.watchWithModifiers("B", "arrow_down") inputState.watchWithModifiers("L", "arrow_left") inputState.watchWithModifiers("R", "arrow_right") do = DirectObject() do.accept("escape", show_menu) do.accept("1", V1) do.accept("2", V2) do.accept("3", V3) do.accept("page_up", up) do.accept("page_down", down) do.accept("x-repeat", start_function) do.accept("x", stop_function) do.accept("p", parkingbrake) do.accept("backspace", rotate) do.accept("enter", horn) do.accept("f12", take_screenshot) do.accept("h", headlights) #The ground self.ground = BulletPlaneShape(Vec3(0, 0, 1,), 1) self.ground_node = BulletRigidBodyNode("The ground") self.ground_node.addShape(self.ground) self.ground_np = render.attachNewNode(self.ground_node) self.ground_np.setPos(0, 0, -2) scene.attachRigidBody(self.ground_node) self.ground_model = loader.loadModel("Models/plane.egg") self.ground_model.reparentTo(render) self.ground_model.setPos(0,0,-1) self.ground_model.setScale(3) self.ground_tex = loader.loadTexture("Textures/ground.png") self.ground_tex2 = loader.loadTexture("Textures/ground2.png") self.ground_tex3 = loader.loadTexture("Textures/ground3.png") self.ground_model.setTexture(self.ground_tex, 1) #The car Car_shape = BulletBoxShape(Vec3(1, 2.0, 1.0)) Car_node = BulletRigidBodyNode("The Car") Car_node.setMass(1200.0) Car_node.addShape(Car_shape) Car_np = render.attachNewNode(Car_node) Car_np.setPos(0,0,3) Car_np.setHpr(0,0,0) Car_np.node().setDeactivationEnabled(False) scene.attachRigidBody(Car_node) Car_model = loader.loadModel("Models/Car.egg") Car_model.reparentTo(Car_np) Car_tex = loader.loadTexture("Textures/Car1.png") Car_model.setTexture(Car_tex, 1) self.Car_sim = BulletVehicle(scene, Car_np.node()) self.Car_sim.setCoordinateSystem(ZUp) scene.attachVehicle(self.Car_sim) #The inside of the car Car_int = loader.loadModel("Models/inside.egg") Car_int.reparentTo(Car_np) Car_int_tex = loader.loadTexture("Textures/inside.png") Car_int.setTexture(Car_int_tex, 1) Car_int.setTransparency(TransparencyAttrib.MAlpha) #The steering wheel Sw = loader.loadModel("Models/Steering wheel.egg") Sw.reparentTo(Car_np) Sw.setPos(0.25,0,-0.025) #The first headlight Headlight1 = Spotlight("Headlight1") lens = PerspectiveLens() lens.setFov(180) Headlight1.setLens(lens) Headlight1np = render.attachNewNode(Headlight1) Headlight1np.reparentTo(Car_np) Headlight1np.setPos(-0.8,2.5,-0.5) Headlight1np.setP(-15) render.setLight(Headlight1np) #The second headlight Headlight2 = Spotlight("Headlight2") Headlight2.setLens(lens) Headlight2np = render.attachNewNode(Headlight2) Headlight2np.reparentTo(Car_np) Headlight2np.setPos(0.8,2.5,-0.5) Headlight2np.setP(-15) render.setLight(Headlight2np) #Sounds self.horn_sound = loader.loadSfx("Sounds/horn.ogg") self.start_sound = loader.loadSfx("Sounds/enginestart.ogg") self.engine_idle_sound = loader.loadSfx("Sounds/engineidle.ogg") self.engine_idle_sound.setLoop(True) self.accelerate_sound = loader.loadSfx("Sounds/enginethrottle.ogg") #Camera base.disableMouse() camera.reparentTo(Car_np) camera.setPos(0,-15,3) camera.setHpr(0,-10,0) #Wheel function def Wheel(pos, np, r, f): w = self.Car_sim.createWheel() w.setNode(np.node()) w.setChassisConnectionPointCs(pos) w.setFrontWheel(f) w.setWheelDirectionCs(Vec3(0, 0, -1)) w.setWheelAxleCs(Vec3(1, 0, 0)) w.setWheelRadius(r) w.setMaxSuspensionTravelCm(40) w.setSuspensionStiffness(120) w.setWheelsDampingRelaxation(2.3) w.setWheelsDampingCompression(4.4) w.setFrictionSlip(50) w.setRollInfluence(0.1) #Wheels w1_np = loader.loadModel("Models/Lwheel") w1_np.reparentTo(render) w1_np.setColorScale(0,6) Wheel(Point3(-1,1,-0.6), w1_np, 0.4, False) w2_np = loader.loadModel("Models/Rwheel") w2_np.reparentTo(render) w2_np.setColorScale(0,6) Wheel(Point3(-1.1,-1.2,-0.6), w2_np, 0.4, True) w3_np = loader.loadModel("Models/Lwheel") w3_np.reparentTo(render) w3_np.setColorScale(0,6) Wheel(Point3(1.1,-1,-0.6), w3_np, 0.4, True) w4_np = loader.loadModel("Models/Rwheel") w4_np.reparentTo(render) w4_np.setColorScale(0,6) Wheel(Point3(1,1,-0.6), w4_np, 0.4, False) #The engine and steering def processInput(dt): #Vehicle properties self.steeringClamp = 35.0 self.steeringIncrement = 70 engineForce = 0.0 brakeForce = 0.0 #Get the vehicle's current speed self.carspeed = self.Car_sim.getCurrentSpeedKmHour() #Engage clutch when in gear 0 if self.gear == 0: self.clutch = 1 #Slow the steering when at higher speeds self.steeringIncrement = self.steeringIncrement - self.carspeed / 1.5 #Reset the steering if not inputState.isSet("L") and not inputState.isSet("R"): if self.steering < 0.00: self.steering = self.steering + 0.6 if self.steering > 0.00: self.steering = self.steering - 0.6 if self.steering < 1.0 and self.steering > -1.0: self.steering = 0 #Slow the car down while it's moving if self.clutch == 0: brakeForce = brakeForce + self.carspeed / 5 else: brakeForce = brakeForce + self.carspeed / 15 #Forward if self.start == 1: if inputState.isSet("F"): self.RPM = self.RPM + 35 self.accelerate_sound.play() if self.clutch == 0: if self.gear == -1: if self.carspeed > self.carmaxreversespeed: engineForce = -self.RPM / 3 if self.gear == 1: if self.carspeed < self.carmaxspeed: engineForce = self.RPM / 1 #Brake if inputState.isSet("B"): engineForce = 0.0 brakeForce = 12.0 if self.gear != 0 and self.clutch == 0: self.RPM = self.RPM - 20 #Left if inputState.isSet("L"): if self.steering < 0.0: #This makes the steering reset at the correct speed when turning from right to left self.steering += dt * self.steeringIncrement + 0.6 self.steering = min(self.steering, self.steeringClamp) else: #Normal steering self.steering += dt * self.steeringIncrement self.steering = min(self.steering, self.steeringClamp) #Right if inputState.isSet("R"): if self.steering > 0.0: #This makes the steering reset at the correct speed when turning from left to right self.steering -= dt * self.steeringIncrement + 0.6 self.steering = max(self.steering, -self.steeringClamp) else: #Normal steering self.steering -= dt * self.steeringIncrement self.steering = max(self.steering, -self.steeringClamp) #Park if self.Pbrake == 1: brakeForce = 10.0 if self.gear != 0 and self. clutch == 0: self.RPM = self.RPM - 20 #Apply forces to wheels self.Car_sim.applyEngineForce(engineForce, 0); self.Car_sim.applyEngineForce(engineForce, 3); self.Car_sim.setBrake(brakeForce, 1); self.Car_sim.setBrake(brakeForce, 2); self.Car_sim.setSteeringValue(self.steering, 0); self.Car_sim.setSteeringValue(self.steering, 3); #Steering wheel Sw.setHpr(0,0,-self.steering*10) #The HUD self.gear_hud = OnscreenImage(image = "Textures/gear_hud.png", pos = (-1,0,-0.85), scale = (0.2)) self.gear_hud.setTransparency(TransparencyAttrib.MAlpha) self.gear2_hud = OnscreenImage(image = "Textures/gear2_hud.png", pos = (-1,0,-0.85), scale = (0.2)) self.gear2_hud.setTransparency(TransparencyAttrib.MAlpha) self.starter = OnscreenImage(image = "Textures/starter.png", pos = (-1.2,0,-0.85), scale = (0.15)) self.starter.setTransparency(TransparencyAttrib.MAlpha) self.park = OnscreenImage(image = "Textures/pbrake.png", pos = (-0.8,0,-0.85), scale = (0.1)) self.park.setTransparency(TransparencyAttrib.MAlpha) self.rev_counter = OnscreenImage(image = "Textures/dial.png", pos = (-1.6, 0.0, -0.70), scale = (0.6,0.6,0.4)) self.rev_counter.setTransparency(TransparencyAttrib.MAlpha) self.rev_needle = OnscreenImage(image = "Textures/needle.png", pos = (-1.6, 0.0, -0.70), scale = (0.5)) self.rev_needle.setTransparency(TransparencyAttrib.MAlpha) self.rev_text = OnscreenText(text = " ", pos = (-1.6, -0.90, 0), scale = 0.05) self.speedometer = OnscreenImage(image = "Textures/dial.png", pos = (-1.68, 0.0, -0.10), scale = (0.7,0.7,0.5)) self.speedometer.setTransparency(TransparencyAttrib.MAlpha) self.speedometer_needle = OnscreenImage(image = "Textures/needle.png", pos = (-1.68, 0.0, -0.10), scale = (0.5)) self.speedometer_needle.setTransparency(TransparencyAttrib.MAlpha) self.speedometer_text = OnscreenText(text = " ", pos = (-1.68, -0.35, 0), scale = 0.05) #Update the HUD def Update_HUD(): #Move gear selector if self.gear == -1: self.gear2_hud.setPos(-1,0,-0.785) if self.gear == 0: self.gear2_hud.setPos(-1,0,-0.85) if self.gear == 1: self.gear2_hud.setPos(-1,0,-0.91) #Rotate starter if self.start == 0: self.starter.setHpr(0,0,0) else: self.starter.setHpr(0,0,45) #Update the parking brake light if self.Pbrake == 1: self.park.setImage("Textures/pbrake2.png") self.park.setTransparency(TransparencyAttrib.MAlpha) else: self.park.setImage("Textures/pbrake.png") self.park.setTransparency(TransparencyAttrib.MAlpha) #Update the rev counter self.rev_needle.setR(self.RPM/22) rev_string = str(self.RPM)[:4] self.rev_text.setText(rev_string+" RPM") #Update the speedometer if self.carspeed > 0.0: self.speedometer_needle.setR(self.carspeed*2.5) if self.carspeed < 0.0: self.speedometer_needle.setR(-self.carspeed*2.5) speed_string = str(self.carspeed)[:3] self.speedometer_text.setText(speed_string+" KPH") #Update the program def update(task): dt = globalClock.getDt() processInput(dt) Update_HUD() set_time() set_terrain() set_headlights() update_rpm() scene.doPhysics(dt, 5, 1.0/180.0) return task.cont taskMgr.add(update, "Update")
class ToontownFogManager: def __init__(self): self.fog = None self.fogMode = None print("Initialized Fog Manager") self.fog = Fog("ActiveFog") self.fog.setColor(1, 1, 1) self.fogTypes = { 0: Fog.MExponential, 1: Fog.MExponentialSquared, 2: Fog.MLinear } def setFog(self, np): np.setFog(self.fog) def setColor(self, r, g, b): self.fog.setColor(r, g, b) def clearFog(self): return render.clearFog() def getFogMode(self): self.fogMode = self.fog.getMode() def setFogMode(self, id): mode = self.fog.setMode(self.fogTypes[id]) self.fogMode = mode ## For Exponential Fog def setDensity(self, density): """ Determines the density value used for exponential fog calculations. :param float density: A value between [0, 1] """ self.fog.setExpDensity(density) ## For Linear Fog def setLinearRange(self, range, opacity): """ Specifies the effects of the fog in linear distance units. This is only used if the mode is M_linear. This specifies a fog that begins at distance onset units from the origin, and becomes totally opaque at distance <opaque units> from the origin, along the forward axis (usually Y). This function also implicitly sets the mode the M_linear, if it is not already set. :param float opacity: [0, 1] """ self.fog.setLinearRange(range, opacity) def setLinearFallback(self, angle, onset, opaque): """ :param float angle: the minimum viewing angle (angle between the camera direction and fog direction) at which the fallback effect will be employed. :type onset: float :param float opaque: [0, 1] Defines how the fog should be rendered when the fog effect is diminished in this way. Onset and opaque specify camera-relative onset and opaque distances that will be fallen back on, overriding the Fog node's own onset and opaque distances. The linear fallback workaround will only look good in certain situations, for example when the fog is deep inside a dark cave. So in general, exponential mode fog is more useful than the default linear mode fog. """ self.fog.setLinearFallback(angle, onset, opaque)
class Arena: def __init__(self, arenaNr): arenaPath = "levels/arena%d/" % arenaNr self.arena = loader.loadModel(arenaPath + "arena") self.arena.setScale(2) self.arena.reparentTo(render) self.arena.hide() 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, 2048, 2048) sun.setScene(render) #sun.showFrustum() self.ambientSound = None self.levelParticles = None if arenaNr == 1: sunLens.setNearFar(25,45) sun.setLens(sunLens) self.sunNp = render.attachNewNode(sun) self.sunNp.setPos(-10, -10, 30) self.sunNp.lookAt(0,0,0) self.ambientSound = loader.loadSfx("assets/audio/ambientLevel1.ogg") self.ambientSound.setLoop(True) self.fog = Fog("Outside Fog") self.fog.setColor(0.3,0.3,0.5) self.fog.setExpDensity(0.025) self.levelParticles = ParticleEffect() self.levelParticles.loadConfig("assets/fx/Leafs.ptf") self.levelParticles.start(parent = render2d, renderParent = render2d) elif arenaNr == 2: sunLens.setFov(120, 40) sunLens.setNearFar(2,10) sun.setLens(sunLens) self.sunNp = render.attachNewNode(sun) self.sunNp.setPos(0, 0, 5) self.sunNp.lookAt(0,0,0) self.fog = Fog("Temple Fog") self.fog.setColor(0,0,0) self.fog.setExpDensity(0.065) def start(self): self.arena.show() render.setLight(self.alnp) render.setLight(self.sunNp) if self.ambientSound != None: self.ambientSound.play() render.setFog(self.fog) def stop(self): self.arena.hide() render.clearLight() if self.ambientSound != None: self.ambientSound.stop() render.clearFog() if self.levelParticles != None: self.levelParticles.cleanup() def getStartPos(self, charNr): if charNr == 1: return self.arena.find("**/StartPosA").getPos() * 2 elif charNr == 2: return self.arena.find("**/StartPosB").getPos() * 2 else: return (0,0,0)
def gameLoop(self, task): #Compensate for inconsistent update intervals dt = globalClock.getDt() if self.GAME_MODE == MAIN_MENU: if not self.mode_initialized: self.buildMainMenu() self.mode_initialized = True if self.GAME_MODE == IN_GAME_MENU: if not self.mode_initialized: inGameMenuFogColor = (50, 150, 50) inGameMenuFog = Fog("inGameMenuFog") inGameMenuFog.setMode(Fog.MExponential) inGameMenuFog.setColor(*inGameMenuFogColor) inGameMenuFog.setExpDensity(.01) render.setFog(inGameMenuFog) self.buildInGameMenu() self.mode_initialized = True if self.GAME_MODE == NORMAL: if not self.mode_initialized: props = WindowProperties() props.setCursorHidden(True) base.win.requestProperties(props) self.last_mouse_x = self.win.getPointer(0).getX() self.last_mouse_y = self.win.getPointer(0).getY() self.mode_initialized = True #Handle keyboard input self.avatar.handleKeys(self.keys) self.avatar.move(dt) #Mouse-based viewpoint rotation mouse_pos = self.win.getPointer(0) current_mouse_x = mouse_pos.getX() current_mouse_y = mouse_pos.getY() mouse_shift_x = current_mouse_x - self.last_mouse_x mouse_shift_y = current_mouse_y - self.last_mouse_y self.last_mouse_x = current_mouse_x self.last_mouse_y = current_mouse_y if current_mouse_x < 5 or current_mouse_x >= (self.win_center_x * 1.5): base.win.movePointer(0, self.win_center_x, current_mouse_y) self.last_mouse_x = self.win_center_x if current_mouse_y < 5 or current_mouse_y >= (self.win_center_y * 1.5): base.win.movePointer(0, current_mouse_x, self.win_center_y) self.last_mouse_y = self.win_center_y yaw_shift = -((mouse_shift_x) * Camera.ROT_RATE[0]) pitch_shift = -((mouse_shift_y) * Camera.ROT_RATE[1]) self.avatar.yawRot += yaw_shift self.mainCamera.pitchRot += pitch_shift if self.mainCamera.pitchRot > Camera.MAX_PITCH_ROT: self.mainCamera.pitchRot = Camera.MAX_PITCH_ROT elif self.mainCamera.pitchRot < Camera.MIN_PITCH_ROT: self.mainCamera.pitchRot = Camera.MIN_PITCH_ROT self.avatar.objectNP.setH(self.avatar.yawRot) self.mainCamera.camObject.setH(self.avatar.yawRot) self.mainCamera.camObject.setP(self.mainCamera.pitchRot) if self.NAVIGATION_MODE == TERRAIN: xy_plane_cam_dist = Camera.AVATAR_DIST cam_z_adjust = Camera.ELEVATION elif self.NAVIGATION_MODE == SPACE: xy_plane_cam_dist = Camera.AVATAR_DIST*cos(radians(self.pitchRot)) cam_z_adjust = Camera.AVATAR_DIST*sin(radians(self.pitchRot)) cam_x_adjust = xy_plane_cam_dist*sin(radians(self.avatar.yawRot)) cam_y_adjust = xy_plane_cam_dist*cos(radians(self.avatar.yawRot)) self.mainCamera.camObject.setPos(self.avatar.objectNP.getX() + cam_x_adjust, self.avatar.objectNP.getY() - cam_y_adjust, self.avatar.objectNP.getZ() + cam_z_adjust) #Find collisions self.cTrav.traverse(render) return Task.cont
class World(DirectObject): def __init__(self): self.last_mousex = 0 self.last_mousey = 0 self.zone = None self.zone_reload_name = None self.winprops = WindowProperties() # simple console output self.consoleNode = NodePath(PandaNode("console_root")) self.consoleNode.reparentTo(aspect2d) self.console_num_lines = 24 self.console_cur_line = -1 self.console_lines = [] for i in range(0, self.console_num_lines): self.console_lines.append( OnscreenText( text="", style=1, fg=(1, 1, 1, 1), pos=(-1.3, 0.4 - i * 0.05), align=TextNode.ALeft, scale=0.035, parent=self.consoleNode, ) ) # Configuration self.consoleOut("zonewalk v.%s loading configuration" % VERSION) self.configurator = Configurator(self) cfg = self.configurator.config resaveRes = False if "xres" in cfg: self.xres = int(cfg["xres"]) else: self.xres = 1024 resaveRes = True if "yres" in cfg: self.yres = int(cfg["yres"]) else: self.yres = 768 resaveRes = True if resaveRes: self.saveDefaultRes() self.xres_half = self.xres / 2 self.yres_half = self.yres / 2 self.mouse_accum = MouseAccume(lambda: (self.xres_half, self.yres_half)) self.eyeHeight = 7.0 self.rSpeed = 80 self.flyMode = 1 # application window setup base.win.setClearColor(Vec4(0, 0, 0, 1)) self.winprops.setTitle("zonewalk") self.winprops.setSize(self.xres, self.yres) base.win.requestProperties(self.winprops) base.disableMouse() # network test stuff self.login_client = None if "testnet" in cfg: if cfg["testnet"] == "1": self.doLogin() # Post the instructions self.title = addTitle("zonewalk v." + VERSION) self.inst0 = addInstructions(0.95, "[FLYMODE][1]") self.inst1 = addInstructions(-0.95, "Camera control with WSAD/mouselook. Press K for hotkey list, ESC to exit.") self.inst2 = addInstructions(0.9, "Loc:") self.inst3 = addInstructions(0.85, "Hdg:") self.error_inst = addInstructions(0, "") self.kh = [] self.campos = Point3(155.6, 41.2, 4.93) base.camera.setPos(self.campos) # Accept the application control keys: currently just esc to exit navgen self.accept("escape", self.exitGame) self.accept("window-event", self.resizeGame) # Create some lighting ambient_level = 0.6 ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(ambient_level, ambient_level, ambient_level, 1.0)) render.setLight(render.attachNewNode(ambientLight)) direct_level = 0.8 directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(Vec3(0.0, 0.0, -1.0)) directionalLight.setColor(Vec4(direct_level, direct_level, direct_level, 1)) directionalLight.setSpecularColor(Vec4(direct_level, direct_level, direct_level, 1)) render.setLight(render.attachNewNode(directionalLight)) # create a point light that will follow our view point (the camera for now) # attenuation is set so that this point light has a torch like effect self.plight = PointLight("plight") self.plight.setColor(VBase4(0.8, 0.8, 0.8, 1.0)) self.plight.setAttenuation(Point3(0.0, 0.0, 0.0002)) self.plnp = base.camera.attachNewNode(self.plight) self.plnp.setPos(0, 0, 0) render.setLight(self.plnp) self.cam_light = 1 self.keyMap = { "left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0, "cam-right": 0, "mouse3": 0, "flymode": 1, } # setup FOG self.fog_colour = (0.8, 0.8, 0.8, 1.0) self.linfog = Fog("A linear-mode Fog node") self.linfog.setColor(self.fog_colour) self.linfog.setLinearRange(700, 980) # onset, opaque distances as params # linfog.setLinearFallback(45,160,320) base.camera.attachNewNode(self.linfog) render.setFog(self.linfog) self.fog = 1 # camera control self.campos = Point3(0, 0, 0) self.camHeading = 0.0 self.camPitch = 0.0 base.camLens.setFov(65.0) base.camLens.setFar(1200) self.cam_speed = 0 # index into self.camp_speeds self.cam_speeds = [40.0, 80.0, 160.0, 320.0, 640.0] # Collision Detection for "WALKMODE" # We will detect the height of the terrain by creating a collision # ray and casting it downward toward the terrain. The ray will start above the camera. # A ray may hit the terrain, or it may hit a rock or a tree. If it # hits the terrain, we can detect the height. If it hits anything # else, we rule that the move is illegal. self.cTrav = CollisionTraverser() self.camGroundRay = CollisionRay() self.camGroundRay.setOrigin(0.0, 0.0, 0.0) self.camGroundRay.setDirection(0, 0, -1) # straight down self.camGroundCol = CollisionNode("camRay") self.camGroundCol.addSolid(self.camGroundRay) self.camGroundCol.setFromCollideMask(BitMask32.bit(0)) self.camGroundCol.setIntoCollideMask(BitMask32.allOff()) # attach the col node to the camCollider dummy node self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol) self.camGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler) # Uncomment this line to see the collision rays # self.camGroundColNp.show() # Uncomment this line to show a visual representation of the # collisions occuring # self.cTrav.showCollisions(render) # Add the spinCameraTask procedure to the task manager. # taskMgr.add(self.spinCameraTask, "SpinCameraTask") taskMgr.add(self.camTask, "camTask") self.toggleControls(1) # need to step the task manager once to make our fake console work taskMgr.step() # CONSOLE --------------------------------------------------------------------- def consoleScroll(self): for i in range(0, self.console_num_lines - 1): self.console_lines[i].setText(self.console_lines[i + 1].getText()) def consoleOut(self, text): print text # output to stdout/log too if self.console_cur_line == self.console_num_lines - 1: self.consoleScroll() elif self.console_cur_line < self.console_num_lines - 1: self.console_cur_line += 1 self.console_lines[self.console_cur_line].setText(text) taskMgr.step() def consoleOn(self): self.consoleNode.show() def consoleOff(self): self.consoleNode.hide() # User controls ----------------------------------------------------------- def toggleControls(self, on): if on == 1: self.accept("escape", self.exitGame) self.accept("1", self.setSpeed, ["speed", 0]) self.accept("2", self.setSpeed, ["speed", 1]) self.accept("3", self.setSpeed, ["speed", 2]) self.accept("4", self.setSpeed, ["speed", 3]) self.accept("5", self.setSpeed, ["speed", 4]) self.accept("alt-f", self.fogToggle) self.accept("t", self.camLightToggle) self.accept("k", self.displayKeyHelp) self.accept("f", self.toggleFlymode) self.accept("l", self.reloadZone) self.accept("z", self.saveDefaultZone) self.accept("a", self.setKey, ["cam-left", 1]) self.accept("d", self.setKey, ["cam-right", 1]) self.accept("w", self.setKey, ["forward", 1]) self.accept("mouse1", self.setKey, ["forward", 1]) self.accept("mouse3", self.setKey, ["mouse3", 1]) self.accept("s", self.setKey, ["backward", 1]) self.accept("k-up", self.hideKeyHelp) self.accept("a-up", self.setKey, ["cam-left", 0]) self.accept("d-up", self.setKey, ["cam-right", 0]) self.accept("w-up", self.setKey, ["forward", 0]) self.accept("mouse1-up", self.setKey, ["forward", 0]) self.accept("mouse3-up", self.setKey, ["mouse3", 0]) self.accept("s-up", self.setKey, ["backward", 0]) else: messenger.clear() def setSpeed(self, key, value): self.cam_speed = value self.setFlymodeText() def fogToggle(self): if self.fog == 1: render.clearFog() base.camLens.setFar(100000) self.fog = 0 else: render.setFog(self.linfog) base.camLens.setFar(1200) self.fog = 1 def camLightToggle(self): if self.cam_light == 0: render.setLight(self.plnp) self.cam_light = 1 else: render.clearLight(self.plnp) self.cam_light = 0 def displayKeyHelp(self): self.kh = [] msg = "HOTKEYS:" pos = 0.75 self.kh.append( OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04) ) msg = "------------------" pos -= 0.05 self.kh.append( OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04) ) msg = "W: camera fwd, S: camera bck, A: rotate view left, D: rotate view right" pos -= 0.05 self.kh.append( OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04) ) msg = "1-5: set camera movement speed" pos -= 0.05 self.kh.append( OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04) ) msg = "F: toggle Flymode/Walkmode" pos -= 0.05 self.kh.append( OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04) ) msg = "L: load a zone" pos -= 0.05 self.kh.append( OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04) ) msg = "ALT-F: toggle FOG and FAR plane on/off" pos -= 0.05 self.kh.append( OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04) ) msg = 'T: toggle additional camera "torch" light on/off' pos -= 0.05 self.kh.append( OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04) ) msg = "Z: set currently loaded zone as new startup default" pos -= 0.05 self.kh.append( OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04) ) msg = "ESC: exit zonewalk" pos -= 0.05 self.kh.append( OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04) ) def hideKeyHelp(self): for n in self.kh: n.removeNode() def setFlymodeText(self): zname = "" if self.zone: zname = self.zone.name if self.flyMode == 0: self.inst0.setText("[WALKMODE][%i] %s" % (self.cam_speed + 1, zname)) else: self.inst0.setText("[FLYMODE][%i] %s " % (self.cam_speed + 1, zname)) def toggleFlymode(self): zname = "" if self.zone: zname = self.zone.name if self.flyMode == 0: self.flyMode = 1 else: self.flyMode = 0 self.setFlymodeText() # Define a procedure to move the camera. def spinCameraTask(self, task): angleDegrees = task.time * 6.0 angleRadians = angleDegrees * (pi / 180.0) base.camera.setPos(20 * sin(angleRadians), -20.0 * cos(angleRadians), 3) base.camera.setHpr(angleDegrees, 0, 0) return task.cont def camTask(self, task): # query the mouse mouse_dx = 0 mouse_dy = 0 # if we have a mouse and the right button is depressed if base.mouseWatcherNode.hasMouse(): if self.keyMap["mouse3"] != 0: self.mouse_accum.update() else: self.mouse_accum.reset() mouse_dx = self.mouse_accum.dx mouse_dy = self.mouse_accum.dy self.rXSpeed = fabs(self.mouse_accum.dx) * (self.cam_speed + 1) * max(5 * 1000 / self.xres, 3) self.rYSpeed = fabs(self.mouse_accum.dy) * (self.cam_speed + 1) * max(3 * 1000 / self.yres, 1) if self.keyMap["cam-left"] != 0 or mouse_dx < 0: if self.rSpeed < 160: self.rSpeed += 80 * globalClock.getDt() if mouse_dx != 0: self.camHeading += self.rXSpeed * globalClock.getDt() else: self.camHeading += self.rSpeed * globalClock.getDt() if self.camHeading > 360.0: self.camHeading = self.camHeading - 360.0 elif self.keyMap["cam-right"] != 0 or mouse_dx > 0: if self.rSpeed < 160: self.rSpeed += 80 * globalClock.getDt() if mouse_dx != 0: self.camHeading -= self.rXSpeed * globalClock.getDt() else: self.camHeading -= self.rSpeed * globalClock.getDt() if self.camHeading < 0.0: self.camHeading = self.camHeading + 360.0 else: self.rSpeed = 80 if mouse_dy > 0: self.camPitch += self.rYSpeed * globalClock.getDt() elif mouse_dy < 0: self.camPitch -= self.rYSpeed * globalClock.getDt() # set camera heading and pitch base.camera.setHpr(self.camHeading, self.camPitch, 0) # viewer position (camera) movement control v = render.getRelativeVector(base.camera, Vec3.forward()) if not self.flyMode: v.setZ(0.0) move_speed = self.cam_speeds[self.cam_speed] if self.keyMap["forward"] == 1: self.campos += v * move_speed * globalClock.getDt() if self.keyMap["backward"] == 1: self.campos -= v * move_speed * globalClock.getDt() # actually move the camera lastPos = base.camera.getPos() base.camera.setPos(self.campos) # self.plnp.setPos(self.campos) # move the point light with the viewer position # WALKMODE: simple collision detection # we simply check a ray from slightly below the "eye point" straight down # for geometry collisions and if there are any we detect the point of collision # and adjust the camera's Z accordingly if self.flyMode == 0: # move the camera to where it would be if it made the move # the colliderNode moves with it # base.camera.setPos(self.campos) # check for collissons self.cTrav.traverse(render) entries = [] for i in range(self.camGroundHandler.getNumEntries()): entry = self.camGroundHandler.getEntry(i) entries.append(entry) # print 'collision' entries.sort(lambda x, y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ())) if len(entries) > 0: # and (entries[0].getIntoNode().getName() == "terrain"): # print len(entries) self.campos.setZ(entries[0].getSurfacePoint(render).getZ() + self.eyeHeight) else: self.campos = lastPos base.camera.setPos(self.campos) # if (base.camera.getZ() < self.player.getZ() + 2.0): # base.camera.setZ(self.player.getZ() + 2.0) # update loc and hpr display pos = base.camera.getPos() hpr = base.camera.getHpr() self.inst2.setText("Loc: %.2f, %.2f, %.2f" % (pos.getX(), pos.getY(), pos.getZ())) self.inst3.setText("Hdg: %.2f, %.2f, %.2f" % (hpr.getX(), hpr.getY(), hpr.getZ())) return task.cont def exitGame(self): sys.exit(0) def resizeGame(self, win): props = base.win.getProperties() self.xres = props.getXSize() self.yres = props.getYSize() self.xres_half = self.xres / 2 self.yres_half = self.yres / 2 self.saveDefaultRes() # Records the state of the arrow keys # this is used for camera control def setKey(self, key, value): self.keyMap[key] = value # ------------------------------------------------------------------------- # this is the mythical MAIN LOOP :) def update(self): if self.zone_reload_name != None: self.doReload(self.zone_reload_name) self.zone_reload_name = None if self.zone != None: self.zone.update() taskMgr.step() if self.login_client != None: self.login_client.update() # ZONE loading ------------------------------------------------------------ # general zone loader driver # removes existing zone (if any) and load the new one def loadZone(self, name, path): if path[len(path) - 1] != "/": path += "/" if self.zone: self.zone.rootNode.removeNode() self.zone = Zone(self, name, path) error = self.zone.load() if error == 0: self.consoleOff() self.setFlymodeText() base.setBackgroundColor(self.fog_colour) def saveDefaultRes(self): cfg = self.configurator.config cfg["xres"] = str(self.xres) cfg["yres"] = str(self.yres) self.configurator.saveConfig() # initial world load after bootup def load(self): cfg = self.configurator.config if self.login_client != None: return zone_name = cfg["default_zone"] basepath = cfg["basepath"] self.loadZone(zone_name, basepath) # config save user interfacce def saveDefaultZone(self): if self.zone: cfg = self.configurator.config cfg["default_zone"] = self.zone.name self.configurator.saveConfig() # zone reload user interface # this gets called from our update loop when it detects that zone_reload_name has been set # we do this in this convoluted fashion in order to keep the main loop taskMgr updates ticking # because otherwise our status console output at various stages during the zone load would not # be displayed. Yes, this is hacky. def doReload(self, name): cfg = self.configurator.config basepath = cfg["basepath"] self.loadZone(name, basepath) # form dialog callback # this gets called from the form when the user has entered a something # (hopefully a correct zone short name) def reloadZoneDialogCB(self, name): self.frmDialog.end() self.zone_reload_name = name self.toggleControls(1) # this is called when the user presses "l" # it disables normal controls and fires up our query form dialog def reloadZone(self): base.setBackgroundColor((0, 0, 0)) self.toggleControls(0) self.consoleOn() self.frmDialog = FileDialog( "Please enter the shortname of the zone you wish to load:", "Examples: qrg, blackburrow, freportn, crushbone etc.", self.reloadZoneDialogCB, ) self.frmDialog.activate() # relies on the main update loop to run ############################### # EXPERIMENTAL def doLogin(self): self.login_client = UDPClientStream("127.0.0.1", 5998)
class CTSafeZoneLoader(SafeZoneLoader): notify = directNotify.newCategory("CTSafeZoneLoader") bldgPoints = [ Point3(0, 0, 0), Point3(0, 95, 0), Point3(75, 0, 0), Point3(75, 95, 0), Point3(-110, 0, 0), Point3(-185, 0, 0), Point3(-110, 95, 0), Point3(-185, 95, 0), Point3(-296.5, 0, 0), Point3(-296.5, 95, 0), Point3(-372, 95, 0), Point3(-372, 0, 0), Point3(189, 0, 0), Point3(189, 95, 0), Point3(264, 95, 0), Point3(264, 0, 0), Point3(264, 221.5, 0), Point3(264, 318, 0), Point3(188, 318, 0), Point3(188, 221.5, 0), Point3(75, 221.5, 0), Point3(75, 318, 0), Point3(0, 221.5, 0), Point3(0, 318, 0), Point3(-110, 318, 0), Point3(-110, 221.5, 0), Point3(-185, 318, 0), Point3(-185, 221.5, 0), Point3(-296.5, 318, 0), Point3(-296.5, 221.5, 0), Point3(-372, 318, 0), Point3(-372, 221.5, 0), ] bldgSectionData = [[Point3(0, 0, 0), Vec3(0, 0, 0)], [Point3(-38.59, -43.57, 0), Vec3(180, 0, 0)]] tLightData = [[(0.71, -2.06, 0.0), (0, 0, 0)], [(0.71, -226.17, -0.59), (0, 0, 0)], [(0.71, -451.44, 0.0), (0, 0, 0)], [(0.71, 221.32, 0), (0, 0, 0)], [(-39.05, 404.94, 0), (180, 0, 0)], [(-221.31, 404.94, 0.0), (180, 0, 0)], [(147.93, 404.94, 0), (180, 0, 0)], [(187.76, 221.68, 0), (0, 0, 0)], [(187.76, -1.82, 0), (0, 0, 0)], [(187.76, -227.4, -0.59), (0, 0, 0)], [(187.76, -451.28, 0), (0, 0, 0)], [(-185.21, -451.28, 0), (0, 0, 0)], [(-185.21, -226.94, 0), (0, 0, 0)], [(-185.21, -1.95, 0), (0, 0, 0)], [(-185.21, 221.7, 0), (0, 0, 0)]] def __init__(self, hood, parentFSMState, doneEvent): SafeZoneLoader.__init__(self, hood, parentFSMState, doneEvent) self.playground = CTPlayground.CTPlayground self.safeZoneSong = 'phase_12/audio/bgm/Bossbot_Entry_v1.ogg' self.interiorSong = None self.battleMusicFile = None self.invasionMusicFiles = None self.tournamentMusicFiles = None self.bossBattleMusicFile = None self.dnaFile = None self.szStorageDNAFile = None self.buildingSectionNodes = [] self.trafficLightNodes = [] self.trafficLights = [] self.fog = None self.rain = None self.rainRender = None self.soundRain = None self.thunderSounds = [ base.loadSfx('phase_14/audio/sfx/big_thunder_1.ogg'), base.loadSfx('phase_14/audio/sfx/big_thunder_2.ogg'), base.loadSfx('phase_14/audio/sfx/big_thunder_3.ogg'), base.loadSfx('phase_14/audio/sfx/big_thunder_4.ogg'), base.loadSfx('phase_14/audio/sfx/big_thunder_5.ogg'), base.loadSfx('phase_14/audio/sfx/big_thunder_6.ogg'), base.loadSfx('phase_14/audio/sfx/big_thunder_7.ogg'), base.loadSfx('phase_14/audio/sfx/big_thunder_8.ogg'), base.loadSfx('phase_14/audio/sfx/big_thunder_9.ogg'), base.loadSfx('phase_14/audio/sfx/big_thunder_10.ogg') ] def load(self): SafeZoneLoader.load(self) self.soundRain = base.loadSfx('phase_14/audio/sfx/rain_ambient.ogg') self.rain = ParticleLoader.loadParticleEffect('phase_14/etc/rain.ptf') self.rain.setPos(0, 0, 5) self.rainRender = self.geom.attachNewNode('snowRender') self.rainRender.setDepthWrite(0) self.rainRender.setBin('fixed', 1) def unload(self): self.soundRain = None self.rain = None del self.rainRender SafeZoneLoader.unload(self) def createSafeZone(self, foo): self.geom = loader.loadModel( 'phase_14/models/neighborhoods/cogtropolis.egg') self.geom.reparentTo(hidden) for i in range(2): bldgSectionNode = render.attachNewNode('bldgSection' + str(i)) bldgSectionNode.setPos(self.bldgSectionData[i][0]) bldgSectionNode.setHpr(self.bldgSectionData[i][1]) for point in self.bldgPoints: bldg = loader.loadModel( 'phase_14/models/props/cogtropolis_big_building_1.egg') bldg.reparentTo(bldgSectionNode) bldg.setPos(point) self.buildingSectionNodes.append(bldgSectionNode) for data in self.tLightData: node = render.attachNewNode('tlight-intersection-holder') node.setPos(data[0]) node.setHpr(data[1]) light = TrafficLight.TrafficLight() light.reparentTo(node) light.startFlashing() light2 = TrafficLight.TrafficLight(1) light2.reparentTo(node) light2.startFlashing() self.trafficLightNodes.append(node) self.trafficLights.append(light) self.trafficLights.append(light2) self.fog = Fog('CogTropolis-fog') self.fog.setColor(0.3, 0.3, 0.3) self.fog.setExpDensity(0.0075) self.geom.flattenMedium() gsg = base.win.getGsg() if gsg: self.geom.prepareScene(gsg) def unload(self): for trafficLight in self.trafficLights: trafficLight.destroy() del self.trafficLights for trafficLightN in self.trafficLightNodes: trafficLightN.removeNode() for section in self.buildingSectionNodes: section.removeNode() del self.trafficLightNodes del self.buildingSectionNodes del self.fog SafeZoneLoader.unload(self)
class MetalSlender(ShowBase): VERSION=0.1 GRAVITY = 9.81 def __init__(self): ShowBase.__init__(self) self.initVideo() self.initGame() def initVideo(self): self.render.setShaderAuto() #TODO: Not working self.render.setAntialias(AntialiasAttrib.MMultisample) self.props = WindowProperties() # self.props.setFullscreen(True) # self.props.setSize(1920, 1080) self.props.setSize(1280, 720) self.props.setCursorHidden(False) self.props.setMouseMode(self.props.M_absolute) self.win.requestProperties(self.props) self.win.movePointer(0, 100, 100) def initGame(self): self.paused = False self.initTimer = True self.time = 0 self.gameOver = True # self.setFrameRateMeter(True) self.taskMgr.add(self.menuDisplay, "menuDisplay") self.mainMenu = MainMenu(self) self.introSound = self.loader.loadSfx('assets/sounds/intro.mp3') self.introSound.setLoop(True) self.introSound.play() #TODO: Refactor environment into a class that inherits from nodepath def setupEnvironment(self): self.setBackgroundColor(0,0,0) self.setupLighting() self.setupFog() self.setupSkydome() self.setupPhysics() def setupFog(self): self.fog = Fog("fog") self.fog.setColor(FOG_COLOR) self.fog.setExpDensity(FOG_EXP_DENSITY) self.render.setFog(self.fog) def setupSkydome(self): self.skydome = self.loader.loadModel(EGG_SKYDOME) self.skydome.setBin('background', 0) self.skydome.setDepthWrite(False) self.skydome.reparentTo(self.cam) self.skydome.setCompass() self.skydome.setLight(self.shadeless) self.skydome.setScale(20) def setupLighting(self): alight = AmbientLight("AmbientLight") alight.setColor(AMBIENT_LIGHT) self.amblight = self.render.attachNewNode(alight) self.render.setLight(self.amblight) alight = AmbientLight("ShadelessLight") alight.setColor((1.0, 1.0, 1.0, 1.0)) self.shadeless = self.render.attachNewNode(alight) def setupPhysics(self): self.cTrav = CollisionTraverser() plane = self.render.attachNewNode(CollisionNode('WorldBottom')) plane.node().addSolid(CollisionPlane(Plane(0, 0, 1, 30))) plane.node().setIntoCollideMask(CollisionMask.SCENE) #TODO: Set the scenario's into collide mask to a special value def loadScenario(self): self.rooms = [] self.rooms.append(Room(self, self.render, "LCG" , "assets/chicken/lcg" )) self.rooms.append(Room(self, self.render, "Bloco H" , "assets/chicken/blocoh" )) self.rooms.append(Room(self, self.render, "Bloco H2" , "assets/chicken/blocoh2")) self.rooms.append(Room(self, self.render, "Collision", "assets/chicken/collision" )) self.rooms[-1].root.setCollideMask(CollisionMask.SCENE) def addCommands(self): self.accept('escape', self.userExit) self.accept('g', self.endGame) self.accept('i', self.actionKeys, ['i']) self.accept('p', self.pauseGame) self.accept('z', self.restartGame) self.cTrav.setRespectPrevTransform(True) def addTasks(self): self.taskMgr.add(self.camctrl.update, "camera/control") self.taskMgr.add(self.player.updateAll, "player/update") self.taskMgr.add(self.hud.update, 'hud') self.taskMgr.add(self.player.flashlight.updatePower, 'player/flashlight/update') self.taskMgr.add(self.AIUpdate,"AIUpdate") self.taskMgr.add(self.camctrl.update, "camera/control") self.taskMgr.add(self.checkGoal, 'CheckGoal') def actionKeys(self, key): if key == 'i': self.player.fear = min(self.player.fear + 0.1, 1.0) def AIUpdate(self,task): pass hasAttacked = [] for enemy in self.enemies: attack = enemy.update() hasAttacked.append(attack) for i in hasAttacked: if (i == True): self.player.hurt()#TODO:The enemy itself should hurt the player #attack self.AIworld.update() if (self.player.isDead()): for enemy in self.enemies: enemy.stop() self.endGame() return task.done return task.cont def newGame(self): self.setupEnvironment() self.AIworld = AIWorld(self.render) self.introSound.stop() #TODO: Play creepy sound initialSound = loader.loadSfx('assets/sounds/enemies/nazgul_scream.mp3') initialSound.play() self.enemies = [] self.items = [] self.keys = [] #TODO: Many things are only done once the game is started # Load the scene. self.loadScenario() self.player = Player(self, self.render, 'Player', pos=Vec3(6, 1.44, -1.5)) self.actions = ActionManager(self, self.player, self.rooms) self.em = EventManager(self, self.player, self.actions, self.rooms) self.em.start() for enemy in self.enemies: enemy.getHooded().addIntruder(self.player) enemy.start() self.hud = HUD(self, self.player) self.controls = PlayerControls(self.player, self.actions) self.camctrl = CameraControls(self, self.player) self.props.setCursorHidden(True) self.win.requestProperties(self.props) self.mainMenu.hideNewGame() self.addTasks() self.addCommands() # self.cTrav = None def pauseGame(self): if (self.paused == True): self.props.setCursorHidden(True) self.win.requestProperties(self.props) self.mainMenu.hidePauseGame() self.paused = False self.events.start() self.taskMgr.add(self.player.updateAll, "player/update") self.taskMgr.add(self.hud.update, 'hud') self.taskMgr.add(self.player.flashlight.updatePower, 'player/flashlight/update') self.taskMgr.add(self.AIUpdate,"AIUpdate") self.taskMgr.add(self.camctrl.update, "camera/control") self.taskMgr.add(self.checkGoal, 'CheckGoal') self.accept('p', self.pauseGame) else: self.events.stop() self.ignore('p') self.player.pause() self.taskMgr.remove("camera/control") self.taskMgr.remove("player/update") self.taskMgr.remove('hud') self.player.resetLast() self.taskMgr.remove('player/flashlight/update') self.taskMgr.remove("AIUpdate") self.taskMgr.remove('CheckGoal') self.props.setCursorHidden(False) self.win.requestProperties(self.props) self.mainMenu.showPauseGame() self.paused = True def restartGame(self): self.events.stop() self.taskMgr.remove("camera/control") self.taskMgr.remove("player/update") self.taskMgr.remove('hud') self.taskMgr.remove('player/flashlight/update') self.taskMgr.remove("AIUpdate") self.taskMgr.remove('CheckGoal') self.cleanResources() self.props.setCursorHidden(False) self.win.requestProperties(self.props) self.initGame() def cleanResources(self): self.AIworld = None del self.enemies [:] del self.rooms [:] self.enemies = None self.rooms = None self.player = None self.actions = None self.events = None self.mainMenu = None self.fog = None self.skydome.removeNode() self.amblight.removeNode() self.shadeless.removeNode() self.target1.removeNode() self.target2.removeNode() self.banana.removeNode() self.skydome = None self.amblight = None self.shadeless = None self.target1 = None self.target2 = None self.banana = None self.hud = None self.camctrl = None self.controls = None self.cTrav.clearColliders() gc.collect() self.taskMgr.add(self.player.updateAll, "player/update") self.taskMgr.add(self.player.flashlight.updatePower, 'player/flashlight/update') self.taskMgr.add(self.AIUpdate,"AIUpdate") self.taskMgr.add(self.camctrl.update, "camera/control") self.taskMgr.add(self.playerUpdate, "playerUpdate") self.taskMgr.add(self.checkGoal, 'CheckGoal') def endGame(self): self.hud.hide() if (self.gameOver): self.image = OnscreenImage(image="assets/images/GameOver.png", pos = (0, 0, 0), parent=base.render2d, scale=(1,1,1)) else: self.image = OnscreenImage(image="assets/images/to-be-continued.jpg", pos = (0, 0, 0), parent=base.render2d, scale=(1,1,1)) self.startTimer(3) self.taskMgr.remove("camera/control") def menuDisplay(self, task): if (self.initTimer == False): hasFinished = self.timer() if (hasFinished): self.resetTimer() self.image.hide() self.props.setCursorHidden(False) self.props.setMouseMode(self.props.M_absolute) self.win.requestProperties(self.props) self.mainMenu.showNewGame() return task.cont def timer(self): currentTime = time.time() diff = currentTime - self.time if (diff > self.interval): self.resetTimer() return True else: return False def resetTimer(self): self.initTimer = True def startTimer(self, interval): if (self.initTimer == True): self.interval = interval self.initTimer = False self.time = time.time() def playerUpdate(self, task): reached = self.checkGoal() if (reached): # self.player.die() self.endGame() return task.done someKey = False for key in self.actions.keys: if (key.wasPicked()): someKey = True self.hud.setKey(someKey) return task.cont def checkGoal(self, task): close = not self.goal.isEmpty() and self.player.getNodePath().getDistance(self.goal) < 2 hasKey = 'goal' in [key.lock for key in self.player.inventory] if (close and hasKey): self.gameOver = False self.endGame() return task.cont
class DistributedRace(DistributedObject.DistributedObject): notify = DirectNotifyGlobal.directNotify.newCategory('DistributedRace') ReadyPost = 'RaceReady' WinEvent = 'RaceWinEvent' BGM_BaseDir = 'phase_6/audio/bgm/' SFX_BaseDir = 'phase_6/audio/sfx/' SFX_StartBoop = SFX_BaseDir + 'KART_raceStart1.ogg' SFX_StartBoop2 = SFX_BaseDir + 'KART_raceStart2.ogg' SFX_Applause = SFX_BaseDir + 'KART_Applause_%d.ogg' def __init__(self, cr): self.qbox = loader.loadModel('phase_6/models/karting/qbox') self.boostArrowTexture = loader.loadTexture('phase_6/maps/boost_arrow.jpg', 'phase_6/maps/boost_arrow_a.rgb') self.boostArrowTexture.setMinfilter(Texture.FTLinear) DistributedObject.DistributedObject.__init__(self, cr) self.kartMap = {} self.fsm = ClassicFSM.ClassicFSM('Race', [State.State('join', self.enterJoin, self.exitJoin, ['prep', 'leave']), State.State('prep', self.enterPrep, self.exitPrep, ['tutorial', 'leave']), State.State('tutorial', self.enterTutorial, self.exitTutorial, ['start', 'waiting', 'leave']), State.State('waiting', self.enterWaiting, self.exitWaiting, ['start', 'leave']), State.State('start', self.enterStart, self.exitStart, ['racing', 'leave']), State.State('racing', self.enterRacing, self.exitRacing, ['finished', 'leave']), State.State('finished', self.enterFinished, self.exitFinished, ['leave']), State.State('leave', self.enterLeave, self.exitLeave, [])], 'join', 'leave') self.gui = RaceGUI(self) base.race = self self.currT = 0 self.currLapT = 0 self.currGag = 0 self.tdelay = 0 self.finished = False self.thrownGags = [] self.effectManager = EffectManager.EffectManager() self.piejectileManager = PiejectileManager.PiejectileManager() self.lastTimeUpdate = globalClock.getFrameTime() self.initGags() self.canShoot = True self.isUrbanTrack = False self.hasFog = False self.dummyNode = None self.fog = None self.bananaSound = base.loadSfx('phase_6/audio/sfx/KART_tossBanana.ogg') self.anvilFall = base.loadSfx('phase_6/audio/sfx/KART_Gag_Hit_Anvil.ogg') self.accept('leaveRace', self.leaveRace) self.toonsToLink = [] self.curveTs = [] self.curvePoints = [] self.localKart = None self.musicTrack = None self.victory = None self.miscTaskNames = [] self.boostDir = {} self.knownPlace = {} self.placeFixup = [] self.curve = None self.barricadeSegments = 100.0 self.outerBarricadeDict = {} self.innerBarricadeDict = {} self.maxLap = 0 self.oldT = 0 self.debugIt = 0 self.startPos = None return def generate(self): self.notify.debug('generate: %s' % self.doId) DistributedObject.DistributedObject.generate(self) bboard.post('race', self) self.roomWatcher = None self.cutoff = 0.01 self.startBoopSfx = base.loadSfx(self.SFX_StartBoop) self.startBoop2Sfx = base.loadSfx(self.SFX_StartBoop2) return def announceGenerate(self): self.notify.debug('announceGenerate: %s' % self.doId) DistributedObject.DistributedObject.announceGenerate(self) musicFile = self.BGM_BaseDir + RaceGlobals.TrackDict[self.trackId][7] self.raceMusic = base.loadMusic(musicFile) base.playMusic(self.raceMusic, looping=1, volume=0.8) base.camera.reparentTo(render) if self.trackId in (RaceGlobals.RT_Urban_1, RaceGlobals.RT_Urban_1_rev, RaceGlobals.RT_Urban_2, RaceGlobals.RT_Urban_2_rev): self.isUrbanTrack = True self.oldFarPlane = base.camLens.getFar() base.camLens.setFar(12000) localAvatar.startPosHprBroadcast() localAvatar.d_broadcastPositionNow() DistributedSmoothNode.activateSmoothing(1, 1) self.reversed = self.trackId / 2.0 > int(self.trackId / 2.0) for i in xrange(3): base.loader.tick() self.sky = loader.loadModel('phase_3.5/models/props/TT_sky') self.sky.setPos(0, 0, 0) self.sky.setScale(20.0) self.sky.setFogOff() if self.trackId in (RaceGlobals.RT_Urban_1, RaceGlobals.RT_Urban_1_rev, RaceGlobals.RT_Urban_2, RaceGlobals.RT_Urban_2_rev): self.loadFog() self.setupGeom() self.startSky() for i in xrange(5): base.loader.tick() def disable(self): self.notify.debug('disable %s' % self.doId) if self.musicTrack: self.musicTrack.finish() self.raceMusic.stop() self.stopSky() if self.sky is not None: self.sky.removeNode() if self.dummyNode: self.dummyNode.removeNode() self.dummyNode = None for taskName in self.miscTaskNames: taskMgr.remove(taskName) taskMgr.remove('raceWatcher') self.ignoreAll() DistributedSmoothNode.activateSmoothing(1, 0) if self.isUrbanTrack: self.unloadUrbanTrack() if self.fog: render.setFogOff() del self.fog self.fog = None if self.geom is not None: self.geom.hide() base.camLens.setFar(self.oldFarPlane) DistributedObject.DistributedObject.disable(self) return def delete(self): self.notify.debug('delete %s' % self.doId) if self.gui: self.gui.destroy() self.gui = None if self.geom is not None: self.geom.removeNode() self.geom = None for i in self.gags: i.delete() del i self.piejectileManager.delete() if self.curveTs: del self.curveTs if self.curvePoints: del self.curvePoints if self.curve: del self.curve if self.victory: del self.victory del self.fsm del self.anvilFall del self.bananaSound del self.localKart DistributedObject.DistributedObject.delete(self) taskMgr.remove(self.uniqueName('countdownTimerTask')) taskMgr.remove('raceWatcher') bboard.remove('race') self.ignoreAll() del base.race return def d_requestThrow(self, x, y, z): self.sendUpdate('requestThrow', [x, y, z]) def d_requestKart(self): self.sendUpdate('requestKart', []) def waitingForJoin(self): self.notify.debug('I got the barrier') self.fsm.enterInitialState() def racerDisconnected(self, avId): self.notify.debug('lost racer: %s' % avId) if avId in self.kartMap: if avId in self.toonsToLink: self.toonsToLink.remove(avId) toon = base.cr.doId2do.get(avId, None) kart = base.cr.doId2do.get(self.kartMap.get(avId, None), None) self.avIds.remove(avId) del self.kartMap[avId] self.gui.racerLeft(avId, unexpected=True) if kart: kart.reparentTo(hidden) if toon: toon.reparentTo(hidden) if len(self.toonsToLink) == 0: self.doneBarrier('waitingForPrep') return def setPlace(self, avId, totalTime, place, entryFee, qualify, winnings, bonus, trophies, circuitPoints, circuitTime): if self.fsm.getCurrentState().getName() == 'leaving': return if avId == localAvatar.doId: cheerToPlay = place + (4 - self.numRacers) if cheerToPlay > 4: cheerToPlay = 4 self.victory = base.loadSfx(self.SFX_Applause % cheerToPlay) self.victory.play() self.knownPlace[avId] = place kart = base.cr.doId2do.get(self.kartMap.get(avId, None), None) avatar = base.cr.doId2do.get(avId, None) if avatar: self.gui.racerFinished(avId, self.trackId, place, totalTime, entryFee, qualify, winnings, bonus, trophies, circuitPoints, circuitTime) taskName = 'hideAv: %s' % avId taskMgr.doMethodLater(6, avatar.reparentTo, taskName, extraArgs=[hidden]) self.miscTaskNames.append(taskName) if kart: taskName = 'hideKart: %s' % self.localKart.doId taskMgr.doMethodLater(6, kart.reparentTo, taskName, extraArgs=[hidden]) self.miscTaskNames.append(taskName) return def setCircuitPlace(self, avId, place, entryFee, winnings, bonus, trophies): print 'setting cicruit place' if self.fsm.getCurrentState().getName() == 'leaving': return if avId == localAvatar.doId: cheerToPlay = place + (4 - self.numRacers) self.victory = base.loadSfx(self.SFX_Applause % cheerToPlay) self.victory.play() oldPlace = 0 if self.knownPlace.get(avId): oldPlace = self.knownPlace[avId] self.placeFixup.append([oldPlace - 1, place - 1]) avatar = base.cr.doId2do.get(avId, None) if avatar: print 'circuit trophies %s' % trophies print 'winnings %s' % winnings self.gui.racerFinishedCircuit(avId, oldPlace, entryFee, winnings, bonus, trophies) return def endCircuitRace(self): print self.placeFixup self.gui.circuitFinished(self.placeFixup) def prepForRace(self): self.fsm.request('prep') def startRace(self, startTime = 0): self.baseTime = globalClockDelta.networkToLocalTime(startTime) self.fsm.request('start') def startTutorial(self): self.fsm.request('tutorial') def genGag(self, slot, number, type): self.notify.debug('making gag...') if not self.gags[slot].isActive(): self.gags[slot].genGag(number, type) def dropAnvilOn(self, ownerId, avId, timeStamp): kart = base.cr.doId2do.get(self.kartMap.get(avId, None), None) if kart: if avId != ownerId: if avId == localAvatar.doId: self.anvilFall.play() kart.dropOnMe(timeStamp) else: kart.dropOnHim(timeStamp) return def shootPiejectile(self, sourceId, targetId, type = 0): kart = base.cr.doId2do.get(self.kartMap.get(sourceId, None), None) if kart: self.piejectileManager.addPiejectile(sourceId, targetId, type) return def goToSpeedway(self, avIds, reason = RaceGlobals.Exit_UserReq): self.notify.debug('goToSpeedway %s %s' % (avIds, reason)) if localAvatar.doId in avIds: base.loader.endBulkLoad('atRace') self.kartCleanup() self.doneBarrier('waitingForExit') self.sendUpdate('racerLeft', [localAvatar.doId]) out = {'loader': 'safeZoneLoader', 'where': 'playground', 'how': 'teleportIn', 'hoodId': localAvatar.lastHood, 'zoneId': localAvatar.lastHood, 'shardId': None, 'avId': -1, 'reason': reason} base.cr.playGame.fsm.request('quietZone', [out]) return def kartCleanup(self): kart = self.localKart if kart: kart.setState('P', 0) for i in self.avIds: if i != localAvatar.doId: toon = base.cr.doId2do.get(i, None) if toon: toon.stopSmooth() toon.setScale(1) toon.setShear(0, 0, 0) toon.reparentTo(render) kart.doHeadScale(toon, None) localAvatar.setPos(0, 14, 0) localAvatar.sendCurrentPosition() return def heresMyT(self, avId, avNumLaps, avTime, timestamp): self.gui.updateRacerInfo(avId, curvetime=avNumLaps + avTime) def setZoneId(self, zoneId): self.zoneId = zoneId def setRaceType(self, raceType): self.raceType = raceType def setCircuitLoop(self, circuitLoop): self.circuitLoop = circuitLoop def setTrackId(self, id): DistributedRace.notify.debug('setTrackId: %s' % id) self.trackId = id def setAvatars(self, avIds): ids = '' for i in avIds: ids += str(i) + ' ' DistributedRace.notify.debug('setAvatars: %s' % ids) self.avIds = avIds self.avT = [0] * len(self.avIds) def setLapCount(self, lapCount): self.lapCount = lapCount def setStartingPlaces(self, startList): self.startingPlaces = startList def enterJoin(self): self.doneBarrier('waitingForJoin') self.notify.debug('entering Join') def exitJoin(self): pass def setEnteredRacers(self, avAndKarts): self.notify.debug('setEnteredRacers %s' % avAndKarts) avatarsGone = [] avatarsLeft = [] self.numRacers = len(avAndKarts) for i in avAndKarts: if i[0] in self.avIds: self.kartMap[i[0]] = i[1] avatarsLeft.append(i[0]) for i in self.avIds: if i not in avatarsLeft: avatarsGone.append(i) base.loader.tick() for i in avatarsGone: self.avIds.remove(i) self.toonsToLink = list(self.avIds) for i in avAndKarts: self.cr.relatedObjectMgr.requestObjects(i, allCallback=self.__gotKartAvatarLink) def __gotKartAvatarLink(self, avAndKart): self.notify.debug('got a Link') toon = avAndKart[0] kart = avAndKart[1] base.loader.tick() if toon.doId in self.toonsToLink: self.toonsToLink.remove(toon.doId) if toon.doId == localAvatar.doId: self.localKart = kart if len(self.toonsToLink) == 0: self.doneBarrier('waitingForPrep') def enterPrep(self): self.d_requestKart() self.notify.debug('entering Prep State') if self.reversed: self.spin = Vec3(180, 0, 0) else: self.spin = Vec3(0, 0, 0) for i in xrange(4): base.loader.tick() self.gui.initRaceMode() self.gui.initResultMode() self.myPos = self.startingPos[self.startingPlaces[self.avIds.index(localAvatar.doId)]] self.localKart.setPosHpr(self.myPos[0], self.myPos[1] + self.spin) self.localKart.setupLapCollisions() if self.dummyNode: self.dummyNode.setPosHpr(self.myPos[0], self.myPos[1] + self.spin) self.currentPole = self.findSegmentStart() self.rabbitPoint = Vec3(0, 0, 0) self.doneBarrier('waitingForReady') def exitPrep(self): pass def enterTutorial(self): self.notify.debug('entering Tutorial State') base.loader.endBulkLoad('atRace') self.localKart.setPosHpr(self.myPos[0], self.myPos[1] + self.spin) base.transitions.irisIn() self.rulesDoneEvent = 'finishedRules' self.accept(self.rulesDoneEvent, self.handleRulesDone) self.rulesPanel = MinigameRulesPanel.MinigameRulesPanel('RacingRulesPanel', self.getTitle(), self.getInstructions(), self.rulesDoneEvent, 10) self.rulesPanel.load() self.rulesPanel.frame.setPos(0, 0, -0.6667) self.rulesPanel.enter() def exitTutorial(self): self.ignore(self.rulesDoneEvent) self.rulesPanel.exit() self.rulesPanel.unload() del self.rulesPanel def getTitle(self): return TTLocalizer.KartRace_TitleInfo def getInstructions(self): return TTLocalizer.KartRace_TrackInfo[self.trackId] def handleRulesDone(self): self.doneBarrier('readRules') self.fsm.request('waiting') def enterWaiting(self): self.waitingLabel = DirectLabel() self.waitingLabel['text'] = TTLocalizer.BuildingWaitingForVictors self.waitingLabel.setScale(TTLocalizer.DRenterWaiting) def exitWaiting(self): self.waitingLabel.removeNode() def enterStart(self): waitTime = self.baseTime - globalClock.getFrameTime() taskName = 'enableRaceModeLater' taskMgr.doMethodLater(1, self.gui.enableRaceMode, taskName, extraArgs=[]) self.miscTaskNames.append(taskName) for i in self.avIds: self.gui.racerEntered(i) self.startCountdownClock(waitTime, 0) taskMgr.doMethodLater(waitTime, self.fsm.request, 'goToRacing', extraArgs=['racing']) def exitStart(self): pass def enterRacing(self): self.localKart.setInput(1) self.gui.setTimerEnabled(True) self.raceTask = taskMgr.add(self.raceWatcher, 'raceWatcher') def exitRacing(self): pass def raceWatcher(self, task): kart = base.cr.doId2do.get(self.kartMap.get(localAvatar.doId, None), None) if self.localKart.amIClampingPosition(): self.notify.debug('teleporting kart %d back to main track' % localAvatar.doId) self.localKart.setPos(self.curvePoints[self.currentPole]) kartPoint = self.localKart.getPos() direction = 0 while True: currPoint = self.curvePoints[self.currentPole] nextPole = (self.currentPole + 1) % len(self.curvePoints) nextPoint = self.curvePoints[nextPole] segment = nextPoint - currPoint segment.setZ(0) segLength2 = segment.lengthSquared() kartVector = kartPoint - currPoint kartVector.setZ(0) project = segment * (segment.dot(kartVector) / segLength2) projLength2 = project.lengthSquared() if project.dot(segment) < 0: if direction == 1: break prevPole = (self.currentPole - 1) % len(self.curvePoints) self.currentPole = prevPole direction = -1 elif projLength2 > segLength2: if direction == -1: break self.currentPole = nextPole direction = 1 else: break if self.dummyNode: self.dummyNode.setPos(kartPoint[0], kartPoint[1], 0) self.dummyNode.setHpr(self.localKart.getH(), 0, 0) t = projLength2 / segLength2 if self.debugIt: self.notify.debug('self.debugIt = %d' % self.debugIt) import pdb pdb.set_trace() if nextPole < self.currentPole: newT = self.curveTs[self.currentPole] * (1 - t) + self.curve.getMaxT() * t else: newT = self.curveTs[self.currentPole] * (1 - t) + self.curveTs[nextPole] * t kartDirection = self.localKart.forward.getPos(render) - self.localKart.getPos(render) kartDirection.normalize() project.normalize() globalDirection = kartDirection.dot(project) if globalDirection < 0: self.wrongWay = True elif globalDirection > 0.1: self.wrongWay = False newLapT = (newT - self.startT) / self.curve.getMaxT() % 1.0 if newLapT - self.currLapT < -0.5: self.laps += 1 self.changeMusicTempo(1 + self.laps * 0.5) self.notify.debug('crossed the start line: %s, %s, %s, %s' % (self.laps, self.startT, self.currT, newT)) elif newLapT - self.currLapT > 0.5: self.laps -= 1 self.changeMusicTempo(1 + self.laps * 0.5) self.notify.debug('crossed the start line - wrong way: %s, %s, %s, %s' % (self.laps, self.startT, self.currT, newT)) self.currT = newT self.currLapT = newLapT if self.isUrbanTrack: self.showBuildings(self.currT) now = globalClock.getFrameTime() timestamp = globalClockDelta.localToNetworkTime(now) if self.laps == self.lapCount: self.sendUpdate('heresMyT', [localAvatar.doId, self.laps, self.currLapT, timestamp]) self.fsm.request('finished') if self.laps > self.maxLap: self.maxLap = self.laps self.sendUpdate('heresMyT', [localAvatar.doId, self.laps, self.currLapT, timestamp]) if now - self.lastTimeUpdate > 0.5: self.lastTimeUpdate = now self.sendUpdate('heresMyT', [localAvatar.doId, self.laps, self.currLapT, timestamp]) self.gui.updateRacerInfo(localAvatar.doId, curvetime=self.currLapT + self.laps) self.gui.update(now) return Task.cont def enterFinished(self): taskMgr.remove('raceWatcher') self.fadeOutMusic() self.localKart.interruptTurbo() self.localKart.disableControls() taskName = 'parkIt' taskMgr.doMethodLater(2, self.stopDriving, taskName, extraArgs=[]) self.miscTaskNames.append(taskName) self.finished = True base.camera.reparentTo(render) base.camera.setPos(self.localKart.getPos(render) + Vec3(0, 0, 10)) base.camera.setH(self.localKart.getH(render) + 180) self.gui.disableRaceMode() self.gui.enableResultMode() localAvatar.reparentTo(hidden) self.localKart.reparentTo(hidden) def exitFinished(self): pass def stopDriving(self): kart = base.cr.doId2do.get(self.kartMap.get(localAvatar.doId, None), None) cpos = base.camera.getPos() chpr = base.camera.getHpr() localAvatar.reparentTo(hidden) self.localKart.reparentTo(hidden) self.localKart.stopSmooth() self.localKart.stopPosHprBroadcast() base.camera.setPos(cpos) base.camera.setHpr(chpr) return def enterLeave(self): kart = base.cr.doId2do.get(self.kartMap.get(localAvatar.doId, None), None) taskMgr.remove('raceWatcher') self.gui.disable() if self.localKart: self.localKart.disableControls() base.transitions.irisOut() if self.raceType == RaceGlobals.Circuit and not len(self.circuitLoop) == 0: self.sendUpdate('racerLeft', [localAvatar.doId]) else: taskMgr.doMethodLater(1, self.goToSpeedway, 'leaveRace', extraArgs=[[localAvatar.doId], RaceGlobals.Exit_UserReq]) if self.victory: self.victory.stop() self.bananaSound.stop() self.anvilFall.stop() return def exitLeave(self): pass def getCountdownColor(self, countdownTimeInt): clockNodeColors = [Vec4(0, 1, 0, 1), Vec4(1, 1, 0, 1), Vec4(1, 0.5, 0, 1), Vec4(1, 0, 0, 1)] i = max(min(countdownTimeInt, len(clockNodeColors) - 1), 0) return clockNodeColors[i] def startCountdownClock(self, countdownTime, ts): self.clockNode = TextNode('k') self.clockNode.setFont(ToontownGlobals.getSignFont()) self.clockNode.setAlign(TextNode.ACenter) countdownInt = int(countdownTime) self.clockNode.setTextColor(self.getCountdownColor(countdownInt)) self.clockNode.setText(str(countdownInt)) self.clock = render2d.attachNewNode(self.clockNode) rs = TTLocalizer.DRrollScale self.clock.setPosHprScale(0, 0, 0, 0, 0, 0, rs, rs, rs) self.clock.hide() if ts < countdownTime: self.countdown(countdownTime - ts) def timerTask(self, task): countdownTime = int(task.duration - task.time) timeStr = str(countdownTime + 1) if self.clock.isHidden(): if task.duration - task.time <= task.maxCount: self.clock.show() if self.clockNode.getText() != timeStr: self.startBoopSfx.play() self.clockNode.setText(timeStr) self.clockNode.setTextColor(self.getCountdownColor(countdownTime + 1)) if task.time >= task.duration: self.startBoop2Sfx.play() self.clockNode.setText(TTLocalizer.KartRace_Go) self.clockNode.setTextColor(self.getCountdownColor(-1)) taskMgr.doMethodLater(1, self.endGoSign, 'removeGoSign') return Task.done else: return Task.cont def endGoSign(self, t): self.clock.removeNode() def countdown(self, duration): countdownTask = Task(self.timerTask) countdownTask.duration = duration countdownTask.maxCount = RaceGlobals.RaceCountdown taskMgr.remove(self.uniqueName('countdownTimerTask')) return taskMgr.add(countdownTask, self.uniqueName('countdownTimerTask')) def initGags(self): self.banana = globalPropPool.getProp('banana') self.banana.setScale(2) self.pie = globalPropPool.getProp('creampie') self.pie.setScale(1) def makeCheckPoint(self, trigger, location, event): cs = CollisionSphere(0, 0, 0, 140) cs.setTangible(0) triggerEvent = 'imIn-' + trigger cn = CollisionNode(trigger) cn.addSolid(cs) cn.setIntoCollideMask(BitMask32(32768)) cn.setFromCollideMask(BitMask32(32768)) cnp = NodePath(cn) cnp.reparentTo(self.geom) cnp.setPos(location) self.accept(triggerEvent, event) def loadUrbanTrack(self): self.dnaStore = DNAStorage() files = ('phase_4/dna/storage.pdna', 'phase_5/dna/storage_town.pdna', 'phase_4/dna/storage_TT.pdna', 'phase_5/dna/storage_TT_town.pdna', 'phase_8/dna/storage_BR.pdna', 'phase_8/dna/storage_BR_town.pdna', 'phase_8/dna/storage_DL.pdna', 'phase_8/dna/storage_DL_town.pdna') dnaBulk = DNABulkLoader(self.dnaStore, files) dnaBulk.loadDNAFiles() dnaFile = 'phase_6/dna/urban_track_town.pdna' if self.trackId in (RaceGlobals.RT_Urban_2, RaceGlobals.RT_Urban_2_rev): dnaFile = 'phase_6/dna/urban_track_town_B.pdna' node = loader.loadDNAFile(self.dnaStore, dnaFile) self.townGeom = self.geom.attachNewNode(node) self.townGeom.findAllMatches('**/+CollisionNode').stash() self.buildingGroups = {} self.currBldgInd = {} self.currBldgGroups = {} bgGeom = self.geom.find('**/polySurface8') if self.dummyNode: bgGeom.reparentTo(self.dummyNode) else: bgGeom.reparentTo(localAvatar) bgGeom.setScale(0.1) ce = CompassEffect.make(NodePath(), CompassEffect.PRot) bgGeom.node().setEffect(ce) bgGeom.setDepthTest(0) bgGeom.setDepthWrite(0) bgGeom.setBin('background', 102) bgGeom.setZ(-1) self.bgGeom = bgGeom l = self.geom.findAllMatches('**/+ModelNode') for n in l: n.node().setPreserveTransform(0) self.geom.flattenLight() maxNum = 0 for side in ['inner', 'outer']: self.buildingGroups[side] = [] self.currBldgInd[side] = None self.currBldgGroups[side] = None i = 0 while 1: bldgGroup = self.townGeom.find('**/Buildings_' + side + '-' + str(i)) if bldgGroup.isEmpty(): break l = bldgGroup.findAllMatches('**/+ModelNode') for n in l: n2 = n.getParent().attachNewNode(n.getName()) n.getChildren().reparentTo(n2) n.removeNode() bldgGroup.flattenStrong() if not bldgGroup.getNode(0).getBounds().isEmpty(): self.buildingGroups[side].append(bldgGroup) i += 1 if i > maxNum: maxNum = i for side in ['innersidest', 'outersidest']: self.buildingGroups[side] = [] self.currBldgInd[side] = None self.currBldgGroups[side] = None for i in xrange(maxNum): for barricade in ('innerbarricade', 'outerbarricade'): bldgGroup = self.townGeom.find('**/Buildings_' + side + '-' + barricade + '_' + str(i)) if bldgGroup.isEmpty(): continue l = bldgGroup.findAllMatches('**/+ModelNode') for n in l: n2 = n.getParent().attachNewNode(n.getName()) n.getChildren().reparentTo(n2) n.removeNode() self.buildingGroups[side].append(bldgGroup) treeNodes = self.townGeom.findAllMatches('**/prop_tree_*') for tree in treeNodes: tree.flattenStrong() snowTreeNodes = self.townGeom.findAllMatches('**/prop_snow_tree_*') for snowTree in snowTreeNodes: snowTree.flattenStrong() for side in ['inner', 'outer', 'innersidest', 'outersidest']: for grp in self.buildingGroups[side]: grp.stash() self.showBuildings(0) def unloadUrbanTrack(self): del self.buildingGroups self.townGeom.removeNode() def loadFog(self): self.hasFog = True if self.isUrbanTrack: base.camLens.setFar(650) else: base.camLens.setFar(650) self.dummyNode = render.attachNewNode('dummyNode') if base.wantFog: self.fog = Fog('TrackFog') self.fog.setColor(Vec4(0.6, 0.7, 0.8, 1.0)) if self.isUrbanTrack: self.fog.setLinearRange(200.0, 650.0) else: self.fog.setLinearRange(200.0, 800.0) render.setFog(self.fog) self.sky.setScale(1.725) self.sky.reparentTo(self.dummyNode) def showBuildings(self, t, forceRecompute = False): firstTimeCalled = 0 if self.curve: t = t / self.curve.getMaxT() else: firstTimeCalled = 1 if self.reversed: t = 1.0 - t numGroupsShown = 5 for side in ['inner', 'outer']: numBldgGroups = len(self.buildingGroups[side]) bldgInd = int(t * numBldgGroups) bldgInd = bldgInd % numBldgGroups if self.trackId in (RaceGlobals.RT_Urban_2, RaceGlobals.RT_Urban_2_rev): oldBldgInd = int(self.oldT * numBldgGroups) newBldgInd = int(t * numBldgGroups) kartPoint = self.startPos kart = base.cr.doId2do.get(self.kartMap.get(localAvatar.doId, None), None) if kart: kartPoint = self.localKart.getPos() if not self.currBldgInd[side]: self.currBldgInd[side] = 0 curInd = self.currBldgInd[side] myCurGroup = self.buildingGroups[side][curInd] prevGrp = (curInd - 1) % numBldgGroups myPrevGroup = self.buildingGroups[side][prevGrp] nextGrp = (curInd + 1) % numBldgGroups myNextGroup = self.buildingGroups[side][nextGrp] curVector = myCurGroup.getNode(0).getBounds().getCenter() - kartPoint curDistance = curVector.lengthSquared() prevVector = myPrevGroup.getNode(0).getBounds().getCenter() - kartPoint prevDistance = prevVector.lengthSquared() nextVector = myNextGroup.getNode(0).getBounds().getCenter() - kartPoint nextDistance = nextVector.lengthSquared() if curDistance <= prevDistance and curDistance <= nextDistance: bldgInd = self.currBldgInd[side] elif prevDistance <= curDistance and prevDistance <= nextDistance: bldgInd = prevGrp elif nextDistance <= curDistance and nextDistance <= prevDistance: bldgInd = nextGrp else: self.notify.warning('unhandled case!!!!') bldgInd = self.currBldgInd[side] if bldgInd != self.currBldgInd[side]: currBldgGroups = self.currBldgGroups[side] if currBldgGroups: for i in currBldgGroups: self.buildingGroups[side][i].stash() prevGrp2 = (bldgInd - 2) % numBldgGroups prevGrp = (bldgInd - 1) % numBldgGroups currGrp = bldgInd % numBldgGroups nextGrp = (bldgInd + 1) % numBldgGroups nextGrp2 = (bldgInd + 2) % numBldgGroups self.currBldgGroups[side] = [prevGrp2, prevGrp, currGrp, nextGrp, nextGrp2] for i in self.currBldgGroups[side]: self.buildingGroups[side][i].unstash() self.currBldgInd[side] = bldgInd if self.currBldgGroups['inner'] != self.currBldgGroups['outer']: pass if t != self.oldT: self.oldT = t if self.trackId in (RaceGlobals.RT_Urban_2, RaceGlobals.RT_Urban_2_rev): if self.reversed: t = 1.0 - t for side in ['innersidest', 'outersidest']: segmentInd = int(t * self.barricadeSegments) seglmentInd = segmentInd % self.barricadeSegments if segmentInd != self.currBldgInd[side] or forceRecompute: currBldgGroups = self.currBldgGroups[side] if currBldgGroups: for i in currBldgGroups: self.buildingGroups[side][i].stash() self.currBldgGroups[side] = [] if side == 'innersidest': dict = self.innerBarricadeDict elif side == 'outersidest': dict = self.outerBarricadeDict if segmentInd in dict: self.currBldgGroups[side] = dict[segmentInd] for i in self.currBldgGroups[side]: self.buildingGroups[side][i].unstash() self.currBldgInd[side] = segmentInd return def setupGeom(self): trackFilepath = RaceGlobals.TrackDict[self.trackId][0] self.geom = loader.loadModel(trackFilepath) for i in xrange(10): base.loader.tick() self.geom.reparentTo(render) if self.reversed: lapStartPos = self.geom.find('**/lap_start_rev').getPos() else: lapStartPos = self.geom.find('**/lap_start').getPos() self.startPos = lapStartPos lapMidPos = self.geom.find('**/lap_middle').getPos() for i in xrange(5): base.loader.tick() self.startingPos = [] posLocators = self.geom.findAllMatches('**/start_pos*') for i in xrange(posLocators.getNumPaths()): base.loader.tick() self.startingPos.append([posLocators[i].getPos(), posLocators[i].getHpr()]) self.notify.debug('self.startingPos: %s' % self.startingPos) self.wrongWay = False self.laps = 0 if self.isUrbanTrack: self.loadUrbanTrack() self.genArrows() if self.reversed: self.curve = self.geom.find('**/curve_reverse').node() else: self.curve = self.geom.find('**/curve_forward').node() for i in xrange(4000): self.curvePoints.append(Point3(0, 0, 0)) self.curve.getPoint(i / 4000.0 * (self.curve.getMaxT() - 1e-11), self.curvePoints[-1]) self.curveTs.append(i / 4000.0 * (self.curve.getMaxT() - 1e-11)) if self.trackId in (RaceGlobals.RT_Urban_2, RaceGlobals.RT_Urban_2_rev): self.precomputeSideStreets() for i in xrange(10): base.loader.tick() self.startT = self.getNearestT(lapStartPos) self.midT = self.getNearestT(lapMidPos) self.gags = [] gagList = RaceGlobals.TrackDict[self.trackId][4] for i in xrange(len(gagList)): self.notify.debug('generating gag: %s' % i) self.gags.append(RaceGag(self, i, Vec3(*gagList[i]) + Vec3(0, 0, 3))) for i in xrange(5): base.loader.tick() def precomputeSideStreets(self): farDist = base.camLens.getFar() + 300 farDistSquared = farDist * farDist for i in xrange(int(self.barricadeSegments)): testPoint = Point3(0, 0, 0) self.curve.getPoint(i / self.barricadeSegments * (self.curve.getMaxT() - 1e-11), testPoint) for side in ('innersidest', 'outersidest'): for bldgGroupIndex in xrange(len(self.buildingGroups[side])): bldgGroup = self.buildingGroups[side][bldgGroupIndex] if not bldgGroup.getNode(0).getBounds().isEmpty(): bldgPoint = bldgGroup.getNode(0).getBounds().getCenter() vector = testPoint - bldgPoint if vector.lengthSquared() < farDistSquared: if side == 'innersidest': dict = self.innerBarricadeDict elif side == 'outersidest': dict = self.outerBarricadeDict else: self.notify.error('unhandled side') if i in dict: if bldgGroupIndex not in dict[i]: dict[i].append(bldgGroupIndex) else: dict[i] = [bldgGroupIndex] for childIndex in (0,): if childIndex >= bldgGroup.getNumChildren(): continue childNodePath = bldgGroup.getChild(childIndex) bldgPoint = childNodePath.node().getBounds().getCenter() vector = testPoint - bldgPoint if vector.lengthSquared() < farDistSquared: if side == 'innersidest': dict = self.innerBarricadeDict elif side == 'outersidest': dict = self.outerBarricadeDict else: self.notify.error('unhandled side') if i in dict: if bldgGroupIndex not in dict[i]: dict[i].append(bldgGroupIndex) else: dict[i] = [bldgGroupIndex] for side in ('innersidest', 'outersidest'): for bldgGroup in self.buildingGroups[side]: bldgGroup.flattenStrong() if self.isUrbanTrack: self.showBuildings(0, forceRecompute=True) def findSegmentStart(self): kart = base.cr.doId2do.get(self.kartMap.get(localAvatar.doId, None), None) minLength2 = 1000000 minIndex = -1 currPoint = Point3(0, 0, 0) kartPoint = self.localKart.getPos() for i in xrange(len(self.curvePoints)): currPoint = self.curvePoints[i] currLength2 = (kartPoint - currPoint).lengthSquared() if currLength2 < minLength2: minLength2 = currLength2 minIndex = i currPoint = self.curvePoints[minIndex] if minIndex + 1 == len(self.curvePoints): nextPoint = self.curvePoints[0] else: nextPoint = self.curvePoints[minIndex + 1] if minIndex - 1 < 0: prevIndex = len(self.curvePoints) - 1 else: prevIndex = minIndex - 1 forwardSegment = nextPoint - currPoint if (kartPoint - currPoint).dot(forwardSegment) > 0: return minIndex else: return prevIndex return def getNearestT(self, pos): minLength2 = 1000000 minIndex = -1 currPoint = Point3(0, 0, 0) for i in xrange(len(self.curvePoints)): currPoint = self.curvePoints[i] currLength2 = (pos - currPoint).lengthSquared() if currLength2 < minLength2: minLength2 = currLength2 minIndex = i currPoint = self.curvePoints[minIndex] if minIndex + 1 == len(self.curvePoints): nextPoint = self.curvePoints[0] else: nextPoint = self.curvePoints[minIndex + 1] if minIndex - 1 < 0: prevIndex = len(self.curvePoints) - 1 else: prevIndex = minIndex - 1 forwardSegment = nextPoint - currPoint if (pos - currPoint).dot(forwardSegment) > 0: pole = minIndex else: pole = prevIndex currPoint = self.curvePoints[pole] nextPole = (pole + 1) % len(self.curvePoints) nextPoint = self.curvePoints[nextPole] segment = nextPoint - currPoint segment.setZ(0) segLength2 = segment.lengthSquared() posVector = pos - currPoint posVector.setZ(0) project = segment * (segment.dot(posVector) / segLength2) percent = project.lengthSquared() / segLength2 if nextPole < pole: t = self.curveTs[pole] * (1 - percent) + self.curve.getMaxT() * percent else: t = self.curveTs[pole] * (1 - percent) + self.curveTs[nextPole] * percent return t def hasGag(self, slot, type, index): if self.gags[slot].isActive(): self.gags[slot].disableGag() def leaveRace(self): self.fsm.request('leave') def racerLeft(self, avId): if avId != localAvatar.doId: self.gui.racerLeft(avId, unexpected=False) def skyTrack(self, task): return SkyUtil.cloudSkyTrack(task) def startSky(self): if self.hasFog: SkyUtil.startCloudSky(self, parent=self.dummyNode, effects=CompassEffect.PRot) else: SkyUtil.startCloudSky(self, parent=render) def stopSky(self): taskMgr.remove('skyTrack') def pickupGag(self, slot, index): self.canShoot = False standing = self.gui.racerDict[localAvatar.doId].place - 1 self.currGag = RaceGlobals.GagFreq[standing][index] cycleTime = 2 self.gui.waitingOnGag(cycleTime) taskMgr.doMethodLater(cycleTime, self.enableShoot, 'enableShoot') self.sendUpdate('hasGag', [slot, self.currGag, index]) def shootGag(self): if self.canShoot: if self.currGag == 1: self.bananaSound.play() self.shootBanana() elif self.currGag == 2: self.d_requestThrow(0, 0, 0) self.localKart.startTurbo() elif self.currGag == 3: self.d_requestThrow(0, 0, 0) elif self.currGag == 4: self.bananaSound.play() self.shootPie() self.currGag = 0 self.gui.updateGag(0) def enableShoot(self, t): self.canShoot = True if self.gui: self.gui.updateGag(self.currGag) def shootBanana(self): pos = self.localKart.getPos(render) banana = self.banana.copyTo(self.geom) banana.setPos(pos) self.thrownGags.append(banana) self.d_requestThrow(pos[0], pos[1], pos[2]) def shootPie(self): pos = self.localKart.getPos(render) self.d_requestThrow(pos[0], pos[1], pos[2]) def genArrows(self): base.arrows = [] arrowId = 0 for boost in RaceGlobals.TrackDict[self.trackId][5]: self.genArrow(boost[0], boost[1], arrowId) arrowId += 1 def genArrow(self, pos, hpr, id): factory = CardMaker('factory') factory.setFrame(-.5, 0.5, -.5, 0.5) arrowNode = factory.generate() arrowRoot = NodePath('root') baseArrow = NodePath(arrowNode) baseArrow.setTransparency(1) baseArrow.setTexture(self.boostArrowTexture) baseArrow.reparentTo(arrowRoot) arrow2 = baseArrow.copyTo(baseArrow) arrow2.setPos(0, 0, 1) arrow3 = arrow2.copyTo(arrow2) arrowRoot.setPos(*pos) arrowRoot.setHpr(*hpr) baseArrow.setHpr(0, -90, 0) baseArrow.setScale(24) arrowRoot.reparentTo(self.geom) trigger = 'boostArrow' + str(id) cs = CollisionTube(Point3(0.6, -6, 0), Point3(0.6, 54, 0), 4.8) cs.setTangible(0) triggerEvent = 'imIn-' + trigger cn = CollisionNode(trigger) cn.addSolid(cs) cn.setIntoCollideMask(BitMask32(32768)) cn.setFromCollideMask(BitMask32(32768)) cnp = NodePath(cn) cnp.reparentTo(arrowRoot) self.accept(triggerEvent, self.hitBoostArrow) arrowVec = arrow2.getPos(self.geom) - baseArrow.getPos(self.geom) arrowVec.normalize() idStr = str(id) cnp.setTag('boostId', idStr) self.boostDir[idStr] = arrowVec base.arrows.append(arrowRoot) def hitBoostArrow(self, cevent): into = cevent.getIntoNodePath() idStr = into.getTag('boostId') arrowVec = self.boostDir.get(idStr) if arrowVec == None: print 'Unknown boost arrow %s' % idStr return fvec = self.localKart.forward.getPos(self.geom) - self.localKart.getPos(self.geom) fvec.normalize() dotP = arrowVec.dot(fvec) if dotP > 0.7: self.localKart.startTurbo() return def fadeOutMusic(self): if self.musicTrack: self.musicTrack.finish() curVol = self.raceMusic.getVolume() interval = LerpFunctionInterval(self.raceMusic.setVolume, fromData=curVol, toData=0, duration=3) self.musicTrack = Sequence(interval) self.musicTrack.start() def changeMusicTempo(self, newPR): return # TODO: Reenable when we have music change support. if self.musicTrack: self.musicTrack.finish() curPR = self.raceMusic.getPlayRate() interval = LerpFunctionInterval(self.raceMusic.setPlayRate, fromData=curPR, toData=newPR, duration=3) self.musicTrack = Sequence(interval) self.musicTrack.start() def setRaceZone(self, zoneId, trackId): hoodId = self.cr.playGame.hood.hoodId base.loader.endBulkLoad('atRace') self.kartCleanup() self.doneBarrier('waitingForExit') self.sendUpdate('racerLeft', [localAvatar.doId]) out = {'loader': 'racetrack', 'where': 'racetrack', 'hoodId': hoodId, 'zoneId': zoneId, 'trackId': trackId, 'shardId': None, 'reason': RaceGlobals.Exit_UserReq} base.cr.playGame.hood.loader.fsm.request('quietZone', [out]) return
class Estate(Place.Place): notify = DirectNotifyGlobal.directNotify.newCategory('Estate') def __init__(self, loader, avId, zoneId, parentFSMState, doneEvent): Place.Place.__init__(self, None, doneEvent) self.id = MyEstate self.avId = avId self.zoneId = zoneId self.loader = loader self.cameraSubmerged = -1 self.toonSubmerged = -1 self.fsm = ClassicFSM.ClassicFSM('Estate', [State.State('init', self.enterInit, self.exitInit, ['final', 'teleportIn', 'doorIn', 'walk']), State.State('petTutorial', self.enterPetTutorial, self.exitPetTutorial, ['walk']), State.State('walk', self.enterWalk, self.exitWalk, ['final', 'sit', 'stickerBook', 'options', 'quest', 'fishing', 'mailbox', 'stopped', 'DFA', 'trialerFA', 'doorOut', 'push', 'pet', 'purchase']), State.State('stopped', self.enterStopped, self.exitStopped, ['walk', 'teleportOut']), State.State('sit', self.enterSit, self.exitSit, ['walk']), State.State('push', self.enterPush, self.exitPush, ['walk']), State.State('stickerBook', self.enterStickerBook, self.exitStickerBook, ['walk', 'sit', 'quest', 'fishing', 'mailbox', 'stopped', 'doorOut', 'push', 'pet', 'DFA', 'trialerFA']), State.State('teleportIn', self.enterTeleportIn, self.exitTeleportIn, ['walk', 'petTutorial']), State.State('teleportOut', self.enterTeleportOut, self.exitTeleportOut, ['teleportIn', 'walk', 'final']), State.State('doorIn', self.enterDoorIn, self.exitDoorIn, ['walk']), State.State('doorOut', self.enterDoorOut, self.exitDoorOut, ['final', 'walk']), State.State('final', self.enterFinal, self.exitFinal, ['teleportIn']), State.State('quest', self.enterQuest, self.exitQuest, ['walk']), State.State('fishing', self.enterFishing, self.exitFishing, ['walk', 'stopped']), State.State('mailbox', self.enterMailbox, self.exitMailbox, ['walk', 'stopped']), State.State('stopped', self.enterStopped, self.exitStopped, ['walk']), State.State('pet', self.enterPet, self.exitPet, ['walk', 'trialerFA']), State.State('trialerFA', self.enterTrialerFA, self.exitTrialerFA, ['trialerFAReject', 'DFA']), State.State('trialerFAReject', self.enterTrialerFAReject, self.exitTrialerFAReject, ['walk']), State.State('DFA', self.enterDFA, self.exitDFA, ['DFAReject', 'teleportOut']), State.State('purchase', self.enterPurchase, self.exitPurchase, ['walk']), State.State('DFAReject', self.enterDFAReject, self.exitDFAReject, ['walk'])], 'init', 'final') self.fsm.enterInitialState() self.doneEvent = doneEvent self.parentFSMState = parentFSMState return def delete(self): self.unload() def load(self): Place.Place.load(self) self.fog = Fog('EstateFog') taskMgr.add(self.__checkCameraUnderwater, 'estate-check-cam-underwater') path = self.loader.geom.find('**/Path') path.setBin('ground', 10, 1) self.parentFSMState.addChild(self.fsm) def unload(self): self.ignoreAll() self.notify.info('remove estate-check-toon-underwater to TaskMgr in unload()') taskMgr.remove('estate-check-toon-underwater') taskMgr.remove('estate-check-cam-underwater') self.parentFSMState.removeChild(self.fsm) del self.fsm self.fog = None Place.Place.unload(self) return def enter(self, requestStatus): hoodId = requestStatus['hoodId'] zoneId = requestStatus['zoneId'] newsManager = base.cr.newsManager if config.GetBool('want-estate-telemetry-limiter', 1): limiter = TLGatherAllAvs('Estate', RotationLimitToH) else: limiter = TLNull() self._telemLimiter = limiter if newsManager: holidayIds = base.cr.newsManager.getDecorationHolidayId() if (ToontownGlobals.HALLOWEEN_COSTUMES in holidayIds or ToontownGlobals.SPOOKY_COSTUMES in holidayIds) and self.loader.hood.spookySkyFile: lightsOff = Sequence(LerpColorScaleInterval(base.cr.playGame.hood.loader.geom, 0.1, Vec4(0.55, 0.55, 0.65, 1)), Func(self.loader.hood.startSpookySky)) lightsOff.start() else: self.loader.hood.startSky() lightsOn = LerpColorScaleInterval(base.cr.playGame.hood.loader.geom, 0.1, Vec4(1, 1, 1, 1)) lightsOn.start() else: self.loader.hood.startSky() lightsOn = LerpColorScaleInterval(base.cr.playGame.hood.loader.geom, 0.1, Vec4(1, 1, 1, 1)) lightsOn.start() self.loader.hood.sky.setFogOff() self.__setFaintFog() for i in self.loader.nodeList: self.loader.enterAnimatedProps(i) self.loader.geom.reparentTo(render) # The client April Toons Manager is currently broken, so we have to do this hacky thing instead. :( #if hasattr(base.cr, 'aprilToonsMgr'): #if self.isEventActive(AprilToonsGlobals.EventEstateGravity): #base.localAvatar.startAprilToonsControls() if base.config.GetBool('want-april-toons'): base.localAvatar.startAprilToonsControls() self.accept('doorDoneEvent', self.handleDoorDoneEvent) self.accept('DistributedDoor_doorTrigger', self.handleDoorTrigger) self.fsm.request(requestStatus['how'], [requestStatus]) def exit(self): base.localAvatar.stopChat() if base.config.GetBool('want-april-toons'): base.localAvatar.stopAprilToonsControls() self._telemLimiter.destroy() del self._telemLimiter if hasattr(self, 'fsm'): self.fsm.requestFinalState() self.loader.geom.reparentTo(hidden) for i in self.loader.nodeList: self.loader.exitAnimatedProps(i) self.loader.hood.stopSky() render.setFogOff() base.cr.cache.flush() def __setZoneId(self, zoneId): self.zoneId = zoneId def detectedMailboxCollision(self): self.fsm.request('mailbox') def detectedGardenPlotUse(self): if hasattr(self, 'fsm'): self.fsm.request('stopped') def detectedGardenPlotDone(self): if hasattr(self, 'fsm'): self.fsm.request('walk') def detectedFlowerSellUse(self): if hasattr(self, 'fsm'): self.fsm.request('stopped') def detectedFlowerSellDone(self): if hasattr(self, 'fsm'): self.fsm.request('walk') def doRequestLeave(self, requestStatus): self.fsm.request('trialerFA', [requestStatus]) def enterInit(self): pass def exitInit(self): pass def enterPurchase(self): Place.Place.enterPurchase(self) def exitPurchase(self): Place.Place.exitPurchase(self) def enterPetTutorial(self, bDummy = True): self.notify.info('remove estate-check-toon-underwater to TaskMgr in enterPetTutorial()') taskMgr.remove('estate-check-toon-underwater') self.petTutorialDoneEvent = 'PetTutorialDone' self.acceptOnce(self.petTutorialDoneEvent, self.petTutorialDone) self.petTutorial = PetTutorial.PetTutorial(self.petTutorialDoneEvent) def exitPetTutorial(self): self.notify.info('add estate-check-toon-underwater to TaskMgr in exitPetTutorial()') if hasattr(self, 'fsm'): taskMgr.add(self.__checkToonUnderwater, 'estate-check-toon-underwater') if hasattr(self, 'petTutorial') and self.petTutorial is not None: self.petTutorial.destroy() return def petTutorialDone(self): self.ignore(self.petTutorialDoneEvent) self.petTutorial.destroy() self.petTutorial = None self.fsm.request('walk', [1]) return def enterMailbox(self): Place.Place.enterPurchase(self) base.localAvatar.startSleepWatch(self.__handleFallingAsleepMailbox) self.enablePeriodTimer() def __handleFallingAsleepMailbox(self, arg): if hasattr(self, 'fsm'): self.fsm.request('walk') messenger.send('mailboxAsleep') base.localAvatar.forceGotoSleep() def exitMailbox(self): Place.Place.exitPurchase(self) base.localAvatar.stopSleepWatch() self.disablePeriodTimer() def enterTeleportIn(self, requestStatus): self._etiToken = self.addSetZoneCompleteCallback(Functor(self._teleportToHouse, requestStatus)) Place.Place.enterTeleportIn(self, requestStatus) def _teleportToHouse(self, requestStatus): try: houseDo = base.cr.doId2do.get(base.localAvatar.houseId) house = houseDo.house pos = house.getPos(render) base.localAvatar.detachNode() base.localAvatar.setPosHpr(house, 17, 3, 0, 125, 0, 0) except: x, y, z, h, p, r = HouseGlobals.defaultEntryPoint base.localAvatar.detachNode() base.localAvatar.setPosHpr(render, x, y, z, h, p, r) base.localAvatar.setScale(1, 1, 1) self.toonSubmerged = -1 self.notify.info('remove estate-check-toon-underwater to TaskMgr in enterTeleportIn()') taskMgr.remove('estate-check-toon-underwater') if base.wantPets: if base.localAvatar.hasPet() and not base.localAvatar.bPetTutorialDone: self.nextState = 'petTutorial' def teleportInDone(self): self.notify.debug('teleportInDone') self.toonSubmerged = -1 if self.nextState is not 'petTutorial': self.notify.info('add estate-check-toon-underwater to TaskMgr in teleportInDone()') if hasattr(self, 'fsm'): taskMgr.add(self.__checkToonUnderwater, 'estate-check-toon-underwater') Place.Place.teleportInDone(self) def exitTeleportIn(self): self.removeSetZoneCompleteCallback(self._etiToken) Place.Place.exitTeleportIn(self) def enterTeleportOut(self, requestStatus): Place.Place.enterTeleportOut(self, requestStatus, self.__teleportOutDone) def __teleportOutDone(self, requestStatus): if hasattr(self, 'fsm'): self.fsm.requestFinalState() hoodId = requestStatus['hoodId'] zoneId = requestStatus['zoneId'] avId = requestStatus['avId'] shardId = requestStatus['shardId'] if hoodId == ToontownGlobals.MyEstate and zoneId == self.getZoneId() and shardId == None: self.fsm.request('teleportIn', [requestStatus]) elif hoodId == ToontownGlobals.MyEstate and shardId == None: self.doneStatus = requestStatus self.getEstateZoneAndGoHome(requestStatus) else: self.doneStatus = requestStatus messenger.send(self.doneEvent, [self.doneStatus]) return def goHomeFailed(self, task): self.notifyUserGoHomeFailed() self.ignore('setLocalEstateZone') self.doneStatus['avId'] = -1 self.doneStatus['zoneId'] = self.getZoneId() self.fsm.request('teleportIn', [self.doneStatus]) return Task.done def exitTeleportOut(self): Place.Place.exitTeleportOut(self) def exitDoorIn(self): self.toonSubmerged = -1 self.notify.info('add estate-check-toon-underwater to TaskMgr in exitDoorIn()') if hasattr(self, 'fsm'): taskMgr.add(self.__checkToonUnderwater, 'estate-check-toon-underwater') Place.Place.exitDoorIn(self) def getZoneId(self): if self.zoneId: return self.zoneId else: self.notify.warning('no zone id available') def __checkCameraUnderwater(self, task): if base.camera.getZ(render) < -1.2: self.__submergeCamera() else: self.__emergeCamera() return Task.cont def __checkToonUnderwater(self, task): if base.localAvatar.getZ() < -4.0: self.__submergeToon() else: self.__emergeToon() return Task.cont def __submergeCamera(self): if self.cameraSubmerged == 1: return self.__setUnderwaterFog() base.playSfx(self.loader.underwaterSound, looping=1, volume=0.8) self.cameraSubmerged = 1 self.walkStateData.setSwimSoundAudible(1) def __emergeCamera(self): if self.cameraSubmerged == 0: return self.loader.underwaterSound.stop() self.loader.hood.sky.setFogOff() self.__setFaintFog() self.cameraSubmerged = 0 self.walkStateData.setSwimSoundAudible(0) def forceUnderWater(self): self.toonSubmerged = 0 self.__submergeToon() def __submergeToon(self): if self.toonSubmerged == 1: return self.notify.debug('continuing in __submergeToon') if hasattr(self, 'loader') and self.loader: base.playSfx(self.loader.submergeSound) if base.config.GetBool('disable-flying-glitch') == 0: self.fsm.request('walk') self.walkStateData.fsm.request('swimming', [self.loader.swimSound]) pos = base.localAvatar.getPos(render) base.localAvatar.d_playSplashEffect(pos[0], pos[1], -2.3) self.toonSubmerged = 1 def __emergeToon(self): if self.toonSubmerged == 0: return self.notify.debug('continuing in __emergeToon') if hasattr(self, 'walkStateData'): self.walkStateData.fsm.request('walking') self.toonSubmerged = 0 # The client April Toons Manager is currently broken, so we have to do this hacky thing instead. :( #if hasattr(base.cr, 'aprilToonsMgr'): #if self.isEventActive(AprilToonsGlobals.EventEstateGravity): #base.localAvatar.startAprilToonsControls() if base.config.GetBool('want-april-toons'): base.localAvatar.startAprilToonsControls() def __setUnderwaterFog(self): if base.wantFog: self.fog.setColor(Vec4(0.0, 0.0, 0.6, 1.0)) self.fog.setLinearRange(0.1, 100.0) render.setFog(self.fog) self.loader.hood.sky.setFog(self.fog) def __setWhiteFog(self): if base.wantFog: self.fog.setColor(Vec4(0.8, 0.8, 0.8, 1.0)) self.fog.setLinearRange(0.0, 400.0) render.setFog(self.fog) self.loader.hood.sky.setFog(self.fog) def __setFaintFog(self): if base.wantFog: self.fog.setColor(Vec4(0.8, 0.8, 0.8, 1.0)) self.fog.setLinearRange(0.0, 700.0) render.setFog(self.fog)
class CTSafeZoneLoader(SafeZoneLoader): notify = directNotify.newCategory('CTSafeZoneLoader') bldgPoints = [Point3(0, 0, 0), Point3(0, 95, 0), Point3(75, 0, 0), Point3(75, 95, 0), Point3(-110, 0, 0), Point3(-185, 0, 0), Point3(-110, 95, 0), Point3(-185, 95, 0), Point3(-296.5, 0, 0), Point3(-296.5, 95, 0), Point3(-372, 95, 0), Point3(-372, 0, 0), Point3(189, 0, 0), Point3(189, 95, 0), Point3(264, 95, 0), Point3(264, 0, 0), Point3(264, 221.5, 0), Point3(264, 318, 0), Point3(188, 318, 0), Point3(188, 221.5, 0), Point3(75, 221.5, 0), Point3(75, 318, 0), Point3(0, 221.5, 0), Point3(0, 318, 0), Point3(-110, 318, 0), Point3(-110, 221.5, 0), Point3(-185, 318, 0), Point3(-185, 221.5, 0), Point3(-296.5, 318, 0), Point3(-296.5, 221.5, 0), Point3(-372, 318, 0), Point3(-372, 221.5, 0)] bldgSectionData = [[Point3(0, 0, 0), Vec3(0, 0, 0)], [Point3(-38.59, -43.57, 0), Vec3(180, 0, 0)]] tLightData = [[(0.71, -2.06, 0.0), (0, 0, 0)], [(0.71, -226.17, -0.59), (0, 0, 0)], [(0.71, -451.44, 0.0), (0, 0, 0)], [(0.71, 221.32, 0), (0, 0, 0)], [(-39.05, 404.94, 0), (180, 0, 0)], [(-221.31, 404.94, 0.0), (180, 0, 0)], [(147.93, 404.94, 0), (180, 0, 0)], [(187.76, 221.68, 0), (0, 0, 0)], [(187.76, -1.82, 0), (0, 0, 0)], [(187.76, -227.4, -0.59), (0, 0, 0)], [(187.76, -451.28, 0), (0, 0, 0)], [(-185.21, -451.28, 0), (0, 0, 0)], [(-185.21, -226.94, 0), (0, 0, 0)], [(-185.21, -1.95, 0), (0, 0, 0)], [(-185.21, 221.7, 0), (0, 0, 0)]] def __init__(self, hood, parentFSMState, doneEvent): SafeZoneLoader.__init__(self, hood, parentFSMState, doneEvent) self.playground = CTPlayground.CTPlayground self.pgMusicFilename = 'phase_12/audio/bgm/Bossbot_Entry_v1.mid' self.interiorMusicFilename = None self.battleMusicFile = None self.invasionMusicFiles = None self.tournamentMusicFiles = None self.bossBattleMusicFile = None self.dnaFile = None self.szStorageDNAFile = None self.buildingSectionNodes = [] self.trafficLightNodes = [] self.trafficLights = [] self.fog = None self.rain = None self.rainRender = None self.soundRain = None self.thunderSounds = [base.loadSfx('phase_14/audio/sfx/big_thunder_1.mp3'), base.loadSfx('phase_14/audio/sfx/big_thunder_2.mp3'), base.loadSfx('phase_14/audio/sfx/big_thunder_3.mp3'), base.loadSfx('phase_14/audio/sfx/big_thunder_4.mp3'), base.loadSfx('phase_14/audio/sfx/big_thunder_5.mp3'), base.loadSfx('phase_14/audio/sfx/big_thunder_6.mp3'), base.loadSfx('phase_14/audio/sfx/big_thunder_7.mp3'), base.loadSfx('phase_14/audio/sfx/big_thunder_8.mp3'), base.loadSfx('phase_14/audio/sfx/big_thunder_9.mp3'), base.loadSfx('phase_14/audio/sfx/big_thunder_10.mp3')] return def load(self): SafeZoneLoader.load(self) self.soundRain = base.loadSfx('phase_14/audio/sfx/rain_ambient.mp3') self.rain = ParticleLoader.loadParticleEffect('phase_14/etc/rain.ptf') self.rain.setPos(0, 0, 5) self.rainRender = self.geom.attachNewNode('snowRender') self.rainRender.setDepthWrite(0) self.rainRender.setBin('fixed', 1) def unload(self): self.soundRain = None self.rain = None del self.rainRender SafeZoneLoader.unload(self) return def createSafeZone(self, foo): self.geom = loader.loadModel('phase_14/models/neighborhoods/cogtropolis.egg') self.geom.reparentTo(hidden) for i in range(2): bldgSectionNode = render.attachNewNode('bldgSection' + str(i)) bldgSectionNode.setPos(self.bldgSectionData[i][0]) bldgSectionNode.setHpr(self.bldgSectionData[i][1]) for point in self.bldgPoints: bldg = loader.loadModel('phase_14/models/props/cogtropolis_big_building_1.egg') bldg.reparentTo(bldgSectionNode) bldg.setPos(point) self.buildingSectionNodes.append(bldgSectionNode) for data in self.tLightData: node = render.attachNewNode('tlight-intersection-holder') node.setPos(data[0]) node.setHpr(data[1]) light = TrafficLight.TrafficLight() light.reparentTo(node) light.startFlashing() light2 = TrafficLight.TrafficLight(1) light2.reparentTo(node) light2.startFlashing() self.trafficLightNodes.append(node) self.trafficLights.append(light) self.trafficLights.append(light2) self.fog = Fog('CogTropolis-fog') self.fog.setColor(0.3, 0.3, 0.3) self.fog.setExpDensity(0.0075) self.geom.flattenMedium() gsg = base.win.getGsg() if gsg: self.geom.prepareScene(gsg) def unload(self): for trafficLight in self.trafficLights: trafficLight.destroy() del self.trafficLights for trafficLightN in self.trafficLightNodes: trafficLightN.removeNode() for section in self.buildingSectionNodes: section.removeNode() del self.trafficLightNodes del self.buildingSectionNodes del self.fog SafeZoneLoader.unload(self)
class DistributedEagleGame(DistributedMinigame): notify = directNotify.newCategory('DistributedEagleGame') Round2MusicSpeed = {1: 1.0, 2: 1.15, 3: 1.35} def __init__(self, cr): DistributedMinigame.__init__(self, cr) self.platformPositions = {0: (-5, 0.5, -0.5), 1: (-15, 0.5, -0.5), 2: (5, 0.5, -0.5), 3: (15, 0.5, -0.5)} self.fsm.addState(State('roundCountdown', self.enterRoundCountdown, self.exitRoundCountdown, ['play'])) self.fsm.addState(State('roundOver', self.enterRoundOver, self.exitRoundOver, ['finalScores', 'roundCountdown'])) self.fsm.addState(State('finalScores', self.enterFinalScores, self.exitFinalScores, ['gameOver'])) self.fsm.getStateNamed('waitForOthers').addTransition('roundCountdown') self.fsm.getStateNamed('play').addTransition('roundOver') self.fsm.getStateNamed('gameOver').addTransition('finalScores') self.cannonFSM = ClassicFSM('Cannon', [State('off', self.enterOff, self.exitOff), State('control', self.enterControlCannon, self.exitControlCannon), State('fly', self.enterFly, self.exitFly)], 'off', 'off') self.cannonFSM.enterInitialState() self.hitEagleSfx = None self.toonOof = None self.cannonMoveSfx = None self.fallSfx = None self.bgColor = (0.05, 0.05, 0.05) self.cannonId = None self.cannonBarrel = '**/cannon' self.fog = None self.platforms = [] self.round = 0 self.world = None self.worldModelPath = 'phase_5/models/cogdominium/tt_m_ara_cfg_quadrant2.bam' self.nodesToStash = ['lights', 'streamers', 'tt_m_ara_cfg_girders2b:Rwall_col', 'tt_m_ara_cfg_girders2b:Lwall_col'] self.triggers = ['tt_m_ara_cfg_clump2:col_clump2', 'tt_m_ara_cfg_clump4:col_clump4', 'tt_m_ara_cfg_clump5:col_clump5', 'tt_m_ara_cfg_clump6:col_clump6', 'tt_m_ara_cfg_clump7:col_clump7', 'tt_m_ara_cfg_base:ceiling_collision'] return def allRoundsEnded(self): self.fsm.request('finalScores') def roundOver(self): if self.cannonId == None: self.__handleMissedEagle() self.fsm.request('roundOver') return def enterControlCannon(self): self.__setupCamera(1) self.cannon = self.cr.doId2do.get(self.cannonId) array = [] array.append(inputState.watchWithModifiers('cannonUp', 'arrow_up', inputSource=inputState.ArrowKeys)) array.append(inputState.watchWithModifiers('cannonDown', 'arrow_down', inputSource=inputState.ArrowKeys)) array.append(inputState.watchWithModifiers('cannonLeft', 'arrow_left', inputSource=inputState.ArrowKeys)) array.append(inputState.watchWithModifiers('cannonRight', 'arrow_right', inputSource=inputState.ArrowKeys)) self.cist = array taskMgr.add(self.__handleCannonControls, 'DEagleGame-handleCannonControls') taskMgr.add(self.__broadcastCannonAndLTTask, 'DEagleGame-broadcastCannonAndLT') self.acceptOnce('control', self.controlKeyPressed) def broadcastLTPos(self): lt = base.localAvatar lt.d_setPosHpr(lt.getX(render), lt.getY(render), lt.getZ(render), lt.getH(render), lt.getP(render), lt.getR(render)) def __broadcastCannonAndLTTask(self, task): self.cannon.d_setBarrelOrientation(self.cannon.find(self.cannonBarrel).getH(), self.cannon.find(self.cannonBarrel).getP()) self.broadcastLTPos() task.delayTime = 0.5 return task.again def __handleCannonControls(self, task): up = inputState.isSet('cannonUp') down = inputState.isSet('cannonDown') left = inputState.isSet('cannonLeft') right = inputState.isSet('cannonRight') dt = globalClock.getDt() upAmount = 30 * dt downAmount = 45 * dt leftAmount = 45 * dt rightAmount = 45 * dt if up: self.cannon.find(self.cannonBarrel).setP(self.cannon.find(self.cannonBarrel).getP() + upAmount) elif down: self.cannon.find(self.cannonBarrel).setP(self.cannon.find(self.cannonBarrel).getP() - downAmount) if left: self.cannon.find(self.cannonBarrel).setH(self.cannon.find(self.cannonBarrel).getH() + leftAmount) elif right: self.cannon.find(self.cannonBarrel).setH(self.cannon.find(self.cannonBarrel).getH() - rightAmount) if up or down or left or right: if self.cannonMoveSfx.status() == self.cannonMoveSfx.READY: base.playSfx(self.cannonMoveSfx) elif self.cannonMoveSfx.status() == self.cannonMoveSfx.PLAYING: self.cannonMoveSfx.stop() return task.cont def exitControlCannon(self): self.ignore('control') taskMgr.remove('DEagleGame-handleCannonControls') taskMgr.remove('DEagleGame-broadcastCannonAndLT') for token in self.cist: token.release() del self.cist del self.cannon def controlKeyPressed(self): self.cannon.d_shoot() self.cannon.shoot() self.cannonFSM.request('fly') def __handleEagleHit(self, eagleId): self.toonOof.play() self.hitEagleSfx.play() self.sendUpdate('hitEagle', [eagleId]) def enterFly(self): self.acceptOnce(EGG.EAGLE_HIT_EVENT, self.__handleEagleHit) self.__setupCamera() cannon = self.cr.doId2do.get(self.cannonId) base.localAvatar.b_lookAtObject(0, 0, 0, blink=0) base.localAvatar.b_setAnimState('swim') dummyNode = NodePath('dummyNode') dummyNode.reparentTo(base.localAvatar) dummyNode.setPos(0, 160, -90) base.localAvatar.setPos(base.localAvatar.getPos(render)) base.localAvatar.setHpr(cannon.find(self.cannonBarrel).getHpr(render)) base.localAvatar.reparentTo(render) self.flyProjectile = FlightProjectileInterval(base.localAvatar, startPos=cannon.find(self.cannonBarrel).getPos(render) + (0, 5.0, 0), endPos=dummyNode.getPos(render), duration=5.0, name='DEagleGame-localAvatarFly', gravityMult=0.25) self.flyProjectile.setDoneEvent(self.flyProjectile.getName()) self.acceptOnce(self.flyProjectile.getDoneEvent(), self.__handleMissedEagle) self.flyProjectile.start() dummyNode.removeNode() del dummyNode self.cannonId = None del cannon base.localAvatar.startPosHprBroadcast() base.localAvatar.d_broadcastPositionNow() return def __handleMissedEagle(self): base.playSfx(self.fallSfx) self.sendUpdate('missedEagle', []) def exitFly(self): self.ignore(EGG.EAGLE_HIT_EVENT) self.ignore(self.flyProjectile.getDoneEvent()) self.flyProjectile.pause() del self.flyProjectile def __setupCamera(self, inCannon = 0): if inCannon: cannon = self.cr.doId2do.get(self.cannonId) camera.reparentTo(cannon) else: camera.reparentTo(base.localAvatar) camera.setPos(0.0, -14.75, 6.33) camera.setP(356.82) def enterPlay(self): DistributedMinigame.enterPlay(self) self.music.setPlayRate(self.Round2MusicSpeed[self.getRound()]) self.createTimer() if self.cannonId != None: self.cannonFSM.request('control') return def exitPlay(self): self.cannonFSM.request('off') self.deleteTimer() DistributedMinigame.exitPlay(self) def enterCannon(self, cannonId): self.cannonId = cannonId self.cannon = self.cr.doId2do.get(cannonId) base.localAvatar.stopPosHprBroadcast() base.localAvatar.d_clearSmoothing() self.broadcastLTPos() base.localAvatar.reparentTo(self.cannon.find(self.cannonBarrel)) base.localAvatar.setPosHpr(0, 3.5, 0, 90, -90, 90) base.localAvatar.b_setAnimState('neutral') base.localAvatar.b_lookAtObject(0, 90, 0, blink=0) base.localAvatar.animFSM.request('off') self.broadcastLTPos() if self.fsm.getCurrentState().getName() == 'play': self.cannonFSM.request('control') else: self.__setupCamera(1) def startRound(self, roundNum): self.round = roundNum self.fsm.request('roundCountdown', [roundNum]) def getRound(self): return self.round def enterRoundCountdown(self, roundNum): self.text = getGameText() self.track = Sequence(Func(self.text.setText, 'Round {0}'.format(roundNum)), getRoundIval(self.text), Func(self.text.setText, '3'), getCountdownIval(self.text), Func(self.text.setText, '2'), getCountdownIval(self.text), Func(self.text.setText, '1'), getCountdownIval(self.text), Func(self.fsm.request, 'play')) self.track.start() def exitRoundCountdown(self): self.track.pause() del self.track self.text.destroy() del self.text def enterRoundOver(self): self.text = getGameText() self.track = Sequence(Func(self.text.setText, "Time's Up!"), getRoundIval(self.text), Func(base.transitions.fadeOut, 1.0), Wait(2.0), Func(base.transitions.fadeIn, 1.0)) self.track.start() def exitRoundOver(self): self.track.pause() del self.track self.text.destroy() del self.text def allPlayersReady(self): self.waitLbl.hide() def load(self): self.hitEagleSfx = base.loadSfx('phase_4/audio/sfx/AA_drop_anvil_miss.mp3') self.hitObstacleSfx = base.loadSfx('phase_4/audio/sfx/MG_cannon_hit_tower.mp3') self.toonOof = base.loadSfx('phase_5/audio/sfx/tt_s_ara_cfg_toonHit.mp3') self.cannonMoveSfx = base.loadSfx('phase_4/audio/sfx/MG_cannon_adjust.mp3') self.cannonMoveSfx.setLoop(True) self.fallSfx = base.loadSfx('phase_4/audio/sfx/MG_sfx_vine_game_fall.mp3') self.setMinigameMusic('phase_9/audio/bgm/CHQ_FACT_bg.mid') self.setDescription('Shoot as many flying Legal Eagles as you can using your cannon. Use the arrow keys to aim your cannon and press the control key to fire.') self.setWinnerPrize(60) self.setLoserPrize(20) base.setBackgroundColor(*self.bgColor) self.world = loader.loadModel(self.worldModelPath) for nodeName in self.nodesToStash: node = self.world.find('**/' + nodeName) node.removeNode() self.world.find('**/tt_m_ara_cfg_clump7:clump7').setY(30.0) self.world.find('**/tt_m_ara_cfg_eagleNest:eagleNest_mesh').setY(30.0) self.world.setColorScale(0.75, 0.75, 0.75, 1.0) self.world.reparentTo(base.render) self.world.setZ(-5.0) for i in range(len(self.platformPositions.keys())): platform = loader.loadModel('phase_9/models/cogHQ/platform1.bam') platform.find('**/platformcollision').removeNode() platform.reparentTo(render) platform.setPos(*self.platformPositions[i]) self.platforms.append(platform) for triggerName in self.triggers: trigger = self.world.find('**/' + triggerName) trigger.setCollideMask(CIGlobals.WallBitmask) self.accept('enter' + triggerName, self.__handleHitWall) self.fog = Fog('DEagleGame-sceneFog') self.fog.setColor(*self.bgColor) self.fog.setExpDensity(0.01) render.setFog(self.fog) DistributedMinigame.load(self) def __handleHitWall(self, entry): self.toonOof.play() self.hitObstacleSfx.play() self.sendUpdate('missedEagle') def playMinigameMusic(self): DistributedMinigame.playMinigameMusic(self) self.music.setVolume(0.3) def announceGenerate(self): DistributedMinigame.announceGenerate(self) base.localAvatar.disableChatInput() self.load() def disable(self): for triggerName in self.triggers: self.ignore('enter' + triggerName) base.localAvatar.createChatInput() camera.reparentTo(render) camera.setPosHpr(0, 0, 0, 0, 0, 0) render.clearFog() self.triggers = None self.toonOof = None self.hitEagleSfx = None self.hitObstacleSfx = None self.cannonMoveSfx = None self.fallSfx = None if self.world: self.world.removeNode() self.world = None self.worldModelPath = None self.nodesToStash = None self.fog = None self.round = None for platform in self.platforms: platform.removeNode() self.platforms = None self.cannonId = None self.cannonBarrel = None self.platformPositions = None base.setBackgroundColor(CIGlobals.DefaultBackgroundColor) self.bgColor = None DistributedMinigame.disable(self) return
class FogDemo(ShowBase): # Macro-like function used to reduce the amount to code needed to create the # on screen instructions def genLabelText(self, i, text): return OnscreenText(text=text, parent=base.a2dTopLeft, scale=.05, pos=(0.06, -.065 * i), fg=(1, 1, 1, 1), align=TextNode.ALeft) 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) # Standard initialization stuff # Standard title that's on screen in every tutorial self.title = OnscreenText(text="Panda3D: Tutorial - Fog", style=1, fg=(1, 1, 1, 1), shadow=(0, 0, 0, .5), parent=base.a2dBottomRight, align=TextNode.ARight, pos=(-0.1, 0.1), scale=.08) # Code to generate the on screen instructions self.escapeEventText = self.genLabelText(1, "ESC: Quit") self.pkeyEventText = self.genLabelText(2, "[P]: Pause") self.tkeyEventText = self.genLabelText(3, "[T]: Toggle Fog") self.dkeyEventText = self.genLabelText(4, "[D]: Make fog color black") self.sdkeyEventText = self.genLabelText(5, "[SHIFT+D]: Make background color black") self.rkeyEventText = self.genLabelText(6, "[R]: Make fog color red") self.srkeyEventText = self.genLabelText(7, "[SHIFT+R]: Make background color red") self.bkeyEventText = self.genLabelText(8, "[B]: Make fog color blue") self.sbkeyEventText = self.genLabelText(9, "[SHIFT+B]: Make background color blue") self.gkeyEventText = self.genLabelText(10, "[G]: Make fog color green") self.sgkeyEventText = self.genLabelText(11, "[SHIFT+G]: Make background color green") self.lkeyEventText = self.genLabelText(12, "[L]: Make fog color light grey") self.slkeyEventText = self.genLabelText(13, "[SHIFT+L]: Make background color light grey") self.pluskeyEventText = self.genLabelText(14, "[+]: Increase fog density") self.minuskeyEventText = self.genLabelText(15, "[-]: Decrease fog density") # disable mouse control so that we can place the camera base.disableMouse() camera.setPosHpr(0, 0, 10, 0, -90, 0) base.setBackgroundColor(0, 0, 0) # set the background color to black # World specific-code # Create an instance of fog called 'distanceFog'. #'distanceFog' is just a name for our fog, not a specific type of fog. self.fog = Fog('distanceFog') # Set the initial color of our fog to black. self.fog.setColor(0, 0, 0) # Set the density/falloff of the fog. The range is 0-1. # The higher the numer, the "bigger" the fog effect. self.fog.setExpDensity(.08) # We will set fog on render which means that everything in our scene will # be affected by fog. Alternatively, you could only set fog on a specific # object/node and only it and the nodes below it would be affected by # the fog. render.setFog(self.fog) # Define the keyboard input # Escape closes the demo self.accept('escape', sys.exit) # Handle pausing the tunnel self.accept('p', self.handlePause) # Handle turning the fog on and off self.accept('t', toggleFog, [render, self.fog]) # Sets keys to set the fog to various colors self.accept('r', self.fog.setColor, [1, 0, 0]) self.accept('g', self.fog.setColor, [0, 1, 0]) self.accept('b', self.fog.setColor, [0, 0, 1]) self.accept('l', self.fog.setColor, [.7, .7, .7]) self.accept('d', self.fog.setColor, [0, 0, 0]) # Sets keys to change the background colors self.accept('shift-r', base.setBackgroundColor, [1, 0, 0]) self.accept('shift-g', base.setBackgroundColor, [0, 1, 0]) self.accept('shift-b', base.setBackgroundColor, [0, 0, 1]) self.accept('shift-l', base.setBackgroundColor, [.7, .7, .7]) self.accept('shift-d', base.setBackgroundColor, [0, 0, 0]) # Increases the fog density when "+" key is pressed self.accept('+', self.addFogDensity, [.01]) # This is to handle the other "+" key (it's over = on the keyboard) self.accept('=', self.addFogDensity, [.01]) self.accept('shift-=', self.addFogDensity, [.01]) # Decreases the fog density when the "-" key is pressed self.accept('-', self.addFogDensity, [-.01]) # Load the tunel and start the tunnel self.initTunnel() self.contTunnel() # This function will change the fog density by the amount passed into it # This function is needed so that it can look up the current value and # change it when the key is pressed. If you wanted to bind a key to set it # at a given value you could call self.fog.setExpDensity directly def addFogDensity(self, change): # The min() statement makes sure the density is never over 1 # The max() statement makes sure the density is never below 0 self.fog.setExpDensity( min(1, max(0, self.fog.getExpDensity() + change))) # Code to initialize the tunnel def initTunnel(self): self.tunnel = [None] * 4 for x in range(4): # Load a copy of the tunnel self.tunnel[x] = loader.loadModel('models/tunnel') # The front segment needs to be attached to render if x == 0: self.tunnel[x].reparentTo(render) # The rest of the segments parent to the previous one, so that by moving # the front segement, the entire tunnel is moved else: self.tunnel[x].reparentTo(self.tunnel[x - 1]) # We have to offset each segment by its length so that they stack onto # each other. Otherwise, they would all occupy the same space. self.tunnel[x].setPos(0, 0, -TUNNEL_SEGMENT_LENGTH) # Now we have a tunnel consisting of 4 repeating segments with a # hierarchy like this: # render<-tunnel[0]<-tunnel[1]<-tunnel[2]<-tunnel[3] # This function is called to snap the front of the tunnel to the back # to simulate traveling through it def contTunnel(self): # This line uses slices to take the front of the list and put it on the # back. For more information on slices check the Python manual self.tunnel = self.tunnel[1:] + self.tunnel[0:1] # Set the front segment (which was at TUNNEL_SEGMENT_LENGTH) to 0, which # is where the previous segment started self.tunnel[0].setZ(0) # Reparent the front to render to preserve the hierarchy outlined above self.tunnel[0].reparentTo(render) # Set the scale to be apropriate (since attributes like scale are # inherited, the rest of the segments have a scale of 1) self.tunnel[0].setScale(.155, .155, .305) # Set the new back to the values that the rest of teh segments have self.tunnel[3].reparentTo(self.tunnel[2]) self.tunnel[3].setZ(-TUNNEL_SEGMENT_LENGTH) self.tunnel[3].setScale(1) # Set up the tunnel to move one segment and then call contTunnel again # to make the tunnel move infinitely self.tunnelMove = Sequence( LerpFunc(self.tunnel[0].setZ, duration=TUNNEL_TIME, fromData=0, toData=TUNNEL_SEGMENT_LENGTH * .305), Func(self.contTunnel) ) self.tunnelMove.start() # This function calls toggle interval to pause or unpause the tunnel. # Like addFogDensity, toggleInterval could not be passed directly in the # accept command since the value of self.tunnelMove changes whenever #self.contTunnel is called def handlePause(self): toggleInterval(self.tunnelMove)
class Terrain(): def __init__(self, _heightField): texture = loader.loadTexture("ground_tex.png") self.zScale = 45 self.terrain = GeoMipTerrain("BasicTerrain") self.terrain.setHeightfield(_heightField) # Dynamic settings? self.terrain.setBlockSize(16) self.terrain.setNear(20) self.terrain.setFar(100) self.terrain.setFocalPoint(base.camera) # Settings self.terrain.getRoot().setSz(self.zScale) self.terrain.getRoot().setTexture(texture) self.terrain.getRoot().reparentTo(render) self.terrain.generate() self.terrainSize = (self.terrain.heightfield().getReadXSize(), self.terrain.heightfield().getReadYSize()) print "Terrain Size:", self.terrainSize taskMgr.add(self.terrainTask, "TerrainTask") self.skydome = loader.loadModel("Skydome") self.skydome.setDepthTest(False) self.skydome.setAttrib(CullBinAttrib.make("skydomeBin", 1000)) self.skydome.reparentTo(camera) self.skydome.setScale(2) self.skydome.setPos(0, 0, -0.5) self.skydome.setCollideMask(BitMask32.allOff()) taskMgr.add(self.skydomeTask, "paperplanet_skydome") # Add some fancy fog self.fog = Fog("Fog Name") self.fog.setColor(0.4,0.2,0.3) self.fog.setExpDensity(0.015) render.setFog(self.fog) # Some Test light dlight = DirectionalLight("dlight") dlight.setColor(VBase4(0.8, 0.8, 0.5, 1)) dlnp = render.attachNewNode(dlight) dlnp.setHpr(0, -60, 0) render.setLight(dlnp) # Add basic blacksmith hut tmp = loader.loadModel("blacksmith_hut") tmp.reparentTo(render) tmp.setPos(164.054, 340.92, 11.3384) def skydomeTask(self, task): self.skydome.setHpr(render, 0,0,0) return task.cont def terrainTask(self, task): # tmp self.terrain.update() return task.cont
def setup(self): # Debug (useful to turn on for physics) self.debugNP = self.render.attachNewNode(BulletDebugNode('Debug')) self.debugNP.hide() # Physics World self.world = BulletWorld() self.world.setGravity(Vec3(0, 0, -9.81)) self.world.setDebugNode(self.debugNP.node()) # Main Character self.player = Player() self.player.createPlayer(render, self.world) # Enemies self.createEnemies() # Music self.backgroundMusic = loader.loadSfx('../sounds/elfman-piano-solo.ogg') self.backgroundMusic.setLoop(True) self.backgroundMusic.stop() self.backgroundMusic.setVolume(0.9) # lower this when I add sound effects # Sound Effects self.collect = base.loader.loadSfx("../sounds/collect-sound.wav") self.collect.setVolume(1) self.damage = base.loader.loadSfx("../sounds/damage.wav") self.damage.setVolume(0.5) self.winner = base.loader.loadSfx("../sounds/win-yay.wav") self.winner.setVolume(1) self.dead = base.loader.loadSfx("../sounds/severe-damage.wav") self.dead.setVolume(1) # Level 1 Skybox self.skybox = loader.loadModel('../models/skybox_galaxy.egg') self.skybox.setScale(1000) # make big enough to cover whole terrain self.skybox.setBin('background', 1) self.skybox.setDepthWrite(0) self.skybox.setLightOff() self.skybox.reparentTo(render) # Lighting dLight = DirectionalLight("dLight") dLight.setColor(Vec4(0.8, 0.8, 0.5, 1)) dLight.setDirection(Vec3(-5, -5, -5)) dlnp = render.attachNewNode(dLight) dlnp.setHpr(0, 60, 0) render.setLight(dlnp) aLight = AmbientLight("aLight") aLight.setColor(Vec4(0.5, 0.5, 0.5, 1)) alnp = render.attachNewNode(aLight) render.setLight(alnp) # Fog colour = (0.2, 0.2, 0.3) genfog = Fog("general fog") genfog.setColor(*colour) genfog.setExpDensity(0.003) render.setFog(genfog) base.setBackgroundColor(*colour) # Create wall (x, y, z, h) self.createWall(-30.2215, -6.2, -2, 45) self.createWall(-203, 555.8, -2, 70) #-----Level 1 Platforms----- # Platform to collect B self.createPlatform(72, 70.2927, -1) # Platforms to collect R self.createPlatform(211, 210, -1) self.createPlatform(225, 223, 2.7) # Platforms to collect E and A self.createPlatform(330, 462, -0.4) self.createPlatform(340, 471, 2.1) self.createPlatform(350, 480, 4) self.createPlatform(335, 483, 5) # Platforms to collect K self.createPlatform(184, 712, -1) self.createPlatform(208, 730, -1) self.createPlatform(207, 711, -1) self.createPlatform(186, 731, -1) #-----Level 2 Platforms----- # Moving platforms if self.movingPlatforms > 0: del self.movingPlatforms[:] self.createMovingPlatforms() # Create complex mesh for Track using BulletTriangleMeshShape mesh = BulletTriangleMesh() self.track = loader.loadModel("../models/mountain_valley_track.egg") self.track.flattenStrong() for geomNP in self.track.findAllMatches('**/+GeomNode'): geomNode = geomNP.node() ts = geomNP.getTransform(self.track) for geom in geomNode.getGeoms(): mesh.addGeom(geom, ts) shape = BulletTriangleMeshShape(mesh, dynamic=False) node = BulletRigidBodyNode('Track') node.setMass(0) node.addShape(shape) tracknn = render.attachNewNode(node) self.world.attachRigidBody(tracknn.node()) tracknn.setPos(27, -5, -2) self.track.reparentTo(tracknn)
class Estate(Place.Place): notify = DirectNotifyGlobal.directNotify.newCategory('Estate') def __init__(self, loader, avId, zoneId, parentFSMState, doneEvent): Place.Place.__init__(self, None, doneEvent) self.id = MyEstate self.avId = avId self.zoneId = zoneId self.loader = loader self.cameraSubmerged = -1 self.toonSubmerged = -1 self.fsm = ClassicFSM.ClassicFSM('Estate', [ State.State('init', self.enterInit, self.exitInit, ['final', 'teleportIn', 'doorIn', 'walk']), State.State('petTutorial', self.enterPetTutorial, self.exitPetTutorial, ['walk']), State.State('walk', self.enterWalk, self.exitWalk, [ 'final', 'sit', 'stickerBook', 'options', 'quest', 'fishing', 'mailbox', 'stopped', 'DFA', 'trialerFA', 'doorOut', 'push', 'pet', 'purchase' ]), State.State('stopped', self.enterStopped, self.exitStopped, ['walk', 'teleportOut']), State.State('sit', self.enterSit, self.exitSit, ['walk']), State.State('push', self.enterPush, self.exitPush, ['walk']), State.State( 'stickerBook', self.enterStickerBook, self.exitStickerBook, [ 'walk', 'sit', 'quest', 'fishing', 'mailbox', 'stopped', 'doorOut', 'push', 'pet', 'DFA', 'trialerFA' ]), State.State('teleportIn', self.enterTeleportIn, self.exitTeleportIn, ['walk', 'petTutorial']), State.State('teleportOut', self.enterTeleportOut, self.exitTeleportOut, ['teleportIn', 'walk', 'final']), State.State('doorIn', self.enterDoorIn, self.exitDoorIn, ['walk']), State.State('doorOut', self.enterDoorOut, self.exitDoorOut, ['final', 'walk']), State.State('final', self.enterFinal, self.exitFinal, ['teleportIn']), State.State('quest', self.enterQuest, self.exitQuest, ['walk']), State.State('fishing', self.enterFishing, self.exitFishing, ['walk', 'stopped']), State.State('mailbox', self.enterMailbox, self.exitMailbox, ['walk', 'stopped']), State.State('stopped', self.enterStopped, self.exitStopped, ['walk']), State.State('pet', self.enterPet, self.exitPet, ['walk', 'trialerFA']), State.State('trialerFA', self.enterTrialerFA, self.exitTrialerFA, ['trialerFAReject', 'DFA']), State.State('trialerFAReject', self.enterTrialerFAReject, self.exitTrialerFAReject, ['walk']), State.State('DFA', self.enterDFA, self.exitDFA, ['DFAReject', 'teleportOut']), State.State('purchase', self.enterPurchase, self.exitPurchase, ['walk']), State.State('DFAReject', self.enterDFAReject, self.exitDFAReject, ['walk']) ], 'init', 'final') self.fsm.enterInitialState() self.doneEvent = doneEvent self.parentFSMState = parentFSMState return def delete(self): self.unload() def load(self): Place.Place.load(self) self.fog = Fog('EstateFog') taskMgr.add(self.__checkCameraUnderwater, 'estate-check-cam-underwater') path = self.loader.geom.find('**/Path') path.setBin('ground', 10, 1) self.parentFSMState.addChild(self.fsm) def unload(self): self.ignoreAll() self.notify.info( 'remove estate-check-toon-underwater to TaskMgr in unload()') taskMgr.remove('estate-check-toon-underwater') taskMgr.remove('estate-check-cam-underwater') self.parentFSMState.removeChild(self.fsm) del self.fsm self.fog = None Place.Place.unload(self) return def enter(self, requestStatus): hoodId = requestStatus['hoodId'] zoneId = requestStatus['zoneId'] newsManager = base.cr.newsManager if config.GetBool('want-estate-telemetry-limiter', 1): limiter = TLGatherAllAvs('Estate', RotationLimitToH) else: limiter = TLNull() self._telemLimiter = limiter if newsManager: holidayIds = base.cr.newsManager.getDecorationHolidayId() if (ToontownGlobals.HALLOWEEN_COSTUMES in holidayIds or ToontownGlobals.SPOOKY_COSTUMES in holidayIds) and self.loader.hood.spookySkyFile: lightsOff = Sequence( LerpColorScaleInterval(base.cr.playGame.hood.loader.geom, 0.1, Vec4(0.55, 0.55, 0.65, 1)), Func(self.loader.hood.startSpookySky)) lightsOff.start() else: self.loader.hood.startSky() lightsOn = LerpColorScaleInterval( base.cr.playGame.hood.loader.geom, 0.1, Vec4(1, 1, 1, 1)) lightsOn.start() else: self.loader.hood.startSky() lightsOn = LerpColorScaleInterval( base.cr.playGame.hood.loader.geom, 0.1, Vec4(1, 1, 1, 1)) lightsOn.start() self.loader.hood.sky.setFogOff() self.__setFaintFog() for i in self.loader.nodeList: self.loader.enterAnimatedProps(i) self.loader.geom.reparentTo(render) # The client April Toons Manager is currently broken, so we have to do this hacky thing instead. :( #if hasattr(base.cr, 'aprilToonsMgr'): #if self.isEventActive(AprilToonsGlobals.EventEstateGravity): #base.localAvatar.startAprilToonsControls() if base.config.GetBool('want-april-toons'): base.localAvatar.startAprilToonsControls() self.accept('doorDoneEvent', self.handleDoorDoneEvent) self.accept('DistributedDoor_doorTrigger', self.handleDoorTrigger) self.fsm.request(requestStatus['how'], [requestStatus]) def exit(self): base.localAvatar.stopChat() if base.config.GetBool('want-april-toons'): base.localAvatar.stopAprilToonsControls() self._telemLimiter.destroy() del self._telemLimiter if hasattr(self, 'fsm'): self.fsm.requestFinalState() self.loader.geom.reparentTo(hidden) for i in self.loader.nodeList: self.loader.exitAnimatedProps(i) self.loader.hood.stopSky() render.setFogOff() base.cr.cache.flush() def __setZoneId(self, zoneId): self.zoneId = zoneId def detectedMailboxCollision(self): self.fsm.request('mailbox') def detectedGardenPlotUse(self): if hasattr(self, 'fsm'): self.fsm.request('stopped') def detectedGardenPlotDone(self): if hasattr(self, 'fsm'): self.fsm.request('walk') def detectedFlowerSellUse(self): if hasattr(self, 'fsm'): self.fsm.request('stopped') def detectedFlowerSellDone(self): if hasattr(self, 'fsm'): self.fsm.request('walk') def doRequestLeave(self, requestStatus): self.fsm.request('trialerFA', [requestStatus]) def enterInit(self): pass def exitInit(self): pass def enterPurchase(self): Place.Place.enterPurchase(self) def exitPurchase(self): Place.Place.exitPurchase(self) def enterPetTutorial(self, bDummy=True): self.notify.info( 'remove estate-check-toon-underwater to TaskMgr in enterPetTutorial()' ) taskMgr.remove('estate-check-toon-underwater') self.petTutorialDoneEvent = 'PetTutorialDone' self.acceptOnce(self.petTutorialDoneEvent, self.petTutorialDone) self.petTutorial = PetTutorial.PetTutorial(self.petTutorialDoneEvent) def exitPetTutorial(self): self.notify.info( 'add estate-check-toon-underwater to TaskMgr in exitPetTutorial()') if hasattr(self, 'fsm'): taskMgr.add(self.__checkToonUnderwater, 'estate-check-toon-underwater') if hasattr(self, 'petTutorial') and self.petTutorial is not None: self.petTutorial.destroy() return def petTutorialDone(self): self.ignore(self.petTutorialDoneEvent) self.petTutorial.destroy() self.petTutorial = None self.fsm.request('walk', [1]) return def enterMailbox(self): Place.Place.enterPurchase(self) base.localAvatar.startSleepWatch(self.__handleFallingAsleepMailbox) self.enablePeriodTimer() def __handleFallingAsleepMailbox(self, arg): if hasattr(self, 'fsm'): self.fsm.request('walk') messenger.send('mailboxAsleep') base.localAvatar.forceGotoSleep() def exitMailbox(self): Place.Place.exitPurchase(self) base.localAvatar.stopSleepWatch() self.disablePeriodTimer() def enterTeleportIn(self, requestStatus): self._etiToken = self.addSetZoneCompleteCallback( Functor(self._teleportToHouse, requestStatus)) Place.Place.enterTeleportIn(self, requestStatus) def _teleportToHouse(self, requestStatus): try: houseDo = base.cr.doId2do.get(base.localAvatar.houseId) house = houseDo.house pos = house.getPos(render) base.localAvatar.detachNode() base.localAvatar.setPosHpr(house, 17, 3, 0, 125, 0, 0) except: x, y, z, h, p, r = HouseGlobals.defaultEntryPoint base.localAvatar.detachNode() base.localAvatar.setPosHpr(render, x, y, z, h, p, r) base.localAvatar.setScale(1, 1, 1) self.toonSubmerged = -1 self.notify.info( 'remove estate-check-toon-underwater to TaskMgr in enterTeleportIn()' ) taskMgr.remove('estate-check-toon-underwater') if base.wantPets: if base.localAvatar.hasPet( ) and not base.localAvatar.bPetTutorialDone: self.nextState = 'petTutorial' def teleportInDone(self): self.notify.debug('teleportInDone') self.toonSubmerged = -1 if self.nextState is not 'petTutorial': self.notify.info( 'add estate-check-toon-underwater to TaskMgr in teleportInDone()' ) if hasattr(self, 'fsm'): taskMgr.add(self.__checkToonUnderwater, 'estate-check-toon-underwater') Place.Place.teleportInDone(self) def exitTeleportIn(self): self.removeSetZoneCompleteCallback(self._etiToken) Place.Place.exitTeleportIn(self) def enterTeleportOut(self, requestStatus): Place.Place.enterTeleportOut(self, requestStatus, self.__teleportOutDone) def __teleportOutDone(self, requestStatus): if hasattr(self, 'fsm'): self.fsm.requestFinalState() hoodId = requestStatus['hoodId'] zoneId = requestStatus['zoneId'] avId = requestStatus['avId'] shardId = requestStatus['shardId'] if hoodId == ToontownGlobals.MyEstate and zoneId == self.getZoneId( ) and shardId == None: self.fsm.request('teleportIn', [requestStatus]) elif hoodId == ToontownGlobals.MyEstate and shardId == None: self.doneStatus = requestStatus self.getEstateZoneAndGoHome(requestStatus) else: self.doneStatus = requestStatus messenger.send(self.doneEvent, [self.doneStatus]) return def goHomeFailed(self, task): self.notifyUserGoHomeFailed() self.ignore('setLocalEstateZone') self.doneStatus['avId'] = -1 self.doneStatus['zoneId'] = self.getZoneId() self.fsm.request('teleportIn', [self.doneStatus]) return Task.done def exitTeleportOut(self): Place.Place.exitTeleportOut(self) def exitDoorIn(self): self.toonSubmerged = -1 self.notify.info( 'add estate-check-toon-underwater to TaskMgr in exitDoorIn()') if hasattr(self, 'fsm'): taskMgr.add(self.__checkToonUnderwater, 'estate-check-toon-underwater') Place.Place.exitDoorIn(self) def getZoneId(self): if self.zoneId: return self.zoneId else: self.notify.warning('no zone id available') def __checkCameraUnderwater(self, task): if base.camera.getZ(render) < -1.2: self.__submergeCamera() else: self.__emergeCamera() return Task.cont def __checkToonUnderwater(self, task): if base.localAvatar.getZ() < -4.0: self.__submergeToon() else: self.__emergeToon() return Task.cont def __submergeCamera(self): if self.cameraSubmerged == 1: return self.__setUnderwaterFog() base.playSfx(self.loader.underwaterSound, looping=1, volume=0.8) self.cameraSubmerged = 1 self.walkStateData.setSwimSoundAudible(1) def __emergeCamera(self): if self.cameraSubmerged == 0: return self.loader.underwaterSound.stop() self.loader.hood.sky.setFogOff() self.__setFaintFog() self.cameraSubmerged = 0 self.walkStateData.setSwimSoundAudible(0) def forceUnderWater(self): self.toonSubmerged = 0 self.__submergeToon() def __submergeToon(self): if self.toonSubmerged == 1: return self.notify.debug('continuing in __submergeToon') if hasattr(self, 'loader') and self.loader: base.playSfx(self.loader.submergeSound) if base.config.GetBool('disable-flying-glitch') == 0: self.fsm.request('walk') self.walkStateData.fsm.request('swimming', [self.loader.swimSound]) pos = base.localAvatar.getPos(render) base.localAvatar.d_playSplashEffect(pos[0], pos[1], -2.3) self.toonSubmerged = 1 def __emergeToon(self): if self.toonSubmerged == 0: return self.notify.debug('continuing in __emergeToon') if hasattr(self, 'walkStateData'): self.walkStateData.fsm.request('walking') self.toonSubmerged = 0 # The client April Toons Manager is currently broken, so we have to do this hacky thing instead. :( #if hasattr(base.cr, 'aprilToonsMgr'): #if self.isEventActive(AprilToonsGlobals.EventEstateGravity): #base.localAvatar.startAprilToonsControls() if base.config.GetBool('want-april-toons'): base.localAvatar.startAprilToonsControls() def __setUnderwaterFog(self): if base.wantFog: self.fog.setColor(Vec4(0.0, 0.0, 0.6, 1.0)) self.fog.setLinearRange(0.1, 100.0) render.setFog(self.fog) self.loader.hood.sky.setFog(self.fog) def __setWhiteFog(self): if base.wantFog: self.fog.setColor(Vec4(0.8, 0.8, 0.8, 1.0)) self.fog.setLinearRange(0.0, 400.0) render.setFog(self.fog) self.loader.hood.sky.setFog(self.fog) def __setFaintFog(self): if base.wantFog: self.fog.setColor(Vec4(0.8, 0.8, 0.8, 1.0)) self.fog.setLinearRange(0.0, 700.0) render.setFog(self.fog)
class VisualTest(ShowBase): 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 update(self, evt): self.var1 = self.var1 + 0.1 #self.dirLight.color = (self.var1,0,1,1) #self.dirLightPath.setHpr(self.var1,-self.var1,0) self.camera.setPos(60 + self.var1, 60 + self.var1, 20) #self.pointLightPath.setPos(30+self.var1 ,52.5,4) self.camera.lookAt(self.player) return Task.cont