def shoot():
bala = self.particlesDummy.attachNewNode("balaDummy")
balaImage = OnscreenImage(image="prova/textures/bala.png",
parent=bala)
balaImage.setTransparency(1)
balaImage.setScale(.1, 1., .2)
balaImage.setBillboardPointEye()
bala.setQuat(self.modelAvio.getQuat(render))
if self.balaPositiu:
bala.setPos(self.balaDreta.getPos(render))
self.balaPositiu = False
else:
bala.setPos(self.balaEsquerra.getPos(render))
self.balaPositiu = True
balaSphere = bala.attachNewNode(self.balaCol)
balaColHandler = CollisionHandlerQueue()
base.cTrav.addCollider(balaSphere, balaColHandler)
#~ if type(self.shootPoint) == 'libpanda.Point3':
#~ bala.lookAt(self.shootPoint)
#~ else: bala.setH(bala, 180.)
taskMgr.add(
mouBala,
"moubala",
extraArgs=[bala, balaImage, self.BALA_VEL, balaColHandler],
appendTask=True)
def configureDance(self):
self.PRESSED,self.NPRESSED,self.PERFECT,self.GOOD,self.MISS=10,-10,2,1,0
danceNode = self.render.attachNewNode(PandaNode('dance'))
# load and set up scene
danceScene = self.loader.loadModel("../models/disco_hall")
danceScene.reparentTo(danceNode)
danceScene.setPosHpr(0, 50, -4, 90, 0, 0)
self.configureLights(danceNode)
self.configureDancer(danceNode)
scoreCircle=OnscreenImage(
image = '../textures/arrivalCircle.png', pos = (-1,0,0.8))
scoreCircle.setTransparency(TransparencyAttrib.MAlpha)
scoreCircle.setScale(0.2)
scoreText= OnscreenText(text =str(0), pos = (-1.02,0.76),
scale = 0.1,fg=(1,1,1,1))
position=self.dancer.getPos()
position[1]=0
position[2]=-0.4
GUIarrows=DirectFrame(frameColor=(0.3,0.3,0.7,0.3),
frameSize=(-0.8,.8,0.2,-0.2),
pos=position)
hitSign=OnscreenImage(image ='../textures/circle.png', pos = (-0.6, 0, -0.4))
hitSign.setTransparency(TransparencyAttrib.MAlpha)
hitSign.setScale(0.15)
scoreReminder=OnscreenText(text ='PERFECT', pos = (-0.6,-0.4),
scale = 0.04,fg=(1,1,1,1),shadow=(0.4,0.4,0.7,0.3))
self.setPanel('dance',Panel(danceNode, {'scoreCircle': scoreCircle,
'GUIarrows':GUIarrows,'hitSign': hitSign,'scoreText': scoreText,
'scoreReminder': scoreReminder}))
def loadGUI(self):
self.vidas_imgs = list()
w = 0.24
for i in range(self.VIDAS):
image_warning = OnscreenImage(
image='../data/Texture/signal_warning.png',
pos=(-1 + i * w, 0, 0.85),
parent=self._playing_node2d)
image_warning.setScale(0.1)
image_warning.setTransparency(TransparencyAttrib.MAlpha)
image_warning.hide()
image_ok = OnscreenImage(image='../data/Texture/signal_ok.png',
pos=(-1 + i * w, 0, 0.85),
parent=self._playing_node2d)
image_ok.setScale(0.1)
image_ok.setTransparency(TransparencyAttrib.MAlpha)
image_ok.show()
self.vidas_imgs.append((image_ok, image_warning))
self._level_time_O = OnscreenText(text='',
pos=(0, 0.85),
scale=0.14,
fg=(1.0, 1.0, 1.0, 1.0),
bg=(0.0, 0.0, 0.0, 1.0),
parent=self._playing_node2d)
class ItemIcon():
def __init__(self, itemName, parentNode):
print 'itemicon', itemName, parentNode
self.parentNode = parentNode # The node of its parent (e.g. the inventory)
self.itemName = itemName # The filename of the icon
self.image = None # The actual icon
#self.iconNode = aspect2d.attachNewNode('iconnode')
self.LoadContent()
def LoadContent(self):
self.itemImage = OnscreenImage(image = "Assets/Images/Items/%s.png" % (self.itemName))
self.itemImage.setScale((self.itemImage.getTexture().getOrigFileXSize() / 1024.0, 1, self.itemImage.getTexture().getOrigFileYSize() / 1024.0))
self.itemImage.setTransparency(TransparencyAttrib.MAlpha)
self.itemImage.reparentTo(self.parentNode)
def setBin(self, binType, value):
print 'set bin', binType, value
self.itemImage.setBin(binType, value)
def SetPos(self, pos):
self.itemImage.setPos(pos)
def Destroy(self):
self.itemImage.destroy()
def clear(self,fadeout = 0,bgfile = None):
self.clearQuickItems()
if not fadeout:
self.itemEntries.clear()
self.reload()
else:
dr = self.camera.node().getDisplayRegion(0)
texture = dr.getScreenshot()
w = dr.getPixelWidth()
h = dr.getPixelHeight()
self.itemEntries.clear()
self.reload()
if bgfile:
bgentry = StoryViewItemEntry(fileName = bgfile,key = '__bg__',category = SVIC.BG)
self.newItem(bgentry)
tempbg = OnscreenImage(texture)
if w > h:
tempbg.setScale(1*w/float(h),1,1)
else: tempbg.setScale(1,1,1*h/float(w))
tempbg.setColor(1,1,1,1)
tempbg.reparentTo(self.bgNodePath)
tempbg.setName('__tempbg__')
li = LerpColorInterval(tempbg, fadeout, (1,1,1,0), (1,1,1,1),blendType = 'easeInOut' )
self._intervals.append(li)
li.start()
def LoadImage(self, filename, parent):
myImage = OnscreenImage(image = 'Assets/Images/HUD/%s' % (filename))
myImage.setTransparency(TransparencyAttrib.MAlpha)
myImage.reparentTo(parent)
myImage.setScale((myImage.getTexture().getOrigFileXSize() / 1024.0, 1, myImage.getTexture().getOrigFileYSize() / 1024.0))
myImage.hide()
return myImage
def makeOnscreenVariable(self,fileName,x,y,z,width,height):
imageVariable = OnscreenImage(image = fileName)
imageVariable.reparentTo(pixel2d)
imageVariable.setPos(x,y,z)
imageVariable.setScale(width,1,height)
#probably needs an include of some sort
imageVariable.setTransparency(TransparencyAttrib.MAlpha)
return imageVariable
def generate2DArrows(self,arrowList):
self.movingArrows =[None] * self.FULLSCORE
for i in range(len(arrowList)):
imagePath = self._2DdownArrow
if(arrowList[i].type == 'l'):
imagePath = self._2DrightArrow
arrow=OnscreenImage(image = imagePath, pos = (0.3, 0, 0))
arrow.setTransparency(TransparencyAttrib.MAlpha)
arrow.setScale(0.1)
x,y,z=-0.6,0,0
startX,startY,startZ=x+arrowList[i].getExpectedTime(),y,z
arrow.setPos(startX,startY,startZ)
arrow.reparentTo(self.getPanel('dance').getItem('GUIarrows'))
arrow.hide()
self.movingArrows[i] = arrow
def loadGUI(self):
self.vidas_imgs = list()
w = 0.24
for i in range(self.VIDAS):
image_warning = OnscreenImage(image = '../data/Texture/signal_warning.png', pos=(-1 + i*w, 0, 0.85), parent=self._playing_node2d)
image_warning.setScale(0.1)
image_warning.setTransparency(TransparencyAttrib.MAlpha)
image_warning.hide()
image_ok = OnscreenImage(image = '../data/Texture/signal_ok.png', pos=(-1 + i*w, 0, 0.85), parent=self._playing_node2d)
image_ok.setScale(0.1)
image_ok.setTransparency(TransparencyAttrib.MAlpha)
image_ok.show()
self.vidas_imgs.append((image_ok, image_warning))
self._level_time_O = OnscreenText(text = '', pos = (0, 0.85), scale = 0.14, fg=(1.0, 1.0, 1.0, 1.0), bg=(0.0, 0.0, 0.0, 1.0), parent=self._playing_node2d)
def __init__(self):
ShowBase.__init__(self)
imageObject = OnscreenImage(image='me.png', pos=(-0.5, 0, 0.02))
# Reparent the model to render.
imageObject.reparentTo(self.render)
# Apply scale and position transforms on the model.
imageObject.setScale(10, 10, 10)
imageObject.setPos(0, 42, 0)
car = OnscreenImage(image="car.png", pos=(0,0,0))
car.reparent_to(self.render)
car.setScale(3, 3, 3)
car.setPos(0, 41, 0)
self.accept('arrow_left-up', self.car_go_left, [car])
self.accept('arrow_right-up', self.car_go_right, [car])
class HUD():
def __init__(self):
self.speedometer = OnscreenImage(image = 'img/speedometerDial.png', pos = (-1, 0, -.7) )
self.speedometer.setScale(.25)
self.speedometer.setTransparency(TransparencyAttrib.MAlpha)
self.speedPin = OnscreenImage(image = 'img/speedometerNeedle.png', pos = (-1, 0, -.7))
self.speedPin.setScale(.10)
self.speedPin.setTransparency(TransparencyAttrib.MAlpha)
self.speedPin.setHpr(0, 0, 0)
self.minimap = OnscreenImage(image = 'img/minimap.png', pos = (1.05, 0, -.65))
self.minimap.setScale(.19, .19, .3)
self.dot = OnscreenImage(image = 'img/dot.png', pos = (1.01, 0, -.55))
self.dot.setScale(.025)
font1 = loader.loadFont('img/goodfish.ttf')
self.lapText = OnscreenText(text = "0/10", font = font1, pos = (1, -.1, 0), fg = (1, 1, 1, 1) )
self.lapText.setScale(.05)
self.placeText = OnscreenText(text = "", font = font1, pos = (1, -.2, 0), fg = (1, 1, 1, 1))
self.placeText.setScale(.05)
self.timerText = OnscreenText(text = "Time: ", font = font1, pos = (1, -.3, 0), fg = (1, 1, 1, 1))
def update(self, velocity, x, y, laps, place, time):
if velocity < 0:
velocity = -velocity
self.dot.setPos(1.01+(x/4250), 0, -.55+(y/4250))
self.lapText.setText("Laps: " + str(laps)+"/3")
self.speedPin.setHpr(0, 0, 4*velocity)
self.placeText.setText("Position: "+str(place))
self.timerText.setText("Time: "+ str(round(time)))
"""def getDist(self, x, y, checkpoint):
cx = checkpoint[0]
cy = checkpoint[1]
dist = math.sqrt((cx-x)**2 + (cy-y)**2)
rotAngle = math.atan2(-y,x)
newX = x*math.cos(rotAngle) - y*math.sin(rotAngle)
dToCheckpoint = dist - newX
return dToCheckpoint"""
"""def updateMiniMap(self, x, y):
self.dot.setPos(1+(x/1000), 0, -.7+(y/1000))"""
def shoot():
bala = self.particlesDummy.attachNewNode("balaDummy")
balaImage = OnscreenImage(image="prova/textures/bala.png", parent=bala)
balaImage.setTransparency(1)
balaImage.setScale(0.1, 1.0, 0.2)
balaImage.setBillboardPointEye()
bala.setQuat(self.modelAvio.getQuat(render))
if self.balaPositiu:
bala.setPos(self.balaDreta.getPos(render))
self.balaPositiu = False
else:
bala.setPos(self.balaEsquerra.getPos(render))
self.balaPositiu = True
balaSphere = bala.attachNewNode(self.balaCol)
balaColHandler = CollisionHandlerQueue()
base.cTrav.addCollider(balaSphere, balaColHandler)
# ~ if type(self.shootPoint) == 'libpanda.Point3':
# ~ bala.lookAt(self.shootPoint)
# ~ else: bala.setH(bala, 180.)
taskMgr.add(mouBala, "moubala", extraArgs=[bala, balaImage, self.BALA_VEL, balaColHandler], appendTask=True)
class Menu(DirectObject):
def __init__(self):
self.title = OnscreenImage(image = 'img/titleScreen.png', pos = (0, 0, 0) )
self.pointer = OnscreenImage(image = 'img/titleSelector.png', pos = (-.2, 0 ,-.63))
self.pointer.setScale(.05)
self.start = False
self.instructions = False
self.pointerPosition = 1
self.pointer.setTransparency(TransparencyAttrib.MAlpha)
self.accept("enter", self.screenHandler)
self.accept("arrow_up", self.movePointerUp)
self.accept("arrow_down", self.movePointerDown)
self.accept("backspace", self.back)
self.accept("escape", sys.exit)
def screenHandler(self):
if self.pointerPosition == 1:
self.start = True
self.title.destroy()
self.pointer.destroy()
else:
self.instructions = True
self.title.setImage('img/instructions.png')
def back(self):
if self.instructions == True:
self.instructions = False
self.title.setImage('img/titleScreen.png')
self.pointer.setImage('img/titleSelector.png')
def movePointerUp(self):
if self.pointerPosition == 2:
self.pointer.setPos(-.2, 0, -.63)
self.pointerPosition = 1
def movePointerDown(self):
if self.pointerPosition == 1:
self.pointer.setPos(-.2, 0, -.8)
self.pointerPosition = 2
def destroy(self):
self.ignoreAll()
class Cursor:
def __init__(self, path, scale, hotspot):
if not path:
return
self.__set_standard_curson(False)
self.cursor_img = OnscreenImage(path)
self.cursor_img.setTransparency(True)
self.cursor_img.setScale(scale)
self.cursor_img.setBin('gui-popup', 50)
self.hotspot_dx = scale[0] * (1 - 2 * hotspot[0])
self.hotspot_dy = scale[2] * (1 - 2 * hotspot[1])
eng.event.attach(self.on_frame)
def __set_standard_curson(self, show):
props = WindowProperties()
props.setCursorHidden(not show)
base.win.requestProperties(props)
def show(self):
self.cursor_img.show()
def show_standard(self):
self.__set_standard_curson(True)
def hide(self):
self.cursor_img.hide()
def hide_standard(self):
self.__set_standard_curson(False)
def cursor_top(self):
self.cursor_img.reparent_to(self.cursor_img.get_parent())
def on_frame(self):
if base.mouseWatcherNode.hasMouse():
x = base.mouseWatcherNode.getMouseX()
y = base.mouseWatcherNode.getMouseY()
h_x = x * base.getAspectRatio() + self.hotspot_dx
self.cursor_img.setPos(h_x, 0, y - self.hotspot_dy)
class TestApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.set_background_color(0.1137, 0.1450, 0.1725)
self.disable_mouse()
self.mire = OnscreenImage(image=os.path.join(MAINDIR, 'test.jpeg'))
self.mire.setScale(1.6, 1, 1)
self.mire.hide()
self.is_shown = False
command_dic = {"toggleImage": self.toggleImage}
self.commandline = pconsole.Console()
self.commandline.create(command_dic, app=self, event='f1')
self.task_mgr.add(self.update, "updatingTask")
def update(self, task):
return task.cont
def toggleImage(self):
if self.is_shown:
self.mire.hide()
else:
self.mire.show()
self.is_shown = not self.is_shown
class KeyValue(object):
weaponOverHeat = 5
time = 0
step = False
curScale = 0
fireRight = True
fireLeft = False
delayShot = 0
def __init__(self, camera, id):
self.audio3d = Audio3DManager(base.sfxManagerList[0], base.camera)
#load the other keyValue texture
keyTexRed = base.loader.loadTexture("resources/tex/keyValueRed.png")
#Set model and projectile paths
self.gunPath1 = NodePath("gun")
self.gunPath1.reparentTo(base.camera)
self.gunPath1.setPos(1.2 ,10,-3.5)
self.gunModel1 = loader.loadModel("./resources/keyValue")
self.gunModel1.setTexture(keyTexRed,1)
self.gunModel1.reparentTo(self.gunPath1)
self.gunModel1.setPos(camera,1.2,4.5,-1.7)
self.gunModel1.setHpr(-90,0,0)
self.gunPath2 = NodePath("gun")
self.gunPath2.reparentTo(base.camera)
self.gunPath2.setPos(-1.2,10,-3.5)
self.gunModel2 = loader.loadModel("./resources/keyValue")
self.gunModel2.reparentTo(self.gunPath2)
self.gunModel2.setPos(camera,-1.2,4.5,-1.7)
self.gunModel2.setHpr(-90,0,0)
self.reticle = OnscreenImage("./resources/kvReticle.png")
self.reticle.setTransparency(True)
self.reticle.setScale(0)
base.taskMgr.add(self.animate, "kvReticle")
def hide(self):
self.reticle.setScale(0)
self.gunModel1.hide()
self.gunPath1.hide()
self.gunModel2.hide()
self.gunPath2.hide()
def show(self):
self.gunModel1.show()
self.gunPath1.show()
self.gunModel2.show()
self.gunPath2.show()
def fire(self, task):
#Fires left or right
if self.fireRight:
#Spawn projectile, add it to taskMgr and play sfx
proj = KVProjectile(self.gunPath1, base.camera, len(base.projectileList))
proj.projectileModel.setColor(0, 0, 255)
base.taskMgr.add(proj.moveTask, "move projectile")
base.projectileList.append(proj)
shotSfx = self.audio3d.loadSfx("./resources/sounds/key_value.wav")
self.audio3d.attachSoundToObject(shotSfx, base.camera)
shotSfx.play()
self.fireRight = False
self.fireLeft = True
else:
#Spawn projectile, add it to taskMgr and play sfx
proj = KVProjectile(self.gunPath2, base.camera, len(base.projectileList))
proj.projectileModel.setColor(255, 0, 0)
base.taskMgr.add(proj.moveTask, "move projectile")
base.projectileList.append(proj)
shotSfx = self.audio3d.loadSfx("./resources/sounds/key_value.wav")
self.audio3d.attachSoundToObject(shotSfx, base.camera)
shotSfx.play()
self.fireRight = True
self.fireLeft = False
base.player.overHeat += self.weaponOverHeat
self.delayShot = task.time + .1
base.taskMgr.add(self.contTask, "weaponDelay")
def contTask(self, task):
return task.cont
def animate(self, task):
if task.time - self.time > .05:
self.reticle.setScale(self.curScale)
if self.curScale < .03 and self.step:
self.curScale += .001
self.reticle.setScale(self.curScale)
self.time = task.time
if self.curScale >= .03:
self.step = False
elif self.curScale > .01:
self.curScale -= .001
self.reticle.setScale(self.curScale)
self.time = task.time
if self.curScale <= .01:
self.step = True
return task.cont
def canShoot(self):
taskList = base.taskMgr.getTasksNamed("weaponDelay")
if taskList[0].time >= self.delayShot:
return True
else:
return False
def getOverHeat(self):
return self.overheat
def resetWeapon(self):
delayShot = 0
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
def __init__(self):
self.points = 0
self.timersecs = 60
self.duration = 0
self.ncandy = 0
self.runralph = 0
self.gamepause = 0
self.picked = 0
self.bg = loader.loadSfx("./sounds/faster_than_all.ogg")
self.bg.setLoop(True)
self.bg.setVolume(0.3)
self.bgcount = loader.loadSfx("./sounds/panic.ogg")
self.bgcount.setLoop(False)
self.bgcount.setVolume(1)
self.playBG()
butaicon = OnscreenImage(image = './GUI/smiley1.png', pos = (0.66, 0, 0.85))
butaicon.setScale(0.12,0,0.11)
butaicon.setTransparency(TransparencyAttrib.MAlpha)
tpButa = TextProperties()
tpButa.setTextColor(1,1,1,1)
butafont = loader.loadFont('./GUI/fonts/butafont.ttf')
tpButa.setFont(butafont)
tpButa.setShadow(0.05, 0.05)
tpButa.setShadowColor(0,0,0,1)
tpMgr = TextPropertiesManager.getGlobalPtr()
tpMgr.setProperties("buta", tpButa)
tpMenu = TextProperties()
tpMenu.setTextColor(1,0.6,0.75,1)
tpMenu.setFont(butafont)
tpMenu.setShadow(0.05, 0.05)
tpMenu.setShadowColor(1,0.8,0.9,1)
tpMgr.setProperties("menu", tpMenu)
#Add candy number
self.candy = TextNode('Candy Number')
self.candy.setText("\1buta\1x "+str(self.ncandy)+" \2")
self.candynumNP = aspect2d.attachNewNode(self.candy)
self.candynumNP.setScale(0.18)
self.candynumNP.setPos(0.79, 0, 0.8)
#Add points number
self.ptnum = TextNode('Pt Number')
self.ptnum.setText("\1buta\1Pt. "+str(self.points)+" \2")
self.ptnumNP = aspect2d.attachNewNode(self.ptnum)
self.ptnumNP.setScale(0.18)
self.ptnumNP.setPos(-1.31, 0, 0.8)
#Add record number
recordfile = open("candyrecord.dat","r")
self.record = int(recordfile.read())
recordfile.close()
self.rcnum = TextNode('Record Number')
self.rcnum.setText("\1buta\1Record \n"+str(self.record)+" \2")
self.rcnumNP = aspect2d.attachNewNode(self.rcnum)
self.rcnumNP.setScale(0.11)
self.rcnumNP.setPos(-1.38, 0, 0.65)
self.rcnum.setWordwrap(4.5)
#Add timer
self.timer = TextNode('Timer')
self.timer.setText("\1buta\1 "+str(self.timersecs/60)+":00 \2")
self.timerNP = aspect2d.attachNewNode(self.timer)
self.timerNP.setScale(0.18)
self.timerNP.setPos(0.9,0,-0.93)
self.itemset = {"musicon":loader.loadTexture('./GUI/soundon.png'),"musicoff":loader.loadTexture('./GUI/soundoff.png'),}
self.itembox = DirectButton(image=self.itemset["musicon"], scale=.10, pos=(-1.19,0,-0.82), relief=None, state=DGG.NORMAL, command=self.changemusic, clickSound=None)
self.itembox.setScale(0.15)
self.itembox.setTransparency(TransparencyAttrib.MAlpha)
class Myapp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.accept("escape", sys.exit)
self.accept("mouse1", self.startShoot)
self.accept("mouse1-up", self.endShoot)
base.disableMouse()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.heading = 0
self.pitch = 0
self.mousex = 0
self.mousey = 0
self.flight = []
self.cs_flight = []
self.explosion = []
self.score = 0
self.life = 20
self.m1down = 1
self.environ = self.loader.loadModel("models/terrain")
self.environ.reparentTo(self.render)
self.environ.setScale(0.8, 0.8, 0.8)
self.environ.setPos(0, 0, -10)
self.environ.setHpr(-90, 0, 0)
for k in range(0, 5):
self.flight.append(self.loader.loadModel("models/spitfire"))
self.flight[k].reparentTo(self.render)
self.flight[k].setScale(0.1, 0.1, 0.1)
self.flight[k].setPos(randint(-40, 20), randint(300, 400),
randint(10, 20))
self.cs_flight.append(self.flight[k].attachNewNode(
CollisionNode(str(k))))
self.cs_flight[k].node().addSolid(CollisionSphere(0, 0, 5, 30))
#self.cs_flight[k].show()
self.flight[k].setCollideMask(BitMask32.bit(1))
self.bullets = []
self.crosshair = OnscreenImage(image='models/crosshair.png',
pos=(0, 0, 0))
self.crosshair.setScale(0.03, 0.03, 0.03)
self.crosshair.setTransparency(TransparencyAttrib.MAlpha)
self.title = OnscreenText(" ",
style=1,
fg=(1, 1, 1, 1),
pos=(0, 0),
scale=.07)
self.taskMgr.add(self.mouse_control, "mouse_control")
self.taskMgr.add(self.update_flight, "update_flight")
self.picker = CollisionTraverser()
self.pq = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(BitMask32.bit(1))
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.picker.addCollider(self.pickerNP, self.pq)
self.gun = OnscreenImage(image='models/gun.png', pos=(0.24, 0, -0.54))
self.gun.setScale(1, 0.6, 0.6)
self.gun.setTransparency(TransparencyAttrib.MAlpha)
self.sound = base.loader.loadSfx("models/sound.ogg")
base.setFrameRateMeter(True)
def mouse_control(self, task):
md = base.win.getPointer(0)
x = md.getX()
y = md.getY()
if base.win.movePointer(0, 100, 100):
self.heading = self.heading - (x - 100) * 0.1
self.pitch = self.pitch - (y - 100) * 0.1
if (self.pitch < -10): self.pitch = -10
if (self.pitch > 20): self.pitch = 20
if (self.heading < -40): self.heading = -40
if (self.heading > 30): self.heading = 30
base.camera.setHpr(self.heading, self.pitch, 0)
return Task.cont
def update_flight(self, task):
i = 0
while (i < len(self.flight)):
x = self.flight[i].getY()
if x < -3:
self.flight[i].setPos(randint(-40, 20), randint(200, 300),
randint(10, 20))
if (self.life == 0):
self.game_end()
else:
self.life -= 1
else:
x -= 0.7
self.flight[i].setPos(self.flight[i].getX(), x,
self.flight[i].getZ())
i += 1
self.title.destroy()
self.title = OnscreenText(text='Life: ' + str(self.life) + ' Score: ' +
str(self.score),
style=1,
fg=(1, 1, 1, 1),
pos=(-1.5, 0.9),
scale=.07)
return Task.cont
def removeBullet(self, task):
if len(self.bullets) < 1: return
self.bulletNP = self.bullets.pop(0)
self.bulletNP.removeNode()
return task.done
def shootBullet(self, task):
self.ball = self.loader.loadModel("models/bullet")
self.ball.reparentTo(self.render)
self.ball.setScale(0.02, 0.02, 0.02)
self.ball.setPos(0, 0, 0)
self.bullets.append(self.ball)
self.bt = ProjectileInterval(self.ball,
startPos=Point3(0, 0, -5),
endPos=Point3(self.heading * -2, 100,
self.pitch * 2),
duration=0.3,
gravityMult=-2)
self.bt.start()
self.taskMgr.doMethodLater(0.3, self.removeBullet, 'removeBullet')
self.hit_flight()
if (self.m1down):
self.taskMgr.doMethodLater(0.2, self.shootBullet, 'shootbullet')
def hit_flight(self):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, 0, 0)
self.picker.traverse(render)
if self.pq.getNumEntries() > 0:
self.pq.sortEntries()
pickedObj = self.pq.getEntry(0).getIntoNodePath()
if pickedObj.getName() != 'CINEMA4D_Mesh':
k = int(pickedObj.getName())
self.score += 1
self.explode(self.flight[k].getX(), self.flight[k].getY(),
self.flight[k].getZ())
self.flight[k].setPos(randint(-40, 20), randint(200, 300),
randint(10, 20))
def game_end(self):
self.crosshair.remove()
self.gov = OnscreenText("Game Over",
style=1,
fg=(1, 1, 1, 1),
pos=(0, 0),
scale=0.07)
self.taskMgr.remove("mouse_control")
self.taskMgr.remove("update_flight")
#self.explode(20,20,20)
p = open('score.txt', 'r')
score = p.readline()
p.close()
if (self.score > int(score)):
p = open('score.txt', 'w')
p.write(str(self.score))
p.close()
def explode(self, x, y, z):
k = len(self.explosion)
self.explosion.append(loader.loadModel('explosion/flip.egg'))
self.explosion[k].reparentTo(self.render)
self.explosion[k].setPos(x, y, z)
self.explosion[k].setScale(5, 5, 5)
self.taskMgr.doMethodLater(0.6, self.removeExplosion, 'removeExp')
def removeExplosion(self, task):
if len(self.explosion) < 1: return
self.explosion[0].removeNode()
del self.explosion[0]
return task.done
def endShoot(self):
self.m1down = 0
self.sound.stop()
def startShoot(self):
self.sound.play()
self.m1down = 1
self.taskMgr.doMethodLater(0.1, self.shootBullet, 'shootbullet')
class World(ShowBase):
def __init__(self):
base.win.setClearColor(Vec4(0,0,0,1))
# Game state variables
self.showHelp = False
self.showMenu = True
self.isLevel1 = False
self.isLevel2 = False
self.characterClass = 0
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[Left Arrow]: Rotate Left")
self.inst3 = addInstructions(0.85, "[Right Arrow]: Rotate Right")
self.inst4 = addInstructions(0.80, "[Up Arrow]: Run Forward")
self.inst5 = addInstructions(0.75, "[Down Arrow]: Run Backward")
self.inst6 = addInstructions(0.70, "[Shift + Up Arrow]: Speed up Running Forward")
self.inst7 = addInstructions(0.65, "[Shift + Down Arrow]: Speed up Running Backward")
self.inst8 = addInstructions(0.60, "[CTRL]: Hit the Enemy")
self.inst9 = addInstructions(0.55, "[Space]: Jump")
self.inst10 = addInstructions(0.50, "[D]: Show / Hide Debug")
self.inst11 = addInstructions(0.45, "[A]: Rotate Camera Left")
self.inst12 = addInstructions(0.40, "[S]: Rotate Camera Right")
self.inst13 = addInstructions(0.35, "[H]: Show/ Hide Help")
self.inst14 = addInstructions(0.30, "[Enter]: Show/ Hide Menu")
inputState.watchWithModifiers('forward', 'arrow_up')
inputState.watchWithModifiers('reverse', 'arrow_down')
inputState.watchWithModifiers('turnLeft', 'arrow_left')
inputState.watchWithModifiers('turnRight', 'arrow_right')
inputState.watchWithModifiers('rotateCamLeft', 'a')
inputState.watchWithModifiers('rotateCamRight', 's')
inputState.watchWithModifiers('jump', 'space')
inputState.watchWithModifiers('speedUp', 'shift')
inputState.watchWithModifiers('hit', 'control')
inputState.watchWithModifiers('debug', 'd')
inputState.watchWithModifiers('help', 'h')
inputState.watchWithModifiers('menu', 'enter')
self.accept("escape", sys.exit)
#Background music
self.mySound = base.loader.loadSfx("sound/Ancient Egyptian Music - Dark Pyramid.mp3")
#Menu
self.imageObject = OnscreenImage(image = 'models/menu.jpg', pos = (0, 0, 0))
self.imageObject.setScale(2,1,1)
self.b1 = DirectButton(text = "Play Level 1", scale=.07, command=self.setLevel1, pos=(0,0,0.2),text_shadow =(0,0,0,0.9), text_bg=(0, 0, 0, 1),text_fg = (1,1,1,1))
self.b2 = DirectButton(text = "Play Level 2", scale=.07, command=self.setLevel2, pos=(0.0,0,0),text_shadow =(0,0,0,0.9), text_bg=(0, 0, 0, 1),text_fg = (1,1,1,1))
self.b3 = DirectButton(text = "Exit", scale=.07, command=sys.exit, pos=(0,0,-0.2),text_shadow =(0,0,0,0.9),text_bg=(0, 0, 0, 1),text_fg = (1,1,1,1))
taskMgr.add(self.update, 'updateMain')
base.disableMouse()
# 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 setLevel1(self):
if self.isLevel1 == True or self.isLevel2 == True:
self.characterClass.removeAll()
self.showMenu = False
self.characterClass = Character()
base.camera.setPos(self.characterClass.characterNP.getX(),self.characterClass.characterNP.getY()+15,5)
base.camera.setHpr(self.characterClass.characterNP.getHpr())
base.camera.lookAt(self.characterClass.characterNP)
self.isLevel1 = True
self.isLevel2 = False
def setLevel2(self):
if self.isLevel1 == True or self.isLevel2 == True:
self.characterClass.removeAll()
self.showMenu = False
self.characterClass = Character2()
base.camera.setPos(self.characterClass.characterNP.getX(),self.characterClass.characterNP.getY()+15,5)
base.camera.setHpr(self.characterClass.characterNP.getHpr())
base.camera.lookAt(self.characterClass.characterNP)
self.isLevel2 = True
self.isLevel1 = False
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
class World(DirectObject):
def __init__(self):
self.start = False
self.mainScreen = OnscreenImage(image = 'mainScreen.png')
#self.mainScreen.setScale(1.25)
self.accept("mouse1", self.begin)
def begin(self):
if self.start == False:
self.start = True
self.mainScreen.destroy()
self.__init__1()
def __init__1(self):
#load physics
base.enableParticles()
#create a traverser
base.cTrav = CollisionTraverser()
self.cevent = CollisionHandlerEvent()
self.cevent.addInPattern('into-%in')
self.cevent.addOutPattern('outof-%in')
#load all the models
self.w_terrain = Terrain()
self.p_bike = PlayerBike(base.cTrav)
#disable mouse
base.disableMouse()
self.dead = False
self.deadCount = 0
taskMgr.add(self.gameOverDead, 'deadTask')
self.win = False
self.winCount = 0
taskMgr.add(self.gameOverWin, 'winTask')
#load and play background sound
backgroundSound = base.loader.loadSfx('Modern_Battlefield.mp3')
backgroundSound.setLoop(True)
backgroundSound.play()
#parent the camera to the player bike and offset the initial location
base.camera.reparentTo(self.p_bike.bike)
base.camera.setZ(6)
base.camera.setP(-8)
base.camera.setY(-32)
#set up accept tasks
#close the game
self.accept("escape", sys.exit)
#handle movement
self.accept("arrow_up", self.p_bike.setDirection, ["forward", 1])
self.accept("arrow_right", self.p_bike.setDirection, ["right", 1])
self.accept("arrow_left", self.p_bike.setDirection, ["left", 1])
self.accept("arrow_up-up", self.p_bike.setDirection, ["forward", 0])
self.accept("arrow_right-up", self.p_bike.setDirection, ["right", 0])
self.accept("arrow_left-up", self.p_bike.setDirection, ["left", 0])
#handle shooting
#self.accept("space", self.p_bike.setShoot, [1])
#self.accept("space-up", self.p_bike.setShoot, [0])
self.accept("z", self.p_bike.setShoot, [1])
self.accept("z-up", self.p_bike.setShoot, [0])
#powerup collisions
self.accept("p_bike-powerup1", self.powerupCollision)
self.accept("p_bike-powerup2", self.powerupCollision)
self.accept("p_bike-powerup3", self.powerupCollision)
self.accept("p_bike-powerup4", self.powerupCollision)
self.accept("p_bike-powerup5", self.powerupCollision)
#bullet collision with player
self.accept("p_bike-bullet", self.bulletCollision)
self.accept("e_bike-bullet", self.bulletCollision)
#setup basic environment lighting
self.ambientLight = AmbientLight("ambientLight")
self.ambientLight.setColor((.25, .25, .25, 1))
self.ambientLightNP = render.attachNewNode(self.ambientLight)
render.setLight(self.ambientLightNP)
render.setShaderAuto()
self.playerHealth = OnscreenImage(image = 'PlayerHealthBar.png')
self.playerHealth.setX(-1)
self.playerHealth.setZ(-1.95)
#enemy health
self.enemyHealth = OnscreenImage(image = 'EnemyHealthBar.png')
self.enemyHealth.setX(1)
self.enemyHealth.setZ(-1.95)
self.initAI()
self.e_bikes = [self.addEnemy()]
base.cTrav.addCollider(self.p_bike.cNodePath1, self.e_bikes[0].cevent)
def gameOverDead(self, task):
if self.dead == True:
self.deadCount += 1
if self.deadCount > 200:
self.gameOver = OnscreenImage(image = 'gameOver.png')
self.gameOver.setScale(1.35)
return Task.cont
def gameOverWin(self, task):
if self.win == True:
self.winCount += 1
if self.winCount > 200:
self.gameOverWin = OnscreenImage(image = 'win.png')
self.gameOverWin.setScale(1.35)
return Task.cont
def powerupCollision(self, cEntry):
#check powerup1
if cEntry.getIntoNodePath() == self.w_terrain.cPowerNode1Path:
self.w_terrain.powerUp1 = False
self.p_bike.invin = True
#print('I WIN')
#check powerup2
elif cEntry.getIntoNodePath() == self.w_terrain.cPowerNode2Path:
self.w_terrain.powerUp2 = False
self.p_bike.shotgun = True
self.p_bike.p_up_timer = 0
#check powerup3
elif cEntry.getIntoNodePath() == self.w_terrain.cPowerNode3Path:
self.w_terrain.powerUp3 = False
self.p_bike.shotgun = True
self.p_bike.p_up_timer = 0
#check power4
elif cEntry.getIntoNodePath() == self.w_terrain.cPowerNode4Path:
self.w_terrain.powerUp4 = False
self.p_bike.health_up = True
#check powerup5
elif cEntry.getIntoNodePath() == self.w_terrain.cPowerNode5Path:
self.w_terrain.powerUp5 = False
self.p_bike.health_up = True
cEntry.getIntoNodePath().remove()
def bulletCollision(self, cEntry):
#check which bike is being hit
if self.p_bike.invin == False and (cEntry.getFromNodePath() == self.p_bike.cNodePath1 or cEntry.getFromNodePath() == self.p_bike.cNodePath1 or cEntry.getFromNodePath() == self.p_bike.cNodePath3):
#print('player bike!')
self.p_bike.hp -= 1
self.playerHealth.setX(self.playerHealth.getX() - .1)
#print('player hp:', self.p_bike.hp)
if self.p_bike.hp <= 0:
#kill player bike and reset camera
taskMgr.remove("moveTask")
taskMgr.remove("bulletTask")
taskMgr.remove("shootTask")
taskMgr.remove("powerupTask")
x = base.camera.getX() + self.p_bike.bike.getX()
y = base.camera.getY() + self.p_bike.bike.getY()
h = self.p_bike.bike.getH()
angle = deg2Rad(self.p_bike.bike.getH())
dy = -math.cos(angle)
dx = math.sin(angle)
dx = -dx * 32
dy = -dy * 32
base.camera.reparentTo(render)
base.camera.setPos(0,0,0)
base.camera.setPosHpr( self.p_bike.bike.getX() - dx, self.p_bike.bike.getY() - dy, 7, self.p_bike.bike.getH(), -8, 0)
x = self.p_bike.bike.getX()
y = self.p_bike.bike.getY()
z = self.p_bike.bike.getZ()
h = self.p_bike.bike.getH()
self.p_bike.bike.delete()
self.death_player = Actor("moto2_deadActor.egg", {"death":"moto2_deadAnim.egg"})
self.death_player.reparentTo(render)
self.death_player.setPos(x,y,z)
self.death_player.setH(h)
self.animcontrol = self.death_player.getAnimControl('death')
self.death_player.play("death")
self.dead = True
#UNCOMMENT WHEN ENEMY BIKES ARE FIXED
else:
for enemy in self.e_bikes:
#print('in enemy list')
#print(cEntry.getFromNodePath())
#print(cEntry.getFromNodePath().getParent())
#print(cEntry.getFromNodePath().getParent())
#print(enemy.cNodePath)
#print(cEntry.getIntoNodePath())
#print(cEntry.getIntoNodePath().getParent())
if cEntry.getFromNodePath() == enemy.cNodePath1 or cEntry.getFromNodePath() == enemy.cNodePath2 or cEntry.getFromNodePath() == enemy.cNodePath3:
#print('enemy hit')
enemy.hp -= 1
self.enemyHealth.setX(self.enemyHealth.getX() + .1)
#print('enemy hp:', enemy.hp)
if enemy.hp <= 0:
#print('Game Over. You Win!')
#kill enemy bike
x = enemy.cNodePath.getParent().getX()
y = enemy.cNodePath.getParent().getY()
z = enemy.cNodePath.getParent().getZ()
h = enemy.cNodePath.getParent().getH()
#print(x,y,z,h)
enemy.cNodePath.getParent().remove()
self.death_enemy = Actor("moto1_deadActor.egg", {"death":"moto1_deadAnim.egg"})
self.death_enemy.reparentTo(render)
self.death_enemy.setPos(x,y,z)
self.death_enemy.setH(h)
self.death_enemy.play("death")
self.win = True
break
#destroy the bullet
for i in range(len(self.p_bike.bullet.bulletList)):
if cEntry.getIntoNodePath().getParent() == self.p_bike.bullet.bulletList[i]:
#print('erased')
self.p_bike.bullet.bulletTime.remove(self.p_bike.bullet.bulletTime[i])
self.p_bike.bullet.bulletList.remove(self.p_bike.bullet.bulletList[i])
cEntry.getIntoNodePath().getParent().remove()
break
#UNCOMMENT WHEN ENEMY BIKES ARE FIXED
#cycle through the enemy bullets
for enemy in self.e_bikes:
for i in range(len(enemy.bullet.bulletList)):
if cEntry.getIntoNodePath().getParent() == enemy.bullet.bulletList[i]:
#print('erased')
enemy.bullet.bulletTime.remove(enemy.bullet.bulletTime[i])
enemy.bullet.bulletList.remove(enemy.bullet.bulletList[i])
cEntry.getIntoNodePath().getParent().remove()
break
def initAI(self):
self.AIworld = AIWorld(render)
#self.AIworld.addObstacle(self.w_terrain.wall_terrain)
#self.AIworld.addObstacle(self.w_terrain.cNodePathWall1)
#self.AIworld.addObstacle(self.w_terrain.cNodePathWall2)
#self.AIworld.addObstacle(self.w_terrain.cNodePathWall3)
#self.AIworld.addObstacle(self.w_terrain.cNodePathWall4)
#self.AIworld.addObstacle(self.w_terrain.bounds)
#AI World update
taskMgr.add(self.AIUpdate,"AIUpdate")
def AIUpdate(self, task):
self.AIworld.update()
for i in self.e_bikes:
i.update()
i.bike.setHpr(i.bike.getH(), 0, i.bike.getR())
#i.bike.setZ(max(0.0, i.bike.getZ()))
#i.bike.setZ(0.0)
#print i.bike.getHpr()
return Task.cont
def addEnemy(self):
enemy = EnemyBike(base.cTrav, self.cevent)
enemy.target = self.p_bike
enemy.setMode('scan')
self.AIworld.addAiChar(enemy.AIchar)
base.cTrav.addCollider(self.p_bike.cNodePath1, enemy.cevent)
return enemy
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
class Menu (DirectObject):
def __init__(self, cursor):
#-----------------------------------------------------------------------------------------------------------------------------------------------
#---------------------------------------------------VARIABLE DECLARATION------------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
self.title = None
self.play = None
self.credits = None
self.ins = None
self.selected = "PLAY"
self.pastTime = 0.0
self.oldX = 0.0
self.run = True
self.moved = 0.0
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------MENU INIT----------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
self.title = OnscreenImage("./tex/menu/glooveth.png", (0, 0, -0.25), None, (1.0,1.0,0.25), None, None, 10)
self.title.setTransparency(TransparencyAttrib.MAlpha)
self.credits = OnscreenImage("./tex/menu/credits.png", (-1.0, 0, -0.75), None, (0.25,1.0,0.125), None, None, 10)
self.credits.setTransparency(TransparencyAttrib.MAlpha)
self.ins = OnscreenImage("./tex/menu/ins.png", (1.0, 0, -0.75), None, (0.25,1.0,0.125), None, None, 10)
self.ins.setTransparency(TransparencyAttrib.MAlpha)
self.play = OnscreenImage("./tex/menu/playOver.png", (0, 0, -0.75), None, (0.35,1.0,0.20), None, None, 10)
self.play.setTransparency(TransparencyAttrib.MAlpha)
# Cursor
self.cursor = cursor
# Start tasks
taskMgr.add(self.taskMenuMovement, 'taskMenuMovement')
#end __init__
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------FUNCTIONS----------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# It hides the main menu of the game
def hide(self):
self.title.hide()
self.play.hide()
self.credits.hide()
self.ins.hide()
self.run = False
#end hide
# It shows the main menu of the game
def show(self):
self.title.show()
self.play.show()
self.credits.show()
self.ins.show()
taskMgr.add( self.taskMenuMovement, 'taskMenuMovement' )
self.run = True
#end show
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------TASKS,THREADS------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# Menu interaction
def taskMenuMovement(self, task):
if( self.run == True ):
mpos = self.cursor.getCursorPos()
if( (mpos.getX() < -0.33) and (self.oldX >= -0.33 ) ): self.selected = "CREDITS"
elif( (mpos.getX() > -0.33) and (self.oldX <= -0.33) ): self.selected = "PLAY"
elif( (mpos.getX() < 0.33) and (self.oldX >= 0.33) ): self.selected = "PLAY"
elif( (mpos.getX() > 0.33) and (self.oldX <= 0.33) ): self.selected = "INS"
# Making bigger the button selected depending on the region of the cursor
if( self.selected == "PLAY" ):
self.play.setImage("./tex/menu/playOver.png")
self.play.setTransparency(TransparencyAttrib.MAlpha)
self.play.setScale((0.35,1.0,0.20))
elif( self.selected == "CREDITS" ):
self.credits.setImage("./tex/menu/creditsOver.png")
self.credits.setTransparency(TransparencyAttrib.MAlpha)
self.credits.setScale((0.35,1.0,0.20))
elif( self.selected == "INS" ):
self.ins.setImage("./tex/menu/insOver.png")
self.ins.setTransparency(TransparencyAttrib.MAlpha)
self.ins.setScale((0.35,1.0,0.20))
self.oldX = mpos.getX()
# Setting the others to a smaller size
if( self.selected == "PLAY" ):
self.credits.setImage("./tex/menu/credits.png")
self.credits.setTransparency(TransparencyAttrib.MAlpha)
self.credits.setScale((0.25,1.0,0.125))
self.ins.setImage("./tex/menu/ins.png")
self.ins.setTransparency(TransparencyAttrib.MAlpha)
self.ins.setScale((0.25,1.0,0.125))
elif( self.selected == "CREDITS" ):
self.play.setImage("./tex/menu/play.png")
self.play.setTransparency(TransparencyAttrib.MAlpha)
self.play.setScale((0.25,1.0,0.125))
self.ins.setImage("./tex/menu/ins.png")
self.ins.setTransparency(TransparencyAttrib.MAlpha)
self.ins.setScale((0.25,1.0,0.125))
elif( self.selected == "INS" ):
self.play.setImage("./tex/menu/play.png")
self.play.setTransparency(TransparencyAttrib.MAlpha)
self.play.setScale((0.25,1.0,0.125))
self.credits.setImage("./tex/menu/credits.png")
self.credits.setTransparency(TransparencyAttrib.MAlpha)
self.credits.setScale((0.25,1.0,0.125))
return task.cont
else: return task.done
#end taskMenuMovement
#end class Menu
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 FPS(object, DirectObject):
def __init__(self):
self.winXhalf = base.win.getXSize() / 2
self.winYhalf = base.win.getYSize() / 2
winprops = WindowProperties()
winprops.setCursorHidden(True)
base.win.requestProperties(winprops)
self.model = loader.loadModel('models/Guns/45.x')
self.model.reparentTo(base.camera)
self.model.setPos(USP45_POS)
self.model.setHpr(USP45_HPR)
self.model.setScale(PISTOL_SCALE)
self.gun = 1
self.initSound()
self.initCollision()
self.loadLevel()
self.initPlayer()
self.setupMouseCollision()
self.loadCrosshairs()
self.loadRalph()
def initSound(self):
self.deathSnd = base.loader.loadSfx("models/sounds/and.ogg")
self.spawnSnd = base.loader.loadSfx("models/sounds/faster.ogg")
self.fireSnd = base.loader.loadSfx("models/sounds/rifle.ogg")
def loadCrosshairs(self):
self.crosshairs = OnscreenImage(image='models/crosshair.png',
pos=base.win.getPointer(0))
self.crosshairs.setTransparency(TransparencyAttrib.MAlpha)
self.crosshairs.setScale(.04, .04, .04)
def initCollision(self):
#initialize traverser
base.cTrav = CollisionTraverser()
base.cTrav.setRespectPrevTransform(True)
base.cTrav.showCollisions(render)
self.mPicker = CollisionTraverser()
self.mPicker.showCollisions(render)
self.mCQue = CollisionHandlerQueue()
# base.cTrav.showCollisions(render)
#initialize pusher
self.pusher = CollisionHandlerPusher()
# collision bits
self.groundCollBit = BitMask32.bit(0)
self.collBitOff = BitMask32.allOff()
self.zombieColBitFrom = BitMask32.bit(2)
self.zombieColBitInto = BitMask32.bit(2)
self.zombieColBitOff = BitMask32.allOff()
def loadLevel(self):
self.level = loader.loadModel('models/world')
self.level.reparentTo(render)
self.level.setPos(0, 0, 0)
self.level.setColor(1, 1, 1, .5)
self.level.setCollideMask(self.groundCollBit)
self.box = loader.loadModel("models/box")
self.box.reparentTo(render)
self.box.setPos(-29.83, 0, 0)
self.box.setScale(1)
self.box.setCollideMask(self.groundCollBit)
self.box1 = loader.loadModel("models/box")
self.box1.reparentTo(render)
self.box1.setPos(-51.14, -17.90, 0)
self.box1.setScale(1)
self.box1.setCollideMask(self.groundCollBit)
def loadRalph(self):
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.setPos(ralphStartPos)
self.ralph.setScale(.3)
self.ralphLife = 10
ralphaiStartPos = Vec3(-50, 20, 0)
self.ralphai = Actor("models/ralph", {
"run": "models/ralph-run",
"walk": "models/ralph-walk"
})
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.ralphHeadSphere = CollisionSphere(0, -.2, 4.5, .7)
self.ralphHeadCol = CollisionNode('ralphHeadColSphere')
self.ralphHeadCol.addSolid(self.ralphHeadSphere)
self.ralphHeadCol.setFromCollideMask(self.zombieColBitFrom)
self.ralphHeadCol.setIntoCollideMask(self.zombieColBitInto)
self.ralphHeadColNp = self.ralph.attachNewNode(self.ralphHeadCol)
self.mPicker.addCollider(self.ralphHeadColNp, self.mCQue)
self.ralphBodySphere = CollisionSphere(0, -.2, 2, 1)
self.ralphBodyCol = CollisionNode('ralphBodyColSphere')
self.ralphBodyCol.addSolid(self.ralphBodySphere)
self.ralphBodyCol.setFromCollideMask(self.zombieColBitFrom)
self.ralphBodyCol.setIntoCollideMask(self.zombieColBitInto)
self.ralphBodyColNp = self.ralph.attachNewNode(self.ralphBodyCol)
self.mPicker.addCollider(self.ralphBodyColNp, self.mCQue)
self.ralphHeadColNp.show()
self.ralphBodyColNp.show()
base.taskMgr.doMethodLater(.7, self.spawnSound, "spawnSound")
self.isMoving = False
self.setAI()
def spawnSound(self, task):
self.spawnSnd.play()
return task.done
def Scar(self):
self.model.removeNode()
self.model = loader.loadModel('models/Guns/SCAR.x')
self.model.reparentTo(base.camera)
self.model.setPos(SCAR_POS)
self.model.setHpr(SCAR_HPR)
self.model.setScale(RIFLE_SCALE)
self.gun = 4
def M4(self):
self.model.removeNode()
self.model = loader.loadModel('models/Guns/M4.x')
self.model.reparentTo(base.camera)
self.model.setPos(M4_POS)
self.model.setHpr(M4_HPR)
self.model.setScale(RIFLE_SCALE)
self.gun = 3
def Shotgun(self):
self.model.removeNode()
self.model = loader.loadModel('models/Guns/Shotgun.x')
self.model.reparentTo(base.camera)
self.model.setPos(SHOTGUN_POS)
self.model.setHpr(SHOTGUN_HPR)
self.model.setScale(RIFLE_SCALE)
self.gun = 2
def Pistol(self):
self.model.removeNode()
self.model = loader.loadModel('models/Guns/45.x')
self.model.reparentTo(base.camera)
self.model.setPos(USP45_POS)
self.model.setHpr(USP45_HPR)
self.model.setScale(PISTOL_SCALE)
self.gun = 1
def setupMouseCollision(self):
self.mRay = CollisionRay()
self.mRayNode = CollisionNode('pickRay')
self.mRayNode.addSolid(self.mRay)
self.mRayNode.setFromCollideMask(self.zombieColBitFrom)
self.mRayNode.setIntoCollideMask(self.zombieColBitOff)
self.mPickNp = base.camera.attachNewNode(self.mRayNode)
self.mPicker.addCollider(self.mPickNp, self.mCQue)
self.mPickNp.show()
def initPlayer(self):
#load man
self.man = render.attachNewNode(
'man') # keep this node scaled to identity
self.man.setPos(0, 0, 10)
# camera
base.camera.reparentTo(self.man)
base.camera.setPos(0, 0, 1.7)
base.camLens.setNearFar(.1, 1000)
base.disableMouse()
#create a collsion solid around the man
manC = self.man.attachCollisionSphere('manSphere', 0, 0, 1, .4,
self.groundCollBit,
self.collBitOff)
self.pusher.addCollider(manC, self.man)
base.cTrav.addCollider(manC, self.pusher)
speed = 4
Forward = Vec3(0, speed * 2, 0)
Back = Vec3(0, -speed, 0)
Left = Vec3(-speed, 0, 0)
Right = Vec3(speed, 0, 0)
Stop = Vec3(0)
self.walk = Stop
self.strife = Stop
self.jump = 0
taskMgr.add(self.move, 'move-task')
self.jumping = LerpFunc(Functor(self.__setattr__, "jump"),
duration=.5,
fromData=.4,
toData=0)
self.accept("escape", sys.exit)
self.accept("space", self.startJump)
self.accept("s", self.__setattr__, ["walk", Back])
self.accept("w", self.__setattr__, ["walk", Forward])
self.accept("s-up", self.__setattr__, ["walk", Stop])
self.accept("w-up", self.__setattr__, ["walk", Stop])
self.accept("a", self.__setattr__, ["strife", Left])
self.accept("d", self.__setattr__, ["strife", Right])
self.accept("a-up", self.__setattr__, ["strife", Stop])
self.accept("d-up", self.__setattr__, ["strife", Stop])
self.accept("wheel_up", self.nextWeapon)
self.accept("wheel_down", self.prevWeapon)
self.accept("1", self.Pistol)
self.accept("2", self.Shotgun)
self.accept("3", self.M4)
self.accept("4", self.Scar)
self.accept('mouse1', self.onMouseTask)
#add mouse collision to our world
self.setupMouseCollision()
self.manGroundColNp = self.man.attachCollisionRay(
'manRay', 0, 0, .6, 0, 0, -1, self.groundCollBit, self.collBitOff)
self.manGroundHandler = CollisionHandlerGravity()
self.manGroundHandler.addCollider(self.manGroundColNp, self.man)
base.cTrav.addCollider(self.manGroundColNp, self.manGroundHandler)
def nextWeapon(self):
if self.gun == 1:
self.Shotgun()
elif self.gun == 2:
self.M4()
elif self.gun == 3:
self.Scar()
elif self.gun == 4:
self.Pistol()
def prevWeapon(self):
if self.gun == 1:
self.Scar()
elif self.gun == 2:
self.Pistol()
elif self.gun == 3:
self.Shotgun()
elif self.gun == 4:
self.M4()
def startJump(self):
if self.manGroundHandler.isOnGround():
self.jumping.start()
def move(self, task):
dt = globalClock.getDt()
# mouse
md = base.win.getPointer(0)
x = md.getX()
y = md.getY()
if base.win.movePointer(0, self.winXhalf, self.winYhalf):
self.man.setH(self.man, (x - self.winXhalf) * -0.1)
base.camera.setP(
clampScalar(-90, 90,
base.camera.getP() - (y - self.winYhalf) * 0.1))
# move where the keys set it
moveVec = (self.walk + self.strife) * dt # horisontal
moveVec.setZ(self.jump) # vertical
self.man.setFluidPos(self.man, moveVec)
# jump damping
if self.jump > 0:
self.jump = clampScalar(0, 1, self.jump * .9)
return task.cont
def onMouseTask(self):
mpos = base.mouseWatcherNode.getMouse()
self.mRay.setDirection(render.getRelativeVector(camera, Vec3(0, 1, 0)))
self.mRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
self.mPicker.traverse(render)
self.fireSnd.play()
entries = []
for i in range(self.mCQue.getNumEntries()):
entry = self.mCQue.getEntry(i)
print entry
entries.append(entry)
if (len(entries) > 0) and (entries[0].getIntoNode().getName()
== 'terrain'):
print 'terrain'
entries = []
for i in range(self.mCQue.getNumEntries()):
entry = self.mCQue.getEntry(i)
print entry
entries.append(entry)
if (len(entries) > 0) and (entries[0].getIntoNode().getName()
== 'ralphHeadColSphere'):
self.ralphLife -= 10
base.taskMgr.doMethodLater(.3, self.deathSound, "deathSound")
entries = []
for i in range(self.mCQue.getNumEntries()):
entry = self.mCQue.getEntry(i)
print entry
entries.append(entry)
if (len(entries) > 0) and (entries[0].getIntoNode().getName()
== 'ralphBodyColSphere'):
self.ralphLife -= 5
if self.ralphLife < 5:
base.taskMgr.doMethodLater(.3, self.deathSound, "deathSound")
if self.ralphLife <= 0:
self.ralph.cleanup()
self.ralphai.cleanup()
self.loadRalph()
def deathSound(self, task):
self.deathSnd.play()
return task.done
def setAI(self):
#Creating AI World
self.AIworld = AIWorld(render)
self.AIchar = AICharacter("ralph", self.ralph, 130, 0.05, 25)
self.AIworld.addAiChar(self.AIchar)
self.AIbehaviors = self.AIchar.getAiBehaviors()
self.AIbehaviors.initPathFind("models/navmesh.csv")
self.setMove()
#AI World update
taskMgr.add(self.AIUpdate, "AIUpdate")
def setMove(self):
self.AIbehaviors.addStaticObstacle(self.box)
self.AIbehaviors.addStaticObstacle(self.box1)
self.AIbehaviors.pathFindTo(self.man)
self.ralph.loop("run")
#to update the AIWorld
def AIUpdate(self, task):
self.AIworld.update()
self.ralphMove()
return Task.cont
def ralphMove(self):
startpos = self.ralph.getPos()
# Now check for collisions.
self.cTrav.traverse(render)
entries = []
for i in range(self.ralphGroundHandler.getNumEntries()):
entry = self.ralphGroundHandler.getEntry(i)
entries.append(entry)
entries.sort(lambda x, y: cmp(
y.getSurfacePoint(render).getZ(),
x.getSurfacePoint(render).getZ()))
if (len(entries) > 0) and (entries[0].getIntoNode().getName()
== "terrain"):
self.ralph.setZ(entries[0].getSurfacePoint(render).getZ())
else:
self.ralph.setPos(startpos)
self.ralph.setP(0)
return Task.cont
class Myapp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.accept("escape",sys.exit)
self.accept("mouse1", self.startShoot)
self.accept("mouse1-up", self.endShoot)
base.disableMouse()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.heading = 0
self.pitch = 0
self.mousex = 0
self.mousey = 0
self.flight = []
self.cs_flight = []
self.explosion = []
self.score = 0
self.life = 20
self.m1down = 1
self.environ = self.loader.loadModel("models/terrain")
self.environ.reparentTo(self.render)
self.environ.setScale(0.8, 0.8, 0.8)
self.environ.setPos(0,0,-10)
self.environ.setHpr(-90,0,0)
for k in range(0,5):
self.flight.append(self.loader.loadModel("models/spitfire"))
self.flight[k].reparentTo(self.render)
self.flight[k].setScale(0.1, 0.1, 0.1)
self.flight[k].setPos(randint(-40,20), randint(300,400),randint(10,20))
self.cs_flight.append( self.flight[k].attachNewNode(CollisionNode(str(k))))
self.cs_flight[k].node().addSolid(CollisionSphere(0,0,5,30))
#self.cs_flight[k].show()
self.flight[k].setCollideMask(BitMask32.bit(1))
self.bullets = []
self.crosshair = OnscreenImage(image = 'models/crosshair.png', pos = (0,0,0))
self.crosshair.setScale(0.03,0.03,0.03)
self.crosshair.setTransparency(TransparencyAttrib.MAlpha)
self.title = OnscreenText(" ",
style=1, fg=(1,1,1,1),
pos=(0,0), scale = .07)
self.taskMgr.add(self.mouse_control, "mouse_control")
self.taskMgr.add(self.update_flight, "update_flight")
self.picker = CollisionTraverser()
self.pq = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(BitMask32.bit(1))
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.picker.addCollider(self.pickerNP,self.pq)
self.gun = OnscreenImage(image = 'models/gun.png', pos = (0.24, 0, -0.54))
self.gun.setScale(1,0.6,0.6)
self.gun.setTransparency(TransparencyAttrib.MAlpha)
self.sound = base.loader.loadSfx("models/sound.ogg")
base.setFrameRateMeter(True)
def mouse_control(self,task):
md = base.win.getPointer(0)
x = md.getX()
y = md.getY()
if base.win.movePointer(0, 100, 100):
self.heading = self.heading - (x - 100) * 0.1
self.pitch = self.pitch - (y - 100) * 0.1
if (self.pitch < -10): self.pitch = -10
if (self.pitch > 20): self.pitch = 20
if (self.heading < -40): self.heading = -40
if (self.heading > 30): self.heading = 30
base.camera.setHpr(self.heading,self.pitch,0)
return Task.cont
def update_flight(self,task):
i = 0
while(i<len(self.flight)):
x = self.flight[i].getY()
if x<-3:
self.flight[i].setPos(randint(-40,20), randint(200,300),randint(10,20))
if(self.life ==0):
self.game_end()
else:
self.life -= 1
else:
x -= 0.7
self.flight[i].setPos(self.flight[i].getX(), x, self.flight[i].getZ())
i+=1
self.title.destroy()
self.title = OnscreenText(text='Life: ' + str(self.life)+' Score: '+str(self.score),
style=1, fg=(1,1,1,1),
pos=(-1.5,0.9), scale = .07)
return Task.cont
def removeBullet(self,task):
if len(self.bullets) < 1: return
self.bulletNP = self.bullets.pop(0)
self.bulletNP.removeNode()
return task.done
def shootBullet(self,task):
self.ball = self.loader.loadModel("models/bullet")
self.ball.reparentTo(self.render)
self.ball.setScale(0.02,0.02,0.02)
self.ball.setPos(0,0,0)
self.bullets.append(self.ball)
self.bt = ProjectileInterval(self.ball,
startPos = Point3(0,0,-5),
endPos = Point3(self.heading * -2 , 100 , self.pitch*2), duration = 0.3 ,
gravityMult = -2 )
self.bt.start()
self.taskMgr.doMethodLater(0.3, self.removeBullet, 'removeBullet')
self.hit_flight()
if(self.m1down):
self.taskMgr.doMethodLater(0.2, self.shootBullet, 'shootbullet')
def hit_flight(self):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode,0,0)
self.picker.traverse(render)
if self.pq.getNumEntries() > 0:
self.pq.sortEntries()
pickedObj = self.pq.getEntry(0).getIntoNodePath()
if pickedObj.getName() != 'CINEMA4D_Mesh' :
k = int(pickedObj.getName())
self.score += 1
self.explode(self.flight[k].getX(),self.flight[k].getY(),self.flight[k].getZ())
self.flight[k].setPos(randint(-40,20), randint(200,300),randint(10,20))
def game_end(self):
self.crosshair.remove()
self.gov = OnscreenText("Game Over",
style=1, fg=(1,1,1,1),
pos=(0,0), scale = 0.07)
self.taskMgr.remove("mouse_control")
self.taskMgr.remove("update_flight")
#self.explode(20,20,20)
p = open('score.txt','r')
score = p.readline()
p.close()
if(self.score > int(score)):
p = open('score.txt','w')
p.write(str(self.score))
p.close()
def explode(self,x,y,z):
k = len(self.explosion)
self.explosion.append(loader.loadModel('explosion/flip.egg'))
self.explosion[k].reparentTo(self.render)
self.explosion[k].setPos(x,y,z)
self.explosion[k].setScale(5,5,5)
self.taskMgr.doMethodLater(0.6, self.removeExplosion, 'removeExp')
def removeExplosion(self,task):
if len(self.explosion) < 1: return
self.explosion[0].removeNode()
del self.explosion[0]
return task.done
def endShoot(self):
self.m1down = 0
self.sound.stop()
def startShoot(self):
self.sound.play()
self.m1down = 1
self.taskMgr.doMethodLater(0.1, self.shootBullet, 'shootbullet')
class Player(DirectObject):
#using this to be our player
#define tehings like health in here
#have to tie the camera to this
#game manager ->player ->camera as far as instantiating goes
def __init__(self):
#Color values
self.red = 0
self.green = 1
self.blue = 1
self.oRed = 0
self.oGreen = 1
self.oBlue = 1
#Limits use of weapons on menus
self.canUseWeapons = True
#Current overheat value
self.overHeat = 0
#Amount of overheat reduced per cycle
self.overHeatCount = .1
#Flag for overheated weapons
self.isOverHeated = False
#Flag for ccritical health
self.down = True
#Create player node
self.playerNode = NodePath('player')
self.playerNode.reparentTo(render)
self.playerNode.setPos(0,-30,30)
self.playerNode.setScale(1.0)
#Create player model and reparent it to playerNode
self.playerModel = loader.loadModel("./resources/player")
self.playerModel.reparentTo(self.playerNode)
self.playerModel.setPos(0,0,2)
#Create weapons and store them in a map
self.rRifle = RecursionRifle(base.camera, len(base.projectileList))
self.mhBlunder = MHB(base.camera, len(base.projectileList))
self.kvDuals = KeyValue(base.camera, len(base.projectileList))
self.weaponMap = {1:self.rRifle, 2:self.mhBlunder, 3:self.kvDuals}
self.curWeapon = 1
#Names of weapons for switcching images
self.weaponNameMap = {1:"./resources/rrName.png", 2:"./resources/mhbName.png", 3:"./resources/kvdName.png"}
#Load all weaponName images in so it doesn't stutter on swap
self.weaponName = OnscreenImage(self.weaponNameMap[3])
self.weaponName.setTransparency(True)
self.weaponName.setImage(self.weaponNameMap[2])
self.weaponName.setTransparency(True)
self.weaponName.setImage(self.weaponNameMap[1])
self.weaponName.setTransparency(True)
self.weaponName.reparentTo(render2d)
#Hide weapons currently not in use
self.mhBlunder.hide()
self.kvDuals.hide()
#Weapon controls
self.accept("mouse1", self.fireWeapon)
self.accept("mouse3", self.swapWeapon)
#Display HUD
self.hud = OnscreenImage("resources/hud.png")
self.hud.setTransparency(True)
self.hud.reparentTo(render2d)
# define player health here
# try not to re-create the player object, will alter reset these values
# alernatively, dump player stats off in save file before recreating
print "Mod:",base.damageMod
self.maxEnergy = 100/base.damageMod
self.curEnergy = self.maxEnergy
self.accept("cnode", self.hit)
self.accept("pickuphealth", self.energyUpgrade)
#Load font for text nodes
font = loader.loadFont("./resources/ni7seg.ttf")
#Text node for health bar
self.healthLable = TextNode('health field name')
self.healthLable.setFont(font)
self.healthLable.setText("Abstraction")
self.textNodePath = aspect2d.attachNewNode(self.healthLable)
self.textNodePath.setScale(0.05)
self.healthLable.setAlign(TextNode.ACenter)
self.textNodePath.setPos(0, 0, .68)
self.healthLable.setTextColor(self.red, self.green, self.blue, 1)
#TextNode for enemy counter
self.enemiesLeft = TextNode('monsters to kill')
self.enemiesLeft.setFont(font)
self.enemiesLeft.setText(str(len(base.enemyList)))
self.texnp = aspect2d.attachNewNode(self.enemiesLeft)
self.texnp.setScale(.1)
self.texnp.setPos(-1.68, 0, -.75)
self.enemiesLeft.setTextColor(1, 1, 0, 1)
#Health bar
self.bar = DirectWaitBar(text = "", value = self.curEnergy, range = self.maxEnergy, pos = (0,.4,.95), barColor = (self.red, self.green, self.blue, 1))
self.bar.setScale(0.5)
#Usage bar
self.usageBar = DirectWaitBar(text = "", value = self.overHeat, range = 100, pos = (1.25, -.4, -.95), barColor =(1, 0, 0,1))
self.usageBar.setScale(0.5)
#Initailize player collision
self.createColision()
#Add player tasks
base.taskMgr.add(self.updateUsage, "usagePaint", taskChain='Gametasks')
base.taskMgr.add(self.hFlicker, "hflicker", taskChain='GameTasks')
base.taskMgr.add(self.updateCount, "Ecount", taskChain='GameTasks')
base.taskMgr.add(CameraMovement(self.playerModel).cameraControl, "cameraControl", taskChain='GameTasks')
base.taskMgr.add(self.overHeatTask, "overHeatTask")
base.taskMgr.add(self.killFloor, "Kill Floor")
#Deducts health and updates health bar
def hit(self, damage):
self.curEnergy = self.curEnergy-damage
self.bar['value'] = self.curEnergy
#If the player dies
if self.curEnergy <= 0:
#Hide player HUD elements
self.hide()
#Player can't use weapons while dead
self.canUseWeapons = False
#Request game over menu from fsm
base.fsm.request('GameOver', 1)
#Hides all visable elements attached to the player
def hide(self):
self.weaponMap[self.curWeapon].reticle.setScale(0)
self.weaponMap[self.curWeapon].curScale = 0
self.weaponMap[self.curWeapon].step = False
self.textNodePath.hide()
self.texnp.hide()
self.hud.setScale(0)
self.weaponName.setScale(0)
self.usageBar.hide()
self.bar.hide()
#Display all visable elements attached to the player
def show(self):
self.textNodePath.show()
self.texnp.show()
self.hud.setScale(1)
self.weaponName.setScale(1)
self.usageBar.show()
self.bar.show()
#Reset the reticle for the current weapon
if self.curWeapon == 1:
self.weaponMap[1].reticle.setScale(.025)
self.weaponMap[1].curScale = .025
elif self.curWeapon == 2:
self.weaponMap[2].reticle.setScale(.075)
self.weaponMap[2].curScale = .075
else:
self.weaponMap[3].reticle.setScale(.025)
self.weaponMap[3].curScale = .025
# set the player health to a specific value
def adjustHealth(self, value):
self.curEnergy = value
self.bar['value'] = self.curEnergy
#Update enemy counter
def updateCount(self, task):
self.enemiesLeft.setText(str(len(base.enemyList)))
return task.cont
#Update usage bar and color
def updateUsage(self, task):
if self.curEnergy > 0:
if self.overHeat < 50:
self.usageBar['barColor'] = (.2, 1, .5, 1)
elif self.overHeat >=50 and self.overHeat <70:
self.usageBar['barColor'] = (1, 1, .2, 1)
elif self.overHeat >= 70:
self.usageBar['barColor'] = (1, 0, 0, 1)
self.usageBar['value'] = self.overHeat
if self.isOverHeated:
self.usageBar['barColor'] = (1, 0, 0, 1)
return task.cont
#Swaps to next weapon in the map
def swapWeapon(self):
#If you're not in a menu
if self.canUseWeapons:
#Reset weapon delay
self.weaponMap[self.curWeapon].resetWeapon
#Change to next weapon and hide reticles
if self.curWeapon == 1:
self.weaponName.setImage(self.weaponNameMap[2])
self.weaponName.setTransparency(True)
self.weaponMap[1].reticle.setScale(0)
self.weaponMap[1].curScale = 0
self.weaponMap[1].step = False
self.rRifle.hide()
self.mhBlunder.show()
self.curWeapon = 2
self.weaponMap[2].reticle.setScale(.075)
self.weaponMap[2].curScale = .075
elif self.curWeapon == 2:
self.weaponName.setImage(self.weaponNameMap[3])
self.weaponName.setTransparency(True)
self.weaponMap[2].reticle.setScale(0)
self.weaponMap[2].curScale = 0
self.weaponMap[2].step = False
self.mhBlunder.hide()
self.kvDuals.show()
self.curWeapon = 3
self.weaponMap[3].reticle.setScale(.025)
self.weaponMap[3].curScale = .025
elif self.curWeapon == 3:
self.weaponName.setImage(self.weaponNameMap[1])
self.weaponName.setTransparency(True)
self.weaponMap[3].reticle.setScale(0)
self.weaponMap[3].curScale = 0
self.weaponMap[3].step = False
self.kvDuals.hide()
self.rRifle.show()
self.curWeapon = 1
self.weaponMap[1].reticle.setScale(.025)
self.weaponMap[1].curScale = .025
base.taskMgr.remove("weaponDelay")
#Fires current weapon
def fireWeapon(self):
#If the player is not in a menu
if self.canUseWeapons:
#If there isn't a weapon delay task add one
if base.taskMgr.hasTaskNamed("weaponDelay") == False:
#If your not overheated
if not self.isOverHeated:
base.taskMgr.add(self.weaponMap[self.curWeapon].fire, "fire")
#If you can shoot as defined by weapon delay
elif self.weaponMap[self.curWeapon].canShoot() == True:
#and if your not overheated
if not self.isOverHeated:
base.taskMgr.remove("weaponDelay")
base.taskMgr.add(self.weaponMap[self.curWeapon].fire, "fire")
#Handles weapon overheat
def overHeatTask(self, task):
#Every cycle decrement your overheat by the specified amount
self.overHeat -= self.overHeatCount
#If you exceed the limit
if self.overHeat >= 100:
#Increase cooldown amount and set overheated flag
self.overHeatCount = .5
self.isOverHeated = True
#If your are not overheated anymore reset not default cooldown values
elif self.overHeat < 0:
self.overHeatCount = .1
self.overHeat = 0
self.isOverHeated = False
return task.cont
#Initialize player collision
def createColision(self):
#Set up floor collision handler
base.floor = CollisionHandlerGravity()
base.floor.setGravity(9.8)
#Create player collision node and add to traverser
self.playerCollNodePath = self.initCollisionSphere(self.playerNode.getChild(0))
base.cTrav.addCollider(self.playerCollNodePath, base.pusher)
base.pusher.addCollider(self.playerCollNodePath, self.playerNode)
# Create Floor Ray - for gravity / floor
floorCollRayPath = self.initCollisionRay(1,-1)
base.floor.addCollider(floorCollRayPath, self.playerNode)
base.cTrav.addCollider(floorCollRayPath, base.floor)
floorCollRayPath.reparentTo(self.playerModel)
#Initialize player collision sphere
def initCollisionSphere(self, obj):
# Create sphere and attach to player
cNode = CollisionNode('player')
cs = CollisionSphere(0, 0, 4, 2)
cNodePath = obj.attachNewNode(CollisionNode('cnode'))
cNodePath.node().addSolid(cs)
cNodePath.show()
return cNodePath
#Attach player to a collision ray
def initCollisionRay(self, originZ, dirZ):
ray = CollisionRay(0,0,originZ,0,0,dirZ)
collNode = CollisionNode('playerRay')
collNode.addSolid(ray)
collNode.setFromCollideMask(BitMask32.bit(1))
collNode.setIntoCollideMask(BitMask32.allOff())
collRayNP = self.playerNode.attachNewNode(collNode)
collRayNP.show()
return collRayNP
#call this method when collide with a health upgrade
def energyUpgrade(self):
self.maxEnergy +=(10/base.damageMod)
self.curEnergy = self.curEnergy+(10/base.damageMod)
self.bar['range'] = self.maxEnergy
self.adjustHealth(self.curEnergy)
#Hurts player and resets the to the levels origin upon falliong in a pit.
def killFloor(self, task):
z = int(self.playerNode.getPos()[2])
if(z < -7):
self.playerNode.setPos(0, 0, 6) #resets height
self.playerModel.setPos(base.xPos, base.yPos, base.zPos) #resets position
self.hit(10)
return task.cont
#Makes the health bar flicker when your health is critical
def hFlicker(self, task):
if self.curEnergy <=30:
if self.down:
self.red = self.red+0.1
self.blue = self.blue-.01
self.green = self.green-.01
else:
self.red = self.red-0.1
self.blue = self.green+0.1
self.green = self.green+0.1
else:
self.red = self.oRed
self.blue = self.oBlue
self.green = self.oGreen
if self.red >=1:
self.down = False
if self.red <=0:
self.down = True
self.healthLable.setTextColor(self.red, self.green, self.blue, 1)
self.bar['barColor']=(self.red, self.green, self.blue, 1)
return task.cont
#Resets players health and signifies they have restarted level after death
def resetEnergy(self):
self.canUseWeapons = True
self.curEnergy = self.maxEnergy
self.adjustHealth(self.curEnergy)
class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.imageObject = OnscreenImage(image = 'earth.jpg', pos = (0, 1, 0))
self.imageObject.setScale(1.9,1,1)
tpRed = TextProperties()
tpRed.setTextColor(1, 1, 1, 1)
tpSlant = TextProperties()
tpSlant.setSlant(0.3)
tpRoman = TextProperties()
cmr12 = loader.loadFont('cmr12.egg')
tpRoman.setFont(cmr12)
tpMgr = TextPropertiesManager.getGlobalPtr()
tpMgr.setProperties("red", tpRed)
tpMgr.setProperties("slant", tpSlant)
tpMgr.setProperties("roman", tpRoman)
self.textObject = OnscreenText(text = '\1red\1\1roman\1\1slant\1Space Collector', pos = (-0.6, 0.4), scale = 0.2)
self.textScore=0
self.b = DirectButton(text = ("Start", "Start", "Start", "disabled"),command=self.beginGame)
self.b.setScale(0.1,0.1,0.1)
self.b.setPos(0.7,0,-0.8)
myMaterial = Material()
myMaterial.setShininess(1000)
myMaterial.setDiffuse(VBase4(0.5,0.5,0.5,1))
myMaterial.setAmbient(VBase4(5,5,5,1))
myMaterial.setSpecular(VBase4(10,10,10,1))
myTexture = loader.loadTexture("maps/grayjumpjetTexture.tif")
self.ship = loader.loadModel("GrayJumpJet")
self.ship.setScale(0.15, 0.3, 0.15)
self.ship.setPos(0,0,0)
self.ship.setTexture(myTexture,1)
self.ship.reparentTo(render)
self.slab = loader.loadModel("box")
self.slab.find("**/Cube;+h").setCollideMask(BitMask32.bit(0))
self.slab.setScale(1.5,10,1)
self.slab.setPos(0,0,-1)
self.slab.setHpr(0,0,0)
self.slab.setMaterial(myMaterial)
self.slab.setTexGen(TextureStage.getDefault(), TexGenAttrib.MWorldPosition)
self.slab.setTexProjector(TextureStage.getDefault(), render, self.slab)
self.slab.setTexture(loader.loadTexture("maps/crate_Material_#11_CL.tif"),1)
self.junk = [None]*100
self.loadJunk()
self.createTrack()
base.trackball.node().setPos(0, 20, -4)
self.acceleration=0
self.velocity=0
self.yPos=0
render.setShaderAuto()
self.cTrav = CollisionTraverser()
self.shipGroundRay = CollisionRay()
self.shipGroundRay.setOrigin(0,0,1000)
self.shipGroundRay.setDirection(0,0,-1)
self.shipGroundCol = CollisionNode('shipRay')
self.shipGroundCol.addSolid(self.shipGroundRay)
self.shipGroundCol.setFromCollideMask(BitMask32.bit(0))
self.shipGroundCol.setIntoCollideMask(BitMask32.allOff())
self.shipGroundColNp = self.ship.attachNewNode(self.shipGroundCol)
self.shipGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.shipGroundColNp, self.shipGroundHandler)
self.collHandEvent = CollisionHandlerEvent()
# add the into pattern with fromObject-into-thisObject
self.collHandEvent.addInPattern( 'into-%in' )
self.accept("into-Junk",self.cHandler)
bkground = loader.loadModel("square")
bkground.reparentTo(camera)
bkground.setScale(300,170,50)
tex = loader.loadTexture("earth2.jpg")
bkground.setTexture(tex,1)
bkground.setPos(0,299,0)
bkground.setHpr(0,90,0)
base.camLens.setFar(300)
self.mySound = loader.loadMusic("coinslot1.wav")
self.timer=60
self.textTimer=0
self.prevY=0
self.prevX=0
self.shipGroundColNp.show()
#self.camGroundColNp.show()
self.collided=1
self.jumpTime=0
self.jumpOn=0
self.curZ=0
self.interval=0
self.zPosition=0
self.isGameOver=0
self.score=0
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
if base.mouseWatcherNode.hasMouse():
self.prevX=base.mouseWatcherNode.getMouseX()
self.prevY=base.mouseWatcherNode.getMouseY()
def beginGame(self):
self.textObject.destroy()
self.imageObject.destroy()
self.b.destroy()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.taskMgr.add(self.moveForward, "MoveForward")
self.accept("mouse1",self.jump)
self.textScore = OnscreenText(text = '\1red\1\1slant\1Score : 0', pos = (-0.8, 0.8), scale = 0.1)
self.textTimer = OnscreenText(text = '\1red\1\1slant\1Time Left : 2:00', pos = (-0.8, 0.7), scale = 0.1)
print 'GameBegin'
def cHandler(self,collEntry):
print "collision"
def loadJunk(self):
f = open('junk1.txt','r')
x=f.readline()
y=f.readline()
z=f.readline()
i=0
while x!="":
self.junk[i] = loader.loadModel("rubbishset/rubbish-set.lwo")
self.junk[i].setScale(0.5,1,0.5)
self.junk[i].reparentTo(render)
colSphere=self.initCollisionSphere(self.junk[i],"Junk")
self.junk[i].setPos(int(x),int(y),int(z))
x=f.readline()
y=f.readline()
z=f.readline()
i=i+1
def initCollisionSphere(self,node,name):
bounds = node.getBounds()
center = bounds.getCenter()
radius = bounds.getRadius()*0.6
cNode = CollisionNode(name)
cNode.addSolid(CollisionSphere(center,radius))
cNP=node.attachNewNode(cNode)
cNP.show()
return cNP
def createTrack(self):
f = open('track.txt','r')
a = f.read(1)
i=0
j=0
while(a!=""):
if a=="\n":
a=f.read(1)
if(a==""):
break
nSlab = int(a)
#print nSlab
while nSlab!=0:
placeholder = render.attachNewNode("Slab")
placeholder.setColor(j*0.92*0.4,nSlab*nSlab*0.51,0.23,1)
placeholder.setPos(j*3-7,i*15,nSlab-3)
self.slab.instanceTo(placeholder)
nSlab=nSlab-1
j=j+1
if(j==5):
i=i+1
j=0
print i
a=f.read(1)
def moveForward(self, task):
curX=0
curY=0
shipCollided=0
c=self.timer-int(task.time)
self.textTimer.setText('\1red\1\1slant\1Time Left : '+str(int(c/60))+':'+str(c%60))
if base.mouseWatcherNode.hasMouse():
curX=base.mouseWatcherNode.getMouseX()
curY=base.mouseWatcherNode.getMouseY()
#if(curY>self.prevY+0.01):
self.acceleration = self.acceleration+1
#if(curY<self.prevY-0.01):
# self.acceleration = self.acceleration-1
if(self.acceleration<45 and self.acceleration>=0):
self.velocity=self.acceleration*task.time
self.yPos=self.velocity * task.time
self.ship.setY(self.yPos)
if self.prevX<curX-0.001:
self.ship.setHpr(0,0,5)
#Sequence(self.ship.hprInterval(0.1,Point3(0,0,10),self.ship.getHpr())).start()
self.ship.setX(curX*8)
self.prevX=curX
elif self.prevX>curX+0.001:
self.ship.setHpr(0,0,-5)
#Sequence(self.ship.hprInterval(0.1,Point3(0,0,-10),self.ship.getHpr())).start()
self.ship.setX(curX*8)
self.prevX=curX
else:
#self.ship.setHpr(0,0,0)
Sequence(self.ship.hprInterval(0.1,Point3(0,0,0),self.ship.getHpr())).start()
#print yPos
self.camera.setPos(0,self.yPos-25,4)
#self.slnp.setPos(0,self.yPos+20,4)
self.cTrav.traverse(render)
entries = []
for i in range(self.shipGroundHandler.getNumEntries()):
entry = self.shipGroundHandler.getEntry(i)
entries.append(entry)
entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),
x.getSurfacePoint(render).getZ()))
if (len(entries)>0) and (entries[0].getIntoNode().getName() == "Cube"):
self.zPosition=entries[0].getSurfacePoint(render).getZ()
#self.ship.setZ(entries[0].getSurfacePoint(render).getZ()+1)
print str(self.zPosition) + " "+str(self.ship.getZ())
if self.zPosition>=self.ship.getZ():
shipCollided=1
self.isGameOver=1
else:
shipCollided=0
self.collided=1
print entries[0].getIntoNode().getName() + "collided"
elif (len(entries)>0) and (entries[0].getIntoNode().getName() == "Junk"):
pZ=entries[0].getSurfacePoint(render).getZ()
if(self.ship.getZ()<=pZ and self.ship.getZ()>=pZ-2):
entries[0].getIntoNode().getParent(0).removeAllChildren()
self.score=self.score+1000
self.timer=self.timer+20
self.textScore.setText('\1red\1\1slant\1Score : '+str(self.score))
self.mySound.play()
print self.score
else:
self.collided=0
if shipCollided!=1:
val=0
if(self.jumpOn==1):
val=10
if(self.interval==0):
self.interval=task.time
self.curZ=self.ship.getZ()
self.jumpTime=0
else:
self.jumpTime=self.jumpTime+task.time-self.interval
self.interval=task.time
zPos = self.curZ + val*self.jumpTime - 12*self.jumpTime*self.jumpTime
if(zPos<self.zPosition+1 and self.collided==1):
zPos=self.zPosition+1
self.ship.setZ(zPos)
self.accept("mouse1",self.jump)
self.jumpOn=0
self.interval=0
else:
self.ship.setZ(zPos)
if zPos<-40:
self.isGameOver=1
self.prevX=curX
self.prevY=curY
self.score=self.score+1
self.textScore.setText('\1red\1\1slant\1Score : '+str(self.score))
if(self.isGameOver==1):
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.imageObject = OnscreenImage(image = 'earth.jpg', pos = (0, 1, 0))
self.imageObject.setScale(1.9,1,1)
self.textObject = OnscreenText(text = '\1red\1\1roman\1\1slant\1Space Collector', pos = (-0.6, 0.4), scale = 0.2)
self.b = DirectButton(text = ("Start", "Start", "Start", "disabled"),command=self.beginGame)
self.b.setScale(0.1,0.1,0.1)
self.b.setPos(0.7,0,-0.8)
self.ship.setPos(0,0,0)
self.zPosition=0
self.prevY=0
self.prevX=0
self.collided=1
self.jumpTime=0
self.jumpOn=0
self.curZ=0
self.interval=0
self.zPosition=0
self.isGameOver=0
self.score=0
self.acceleration=0
self.velocity=0
self.yPos=0
self.score=0
self.timer=120
self.textTimer.destroy()
self.textScore.destroy()
for x in self.junk:
if(x!=None):
x.detachNode()
x=None
print 'destroyed'
self.loadJunk()
else:
return Task.cont
def jump(self):
self.jumpOn=1
self.ignore("mouse1")
class Unit:
def __init__(self, unitID, position, mainClass):
# self = copy.copy(mainClass.unitHandler.unitDict[mainClass.unitHandler.main['units'][unitID]])
self.model = mainClass.unitHandler.unitDict[mainClass.unitHandler.main["units"][unitID]].model
self.fullName = copy.copy(mainClass.unitHandler.unitDict[mainClass.unitHandler.main["units"][unitID]].fullName)
self.HP = copy.copy(mainClass.unitHandler.unitDict[mainClass.unitHandler.main["units"][unitID]].HP)
self.info = copy.copy(mainClass.unitHandler.unitDict[mainClass.unitHandler.main["units"][unitID]].info)
self.moveType = copy.copy(mainClass.unitHandler.unitDict[mainClass.unitHandler.main["units"][unitID]].moveType)
self.model = copy.copy(mainClass.unitHandler.unitDict[mainClass.unitHandler.main["units"][unitID]].model)
self.radius = copy.copy(mainClass.unitHandler.unitDict[mainClass.unitHandler.main["units"][unitID]].radius)
self.mass = copy.copy(mainClass.unitHandler.unitDict[mainClass.unitHandler.main["units"][unitID]].mass)
self.startForce = copy.copy(
mainClass.unitHandler.unitDict[mainClass.unitHandler.main["units"][unitID]].startForce
)
self.maxForce = copy.copy(mainClass.unitHandler.unitDict[mainClass.unitHandler.main["units"][unitID]].maxForce)
self.dig = copy.copy(mainClass.unitHandler.unitDict[mainClass.unitHandler.main["units"][unitID]].dig)
self.reinforce = copy.copy(
mainClass.unitHandler.unitDict[mainClass.unitHandler.main["units"][unitID]].reinforce
)
self.shovel = copy.copy(mainClass.unitHandler.unitDict[mainClass.unitHandler.main["units"][unitID]].shovel)
self.hold = copy.copy(mainClass.unitHandler.unitDict[mainClass.unitHandler.main["units"][unitID]].hold)
self.modelHeight = copy.copy(
mainClass.unitHandler.unitDict[mainClass.unitHandler.main["units"][unitID]].modelHeight
)
self.selectScale = copy.copy(
mainClass.unitHandler.unitDict[mainClass.unitHandler.main["units"][unitID]].selectScale
)
self.job = False
self.uID = mainClass.unitHandler.unitUniqueID
print self.uID
self.modelNode = loader.loadModel(self.model)
self.modelNode.setName("unit " + str(self.uID).zfill(3))
self.modelNode.reparentTo(render)
self.modelNode.setPos(position)
self.modelNode.setCollideMask(BitMask32.bit(1))
self.select = OnscreenImage(image="data/models/game/selected.png")
self.select.setScale(float(self.selectScale))
self.select.reparentTo(self.modelNode)
self.select.setZ(float(self.modelHeight) / 2)
self.select.setTransparency(TransparencyAttrib.MAlpha)
self.select.setBillboardPointEye()
self.select.hide()
self.groundRay = CollisionRay()
self.groundRay.setOrigin(0, 0, 100)
self.groundRay.setDirection(0, 0, -1)
self.groundCol = CollisionNode("unit Ray")
self.groundCol.addSolid(self.groundRay)
self.groundCol.setTag("units", "ray1")
self.groundCol.setFromCollideMask(BitMask32.bit(0))
self.groundCol.setIntoCollideMask(BitMask32.allOff())
self.groundColNp = self.modelNode.attachNewNode(self.groundCol)
self.groundColNp.setPos(0, 0, 0)
self.groundHandler = CollisionHandlerFloor()
self.groundHandler.setMaxVelocity(100)
base.cTrav2.addCollider(self.groundColNp, self.groundHandler)
self.groundHandler.addCollider(self.groundColNp, self.modelNode)
self.AI = AICharacter(self.fullName, self.modelNode, self.mass * 2, self.startForce * 2, self.maxForce * 2)
mainClass.unitHandler.AIWorld.addAiChar(self.AI)
self.AIBehaviors = self.AI.getAiBehaviors()
if self.moveType == "ground":
self.aStar = astar.aStar(mainClass.unitHandler.meshes.landMesh, mainClass)
elif self.moveType == "water":
self.aStar = astar.aStar(mainClass.unitHandler.meshes.waterMesh, mainClass)
elif self.moveType == "air":
self.aStar = astar.aStar(mainClass.unitHandler.meshes.airMesh, mainClass)
print self
class Engine(ShowBase):
def __init__(self, mouse):
ShowBase.__init__(self)
self.mouse = mouse
self.joy_x = None
self.joy_y = None
props = WindowProperties()
props.setMouseMode(WindowProperties.MRelative) # keep mouse in screen
self.disableMouse()
self.win.requestProperties(props)
self.setBackgroundColor(0, 0, 0)
# Make missiles glow
self.filters = CommonFilters(self.win, self.cam)
self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size="large")
self.screen_width = self.win.getXSize()
self.screen_height = self.win.getYSize()
self.center_x = self.screen_width/2
self.center_y = self.screen_height/2
# self.win.movePointer(0, self.center_x, self.center_y)
self.enableParticles()
self.cTrav = CollisionTraverser()
# self.cTrav.setRespectPrevTransform(True)
self.pusher = PhysicsCollisionHandler()
self.pusher.addInPattern('%fn-into-%in')
self.target = None
self.maxvel = 50
self.roll_time = 0
self.fuel = 1000
self.ship()
self.sounds()
self.hud()
self.part = Spacedust(self)
self.events()
self.camLens.setFov(70)
self.camLens.setNear(1)
self.camLens.setFar(500)
self.get_key = {
"ACCEL": False,
"DECEL": False,
"FORWARD_THRUST": False,
"REVERSE_THRUST": False,
"ROLL_LEFT": False,
"ROLL_RIGHT": False,
"ROLL_LEFT_BEG": False,
"ROLL_RIGHT_BEG": False,
"FIRE": False,
"FIRING": False,
"LOCK": False,
"LOCKING": False,
}
self.AIworld = AIWorld(self.render)
self.taskMgr.add(self.update, "task-update")
self.taskMgr.doMethodLater(1, self.fuel_usage, "task-fuel-usage")
self.taskMgr.add(self.AI_update, "AI-update")
self.gen_enemy()
def gen_enemy(self):
x = randint(-1000, 1000)
y = randint(-1000, 1000)
z = randint(-1000, 1000)
Enemy(self, 0, x, y, z)
def AI_update(self, task):
self.AIworld.update()
return task.cont
def hud(self):
self.font = self.loader.loadFont("./fnt/subatomic.tsoonami.ttf")
self.aim = OnscreenImage(image="./png/ring.png", pos=Vec3(0), scale=0.02)
self.aim.setTransparency(TransparencyAttrib.MAlpha)
self.locker = OnscreenImage(image="./png/ring.png", pos=Vec3(0), scale=0.12)
self.locker.setTransparency(TransparencyAttrib.MAlpha)
self.locker.hide()
self.txtFuel = OnscreenText(parent=self.render2d, align=TextNode.ALeft, pos=(-0.95, 0.8), text='FUEL', fg=(1, 1, 1, 0.5), scale=0.05, font=self.font, mayChange=True)
self.txtSpeed = OnscreenText(parent=self.render2d, align=TextNode.ALeft, pos=(-0.95, 0.7), text='SPEED', fg=(1, 1, 1, 0.5), scale=0.05, font=self.font, mayChange=True)
self.txtDist = OnscreenText(parent=self.render2d, align=TextNode.ALeft, pos=(-0.95, 0.6), text='DIST', fg=(1, 1, 1, 0.5), scale=0.05, font=self.font, mayChange=True)
self.txtCoord = OnscreenText(parent=self.render2d, align=TextNode.ALeft, pos=(-0.95, 0.5), text='COORD', fg=(1, 1, 1, 0.5), scale=0.05, font=self.font, mayChange=True)
self.taskMgr.doMethodLater(1, self.instruments, "task-instruments")
def instruments(self, task):
self.txtSpeed.setText("SPEED: %s" % str(int(self.mvel)))
self.txtFuel.setText("FUEL: %s" % str(self.fuel))
if self.target is not None:
self.txtDist.setText("DISTANCE: %s" % str(round(self.dist, 1)))
else:
self.txtDist.setText("DISTANCE: ---")
self.txtCoord.setText("COORD: %s %s %s" % (str(round(self.fighter.getX(), 1)), str(round(self.fighter.getY(), 1)), str(round(self.fighter.getZ(), 1))))
return task.again
def set_key(self, key, value):
self.get_key[key] = value
def toggle_key(self, key):
self.set_key(key, not self.get_key[key])
def init_roll(self, a, task):
if task.time <= 2:
if self.roll_time <= task.time:
self.roll_time = task.time
else:
self.roll_time += task.time
if self.roll_time > 2:
self.roll_time = 2
self.fighter.setR(self.fighter.getR() + a * self.roll_time)
else:
self.fighter.setR(self.fighter.getR() + a * 2)
return task.cont
def end_roll(self, a, b, task):
if task.time < b:
self.roll_time -= task.time
if self.roll_time < 0:
self.roll_time = 0
self.fighter.setR(self.fighter.getR() + a * (b - task.time))
return task.cont
else:
return task.done
def roll(self, a):
if a > 0:
self.set_key("ROLL_RIGHT_BEG", True)
else:
self.set_key("ROLL_LEFT_BEG", True)
self.taskMgr.add(self.init_roll, "task-init-roll", extraArgs=[a], appendTask=True)
def unroll(self, a):
if a > 0:
self.set_key("ROLL_RIGHT_BEG", False)
else:
self.set_key("ROLL_LEFT_BEG", False)
self.taskMgr.remove("task-init-roll")
self.taskMgr.add(self.end_roll, "task-end-roll", extraArgs=[a, self.roll_time], appendTask=True)
def to_roll(self):
if self.get_key["ROLL_LEFT"]:
if not self.get_key["ROLL_LEFT_BEG"]:
if self.fuel > 5:
self.roll(-1)
self.snd_roller.play()
else:
if self.get_key["ROLL_LEFT_BEG"]:
self.unroll(-1)
self.snd_roller.stop()
if self.get_key["ROLL_RIGHT"]:
if not self.get_key["ROLL_RIGHT_BEG"]:
if self.fuel > 5:
self.roll(+1)
self.snd_roller.play()
else:
if self.get_key["ROLL_RIGHT_BEG"]:
self.unroll(+1)
self.snd_roller.stop()
def fuel_usage(self, task):
if self.get_key["FORWARD_THRUST"] or self.get_key["REVERSE_THRUST"]:
self.fuel -= 9
if self.get_key["ROLL_LEFT_BEG"] or self.get_key["ROLL_RIGHT_BEG"]:
self.fuel -= 4
self.fuel -= 1
if self.fuel < 0:
self.fuel = 0
return task.again
def chk_speed(self, mvel):
if mvel < 0.01:
# stop fighter dead
if self.prt.getActive():
self.set_key("DECEL", False)
mvel = 0
if mvel > self.maxvel:
# stop fighter accelerating
if self.pft.getActive():
self.set_key("ACCEL", False)
mvel = self.maxvel
self.part.p.renderer.setLineScaleFactor(mvel*2)
self.part.pn.setPos(self.fighter, 0, 10, 0)
return mvel
def thrust_shake(self, task):
x = uniform(-1000, 1000)
y = uniform(-1000, 1000)
self.repos(x, y, 0.001)
return task.cont
def thrust_end(self, task):
if task.time < 5:
f = (5. - task.time) / 5.
s = 1000.*f
x = uniform(-s, s)
y = uniform(-s, s)
self.repos(x, y, 0.001)
self.snd_thrust.setVolume(f)
return task.cont
self.snd_thrust.stop()
return task.done
def thrust(self, a):
if a > 0:
self.set_key("FORWARD_THRUST", True)
else:
self.set_key("REVERSE_THRUST", True)
self.taskMgr.remove("task-thrust-end")
self.snd_thrust.setVolume(1)
self.snd_thrust.play()
self.taskMgr.add(self.thrust_shake, "task-thrust-shake")
def unthrust(self, a):
if a > 0:
self.set_key("FORWARD_THRUST", False)
else:
self.set_key("REVERSE_THRUST", False)
self.taskMgr.remove("task-thrust-shake")
self.taskMgr.add(self.thrust_end, "task-thrust-end")
def to_thrust(self):
if self.get_key["ACCEL"]:
if self.mvel < self.maxvel - 1:
if not self.get_key["FORWARD_THRUST"]:
if self.fuel > 10:
self.pft.setActive(True)
self.thrust(+1)
else:
if self.get_key["FORWARD_THRUST"]:
self.pft.setActive(False)
self.unthrust(+1)
if self.get_key["DECEL"]:
if self.mvel > 0:
if not self.get_key["REVERSE_THRUST"]:
if self.fuel > 10:
self.prt.setActive(True)
self.thrust(-1)
else:
if self.get_key["REVERSE_THRUST"]:
self.prt.setActive(False)
self.unthrust(-1)
def events(self):
self.accept("escape", self.quit)
self.accept('mouse1', self.set_key, ["FIRE", True])
self.accept('mouse1-up', self.set_key, ["FIRE", False])
self.accept('mouse3', self.set_key, ["LOCK", True])
self.accept('mouse3-up', self.set_key, ["LOCK", False])
self.accept("w", self.set_key, ["ACCEL", True])
self.accept("w-up", self.set_key, ["ACCEL", False])
self.accept("s", self.set_key, ["DECEL", True])
self.accept("s-up", self.set_key, ["DECEL", False])
self.accept("a", self.set_key, ["ROLL_LEFT", True])
self.accept("a-up", self.set_key, ["ROLL_LEFT", False])
self.accept("d", self.set_key, ["ROLL_RIGHT", True])
self.accept("d-up", self.set_key, ["ROLL_RIGHT", False])
def update(self, task):
self.pos()
self.speed()
if self.fuel > 0:
self.to_roll()
self.to_thrust()
self.to_fire()
self.to_lock()
self.rehud()
return task.cont
def rehud(self):
if self.target is not None:
c = self.target.np.getPos(self.fighter)
self.dist = c.length()
c.normalize()
self.d2 = c - Vec3(0, 1, 0)*c.dot(Vec3(0, 1, 0))
self.target.radar.setPos(self.d2.getX(), 1, self.d2.getZ())
def sounds(self):
self.audio3d = Audio3DManager.Audio3DManager(self.sfxManagerList[0], self.camera)
self.audio3d.setListenerVelocityAuto()
self.snd_space = self.loader.loadSfx("./snd/space.flac")
self.snd_space.setLoop(True)
self.snd_thrust = self.loader.loadSfx("./snd/thrust.flac")
self.snd_thrust.setLoop(True)
self.snd_roller = self.loader.loadSfx("./snd/roller.flac")
self.snd_roller.setLoop(True)
self.snd_launch = self.loader.loadSfx("./snd/launch.flac")
self.snd_lock = self.loader.loadSfx("./snd/lock.flac")
self.snd_space.play()
def quit(self):
self.taskMgr.running = False
def repos(self, x, y, d):
player_q = self.fighter.getQuat()
up = player_q.getUp()
right = player_q.getRight()
up.normalize()
right.normalize()
up_q = copy(player_q)
right_q = copy(player_q)
up_q.setFromAxisAngle(-(x * d), up)
right_q.setFromAxisAngle(y * d, right)
self.fighter.setQuat(player_q.multiply(up_q.multiply(right_q)))
def move_end(self, x, y, task):
if task.time <= 1:
d = 0.002*(1 - task.time)
self.repos(x, y, d)
return task.cont
return task.done
def pos(self):
if self.mouse:
md = self.win.getPointer(0)
x = md.getX()
y = md.getY()
else:
x = self.joy_x
y = self.joy_y
if self.win.movePointer(0, self.center_x, self.center_y):
x -= self.center_x
y -= self.center_y
if x != 0 or y != 0:
self.taskMgr.add(self.move_end, 'task-move-end', extraArgs=[x, y], appendTask=True)
def speed(self):
fwd = self.fighter.getQuat().getForward()
fwd.normalize()
self.mvel = self.anpo.getVelocity().length()
# speed control
self.mvel = self.chk_speed(self.mvel)
self.anpo.setVelocity(fwd * self.mvel)
def ship(self):
an = ActorNode()
an.getPhysicsObject().setMass(100)
self.fighter = self.render.attachNewNode(an)
self.physicsMgr.attachPhysicalNode(an)
self.anpo = an.getPhysicsObject()
fn = ForceNode("force-node-fighter")
self.fighter.attachNewNode(fn)
self.pft = LinearVectorForce(Vec3(0, +1, 0) * 500) # forward thrust
self.prt = LinearVectorForce(Vec3(0, -1, 0) * 500) # reverse thrust
self.pft.setMassDependent(1)
self.prt.setMassDependent(1)
self.pft.setActive(False)
self.prt.setActive(False)
fn.addForce(self.pft)
fn.addForce(self.prt)
an.getPhysical(0).addLinearForce(self.pft)
an.getPhysical(0).addLinearForce(self.prt)
self.camera.reparentTo(self.fighter)
from_obj = self.fighter.attachNewNode(CollisionNode('fighter'))
from_obj.node().setFromCollideMask(BitMask32(0x1))
from_obj.setCollideMask(BitMask32(0x1))
from_obj.node().addSolid(CollisionSphere(0, 0, 0, 1))
# from_obj.show()
self.pusher.addCollider(from_obj, self.fighter)
self.cTrav.addCollider(from_obj, self.pusher)
def launch_bullet(self):
speed = 500.
scale = Vec3(0.05)
color = Vec4(0, 1, 0, 1)
mask = BitMask32(0x2)
lookat = Vec3(0, 100, 0)
Missile(self, "bullet", speed, scale, color, mask, self.fighter, Vec3(-0.5, 0, 0), self.fighter, lookat, 0.5)
Missile(self, "bullet", speed, scale, color, mask, self.fighter, Vec3(+0.5, 0, 0), self.fighter, lookat, 0.5)
self.snd_launch.play()
def to_fire(self):
if self.get_key["FIRE"]:
if not self.get_key["FIRING"]:
self.set_key("FIRING", True)
self.taskMgr.doMethodLater(0.16, self.fire_bullet, "task-fire-bullet")
else:
if self.get_key["FIRING"]:
self.set_key("FIRING", False)
self.taskMgr.remove("task-fire-bullet")
def fire_bullet(self, task):
if self.fuel >= 5:
self.fuel -= 5
self.launch_bullet()
return task.again
def launch_missile(self):
speed = 100
scale = Vec3(0.2)
color = Vec4(1, 0, 0, 1)
mask = BitMask32(0x2)
lookat = Vec3(0, 0, 0)
self.missile = Missile(self, "missile", speed, scale, color, mask, self.fighter, Vec3(0, 0, -2), self.target.np, lookat, 3)
self.snd_launch.play()
self.taskMgr.add(self.guide_missile, "task-guide-missile")
def guide_missile(self, task):
try:
quat = Quat()
lookAt(quat, self.target.np.getPos() - self.missile.anp.getPos(), Vec3.up())
self.missile.anp.setQuat(quat)
fwd = quat.getForward()
fwd.normalize()
mvel = self.missile.anpo.getVelocity().length()
self.missile.anpo.setVelocity(fwd*mvel)
except:
return task.done
return task.cont
def can_lock(self):
if self.dist >= 30 and self.dist <= 300 and abs(self.d2.getX()) <= 0.1 and abs(self.d2.getZ()) <= 0.1:
return True
else:
return False
def remove_lock(self):
if self.get_key["LOCKING"]:
self.set_key("LOCKING", False)
self.locker.hide()
self.snd_lock.stop()
self.taskMgr.remove("task-fire-missile")
def to_lock(self):
if self.get_key["LOCK"]:
if self.can_lock():
if self.fuel >= 100:
if not self.get_key["LOCKING"]:
self.set_key("LOCKING", True)
self.locker.setScale(0.12)
self.locker.setColor(1, 0, 0, 0.5)
self.locker.show()
self.snd_lock.play()
self.taskMgr.add(self.fire_missile, "task-fire-missile")
else:
self.remove_lock()
else:
self.remove_lock()
else:
self.remove_lock()
def fire_missile(self, task):
if self.fuel >= 100:
if task.time < 3.6:
e = (3.6 - task.time)/3.6
f = 0.02 + e*0.1
self.locker.setScale(f)
self.locker.setColor(e, 1-e, 0, 0.5)
return task.cont
else:
self.fuel -= 100
self.launch_missile()
return task.done
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 Proyecto(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
#Instrucciones
self.ralph_escape = addInstructions(.06, "[ESC]: Para Salir")
self.ralph_run = addInstructions(.12, "[A]: Para Correr")
self.ralph_saluda = addInstructions(.18, "[S]: Para Saludar")
self.ralph_giraD = addInstructions(.24, "[E]: Girar a la derecha")
self.ralph_giraI = addInstructions(.30, "[Q]: Girar a la izquierda")
# Carga de Actor
"""self.Ralph = Actor("models/ralph",
{"run": "models/ralph-run",
"walk": "models/ralph-walk"})
self.Ralph.setScale(.5,.5,.5)
self.Ralph.reparentTo(self.render)
self.Ralph.setPos(0,10,-1) # X,Y,Z"""
# Carga de imágenes
self.Perro = OnscreenImage(image='src/images/Dog.png')
self.Vaca = OnscreenImage(image='src/images/Cow.png')
self.Leon = OnscreenImage(image='src/images/Lion.png')
self.Perro.setScale(.2, .2, .2)
self.Vaca.setScale(.2, .2, .2)
self.Leon.setScale(.2, .2, .2)
self.Perro.setPos(-1, 0, 0)
self.Vaca.setPos(0, 0, 0)
self.Leon.setPos(1, 0, 0)
# Carga de audio
self.audioPerro = loader.loadSfx("src/sounds/Dog.mp3")
self.audioPerro.play()
#self.audioPerro.play()
# Definir articulaciones con Joint
"""self.BrazoDerecho = self.Ralph.controlJoint(None, 'modelRoot', 'RightShoulder')
self.BrazoIzquierdo = self.Ralph.controlJoint(None, 'modelRoot', 'LeftShoulder')
# Movimientos con el brazo derecho
self.moverBrazoDerechoAbajo = self.BrazoDerecho.hprInterval(1.0, Point3(72.2059, 106.186,-45))
self.moverBrazoDerechoArriba = self.BrazoDerecho.hprInterval(1.0, Point3(72.2059, 76.186, 6.02231))
self.Secuencia1 = Sequence(self.moverBrazoDerechoAbajo, self.moverBrazoDerechoArriba)
# Movimientos con el brazo izquierdo
self.moverBrazoIzquierdoAbajo = self.BrazoIzquierdo.hprInterval(1.0, Point3(160.1401, -22.1706, 6.55722))
self.moverBrazoIzquierdoArriba = self.BrazoIzquierdo.hprInterval(1.0, Point3(80.1401, -52.1706, 6.55722))
self.Secuencia2 = Sequence(self.moverBrazoIzquierdoAbajo, self.moverBrazoIzquierdoArriba)
# Movimientos paralelos
self.Paralelo = Parallel(self.Secuencia1, self.Secuencia2)"""
# Add Eventos
self.accept("escape", sys.exit)
self.accept("a", self.ralphRun)
self.accept("s", self.ralphSaluda)
self.accept("q", self.ralphGiraI)
self.accept("e", self.ralphGiraD)
def ralphRun(self):
self.Ralph.loop("run")
def ralphSaluda(self):
if self.Paralelo.isPlaying():
self.Paralelo.finish()
else:
self.Paralelo.loop()
def ralphGiraI(self):
i = self.Ralph.getH()
self.Ralph.setHpr(i - 10, 0, 0)
def ralphGiraD(self):
i = self.Ralph.getH()
self.Ralph.setHpr(i + 10, 0, 0)
class DemoBase(ShowBase, ABC):
def __init__(self):
super().__init__()
# Allow panda to synthesize shaders. Make sure hardware-animated-vertices is set
# to true in panda config.
render.setShaderAuto()
# Show FPS
self.setFrameRateMeter(True)
# Load character
self.character = Actor('data/character/character')
self.character.reparentTo(self.render)
self.joints = []
for name in JOINT_NAMES:
j = self.character.controlJoint(None, 'modelRoot', name)
j.reparentTo(self.render)
self.joints.append(j)
# Add lights
dlight = core.DirectionalLight('DirectionalLight')
dlight.setDirection(core.LVector3(2, 0, -1))
dlight.setColor(core.LColor(1, 1, 1, 1))
dlnp = self.render.attachNewNode(dlight)
self.render.setLight(dlnp)
alight = core.AmbientLight('AmbientLight')
alight.setColor(core.LColor(0.6, 0.6, 0.6, 1))
alnp = self.render.attachNewNode(alight)
self.render.setLight(alnp)
# Camera angle in xy-plane (degrees)
self.camera_angle = 0
# Camera control
self.cam_left_pressed, self.cam_right_pressed = 0, 0
self.accept('a', self.set_cam_left_pressed, [1])
self.accept('a-up', self.set_cam_left_pressed, [0])
self.accept('d', self.set_cam_right_pressed, [1])
self.accept('d-up', self.set_cam_right_pressed, [0])
# Pad display
self.pad_radius = 60
self.pad_outline = OnscreenImage('project/data/pad/pad_outline.png',
(0, 0, 0))
self.pad_outline.setTransparency(core.TransparencyAttrib.MAlpha)
self.pad_outline.hide()
self.pad_response_circle = OnscreenImage(
'project/data/pad/pad_response_indicator.png', (0, 0, 0))
self.pad_response_circle.setTransparency(
core.TransparencyAttrib.MAlpha)
self.pad_response_circle.hide()
self.accept('window-event', self.handle_window_event)
# Pad control
self.mouse1_pressed, self.controlling_pad = False, False
self.accept('mouse1', self.set_mouse1_pressed, [True])
self.accept('mouse1-up', self.set_mouse1_pressed, [False])
# Load terrain
self.heightmaps = {}
self.set_heightmap('hmap2', 'project/data/heightmaps/hmap2.npy')
# Heightmap choice
self.accept('1', self.set_heightmap,
['hmap1', 'project/data/heightmaps/hmap1.npy'])
self.accept('2', self.set_heightmap,
['hmap2', 'project/data/heightmaps/hmap2.npy'])
self.accept('3', self.set_heightmap,
['hmap3', 'project/data/heightmaps/hmap3.npy'])
self.accept('4', self.set_heightmap,
['hmap4', 'project/data/heightmaps/hmap4.npy'])
self.accept('5', self.set_heightmap,
['hmap5', 'project/data/heightmaps/hmap5.npy'])
# Tasks
self.taskMgr.add(self.update_pad, 'UpdatePadTask', sort=1)
self.last_update_char_time = 0
self.taskMgr.add(self.update_character, 'UpdateCharacterTask', sort=2)
self.last_update_cam_time = 0
self.taskMgr.add(self.update_camera, 'UpdateCameraTask', sort=3)
def set_cam_left_pressed(self, val):
self.cam_left_pressed = val
def set_cam_right_pressed(self, val):
self.cam_right_pressed = val
def set_mouse1_pressed(self, val):
self.mouse1_pressed = val
if self.mouse1_pressed and self.mouseWatcherNode.hasMouse():
mpos = self.screen_coords_to_pixels(
self.mouseWatcherNode.getMouse())
diff = mpos - self.pad_center
self.controlling_pad = diff.lengthSquared() <= self.pad_radius**2
else:
self.controlling_pad = False
def handle_window_event(self, window):
self.window_w, self.window_h = window.getSize()
min_dim = min(self.window_w, self.window_h)
self.pad_radius = min_dim * 0.1
if self.window_w < 1300:
self.pad_center = core.LVector2(min_dim * 0.15, min_dim * 0.15)
else:
self.pad_center = core.LVector2(self.window_w * 0.75,
self.window_h * 0.5)
self.pad_outline.setPos(self.pixels_to_im_coords(self.pad_center))
self.pad_outline.setScale(2 * self.pad_radius / min_dim)
self.pad_outline.show()
self.pad_response_circle.setScale(0.2 * self.pad_radius / min_dim)
# Propagate event
self.windowEvent(window)
# Converts from screen coords in the [-1, 1] range to pixel coords
def screen_coords_to_pixels(self, point):
x_frac, y_frac = (point + 1.0) / 2.0
return core.LVector2(x_frac * self.window_w,
(1 - y_frac) * self.window_h)
# Converts from pixel coords to coords that can be passed in to OnscreenImage.setPos()
def pixels_to_im_coords(self, point):
px, py = point
px, py = px - self.window_w / 2, py - self.window_h / 2
return core.LVector3(px, 0,
-py) * (2.0 / min(self.window_w, self.window_h))
def update_pad(self, task):
if self.controlling_pad and self.mouseWatcherNode.hasMouse():
mpos = self.screen_coords_to_pixels(
self.mouseWatcherNode.getMouse())
pad_input = (mpos - self.pad_center) * PAD_SENSITIVITY
if pad_input.lengthSquared() > 1:
pad_input.normalize()
resp_circle_pos = self.pad_center + pad_input * (self.pad_radius *
0.9)
self.pad_response_circle.setPos(
self.pixels_to_im_coords(resp_circle_pos))
self.pad_response_circle.show()
else:
pad_input = core.LVector2()
self.pad_response_circle.hide()
pad_input.setY(-pad_input.getY()) # flip y
self.pad_input = pad_input
return Task.cont
def set_joint_global_xforms(self, global_xforms):
# Invert global transforms
inverse_global_xforms = [None] * NUM_JOINTS
for i in PARENT_JOINTS:
inverse_global_xforms[i] = core.LMatrix4()
inverse_global_xforms[i].invertAffineFrom(global_xforms[i])
# Use each joint's global xform and the inverse of its parent's global xform to
# compute and apply its local xform
self.joints[0].setMat(global_xforms[0])
for i in range(1, NUM_JOINTS):
local_xform = global_xforms[i] * inverse_global_xforms[
JOINT_PARENTS[i]]
self.joints[i].setMat(local_xform)
def update_character(self, task):
dt = task.time - self.last_update_char_time
self._update_character(task.time, dt)
self.character.setPos(self.char_pos)
self.set_joint_global_xforms([
core.LMatrix4(*m)
for m in self.joint_global_xforms.reshape(31, 16)
])
self.last_update_char_time = task.time
return Task.cont
@abstractmethod
def _update_character(self, t, dt):
'''Should set self.char_pos and self.joint_global_xforms.'''
raise NotImplementedError()
def update_camera(self, task):
dt = task.time - self.last_update_cam_time
# Update camera angle
self.camera_angle += 90 * (self.cam_right_pressed -
self.cam_left_pressed) * dt
# Reposition camera
ang_rads = self.camera_angle * pi / 180
cam_offset = core.LVector3(300 * cos(ang_rads), 300 * sin(ang_rads),
320)
self.camera.setPos(self.char_pos + cam_offset)
self.camera.lookAt(self.char_pos + core.LVector3(0, 0, 80),
core.LVector3(0, 0, 1))
self.last_update_cam_time = task.time
return Task.cont
def set_heightmap(self, name, fname):
if name not in self.heightmaps:
self.heightmaps[name] = Heightmap(name, fname, self.render)
reset = False
if hasattr(self, 'heightmap'):
self.heightmap.model_np.stash()
reset = True
self.heightmap = self.heightmaps[name]
self.heightmap.model_np.unstash()
if reset: self.reset_level()
def reset_level(self):
self.camera_angle = 0
self.char_pos = core.LVector3()
class initGame():
def __init__(self, windowProps, user, connection):
self.user = user
self.connection = connection
render.setShaderAuto()
self.wp = windowProps
# keeps the game running the same on all systems (kinda sorta barely)#
FPS = 60
globalClock = ClockObject.getGlobalClock()
globalClock.setMode(ClockObject.MLimited)
globalClock.setFrameRate(FPS)
globalClock.setMaxDt(1)
self.world = BulletWorld()
self.fakeNode = render.attachNewNode("fakeNode")
self.initFakeGui()
self.playIntroLevelMusic()
self.initBullet()
self.initScore()
self.initCollisions()
self.loadPlayer()
self.createCamera(self.player.np)
self.parseLevelFile("Home")
self.getLevelBounds()
self.startTime()
self.createLight()
self.loadSkyBox()
self.loadControls()
#self.parseStory()
colour = (0.5,0.8,0.8)
expfog = Fog("Scene-wide exponential Fog object")
expfog.setColor(*colour)
expfog.setExpDensity(0.0005)
render.setFog(expfog)
base.setBackgroundColor(*colour)
base.camLens.setFar(1000)
def playIntroLevelMusic(self):
self.music = Music("play","./sounds/batfeet.mp3", .1, True)
def getLevelBounds(self):
self.levelNodeBounds = render.find("renderDummy").getBounds()
def parseStory(self):
self.story = StoryParser("./stories/Story.txt")
def searchDirectories(self):
for root, dirs, files in os.walk("./"):
for name in files:
if name.endswith((".txt")):
print(name)
for name in dirs:
if name == "textures":
for root, dirs, files in os.walk(name):
for name in files:
if name.endswith(".jpg"):
print(name)
def initFakeGui(self):
self.menuBar = OnscreenImage(image = './graphics/MenuBar.png', pos = (0,0,-.94))
self.userText = OnscreenText(text = self.user, pos = (-1.05, -.9625), scale = 0.1)
self.menuBar.setScale(1.625, 1, .0625)
def initScore(self):
self.scoreHandler = ScoreHandler()
def initCollisions(self):
self.collisions = pCollisions(self.scoreHandler, self.music)
def parseLevelFile(self, arg):
if arg == "Home":
self.parsedLevel = LevelParser("./levels/HomeLevel.txt", self.collisions, self.player.np, self.world, self.scoreHandler)
def startTime(self):
self.time = KeepTime()
def initBullet(self):
self.world.setGravity(Vec3(0, 0, -9.81))
self.debugNode = BulletDebugNode('Debug')
self.debugNode.showWireframe(True)
self.debugNode.showConstraints(True)
self.debugNode.showBoundingBoxes(False)
self.debugNode.showNormals(False)
self.debugNP = render.attachNewNode(self.debugNode)
self.world.setDebugNode(self.debugNP.node())
def loadSkyBox(self):
self.skyBox = SkyBox("Box")
def createCamera(self, nodePath):
self.camera = gameCamera(nodePath, self.world, self.collisions)
def loadControls(self):
#args order = bullet update loop, bullet debug node, camera, windowProps, player class, spotLightNode, windowProps, timerTask, bulletWorld, collisions#
self.controlHandler = ControlHandler(self.update, self.debugNP, self.camera, self.wp, self.player, self.time.timerTask, self.world, self.collisions, self.music)
def loadPlayer(self):
self.player = Player(self.collisions, "sphere", self.world, self.music, self.scoreHandler)
#self.player = Player("sphere", self.world, 0, 0, 16)
def createLight(self):
self.lightSource = GameLight(self.player.np)
def update(self, task):
##############################################
# #BULLET UPDATE# #
##############################################
dt = globalClock.getDt()
#self.dtTimer()
self.world.doPhysics(dt*2, 7)
#############################################
# #CAMERA UPDATE# #
#############################################
self.camera.cn.setPos(self.player.np.getPos())
#self.fakeNode.setPos(self.player.np.getPos())
self.camera.hNode.setPos(self.player.np.getPos())
self.camera.pNode.setPos(self.player.np.getPos())
self.camera.cn.setP(self.camera.pNode.getP())
self.camera.cn.setH(self.camera.hNode.getH())
pointer = base.win.getPointer(0)
pointerX = pointer.getX()
pointerY = pointer.getY()
if base.win.movePointer(0, base.win.getXSize()/2, base.win.getYSize ()/2):
if self.camera.inverted == "yes":
Pitch = -((pointerY - base.win.getYSize()/2)*.1)
else:
Pitch = ((pointerY - base.win.getYSize()/2)*.1)
Heading = -((pointerX - base.win.getXSize()/2)*.1)
#endValue = 0
#endValue += Pitch
self.camera.pNode.setP(self.camera.pNode, Pitch)
self.camera.hNode.setH(self.camera.hNode, Heading)
#self.fakeNode.setH(self.fakeNode, Heading)
#############################################
# #PLAYER UPDATE# #
#############################################
force = Vec3(0, 0, 0)
if inputState.isSet('up'):
force.setY(10.0)
if inputState.isSet('down'):
force.setY(-10.0)
if inputState.isSet('left'):
force.setX(-10.0)
if inputState.isSet('right'):
force.setX(10.0)
#force *= 10
force = render.getRelativeVector(self.camera.cn, force)
self.player.np.node().setActive(True)
self.player.np.node().applyCentralForce(force)
#self.player.np.setColor(random.random(), random.random(), random.random(), random.random())
if self.player.np.getZ() < 0 - (self.levelNodeBounds.getRadius() * 6):
self.player.np.setPos(self.collisions.level.spawn)
self.player.np.node().setLinearVelocity(Vec3(0,0,0))
return task.cont
class RightMenu:
"""
Add comment.
"""
def __init__(self):
self.visible_x_np = None
self.visible_y_np = None
self.visible_z_np = None
self.filter_label_np = None
self.dims_parent_np = None
# Dictionary for the tagset/dims
self.dimensionCards = {}
# Member variable for dimension/filter context menu.
self.selected_tagset_id = None
self.selected_hierarchy_id = None
self.selected_filter_id = None
# Create nodepath for the menu.
self.right_menu_node_path = camera.attachNewNode(
'right_menu_node_path')
self.right_menu_node_path.setY(3)
# Flag for right menu visability.
self.is_visable = True
# Create background for the menu.
self.bg = OnscreenImage(image='static/images/box.tif')
self.bg.setTransparency(TransparencyAttrib.MAlpha)
self.bg.setAlphaScale(0.24)
self.bg.setScale(1, 2, 2)
# start the placement task for menu placement.
base.taskMgr.add(self.__placement, 'menuplacement_left_panel')
# Collections of cards. Used for card highlighting.
self.cards = dict()
# How many dimensions should we show in the dimension list?
self.max_dimension_visable_in_menu = 10
# Member variable for the dimensions scrollbar if needed.
self.dimension_scrollbar = None
# Create all the objects for this menu.
self.__initalize_objects()
self.__createTagsetAndHierarchyLabels()
self.__register_view_menu_messages()
# Create instance of filter menu.
self.filter_menu = FilterMenu(np=self.right_menu_node_path,
begin_pos=self.last_dim_pos)
# Events that we are interested in.
base.accept(CUBE_MENU_RELOAD_FILTERS, self.reload_filter2)
base.accept(TAGSET_BTN_CLICK, self.btn_dimensions)
base.accept(HIERARCHY_BTN_CLICK, self.btn_hierarchy)
base.accept(SEARCH_BTN_CLICK, self.btn_search)
base.accept(FILTER_BTN_CLICK, self.btn_filters)
base.accept(CUBE_MENU_OVERVIEW_X_BUTTON_CLICK, self.btn_x_view)
base.accept(CUBE_MENU_OVERVIEW_Y_BUTTON_CLICK, self.btn_y_view)
base.accept(CUBE_MENU_OVERVIEW_Z_BUTTON_CLICK, self.btn_z_view)
base.accept(CUBE_MENU_RELOAD_DIMENSIONS, self.reloadDimensionLabels)
def reloadDimensionLabels(self):
"""
Function for reloading the tagset/hir list.
This function is called when tagset/hir is changed
or new are added.
"""
self.__createTagsetAndHierarchyLabels()
#self.reload()
def __createTagsetAndHierarchyLabels(self):
if self.dims_parent_np is not None:
self.dims_parent_np.remove()
if self.dimension_scrollbar is not None:
self.dimension_scrollbar.remove()
# Create labels for each tagset and hirs.
card_pos = -1.1
index = 0
# List that contains the dimension cards. Used for scrolling the cards.
self.dimension_list = []
#self.cards = dict()
self.dims_parent_np = self.right_menu_node_path.attachNewNode(
'parent_dim_np')
for tagset in photocube.objectcube.objectCubeService.getAllTagsets():
if (tagset.typeId == 1 or tagset.typeId == 5) and (
tagset.name[:5] != 'Rank:' and tagset.name[:5] != 'Dist:'
): #FOR MASTER PRESENTATION, NOT SHOWING SEARCH DIMENSION
#print 'tagset.name: ' + tagset.name + 'tagset.typeId: ' + str(tagset.typeId)
dim_np = self.dims_parent_np.attachNewNode('dim;tagset;' +
str(tagset.id))
# Create a card to make the dimension clickable
card_np = dim_np.attachNewNode('card-tagset-' + tagset.name)
card_np = card_np.attachNewNode('card-x-label-np')
card_np.setPos(1, 1.5, 1.5)
cm = CardMaker('card')
card = card_np.attachNewNode(cm.generate())
card.setScale(0.50, 1, 0.050)
card.setPos(-2.045, -1.3, card_pos)
card.setTwoSided(True)
card.setColor(0, 0, 0)
# Make the tagset cards clickable.
base.accept(
photocube.devices.mouse_handler.makeNPPickableRight(
dim_np), self.on_tagset_right_click)
base.accept(
photocube.devices.mouse_handler.makeNPPickableLeft(dim_np),
self.on_tagset_right_click)
# Create a new node for the text label.
t_node = card.attachNewNode('card-label' + tagset.name)
t_node.setY(-0.001)
t_node.setZ(1.35)
t_node.setX(0.03)
t = OnscreenText(text=tagset.name[0:43] + ' (tagset)',
fg=(1, 1, 1, 1),
parent=t_node,
pos=(0, -1, -4),
scale=(0.075, 0.73),
align=TextNode.ALeft)
# Make the dim button mouse over enabled.
if dim_np.__str__() not in self.cards.keys():
self.cards[dim_np.__str__()] = card
self.dimension_list.append(dim_np)
messageHover, messageLeave = photocube.devices.mouse_handler.makeNPMouseHoverable(
dim_np)
# When created, the menu is hided.
dim_np.hide()
# Accept the hover messages.
base.accept(messageLeave, self.mouse_leave)
base.accept(messageHover, self.mouse_over)
"""
dim_np = self.dims_parent_np.attachNewNode('dim;tagset;' + str(tagset.id))
# Create a card to make the dimension clickable
card_np = dim_np.attachNewNode('card-tagset-'+ tagset.name)
card_np = card_np.attachNewNode('card-x-label-np')
card_np.setPos(1,1.5,1.5)
cm = CardMaker('card')
card = card_np.attachNewNode(cm.generate())
card.setScale(0.50, 1, 0.050)
card.setPos(-2.045, -1.3, card_pos)
card.setTwoSided(True)
card.setColor(0,0,0)
# Make the tagset cards clickable.
base.accept(photocube.devices.mouse_handler.makeNPPickableRight(dim_np), self.on_tagset_right_click)
base.accept(photocube.devices.mouse_handler.makeNPPickableLeft(dim_np), self.on_tagset_right_click)
# Create a new node for the text label.
t_node = card.attachNewNode( 'card-label' + tagset.name )
t_node.setY(-0.001)
t_node.setZ(1.35)
t_node.setX(0.03)
t = OnscreenText(text=tagset.name[0:43] + ' (tagset)', fg=(1,1,1,1), parent=t_node, pos=(0, -1, -4), scale=(0.075, 0.73), align=TextNode.ALeft)
# Make the dim button mouse over enabled.
if dim_np.__str__() not in self.cards.keys():
self.cards[ dim_np.__str__() ] = card
self.dimension_list.append( dim_np )
messageHover,messageLeave = photocube.devices.mouse_handler.makeNPMouseHoverable( dim_np )
# When created, the menu is hided.
dim_np.hide()
# Accept the hover messages.
base.accept(messageLeave, self.mouse_leave)
base.accept(messageHover, self.mouse_over)
"""
# show the hir
if tagset.name[:5] != 'Rank:' and tagset.name[:5] != 'Dist:': #FOR MASTER PRESENTATION, NOT SHOWING SEARCH DIMENSION
for hir in tagset.getPersistentDimensions():
hir_np = self.dims_parent_np.attachNewNode('dim;hir;' +
tagset.name +
';' +
str(hir.id) +
';' +
str(tagset.id))
# Create a card to make the dimension clickable
card_np = hir_np.attachNewNode('card-tagset-' +
tagset.name)
card_np = card_np.attachNewNode('card-x-label-np')
card_np.setPos(1, 1.5, 1.5)
cm = CardMaker('card-hir')
card = card_np.attachNewNode(cm.generate())
card.setScale(0.50, 1, 0.050)
card.setPos(-2.045, -1.3, card_pos)
card.setTwoSided(True)
card.setColor(0, 0, 0)
# Make the hierachy card clickable.
base.accept(
photocube.devices.mouse_handler.makeNPPickableRight(
hir_np), self.on_hierarchy_right_click)
base.accept(
photocube.devices.mouse_handler.makeNPPickableLeft(
hir_np), self.on_hierarchy_right_click)
# Make the hierachy card hoverable.
messageHover, messageLeave = photocube.devices.mouse_handler.makeNPMouseHoverable(
hir_np)
base.accept(messageHover, self.mouse_over)
base.accept(messageLeave, self.mouse_leave)
# Create a new node for the text label.
t_node = card.attachNewNode('card-label' + tagset.name)
t_node.setY(-0.001)
t_node.setZ(1.35)
t_node.setX(0.03)
t = OnscreenText(text=hir.getRoot().name + ' (hierarchy)',
fg=(1, 1, 1, 1),
parent=t_node,
pos=(0, -1, -4),
scale=(0.075, 0.73),
align=TextNode.ALeft)
# Make the dim button mouse over enabled.
if hir_np.__str__() not in self.cards.keys():
self.cards[hir_np.__str__()] = card
self.dimension_list.append(hir_np)
photocube.devices.mouse_handler.makeNPMouseHoverable(
hir_np)
# Create label for filters
if len(self.dimension_list) < self.max_dimension_visable_in_menu:
self.last_dim_pos = -0.025 * len(self.dimension_list)
else:
self.last_dim_pos = -0.25
self.dimension_scrollbar = DirectScrollBar(
range=(0, math.ceil(len(self.dimension_list))),
orientation=DGG.VERTICAL,
command=self.on_dimension_scroll_change,
scrollSize=5,
pageSize=len(self.dimension_list) / 5,
value=0)
self.dimension_scrollbar.setScale(0.5, 1, 0.69)
self.dimension_scrollbar['frameColor'] = (0.6, 0.6, 0.6, 0.8)
# disable the click sound for the scrollbar.
self.dimension_scrollbar[
'incButton_clickSound'] = button_mouseclick_sound
self.dimension_scrollbar['incButton_rolloverSound'] = None
self.dimension_scrollbar[
'decButton_clickSound'] = button_mouseclick_sound
self.dimension_scrollbar['decButton_rolloverSound'] = None
self.dimension_scrollbar['thumb_clickSound'] = None
self.dimension_scrollbar['thumb_rolloverSound'] = None
self.dimension_scrollbar['incButton_relief'] = None
self.dimension_scrollbar['decButton_relief'] = None
self.dimension_scrollbar['decButton_text'] = '-'
self.dimension_scrollbar['decButton_text_scale'] = 0.07
self.dimension_scrollbar['incButton_text'] = '+'
self.dimension_scrollbar['incButton_text_scale'] = (0.07, 0.05)
self.dimension_scrollbar['incButton_text_pos'] = (-0.005, -0.02)
self.dimension_scrollbar['decButton_text_pos'] = (-0.005, -0.02)
self.dimension_scrollbar['thumb_frameColor'] = (0, 0, 0, 0.2)
self.dimenion_scroll_value = self.dimension_scrollbar['value']
self.text_dims = OnscreenText(mayChange=True,
text='Filters:',
fg=(1, 1, 1, 1),
parent=self.right_menu_node_path,
pos=(-1.10, self.last_dim_pos, -10),
scale=(0.040),
align=TextNode.ALeft)
# create nodepath for the filter labels
self.filter_label_np = self.right_menu_node_path.attachNewNode(
'filter-label-np')
self.current_dimension_index_left = 0
self.current_dimension_index_right = self.max_dimension_visable_in_menu - 1
self.show_dimension_tabs()
def __initalize_objects(self):
# refactored from the function for dims labels reload
self.text_dims = OnscreenText(text='Dimensions:',
fg=(1, 1, 1, 1),
parent=self.right_menu_node_path,
pos=(-1.10, 0.45, -10),
scale=0.040,
align=TextNode.ALeft)
# Create a label for the menu.
self.text_dims = OnscreenText(mayChange=True,
text='Visible:',
fg=(1, 1, 1, 1),
parent=self.right_menu_node_path,
pos=(-1.10, 0.74, -10),
scale=(0.040),
align=TextNode.ALeft)
self.visible_x_np = self.right_menu_node_path.attachNewNode(
'np_visiable_x')
self.visible_x_np.setPos(-0.50, 0, 0.85)
self.visible_x_np.setScale(0.6)
self.text_x = OnscreenText(mayChange=True,
text=EMPTY_ON_FRONT,
fg=(1, 1, 1, 1),
parent=self.visible_x_np,
align=TextNode.ALeft,
pos=(-0.95, -0.29, -0.21),
scale=0.075)
# Create clicable card for x.
card_np = self.visible_x_np.attachNewNode(
'card-x-label-np').attachNewNode('card-x-label-np')
card_np.setPos(1, 1.5, 1.5)
cm = CardMaker('card-x')
card = card_np.attachNewNode(cm.generate())
card.setScale(0.8, 1, 0.1)
card.setPos(-1.93, -1.3, -1.78)
card.setTwoSided(True)
card.setColor(0, 0, 0)
# Make the x view nodepath clickable.
self.curXDimRightClickMessage = mouse_handler.makeNPPickableRight(
self.visible_x_np)
self.curXDimLeftClickMessage = mouse_handler.makeNPPickableLeft(
self.visible_x_np)
# Make the x view nodepath mouseoverable and save the nodepath for making it glow.
self.cards[self.visible_x_np.__str__()] = card
leavemessage, hoverMessage = photocube.devices.mouse_handler.makeNPMouseHoverable(
self.visible_x_np)
base.accept(hoverMessage, self.mouse_leave)
base.accept(leavemessage, self.mouse_over)
# Create notepath for y
self.visible_y_np = self.right_menu_node_path.attachNewNode(
'np_visiable_y')
self.visible_y_np.setPos(-0.50, 0, 0.78)
self.visible_y_np.setScale(0.6)
self.text_y = OnscreenText(mayChange=True,
text=EMPTY_ON_IN,
fg=(1, 1, 1, 1),
parent=self.visible_y_np,
align=TextNode.ALeft,
pos=(-0.95, -0.29, 0.21),
scale=0.075)
# Create clicable card for y.
card_np = self.visible_y_np.attachNewNode(
'card-y-label-np').attachNewNode('card-y-label-np')
card_np.setPos(1, 1.5, 1.5)
cm = CardMaker('card-y')
card = card_np.attachNewNode(cm.generate())
card.setScale(0.8, 1, 0.1)
card.setPos(-1.93, -1.3, -1.78)
card.setTwoSided(True)
card.setColor(0, 0, 0)
card.setTransparency(TransparencyAttrib.MAlpha)
self.curYDimRightClickMessage = mouse_handler.makeNPPickableRight(
self.visible_y_np)
self.curYDimLeftClickMessage = mouse_handler.makeNPPickableLeft(
self.visible_y_np)
# Make the y view nodepath mouseoverable.
self.cards[self.visible_y_np.__str__()] = card
#TODO: Here is a good place to refactor.
photocube.devices.mouse_handler.makeNPMouseHoverable(self.visible_y_np)
base.accept('zoomout_render/camera/right_menu_node_path/np_visiable_y',
self.mouse_leave)
base.accept('zoomin_render/camera/right_menu_node_path/np_visiable_y',
self.mouse_over)
# Create notepath for z
self.visible_z_np = self.right_menu_node_path.attachNewNode(
'np_visiable_z')
self.visible_z_np.setPos(-0.50, 0, 0.71)
self.visible_z_np.setScale(0.6)
self.text_z = OnscreenText(mayChange=True,
text=EMPTY_ON_UP,
fg=(1, 1, 1, 1),
parent=self.visible_z_np,
align=TextNode.ALeft,
pos=(-0.95, -0.28, 0.21),
scale=0.075)
# Create clicable card for y.
card_np = self.visible_z_np.attachNewNode(
'card-z-label-np').attachNewNode('card-z-label-np')
card_np.setPos(1, 1.5, 1.5)
cm = CardMaker('card-z')
card = card_np.attachNewNode(cm.generate())
card.setScale(0.8, 1, 0.1)
card.setPos(-1.93, -1.3, -1.78)
card.setTwoSided(True)
card.setColor(0, 0, 0)
card.setTransparency(TransparencyAttrib.MAlpha)
self.curZDimRightClickMessage = mouse_handler.makeNPPickableRight(
self.visible_z_np)
self.curZDimLeftClickMessage = mouse_handler.makeNPPickableLeft(
self.visible_z_np)
# Make the z view nodepath mouseoverable.
self.cards[self.visible_z_np.__str__()] = card
photocube.devices.mouse_handler.makeNPMouseHoverable(self.visible_z_np)
base.accept('zoomout_render/camera/right_menu_node_path/np_visiable_z',
self.mouse_leave)
base.accept('zoomin_render/camera/right_menu_node_path/np_visiable_z',
self.mouse_over)
def on_dimension_scroll_change(self):
val = int(self.dimension_scrollbar['value'])
#print 'val', val
if val == self.dimenion_scroll_value:
return
elif val < self.dimenion_scroll_value:
for n in range(self.dimenion_scroll_value - val):
self.dim_menu_move_up()
else:
for n in range(val - self.dimenion_scroll_value):
self.dim_menu_move_down()
#self.dimenion_scroll_value = self.dimension_scrollbar['value']
self.dimenion_scroll_value = val
def show_dimension_tabs(self):
card_pos = 0
i = 0
for card in self.dimension_list:
card.hide()
card.setX(100)
for r in range(self.current_dimension_index_left,
len(self.dimension_list)):
self.dimension_list[r].show()
self.dimension_list[r].setZ(card_pos)
self.dimension_list[r].setX(0)
card_pos -= 0.06
i += 1
if i is self.max_dimension_visable_in_menu:
break
def dim_menu_move_down(self):
r = len(self.dimension_list) - self.current_dimension_index_right
if r > 1:
self.current_dimension_index_left += 1
self.current_dimension_index_right += 1
self.show_dimension_tabs()
def dim_menu_move_up(self):
if self.current_dimension_index_left > 0:
self.current_dimension_index_left -= 1
self.current_dimension_index_right -= 1
self.show_dimension_tabs()
def btn_filters(self, index):
self.filter_menu.btn_filters(index)
def mouse_over(self, p):
if not photocube.ui.coremenu.context_menu_handler.has_open_context():
#print 'here', p
c = self.cards[p.__str__()]
#print c
self.current_glowing_card = c
c.setColor(0.15, 0.15, 0.15)
def mouse_leave(self, p):
if not photocube.ui.coremenu.context_menu_handler.has_open_context():
c = self.cards[p.__str__()]
c.setColor(0, 0, 0)
self.current_glowing_card = None
def clear_glow(self, f=None):
if not photocube.ui.coremenu.context_menu_handler.has_open_context():
#print 'clear'
self.clear_all_glowings()
def clear_all_glowings(self):
for key in self.cards.keys():
card = self.cards[key]
card.setColor(0, 0, 0)
self.current_glowing_card = None
def btn_x_view(self, index):
self.clear_glow()
if index == 'view up':
x = photocube.cube.cubeService.coordinate.get_x()
if x is not None:
messenger.send('dim_move_to_axis', [X_AXIS, Z_AXIS])
action = ActionAxis(ACTION_MOVE, X_AXIS, Z_AXIS)
actionManager.addAction(action)
if index == 'view in':
x = photocube.cube.cubeService.coordinate.get_x()
if x is not None:
messenger.send('dim_move_to_axis', [X_AXIS, Y_AXIS])
action = ActionAxis(ACTION_MOVE, X_AXIS, Y_AXIS)
actionManager.addAction(action)
if index == "swap with up":
messenger.send('x_dim_action_swap', [Z_AXIS])
# create action for the swap.
action = ActionAxis(ACTION_SWAP, X_AXIS, Z_AXIS)
actionManager.addAction(action)
if index == "swap with in":
messenger.send('x_dim_action_swap', [Y_AXIS])
# create action for the swap.
action = ActionAxis(ACTION_SWAP, X_AXIS, Y_AXIS)
actionManager.addAction(action)
if index is 'clear':
messenger.send('dim_action_clear', [X_AXIS])
action = ActionAxis(ACTION_CLEAR, X_AXIS)
actionManager.addAction(action)
def btn_y_view(self, index):
"""
This function is called when we select buttons
in the view y context menu.
"""
self.clear_glow()
if index == 'clear':
messenger.send('dim_action_clear', [Y_AXIS])
action = ActionAxis(ACTION_CLEAR, Y_AXIS)
actionManager.addAction(action)
if index == 'view front':
y = photocube.cube.cubeService.coordinate.get_y()
if y is not None:
messenger.send('dim_move_to_axis', [Y_AXIS, X_AXIS])
action = ActionAxis(ACTION_MOVE, Y_AXIS, X_AXIS)
actionManager.addAction(action)
if index == 'view up':
y = photocube.cube.cubeService.coordinate.get_y()
if y is not None:
messenger.send('dim_move_to_axis', [Y_AXIS, Z_AXIS])
action = ActionAxis(ACTION_MOVE, Y_AXIS, Z_AXIS)
actionManager.addAction(action)
if index == "swap with front":
messenger.send('y_dim_action_swap', [X_AXIS])
action = ActionAxis(ACTION_SWAP, Y_AXIS, X_AXIS)
actionManager.addAction(action)
if index == "swap with up":
messenger.send('y_dim_action_swap', [Z_AXIS])
action = ActionAxis(ACTION_SWAP, Y_AXIS, Z_AXIS)
actionManager.addAction(action)
def btn_z_view(self, index):
self.clear_glow()
if index == 'clear':
messenger.send('dim_action_clear', [Z_AXIS])
action = ActionAxis(ACTION_CLEAR, Z_AXIS)
actionManager.addAction(action)
if index == 'view front':
z = photocube.cube.cubeService.coordinate.get_z()
if z is not None:
messenger.send('dim_move_to_axis', [Z_AXIS, X_AXIS])
action = ActionAxis(ACTION_MOVE, Z_AXIS, X_AXIS)
actionManager.addAction(action)
if index == 'view in':
z = photocube.cube.cubeService.coordinate.get_z()
if z is not None:
messenger.send('dim_move_to_axis', [Z_AXIS, Y_AXIS])
action = ActionAxis(ACTION_MOVE, Z_AXIS, Y_AXIS)
actionManager.addAction(action)
if index == "swap with front":
messenger.send('z_dim_action_swap', [X_AXIS])
action = ActionAxis(ACTION_SWAP, Z_AXIS, X_AXIS)
actionManager.addAction(action)
if index == "swap with in":
messenger.send('z_dim_action_swap', [Y_AXIS])
action = ActionAxis(ACTION_SWAP, Z_AXIS, Y_AXIS)
actionManager.addAction(action)
def btn_dimensions(self, index):
self.clear_glow()
tagset = photocube.objectcube.objectCubeService.get_tagset_by_id(
self.selected_tagset_id)
if index == 'view front':
action = ActionTagset(ACTION_SET, tagset.id, X_AXIS)
actionManager.addAction(action)
messenger.send('dim_view_tagset', [X_AXIS, tagset])
if index == 'view in':
action = ActionTagset(ACTION_SET, tagset.id, Y_AXIS)
actionManager.addAction(action)
messenger.send('dim_view_tagset', [Y_AXIS, tagset])
if index == 'view up':
action = ActionTagset(ACTION_SET, tagset.id, Z_AXIS)
actionManager.addAction(action)
messenger.send('dim_view_tagset', [Z_AXIS, tagset])
if index == 'add dimension filter':
dim_filter = ObjectCubePython.DimensionFilter(
tagset.getDefaultDimension().getRoot(), tagset.id)
filterManager.add_filter(dim_filter, True)
# add action
action = ActionFilter(ACTION_DIMENSIONFILTER,
ACTION_ADD,
tagsetId=tagset.id)
actionManager.addAction(action)
# reload filters menu.
self.reload_filter2()
if index == 'add tag filter':
photocube.dialogs.dialogService.open_add_tagfilter(tagset)
if index == 'add range filter':
if tagset.typeId == 3:
photocube.dialogs.dialogService.open_add_date_range(tagset)
elif tagset.typeId == 4:
photocube.dialogs.dialogService.open_add_time_range(tagset)
else:
photocube.dialogs.dialogService.open_add_numerical_range(
tagset)
if index == 'edit':
photocube.dialogs.dialogService.openCreateNewTagsetDialog(tagset)
def btn_hierarchy(self, index):
# Get the tagset that the hir belongs to.
tagset = photocube.objectcube.objectCubeService.get_tagset_by_id(
self.selected_tagset_id)
print 'selected_hierarchy_id: ' + str(self.selected_hierarchy_id)
# Get the hirarchy from the tagset.
dim = tagset.getDimension(int(self.selected_hierarchy_id))
print 'Dimension click'
if index == 'view front':
print 'DimId: ' + str(dim.id)
print 'TagSetId: ' + str(tagset.id)
print index + ': Begin'
print 'ACTION_SET'
print ACTION_SET
print 'X_AXIS'
print X_AXIS
action = ActionHierachy(ACTION_SET, tagset.id, dim.id, X_AXIS)
actionManager.addAction(action)
print 'action'
print action
messenger.send('dim_view_hierarchy', [X_AXIS, dim])
print index + ': End'
elif index == 'view in':
action = ActionHierachy(ACTION_SET, tagset.id, dim.id, Y_AXIS)
actionManager.addAction(action)
messenger.send('dim_view_hierarchy', [Y_AXIS, dim])
elif index == 'view up':
action = ActionHierachy(ACTION_SET, tagset.id, dim.id, Z_AXIS)
actionManager.addAction(action)
messenger.send('dim_view_hierarchy', [Z_AXIS, dim])
elif index == 'add dimension filter':
dim_filter = ObjectCubePython.DimensionFilter(
dim.getRoot(), tagset.id)
filterManager.add_filter(dim_filter, True)
# add action
action = ActionFilter(ACTION_DIMENSIONFILTER,
ACTION_ADD,
tagsetId=tagset.id,
hirarchyId=int(self.selected_hierarchy_id))
actionManager.addAction(action)
self.reload_filter2()
else:
raise Exception('btn_hierarchy: unknown index: ' + index)
def btn_search(self, index):
tagset = photocube.objectcube.objectCubeService.get_tagset_by_id(
self.selected_tagset_id)
if index == 'search':
print 'Vuubidu'
photocube.dialogs.dialogService.openSearchDialogWithTagSet(tagset)
def reload_filter2(self):
self.filter_menu.reload()
def on_x_view_right_click(self, f):
photocube.ui.coremenu.context_menu_handler.open_x_view_context()
def open_context_view_y(self, f):
photocube.ui.coremenu.context_menu_handler.open_y_view_context()
def open_context_view_z(self, f):
photocube.ui.coremenu.context_menu_handler.open_z_view_context()
def on_hierarchy_right_click(self, f):
split_list = f.__str__().split(';')
self.selected_hierarchy_id = int(split_list[3])
self.selected_tagset_id = int(split_list[4])
photocube.ui.coremenu.context_menu_handler.open_context_hierarchy()
def on_tagset_right_click(self, f):
"""
Function for opening dimension context.
"""
split_list = f.__str__().split(';')
self.selected_tagset_id = int(split_list[len(split_list) - 1])
t_id = photocube.objectcube.objectCubeService.get_tagset_by_id(
self.selected_tagset_id).typeId
print 't_id' + str(t_id)
if t_id == photocube.objectcube.framework.TagSet.TYPE.ALPHANUMERICAL:
print 'ALPHANUMERICAL'
photocube.ui.coremenu.context_menu_handler.open_context_tagset_search_alphanumerical(
)
elif t_id == photocube.objectcube.framework.TagSet.TYPE.RGB:
print 'RGB'
photocube.ui.coremenu.context_menu_handler.open_context_tagset_search_rgb(
)
'''
if t_id == photocube.objectcube.framework.TagSet.TYPE.ALPHANUMERICAL:
photocube.ui.coremenu.context_menu_handler.open_context_tagset_alphanumerical()
else:
photocube.ui.coremenu.context_menu_handler.open_context_tagset_numerical()
'''
def hide(self):
#self.right_menu_node_path.hide()
if self.dimension_scrollbar is not None:
self.dimension_scrollbar.hide()
self.filter_menu.hide()
# hide the background image
self.bg.hide()
self.is_visable = False
def show(self):
#self.right_menu_node_path.show()
if self.dimension_scrollbar is not None:
self.dimension_scrollbar.show()
#self.filter_menu.show()
# hide the background image
#self.bg.show()
self.is_visable = True
def setXViewText(self, text):
self.text_x.setText('front: ' + text)
def setYViewText(self, text):
self.text_y.setText('in: ' + text)
def setZViewText(self, text):
self.text_z.setText('up: ' + text)
def __register_view_menu_messages(self):
# Click messages for dimensions.
base.accept(self.curXDimRightClickMessage, self.on_x_view_right_click)
base.accept(self.curXDimLeftClickMessage, self.on_x_view_right_click)
base.accept(self.curYDimRightClickMessage, self.open_context_view_y)
base.accept(self.curYDimLeftClickMessage, self.open_context_view_y)
base.accept(self.curZDimRightClickMessage, self.open_context_view_z)
base.accept(self.curZDimLeftClickMessage, self.open_context_view_z)
base.accept('clear_glow', self.clear_glow)
base.accept('zoomout_none', self.clear_glow)
def __placement(self, task):
"""
Called to fix the size, location of object when the aspect changes.
"""
if self.is_visable:
base.camLens.setAspectRatio(base.getAspectRatio())
wp = base.win.getProperties()
base.camLens.setAspectRatio(
(wp.getXSize() + 0.0) / (wp.getYSize() + 0.0))
self.right_menu_node_path.show()
self.right_menu_node_path.setX(
(base.getAspectRatio() + (0.40 / base.getAspectRatio())))
# Fix the position of the menu background image.
self.bg.setX(0.32 + base.getAspectRatio())
if self.dimension_scrollbar is not None:
self.dimension_scrollbar.setX(base.getAspectRatio() - 0.04)
self.dimension_scrollbar.setZ(0.18)
else:
# set the position for the dimensino buttons
base.camLens.setAspectRatio(base.getAspectRatio())
wp = base.win.getProperties()
base.camLens.setAspectRatio(
(wp.getXSize() + 0.0) / (wp.getYSize() + 0.0))
#self.right_menu_node_path.setX( (base.getAspectRatio()+(0.3/base.getAspectRatio())) )
self.right_menu_node_path.hide()
self.right_menu_node_path.setX(500)
#THIS IS NOT ALLOWD, CLOSES CLUSTER MENUS AS WELL!
#messenger.send('CLOSE_ALL_CONTEXT')
# Fix the position of the menu background image.
self.bg.setX(0.95 + base.getAspectRatio())
self.bg.show()
return task.cont
class MainMenu(DirectObject):
def __init__(self, skipIntro=False):
render.show()
engine.Mouse.showCursor()
# In case we just got back from the tutorial, which hides everything
# sometimes.
engine.renderLit.show()
self.backgroundSound = audio.FlatSound("menu/background.ogg",
volume=0.3)
self.backgroundSound.setVolume(0)
self.backgroundSound.setLoop(True)
self.clickSound = audio.FlatSound("menu/click.ogg", volume=0.3)
self.active = True
self.accept("escape", self.escape)
self.accept("mouse1", self.click)
self.cameraDistance = 20
self.globe = engine.loadModel("menu/Globe")
self.globe.reparentTo(render)
self.globe.setTransparency(TransparencyAttrib.MAlpha)
self.globe.setColor(Vec4(1, 1, 1, 0.6))
self.globe.setTwoSided(True)
self.globe.setRenderModeWireframe()
self.overlay = camera.attachNewNode("overlay")
self.overlay.setTransparency(TransparencyAttrib.MAlpha)
self.overlay.setColor(Vec4(1, 1, 1, 0))
self.overlay.setPos(0, 0, 0)
self.overlay.setPos(0, self.cameraDistance, 0)
self.overlay1 = engine.loadModel("menu/overlay1")
self.overlay1.setScale(4)
self.overlay1.setTwoSided(True)
self.overlay1.setRenderModeWireframe()
self.overlay1.reparentTo(self.overlay)
self.overlay2 = engine.loadModel("menu/overlay2")
self.overlay2.setScale(4)
self.overlay2.setTwoSided(True)
self.overlay2.setRenderModeWireframe()
self.overlay2.reparentTo(self.overlay)
self.overlay3 = engine.loadModel("menu/overlay3")
self.overlay3.setScale(4)
self.overlay3.setTwoSided(True)
self.overlay3.setRenderModeWireframe()
self.overlay3.setR(uniform(0, 360))
self.overlay3.setP(uniform(0, 360))
self.overlay3.setH(uniform(0, 360))
self.overlay3.reparentTo(self.overlay)
self.overlay4 = engine.loadModel("menu/overlay3")
self.overlay4.setScale(4)
self.overlay4.setTwoSided(True)
self.overlay4.setRenderModeWireframe()
self.overlay4.setH(uniform(0, 360))
self.overlay4.setR(uniform(0, 360))
self.overlay4.setP(uniform(0, 360))
self.overlay4.reparentTo(self.overlay)
self.text = engine.loadModel("menu/text")
self.text.setScale(4)
self.text.setTwoSided(True)
self.text.reparentTo(self.overlay)
self.selector = engine.loadModel("menu/selector")
self.selector.setScale(4)
self.selector.setTwoSided(True)
self.selector.reparentTo(self.overlay)
self.selectedItem = 0
self.skyBox = engine.loadModel("menu/skybox")
self.skyBox.setScale(self.cameraDistance * 5)
self.skyBox.setRenderModeWireframe()
self.skyBox.setTwoSided(True)
self.skyBox.reparentTo(render)
self.skyBox.setTransparency(TransparencyAttrib.MAlpha)
self.skyBox.setColor(Vec4(1, 1, 1, 0))
cmbg = CardMaker("background")
size = 10
cmbg.setFrame(-size * engine.aspectRatio, size * engine.aspectRatio,
-size, size)
self.background = camera.attachNewNode(cmbg.generate())
self.background.setTexture(loader.loadTexture("menu/background.jpg"),
1)
self.background.setPos(0, size * 1.25, 0)
self.background.setDepthWrite(False)
self.belt = JunkBelt(5)
self.angle = uniform(0, 360)
self.period = 60
self.uiAngle = 0
self.logo = OnscreenImage(image="menu/logo.png",
pos=(0, 0, 0),
scale=((512.0 / 175.0) * 0.075, 0, 0.075))
self.logo.setTransparency(TransparencyAttrib.MAlpha)
self.logo.setColor(1, 1, 1, 0)
self.logo.setBin("transparent", 0)
self.loadingScreen = OnscreenImage(image="menu/loading.jpg",
pos=(0, 0, 0))
self.loadingScreen.setScale(render2d, VBase3(1))
self.loadingScreen.setSx(2)
self.loadingScreen.hide()
self.skipToEndOfTutorial = skipIntro
global firstBoot
firstBoot = False
self.introTime = 2
if firstBoot and not skipIntro:
self.introTime = 4
self.showLogin = firstBoot
self.hostList = ui.HostList(self.startClient)
self.mapList = ui.MapList(self.startServer)
self.loginDialog = ui.LoginDialog(self.setUsername)
self.loginDialogShown = False
self.introSound = audio.FlatSound("menu/intro.ogg", volume=0.15)
self.introSound.play()
self.clientConnectAddress = None
self.serverMapName = None
self.serverMode = 0 # 0 for normal, 1 for tutorial
self.serverGameType = 0 # 0 for deathmatch, 1 for survival
self.username = "******"
self.startTime = -1
self.goTime = -1
if base.appRunner is not None:
token = base.appRunner.getToken("username")
if token != "" and token != "Unnamed":
self.setUsername(token)
self.loginDialogShown = True
def escape(self):
if self.hostList.visible:
self.hostList.hide()
elif self.mapList.visible:
self.mapList.hide()
def startClient(self, host):
self.clickSound.play()
self.hostList.hide()
self.loadingScreen.show()
self.clientConnectAddress = host
self.goTime = engine.clock.time
def startServer(self, map, gametype):
# Tutorial works on Point Control maps.
if not (self.serverMode == 1 and gametype == 1):
self.clickSound.play()
self.mapList.hide()
self.loadingScreen.show()
self.serverMapName = map
self.serverGameType = gametype
self.goTime = engine.clock.time
def setUsername(self, username):
self.clickSound.play()
self.username = username
engine.savedUsername = self.username
engine.saveConfigFile()
self.loginDialog.hide()
def update(self):
if not self.active:
return
net.context.readTick()
if self.startTime == -1:
self.startTime = engine.clock.time
elapsedTime = engine.clock.time - self.startTime
if elapsedTime < self.introTime:
blend = elapsedTime / self.introTime
self.angle += engine.clock.timeStep * (1 - blend)
self.cameraDistance = 20 + (1 - blend)**2 * 200
elif elapsedTime < self.introTime + 2:
self.cameraDistance = 20
blend = (elapsedTime - self.introTime) / 2
self.overlay.setColor(Vec4(1, 1, 1, blend))
self.logo.setColor(1, 1, 1, blend)
self.skyBox.setColor(Vec4(1, 1, 1, blend))
if not self.backgroundSound.isPlaying():
self.backgroundSound.play()
self.backgroundSound.setVolume(blend * 0.5)
else:
self.cameraDistance = 20
self.overlay.setColor(Vec4(1, 1, 1, 1))
self.logo.setColor(1, 1, 1, 1)
self.skyBox.setColor(Vec4(1, 1, 1, 1))
self.backgroundSound.setVolume(0.5)
if elapsedTime > self.introTime:
if not self.loginDialogShown and self.showLogin:
self.loginDialog.show()
self.loginDialogShown = True
self.uiAngle -= engine.clock.timeStep * 2
self.text.setR(self.uiAngle)
self.hostList.update()
self.mapList.update()
self.loginDialog.update()
mouse = base.win.getPointer(0)
props = base.win.getProperties()
vector = Vec3((mouse.getX() / float(props.getXSize())) - 0.5,
(mouse.getY() / float(props.getYSize())) - 0.5, 0)
vector.normalize()
angle = math.degrees(math.atan2(-vector.getX(), vector.getY())) + 180
angle -= self.uiAngle
if not self.hostList.visible and not self.mapList.visible and not self.loginDialog.visible:
self.selectedItem = int(round(angle / 90.0))
while self.selectedItem > 3:
self.selectedItem -= 4
while self.selectedItem < 0:
self.selectedItem += 4
self.selector.setR(self.uiAngle + self.selectedItem * 90)
self.overlay1.setR(self.overlay1.getR() - engine.clock.timeStep * 2)
self.overlay2.setR(self.overlay2.getR() + engine.clock.timeStep * 2)
self.overlay3.setH(self.overlay3.getH() + engine.clock.timeStep * 10)
self.overlay4.setP(self.overlay4.getP() - engine.clock.timeStep * 10)
self.belt.update()
self.angle += engine.clock.timeStep * 0.025
camera.setPos(
math.cos(self.angle) * self.cameraDistance,
math.sin(self.angle) * self.cameraDistance,
math.cos(elapsedTime / 45 + 2) * 2)
camera.lookAt(Point3(0, 0, 0))
backend = None
game = None
if self.goTime != -1 and engine.clock.time - self.goTime > 0.25:
if self.clientConnectAddress is not None:
self.delete()
online.connectTo(self.clientConnectAddress)
backend = ClientBackend(self.clientConnectAddress,
self.username)
game = Game(backend)
elif self.serverMapName is not None:
if self.serverMode == 0:
# Normal server mode
self.delete()
if self.serverGameType == 0:
backend = PointControlBackend(
True, self.username) # Deathmatch
else:
backend = SurvivalBackend(True,
self.username) # Survival
game = Game(backend)
game.localStart(self.serverMapName)
elif self.serverMode == 1:
# Tutorial mode
self.delete()
backend = PointControlBackend(False, self.username)
game = Tutorial(backend,
2 if self.skipToEndOfTutorial else 0)
game.localStart(self.serverMapName)
net.context.writeTick()
return backend, game
def click(self):
if self.mapList.visible or self.hostList.visible or self.loginDialog.visible or engine.clock.time - \
self.startTime < self.introTime + 0.5:
return
self.clickSound.play()
if self.selectedItem == 0: # Join
self.hostList.show()
elif self.selectedItem == 1: # Tutorial
self.mapList.show()
self.serverMode = 1
elif self.selectedItem == 2: # Exit
engine.exit()
elif self.selectedItem == 3: # Host
self.mapList.show()
self.serverMode = 0
def delete(self):
self.loadingScreen.destroy()
self.hostList.delete()
self.mapList.delete()
self.loginDialog.delete()
self.active = False
self.overlay.removeNode()
self.belt.delete()
self.background.removeNode()
self.globe.removeNode()
self.skyBox.removeNode()
self.ignoreAll()
self.logo.destroy()
self.introSound.stop()
self.backgroundSound.stop()
def _createItem(self, entry, ignore_fadein = False):
'''Create an item(not including adding this to itemEntries)'''
imagepathes = runtime_data.game_settings['imagepathes']
imagetypes = runtime_data.game_settings['imagetypes']
modelpathes = runtime_data.game_settings['modelpathes']
modeltypes = runtime_data.game_settings['modeltypes']
if self._sceneItems.has_key(entry.key):
self._sceneItems[entry.key].removeNode()
self._sceneItems.pop(entry.key)
item = None
if entry.category == SVIC.FG or entry.category == SVIC.BG or entry.category == SVIC.O2D:
texture = None
for ft in ((folder,type) for folder in imagepathes for type in imagetypes):
if exists(ft[0] + entry.fileName + ft[1]):
texture = loader.loadTexture(ft[0] + entry.fileName + ft[1])
break
'''Alternative
item = loader.loadModel(r"models/plain.egg")
item.setTexture(texture, 1)
'''
item = OnscreenImage(texture)
item.setPos(entry.pos[0],entry.pos[1],entry.pos[2])
item.setScale(entry.scale[0]*texture.getOrigFileXSize()/float(texture.getOrigFileYSize()),entry.scale[1],entry.scale[2]) #Always make its height fill the screen normally
color = (entry.color[0],entry.color[1],entry.color[2],entry.color[3])
if entry.fadein:
lv = LerpColorInterval(item, entry.fadein, color, (color[0],color[1],color[2],0) )
self._intervals.append(lv)
lv.start()
else: item.setColor(color)
item.setName(entry.key)
if entry.category == SVIC.FG:
item.reparentTo(self.fgNodePath)
elif entry.category == SVIC.BG:
item.reparentTo(self.bgNodePath)
elif entry.category == SVIC.O2D:
item.reparentTo(self.vNodePath)
elif entry.category == SVIC.AFG:
item = None
for ft in ((folder,type) for folder in imagepathes for type in modeltypes):
if exists(ft[0] + entry.fileName + ft[1]):
item = loader.loadModel(ft[0] + entry.fileName + ft[1])
break
if not item: item = loader.loadModel(entry.fileName)
item.setPos(entry.pos[0],entry.pos[1],entry.pos[2])
item.setScale(entry.scale) #For generated egg animation with "egg-texture-cards" is a 1x1 rectangle by default
color = (entry.color[0],entry.color[1],entry.color[2],entry.color[3])
if entry.fadein:
lv = LerpColorInterval(item, entry.fadein, color, (color[0],color[1],color[2],0) )
self._intervals.append(lv)
lv.start()
else: item.setColor(color)
item.setTransparency(1)
item.setName(entry.key)
item.reparentTo(self.fgNodePath)
#item.setBin("unsorted", 0)
elif entry.category == SVIC.O3D:
item = None
for ft in ((folder,type) for folder in modelpathes for type in modeltypes):
if exists(ft[0] + entry.fileName + ft[1]):
item = loader.loadModel(ft[0] + entry.fileName + ft[1])
break
if not item: item = loader.loadModel(entry.fileName)
item.setPos(entry.pos[0],entry.pos[1],entry.pos[2])
item.setScale(entry.scale) #For generated egg animation with "egg-texture-cards" is a 1x1 rectangle by default
color = (entry.color[0],entry.color[1],entry.color[2],entry.color[3])
if entry.fadein:
lv = LerpColorInterval(item, entry.fadein, color, (color[0],color[1],color[2],0) )
self._intervals.append(lv)
lv.start()
else: item.setColor(color)
item.setTransparency(1)
item.setName(entry.key)
item.reparentTo(self.vNodePath)
if item:
self._sceneItems[entry.key] = item
if entry.quickitem:
self._quickitems.append(entry.key)
class MHB(object):
weaponOverHeat = 33
time = 0
step = False
curScale = 0
hbcount = 0
delayShot = 0
def __init__(self, camera, id):
self.audio3d = Audio3DManager(base.sfxManagerList[0], base.camera)
#Set model and projectile paths
self.gunPath = NodePath("gun2")
self.gunPath.reparentTo(base.camera)
self.gunPath.setPos(1.5,10.5,-3.8)
self.gunModel = loader.loadModel("./resources/mhb")
self.gunModel.reparentTo(self.gunPath)
self.gunModel.setPos(camera, .7,3,-1.4)
self.gunModel.setHpr(-90,0,0)
self.reticle = OnscreenImage("./resources/mhbReticle.png")
self.reticle.setTransparency(True)
self.reticle.setScale(0)
base.taskMgr.add(self.animate, "mhbReticle")
self.gunModel.setColor(0, 0, 0)
def hide(self):
self.reticle.setScale(0)
self.gunModel.hide()
self.gunPath.hide()
def show(self):
self.gunModel.show()
self.gunPath.show()
def fire(self, task):
#Spawn 20 projectiles, add them to taskMgr and play sfx
for i in range(1,20):
proj = MHBProjectile(self.gunPath, base.camera, len(base.projectileList)+self.hbcount, i)
base.taskMgr.add(proj.moveTask, "move projectile")
base.projectileList.append(proj)
self.hbcount+=1
shotSfx = self.audio3d.loadSfx("./resources/sounds/blunderbuss.wav")
self.audio3d.attachSoundToObject(shotSfx, base.camera)
shotSfx.play()
base.player.overHeat += self.weaponOverHeat
self.delayShot = task.time + 1.2
base.taskMgr.add(self.contTask, "weaponDelay")
def contTask(self, task):
return task.cont
def animate(self, task):
if task.time - self.time > .025:
if self.curScale < .08 and self.step:
self.curScale += .001
self.reticle.setScale(self.curScale)
self.time = task.time
if self.curScale == .08:
self.step = False
elif self.curScale > .04:
self.curScale -= .001
self.reticle.setScale(self.curScale)
self.time = task.time
if self.curScale <= .04:
self.step = True
return task.cont
def canShoot(self):
taskList = base.taskMgr.getTasksNamed("weaponDelay")
if taskList[0].time >= self.delayShot:
return True
else:
return False
def getOverHeat(self):
return self.overheat
def resetWeapon(self):
time = 0
step = False
hbcount = 0
delayShot = 0
class Crosshair(DirectObject):
def __init__(self):
self.crosshair = OnscreenImage('../assets/gui/crosshair3.png', (0, 0, 0) )
self.crosshair.setScale(0.03)
self.crosshair.setTransparency(TransparencyAttrib.MAlpha, 0)
class RecursionRifle(object):
#Amout overheat increases by
weaponOverHeat = 10
#For calculating delta time
time = 0
#Flag for animation
step = False
#Current animation scale
curScale = .025
#Delta for shot delay
delayShot = 0
def __init__(self, camera, id):
self.audio3d = Audio3DManager(base.sfxManagerList[0], base.camera)
#Get projectile path and gun model
self.gunPath = NodePath("gun")
self.gunPath.reparentTo(base.camera)
self.gunPath.setPos(1,10,-3.5)
self.gunModel = loader.loadModel("./resources/rr")
self.gunModel.reparentTo(self.gunPath)
self.gunModel.setPos(camera,.7,4,-2)
self.gunModel.setHpr(90,0,0)
self.gunModel.setColor(0, 255, 0)
#Set gun reticle
self.reticle = OnscreenImage("./resources/reticle.png")
self.reticle.setTransparency(True)
self.reticle.setScale(self.curScale)
base.taskMgr.add(self.animate, "rrReticle")
#Hides all visable enlements of the gun
def hide(self):
self.reticle.setScale(0)
self.gunModel.hide()
self.gunPath.hide()
#Hides all visable elements of the gun
def show(self):
self.gunModel.show()
self.gunPath.show()
#Fires recursion rifle
def fire(self, task):
#Spawn projectile, add it to taskMgr and play sfx
proj = RRProjectile(self.gunPath, base.camera, len(base.projectileList))
base.taskMgr.add(proj.moveTask, "move projectile")
base.projectileList.append(proj)
shotSfx = self.audio3d.loadSfx("./resources/sounds/recursion_rifle.wav")
self.audio3d.attachSoundToObject(shotSfx, base.camera)
shotSfx.play()
base.player.overHeat += self.weaponOverHeat
self.delayShot = task.time + .5
base.taskMgr.add(self.contTask, "weaponDelay")
#Handles animation of recursion rifle reticle
def animate(self, task):
#If delta has been long enough
if task.time - self.time > .05:
#Update scale
self.reticle.setScale(self.curScale)
if self.curScale < .03 and self.step:
self.curScale += .001
self.reticle.setScale(self.curScale)
self.time = task.time
if self.curScale >= .03:
self.step = False
elif self.curScale > .01:
self.curScale -= .001
self.reticle.setScale(self.curScale)
self.time = task.time
if self.curScale <= .01:
self.step = True
return task.cont
#Used to calculate delta for shot delay
def contTask(self, task):
return task.cont
#You can shoot if the delay has been met
def canShoot(self):
taskList = base.taskMgr.getTasksNamed("weaponDelay")
if taskList[0].time >= self.delayShot:
return True
else:
return False
#Resets delay
def resetWeapon(self):
delayShot = 0
class MainMenu(DirectObject):
"""This class represents the main menu as seen directly after the
application has been started"""
def __init__(self):
# loading music
self.menuMusic = loader.loadMusic("music/01Menu.mp3")
self.menuMusic.setLoop(True)
# create a main frame as big as the window
self.frameMain = DirectFrame(
# set framesize the same size as the window
frameSize = (base.a2dLeft, base.a2dRight,
base.a2dTop, base.a2dBottom),
# position center
pos = (0, 0, 0),
# set tramsparent background color
frameColor = (0.15, 0.15, 0.15, 1))
#self.frameMain.reparentTo(render2d)
self.menuBackground = OnscreenImage(
image = 'gui/Background.png',
scale = (1.66, 1, 1),
pos = (0, 0, 0))
self.menuBackground.reparentTo(self.frameMain)
self.defaultBtnMap = base.loader.loadModel("gui/button_map")
self.buttonGeom = (
self.defaultBtnMap.find("**/button_ready"),
self.defaultBtnMap.find("**/button_click"),
self.defaultBtnMap.find("**/button_rollover"),
self.defaultBtnMap.find("**/button_disabled"))
self.defaultTxtMap = base.loader.loadModel("gui/textbox_map")
self.textboxGeom = self.defaultTxtMap.find("**/textbox")
monospace = loader.loadFont('gui/DejaVuSansMono.ttf')
defaultFont = loader.loadFont('gui/eufm10.ttf')
# create the title
self.textscale = 0.25
self.title = DirectLabel(
# scale and position
scale = self.textscale,
pos = (0.0, 0.0, base.a2dTop - self.textscale),
# frame
frameColor = (0, 0, 0, 0),
# Text
text = "Dungeon Crawler",
text_align = TextNode.ACenter,
text_fg = (0.82,0.85,0.87,1),
text_shadow = (0, 0, 0, 1),
text_shadowOffset = (-0.02, -0.02),
text_font = defaultFont)
self.title.setTransparency(1)
self.title.reparentTo(self.frameMain)
# create a host button
self.btnHostPos = Vec3(0, 0, .45)
self.btnHostScale = 0.25
self.btnHost = DirectButton(
# Scale and position
scale = self.btnHostScale,
pos = self.btnHostPos,
# Text
text = "Host",
text_scale = 0.8,
text_pos = (0, -0.2),
text_fg = (0.82,0.85,0.87,1),
text_shadow = (0, 0, 0, 1),
text_shadowOffset = (-0.02, -0.02),
text_font = defaultFont,
# Frame
geom = self.buttonGeom,
frameColor = (0, 0, 0, 0),
relief = 0,
pressEffect = False,
# Functionality
command = self.host,
rolloverSound = None,
clickSound = None)
self.btnHost.setTransparency(1)
self.btnHost.reparentTo(self.frameMain)
# create a join button
self.btnJoinPos = Vec3(0, 0, 0)
self.btnJoinScale = 0.25
self.btnJoin = DirectButton(
scale = self.btnJoinScale,
pos = self.btnJoinPos,
text = "Join",
text_scale = 0.8,
text_pos = (0, -0.2),
text_fg = (0.82,0.85,0.87,1),
text_shadow = (0, 0, 0, 1),
text_shadowOffset = (-0.02, -0.02),
text_font = defaultFont,
geom = self.buttonGeom,
frameColor = (0, 0, 0, 0),
relief = 0,
pressEffect = False,
command = self.join,
rolloverSound = None,
clickSound = None)
self.btnJoin.setTransparency(1)
self.btnJoin.reparentTo(self.frameMain)
# create the IP input field
self.txtIPPos = Vec3(0, 0, -.30)
self.txtIPScale = 0.25
self.txtIPWidth = 9
self.txtIP = DirectEntry(
# scale and position
pos = self.txtIPPos,
scale = self.txtIPScale,
width = self.txtIPWidth,
# Text
entryFont = monospace,
text_align = TextNode.ACenter,
text = "",
text_scale = 0.5,
text_pos = (0, -0.2),
text_fg = (0.82,0.85,0.87,1),
text_shadow = (0, 0, 0, 1),
text_shadowOffset = (0.04, 0.04),
initialText = "127.0.0.1",
numLines = 1,
# Frame
geom = self.textboxGeom,
frameColor = (0, 0, 0, 0),
relief = 0,
# Functionality
command = self.join,
focusInCommand = self.clearText)
self.txtIP.reparentTo(self.frameMain)
# create an exit button
self.btnExitPos = Vec3(0, 0, -.75)
self.btnExitScale = 0.25
self.btnExit = DirectButton(
scale = self.btnExitScale,
pos = self.btnExitPos,
text = "Exit",
text_scale = 0.8,
text_pos = (0, -0.2),
text_fg = (0.82,0.85,0.87,1),
text_shadow = (0, 0, 0, 1),
text_shadowOffset = (-0.02, -0.02),
text_font = defaultFont,
geom = self.buttonGeom,
frameColor = (0, 0, 0, 0),
relief = 0,
pressEffect = False,
command = lambda: base.messenger.send("escape"),
rolloverSound = None,
clickSound = None)
self.btnExit.setTransparency(1)
self.btnExit.reparentTo(self.frameMain)
# create a mute checkbox
self.cbVolumeMute = DirectCheckBox(
# set size
scale = (0.1, 0.1, 0.1),
frameSize = (-1, 1, 1, -1),
# functionality and visuals
command = self.cbVolumeMute_CheckedChanged,
isChecked = True,
checkedImage = "gui/SoundSwitch_off.png",
uncheckedImage = "gui/SoundSwitch_on.png",
# mouse behaviour
relief = 0,
pressEffect = False,
rolloverSound = None,
clickSound = None
)
self.cbVolumeMute.setTransparency(1)
self.cbVolumeMute.reparentTo(self.frameMain)
self.cbVolumeMute.commandFunc(None)
# catch window resizes and recalculate the aspectration
self.accept("window-event", self.recalcAspectRatio)
self.accept("showerror", self.showError)
# show the menu right away
self.show()
def host(self):
"""Function which will be called by pressing the host button"""
self.hide()
base.messenger.send("start_server")
def join(self, ip=None):
"""Function which will be called by pressing the join button"""
if ip == None: ip = self.txtIP.get(True)
if ip == "": return
self.hide()
base.messenger.send("start_client", [ip])
def showError(self, msg):
self.show()
self.dialog = OkDialog(
dialogName="ErrorDialog",
text="Error: {}".format(msg),
command=self.closeDialog)
def closeDialog(self, args):
self.dialog.hide()
def show(self):
"""Show the GUI"""
self.frameMain.show()
self.menuMusic.play()
def hide(self):
"""Hide the GUI"""
self.frameMain.hide()
self.menuMusic.stop()
def clearText(self):
"""Function to clear the text that was previously entered in the
IP input field"""
self.txtIP.enterText("")
def cbVolumeMute_CheckedChanged(self, checked):
if bool(checked):
base.disableAllAudio()
else:
base.enableAllAudio()
def recalcAspectRatio(self, window):
"""get the new aspect ratio to resize the mainframe"""
# set the mainframe size to the window borders again
self.frameMain["frameSize"] = (
base.a2dLeft, base.a2dRight,
base.a2dTop, base.a2dBottom)
# calculate new aspec tratio
wp = window.getProperties()
aspX = 1.0
aspY = 1.0
wpXSize = wp.getXSize()
wpYSize = wp.getYSize()
if wpXSize > wpYSize:
aspX = wpXSize / float(wpYSize)
else:
aspY = wpYSize / float(wpXSize)
# calculate new position/size/whatever of the gui items
self.title.setPos(0.0, 0.0, base.a2dTop - self.textscale)
self.menuBackground.setScale(1.0 * aspX, 1.0, 1.0 * aspY)
self.cbVolumeMute.setPos(base.a2dRight - 0.15, 0, base.a2dBottom + 0.15)
class Jugador(DirectObject):
# Les variables que tinguin un # son canviables, i les que tinguin ## depenen de la nau
WIN_WIDTH = 800 #
H_WIDTH = WIN_WIDTH / 2
WIN_HEIGHT = 600 #
H_HEIGHT = WIN_HEIGHT / 2
CAM_FOV = 51.0
CAM_FOV_RAD = radians(CAM_FOV) / 2
CAM_FOV_RAD_TAN = tan(CAM_FOV_RAD)
VEL_MAX_AVIO = 100 ##
VEL_MIN_AVIO = 30 ##
VEL_AVIO_RECTE = 40.0 ##
VEL_TOMBA_AVIO = 90.0 ##
VEL_COSTAT = 30.0 ##
ACCELERACIO = 35 ##
CAMERA_Y = -9 ##
BALA_VEL_BASE = 500 ##
QUIT_KEY = "escape" #
ACCELERATE_KEY = "w" #
DECELERATE_KEY = "s" #
RIGHT_KEY = "d" #
LEFT_KEY = "a" #
CENTRA_RATA_KEY = "c" #
SHOOT_KEYS = ["mouse1", "e"] #
SHOOT_TIME = 0.15 ##
def __init__(self, base, ini_pos=Point3(0, 100, 100), tipus="kamikaze", wwidth=None, wheight=None):
DirectObject.__init__(self)
if wwidth and wheight:
self.WIN_WIDTH = wwidth
self.H_WIDTH = self.WIN_WIDTH / 2
self.WIN_HEIGHT = wheight
self.H_HEIGHT = self.WIN_HEIGHT / 2
self.keyMap = {"shoot": 0, "centerPointer": 0, "turn": 0}
self.bulletClock = 0.0
self.overheatClock = 0.0
self.BALA_VEL = self.BALA_VEL_BASE + self.VEL_MIN_AVIO
ambient = AmbientLight("alight")
ambientNp = render.attachNewNode(ambient)
ambient.setColor(VBase4(0.3, 0.3, 0.3, 1.0))
self.avio = render.attachNewNode("avio")
self.avio.setHpr(randint(0, 359), randint(0, 359), randint(0, 359))
self.avio.setPos(ini_pos)
self.avioR = self.avio.attachNewNode("avioDum2")
if tipus == "kamikaze":
self.modelAvio = base.loader.loadModel("prova/avio1blend")
else:
self.modelAvio = base.loader.loadModel("prova/avio1blend")
self.modelAvio.reparentTo(self.avioR)
self.avioVel = self.VEL_MIN_AVIO
self.balaDreta = self.modelAvio.find("**/BalaDreta")
self.balaEsquerra = self.modelAvio.find("**/BalaEsquerra")
self.avio.setLight(ambientNp)
self.avio.setAntialias(AntialiasAttrib.MMultisample)
self.modelAvio.setColor(1, 1, 0, 1)
self.modelAvio.setScale(0.51)
lightBales = AmbientLight("dlight")
self.lightBalesNp = base.camera.attachNewNode(lightBales)
self.lightBalesNp.setHpr(0, 0, 0)
# -#-#-#-configuracio de camara
base.disableMouse()
# ~ self.oobe()
base.camera.reparentTo(self.avio)
base.camera.setHpr(self.avio, 0, 0, 0)
base.camera.setPos(self.avio, 0, self.CAMERA_Y, 1.5)
base.camLens.setFov(self.CAM_FOV * (4.0 / 3.0), self.CAM_FOV)
self.mirilla2 = OnscreenImage(image="prova/textures/areatir2.png", parent=pixel2d)
self.mirilla2.setScale(128)
self.mirilla2.setTransparency(1)
self.mirilla2.setPos(self.H_WIDTH, 0, -self.H_HEIGHT)
self.mirilla = base.loader.loadModel("prova/textures/fixador.egg")
self.mirilla.reparentTo(pixel2d)
self.mirilla.setScale(64.0)
self.mirilla.setPos(0, 0, 0)
self.mirilla.find("**/+SequenceNode").node().pose(0)
self.cursorGirar = pixel2d.attachNewNode("cursorGirar")
self.cursorGirarImage = OnscreenImage(image="prova/textures/fletxa.png", parent=self.cursorGirar)
self.cursorGirarImage.setScale(16.0 / 2, 1.0, 32.0 / 2)
self.cursorGirarImage.setPos(0, 0, 0)
self.cursorGirarImage.setHpr(-90, 0, -90)
self.cursorGirarImage.setTransparency(1)
cursorGirarEffect = BillboardEffect.make(
up_vector=Vec3(0, 0, 1),
eye_relative=False,
axial_rotate=False,
offset=0.0,
look_at=self.mirilla2,
look_at_point=Point3(0, 0, 0),
)
self.cursorGirar.setEffect(cursorGirarEffect)
self.overheats = []
for i in range(8):
if i % 2 == 0:
self.overheats.append(OnscreenImage(image="prova/textures/overheat1.png", parent=pixel2d))
else:
self.overheats.append(OnscreenImage(image="prova/textures/overheat2.png", parent=pixel2d))
self.overheats[i].setScale(32.0, 1.0, 32.0)
self.overheats[i].setTransparency(1)
self.overheats[i].hide()
self.overheats[0].setPos(self.H_WIDTH + 36, 0, -self.H_HEIGHT + 36)
self.overheats[0].setHpr(0, 0, 0)
self.overheats[1].setPos(self.H_WIDTH + 36, 0, -self.H_HEIGHT + 36)
self.overheats[1].setHpr(0, 0, 0)
self.overheats[2].setPos(self.H_WIDTH + 36, 0, -self.H_HEIGHT - 36)
self.overheats[2].setHpr(0, 0, 90)
self.overheats[3].setPos(self.H_WIDTH + 36, 0, -self.H_HEIGHT - 36)
self.overheats[3].setHpr(0, 0, 90)
self.overheats[4].setPos(self.H_WIDTH - 36, 0, -self.H_HEIGHT - 36)
self.overheats[4].setHpr(0, 0, 180)
self.overheats[5].setPos(self.H_WIDTH - 36, 0, -self.H_HEIGHT - 36)
self.overheats[5].setHpr(0, 0, 180)
self.overheats[6].setPos(self.H_WIDTH - 36, 0, -self.H_HEIGHT + 36)
self.overheats[6].setHpr(0, 0, -90)
self.overheats[7].setPos(self.H_WIDTH - 36, 0, -self.H_HEIGHT + 36)
self.overheats[7].setHpr(0, 0, -90)
# PARTICLE SYSTEM SETUP
self.particlesDummy = render.attachNewNode("particlesDummy")
self.particlesDummy.setPosHprScale(0, 0, 0, 0, 0, 0, 1, 1, 1)
self.particlesDummy.clearLight(render.find("dlight"))
self.particlesDummy.setLight(self.lightBalesNp)
base.enableParticles()
# COLLISIONS
base.cTrav = CollisionTraverser()
base.cTrav.setRespectPrevTransform(True)
self.balaCol = CollisionNode("balaCol")
self.balaCol.setIntoCollideMask(BitMask32.allOff())
self.balaCol.setFromCollideMask(BitMask32(0x00000001))
balaColSolid = CollisionSphere(0.0, 0.0, 0.0, 0.2)
self.balaCol.addSolid(balaColSolid)
self.pickRay = CollisionNode("pickRay")
self.pickRayNp = base.camera.attachNewNode(self.pickRay)
self.pickRay.setIntoCollideMask(BitMask32.allOff())
self.pickRay.setFromCollideMask(BitMask32(0x00000002))
self.pickRayCHandler = CollisionHandlerQueue()
self.mouseRay = CollisionRay()
self.pickRay.addSolid(self.mouseRay)
self.mouseRay.setOrigin(0, 0, 0)
base.cTrav.addCollider(self.pickRayNp, self.pickRayCHandler)
# ~ self.nearPlane = CollisionNode("nearPlane")
# ~ self.nearPlaneNp = base.camera.attachNewNode(self.nearPlane)
# ~ base.camRays.setIntoCollideMask(BitMask32(0x00000001))
# ~ self.nearPlaneNp.setPos(0, 1, 0)
# ~ self.nearPlaneColSolid = CollisionPlane(Plane(Vec3(0, -1, 0), Point3(0, 1, 0)))
# ~ self.nearPlane.addSolid(self.nearPlaneColSolid)
def giraAvio(task):
timeVar = globalClock.getDt()
point = base.win.getPointer(0)
pointerx = point.getX()
pointery = point.getY()
self.mouseRay.setFromLens(base.camNode, pointerx, pointery)
# Cursors de la pantalla
self.mirilla.setPos(pointerx, 0, -pointery)
self.cursorGirar.setPos(pointerx, 0, -pointery)
r = pow(abs(pointery - self.H_HEIGHT), 2) + pow(abs(pointerx - self.H_WIDTH), 2)
if r > 8000:
self.mirilla.hide()
self.cursorGirar.show()
else:
self.mirilla.show()
self.cursorGirar.hide()
# 3D
pointerx = pointerx - self.H_WIDTH
pointery = pointery - self.H_HEIGHT
self.avioR.setX(self.avio, -pointerx * 3.0 / float(self.WIN_WIDTH))
self.avioR.setZ(self.avio, pointery * 3.0 / (self.WIN_HEIGHT))
self.avio.setH(self.avio, -pointerx * 256.0 / self.WIN_WIDTH * timeVar)
self.avio.setP(self.avio, -pointery * 256.0 / self.WIN_HEIGHT * timeVar)
self.avioR.setR(self.avio, pointerx / 10.0)
self.avioR.setP(self.avio, pointery / 70.0)
self.avioR.setH(self.avio, -pointerx / 50.0)
# ~ self.avioVel += self.avioAcc*timeVar
# ~ self.avio.setPos(self.avio, self.avioVel*timeVar)
return task.cont
def propulsaAvio(acceleracio, task):
self.avioVel += acceleracio * globalClock.getDt()
if self.avioVel < self.VEL_MIN_AVIO:
self.avioVel = self.VEL_MIN_AVIO
elif self.avioVel > self.VEL_MAX_AVIO:
self.avioVel = self.VEL_MAX_AVIO
self.BALA_VEL = self.BALA_VEL_BASE + self.avioVel
# MOSTRA LA VELOCITAT
pos = float(self.avioVel - self.VEL_MIN_AVIO) / (self.VEL_MAX_AVIO - self.VEL_MIN_AVIO)
base.camera.setY(self.CAMERA_Y - pos * 4)
# ~ self.marcaVelocitat.setX(MARCAVEL_INI_X+pos*137.)
return task.cont
self.haCremat = False
def mouAvio(task):
timeVar = globalClock.getDt()
self.avio.setPos(self.avio, 0, self.avioVel * timeVar, 0)
if self.keyMap["shoot"] == 1:
if self.bulletClock <= 0.0:
self.bulletClock = self.SHOOT_TIME
if not self.haCremat:
if self.overheatClock > 16:
self.haCremat = True
self.overheatClock = 18
else:
self.overheatClock += self.SHOOT_TIME
shoot()
else:
self.bulletClock -= timeVar
else:
self.bulletClock = 0.0
self.overheatClock -= timeVar
if self.overheatClock < 16:
self.haCremat = False
if self.haCremat:
self.overheatClock -= timeVar
if self.overheatClock < 0:
self.overheatClock = 0
elif self.overheatClock < 2:
self.overheats[0].hide()
elif self.overheatClock < 4:
self.overheats[1].hide()
self.overheats[0].show()
elif self.overheatClock < 6:
self.overheats[2].hide()
self.overheats[1].show()
elif self.overheatClock < 8:
self.overheats[3].hide()
self.overheats[2].show()
elif self.overheatClock < 10:
self.overheats[4].hide()
self.overheats[3].show()
elif self.overheatClock < 12:
self.overheats[5].hide()
self.overheats[4].show()
elif self.overheatClock < 14:
self.overheats[6].hide()
self.overheats[5].show()
self.overheats[7].hide()
elif self.overheatClock < 16:
self.overheats[7].hide()
self.overheats[6].show()
else:
self.overheats[7].show()
if self.keyMap["turn"] == 1:
self.avio.setX(self.avio, -self.VEL_COSTAT * timeVar)
elif self.keyMap["turn"] == -1:
self.avio.setX(self.avio, self.VEL_COSTAT * timeVar)
return task.cont
def avioRecte(task):
p = self.avio.getP(render)
if p > 170 or p < -170:
return task.cont
timeVar = globalClock.getDt()
roll = self.avio.getR(render)
if roll < -self.VEL_AVIO_RECTE * timeVar:
self.avio.setR(render, roll + self.VEL_AVIO_RECTE * timeVar)
elif roll <= self.VEL_AVIO_RECTE * timeVar:
self.avio.setR(render, 0)
else:
self.avio.setR(render, roll - self.VEL_AVIO_RECTE * timeVar)
return task.cont
self.balaPositiu = True
def shoot():
bala = self.particlesDummy.attachNewNode("balaDummy")
balaImage = OnscreenImage(image="prova/textures/bala.png", parent=bala)
balaImage.setTransparency(1)
balaImage.setScale(0.1, 1.0, 0.2)
balaImage.setBillboardPointEye()
bala.setQuat(self.modelAvio.getQuat(render))
if self.balaPositiu:
bala.setPos(self.balaDreta.getPos(render))
self.balaPositiu = False
else:
bala.setPos(self.balaEsquerra.getPos(render))
self.balaPositiu = True
balaSphere = bala.attachNewNode(self.balaCol)
balaColHandler = CollisionHandlerQueue()
base.cTrav.addCollider(balaSphere, balaColHandler)
# ~ if type(self.shootPoint) == 'libpanda.Point3':
# ~ bala.lookAt(self.shootPoint)
# ~ else: bala.setH(bala, 180.)
taskMgr.add(mouBala, "moubala", extraArgs=[bala, balaImage, self.BALA_VEL, balaColHandler], appendTask=True)
def mouBala(bala, balaImage, vel, queue, task):
if task.time > 3:
balaImage.detachNode()
expbala = ParticleEffect()
expbala.reparentTo(self.particlesDummy)
expbala.loadConfig("explosio.ptf")
expbala.start(bala)
taskMgr.doMethodLater(0.25, suprimir, "suprimir", extraArgs=[bala, expbala])
return task.done
if queue.getNumEntries() != 0:
balaImage.detachNode()
entry = queue.getEntry(0)
bala.setPos(entry.getSurfacePoint(self.particlesDummy))
expbala = ParticleEffect()
expbala.reparentTo(self.particlesDummy)
expbala.loadConfig("explosio.ptf")
expbala.start(bala)
taskMgr.doMethodLater(0.25, suprimir, "suprimir", extraArgs=[bala, expbala])
return task.done
bala.setFluidPos(bala, 0, vel * globalClock.getDt(), 0)
balaImage.setR(balaImage, 1000 * globalClock.getDt())
return task.cont
def suprimir(bala, expbala):
bala.detachNode()
expbala.cleanup()
expbala.detachNode()
def setKey(key, value):
self.keyMap[key] = value
def centraRatoli():
point = base.win.getPointer(0)
x = point.getX()
y = point.getY()
x -= self.H_WIDTH
y -= self.H_HEIGHT
r = sqrt(pow(abs(y), 2) + pow(abs(x), 2))
def centra(t, x, y):
base.win.movePointer(0, trunc(x * t) + self.H_WIDTH, trunc(y * t) + self.H_HEIGHT)
i = LerpFunc(
centra,
fromData=1.0,
toData=0.0,
duration=r / 700.0,
blendType="easeInOut",
extraArgs=[x, y],
name="centraRata",
)
i.start()
self.previousPos = 0
self.interval01 = LerpPosHprInterval(
self.modelAvio,
0.5,
Point3(3, 0, 0),
VBase3(0, 0, 70),
Point3(0, 0, 0),
VBase3(0, 0, 0),
blendType="easeInOut",
)
self.interval10 = LerpPosHprInterval(
self.modelAvio,
0.5,
Point3(0, 0, 0),
VBase3(0, 0, 0),
Point3(-3, 0, 0),
VBase3(0, 0, -70),
blendType="easeInOut",
)
self.interval02 = LerpPosHprInterval(
self.modelAvio,
0.5,
Point3(-3, 0, 0),
VBase3(0, 0, -70),
Point3(0, 0, 0),
VBase3(0, 0, 0),
blendType="easeInOut",
)
self.interval20 = LerpPosHprInterval(
self.modelAvio,
0.5,
Point3(0, 0, 0),
VBase3(0, 0, 0),
Point3(3, 0, 0),
VBase3(0, 0, 70),
blendType="easeInOut",
)
self.interval12 = LerpPosHprInterval(
self.modelAvio,
1.0,
Point3(-3, 0, 0),
VBase3(0, 0, -70),
Point3(3, 0, 0),
VBase3(0, 0, 70),
blendType="easeInOut",
)
self.interval21 = LerpPosHprInterval(
self.modelAvio,
1.0,
Point3(3, 0, 0),
VBase3(0, 0, 70),
Point3(-3, 0, 0),
VBase3(0, 0, -70),
blendType="easeInOut",
)
def allIntervalsStopped():
if (
self.interval01.isStopped()
and self.interval10.isStopped()
and self.interval02.isStopped()
and self.interval20.isStopped()
and self.interval12.isStopped()
and self.interval21.isStopped()
):
return True
else:
return False
def tombaAvio(task):
if self.keyMap["turn"] == 0 and self.previousPos != 0 and allIntervalsStopped():
if self.previousPos == 1:
self.interval10.start()
else:
self.interval20.start()
self.previousPos = 0
elif self.keyMap["turn"] == -1 and self.previousPos != -1 and allIntervalsStopped():
if self.previousPos == 0:
self.interval01.start()
else:
self.interval21.start()
self.previousPos = -1
elif self.keyMap["turn"] == 1 and self.previousPos != 1 and allIntervalsStopped():
if self.previousPos == 0:
self.interval02.start()
else:
self.interval12.start()
self.previousPos = 1
return task.cont
def anim1():
self.mirilla.find("**/+SequenceNode").node().setPlayRate(1.0)
self.mirilla.find("**/+SequenceNode").node().play(0, 3)
def anim2():
self.mirilla.find("**/+SequenceNode").node().setPlayRate(1.0)
self.mirilla.find("**/+SequenceNode").node().play(4, 8)
def anim3():
self.mirilla.find("**/+SequenceNode").node().setPlayRate(-1.0)
self.mirilla.find("**/+SequenceNode").node().play(0, 3)
def anim4():
self.mirilla.find("**/+SequenceNode").node().setPlayRate(-1.0)
self.mirilla.find("**/+SequenceNode").node().play(3, 8)
# events
self.accept(self.QUIT_KEY, sysExit, [0])
self.accept(
self.ACCELERATE_KEY,
taskMgr.add,
[propulsaAvio, "propulsaAvio1", None, [self.ACCELERACIO], None, None, True],
)
self.accept(self.ACCELERATE_KEY + "-up", taskMgr.remove, ["propulsaAvio1"])
self.accept(
self.DECELERATE_KEY,
taskMgr.add,
[propulsaAvio, "propulsaAvio2", None, [-self.ACCELERACIO], None, None, True],
)
self.accept(self.DECELERATE_KEY + "-up", taskMgr.remove, ["propulsaAvio2"])
for key in self.SHOOT_KEYS:
self.accept(key, setKey, ["shoot", 1])
self.accept(key + "-up", setKey, ["shoot", 0])
self.accept(self.RIGHT_KEY, setKey, ["turn", -1])
self.accept(self.LEFT_KEY, setKey, ["turn", 1])
self.accept(self.RIGHT_KEY + "-up", setKey, ["turn", 0])
self.accept(self.LEFT_KEY + "-up", setKey, ["turn", 0])
self.accept(self.CENTRA_RATA_KEY, centraRatoli)
self.accept("n", anim1)
self.accept("m", anim2)
self.accept("v", anim3)
self.accept("b", anim4)
taskMgr.add(giraAvio, "GiraAvio")
taskMgr.add(mouAvio, "MouAvio")
taskMgr.add(avioRecte, "avioRecte")
taskMgr.add(tombaAvio, "tombaAvio")
class Unit:
def __init__(self, unitID, position, mainClass):
# self = copy.copy(mainClass.unitHandler.unitDict[mainClass.unitHandler.main['units'][unitID]])
self.model = mainClass.unitHandler.unitDict[
mainClass.unitHandler.main['units'][unitID]].model
self.fullName = copy.copy(mainClass.unitHandler.unitDict[
mainClass.unitHandler.main['units'][unitID]].fullName)
self.HP = copy.copy(mainClass.unitHandler.unitDict[
mainClass.unitHandler.main['units'][unitID]].HP)
self.info = copy.copy(mainClass.unitHandler.unitDict[
mainClass.unitHandler.main['units'][unitID]].info)
self.moveType = copy.copy(mainClass.unitHandler.unitDict[
mainClass.unitHandler.main['units'][unitID]].moveType)
self.model = copy.copy(mainClass.unitHandler.unitDict[
mainClass.unitHandler.main['units'][unitID]].model)
self.radius = copy.copy(mainClass.unitHandler.unitDict[
mainClass.unitHandler.main['units'][unitID]].radius)
self.mass = copy.copy(mainClass.unitHandler.unitDict[
mainClass.unitHandler.main['units'][unitID]].mass)
self.startForce = copy.copy(mainClass.unitHandler.unitDict[
mainClass.unitHandler.main['units'][unitID]].startForce)
self.maxForce = copy.copy(mainClass.unitHandler.unitDict[
mainClass.unitHandler.main['units'][unitID]].maxForce)
self.dig = copy.copy(mainClass.unitHandler.unitDict[
mainClass.unitHandler.main['units'][unitID]].dig)
self.reinforce = copy.copy(mainClass.unitHandler.unitDict[
mainClass.unitHandler.main['units'][unitID]].reinforce)
self.shovel = copy.copy(mainClass.unitHandler.unitDict[
mainClass.unitHandler.main['units'][unitID]].shovel)
self.hold = copy.copy(mainClass.unitHandler.unitDict[
mainClass.unitHandler.main['units'][unitID]].hold)
self.modelHeight = copy.copy(mainClass.unitHandler.unitDict[
mainClass.unitHandler.main['units'][unitID]].modelHeight)
self.selectScale = copy.copy(mainClass.unitHandler.unitDict[
mainClass.unitHandler.main['units'][unitID]].selectScale)
self.job = False
self.uID = mainClass.unitHandler.unitUniqueID
print self.uID
self.modelNode = loader.loadModel(self.model)
self.modelNode.setName('unit ' + str(self.uID).zfill(3))
self.modelNode.reparentTo(render)
self.modelNode.setPos(position)
self.modelNode.setCollideMask(BitMask32.bit(1))
self.select = OnscreenImage(image='data/models/game/selected.png')
self.select.setScale(float(self.selectScale))
self.select.reparentTo(self.modelNode)
self.select.setZ(float(self.modelHeight) / 2)
self.select.setTransparency(TransparencyAttrib.MAlpha)
self.select.setBillboardPointEye()
self.select.hide()
self.groundRay = CollisionRay()
self.groundRay.setOrigin(0, 0, 100)
self.groundRay.setDirection(0, 0, -1)
self.groundCol = CollisionNode('unit Ray')
self.groundCol.addSolid(self.groundRay)
self.groundCol.setTag('units', 'ray1')
self.groundCol.setFromCollideMask(BitMask32.bit(0))
self.groundCol.setIntoCollideMask(BitMask32.allOff())
self.groundColNp = self.modelNode.attachNewNode(self.groundCol)
self.groundColNp.setPos(0, 0, 0)
self.groundHandler = CollisionHandlerFloor()
self.groundHandler.setMaxVelocity(100)
base.cTrav2.addCollider(self.groundColNp, self.groundHandler)
self.groundHandler.addCollider(self.groundColNp, self.modelNode)
self.AI = AICharacter(self.fullName, self.modelNode, self.mass * 2,
self.startForce * 2, self.maxForce * 2)
mainClass.unitHandler.AIWorld.addAiChar(self.AI)
self.AIBehaviors = self.AI.getAiBehaviors()
if (self.moveType == 'ground'):
self.aStar = astar.aStar(mainClass.unitHandler.meshes.landMesh,
mainClass)
elif (self.moveType == 'water'):
self.aStar = astar.aStar(mainClass.unitHandler.meshes.waterMesh,
mainClass)
elif (self.moveType == 'air'):
self.aStar = astar.aStar(mainClass.unitHandler.meshes.airMesh,
mainClass)
print self
# mainClass.unitHandler.unitUniqueID += 1
class Menu(DirectObject):
def __init__(self, cursor):
#-----------------------------------------------------------------------------------------------------------------------------------------------
#---------------------------------------------------VARIABLE DECLARATION------------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
self.title = None
self.play = None
self.credits = None
self.ins = None
self.selected = "PLAY"
self.pastTime = 0.0
self.oldX = 0.0
self.run = True
self.moved = 0.0
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------MENU INIT----------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
self.title = OnscreenImage("./tex/menu/glooveth.png", (0, 0, -0.25),
None, (1.0, 1.0, 0.25), None, None, 10)
self.title.setTransparency(TransparencyAttrib.MAlpha)
self.credits = OnscreenImage("./tex/menu/credits.png",
(-1.0, 0, -0.75), None,
(0.25, 1.0, 0.125), None, None, 10)
self.credits.setTransparency(TransparencyAttrib.MAlpha)
self.ins = OnscreenImage("./tex/menu/ins.png", (1.0, 0, -0.75), None,
(0.25, 1.0, 0.125), None, None, 10)
self.ins.setTransparency(TransparencyAttrib.MAlpha)
self.play = OnscreenImage("./tex/menu/playOver.png", (0, 0, -0.75),
None, (0.35, 1.0, 0.20), None, None, 10)
self.play.setTransparency(TransparencyAttrib.MAlpha)
# Cursor
self.cursor = cursor
# Start tasks
taskMgr.add(self.taskMenuMovement, 'taskMenuMovement')
#end __init__
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------FUNCTIONS----------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# It hides the main menu of the game
def hide(self):
self.title.hide()
self.play.hide()
self.credits.hide()
self.ins.hide()
self.run = False
#end hide
# It shows the main menu of the game
def show(self):
self.title.show()
self.play.show()
self.credits.show()
self.ins.show()
taskMgr.add(self.taskMenuMovement, 'taskMenuMovement')
self.run = True
#end show
#-----------------------------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------TASKS,THREADS------------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------------------------------
# Menu interaction
def taskMenuMovement(self, task):
if (self.run == True):
mpos = self.cursor.getCursorPos()
if ((mpos.getX() < -0.33) and (self.oldX >= -0.33)):
self.selected = "CREDITS"
elif ((mpos.getX() > -0.33) and (self.oldX <= -0.33)):
self.selected = "PLAY"
elif ((mpos.getX() < 0.33) and (self.oldX >= 0.33)):
self.selected = "PLAY"
elif ((mpos.getX() > 0.33) and (self.oldX <= 0.33)):
self.selected = "INS"
# Making bigger the button selected depending on the region of the cursor
if (self.selected == "PLAY"):
self.play.setImage("./tex/menu/playOver.png")
self.play.setTransparency(TransparencyAttrib.MAlpha)
self.play.setScale((0.35, 1.0, 0.20))
elif (self.selected == "CREDITS"):
self.credits.setImage("./tex/menu/creditsOver.png")
self.credits.setTransparency(TransparencyAttrib.MAlpha)
self.credits.setScale((0.35, 1.0, 0.20))
elif (self.selected == "INS"):
self.ins.setImage("./tex/menu/insOver.png")
self.ins.setTransparency(TransparencyAttrib.MAlpha)
self.ins.setScale((0.35, 1.0, 0.20))
self.oldX = mpos.getX()
# Setting the others to a smaller size
if (self.selected == "PLAY"):
self.credits.setImage("./tex/menu/credits.png")
self.credits.setTransparency(TransparencyAttrib.MAlpha)
self.credits.setScale((0.25, 1.0, 0.125))
self.ins.setImage("./tex/menu/ins.png")
self.ins.setTransparency(TransparencyAttrib.MAlpha)
self.ins.setScale((0.25, 1.0, 0.125))
elif (self.selected == "CREDITS"):
self.play.setImage("./tex/menu/play.png")
self.play.setTransparency(TransparencyAttrib.MAlpha)
self.play.setScale((0.25, 1.0, 0.125))
self.ins.setImage("./tex/menu/ins.png")
self.ins.setTransparency(TransparencyAttrib.MAlpha)
self.ins.setScale((0.25, 1.0, 0.125))
elif (self.selected == "INS"):
self.play.setImage("./tex/menu/play.png")
self.play.setTransparency(TransparencyAttrib.MAlpha)
self.play.setScale((0.25, 1.0, 0.125))
self.credits.setImage("./tex/menu/credits.png")
self.credits.setTransparency(TransparencyAttrib.MAlpha)
self.credits.setScale((0.25, 1.0, 0.125))
return task.cont
else:
return task.done
#end taskMenuMovement
#end class Menu
class Jugador(DirectObject):
#Les variables que tinguin un # son canviables, i les que tinguin ## depenen de la nau
WIN_WIDTH = 800 #
H_WIDTH = WIN_WIDTH / 2
WIN_HEIGHT = 600 #
H_HEIGHT = WIN_HEIGHT / 2
CAM_FOV = 51.
CAM_FOV_RAD = radians(CAM_FOV) / 2
CAM_FOV_RAD_TAN = tan(CAM_FOV_RAD)
VEL_MAX_AVIO = 100 ##
VEL_MIN_AVIO = 30 ##
VEL_AVIO_RECTE = 40. ##
VEL_TOMBA_AVIO = 90. ##
VEL_COSTAT = 30. ##
ACCELERACIO = 35 ##
CAMERA_Y = -9 ##
BALA_VEL_BASE = 500 ##
QUIT_KEY = "escape" #
ACCELERATE_KEY = "w" #
DECELERATE_KEY = "s" #
RIGHT_KEY = "d" #
LEFT_KEY = "a" #
CENTRA_RATA_KEY = "c" #
SHOOT_KEYS = ["mouse1", "e"] #
SHOOT_TIME = .15 ##
def __init__(self,
base,
ini_pos=Point3(0, 100, 100),
tipus="kamikaze",
wwidth=None,
wheight=None):
DirectObject.__init__(self)
if wwidth and wheight:
self.WIN_WIDTH = wwidth
self.H_WIDTH = self.WIN_WIDTH / 2
self.WIN_HEIGHT = wheight
self.H_HEIGHT = self.WIN_HEIGHT / 2
self.keyMap = {"shoot": 0, "centerPointer": 0, "turn": 0}
self.bulletClock = 0.
self.overheatClock = 0.
self.BALA_VEL = self.BALA_VEL_BASE + self.VEL_MIN_AVIO
ambient = AmbientLight("alight")
ambientNp = render.attachNewNode(ambient)
ambient.setColor(VBase4(.3, .3, .3, 1.))
self.avio = render.attachNewNode("avio")
self.avio.setHpr(randint(0, 359), randint(0, 359), randint(0, 359))
self.avio.setPos(ini_pos)
self.avioR = self.avio.attachNewNode("avioDum2")
if tipus == "kamikaze":
self.modelAvio = base.loader.loadModel('prova/avio1blend')
else:
self.modelAvio = base.loader.loadModel('prova/avio1blend')
self.modelAvio.reparentTo(self.avioR)
self.avioVel = self.VEL_MIN_AVIO
self.balaDreta = self.modelAvio.find("**/BalaDreta")
self.balaEsquerra = self.modelAvio.find("**/BalaEsquerra")
self.avio.setLight(ambientNp)
self.avio.setAntialias(AntialiasAttrib.MMultisample)
self.modelAvio.setColor(1, 1, 0, 1)
self.modelAvio.setScale(.51)
lightBales = AmbientLight('dlight')
self.lightBalesNp = base.camera.attachNewNode(lightBales)
self.lightBalesNp.setHpr(0, 0, 0)
#-#-#-#-configuracio de camara
base.disableMouse()
#~ self.oobe()
base.camera.reparentTo(self.avio)
base.camera.setHpr(self.avio, 0, 0, 0)
base.camera.setPos(self.avio, 0, self.CAMERA_Y, 1.5)
base.camLens.setFov(self.CAM_FOV * (4. / 3.), self.CAM_FOV)
self.mirilla2 = OnscreenImage(image="prova/textures/areatir2.png",
parent=pixel2d)
self.mirilla2.setScale(128)
self.mirilla2.setTransparency(1)
self.mirilla2.setPos(self.H_WIDTH, 0, -self.H_HEIGHT)
self.mirilla = base.loader.loadModel("prova/textures/fixador.egg")
self.mirilla.reparentTo(pixel2d)
self.mirilla.setScale(64.)
self.mirilla.setPos(0, 0, 0)
self.mirilla.find('**/+SequenceNode').node().pose(0)
self.cursorGirar = pixel2d.attachNewNode("cursorGirar")
self.cursorGirarImage = OnscreenImage(
image="prova/textures/fletxa.png", parent=self.cursorGirar)
self.cursorGirarImage.setScale(16. / 2, 1., 32. / 2)
self.cursorGirarImage.setPos(0, 0, 0)
self.cursorGirarImage.setHpr(-90, 0, -90)
self.cursorGirarImage.setTransparency(1)
cursorGirarEffect = BillboardEffect.make(up_vector=Vec3(0, 0, 1),
eye_relative=False,
axial_rotate=False,
offset=0.,
look_at=self.mirilla2,
look_at_point=Point3(0, 0, 0))
self.cursorGirar.setEffect(cursorGirarEffect)
self.overheats = []
for i in range(8):
if i % 2 == 0:
self.overheats.append(
OnscreenImage(image="prova/textures/overheat1.png",
parent=pixel2d))
else:
self.overheats.append(
OnscreenImage(image="prova/textures/overheat2.png",
parent=pixel2d))
self.overheats[i].setScale(32., 1., 32.)
self.overheats[i].setTransparency(1)
self.overheats[i].hide()
self.overheats[0].setPos(self.H_WIDTH + 36, 0, -self.H_HEIGHT + 36)
self.overheats[0].setHpr(0, 0, 0)
self.overheats[1].setPos(self.H_WIDTH + 36, 0, -self.H_HEIGHT + 36)
self.overheats[1].setHpr(0, 0, 0)
self.overheats[2].setPos(self.H_WIDTH + 36, 0, -self.H_HEIGHT - 36)
self.overheats[2].setHpr(0, 0, 90)
self.overheats[3].setPos(self.H_WIDTH + 36, 0, -self.H_HEIGHT - 36)
self.overheats[3].setHpr(0, 0, 90)
self.overheats[4].setPos(self.H_WIDTH - 36, 0, -self.H_HEIGHT - 36)
self.overheats[4].setHpr(0, 0, 180)
self.overheats[5].setPos(self.H_WIDTH - 36, 0, -self.H_HEIGHT - 36)
self.overheats[5].setHpr(0, 0, 180)
self.overheats[6].setPos(self.H_WIDTH - 36, 0, -self.H_HEIGHT + 36)
self.overheats[6].setHpr(0, 0, -90)
self.overheats[7].setPos(self.H_WIDTH - 36, 0, -self.H_HEIGHT + 36)
self.overheats[7].setHpr(0, 0, -90)
#PARTICLE SYSTEM SETUP
self.particlesDummy = render.attachNewNode("particlesDummy")
self.particlesDummy.setPosHprScale(0, 0, 0, 0, 0, 0, 1, 1, 1)
self.particlesDummy.clearLight(render.find("dlight"))
self.particlesDummy.setLight(self.lightBalesNp)
base.enableParticles()
#COLLISIONS
base.cTrav = CollisionTraverser()
base.cTrav.setRespectPrevTransform(True)
self.balaCol = CollisionNode("balaCol")
self.balaCol.setIntoCollideMask(BitMask32.allOff())
self.balaCol.setFromCollideMask(BitMask32(0x00000001))
balaColSolid = CollisionSphere(0., 0., 0., .2)
self.balaCol.addSolid(balaColSolid)
self.pickRay = CollisionNode("pickRay")
self.pickRayNp = base.camera.attachNewNode(self.pickRay)
self.pickRay.setIntoCollideMask(BitMask32.allOff())
self.pickRay.setFromCollideMask(BitMask32(0x00000002))
self.pickRayCHandler = CollisionHandlerQueue()
self.mouseRay = CollisionRay()
self.pickRay.addSolid(self.mouseRay)
self.mouseRay.setOrigin(0, 0, 0)
base.cTrav.addCollider(self.pickRayNp, self.pickRayCHandler)
#~ self.nearPlane = CollisionNode("nearPlane")
#~ self.nearPlaneNp = base.camera.attachNewNode(self.nearPlane)
#~ base.camRays.setIntoCollideMask(BitMask32(0x00000001))
#~ self.nearPlaneNp.setPos(0, 1, 0)
#~ self.nearPlaneColSolid = CollisionPlane(Plane(Vec3(0, -1, 0), Point3(0, 1, 0)))
#~ self.nearPlane.addSolid(self.nearPlaneColSolid)
def giraAvio(task):
timeVar = globalClock.getDt()
point = base.win.getPointer(0)
pointerx = point.getX()
pointery = point.getY()
self.mouseRay.setFromLens(base.camNode, pointerx, pointery)
#Cursors de la pantalla
self.mirilla.setPos(pointerx, 0, -pointery)
self.cursorGirar.setPos(pointerx, 0, -pointery)
r = pow(abs(pointery - self.H_HEIGHT), 2) + pow(
abs(pointerx - self.H_WIDTH), 2)
if r > 8000:
self.mirilla.hide()
self.cursorGirar.show()
else:
self.mirilla.show()
self.cursorGirar.hide()
#3D
pointerx = (pointerx - self.H_WIDTH)
pointery = (pointery - self.H_HEIGHT)
self.avioR.setX(self.avio, -pointerx * 3. / float(self.WIN_WIDTH))
self.avioR.setZ(self.avio, pointery * 3. / (self.WIN_HEIGHT))
self.avio.setH(self.avio,
-pointerx * 256. / self.WIN_WIDTH * timeVar)
self.avio.setP(self.avio,
-pointery * 256. / self.WIN_HEIGHT * timeVar)
self.avioR.setR(self.avio, pointerx / 10.)
self.avioR.setP(self.avio, pointery / 70.)
self.avioR.setH(self.avio, -pointerx / 50.)
#~ self.avioVel += self.avioAcc*timeVar
#~ self.avio.setPos(self.avio, self.avioVel*timeVar)
return task.cont
def propulsaAvio(acceleracio, task):
self.avioVel += acceleracio * globalClock.getDt()
if self.avioVel < self.VEL_MIN_AVIO:
self.avioVel = self.VEL_MIN_AVIO
elif self.avioVel > self.VEL_MAX_AVIO:
self.avioVel = self.VEL_MAX_AVIO
self.BALA_VEL = self.BALA_VEL_BASE + self.avioVel
#MOSTRA LA VELOCITAT
pos = float(self.avioVel - self.VEL_MIN_AVIO) / (
self.VEL_MAX_AVIO - self.VEL_MIN_AVIO)
base.camera.setY(self.CAMERA_Y - pos * 4)
#~ self.marcaVelocitat.setX(MARCAVEL_INI_X+pos*137.)
return task.cont
self.haCremat = False
def mouAvio(task):
timeVar = globalClock.getDt()
self.avio.setPos(self.avio, 0, self.avioVel * timeVar, 0)
if self.keyMap["shoot"] == 1:
if self.bulletClock <= 0.:
self.bulletClock = self.SHOOT_TIME
if not self.haCremat:
if self.overheatClock > 16:
self.haCremat = True
self.overheatClock = 18
else:
self.overheatClock += self.SHOOT_TIME
shoot()
else:
self.bulletClock -= timeVar
else:
self.bulletClock = 0.
self.overheatClock -= timeVar
if self.overheatClock < 16: self.haCremat = False
if self.haCremat: self.overheatClock -= timeVar
if self.overheatClock < 0:
self.overheatClock = 0
elif self.overheatClock < 2:
self.overheats[0].hide()
elif self.overheatClock < 4:
self.overheats[1].hide()
self.overheats[0].show()
elif self.overheatClock < 6:
self.overheats[2].hide()
self.overheats[1].show()
elif self.overheatClock < 8:
self.overheats[3].hide()
self.overheats[2].show()
elif self.overheatClock < 10:
self.overheats[4].hide()
self.overheats[3].show()
elif self.overheatClock < 12:
self.overheats[5].hide()
self.overheats[4].show()
elif self.overheatClock < 14:
self.overheats[6].hide()
self.overheats[5].show()
self.overheats[7].hide()
elif self.overheatClock < 16:
self.overheats[7].hide()
self.overheats[6].show()
else:
self.overheats[7].show()
if self.keyMap["turn"] == 1:
self.avio.setX(self.avio, -self.VEL_COSTAT * timeVar)
elif self.keyMap["turn"] == -1:
self.avio.setX(self.avio, self.VEL_COSTAT * timeVar)
return task.cont
def avioRecte(task):
p = self.avio.getP(render)
if p > 170 or p < -170: return task.cont
timeVar = globalClock.getDt()
roll = self.avio.getR(render)
if roll < -self.VEL_AVIO_RECTE * timeVar:
self.avio.setR(render, roll + self.VEL_AVIO_RECTE * timeVar)
elif roll <= self.VEL_AVIO_RECTE * timeVar:
self.avio.setR(render, 0)
else:
self.avio.setR(render, roll - self.VEL_AVIO_RECTE * timeVar)
return task.cont
self.balaPositiu = True
def shoot():
bala = self.particlesDummy.attachNewNode("balaDummy")
balaImage = OnscreenImage(image="prova/textures/bala.png",
parent=bala)
balaImage.setTransparency(1)
balaImage.setScale(.1, 1., .2)
balaImage.setBillboardPointEye()
bala.setQuat(self.modelAvio.getQuat(render))
if self.balaPositiu:
bala.setPos(self.balaDreta.getPos(render))
self.balaPositiu = False
else:
bala.setPos(self.balaEsquerra.getPos(render))
self.balaPositiu = True
balaSphere = bala.attachNewNode(self.balaCol)
balaColHandler = CollisionHandlerQueue()
base.cTrav.addCollider(balaSphere, balaColHandler)
#~ if type(self.shootPoint) == 'libpanda.Point3':
#~ bala.lookAt(self.shootPoint)
#~ else: bala.setH(bala, 180.)
taskMgr.add(
mouBala,
"moubala",
extraArgs=[bala, balaImage, self.BALA_VEL, balaColHandler],
appendTask=True)
def mouBala(bala, balaImage, vel, queue, task):
if task.time > 3:
balaImage.detachNode()
expbala = ParticleEffect()
expbala.reparentTo(self.particlesDummy)
expbala.loadConfig('explosio.ptf')
expbala.start(bala)
taskMgr.doMethodLater(.25,
suprimir,
"suprimir",
extraArgs=[bala, expbala])
return task.done
if queue.getNumEntries() != 0:
balaImage.detachNode()
entry = queue.getEntry(0)
bala.setPos(entry.getSurfacePoint(self.particlesDummy))
expbala = ParticleEffect()
expbala.reparentTo(self.particlesDummy)
expbala.loadConfig('explosio.ptf')
expbala.start(bala)
taskMgr.doMethodLater(.25,
suprimir,
"suprimir",
extraArgs=[bala, expbala])
return task.done
bala.setFluidPos(bala, 0, vel * globalClock.getDt(), 0)
balaImage.setR(balaImage, 1000 * globalClock.getDt())
return task.cont
def suprimir(bala, expbala):
bala.detachNode()
expbala.cleanup()
expbala.detachNode()
def setKey(key, value):
self.keyMap[key] = value
def centraRatoli():
point = base.win.getPointer(0)
x = point.getX()
y = point.getY()
x -= self.H_WIDTH
y -= self.H_HEIGHT
r = sqrt(pow(abs(y), 2) + pow(abs(x), 2))
def centra(t, x, y):
base.win.movePointer(0,
trunc(x * t) + self.H_WIDTH,
trunc(y * t) + self.H_HEIGHT)
i = LerpFunc(centra,
fromData=1.,
toData=0.,
duration=r / 700.,
blendType='easeInOut',
extraArgs=[x, y],
name="centraRata")
i.start()
self.previousPos = 0
self.interval01 = LerpPosHprInterval(self.modelAvio,
.5,
Point3(3, 0, 0),
VBase3(0, 0, 70),
Point3(0, 0, 0),
VBase3(0, 0, 0),
blendType='easeInOut')
self.interval10 = LerpPosHprInterval(self.modelAvio,
.5,
Point3(0, 0, 0),
VBase3(0, 0, 0),
Point3(-3, 0, 0),
VBase3(0, 0, -70),
blendType='easeInOut')
self.interval02 = LerpPosHprInterval(self.modelAvio,
.5,
Point3(-3, 0, 0),
VBase3(0, 0, -70),
Point3(0, 0, 0),
VBase3(0, 0, 0),
blendType='easeInOut')
self.interval20 = LerpPosHprInterval(self.modelAvio,
.5,
Point3(0, 0, 0),
VBase3(0, 0, 0),
Point3(3, 0, 0),
VBase3(0, 0, 70),
blendType='easeInOut')
self.interval12 = LerpPosHprInterval(self.modelAvio,
1.,
Point3(-3, 0, 0),
VBase3(0, 0, -70),
Point3(3, 0, 0),
VBase3(0, 0, 70),
blendType='easeInOut')
self.interval21 = LerpPosHprInterval(self.modelAvio,
1.,
Point3(3, 0, 0),
VBase3(0, 0, 70),
Point3(-3, 0, 0),
VBase3(0, 0, -70),
blendType='easeInOut')
def allIntervalsStopped():
if self.interval01.isStopped() and self.interval10.isStopped(
) and self.interval02.isStopped() and self.interval20.isStopped(
) and self.interval12.isStopped() and self.interval21.isStopped():
return True
else:
return False
def tombaAvio(task):
if self.keyMap[
"turn"] == 0 and self.previousPos != 0 and allIntervalsStopped(
):
if self.previousPos == 1: self.interval10.start()
else: self.interval20.start()
self.previousPos = 0
elif self.keyMap[
"turn"] == -1 and self.previousPos != -1 and allIntervalsStopped(
):
if self.previousPos == 0: self.interval01.start()
else: self.interval21.start()
self.previousPos = -1
elif self.keyMap[
"turn"] == 1 and self.previousPos != 1 and allIntervalsStopped(
):
if self.previousPos == 0: self.interval02.start()
else: self.interval12.start()
self.previousPos = 1
return task.cont
def anim1():
self.mirilla.find('**/+SequenceNode').node().setPlayRate(1.)
self.mirilla.find('**/+SequenceNode').node().play(0, 3)
def anim2():
self.mirilla.find('**/+SequenceNode').node().setPlayRate(1.)
self.mirilla.find('**/+SequenceNode').node().play(4, 8)
def anim3():
self.mirilla.find('**/+SequenceNode').node().setPlayRate(-1.)
self.mirilla.find('**/+SequenceNode').node().play(0, 3)
def anim4():
self.mirilla.find('**/+SequenceNode').node().setPlayRate(-1.)
self.mirilla.find('**/+SequenceNode').node().play(3, 8)
#events
self.accept(self.QUIT_KEY, sysExit, [0])
self.accept(self.ACCELERATE_KEY, taskMgr.add, [
propulsaAvio, "propulsaAvio1", None, [self.ACCELERACIO], None,
None, True
])
self.accept(self.ACCELERATE_KEY + "-up", taskMgr.remove,
["propulsaAvio1"])
self.accept(self.DECELERATE_KEY, taskMgr.add, [
propulsaAvio, "propulsaAvio2", None, [-self.ACCELERACIO], None,
None, True
])
self.accept(self.DECELERATE_KEY + "-up", taskMgr.remove,
["propulsaAvio2"])
for key in self.SHOOT_KEYS:
self.accept(key, setKey, ["shoot", 1])
self.accept(key + "-up", setKey, ["shoot", 0])
self.accept(self.RIGHT_KEY, setKey, ["turn", -1])
self.accept(self.LEFT_KEY, setKey, ["turn", 1])
self.accept(self.RIGHT_KEY + "-up", setKey, ["turn", 0])
self.accept(self.LEFT_KEY + "-up", setKey, ["turn", 0])
self.accept(self.CENTRA_RATA_KEY, centraRatoli)
self.accept("n", anim1)
self.accept("m", anim2)
self.accept("v", anim3)
self.accept("b", anim4)
taskMgr.add(giraAvio, "GiraAvio")
taskMgr.add(mouAvio, "MouAvio")
taskMgr.add(avioRecte, "avioRecte")
taskMgr.add(tombaAvio, "tombaAvio")
