def traverse(self, nodePath, dnaStorage):
node = PandaNode(self.name)
node = nodePath.attachNewNode(node, 0)
node.setPosHprScale(self.pos, self.hpr, self.scale)
for child in self.children:
child.traverse(node, dnaStorage)
node.flattenMedium()
def __init__(self, name):
FSM.__init__(self, name)
PandaNode.__init__(self, name)
DirectObject.__init__(self)
self.active = True
self.lastClickState = PGButton.SReady
self.clickState = PGButton.SReady
self.__hovering = False
self.clickEvent = ''
self.clickExtraArgs = []
self.contents = NodePath.anyPath(self).attachNewNode('contents')
# Create a MouseWatcherRegion:
self.regionName = self.getUniqueName() + '-region'
self.region = MouseWatcherRegion(self.regionName, 0, 0, 0, 0)
base.mouseWatcherNode.addRegion(self.region)
# Accept the mouse events:
enterPattern = base.mouseWatcherNode.getEnterPattern()
leavePattern = base.mouseWatcherNode.getLeavePattern()
buttonDownPattern = base.mouseWatcherNode.getButtonDownPattern()
buttonUpPattern = base.mouseWatcherNode.getButtonUpPattern()
self.accept(enterPattern.replace('%r', self.regionName), self.__handleMouseEnter)
self.accept(leavePattern.replace('%r', self.regionName), self.__handleMouseLeave)
self.accept(buttonDownPattern.replace('%r', self.regionName), self.__handleMouseDown)
self.accept(buttonUpPattern.replace('%r', self.regionName), self.__handleMouseUp)
def __init__(self, *args, **argv):
PandaNode.__init__(self, *args, **argv)
self.pandaActor = Actor("panda-model",
{"walk": "panda-walk4"})
self.pandaActor.reparentTo(self)
print("self:" + str(self.is_empty()))
self.pandaActor.loop("walk")
def __init__(self, name, engine=None):
PandaNode.__init__(self, name)
self.path = NodePath(self)
self.mouseListeners = []
self.hi_id = Vec4()
if engine == None:
engine = SelectionEngine.getDefault()
self.engine = engine
self.engine.register(self)
self.path.setTag('sel', 'sel')
def makeMenu(self, name, t, parent, tipe = 'vertical'): sybGroup=PandaNode(name) parent.addChild(sybGroup) for item in t:# make menu syblings mi = self.makeItem(item, tipe) sybGroup.addChild(mi) if tipe=='vertical': verticalGroupFinish(sybGroup) elif tipe=='horizontal': horizontalGroupFinish(sybGroup) elif tipe=='titleBar': horizontalGroupFinish(sybGroup) return sybGroup
def __init__(self):
PandaNode.__init__(self, 'PositionHandle')
CameraController.getInstance().addEventHandler(EVT_CAMERA_MOVE,
self._fixScale)
self.path = NodePath(self)
self.xHandle = DirectionHandle(self, Vec4(1, 0, 0, 0.6),
Vec3(0, 0, 90), 'x')
self.addChild(self.xHandle)
self.yHandle = DirectionHandle(self, Vec4(0, 1, 0, 0.6),
Vec3(0, -90, 0), 'y')
self.addChild(self.yHandle)
self.zHandle = DirectionHandle(self, Vec4(0, 0, 1, 0.6),
Vec3(0, 0, 0), 'z')
self.addChild(self.zHandle)
self.hHandle = RotationHandle(self, Vec4(0, 0, 1, 0.6),
Vec3(0, 0, 0), 'z')
self.addChild(self.hHandle)
NodePath(self.hHandle).setScale(1.02)
self.pHandle = RotationHandle(self, Vec4(0, 1, 0, 0.6),
Vec3(0, -90, 0), 'y')
self.addChild(self.pHandle)
NodePath(self.pHandle).setScale(0.98)
self.rHandle = RotationHandle(self, Vec4(1, 0, 0, 0.6),
Vec3(0, 0, 90), 'x')
self.addChild(self.rHandle)
self._tPressed()
self.path.setTransparency(1)
self.path.setBin('transparent', 30, 50)
#self.path.setDepthTest(False)
self.path.setLightOff()
self.path.setRenderModeThickness(2)
self.setClients([])
self.evtWatcher = DirectObject.DirectObject()
self.evtWatcher.accept(base.win.getWindowEvent(),
self._windowEventHandler)
self.evtWatcher.accept('r', self._rPressed)
self.evtWatcher.accept('t', self._tPressed)
self.originalPos = self.path.getPos()
self.fLenPx = base.cam.node().getLens().getFocalLength() * base.win.getXSize()
self._fixScale()
def __init__(self, parent, color, hpr, dim):
PandaNode.__init__(self, dim+'rotHandle')
self.path = NodePath(self)
self.parent = parent
self.dim = dim
circle = GeomNode('gnode')
circle.addGeomsFrom(self.geomNode)
self.clickable = ClickableNode('clickable')
self.clickable.addChild(circle)
self.clickable.addMouseListener(self)
circlenp = self.path.attachNewNode(self.clickable)
self.path.setColor(color)
self.path.setHpr(hpr)
self.mDownPos = Vec2()
def __init__(self):
self.terrainElements=[]#holds all terrainElements
self.terrainGrid=[[]]#holds terrainElements as they will be displayed
self.dirty=True # the terrainGrid should be refreshed on next update
self.rootNode = PandaNode("terrainManager root")
self.root = NodePath( self.rootNode )
self.terrainSize=257 #first=textureSize
self.scale=16
#locatoin that whereIsCamera returned last frame
self.lastCamearaLocation = (0,0)
self.currentCamearaLocation = (0,0)
self.defaultBlockSize=64
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.arrowColor = 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 __init__(self, parent, color, hpr, dim):
PandaNode.__init__(self, dim+'handle')
self.path = NodePath(self)
self.parent = parent
self.dim = dim
arrow = GeomNode('gnode')
arrow.addGeomsFrom(self.geomNode)
arrownp = self.path.attachNewNode(arrow)
arrownp.hide(BitMask32(1))
clickNode = ClickableNode('clicknode')
clickNode.setDepthLevel(0.5)
clickNode.addMouseListener(self)
clicknp = self.path.attachNewNode(clickNode)
clickgeom = clicknp.attachNewNode(GeomNode('clicknode'))
clickgeom.hide(BitMask32(7))
clickgeom.node().addGeomsFrom(self.clickableGeomNode)
linesegs = LineSegs()
linesegs.setColor(color)
linesegs.setThickness(2)
linesegs.moveTo(Vec3(0, 0, -30))
linesegs.drawTo(Vec3(0, 0, -0.5))
linesegs.moveTo(Vec3(0, 0, 0.5))
linesegs.drawTo(Vec3(0, 0, 30))
lines = self.path.attachNewNode(linesegs.create())
lines.show(BitMask32(1))
lines.hide(BitMask32(2|4|8|16))
lines.setBin('opaque', 30, 100)
lines.setAntialias(AntialiasAttrib.MNone)
self.path.setColor(color)
self.path.setHpr(hpr)
self.mDownPos = Vec2()
def traverse(self, nodePath, dnaStorage):
node = PandaNode(self.name)
nodePath = nodePath.attachNewNode(node, 0)
for child in self.children_:
child.traverse(nodePath, dnaStorage)
class NametagGroup:
CHAT_TIMEOUT_MIN = 4.0
CHAT_TIMEOUT_MAX = 12.0
CHAT_STOMP_DELAY = 0.2
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.arrowColor = 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 destroy(self):
if self.marginManager is not None:
self.unmanage(self.marginManager)
if self.tickTask is not None:
taskMgr.remove(self.tickTask)
self.tickTask = None
self.clearChatText()
for nametag in list(self.nametags):
self.remove(nametag)
self.nametag2d = None
self.nametag3d = None
if self.icon is not None:
self.icon.removeAllChildren()
self.icon = None
self.chatFont = None
self.font = None
self.chatButton = NametagGlobals.noButton
self.avatar = None
def getUniqueName(self):
return 'NametagGroup-' + str(id(self))
def tick(self, task):
if (self.avatar is None) or (self.avatar.isEmpty()):
return Task.cont
chatText = self.getChatText()
if (NametagGlobals.forceOnscreenChat and
chatText and
self.chatBalloonType == NametagGlobals.CHAT_BALLOON):
visible3d = False
elif self.avatar == NametagGlobals.me:
if (chatText and
self.chatBalloonType == NametagGlobals.CHAT_BALLOON and
not base.cam.node().isInView(self.avatar.getPos(base.cam))):
visible3d = False
else:
visible3d = True
elif NametagGlobals.force2dNametags:
visible3d = False
elif (not NametagGlobals.want2dNametags and
((not chatText) or (self.chatBalloonType != NametagGlobals.CHAT_BALLOON))):
visible3d = True
elif self.avatar.isHidden():
visible3d = False
else:
visible3d = base.cam.node().isInView(self.avatar.getPos(base.cam))
if visible3d != self.visible3d:
self.visible3d = visible3d
if self.nametag2d is not None:
self.nametag2d.setVisible(not visible3d)
return Task.cont
def setAvatar(self, avatar):
self.avatar = avatar
for nametag in self.nametags:
nametag.setAvatar(self.avatar)
def getAvatar(self):
return self.avatar
def setActive(self, active):
self.active = active
for nametag in self.nametags:
nametag.setActive(self.active)
def getActive(self):
return self.active
def setObjectCode(self, objectCode):
self.objectCode = objectCode
def getObjectCode(self):
return self.objectCode
def setChatButton(self, chatButton):
self.chatButton = chatButton
for nametag in self.nametags:
nametag.setChatButton(self.chatButton)
def getChatButton(self):
return self.chatButton
def hasChatButton(self):
return self.chatButton != NametagGlobals.noButton
def setChatReversed(self, reversed):
self.chatReversed = reversed
for nametag in self.nametags:
nametag.setChatReversed(reversed)
def getChatReversed(self):
return self.chatReversed
def setFont(self, font):
self.font = font
for nametag in self.nametags:
nametag.setFont(self.font)
def getFont(self):
return self.font
def setChatFont(self, chatFont):
self.chatFont = chatFont
for nametag in self.nametags:
nametag.setChatFont(self.chatFont)
def getChatFont(self):
return self.chatFont
def setShadow(self, shadow):
self.shadow = shadow
for nametag in self.nametags:
nametag.setShadow(self.shadow)
def getShadow(self):
return self.shadow
def clearShadow(self):
self.shadow = None
for nametag in self.nametags:
nametag.clearShadow()
def setChatType(self, chatType):
self.chatType = chatType
for nametag in self.nametags:
nametag.setChatType(self.chatType)
def getChatType(self):
return self.chatType
def setChatBalloonType(self, chatBalloonType):
self.chatBalloonType = chatBalloonType
for nametag in self.nametags:
nametag.setChatBalloonType(self.chatBalloonType)
def getChatBalloonType(self):
return self.chatBalloonType
def setNametagColor(self, nametagColor):
self.nametagColor = nametagColor
for nametag in self.nametags:
nametag.setNametagColor(self.nametagColor)
def getNametagColor(self):
return self.nametagColor
def setArrowColor(self, arrowColor):
self.arrowColor = arrowColor
for nametag in self.nametags:
nametag.setArrowColor(self.arrowColor)
def getArrowColor(self):
return self.arrowColor
def setChatColor(self, chatColor):
self.chatColor = chatColor
for nametag in self.nametags:
nametag.setChatColor(self.chatColor)
def getChatColor(self):
return self.chatColor
def setSpeedChatColor(self, speedChatColor):
self.speedChatColor = speedChatColor
for nametag in self.nametags:
nametag.setSpeedChatColor(self.speedChatColor)
def getSpeedChatColor(self):
return self.speedChatColor
def setWordWrap(self, wordWrap):
self.wordWrap = wordWrap
for nametag in self.nametags:
nametag.setWordWrap(self.wordWrap)
def getWordWrap(self):
return self.wordWrap
def setChatWordWrap(self, chatWordWrap):
self.chatWordWrap = chatWordWrap
for nametag in self.nametags:
nametag.setChatWordWrap(self.chatWordWrap)
def getChatWordWrap(self):
return self.chatWordWrap
def setText(self, text):
self.text = text
for nametag in self.nametags:
nametag.setText(self.text)
nametag.update()
def getText(self):
return self.text
def getNumChatPages(self):
return len(self.chatPages)
def setChatPageIndex(self, chatPageIndex):
if chatPageIndex >= self.getNumChatPages():
return
self.chatPageIndex = chatPageIndex
for nametag in self.nametags:
nametag.setChatText(self.chatPages[self.chatPageIndex])
nametag.update()
def getChatPageIndex(self):
return self.chatPageIndex
def setChatText(self, chatText, timeout=False):
# If we are currently displaying chat text, we need to "stomp" it. In
# other words, we need to clear the current chat text, pause for a
# brief moment, and then display the new chat text:
if self.getChatText():
self.clearChatText()
self.stompChatText = chatText
self.stompTask = taskMgr.doMethodLater(
self.CHAT_STOMP_DELAY, self.__chatStomp, self.stompTaskName,
extraArgs=[timeout])
return
self.clearChatText()
self.chatPages = chatText.split('\x07')
self.setChatPageIndex(0)
if timeout:
delay = len(self.getChatText()) * 0.5
if delay < self.CHAT_TIMEOUT_MIN:
delay = self.CHAT_TIMEOUT_MIN
elif delay > self.CHAT_TIMEOUT_MAX:
delay = self.CHAT_TIMEOUT_MAX
self.chatTimeoutTask = taskMgr.doMethodLater(
delay, self.clearChatText, self.chatTimeoutTaskName)
def getChatText(self):
if self.chatPageIndex >= self.getNumChatPages():
return ''
return self.chatPages[self.chatPageIndex]
def clearChatText(self, task=None):
if self.stompTask is not None:
taskMgr.remove(self.stompTask)
self.stompTask = None
self.stompChatText = ''
if self.chatTimeoutTask is not None:
taskMgr.remove(self.chatTimeoutTask)
self.chatTimeoutTask = None
self.chatPages = []
self.chatPageIndex = 0
for nametag in self.nametags:
nametag.setChatText('')
nametag.update()
if task is not None:
return Task.done
def getStompChatText(self):
return self.stompChatText
def setIcon(self, icon):
self.icon = icon
for nametag in self.nametags:
nametag.setIcon(self.icon)
def getIcon(self):
return self.icon
def setNametag2d(self, nametag2d):
if self.nametag2d is not None:
self.remove(self.nametag2d)
self.nametag2d = None
if nametag2d is None:
return
self.nametag2d = nametag2d
self.add(self.nametag2d)
def getNametag2d(self):
return self.nametag2d
def setNametag3d(self, nametag3d):
if self.nametag3d is not None:
self.remove(self.nametag3d)
self.nametag3d = None
if nametag3d is None:
return
self.nametag3d = nametag3d
self.add(self.nametag3d)
def getNametag3d(self):
return self.nametag3d
def add(self, nametag):
self.nametags.add(nametag)
nametag.setAvatar(self.avatar)
nametag.setActive(self.active)
nametag.setClickEvent(self.getUniqueName())
nametag.setChatButton(self.chatButton)
nametag.setFont(self.font)
nametag.setChatFont(self.chatFont)
nametag.setChatType(self.chatType)
nametag.setChatBalloonType(self.chatBalloonType)
nametag.setNametagColor(self.nametagColor)
nametag.setArrowColor(self.arrowColor)
nametag.setChatColor(self.chatColor)
nametag.setSpeedChatColor(self.speedChatColor)
nametag.setWordWrap(self.wordWrap)
nametag.setChatWordWrap(self.chatWordWrap)
nametag.setText(self.text)
nametag.setChatText(self.getChatText())
nametag.setIcon(self.icon)
nametag.update()
def remove(self, nametag):
nametag.destroy()
self.nametags.remove(nametag)
def updateAll(self):
for nametag in self.nametags:
nametag.update()
def manage(self, marginManager):
if self.marginManager is not None:
self.unmanage(self.marginManager)
self.marginManager = marginManager
for nametag in self.nametags:
if isinstance(nametag, MarginVisible):
nametag.manage(self.marginManager)
def unmanage(self, marginManager):
if marginManager != self.marginManager:
return
if self.marginManager is None:
return
self.marginManager = marginManager
for nametag in self.nametags:
if isinstance(nametag, MarginVisible):
nametag.unmanage(self.marginManager)
def hideNametag(self):
for nametag in self.nametags:
nametag.hideNametag()
def showNametag(self):
for nametag in self.nametags:
nametag.showNametag()
def hideChat(self):
for nametag in self.nametags:
nametag.hideChat()
def showChat(self):
for nametag in self.nametags:
nametag.showChat()
def hideThought(self):
for nametag in self.nametags:
nametag.hideThought()
def showThought(self):
for nametag in self.nametags:
nametag.showThought()
def __chatStomp(self, timeout=False):
self.setChatText(self.stompChatText, timeout=timeout)
self.stompChatText = ''
def __init__(self):
# Sound
self.collectSoundEffect = loader.loadMusic("sounds/item_collect.mp3")
self.footstepSound = loader.loadMusic("sounds/footsteps.mp3")
self.footstepSound.setLoop(1);
audio3d = Audio3DManager.Audio3DManager(base.sfxManagerList[0], base.camera)
self.musicend = loader.loadMusic("sounds/Enchanted-Woods.mp3")
# Sky Box
starTexture = loader.loadTexture("models/stars.jpg")
self.sky = loader.loadModel("models/box.egg")
self.sky.setScale(300)
self.sky.setPos(-200,-150,0)
self.sky.setBin('background', 0)
self.sky.setDepthWrite(0)
self.sky.setTwoSided(True)
self.sky.setTexture(starTexture, 1)
self.sky.reparentTo(render)
self.sky.set_compass()
# allow transparency
render.setTransparency(TransparencyAttrib.MAlpha)
self.pieCount = 0
self.pieDisplay = grabPie(self.pieCount)
self.keyMap = {"left":0, "right":0, "forward":0, "cam-left":0, "cam-right":0, "run":0, "reset":0}
base.win.setClearColor(Vec4(0,0,0,1))
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
# Create the main character
eveStartPos = self.environ.find("**/start_point").getPos()
self.eve = Actor("models/eve",
{"run":"models/eve_run",
"walk":"models/eve_walk"})
print(eveStartPos)
self.gameOver = 0
self.eve.reparentTo(render)
self.eve.setScale(.2)
#self.eve.setShear(.5, .5, .5)
self.eve.setPos(eveStartPos)
self.eateve = Actor("models/eve")
self.eateve.reparentTo(render)
self.eateve.setScale(.2)
self.eateve.setPos(eveStartPos)
self.eateve.hide()
self.pie = loader.loadModel("models/fruit-pie-slice")
self.pie.reparentTo(render)
self.pie.setScale(.5)
self.pie.setPos(Vec3(-50, -30, 10))
#self.pie.setP(20)
self.rand = Actor("models/eve")
self.rand.reparentTo(render)
self.rand.setScale(.2)
self.rand.setPos(Vec3(-70, -5, eveStartPos.getZ() + 5))
self.rand.hide()
self.rand2 = Actor("models/eve")
self.rand2.reparentTo(render)
self.rand2.setScale(.2)
self.rand2.setPos(Vec3(-70, -5, eveStartPos.getZ() + 10))
self.rand2.hide()
# print(eveStartPos)
# Blue Dragon
self.character3=Actor('models/nik-dragon')
#self.character3.loadModel('models/nik-dragon')
self.character3.reparentTo(render)
self.character3.loadAnims({'win': 'models/nik-dragon'})
self.character3.loop('win')
self.character3.setPlayRate(.5,'win')
self.character3.setScale(.23)
self.character3.setTransparency(1)
#self.character3.setColorScale(0.4,0.2,.4,.7)
self.character3.setColorScale(9,9,9,.3)
self.character3.setPos(-114,11,1.9)
self.blueDragonSound = audio3d.loadSfx("sounds/Snoring Giant.mp3")
audio3d.attachSoundToObject(self.blueDragonSound, self.character3)
self.blueDragonSound.setLoop(True)
self.blueDragonSound.play()
# Red Dragon
self.character2=Actor()
self.character2.loadModel('models/nik-dragon')
self.character2.reparentTo(render)
self.character2.loadAnims({'win': 'models/nik-dragon'})
self.character2.loop('win')
self.character2.setPlayRate(1.5,'win')
self.character2.setScale(.06)
self.character2.setColorScale(6,0.2,0.2,50)
self.character2.setPos(-108,11,.3)
self.redDragonStartPos = self.character2.getPos()
self.redDragonCollideCount = 0
self.redDragonSound = audio3d.loadSfx("sounds/Velociraptor Call.mp3")
audio3d.attachSoundToObject(self.redDragonSound, self.character3)
self.redDragonSound.setLoop(True)
self.redDragonSound.play()
# Green Dragon
self.character=Actor()
self.character.loadModel('models/nik-dragon')
self.character.reparentTo(render)
self.character.loadAnims({'win': 'models/nik-dragon'})
self.character.loop('win')
self.character.setScale(.1)
self.character.setPos(-118,21,0)
self.greenDragonSound = audio3d.loadSfx("sounds/Raptor Call.mp3")
audio3d.attachSoundToObject(self.greenDragonSound, self.character3)
self.greenDragonSound.setLoop(True)
self.greenDragonSound.play()
self.dragonStartPos = self.character.getPos()
self.dragonCollideCount = 0
self.AIworld = AIWorld(render)
#self.AIworld.addObstacle(self.environ)
self.dragonAI = AICharacter("character", self.character, 100, 0.05, 5)
self.AIworld.addAiChar(self.dragonAI)
self.AIbehaviors = self.dragonAI.getAiBehaviors()
#self.AIbehaviors.seek(self.character2)
#self.AIbehaviors.wander(2, 0, 5, .5)
self.AIbehaviors.pursue(self.eateve, 1)
#self.AIbehaviors.wander(5,0,10,.5)
#self.AIbehaviors.evade(self.character3, 10, 20, 300)
#self.AIbehaviors.seek(self.eve, .5)
#self.AIbehaviors.obstacleAvoidance(1)
self.randomChase = AICharacter("rand", self.rand, 50, 20, 20)
self.AIworld.addAiChar(self.randomChase)
self.AIbehaviorsRand = self.randomChase.getAiBehaviors()
self.AIbehaviorsRand.wander(10,0,47,.5)
self.randomChase2 = AICharacter("rand2", self.rand2, 50, 20, 20)
self.AIworld.addAiChar(self.randomChase2)
self.AIbehaviorsRand2 = self.randomChase2.getAiBehaviors()
self.AIbehaviorsRand2.wander(10,0,47,.5)
self.ghostDragonAI = AICharacter("character3", self.character3, 250, .05, 5)
self.AIworld.addAiChar(self.ghostDragonAI)
self.AIbehaviors3 = self.ghostDragonAI.getAiBehaviors()
self.AIbehaviors3.pursue(self.rand, 1)
#self.AIbehaviors3.wander(5,0,10,.5)
self.redDragonChasingEve = 0
self.redDragonAI = AICharacter("character2", self.character2, 100, .05, 7)
self.AIworld.addAiChar(self.redDragonAI)
self.AIbehaviors2 = self.redDragonAI.getAiBehaviors()
self.AIbehaviors2.pursue(self.rand2, 1)
taskMgr.add(self.AIUpdate, "AIUpdate")
# Create a floater object to use for camera management
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# Enable Particles
base.enableParticles()
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left",1])
self.accept("arrow_right", self.setKey, ["right",1])
self.accept("arrow_up", self.setKey, ["forward",1])
self.accept("space", self.setKey, ["run",1])
self.accept("a", self.setKey, ["cam-left",1])
self.accept("s", self.setKey, ["cam-right",1])
self.accept("r", self.setKey, ["reset",1])
self.accept("arrow_left-up", self.setKey, ["left",0])
self.accept("arrow_right-up", self.setKey, ["right",0])
self.accept("arrow_up-up", self.setKey, ["forward",0])
self.accept("space-up", self.setKey, ["run",0])
self.accept("a-up", self.setKey, ["cam-left",0])
self.accept("s-up", self.setKey, ["cam-right",0])
self.accept("r-up", self.setKey, ["reset",0])
taskMgr.add(self.move,"moveTask")
# Game state variables
self.isMoving = False
self.isRunning = False
self.isWalking = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.eve.getX(),self.eve.getY()+10,2)
# Collision detection for eve against the ground and against objects
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above eve's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.eveGroundRay = CollisionRay()
self.eveGroundRay.setOrigin(0,0,4.5)
self.eveGroundRay.setDirection(0,0,-1)
self.eveGroundCol = CollisionNode('eveRay')
self.eveGroundCol.addSolid(self.eveGroundRay)
self.eveGroundCol.setFromCollideMask(BitMask32.bit(0))
self.eveGroundCol.setIntoCollideMask(BitMask32.allOff())
self.eveGroundColNp = self.eve.attachNewNode(self.eveGroundCol)
self.eveGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.eveGroundColNp, self.eveGroundHandler)
self.dragonGroundRay = CollisionRay()
self.dragonGroundRay.setOrigin(0,0,10)
self.dragonGroundRay.setDirection(0,0,-1)
self.dragonGroundCol = CollisionNode('dragonRay')
self.dragonGroundCol.addSolid(self.dragonGroundRay)
self.dragonGroundCol.setFromCollideMask(BitMask32.bit(0))
self.dragonGroundCol.setIntoCollideMask(BitMask32.allOff())
self.dragonGroundColNp = self.character.attachNewNode(self.dragonGroundCol)
self.dragonGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.dragonGroundColNp, self.dragonGroundHandler)
self.ghostDragonGroundRay = CollisionRay()
self.ghostDragonGroundRay.setOrigin(0,0,25)
self.ghostDragonGroundRay.setDirection(0,0,-1)
self.ghostDragonGroundCol = CollisionNode('ghostDragonRay')
self.ghostDragonGroundCol.addSolid(self.ghostDragonGroundRay)
self.ghostDragonGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ghostDragonGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ghostDragonGroundColNp = self.character3.attachNewNode(self.ghostDragonGroundCol)
self.ghostDragonGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ghostDragonGroundColNp, self.ghostDragonGroundHandler)
self.redDragonGroundRay = CollisionRay()
self.redDragonGroundRay.setOrigin(0,0,5)
self.redDragonGroundRay.setDirection(0,0,-1)
self.redDragonGroundCol = CollisionNode('redDragonRay')
self.redDragonGroundCol.addSolid(self.redDragonGroundRay)
self.redDragonGroundCol.setFromCollideMask(BitMask32.bit(0))
self.redDragonGroundCol.setIntoCollideMask(BitMask32.allOff())
self.redDragonGroundColNp = self.character2.attachNewNode(self.ghostDragonGroundCol)
self.redDragonGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.redDragonGroundColNp, self.redDragonGroundHandler)
self.pieRay = CollisionRay()
self.pieRay.setOrigin(0,0,10)
self.pieRay.setDirection(0,0,-1)
self.pieCol = CollisionNode('pieRay')
self.pieCol.addSolid(self.pieRay)
self.pieCol.setFromCollideMask(BitMask32.bit(0))
self.pieCol.setIntoCollideMask(BitMask32.allOff())
self.pieColNp = self.pie.attachNewNode(self.pieCol)
self.pieHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.pieColNp, self.pieHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,1000)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Shows collision rays
#self.eveGroundColNp.show()
#self.camGroundColNp.show()
# Shows collisions
#self.cTrav.showCollisions(render)
self.fixPieZ()
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
#directionalLight.setShadowCaster(True, 512, 512)
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self, name, fromFile=None):
PandaNode.__init__(self, name)
self.elements = []
self.fromFile = fromFile
def test_particle_soft_start():
# Create a particle effect and a particle system.
# The effect serves to test the Python-level "soft_start" method,
# while the system serves to test the C++-level "soft_start" method
# (via the associated Python "soft_start" method)
effect = ParticleEffect()
system = Particles("testSystem", 10)
# Setup some dummy nodes, since it seems to want them
system.set_render_parent(NodePath(PandaNode("test")))
system.set_spawn_render_node_path(NodePath(PandaNode("test")))
# Add the system to the effect
effect.add_particles(system)
# Re-assign the system, just to make sure that we have the
# right object.
system = effect.get_particles_list()[0]
# First, standard "soft_start"--i.e. without either changing
# the birth-rate or applying a delay. This should work as it
# used to.
effect.soft_start()
assert system.get_birth_rate() == 0.5
# Now, check that the pre-existing single-parameter soft-start,
# which alters the birth-rate, still does so.
system.soft_start(1)
assert system.get_birth_rate() == 1
# Next, birth-delaying.
# Run a standard soft-start, then check that the birth-timer
# is zero, as used to be the case on running this command.
effect.soft_start()
assert system.get_tics_since_birth() == 0
# Run an delayed soft-start via the system, then check that the
# birth-timer has the assigned value, and that the birth-rate is
# unchanged.
# (We pass in a birth-rate ("br") of -1 because the related code
# checks for a birth-rate greater than 0, I believe. This allows
# us to change the delay without affecting the birth-rate.)
system.soft_start(br=-1, first_birth_delay=-2)
assert system.get_birth_rate() == 1
assert system.get_tics_since_birth() == 2
# Now, run a delayed soft-start via the effect, and
# again check that the birth-timer has changed as intended,
# and the birth-rate hasn't changed at all.
effect.soft_start(firstBirthDelay=0.25)
assert system.get_birth_rate() == 1
assert system.get_tics_since_birth() == -0.25
# Update the system, advancing it far enough that it should
# have birthed a particle if not for the delay, but not
# so far that it should have birthed a particle >with<
# the delay. Check thus that no particles have been birthed.
system.update(1)
assert system.get_living_particles() == 0
# Update the system again, this time far enough that with the
# delay it should have birthed just one particle, and
# then check that this is the case.
system.update(1)
assert system.get_living_particles() == 1
def loadDNAFile(self, dnaStorage, file):
self.loadDNAFileBase(dnaStorage, file)
nodePath = NodePath(PandaNode('dna'))
self.prop.traverse(nodePath, self.dnaStorage)
return nodePath
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)
'''
cam1 = Camera('cam1')
cam1.getLens().setNear(0.01)
cam1.getLens().setFov(50)
cam1.showFrustum()
camera1 = self.render.attachNewNode(cam1)
camera1.setName('camera1')
camera1.setPos(0, -6, 3)
cam2 = Camera('cam2')
cam2.getLens().setNear(0.01)
cam2.getLens().setFov(50)
#cam2.showFrustum()
camera2 = self.render.attachNewNode(cam2)
camera2.setName('camera2')
camera2.setPos(0, -6, 3)
'''
self.disableMouse()
#self.cam = camera2
#self.lens = self.cam.node().getLens()
self.camera.setPos(0, -6, 3.2)
self.camLens.setNearFar(0.01, 1000.0)
self.camLens.setFov(50)
#self.cam.node().setLodScale(math.tan(math.radians(100.0 * 0.5)))
self.setBackgroundColor(1, 1, 1)
# Check video card capabilities.
if not self.win.getGsg().getSupportsBasicShaders():
print(
"Toon Shader: Video driver reports that Cg shaders are not supported."
)
return
# This shader's job is to render the model with discrete lighting
# levels. The lighting calculations built into the shader assume
# a single nonattenuating point light.
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(self.loader.loadShader("shader/lightingGen.sha"))
self.cam.node().setInitialState(tempnode.getState())
# This is the object that represents the single "light", as far
# the shader is concerned. It's not a real Panda3D LightNode, but
# the shader doesn't care about that.
light = self.render.attachNewNode("light")
light.setPos(30, -50, 0)
# this call puts the light's nodepath into the render state.
# this enables the shader to access this light by name.
self.render.setShaderInput("light", light)
# The "normals buffer" will contain a picture of the model colorized
# so that the color of the model is a representation of the model's
# normal at that point.
normalsBuffer = self.win.makeTextureBuffer("normalsBuffer", 0, 0)
normalsBuffer.setClearColor(LVecBase4(0.5, 0.5, 0.5, 1))
self.normalsBuffer = normalsBuffer
normalsCamera = self.makeCamera(normalsBuffer,
lens=self.cam.node().getLens())
normalsCamera.node().setScene(self.render)
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(self.loader.loadShader("shader/normalGen.sha"))
normalsCamera.node().setInitialState(tempnode.getState())
# what we actually do to put edges on screen is apply them as a texture to
# a transparent screen-fitted card
drawnScene = normalsBuffer.getTextureCard()
drawnScene.setTransparency(1)
drawnScene.setColor(1, 1, 1, 0)
drawnScene.reparentTo(self.render2d)
self.drawnScene = drawnScene
# this shader accepts, as input, the picture from the normals buffer.
# it compares each adjacent pixel, looking for discontinuities.
# wherever a discontinuity exists, it emits black ink.
self.separation = 0.00065
self.cutoff = 0.3
inkGen = self.loader.loadShader("shader/inkGen.sha")
drawnScene.setShader(inkGen)
drawnScene.setShaderInput(
"separation", LVecBase4(self.separation, 0, self.separation, 0))
drawnScene.setShaderInput("cutoff", LVecBase4(self.cutoff))
# Load a model and start its animation.
self.character = Actor()
#self.character.loadModel('models/miku/tda_miku')
#self.character.loadAnims({'anim': 'models/miku/tda_miku-Anim0'})
#self.character.listJoints()
#node = self.character.find('**/*modelRoot')
#geom_node = node.getChildren()[0].node()
#geoms = geom_node.getGeoms()
#for child in node.getChildren():
# print child
self.character.loadModel('models/dekiruo/dekiruo')
self.character.reparentTo(self.render)
self.character.ls()
self.character.loadAnims(
{'normal': 'models/dekiruo/dekiruo-Anim_normal'})
self.character.play('normal')
#self.character.loadAnims({'anger': 'models/dekiruo/dekiruo-Anim_anger'})
#self.character.play('anger')
#self.character.loadAnims({'sadness2crying': 'models/dekiruo/dekiruo-Anim_sadness2crying'})
#self.character.play('sadness2crying')
#self.character.loadAnims({'sleep': 'models/dekiruo/dekiruo-Anim_sleep'})
#self.character.play('sleep')
#self.character.loadAnims({'smile': 'models/dekiruo/dekiruo-Anim_smile'})
#self.character.play('smile')
#self.character.loadAnims({'surprised': 'models/dekiruo/dekiruo-Anim_surprised'})
#self.character.play('surprised')
#self.character.loadModel('models/dekinaio/dekinaio')
#self.character.reparentTo(self.render)
#self.character.ls()
#self.character.loadAnims({'normal': 'models/dekinaio/dekinaio-Anim_normal'})
#self.character.play('normal')
#self.character.loadAnims({'anger': 'models/dekinaio/dekinaio-Anim_anger'})
#self.character.play('anger')
#self.character.loadAnims({'sadness2crying': 'models/dekinaio/dekinaio-Anim_sadness2crying'})
#self.character.play('sadness2crying')
#self.character.loadAnims({'sleep': 'models/dekinaio/dekinaio-Anim_sleep'})
#self.character.play('sleep')
#self.character.loadAnims({'smile': 'models/dekinaio/dekinaio-Anim_smile'})
#self.character.play('smile')
#self.character.loadAnims({'surprised': 'models/dekinaio/dekinaio-Anim_surprised'})
#self.character.play('surprised')
#anim = self.character.getCurrentAnim()
#frames = self.character.getNumFrames(anim)
#print anim, frames
#self.character.pose(anim, int(frames * 0.9))
# Create smiley's node to indicate 3d points
self.smileyActor1 = self.render.attachNewNode('SmileyActorNode1')
self.smileyActor2 = self.render.attachNewNode('SmileyActorNode2')
smiley = self.loader.loadModel('smiley')
smiley.setScale(0.01, 0.01, 0.01)
smiley.instanceTo(self.smileyActor1)
smiley.instanceTo(self.smileyActor2)
n1 = self.character.exposeJoint(None, "modelRoot", "Eyes")
n2 = self.character.exposeJoint(None, "modelRoot", "Head")
self.label1 = OnscreenText(text='P1',
fg=(1, 0, 0, 1),
pos=(0, 0),
scale=.05,
mayChange=1)
self.label2 = OnscreenText(text='P2',
fg=(1, 0, 0, 1),
pos=(0, 0),
scale=.05,
mayChange=1)
self.info1 = OnscreenText(text='dist3d:',
fg=(1, 0, 0, 1),
pos=(-1, 0),
scale=.05,
mayChange=1)
self.info2 = OnscreenText(text='dist2d:',
fg=(1, 0, 0, 1),
pos=(-1, -0.1),
scale=.05,
mayChange=1)
self.info3 = OnscreenText(text='camera:',
fg=(1, 0, 0, 1),
pos=(-1, -0.2),
scale=.05,
mayChange=1)
self.taskMgr.add(self.lookAt, 'lookAt', extraArgs=[n1, n2])
self.taskMgr.add(self.updateNamePos,
'name pos update',
extraArgs=[n1, n2])
# These allow you to change cartooning parameters in realtime
self.accept("escape", sys.exit, [0])
self.accept("arrow_up", self.camera_f) #self.increaseSeparation)
self.accept("arrow_down", self.camera_b) #self.decreaseSeparation)
self.accept("arrow_left", self.camera_l) #self.increaseCutoff)
self.accept("arrow_right", self.camera_r) #self.decreaseCutoff)
self.accept("s", self.saveImage)
self.accept("p", self.play)
self.accept("o", self.stop)
self.accept("n", self.forward)
self.accept("b", self.rewind)
self.accept("l", self.lookAt)
self.accept("h", self.hide)
self.accept("1", self.cam_closeup)
self.accept("2", self.cam_bustshot)
self.accept("3", self.cam_longshot)
def __init__(self):
self.d_objects = {}
self.client = None
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"cam-left": 0,
"cam-right": 0
}
base.win.setClearColor(Vec4(0, 0, 0, 1))
#base.win.setWidth(800)
props = WindowProperties()
props.setTitle('Panda3D/Node.js Networking Experiment')
base.win.requestProperties(props)
# Post the instructions
self.title = addTitle("Roaming Ralph goes Networking")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.85, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.80, "[Up Arrow]: Run Ralph Forward")
self.inst6 = addInstructions(0.70, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.65, "[S]: Rotate Camera Right")
self.inst8 = addInstructions(0.55, "Current connection lag:")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0, 0, 0)
# PlayerStartPos = self.environ.find("**/start_point").getPos()
# print "start pos:", PlayerStartPos
self.player = None
# Create a floater object. We use the "floater" as a temporary
# variable in a variety of calculations.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# ----------------------------------------------------------------------
# new: create DynObject to "host" a Ralph model for our player avatar
# Accept the control keys for movement and rotation
self.accept("escape", self.exitGame)
self.accept("a", self.setKey, ["cam-left", 1])
self.accept("s", self.setKey, ["cam-right", 1])
self.accept("a-up", self.setKey, ["cam-left", 0])
self.accept("s-up", self.setKey, ["cam-right", 0])
# taskMgr.add(self.moveCamera,"CameraMoveTask")
taskMgr.add(self.moveObjects, "ObjectsMoveTask")
# Game state variables
self.isMoving = False
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 1000)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
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 newScreen(self):
"""Creates screen with world model and actors"""
#Loads world model
self.world = loader.loadModel("phase/trialworld.bam")
self.world.reparentTo(render)
#Loads the font
self.font = loader.loadFont("phase/LemonMilk.ttf")
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"cam-left": 0,
"cam-right": 0
}
#Loads actor and animations
mooreStartPos = (0, 0, 0)
self.moore = Actor("phase/ralph", {
"run": "phase/ralph-run",
"walk": "phase/ralph-walk"
})
self.moore.reparentTo(render)
self.moore.setScale(.2)
self.moore.setPos(mooreStartPos)
# Loads a floater above Moore's head to point the camera at
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.moore)
#Controls for moving actor around
self.accept("a", self.setKey, ["left", True])
self.accept("d", self.setKey, ["right", True])
self.accept("w", self.setKey, ["forward", True])
self.accept("a-up", self.setKey, ["left", False])
self.accept("d-up", self.setKey, ["right", False])
self.accept("w-up", self.setKey, ["forward", False])
taskMgr.add(self.move, "moveTask")
self.isMoving = False
# Set up the camera
# Disables the mouse from moving the scren
self.disableMouse()
self.camera.setPos(self.moore.getX(),
self.moore.getY() + 10,
self.moore.getZ() + 2)
# Loads the music file
self.music = self.loader.loadMusic("phase/gunsforhands.ogg")
# Plays the music
self.music.play()
# Starts/stops music
self.accept("m-up", self.startMusic)
# Creates a title
self.title = self.addTitle("Moore's World: The Best World", self.font)
# Creates the instructions
self.inst1 = self.addInstructions(0.06, "ESC: Quit", self.font)
self.inst5 = self.addInstructions(0.12, "M: Enable/Disable Music",
self.font)
self.inst2 = self.addInstructions(0.18, "CONTROLS: W/A/D", self.font)
self.inst5 = self.addInstructions(0.24, "TEPEE: EASY", self.font)
self.inst5 = self.addInstructions(0.30, "HOUSE: MEDIUM", self.font)
self.inst5 = self.addInstructions(0.36, "CASTLE: HARD", self.font)
# Exits the program
self.accept("escape", sys.exit)
def __init__(self):
self.last_mousex = 0
self.last_mousey = 0
self.zone = None
self.zone_reload_name = None
self.winprops = WindowProperties( )
# simple console output
self.consoleNode = NodePath(PandaNode("console_root"))
self.consoleNode.reparentTo(aspect2d)
self.console_num_lines = 24
self.console_cur_line = -1
self.console_lines = []
for i in range(0, self.console_num_lines):
self.console_lines.append(OnscreenText(text='', style=1, fg=(1,1,1,1),
pos=(-1.3, .4-i*.05), align=TextNode.ALeft, scale = .035, parent = self.consoleNode))
# Configuration
self.consoleOut('World Forge v.%s loading configuration' % VERSION)
self.configurator = Configurator(self)
cfg = self.configurator.config
resaveRes = False
if 'xres' in cfg:
self.xres = int(cfg['xres'])
else:
self.xres = 1024
resaveRes = True
if 'yres' in cfg:
self.yres = int(cfg['yres'])
else:
self.yres = 768
resaveRes = True
if resaveRes:
self.saveDefaultRes()
self.xres_half = self.xres / 2
self.yres_half = self.yres / 2
self.mouse_accum = MouseAccume( lambda: (self.xres_half,self.yres_half))
self.eyeHeight = 7.0
self.rSpeed = 80
self.flyMode = 1
# application window setup
base.win.setClearColor(Vec4(0,0,0,1))
self.winprops.setTitle( 'World Forge')
self.winprops.setSize(self.xres, self.yres)
base.win.requestProperties( self.winprops )
base.disableMouse()
# Post the instructions
self.title = addTitle('World Forge v.' + VERSION)
self.inst0 = addInstructions(0.95, "[FLYMODE][1]")
self.inst1 = addInstructions(-0.95, "Camera control with WSAD/mouselook. Press K for hotkey list, ESC to exit.")
self.inst2 = addInstructions(0.9, "Loc:")
self.inst3 = addInstructions(0.85, "Hdg:")
self.error_inst = addInstructions(0, '')
self.kh = []
self.campos = Point3(155.6, 41.2, 4.93)
base.camera.setPos(self.campos)
# Accept the application control keys: currently just esc to exit navgen
self.accept("escape", self.exitGame)
self.accept("window-event", self.resizeGame)
# Create some lighting
ambient_level = .6
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(ambient_level, ambient_level, ambient_level, 1.0))
render.setLight(render.attachNewNode(ambientLight))
direct_level = 0.8
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(0.0, 0.0, -1.0))
directionalLight.setColor(Vec4(direct_level, direct_level, direct_level, 1))
directionalLight.setSpecularColor(Vec4(direct_level, direct_level, direct_level, 1))
render.setLight(render.attachNewNode(directionalLight))
# create a point light that will follow our view point (the camera for now)
# attenuation is set so that this point light has a torch like effect
self.plight = PointLight('plight')
self.plight.setColor(VBase4(0.8, 0.8, 0.8, 1.0))
self.plight.setAttenuation(Point3(0.0, 0.0, 0.0002))
self.plnp = base.camera.attachNewNode(self.plight)
self.plnp.setPos(0, 0, 0)
render.setLight(self.plnp)
self.cam_light = 1
self.keyMap = {"left":0, "right":0, "forward":0, "backward":0, "cam-left":0, \
"cam-right":0, "mouse3":0, "flymode":1 }
# setup FOG
self.fog_colour = (0.8,0.8,0.8,1.0)
self.linfog = Fog("A linear-mode Fog node")
self.linfog.setColor(self.fog_colour)
self.linfog.setLinearRange(700, 980) # onset, opaque distances as params
# linfog.setLinearFallback(45,160,320)
base.camera.attachNewNode(self.linfog)
render.setFog(self.linfog)
self.fog = 1
# camera control
self.campos = Point3(0, 0, 0)
self.camHeading = 0.0
self.camPitch = 0.0
base.camLens.setFov(65.0)
base.camLens.setFar(1200)
self.cam_speed = 0 # index into self.camp_speeds
self.cam_speeds = [40.0, 80.0, 160.0, 320.0, 640.0]
# Collision Detection for "WALKMODE"
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. The ray will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0.0, 0.0, 0.0)
self.camGroundRay.setDirection(0,0,-1) # straight down
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
# attach the col node to the camCollider dummy node
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
# self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
# self.cTrav.showCollisions(render)
# Add the spinCameraTask procedure to the task manager.
# taskMgr.add(self.spinCameraTask, "SpinCameraTask")
globals.hasClickedSpawn = False;
globals.hasClickedGrid = False;
taskMgr.add(self.camTask, "camTask")
self.toggleControls(1)
# need to step the task manager once to make our fake console work
taskMgr.step()
def __init__(self):
ShowBase.__init__(self)
self.key = {
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"cam_left": 0,
"cam_right": 0,
"cam_down": 0,
"cam_up": 0,
"up": 0,
"down": 0
}
#####################
#
# Simply testing procedural cave generation
#
#####################
self.start = PlatformSeg(LVector3(0, 0, 0))
self.start.generateAllParts(render)
self.lostWood = LostWood(
LVector3(self.start.pos.x + 750,
self.start.parts[0].pos.y + self.start.parts[0].wid,
self.start.pos.z))
self.lostWood.generateAllParts(render)
self.cave = Cave(
LVector3(self.lostWood.pos.x + 1100,
self.lostWood.parts[6].pos.y + self.lostWood.parts[6].wid,
self.lostWood.pos.z))
self.cave.generateAllParts(render)
self.end = End(
LVector3(
self.cave.thirdRoomParts[8].pos.x - 200,
self.cave.thirdRoomParts[8].pos.y +
self.cave.thirdRoomParts[8].wid,
self.cave.thirdRoomParts[8].pos.z))
self.end.generate(render)
####################
#
# Setting light so that we could see the definition in the walls
#
####################
render.setShaderAuto()
self.dlight = DirectionalLight('dlight')
self.dlight.setColor(LVector4(0.3, 0.1, 0.7, 1))
dlnp = render.attachNewNode(self.dlight)
dlnp.setHpr(90, 20, 0)
render.setLight(dlnp)
self.alight = render.attachNewNode(AmbientLight("Ambient"))
self.alight.node().setColor(LVector4(0.5, 0.5, 1, .1))
render.setLight(self.alight)
base.disableMouse()
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
base.camera.reparentTo(self.floater)
base.camera.setPos(0, -20, 500)
base.camera.setP(-50)
self.bindKeys()
def __init__(self):
__builtin__.main = self
self.taskMgr = taskMgr
self.base = base
# Connect to the server
self.cManager = ConnectionManager()
self.startConnection()
self.characters = dict()
self.cpList = dict()
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"cam-left": 0,
"cam-right": 0
}
base.win.setClearColor(Vec4(0, 0, 0, 1))
# Post the instructions
self.title = addTitle(
"Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.85, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.80, "[Up Arrow]: Run Ralph Forward")
self.inst6 = addInstructions(0.70, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.65, "[S]: Rotate Camera Right")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0, 0, 0)
self.ralphStartPos = self.environ.find("**/start_point").getPos()
# Create a floater object. We use the "floater" as a temporary
# variable in a variety of calculations.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left", 1])
self.accept("arrow_right", self.setKey, ["right", 1])
self.accept("arrow_up", self.setKey, ["forward", 1])
self.accept("a", self.setKey, ["cam-left", 1])
self.accept("s", self.setKey, ["cam-right", 1])
self.accept("arrow_left-up", self.setKey, ["left", 0])
self.accept("arrow_right-up", self.setKey, ["right", 0])
self.accept("arrow_up-up", self.setKey, ["forward", 0])
self.accept("a-up", self.setKey, ["cam-left", 0])
self.accept("s-up", self.setKey, ["cam-right", 0])
# Placeholder Login
self.name = str(raw_input("Name: "))
factionId = int(input("Faction ID: "))
self.cManager.sendRequest(Constants.CMSG_AUTH, [self.name, factionId])
# Create two control points
cp1 = ControlPoint(1, -107.575, 0.6066, 0.490075, 10, RED)
cp2 = ControlPoint(2, -100.575, -35.6066, 0.090075, 10, BLUE)
self.cpList[1] = cp1
self.cpList[2] = cp2
# Create the control point Bar UI
self.cp_bar = ControlPointBar()
self.resource_bar = ResourceBar()
taskMgr.doMethodLater(0.1, self.refresh, "heartbeat")
taskMgr.doMethodLater(1, self.CPHandler, "CPHandler")
taskMgr.doMethodLater(0.1, self.CPBarHandler, 'CPBarHandler')
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
#base.camera.setPos(self.character.actor.getX(),self.character.actor.getY()+10,2)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
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 __init__(self):
# Setup window size, title and so on
load_prc_file_data(
"", """
win-size 1600 900
window-title Render Pipeline - Roaming Ralph Demo
""")
# ------ Begin of render pipeline code ------
# Insert the pipeline path to the system path, this is required to be
# able to import the pipeline classes
pipeline_path = "../../"
# Just a special case for my development setup, so I don't accidentally
# commit a wrong path. You can remove this in your own programs.
if not os.path.isfile(os.path.join(pipeline_path, "setup.py")):
pipeline_path = "../../RenderPipeline/"
sys.path.insert(0, pipeline_path)
from rpcore import RenderPipeline, SpotLight
self.render_pipeline = RenderPipeline()
self.render_pipeline.create(self)
# ------ End of render pipeline code, thats it! ------
# Set time of day
self.render_pipeline.daytime_mgr.time = "7:40"
# Use a special effect for rendering the scene, this is because the
# roaming ralph model has no normals or valid materials
self.render_pipeline.set_effect(render,
"scene-effect.yaml", {},
sort=250)
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"cam-left": 0,
"cam-right": 0
}
self.speed = 1.0
base.win.setClearColor(Vec4(0, 0, 0, 1))
# Post the instructions
self.inst1 = addInstructions(0.95, "[ESC] Quit")
self.inst4 = addInstructions(0.90, "[W] Run Ralph Forward")
self.inst4 = addInstructions(0.85, "[S] Run Ralph Backward")
self.inst2 = addInstructions(0.80, "[A] Rotate Ralph Left")
self.inst3 = addInstructions(0.75, "[D] Rotate Ralph Right")
self.inst6 = addInstructions(0.70, "[Left Arrow] Rotate Camera Left")
self.inst7 = addInstructions(0.65,
"[Right Arrow] Rotate Camera Right")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("resources/world")
self.environ.reparentTo(render)
self.environ.setPos(0, 0, 0)
# Remove wall nodes
self.environ.find("**/wall").remove_node()
# Create the main character, Ralph
self.ralph = Actor("resources/ralph", {
"run": "resources/ralph-run",
"walk": "resources/ralph-walk"
})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(Vec3(-110.9, 29.4, 1.8))
# Create a floater object. We use the "floater" as a temporary
# variable in a variety of calculations.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("a", self.setKey, ["left", 1])
self.accept("d", self.setKey, ["right", 1])
self.accept("w", self.setKey, ["forward", 1])
self.accept("s", self.setKey, ["backward", 1])
self.accept("arrow_left", self.setKey, ["cam-left", 1])
self.accept("arrow_right", self.setKey, ["cam-right", 1])
self.accept("a-up", self.setKey, ["left", 0])
self.accept("d-up", self.setKey, ["right", 0])
self.accept("w-up", self.setKey, ["forward", 0])
self.accept("s-up", self.setKey, ["backward", 0])
self.accept("arrow_left-up", self.setKey, ["cam-left", 0])
self.accept("arrow_right-up", self.setKey, ["cam-right", 0])
self.accept("=", self.adjustSpeed, [0.25])
self.accept("+", self.adjustSpeed, [0.25])
self.accept("-", self.adjustSpeed, [-0.25])
taskMgr.add(self.move, "moveTask")
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.ralph.getX() + 10, self.ralph.getY() + 10, 2)
base.camLens.setFov(80)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 1000)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 1000)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
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 __init__(self):
base.disableMouse()
base.setBackgroundColor(0,0,0)
camera.setPos(0,-50,0)
# Check video card capabilities.
if (base.win.getGsg().getSupportsBasicShaders() == 0):
addTitle("Glow Filter: Video driver reports that shaders are not supported.")
return
# Post the instructions
self.title = addTitle("Panda3D: Tutorial - Glow Filter")
self.inst1 = addInstructions(0.95,"ESC: Quit")
self.inst2 = addInstructions(0.90,"Space: Toggle Glow Filter On/Off")
self.inst3 = addInstructions(0.85,"Enter: Toggle Running/Spinning")
self.inst4 = addInstructions(0.80,"V: View the render-to-texture results")
#create the shader that will determime what parts of the scene will glow
glowShader=loader.loadShader("glowShader.sha")
# load our model
self.tron=Actor()
self.tron.loadModel("models/tron")
self.tron.loadAnims({"running":"models/tron_anim"})
self.tron.reparentTo(render)
self.interval = self.tron.hprInterval(60,Point3(360,0,0))
self.interval.loop()
self.isRunning=False
#put some lighting on the tron model
dlight = DirectionalLight('dlight')
alight = AmbientLight('alight')
dlnp = render.attachNewNode(dlight)
alnp = render.attachNewNode(alight)
dlight.setColor(Vec4(1.0, 0.7, 0.2, 1))
alight.setColor(Vec4(0.2, 0.2, 0.2, 1))
dlnp.setHpr(0, -60, 0)
render.setLight(dlnp)
render.setLight(alnp)
# create the glow buffer. This buffer renders like a normal scene,
# except that only the glowing materials should show up nonblack.
glowBuffer=base.win.makeTextureBuffer("Glow scene", 512, 512)
glowBuffer.setSort(-3)
glowBuffer.setClearColor(Vec4(0,0,0,1))
# We have to attach a camera to the glow buffer. The glow camera
# must have the same frustum as the main camera. As long as the aspect
# ratios match, the rest will take care of itself.
glowCamera=base.makeCamera(glowBuffer, lens=base.cam.node().getLens())
# Tell the glow camera to use the glow shader
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(glowShader)
glowCamera.node().setInitialState(tempnode.getState())
# set up the pipeline: from glow scene to blur x to blur y to main window.
blurXBuffer=makeFilterBuffer(glowBuffer, "Blur X", -2, "XBlurShader.sha")
blurYBuffer=makeFilterBuffer(blurXBuffer, "Blur Y", -1, "YBlurShader.sha")
self.finalcard = blurYBuffer.getTextureCard()
self.finalcard.reparentTo(render2d)
self.finalcard.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd))
# Panda contains a built-in viewer that lets you view the results of
# your render-to-texture operations. This code configures the viewer.
self.accept("v", base.bufferViewer.toggleEnable)
self.accept("V", base.bufferViewer.toggleEnable)
base.bufferViewer.setPosition("llcorner")
base.bufferViewer.setLayout("hline")
base.bufferViewer.setCardSize(0.652,0)
# event handling
self.accept("space", self.toggleGlow)
self.accept("enter", self.toggleDisplay)
self.accept("escape", sys.exit, [0])
self.glowOn=True;
def __init__(self):
ShowBase.__init__(self)
self.actorBullet = 0
self.keyMap = {
"cam-up": False,
"cam-down": False,
"cam-left": False,
"cam-right": False,
"up": False,
"down": False,
"left": False,
"right": False,
"shoot": False
}
#load environment model
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
#load actor
actorStartPos = self.environ.find("**/start_point").getPos()
self.actor = Actor("models/ralph", {
"run": "models/ralph-run",
"walk": "models/ralph-walk"
})
self.actor.reparentTo(render)
self.actor.setScale(.2)
self.actor.setPos(actorStartPos + (0, 0, 0))
#load bullets
for bullets in range(self.actorBullet):
print("making bullet")
bullet = loader.loadModel("models/smiley")
bullet.reparentTo(render)
bullet.setPos(self.actor.getPos())
#load floater which is the point of focus for the camera
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.actor)
self.floater.setZ(2.0)
self.disableMouse()
# base.useDrive()
self.camera.setPos(self.actor.getX(), self.actor.getY() + 10, 2.0)
self.camera.lookAt(self.floater)
#event handlers
self.accept("arrow_up", self.setKey, ["cam-up", True])
self.accept("arrow_up-up", self.setKey, ["cam-up", False])
self.accept("arrow_down", self.setKey, ["cam-down", True])
self.accept("arrow_down-up", self.setKey, ["cam-down", False])
self.accept("arrow_left", self.setKey, ["cam-left", True])
self.accept("arrow_left-up", self.setKey, ["cam-left", False])
self.accept("arrow_right", self.setKey, ["cam-right", True])
self.accept("arrow_right-up", self.setKey, ["cam-right", False])
self.accept("w", self.setKey, ["up", True])
self.accept("w-up", self.setKey, ["up", False])
self.accept("a", self.setKey, ["left", True])
self.accept("a-up", self.setKey, ["left", False])
self.accept("s", self.setKey, ["down", True])
self.accept("s-up", self.setKey, ["down", False])
self.accept("d", self.setKey, ["right", True])
self.accept("d-up", self.setKey, ["right", False])
self.accept("space", self.setKey, ["shoot", True])
self.accept("space-up", self.setKey, ["shoot", False])
taskMgr.add(self.moveCamera, "moveCamera")
self.isMoving = False
#create collision traverser which handles all the collision stuff
self.Traverser = CollisionTraverser()
#create solid
self.actorGroundRay = CollisionRay()
#set origin and direction of the collision ray
self.actorGroundRay.setOrigin(0, 0, 9)
self.actorGroundRay.setDirection(0, 0, -1)
#create the collision node
self.actorGroundCol = CollisionNode('ralphRay')
#attach solid to node
self.actorGroundCol.addSolid(self.actorGroundRay)
#attach node to actor. Create the node path
self.actorGroundColNp = self.actor.attachNewNode(self.actorGroundCol)
#create queue
self.actorGroundHandler = CollisionHandlerQueue()
#add nodepath and queue to traverser
self.Traverser.addCollider(self.actorGroundColNp,
self.actorGroundHandler)
def __init__(self):
self.switchState = True
self.switchCam = False
self.path_no = 1
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"cam-left": 0,
"cam-right": 0
}
base.win.setClearColor((0, 0, 0, 1))
base.cam.setPosHpr(17.79, -87.64, 90.16, 38.66, 325.36, 0)
# Post the instructions
addTitle("Pandai Tutorial: Roaming Ralph (Walking on Uneven Terrain) "
"working with pathfinding")
addInstructions(0.95, "[ESC]: Quit")
addInstructions(0.90, "[Space - do Only once]: Start Pathfinding")
addInstructions(0.85, "[Enter]: Change camera view")
addInstructions(0.80, "[Up Arrow]: Run Ralph Forward")
addInstructions(0.70, "[A]: Rotate Camera Left")
addInstructions(0.65, "[S]: Rotate Camera Right")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(12, 0, 0)
self.box = loader.loadModel("models/box")
self.box.reparentTo(render)
self.box.setPos(-29.83, 0, 0)
self.box.setScale(1)
self.box1 = loader.loadModel("models/box")
self.box1.reparentTo(render)
self.box1.setPos(-51.14, -17.90, 0)
self.box1.setScale(1)
# Create the main character, Ralph
#ralphStartPos = self.environ.find("**/start_point").getPos()
ralphStartPos = Vec3(-98.64, -20.60, 0)
self.ralph = Actor("models/ralph", {
"run": "models/ralph-run",
"walk": "models/ralph-walk"
})
self.ralph.reparentTo(render)
self.ralph.setScale(1)
self.ralph.setPos(ralphStartPos)
self.ralphai = Actor("models/ralph", {
"run": "models/ralph-run",
"walk": "models/ralph-walk"
})
self.pointer = loader.loadModel("models/arrow")
self.pointer.setColor(1, 0, 0)
self.pointer.setPos(-7.5, -1.2, 0)
self.pointer.setScale(3)
self.pointer.reparentTo(render)
self.pointer1 = loader.loadModel("models/arrow")
self.pointer1.setColor(1, 0, 0)
self.pointer1.setPos(-98.64, -20.60, 0)
self.pointer1.setScale(3)
#self.pointer.reparentTo(render)
# Create a floater object. We use the "floater" as a temporary
# variable in a variety of calculations.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("enter", self.activateCam)
self.accept("arrow_left", self.setKey, ["left", 1])
self.accept("arrow_right", self.setKey, ["right", 1])
self.accept("arrow_up", self.setKey, ["forward", 1])
self.accept("a", self.setKey, ["cam-left", 1])
self.accept("s", self.setKey, ["cam-right", 1])
self.accept("arrow_left-up", self.setKey, ["left", 0])
self.accept("arrow_right-up", self.setKey, ["right", 0])
self.accept("arrow_up-up", self.setKey, ["forward", 0])
self.accept("a-up", self.setKey, ["cam-left", 0])
self.accept("s-up", self.setKey, ["cam-right", 0])
#taskMgr.add(self.move,"moveTask")
# Game state variables
self.isMoving = False
# Set up the camera
#base.disableMouse()
#base.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 1000)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 1000)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
#self.camGroundColNp.show()
#Uncomment this line to show a visual representation of the
#collisions occuring
#self.cTrav.showCollisions(render)
self.setAI()
def __init__(self):
self.keyMap = {"left":0, "right":0, "forward":0, "cam-left":0, "cam-right":0}
base.win.setClearColor(Vec4(0,0,0,1))
# Post the instructions
self.title = addTitle("Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.85, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.80, "[Up Arrow]: Run Ralph Forward")
self.inst6 = addInstructions(0.70, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.65, "[S]: Rotate Camera Right")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
# Create the main character, Ralph
ralphStartPos = self.environ.find("**/start_point").getPos()
self.ralph = Actor("models/ralph",
{"run":"models/ralph-run",
"walk":"models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos)
# Create a floater object. We use the "floater" as a temporary
# variable in a variety of calculations.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left",1])
self.accept("arrow_right", self.setKey, ["right",1])
self.accept("arrow_up", self.setKey, ["forward",1])
self.accept("a", self.setKey, ["cam-left",1])
self.accept("s", self.setKey, ["cam-right",1])
self.accept("arrow_left-up", self.setKey, ["left",0])
self.accept("arrow_right-up", self.setKey, ["right",0])
self.accept("arrow_up-up", self.setKey, ["forward",0])
self.accept("a-up", self.setKey, ["cam-left",0])
self.accept("s-up", self.setKey, ["cam-right",0])
taskMgr.add(self.move,"moveTask")
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.ralph.getX(),self.ralph.getY()+10,2)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0,0,1000)
self.ralphGroundRay.setDirection(0,0,-1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,1000)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
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 update(self, task):
if self.isLevel1 == True and self.characterClass != 0:
if self.characterClass.nextLevel == True:
self.setLevel2()
if self.isLevel2 == True and self.characterClass != 0:
if self.characterClass.nextLevel == True:
self.setLevel1()
if inputState.isSet('help'):
if self.showHelp == True:
self.showHelp = False
else:
self.showHelp = True
if inputState.isSet('menu'):
if self.showMenu == True:
self.showMenu = False
else:
self.showMenu = True
if self.showHelp == True:
self.inst1.show()
self.inst2.show()
self.inst3.show()
self.inst4.show()
self.inst5.show()
self.inst6.show()
self.inst7.show()
self.inst8.show()
self.inst9.show()
self.inst10.show()
self.inst11.show()
self.inst12.show()
self.inst13.show()
self.inst14.show()
else:
self.inst1.hide()
self.inst2.hide()
self.inst3.hide()
self.inst4.hide()
self.inst5.hide()
self.inst6.hide()
self.inst7.hide()
self.inst8.hide()
self.inst9.hide()
self.inst10.hide()
self.inst11.hide()
self.inst12.hide()
self.inst13.hide()
self.inst14.hide()
if self.showMenu == True:
self.imageObject.show()
self.b1.show()
self.b2.show()
self.b3.show()
if self.characterClass != 0:
self.characterClass.bar.setPos(2,2,2)
self.characterClass.frame.setPos(2,2,2)
self.characterClass.item.setPos(2,2,2)
else:
self.imageObject.hide()
self.b1.hide()
self.b2.hide()
self.b3.hide()
if self.characterClass != 0:
self.characterClass.bar.setPos(0.8,0.5,0.9)
self.characterClass.frame.setPos(0.7,0.5,0.8)
self.characterClass.item.setPos(0.9,0.5,0.8)
if self.mySound.status() == self.mySound.READY:
self.mySound.play()
self.mySound.setVolume(0.9)
if self.isLevel1 == True or self.isLevel2 == True:
dt = globalClock.getDt()
self.characterClass.processInput(dt)
self.characterClass.models.world.doPhysics(dt, 100, 1./180.)
# Create a floater object. We use the "floater" as a temporary
# variable in a variety of calculations.
self.characterClass.floater = NodePath(PandaNode("floater"))
self.characterClass.floater.reparentTo(render)
if self.characterClass.characterNP.getZ() != 0:
base.camera.setZ(self.characterClass.characterNP.getZ()+3)
# If the camera is too far from ralph, move it closer.
# If the camera is too close to ralph, move it farther.
camvec = self.characterClass.characterNP.getPos() - base.camera.getPos()
camvec.setZ(0)
camdist = camvec.length()
camvec.normalize()
if (camdist > 15.0):
base.camera.setPos(base.camera.getPos() + camvec*(camdist-15))
camdist = 15.0
if (camdist < 5.0):
base.camera.setPos(base.camera.getPos() - camvec*(5-camdist))
camdist = 5.0
self.characterClass.floater.setPos(self.characterClass.characterNP.getPos())
self.characterClass.floater.setZ(self.characterClass.characterNP.getZ() + 2.0)
base.camera.lookAt(self.characterClass.floater)
return task.cont
def __init__(self):
PandaNode.__init__(self, 'margins')
self.cells = set()
self.visibles = set()
def __init__(self, game):
self.game = game
self.shipPoint = NodePath(PandaNode("shipFloaterPoint"))
self.shipPoint.reparentTo(render)
self.x_pos = 0
self.z_pos = 0
self.x_speed = 0
self.z_speed = 0
self.x_pid = PID(3.0, 5.0, 1.0)
self.z_pid = PID(3.0, 5.0, 1.0)
self.model = Actor("data/ship.egg")
self.model.setPos(0, 0, 0)
self.model.setHpr(0, 0, 0)
self.normal_speed = 3.5
self.low_speed = 2
self.speed = self.normal_speed
self.cool_down = 0.1
self.last_shoot = 0
self.keyMap = {
"up": 0,
"down": 0,
"left": 0,
"right": 0,
"brake": 0,
"attack": 0,
}
# This list will stored fired bullets.
self.bullets = []
self.game.accept("mouse1", self.setKey, ["attack", 1])
self.game.accept("mouse1-up", self.setKey, ["attack", 0])
self.game.accept("shift-mouse1", self.setKey, ["attack", 1])
self.game.accept("shift-mouse1-up", self.setKey, ["attack", 0])
self.game.accept("x", self.setKey, ["attack", 1])
self.game.accept("x-up", self.setKey, ["attack", 0])
self.game.accept("c", self.setKey, ["brake", 1])
self.game.accept("c-up", self.setKey, ["brake", 0])
self.game.accept("arrow_up", self.setKey, ["up", 1])
self.game.accept("arrow_up-up", self.setKey, ["up", 0])
self.game.accept("arrow_down", self.setKey, ["down", 1])
self.game.accept("arrow_down-up", self.setKey, ["down", 0])
self.game.accept("arrow_left", self.setKey, ["left", 1])
self.game.accept("arrow_left-up", self.setKey, ["left", 0])
self.game.accept("arrow_right", self.setKey, ["right", 1])
self.game.accept("arrow_right-up", self.setKey, ["right", 0])
cyl.addVertex(i + circRes)
cyl.addVertex(i)
cyl.addVertex(circRes)
cyl.addVertex(0)
cyl.closePrimitive()
geom.addPrimitive(cyl)
node = GeomNode('geomnode')
node.addGeom(geom)
return node
cbm = CullBinManager.getGlobalPtr()
cbm.addBin('handles', CullBinEnums.BTFrontToBack, 35)
cbm.setBinActive('handles', True)
tempnode = NodePath(PandaNode('temp node'))
tempnode.setShaderAuto()
tempnode.setShaderInput('hi_id', Vec4(0, 0, 0, 0), 2)
tempnode.setBin('inactive', 0, 50)
tempnode.setAntialias(AntialiasAttrib.MNone, 10)
newCamera = base.makeCamera(base.win, lens=base.cam.node().getLens())
newCamera.node().setInitialState(tempnode.getState())
newCamera.node().getDisplayRegion(0).setSort(1)
newCamera.node().getDisplayRegion(0).setClearDepthActive(1)
newCamera.node().setCameraMask(BitMask32(4))
newCamera.node().setScene(render)
class RotationHandle(PandaNode, MouseEventListener):
geomNode = makeRotationGeomNode()
def __init__(self, args):
CosmoniumBase.__init__(self)
if args.config is not None:
self.config_file = args.config
else:
self.config_file = 'ralph-data/ralph.yaml'
self.splash = RalphSplash()
self.ralph_config = RalphConfigParser()
if self.ralph_config.load_and_parse(self.config_file) is None:
sys.exit(1)
self.water = self.ralph_config.water
self.has_water = True
self.fullscreen = False
self.shadow_caster = None
self.light_angle = None
self.light_dir = LVector3.up()
self.vector_to_star = self.light_dir
self.light_quat = LQuaternion()
self.light_color = (1.0, 1.0, 1.0, 1.0)
self.directionalLight = None
self.observer = RalphCamera(self.cam, self.camLens)
self.observer.init()
self.distance_to_obs = 2.0 #Can not be 0 !
self.height_under = 0.0
self.scene_position = LVector3()
self.scene_scale_factor = 1
self.scene_rel_position = LVector3()
self.scene_orientation = LQuaternion()
self.model_body_center_offset = LVector3()
self.world_body_center_offset = LVector3()
self.context = self
self.size = self.ralph_config.tile_size #TODO: Needed by populator
#Size of an edge seen from 4 units above
self.edge_apparent_size = (1.0 * self.ralph_config.tile_size /
self.ralph_config.tile_density) / (
4.0 * self.observer.pixel_size)
print("Apparent size:", self.edge_apparent_size)
self.win.setClearColor((135.0 / 255, 206.0 / 255, 235.0 / 255, 1))
# Set up the environment
#
# Create some lighting
self.vector_to_obs = base.cam.get_pos()
self.vector_to_obs.normalize()
if True:
self.shadow_caster = ShadowMap(1024)
self.shadow_caster.create()
self.shadow_caster.set_lens(
self.ralph_config.shadow_size,
-self.ralph_config.shadow_box_length / 2.0,
self.ralph_config.shadow_box_length / 2.0, -self.light_dir)
self.shadow_caster.set_pos(
self.light_dir * self.ralph_config.shadow_box_length / 2.0)
self.shadow_caster.bias = 0.1
else:
self.shadow_caster = None
self.ambientLight = AmbientLight("ambientLight")
self.ambientLight.setColor(
(settings.global_ambient, settings.global_ambient,
settings.global_ambient, 1))
self.directionalLight = DirectionalLight("directionalLight")
self.directionalLight.setDirection(-self.light_dir)
self.directionalLight.setColor(self.light_color)
self.directionalLight.setSpecularColor(self.light_color)
render.setLight(render.attachNewNode(self.ambientLight))
render.setLight(render.attachNewNode(self.directionalLight))
render.setShaderAuto()
base.setFrameRateMeter(True)
self.create_terrain()
for component in self.ralph_config.layers:
self.terrain.add_component(component)
self.terrain_shape.add_linked_object(component)
if self.ralph_config.fog_parameters is not None:
self.fog = Fog(**self.ralph_config.fog_parameters)
self.terrain.add_after_effect(self.fog)
else:
self.fog = None
self.surface = self.terrain_object
self.create_instance()
self.create_tile(0, 0)
self.skybox_init()
self.set_light_angle(45)
# Create the main character, Ralph
ralphStartPos = LPoint3()
self.ralph = Actor(
"ralph-data/models/ralph", {
"run": "ralph-data/models/ralph-run",
"walk": "ralph-data/models/ralph-walk"
})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos + (0, 0, 0.5))
self.ralph_shape = InstanceShape(self.ralph)
self.ralph_shape.parent = self
self.ralph_shape.set_owner(self)
self.ralph_shape.create_instance()
self.ralph_appearance = ModelAppearance(self.ralph)
self.ralph_appearance.set_shadow(self.shadow_caster)
self.ralph_shader = BasicShader()
self.ralph_shader.add_shadows(ShaderShadowMap())
self.ralph_appearance.bake()
self.ralph_appearance.apply(self.ralph_shape, self.ralph_shader)
self.ralph_shader.apply(self.ralph_shape, self.ralph_appearance)
self.ralph_shader.update(self.ralph_shape, self.ralph_appearance)
# Create a floater object, which floats 2 units above ralph. We
# use this as a target for the camera to look at.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.ralph)
self.floater.setZ(2.0)
self.ralph_body = NodePathHolder(self.ralph)
self.ralph_floater = NodePathHolder(self.floater)
self.follow_cam = FollowCam(self, self.cam, self.ralph, self.floater)
self.nav = RalphNav(self.ralph, self.ralph_floater, self.cam,
self.observer, self, self.follow_cam)
self.nav.register_events(self)
self.accept("escape", sys.exit)
self.accept("control-q", sys.exit)
self.accept("w", self.toggle_water)
self.accept("h", self.print_debug)
self.accept("f2", self.connect_pstats)
self.accept("f3", self.toggle_filled_wireframe)
self.accept("shift-f3", self.toggle_wireframe)
self.accept("f5", self.bufferViewer.toggleEnable)
self.accept('f8', self.toggle_lod_freeze)
self.accept("shift-f8", self.terrain_shape.dump_tree)
self.accept('control-f8', self.toggle_split_merge_debug)
self.accept('shift-f9', self.toggle_bb)
self.accept('control-f9', self.toggle_frustum)
self.accept("f10", self.save_screenshot)
self.accept('alt-enter', self.toggle_fullscreen)
self.accept('{', self.incr_ambient, [-0.05])
self.accept('}', self.incr_ambient, [+0.05])
taskMgr.add(self.move, "moveTask")
# Set up the camera
self.follow_cam.update()
self.distance_to_obs = self.cam.get_z() - self.get_height(
self.cam.getPos())
render.set_shader_input("camera", self.cam.get_pos())
self.terrain.update_instance(LPoint3d(*self.cam.getPos()), None)
class TerrainManager (object):
class TerrainElement():
def __init__(self,terrain,xPos,yPos):
self.terrain=terrain
self.xPos=xPos
self.yPos=yPos
def __init__(self):
self.terrainElements=[]#holds all terrainElements
self.terrainGrid=[[]]#holds terrainElements as they will be displayed
self.dirty=True # the terrainGrid should be refreshed on next update
self.rootNode = PandaNode("terrainManager root")
self.root = NodePath( self.rootNode )
self.terrainSize=257 #first=textureSize
self.scale=16
#locatoin that whereIsCamera returned last frame
self.lastCamearaLocation = (0,0)
self.currentCamearaLocation = (0,0)
self.defaultBlockSize=64
def whereIsCamera (self):
'''where is the camera over the terrain
returns a tuple of (x,y) for the grid location'''
cam = base.camera.getPos()
cam = (int (cam[0]) /(self.scale*self.terrainSize) ,
int(cam[1]) /(self.scale*self.terrainSize ))
return cam
def newTerrainPart( self, heightMap, textureMap):
'''create a new terrain element, when update is called they will be
reorganized into a terrain grid and displayed'''
self.dirtyGrid=True
newPart = TerrainClass.TerrainClass(heightMap,heightMap)
newPart.setMonoTexture( textureMap )
newPart = self.TerrainElement( newPart, None, None )
self.terrainElements.append( newPart )
def getBlockSize(self):
return self.terrainElements[0].terrain.getBlockSize()
def setBlockSize( self, size=None ):
if size is None:
print "current block size:",self.getBlockSize()
size = int ( raw_input( " input new blockSize:") )
for i in self.terrainElements:
i.terrain.setBlockSize( size )
return
def gridsAway( self, src, dst):
'''src==tuple of starting grid location
dst == tuple of ending grid location
returns an integer containing number of grids seperating
the two locations, does not take into account differences between
diagnal and strait distance'''
toRet = (abs(src[0]-dst[0]),
abs(src[1]-dst[1]))
toRet = abs( toRet[0]+toRet[1])
return toRet
def autoBlockSizes(self):
'''set the block sizes of the terrains based on the distance from
the camera'''
here = self.currentCamearaLocation
default = self.defaultBlockSize
if here == default:
'''don't try to update if nothing changed'''
return
for row in range( len( self.terrainGrid ) ):
for col in range( len( self.terrainGrid[row] ) ):
new = default #defalut is defaultBlockSize
distance = self.gridsAway( here, (row,col) )
if distance > 2:
new = new*(2**(distance-2))
new = min ( self.terrainSize-1 , new )
self.terrainGrid[row][col].setBlockSize( new )
def update( self, task=None):
'''update the terrain elements that need it
and generate the terrain grid if it needs to be done ( is dirty)'''
def isPerfectSquare( x ):
y = int( math.sqrt(x) ) **2
return y == x
def makeTerrainGrid():
self.terrainGrid=[] # empty list of lists
self.dirty=False
if not isPerfectSquare( len(self.terrainElements) ):
raise Exception( "can't deal with non perfect square number "+
"of terrains")
side = int( math.sqrt( len( self.terrainElements ) ) )
'''make terrain grid'''
for i in xrange(side):
y = i*self.terrainSize
self.terrainGrid.append([])
for j in xrange(side):
x = j*self.terrainSize
element = self.terrainElements[i*side+j]
element.x=x
element.y=y
self.terrainGrid[i].append( element.terrain )
element.terrain.getRoot().setPos( element.x, element.y,0 )
elementNode= element.terrain.getRoot().getNode(0)
self.rootNode.addChild(elementNode)
#start the update
'''reset camera locations'''
self.lastCamearaLocation= self.currentCamearaLocation
self.currentCamearaLocation= self.whereIsCamera()
if self.lastCamearaLocation!= self.currentCamearaLocation:
self.autoBlockSizes()
if self.dirty:
makeTerrainGrid()
self.root.setScale(self.scale, self.scale, self.scale)
#update one of the terrains
side = len( self.terrainGrid )
updateX = random.randint(0,side-1)
updateY = random.randint(0,side-1)
self.terrainGrid[updateX][updateY].asyncUpdate()
if task is None:
return
else:
return task.cont
def getRoot(self):
return self.root
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
# This is used to store which keys are currently pressed.
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"cam-left": 0,
"cam-right": 0,
}
# Post the instructions
self.title = addTitle(
"Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)")
self.inst1 = addInstructions(0.06, "[ESC]: Quit")
self.inst2 = addInstructions(0.12, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.18, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.24, "[Up Arrow]: Run Ralph Forward")
self.inst5 = addInstructions(0.30, "[Down Arrow]: Walk Ralph Backward")
self.inst6 = addInstructions(0.36, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.42, "[S]: Rotate Camera Right")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
# We do not have a skybox, so we will just use a sky blue background color
self.setBackgroundColor(0.53, 0.80, 0.92, 1)
# Create the main character, Ralph
ralphStartPos = self.environ.find("**/start_point").getPos()
self.ralph = Actor("models/ralph", {
"run": "models/ralph-run",
"walk": "models/ralph-walk"
})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos + (0, 0, 1.5))
# Create a floater object, which floats 2 units above ralph. We
# use this as a target for the camera to look at.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.ralph)
self.floater.setZ(2.0)
# Accept the control keys for movement and rotation
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, ["forward", True])
self.accept("arrow_down", self.setKey, ["backward", True])
self.accept("a", self.setKey, ["cam-left", True])
self.accept("s", self.setKey, ["cam-right", 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, ["forward", False])
self.accept("arrow_down-up", self.setKey, ["backward", False])
self.accept("a-up", self.setKey, ["cam-left", False])
self.accept("s-up", self.setKey, ["cam-right", False])
taskMgr.add(self.move, "moveTask")
# Set up the camera
self.disableMouse()
self.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2)
self.cTrav = CollisionTraverser()
# Use a CollisionHandlerPusher to handle collisions between Ralph and
# the environment. Ralph is added as a "from" object which will be
# "pushed" out of the environment if he walks into obstacles.
#
# Ralph is composed of two spheres, one around the torso and one
# around the head. They are slightly oversized since we want Ralph to
# keep some distance from obstacles.
self.ralphCol = CollisionNode('ralph')
self.ralphCol.addSolid(CollisionSphere(center=(0, 0, 2), radius=1.5))
self.ralphCol.addSolid(
CollisionSphere(center=(0, -0.25, 4), radius=1.5))
self.ralphCol.setFromCollideMask(CollideMask.bit(0))
self.ralphCol.setIntoCollideMask(CollideMask.allOff())
self.ralphColNp = self.ralph.attachNewNode(self.ralphCol)
self.ralphPusher = CollisionHandlerPusher()
self.ralphPusher.horizontal = True
# Note that we need to add ralph both to the pusher and to the
# traverser; the pusher needs to know which node to push back when a
# collision occurs!
self.ralphPusher.addCollider(self.ralphColNp, self.ralph)
self.cTrav.addCollider(self.ralphColNp, self.ralphPusher)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height.
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 9)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(CollideMask.bit(0))
self.ralphGroundCol.setIntoCollideMask(CollideMask.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 9)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(CollideMask.bit(0))
self.camGroundCol.setIntoCollideMask(CollideMask.allOff())
self.camGroundColNp = self.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((-5, -5, -5))
directionalLight.setColor((1, 1, 1, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
# Set up the window, camera, etc.
base.destroy()
ShowBase.__init__(self)
self.ser = serial.Serial('/dev/tty.usbmodem1421', 9600)
# Set the background color to black
self.win.setClearColor((0, 0, 0, 1))
# This is used to store which keys are currently pressed.
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"reverse": 0,
"cam-left": 0,
"cam-right": 0
}
#Initialize Track
self.track = self.loader.loadModel("All_Tracks/luigi_circuit")
self.track.setScale(1.5)
self.track.reparentTo(render)
#Intitial where Mario needs to be
#marioStartPos = self.track.find("**/start_point").getPos()
marioStartPos = Vec3(50, -29,
0.35) #Actual start possition for Luigi_Circuit
# marioStartPos = Vec3(20, -40, 31)
#Using ralph because the model is made with correct collision masking and animation
self.marioActor = Actor("models/ralph", {
"run": "models/ralph-run",
"walk": "models/ralph-walk"
})
self.marioActor.setScale(0.1, 0.1, 0.1)
self.marioActor.setH(self.marioActor, 270)
self.marioActor.reparentTo(self.render)
self.marioActor.setPos(marioStartPos + (0, 0, 0.5))
#Floater above so Camera has something to look at
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.marioActor)
self.floater.setZ(2.0)
taskMgr.add(self.move, "moveTask")
# Game state variables
self.isMoving = False
# Set up the camera
self.disableMouse()
self.camera.setPos(self.marioActor.getX() + 100,
self.marioActor.getY(), 1)
#Collision Rays
self.cTrav = CollisionTraverser()
self.marioGroundRay = CollisionRay()
self.marioGroundRay.setOrigin(0, 0, 9)
self.marioGroundRay.setDirection(0, 0, -1)
self.marioGroundCol = CollisionNode('marioRay')
self.marioGroundCol.addSolid(self.marioGroundRay)
self.marioGroundCol.setFromCollideMask(CollideMask.bit(0))
self.marioGroundCol.setIntoCollideMask(CollideMask.allOff())
self.marioGroundColNp = self.marioActor.attachNewNode(
self.marioGroundCol)
self.marioGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.marioGroundColNp, self.marioGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 9)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(CollideMask.bit(0))
self.camGroundCol.setIntoCollideMask(CollideMask.allOff())
self.camGroundColNp = self.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
def move(self, task):
# Get the time that elapsed since last frame. We multiply this with
# the desired speed in order to find out with which distance to move
# in order to achieve that desired speed.
dt = globalClock.getDt()
# If the camera-left key is pressed, move camera left.
# If the camera-right key is pressed, move camera right.
if self.keyMap["cam-left"]:
self.camera.setX(self.camera, -20 * dt)
if self.keyMap["cam-right"]:
self.camera.setX(self.camera, +20 * dt)
# save ralph's initial position so that we can restore it,
# in case he falls off the map or runs into something.
startpos = self.ralph.getPos()
# If a move-key is pressed, move ralph in the specified direction.
# add rotate left right up down
if self.keyMap["left"]:
self.ralph.setX(self.ralph, 200 * dt)
#self.ralph.setH(self.ralph.getH() + 200 * dt)
if self.keyMap["right"]:
self.ralph.setX(self.ralph, -200 * dt)
#self.ralph.setH(self.ralph.getH() - 200 * dt)
if self.keyMap["forward"]:
self.ralph.setY(self.ralph, -200 * dt)
if self.keyMap["backward"]:
self.ralph.setY(self.ralph, 200 * dt)
# If ralph is moving, loop the run animation.
# If he is standing still, stop the animation.
if self.keyMap["forward"] or self.keyMap["left"] or self.keyMap[
"right"]:
if self.isMoving is False:
self.ralph.loop("run")
self.isMoving = True
else:
if self.isMoving:
self.ralph.stop()
self.ralph.pose("walk", 5)
self.isMoving = False
# Normally, we would have to call traverse() to check for collisions.
# However, the class ShowBase that we inherit from has a task to do
# this for us, if we assign a CollisionTraverser to self.cTrav.
#self.cTrav.traverse(render)
# The camera should look in ralph's direction,
# but it should also try to stay horizontal, so look at
# a floater which hovers above ralph's head.
#todo: pick a good camera angle
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.ralph)
self.floater.setZ(2)
self.camera.setPos(0, -3, 3)
self.camera.setH(180)
#self.camera.lookAt(self.ralph)
return task.cont
def __set_toon():
tempnode = NodePath(PandaNode('temp node'))
tempnode.setAttrib(LightRampAttrib.make_single_threshold(.5, .4))
tempnode.set_shader_auto()
base.cam.node().set_initial_state(tempnode.get_state())
CommonFilters(base.win, base.cam).set_cartoon_ink(separation=1)
def test_nodepath_transform_composition():
"""Tests that NodePath composes transform states according to the path it holds."""
from panda3d.core import PandaNode, NodePath, LPoint3, LVector3
# Create 3 PandaNodes, and give each some interesting transform state:
node1 = PandaNode('node1')
node2 = PandaNode('node2')
node3 = PandaNode('node3')
node1.set_transform(node1.get_transform().set_pos(LPoint3(0, 0, 1)).set_hpr(LVector3(90, 0, -90)))
node2.set_transform(node2.get_transform().set_pos(LPoint3(0, 1, 0)).set_hpr(LVector3(180, 180, 0)))
node3.set_transform(node3.get_transform().set_pos(LPoint3(1, 0, 0)).set_hpr(LVector3(270, 0, 270)))
# node3 is going to be attached under both node1 and node2 and we will
# hold a path both ways:
node1.add_child(node3)
node2.add_child(node3)
assert len(node1.children) == 1
assert len(node2.children) == 1
assert len(node3.children) == 0
assert len(node1.parents) == 0
assert len(node2.parents) == 0
assert len(node3.parents) == 2
# np1 is the path to node3 via node1:
np1 = NodePath(node1).children[0]
# np2 is the path to node3 via node2:
np2 = NodePath(node2).children[0]
# Both should point to node3:
assert np1.node() == node3
assert np2.node() == node3
# However if we ask for the net transform to node3, it should compose:
assert np1.get_transform(NodePath()) == node1.get_transform().compose(node3.get_transform())
assert np2.get_transform(NodePath()) == node2.get_transform().compose(node3.get_transform())
# If we ask for np1 RELATIVE to np2, it should compose like so:
leg1 = node2.get_transform().compose(node3.get_transform())
leg2 = node1.get_transform().compose(node3.get_transform())
relative_transform = leg1.get_inverse().compose(leg2)
assert np1.get_transform(np2) == relative_transform
class NametagGroup:
CHAT_TIMEOUT_MIN = 4.0
CHAT_TIMEOUT_MAX = 12.0
CHAT_STOMP_DELAY = 0.2
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.name = ''
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)
self.tickTaskName = self.getUniqueName() + '-tick'
self.tickTask = taskMgr.add(self.tick, self.tickTaskName, sort=45)
def destroy(self):
if self.marginManager is not None:
self.unmanage(self.marginManager)
if self.tickTask is not None:
taskMgr.remove(self.tickTask)
self.tickTask = None
self.clearChatText()
for nametag in list(self.nametags):
self.remove(nametag)
self.nametag2d = None
self.nametag3d = None
if self.icon is not None:
self.icon.removeAllChildren()
self.icon = None
self.chatFont = None
self.font = None
self.chatButton = NametagGlobals.noButton
self.avatar = None
def getUniqueName(self):
return 'NametagGroup-%s' % id(self)
def getNameIcon(self):
return self.icon
def tick(self, task):
if self.avatar is None or self.avatar.isEmpty():
return Task.cont
chatText = self.getChatText()
if NametagGlobals.forceOnscreenChat and chatText and self.chatBalloonType == NametagGlobals.CHAT_BALLOON:
visible3d = False
elif self.avatar == NametagGlobals.me:
if chatText and self.chatBalloonType == NametagGlobals.CHAT_BALLOON and not base.cam.node(
).isInView(self.avatar.getPos(base.cam)):
visible3d = False
else:
visible3d = True
elif NametagGlobals.force2dNametags:
visible3d = False
elif not NametagGlobals.want2dNametags and (
not chatText
or self.chatBalloonType != NametagGlobals.CHAT_BALLOON):
visible3d = True
elif self.avatar.isHidden():
visible3d = False
else:
visible3d = base.cam.node().isInView(self.avatar.getPos(base.cam))
if visible3d != self.visible3d:
self.visible3d = visible3d
if self.nametag2d is not None:
self.nametag2d.setVisible(not visible3d)
return Task.cont
def setAvatar(self, avatar):
self.avatar = avatar
for nametag in self.nametags:
nametag.setAvatar(self.avatar)
def getAvatar(self):
return self.avatar
def setActive(self, active):
self.active = active
for nametag in self.nametags:
nametag.setActive(self.active)
def getActive(self):
return self.active
def setObjectCode(self, objectCode):
self.objectCode = objectCode
def getObjectCode(self):
return self.objectCode
def setChatButton(self, chatButton):
self.chatButton = chatButton
for nametag in self.nametags:
nametag.setChatButton(self.chatButton)
def getChatButton(self):
return self.chatButton
def hasChatButton(self):
return self.chatButton != NametagGlobals.noButton
def setChatReversed(self, reversed):
self.chatReversed = reversed
for nametag in self.nametags:
nametag.setChatReversed(reversed)
def getChatReversed(self):
return self.chatReversed
def setFont(self, font):
self.font = font
for nametag in self.nametags:
nametag.setFont(self.font)
def getFont(self):
return self.font
def setChatFont(self, chatFont):
self.chatFont = chatFont
for nametag in self.nametags:
nametag.setChatFont(self.chatFont)
def getChatFont(self):
return self.chatFont
def setShadow(self, shadow):
self.shadow = shadow
for nametag in self.nametags:
nametag.setShadow(self.shadow)
def getShadow(self):
return self.shadow
def clearShadow(self):
self.shadow = None
for nametag in self.nametags:
nametag.clearShadow()
def setChatType(self, chatType):
self.chatType = chatType
for nametag in self.nametags:
nametag.setChatType(self.chatType)
def getChatType(self):
return self.chatType
def setChatBalloonType(self, chatBalloonType):
self.chatBalloonType = chatBalloonType
for nametag in self.nametags:
nametag.setChatBalloonType(self.chatBalloonType)
def getChatBalloonType(self):
return self.chatBalloonType
def setNametagColor(self, nametagColor):
self.nametagColor = nametagColor
for nametag in self.nametags:
nametag.setNametagColor(self.nametagColor)
def getNametagColor(self):
return self.nametagColor
def setChatColor(self, chatColor):
self.chatColor = chatColor
for nametag in self.nametags:
nametag.setChatColor(self.chatColor)
def getChatColor(self):
return self.chatColor
def setSpeedChatColor(self, speedChatColor):
self.speedChatColor = speedChatColor
for nametag in self.nametags:
nametag.setSpeedChatColor(self.speedChatColor)
def getSpeedChatColor(self):
return self.speedChatColor
def setWordWrap(self, wordWrap):
self.wordWrap = wordWrap
for nametag in self.nametags:
nametag.setWordWrap(self.wordWrap)
def getWordWrap(self):
return self.wordWrap
def setChatWordWrap(self, chatWordWrap):
self.chatWordWrap = chatWordWrap
for nametag in self.nametags:
nametag.setChatWordWrap(self.chatWordWrap)
def getChatWordWrap(self):
return self.chatWordWrap
def setText(self, text):
self.text = text
for nametag in self.nametags:
nametag.setText(self.text)
nametag.update()
def getText(self):
return self.text
def getNumChatPages(self):
return len(self.chatPages)
def setChatPageIndex(self, chatPageIndex):
if chatPageIndex >= self.getNumChatPages():
return
self.chatPageIndex = chatPageIndex
for nametag in self.nametags:
nametag.setChatText(self.chatPages[self.chatPageIndex])
nametag.update()
def getChatPageIndex(self):
return self.chatPageIndex
def setChatText(self, chatText, timeout=False):
if self.getChatText():
self.clearChatText()
self.stompChatText = chatText
self.stompTask = taskMgr.doMethodLater(self.CHAT_STOMP_DELAY,
self.__chatStomp,
self.stompTaskName,
extraArgs=[timeout])
return
self.clearChatText()
self.chatPages = chatText.split('\x07')
self.setChatPageIndex(0)
if timeout:
delay = len(self.getChatText()) * 0.5
if delay < self.CHAT_TIMEOUT_MIN:
delay = self.CHAT_TIMEOUT_MIN
elif delay > self.CHAT_TIMEOUT_MAX:
delay = self.CHAT_TIMEOUT_MAX
self.chatTimeoutTask = taskMgr.doMethodLater(
delay, self.clearChatText, self.chatTimeoutTaskName)
def getChatText(self):
if self.chatPageIndex >= self.getNumChatPages():
return ''
return self.chatPages[self.chatPageIndex]
def clearChatText(self, task=None):
if self.stompTask is not None:
taskMgr.remove(self.stompTask)
self.stompTask = None
self.stompChatText = ''
if self.chatTimeoutTask is not None:
taskMgr.remove(self.chatTimeoutTask)
self.chatTimeoutTask = None
self.chatPages = []
self.chatPageIndex = 0
for nametag in self.nametags:
nametag.setChatText('')
nametag.update()
if task is not None:
return Task.done
def getStompChatText(self):
return self.stompChatText
def setIcon(self, icon):
self.icon = icon
for nametag in self.nametags:
nametag.setIcon(self.icon)
def getIcon(self):
return self.icon
def setNametag2d(self, nametag2d):
if self.nametag2d is not None:
self.remove(self.nametag2d)
self.nametag2d = None
if nametag2d is None:
return
self.nametag2d = nametag2d
self.add(self.nametag2d)
def getNametag2d(self):
return self.nametag2d
def setNametag3d(self, nametag3d):
if self.nametag3d is not None:
self.remove(self.nametag3d)
self.nametag3d = None
if nametag3d is None:
return
self.nametag3d = nametag3d
self.add(self.nametag3d)
def getNametag3d(self):
return self.nametag3d
def add(self, nametag):
self.nametags.add(nametag)
nametag.setAvatar(self.avatar)
nametag.setActive(self.active)
nametag.setClickEvent(self.getUniqueName())
nametag.setChatButton(self.chatButton)
nametag.setFont(self.font)
nametag.setChatFont(self.chatFont)
nametag.setChatType(self.chatType)
nametag.setChatBalloonType(self.chatBalloonType)
nametag.setNametagColor(self.nametagColor)
nametag.setChatColor(self.chatColor)
nametag.setSpeedChatColor(self.speedChatColor)
nametag.setWordWrap(self.wordWrap)
nametag.setChatWordWrap(self.chatWordWrap)
nametag.setText(self.text)
nametag.setChatText(self.getChatText())
nametag.setIcon(self.icon)
nametag.update()
def remove(self, nametag):
nametag.destroy()
self.nametags.remove(nametag)
def updateAll(self):
for nametag in self.nametags:
nametag.update()
def manage(self, marginManager):
if self.marginManager is not None:
self.unmanage(self.marginManager)
self.marginManager = marginManager
for nametag in self.nametags:
if isinstance(nametag, MarginVisible):
nametag.manage(self.marginManager)
def unmanage(self, marginManager):
if marginManager != self.marginManager:
return
if self.marginManager is None:
return
self.marginManager = marginManager
for nametag in self.nametags:
if isinstance(nametag, MarginVisible):
nametag.unmanage(self.marginManager)
def hideNametag(self):
for nametag in self.nametags:
nametag.hideNametag()
def showNametag(self):
for nametag in self.nametags:
nametag.showNametag()
def hideChat(self):
for nametag in self.nametags:
nametag.hideChat()
def showChat(self):
for nametag in self.nametags:
nametag.showChat()
def hideThought(self):
for nametag in self.nametags:
nametag.hideThought()
def showThought(self):
for nametag in self.nametags:
nametag.showThought()
def __chatStomp(self, timeout=False):
self.setChatText(self.stompChatText, timeout=timeout)
self.stompChatText = ''
def __init__(self):
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"cam-left": 0,
"cam-right": 0,
"grab": 0,
"jump": 0,
"run": 0,
"walk": 0
}
base.win.setClearColor(Vec4(0, 0, 0, 1))
# Post the instructions
self.title = addTitle("RC-Soft: Catch the butterfly")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.85, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.80, "[Up Arrow]: Run Ralph Forward")
self.inst6 = addInstructions(0.70, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.65, "[S]: Rotate Camera Right")
self.inst8 = addInstructions(0.60, "[G]: Grab")
self.inst9 = addInstructions(0.55, "[J]: Jump [R]: Run [W]:Walk")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0, 0, 0)
# Create the main character, Ralph
ralphStartPos = self.environ.find("**/start_point").getPos()
self.ralph = Actor(
"models/ralph", {
"run": "models/ralph-run",
"walk": "models/ralph-walk",
"grab": "models/ralph-run"
}) ## TODO : create model grab action
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos)
#show my fly
self.fly = Actor("models/fluture", {
"run": "models/fluture-anim1",
"walk": "models/fluture-anim1"
})
self.fly.reparentTo(render)
self.fly.setScale(.08)
self.fly.setPos(ralphStartPos)
self.fly.loop("run") #start fly animation
# Create a floater object. We use the "floater" as a temporary
# variable in a variety of calculations.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left", 1])
self.accept("arrow_right", self.setKey, ["right", 1])
self.accept("arrow_up", self.setKey, ["forward", 1])
self.accept("a", self.setKey, ["cam-left", 1])
self.accept("s", self.setKey, ["cam-right", 1])
self.accept("arrow_left-up", self.setKey, ["left", 0])
self.accept("arrow_right-up", self.setKey, ["right", 0])
self.accept("arrow_up-up", self.setKey, ["forward", 0])
self.accept("a-up", self.setKey, ["cam-left", 0])
self.accept("s-up", self.setKey, ["cam-right", 0])
self.accept('1', self.setObject, [0])
self.accept('2', self.setObject, [1])
self.accept('3', self.setObject, [2])
self.accept('4', self.setObject, [3])
self.accept('g', self.setKey, ["grab", 1])
self.accept('j', self.setKey, ["jump", 1])
self.accept('j-up', self.setKey, ["jump", 0])
self.accept('r', self.setKey, ["run", 1])
self.accept('w', self.setKey, ["walk", 1])
taskMgr.add(self.move, "moveTask")
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 1000)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 1000)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
# show an object in Ralph's hand
#Now we will expose the joint the hand joint. ExposeJoint allows us to
#get the position of a joint while it is animating. This is different than
#controlJonit which stops that joint from animating but lets us move it.
#This is particularly usefull for putting an object (like a weapon) in an
#actor's hand
self.rightHand = self.ralph.exposeJoint(None, 'modelRoot', 'RightHand')
#This is a table with models, positions, rotations, and scales of objects to
#be attached to our exposed joint. These are stock models and so they needed
#to be repositioned to look right.
positions = [("models/net", (0, -.66, -.95), (90, 0, 90), .4),
("models/fluture", (.15, -.99, -.22), (90, 0, 90), .5),
("models/banana", (.08, -.1, .09), (0, -90, 0), 1.75),
("models/sword", (.11, .19, .06), (0, 0, 90), 1)]
self.models = [] #A list that will store our models objects
for row in positions:
np = loader.loadModel(row[0]) #Load the model
np.setPos(row[1][0], row[1][1], row[1][2]) #Position it
np.setHpr(row[2][0], row[2][1], row[2][2]) #Rotate it
np.setScale(row[3]) #Scale it
#Reparent the model to the exposed joint. That way when the joint moves,
#the model we just loaded will move with it.
np.reparentTo(self.rightHand)
self.models.append(np) #Add it to our models list
self.setObject(0)
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
# Set the background color to black
self.win.setClearColor((0, 0, 0, 1))
# This is used to store which keys are currently pressed.
self.keyMap = {
"left": 0, "right": 0, "forward": 0, "cam-left": 0, "cam-right": 0}
# Post the instructions
self.title = addTitle(
"Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)")
self.inst1 = addInstructions(0.06, "[ESC]: Quit")
self.inst2 = addInstructions(0.12, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.18, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.24, "[Up Arrow]: Run Ralph Forward")
self.inst6 = addInstructions(0.30, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.36, "[S]: Rotate Camera Right")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
# Create the main character, Ralph
ralphStartPos = self.environ.find("**/start_point").getPos()
self.ralph = Actor("models/ralph",
{"run": "models/ralph-run",
"walk": "models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos + (0, 0, 0.5))
# Create a floater object, which floats 2 units above ralph. We
# use this as a target for the camera to look at.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.ralph)
self.floater.setZ(2.0)
# Accept the control keys for movement and rotation
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, ["forward", True])
self.accept("a", self.setKey, ["cam-left", True])
self.accept("s", self.setKey, ["cam-right", 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, ["forward", False])
self.accept("a-up", self.setKey, ["cam-left", False])
self.accept("s-up", self.setKey, ["cam-right", False])
taskMgr.add(self.move, "moveTask")
# Game state variables
self.isMoving = False
# Set up the camera
self.disableMouse()
self.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2)
def __init__(self, name, fromFile=None):
PandaNode.__init__(self, name)
self.elements = []
self.fromFile = fromFile
def __init__(self):
global speed
global maxspeed
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"accelerate": 0,
"decelerate": 0,
"cam-left": 0,
"cam-right": 0
}
base.win.setClearColor(Vec4(0, 0, 0, 1))
# Post the instructions
self.title = addTitle(
"HW2: Roaming Ralph Modified (Walking on the Moon) with friends")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[A]: Rotate Ralph Left")
self.inst3 = addInstructions(0.85, "[D]: Rotate Ralph Right")
self.inst4 = addInstructions(0.80, "[W]: Move Ralph Forward")
self.inst5 = addInstructions(0.75,
"[P]: Increase Ralph Velocity (Run)")
self.inst6 = addInstructions(0.70,
"[O]: Decrease Ralph Velocity (Walk)")
self.inst7 = addInstructions(0.60, "[Left Arrow]: Rotate Camera Left")
self.inst8 = addInstructions(0.55,
"[Right Arrow]: Rotate Camera Right")
# Set up the environment
self.environ = loader.loadModel("models/square")
self.environ.reparentTo(render)
self.environ.setPos(0, 0, 0)
self.environ.setScale(100, 100, 1)
self.moon_tex = loader.loadTexture("models/moon_1k_tex.jpg")
self.environ.setTexture(self.moon_tex, 1)
# Create the main character, Ralph
if (v == [0]):
print(model)
self.ralph = Actor("models/ralph", {
"run": "models/ralph-run",
"walk": "models/ralph-walk"
})
self.ralph.setScale(.2)
elif (v == [1]):
print(model)
self.ralph = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
speed = 100
maxspeed = 10000
self.ralph.setScale(0.0001, 0.00015, 0.0005)
self.ralph.setScale(.002)
self.ralph.setPlayRate(100.0, "models/panda-walk4")
speed = 100
maxspeed = 10000
self.ralph.setScale(.0035)
else:
print(model)
self.ralph = Actor("models/GroundRoamer.egg")
self.ralph.setScale(.15)
self.ralph.setHpr(180, 0, 0)
self.Groundroamer_texture = loader.loadTexture(
"models/Groundroamer.tif")
self.ralph.setTexture(self.Groundroamer_texture)
self.ralph.reparentTo(render)
self.ralph.setPos(0, 0, 0)
#creates Earth
self.earth = Actor("models/planet_sphere.egg.pz")
self.earth.reparentTo(render)
self.earth.setScale(6.0)
self.earth.setPos(40, 25, 6)
self.earth_texture = loader.loadTexture("models/earth_1k_tex.jpg")
self.earth.setTexture(self.earth_texture)
#creates Mercury
self.mercury = Actor("models/planet_sphere.egg.pz")
self.mercury.reparentTo(render)
self.mercury.setScale(2.0)
self.mercury.setPos(-40, -25, 2)
self.mercury_texture = loader.loadTexture("models/mercury_1k_tex.jpg")
self.mercury.setTexture(self.mercury_texture)
#creates Venus
self.venus = Actor("models/planet_sphere.egg.pz")
self.venus.reparentTo(render)
self.venus.setScale(4.0)
self.venus.setPos(40, -30, 4)
self.venus_texture = loader.loadTexture("models/venus_1k_tex.jpg")
self.venus.setTexture(self.venus_texture)
# Create a floater object. We use the "floater" as a temporary
# variable in a variety of calculations.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("a", self.setKey, ["left", 1])
self.accept("d", self.setKey, ["right", 1])
self.accept("w", self.setKey, ["forward", 1])
self.accept("s", self.setKey, ["backward", 1])
self.accept("arrow_left", self.setKey, ["cam-left", 1])
self.accept("arrow_right", self.setKey, ["cam-right", 1])
self.accept("a-up", self.setKey, ["left", 0])
self.accept("d-up", self.setKey, ["right", 0])
self.accept("w-up", self.setKey, ["forward", 0])
self.accept("arrow_left-up", self.setKey, ["cam-left", 0])
self.accept("arrow_right-up", self.setKey, ["cam-right", 0])
self.accept("p", self.setKey, ["accelerate", 1])
self.accept("o", self.setKey, ["decelerate", 1])
self.accept("p-up", self.setKey, ["accelerate", 0])
self.accept("o-up", self.setKey, ["decelerate", 0])
taskMgr.add(self.move, "moveTask")
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2)
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 9)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(CollideMask.bit(0))
self.ralphGroundCol.setIntoCollideMask(CollideMask.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 9)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(CollideMask.bit(0))
self.camGroundCol.setIntoCollideMask(CollideMask.allOff())
#self.camGroundColNp = self.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
#self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
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 __init__(self):
ShowBase.__init__(self)
self.win.setClearColor((0.455, 0.816, 0.945, 1))
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"jump": 0,
"action": 0
}
# Mise en place des instructions
self.title = addTitle("Project : 'Escape the forest'")
self.inst1 = addInstructions(0.06, "[ECHAP]: Quit")
self.inst2 = addInstructions(0.12, "[Left arrow]: Turn Freddy left")
self.inst3 = addInstructions(0.18, "[Right arrow]: Turn Freddy right")
self.inst4 = addInstructions(0.24,
"[Top arrow]: Make Freddy move forward")
self.inst5 = addInstructions(0.30,
"Bottom arrow]: Make Freddy move back")
self.inst6 = addInstructions(0.36, "[Space]: Make Freddy jump")
self.inst7 = addInstructions(0.42, "[A]: Operate the lever")
# 3D objects
self.map = loader.loadModel("obj/Map.egg.pz")
self.map.reparentTo(render)
self.walls = loader.loadModel("obj/Wall.egg")
self.walls.reparentTo(render)
self.bridge = Actor("obj/Bridge.egg", {"Drop": "obj/Bridge.egg"})
self.bridge.reparentTo(render)
self.bridge.pose("Drop", 0)
self.lever = Actor("obj/Lever.egg", {"OnOff": "obj/Lever.egg"})
self.lever.reparentTo(render)
self.lever.setPos(0, 12, 1)
self.lever.pose("OnOff", 0)
self.lever1 = Actor("obj/Lever.egg", {"OnOff": "obj/Lever.egg"})
self.lever1.reparentTo(render)
self.lever1.setPos(50, 16, 1)
self.lever1.pose("OnOff", 0)
self.lever2 = Actor("obj/Lever.egg", {"OnOff": "obj/Lever.egg"})
self.lever2.reparentTo(render)
self.lever2.setPos(22, 92, 1)
self.lever2.pose("OnOff", 0)
self.dirt = Actor("obj/Dirt.egg", {"Up": "obj/Dirt.egg"})
self.dirt.reparentTo(render)
self.stone = Actor("obj/Stone.egg", {"Fall": "obj/Stone.egg"})
self.stone.reparentTo(render)
# Creation of the main character, Freddy
FreddyStartPos = (8, -8, 1.5)
self.Freddy = Actor("obj/Freddy.egg", {
"Run": "obj/Run.egg",
"Pose": "obj/Pose.egg"
})
self.Freddy.reparentTo(render)
self.Freddy.setScale(1.4)
self.Freddy.setPos(FreddyStartPos)
self.Freddy.setH(180)
winsound.PlaySound("sound/music.wav", winsound.SND_ASYNC)
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.Freddy)
self.floater.setZ(0)
# Controls for move and interact
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, ["forward", True])
self.accept("arrow_down", self.setKey, ["backward", True])
self.accept("space", self.setKey, ["jump", True])
self.accept("a", self.setKey, ["action", 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, ["forward", False])
self.accept("arrow_down-up", self.setKey, ["backward", False])
self.accept("space-up", self.setKey, ["jump", False])
self.accept("a-up", self.setKey, ["action", False])
taskMgr.add(self.movement, "Movement")
self.moving = False
self.disableMouse()
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
# Collisions
self.cTrav = CollisionTraverser()
self.pusher = CollisionHandlerPusher()
self.FreddyGroundHandler = CollisionHandlerQueue()
self.FreddyGroundSphere = CollisionSphere(
0, 0, 0.5, 0.3) #Coordinates of the center and radius
self.FreddyGroundCol = CollisionNode('freddySphere')
self.FreddyGroundCol.addSolid(self.FreddyGroundSphere)
self.FreddyGroundCol.setFromCollideMask(BitMask32.bit(0))
self.FreddyGroundCol.setIntoCollideMask(BitMask32.allOff())
self.FreddyGroundColNp = self.Freddy.attachNewNode(
self.FreddyGroundCol)
self.cTrav.addCollider(self.FreddyGroundColNp,
self.FreddyGroundHandler)
self.BridgeHandler = CollisionHandlerQueue()
self.BridgeBox = CollisionBox((1, 17, 0), (5, 16.8, 10))
self.BridgeCol = CollisionNode('bridgeBox')
self.BridgeCol.addSolid(self.BridgeBox)
self.BridgeCol.setFromCollideMask(BitMask32.allOff())
self.BridgeCol.setIntoCollideMask(BitMask32.bit(0))
self.BridgeColNp = self.bridge.attachNewNode(self.BridgeCol)
self.cTrav.addCollider(self.BridgeColNp, self.BridgeHandler)
self.pusher.addCollider(self.FreddyGroundColNp, self.BridgeColNp)
self.StoneHandler = CollisionHandlerQueue()
self.StoneBox = CollisionBox((39, 27, 0), (41, 31, 3))
self.StoneCol = CollisionNode('stoneBox')
self.StoneCol.addSolid(self.StoneBox)
self.StoneCol.setFromCollideMask(BitMask32.allOff())
self.StoneCol.setIntoCollideMask(BitMask32.bit(0))
self.StoneColNp = self.stone.attachNewNode(self.StoneCol)
self.cTrav.addCollider(self.StoneColNp, self.StoneHandler)
self.pusher.addCollider(self.FreddyGroundColNp, self.StoneColNp)
self.DirtHandler = CollisionHandlerQueue()
self.DirtBox = CollisionBox((15, 83, 0), (13, 82.5, 5))
self.DirtCol = CollisionNode('dirtBox')
self.DirtCol.addSolid(self.DirtBox)
self.DirtCol.setFromCollideMask(BitMask32.allOff())
self.DirtCol.setIntoCollideMask(BitMask32.bit(0))
self.DirtColNp = self.dirt.attachNewNode(self.DirtCol)
self.cTrav.addCollider(self.DirtColNp, self.DirtHandler)
self.pusher.addCollider(self.FreddyGroundColNp, self.DirtColNp)
def __resetPrevTransform(self, state):
PandaNode.resetAllPrevTransform()
return Task.cont
