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
