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 __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 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 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 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):
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 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
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)
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()
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 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
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")
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')
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 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 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 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 World(DirectObject):
# Initialize the world class
def __init__(self):
# A few window settings
base.disableMouse()
camera.setPosHpr(0, 0.5, 10, 0, -100, 0) #Vary this
base.setBackgroundColor(0, 0.5, 1)
# Load the Boeing707
self.scale = 0.04
self.xPos = 0.0
self.yPos = 0.0
self.tilt = 0.0
self.lift = 0.0
self.plane = loader.loadModel('./models/plane/boeing707')
self.plane.reparentTo(render)
self.plane.setScale(self.scale, self.scale, self.scale)
self.plane.setPosHpr(self.xPos, -0.7 + self.yPos, 0, 0, 270 + self.lift, self.tilt)
# Load fog into the view
self.fog = Fog('distanceFog')
self.fog.setColor(0, 0.5, 1)
self.fog.setExpDensity(.08)
render.setFog(self.fog)
# Load the tunnel and keep it running infinitely
self.initTunnel()
self.contTunnel()
# Key mappings
self.accept('escape', sys.exit)
self.accept('+', self.scaleUp)
self.accept('-', self.scaleDown)
try:
self.ser = serial.Serial('/dev/ttyUSB0', 9600)
taskMgr.add(self.serialTask, "serialTask")
except:
print("Could not open Serial port")
# The serial task
def serialTask(self, task):
reading = self.ser.readline()
if(reading != ""):
try:
if(reading[0] == 'y'):
x = float(reading[1:])
devX = (X_STABLE - x)
if(devX < -25):
self.moveLeft()
elif(devX > 25):
self.moveRight()
else:
self.stabilizeTilt()
if(reading[0] == 'x'):
y = float(reading[1:])
devY = (Y_STABLE - y)
if(devY < -25):
self.liftDown()
elif(devY > 25):
self.liftUp()
else:
self.stabilizeLift()
except:
pass
return Task.cont
# Make the Boeing stable on the tilt
def stabilizeTilt(self):
if(self.tilt > 0):
if(self.tilt != 0.0):
self.tilt = self.tilt - 0.25
else:
if(self.tilt != 0.0):
self.tilt = self.tilt + 0.25
self.plane.setPosHpr(self.xPos, -0.7 + self.yPos, 0, 0, 270 + self.lift, self.tilt)
# Make the Boeing stable on the lift
def stabilizeLift(self):
if(self.lift > 0):
if(self.lift != 0.0):
self.lift = self.lift - 0.25
else:
if(self.lift != 0.0):
self.lift = self.lift + 0.25
self.lift.setPosHpr(self.xPos, -0.7 + self.yPos, 0, 0, 270 + self.lift, self.tilt)
# Zoom into the plane
def scaleUp(self):
self.scale = self.scale + 0.005
self.plane.setScale(self.scale, self.scale, self.scale)
# Zoom out of the plane
def scaleDown(self):
self.scale = self.scale - 0.005
self.plane.setScale(self.scale, self.scale, self.scale)
# Move the plane right
def moveRight(self):
if(self.tilt >= MAX_TILT):
self.tilt = MAX_TILT
self.xPos = self.xPos + 0.01
self.tilt = self.tilt + 0.25
self.plane.setPosHpr(self.xPos, -0.7 + self.yPos, 0, 0, 270 + self.lift, self.tilt)
# Move the plane left
def moveLeft(self):
if(self.tilt <= -MAX_TILT):
self.tilt = -MAX_TILT
self.tilt = self.tilt - 0.25
self.xPos = self.xPos - 0.01
self.plane.setPosHpr(self.xPos, -0.7 + self.yPos, 0, 0, 270 + self.lift, self.tilt)
# Lift the plane up
def liftUp(self):
if(self.lift >= MAX_LIFT):
self.lift = MAX_LIFT
self.lift = self.lift + 0.25
self.yPos = self.yPos + 0.01
self.plane.setPosHpr(self.xPos, -0.7 + self.yPos, 0, 0, 270 + self.lift, self.tilt)
# Lift the plane down
def liftDown(self):
if(self.lift <= -MAX_LIFT):
self.lift = -MAX_LIFT
self.lift = self.lift - 0.25
self.yPos = self.yPos - 0.01
self.plane.setPosHpr(self.xPos, -0.7 + self.yPos, 0, 0, 270 + self.lift, self.tilt)
# The tunnel initialization function
def initTunnel(self):
self.tunnel = [None for i in range(4)]
for x in range(4):
self.tunnel[x] = loader.loadModel('models/terrain/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)
# Function to keep the tunnel running infinite
def contTunnel(self):
self.tunnel = self.tunnel[1:]+ self.tunnel[0:1]
self.tunnel[0].setZ(0)
self.tunnel[0].reparentTo(render)
self.tunnel[0].setScale(.455, .455, .605)
self.tunnel[3].reparentTo(self.tunnel[2])
self.tunnel[3].setZ(-TUNNEL_SEGMENT_LENGTH)
self.tunnel[3].setScale(1)
self.tunnelMove = Sequence(
LerpFunc(self.tunnel[0].setZ,
duration = TUNNEL_TIME,
fromData = 0,
toData = TUNNEL_SEGMENT_LENGTH*.305),
Func(self.contTunnel)
)
self.tunnelMove.start()
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
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 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 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 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 DistributedDodgeballGame(DistributedToonFPSGame, TeamMinigame):
notify = directNotify.newCategory('DistributedDodgeballGame')
TreeData = [
[
'prop_snow_tree_small_ur', Point3(23.23, 66.52, 7.46)],
[
'prop_snow_tree_small_ul', Point3(-34.03, 88.02, 24.17)],
[
'prop_snow_tree_small_ur', Point3(-54.8, 0, 4.19)],
[
'prop_snow_tree_small_ul', Point3(54.8, -5, 4.19)],
[
'prop_snow_tree_small_ur', Point3(62.71, 62.66, 16.8)],
[
'prop_snow_tree_small_ul', Point3(-23.23, -66.52, 6)],
[
'prop_snow_tree_small_ur', Point3(34.03, -88.02, 23)],
[
'prop_snow_tree_small_ul', Point3(-62.71, -62.66, 16)]]
SnowballData = [
Point3(30, 0, 0.75),
Point3(22.5, 0, 0.75),
Point3(15, 0, 0.75),
Point3(7.5, 0, 0.75),
Point3(0, 0, 0.75),
Point3(-7.5, 0, 0.75),
Point3(-15, 0, 0.75),
Point3(-22.5, 0, 0.75),
Point3(-30, 0, 0.75)]
GameSong = 'phase_4/audio/bgm/MG_Dodgeball.ogg'
GameDesc = 'Welcome to the north! You have been invited to play dodgeball with the penguins!\n\nHow To Play\nWASD to Move and use the mouse to aim.\nLeft click to Throw!\nThrow a snowball at a teammate to unfreeze them!\n\nObjective\nThe first team to freeze everyone!'
InitCamTrans = [
Point3(25, 45, 19.5317), Vec3(154.001, -15, 0)]
SnowBallDmg = 25
GetSnowBalls = 'Pick up a snowball from the center!'
Team2OtherBarrier = {BLUE: 'red_barrier_coll', RED: 'blue_barrier_coll'}
def __init__(self, cr):
try:
self.DistributedDodgeballGame_initialized
return
except:
self.DistributedDodgeballGame_initialized = 1
DistributedToonFPSGame.__init__(self, cr)
TeamMinigame.__init__(self, 'BlueSnow', ('phase_4/maps/db_blue_neutral.png',
'phase_4/maps/db_blue_hover.png',
'phase_4/maps/db_blue_hover.png'), 'RedIce', ('phase_4/maps/db_red_neutral.png',
'phase_4/maps/db_red_hover.png',
'phase_4/maps/db_red_hover.png'))
self.fsm.addState(State('chooseTeam', self.enterChooseTeam, self.exitChooseTeam, ['waitForOthers']))
self.fsm.addState(State('scrollBy', self.enterScrollBy, self.exitScrollBy, ['countdown']))
self.fsm.addState(State('countdown', self.enterCountdown, self.exitCountdown, ['play']))
self.fsm.addState(State('announceGameOver', self.enterAnnGameOver, self.exitAnnGameOver, ['displayWinners']))
self.fsm.addState(State('displayWinners', self.enterDisplayWinners, self.exitDisplayWinners, ['gameOver']))
self.fsm.getStateNamed('waitForOthers').addTransition('chooseTeam')
self.fsm.getStateNamed('waitForOthers').addTransition('scrollBy')
self.fsm.getStateNamed('play').addTransition('announceGameOver')
self.firstPerson = DodgeballFirstPerson(self)
self.scrollBySeq = None
self.infoText = None
self.redScoreLbl = None
self.blueScoreLbl = None
self.infoText = getAlertText()
self.spawnPointsByTeam = {BLUE: [
[
Point3(5, 15, 0), Vec3(180, 0, 0)],
[
Point3(15, 15, 0), Vec3(180, 0, 0)],
[
Point3(-5, 15, 0), Vec3(180, 0, 0)],
[
Point3(-15, 15, 0), Vec3(180, 0, 0)]],
RED: [
[
Point3(5, -15, 0), Vec3(0, 0, 0)],
[
Point3(15, -15, 0), Vec3(0, 0, 0)],
[
Point3(-5, -15, 0), Vec3(0, 0, 0)],
[
Point3(-15, -15, 0), Vec3(0, 0, 0)]]}
self.winnerMusic = base.loadMusic('phase_9/audio/bgm/encntr_hall_of_fame.mid')
self.loserMusic = base.loadMusic('phase_9/audio/bgm/encntr_sting_announce.mid')
self.danceSound = base.loadSfx('phase_3.5/audio/sfx/ENC_Win.ogg')
self.sky = None
self.arena = None
self.fog = None
self.snow = None
self.snowRender = None
self.trees = []
self.snowballs = []
return
def getTeamDNAColor(self, team):
print 'getTeamDNAColor'
if team == TEAM1:
print 'blue'
return ToonDNA.colorName2DNAcolor['blue']
if team == TEAM2:
print 'bright red'
return ToonDNA.colorName2DNAcolor['bright red']
def enterDisplayWinners(self):
base.localAvatar.stopLookAround()
base.localAvatar.resetHeadHpr()
base.localAvatar.getGeomNode().show()
camera.reparentTo(render)
camera.setPos((-2.5, 12, 3.5))
camera.setHpr((-175.074, -5.47218, 0))
base.transitions.fadeIn()
base.playSfx(self.danceSound, looping=1)
if self.winnerTeam == self.team:
base.playMusic(self.winnerMusic, volume=0.8)
else:
base.playMusic(self.loserMusic, volume=0.8)
winnerPositions = [(-2, 0, 0), (2, 0, 0), (6, 0, 0), (-6, 0, 0)]
loserPositions = [(-3.5, -10, 0), (-1.5, -15, 0), (3.0, -8, 0), (5.5, -12, 0)]
for team in [RED, BLUE]:
for avId in self.playerListByTeam[team]:
av = self.cr.doId2do.get(avId)
if av:
av.stopSmooth()
av.setHpr(0, 0, 0)
if team == self.winnerTeam:
posList = winnerPositions
av.setAnimState('off')
av.stop()
if not self.getRemoteAvatar(avId).isFrozen:
av.loop('win')
else:
posList = loserPositions
av.setAnimState('off')
av.stop()
if not self.getRemoteAvatar(avId).isFrozen:
av.loop('pout')
pos = random.choice(posList)
posList.remove(pos)
av.setPos(pos)
if self.winnerTeam == team:
text = 'YOU WIN!'
else:
text = 'YOU LOSE!'
self.gameOverLbl.setText(text)
self.track = Sequence(Wait(2.0), Func(self.gameOverLbl.setScale, 0.01), Func(self.gameOverLbl.show), getAlertPulse(self.gameOverLbl, 0.27, 0.25))
self.track.start()
def exitDisplayWinners(self):
base.transitions.noTransitions()
self.danceSound.stop()
if hasattr(self, 'track'):
self.track.finish()
self.track = None
self.gameOverLbl.hide()
return
def enterAnnGameOver(self, timeRanOut=0):
self.firstPerson.vModel.hide()
text = 'GAME\nOVER'
if timeRanOut:
text = "TIME's\nUP"
self.gameOverLbl.setText(text)
self.gameOverLbl.show()
base.transitions.fadeScreen()
taskMgr.doMethodLater(3.0, self.__annGameOverTask, self.uniqueName('annGameOverTask'))
def __annGameOverTask(self, task):
self.gameOverLbl.hide()
self.ival = Sequence(base.transitions.getFadeOutIval(), Func(self.fsm.request, 'displayWinners'))
self.ival.start()
return task.done
def exitAnnGameOver(self):
taskMgr.remove(self.uniqueName('annGameOverTask'))
if hasattr(self, 'ival'):
self.ival.finish()
del self.ival
self.gameOverLbl.hide()
def teamWon(self, team):
self.winnerTeam = team
base.localAvatar.disableAvatarControls()
self.firstPerson.end()
self.deleteTimer()
self.fsm.request('announceGameOver')
def incrementTeamScore(self, team):
TeamMinigame.incrementTeamScore(self, team)
if team == BLUE:
self.blueScoreLbl.setText('BLUE: ' + str(self.scoreByTeam[team]))
ToontownIntervals.start(ToontownIntervals.getPulseLargerIval(self.blueScoreLbl, 'blueScorePulse'))
else:
if team == RED:
self.redScoreLbl.setText('RED: ' + str(self.scoreByTeam[team]))
ToontownIntervals.start(ToontownIntervals.getPulseLargerIval(self.redScoreLbl, 'redScorePulse'))
def getWinterDodgeballScoreText(self, color):
text = OnscreenText(fg=color, font=CIGlobals.getMinnieFont(), scale=0.15, shadow=(0,
0,
0,
1))
return text
def snowballHitWall(self, snowballIndex):
snowball = self.snowballs[snowballIndex]
snowball.handleHitWallOrPlayer()
base.playSfx(snowball.impactSound, node=snowball, volume=1.5)
def snowballHitGround(self, snowballIndex):
snowball = self.snowballs[snowballIndex]
snowball.handleHitGround()
base.playSfx(snowball.impactSound, node=snowball, volume=1.5)
def snowballHitPlayer(self, damagedPlayer, throwerTeam, snowballIndex):
av = self.getRemoteAvatar(damagedPlayer)
if av:
if throwerTeam == av.team:
if av.unFreeze():
if damagedPlayer == base.localAvatar.doId:
self.showAlert('A team member has unfroze you!')
self.firstPerson.camFSM.request('unfrozen')
self.sendUpdate('teamMateUnfrozeMe', [self.team])
elif av.freeze():
if damagedPlayer == base.localAvatar.doId:
self.showAlert("You've been frozen by an enemy!")
self.firstPerson.camFSM.request('frozen')
self.sendUpdate('enemyFrozeMe', [self.team, throwerTeam])
snowball = self.snowballs[snowballIndex]
snowball.handleHitWallOrPlayer()
base.playSfx(snowball.impactSound, node=snowball, volume=1.5)
def playerCaughtSnowball(self, snowballIndex, catcherId):
av = self.getRemoteAvatar(catcherId)
if av:
snowball = self.snowballs[snowballIndex]
snowball.pauseThrowIval()
snowball.pickup(av)
def setupRemoteAvatar(self, avId):
av = RemoteDodgeballAvatar(self, self.cr, avId)
if avId == self.cr.localAvId:
self.myRemoteAvatar = av
self.remoteAvatars.append(av)
def __getSnowTree(self, path):
trees = loader.loadModel('phase_8/models/props/snow_trees.bam')
tree = trees.find('**/' + path)
tree.find('**/*shadow*').removeNode()
return tree
def load(self):
self.setMinigameMusic(DistributedDodgeballGame.GameSong)
self.setDescription(DistributedDodgeballGame.GameDesc)
self.setWinnerPrize(200)
self.setLoserPrize(0)
self.createWorld()
self.blueScoreLbl = self.getWinterDodgeballScoreText(VBase4(0, 0, 1, 1))
self.blueScoreLbl.reparentTo(base.a2dTopLeft)
self.blueScoreLbl['align'] = TextNode.ALeft
self.blueScoreLbl.setText('Blue: 0')
self.blueScoreLbl.setZ(-0.17)
self.blueScoreLbl.setX(0.05)
self.blueScoreLbl.hide()
self.redScoreLbl = self.getWinterDodgeballScoreText(VBase4(1, 0, 0, 1))
self.redScoreLbl.reparentTo(base.a2dTopLeft)
self.redScoreLbl['align'] = TextNode.ALeft
self.redScoreLbl.setText('Red: 0')
self.redScoreLbl.setZ(-0.35)
self.redScoreLbl.setX(0.05)
self.redScoreLbl.hide()
trans = DistributedDodgeballGame.InitCamTrans
camera.setPos(trans[0])
camera.setHpr(trans[1])
DistributedToonFPSGame.load(self)
def createWorld(self):
self.deleteWorld()
self.sky = loader.loadModel('phase_3.5/models/props/BR_sky.bam')
self.sky.reparentTo(render)
self.sky.setZ(-40)
self.sky.setFogOff()
self.arena = loader.loadModel('phase_4/models/minigames/dodgeball_arena.egg')
self.arena.reparentTo(render)
self.arena.setScale(0.75)
self.arena.find('**/team_divider').setBin('ground', 18)
self.arena.find('**/floor').setBin('ground', 18)
self.arena.find('**/team_divider_coll').setCollideMask(CIGlobals.FloorBitmask)
for data in DistributedDodgeballGame.TreeData:
code = data[0]
pos = data[1]
tree = self.__getSnowTree(code)
tree.reparentTo(self.arena)
tree.setPos(pos)
self.trees.append(tree)
for i in xrange(len(DistributedDodgeballGame.SnowballData)):
snowdata = DistributedDodgeballGame.SnowballData[i]
snowball = Snowball(self, i)
snowball.load()
snowball.reparentTo(render)
snowball.setPos(snowdata)
self.snowballs.append(snowball)
self.snow = ParticleLoader.loadParticleEffect('phase_8/etc/snowdisk.ptf')
self.snow.setPos(0, 0, 5)
self.snowRender = self.arena.attachNewNode('snowRender')
self.snowRender.setDepthWrite(0)
self.snowRender.setBin('fixed', 1)
self.snow.start(camera, self.snowRender)
self.fog = Fog('snowFog')
self.fog.setColor(0.486, 0.784, 1)
self.fog.setExpDensity(0.003)
render.setFog(self.fog)
def throw(self, snowballIndex, p):
snowball = self.snowballs[snowballIndex]
snowball.throw(p)
def snowballPickup(self, snowballIndex, pickerUpperAvId):
remoteAv = self.getRemoteAvatar(pickerUpperAvId)
if remoteAv:
snowball = self.snowballs[snowballIndex]
snowball.pickup(remoteAv)
def deleteWorld(self):
if self.redScoreLbl:
self.redScoreLbl.destroy()
self.redScoreLbl = None
if self.blueScoreLbl:
self.blueScoreLbl.destroy()
self.blueScoreLbl = None
for snowball in self.snowballs:
snowball.removeNode()
self.snowballs = []
for tree in self.trees:
tree.removeNode()
self.trees = []
if self.snow:
self.snow.cleanup()
self.snow = None
if self.snowRender:
self.snowRender.removeNode()
self.snowRender = None
self.fog = None
if self.sky:
self.sky.removeNode()
self.sky = None
if self.arena:
self.arena.removeNode()
self.arena = None
render.clearFog()
return
def enterPlay(self):
self.createTimer()
self.redScoreLbl.show()
self.blueScoreLbl.show()
self.firstPerson.camFSM.request('unfrozen')
self.arena.find('**/' + self.Team2OtherBarrier[self.team]).stash()
def exitPlay(self):
self.firstPerson.crosshair.destroy()
self.firstPerson.crosshair = None
self.firstPerson.camFSM.request('off')
DistributedToonFPSGame.exitPlay(self)
return
def enterCountdown(self):
self.firstPerson.start()
self.firstPerson.disableMouse()
self.infoText.setText(DistributedDodgeballGame.GetSnowBalls)
self.countdownText = getGameText()
self.countdownIval = Parallel(Sequence(Func(self.countdownText.setText, '5'), getCountdownIval(self.countdownText), Func(self.countdownText.setText, '4'), getCountdownIval(self.countdownText), Func(self.countdownText.setText, '3'), getCountdownIval(self.countdownText), Func(self.countdownText.setText, '2'), getCountdownIval(self.countdownText), Func(self.countdownText.setText, '1'), getCountdownIval(self.countdownText)), getAlertPulse(self.infoText), name='COUNTDOWNIVAL')
self.countdownIval.setDoneEvent(self.countdownIval.getName())
self.acceptOnce(self.countdownIval.getDoneEvent(), self.__handleCountdownDone)
self.countdownIval.start()
def __handleCountdownDone(self):
self.fsm.request('play')
def exitCountdown(self):
if hasattr(self, 'countdownText'):
self.countdownText.destroy()
del self.countdownText
if hasattr(self, 'countdownIval'):
self.ignore(self.countdownIval.getDoneEvent())
self.countdownIval.finish()
del self.countdownIval
def enterScrollBy(self):
BLUE_START_POS = Point3(-20, 0, 4)
BLUE_END_POS = Point3(20, 0, 4)
BLUE_HPR = Vec3(0, 0, 0)
RED_START_POS = Point3(20, 0, 4)
RED_END_POS = Point3(-20, 0, 4)
RED_HPR = Vec3(180, 0, 0)
self.playMinigameMusic()
self.scrollBySeq = Sequence(Func(camera.setHpr, BLUE_HPR), LerpPosInterval(camera, duration=5.0, pos=BLUE_END_POS, startPos=BLUE_START_POS, blendType='easeOut'), Func(base.transitions.fadeOut, 0.4), Wait(0.5), Func(base.transitions.fadeIn, 0.4), Func(camera.setHpr, RED_HPR), LerpPosInterval(camera, duration=5.0, pos=RED_END_POS, startPos=RED_START_POS, blendType='easeOut'), name='SCROLLBYSEQ')
self.scrollBySeq.setDoneEvent(self.scrollBySeq.getName())
self.acceptOnce(self.scrollBySeq.getDoneEvent(), self.__handleScrollByDone)
self.scrollBySeq.start()
def __handleScrollByDone(self):
self.fsm.request('countdown')
def exitScrollBy(self):
if self.scrollBySeq:
self.ignore(self.scrollBySeq.getDoneEvent())
self.scrollBySeq.finish()
self.scrollBySeq = None
return
def allPlayersReady(self):
self.fsm.request('scrollBy')
def chooseUrTeam(self):
self.fsm.request('chooseTeam')
def enterChooseTeam(self):
self.makeSelectionGUI()
def acceptedIntoTeam(self, spawnPoint):
TeamMinigame.acceptedIntoTeam(self)
self.sendUpdate('readyToStart')
self.fsm.request('waitForOthers')
pos, hpr = self.spawnPointsByTeam[self.team][spawnPoint]
base.localAvatar.setPos(pos)
base.localAvatar.setHpr(hpr)
def exitChooseTeam(self):
self.destroySelectionGUI()
def announceGenerate(self):
DistributedToonFPSGame.announceGenerate(self)
base.camLens.setMinFov(CIGlobals.GunGameFOV / (4.0 / 3.0))
self.load()
def disable(self):
base.camLens.setMinFov(CIGlobals.DefaultCameraFov / (4.0 / 3.0))
self.fsm.requestFinalState()
self.deleteWorld()
self.trees = None
self.snowballs = None
self.spawnPointsByTeam = None
if self.firstPerson:
self.firstPerson.reallyEnd()
self.firstPerson.cleanup()
self.firstPerson = None
self.scrollBySeq = None
self.winnerMusic = None
self.loserMusic = None
self.danceSound = None
self.infoText = None
base.localAvatar.setWalkSpeedNormal()
DistributedToonFPSGame.disable(self)
return
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
class Stench:
"""All the Stench visual effects and sounds as a single object."""
def __init__(self):
self._is_playing = False
self._nextclick = 0
background = NodePath("background")
background.setDepthTest(0)
background.setDepthWrite(0)
self._snd1 = loader.loadSfx("sounds/Stench/hollow.ogg") # noqa: F821
self._snd1.setLoop(True)
self._snd2 = loader.loadSfx("sounds/Stench/creepy.ogg") # noqa: F821
self._snd2.setLoop(True)
self._snd3 = loader.loadSfx("sounds/Stench/breathing.ogg") # noqa: F821
self._snd3.setLoop(True)
self._snd4 = loader.loadSfx("sounds/Stench/teeth.ogg") # noqa: F821
self._snd4.setLoop(True)
self._stench = ParticleEffect()
self._stench.loadConfig("effects/stench.ptf")
self._stench.setPos(0, 3.5, 0.3)
self._fog = Fog("Stench")
self._fog.setColor(1, 0.69, 0)
self._fog.setExpDensity(0.1)
tex = Texture()
tex.setMinfilter(Texture.FTLinear)
base.win.addRenderTexture( # noqa: F821
tex, GraphicsOutput.RTMTriggeredCopyTexture
)
taskMgr.add(self._snapshot, "tex_snapshot") # noqa: F821
self._bcard = base.win.getTextureCard() # noqa: F821
self._bcard.reparentTo(background) # noqa: F821
self._bcard.setTransparency(1)
self._bcard.setColor(1, 1, 1, 1)
self._bcard.setScale(1)
self._bcard.hide()
self._fcard = base.win.getTextureCard() # noqa: F821
self._fcard.reparentTo(base.render2d) # noqa: F821
self._fcard.setTransparency(1)
self._fcard.setColor(1, 1, 1, 0.4)
self._fcard.setScale(1.08)
self._fcard.hide()
@property
def is_playing(self):
"""Flag indicating if the Stench effect is playing.
Returns:
bool:
True, if the Stench effect is playing, False otherwise.
"""
return self._is_playing
def _snapshot(self, task):
"""Make snapshot of the screen."""
if task.time > self._nextclick:
self._nextclick += 0.001
if self._nextclick < task.time:
self._nextclick = task.time
base.win.triggerCopy() # noqa: F821
return task.cont
def set_fog(self):
"""Turn on fog."""
render.setFog(self._fog) # noqa: F821
def play(self):
"""Start playing the Stench visual effects and sounds."""
if self._is_playing:
return
self._is_playing = True
render.setFog(self._fog) # noqa: F821
self._bcard.show()
self._fcard.show()
self._snd1.play()
self._snd2.play()
self._snd3.play()
self._snd4.play()
base.effects_mgr.love_fog.switch() # noqa: F821
base.effects_mgr.love_fog.switch() # noqa: F821
def play_clouds(self):
"""Start playing the Stench particle effect."""
if self._is_playing:
return
self._stench.start(base.train.model, render) # noqa: F821
self._stench.softStart()
def stop(self):
"""Stop playing the Stench effects and sounds."""
if not self._is_playing:
return
self._is_playing = False
taskMgr.doMethodLater( # noqa: F821
0.2, drown_snd, "drown_stench_snd1", extraArgs=[self._snd1], appendTask=True
)
taskMgr.doMethodLater( # noqa: F821
0.2, drown_snd, "drown_stench_snd2", extraArgs=[self._snd2], appendTask=True
)
taskMgr.doMethodLater( # noqa: F821
0.2, drown_snd, "drown_stench_snd3", extraArgs=[self._snd3], appendTask=True
)
taskMgr.doMethodLater( # noqa: F821
0.2, drown_snd, "drown_stench_snd4", extraArgs=[self._snd4], appendTask=True
)
self._stench.softStop()
self._fcard.hide()
self._bcard.hide()
render.clearFog() # noqa: F821
if base.effects_mgr.love_fog.is_on: # noqa: F821
base.effects_mgr.love_fog.is_on = False # noqa: F821
base.effects_mgr.love_fog.switch() # noqa: F821
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 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
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 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)
