def updateLight(task):
base.camera.setHpr(task.time / 20.0 * 360, 0, 0)
base.camera.setPos(0, 0, 0)
base.camera.setPos(base.cam, 0, -80, 15)
base.camera.setP(-4)
h = task.time / 10.0 * 360 + 180
dlnp.setHpr(0, h, 0)
h = h + 90
h = h % 360
h = min(h, 360 - h)
# h is now angle from straight up
hv = h / 180.0
hv = 1 - hv
sunset = max(0, 1.0 - abs(hv - .5) * 8)
if hv > .5:
sunset = 1
# sunset=sunset**.2
sunset = VBase4(0.8, 0.5, 0.0, 1) * sunset
sun = max(0, hv - .5) * 2 * 4
sun = min(sun, 1)
dlight.setColor((VBase4(0.4, 0.9, 0.8, 1) * sun * 2 + sunset))
alight.setColor(VBase4(0.2, 0.2, 0.3, 1) * sun +
VBase4(0.2, 0.2, 0.3, 1) + sunset * .2)
return Task.cont
def __updateKeyPressRateTask(self, task):
if self.state not in 'Controlled':
return Task.done
for i in range(len(self.keyTTL)):
self.keyTTL[i] -= 0.1
for i in range(len(self.keyTTL)):
if self.keyTTL[i] <= 0:
a = self.keyTTL[0:i]
del self.keyTTL
self.keyTTL = a
break
self.keyRate = len(self.keyTTL)
keyRateDiff = self.keyRate - self.BASELINE_KEY_RATE
diffPower = keyRateDiff / 300.0
if self.power < 1 and diffPower > 0:
diffPower = diffPower * math.pow(1 - self.power, 1.25)
newPower = self.power + diffPower
if newPower > 1:
newPower = 1
elif newPower < 0:
newPower = 0
self.notify.debug('diffPower=%.2f keyRate = %d, newPower=%.2f' % (diffPower, self.keyRate, newPower))
self.power = newPower
self.powerBar['value'] = newPower
if self.power < self.YELLOW_POWER_THRESHOLD:
self.powerBar['barColor'] = VBase4(0.75, 0.75, 1.0, 0.8)
elif self.power < self.RED_POWER_THRESHOLD:
self.powerBar['barColor'] = VBase4(1.0, 1.0, 0.0, 0.8)
else:
self.powerBar['barColor'] = VBase4(1.0, 0.0, 0.0, 0.8)
self.__spawnUpdateKeyPressRateTask()
return Task.done
def getFadeInTrack():
fadeInTrack = LerpColorScaleInterval(self.nodePath,
0.5,
colorScale=VBase4(1, 1, 1, 1),
startColorScale=VBase4(
0, 0, 0, 0),
blendType='easeOut')
return fadeInTrack
def collide(self, collEntry):
print("WERT: object has collided into another object")
Sequence(
Func(collEntry.getFromNodePath().getParent().setColor,
VBase4(1, 0, 0, 1)), Wait(0.2),
Func(collEntry.getFromNodePath().getParent().setColor,
VBase4(0, 1, 0, 1)), Wait(0.2),
Func(collEntry.getFromNodePath().getParent().setColor,
VBase4(1, 1, 1, 1))).start()
def __init__(self, model, data, cellWidth):
MazeBase.__init__(self, model, data, cellWidth)
self._initWaterCoolers()
self.elevatorPos = self.maze.find('**/elevator_loc').getPos(render)
self.exitPos = self.maze.find('**/exit_loc').getPos(render)
self.maze.flattenStrong()
self._clearColor = VBase4(base.win.getClearColor())
self._clearColor.setW(1.0)
base.win.setClearColor(VBase4(0.0, 0.0, 0.0, 1.0))
def __init__(self, model, data, cellWidth):
MazeBase.__init__(self, model, data, cellWidth)
self._initWaterCoolers()
self.elevatorPos = self.maze.find('**/elevator_loc').getPos(render)
self.exitPos = self.maze.find('**/exit_loc').getPos(render)
self.maze.flattenStrong()
self._clearColor = VBase4(base.win.getClearColor())
self._clearColor.setW(1.0)
base.win.setClearColor(VBase4(0.0, 0.0, 0.0, 1.0))
if __debug__ and base.config.GetBool('cogdomaze-dev', False):
self._initCollisionVisuals()
def createMeterInterval(self, icon, meter, time):
ivalDarkness = LerpScaleInterval(meter, time, scale=Vec3(1, 1, 1), startScale=Vec3(1, 0.001, 0.001))
flashingTrack = Sequence()
flashDuration = 10
if time > flashDuration:
flashingTrack.append(Wait(time - flashDuration))
for i in xrange(10):
flashingTrack.append(Parallel(LerpColorScaleInterval(icon, 0.5, VBase4(1, 0, 0, 1)), icon.scaleInterval(0.5, 1.25)))
flashingTrack.append(Parallel(LerpColorScaleInterval(icon, 0.5, VBase4(1, 1, 1, 1)), icon.scaleInterval(0.5, 1)))
retIval = Parallel(ivalDarkness, flashingTrack)
return retIval
def change_material(self, new_material):
self.material = new_material
if self.material == 'grass':
new_color = VBase4(0, .7, 0, 1.0)
elif self.material == 'stone':
new_color = VBase4(.5, .5, .5, 1.0)
if self.material == 'objective':
new_color = VBase4(0.7, 0.7, 0.7, 1.0)
if self.material == 'obstacle':
new_color = VBase4(0.7, 0.7, 0.3, 1.0)
if self.terrain.hoveredTile == self:
new_color *= 1.5
self.nodePath.setColor(new_color)
def __updateWaterPower(self, task):
if not self.powerBar:
print('### no power bar!!!')
return task.done
newPower = self.__getWaterPower(globalClock.getFrameTime())
self.power = newPower
self.powerBar['value'] = newPower
if self.power < self.YELLOW_POWER_THRESHOLD:
self.powerBar['barColor'] = VBase4(0.75, 0.75, 1.0, 0.8)
elif self.power < self.RED_POWER_THRESHOLD:
self.powerBar['barColor'] = VBase4(1.0, 1.0, 0.0, 0.8)
else:
self.powerBar['barColor'] = VBase4(1.0, 0.0, 0.0, 0.8)
return task.cont
def _updateVictoryBar(self):
if not (hasattr(self, '_victoryBalanceBar')
and self._victoryBalanceBar):
return
netDistance = 0
for cog in self.cogs:
netDistance = netDistance + cog.targetDistance
teamDistance = netDistance / 6.0
self._victoryBalanceBarOrange.setScale(
PartyGlobals.CogActivityBarStartScale +
teamDistance * 10 * PartyGlobals.CogActivityBarUnitScale, 1.0, 1.0)
self._victoryBalanceBarPie.setX(
PartyGlobals.CogActivityVictoryBarPiePos[0] +
teamDistance * 10 * PartyGlobals.CogActivityBarPieUnitMove)
self._victoryBalanceBarPie.setY(
PartyGlobals.CogActivityVictoryBarPiePos[1])
self._victoryBalanceBarPie.setZ(
PartyGlobals.CogActivityVictoryBarPiePos[2])
if teamDistance > 0.0:
self._victoryBalanceBarArrow.setColor(
PartyGlobals.CogActivityColors[1])
elif teamDistance < 0.0:
self._victoryBalanceBarArrow.setColor(
PartyGlobals.CogActivityColors[0])
else:
self._victoryBalanceBarArrow.setColor(VBase4(1.0, 1.0, 1.0, 1.0))
def _initFog(self):
self.fog = Fog("FlyingFog")
self.fog.setColor(VBase4(0.8, 0.8, 0.8, 1.0))
self.fog.setLinearRange(100.0, 400.0)
self._renderFog = render.getFog()
render.setFog(self.fog)
def buildDirectionalLight(self, hpr, pos, color, near, far, casts_shadow,
shadow_caster, film_size):
"""
Builds a Panda3D directional light with the specified rotation, position
and color.
NOTE: This light tends to be buggy. Requires at least one spotlight for it
to work properly.
"""
if not self.has_dlight:
self.light_counter += 1
dlight = DirectionalLight("light%s" % self.light_counter)
dlight.getLens().setFilmSize(*film_size)
dlight.getLens().setNearFar(near, far)
if shadow_caster:
x, y = shadow_caster
dlight.setShadowCaster(True, x, y)
else:
dlight.setShadowCaster(False)
#dlight.showFrustum()
dlightnp = render.attachNewNode(dlight)
dlightnp.setPos(VBase3(*pos))
dlightnp.setHpr(VBase3(*hpr))
dlight.setColor(VBase4(*color))
render.setLight(dlightnp)
return dlightnp
else:
return 0
def setCamera(self, num):
"""
This method sets which cameras view is shown in the panda3d window.
"""
if MANUAL_CAMERA:
self.cur_camera = num - 1
return
self.display_region.setClearColor(VBase4(0, 0, 0, 1))
self.display_region.setClearColorActive(True)
self.display_region.setClearDepthActive(True)
if num == 0:
self.cur_camera = -1
self.display_region.setCamera(self.default_camera)
self.cam_label.setText("Top Down")
else:
camera_list = self.model.getCameraList()
index = num - 1
if index < len(camera_list):
self.cur_camera = index
camera = camera_list[index]
camera_np = camera.getCameraNode()
self.display_region.setCamera(camera_np)
name = camera.getName()
status_label = camera.getStatusLabel()
label = "%s: %s" % (name, status_label)
self.cam_label.setText(label)
class MinimapBlackPearlShip(MinimapShip):
DEFAULT_COLOR = VBase4(0.10000000000000001, 0.5, 1.0, 0.69999999999999996)
def updateOnMap(self, map):
MinimapShip.updateOnMap(self, map)
if self.isLocalAvShip:
map.updateRadarTransform(self.worldNode)
def _set_light_sources(self):
light_positions = [(1, -1, 1), (-1, -5, 1)]
intensity = 0.8
for l_pos in light_positions:
plight = PointLight('plight')
plight.setColor(VBase4(intensity, intensity, intensity, 1))
plnp = render.attachNewNode(plight)
plnp.setPos(l_pos[0], l_pos[1], l_pos[2])
render.setLight(plnp)
light = AmbientLight('')
light.setColor(VBase4(0.4, 0.4, 0.4, 1))
light_np = render.attachNewNode(light)
light_np.setPos(0, 0, 0)
render.setLight(light_np)
pass
def __enableControlInterface(self):
gui = loader.loadModel('phase_3.5/models/gui/avatar_panel_gui')
self.closeButton = DirectButton(image=(gui.find('**/CloseBtn_UP'),
gui.find('**/CloseBtn_DN'),
gui.find('**/CloseBtn_Rllvr'),
gui.find('**/CloseBtn_UP')),
relief=None,
scale=2,
text=TTLocalizer.BossbotGolfSpotLeave,
text_scale=0.04,
text_pos=(0, -0.07),
text_fg=VBase4(1, 1, 1, 1),
pos=(1.05, 0, -0.82),
command=self.__exitGolfSpot)
self.accept('escape', self.__exitGolfSpot)
self.accept('control', self.__controlPressed)
self.accept('control-up', self.__controlReleased)
self.accept('InputState-forward', self.__upArrow)
self.accept('InputState-reverse', self.__downArrow)
self.accept('InputState-turnLeft', self.__leftArrow)
self.accept('InputState-turnRight', self.__rightArrow)
taskMgr.add(self.__watchControls, 'watchGolfSpotControls')
taskMgr.doMethodLater(5, self.__displayGolfSpotAdvice,
self.golfSpotAdviceName)
self.arrowVert = 0
self.arrowHorz = 0
if self.powerBar:
self.powerBar.show()
return
def _initFog(self):
self.fog = Fog("MazeFog")
self.fog.setColor(VBase4(0.3, 0.3, 0.3, 1.0))
self.fog.setLinearRange(0.0, 100.0)
self._renderFog = render.getFog()
render.setFog(self.fog)
def load(self):
self.maze = Maze(CogdoMazeGameGlobals.TempMazeFile)
#self.maze.maze.setColorScale(0.0, 0, 5.0, 1.0)
self.maze.setScale(2, 1.75)
self.guiMgr = CogdoMazeGuiManager(self.maze)
self.audioMgr = CogdoMazeAudioManager()
self.toonId2Door = {}
self.keyIdToKey = {}
self.players = []
self.toonId2Player = {}
self.lockId2Lock = {}
self.localPlayer = CogdoMazeLocalPlayer(len(self.players), base.localAvatar, self, self.guiMgr)
self._addPlayer(self.localPlayer)
# TEMP...
self.sprites = loader.loadModel("cogdominium/mazeSprites.egg")
# Create door
pos = self.maze.tile2world(int(self.maze.width / 2), self.maze.height - 1)
gridPos = self.maze.world2tile(pos[0], pos[1])
# TEMP
openDoorModel = self.sprites.find("**/door_open")
openDoorModel.setScale(8)
openDoorModel.setZ(0.25)
closedDoorModel = self.sprites.find("**/door_closed")
closedDoorModel.setScale(8)
closedDoorModel.setZ(0.25)
self.door = CogdoMazeDoor(closedDoorModel, openDoorModel)
self.door.setPosition(pos[0], pos[1] - 0.05)
self.door.offstage()
self.guiMgr.mazeMapGui.addDoor(gridPos[0], gridPos[1], VBase4(1, 1, 1, 1))
# load key model, keys will be placed when everyone's there
self.fuseModels = (
self.sprites.find("**/fuse_white"),
self.sprites.find("**/fuse_blue"),
self.sprites.find("**/fuse_yellow"),
self.sprites.find("**/fuse_red"),
)
for fuse in self.fuseModels:
fuse.setScale(2)
fuse.setBillboardPointEye()
self.fuseBoxModels = (
(self.sprites.find("**/fusebox_white"), self.sprites.find("**/fusebox_white_plugged")),
(self.sprites.find("**/fusebox_blue"), self.sprites.find("**/fusebox_blue_plugged")),
(self.sprites.find("**/fusebox_yellow"), self.sprites.find("**/fusebox_yellow_plugged")),
(self.sprites.find("**/fusebox_red"), self.sprites.find("**/fusebox_red_plugged")),
)
for fuseBox in self.fuseBoxModels:
fuseBox[0].setScale(4)
fuseBox[1].setScale(4)
#self._initFog()
self.accept(self.distGame.getRemoteActionEventName(), self.handleRemoteAction)
def enterFree(self):
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = None
self.restoreScaleTrack = Sequence(Wait(6),
self.getRestoreScaleInterval(),
name='restoreScaleTrack')
self.restoreScaleTrack.start()
if self.avId == localAvatar.doId:
if not self.isDisabled():
self.ballModel.setAlphaScale(0.29999999999999999)
self.ballModel.setTransparency(1)
taskMgr.doMethodLater(5,
self._DistributedGolfSpot__allowDetect,
self.triggerName)
self.fadeTrack = Sequence(Func(self.ballModel.setTransparency,
1),
self.ballModel.colorScaleInterval(
0.20000000000000001,
VBase4(1, 1, 1,
0.29999999999999999)),
name='fadeTrack-enterFree')
self.fadeTrack.start()
else:
self.trigger.unstash()
self.accept(self.triggerEvent,
self._DistributedGolfSpot__hitTrigger)
self.avId = 0
def reload(self,manager,xml):
color = xml.find('color')
if color!=None:
self.light.setColor(VBase4(float(color.get('r')), float(color.get('g')), float(color.get('b')), 1.0))
pos = xml.find('pos')
if pos!=None:
self.lightNode.setPos(render, float(pos.get('x')), float(pos.get('y')), float(pos.get('z')))
def __blink(self, task):
blink = Sequence(
LerpColorScaleInterval(self.suit, Globals.BlinkSpeed,
VBase4(1.0, 1.0, 1.0, 1.0)),
LerpColorScaleInterval(self.suit, Globals.BlinkSpeed,
Globals.BlinkColor))
blink.start()
return Task.again
class MinimapBlackPearlShip(MinimapShip):
__module__ = __name__
DEFAULT_COLOR = VBase4(0.1, 0.5, 1.0, 0.7)
def updateOnMap(self, map):
MinimapShip.updateOnMap(self, map)
if self.isLocalAvShip:
map.updateRadarTransform(self.worldNode)
def _DistributedGolfSpot__displayGolfSpotAdvice(self, task):
if self.golfSpotAdviceLabel == None:
self.golfSpotAdviceLabel = DirectLabel(
text=TTLocalizer.BossbotGolfSpotAdvice,
text_fg=VBase4(1, 1, 1, 1),
text_align=TextNode.ACenter,
relief=None,
pos=(0, 0, 0.68999999999999995),
scale=0.10000000000000001)
def __allowDetect(self, task):
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = Sequence(
self.tableGroup.colorScaleInterval(0.2, VBase4(1, 1, 1, 1)),
Func(self.tableGroup.clearColorScale),
Func(self.tableGroup.clearTransparency))
self.fadeTrack.start()
self.allowLocalRequestControl = True
def init_node_path(self):
if self.node_path:
self.parent.node_path_mesh.clearLight(self.node_path)
self.node_path.remove()
from pandac.PandaModules import AmbientLight
alight = AmbientLight('alight')
alight.setColor(VBase4(*[x / 127.0 for x in self.color] + [1.0]))
self.node_path = self.parent.node_path_mesh.attachNewNode(alight)
self.parent.node_path_mesh.setLight(self.node_path)
def __displayPitcherAdvice(self, task):
if self.pitcherAdviceLabel == None:
self.pitcherAdviceLabel = DirectLabel(
text=TTLocalizer.BossbotPitcherAdvice,
text_fg=VBase4(1, 1, 1, 1),
text_align=TextNode.ACenter,
relief=None,
pos=(0, 0, 0.69),
scale=0.1)
def set_lighting(self):
dlight = DirectionalLight('dlight')
dlnp = self.render.attachNewNode(dlight)
dlnp.setHpr(45,-45,0)
self.render.setLight(dlnp)
ambientLight = AmbientLight('ambientLight')
ambientLight.setColor(VBase4(0.5, 0.5, 0.5, 1))
ambientLightNP = render.attachNewNode(ambientLight)
self.render.setLight(ambientLightNP)
def loadAssets(self):
self.root = render.attachNewNode('golfSpot-%d' % self.index)
self.root.setPos(*self.positions[self.index])
self.ballModel = loader.loadModel('phase_6/models/golf/golf_ball')
self.ballColor = VBase4(1, 1, 1, 1)
if self.index < len(GolfGlobals.PlayerColors):
self.ballColor = VBase4(*GolfGlobals.PlayerColors[self.index])
self.ballModel.setColorScale(self.ballColor)
self.ballModel.reparentTo(self.root)
self.club = loader.loadModel('phase_6/models/golf/putter')
self.clubLookatSpot = self.root.attachNewNode('clubLookat')
self.clubLookatSpot.setY(-(GolfGlobals.GOLF_BALL_RADIUS + 0.1))
cs = CollisionSphere(0, 0, 0, 1)
cs.setTangible(0)
cn = CollisionNode(self.triggerName)
cn.addSolid(cs)
cn.setIntoCollideMask(ToontownGlobals.WallBitmask)
self.trigger = self.root.attachNewNode(cn)
self.trigger.stash()
self.hitBallSfx = loader.loadSfx('phase_6/audio/sfx/Golf_Hit_Ball.ogg')
def setupLights(self):
# create a point light
plight = PointLight('plight')
# set its color
plight.setColor(VBase4(1.0, 1.0, 1.0, 1))
# attach the light to the render
plnp = render.attachNewNode(plight)
# set position
plnp.setPos(0.0, 0.0, 2.0)
# turn on light
render.setLight(plnp)
def showExiting(self):
if self.closeButton:
self.closeButton.destroy()
self.closeButton = DirectLabel(
relief=None,
text=TTLocalizer.BossbotPitcherLeaving,
pos=(1.05, 0, -0.88),
text_pos=(0, 0),
text_scale=0.06,
text_fg=VBase4(1, 1, 1, 1))
self.__cleanupPitcherAdvice()
