def createSafeZone(self, dnaFile):
assert (self.notify.debug("createParty()"))
SafeZoneLoader.SafeZoneLoader.createSafeZone(self, dnaFile)
parent = self.geom.getParent()
geom = self.geom
n = NodePath("PartyGroundRoot")
n.reparentTo(parent)
geom.reparentTo(n)
geom.setPos(-10.0, 0.0, 0.0)
self.geom = n
# load the sun and moon
self.loadSunMoon()
def __init__(self, parent, frameModel, startPlatformModel, endPlatformModel, quadLengthUnits, quadVisibilityAhead, quadVisibiltyBehind):
self.parent = parent
self.quadLengthUnits = quadLengthUnits
self._halfQuadLengthUnits = quadLengthUnits / 2.0
self.quadVisibiltyAhead = quadVisibilityAhead
self.quadVisibiltyBehind = quadVisibiltyBehind
self._frameModel = frameModel
self.root = NodePath('CogdoFlyingLevel')
self.quadrantRoot = NodePath('QuadrantsRoot')
self.quadrantRoot.reparentTo(self.root)
self._startPlatformModel = startPlatformModel
self._startPlatformModel.reparentTo(self.root)
self._startPlatformModel.setZ(Globals.Level.StartPlatformHeight)
self._endPlatformModel = endPlatformModel
self._endPlatformModel.reparentTo(self.root)
self._endPlatformModel.setZ(Globals.Level.EndPlatformHeight)
self.wallR = self._frameModel.find('**/wallR')
self.wallL = self._frameModel.find('**/wallL')
self._exit = CogdoGameExit()
self._exit.reparentTo(self._endPlatformModel)
loc = self._endPlatformModel.find('**/exit_loc')
offset = loc.getPos(render)
self._exit.setPos(render, offset)
self.quadrants = []
self.visibleQuadIndices = []
self._numQuads = 0
self._currentQuadNum = -1
self._camera = None
self._initCollisions()
self.upLimit = self._frameModel.find('**/limit_up').getZ(render)
self.downLimit = self._frameModel.find('**/limit_down').getZ(render)
self.leftLimit = self._frameModel.find('**/limit_left').getX(render) - 30.0
self.rightLimit = self._frameModel.find('**/limit_right').getX(render) + 30.0
self.backLimit = -self.quadLengthUnits
self.forwardLimit = self.quadLengthUnits * 20
self._frameModel.flattenStrong()
self.gatherableFactory = CogdoFlyingGatherableFactory()
self.obstacleFactory = CogdoFlyingObtacleFactory()
return
def addToon(self, toon):
marker = NodePath('toon_marker-%i' % toon.doId)
marker.reparentTo(self)
self._getToonMarker(toon).copyTo(marker)
marker.setColor(toon.style.getHeadColor())
if toon.isLocal():
marker.setScale(Globals.Gui.LocalMarkerScale)
marker.setBin('fixed', 10)
else:
marker.setScale(Globals.Gui.MarkerScale)
marker.setBin('fixed', 5)
marker.flattenStrong()
self._toonMarkers[toon] = marker
def getAIShip(self, shipClass):
from pirates.ship.ShipAI import ShipAI
ShipAI = ShipAI
modelClass = ShipGlobals.getModelClass(shipClass)
hull = self.getHull(modelClass, 0)
root = NodePath('Ship')
collisions = root.attachNewNode('collisions')
mastSetup = ShipGlobals.getMastSetup(shipClass)
for data in [(0, 'location_mainmast_0'), (1, 'location_mainmast_1'),
(2, 'location_mainmast_2'), (3, 'location_aftmast*'),
(4, 'location_foremast*')]:
mastData = mastSetup.get(data[0])
if mastData:
mast = self.mastSets[mastData[0]].getMastSet(mastData[1] - 1)
model = NodePath(mast.charRoot)
model.setPos(
hull.locators.find('**/%s' % data[1]).getPos(
hull.locators))
model.setHpr(
hull.locators.find('**/%s' % data[1]).getHpr(
hull.locators))
model.setScale(
hull.locators.find('**/%s' % data[1]).getScale(
hull.locators))
if modelClass > ShipGlobals.INTERCEPTORL3 or data[0] != 3:
mastCode = str(data[0])
else:
mastCode = '0'
mast.collisions.find('**/collision_masts').setTag(
'Mast Code', mastCode)
collisions.node().stealChildren(mast.collisions.node())
continue
collisions.node().stealChildren(hull.collisions.node())
hull.locators.reparentTo(root)
ship = ShipAI.ShipAI(root, collisions, hull.locators)
ship.modelRoot.setTag('Mast Code', str(255))
ship.modelRoot.setTag('Hull Code', str(255))
return ship
def loadModels(self):
self.tramp = self.root.attachNewNode(self.uniqueName('tramp'))
self.screenPlaneElements = NodePath(self.uniqueName('screenPlane'))
self.trampActor = Actor('phase_13/models/parties/trampoline_model', {'emptyAnim': 'phase_13/models/parties/trampoline_anim'})
self.trampActor.reparentTo(self.tramp)
if self.texture:
reskinNode = self.tramp.find('**/trampoline/__Actor_modelRoot/-GeomNode')
reskinNode.setTexture(loader.loadTexture(self.texture), 100)
self.surface = NodePath(self.uniqueName('trampSurface'))
self.surface.reparentTo(self.tramp)
self.surface.setZ(self.trampHeight)
self.trampActor.controlJoint(self.surface, 'modelRoot', 'trampoline_joint1')
self.sign.setPos(PartyGlobals.TrampolineSignOffset)
self.beans = [ loader.loadModelCopy('phase_4/models/props/jellybean4') for i in range(self.numJellyBeans) ]
for bean in self.beans:
bean.find('**/jellybean').setP(-35.0)
bean.setScale(3.0)
bean.setTransparency(True)
bean.reparentTo(self.tramp)
bean.stash()
self.beans[-1].setScale(8.0)
def __updateModel(self):
if self.editModel:
# create a image with the same size of the texture
textureSize = (self.editTexture.getXSize(),
self.editTexture.getYSize())
# create a dummy node, where we setup the parameters for the background rendering
loadPaintNode = NodePath(PandaNode('paintnode'))
loadPaintNode.setShader(Shader.make(self.backgroundShader), 10001)
loadPaintNode.setShaderInput('texsize', textureSize[0],
textureSize[1], 0, 0)
# copy the state onto the camera
self.modelColorCam.node().setInitialState(loadPaintNode.getState())
# the camera gets a special bitmask, to show/hide models from it
self.modelColorCam.node().setCameraMask(BitMask32.bit(1))
if False:
# doesnt work, but would be nicer (not messing with the default render state)
hiddenNode = NodePath(PandaNode('hiddennode'))
hiddenNode.hide(BitMask32.bit(1))
showTroughNode = NodePath(PandaNode('showtroughnode'))
showTroughNode.showThrough(BitMask32.bit(1))
self.modelColorCam.node().setTagStateKey(
'show-on-backrender-cam')
self.modelColorCam.node().setTagState('False',
hiddenNode.getState())
self.modelColorCam.node().setTagState(
'True', showTroughNode.getState())
render.setTag('show-on-backrender-cam', 'False')
self.editModel.setTag('show-on-backrender-cam', 'True')
else:
# make only the model visible to the background camera
render.hide(BitMask32.bit(1))
self.editModel.showThrough(BitMask32.bit(1))
def getFlyBallBubble(self):
if self.__flyBallBubble == None:
bubble = CollisionSphere(0, 0, 0, GolfGlobals.GOLF_BALL_RADIUS)
node = CollisionNode('flyBallBubble')
node.addSolid(bubble)
node.setFromCollideMask(ToontownGlobals.PieBitmask
| ToontownGlobals.CameraBitmask
| ToontownGlobals.FloorBitmask)
node.setIntoCollideMask(BitMask32.allOff())
self.__flyBallBubble = NodePath(node)
self.flyBallHandler = CollisionHandlerEvent()
self.flyBallHandler.addInPattern('flyBallHit-%d' % self.index)
return self.__flyBallBubble
def loadLever(self):
self.lever = self.root.attachNewNode('%sLever' % self.activityName)
self.leverModel = self.party.defaultLeverModel.copyTo(self.lever)
self.controlColumn = NodePath('cc')
column = self.leverModel.find('**/column')
column.getChildren().reparentTo(self.controlColumn)
self.controlColumn.reparentTo(column)
self.stickHinge = self.controlColumn.attachNewNode('stickHinge')
self.stick = self.party.defaultStickModel.copyTo(self.stickHinge)
self.stickHinge.setHpr(0.0, 90.0, 0.0)
self.stick.setHpr(0, -90.0, 0)
self.stick.flattenLight()
self.bottom = self.leverModel.find('**/bottom')
self.bottom.wrtReparentTo(self.controlColumn)
self.bottomPos = self.bottom.getPos()
cs = CollisionSphere(0.0, 1.35, 2.0, 1.0)
cs.setTangible(False)
cn = CollisionNode(self.leverTriggerEvent)
cn.addSolid(cs)
cn.setIntoCollideMask(OTPGlobals.WallBitmask)
self.leverTrigger = self.root.attachNewNode(cn)
self.leverTrigger.reparentTo(self.lever)
self.leverTrigger.stash()
cs = CollisionTube(0.0, 2.7, 0.0, 0.0, 2.7, 3.0, 1.2)
cn = CollisionNode('levertube')
cn.addSolid(cs)
cn.setIntoCollideMask(OTPGlobals.WallBitmask)
self.leverTube = self.leverModel.attachNewNode(cn)
host = base.cr.doId2do.get(self.party.partyInfo.hostId)
if host is None:
self.notify.debug(
'%s loadLever : Host has left the game before lever could be created.'
% self.activityName)
return
scale = host.getGeomNode().getChild(0).getSz(render)
self.leverModel.setScale(scale)
self.controlColumn.setPos(0, 0, 0)
host.setPosHpr(self.lever, 0, 0, 0, 0, 0, 0)
host.pose('leverNeutral', 0)
host.update()
pos = host.rightHand.getPos(self.controlColumn)
self.controlColumn.setPos(pos[0], pos[1], pos[2] - 1)
self.bottom.setZ(host, 0.0)
self.bottom.setPos(self.bottomPos[0], self.bottomPos[1],
self.bottom.getZ())
lookAtPoint = Point3(0.3, 0, 0.1)
lookAtUp = Vec3(0, -1, 0)
self.stickHinge.lookAt(host.rightHand, lookAtPoint, lookAtUp)
host.play('walk')
host.update()
return
def load(self):
self.notify.debug('load()')
CogdoGameMovie.load(self)
backgroundGui = loader.loadModel('phase_5/models/cogdominium/tt_m_gui_csa_flyThru')
self.bg = backgroundGui.find('**/background')
self.chatBubble = backgroundGui.find('**/chatBubble')
self.chatBubble.setScale(6.5, 6.5, 7.3)
self.chatBubble.setPos(0.32, 0, -0.78)
self.bg.setScale(5.2)
self.bg.setPos(0.14, 0, -0.6667)
self.bg.reparentTo(aspect2d)
self.chatBubble.reparentTo(aspect2d)
self.frame = DirectFrame(geom=self.bg, relief=None, pos=(0.2, 0, -0.6667))
self.bg.wrtReparentTo(self.frame)
self.gameTitleText = DirectLabel(parent=self.frame, text=TTLocalizer.CogdoBarrelRoomTitle, scale=TTLocalizer.MRPgameTitleText * 0.8, text_align=TextNode.ACenter, text_font=getSignFont(), text_fg=(1.0, 0.33, 0.33, 1.0), pos=TTLocalizer.MRgameTitleTextPos, relief=None)
self.chatBubble.wrtReparentTo(self.frame)
self.frame.hide()
backgroundGui.removeNode()
self.toonDNA = ToonDNA.ToonDNA()
self.toonDNA.newToonFromProperties('dss', 'ss', 'm', 'm', 2, 0, 2, 2, 1, 8, 1, 8, 1, 14)
self.toonHead = Toon.Toon()
self.toonHead.setDNA(self.toonDNA)
self.makeSuit('sc')
self.toonHead.getGeomNode().setDepthWrite(1)
self.toonHead.getGeomNode().setDepthTest(1)
self.toonHead.loop('neutral')
self.toonHead.setPosHprScale(-0.73, 0, -1.27, 180, 0, 0, 0.18, 0.18, 0.18)
self.toonHead.reparentTo(hidden)
self.toonHead.startBlink()
self.clipPlane = self.toonHead.attachNewNode(PlaneNode('clip'))
self.clipPlane.node().setPlane(Plane(0, 0, 1, 0))
self.clipPlane.setPos(0, 0, 2.45)
self._toonDialogueSfx = loader.loadSfx('phase_3.5/audio/dial/AV_dog_long.ogg')
self._camHelperNode = NodePath('CamHelperNode')
self._camHelperNode.reparentTo(render)
dialogue = TTLocalizer.CogdoBarrelRoomIntroDialog
def start():
self.frame.show()
base.setCellsActive(base.bottomCells + base.leftCells + base.rightCells, 0)
def end():
self._dialogueLabel.reparentTo(hidden)
self.toonHead.reparentTo(hidden)
self.frame.hide()
base.setCellsActive(base.bottomCells + base.leftCells + base.rightCells, 1)
self._stopUpdateTask()
self._ival = Sequence(Func(start), Func(self.displayLine, dialogue), Wait(CogdoBarrelRoomConsts.BarrelRoomIntroTimeout), Func(end))
self._startUpdateTask()
return
def _initVisuals(self):
RepairMincroGame._initVisuals(self)
self.model = loader.loadModel('models/gui/pir_m_gui_srp_pitching_main')
self.board = self.model.find('**/piece_hull')
self.board.reparentTo(self)
self.board.setPos(0.0, 0.0, 0.19)
self.crossHair = self.model.find('**/crosshair')
self.crossHair.reparentTo(base.a2dBackground)
self.crossHair.setBin('fixed', 45)
self.crossHair.setScale(1.0)
self.crossHair.setColorScale(0.0, 1.0, 0.0, 1.0)
self.crossHair.stash()
self.bucketIdle = self.model.find('**/pitchCursor/idle')
self.bucketIdle.reparentTo(base.a2dBackground)
self.bucketIdle.setBin('fixed', 45)
self.bucketIdle.setScale(1.3500000000000001)
self.bucketIdle.stash()
self.bucket = self.bucketIdle.copyTo(NodePath())
self.bucket.reparentTo(base.a2dBackground)
self.bucket.setHpr(0, 0, 90)
self.bucket.setBin('fixed', 45)
self.bucket.setScale(1.3500000000000001)
self.bucket.stash()
self.missPatch = NodePath('dummy')
self.missPatchAsset = self.model.find('**/miss')
self.missPatchAsset.reparentTo(self.missPatch)
self.missPatch.reparentTo(self)
self.missPatch.setScale(1.1000000000000001)
self.missPatch.stash()
self.missSeq = None
index = 1
while True:
locator = self.model.find('**/locator_%i' % index)
if locator.isEmpty():
break
self.locators.append(locator)
index += 1
def createDiner(self, i):
diner = Suit.Suit()
diner.dna = SuitDNA.SuitDNA()
level = self.dinerInfo[i][2]
level -= 4
diner.dna.newSuitRandom(level=level, dept='c')
dept = self.dinerInfo[i][3][i]
diner.dna.newSuitRandom(level=level, dept=dept)
diner.setDNA(diner.dna)
if self.useNewAnimations:
diner.loop('sit', fromFrame=i)
else:
diner.pose('landing', 0)
locator = self.tableGroup.find('**/chair_%d' % (i + 1))
locatorScale = locator.getNetTransform().getScale()[0]
correctHeadingNp = locator.attachNewNode('correctHeading')
self.chairLocators[i] = correctHeadingNp
heading = self.rotationsPerSeatIndex[i]
correctHeadingNp.setH(heading)
sitLocator = correctHeadingNp.attachNewNode('sitLocator')
base.sitLocator = sitLocator
pos = correctHeadingNp.getPos(render)
if SuitDNA.getSuitBodyType(diner.dna.name) == 'c':
sitLocator.setPos(0.5, 3.65, -3.75)
else:
sitLocator.setZ(-2.4)
sitLocator.setY(2.5)
sitLocator.setX(0.5)
self.sitLocators[i] = sitLocator
diner.setScale(1.0 / locatorScale)
diner.reparentTo(sitLocator)
newLoc = NodePath('serviceLoc-%d-%d' % (self.index, i))
newLoc.reparentTo(correctHeadingNp)
newLoc.setPos(0, 3.0, 1)
self.serviceLocs[i] = newLoc
base.serviceLoc = newLoc
head = diner.find('**/joint_head')
newIndicator = DinerStatusIndicator.DinerStatusIndicator(parent=head,
pos=Point3(
0, 0,
3.5),
scale=5.0)
newIndicator.wrtReparentTo(diner)
self.dinerStatusIndicators[i] = newIndicator
# remove nametag (rip lag)
diner.nametag3d.stash()
diner.nametag.destroy()
return diner
def startBallPlayback(self, power, angle, sequenceNum):
flyBall = self.ballModel.copyTo(NodePath())
flyBall.setScale(1.0)
flyBallBubble = self.getFlyBallBubble().instanceTo(NodePath())
flyBallBubble.reparentTo(flyBall)
flyBall.setTag('pieSequence', str(sequenceNum))
flyBall.setTag('throwerId', str(self.avId))
t = power / 100.0
t = 1.0 - t
dist = 300 - 200 * t
time = 1.5 + 0.5 * t
proj = ProjectileInterval(None, startPos=Point3(0, 0, 0), endPos=Point3(0, dist, 0), duration=time)
relVel = proj.startVel
def getVelocity(root = self.root, relVel = relVel):
return render.getRelativeVector(root, relVel)
fly = Sequence(Func(flyBall.reparentTo, render), Func(flyBall.setPosHpr, self.root, 0, 0, 0, 0, 0, 0), Func(base.cTrav.addCollider, flyBallBubble, self.flyBallHandler), ProjectileInterval(flyBall, startVel=getVelocity, duration=3), Func(flyBall.detachNode), Func(base.cTrav.removeCollider, flyBallBubble), Func(self.notify.debug, 'removed collider'), Func(self.flyBallFinishedFlying, sequenceNum))
flyWithSound = Parallel(fly, SoundInterval(self.hitBallSfx, node=self.root), name='flyWithSound')
self.notify.debug('starting flyball track')
flyWithSound.start()
self.flyBallTracks[sequenceNum] = flyWithSound
return
def __init__(self, worldNode, holiday, zone):
MinimapObject.__init__(self, 'capturePoint-%d' % zone, worldNode, NodePath('capturePoint'))
self.holidayId = holiday
self.zone = zone
self.hpMeter = None
self.barricadeIcon = None
self.barricadeDestroyed = None
self.blinker = None
self.sentRemove = False
self.hp = 0
self.maxHp = 0
whiteColor = (1.0, 1.0, 1.0, 1.0)
self.blinker = Sequence(Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor), Wait(0.2), Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor), Wait(0.2), Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor), Wait(0.2), Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor), Wait(0.2), Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor), Wait(0.2), Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor), Wait(0.2), Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor), Wait(0.2), Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor), Wait(0.2), Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor), Wait(0.2), Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor))
return
def announceGenerate(self):
DistributedObject.DistributedObject.announceGenerate(self)
self.sendUpdate('avIdEnteredParty', [base.localAvatar.doId])
globalClock.syncFrameTime()
self.startPartyClock()
base.localAvatar.chatMgr.chatInputSpeedChat.addInsidePartiesMenu()
self.spawnTitleText()
messenger.send(self.generatedEvent)
if config.GetBool('show-debug-party-grid', 0):
self.testGrid = NodePath('test_grid')
self.testGrid.reparentTo(base.cr.playGame.hood.loader.geom)
for i in range(len(self.grid)):
for j in range(len(self.grid[i])):
cm = CardMaker('gridsquare')
np = NodePath(cm.generate())
np.setScale(12)
np.setP(-90.0)
np.setPos(PartyUtils.convertDistanceFromPartyGrid(j, 0) - 6.0, PartyUtils.convertDistanceFromPartyGrid(i, 1) - 6.0, 0.1)
np.reparentTo(self.testGrid)
if self.grid[i][j]:
np.setColorScale(0.0, 1.0, 0.0, 1.0)
else:
np.setColorScale(1.0, 0.0, 0.0, 1.0)
def __init__(self, cr):
DistributedLawnDecor.DistributedLawnDecor.__init__(self, cr)
#self.defaultModel = "phase_8/models/props/flower_treasure.bam"
self.plantPath = NodePath('plantPath')
self.plantPath.reparentTo(self)
self.plotScale = 1.0
self.plantingGuiDoneEvent = "plantingGuiDone"
self.toonStatueSelectionDoneEvent = "toonStatueSelectionDone"
self.defaultModel = "phase_5.5/models/estate/dirt_mound"
self.colorScaler = Vec4(1, 1, 1, 1)
self.plantingGui = None
def loadCloud(self, version, radius, zOffset):
self.notify.debug('loadOnePlatform version=%d' % version)
cloud = NodePath('cloud-%d%d' % (radius, version))
cloudModel = loader.loadModel('phase_5.5/models/estate/bumper_cloud')
cc = cloudModel.copyTo(cloud)
colCube = cc.find('**/collision')
colCube.setName('cloudSphere-0')
dTheta = 2.0 * math.pi / self.numClouds
cloud.reparentTo(self.cloudOrigin)
axes = [Vec3(1, 0, 0), Vec3(0, 1, 0), Vec3(0, 0, 1)]
cloud.setPos(radius * math.cos(version * dTheta), radius * math.sin(version * dTheta), 4 * random.random() + zOffset)
cloud.setScale(4.0)
cloud.setTag('number', '%d%d' % (radius, version))
self.clouds.append([cloud, random.choice(axes)])
def __init__(self, carNode):
self.ticks = 0
self.endOfLife = False
self.subExplosions = []
self.carNode = carNode
self.containerNode = NodePath("CarExplosion")
self.containerNode.reparentTo(carNode)
self.containerNode.setPos(0.0, 0.0, 0.0)
subExplosion = CarSubExplosion(-30, 0.3, 0, 0, self.containerNode)
self.subExplosions.append(subExplosion)
for i in range(6):
self.addSubExplosion()
def __init__(self, serialNum, model, level, parent):
self.serialNum = serialNum
self._model = model
self._level = level
self._root = NodePath('Quadrant' + ` serialNum `)
self._model.reparentTo(self._root)
self._root.reparentTo(parent)
self._visible = True
self.platforms = {}
self.gatherables = []
self.obstacles = []
self._playing = False
self._obstaclesRoot = NodePath('obstacles')
self._obstaclesRoot.reparentTo(self._root)
self._initObstacles(self._obstaclesRoot)
self._gatherablesRoot = NodePath('gatherables')
self._gatherablesRoot.reparentTo(self._root)
self._initGatherables(self._gatherablesRoot)
self._platformsRoot = NodePath('platforms')
self._platformsRoot.reparentTo(self._model)
self._initPlatforms(self._platformsRoot)
self._optimize()
self.place()
def renderQuadInto(self, mul=1, div=1, align=1, depthtex=None, colortex=None, auxtex0=None, auxtex1=None):
""" Creates an offscreen buffer for an intermediate
computation. Installs a quad into the buffer. Returns
the fullscreen quad. The size of the buffer is initially
equal to the size of the main window. The parameters 'mul',
'div', and 'align' can be used to adjust that size. """
texgroup = (depthtex, colortex, auxtex0, auxtex1)
winx, winy = self.getScaledSize(mul, div, align)
depthbits = bool(depthtex != None)
buffer = self.createBuffer("filter-stage", winx, winy, texgroup, depthbits)
if (buffer == None):
return None
cm = CardMaker("filter-stage-quad")
cm.setFrameFullscreenQuad()
quad = NodePath(cm.generate())
quad.setDepthTest(0)
quad.setDepthWrite(0)
quad.setColor(Vec4(1,0.5,0.5,1))
quadcamnode = Camera("filter-quad-cam")
lens = OrthographicLens()
lens.setFilmSize(2, 2)
lens.setFilmOffset(0, 0)
lens.setNearFar(-1000, 1000)
quadcamnode.setLens(lens)
quadcam = quad.attachNewNode(quadcamnode)
dr = buffer.makeDisplayRegion((0, 1, 0, 1))
dr.disableClears()
dr.setCamera(quadcam)
dr.setActive(True)
dr.setScissorEnabled(False)
# This clear stage is important if the buffer is padded, so that
# any pixels accidentally sampled in the padded region won't
# be reading from unititialised memory.
buffer.setClearColor((0, 0, 0, 1))
buffer.setClearColorActive(True)
self.buffers.append(buffer)
self.sizes.append((mul, div, align))
return quad
def __init__(self, cameraNP):
self.cameraNP = cameraNP
self.id = CameraManager.nextID
CameraManager.nextID += 1
self.otherNP = render
self.lookAtNP = NodePath("CameraManager%d.lookAtNP" % self.id)
self.lookAtEnabled = False
self.targetPos = Point3(0.0, 0.0, 0.0)
self.targetLookAtPos = Point3(0.0, 1.0, 0.0)
self.enabled = False
self.rate = 10.0
def loadAssets(self):
self.beltModel = NodePath('beltModel')
self.beltModel.reparentTo(self.boss.geom)
self.startLocator = self.boss.geom.find('**/conveyer_belt_start_%d' %
(self.index + 1))
self.endLocator = self.boss.geom.find('**/conveyer_belt_end_%d' %
(self.index + 1))
center = (self.startLocator.getPos() + self.endLocator.getPos()) / 2.0
self.beltHeight = center.getZ()
self.beltHeight += 0.10000000000000001
center.setZ(0)
self.beltLength = (self.endLocator.getPos() -
self.startLocator.getPos()).length()
self.distBetweenFoodNodes = self.beltLength / self.NumFoodNodes
self.notify.debug('setting beltModelPos to %s' % center)
self.beltModel.setPos(center)
self.setupFoodNodes()
self.setupFoodIvals()
self.setupToonupIvals()
if self.index == 0:
self.beltActorModel = loader.loadModel(
'phase_12/models/bossbotHQ/food_belt1_model')
else:
self.beltActorModel = loader.loadModel(
'phase_12/models/bossbotHQ/food_belt2_model')
if self.beltActorModel:
self.beltActor = Actor.Actor(self.beltActorModel)
if self.index == 0:
self.beltActor.loadAnims(
{'idle': 'phase_12/models/bossbotHQ/food_belt1'})
else:
self.beltActor.loadAnims(
{'idle': 'phase_12/models/bossbotHQ/food_belt2'})
self.beltActor.reparentTo(render)
self.beltActor.setPlayRate(self.BeltActorPlayRate, 'idle')
mesh = self.beltActor.find('**/mesh_tide1')
joint = self.beltActor.find('**/uvj_WakeWhiteTide1')
mesh.setTexProjector(mesh.findTextureStage('default'), joint,
self.beltActor)
self.beltActor.setPos(self.startLocator.getPos())
self.beltSound = base.loadSfx(
'phase_12/audio/sfx/CHQ_FACT_conveyor_belt.wav')
self.beltSound.setLoop(1)
self.beltSoundInterval = SoundInterval(self.beltSound,
node=self.beltModel,
listenerNode=base.localAvatar,
seamlessLoop=True,
volume=0.25,
cutOff=100)
def __init__(self, actor):
"""Initialise the camera, setting it to follow 'actor'.
Arguments:
actor -- The Actor that the camera will initially follow.
"""
self.actor = actor
self.prevtime = 0
# The camera's controls:
# "left" = move the camera left, 0 = off, 1 = on
# "right" = move the camera right, 0 = off, 1 = on
self.controlMap = {"left": 0, "right": 0}
taskMgr.add(self.move, "cameraMoveTask")
# Create a "floater" object. It is used to orient the camera above the
# target actor's head.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# Set up the camera.
base.disableMouse()
base.camera.setPos(self.actor.getX(), self.actor.getY() + 2, 2)
# uncomment for topdown
#base.camera.setPos(self.actor.getX(),self.actor.getY()+10,2)
#base.camera.setHpr(180, -50, 0)
# A CollisionRay beginning above the camera and going down toward the
# ground is used to detect camera collisions and the height of the
# camera above the ground. A ray may hit the terrain, or it may hit a
# rock or a tree. If it hits the terrain, we detect the camera's
# height. If it hits anything else, the camera is in an illegal
# position.
self.cTrav = CollisionTraverser()
self.groundRay = CollisionRay()
self.groundRay.setOrigin(0, 0, 1000)
self.groundRay.setDirection(0, 0, -1)
self.groundCol = CollisionNode('camRay')
self.groundCol.addSolid(self.groundRay)
self.groundCol.setFromCollideMask(BitMask32.bit(1))
self.groundCol.setIntoCollideMask(BitMask32.allOff())
self.groundColNp = base.camera.attachNewNode(self.groundCol)
self.groundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.groundColNp, self.groundHandler)
def loadGrass(self):
self.grassRoot = NodePath("GrassRoot")
self.grassRoot.reparentTo(base.cr.playGame.hood.loader.geom)
grass = loader.loadModel("phase_13/models/parties/grass")
clearPositions = self.getClearSquarePositions()
# Create up to 3 tufts of grass per clear square (avg) or up to PartyGlobals.TuftsOfGrass.
numTufts = min(len(clearPositions) * 3, PartyGlobals.TuftsOfGrass)
for i in range(numTufts):
g = grass.copyTo(self.grassRoot)
pos = random.choice(clearPositions)
g.setPos(pos[0]+random.randint(-8,8), pos[1]+random.randint(-8,8), 0.0)
def load(self):
self.root = NodePath('PartyCog-%d' % self.id)
self.root.reparentTo(self.parentNode)
path = 'phase_13/models/parties/cogPinata_'
self.actor = Actor(path + 'actor', {'idle': path + 'idle_anim',
'down': path + 'down_anim',
'up': path + 'up_anim',
'bodyHitBack': path + 'bodyHitBack_anim',
'bodyHitFront': path + 'bodyHitFront_anim',
'headHitBack': path + 'headHitBack_anim',
'headHitFront': path + 'headHitFront_anim'})
self.actor.reparentTo(self.root)
self.temp_transform = Mat4()
self.head_locator = self.actor.attachNewNode('temphead')
self.bodyColl = CollisionTube(0, 0, 1, 0, 0, 5.75, 0.75)
self.bodyColl.setTangible(1)
self.bodyCollNode = CollisionNode('PartyCog-%d-Body-Collision' % self.id)
self.bodyCollNode.setCollideMask(ToontownGlobals.PieBitmask)
self.bodyCollNode.addSolid(self.bodyColl)
self.bodyCollNodePath = self.root.attachNewNode(self.bodyCollNode)
self.headColl = CollisionTube(0, 0, 3, 0, 0, 3.0, 1.5)
self.headColl.setTangible(1)
self.headCollNode = CollisionNode('PartyCog-%d-Head-Collision' % self.id)
self.headCollNode.setCollideMask(ToontownGlobals.PieBitmask)
self.headCollNode.addSolid(self.headColl)
self.headCollNodePath = self.root.attachNewNode(self.headCollNode)
self.arm1Coll = CollisionSphere(1.65, 0, 3.95, 1.0)
self.arm1Coll.setTangible(1)
self.arm1CollNode = CollisionNode('PartyCog-%d-Arm1-Collision' % self.id)
self.arm1CollNode.setCollideMask(ToontownGlobals.PieBitmask)
self.arm1CollNode.addSolid(self.arm1Coll)
self.arm1CollNodePath = self.root.attachNewNode(self.arm1CollNode)
self.arm2Coll = CollisionSphere(-1.65, 0, 3.45, 1.0)
self.arm2Coll.setTangible(1)
self.arm2CollNode = CollisionNode('PartyCog-%d-Arm2-Collision' % self.id)
self.arm2CollNode.setCollideMask(ToontownGlobals.PieBitmask)
self.arm2CollNode.addSolid(self.arm2Coll)
self.arm2CollNodePath = self.root.attachNewNode(self.arm2CollNode)
splatName = 'splat-creampie'
self.splat = globalPropPool.getProp(splatName)
self.splat.setBillboardPointEye()
self.splatType = globalPropPool.getPropType(splatName)
self.pieHitSound = globalBattleSoundCache.getSound('AA_wholepie_only.ogg')
self.upSound = globalBattleSoundCache.getSound('AV_jump_to_side.ogg')
self.hole = loader.loadModel('phase_13/models/parties/cogPinataHole')
self.hole.setTransparency(True)
self.hole.setP(-90.0)
self.hole.setScale(3)
self.hole.setBin('ground', 3)
self.hole.reparentTo(self.parentNode)
def makeArc(angleDegrees=360, numSteps=16, color=Vec4(1, 1, 1, 1)):
ls = LineSegs()
angleRadians = deg2Rad(angleDegrees)
for i in range(numSteps + 1):
a = angleRadians * i / numSteps
y = math.sin(a)
x = math.cos(a)
ls.drawTo(x, y, 0)
node = ls.create()
if color != Vec4(1, 1, 1, 1):
for i in range(numSteps + 1):
ls.setVertexColor(i, color)
pass
return NodePath(node)
def setupFoodNodes(self):
for i in xrange(self.NumFoodNodes):
newPosIndex = self.NumFoodNodes - 1 - i
yPos = -(self.beltLength /
2.0) + newPosIndex * self.distBetweenFoodNodes
newFoodNode = NodePath('foodNode-%d-%d' % (self.index, i))
newFoodNode.reparentTo(self.beltModel)
newFoodNode.setPos(0, yPos, self.beltHeight)
debugFood = None
if debugFood:
debugFood.setScale(0.1)
debugFood.reparentTo(newFoodNode)
newFoodNode.setH(180)
self.foodNodes.append(newFoodNode)
def enable(self):
if self._enabled:
return
self._toon.detachCamera()
self._prevToonY = 0.0
levelBounds = self._level.getBounds()
l = Globals.Camera.LevelBoundsFactor
self._bounds = ((levelBounds[0][0] * l[0], levelBounds[0][1] * l[0]), (levelBounds[1][0] * l[1], levelBounds[1][1] * l[1]), (levelBounds[2][0] * l[2], levelBounds[2][1] * l[2]))
self._lookAtZ = self._toon.getHeight() + Globals.Camera.LookAtToonHeightOffset
self._camParent = NodePath('CamParent')
self._camParent.reparentTo(self._parent)
self._camParent.setPos(self._toon, 0, 0, 0)
self._camParent.setHpr(180, Globals.Camera.Angle, 0)
self._camera.reparentTo(self._camParent)
self._camera.setPos(0, Globals.Camera.Distance, 0)
self._camera.lookAt(self._toon, 0, 0, self._lookAtZ)
self._cameraLookAtNP = NodePath('CameraLookAt')
self._cameraLookAtNP.reparentTo(self._camera.getParent())
self._cameraLookAtNP.setPosHpr(self._camera.getPos(), self._camera.getHpr())
self._levelBounds = self._level.getBounds()
self._enabled = True
self._frozen = False
self._initCollisions()
def setupWheel():
global wheel
model = loader.loadModel('models/shipparts/pir_m_shp_prt_wheel')
wheel = NodePath('wheelRoot')
r = model.find('**/+LODNode')
r.flattenStrong()
collisions = model.find('**/collisions')
high = r.find('**/lod_high')
med = r.find('**/lod_med')
low = r.find('**/lod_low')
high.reparentTo(wheel.attachNewNode(ModelNode('high')))
med.reparentTo(wheel.attachNewNode(ModelNode('med')))
low.reparentTo(wheel.attachNewNode(ModelNode('low')))
collisions.reparentTo(wheel)
def createSprite(self, sprite):
'''
Creates a new sprite and returns a SpriteRenderInterface for controlling this sprite instance.
The newly created sprite is located at (0,0) in screen coordinates its dimensions are specified
by the given Sprite argument.
@param sprite: A Sprite resource that describes the properties of the sprite to created.
@return: A SpriteRenderInterface instance or None if it failed to create the sprite.
'''
if sprite.eggFile is not None:
spriteNP = self.resources.loadModel(sprite.eggFile)
tex = None
else:
if sprite.video is not None:
card = self.cardMaker.generate()
tex = VideoPlayer.renderToTexture(self.resources,
video=sprite.video,
audio=sprite.audio)
elif sprite.image is not None:
card = self.cardMaker.generate()
tex = self.resources.loadTexture(sprite.image)
sprite.width = tex.getXSize()
sprite.height = tex.getYSize()
else:
self.log.error('Could not determine type for sprite: %s' %
sprite.name)
return None
spriteNP = NodePath(card)
spriteNP.setTexture(tex)
nodeName = self.getSpriteNodeName(sprite.name)
spriteNP.setName(nodeName)
spriteNP.setPos(0, 1, 0)
spriteNP.setScale(sprite.width, 1.0, sprite.height)
spriteNP.setTransparency(1)
spriteNP.reparentTo(self.sprite2d)
spriteNP.setDepthTest(False)
spriteNP.setDepthWrite(False)
spriteNP.setBin("fixed", PanoConstants.RENDER_ORDER_SPRITES)
spriteNP.setPythonTag('sprite', sprite)
if sprite.video is not None:
spriteNP.setPythonTag('video', tex)
tex.setLoop(True)
tex.play()
return SpriteRenderInterface(spriteNP)
def __init__(self, parent, system, **kwargs):
super(StarSystemView, self).__init__(parent, system, **kwargs)
self.refscale = 100
self.node = NodePath('system')
planets, stars = [self.obj.planets, self.obj.stars]
starview = StarView(self, system.star)
starview.node.setScale(self.refscale)
self.starview = starview
# Calculate the smallest distance between any two objects so
# we can ensure no overlaps even in the worst-case scenarios.
last_apsis = 0
min_dist = float("inf")
for planet in self.obj.planets:
dist = planet.apsis - last_apsis
if dist < min_dist: min_dist = dist
last_apsis = planet.apsis
scalefactor = system.star.radius / system.star.radius_km
scalefactor *= (min_dist * 1.2) / last_apsis
scalefactor *= self.refscale / 2
self.scalefactor = scalefactor
min_radius = min([obj.radius for obj in planets + stars])
max_radius = max([obj.radius for obj in planets + stars])
self.planet_views = []
for planet in planets:
pview = PlanetView(self, planet)
pview.set_light(starview.light)
pview.node.setScale(self.refscale * log(planet.radius_km) /
log(system.star.radius_km))
self.planet_views.append(pview)
self.update_orbits()
self.ship_views = {}
for ship in self.obj.ships:
self.add_ship(ship)
#cm = CardMaker('card')
#radius = last_apsis*AU*scalefactor
#cm.setFrame(-radius, radius, -radius, radius)
#trail = self.node.attachNewNode(cm.generate())
#trail.setP(90)
#trail.setTwoSided(True)
self.node.reparentTo(self.parent.node)
