def __init__(self, nodeGroundHandler, name):
self.name = name
self.bullet = NodePath(
"bullet") # loader.loadModel('res/models/box.egg')
self.bullet.setScale(1)
self.shoot = NodePath("shoot")
self.shoot.setPos(self.Start)
self.bullet.reparentTo(self.shoot)
DoorImage = OnscreenImage(image="res/portal/door.png",
pos=(0, -2, 0),
scale=(8.8, 1, 14.2))
DoorImage.setTransparency(TransparencyAttrib.MAlpha)
DoorImage.setSa(0.5)
self.Portal = NodePath("Portal")
DoorImage.reparentTo(self.Portal)
self.Portal.setScale(5)
# forward Segment
forwardSegment = CollisionRay(0, 0, 0, 0, 1, 0)
self.cn = CollisionNode(name)
self.cn.addSolid(forwardSegment)
self.cn.setFromCollideMask(BitMask32.bit(0))
self.cn.setIntoCollideMask(BitMask32.allOff())
self.solid = self.shoot.attachNewNode(self.cn)
base.cTrav.addCollider(self.solid, nodeGroundHandler)
# Right Segment
RightSegment = CollisionSegment(-20, -0.2, 0, 20, -0.2, 0)
self.cnRight = CollisionNode(name + 'right')
self.cnRight.addSolid(RightSegment)
self.cnRight.setFromCollideMask(BitMask32.allOff())
self.cnRight.setIntoCollideMask(BitMask32.allOff())
self.solid = self.Portal.attachNewNode(self.cnRight)
self.RightSegmentCollisionHandlerQueue = CollisionHandlerQueue()
base.cTrav.addCollider(self.solid,
self.RightSegmentCollisionHandlerQueue)
# self.solid.show()
# Up Segment
UpSegment = CollisionSegment(0, -0.2, -15, 0, -0.2, 15)
self.cnUp = CollisionNode(name + 'up')
self.cnUp.addSolid(UpSegment)
self.cnUp.setFromCollideMask(BitMask32.allOff())
self.cnUp.setIntoCollideMask(BitMask32.allOff())
self.solid = self.Portal.attachNewNode(self.cnUp)
# self.solid.show()
base.cTrav.addCollider(self.solid,
self.RightSegmentCollisionHandlerQueue)
Sphere = CollisionSphere(0, 0, 0, 60)
self.cnout = CollisionNode(name + 'out')
self.cnout.addSolid(Sphere)
self.cnout.setFromCollideMask(BitMask32.bit(0))
self.cnout.setIntoCollideMask(BitMask32.allOff())
self.solid = self.shoot.attachNewNode(self.cnout)
# self.solid.show()
base.cTrav.addCollider(self.solid, nodeGroundHandler)
self.NeedCheckPos = False
self.initParticle()
class LevelThree(object):
def __init__(self, m):
"""
:param m: Menu
"""
self.levelName = "levelThree"
self.gameState = ''
m.game = self
self.menu = m
self.loadScene()
if self.menu.tempPlayer is None:
self.initCollision()
self.initPlayer()
else:
print 'temp not none'
self.node = self.menu.tempPlayer
self.node.node.setPos(-250, 265, 20)
self.node.game = self
self.node.initMission()
self.node.mission.memoryNum = self.menu.tempPlayer.mission.memoryNum
# self.enmey = self.menu.tempPlayer.game.enemy
self.enemy = Enemylevel2(self.node)
self.node.node.setPos(200, 5, 20)
base.accept("escape", self.pauseGame)
base.disableMouse()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.mutableMap = {}
self.glowFilter()
self.initMania()
self.finalcard.reparentTo(hidden)
self.initBag()
self.menu.loadState = True
self.menu.passFrame.show()
self.node.erosionFrame.show()
self.node.currentItemFrame.show()
taskMgr.add(self.waitOne, "waitOne")
self.setupskillpattern()
self.setLight()
def waitOne(self, task):
if task.time < 1:
self.menu.passFrame['frameColor'] = (0, 0, 0, 1 - task.time)
return task.cont
self.menu.passFrame['frameColor'] = (0, 0, 0, 0)
self.menu.passFrame.hide()
# self.beginPlot()
return task.done
def beginPlot(self):
self.menu.tutorialDialog.show()
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.node.endTask()
self.nextPlot(0)
def nextPlot(self, index):
if index == 1 or index == 0:
self.menu.nextButton['text'] = self.node.mission.plotText[0][index]
self.menu.nextButton['command'] = self.nextPlot
self.menu.nextButton['extraArgs'] = [index + 1]
elif index == 2:
self.menu.ocanioButton['text'] = self.node.mission.plotText[0][index]
self.menu.ocanioButton['command'] = self.nextPlot
self.menu.ocanioButton['extraArgs'] = [index + 1]
self.menu.tutorialDialog.hide()
self.menu.ocanioDialog.show()
elif index == 3:
self.menu.nextButton['text'] = self.node.mission.plotText[0][index]
self.menu.nextButton['command'] = self.node.mission.hideTutorial
self.menu.nextButton['extraArgs'] = []
self.menu.tutorialDialog.show()
self.menu.ocanioDialog.hide()
def initBag(self):
self.bagState = True
self.bagText = ""
if self.menu.tempPlayer is not None:
self.node.bag = self.menu.tempPlayer.bag
else:
self.node.bag = Bag(self.node)
base.accept("b", self.openBag)
def openBag(self):
# print 'b'
if self.bagState:
self.node.bag.bagframe.show()
self.node.bag.showdisplay.setActive(True)
self.node.bag.textObject.setText(self.bagText)
self.bagState = not self.bagState
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.menu.selectDialog.hide()
self.gameState = 'pause'
self.node.state = 'pause'
self.node.endTask()
base.accept('escape', self.openBag)
else:
self.node.bag.bagframe.hide()
self.node.bag.showdisplay.setActive(False)
self.bagText = self.node.bag.textObject.getText()
self.node.bag.textObject.setText("")
self.node.bag.textObject.setWordwrap(0)
self.bagState = not self.bagState
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.gameState = ''
self.node.state = ''
self.node.initTask()
base.accept('escape', self.pauseGame)
def initCollision(self):
""" create the collision system """
base.cTrav = CollisionTraverser()
base.pusher = CollisionHandlerPusher()
base.cTrav.setRespectPrevTransform(True)
def loadScene(self):
""" load the self.sceneModel
must have
<Group> *something* {
<Collide> { Polyset keep descend }
in the egg file
"""
self.goodmanager = GoodsManager()
# AddGoods(self,Node,CollisionName,Name,Interactive)
self.goodmanager.AddGoods(loader.loadModel('res/models/Scene3/Scene3Cat/Scene3_Ver3.0_wall.egg'), ["Wall1", "Wall2", "floor"],
"wall", False)
self.goodmanager.AddGoods(loader.loadModel('res/models/Scene3/Scene3Cat/Scene3_light.egg'), ["light_box"], "light_box", False)
'''
studyroom
'''
prefix = 'res/models/Scene3/Scene3Cat/studyroom/Scene3_'
self.loadIn(prefix + 'zhuozi.egg', "zhuozi_box", False)
self.loadIn(prefix + 'biaoyu1.egg', "biaoyu1_box", True)
self.loadIn(prefix + 'biaoyu2.egg', "biaoyu2_box", True)
self.loadIn(prefix + 'biaoyu3.egg', "biaoyu3_box", True)
self.loadIn(prefix + 'vaccine.egg', "vaccine_studyroom_box", True)
self.loadIn(prefix + 'book_studyroom.egg', "book_studyroom_box", True)
self.loadIn(prefix + 'bookshelf.egg', "bookshelf_box", True)
'''
lab
'''
prefix = 'res/models/Scene3/Scene3Cat/lab/Scene3_'
self.loadIn(prefix + 'desk.egg', 'desk_box', False)
# self.loadIn(prefix + 'bottle.egg', 'bottle_box', True)
self.loadIn(prefix + 'emptybottle.egg', 'emptybottle_box', True)
self.loadIn(prefix + 'biaoyu.egg', 'biaoyu_box', True)
self.loadIn(prefix + 'labtable.egg', 'labtable_box', False)
self.loadIn(prefix + 'notebook1.egg', 'notebook1_box', True)
self.loadIn(prefix + 'notebook2.egg', 'notebook2_box', True)
self.loadIn(prefix + 'notebook3.egg', 'notebook3_box', True)
self.loadIn(prefix + 'pool.egg', 'pool_box', True)
self.goodmanager.GoodsIta['pool_box'].Node.setTwoSided(True)
'''
hall
'''
prefix = 'res/models/Scene3/Scene3Cat/hall/Scene3_'
self.loadIn(prefix + 'exit.egg', 'exit_box', True)
self.loadIn(prefix + 'king.egg', 'king_box', False)
self.loadIn(prefix + 'rook1.egg', 'rook1_box', False)
self.loadIn(prefix + 'rook2.egg', 'rook2_box', False)
self.loadIn(prefix + 'knight.egg', 'knight_box', False)
self.loadIn(prefix + 'bishop.egg', 'bishop_box', False)
self.loadIn(prefix + 'chessdesk.egg', 'chessdesk_box', True)
self.goodmanager.GoodsIta["studydoor_box"] = Door(Vec3(-624.5253, -831.2924, 105.000), "studydoor_box",
prefix + 'studydoor.egg', 90, Door.Out)
self.goodmanager.GoodsIta["labdoor_box"] = Door(Vec3(-272.8592, 182.9539, 105.000), "labdoor_box",
prefix + 'labdoor.egg', 90, Door.Out)
self.goodmanager.GoodsIta["chessdoor_box"] = Door(Vec3(-837.2316, -684.3346, 105.000), "chessdoor_box",
prefix + 'chessdoor.egg', 90, Door.Out)
'''
chessroom
'''
prefix = 'res/models/Scene3/Scene3Cat/chessroom/Scene3_'
self.loadIn(prefix + 'key.egg', 'key_box', True)
self.loadIn(prefix + 'zitiao.egg', 'zitiao_box', True)
self.loadIn(prefix + 'paints.egg', 'paints_box', True)
self.loadIn(prefix + 'pillar.egg', 'pillar_box', False)
self.loadIn(prefix + 'midpillar.egg', 'midpillar_box', True)
self.loadIn(prefix + 'vaccine1.egg', 'vaccine1_box', True)
self.loadIn(prefix + 'vaccine2.egg', 'vaccine2_box', True)
self.loadIn(prefix + 'book_chessroom.egg', 'book_chessroom_box', True)
'''
elevator
'''
prefix = 'res/models/Scene3/Scene3Cat/elevator/Scene3_'
self.loadIn(prefix + 'leftdianti.egg', 'leftdianti_box', False)
self.loadIn(prefix + 'rightdianti.egg', 'rightdianti_box', False)
self.loadIn(prefix + 'diantikuang.egg', 'diantikuang_box', False)
self.loadIn(prefix + 'elebutton.egg', 'elebutton_box', True)
def loadIn(self, path, name, b):
self.goodmanager.AddGoods(loader.loadModel(path), [name], name, b)
def itemCollision(self, model, name, radius):
nodePath = NodePath(name)
node = CollisionNode(name)
node.addSolid(CollisionSphere(20, 0, radius, radius))
solid = model.attachNewNode(node)
nodePath.reparentTo(model)
solid.show()
base.cTrav.addCollider(solid, base.pusher)
base.pusher.addCollider(solid, nodePath, base.drive.node())
def initPlayer(self):
""" loads the player and creates all the controls for him"""
self.node = Player(self.goodmanager, self.menu, self)
# self.enemy = Enemy(self.node)
# self.enemy = Enemylevel2(self.node)
# self.goodmanager.GoodsIta["enemy"] = Enemy(self.node)
# self.goodmanager.GoodsIta["enemy"].state = 1
def pauseGame(self):
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.menu.selectDialog.hide()
self.gameState = 'pause'
self.node.state = 'pause'
self.node.endTask()
self.node.erosionFrame.hide()
self.node.currentItemFrame.hide()
base.accept('escape', self.escapeEvent)
base.accept('b', self.menu.nothing)
self.menu.pauseFrame.show()
def escapeEvent(self):
self.menu.pauseFrame.hide()
self.node.state = ''
self.node.initTask()
self.node.erosionFrame.show()
self.node.currentItemFrame.show()
base.accept('escape', self.pauseGame)
base.accept('b', self.openBag)
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
def makeFilterBuffer(self, srcbuffer, name, sort, prog):
blurBuffer = base.win.makeTextureBuffer(name, 512, 512)
blurBuffer.setSort(sort)
blurBuffer.setClearColor(LVector4(1, 0, 0, 1))
blurCamera = base.makeCamera2d(blurBuffer)
blurScene = NodePath("new Scene")
blurCamera.node().setScene(blurScene)
shader = loader.loadShader(prog)
card = srcbuffer.getTextureCard()
card.reparentTo(blurScene)
card.setShader(shader)
return blurBuffer
def glowFilter(self):
glowShader = loader.loadShader("shaders/glowShader.sha")
# dlight = DirectionalLight('dlight')
# alight = AmbientLight('alight')
# dlnp = render.attachNewNode(dlight)
# alnp = render.attachNewNode(alight)
# dlight.setColor(LVector4(0.3, 0.3, 0.3, 1))
# alight.setColor(LVector4(0.8, 0.8, 0.8, 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", 1024, 768)
glowBuffer.setSort(-3)
glowBuffer.setClearColor(LVector4(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.
self.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)
self.glowCamera.node().setInitialState(tempnode.getState())
self.glowCamera.node().setCameraMask(BitMask32.bit(0))
# set up the pipeline: from glow scene to blur x to blur y to main
# window.
blurXBuffer = self.makeFilterBuffer(
glowBuffer, "Blur X", -2, "shaders/XBlurShader.sha")
blurYBuffer = self.makeFilterBuffer(
blurXBuffer, "Blur Y", -1, "shaders/YBlurShader.sha")
self.finalcard = blurYBuffer.getTextureCard()
self.finalcard.reparentTo(render2d)
Attrib = ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.O_incoming_alpha,
ColorBlendAttrib.O_incoming_alpha)
self.finalcard.setAttrib(Attrib)
base.bufferViewer.setPosition("llcorner")
base.bufferViewer.setLayout("hline")
base.bufferViewer.setCardSize(0.652, 0)
base.accept("tab", self.toggleGlow)
self.glowOn = False
def limitGlow(self, task):
if task.time < 5:
return task.cont
else:
self.glowOn = False
self.finalcard.reparentTo(hidden)
# self.goodmanager.GoodsIta["box"].CloseHighLight()
return task.done
def toggleGlow(self):
self.showskillpattern("eyepattern")
if self.glowOn:
return
self.glowOn = True
taskMgr.add(self.limitGlow, "limitGlow")
if self.node.EROSION + 10 > 100:
self.node.EROSION = 100
else:
self.node.EROSION += 10
self.finalcard.reparentTo(render2d)
# self.goodmanager.GoodsIta["box"].OpenHighLight()
def initMania(self):
base.accept("space", self.mania)
self.maniaState = False
def mania(self):
self.showskillpattern("maniapattern")
if not self.maniaState:
self.node.speed *= 1.4
self.maniaState = True
if self.node.EROSION + 10 > 100:
self.node.EROSION = 100
else:
self.node.EROSION += 10
taskMgr.remove("fadeSpeed")
taskMgr.add(self.fadeSpeed, "fadeSpeed")
def fadeSpeed(self, task):
if task.time < 10:
return task.cont
else:
self.node.speed /= 1.4
self.maniaState = False
return task.done
def setupskillpattern(self):
self.eyepattern = OnscreenImage(image="res/skill_icon/eye-white.png", pos=(-1.2, 1, -0.8))
self.eyepattern.setTransparency(TransparencyAttrib.MAlpha)
self.eyepattern.setScale(0.1)
self.eyepattern.setSa(0.8)
self.eyepattern.hide()
self.maniapattern = OnscreenImage(image="res/skill_icon/mania-white.png", pos=(-1.2 + 0.3, 1, -0.8))
self.maniapattern.setTransparency(TransparencyAttrib.MAlpha)
self.maniapattern.setScale(0.1)
self.maniapattern.setSa(0.8)
self.maniapattern.hide()
self.screen_patternArray = {}
self.screen_patternArray["eyepattern"] = [self.eyepattern, False, 5.0, 5.0]
self.screen_patternArray["maniapattern"] = [self.maniapattern, False, 10.0, 10.]
self.patterntask = False
self.patterntaskpretime = 0
# self.mouseIconNormal.setSa(0.5)
def showskillpattern(self, patternname):
self.screen_patternArray[patternname][2] = self.screen_patternArray[patternname][3]
self.screen_patternArray[patternname][1] = True
self.screen_patternArray[patternname][0].show()
if self.patterntask == False:
taskMgr.add(self.showskillpatterntask, "showskillpatterntask")
self.patterntask = True
def showskillpatterntask(self, task):
num = 0
for key in self.screen_patternArray:
if self.screen_patternArray[key][1] == True:
self.screen_patternArray[key][2] -= globalClock.getDt()
if self.screen_patternArray[key][2] < 5.:
if sin(self.screen_patternArray[key][2] * pi * 5) > 0:
self.screen_patternArray[key][0].setSa(0)
else:
self.screen_patternArray[key][0].setSa(0.8)
self.screen_patternArray[key][0].setPos(-1.2 + num * 0.3, 1, -0.8)
if self.screen_patternArray[key][2] < 0:
self.screen_patternArray[key][1] = False
self.screen_patternArray[key][0].hide()
self.screen_patternArray[key][0].setSa(0.8)
num += 1
if num > 0:
return task.cont
self.patterntask = False
return
def setLight(self):
render.setLightOff()
alight=AmbientLight("alight")
alnp=render.attachNewNode(alight)
alight.setColor(VBase4(0.1,0.1,0.1,1))
render.setLight(alnp)
self.lightpivot1 = render.attachNewNode("lightpivot1")
self.lightpivot1.setPos(-371, -94, 100)
self.plight1 = PointLight('plight1')
self.plight1.setColor(VBase4(1, 0.5, 0, 1))
self.temp = LVector3(0.6, 0.08, 0)
self.plight1.setAttenuation(self.temp)
plnp1 = self.lightpivot1.attachNewNode(self.plight1)
# plnp1.setPos(0, 0, 50)
render.setLight(plnp1)
# render.setShaderAuto()
self.lightpivot2 = render.attachNewNode("lightpivot2")
self.lightpivot2.setPos(131, -22, 100)
self.plight2 = PointLight('plight2')
self.plight2.setColor(VBase4(1, 0.5, 0, 1))
self.temp = LVector3(0.6, 0.1, 0)
self.plight2.setAttenuation(self.temp)
plnp2 = self.lightpivot2.attachNewNode(self.plight2)
# plnp1.setPos(0, 0, 50)
render.setLight(plnp2)
self.lightpivot3 = render.attachNewNode("lightpivot3")
self.lightpivot3.setPos(-426, -937, 100)
self.plight3 = PointLight('plight3')
self.plight3.setColor(VBase4(1, 0.5, 0, 1))
self.temp = LVector3(0.6, 0.1, 0)
self.plight3.setAttenuation(self.temp)
plnp3 = self.lightpivot3.attachNewNode(self.plight3)
# plnp1.setPos(0, 0, 50)
render.setLight(plnp3)
self.lightpivot4 = render.attachNewNode("lightpivot4")
self.lightpivot4.setPos(-1313, -532, 100)
self.plight4 = PointLight('plight3')
self.plight4.setColor(VBase4(1, 0.5, 0, 1))
self.temp = LVector3(0.6, 0.1, 0)
self.plight4.setAttenuation(self.temp)
plnp4 = self.lightpivot4.attachNewNode(self.plight4)
# plnp1.setPos(0, 0, 50)
render.setLight(plnp4)
slight = PointLight('slight')
slight.setColor(VBase4(0.1, 0.5, 0.1, 1))
# # slight.setAttenuation(LVector3(0.5,0.08,0))
# lens = PerspectiveLens()
# lens.setFov(10)
# slight.setLens(lens)
self.chessdesk=self.goodmanager.GoodsIta["chessdesk_box"].Node
slnp = self.chessdesk.attachNewNode(slight)
slnp.setPos(-486,-320,1000)
# slnp.lookAt(self.goodmanager.GoodsIta["chessdesk_box"].Node)
self.chessdesk.setLight(slnp)
class LevelTwo(object):
def __init__(self, m):
"""
:param m: Menu
"""
self.levelName = "levelTwo"
self.gameState = ''
m.game = self
self.menu = m
self.setLight()
self.loadScene()
if self.menu.tempPlayer is None:
self.initCollision()
self.initPlayer()
else:
print 'temp not none'
self.node = self.menu.tempPlayer
self.node.node.setPos(-250, 265, 20)
self.node.game = self
self.node.initMission()
self.node.mission.memoryNum = self.menu.tempPlayer.mission.memoryNum
self.enemy = Enemylevel2(self.node)
# self.node.node.setPos(-800, 0, 20)
# self.node.node.setPos(-370, 2800, 25)
self.node.node.setPos(-700, 0, 25)
self.node.node.setHpr(-90, 0, 0)
base.accept("escape", self.pauseGame)
base.disableMouse()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.mutableMap = {}
self.glowFilter()
self.initMania()
self.finalcard.reparentTo(hidden)
self.initBag()
# self.menu.loadState = True
self.menu.passFrame.show()
self.node.erosionFrame.show()
self.node.currentItemFrame.show()
if not self.menu.skipUseless:
self.menu.loadState = True
taskMgr.add(self.waitOne, "waitOne")
else:
self.save = Save(self)
if self.menu.selectedSave == 2:
self.save.loadFile('gameinfo_2.save')
elif self.menu.selectedSave == 3:
self.save.loadFile('gameinfo_3.save')
self.node.changeCamera()
self.menu.loadState = True
self.menu.passFrame.hide()
self.setupskillpattern()
def waitOne(self, task):
if task.time < 1:
self.menu.passFrame['frameColor'] = (0, 0, 0, 1 - task.time)
return task.cont
self.menu.passFrame['frameColor'] = (0, 0, 0, 0)
self.menu.passFrame.hide()
self.beginPlot()
return task.done
def beginPlot(self):
self.menu.ocanioDialog.show()
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.node.endTask()
self.nextPlot()
def nextPlot(self):
self.menu.ocanioButton['text'] = '刚一踏出房间，房间的门就被重重的锁上了。无论我怎么叫喊，\n' \
'里面都没有回应。我尽可能不去想最糟糕的情况，大概kura不会有什么问题的吧。'
self.menu.ocanioButton['command'] = self.node.mission.hideOcanio
self.menu.ocanioButton['extraArgs'] = []
def initBag(self):
self.bagState = True
self.bagText = ""
if self.menu.tempPlayer is not None:
self.node.bag = self.menu.tempPlayer.bag
else:
self.node.bag = Bag(self.node)
base.accept("b", self.openBag)
def openBag(self):
# print 'b'
if self.bagState:
self.node.bag.bagframe.show()
self.node.bag.showdisplay.setActive(True)
self.node.bag.textObject.setText(self.bagText)
self.bagState = not self.bagState
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.menu.selectDialog.hide()
self.gameState = 'pause'
self.node.state = 'pause'
self.node.endTask()
base.accept('escape', self.openBag)
else:
self.node.bag.bagframe.hide()
self.node.bag.showdisplay.setActive(False)
self.bagText = self.node.bag.textObject.getText()
self.node.bag.textObject.setText("")
self.node.bag.textObject.setWordwrap(0)
self.bagState = not self.bagState
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.gameState = ''
self.node.state = ''
self.node.initTask()
base.accept('escape', self.pauseGame)
def initCollision(self):
""" create the collision system """
base.cTrav = CollisionTraverser()
base.pusher = CollisionHandlerPusher()
base.cTrav.setRespectPrevTransform(True)
def loadScene(self):
""" load the self.sceneModel
must have
<Group> *something* {
<Collide> { Polyset keep descend }
in the egg file
"""
self.goodmanager = GoodsManager()
# AddGoods(self,Node,CollisionName,Name,Interactive)
self.goodmanager.AddGoods(loader.loadModel('res/models/Scene2/Scene2Cat/Scene2_light.egg'),
["light"], "light", False)
self.goodmanager.AddGoods(loader.loadModel('res/models/Scene2/Scene2Cat/Scene2_Ver7.0_wall.egg'),
["Wall", "floor"], "wall", False)
self.goodmanager.AddGoods(loader.loadModel('res/models/Scene2/Scene2Cat/Elevator/dianti.egg'),
["dianti"], "dianti_box", True)
self.goodmanager.AddGoods(loader.loadModel('res/models/Scene2/Scene2Cat/Elevator/broken_dianti.egg'),
["broken_dianti"], "broken_dianti_box", True)
self.goodmanager.GoodsIta['broken_dianti_box'].Node.hide()
'''
corridor
'''
prefix = 'res/models/Scene2/Scene2Cat/Corridor/Scene2_Ver5.0_'
self.loadIn(prefix + 'clock_2.egg', "clock_box", True)
# self.loadIn(prefix + 'Outdoor.egg', "outdoor_box", True)
self.loadIn(prefix + 'ElectricBox_2.egg', "ElectricBox", True)
self.loadIn(prefix + 'entrance.egg', "entrance_box", True)
self.loadIn(prefix + 'picture1.egg', "painting_1", True)
self.loadIn(prefix + 'picture2.egg', "painting_2", True)
self.loadIn(prefix + 'picture3.egg', "painting_3", True)
self.loadIn(prefix + 'picture4.egg', "painting_4", True)
self.loadIn(prefix + 'picture5.egg', "painting_5", True)
self.loadIn(prefix + 'picture6.egg', "painting_6", True)
self.loadIn(prefix + 'picture7.egg', "painting_7", True)
self.loadIn(prefix + 'picture8.egg', "painting_8", True)
self.loadIn(prefix + 'picture9.egg', "painting_9", True)
self.loadIn(prefix + 'picture8_cut.egg', "painting_cut", True)
self.goodmanager.GoodsIta["painting_cut"].Node.hide()
self.goodmanager.GoodsIta["outdoor_box"] = Door(Vec3(374.1351, 1973.22, 105.000), "outdoor_box",
prefix + 'Outdoor.egg', 90, Door.Out)
'''
hall
'''
prefix = 'res/models/Scene2/Scene2Cat/Hall/Scene2_Ver5.0_'
self.loadIn(prefix + 'food.egg', 'food_box', True)
self.loadIn(prefix + 'cake.egg', 'cake_box', True)
self.loadIn(prefix + 'diary.egg', 'diary_box', True)
self.loadIn(prefix + 'safe_2.egg', 'safe_box', True)
self.loadIn(prefix + 'carrot.egg', 'carrot_box', True)
self.loadIn(prefix + 'window.egg', 'window_box', True)
self.loadIn(prefix + 'window_broken.egg', 'window_broken_box', True)
self.goodmanager.GoodsIta['window_broken_box'].Node.hide()
self.loadIn(prefix + 'biaoyu.egg', 'biaoyu_box', True)
# self.loadIn(prefix + 'Backdoor.egg', 'backdoor', True)
# self.loadIn(prefix + 'Frontdoor.egg', 'frontdoor', True)
self.loadIn(prefix + 'hammer_2.egg', 'hammer_box', True)
self.loadIn(prefix + 'zhalan_2.egg', 'rabbit_cage', True)
self.loadIn(prefix + 'vaccine.egg', 'hallvaccine_box', True)
self.loadIn(prefix + 'refrigerator_2.egg', 'fridge_box', True)
self.loadIn(prefix + 'rabbit.egg', 'rabbit_box', False)
self.loadIn(prefix + 'yuanzhuo.egg', 'yuanzhuo_box', False)
self.loadIn(prefix + 'changzhuo_2.egg', 'changzhuo_box', False)
self.goodmanager.GoodsIta["Frontdoor"] = Door(Vec3(342.9760, 357.22, 105.000), "Frontdoor",
prefix + 'Frontdoor.egg', 90, Door.Out)
self.goodmanager.GoodsIta["Backdoor"] = Door(Vec3(342.9760, 1571.22, 105.000), "Backdoor",
prefix + 'Backdoor.egg', 90, Door.Out)
'''
Outroom
'''
prefix = 'res/models/Scene2/Scene2Cat/Outroom/Scene2_Ver5.0_'
self.loadIn(prefix + 'vase_2.egg', 'vase_box', True)
self.loadIn(prefix + 'knife.egg', 'knife_box', True)
self.loadIn(prefix + 'jiazi_2.egg', 'jiazi_box', False)
self.loadIn(prefix + 'rongqi.egg', 'rongqi_box', False)
self.loadIn(prefix + 'vaccine.egg', 'vaccine_box', True)
self.loadIn(prefix + 'lavabo_2.egg', 'lavabo_box', True)
self.loadIn(prefix + 'mirror.egg', 'mirror_box', True)
self.loadIn(prefix + 'furnace_2.egg', 'furnace_box', True)
self.loadIn(prefix + 'bookshelf.egg', 'bookshelf_box', True)
self.loadIn(prefix + 'xiaozhuozi_2.egg', 'xiaozhuozi_box', False)
self.goodmanager.staticGoods["infireish"] = GoodsParticle("fireish", (-370, 3183, 25), 16, render,31)
self.goodmanager.staticGoods["insteam"] = GoodsParticle("steam", (-370, 3183, 50), 5, render,30)
self.goodmanager.GoodsIta['Scene2_book-beijuji'] = Book(prefix+'beijuji.egg','beijuji',(-350, 3183, 50))
self.goodmanager.GoodsIta['Scene2_book-beijuji'].Node.setHpr(30, 30, 30)
for i in range(8):
name = "outflowers" + str(i+1)
self.goodmanager.AddGoods(loader.loadModel(prefix + name + '.egg'),
[name], name, False)
self.goodmanager.staticGoods[name].Node.setTwoSided(True)
self.goodmanager.staticGoods['outflowers7'].Node.hide()
self.goodmanager.staticGoods['outflowers8'].Node.hide()
self.mirrorShader = loader.loadShader("shaders/mirrorShader.sha")
self.goodmanager.GoodsIta['mirror_box'].Node.setShader(self.mirrorShader)
# self.goodmanager.GoodsIta['mirror_box'].Node.setTwoSided(True)
self.mirror(self.goodmanager.GoodsIta['mirror_box'].Node)
'''
Inroom
'''
prefix = 'res/models/Scene2/Scene2Cat/Inroom/Scene2_Ver5.0_'
self.loadIn(prefix + 'invase.egg', 'invase_box', True)
self.loadIn(prefix + 'inknife.egg', 'inknife_box', True)
self.loadIn(prefix + 'injiazi.egg', 'injiazi_box', False)
self.loadIn(prefix + 'inlavabo.egg', 'inlavabo_box', True)
self.loadIn(prefix + 'inrongqi.egg', 'inrongqi_box', False)
self.loadIn(prefix + 'infurnace.egg', 'infurnace_box', True)
self.loadIn(prefix + 'inbookshelf.egg', 'inbookshelf_box', True)
self.loadIn(prefix + 'inxiaozhuozi.egg', 'inxiaozhuozi_box', False)
self.goodmanager.staticGoods["fireish"] = GoodsParticle("fireish", (-370, 2870, 25), 16, render, 31)
self.goodmanager.staticGoods["steam"] = GoodsParticle("steam", (-370, 2870, 50), 5, render, 30)
self.goodmanager.GoodsIta['Scene2_book-xijuji'] = Book(prefix + 'inxijuji.egg', 'inxijuji', (-350, 2870, 50))
self.goodmanager.GoodsIta['Scene2_book-xijuji'].Node.setHpr(30, 30, 30)
for i in range(8):
name = "inflowers" + str(i+1)
self.goodmanager.AddGoods(loader.loadModel(prefix + name + '.egg'),
[name], name, False)
self.goodmanager.staticGoods[name].Node.hide()
self.goodmanager.staticGoods[name].Node.setTwoSided(True)
self.goodmanager.staticGoods['inflowers1'].Node.show()
self.h2so4_1 = GoodsParticle("H2SO4", (-380, 2270, 136), 6, render, 32)
self.h2so4_2 = GoodsParticle("smo", (-380, 2270, 110), 5, render, 33)
self.h2so4_3 = GoodsParticle("surface-1", (-365, 2270, 100), 10, render, 34)
self.h2so4_3.particle.setScale(10, 20, 10)
self.h2so4_4 = GoodsParticle("H2SO4", (-380, 3895.5, 136), 6, render, 32)
self.h2so4_5 = GoodsParticle("smo", (-380, 3890, 110), 5, render, 33)
self.h2so4_6 = GoodsParticle("surface-1", (-363, 3890, 100), 10, render, 34)
self.h2so4_6.particle.setScale(10, 20, 10)
def loadIn(self, path, name, b):
self.goodmanager.AddGoods(loader.loadModel(path), [name], name, b)
def itemCollision(self, model, name, radius):
nodePath = NodePath(name)
node = CollisionNode(name)
node.addSolid(CollisionSphere(20, 0, radius, radius))
solid = model.attachNewNode(node)
nodePath.reparentTo(model)
solid.show()
base.cTrav.addCollider(solid, base.pusher)
base.pusher.addCollider(solid, nodePath, base.drive.node())
def initPlayer(self):
""" loads the player and creates all the controls for him"""
self.node = Player(self.goodmanager, self.menu, self)
# self.enemy = Enemy(self.node)
self.enemy = Enemylevel2(self.node)
# self.goodmanager.GoodsIta["enemy"] = Enemy(self.node)
# self.goodmanager.GoodsIta["enemy"].state = 1
def pauseGame(self):
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.menu.selectDialog.hide()
self.gameState = 'pause'
self.node.state = 'pause'
self.node.endTask()
self.node.erosionFrame.hide()
self.node.currentItemFrame.hide()
base.accept('escape', self.escapeEvent)
base.accept('b', self.menu.nothing)
self.menu.pauseFrame.show()
def escapeEvent(self):
self.menu.pauseFrame.hide()
self.node.state = ''
self.node.initTask()
self.node.erosionFrame.show()
self.node.currentItemFrame.show()
base.accept('escape', self.pauseGame)
base.accept('b', self.openBag)
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
def mirror(self,tex):
self.mirrorBuffer = base.win.makeTextureBuffer("mirror", 512, 512)
print 'mirrorBuffer',self.mirrorBuffer
self.mirrorBuffer.setSort(-3)
self.mirrorBuffer.setClearColor(LVector4(0, 0, 0, 1))
print base.cam.node().getLens()
self.mirrorCamera = base.makeCamera(self.mirrorBuffer)
self.mirrorCamera.reparentTo(render)
self.mirrorCamera.setPos((424,3080,104. ))
self.mirrorCamera.setH(180)
pl = self.mirrorCamera.node().getLens()
pl.setFov(90)
pl.setNear(100)
self.mirrorCamera.node().setLens(pl)
self.finalcard = self.mirrorBuffer.getTexture()
tex.setTexture(self.finalcard,1)
# self.UnLoadmirror()
def UnLoadmirror(self):
self.mirrorBuffer.getEngine().removeWindow(self.mirrorBuffer)
self.mirrorBuffer = None
self.mirrorCamera = None
def makeFilterBuffer(self, srcbuffer, name, sort, prog):
blurBuffer = base.win.makeTextureBuffer(name, 512, 512)
blurBuffer.setSort(sort)
blurBuffer.setClearColor(LVector4(1, 0, 0, 1))
blurCamera = base.makeCamera2d(blurBuffer)
blurScene = NodePath("new Scene")
blurCamera.node().setScene(blurScene)
shader = loader.loadShader(prog)
card = srcbuffer.getTextureCard()
card.reparentTo(blurScene)
card.setShader(shader)
return blurBuffer
def glowFilter(self):
glowShader = loader.loadShader("shaders/glowShader.sha")
# dlight = DirectionalLight('dlight')
# alight = AmbientLight('alight')
# dlnp = render.attachNewNode(dlight)
# alnp = render.attachNewNode(alight)
# dlight.setColor(LVector4(0.3, 0.3, 0.3, 1))
# alight.setColor(LVector4(0.8, 0.8, 0.8, 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", 1024, 768)
glowBuffer.setSort(-3)
glowBuffer.setClearColor(LVector4(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.
self.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)
self.glowCamera.node().setInitialState(tempnode.getState())
self.glowCamera.node().setCameraMask(BitMask32.bit(0))
# set up the pipeline: from glow scene to blur x to blur y to main
# window.
blurXBuffer = self.makeFilterBuffer(
glowBuffer, "Blur X", -2, "shaders/XBlurShader.sha")
blurYBuffer = self.makeFilterBuffer(
blurXBuffer, "Blur Y", -1, "shaders/YBlurShader.sha")
self.finalcard = blurYBuffer.getTextureCard()
self.finalcard.reparentTo(render2d)
Attrib = ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.O_incoming_alpha,
ColorBlendAttrib.O_incoming_alpha)
self.finalcard.setAttrib(Attrib)
base.bufferViewer.setPosition("llcorner")
base.bufferViewer.setLayout("hline")
base.bufferViewer.setCardSize(0.652, 0)
base.accept("tab", self.toggleGlow)
self.glowOn = False
def limitGlow(self, task):
if task.time < 5:
return task.cont
else:
self.glowOn = False
self.finalcard.reparentTo(hidden)
# self.goodmanager.GoodsIta["box"].CloseHighLight()
return task.done
def toggleGlow(self):
self.showskillpattern("eyepattern")
if self.glowOn:
return
self.glowOn = True
taskMgr.add(self.limitGlow, "limitGlow")
if self.node.EROSION + 10 > 100:
self.node.EROSION = 100
else:
self.node.EROSION += 10
self.finalcard.reparentTo(render2d)
# self.goodmanager.GoodsIta["box"].OpenHighLight()
def initMania(self):
base.accept("space", self.mania)
self.maniaState = False
def mania(self):
self.showskillpattern("maniapattern")
if not self.maniaState:
self.node.speed *= 1.4
self.maniaState = True
if self.node.EROSION + 10 > 100:
self.node.EROSION = 100
else:
self.node.EROSION += 10
taskMgr.remove("fadeSpeed")
taskMgr.add(self.fadeSpeed, "fadeSpeed")
def fadeSpeed(self, task):
if task.time < 10:
return task.cont
else:
self.node.speed /= 1.4
self.maniaState = False
return task.done
def setupskillpattern(self):
self.eyepattern = OnscreenImage(image="res/skill_icon/eye-white.png", pos=(-1.2, 1, -0.8))
self.eyepattern.setTransparency(TransparencyAttrib.MAlpha)
self.eyepattern.setScale(0.1)
self.eyepattern.setSa(0.8)
self.eyepattern.hide()
self.maniapattern = OnscreenImage(image="res/skill_icon/mania-white.png", pos=(-1.2 + 0.3, 1, -0.8))
self.maniapattern.setTransparency(TransparencyAttrib.MAlpha)
self.maniapattern.setScale(0.1)
self.maniapattern.setSa(0.8)
self.maniapattern.hide()
self.screen_patternArray = {}
self.screen_patternArray["eyepattern"] = [self.eyepattern, False, 5.0, 5.0]
self.screen_patternArray["maniapattern"] = [self.maniapattern, False, 10.0, 10.]
self.patterntask = False
self.patterntaskpretime = 0
# self.mouseIconNormal.setSa(0.5)
def showskillpattern(self, patternname):
self.screen_patternArray[patternname][2] = self.screen_patternArray[patternname][3]
self.screen_patternArray[patternname][1] = True
self.screen_patternArray[patternname][0].show()
if self.patterntask == False:
taskMgr.add(self.showskillpatterntask, "showskillpatterntask")
self.patterntask = True
def showskillpatterntask(self, task):
num = 0
for key in self.screen_patternArray:
if self.screen_patternArray[key][1] == True:
self.screen_patternArray[key][2] -= globalClock.getDt()
if self.screen_patternArray[key][2] < 5.:
if sin(self.screen_patternArray[key][2] * pi * 5) > 0:
self.screen_patternArray[key][0].setSa(0)
else:
self.screen_patternArray[key][0].setSa(0.8)
self.screen_patternArray[key][0].setPos(-1.2 + num * 0.3, 1, -0.8)
if self.screen_patternArray[key][2] < 0:
self.screen_patternArray[key][1] = False
self.screen_patternArray[key][0].hide()
self.screen_patternArray[key][0].setSa(0.8)
num += 1
if num > 0:
return task.cont
self.patterntask = False
return
def setLight(self):
render.setLightOff()
alight=AmbientLight('alight')
alnp=render.attachNewNode(alight)
alight.setColor(VBase4(0.3,0.3,0.3,1))
render.setLight(alnp)
# myFog = Fog("Fog Name")
# myFog.setColor(0.2,0.5, 0.1)
# myFog.setExpDensity(0.5)
# render.setFog(myFog)
self.lightpivot1 = render.attachNewNode("lightpivot1")
self.lightpivot1.setPos(-124, 947, 50)
self.plight1=PointLight('plight1')
self.plight1.setColor(VBase4(1, 0.5, 0, 1))
self.temp=LVector3(0.6, 0.08, 0)
self.plight1.setAttenuation(self.temp)
plnp1=self.lightpivot1.attachNewNode(self.plight1)
plnp1.setPos(0,0,50)
render.setLight(plnp1)
self.lightpivot2 = render.attachNewNode("lightpivot2")
self.lightpivot2.setPos(0, 0, 50)
self.plight2 = PointLight('plight2')
self.plight2.setColor(VBase4(1, 0.5, 0, 1))
self.temp = LVector3(0.6, 0.08, 0)
self.plight2.setAttenuation(self.temp)
plnp2 = self.lightpivot2.attachNewNode(self.plight2)
plnp2.setPos(-200, 0, 50)
render.setLight(plnp2)
self.lightpivot3 = render.attachNewNode("lightpivot3")
self.lightpivot3.setPos(52, 2491, 50)
self.plight3 = PointLight('plight3')
self.plight3.setColor(VBase4(1, 0.5, 0, 1))
self.temp = LVector3(0.6, 0.08, 0)
self.plight3.setAttenuation(self.temp)
plnp3 = self.lightpivot3.attachNewNode(self.plight3)
plnp3.setPos(-200, 0, 50)
render.setLight(plnp3)
slight = Spotlight('slight')
slight.setColor(VBase4(0.1, 0.5, 0.1, 1))
#slight.setAttenuation(LVector3(0.5,0.08,0))
lens = PerspectiveLens()
lens.setFov(10)
slight.setLens(lens)
slnp = render.attachNewNode(slight)
slnp.setPos(-811, 3, 0)
slnp.lookAt(415,10,0)
# slnp.setPos(0,0,0)
# slnp.lookAt(0,0,50)
render.setLight(slnp)
class Game(object):
def __init__(self, m):
"""
:param m: Menu
"""
self.levelName = "tutorial"
self.gameState = ''
m.game = self
self.menu = m
self.initCollision()
self.loadScene()
self.initPlayer()
base.accept("escape", self.pauseGame)
base.disableMouse()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.mutableMap = {}
self.glowFilter()
self.initMania()
self.finalcard.reparentTo(hidden)
self.initBag()
self.menu.loadState = True
# self.menu.passFrame.show()
# self.node.erosionFrame.show()
# self.node.currentItemFrame.show()
# taskMgr.add(self.waitOne, "waitOne")
self.maniaSound = loader.loadSfx("res/sounds/Darkness3.mp3")
self.setupskillpattern()
self.SetLight()
if not self.menu.skipUseless:
self.initVideo()
self.attachControls()
self.IgnoreControls()
def IgnoreControls(self):
for name in self.keyEven:
base.ignore(name)
print base.getAllAccepting()
def attachControls(self):
self.keyEven = ["tab", 'escape', 'b', 'space']
base.accept('b', self.openBag)
base.accept("tab", self.toggleGlow)
base.accept("escape", self.pauseGame)
base.accept('space', self.mania)
def initVideo(self):
self.node.endTask()
media_file = "res/videos/begining.avi"
self.tex = MovieTexture("preVideo")
success = self.tex.read(media_file)
assert success, "Failed to load video!"
cm = CardMaker("preVideo Card")
# cm.setFrameFullscreenQuad()
# cm.setFrame(-1.3, 1.3, -1, 1)
cm.setFrame(-1.2, 1.2, -.95, .95)
# Tell the CardMaker to create texture coordinates that take into
# account the padding region of the texture.
cm.setUvRange(self.tex)
self.card = NodePath(cm.generate())
self.card.reparentTo(base.render2d)
self.card.setTexture(self.tex)
self.videoSound = loader.loadSfx(media_file)
self.tex.synchronizeTo(self.videoSound)
self.videoSound.play()
taskMgr.add(self.playVideo, 'playGameVideo')
def playVideo(self, task):
if self.videoSound.status() != AudioSound.PLAYING:
self.videoSound.stop()
self.menu.soundMgr.setMusicVolume(0)
self.menu.musicVolume = 0
self.card.hide()
# self.menu.soundMgr.playMusic('bgm1.mp3')
self.menu.passFrame.show()
self.node.erosionFrame.show()
self.node.currentItemFrame.show()
taskMgr.add(self.waitOne, "waitOne")
self.attachControls()
self.node.initTask()
return task.done
return task.cont
def waitOne(self, task):
if task.time < 2:
self.menu.passFrame['frameColor'] = (0, 0, 0, 1 - task.time)
return task.cont
self.menu.passFrame['frameColor'] = (0, 0, 0, 0)
self.menu.passFrame.hide()
self.beginPlot()
return task.done
def beginPlot(self):
self.menu.tutorialDialog.show()
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.node.endTask()
self.nextPlot(0)
def nextPlot(self, index):
if index == 1 or index == 0:
self.menu.nextButton['text'] = self.node.mission.plotText[0][index]
self.menu.nextButton['command'] = self.nextPlot
self.menu.nextButton['extraArgs'] = [index + 1]
elif index == 2:
self.menu.ocanioButton['text'] = self.node.mission.plotText[0][
index]
self.menu.ocanioButton['command'] = self.nextPlot
self.menu.ocanioButton['extraArgs'] = [index + 1]
self.menu.tutorialDialog.hide()
self.menu.ocanioDialog.show()
elif index == 3:
self.menu.nextButton['text'] = self.node.mission.plotText[0][index]
self.menu.nextButton['command'] = self.node.mission.hideTutorial
self.menu.nextButton['extraArgs'] = []
self.menu.tutorialDialog.show()
self.menu.ocanioDialog.hide()
def initBag(self):
self.bagState = True
self.bagText = ""
self.node.bag = Bag(self.node)
base.accept("b", self.openBag)
def openBag(self):
# print 'b'
if self.bagState:
self.node.bag.bagframe.show()
self.node.bag.showdisplay.setActive(True)
self.node.bag.textObject.setText(self.bagText)
self.bagState = not self.bagState
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.menu.selectDialog.hide()
self.gameState = 'pause'
self.node.state = 'pause'
self.node.endTask()
base.accept('escape', self.openBag)
else:
self.node.bag.bagframe.hide()
self.node.bag.showdisplay.setActive(False)
self.bagText = self.node.bag.textObject.getText()
self.node.bag.textObject.setText("")
self.node.bag.textObject.setWordwrap(0)
self.bagState = not self.bagState
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.gameState = ''
self.node.state = ''
self.node.initTask()
base.accept('escape', self.pauseGame)
# threading.currentThread().join('gameThread')
def initCollision(self):
""" create the collision system """
base.cTrav = CollisionTraverser()
base.pusher = CollisionHandlerPusher()
base.cTrav.setRespectPrevTransform(True)
def loadScene(self):
""" load the self.sceneModel
must have
<Group> *something* {
<Collide> { Polyset keep descend }
in the egg file
"""
self.goodmanager = GoodsManager()
# AddGoods(self,Node,CollisionName,Name,Interactive)
# self.goodmanager.AddGoods(loader.loadModel('res/models/Scene3/Scene3_Ver3.0.egg'), ["Wall1", "Wall2", "floor"],
# # "wall", False)
self.goodmanager.AddGoods(
loader.loadModel('res/models/Scene1_Ver7.0_wall.egg'),
["Wall1", "Wall2", "floor"], "wall", False)
self.goodmanager.AddGoods(
loader.loadModel('res/models/Scene1_Ver6.0_bed_2.egg'),
["bed_box"], "bed_box", True)
self.goodmanager.AddGoods(
loader.loadModel('res/models/Scene1_Ver6.0_bookshelf.egg'),
["bookshelf_box"], "bookshelf_box", True)
self.goodmanager.AddGoods(
loader.loadModel('res/models/Scene1_Ver6.0_box.egg'), ["box"],
"box", True)
self.goodmanager.AddGoods(
loader.loadModel('res/models/Scene1_Ver6.0_light.egg'), ["light"],
"light", True)
self.goodmanager.AddGoods(
loader.loadModel('res/models/Scene1_Ver6.0_chair1.egg'),
["chair1"], "chair1", False)
self.goodmanager.AddGoods(
loader.loadModel('res/models/Scene1_Ver6.0_chair2.egg'),
["chair2"], "chair2", False)
self.goodmanager.AddGoods(
loader.loadModel('res/models/Scene1_Ver6.0_chair3.egg'),
["chair3"], "chair3", False)
self.goodmanager.AddGoods(
loader.loadModel('res/models/Scene1_Ver6.0_chair4.egg'),
["chair4"], "chair4", False)
self.goodmanager.AddGoods(
loader.loadModel('res/models/Scene1_Ver6.0_desk2.egg'), ["desk2"],
"desk2", False)
self.goodmanager.AddGoods(
loader.loadModel('res/models/Scene1_Ver6.0_desk3.egg'),
["desk3_2"], "desk3_2", False)
self.goodmanager.AddGoods(
loader.loadModel('res/models/Scene1_Ver6.0_matong.egg'),
["matong_box3"], "matong_box3", True)
self.goodmanager.AddGoods(
loader.loadModel('res/models/Scene1_Ver6.0_xishoupen.egg'),
["xishoupen"], "xishoupen", True)
self.goodmanager.AddGoods(
loader.loadModel('res/models/Scene1_Ver6.0_yaoshui.egg'),
["yaoshui"], "yaoshui", True)
self.goodmanager.AddGoods(
loader.loadModel('res/models/Scene1_Exit.egg'), ["Scene1_Exit"],
"Scene1_Exit", True)
self.goodmanager.AddGoods(
loader.loadModel('res/models/Scene1_wallword_1.egg'),
["Scene1_wallword_1"], "Scene1_wallword_1", True)
self.goodmanager.AddGoods(
loader.loadModel('res/models/Scene1_wallword_2.egg'),
["Scene1_wallword_2"], "Scene1_wallword_2", True)
self.goodmanager.AddGoods(
loader.loadModel('res/models/Scene1_MusicBox.egg'), ["MusicBox"],
"MusicBox", True)
self.goodmanager.GoodsIta["toilet_door"] = Door(
Vec3(305, -762.5, 100), "toilet_door",
'res/models/Scene1_Ver6.0_toilet_door.egg', 0, Door.In)
self.goodmanager.GoodsIta["yaoshui"].Node.setPos(0, -350, 0)
self.goodmanager.GoodsIta['MusicBox'].Node.setPos(400, 200, 90)
self.goodmanager.GoodsIta['MusicBox'].Node.setHpr(-90, 0, 0)
self.goodmanager.GoodsIta['MusicBox'].Node.setScale(1.5)
def itemCollision(self, model, name, radius):
nodePath = NodePath(name)
node = CollisionNode(name)
node.addSolid(CollisionSphere(20, 0, radius, radius))
solid = model.attachNewNode(node)
nodePath.reparentTo(model)
solid.show()
base.cTrav.addCollider(solid, base.pusher)
base.pusher.addCollider(solid, nodePath, base.drive.node())
def initPlayer(self):
""" loads the player and creates all the controls for him"""
self.node = Player(self.goodmanager, self.menu, self)
# self.enemy = Enemy(self.node)
self.goodmanager.GoodsIta["enemy"] = Enemy(self.node)
self.goodmanager.GoodsIta["enemy"].state = 1
def pauseGame(self):
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.menu.selectDialog.hide()
self.gameState = 'pause'
self.node.state = 'pause'
self.node.endTask()
self.node.erosionFrame.hide()
self.node.currentItemFrame.hide()
base.accept('escape', self.escapeEvent)
base.accept('b', self.menu.nothing)
self.menu.pauseFrame.show()
def escapeEvent(self):
self.menu.pauseFrame.hide()
self.node.state = ''
self.node.initTask()
self.node.erosionFrame.show()
self.node.currentItemFrame.show()
base.accept('escape', self.pauseGame)
base.accept('b', self.openBag)
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
def SetLight(self):
render.setLightOff()
alight = AmbientLight('alight')
alnp = render.attachNewNode(alight)
alight.setColor(LVector4(0.1, 0.1, 0.1, 1))
#render.setLight(alnp)
plight = PointLight('plight')
plight.setColor(VBase4(3, 3, 3, 1))
plight.setAttenuation(Point3(0.1, 0.1, 0))
plnp = render.attachNewNode(plight)
plnp.setPos(0, 0, 200)
render.setLight(plnp)
plight = PointLight('plight')
plight.setColor(VBase4(1, 1, 1, 1))
plight.setAttenuation(Point3(0.10, 0.1, 0))
plnp = render.attachNewNode(plight)
plnp.setPos(333, -900, 217)
render.setLight(plnp)
plight = PointLight('plight')
plight.setColor(VBase4(1, 1, 1, 1))
plight.setAttenuation(Point3(0.10, 0.1, 0))
plnp = render.attachNewNode(plight)
plnp.setPos((-438.104, 377.736, 400))
render.setLight(plnp)
def makeFilterBuffer(self, srcbuffer, name, sort, prog):
blurBuffer = base.win.makeTextureBuffer(name, 512, 512)
blurBuffer.setSort(sort)
blurBuffer.setClearColor(LVector4(1, 0, 0, 1))
blurCamera = base.makeCamera2d(blurBuffer)
blurScene = NodePath("new Scene")
blurCamera.node().setScene(blurScene)
shader = loader.loadShader(prog)
card = srcbuffer.getTextureCard()
card.reparentTo(blurScene)
card.setShader(shader)
return blurBuffer
def glowFilter(self):
glowShader = loader.loadShader("shaders/glowShader.sha")
# dlight = DirectionalLight('dlight')
# alight = AmbientLight('alight')
# dlnp = render.attachNewNode(dlight)
# alnp = render.attachNewNode(alight)
# dlight.setColor(LVector4(0.3, 0.3, 0.3, 1))
# alight.setColor(LVector4(0.8, 0.8, 0.8, 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", 1024, 768)
glowBuffer.setSort(-3)
glowBuffer.setClearColor(LVector4(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.
self.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)
self.glowCamera.node().setInitialState(tempnode.getState())
self.glowCamera.node().setCameraMask(BitMask32.bit(0))
# set up the pipeline: from glow scene to blur x to blur y to main
# window.
blurXBuffer = self.makeFilterBuffer(glowBuffer, "Blur X", -2,
"shaders/XBlurShader.sha")
blurYBuffer = self.makeFilterBuffer(blurXBuffer, "Blur Y", -1,
"shaders/YBlurShader.sha")
self.finalcard = blurYBuffer.getTextureCard()
self.finalcard.reparentTo(render2d)
Attrib = ColorBlendAttrib.make(ColorBlendAttrib.MAdd,
ColorBlendAttrib.O_incoming_alpha,
ColorBlendAttrib.O_incoming_alpha)
self.finalcard.setAttrib(Attrib)
base.bufferViewer.setPosition("llcorner")
base.bufferViewer.setLayout("hline")
base.bufferViewer.setCardSize(0.652, 0)
base.accept("tab", self.toggleGlow)
self.glowOn = False
def limitGlow(self, task):
if task.time < 5:
return task.cont
else:
self.glowOn = False
self.finalcard.reparentTo(hidden)
self.goodmanager.GoodsIta["box"].CloseHighLight()
self.goodmanager.GoodsIta["yaoshui"].CloseHighLight()
self.goodmanager.GoodsIta["MusicBox"].CloseHighLight()
self.goodmanager.GoodsIta["matong_box3"].CloseHighLight()
self.goodmanager.GoodsIta["Scene1_Exit"].CloseHighLight()
self.goodmanager.GoodsIta["Scene1_wallword_1"].CloseHighLight()
self.goodmanager.GoodsIta["Scene1_wallword_2"].CloseHighLight()
self.goodmanager.GoodsIta["enemy"].CloseHighLight()
self.goodmanager.GoodsIta["xishoupen"].CloseHighLight()
return task.done
def toggleGlow(self):
self.showskillpattern("eyepattern")
if self.glowOn:
return
self.glowOn = True
taskMgr.add(self.limitGlow, "limitGlow")
if self.node.EROSION + 10 > 100:
self.node.EROSION = 100
else:
self.node.EROSION += 10
self.toggleGlowSound = loader.loadSfx("res/sounds/Raise3.mp3")
self.toggleGlowSound.play()
self.finalcard.reparentTo(render2d)
self.goodmanager.GoodsIta["box"].OpenHighLight()
self.goodmanager.GoodsIta["yaoshui"].OpenHighLight()
self.goodmanager.GoodsIta["MusicBox"].OpenHighLight()
self.goodmanager.GoodsIta["matong_box3"].OpenHighLight()
self.goodmanager.GoodsIta["Scene1_Exit"].OpenHighLight()
self.goodmanager.GoodsIta["Scene1_wallword_1"].OpenHighLight()
self.goodmanager.GoodsIta["Scene1_wallword_2"].OpenHighLight()
self.goodmanager.GoodsIta["enemy"].OpenHighLight()
self.goodmanager.GoodsIta["xishoupen"].OpenHighLight()
# if not self.glowOn:
# self.finalcard.reparentTo(hidden)
# self.goodmanager.GoodsIta["box"].CloseHighLight()
# self.goodmanager.GoodsIta["yaoshui"].CloseHighLight()
# self.goodmanager.GoodsIta["MusicBox"].CloseHighLight()
# self.goodmanager.GoodsIta["matong_box3"].CloseHighLight()
# self.goodmanager.GoodsIta["Scene1_Exit"].CloseHighLight()
# self.goodmanager.GoodsIta["Scene1_wallword_1"].CloseHighLight()
# self.goodmanager.GoodsIta["Scene1_wallword_2"].CloseHighLight()
# self.goodmanager.GoodsIta["enemy"].CloseHighLight()
# self.goodmanager.GoodsIta["xishoupen"].CloseHighLight()
# else:
# self.finalcard.reparentTo(render2d)
# self.goodmanager.GoodsIta["box"].OpenHighLight()
# self.goodmanager.GoodsIta["yaoshui"].OpenHighLight()
# self.goodmanager.GoodsIta["MusicBox"].OpenHighLight()
# self.goodmanager.GoodsIta["matong_box3"].OpenHighLight()
# self.goodmanager.GoodsIta["Scene1_Exit"].OpenHighLight()
# self.goodmanager.GoodsIta["Scene1_wallword_1"].OpenHighLight()
# self.goodmanager.GoodsIta["Scene1_wallword_2"].OpenHighLight()
# self.goodmanager.GoodsIta["enemy"].OpenHighLight()
# self.goodmanager.GoodsIta["xishoupen"].OpenHighLight()
# self.node.EROSION += 10
# #print self.goodmanager.staticGoods['wall'].Node
#
# self.glowOn = not (self.glowOn)
def initMania(self):
base.accept("space", self.mania)
self.maniaState = False
def mania(self):
self.showskillpattern("maniapattern")
if not self.maniaState:
self.node.speed *= 1.4
self.maniaState = True
if self.node.EROSION + 10 > 100:
self.node.EROSION = 100
else:
self.node.EROSION += 10
taskMgr.remove("fadeSpeed")
taskMgr.add(self.fadeSpeed, "fadeSpeed")
def fadeSpeed(self, task):
if task.time < 10:
return task.cont
else:
self.node.speed /= 1.4
self.maniaState = False
return task.done
def setupskillpattern(self):
self.eyepattern = OnscreenImage(image="res/skill_icon/eye-white.png",
pos=(-1.2, 1, -0.8))
self.eyepattern.setTransparency(TransparencyAttrib.MAlpha)
self.eyepattern.setScale(0.1)
self.eyepattern.setSa(0.8)
self.eyepattern.hide()
self.maniapattern = OnscreenImage(
image="res/skill_icon/mania-white.png", pos=(-1.2 + 0.3, 1, -0.8))
self.maniapattern.setTransparency(TransparencyAttrib.MAlpha)
self.maniapattern.setScale(0.1)
self.maniapattern.setSa(0.8)
self.maniapattern.hide()
self.screen_patternArray = {}
self.screen_patternArray["eyepattern"] = [self.eyepattern, False, 5.0]
self.screen_patternArray["maniapattern"] = [
self.maniapattern, False, 5.0
]
self.patterntask = False
def showskillpattern(self, patternname):
self.screen_patternArray[patternname][2] = 10.
self.screen_patternArray[patternname][1] = True
self.screen_patternArray[patternname][0].show()
if self.patterntask == False:
taskMgr.add(self.showskillpatterntask, "showskillpatterntask")
def showskillpatterntask(self, task):
num = 0
for key in self.screen_patternArray:
if self.screen_patternArray[key][1] == True:
self.screen_patternArray[key][2] -= globalClock.getDt()
if self.screen_patternArray[key][2] < 5.:
if sin(self.screen_patternArray[key][2] * pi * 5) > 0:
self.screen_patternArray[key][0].setSa(0)
else:
self.screen_patternArray[key][0].setSa(0.8)
self.screen_patternArray[key][0].setPos(
-1.2 + num * 0.3, 1, -0.8)
if self.screen_patternArray[key][2] < 0:
self.screen_patternArray[key][1] = False
self.screen_patternArray[key][0].hide()
self.screen_patternArray[key][0].setSa(0.8)
num += 1
if num > 0:
return task.cont
self.patterntask = False
return
class Player(object):
"""
Player is the main actor in the fps game
"""
HP = 100
EROSION = 0
updateTime = 0
speed = 10
FORWARD = Vec3(0, 2, 0)
BACK = Vec3(0, -1, 0)
LEFT = Vec3(-1, 0, 0)
RIGHT = Vec3(1, 0, 0)
STOP = Vec3(0)
walk = STOP
strafe = STOP
readyToJump = False
jump = 0
state = ''
cameraState = 1
visionState = 0
RightButton = 0
LeftButton = 0
goodmanager = None
isInteractive = False
SLOW = 1
End = 0
Begin = 1
TaskState = End
def __init__(self, goodmanager, m, g):
""" inits the player """
# 6/17
self.walksound = loader.loadSfx("res/sounds/footstep.mp3")
self.goodmanager = goodmanager
self.menu = m
self.game = g
self.loadModel()
self.setUpCamera()
self.setMouseIcon()
self.createCollisions()
self.attachControls()
self.initSkill()
self.shoot = Shoot()
# init mouse update task
self.initSave()
self.initTask()
self.initMission()
def initMission(self):
if self.game.levelName == "tutorial":
self.mission = Mission(self, self.menu)
elif self.game.levelName == "levelTwo":
self.mission = MissionTwo(self, self.menu)
elif self.game.levelName == "levelThree":
self.mission = MissionThree(self, self.menu)
def initSave(self):
self.erosionFrame = DirectFrame(frameColor=(0, 0, 0, 0),
frameSize=(-1, 1, -1, 1),
pos=(-1.2, 0, 0))
self.erosionFrame.hide()
self.erosionFrame.setScale(.02, 1, .4)
self.background = OnscreenImage('res/erosion_bar.png',
pos=(0, 0, 0),
scale=(1, 1, 1))
self.background.setTransparency(TransparencyAttrib.MAlpha)
self.background.reparentTo(self.erosionFrame)
# self.erosionBar = DirectWaitBar(value=self.EROSION, pos=(0, 0, 0), barTexture='res/erosion_value.png',
# relief=None)
# self.erosionBar.setHpr(0, 0, -90)
# self.erosionBar.setScale(0.98, 1, 10)
# self.erosionBar.hide()
# self.erosionBar.reparentTo(self.erosionFrame)
self.erosionBar = OnscreenImage('res/erosion_value.png',
pos=(0, 0, 0),
scale=(1, 1, 1))
self.erosionBar.setScale(1)
self.erosionBar.setTransparency(TransparencyAttrib.MAlpha)
self.erosionBar.reparentTo(self.erosionFrame)
self.currentItemFrame = DirectFrame(
frameColor=(0, 0, 0, 0),
frameSize=(-2, 2, -2, 2),
pos=(-1.2, 0, .8),
image='res/models/items/injection.png',
scale=(.1))
self.currentItemFrame.setTransparency(TransparencyAttrib.MAlpha)
self.currentItemFrame.hide()
# self.currentItemFrame.show()
def initTask(self):
if self.TaskState == self.Begin: return
self.TaskState = self.Begin
self.state = ''
self.game.gameState = ''
self.mouseIconNormal.show()
taskMgr.add(self.mouseUpdate, "mouse-task")
taskMgr.add(self.moveUpdate, "move-task")
taskMgr.add(self.jumpUpdate, 'jump-task')
taskMgr.add(self.erosionUpdate, "erosion-task")
def endTask(self):
if self.TaskState == self.End: return
self.TaskState = self.End
self.state = 'pause'
self.mouseIconWatch.hide()
self.mouseIconNormal.hide()
taskMgr.remove('mouse-task')
taskMgr.remove('move-task')
taskMgr.remove('jump-task')
taskMgr.remove('erosion-task')
# reset update time
self.updateTime = 5
def loadModel(self):
""" make the nodepath for player """
# self.playerModel = Actor("res/models/ralph", {"run": "res/models/ralph-run", "walk": "res/models/ralph-walk"})
self.playerModel = Actor("res/models/hitman-model5", {
"walk": "res/models/hitman-walk5",
"stand": "res/models/hitman-stand"
})
# self.playerModel = Actor("res/models/hitman2-model", {"walk": "res/models/hitman2-walk", "stand":"res/models/hitman-stand"})
self.playerModel.setH(180)
self.playerModel.setZ(0)
self.playerModel.setScale(1.1)
# self.playerModel.hide()
self.node = NodePath("player")
self.node.reparentTo(render)
self.playerModel.reparentTo(self.node)
# self.node.setPos(0, 0, 10)
self.node.setPos(-250, 265, 0)
self.node.setHpr(150, 0, 0)
self.node.setScale(20)
self.node.hide(BitMask32.bit(0))
self.node.hide(BitMask32.bit(1))
def setMouseIcon(self):
self.mouseIconNormal = OnscreenImage(image="res/mouse/mouse1.png",
pos=(0, 1.1, 0))
self.mouseIconNormal.setTransparency(TransparencyAttrib.MAlpha)
self.mouseIconNormal.setScale(0.02)
self.mouseIconNormal.setLightOff()
self.mouseIconNormal.setSa(0.5)
self.mouseIconWatch = OnscreenImage(image="res/mouse/mouse2.png",
pos=(0, 1.1, 0))
self.mouseIconWatch.setTransparency(TransparencyAttrib.MAlpha)
self.mouseIconWatch.setScale(0.05)
self.mouseIconWatch.setSa(0.5)
self.mouseIconWatch.setLightOff()
self.mouseIconNormal.reparentTo(base.camera)
self.mouseIconWatch.reparentTo(base.camera)
self.mouseIconWatch.hide()
def SetMouseModeNormal(self, mode):
if mode == 'Watch':
self.mouseIconWatch.show()
self.mouseIconNormal.hide()
elif mode == 'Normal':
self.mouseIconNormal.show()
self.mouseIconWatch.hide()
def setUpCamera(self):
""" puts camera at the players node """
pl = base.cam.node().getLens()
pl.setFov(70)
base.cam.node().setLens(pl)
base.camera.reparentTo(self.node)
base.cam.node().setCameraMask(BitMask32.bit(3))
self.oldcameraState = 0
self.cameranewPos = None
self.cameranewH = None
self.changeCamera()
# 6/17
def createCollisions(self):
""" create a collision solid and ray for the player """
cn = CollisionNode('PlayerCollideNode')
cn.addSolid(CollisionSphere(0, 0, 4, 1))
solid = self.node.attachNewNode(cn)
solid.setScale(1, 1, 1)
solid.setPos(0, 0, 0)
# solid.show()
base.cTrav.addCollider(solid, base.pusher)
base.pusher.addCollider(solid, self.node, base.drive.node())
# init players floor collisions
ray = CollisionRay()
ray.setOrigin(0, 0, 3)
ray.setDirection(0, 0, -1)
cn = CollisionNode('playerRay')
cn.addSolid(ray)
cn.setFromCollideMask(BitMask32.bit(0))
cn.setIntoCollideMask(BitMask32.allOff())
solid = self.node.attachNewNode(cn)
# solid.show()
base.cTrav.setRespectPrevTransform(True)
self.nodeGroundHandler = CollisionHandlerQueue()
base.cTrav.addCollider(solid, self.nodeGroundHandler)
# init players Forward Ray
ForwardSegment = CollisionSegment(0, 2, 0, 0, 20, 0)
cn = CollisionNode('playerForwardSegment')
cn.addSolid(ForwardSegment)
cn.setFromCollideMask(BitMask32.bit(0))
cn.setIntoCollideMask(BitMask32.allOff())
solid = base.camera.attachNewNode(cn)
# solid.show()
base.cTrav.addCollider(solid, self.nodeGroundHandler)
# repair cross wall
ForwardSegment = CollisionSegment(0, -4, 3, 0, 4, 3)
cn = CollisionNode('PlayerMoveForwardSegment')
cn.addSolid(ForwardSegment)
cn.setFromCollideMask(BitMask32.bit(0))
cn.setIntoCollideMask(BitMask32.allOff())
solid = self.node.attachNewNode(cn)
# solid.show()
base.cTrav.addCollider(solid, self.nodeGroundHandler)
# init play Right Ray
ForwardSegment = CollisionSegment(-2, 0, 3, 2, 0, 3)
cn = CollisionNode('PlayerMoveRightSegment')
cn.addSolid(ForwardSegment)
cn.setFromCollideMask(BitMask32.bit(0))
cn.setIntoCollideMask(BitMask32.allOff())
solid = self.node.attachNewNode(cn)
# solid.show()
base.cTrav.addCollider(solid, self.nodeGroundHandler)
def attachControls(self):
""" attach key events """
# base.accept("space", self.__setattr__, ["readyToJump", True])
# base.accept("space-up", self.__setattr__, ["readyToJump", False])
self.keyEven = [
"s", "s-up", "w", "w-up", "a", "d", "a-up", "d-up", "c", "o",
"mouse3", "mouse3-up", "mouse1", "mouse1-up"
]
base.accept("s", self.__setattr__, ["walk", self.STOP])
base.accept("w", self.__setattr__, ["walk", self.FORWARD])
base.accept("s", self.__setattr__, ["walk", self.BACK])
base.accept("s-up", self.__setattr__, ["walk", self.STOP])
base.accept("w-up", self.__setattr__, ["walk", self.STOP])
base.accept("a", self.__setattr__, ["strafe", self.LEFT])
base.accept("d", self.__setattr__, ["strafe", self.RIGHT])
base.accept("a-up", self.__setattr__, ["strafe", self.STOP])
base.accept("d-up", self.__setattr__, ["strafe", self.STOP])
base.accept("c", self.changeCamera)
base.accept("o", self.doubleVision)
base.accept("mouse3", self.__setattr__, ["RightButton", 1])
base.accept("mouse3-up", self.__setattr__, ["RightButton", 0])
base.accept("mouse1", self.__setattr__, ["LeftButton", 1])
base.accept("mouse1-up", self.__setattr__, ["LeftButton", 0])
def IgnoreControls(self):
for name in self.keyEven:
base.ignore(name)
print base.getAllAccepting()
def initSkill(self):
self.tex = Texture()
self.tex.setMinfilter(Texture.FTLinear)
base.win.addRenderTexture(self.tex,
GraphicsOutput.RTMTriggeredCopyTexture)
self.tex.setClearColor((0, 0, 0, 1))
self.tex.clearImage()
# Create another 2D camera. Tell it to render before the main camera.
self.backcam = base.makeCamera2d(base.win, sort=-10)
self.background = NodePath("background")
self.backcam.reparentTo(self.background)
self.background.setDepthTest(0)
self.background.setDepthWrite(0)
self.backcam.node().getDisplayRegion(0).setClearDepthActive(0)
self.bcard = base.win.getTextureCard()
self.bcard.reparentTo(base.render2d)
self.bcard.setTransparency(1)
self.fcard = base.win.getTextureCard()
self.fcard.reparentTo(base.render2d)
self.fcard.setTransparency(1)
# Add the task that initiates the screenshots.
taskMgr.add(self.takeSnapShot, "takeSnapShot")
if base.win.getGsg().getCopyTextureInverted():
# print("Copy texture is inverted.")
self.bcard.setScale(1, 1, -1)
self.fcard.setScale(1, 1, -1)
self.bcard.hide()
self.fcard.hide()
self.nextclick = 0
self.clickrate = 10000
def takeSnapShot(self, task):
if task.time > self.nextclick:
self.nextclick += 1.0 / self.clickrate
if self.nextclick < task.time:
self.nextclick = task.time
base.win.triggerCopy()
return task.cont
def doubleVision(self):
self.visionState = 1 - self.visionState
if self.visionState == 1:
self.bcard.show()
self.bcard.setColor(1, 1, 1, 0.60)
self.bcard.setScale(1.0)
self.bcard.setPos(-0.05, 0, 0)
self.bcard.setR(0)
self.fcard.show()
self.fcard.setColor(1, 1, 1, 0.60)
self.fcard.setScale(1.0)
self.fcard.setPos(0.05, 0, 0)
self.fcard.setR(0)
self.clickrate = 10000
self.nextclick = 0
else:
self.bcard.hide()
self.fcard.hide()
def changeCamera(self):
if self.cameraState == 1:
self.cameraState = 0
else:
self.cameraState = 1
self.setCamera()
def setCamera(self):
self.cameraoldPos = base.camera.getPos()
self.cameraoldNear = base.cam.node().getLens().getNear()
if self.cameraState == 0:
self.cameranewPos = Vec3(0, -5, 10)
pl = base.cam.node().getLens()
self.cameranewNear = 1
base.cam.node().setLens(pl)
elif self.cameraState == 1:
self.cameranewPos = Vec3(0, -1, 8)
self.cameranewNear = 1
# self.playerModel.hide()
self.playerModel.hide(BitMask32.bit(3))
elif self.cameraState == 2:
self.cameranewPos = Vec3(0, -1.5, 8)
self.cameranewNear = 1
taskMgr.add(self.updatecamera, "updatecamera")
def updatecamera(self, task):
if task.time < 0.2:
camera.setPos(
(self.cameraoldPos * (0.2 - task.time) + self.cameranewPos *
(task.time)) / 0.2)
return task.cont
if self.cameraState == 1:
self.playerModel.hide(BitMask32.bit(3))
else:
self.playerModel.show(BitMask32.bit(3))
pl = base.cam.node().getLens()
pl.setNear(self.cameraoldNear)
base.cam.node().setLens(pl)
return
def erosionUpdate(self, task):
if self.EROSION >= 100:
self.mission.end("endA")
return
if self.EROSION >= 80:
self.visionState = 0
self.doubleVision()
else:
self.visionState = 1
self.doubleVision()
# self.erosionBar['value'] = self.EROSION
self.erosionBar.setScale(1, 1, self.EROSION / 100)
self.erosionBar.setPos(0, 0, -1 + self.EROSION / 100)
if task.time > self.updateTime:
self.EROSION = math.pow(2,
(self.EROSION / 20 - 1)) / 6 + self.EROSION
# print task.time, 'time'
# print self.EROSION
self.updateTime += 10
# print self.updateTime
return task.cont
def erosionUpdateTemp(self):
if self.EROSION >= 100:
if self.game.levelName == 'levelThree':
self.mission.chessBoard.hide()
self.mission.end("endA")
return
if self.EROSION >= 80:
self.visionState = 0
self.doubleVision()
else:
self.visionState = 1
self.doubleVision()
# self.erosionBar['value'] = self.EROSION
self.erosionBar.setScale(1, 1, self.EROSION / 100)
self.erosionBar.setPos(0, 0, -1 + self.EROSION / 100)
def mouseUpdate(self, task):
""" this task updates the mouse """
if self.state == '':
md = base.win.getPointer(0)
x = md.getX()
y = md.getY()
if base.win.movePointer(0,
base.win.getXSize() / 2,
base.win.getYSize() / 2):
self.node.setH(self.node.getH() -
(x - base.win.getXSize() / 2) * 0.1)
base.camera.setP(base.camera.getP() -
(y - base.win.getYSize() / 2) * 0.1)
if (base.camera.getP() < -45.): base.camera.setP(-45)
if (base.camera.getP() > 45.): base.camera.setP(45)
if self.RightButton == 1:
self.shoot.MouseDown(self.node)
self.EROSION += 5
self.RightButton = 0
# check Interactive Goods
nearest = 1000.0
goods = None
for i in range(self.nodeGroundHandler.getNumEntries()):
entry = self.nodeGroundHandler.getEntry(i)
IntoName = entry.getIntoNode().getName()
FromName = entry.getFromNode().getName()
if FromName == 'playerForwardSegment':
if entry.getSurfacePoint(base.camera).getY() < nearest:
nearest = entry.getSurfacePoint(base.camera).getY()
goods = self.goodmanager.GoodsIta.get(IntoName)
if goods and goods.Interactive == True:
# print goods.Name
self.SetMouseModeNormal('Watch')
self.isInteractive = True
self.currentInteract = goods
else:
self.SetMouseModeNormal('Normal')
self.isInteractive = False
self.currentInteract = None
if self.LeftButton == 1 and self.isInteractive:
print 'trigger interactive event'
print goods.Name
self.mission.interactiveWith(goods)
return task.cont
def moveUpdate(self, task):
""" this task makes the player move """
# move where the keys set it
# print self.node.getPos()
nearestForward = 1000.0
nearestRight = 1000.0
RightEntry = None
ForwardEntry = None
for i in range(self.nodeGroundHandler.getNumEntries()):
entry = self.nodeGroundHandler.getEntry(i)
IntoName = entry.getIntoNode().getName()
FromName = entry.getFromNode().getName()
if FromName == 'PlayerMoveForwardSegment' and (
IntoName != 'PlayerCollideNode'):
if entry.getSurfacePoint(self.node).getY() < nearestForward:
nearestForward = entry.getSurfacePoint(self.node).getY()
ForwardEntry = entry
if FromName == 'PlayerMoveRightSegment' and (IntoName !=
'PlayerCollideNode'):
if abs(entry.getSurfacePoint(self.node).getX()) < nearestRight:
nearestRight = abs(entry.getSurfacePoint(self.node).getX())
RightEntry = entry
if nearestForward < 2 and nearestForward > -2:
self.SLOW = abs(nearestForward) * 0.2
self.node.setPos(self.node.getPos() +
ForwardEntry.getSurfaceNormal(render))
else:
self.SLOW = 1
if nearestRight < 2:
self.node.setPos(self.node.getPos() +
RightEntry.getSurfaceNormal(render))
if (nearestForward < 0 and nearestForward > -5.) or nearestRight < 5:
if self.cameraState == 0:
self.cameraState = 2
self.setCamera()
else:
if self.cameraState == 2:
self.cameraState = 0
self.setCamera()
if self.state == '':
self.walksound.setLoop(False)
#self.walksound.stop()
if ((self.walk == self.FORWARD)
and (self.playerModel.getAnimControl('walk').isPlaying()
== False)):
self.walksound.setLoop(True)
self.walksound.setVolume(0.5)
self.walksound.play()
self.playerModel.getAnimControl('walk').play()
elif self.walk == self.STOP and self.playerModel.getAnimControl(
'stand').isPlaying() == False:
self.playerModel.getAnimControl('stand').play()
self.playerModel.getAnimControl('walk').stop()
self.walksound.setLoop(False)
self.walksound.stop()
if self.strafe == LVector3f(
-1, 0, 0) or self.strafe == LVector3f(1, 0, 0):
self.walksound.setLoop(True)
# self.walksound.setVolume(0.5)
self.walksound.play()
elif self.strafe == LVector3f(0, 0, 0):
self.walksound.setLoop(False)
self.walksound.stop()
#elif self.walk == self.BACK:
#self.walksound.setLoop(True)
#self.walksound.setVolume(0.5)
#self.walksound.play()
self.node.setFluidPos(
self.node,
self.walk * globalClock.getDt() * self.speed * self.SLOW)
self.node.setFluidPos(
self.node,
self.strafe * globalClock.getDt() * self.speed * self.SLOW)
return task.cont
# 6/17
def jumpUpdate(self, task):
""" this task simulates gravity and makes the player jump """
# get the highest Z from the down casting ray
highestZ = -100
for i in range(self.nodeGroundHandler.getNumEntries()):
entry = self.nodeGroundHandler.getEntry(i)
# print entry
z = entry.getSurfacePoint(render).getZ()
# if z > highestZ and entry.getFromNode().getName() == 'playerRay' and entry.getIntoNode().getName() != "PlayerCollideNode":
if z > highestZ and entry.getFromNode().getName(
) == 'playerRay' and entry.getIntoNode().getName() == "floor":
highestZ = z
# print highestZ
# gravity effects and jumps
self.node.setZ(self.node.getZ() +
self.jump * globalClock.getDt() * 600)
self.jump -= 1 * globalClock.getDt()
if highestZ > self.node.getZ():
self.jump = 0
self.node.setZ(highestZ)
if self.readyToJump:
self.jump = 1
return task.cont
class CameraHandler():
def __init__(self, character):
self.character = character
# Setup mouse
base.disableMouse()
hideMouse(True)
self.mouseSensitivity = 0.1
base.taskMgr.doMethodLater(0.1, self.prepareCameraTask, "prepare-camera")
# Setup camera
base.camera.reparentTo(self.character.node)
base.camera.setPos(0, 0, 0)
base.camera.lookAt(0, 1, 0)
# Create target
self.target = OnscreenImage(image = "media/target.png", pos = (0, 0, 0))
self.target.setTransparency(TransparencyAttrib.MAlpha)
self.target.setScale(0.1)
self.target.setSa(0.5)
# Create overlay
self.overlayCard = CardMaker("overlayCard")
self.overlayCard.setFrameFullscreenQuad()
self.overlay = base.render2d.attachNewNode(self.overlayCard.generate())
self.overlay.setTransparency(TransparencyAttrib.MAlpha)
self.overlay.setColor(0,0,0,0)
# Setup interval sequences
self.shakeSequence = None
self.flashSequence = None
def shake(self, amplitude = (1,0,0), duration = 1.0, swings = 1):
if self.shakeSequence != None:
self.shakeSequence.finish()
self.shakeSequence = Sequence()
swings = int(swings)
duration = float(duration)
dt = duration / (swings * 4)
ds = Point3(amplitude)
for i in range(swings):
self.shakeSequence.append(LerpPosInterval(base.camera, dt, ds*-1))
self.shakeSequence.append(LerpPosInterval(base.camera, dt*2, ds))
self.shakeSequence.append(LerpPosInterval(base.camera, dt, Point3(0, 0, 0)))
self.shakeSequence.start()
def flash(self, color = (1,1,1,1), duration = 1.0, fadeIn = 0.2):
if self.flashSequence != None:
self.flashSequence.finish()
self.flashSequence = Sequence()
dtIn = float(duration) * fadeIn
dtOut = duration - dtIn
if dtIn > 0:
self.flashSequence.append(LerpColorInterval(self.overlay, dtIn, color))
if dtOut > 0:
self.flashSequence.append(LerpColorInterval(self.overlay, dtOut, (0,0,0,0), color))
self.flashSequence.start()
def prepareCameraTask(self, task):
base.win.movePointer(0, base.win.getXSize()/2, base.win.getYSize()/2)
base.taskMgr.add(self.controlCameraTask, "camera-control")
return task.done
def controlCameraTask(self, task):
char = self.character.node
# Get current mouse location.
md = base.win.getPointer(0)
x = md.getX()
y = md.getY()
# Rotate character based on mouse coordinates.
if base.win.movePointer(0, base.win.getXSize()/2, base.win.getYSize()/2):
char.setP((char.getP() - (y - base.win.getYSize()/2)*self.mouseSensitivity) % 360)
char.setH((char.getH() - (x - base.win.getXSize()/2)*self.mouseSensitivity) % 360)
# Don't let the camera loop over. Allowed range is 0-90 (up) and 360-270 (down).
if char.getP() > 90 and char.getP() < 180:
char.setP(90)
elif char.getP() < 270 and char.getP() >= 180:
char.setP(270)
return task.cont
class CameraHandler():
def __init__(self, character):
self.character = character
# Setup mouse
base.disableMouse()
hideMouse(True)
self.mouseSensitivity = 0.1
base.taskMgr.doMethodLater(0.1, self.prepareCameraTask,
"prepare-camera")
# Setup camera
base.camera.reparentTo(self.character.node)
base.camera.setPos(0, 0, 0)
base.camera.lookAt(0, 1, 0)
# Create target
self.target = OnscreenImage(image="media/target.png", pos=(0, 0, 0))
self.target.setTransparency(TransparencyAttrib.MAlpha)
self.target.setScale(0.1)
self.target.setSa(0.5)
# Create overlay
self.overlayCard = CardMaker("overlayCard")
self.overlayCard.setFrameFullscreenQuad()
self.overlay = base.render2d.attachNewNode(self.overlayCard.generate())
self.overlay.setTransparency(TransparencyAttrib.MAlpha)
self.overlay.setColor(0, 0, 0, 0)
# Setup interval sequences
self.shakeSequence = None
self.flashSequence = None
def shake(self, amplitude=(1, 0, 0), duration=1.0, swings=1):
if self.shakeSequence != None:
self.shakeSequence.finish()
self.shakeSequence = Sequence()
swings = int(swings)
duration = float(duration)
dt = duration / (swings * 4)
ds = Point3(amplitude)
for i in range(swings):
self.shakeSequence.append(LerpPosInterval(base.camera, dt,
ds * -1))
self.shakeSequence.append(LerpPosInterval(base.camera, dt * 2, ds))
self.shakeSequence.append(
LerpPosInterval(base.camera, dt, Point3(0, 0, 0)))
self.shakeSequence.start()
def flash(self, color=(1, 1, 1, 1), duration=1.0, fadeIn=0.2):
if self.flashSequence != None:
self.flashSequence.finish()
self.flashSequence = Sequence()
dtIn = float(duration) * fadeIn
dtOut = duration - dtIn
if dtIn > 0:
self.flashSequence.append(
LerpColorInterval(self.overlay, dtIn, color))
if dtOut > 0:
self.flashSequence.append(
LerpColorInterval(self.overlay, dtOut, (0, 0, 0, 0), color))
self.flashSequence.start()
def prepareCameraTask(self, task):
base.win.movePointer(0,
base.win.getXSize() / 2,
base.win.getYSize() / 2)
base.taskMgr.add(self.controlCameraTask, "camera-control")
return task.done
def controlCameraTask(self, task):
char = self.character.node
# Get current mouse location.
md = base.win.getPointer(0)
x = md.getX()
y = md.getY()
# Rotate character based on mouse coordinates.
if base.win.movePointer(0,
base.win.getXSize() / 2,
base.win.getYSize() / 2):
char.setP(
(char.getP() -
(y - base.win.getYSize() / 2) * self.mouseSensitivity) % 360)
char.setH(
(char.getH() -
(x - base.win.getXSize() / 2) * self.mouseSensitivity) % 360)
# Don't let the camera loop over. Allowed range is 0-90 (up) and 360-270 (down).
if char.getP() > 90 and char.getP() < 180:
char.setP(90)
elif char.getP() < 270 and char.getP() >= 180:
char.setP(270)
return task.cont
