def setupEnviroCamera(self):
clearColor = VBase4(0, 0, 0, 1)
if self.enviroDR:
clearColor = self.enviroDR.getClearColor()
self.win.removeDisplayRegion(self.enviroDR)
if not self.enviroCam:
self.enviroCam = self.cam.attachNewNode(Camera('enviroCam'))
mainDR = self.camNode.getDisplayRegion(0)
if self.stereoEnabled:
self.enviroDR = self.win.makeStereoDisplayRegion()
if not mainDR.isStereo():
self.win.removeDisplayRegion(mainDR)
mainDR = self.win.makeStereoDisplayRegion()
mainDR.setCamera(self.cam)
ml = mainDR.getLeftEye()
mr = mainDR.getRightEye()
el = self.enviroDR.getLeftEye()
er = self.enviroDR.getRightEye()
el.setSort(-8)
ml.setSort(-6)
er.setSort(-4)
er.setClearDepthActive(True)
mr.setSort(-2)
mr.setClearDepthActive(False)
else:
self.enviroDR = self.win.makeMonoDisplayRegion()
if mainDR.isStereo():
self.win.removeDisplayRegion(mainDR)
mainDR = self.win.makeMonoDisplayRegion()
mainDR.setCamera(self.cam)
self.enviroDR.setSort(-10)
self.enviroDR.setClearColor(clearColor)
self.win.setClearColor(clearColor)
self.enviroDR.setCamera(self.enviroCam)
self.enviroCamNode = self.enviroCam.node()
self.enviroCamNode.setLens(self.cam.node().getLens())
self.enviroCamNode.setCameraMask(OTPRender.EnviroCameraBitmask)
render.hide(OTPRender.EnviroCameraBitmask)
self.camList.append(self.enviroCam)
self.backgroundDrawable = self.enviroDR
self.enviroDR.setTextureReloadPriority(-10)
if self.pixelZoomSetup:
self.setupAutoPixelZoom()
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.002) # 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,
25) # 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 enterFree(self):
self.resetPowerBar()
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = None
self.prepareForPhaseFour()
if self.avId == localAvatar.doId:
self.tableGroup.setAlphaScale(0.3)
self.tableGroup.setTransparency(1)
taskMgr.doMethodLater(5, self.__allowDetect, self.triggerName)
self.fadeTrack = Sequence(
Func(self.tableGroup.setTransparency, 1),
self.tableGroup.colorScaleInterval(0.2, VBase4(1, 1, 1, 0.3)))
self.fadeTrack.start()
self.allowLocalRequestControl = False
else:
self.allowLocalRequestControl = True
self.avId = 0
return
def _updateVictoryBar(self):
if not hasattr(self, '_victoryBalanceBar') and self._victoryBalanceBar:
return None
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 projectCarelessly(point, lens=None):
"""
Similar to Lens.project(), but never returns None.
Source: http://www.panda3d.org / forums / viewtopic.php?t=2022 - by tarsierpi
"""
lens = lens or base.camLens
projection_mat = lens.getProjectionMat()
print(projection_mat)
full = projection_mat.xform(VBase4(point[0], point[1], point[2], 1.0))
if full[3] == 0.0:
# There is no meaningful projection for the nodal point of the lens.
# So return a value that is Very Far Away.
return (1000000.0, 1000000.0, -1000000.0)
recip_full3 = 1.0 / full[3]
return (full[0] * recip_full3, full[1] * recip_full3,
full[2] * recip_full3)
def startGame(self):
'''
Start the game
'''
base.enableParticles()
# self.p = ParticleEffect()
# self.loadParticleConfig('./data.parcticles/blowout_fire.ptf')
# Start of the code from steam.ptf
# self.p.cleanup()
self.p = ParticleEffect()
self.p.loadConfig('./data/particles/blowout_test.ptf')
# Sets particles to birth relative to the teapot, but to render at toplevel
self.p.start(render)
self.p.setPos(0.000, 0.000, 0)
# Load the Lights
ambilight = AmbientLight('ambilight')
ambilight.setColor(VBase4(0.2, 0.2, 0.2, 1))
render.setLight(render.attachNewNode(ambilight))
def __init__(self, cr):
DistributedObject.__init__(self, cr)
self._waitingStartLabel = DirectLabel(
text=TTL.MinigameWaitingForOtherPlayers,
text_fg=VBase4(1, 1, 1, 1),
relief=None,
pos=(-0.6, 0, -0.75),
scale=0.075)
self._waitingStartLabel.hide()
self.loadFSM = ClassicFSM.ClassicFSM(
'DistCogdoGame.loaded',
[
State.State('NotLoaded', self.enterNotLoaded,
self.exitNotLoaded, ['Loaded']),
State.State('Loaded', self.enterLoaded, self.exitLoaded,
['NotLoaded'])
],
# Initial state
'NotLoaded',
# Final state
'NotLoaded')
self.fsm = ClassicFSM.ClassicFSM(
'DistCogdoGame',
[
State.State('Intro', self.enterIntro, self.exitIntro,
['WaitServerStart']),
State.State('WaitServerStart', self.enterWaitServerStart,
self.exitWaitServerStart, ['Game']),
State.State('Game', self.enterGame, self.exitGame, ['Finish']),
State.State('Finish', self.enterFinish, self.exitFinish,
['Off']),
State.State('Off', self.enterOff, self.exitOff, ['Intro'])
],
# Initial state
'Off',
# Final state
'Off')
self.fsm.enterInitialState()
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 _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._victoryBalanceBar["value"] = 50 + (netDistance/6 * 100)
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 __init__(self, cr):
DistributedObject.__init__(self, cr)
base.cogdoGame = self
cr.cogdoGame = self
self._waitingStartLabel = DirectLabel(
text=TTL.MinigameWaitingForOtherPlayers,
text_fg=VBase4(1, 1, 1, 1),
relief=None,
pos=(-0.6, 0, -0.75),
scale=0.075)
self._waitingStartLabel.hide()
self.loadFSM = ClassicFSM.ClassicFSM('DistCogdoGame.loaded', [
State.State('NotLoaded', self.enterNotLoaded, self.exitNotLoaded,
['Loaded']),
State.State('Loaded', self.enterLoaded, self.exitLoaded,
['NotLoaded'])
], 'NotLoaded', 'NotLoaded')
self.loadFSM.enterInitialState()
self.fsm = ClassicFSM.ClassicFSM('DistCogdoGame', [
State.State('Visible', self.enterVisible, self.exitVisible,
['Intro']),
State.State('Intro', self.enterIntro, self.exitIntro,
['WaitServerStart']),
State.State('WaitServerStart', self.enterWaitServerStart,
self.exitWaitServerStart, ['Game']),
State.State('Game', self.enterGame, self.exitGame, ['Finish']),
State.State('Finish', self.enterFinish, self.exitFinish, ['Off']),
State.State('Off', self.enterOff, self.exitOff, ['Visible'])
], 'Off', 'Off')
self.fsm.enterInitialState()
self.difficultyOverride = None
self.exteriorZoneOverride = None
self._gotInterior = StateVar(False)
self._toonsInEntranceElev = StateVar(False)
self._wantStashElevator = StateVar(False)
self._stashElevatorFC = FunctionCall(self._doStashElevator,
self._toonsInEntranceElev,
self._gotInterior,
self._wantStashElevator)
return
def initNode(self):
'''
Create a clear menu
'''
self.camera = None
self.selected = 0
self.options = []
self.optionsModells = []
self.menuNode = NodePath("menuNode")
self.menuNode.reparentTo(render)
self.menuNode.setPos(-4.5, 15, 3)
self.menuNode.setH(40)
self.colorA = Vec4(1, 1, 0, 0)
self.colorB = Vec4(0, 1, 1, 0)
# LICHT
plight = PointLight('plight')
plight.setColor(VBase4(10, 10, 10, 1))
plnp = self.menuNode.attachNewNode(plight)
plnp.setPos(-10, -800, 20)
self.menuNode.setLight(plnp)
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.3)
self.ballModel.setTransparency(1)
taskMgr.doMethodLater(5, self.__allowDetect, self.triggerName)
self.fadeTrack = Sequence(Func(self.ballModel.setTransparency,
1),
self.ballModel.colorScaleInterval(
0.2, VBase4(1, 1, 1, 0.3)),
name='fadeTrack-enterFree')
self.fadeTrack.start()
else:
self.trigger.unstash()
self.accept(self.triggerEvent, self.__hitTrigger)
self.avId = 0
def assign_display_region_to_camera(self):
for i in range(0, len(self.display_regions)):
display_region = self.display_regions[i]
display_region.setClearColor(VBase4(0, 0, 0, 1))
display_region.setClearColorActive(True)
display_region.setClearDepthActive(True)
if i == 0:
display_region.setCamera(self.default_camera)
else:
camera_list = self.model.getCameraList()
index = i - 1
if index < len(camera_list):
camera = camera_list[index]
"""camera_pos = camera.pos
print camera_pos
x_2d = (camera_pos[0]+90)*1.7/HEIGHT
y_2d = -camera_pos[2]*1.0/HEIGHT
print x_2d, " ", y_2d, "\n"
marker = makeArc(x_2d, y_2d)
marker.reparentTo(self.new_window_aspect2d)"""
camera_np = camera.getCameraNode()
display_region.setCamera(camera_np)
def __init__(self):
self.avatar = None
self.active = True
self.objectCode = None
self.chatButton = NametagGlobals.noButton
self.chatReversed = False
self.font = None
self.chatFont = None
self.shadow = None
self.marginManager = None
self.visible3d = True
self.chatType = NametagGlobals.CHAT
self.chatBalloonType = NametagGlobals.CHAT_BALLOON
self.nametagColor = NametagGlobals.NametagColors[
NametagGlobals.CCNormal]
self.chatColor = NametagGlobals.ChatColors[NametagGlobals.CCNormal]
self.speedChatColor = VBase4(1, 1, 1, 1)
self.wordWrap = 8
self.chatWordWrap = 12
self.text = ''
self.chatPages = []
self.chatPageIndex = 0
self.chatTimeoutTask = None
self.chatTimeoutTaskName = self.getUniqueName() + '-timeout'
self.stompChatText = ''
self.stompTask = None
self.stompTaskName = self.getUniqueName() + '-stomp'
self.icon = PandaNode('icon')
self.nametag2d = Nametag2d()
self.nametag3d = Nametag3d()
self.nametags = set()
self.add(self.nametag2d)
self.add(self.nametag3d)
# Add the tick task:
self.tickTaskName = self.getUniqueName() + '-tick'
self.tickTask = taskMgr.add(self.tick, self.tickTaskName, sort=45)
def buildSpotlight(self, pos, fov, exponent, casts_shadow, shadow_caster,
pitch, near, far, color):
"""
Builds a Panda3D Spotlight at the specified position with the specified
field of view and color
"""
self.light_counter += 1
light = Spotlight("light%s" % self.light_counter)
if casts_shadow:
x, y = shadow_caster
light.setShadowCaster(True, x, y)
light.getLens().setFar(far)
else:
light.setShadowCaster(False)
light.getLens().setFar(2)
light.setColor(VBase4(*color))
light.getLens().setNear(near)
lightnp = render.attachNewNode(light)
lightnp.setPos(*pos)
lightnp.setP(pitch)
light.getLens().setFov(fov)
light.setExponent(exponent)
return lightnp
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.BossbotPitcherLeave, text_scale=0.04, text_pos=(0, -0.07), text_fg=VBase4(1, 1, 1, 1), pos=(1.05, 0, -0.82), command=self.__exitPitcher)
self.accept('escape', self.__exitPitcher)
self.accept(base.JUMP, 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)
self.accept(base.MOVE_UP, self.__upArrowKeyPressed)
self.accept(base.MOVE_DOWN, self.__downArrowKeyPressed)
taskMgr.add(self.__watchControls, self.watchControlsName)
taskMgr.doMethodLater(5, self.__displayPitcherAdvice, self.pitcherAdviceName)
self.arrowVert = 0
self.arrowHorz = 0
self.powerBar.show()
return
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 _createPartyEditorPage(self):
page = DirectFrame(self.frame)
page.setName('PartyPlannerEditorPage')
self.LayoutTitleLabel = DirectLabel(parent=page, relief=None, text=TTLocalizer.PartyPlannerEditorTitle, pos=self.gui.find('**/title_locator').getPos() + Point3(0.0, 0.0, 0.075), scale=self.titleScale)
self.costLabel = DirectLabel(parent=page, pos=(-0.74, 0.0, 0.17), relief=None, text=TTLocalizer.PartyPlannerTotalCost % 0, text_align=TextNode.ACenter, scale=TTLocalizer.PPcostLabel, textMayChange=True)
self.partyGridBackground = DirectFrame(parent=page, relief=None, geom=self.gui.find('**/partyGrid_flat'))
self.partyGroundsLabel = DirectLabel(parent=page, relief=None, text=TTLocalizer.PartyPlannerPartyGrounds, text_font=ToontownGlobals.getSignFont(), text_fg=VBase4(1.0, 0.0, 0.0, 1.0), text_scale=TTLocalizer.PPpartyGroundsLabel, pos=self.gui.find('**/step_05_partyGrounds_text_locator').getPos(), scale=0.1)
self.activityBackground = DirectFrame(parent=page, relief=None, geom=self.gui.find('**/activitiesDecorations_flat1'), pos=(0.0, 0.0, 0.04))
pos = self.gui.find('**/step_05_instructions_locator').getPos()
self.instructionLabel = DirectLabel(parent=page, relief=None, text=' ', text_pos=(pos[0], pos[2]), text_scale=TTLocalizer.PPinstructionLabel, textMayChange=True, geom=self.gui.find('**/instructions_flat'))
self.elementTitleLabel = DirectLabel(parent=page, relief=None, text=' ', pos=self.gui.find('**/step_05_activitiesName_text_locator').getPos() + Point3(0.0, 0.0, 0.04), text_scale=TTLocalizer.PPelementTitleLabel, textMayChange=True)
self.elementPriceNode = TextNode('ElementPrice')
self.elementPriceNode.setAlign(TextNode.ALeft)
self.elementPriceNode.setTextColor(0.0, 0.0, 0.0, 1.0)
self.elementPriceNode.setFont(ToontownGlobals.getToonFont())
self.elementPrice = page.attachNewNode(self.elementPriceNode)
self.elementPrice.setScale(TTLocalizer.PPelementPriceNode)
self.elementPrice.setPos(self.gui.find('**/step_05_activityPrice_text_locator').getPos() + Point3(-0.02, 0.0, 0.04))
self.elementDescriptionNode = TextNode('ElementDescription')
self.elementDescriptionNode.setAlign(TextNode.ACenter)
self.elementDescriptionNode.setWordwrap(8)
self.elementDescriptionNode.setFont(ToontownGlobals.getToonFont())
self.elementDescriptionNode.setTextColor(0.0, 0.0, 0.0, 1.0)
self.elementDescription = page.attachNewNode(self.elementDescriptionNode)
self.elementDescription.setScale(TTLocalizer.PPelementDescription)
self.elementDescription.setPos(self.gui.find('**/step_05_activityDescription_text_locator').getPos() + Point3(0.0, 0.0, 0.04))
self.totalMoney = base.localAvatar.getTotalMoney()
catalogGui = loader.loadModel('phase_5.5/models/gui/catalog_gui')
self.beanBank = DirectLabel(parent=page, relief=None, text=str(self.totalMoney), text_align=TextNode.ARight, text_scale=0.075, text_fg=(0.95, 0.95, 0, 1), text_shadow=(0, 0, 0, 1), text_pos=(0.495, -0.53), text_font=ToontownGlobals.getSignFont(), textMayChange=True, image=catalogGui.find('**/bean_bank'), image_scale=(0.65, 0.65, 0.65), scale=0.9, pos=(-0.75, 0.0, 0.6))
catalogGui.removeNode()
del catalogGui
self.accept(localAvatar.uniqueName('moneyChange'), self.__moneyChange)
self.accept(localAvatar.uniqueName('bankMoneyChange'), self.__moneyChange)
self.partyEditor = PartyEditor(self, page)
self.partyEditor.request('Hidden')
pos = self.gui.find('**/step_05_add_text_locator').getPos()
self.elementBuyButton = DirectButton(parent=page, relief=None, text=TTLocalizer.PartyPlannerBuy, text_pos=(pos[0], pos[2]), text_scale=TTLocalizer.PPelementBuyButton, geom=(self.gui.find('**/add_up'), self.gui.find('**/add_down'), self.gui.find('**/add_rollover')), geom3_color=VBase4(0.5, 0.5, 0.5, 1.0), textMayChange=True, pos=(0.0, 0.0, 0.04), command=self.partyEditor.buyCurrentElement)
self.okWithPartyGroundsLayoutEvent = 'okWithPartyGroundsLayoutEvent'
self.accept(self.okWithPartyGroundsLayoutEvent, self.okWithPartyGroundsLayout)
self.okWithGroundsGui = TTDialog.TTGlobalDialog(dialogName=self.uniqueName('PartyEditorOkGui'), doneEvent=self.okWithPartyGroundsLayoutEvent, message=TTLocalizer.PartyPlannerOkWithGroundsLayout, style=TTDialog.YesNo, okButtonText=OTPLocalizer.DialogYes, cancelButtonText=OTPLocalizer.DialogNo)
self.okWithGroundsGui.doneStatus = ''
self.okWithGroundsGui.hide()
return page
arrow.set_length(start_length)
else:
t = task.time % time_to_full_length
t = t / time_to_full_length
length_diff = max_length - start_length
new_length = start_length + t * length_diff
arrow.set_length(new_length)
return Task.cont
if __name__ == "__main__":
from direct.directbase import DirectStart
global base, render
print "Arrow::main"
arrow = Arrow()
arrow.set_angle_x_z_plane(45)
#arrow.set_length(0.5)
base.disableMouse()
base.camera.setPos(0, -5, .5)
#taskMgr.add(rotate, 'rotate', extraArgs=[arrow.root_node_path,0.05,0], appendTask=True)
#taskMgr.add(scale, 'scale', extraArgs=[arrow,1.0,0.5,1.0], appendTask=True)
plight = PointLight('plight')
plight.setColor(VBase4(1, 1, 1, 1))
plnp = render.attachNewNode(plight)
plnp.setPos(0, -10, 0)
render.setLight(plnp)
run()
def getModelWidthHeight(model):
tightBounds = model.getTightBounds()
if tightBounds is None:
return 0, 0
minPoint, maxPoint = tightBounds
width = maxPoint.getX() - minPoint.getX()
height = maxPoint.getZ() - minPoint.getZ()
return width, height
# Foreground, background:
NametagColors = {
CCNormal: (
(VBase4(0.3, 0.3, 0.7, 1.0), VBase4(0.8, 0.8, 0.8, 0.375)), # Normal
(VBase4(0.3, 0.3, 0.7, 1.0), VBase4(0.2, 0.2, 0.2, 0.1875)), # Down
(VBase4(0.5, 0.5, 1.0, 1.0), VBase4(1.0, 1.0, 1.0,
0.5625)), # Rollover
(VBase4(0.3, 0.3, 0.7, 1.0), VBase4(1.0, 1.0, 1.0, 0.375)) # Disabled
),
CCNoChat: (
(VBase4(0.8, 0.4, 0.0, 1.0), VBase4(0.8, 0.8, 0.8, 0.375)), # Normal
(VBase4(1.0, 0.5, 0.5, 1.0), VBase4(0.2, 0.2, 0.2, 0.1875)), # Click
(VBase4(1.0, 0.5, 0.0, 1.0), VBase4(1.0, 1.0, 1.0,
0.5625)), # Rollover
(VBase4(0.8, 0.4, 0.0, 1.0), VBase4(0.8, 0.8, 0.8, 0.375)) # Disabled
),
CCNonPlayer: (
(VBase4(0.8, 0.4, 0.0, 1.0), VBase4(0.8, 0.8, 0.8, 0.375)), # Normal
(VBase4(0.8, 0.4, 0.0, 1.0), VBase4(0.8, 0.8, 0.8, 0.1875)), # Down
def exitInputChoice(self):
if not self.controlKeyPressed:
if self.controlKeyWarningIval:
self.controlKeyWarningIval.finish()
self.controlKeyWarningIval = None
self.controlKeyWarningIval = Sequence(Func(self.controlKeyWarningLabel.show), self.controlKeyWarningLabel.colorScaleInterval(10, VBase4(1, 1, 1, 0), startColorScale=VBase4(1, 1, 1, 1)), Func(self.controlKeyWarningLabel.hide))
self.controlKeyWarningIval.start()
if self.timer != None:
self.timer.destroy()
self.timer = None
self.timerStartTime = None
self.hideForceArrows()
self.arrowRotateSound.stop()
self.arrowUpSound.stop()
self.arrowDownSound.stop()
taskMgr.remove(self.uniqueName('aimtask'))
return
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
def __init__(self, cr):
DistributedMinigame.DistributedMinigame.__init__(self, cr)
DistributedIceWorld.DistributedIceWorld.__init__(self, cr)
self.gameFSM = ClassicFSM.ClassicFSM('DistributedIceGame', [
State.State('off', self.enterOff, self.exitOff, ['inputChoice']),
State.State(
'inputChoice', self.enterInputChoice, self.exitInputChoice,
['waitServerChoices', 'moveTires', 'displayVotes', 'cleanup']),
State.State('waitServerChoices', self.enterWaitServerChoices,
self.exitWaitServerChoices, ['moveTires', 'cleanup']),
State.State('moveTires', self.enterMoveTires, self.exitMoveTires,
['synch', 'cleanup']),
State.State('synch', self.enterSynch, self.exitSynch,
['inputChoice', 'scoring', 'cleanup']),
State.State('scoring', self.enterScoring, self.exitScoring,
['cleanup', 'finalResults', 'inputChoice']),
State.State('finalResults', self.enterFinalResults,
self.exitFinalResults, ['cleanup']),
State.State('cleanup', self.enterCleanup, self.exitCleanup, [])
], 'off', 'cleanup')
self.addChildGameFSM(self.gameFSM)
self.cameraThreeQuarterView = (0, -22, 45, 0, -62.890000000000001, 0)
self.tireDict = {}
self.forceArrowDict = {}
self.canDrive = False
self.timer = None
self.timerStartTime = None
self.curForce = 0
self.curHeading = 0
self.headingMomentum = 0.0
self.forceMomentum = 0.0
self.allTireInputs = None
self.curRound = 0
self.curMatch = 0
self.controlKeyWarningLabel = DirectLabel(
text=TTLocalizer.IceGameControlKeyWarning,
text_fg=VBase4(1, 0, 0, 1),
relief=None,
pos=(0.0, 0, 0),
scale=0.14999999999999999)
self.controlKeyWarningLabel.hide()
self.waitingMoveLabel = DirectLabel(
text=TTLocalizer.IceGameWaitingForPlayersToFinishMove,
text_fg=VBase4(1, 1, 1, 1),
relief=None,
pos=(-0.59999999999999998, 0, -0.75),
scale=0.074999999999999997)
self.waitingMoveLabel.hide()
self.waitingSyncLabel = DirectLabel(
text=TTLocalizer.IceGameWaitingForAISync,
text_fg=VBase4(1, 1, 1, 1),
relief=None,
pos=(-0.59999999999999998, 0, -0.75),
scale=0.074999999999999997)
self.waitingSyncLabel.hide()
self.infoLabel = DirectLabel(text='',
text_fg=VBase4(0, 0, 0, 1),
relief=None,
pos=(0.0, 0, 0.69999999999999996),
scale=0.074999999999999997)
self.updateInfoLabel()
self.lastForceArrowUpdateTime = 0
self.sendForceArrowUpdateAsap = False
self.treasures = []
self.penalties = []
self.obstacles = []
self.controlKeyPressed = False
self.controlKeyWarningIval = None
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)
return
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()
return
# SuitGlobals are used to set the appearance of Cogs.
from toontown.suit import SuitDNA
from pandac.PandaModules import VBase4
SCALE_INDEX = 0 # The scale of the cog
HAND_COLOR_INDEX = 1 # The hand color
HEADS_INDEX = 2 # A list of heads
HEAD_TEXTURE_INDEX = 3 # The texture to use for the head
HEIGHT_INDEX = 4 # The height of the cog
aSize = 6.06 # Size of body type 'a'
bSize = 5.29 # Size of body type 'b'
cSize = 4.14 # Size of body type 'c'
ColdCallerHead = VBase4(0.25, 0.35, 1.0, 1.0) # Head used by Cold Caller
# Bossbots
suitProperties = {
'f': (4.0 / cSize, SuitDNA.corpPolyColor, ['flunky', 'glasses'], '', 4.88),
'p': (3.35 / bSize, SuitDNA.corpPolyColor, ['pencilpusher'], '', 5.0),
'ym': (4.125 / aSize, SuitDNA.corpPolyColor, ['yesman'], '', 5.28),
'mm': (2.5 / cSize, SuitDNA.corpPolyColor, ['micromanager'], '', 3.25),
'ds': (4.5 / bSize, SuitDNA.corpPolyColor, ['beancounter'], '', 6.08),
'hh': (6.5 / aSize, SuitDNA.corpPolyColor, ['headhunter'], '', 7.45),
'cr':
(6.75 / cSize, VBase4(0.85, 0.55, 0.55,
1.0), ['flunky'], 'corporate-raider.jpg', 8.23),
'tbc': (7.0 / aSize, VBase4(0.75, 0.95, 0.75,
1.0), ['bigcheese'], '', 9.34),
# Lawbots
'bf': (4.0 / cSize, SuitDNA.legalPolyColor, ['tightwad'],
def enterScoring(self):
sortedByDistance = []
for avId in self.avIdList:
np = self.getTireNp(avId)
pos = np.getPos()
pos.setZ(0)
sortedByDistance.append((avId, pos.length()))
def compareDistance(x, y):
if x[1] - y[1] > 0:
return 1
elif x[1] - y[1] < 0:
return -1
else:
return 0
sortedByDistance.sort(cmp=compareDistance)
self.scoreMovie = Sequence()
curScale = 0.01
curTime = 0
self.scoreCircle.setScale(0.01)
self.scoreCircle.show()
self.notify.debug('newScores = %s' % self.newScores)
circleStartTime = 0
for index in xrange(len(sortedByDistance)):
distance = sortedByDistance[index][1]
avId = sortedByDistance[index][0]
scorePanelIndex = self.avIdList.index(avId)
time = (distance - curScale) / IceGameGlobals.ExpandFeetPerSec
if time < 0:
time = 0.01
scaleXY = distance + IceGameGlobals.TireRadius
self.notify.debug('circleStartTime = %s' % circleStartTime)
self.scoreMovie.append(
Parallel(
LerpScaleInterval(self.scoreCircle, time,
Point3(scaleXY, scaleXY, 1.0)),
SoundInterval(self.scoreCircleSound,
duration=time,
startTime=circleStartTime)))
circleStartTime += time
startScore = self.scorePanels[scorePanelIndex].getScore()
destScore = self.newScores[scorePanelIndex]
self.notify.debug('for avId %d, startScore=%d, newScores=%d' %
(avId, startScore, destScore))
def increaseScores(t,
scorePanelIndex=scorePanelIndex,
startScore=startScore,
destScore=destScore):
oldScore = self.scorePanels[scorePanelIndex].getScore()
diff = destScore - startScore
newScore = int(startScore + diff * t)
if newScore > oldScore:
base.playSfx(self.countSound)
self.scorePanels[scorePanelIndex].setScore(newScore)
self.scores[scorePanelIndex] = newScore
duration = (destScore -
startScore) * IceGameGlobals.ScoreCountUpRate
tireNp = self.tireDict[avId]['tireNodePath']
self.scoreMovie.append(
Parallel(
LerpFunctionInterval(increaseScores, duration),
Sequence(
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 1, 1, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 1, 1, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 1, 1, 1)))))
curScale += distance
self.scoreMovie.append(
Func(self.sendUpdate, 'reportScoringMovieDone', []))
self.scoreMovie.start()
BodyTextures = {
'dots': 'phase_4/maps/BeanbodyDots6.jpg',
'threeStripe': 'phase_4/maps/Beanbody3stripes6.jpg',
'tigerStripe': 'phase_4/maps/BeanbodyZebraStripes6.jpg',
'turtle': 'phase_4/maps/BeanbodyTurtle.jpg',
'giraffe': 'phase_4/maps/BeanbodyGiraffe1.jpg',
'leopard': 'phase_4/maps/BeanbodyLepord2.jpg',
'tummy': 'phase_4/maps/BeanbodyTummy6.jpg'
}
FeetTextures = {
'normal': 'phase_4/maps/BeanFoot6.jpg',
'turtle': 'phase_4/maps/BeanFootTurttle.jpg',
'giraffe': 'phase_4/maps/BeanFootYellow3.jpg',
'leopard': 'phase_4/maps/BeanFootYellow3.jpg'
}
AllPetColors = (VBase4(1.0, 1.0, 1.0,
1.0), VBase4(0.96875, 0.691406, 0.699219, 1.0),
VBase4(0.933594, 0.265625, 0.28125,
1.0), VBase4(0.863281, 0.40625, 0.417969, 1.0),
VBase4(0.710938, 0.234375, 0.4375,
1.0), VBase4(0.570312, 0.449219, 0.164062, 1.0),
VBase4(0.640625, 0.355469, 0.269531,
1.0), VBase4(0.996094, 0.695312, 0.511719,
1.0), VBase4(0.832031, 0.5, 0.296875, 1.0),
VBase4(0.992188, 0.480469, 0.167969,
1.0), VBase4(0.996094, 0.898438, 0.320312, 1.0),
VBase4(0.996094, 0.957031, 0.597656,
1.0), VBase4(0.855469, 0.933594, 0.492188, 1.0),
VBase4(0.550781, 0.824219, 0.324219,
1.0), VBase4(0.242188, 0.742188, 0.515625, 1.0),
VBase4(0.304688, 0.96875, 0.402344,
1.0), VBase4(0.433594, 0.90625, 0.835938, 1.0),
FireworksPostLaunchDelay = 5.0
RocketSoundDelay = 2.0
RocketDirectionDelay = 2.0
FireworksStartedEvent = 'PartyFireworksStarted'
FireworksFinishedEvent = 'PartyFireworksFinished'
FireworksTransitionToDisabledDelay = 3.0
TeamActivityTeams = PythonUtil.Enum(('LeftTeam', 'RightTeam'), start=0)
TeamActivityNeitherTeam = 3
TeamActivityTextScale = 0.135
TeamActivityStartDelay = 8.0
TeamActivityClientWaitDelay = 30.0
TeamActivityDefaultMinPlayersPerTeam = 1
TeamActivityDefaultMaxPlayersPerTeam = 4
TeamActivityDefaultDuration = 60.0
TeamActivityDefaultConclusionDuration = 4.0
TeamActivityStatusColor = VBase4(1.0, 1.0, 0.65, 1.0)
CogActivityBalanceTeams = True
CogActivityStartDelay = 15.0
CogActivityConclusionDuration = 12
CogActivityDuration = 90
CogActivityMinPlayersPerTeam = 1
CogActivityMaxPlayersPerTeam = 4
CogActivityColors = (VBase4(0.22, 0.4, 0.98, 1.0), VBase4(1.0, 0.43, 0.04, 1.0))
CogActivitySplatColorBase = VBase4(0.98, 0.9, 0.094, 1.0)
CogActivitySplatColors = (VBase4(CogActivityColors[0][0] / CogActivitySplatColorBase[0], CogActivityColors[0][1] / CogActivitySplatColorBase[1], CogActivityColors[0][2] / CogActivitySplatColorBase[2], 1.0), VBase4(CogActivityColors[1][0] / CogActivitySplatColorBase[0], CogActivityColors[1][1] / CogActivitySplatColorBase[1], CogActivityColors[1][2] / CogActivitySplatColorBase[2], 1.0))
CogPinataHeadZ = 4.7
CogActivityHitPoints = 1
CogActivityHitPointsForHead = 3
CogPinataPushBodyFactor = 0.05
CogPinataPushHeadFactor = CogPinataPushBodyFactor * abs(CogActivityHitPointsForHead - CogActivityHitPoints)
CogActivityAvgBeansPerSecond = 0.15
def __init__(self):
"""Initialise the scene."""
# Show the framerate
base.setFrameRateMeter(True)
# Initialise terrain:
# Make 4 terrain nodepath objects with different hilliness values
# and arrange them side-by-side in a 2x2 grid, giving a big terrain
# with variable hilly and flat areas.
color = (0.6, 0.8, 0.5, 1) # Bright green-ish
scale = 12
height = 18 # FIXME: For now we are raising the terrain so it
# floats above the sea to prevent lakes from
# appearing (but you still get them sometimes)
t1 = Terrain(color=color,
scale=scale,
trees=0.7,
pos=P.Point3(0, 0, height))
t1.prime.reparentTo(render)
t2 = Terrain(color=color,
scale=scale,
h=24,
pos=P.Point3(32 * scale, 0, height),
trees=0.5)
t2.prime.reparentTo(render)
t3 = Terrain(color=color,
scale=scale,
h=16,
pos=P.Point3(32 * scale, 32 * scale, height),
trees=0.3)
t3.prime.reparentTo(render)
t4 = Terrain(color=color,
scale=scale,
h=2,
pos=P.Point3(0, 32 * scale, height),
trees=0.9)
t4.prime.reparentTo(render)
#tnp1.setPos(tnp1,-32,-32,terrainHeight)
# Initialise sea
sea = Sea()
# Initialise skybox.
self.box = loader.loadModel("models/skybox/space_sky_box.x")
self.box.setScale(6)
self.box.reparentTo(render)
# Initialise characters
self.characters = []
self.player = C.Character(model='models/eve',
run='models/eve-run',
walk='models/eve-walk')
self.player.prime.setZ(100)
self.player._pos = SteerVec(32 * 12 + random.random() * 100,
32 * 12 + random.random() * 100)
self.player.maxforce = 0.4
self.player.maxspeed = 0.55
EdgeScreenTracker(self.player.prime, dist=200) # Setup camera
for i in range(0, 11):
self.characters.append(C.Character())
self.characters[i].prime.setZ(100)
self.characters[i].wander()
self.characters[i].maxforce = 0.3
self.characters[i].maxspeed = 0.2
self.characters[i]._pos = SteerVec(32 * 12 + random.random() * 100,
32 * 12 + random.random() * 100)
C.setContainer(
ContainerSquare(pos=SteerVec(32 * 12, 32 * 12), radius=31 * 12))
#C.toggleAnnotation()
# Initialise keyboard controls.
self.accept("c", C.toggleAnnotation)
self.accept("escape", sys.exit)
# Setup CollisionRay and CollisionHandlerQueue for mouse picking.
self.pickerQ = P.CollisionHandlerQueue()
self.picker = camera.attachNewNode(
P.CollisionNode('Picker CollisionNode'))
self.picker.node().addSolid(P.CollisionRay())
# We want the picker ray to collide with the floor and nothing else.
self.picker.node().setFromCollideMask(C.floorMASK)
self.picker.setCollideMask(P.BitMask32.allOff())
base.cTrav.addCollider(self.picker, self.pickerQ)
try:
handler.addCollider(self.picker, camera)
except:
pass
self.accept('mouse1', self.onClick)
# Set the far clipping plane to be far enough away that we can see the
# skybox.
base.camLens.setFar(10000)
# Initialise lighting
self.alight = AmbientLight('alight')
self.alight.setColor(VBase4(0.35, 0.35, 0.35, 1))
self.alnp = render.attachNewNode(self.alight)
render.setLight(self.alnp)
self.dlight = DirectionalLight('dlight')
self.dlight.setColor(VBase4(0.4, 0.4, 0.4, 1))
self.dlnp = render.attachNewNode(self.dlight)
self.dlnp.setHpr(45, -45, 0)
render.setLight(self.dlnp)
self.plight = PointLight('plight')
self.plight.setColor(VBase4(0.8, 0.8, 0.5, 1))
self.plnp = render.attachNewNode(self.plight)
self.plnp.setPos(160, 160, 50)
self.slight = Spotlight('slight')
self.slight.setColor(VBase4(1, 1, 1, 1))
lens = PerspectiveLens()
self.slight.setLens(lens)
self.slnp = render.attachNewNode(self.slight)
self.slnp.setPos(-20, -20, 20)
self.slnp.lookAt(50, 50, 0)
# Initialise some scene-wide exponential fog
colour = (0.5, 0.8, 0.8)
self.expfog = Fog("Scene-wide exponential Fog object")
self.expfog.setColor(*colour)
self.expfog.setExpDensity(0.0005)
render.setFog(self.expfog)
base.setBackgroundColor(*colour)
# Add a task for this Plant to the global task manager.
self.stepcount = 0
taskMgr.add(self.step, "Plant step task")
