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 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()
class EnvironmentLoader():
""" Loads an environment into the game."""
def __init__(self):
self.envGen = EnvironmentGenerator() # Used to create a new environment
self.SetupDirectories()
self.isSaving = False
self.saveImage = OnscreenImage(image = 'Assets/Images/HUD/Save.png', scale = 128.0 / 1024, pos = (0.8, 0, -0.85))
self.saveImage.setTransparency(TransparencyAttrib.MAlpha)
self.saveImage.reparentTo(aspect2d)
self.saveImage.hide()
taskMgr.setupTaskChain('EnvironmentSave', numThreads = 1,
frameSync = False)
def SetupDirectories(self):
""" Creates the necessary directories for saving
and loading environments.
"""
self.MkDir('Assets')
self.MkDir('Assets/OfflineLevels')
self.MkDir('Assets/ServerLevels')
def MkDir(self, dirName):
""" Creates the specified directory."""
try:
os.makedirs(dirName)
except OSError, e:
if e.errno != errno.EEXIST:
raise
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 LoadContent(self):
# Load the dark background
blackBG = OnscreenImage(image = 'Assets/Images/Inventory/BlackScreen.png', scale = (2, 1, 1))
blackBG.setTransparency(TransparencyAttrib.MAlpha)
blackBG.reparentTo(self.node)
# Load the inventory image
self.inventoryBackground = OnscreenImage(image = 'Assets/Images/Inventory/inventory.png')
self.inventoryBackground.setTransparency(TransparencyAttrib.MAlpha)
self.inventoryBackground.reparentTo(self.node)
# Load the button for changing the firemode
self.fmButton = FireModeButton(self.node)
# Load the inventory slots
startPos = [[263, 524], [622, 440], [622, 282], [372, 361], [406, 282], [406, 440], [293, 361]]
padding = 69
for i, inventory in enumerate(self.inventories):
invSlots = inventory.GetInventorySlots()
for x in xrange(len(invSlots)):
for y in xrange(len(invSlots[0])):
inventorySlot = invSlots[x][y]
if(isinstance(inventory, MainInventory)):
if(y == 0):
button = InventorySlotButton(x, y, startPos[i][0], 741, padding, x, 0, inventorySlot, inventory, self.OnInventorySlotButtonClick)
else:
button = InventorySlotButton(x, y, startPos[i][0], startPos[i][1], padding, x, y - 1, inventorySlot, inventory, self.OnInventorySlotButtonClick)
else:
button = InventorySlotButton(x, y, startPos[i][0], startPos[i][1], padding, x, y, inventorySlot, inventory, self.OnInventorySlotButtonClick)
button.ReparentTo(self.node)
inventorySlot.SetInventorySlotButton(button)
self.node.hide()
class LoadingScreen:
def __init__(self, main):
self.main = main
self.imageObject = OnscreenImage(image = 'IMAGES/loading.jpg', pos = (0, 0, 0))
self.imageObject.reparentTo(render2d)
#base.graphicsEngine.renderFrame()
base.graphicsEngine.renderFrame()
def finish(self):
self.imageObject.destroy()
self.countDownText = OnscreenText(text=str(countDownStart), style=1, fg=(1,1,1,1),
pos=(0.01, 0.1), align = TextNode.ACenter, scale = .2, mayChange = 1)
taskMgr.add(self.countDown,"countDownTask")
def countDown(self,task):
timeLeft = "%01d" % (countDownStart - task.time)
if (countDownStart - task.time) > 1:
self.countDownText.setText(timeLeft)
return task.cont
elif 1 > (countDownStart - task.time) > 0:
self.countDownText.setText("GO!")
return task.cont
else:
self.canMove = True
if not self.main.isActive:
print "Activate"
self.main.isActive = True
taskMgr.add(self.main.update, 'updateWorld')
self.main.activateKeys()
self.countDownText.destroy()
return task.done
def makeGUI(self):
'''
Creates GUI controls and renders on screen
Health, targeting reticle, ammunition, weapon display, score
store results in self.playerGUI
'''
# TODO GUI logic for player
self.playerGUI = DirectFrame(
frameSize=(base.a2dLeft, base.a2dRight, base.a2dBottom,
base.a2dTop),
frameColor=(0, 0, 0, 0) #make completely transparent
)
reticle = OnscreenImage(image='images/reticle.png',
scale=(0.5, 1, .25))
reticle.setTransparency(TransparencyAttrib.MAlpha)
reticle.reparentTo(self.playerGUI)
self.playerGUI.HP = OnscreenText(text="HEALTH",
pos=(0.95, 0.8),
scale=0.2,
fg=(0, 0, 90, 1),
align=TextNode.ACenter,
mayChange=1)
self.playerGUI.HP.reparentTo(self.playerGUI)
self.playerGUI.score = OnscreenText(text="Score: 0",
pos=(-1.5, 0.8),
scale=0.2,
fg=(0, 0, 90, 1),
align=TextNode.ALeft,
mayChange=1)
self.playerGUI.score.reparentTo(self.playerGUI)
def Preload():
loader.loadModel('Assets/Models/Items/SMGAuto')
loader.loadModel('Assets/Models/Items/RifleAuto')
loader.loadModel('Assets/Models/Items/SniperBolt')
loader.loadModel('Assets/Models/Players/ralph')
currentDir = os.getcwd()
for root, dirs, files in os.walk(currentDir):
for f in files:
if f.endswith('.png'):
i = root.find('Assets')
s = '%s/%s' % (root[i:].replace('\\', '/'), f)
#loader.loadTexture(s)
x = OnscreenImage(image = s)
x.reparentTo(render)
x.destroy()
print 'Loaded', s
Globals.FONT_SAF = loader.loadFont('Assets/Fonts/SAF.otf')
Globals.FONT_SAF.setPixelsPerUnit(60)
print 'Loaded Assets/Fonts/SAF.otf'
Globals.AUDIO_3D = Audio3DManager.Audio3DManager(base.sfxManagerList[0], base.camera)
Globals.AUDIO_3D.setDistanceFactor(15.0)
Globals.LoadRocket()
def LoadContent(self):
bg = OnscreenImage(image = 'Assets/Images/Inventory/BlackScreen.png', scale = (2, 1, 1))
bg.setTransparency(TransparencyAttrib.MAlpha)
bg.reparentTo(self.node)
self.LoadButton('Button_Multiplayer', 'multiplayer', 'multiplayer_over', 0, 0, self.OnButtonClicked, ['multiplayer'])
self.LoadButton('Button_Options', 'options', 'options_over', 0, -0.3, self.OnButtonClicked, ['options'])
self.LoadButton('Button_Exit', 'exit', 'exit_over', 0, -0.6, self.OnButtonClicked, ['exit'])
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 set_manager(self, *args, **kwargs):
preloader = OnscreenImage(image=S.preloader, scale=(1, 1, 1))
preloader.reparentTo(render2d)
def callback(task):
self.manager = Manager(*args, **kwargs)
taskMgr.add(self.manager, 'manager')
preloader.destroy()
taskMgr.doMethodLater(0.1, callback, 'set_manager')
def append_button(self, button, beat):
btn_image = OnscreenImage(image=self.tex_buttons[button],
pos=(-beat * self.BTN_SPACE_PER_BEAT, 0,
self.z_pos),
scale=self.BTN_SCALE,
parent=render2d)
btn_image.setTransparency(TransparencyAttrib.MAlpha)
btn_image.reparentTo(self.button_node)
def __init__(self, nodeGroundHandler, name):
self.name = name
self.bullet = NodePath(
"bullet") # loader.loadModel('res/models/box.egg')
self.bullet.setScale(1)
self.shoot = NodePath("shoot")
self.shoot.setPos(self.Start)
self.bullet.reparentTo(self.shoot)
DoorImage = OnscreenImage(image="res/portal/door.png",
pos=(0, -2, 0),
scale=(8.8, 1, 14.2))
DoorImage.setTransparency(TransparencyAttrib.MAlpha)
DoorImage.setSa(0.5)
self.Portal = NodePath("Portal")
DoorImage.reparentTo(self.Portal)
self.Portal.setScale(5)
# forward Segment
forwardSegment = CollisionRay(0, 0, 0, 0, 1, 0)
self.cn = CollisionNode(name)
self.cn.addSolid(forwardSegment)
self.cn.setFromCollideMask(BitMask32.bit(0))
self.cn.setIntoCollideMask(BitMask32.allOff())
self.solid = self.shoot.attachNewNode(self.cn)
base.cTrav.addCollider(self.solid, nodeGroundHandler)
# Right Segment
RightSegment = CollisionSegment(-20, -0.2, 0, 20, -0.2, 0)
self.cnRight = CollisionNode(name + 'right')
self.cnRight.addSolid(RightSegment)
self.cnRight.setFromCollideMask(BitMask32.allOff())
self.cnRight.setIntoCollideMask(BitMask32.allOff())
self.solid = self.Portal.attachNewNode(self.cnRight)
self.RightSegmentCollisionHandlerQueue = CollisionHandlerQueue()
base.cTrav.addCollider(self.solid,
self.RightSegmentCollisionHandlerQueue)
# self.solid.show()
# Up Segment
UpSegment = CollisionSegment(0, -0.2, -15, 0, -0.2, 15)
self.cnUp = CollisionNode(name + 'up')
self.cnUp.addSolid(UpSegment)
self.cnUp.setFromCollideMask(BitMask32.allOff())
self.cnUp.setIntoCollideMask(BitMask32.allOff())
self.solid = self.Portal.attachNewNode(self.cnUp)
# self.solid.show()
base.cTrav.addCollider(self.solid,
self.RightSegmentCollisionHandlerQueue)
Sphere = CollisionSphere(0, 0, 0, 60)
self.cnout = CollisionNode(name + 'out')
self.cnout.addSolid(Sphere)
self.cnout.setFromCollideMask(BitMask32.bit(0))
self.cnout.setIntoCollideMask(BitMask32.allOff())
self.solid = self.shoot.attachNewNode(self.cnout)
# self.solid.show()
base.cTrav.addCollider(self.solid, nodeGroundHandler)
self.NeedCheckPos = False
self.initParticle()
class LifebarUI(UIBase):
def __init__(self,world):
UIBase.__init__(self,world)
#self.mainChar = world.hero
self.liferoundImage = DirectFrame(image='./LEGameAssets/Textures/health_tray.png',
pos = (1.34,0,-1), scale = (1.34,1,1),
frameColor = (1,1,1,0))
self.lifebarImage = OnscreenImage(image='./LEGameAssets/Textures/lifebar.png',
pos = (0.285,0,-0.125),scale=(0.215, 1, 0.026))
self.liferoundImage.setTransparency(1)
self.liferoundImage.reparentTo(base.a2dTopLeft)
self.lifebarImage.reparentTo(base.a2dTopLeft)
self.entirelife = self.world.hero.getMaxHealth()
#self.accept("a", self.update)
#self.accept("s", self.reset)
#self.update()
def update(self):
self.life = self.world.hero.getHealth()
self.lifebarupdate(self.entirelife, self.life)
#self.accept("a", self.lifebarupdate)
#self.accept("s", self.hide)
#self.accept("d", self.show)
# print "lifebar"
#pass
def lifebarupdate(self, entirelife, life):
#entirelife = 100
#self.life = self.life-10
if life>0:
self.lifebarImage['scale'] = (float(life)/entirelife*0.215,1,0.026)
self.lifebarImage['pos'] = (0.285-(1-float(life)/entirelife)*0.215,0,-0.125)
else:
self.lifebarImage.hide()
def reset(self):
self.life = self.world.hero.getMaxHealth()
self.lifebarImage['scale'] = (0.215, 1, 0.026)
self.lifebarImage['pos'] = (0.285,0,-0.125)
self.lifebarImage.show()
def hide(self):
self.liferoundImage.hide()
self.lifebarImage.hide()
def show(self):
self.liferoundImage.show()
self.lifebarImage.show()
#w = LifebarUI()
#run()
def createVelocityIndicator(self, colour=None):
""" loads an image used to represent the direction of motion """
if colour is None:
colour = self.colour
# load the image, put it in aspect2d and make sure
# transparency is respected
vel_ind = OnscreenImage(image="gui/velocityindicator.png", pos=(0.0, 0.0, 0.0), scale=0.05, color=colour)
vel_ind.reparentTo(aspect2d)
vel_ind.setTransparency(TransparencyAttrib.MAlpha)
return vel_ind
class app(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.planet=self.loader.loadModel(MAINDIR+'/Engine/Dark_soul.egg')
self.planet.setPos(0,0,0)
self.planet.setScale(0.09,0.09,0.09)
self.planet.reparentTo(render)
self.setBackgroundColor(0.2,0.2,0.2,1)
self.backgrnd=OnscreenImage(image=str(MAINDIR)+'/Engine/Stars.png',scale=(1.78,1,1))
self.backgrnd.reparentTo(render)
self.backgrnd.setPos(0,0,0)
self.enableParticles()
self.testpart=ParticleEffect()
self.testpart.loadConfig(MAINDIR+'/Engine/destruction_ring.ptf')
self.testpart.start(parent=render,renderParent=render)
self.pointA,self.pointB=LPoint3f(0,0,0),LPoint3f(1,0.1,0.3)
vec = self.pointB - self.pointA
norm=vec.length()
H,P,R=-atan(vec[0]/vec[1])*180/pi+180,(-atan(vec[2]/vec[1])+pi/2)*180/pi,0 # cette formule vaut son poids en or X)
#H,P,R=30,-30,0
self.planet.setHpr(H,P,R)
self.testpart.setHpr(H,P,R)
self.testpart.radiateOrigin=(vec[0]/norm,vec[1]/norm,vec[2]/norm)
# axis
coord=[(1,0,0),(0,1,0),(0,0,1)]
axis=[]
for c in range(3):
axis.append(LineSegs())
axis[c].moveTo(0,0,0)
axis[c].drawTo(coord[c])
axis[c].setThickness(3)
axis[c].setColor(tuple([coord[c][u]*255 for u in range(len(coord[c]))] +[0.05]))
NodePath(axis[c].create()).reparent_to(render)
# end of axis
testline=LineSegs()
testline.moveTo(self.pointA)
testline.drawTo(self.pointB)
testline.setThickness(3)
testline.set_color(0,0,0,1)
NodePath(testline.create()).reparent_to(render)
plight=render.attachNewNode(PointLight('plight01'))
plight.setPos(5,0,0)
self.planet.setLight(plight)
def LoadCrosshair(self, filename):
parentNode = self.node.attachNewNode('CrossHair')
if('Sniper' in filename):
x = OnscreenImage(image = 'Assets/Images/Crosshairs/OuterBlack.png', scale = 2.2)
x.setTransparency(TransparencyAttrib.MAlpha)
x.reparentTo(parentNode)
x = OnscreenImage(image = 'Assets/Images/Crosshairs/%s.png' % (filename), scale = 1)
x.setTransparency(TransparencyAttrib.MAlpha)
x.reparentTo(parentNode)
parentNode.hide()
return parentNode
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 make_level_item(self, level_header):
level_name = level_header['NAME']
level_item = aspect2d.attachNewNode(level_name)
level_img = OnscreenImage(image='./levels/%s/image.png' % level_name,
scale=(512.0/base.win.getXSize(), 1 ,362.0/base.win.getYSize()), pos = (0.0, 0.0, 0.3), parent=level_item)
level_img.setTransparency(TransparencyAttrib.MAlpha)
level_img.reparentTo(level_item)
if level_header.has_key("TITLE"):
title_str = "%s" % level_header["TITLE"]
else:
title_str = "%s" % level_header["NAME"]
artist_str = ""
if level_header.has_key("ARTIST"):
artist_str = "by %s" % level_header["ARTIST"]
title_text = OnscreenText(text = title_str, pos = (0.0, 0.-0.3), scale = 0.2, font=babelfish_font, align=TextNode.ACenter, fg=(1,1,1,1))
title_text.reparentTo(level_item)
next_y = -0.50
if artist_str:
next_y -= 0.05
artist_text = OnscreenText(text = artist_str, pos = (0.0, 0.-0.4), scale = 0.15, font=babelfish_font, align=TextNode.ACenter, fg=(1,1,1,1))
artist_text.reparentTo(level_item)
bpm_text = OnscreenText(text = "BPM %.2f" % level_header["BPM"], pos = (0.0, next_y), scale = 0.18, font=babelfish_font, align=TextNode.ACenter, fg=(1,1,1,1))
bpm_text.reparentTo(level_item)
if self.game_opts.has_option('hiscores', level_name):
his = self.game_opts.get('hiscores', level_name).split(',')
maxrank = OnscreenText(text = "max rank %s" % his[0].upper(),
pos = (0.0, next_y-0.15), scale = 0.18, font=babelfish_font, align=TextNode.ACenter, fg=(1,1,1,1))
hiscore = OnscreenText(text = "hiscore %s" % his[1],
pos = (0.0, next_y-0.25), scale = 0.18, font=babelfish_font, align=TextNode.ACenter, fg=(1,1,1,1))
maxrank.reparentTo(level_item)
hiscore.reparentTo(level_item)
return level_item
def LoadContent(self, title, message):
bg = OnscreenImage(image = 'Assets/Images/Inventory/BlackScreen.png', scale = (2, 1, 1))
bg.setTransparency(TransparencyAttrib.MAlpha)
bg.reparentTo(self.node)
popup = OnscreenImage(image = 'Assets/Images/Menus/Popups/popup.png')
popup.setTransparency(TransparencyAttrib.MAlpha)
popup.reparentTo(self.node)
titleText = OnscreenText(text = title, pos = (-0.29, 0.51), scale = 0.07, fg = (1, 1, 1, 1))
titleText.reparentTo(self.node)
self.LoadButton('Button_Okay', 'okay', 'okay_over', -0.27, -0.13, self.OnButtonClicked, ['okay'])
self.LoadButton('Button_Cancel', 'cancel', 'cancel_over', 0.27, -0.13, self.OnButtonClicked, ['cancel'])
messageText = OnscreenText(text = message, pos = (0, 0.2), scale = 0.07, fg = (1, 1, 1, 1))
messageText.reparentTo(self.node)
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 HUDBottomRight(DirectObject):
def __init__(self):
self.node = base.a2dBottomRight.attachNewNode('hudBottomRight')#GUIOrder.ORDER[GUIOrder.HUD])
self.node.setBin('fixed', GUIOrder.ORDER[GUIOrder.HUD])
self.ammoIcon = OnscreenImage(image = 'Assets/Images/HUD/HUDBottomRight.png', scale = 512.0 / 1024, pos = (-0.5, 0, 0.5))
self.ammoIcon.setTransparency(TransparencyAttrib.MAlpha)
self.ammoIcon.reparentTo(self.node)
self.ammoTextClip = OnscreenText(text = '30', pos = (-0.35, 0.09), scale = 0.12, fg = (1, 1, 1, 1), shadow = (0, 0, 0, 1), mayChange = True, align=TextNode.ARight, font = Globals.FONT_SAF)
self.ammoTextClip.reparentTo(self.node)
self.ammoTextClip.setBin('fixed', GUIOrder.ORDER[GUIOrder.HUD])
self.ammoTextLeft = OnscreenText(text = '90', pos = (-0.23, 0.05), scale = 0.07, fg = (1, 1, 1, 1), shadow = (0, 0, 0, 1), mayChange = True, align=TextNode.ARight, font = Globals.FONT_SAF)
self.ammoTextLeft.reparentTo(self.node)
self.ammoTextLeft.setBin('fixed', GUIOrder.ORDER[GUIOrder.HUD])
self.accept(AmmoChangeEvent.EventName, self.OnAmmoChangeEvent)
self.accept(SelectedItemChangeEvent.EventName, self.OnSelectedItemChangeEvent)
def OnAmmoChangeEvent(self, event):
item = event.GetItem()
if(item and item.GetCurrentClipAmmo() == ''):
self.ChangeAmmoText('', '')
else:
self.ChangeAmmoText(str(item.GetCurrentClipAmmo()), str(item.GetTotalRemainingAmmo()))
def ChangeAmmoText(self, clip, total):
self.ammoTextClip.setText(clip)
self.ammoTextLeft.setText(total)
def OnSelectedItemChangeEvent(self, event):
if(event.GetItemStack() and event.GetItemStack().GetItem()):
self.OnAmmoChangeEvent(AmmoChangeEvent(None, event.GetItemStack().GetItem()))
else:
self.ChangeAmmoText('', '')
def Destroy(self):
self.ignoreAll()
self.ammoIcon.removeNode()
self.ammoTextClip.removeNode()
self.ammoTextLeft.removeNode()
self.node.removeNode()
def LoadContent(self, title, fields, initialValues):
bg = OnscreenImage(image = 'Assets/Images/Inventory/BlackScreen.png', scale = (2, 1, 1))
bg.setTransparency(TransparencyAttrib.MAlpha)
bg.reparentTo(self.node)
popup = OnscreenImage(image = 'Assets/Images/Menus/Popups/fullscreenPopup.png')
popup.setTransparency(TransparencyAttrib.MAlpha)
popup.reparentTo(self.node)
titleText = OnscreenText(text = title, pos = (-0.29, 0.81), scale = 0.07, fg = (1, 1, 1, 1))
titleText.reparentTo(self.node)
self.LoadButton('Button_Okay', 'okay', 'okay_over', -0.27, -0.8, self.OnButtonClicked, ['okay'])
self.LoadButton('Button_Cancel', 'cancel', 'cancel_over', 0.27, -0.8, self.OnButtonClicked, ['cancel'])
y = 0
for i in xrange(len(fields)):
self.fields[fields[i]] = self.CreateField(fields[i], initialValues[i], y, y)
y += 1
def LoadContent(self):
bg = OnscreenImage(image = 'Assets/Images/Menus/MainMenu/background.png', scale = (2, 1, 1))
bg.setTransparency(TransparencyAttrib.MAlpha)
bg.reparentTo(self.node)
bg.setBin('fixed', 1)
title = OnscreenImage(image = 'Assets/Images/Menus/MainMenu/title.png')
title.setTransparency(TransparencyAttrib.MAlpha)
title.reparentTo(self.node)
self.spinner = OnscreenImage(image = 'Assets/Images/Menus/MainMenu/loadingSpinner.png', pos = (-0.15, 1, 0.15), scale = 128.0/1024.0)
self.spinner.setTransparency(TransparencyAttrib.MAlpha)
self.spinner.reparentTo(base.a2dBottomRight)
self.spinner.setBin('gui-popup', 0)
self.spinner.hide()
self.LoadButton('Button_Offline', 'offline', 'offline_over', 0, 0.2, self.OnButtonClicked, ['offline'])
self.LoadButton('Button_Multiplayer', 'multiplayer', 'multiplayer_over', 0, 0, self.OnButtonClicked, ['multiplayer'])
self.LoadButton('Button_Options', 'options', 'options_over', 0, -0.2, self.OnButtonClicked, ['options'])
self.LoadButton('Button_Exit', 'exit', 'exit_over', 0, -0.4, self.OnButtonClicked, ['exit'])
def loadingScreen(self):
self.intro.play()
transition = Transitions(loader)
transition.setFadeColor(0, 0, 0)
text = TextNode('node name')
dummy = NodePath(PandaNode("dummy"))
black = OnscreenImage(image="GUI/black.png",pos=(0,0,0), scale=100)
black.reparentTo(dummy)
textNodePath = aspect2d.attachNewNode(text)
textNodePath.reparentTo(aspect2d, 2)
textNodePath.setScale(0.07)
text.setTextColor(1, 1, 1, 1)
if(self.currentLevel=="newyork"):
Sequence(Func(transition.fadeOut),Func(black.reparentTo, aspect2d),Func(transition.fadeIn),Func(textNodePath.reparentTo,aspect2d, 10),Func(text.setText, "loading"),Wait(1.0),Func(text.setText, "loading."),
Wait(1.0),Func(text.setText, "loading.."), Wait(1.0), Func(text.setText, "loading..."), Func(self.loadNextLevel),Wait(3.0),Func(transition.fadeIn),Func(textNodePath.remove), Func(black.destroy)).start()
elif(self.currentLevel=="asia"):
Sequence(Func(transition.fadeOut),Func(black.reparentTo, aspect2d),Func(transition.fadeIn),Func(textNodePath.reparentTo,aspect2d, 10),Func(text.setText, "loading"),Wait(1.0),Func(text.setText, "loading."),
Wait(1.0),Func(text.setText, "loading.."), Wait(1.0), Func(text.setText, "loading..."), Func(self.loadNextLevel),Wait(3.0),Func(transition.fadeIn),Func(textNodePath.remove), Func(black.destroy)).start()
else:
Sequence(Func(transition.fadeOut),Func(black.reparentTo, aspect2d),Func(transition.fadeIn),Func(textNodePath.reparentTo,aspect2d, 10),Func(text.setText, "loading"),Wait(0.5),Func(text.setText, "loading."),
Wait(0.5),Func(text.setText, "loading.."), Wait(0.5), Func(text.setText, "loading..."), Func(self.loadNextLevel),Wait(1.5),Func(transition.fadeIn),Func(textNodePath.remove), Func(black.destroy)).start()
class HitMarker(DirectObject):
def __init__(self):
self.node = aspect2d.attachNewNode('hitmarker')#GUIOrder.ORDER[GUIOrder.HUD])
self.node.setBin('fixed', GUIOrder.ORDER[GUIOrder.HUD])
self.indicator = OnscreenImage(image = 'Assets/Images/HUD/HitMarker.png', scale = 64.0 / 1024)
self.indicator.setTransparency(TransparencyAttrib.MAlpha)
self.indicator.reparentTo(self.node)
self.alphaSeq = Sequence(Wait(0.2),
LerpColorInterval(self.node, 0.2, Vec4(1, 1, 1, 0), Vec4(1, 1, 1, 1)),
Func(self.Hide))
self.node.hide()
self.accept(PlayerHitEvent.EventName, self.OnPlayerHitEvent)
def Hide(self):
self.node.hide()
def Show(self):
self.node.show()
self.node.setColor(Vec4(1, 1, 1, 1))
def OnPlayerHitEvent(self, event):
if(event.GetAttacker().GetPlayerState().GetValue(PlayerState.PID) == Globals.MY_PID):
self.Show()
self.alphaSeq.start(startT = 0)
def Destroy(self):
self.alphaSeq.finish()
self.ignoreAll()
self.indicator.removeNode()
self.node.removeNode()
class HUDBottomLeft(DirectObject):
def __init__(self):
self.node = base.a2dBottomLeft.attachNewNode('hudhealth')#GUIOrder.ORDER[GUIOrder.HUD])
self.node.setBin('fixed', GUIOrder.ORDER[GUIOrder.HUD])
self.health = OnscreenImage(image = 'Assets/Images/HUD/HUDBottomLeft.png', scale = 512.0 / 1024, pos = (0.5, 0, 0.5))
self.health.setTransparency(TransparencyAttrib.MAlpha)
self.health.reparentTo(self.node)
self.healthText = OnscreenText(text = '100', pos = (0.2, 0.07), scale = 0.12, fg = (1, 1, 1, 1), shadow = (0, 0, 0, 1), mayChange = True, font = Globals.FONT_SAF, align=TextNode.ALeft)
self.healthText.reparentTo(self.node)
self.healthText.setBin('fixed', GUIOrder.ORDER[GUIOrder.HUD])
self.healthColorSeq = Sequence(LerpColorScaleInterval(self.node, 0.25, Globals.COLOR_RED),
LerpColorScaleInterval(self.node, 0.25, Globals.COLOR_WHITE))
self.dieingColorSeq = Sequence(LerpColorScaleInterval(self.node, 1, Globals.COLOR_RED),
LerpColorScaleInterval(self.node, 1, Globals.COLOR_WHITE))
self.accept(PlayerHealthEvent.EventName, self.OnPlayerHealthEvent)
def OnPlayerHealthEvent(self, event):
health = event.GetHealth()
self.healthText.setText(str(health))
if(health < 16):
#self.node.setColor(Globals.COLOR_RED)
self.dieingColorSeq.loop()
elif(health == 100):
self.dieingColorSeq.finish()
else:
self.healthColorSeq.start()
def Destroy(self):
self.ignoreAll()
self.health.removeNode()
self.healthText.removeNode()
self.node.removeNode()
class ExperimentCredits:
def __init__(self):
self.music = loader.loadMusic(
'phase_4/audio/bgm/science_fair_credits.ogg')
cm = CardMaker('screen-cover')
cm.setFrameFullscreenQuad()
self.screenCover = render2d.attachNewNode(cm.generate())
self.screenCover.hide()
self.screenCover.setScale(100)
self.screenCover.setColor((0, 0, 0, 1))
self.logo = OnscreenImage(image='phase_3/maps/toontown-logo.png',
scale=(1.0 * (4.0 / 3.0), 1,
1.0 / (4.0 / 3.0)),
pos=(-0.05, 1, -0.85))
self.logo.setTransparency(TransparencyAttrib.MAlpha)
self.logo.reparentTo(base.a2dTopCenter)
self.logo.hide()
self.creditsSeq = None
def disableToonInterface(self):
pass
def enableToonInterface(self):
pass
def start(self):
base.musicManager.stopAllSounds()
self.disableToonInterface()
self.music.play()
self.creditsSeq = Sequence(
# Fade the screen black
Sequence(
Func(self.screenCover.show),
Func(self.screenCover.setTransparency, 1),
LerpColorScaleInterval(self.screenCover,
4,
Vec4(1, 1, 1, 1),
startColorScale=Vec4(1, 1, 1, 0)),
Func(self.screenCover.clearColorScale),
Func(self.screenCover.clearTransparency)),
# Fade the logo in
Sequence(
Func(self.logo.show),
LerpColorScaleInterval(self.logo,
2,
Vec4(1, 1, 1, 1),
startColorScale=Vec4(1, 1, 1, 0)),
Func(self.logo.clearColorScale)),
# Wait 2 seconds
Wait(2.0),
# Fade the logo out
Sequence(
LerpColorScaleInterval(self.logo,
5,
Vec4(1, 1, 1, 0),
startColorScale=Vec4(1, 1, 1, 1)),
Func(self.logo.clearColorScale), Func(self.logo.hide)),
# Chan's slide
chanSlide.construct(),
)
self.creditsSeq.start()
def stop(self):
pass
def cleanup(self):
pass
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 MissionOne(object):
def __init__(self, p, m):
"""
:type p: Player
"""
self.menu = m
self.player = p
self.password = None
self.passwordExit = None
self.bookIndex = 0
# self.manager = GoodsManager()
self.manager = self.player.goodmanager
self.tutorialText = range(10)
self.plotText = [[0] * 10] * 10
self.memoryText = [[0] * 10] * 10
self.kuraText = range(10)
self.initTutorial()
self.initPlot()
self.initMemory()
self.initKuraMessage()
self.flowerNum = 2
def initTutorial(self):
self.tutorialText[0] = ""
self.tutorialText[1] = "被Erosion感染的人存在侵蚀度这个概念。侵蚀度越高你的身体机能也就越强，\n" \
"但是一定不要为了力量而盲目提升侵蚀度，因为你的侵蚀度达到100%之后意识" \
"就会立刻消亡，成为Erosion病毒的傀儡。"
self.tutorialText[2] = "如果真的需要力量的话，可以发动技能入魔，通过提升侵蚀度的代价短暂提升\n" \
"自身的速度，同时随着侵蚀度上升可以做一些平时力量达不到的事情。但是一\n" \
"定给我不要滥用啊，不然的话就去死吧，笨蛋。系统提示：按下Space发动入魔。"
self.tutorialText[3] = "你终于想起来一些事情了呢~这个房间中有好多能让你找回记忆的东西。找到\n" \
"那些东西，也是拯救我们的办法呢。系统提示：在侵蚀度高于50%时你会有破坏\n" \
"东西的冲动和焦虑感，可能会影响剧情的发展。"
self.tutorialText[4] = "我们这种被Erosion寄生的人呢，在危险的时候会有一种直觉，这种直觉会让\n" \
"你在遭遇危险时听到自己的心跳声。说来，为什么我的心跳这么剧烈呢…"
self.tutorialText[5] = "在遇到无法通过的障碍时，使用侵蚀之门可以在空间中制造通道从而进行穿梭。\n" \
"我先在这里制造一扇给你示范一下，看好了哦。系统提示：按下鼠标右键可以\n" \
"向前方发射侵蚀之门，如果场景中存在两个侵蚀之门即可互相穿梭。"
self.menu.nextButton['command'] = self.hideTutorial
self.menu.nextButton['extraArgs'] = []
def initPlot(self):
self.plotText[0][0] = "终于醒了啊。估计你也想不起来过去的事情了，那我就重新介绍一下自己吧"
self.plotText[0][1] = "我叫Kura。当时有一群人冲向我们，你给自己注射了Erosion，\n然后杀掉了那些人呢。"
self.plotText[0][2] = "那些…人？Kura？不行，我还是想不起来……。"
self.plotText[0][3] = "只有你知道治疗Erosion的办法，所以能从病毒中拯救我们的…也就只有你了。\n" \
"因为我被感染的时间比较长，所以只能保持清醒状态很短时间…务必要从这里逃\n" \
"出去然后找到解药，不然我们恐怕都要迷失在这里了…我会在这里等你的。"
self.plotText[1] = "刚一踏出房间，房间的门就被重重的锁上了。无论我怎么叫喊，里面都没有回应。" \
"我尽可能不去想最糟糕的情况，大概kura不会有什么问题的吧。"
def initMemory(self):
pass
'''
编号2 记忆的回影
'''
self.memoryText[2][0] = "相册上这些实验体…似曾相识的感觉呢……"
self.memoryText[2][1] = "这份研究结论我也见过……为什么呢……"
self.memoryText[2][2] = "实验体被Erosion所侵蚀之后意识会逐渐被吞噬……\n" \
"Erosion结附在实验体上，夺去实验体的意识。"
self.memoryText[2][3] = "而这些失去意识的实验体脸上挂着笑容，大概是本我还活在海市蜃楼中吧。"
'''
编号4 熟识的地点
'''
self.memoryText[4][0] = "什么？！这个地点…我曾经来过。"
self.memoryText[4][1] = "这两个几乎完全相同的实验室…正是我曾经每天待着的地方……"
self.memoryText[4][2] = "为什么我会……有这么强的即视感呢？"
self.memoryText[4][3] = "那些大大的培养槽中的人，都还活着！他们本我的意识\n" \
"已经在幻境中沉沉睡去，大概是已经变成Erosion控制的傀儡……"
self.memoryText[4][4] = "这个实验的实验者是谁？为什么要研究这些傀儡呢？"
'''
编号5 过去的残影
'''
self.memoryText[5][0] = "这个合影……我依稀记得这是我和女儿一起照的……感觉……记忆在涌上来"
self.memoryText[5][1] = "她应该也在这个实验室中……在不久之前她被一些实验体咬伤了\n……不行，" \
"我一定要活着出去，并且找到她……"
self.memoryText[5][2] = "说起来kura，你长的真的很像我的女儿呢。可是你为什么会在这里呢？\n"
self.memoryText[5][3] = "是吗？那你就把我当成你的女儿呗，爸爸。"
self.memoryText[5][4] = "……"
self.memoryText[5][5] = "当然是开玩笑的啦，嘻嘻。我也不知道我为什么在这里，我只知道我也\n" \
"被Erosion感染了。不管这些，你一定要逃出去哦，无论是为了为了你\n" \
"的女儿亦或是你自己，或者说……为了我？"
self.memoryText[5][6] = "嗯，一定。"
def initKuraMessage(self):
self.kuraText[0] = "呜……真是的…干嘛突然用\n手电筒照我呀，好刺眼的……"
self.kuraText[1] = "……呜…又来…恶作剧也要有\n个限度呀………人家也是会生气的哦…"
self.kuraText[2] = "…不是说过了么…恶作剧什么的，要有个…限度呢。\n...\n去死吧你这可恶的人类！"
self.kuraText[3] = "我记得那边有个八音盒哦。\n这个发条应该和那个八音盒有关"
def interactiveWith(self, goods):
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.player.endTask()
self.goods = goods
if goods.Name == "elevator_box":
self.menu.selectDialog.show()
if goods.state == "ready":
self.menu.textLabel['text'] = "随着一声轻响，电梯缓缓地打开了。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "走进电梯"
self.menu.bButton.hide()
elif self.player.bag.haveItem("res/models/items/" + "hammer" + ".png") \
and goods.state == "cracked":
self.menu.textLabel['text'] = "无论怎么按动按钮，电梯都没有反应。\n" \
"电梯门已经残破不堪了，似乎可以强行打开的样子。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"你愤怒的抄起锤子砸向有一点裂缝的电梯门。\n"
"电梯间的门被砸开了。然而里面却没有电梯，\n"
"等待着你的是……", goods, "smashed", None, 'endC', None
]
self.menu.aButton['text'] = "用锤子砸"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "暂时离开"
elif self.player.bag.haveItem("res/models/items/" + "hammer" + ".png")\
and goods.state == "":
self.menu.textLabel['text'] = "无论怎么按动按钮，电梯都没有反应。\n" \
"电梯门已经残破不堪了，似乎可以强行打开的样子。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"你愤怒的抄起锤子砸向电梯门。\n门似乎被砸出了一点缝隙。", goods, "smashed",
["torch", "groupPhoto"], 3, -15
]
self.menu.aButton['text'] = "用锤子砸"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "暂时离开"
else:
self.menu.textLabel['text'] = "无论怎么按动按钮，电梯都没有反应。\n" \
"电梯门已经残破不堪了，似乎可以强行打开的样子。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "暂时离开"
self.menu.bButton.hide()
elif goods.Name == "distribution_box":
self.menu.selectDialog.show()
if goods.state == "opened":
self.menu.textLabel['text'] = "这个配电盒已经被打开了。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
elif self.player.bag.haveItem("res/models/items/" + "goldenKey" + ".png") and \
self.player.bag.haveItem("res/models/items/" + "hammer" + ".png"):
self.menu.textLabel['text'] = "配电盒被紧紧锁着，没有钥匙的话似乎打不开。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"配电盒的锁被打开了。你拉下了电闸，\n"
"看到电梯的按钮亮了起来。", goods, "opened"
]
self.menu.aButton['text'] = "用钥匙打开"
self.menu.bButton['command'] = self.showInfo
self.menu.bButton['extraArgs'] = [
"你砸开了配电盒，此时从配电盒里\n"
"传来巨大电流，你被电成了焦炭。", goods, "", None, "endD", None
]
self.menu.bButton['text'] = "用锤子砸"
elif self.player.bag.haveItem("res/models/items/" + "hammer" +
".png"):
self.menu.textLabel['text'] = "配电盒被紧紧锁着，没有钥匙的话似乎打不开。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"你砸开了配电盒，此时从配电盒里\n"
"传来巨大电流，你被电成了焦炭。", goods, "", None, "endD", None
]
self.menu.aButton['text'] = "用锤子砸"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "暂时离开"
elif self.player.bag.haveItem("res/models/items/" + "goldenKey" +
".png"):
self.menu.textLabel['text'] = "配电盒被紧紧锁着，没有钥匙的话似乎打不开。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"配电盒的锁被打开了。你拉下了电闸，\n"
"看到电梯的按钮亮了起来。", goods, "opened", None, "endD", None
]
self.menu.aButton['text'] = "用钥匙打开"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "暂时离开"
else:
self.menu.textLabel['text'] = "配电盒被紧紧锁着，没有钥匙的话似乎打不开。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "暂时离开"
self.menu.bButton.hide()
elif goods.Name == "clock_box":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "这个钟显示的时间……有点奇怪呢。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
elif goods.Name == "painting_1":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "《不要动我的蛋糕》"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
elif goods.Name == "painting_2":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "《死兔》"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
elif goods.Name == "painting_3":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "《破碎的镜》"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
elif goods.Name == "painting_4":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "《沾血的房间》"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
elif goods.Name == "painting_5":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "《数学题》"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
elif goods.Name == "painting_6":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "《正与反的恒常》"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
elif goods.Name == "painting_7":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "《夕阳》"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
elif goods.Name == "painting_8":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "《花》"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
elif goods.Name == "painting_9":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "《希望》"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
elif goods.Name == "lobby_door":
self.menu.selectDialog.show()
if self.player.EROSION >= 50 and self.goods.state == "":
self.menu.textLabel['text'] = "你的焦虑影响了你的思维。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"你用力向前一拍，砸碎了大厅门。", goods, "unlockedOpen"
]
self.menu.aButton['text'] = "我..."
self.menu.bButton.hide()
self.goods.OnClick()
self.password = Password()
self.password.passwordFrame.hide()
self.password.unloadLeap()
self.password.passState = True
else:
if self.goods.state == "unlockedOpen":
self.menu.textLabel['text'] = "大厅门上现在没有上锁。"
self.menu.aButton['command'] = self.openDoor
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "关闭大厅门"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "离开"
elif self.goods.state == "unlockedClose":
self.menu.textLabel['text'] = "大厅门上现在没有上锁。"
self.menu.aButton['command'] = self.openDoor
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "打开大厅门"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "离开"
else:
self.menu.textLabel['text'] = "门上存在一个电子锁。"
self.menu.aButton['command'] = self.openDoor
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "输入密码"
self.menu.bButton['command'] = self.showInfo
self.menu.bButton['extraArgs'] = [
"这个密码到底是什么呢……", goods, ""
]
self.menu.bButton['text'] = "暂时离开"
elif goods.Name == "laboratory_door":
self.menu.selectDialog.show()
if goods.state == "":
self.menu.textLabel['text'] = "这个门似乎可以推开，但总感觉里面阴森森的，有种不祥的气息。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"里面有窸窸窣窣的声音，不知道是什么东西在里面，\n"
"但是好像很可怕。", goods, ""
]
self.menu.aButton['text'] = "趴在门上听"
self.menu.bButton['command'] = self.showInfo
self.menu.bButton['extraArgs'] = [
"你面前出现了...", goods, "", None, "endE", None
]
self.menu.bButton['text'] = "推开门"
self.menu.bButton.hide()
elif goods.state == "deadRabbit":
self.menu.textLabel['text'] = "这个门似乎可以推开。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"里面有窸窸窣窣的声音，但是声音距离你很远。", goods, "deadRabbit"
]
self.menu.aButton['text'] = "趴在门上听"
self.menu.bButton['command'] = self.showInfo
self.menu.bButton['extraArgs'] = [
"门被打开了。", goods, "deadRabbit", None, "openLabDoor", None
]
self.menu.bButton['text'] = "推开门"
self.menu.bButton.hide()
elif self.player.bag.haveItem("res/models/items/" + "deadRabbit" +
".png"):
self.menu.textLabel['text'] = "这个门似乎可以推开，但总感觉里面阴森森的，有种不祥的气息。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"你将死兔放在门口，之后躲在大厅门旁暗中观察。\n"
"这时，一只血红色的手抓住了兔子，将其拉入了门内。\n"
"不久，门内传来哀嚎声。", goods, "deadRabbit"
]
self.menu.aButton['text'] = "投放死兔"
self.menu.bButton['command'] = self.showInfo
self.menu.bButton['extraArgs'] = [
"你面前出现了...", goods, "", None, "endE", None
]
self.menu.bButton['text'] = "推开门"
self.menu.bButton.hide()
elif self.player.bag.haveItem("res/models/items/" + "rabbit" +
".png"):
self.menu.textLabel['text'] = "这个门似乎可以推开，但总感觉里面阴森森的，有种不祥的气息。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"你将实验兔放在门口，之后躲在大厅门旁暗中观察。\n"
"这时，一只血红色的手抓住了兔子，将其拉入了门内。\n"
"你似乎听到门内传来“我……还……要”", goods, "rabbit"
]
self.menu.aButton['text'] = "投放实验兔"
self.menu.bButton['command'] = self.showInfo
self.menu.bButton['extraArgs'] = [
"你面前出现了...", goods, "", None, "endE", None
]
self.menu.bButton['text'] = "推开门"
self.menu.bButton.hide()
elif self.player.bag.haveItem("res/models/items/" + "hammer" +
".png"):
self.menu.textLabel['text'] = "这个门似乎可以推开，但总感觉里面阴森森的，有种不祥的气息。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"你把门敲开了，看到了一群满身血迹的怪物。\n"
"这时谁都救不了你了。", goods, "", None, "endE", None
]
self.menu.aButton['text'] = "用锤子砸"
self.menu.bButton['command'] = self.showInfo
self.menu.bButton['extraArgs'] = [
"你面前出现了...", goods, "", None, "endE", None
]
self.menu.bButton['text'] = "推开门"
self.menu.bButton.hide()
else:
self.menu.textLabel['text'] = "这个门似乎可以推开，但总感觉里面阴森森的，有种不祥的气息。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "暂时离开"
self.menu.bButton.hide()
elif goods.Name == "fridge_box":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "冰箱中东西不多，仅有几根胡萝卜和一个大蛋糕。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"获得胡萝卜*1", goods, "searched", ["carrot"]
]
self.menu.aButton['text'] = "拿走胡萝卜"
self.menu.bButton['command'] = self.showInfo
self.menu.bButton['extraArgs'] = [
"获得大蛋糕*1", goods, "searched", ["cake"], "endF", None
]
self.menu.bButton['text'] = "拿走大蛋糕"
elif goods.Name == "diary":
self.menu.selectDialog.show()
if self.player.EROSION > 50:
self.menu.textLabel['text'] = "因为意识混乱，日记上的字迹模糊不清，难以调查。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "暂时离开"
self.menu.bButton.hide()
else:
self.menu.textLabel['text'] = "这份研究结论我似乎见过呢。实验体被Erosion所侵蚀之后意识会逐渐被吞噬……\n" \
"Erosion结附在实验体上，夺去实验体的意识。而这些失去意识的实验体脸上\n" \
"挂着笑容，大概是本我意识还活在海市蜃楼中吧。"
self.menu.aButton['command'] = self.beginMemory
self.menu.aButton['extraArgs'] = [0, 2]
self.menu.aButton['text'] = "我记起了..."
self.menu.bButton.hide()
elif goods.Name == "moldy_food":
self.menu.selectDialog.show()
self.menu.textLabel[
'text'] = "食物放了太久 早就发霉了。看起来像是煮好的胡萝卜。“还是不要去尝了吧，不然会死人的”"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"实验兔吃下了发霉的食物，蹬了一下腿就一动不动了。\n"
"获得死兔", goods, "eaten", ["deadRabbit"]
]
self.menu.aButton['text'] = "使用实验兔"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "离开"
elif goods.Name == "safe_box":
self.menu.selectDialog.show()
if self.player.EROSION >= 50 and self.goods.state == "":
self.menu.textLabel['text'] = "你的焦虑影响了你的思维。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"你用力向前一拍，砸碎了大厅门。", goods, "unlockedOpen"
]
self.menu.aButton['text'] = "我..."
self.menu.bButton.hide()
self.goods.OnClick()
self.password = Password()
self.password.passwordFrame.hide()
self.password.unloadLeap()
self.password.passState = True
else:
if self.goods.state == "unlockedOpen":
self.menu.textLabel['text'] = "大厅门上现在没有上锁。"
self.menu.aButton['command'] = self.openDoor
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "关闭大厅门"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "离开"
elif self.goods.state == "unlockedClose":
self.menu.textLabel['text'] = "大厅门上现在没有上锁。"
self.menu.aButton['command'] = self.openDoor
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "打开大厅门"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "离开"
else:
self.menu.textLabel['text'] = "上面似乎有一个密码锁。"
self.menu.aButton['command'] = self.openDoor
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "输入密码"
self.menu.bButton['command'] = self.showInfo
self.menu.bButton['extraArgs'] = [
"这个密码到底是什么呢……", goods, ""
]
self.menu.bButton['text'] = "暂时离开"
elif goods.Name == "rabbit_cage":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "实验室的实验兔笼。里面的兔子似乎因为没有食物而显得很躁动。\n" \
"伸了伸手，发现似乎够不着兔子。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"你使用胡萝卜引诱兔子出来，抓出了一只兔子。\n"
"获得兔子*1", goods, "", ["rabbit"]
]
self.menu.aButton['text'] = "使用胡萝卜"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "离开"
elif goods.Name == "windows_box":
self.menu.selectDialog.show()
if goods.state == "smashed":
self.menu.textLabel['text'] = "这个窗户已经被砸开了。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
else:
self.menu.textLabel['text'] = "这个窗户似乎通向实验室。透过窗户看了看实验室里面，\n" \
"只看到一片阴影在蠕动。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"窗户似乎打不开呢……没有办法放兔子进去。", goods, ""
]
self.menu.aButton['text'] = "放入兔子"
self.menu.bButton['command'] = self.showInfo
self.menu.aButton['text'] = "使用锤子"
if self.player.EROSION > 80:
self.menu.aButton['extraArgs'] = [
"你用锤子直接砸碎了窗户。同时，窗户内传来\n"
"镜子破碎的声音。这时一个锈迹斑斑的铜板掉了\n"
"下来。获得锈迹斑斑的铜板", goods, "smashed", ["copper"]
]
else:
self.menu.aButton['extraArgs'] = [
"实验室窗户异常坚硬，砸不开。", goods, ""
]
elif goods.Name == "scissor":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "这里有把裁纸刀。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"获得裁纸刀*1", goods, "", ["scissor"]
]
self.menu.aButton['text'] = "拿起裁纸刀"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "离开"
elif goods.Name == "tank":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "硫酸槽中盛满了稀硫酸。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"你用稀硫酸除去了铁锈，看到了铜片上的文字。", goods, "", None, "copperText", None
]
self.menu.aButton['text'] = "使用铜板"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "离开"
elif goods.Name == "slogan":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "属于我们的请回来，不属于我们的请离开。我们是不可分离的\n" \
"镜的两面，恢复镜的人会获得祝福，破坏镜的人会万劫不复。\n" \
"当你迷茫如何前进时，不如去走廊欣赏一下艺术。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
elif goods.Name == "stove1":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "熊熊燃烧的火炉。你看到周围的灰烬中残留的纸屑写着文字“悲”"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"你把莎士比亚喜剧集烧掉，火焰变的更旺了", goods, "", None, "burnBook", None
]
self.menu.aButton['text'] = "烧掉喜剧集"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"这时火焰突然跃起。", goods, "", None, "burnFunBook", 15
]
self.menu.aButton['text'] = "烧掉其他书"
elif goods.Name == "stove2":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "熊熊燃烧的火炉。你看到周围的灰烬中残留的纸屑写着文字“喜”"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"你把莎士比亚悲剧集烧掉，火焰变的更旺了", goods, "", None, "burnBook", None
]
self.menu.aButton['text'] = "烧掉悲剧集"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"这时火焰突然跃起。", goods, "", None, "burnSadBook", 15
]
self.menu.aButton['text'] = "烧掉其他书"
elif goods.Name == "mirror":
self.menu.selectDialog.show()
if goods.state == "smashed":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "这其实是块玻璃而已，已经被砸碎了。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
else:
self.menu.textLabel['text'] = "显示出一模一样的情景，但没有映出自己的脸。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = [
"你用锤子砸碎了镜子，发现这其实是一块玻璃，\n"
"表里两侧除了光线以外完全相同。", goods, "smashed"
]
self.menu.aButton['text'] = "使用锤子"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "离开"
elif goods.Name == "flower_vase":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "里面有" + str(self.flowerNum) + "朵纸花。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"你成功插入了一朵纸花。", goods, "", None, "addFlower", None
]
self.menu.aButton['text'] = "插入纸花"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "离开"
elif goods.Name == "bookshelf_box":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "书架里有：《失忆症》《莎士比亚喜剧集》《高等代数分析》"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"获得《莎士比亚喜剧集》", goods, "", ["funBook"]
]
self.menu.aButton['text'] = "拿走莎士比亚喜剧集"
self.menu.bButton['command'] = self.showInfo
self.menu.bButton['extraArgs'] = [
"你看到书架后方有一个人影。\n"
"不对啊…书架明明是在墙角才对……", goods, "", None, "endG", None
]
self.menu.bButton['text'] = "拿走其他"
else:
self.resume()
'''
wall word
'''
def showWordBefore(self):
self.menu.selectDialog.hide()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.wordframe = DirectFrame(frameColor=(0, 0, 0, 1),
frameSize=(-2, 2, -2, 2),
pos=(0, 0, 0))
self.wordImage = OnscreenImage(
'res/models/SceneJPG/Scene1_Wall_Hall.png',
pos=(0, 0, 0),
scale=(1.4, 1, 1))
self.wordImage.reparentTo(self.wordframe)
# self.leaveButton=DirectButton
self.wordframe.show()
self.player.initTask()
base.accept("mouse1", self.wordReturn)
base.accept("escape", self.wordReturn)
def showWordAfter(self):
self.menu.selectDialog.hide()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.wordframe = DirectFrame(frameColor=(0, 0, 0, 1),
frameSize=(-2, 2, -2, 2),
pos=(0, 0, 0))
self.wordImage = OnscreenImage(
'res/models/SceneJPG/Scene1_Wall_Hall2.png',
pos=(0, 0, 0),
scale=(1.4, 1, 1))
self.wordImage.reparentTo(self.wordframe)
# self.wordImage.removeNode()
self.wordframe.show()
self.player.initTask()
base.accept("escape", self.wordReturn)
base.accept("mouse1", self.wordReturn)
def wordReturn(self):
self.wordframe.hide()
self.resume()
self.player.initTask()
base.accept("mouse1", self.player.__setattr__, ["LeftButton", 1])
base.accept('escape', self.player.game.pauseGame)
def changWord(self, info, goods, state, items=None):
goods.state = state
self.manager.GoodsIta["Scene1_wallword_1"].CloseHighLight()
self.manager.GoodsIta["Scene1_wallword_1"].Node.hide()
self.manager.GoodsIta["Scene1_wallword_1"].state = "changed"
self.manager.GoodsIta["Scene1_wallword_2"].Node.show()
self.menu.infoDialog['text'] = info
self.menu.infoDialog.show()
self.resume()
self.player.initTask()
'''
password door
'''
def openDoor(self):
if self.password is None:
self.password = Password()
self.password.password = "******"
else:
self.password.reloadLeap()
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.player.endTask()
self.password.passwordFrame.show()
self.menu.selectDialog.hide()
taskMgr.add(self.waitPass, "waitPass")
base.accept('escape', self.waitPassReturn)
def waitPass(self, task):
if self.password.passState:
self.password.passwordFrame.hide()
self.password.unloadLeap()
self.goods.OnClick()
if self.goods.state == "unlockedOpen":
self.goods.state = "unlockedClose"
else:
self.goods.state = "unlockedOpen"
self.resume()
self.player.initTask()
base.accept('escape', self.player.game.pauseGame)
return
if self.password.wrongTime == 1:
self.password.passwordFrame.hide()
self.password.wrongTime = 0
self.password.unloadLeap()
self.showInfo("密码错误，侵蚀度+5", self.goods, "", None, None, 5)
base.accept('escape', self.player.game.pauseGame)
return task.done
return task.cont
def waitPassReturn(self):
self.resume()
self.player.initTask()
base.accept('escape', self.player.game.pauseGame)
self.password.passwordFrame.hide()
def openExitDoor(self):
if self.passwordExit is None:
self.passwordExit = Password()
else:
self.passwordExit.reloadLeap()
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.player.endTask()
self.passwordExit.passwordFrame.show()
self.menu.selectDialog.hide()
taskMgr.add(self.waitExitPass, "waitExitPass")
base.accept('escape', self.waitExitPassReturn)
def waitExitPass(self, task):
if self.passwordExit.passState:
self.passwordExit.passwordFrame.hide()
self.passwordExit.unloadLeap()
self.goods.OnClick()
if self.goods.state == "unlockedOpen":
self.goods.state = "unlockedClose"
else:
self.goods.state = "unlockedOpen"
self.resume()
self.player.initTask()
base.accept('escape', self.player.game.pauseGame)
return
return task.cont
def waitExitPassReturn(self):
self.resume()
self.player.initTask()
base.accept('escape', self.player.game.pauseGame)
self.passwordExit.passwordFrame.hide()
def doNothing(self):
self.resume()
self.player.initTask()
def showTutorial(self, tutorialIndex):
self.menu.selectDialog.hide()
self.menu.tutorialDialog.show()
self.menu.nextButton['text'] = self.tutorialText[tutorialIndex]
def hideTutorial(self):
self.menu.bButton.show()
self.menu.selectDialog.hide()
self.menu.tutorialDialog.hide()
self.skip()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
base.win.movePointer(0,
base.win.getXSize() / 2,
base.win.getYSize() / 2)
self.player.initTask()
def hideOcanio(self):
self.menu.tutorialDialog.hide()
self.menu.ocanioDialog.hide()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
base.win.movePointer(0,
base.win.getXSize() / 2,
base.win.getYSize() / 2)
self.player.initTask()
def showInfo(self,
info,
goods,
state,
items=None,
index=None,
addErosion=None):
self.menu.infoDialog.show()
goods.state = state
self.menu.infoDialog['text'] = info
if items is not None:
for item in items:
if item == "rabbit":
self.player.bag.addItem(
Goods("res/models/items/" + item + ".png",
self.player.bag.rabbit, "一只实验兔"))
elif item == "deadRabbit":
self.player.bag.addItem(
Goods("res/models/items/" + item + ".png",
self.player.bag.deadRabbit, "一只死兔"))
elif item == "hammer":
self.player.bag.addItem(
Goods("res/models/items/" + item + ".png",
self.player.bag.hammer, "一只锤子"))
elif item == "injection":
self.player.bag.addItem(
Goods("res/models/items/" + item + ".png",
self.player.bag.injection, "抑制剂"))
elif item == "goldenKey":
self.player.bag.addItem(
Goods("res/models/items/" + item + ".png",
self.player.bag.goldenKey, "一把金色钥匙"))
elif item == "carrot":
self.player.bag.addItem(
Goods("res/models/items/" + item + ".png",
self.player.bag.carrot, "一根胡萝卜"))
elif item == "cake":
self.player.bag.addItem(
Goods("res/models/items/" + item + ".png",
self.player.bag.cake, "一块大蛋糕"))
elif item == "copper":
self.player.bag.addItem(
Goods("res/models/items/" + item + ".png",
self.player.bag.copper, "一个锈迹斑斑的铜板"))
elif item == "scissor":
self.player.bag.addItem(
Goods("res/models/items/" + item + ".png",
self.player.bag.scissor, "一把裁纸刀"))
elif item == "funBook":
self.player.bag.addItem(
Goods("res/models/items/" + item + ".png",
self.player.bag.funBook, "《莎士比亚喜剧集》"))
elif item == "sadBook":
self.player.bag.addItem(
Goods("res/models/items/" + item + ".png",
self.player.bag.sadBood, "《莎士比亚悲剧集》"))
else:
self.player.bag.addItem(
Goods("res/models/items/" + item + ".png",
self.player.bag.panda, "这是啥？"))
if index is not None:
if index == 3:
self.beginMemory(0)
self.menu.selectDialog.hide()
self.skip()
elif index == "endC" or index == "endD":
self.end(index)
else:
self.showTutorial(index)
self.skip()
else:
self.resume()
self.player.initTask()
if addErosion is not None:
if self.player.EROSION + addErosion < 0:
self.player.EROSION = 0
elif self.player.EROSION + addErosion > 100:
self.player.EROSION = 100
else:
self.player.EROSION += addErosion
def beginMemory(self, index, memIndex=None):
if memIndex is not None:
if index < 4:
self.menu.tutorialDialog.hide()
self.menu.ocanioDialog.show()
self.menu.ocanioButton['text'] = self.memoryText[memIndex][
index]
self.menu.ocanioButton['command'] = self.beginMemory
self.menu.ocanioButton['extraArgs'] = [index + 1]
else:
self.menu.tutorialDialog.hide()
self.menu.ocanioDialog.show()
self.menu.ocanioButton['text'] = self.memoryText[memIndex][
index]
self.menu.ocanioButton['command'] = self.hideOcanio
self.menu.ocanioButton['extraArgs'] = []
else:
if index < 3 or index == 4:
self.menu.tutorialDialog.hide()
self.menu.ocanioDialog.show()
self.menu.ocanioButton['text'] = self.memoryText[5][index]
self.menu.ocanioButton['command'] = self.beginMemory
self.menu.ocanioButton['extraArgs'] = [index + 1]
elif index == 3 or index == 5:
self.menu.tutorialDialog.show()
self.menu.ocanioDialog.hide()
self.menu.nextButton['text'] = self.memoryText[5][index]
self.menu.nextButton['command'] = self.beginMemory
self.menu.nextButton['extraArgs'] = [index + 1]
elif index == 6:
self.menu.tutorialDialog.hide()
self.menu.ocanioDialog.show()
self.menu.ocanioButton['text'] = self.memoryText[5][index]
self.menu.ocanioButton['command'] = self.hideOcanio
self.menu.ocanioButton['extraArgs'] = []
def aCommand(self):
self.resume()
self.player.initTask()
def bCommand(self):
self.menu.infoDialog.show()
self.menu.infoDialog['text'] = "get something!"
self.resume()
self.player.initTask()
def skip(self):
taskMgr.add(self.fadeTask, "fadeTask")
def fadeTask(self, task):
if task.time < 1.0:
return task.cont
self.menu.infoDialog.hide()
return task.done
def resume(self):
self.menu.bButton.show()
self.menu.selectDialog.hide()
# self.menu.tutorialDialog.hide()
self.skip()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
base.win.movePointer(0,
base.win.getXSize() / 2,
base.win.getYSize() / 2)
def end(self, fun="endB"):
self.endFun = fun
self.menu.tutorialDialog.hide()
taskMgr.add(self.fadeEnd, "fadeEnd")
def fadeEnd(self, task):
if task.time < 1.0:
self.menu.passFrame['frameColor'] = (0, 0, 0, task.time)
return task.cont
self.menu.passFrame.hide()
self.menu.infoDialog.hide()
if self.endFun == "endA":
self.endA()
elif self.endFun == "end1":
self.end1()
elif self.endFun == "endB":
self.endB()
return task.done
def endA(self):
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.player.endTask()
self.menu.mainFrame.show()
self.menu.infoDialog.show()
self.player.erosionFrame.hide()
self.player.currentItemFrame.hide()
self.menu.infoDialog['text'] = "Erosion max!"
self.skip()
def endB(self):
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.player.endTask()
self.menu.mainFrame.show()
self.menu.infoDialog.show()
self.player.erosionFrame.hide()
self.player.currentItemFrame.hide()
self.menu.tutorialDialog.hide()
self.menu.infoDialog['text'] = "Kura被你吓死了！"
self.skip()
def end1(self):
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.player.endTask()
self.menu.mainFrame.show()
self.menu.infoDialog.show()
self.player.erosionFrame.hide()
self.player.currentItemFrame.hide()
self.menu.infoDialog['text'] = "Erosion max!"
self.skip()
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
def append_button(self, button, beat):
btn_image = OnscreenImage(image=self.tex_buttons[button], pos=(-beat*self.BTN_SPACE_PER_BEAT, 0, self.z_pos), scale=self.BTN_SCALE, parent=render2d)
btn_image.setTransparency(TransparencyAttrib.MAlpha)
btn_image.reparentTo(self.button_node)
class login:
TEXT_COLOR = (1,1,1,1)
FONT_TYPE_01 = 0
TEXT_SHADOW_COLOR = (0,0,0,0.5)
characterSelectionInput = ""
output = ""
#frame = DirectFrame()
username01 = "harsh01"
#character selection varaiables
data1=2
#name1 = OnscreenText()
#name2 = OnscreenText()
#name3 = OnscreenText()
name11 = "harsh0111"
name22 = "xtremekiller"
name33 = "killermaster"
#submitBtn = DirectButton()
#cancelBtn = DirectButton()
#createbtn = DirectButton()
greyimage = "grey.png"
swordimage = "sword.png"
axeimage = "Axe.png"
username = OnscreenText()
src = ""
#character creation varaiables
v=[0]
v1=[0]
va1 = [0]
va2 = [0]
va3 = [0]
nameOfChar = OnscreenText()
#nameOfCharTextbox = DirectEntry()
factionSelection = OnscreenText()
nameOfCharInput =''
#charactertype = OnscreenText()
chartitle = ""
factiontitle=""
chardata =""
charFrame = DirectFrame()
frame = DirectFrame()
def __init__(self):
__builtin__.main=self
#self.loginEntry = []
self.createLogin();
self.dict = {}
try:
self.cManager = ConnectionManager()
self.startConnection()
except Exception:
self.error = True
def createLogin(self):
base.win.setClearColor(Vec4(0,0,0,1))
self.imageObject = OnscreenImage(parent = render2d, image = 'images/mainPage.png', pos = (0,0,0), scale = (1.444, 1, 1.444))
self.imageObject.setTransparency(TransparencyAttrib.MAlpha)
self.createMainFrame()
self.createText()
self.createTextEntry()
self.createButtons()
def startConnection(self):
if self.cManager.connection == None:
if not self.cManager.startConnection():
return False
return True
def createMainFrame(self):
"""Create the main base frame."""
self.registerFrame = DirectFrame( frameSize = (-0.512, 0.512, -0.362, 0.362),
frameColor = (0.53, 0.42, 0.18, 0.70),
pos = (0, 0, -0.28) )
self.mainBox = DirectFrame( frameSize = (-0.5, 0.5, -0.35, 0.35),
frameColor = (0, 0, 0, 0.25),
pos = (0, 0, 0) )
self.mainBox.reparentTo(self.registerFrame)
self.blackFrame = DirectFrame( frameSize = (-2, 2, -2, 2),
frameColor = (0, 0, 0, 0.3),
pos = (0, 0, 0),
state = DGG.NORMAL )
self.blackFrame.reparentTo(self.registerFrame, 1)
self.blackFrame.hide()
def createText(self):
"""Create some label for login text entry field"""
self.headerLabel = DirectLabel(text='LOG IN',
text_align=TextNode.ACenter,
frameSize=(-0.2, 0.2, 0.2, 0.2),
text_fg=(1,1,1,1),
text_scale=0.07,
frameColor=(0, 0, 0, 0),
pos=(0, 0, 0.23))
self.headerLabel.reparentTo(self.registerFrame)
self.usernameLabel = DirectLabel(text='Username',
text_align = TextNode.ARight,
text_fg=(1,1,1,1),
text_scale=0.06,
frameColor=(0, 0, 0, 0),
pos=(-0.19, 0, 0.067))
self.usernameLabel.reparentTo(self.registerFrame)
self.passwordLabel = DirectLabel(text='Password',
text_align = TextNode.ARight,
text_fg=(1,1,1,1),
text_scale=0.06,
frameColor=(0, 0, 0, 0),
pos=(-0.19, 0, -0.070))
self.passwordLabel.reparentTo(self.registerFrame)
def createTextEntry(self):
"""Create entry boxes for credentials."""
self.usernameEntry = DirectEntry(self.registerFrame,scale=0.055,
pos=(-0.14, 0, 0.055),
command=self.startSubmit,
focus=1,
focusInCommand=self.focus("username"),
#focusInExtraArgs=[0],
initialText="jeff",
rolloverSound = None)
self.usernameEntry.reparentTo(self.registerFrame)
#self.loginEntry.append(self.usernameEntry)
self.passwordEntry = DirectEntry(self.registerFrame,
scale=0.055,
pos=(-0.14, 0, -0.08),
command=self.startSubmit,
obscured=1,
focusInCommand=self.focus("password"),
#focusInExtraArgs=[1],
rolloverSound = None)
self.passwordEntry.reparentTo(self.registerFrame)
#self.loginEntry.append(self.passwordEntry)
def clearPassword(self):
self.passwordEntry.enterText('')
def startSubmit(self, message):
self.submitLogin()
def createButtons(self):
"""Create some buttons."""
self.validateLoginFrame = DirectFrame( frameSize = (-0.131, 0.131, -0.056, 0.056),
frameColor = (0.33, 0.42, 0.18, 0.95), # color of the login button
pos = (-0.2, 0, -0.22) )
self.validateLoginFrame.reparentTo(self.mainBox)
self.validateLogin = DirectButton (text='Log In',
text_fg=(1, 1, 1, 1),
text_pos=(0, -0.015),
text_scale=0.05,
frameSize=(-0.125, 0.125, -0.05, 0.05),
frameColor=(0, 0, 0, 0.2),
relief=DGG.FLAT,
pos=(0, 0, 0),
command=self.submitLogin,
clickSound = None,
rolloverSound = None)
self.validateLogin.reparentTo(self.validateLoginFrame)
self.registerButtonFrame = DirectFrame( frameSize = (-0.131, 0.131, -0.056, 0.056),
frameColor = (1, 0, 1, 1), # color of the register button
pos = (0.2, 0, -0.22) )
self.registerButtonFrame.reparentTo(self.mainBox)
self.registerButton = DirectButton(text='Register',
text_fg=(1, 1, 1, 1),
text_pos=(0, -0.015),
text_scale=0.05,
frameSize=(-0.125, 0.125, -0.05, 0.05),
frameColor=(0, 0, 0, 0.2),
relief=DGG.FLAT,
pos=(0, 0, 0),
command=self.register,
clickSound = None,
rolloverSound = None)
self.registerButton.reparentTo(self.registerButtonFrame)
def focus(self, text):
print text
def submitLogin(self):
print "Login"
print "username: "******"password: "******"" and self.passwordInput is not ""):
#c = characterSelection()
self.dict = {}
print "You pressed Submit", self.usernameInput, " ; ",self.passwordInput
self.cManager.sendRequest(Constants.CMSG_AUTH, (self.usernameInput, self.passwordInput));
self.mainUsername = self.usernameInput
""" THiS IS WHERE IT STARTS TO GET WEIRD """
#self.createSelectionWindow()
else:
print "Please enter in a username and password"
else:
print "Cannot connect to server."
#def resume(self):
#self.registerFrame.show()
def register(self):
"""Switch to the registration screen."""
self.registerFrame.hide()
#R = Register(self.registerFrame)
base.win.setClearColor(Vec4(0,0,0,1))
self.imageObject = OnscreenImage(parent = render2d, image = 'images/mainPage.png', pos = (0,0,0), scale = (1.444, 1, 1.444))
self.imageObject.setTransparency(TransparencyAttrib.MAlpha)
self.createRMainFrame()
self.createRText()
self.createRTextEntry()
self.createRButtons()
self.error = False
print "Register"
def createRMainFrame(self):
"""Create the main base frame."""
# frameColor is defined as (R,G,B,A)
self.registerFrame = DirectFrame( frameSize = (-0.612, 0.612, -0.462, 0.462),
frameColor = (0.53, 0.42, 0.18, 0.70),
pos = (0, 0, -0.37) )
self.mainBox = DirectFrame( frameSize = (-0.6, 0.6, -0.45, 0.45),
frameColor = (0, 0, 0, 0.25),
pos = (0, 0, 0) )
self.mainBox.reparentTo(self.registerFrame)
self.blackFrame = DirectFrame( frameSize = (-2, 2, -2, 2),
frameColor = (0, 0, 0, 0.3),
pos = (0, 0, 0),
state = DGG.NORMAL )
self.blackFrame.reparentTo(self.registerFrame, 1)
self.blackFrame.hide()
def createRText(self):
"""Create some label for login text entry field"""
self.headerLabel = DirectLabel(text='REGISTER',
text_align=TextNode.ACenter,
frameSize=(-0.2, 0.2, 0.2, 0.2),
text_fg=(1,1,1,1),
text_scale=0.07,
frameColor=(0, 0, 0, 0),
pos=(0, 0, 0.28))
self.headerLabel.reparentTo(self.registerFrame)
self.usernameLabel = DirectLabel(text='Username',
text_align = TextNode.ARight,
text_fg=(1,1,1,1),
text_scale=0.06,
frameColor=(0, 0, 0, 0),
pos=(-0.19, 0, 0.12))
self.usernameLabel.reparentTo(self.registerFrame)
self.passwordLabel = DirectLabel(text='Password',
text_align = TextNode.ARight,
text_fg=(1,1,1,1),
text_scale=0.06,
frameColor=(0, 0, 0, 0),
pos=(-0.19, 0, -0.023))
self.passwordLabel.reparentTo(self.registerFrame)
self.rePasswordLabel = DirectLabel(text='Re-Password',
text_align = TextNode.ARight,
text_fg=(1,1,1,1),
text_scale=0.06,
frameColor=(0, 0, 0, 0),
pos=(-0.19, 0, -0.16))
self.rePasswordLabel.reparentTo(self.registerFrame)
def createRTextEntry(self):
"""Create entry boxes for credentials."""
self.usernameEntry = DirectEntry(self.registerFrame,scale=0.055,
pos=(-0.14, 0, 0.12),
command=self.submitRRegister,
focus=1,
#focusInCommand=self.setFocus,
focusInExtraArgs=[0],
rolloverSound = None)
self.usernameEntry.reparentTo(self.registerFrame)
self.passwordEntry = DirectEntry(self.registerFrame,
scale=0.055,
pos=(-0.14, 0, -0.025),
command=self.submitRRegister,
obscured=1,
#focusInCommand=self.setFocus,
focusInExtraArgs=[1],
rolloverSound = None)
self.passwordEntry.reparentTo(self.registerFrame)
self.rePasswordEntry = DirectEntry(self.registerFrame,
scale=0.055,
pos=(-0.14, 0, -0.165),
command=self.submitRRegister,
obscured=1,
#focusInCommand=self.setFocus,
focusInExtraArgs=[2],
rolloverSound = None)
self.rePasswordEntry.reparentTo(self.registerFrame)
def createRButtons(self):
"""Create some buttons."""
self.validateRegFrame = DirectFrame( frameSize = (-0.131, 0.131, -0.056, 0.056),
frameColor = (0.33, 0.42, 0.18, 0.95),
pos = (-0.2, 0, -0.30) )
self.validateRegFrame.reparentTo(self.mainBox)
self.validateReg = DirectButton (text='Register',
text_fg=(1, 1, 1, 1),
text_pos=(0, -0.015),
text_scale=0.05,
frameSize=(-0.125, 0.125, -0.05, 0.05),
frameColor=(0, 0, 0, 0.2),
relief=DGG.FLAT,
pos=(0, 0, 0),
command=self.submitRRegister,
clickSound = None,
rolloverSound = None)
self.validateReg.reparentTo(self.validateRegFrame)
self.registerButtonFrame = DirectFrame( frameSize = (-0.131, 0.131, -0.056, 0.056),
frameColor = (0.33, 0.42, 0.18, 0.95),
pos = (0.2, 0, -0.30) )
self.registerButtonFrame.reparentTo(self.mainBox)
self.registerButton = DirectButton(text='Cancel',
text_fg=(1, 1, 1, 1),
text_pos=(0, -0.015),
text_scale=0.05,
frameSize=(-0.125, 0.125, -0.05, 0.05),
frameColor=(0, 0, 0, 0.2),
relief=DGG.FLAT,
pos=(0, 0, 0),
command=self.cancel,
clickSound = None,
rolloverSound = None)
self.registerButton.reparentTo(self.registerButtonFrame)
def submitRRegister(self):
print "username: "******"password: "******"re-password: "******"")
self.rePasswordEntry.enterText("")
try:
self.cManager = ConnectionManager()
self.startConnection()
print ""
except Exception:
self.error = True
if self.error is False:
if self.registerPassword == self.registerCPassword and self.registerPassword.strip() != "" and self.registerUsername.strip() != "":
print "Success (",self.registerUsername, ", ",self.registerPassword,", ",self.registerCPassword,")"
self.cManager.sendRequest(Constants.CMSG_REGISTER, (self.registerUsername, self.registerPassword))
self.cancel()
else:
taskMgr.add(self.errorMessage, "destroyIncorrectUsername")
self.message()
print "Failed (",self.registerUsername, ", ",self.registerPassword,", ",self.registerCPassword,")"
else:
print "Cannot Connect to the Server"
def errorMessage(self, task):
if task.time < 5.0:
return task.cont
else:
self.failed.destroy()
return task.done
def message(self):
self.failed = DirectLabel(text='Password needs to match',
text_align=TextNode.ACenter,
frameSize=(-0.2, 0.2, 0.2, 0.2),
text_fg=(1,1,1,1),
text_scale=0.07,
frameColor=(255, 0, 0, 1),
pos=(0, 0, 0.20))
self.failed.reparentTo(self.registerFrame)
def cancel(self):
print "cancel"
self.registerFrame.hide()
self.createLogin()
#self.l = login.resume()
#character Creation
def createCreateCharWindow(self):
self.charFrame = DirectFrame(frameColor=(0, 0, 0, 1), #(R,G,B,A)
frameSize=(-3, 3, -3, 3),#(Left,Right,Bottom,Top)
pos=(-0.5, 0, 0.9))
#print "print somethg:",self.some
self.swordImage=OnscreenImage(image = Constants.IMG_SWORD, pos = (0.85, 0, -.3),scale = 0.15)
self.swordImage.setTransparency(TransparencyAttrib.MAlpha)
self.swordImage.reparentTo(self.charFrame)
self.axeImage=OnscreenImage(image = Constants.IMG_AXE, pos = (0.45, 0, -0.3),scale = 0.15)
self.axeImage.setTransparency(TransparencyAttrib.MAlpha)
self.axeImage.reparentTo(self.charFrame)
self.username = OnscreenText(text = self.username01, pos = (-1,.5), scale = 0.08,fg=(1,0.5,0.5,1),align=TextNode.ACenter,mayChange=0)
self.username.reparentTo(self.charFrame)
self.charactertype = OnscreenText(text = "Character type :", pos = (-.1, -.55), scale = 0.08,fg=(1,0.5,0.5,1),align=TextNode.ACenter,mayChange=0)
self.charactertype.reparentTo(self.charFrame)
self.buttons = [
DirectRadioButton(text = '', variable=self.v, value=[0], scale=0.07, pos=(0.5,0,-.55), command=self.setText),
DirectRadioButton(text = '', variable=self.v, value=[1], scale=0.07, pos=(0.9,0,-.55), command=self.setText)
]
for button in self.buttons:
button.setOthers(self.buttons)
button.reparentTo(self.charFrame)
self.nameOfChar = OnscreenText(text = "Name The Character :", pos = (-0.2, -0.75), scale = 0.08,fg=(1,0.5,0.5,1),align=TextNode.ACenter,mayChange=0)
self.nameOfChar.reparentTo(self.charFrame)
self.nameOfCharTextbox = DirectEntry(text = "" ,scale=.07,pos=(0.3,0, -.75),command=self.setnameOfChar,initialText="Anonymous", numLines = 1,focus=0,focusInCommand=self.clearnameOfChar, focusOutCommand=self.getnameOfChar)
self.nameOfCharTextbox.reparentTo(self.charFrame)
self.factionSelection = OnscreenText(text = "Faction Selection :", pos = (-0.15, -1.0), scale = 0.08,fg=(1,0.5,0.5,1),align=TextNode.ACenter,mayChange=0)
self.factionSelection.reparentTo(self.charFrame)
self.blueImage=OnscreenImage(image = Constants.IMG_BLUE, pos = (0.4, 0, -.9),scale = 0.08)
self.blueImage.setTransparency(TransparencyAttrib.MAlpha)
self.blueImage.reparentTo(self.charFrame)
self.redImage=OnscreenImage(image = Constants.IMG_RED, pos = (0.7, 0, -.9),scale = 0.08)
self.redImage.reparentTo(self.charFrame)
self.redImage.setTransparency(TransparencyAttrib.MAlpha)
self.factionBtns = [
DirectRadioButton(text = '', variable=self.v1, value=[0], scale=0.07, pos=(0.45,0,-1.1), command=self.setfaction),
DirectRadioButton(text = '', variable=self.v1, value=[1], scale=0.07, pos=(0.75,0,-1.1), command=self.setfaction)
]
for button1 in self.factionBtns:
button1.setOthers(self.factionBtns)
button1.reparentTo(self.charFrame)
self.okForCreateBtn = DirectButton(text = ("Create", "Create", "Create", "disabled"), scale=.09, command=self.clickedOkForCreateBtn, pos=(0.2, 0.0, -1.3))
self.cancelForCreateBtn = DirectButton(text = ("Cancel", "Cancel", "Cancel", "disabled"), scale=.09, command=self.clickedCancelForCreateBtn, pos=(0.6, 0.0, -1.3))
self.okForCreateBtn.reparentTo(self.charFrame)
self.cancelForCreateBtn.reparentTo(self.charFrame)
def destroyCreateCharWindow(self):
#self.nameOfChar.destroy()
#self.swordImage.destroy()
#self.axeImage.destroy()
#self.blueImage.destroy()
#self.redImage.destroy()
#self.nameOfChar.destroy()
#self.nameOfCharTextbox.destroy()
#self.factionSelection.destroy()
#self.okForCreateBtn.destroy()
#self.cancelForCreateBtn.destroy()
#self.factionSelection.destroy()
#self.frame.destroy()
#self.factionBtns.destroy()
#self.button.destory()
self.charFrame.hide()
def mainresp(self,chartype,charname,charfact,cid):
print "printed these",chartype,charname,charfact
chardata="".join((chartype," ",charname," ",charfact, " ", str(cid)))
if(self.lengthdic<=3):
self.dict[self.lengthdic+1] = chardata
else:
print "u can have only 3 character"
self.clickedCancelForCreateBtn()
#self.createSelectionWindow()
def addChar(self):
self.mainresp(self.chartitle, self.nameOfCharInput, self.factiontitle)
self.clickedCancelForCreateBtn()
def initializeChars(self, chars):
#self.dict = {}
print "number of chars: ", len(chars)
self.lengthdic = len(self.dict)
for x in chars:
self.type = "sword"
self.faction = "blue"
self.cid = x[0]
self.name = x[1]
self.t1 = x[2]
self.f1 = x[3]
if self.t1 == 0:
self.type = "axe"
if self.f1 == 0:
self.faction = "red"
chardata="".join((self.type," ",self.name," ",self.faction, " ", str(self.cid)))
if(self.lengthdic<=3):
self.dict[self.lengthdic+1] = chardata
self.lengthdic = self.lengthdic + 1
else:
print "U CAN ONLY HAVE 3 CHAR"
self.createSelectionWindow()
def clearnameOfChar(self):
self.nameOfCharTextbox.enterText('')
def getnameOfChar(self):
self.nameOfCharInput = self.nameOfCharTextbox.get()
def setnameOfChar(self, textEntered):
print "name Of Char: ",textEntered
self.nameOfChar = textEntered
def clickedOkForCreateBtn(self):
self.nameOfCharInput = self.nameOfCharTextbox.get().strip()
print "you have pressed the ok button for creating a character"
print "you have Created a char of type",self.chartitle,";Faction : ",self.factiontitle,";name of character",self.nameOfCharInput,"; with username : "******"axe"):
self.type = 0
else:
self.type = 1
if self.factiontitle == "blue":
self.faction = 1
else:
self.faction = 0
self.cManager.sendRequest(Constants.CMSG_CREATE_CHARACTER, (self.nameOfCharInput, self.type ,self.faction));
#print "print somethg:",self.some
def clickedCancelForCreateBtn(self):
print "you have press the cancel button from the create character frame"
self.destroyCreateCharWindow()
self.createSelectionWindow()
#go back to login
def setText(self):
self.chartitle = ""
if self.v[0]:
self.chartitle="sword"
else:
self.chartitle="axe"
def setfaction(self):
self.factiontitle = ""
if self.v1[0]:
self.factiontitle="red"
else:
self.factiontitle="blue"
#character Selection
def createSelectionWindow(self):
self.registerFrame.hide()
self.selFrame = DirectFrame(frameColor=(0, 0, 0, 1), #(R,G,B,A)
frameSize=(-3, 3, -3, 3),#(Left,Right,Bottom,Top)
pos=(-0.5, 0, 0.9))
self.lengthdic = len(self.dict)
print self.lengthdic
if(self.lengthdic>3):
del self.dict[4]
self.lengthdic = len(self.dict)
print "updated lenght : ",self.lengthdic
if(self.lengthdic == 0):
print "lenght is zero no character"
if(self.lengthdic==1):
self.src = self.dict[1]
print "dic 1",self.src
self.dicts1 = self.src.split()
if(self.dicts1[0] =="axe"):
self.fristimageforchartype = Constants.IMG_AXE
else:
self.fristimageforchartype = Constants.IMG_SWORD
#set the name of the character
self.name11 = self.dicts1[1]
#set the color of the faction
if(self.dicts1[2] =="blue"):
self.fristimagefactiontype = Constants.IMG_BLUE
else:
self.fristimagefactiontype = Constants.IMG_RED
if(self.lengthdic==2):
self.src = self.dict[1]
print "dic 1",self.src
self.dicts1 = self.src.split()
if(self.dicts1[0] =="axe"):
self.fristimageforchartype = Constants.IMG_AXE
else:
self.fristimageforchartype = Constants.IMG_SWORD
self.src2 = self.dict[2]
print "dic 2",self.src2
self.dicts2 = self.src2.split()
if(self.dicts2[0] =="axe"):
self.secondimageforchartype = Constants.IMG_AXE
else:
self.secondimageforchartype = Constants.IMG_SWORD
self.name11 = self.dicts1[1]
self.name22 = self.dicts2[1]
#set the color of the faction
if(self.dicts1[2] =="blue"):
self.fristimagefactiontype = Constants.IMG_BLUE
else:
self.fristimagefactiontype = Constants.IMG_RED
if(self.dicts2[2] =="blue"):
self.secondimagefactiontype = Constants.IMG_BLUE
else:
self.secondimagefactiontype = Constants.IMG_RED
if(self.lengthdic<=3 and self.lengthdic>2):
self.src = self.dict[1]
print "dic 1",self.src
self.dicts1 = self.src.split()
if(self.dicts1[0] =="axe"):
self.fristimageforchartype = Constants.IMG_AXE
else:
self.fristimageforchartype = Constants.IMG_SWORD
self.src2 = self.dict[2]
print "dic 2",self.src2
self.dicts2 = self.src2.split()
if(self.dicts2[0] =="axe"):
self.secondimageforchartype = Constants.IMG_AXE
else:
self.secondimageforchartype = Constants.IMG_SWORD
self.src3 = self.dict[3]
print "dic 3",self.src3
self.dicts3 = self.src3.split()
if(self.dicts3[0] =="axe"):
self.thridimageforchartype = Constants.IMG_AXE
else:
self.thridimageforchartype = Constants.IMG_SWORD
self.name11 = self.dicts1[1]
self.name22 = self.dicts2[1]
self.name33 = self.dicts3[1]
#set the color of the faction
if(self.dicts1[2] =="blue"):
self.fristimagefactiontype = Constants.IMG_BLUE
else:
self.fristimagefactiontype = Constants.IMG_RED
if(self.dicts2[2] =="blue"):
self.secondimagefactiontype = Constants.IMG_BLUE
else:
self.secondimagefactiontype = Constants.IMG_RED
if(self.dicts3[2] =="blue"):
self.thridimagefactiontype = Constants.IMG_BLUE
else:
self.thridimagefactiontype = Constants.IMG_RED
#print self.dicts1[0]
if(self.lengthdic==1):
#image = Constants.IMG_GREY
self.greyImage1=OnscreenImage(image = Constants.IMG_GREY , pos = (1.35, 0, -0.45),scale = 0.2)
self.greyImage1.setTransparency(TransparencyAttrib.MAlpha)
self.greyImage2=OnscreenImage(image = Constants.IMG_GREY, pos = (0.55, 0, -0.45),scale = 0.2)
self.greyImage2.setTransparency(TransparencyAttrib.MAlpha)
self.greyImage3=OnscreenImage(image = self.fristimageforchartype, pos = (-0.25, 0, -0.45),scale = 0.2)
self.greyImage3.setTransparency(TransparencyAttrib.MAlpha)
self.name1 = OnscreenText(text = self.name11, pos = (-0.25,-0.85), scale = 0.08,fg=(1,0.5,0.5,1),align=TextNode.ACenter,mayChange=1)
self.factionImage1=OnscreenImage(image = self.fristimagefactiontype, pos = (-0.25, 0, -1.0),scale = 0.08)
self.factionImage1.setTransparency(TransparencyAttrib.MAlpha)
self.factionImage1.reparentTo(self.selFrame)
self.name1.reparentTo(self.selFrame)
#change method and variable names
self.mainRadioBtns1 = [
DirectRadioButton(text = '', variable=self.va1, value=[0], scale=0.07, pos=(-0.2,0,-1.2), command=self.setcharselection1)
]
for mainbutton1 in self.mainRadioBtns1:
mainbutton1.setOthers(self.mainRadioBtns1)
mainbutton1.reparentTo(self.selFrame)
elif(self.lengthdic==2):
#image = Constants.IMG_GREY
self.greyImage1=OnscreenImage(image = Constants.IMG_GREY, pos = (1.35, 0, -0.45),scale = 0.2)
self.greyImage1.setTransparency(TransparencyAttrib.MAlpha)
self.greyImage2=OnscreenImage(image = self.secondimageforchartype, pos = (0.55, 0, -0.45),scale = 0.2)
self.greyImage2.setTransparency(TransparencyAttrib.MAlpha)
self.greyImage3=OnscreenImage(image = self.fristimageforchartype, pos = (-0.25, 0, -0.45),scale = 0.2)
self.greyImage3.setTransparency(TransparencyAttrib.MAlpha)
self.name1 = OnscreenText(text = self.name11, pos = (-0.25,-0.85), scale = 0.08,fg=(1,0.5,0.5,1),align=TextNode.ACenter,mayChange=1)
self.name2 = OnscreenText(text = self.name22, pos = (0.55, -0.85), scale = 0.08,fg=(1,0.5,0.5,1),align=TextNode.ACenter,mayChange=1)
self.factionImage1=OnscreenImage(image = self.fristimagefactiontype, pos = (-0.25, 0, -1.0),scale = 0.08)
self.factionImage1.setTransparency(TransparencyAttrib.MAlpha)
self.factionImage1.reparentTo(self.selFrame)
self.name1.reparentTo(self.selFrame)
self.name2.reparentTo(self.selFrame)
self.factionImage2=OnscreenImage(image = self.secondimagefactiontype, pos = (0.55, 0, -1.0),scale = 0.08)
self.factionImage2.setTransparency(TransparencyAttrib.MAlpha)
self.factionImage1.reparentTo(self.selFrame)
self.factionImage2.reparentTo(self.selFrame)
#change method and variable names
self.mainRadioBtns2 = [
DirectRadioButton(text = '', variable=self.va2, value=[0], scale=0.07, pos=(-0.2,0,-1.2), command=self.setcharselection2),
DirectRadioButton(text = '', variable=self.va2, value=[1], scale=0.07, pos=(0.6,0,-1.2), command=self.setcharselection2)
]
for mainbutton2 in self.mainRadioBtns2:
mainbutton2.setOthers(self.mainRadioBtns2)
mainbutton2.reparentTo(self.selFrame)
elif(self.lengthdic>=3):
self.greyImage1=OnscreenImage(image = self.thridimageforchartype, pos = (1.35, 0, -0.45),scale = 0.2)
self.greyImage1.setTransparency(TransparencyAttrib.MAlpha)
self.greyImage2=OnscreenImage(image = self.secondimageforchartype, pos = (0.55, 0, -0.45),scale = 0.2)
self.greyImage2.setTransparency(TransparencyAttrib.MAlpha)
self.greyImage3=OnscreenImage(image = self.fristimageforchartype, pos = (-0.25, 0, -0.45),scale = 0.2)
self.greyImage3.setTransparency(TransparencyAttrib.MAlpha)
self.name1 = OnscreenText(text = self.name11, pos = (-0.25,-0.85), scale = 0.08,fg=(1,0.5,0.5,1),align=TextNode.ACenter,mayChange=1)
self.name2 = OnscreenText(text = self.name22, pos = (0.55, -0.85), scale = 0.08,fg=(1,0.5,0.5,1),align=TextNode.ACenter,mayChange=1)
self.name3 = OnscreenText(text = self.name33, pos = (1.35, -0.85), scale = 0.08,fg=(1,0.5,0.5,1),align=TextNode.ACenter,mayChange=1)
self.name1.reparentTo(self.selFrame)
self.name2.reparentTo(self.selFrame)
self.name3.reparentTo(self.selFrame)
self.factionImage1=OnscreenImage(image = self.fristimagefactiontype, pos = (-0.25, 0, -1.0),scale = 0.08)
self.factionImage1.setTransparency(TransparencyAttrib.MAlpha)
self.factionImage2=OnscreenImage(image = self.secondimagefactiontype, pos = (0.55, 0, -1.0),scale = 0.08)
self.factionImage2.setTransparency(TransparencyAttrib.MAlpha)
self.factionImage3=OnscreenImage(image = self.thridimagefactiontype, pos = (1.35, 0, -1.0),scale = 0.08)
self.factionImage3.setTransparency(TransparencyAttrib.MAlpha)
self.factionImage1.reparentTo(self.selFrame)
self.factionImage2.reparentTo(self.selFrame)
self.factionImage3.reparentTo(self.selFrame)
#change method and variable names
self.mainRadioBtns3 = [
DirectRadioButton(text = '', variable=self.va3, value=[2], scale=0.07, pos=(-0.2,0,-1.2), command=self.setcharselection3),
DirectRadioButton(text = '', variable=self.va3, value=[1], scale=0.07, pos=(0.6,0,-1.2), command=self.setcharselection3),
DirectRadioButton(text = '', variable=self.va3, value=[0], scale=0.07, pos=(1.4,0,-1.2), command=self.setcharselection3)
]
for mainbutton3 in self.mainRadioBtns3:
mainbutton3.setOthers(self.mainRadioBtns3)
mainbutton3.reparentTo(self.selFrame)
else:
self.greyImage1=OnscreenImage(image = Constants.IMG_GREY, pos = (1.35, 0, -0.45),scale = 0.2)
self.greyImage1.setTransparency(TransparencyAttrib.MAlpha)
self.greyImage2=OnscreenImage(image = Constants.IMG_GREY, pos = (0.55, 0, -0.45),scale = 0.2)
self.greyImage2.setTransparency(TransparencyAttrib.MAlpha)
self.greyImage3=OnscreenImage(image = Constants.IMG_GREY, pos = (-0.25, 0, -0.45),scale = 0.2)
self.greyImage3.setTransparency(TransparencyAttrib.MAlpha)
self.submitBtn = DirectButton(text = ("PLAY", "PLAY", "PLAY", "PLAY"), scale=.1, command=self.clickedSubmit, pos=(0.1, 0.0, -1.45))
if(self.lengthdic >= 3):
print "u have maximum characters"
#self.createbtn = DirectButton(text = ("Create", "Create", "Create", "Create"), scale=.1, command=self.clickedCreate, pos=(0.4, 0.0, -1.45),state=DGG.DISABLED)
else:
self.createbtn = DirectButton(text = ("CREATE", "CREATE", "CREATE", "CREATE"), scale=.1, command=self.clickedCreate, pos=(0.5, 0.0, -1.45))
self.createbtn.reparentTo(self.selFrame)
self.cancelBtn = DirectButton(text = ("CANCEL", "CANCEL", "CANCEL", "CANCEL"), scale=.1, command=self.clickedCancel, pos=(0.97, 0.0, -1.45))
self.submitBtn.reparentTo(self.selFrame)
self.cancelBtn.reparentTo(self.selFrame)
self.greyImage1.reparentTo(self.selFrame)
self.greyImage2.reparentTo(self.selFrame)
self.greyImage3.reparentTo(self.selFrame)
def destroySelectionWindow(self):
#self.frame.destroy()
#self.greyImage1.destroy()
#self.greyImage2.destroy()
#self.greyImage3.destroy()
#self.name1.destroy()
#self.name2.destroy()
#self.name3.destroy()
#self.submitBtn.destroy()
#self.cancelBtn.destroy()
#self.createbtn.destroy()
self.selFrame.hide()
def clickedCancel(self):
print "You pressed Cancel"
self.destroySelectionWindow()
#self.destroyCreateCharWindow()
self.registerFrame.show()
self.clearPassword()
def setcharselection1(self):
self.finalchar = self.dicts1[0]
self.finalname = self.dicts1[1]
self.finaltype = self.dicts1[2]
self.finalcid = self.dicts1[3]
print ""
def setcharselection2(self):
if self.va2[0]:
self.finalchar = self.dicts2[0]
self.finalname = self.dicts2[1]
self.finaltype = self.dicts2[2]
self.finalcid = self.dicts2[3]
else:
self.finalchar = self.dicts1[0]
self.finalname = self.dicts1[1]
self.finaltype = self.dicts1[2]
self.finalcid = self.dicts1[3]
print ""
def setcharselection3(self):
if self.va3==[2]:
self.finalchar = self.dicts1[0]
self.finalname = self.dicts1[1]
self.finaltype = self.dicts1[2]
self.finalcid = self.dicts1[3]
elif self.va3==[1]:
self.finalchar = self.dicts2[0]
self.finalname = self.dicts2[1]
self.finaltype = self.dicts2[2]
self.finalcid = self.dicts2[3]
else:
self.finalchar = self.dicts3[0]
self.finalname = self.dicts3[1]
self.finaltype = self.dicts3[2]
self.finalcid = self.dicts3[3]
print ""
def clearselectCharacterTextbox(self):
self.selectCharacterTextbox.enterText('')
def getselectCharacterTextbox(self):
self.selectCharacterTextbox = self.selectCharacterTextbox.get()
def setselectCharacterTextbox(self, textEntered):
print "name Of Char: ",textEntered
self.selectCharacterTextbox = textEntered
def clickedSubmit(self):
print "you pressed play button and the game will start with cid: ", self.finalcid, "; character type : ",self.finalchar,"; character name :",self.finalname,"; and Faction :",self.finaltype
#game starts from its base faction you have selected
self.tempType = 0
self.tempFact = 0
if self.finalname == "sword":
self.tempType = 1
if self.finaltype == "blue":
self.tempFact = 1
if self.startConnection():
self.cManager.sendRequest(Constants.CMSG_SELECT_CHARACTER, (self.mainUsername, self.finalname, self.finalcid, self.tempType, self.tempFact));
else:
self.cManager = ConnectionManager()
self.startConnection()
self.cManager.sendRequest(Constants.CMSG_SELECT_CHARACTER, (self.mainUsername, self.finalname, self.finalcid, self.tempType, self.tempFact));
def clickedCreate(self):
print "you pressed create button"
self.destroySelectionWindow()
self.createCreateCharWindow()
class LifebarUI(UIBase):
def __init__(self, world):
UIBase.__init__(self, world)
#self.mainChar = world.hero
self.liferoundImage = DirectFrame(
image='./LEGameAssets/Textures/health_tray.png',
pos=(1.34, 0, -1),
scale=(1.34, 1, 1),
frameColor=(1, 1, 1, 0))
self.lifebarImage = OnscreenImage(
image='./LEGameAssets/Textures/lifebar.png',
pos=(0.285, 0, -0.125),
scale=(0.215, 1, 0.026))
self.liferoundImage.setTransparency(1)
self.liferoundImage.reparentTo(base.a2dTopLeft)
self.lifebarImage.reparentTo(base.a2dTopLeft)
self.entirelife = self.world.hero.getMaxHealth()
#self.accept("a", self.update)
#self.accept("s", self.reset)
#self.update()
def update(self):
self.life = self.world.hero.getHealth()
self.lifebarupdate(self.entirelife, self.life)
#self.accept("a", self.lifebarupdate)
#self.accept("s", self.hide)
#self.accept("d", self.show)
# print "lifebar"
#pass
def lifebarupdate(self, entirelife, life):
#entirelife = 100
#self.life = self.life-10
if life > 0:
self.lifebarImage['scale'] = (float(life) / entirelife * 0.215, 1,
0.026)
self.lifebarImage['pos'] = (0.285 -
(1 - float(life) / entirelife) * 0.215,
0, -0.125)
else:
self.lifebarImage.hide()
def reset(self):
self.life = self.world.hero.getMaxHealth()
self.lifebarImage['scale'] = (0.215, 1, 0.026)
self.lifebarImage['pos'] = (0.285, 0, -0.125)
self.lifebarImage.show()
def hide(self):
self.liferoundImage.hide()
self.lifebarImage.hide()
def show(self):
self.liferoundImage.show()
self.lifebarImage.show()
#w = LifebarUI()
#run()
class GameStart(ShowBase):
#Lists for storing entities
projectileList = []
enemyList = []
pickuplist = []
#Initialize keys
keyMap = {"forward":False, "backward":False, "left":False, "right":False, "m":False}
fsm = 0
levelChanger = 0
player = 0
def __init__(self):
#Start ShowBase
ShowBase.__init__(self)
#Set up task chain for game play
base.taskMgr.setupTaskChain('GameTasks')
#Flag to see if a player has already been spawned
self.needPlayer = True
#Load in all menu images. If the don't all get set initially, it stutters on switch,
self.mainMenuImage = OnscreenImage("./resources/mainMenu1.png")
self.mainMenuImage.setImage("./resources/mainMenu2.png")
self.mainMenuImage.reparentTo(render2d)
self.gameOverImage = OnscreenImage("./resources/gameOver1.png")
self.gameOverImage.setImage("./resources/gameOver2.png")
self.gameOverImage.reparentTo(render2d)
self.gameOverImage.hide()
self.victoryImage = OnscreenImage("./resources/victory1.png")
self.victoryImage.setImage("./resources/victory2.png")
self.victoryImage.reparentTo(render2d)
self.victoryImage.hide()
#start FSM
self.fsm = TerminalZoneFSM()
#Open file to get configs
self.configFile = open("config.txt")
self.configList = self.configFile.readlines()
self.configFile.close()
#Get and set resolution
properties = WindowProperties()
self.xRes = self.configList[4].split("=")[1].translate(None,"\n")
self.yRes = self.configList[5].split("=")[1].translate(None,"\n")
properties.setSize(int(self.xRes), int(self.yRes))
base.win.requestProperties(properties)
#Determine prepare to cry mode
if self.configList[7].split("=")[1].translate(None,"\n") == "True":
self.damageMod = 2
else:
self.damageMod = 1
#Starts main menu
self.fsm.request('MainMenu', 1)
def startNewGame(self, load):
#Hide menu background on start of game.
self.mainMenuImage.hide()
#Get window properties, hide the cursor, set properties
properties = WindowProperties()
properties.setCursorHidden(True)
base.win.requestProperties(properties)
#Disable default mouse controls
self.disableMouse()
#Create new collision system
base.cTrav = CollisionTraverser()
base.pusher = CollisionHandlerPusher()
#Init player here
#If we don't already have a player
if self.needPlayer:
self.player = Player()
self.needPlayer = False
#Display HUD and set default stats
self.player.show()
self.player.resetEnergy()
#Load first environment
self.environ = self.loader.loadModel("./resources/theSouthBridge")
self.environ.reparentTo(self.render)
self.environ.setScale(7, 7, 3)
#Load skybox
self.skybox = loader.loadModel("resources/skyBox")
self.skyboxPath = NodePath(self.skybox)
self.skyboxPath.setCompass()
self.skybox.setBin('background',1)
self.skybox.setDepthWrite(False)
self.skybox.setLightOff()
self.skybox.reparentTo(camera)
#Global current player spawn coordinates
self.xPos = 0
self.yPos = 0
self.zPos = 3
#Create level changer
self.levelChanger = LevelChanger()
#Check to see if load game was pressed
if load:
self.levelChanger.goToBoss()
#Create spawner open on current level
self.spawner = Spawner(self.environ, "theRoot")
else:
#Create spawner open on current level
self.spawner = Spawner(self.environ, "theSouthBridge")
#Populate level with enemies
self.spawner.spawn()
#Add tasks
#base.taskMgr.add(self.spawner.checkSpawn, "Spawn Enemies", taskChain='GameTasks')
base.taskMgr.add(self.projCleanTask, "Projectile Clean Up", taskChain='GameTasks')
base.taskMgr.add(self.enemyCleanUp, "enemyCleanup", taskChain='GameTasks')
base.taskMgr.add(self.levelChanger.checkLevel, "checkLevel", taskChain='GameTasks')
base.taskMgr.add(self.pickupClean, "Pickup celeanup", taskChain='GameTasks')
#Get movement controls from config file
self.forward = self.configList[0].split("=")[1].translate(None,"\n")
self.backward = self.configList[1].split("=")[1].translate(None,"\n")
self.left = self.configList[2].split("=")[1].translate(None,"\n")
self.right = self.configList[3].split("=")[1].translate(None,"\n")
#Controls
self.accept("escape", sys.exit, [0])
self.accept("enter", self.startPause)
#Set Controls
self.accept(self.forward, self.setKey, ["forward", True])
self.accept(self.backward, self.setKey, ["backward", True])
self.accept(self.left, self.setKey, ["left", True])
self.accept(self.right, self.setKey, ["right", True])
self.accept(self.forward+"-up", self.setKey, ["forward", False])
self.accept(self.backward+"-up", self.setKey, ["backward", False])
self.accept(self.left+"-up", self.setKey, ["left", False])
self.accept(self.right+"-up", self.setKey, ["right", False])
# Changes the states of the keys pressed
def setKey(self, key, value):
self.keyMap[key] = value
#Spawn and append pickups to the list
def spawnPickup(self, id, node):
n = Pickup(id, node)
self.pickuplist.append(n)
#Cleans projectiles after impact and specified duration
def projCleanTask(self, task):
#using this task to find all the projectiles in the projList
#that have reached the end of their lifespan
#use the built in destroy to remove them
for i in self.projectileList:
if i.flag:
i.projectileNode.removeNode()
self.projectileList.remove(i)
return task.cont
#Clears pickups from the environment after collection
def pickupClean(self, task):
for i in self.pickuplist:
if i.deletePickup:
i.destroy()
self.pickuplist.remove(i)
return task.cont
#Clears enemies from the environment after being killed or upon player death
def enemyCleanUp(self, task):
self.levelChanger.checkLevel(task)
#Remove flagged enemies
for i in self.enemyList:
if i.delFlag:
#i.enemyNode.removeNode()
i.destroy()
self.enemyList.remove(i)
#self.spawner.spawnableCount-=1
return task.cont
#Requests pause from the fsm
def startPause(self):
self.fsm.request('PauseMenu')
#Handles the delay between menu image swaps
def menusTasks(self, s, task):
if task.time > .75:
if s == "mainmenu1":
base.fsm.request('MainMenu', 2)
elif s == "mainmenu2":
base.fsm.request('MainMenu', 1)
elif s == "gameover1":
base.fsm.request('GameOver', 2)
elif s == "gameover2":
base.fsm.request('GameOver', 1)
elif s == "winmenu1":
base.fsm.request('WinMenu', 2)
elif s == "winmenu2":
base.fsm.request('WinMenu', 1)
return task.cont
class KlobWorld(ShowBase):
def __init__(self):
ShowBase.__init__(self)
## wp = WindowProperties(base.win.getProperties())
## wp.setSize(1280,720)
## base.win.requestProperties(wp)
base.setBackgroundColor(255,250,250)
self.listAudio3d = []
self.allSounds()
self.energyTime = 0
self.collHandQue = CollisionHandlerQueue()
self.collHandQueEne = CollisionHandlerQueue()
self.SPEED = .5
self.speedv = 4
base.cTrav = CollisionTraverser()
self.bossLvl = False
self.bossDead = False
self.isMoving = False
self.pause = True
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
self.currentLevel = "start"
self.keyMap = {"left":0, "right":0, "forward":0, "backward":0,
"cam-left":0, "cam-right":0, "cam-up":0, "cam-down":0,
"fire-down":0, "p":0}
###Disable the default camera controls###
base.disableMouse()
self.pusher = CollisionHandlerPusher()
base.cTrav.setRespectPrevTransform(True)
#Uncomment to show collisions with environment
#base.cTrav.showCollisions(render)
self.setAcceptKeys()
self.MainMenu()
## List to keep track of all actors added in each level
## to make it easier to cleanup level when destroyed
self.crAct = []
self.extraElements = []
self.laserAmo = []
self.beamC = []
self.laserAmoCount = 0
self.enemyTimer = 0
self.gunAmmoCount = 0
self.loaded = []
self.bulletC = []
def allSounds(self):
self.audio = Audio3DManager(self.sfxManagerList[0])
self.audio.attachListener(base.camera)
self.heartBeat = base.loadMusic("sounds/heartbeat.wav")
self.cheer = base.loadMusic("sounds/cheer.wav")
self.intro = base.loadMusic("sounds/Mario.wav")
self.bulletSound = base.loadMusic("sounds/gun_shot.wav")
self.laserSound = base.loadMusic("sounds/gun_shot.wav")
self.deadSound = base.loadMusic("sounds/pacman_death.wav")
self.sound = self.audio.loadSfx("sounds/forest.wav")
self.gust = base.loadMusic("sounds/gust.wav")
self.siren = base.loadMusic("sounds/siren_2.wav")
self.waterfallSound = self.audio.loadSfx("sounds/waterfall.wav")
self.etSound = base.loadMusic("sounds/et-sound.wav")
self.walking = base.loadMusic("sounds/running.wav")
self.mainMenuMusic = base.loadMusic("sounds/intro.wav")
self.rainforestMusic = self.loader.loadSfx("sounds/rainforest.wav")
self.egyptMusic = self.loader.loadSfx("sounds/egypt.wav")
self.asiaMusic = self.loader.loadSfx("sounds/asia.wav")
self.newyorkMusic = self.loader.loadSfx("sounds/newyork.wav")
self.mainMenuMusic.setLoop(True)
self.rainforestMusic.setLoop(True)
self.egyptMusic.setLoop(True)
self.asiaMusic.setLoop(True)
self.newyorkMusic.setLoop(True)
self.gust.setLoop(True)
self.sound.setLoop(True)
self.siren.setLoop(True)
self.walking.setVolume(5)
self.heartBeat.setVolume(5)
self.deadSound.setVolume(.5)
self.laserSound.setVolume(.2)
self.bulletSound.setVolume(.2)
self.sound.setVolume(2)
self.rainforestMusic.setVolume(.6)
self.egyptMusic.setVolume(2)
self.siren.setVolume(.3)
def stopAllSounds(self):
self.audio.detachSound(self.waterfallSound)
self.audio.detachSound(self.sound)
self.audio.detachSound(self.rainforestMusic)
self.audio.detachSound(self.egyptMusic)
self.audio.detachSound(self.newyorkMusic)
self.intro.stop()
self.bulletSound.stop()
self.laserSound.stop()
self.deadSound.stop()
self.sound.stop()
self.gust.stop()
self.siren.stop()
self.waterfallSound.stop()
self.etSound.stop()
self.walking.stop()
self.mainMenuMusic.stop()
self.rainforestMusic.stop()
self.egyptMusic.stop()
self.asiaMusic.stop()
self.newyorkMusic.stop()
def MainMenuLevels(self):
if(self.currentLevel != "start"):
self.destroyLevel()
self.stopAllSounds()
self.level1Btn = DirectButton(
scale = (0.27,0.1,0.1),
command = self.loadRainforestLevel,
pos = Vec3(0, 0, 0.4),
image = 'GUI/southamericabutton.png',
relief = None)
self.level2Btn = DirectButton(
scale = (0.27,0.1,0.1),
command = self.loadAfricaLevel,
pos = Vec3(0, 0, 0.15),
image = 'GUI/africabutton.png',
relief = None)
self.level3Btn = DirectButton(
scale = (0.27,0.1,0.1),
command = self.loadAsiaLevel,
pos = Vec3(0, 0, -0.1),
image = 'GUI/asiabutton.png',
relief = None)
self.level4Btn = DirectButton(
scale = (0.27,0.1,0.1),
command = self.loadNewYorkLevel,
pos = Vec3(0, 0, -0.35),
image = 'GUI/americabutton.png',
relief = None)
self.level2Btn.setTransparency(TransparencyAttrib.MAlpha)
self.level3Btn.setTransparency(TransparencyAttrib.MAlpha)
self.level4Btn.setTransparency(TransparencyAttrib.MAlpha)
self.level1Btn.setTransparency(TransparencyAttrib.MAlpha)
def destroyMainMenuLevels(self):
self.level1Btn.destroy()
self.level2Btn.destroy()
self.level3Btn.destroy()
self.level4Btn.destroy()
self.mainMenuBtn = DirectButton(
text="Main Menu",
scale = (0.1,0.1,0.1),
command = self.MainMenuLevels,
pos = Vec3(0.8, 0, -0.9))
def MainMenu(self):
if(self.currentLevel == "help"):
self.destroyHelpMenu()
elif(self.currentLevel != "start"):
self.destroyLevel()
self.mainMenuBtn.destroy()
self.stopAllSounds()
self.currentLevel="start"
self.mainMenuImage = OnscreenImage("GUI/mainmenu.png",pos = Vec3(0, 0.0,-0.8), scale=(1.8, 0, 1.8))
self.mainMenuImage.reparentTo(aspect2d)
self.mainMenuImage.setTransparency(1)
self.mainMenuMusic.play()
mapStart = loader.loadModel('GUI/button_maps.egg')
self.startBtn = DirectButton(geom =
(mapStart.find('**/start_but'),
mapStart.find('**/start_but_click'),
mapStart.find('**/start_but_roll'),
mapStart.find('**/start_but_disabled')),
relief = None,
command = self.introScreen,
scale = (0.7,0.7,0.7),
pos = Vec3(0.6, 0, -0.35))
self.startBtn.setTransparency(TransparencyAttrib.MAlpha)
mapHelp = loader.loadModel('GUI/helpbutton_maps.egg')
self.helpBtn = DirectButton(geom =
(mapHelp.find('**/help_but'),
mapHelp.find('**/help_but_click'),
mapHelp.find('**/help_but_roll'),
mapHelp.find('**/help_but_disabled')),
relief = None,
command = self.HelpMenu,
scale = (0.8,0.65,0.65),
pos = Vec3(0.6, 0,-0.65))
self.helpBtn.setTransparency(TransparencyAttrib.MAlpha)
def destroyMainMenu(self):
self.startBtn.destroy()
self.helpBtn.destroy()
self.mainMenuImage.destroy()
self.stopAllSounds()
def HelpMenu(self):
self.destroyMainMenu()
self.currentLevel="help"
self.helpMenuImage = OnscreenImage("GUI/helpmenu.png",pos = Vec3(0, 0.0,-0.8), scale=(1.8, 0, 1.8))
self.helpMenuImage.reparentTo(aspect2d)
self.helpMenuImage.setTransparency(1)
mapHelp = loader.loadModel('GUI/backbutton_maps.egg')
self.backBtn = DirectButton(geom =
(mapHelp.find('**/backBtn'),
mapHelp.find('**/backBtn_click'),
mapHelp.find('**/backBtn_roll'),
mapHelp.find('**/backBtn_disabled')),
relief = None,
command = self.MainMenu,
scale = (0.7,0.7,0.7),
pos = Vec3(-1.4, 0, 0.8))
self.backBtn.setTransparency(TransparencyAttrib.MAlpha)
###......
#code missing.
### ....
##Records the state of the arrow keys###
def setKey(self, key, value):
if(self.pause is False):
self.keyMap[key] = value
if(self.keyMap["fire-down"] != 0 ):
if( self.energy['value'] != 0 ):
if(self.bossDead is False):
self.beamC.append( self.loadLaser() )
self.laserAmo.append( self.laser() )
if(self.laserAmo):
self.laserAmo[self.laserAmoCount].start()
self.energy['value'] -= 3
self.laserAmoCount = self.laserAmoCount + 1
def loadEnviron(self, filename, scale):
self.environ = self.loader.loadModel(filename)
self.environ.setScale(scale)
self.environ.reparentTo(self.render)
self.environ.setPos(0, 0, 0)
self.environ.setTag('wall','1')
self.environ.setCollideMask(BitMask32(0x01))
alight = AmbientLight('alight')
alight.setColor(VBase4(0.8, 0.8, 0.8, 1))
alnp = render.attachNewNode(alight)
render.setLight(alnp)
def loadAlien(self, point):
###Load alien actor###
self.alien = Actor("models/alien/slugrocket-model",
{"walk":"models/alien/slugrocket-anim"})
self.alien.reparentTo(render)
self.alien.setScale(3)
self.alien.setPos(point)
self.alien.setPlayRate(1.2, "walk")
self.alien.setBlend(frameBlend = True)
self.dlight = DirectionalLight('my dlight')
self.dlnp = render.attachNewNode(self.dlight)
self.dlnp.reparentTo(base.camera)
self.dlnp.lookAt(self.alien)
self.dlight.setColor(VBase4(0.8, 0.8, 0.5, 1))
render.setLight(self.dlnp)
base.camera.setPos(0,-10,2)
base.camera.reparentTo(self.alien)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,1000)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(2))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
base.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
csAlien = CollisionSphere(0,0,0.6,0.6)
cnodeAlienPath = self.alien.attachNewNode(CollisionNode('csAlien'))
cnodeAlienPath.node().addSolid(csAlien)
self.pusher.addCollider(cnodeAlienPath, self.alien)
base.cTrav.addCollider(cnodeAlienPath, self.pusher)
### Uncomment the following comment to show
### the Collision Sphere on the alien
## cnodeAlienPath.show()
self.health = DirectWaitBar(scale = 0.5,
range = 100,
value = 100,
barColor = (0,1,0,1),
pos = Vec3(0.75, 0, 0.9))
self.energy = DirectWaitBar(scale = 0.5,
range = 100,
value = 100,
barColor = (1,1,0,1),
pos = Vec3(-0.75, 0, 0.9))
self.energy.reparentTo(aspect2d)
self.health.reparentTo(aspect2d)
self.hud = OnscreenImage("GUI/hud.png",scale = Vec3(1.43, 1.0, 1.03),pos = Vec3(0, 0.0,0.045))
self.hud.reparentTo(aspect2d)
self.hud.setTransparency(1)
self.extraElements.append(self.energy)
self.extraElements.append(self.health)
self.extraElements.append(self.hud)
def alienDie(self, currLvl):
self.alien.stop()
self.pause=True
temp = NodePath(PandaNode("temp"))
base.camera.reparentTo(self.floater)
base.camera.setZ(base.camera.getZ()+1)
base.camera.setY(base.camera.getY()-25)
self.deadSound.play()
fall = LerpHprInterval(nodePath=self.alien, duration=1.5, hpr=(self.alien.getH(),self.alien.getP(), self.alien.getR()-80))
fall.start()
taskMgr.remove("moveTask")
taskMgr.remove("laterFc")
transition = Transitions(loader)
transition.setFadeColor(0, 0, 0)
self.dieImage = OnscreenImage("GUI/died.png",scale = Vec3(0.7, 0, 0.2),pos = Vec3(0, 0,-0.5))
self.dieImage.reparentTo(aspect2d)
self.dieImage.setTransparency(1)
if(self.currentLevel == "rainforest"):
Sequence(Wait(2.0),Func(transition.fadeOut),Wait(2.0),Func(self.destroyLevel),Func(self.loadRainforestLevel),Func(self.dieImage.destroy),Func(transition.fadeIn)).start()
elif(self.currentLevel == "africa"):
Sequence(Wait(2.0),Func(transition.fadeOut),Wait(2.0),Func(self.destroyLevel),Func(self.loadAfricaLevel),Func(self.dieImage.destroy),Func(transition.fadeIn)).start()
elif(self.currentLevel == "asia"):
Sequence(Wait(2.0),Func(transition.fadeOut),Wait(2.0),Func(self.destroyLevel),Func(self.loadAsiaLevel),Func(self.dieImage.destroy),Func(transition.fadeIn)).start()
elif(self.currentLevel == "newyork"):
Sequence(Wait(2.0),Func(transition.fadeOut),Wait(2.0),Func(self.destroyLevel),Func(self.loadNewYorkLevel),Func(self.dieImage.destroy),Func(transition.fadeIn)).start()
def collide(self, collEntry):
collEntry.getFromNodePath().getParent().removeNode()
def setAcceptKeys(self):
###Accept the control keys for movement and rotation###
self.accept("escape", sys.exit)
self.accept("p", self.setKey, ["p",1])
self.accept("arrow_up", self.setKey, ["forward",1])
self.accept("arrow_up-up", self.setKey, ["forward",0])
self.accept("arrow_down", self.setKey, ["backward", 1])
self.accept("arrow_down-up", self.setKey, ["backward", 0])
self.accept("arrow_left", self.setKey, ["left",1])
self.accept("arrow_left-up", self.setKey, ["left",0])
self.accept("arrow_right", self.setKey, ["right",1])
self.accept("arrow_right-up", self.setKey, ["right",0])
self.accept("a", self.setKey, ["cam-left",1])
self.accept("a-up", self.setKey, ["cam-left",0])
self.accept("s", self.setKey, ["cam-right",1])
self.accept("s-up", self.setKey, ["cam-right",0])
self.accept("z", self.setKey, ["cam-up",1])
self.accept("z-up", self.setKey, ["cam-up",0])
self.accept("x", self.setKey, ["cam-down", 1])
self.accept("x-up", self.setKey, ["cam-down", 0])
# Accept f to fire
self.accept("f", self.setKey, ["fire-down",1])
self.accept("f-up", self.setKey, ["fire-down",0])
self.cTrav.traverse(render)
#gun / laser code ommitted
def getDistance(self, actor):
self.vecAlien = Vec3(self.alien.getPos())
self.vecObj = Vec3(actor.getPos())
disVec = self.vecObj - self.vecAlien
return disVec.length()
def myFunction(self,task):
self.walking.play()
if(self.pause is False):
for r in range(0, len(self.crAct)):
self.crAct[r].setTarget(self.alien)
self.bulletC.append( self.createBullet(self.crAct[r]) )
self.loaded.append( self.loadBullet( self.crAct[r]) )
self.loaded[self.gunAmmoCount].start()
self.gunAmmoCount += 1
self.bulletSound.play()
return task.again
def bossLvlTask(self, dec, task):
self.crAct[0].setAiPursue(self.alien)
if(self.pause is False):
self.deleteProjectiles()
self.charcMoveKeys()
startpos = self.alien.getPos()
self.floater.setPos(self.alien.getPos())
self.floater.setZ(self.alien.getZ() + 2.0)
base.camera.lookAt(self.floater)
self.collHandQueEne.sortEntries()
if(self.collHandQueEne.getNumEntries() > 0):
entryb = self.collHandQueEne.getEntry(0)
if( entryb.getIntoNodePath().getName() == "csAlien"):
self.health['value'] -=5
if(self.bulletC):
self.bulletC[self.gunAmmoCount-1].remove()
self.bulletC.pop(self.gunAmmoCount-1)
self.loaded.pop(self.gunAmmoCount-1)
self.gunAmmoCount -= 1
if( self.health['value'] < 20 ):
self.heartBeat.play()
if(self.health['value'] == 0):
self.alienDie(self.currentLevel)
else:
self.bulletC[self.gunAmmoCount-1].remove()
self.bulletC.pop(self.gunAmmoCount-1)
self.loaded.pop(self.gunAmmoCount-1)
self.gunAmmoCount -= 1
self.collHandQue.sortEntries()
if( self.collHandQue.getNumEntries() > 0 ):
entry = self.collHandQue.getEntry(0)
if( entry.getIntoNodePath().getName() == self.crAct[0].getCNP()):
self.crAct[0].runAround(self.alien)
self.crAct[0].setHitCount(1)
self.crAct[0].decreaseHealth(dec)
if( self.beamC):
self.beamC[self.laserAmoCount-1].remove()
self.beamC.pop(self.laserAmoCount-1)
if(self.laserAmo):
self.laserAmo.pop(self.laserAmoCount-1)
self.laserAmoCount -= 1
if( self.crAct[0].getHealth()%4 == 0):
self.crAct[0].jumpAway(self.alien)
if( self.crAct[0].getHealth() == 0 ):
## print x.getDeaths()
## if( x.canRespawn() ):
## x.setDeaths(1)
## x.resetHitCount(0)
## x.setX(random.randint(0, 50))
## x.setY(self.alien.getY()+15)
## else:
self.crAct[0].cleanup()
self.crAct[0].remove()
self.crAct.pop(0)
self.cutScene()
if( self.crAct ):
self.crAct[0].AIworld.update()
if( self.keyMap["p"]!= 0):
self.cutScene()
return task.cont
def move(self, task):
##ommmitted
return task.cont
def deleteProjectiles(self):
## if(self.pause is False):
if(self.laserAmo):
for i, x in enumerate(self.laserAmo):
if( not x.isPlaying() ):
self.beamC[i].remove()
self.beamC.pop(i)
self.laserAmo.pop(i)
self.laserAmoCount = self.laserAmoCount -1
if(self.loaded):
for i, x in enumerate(self.loaded):
if(not x.isPlaying()):
#self.crAct[i].setTarget(self.alien)
self.bulletC[i].remove()
self.bulletC.pop(i)
self.loaded.pop(i)
self.gunAmmoCount = self.gunAmmoCount -1
self.energyTime = self.energyTime + globalClock.getDt()
if(self.energyTime > 2 ):
if(self.energy['value'] != 100):
self.energy['value'] +=5
self.energyTime = 0
def charcMoveKeys(self):
if (self.keyMap["cam-left"]!=0):
base.camera.setX(base.camera, -20 * globalClock.getDt())
if (self.keyMap["cam-right"]!=0):
base.camera.setX(base.camera, +20 * globalClock.getDt())
if (self.keyMap["cam-up"]!=0):
base.camera.setY(base.camera, -20 * globalClock.getDt())
if (self.keyMap["cam-down"]!=0):
base.camera.setY(base.camera, +20 * globalClock.getDt())
if (self.keyMap["forward"]!=0):
self.alien.setY(self.alien, 10 * globalClock.getDt())
if (self.keyMap["backward"]!=0):
self.alien.setY(self.alien, -10 * globalClock.getDt())
if (self.keyMap["left"]!=0):
self.alien.setH(self.alien.getH() + 40 * globalClock.getDt())
if (self.keyMap["right"]!=0):
self.alien.setH(self.alien.getH() - 40 * globalClock.getDt())
if (self.keyMap["forward"]!=0) or (self.keyMap["left"]!=0) or (self.keyMap["right"]!=0) or (self.keyMap["backward"] != 0):
if self.isMoving is False:
self.alien.loop("walk")
self.isMoving = True
else:
if self.isMoving:
self.alien.stop()
self.alien.pose("walk",5)
self.isMoving = False
def loadingScreen(self):
self.intro.play()
transition = Transitions(loader)
transition.setFadeColor(0, 0, 0)
text = TextNode('node name')
dummy = NodePath(PandaNode("dummy"))
black = OnscreenImage(image="GUI/black.png",pos=(0,0,0), scale=100)
black.reparentTo(dummy)
textNodePath = aspect2d.attachNewNode(text)
textNodePath.reparentTo(aspect2d, 2)
textNodePath.setScale(0.07)
text.setTextColor(1, 1, 1, 1)
if(self.currentLevel=="newyork"):
Sequence(Func(transition.fadeOut),Func(black.reparentTo, aspect2d),Func(transition.fadeIn),Func(textNodePath.reparentTo,aspect2d, 10),Func(text.setText, "loading"),Wait(1.0),Func(text.setText, "loading."),
Wait(1.0),Func(text.setText, "loading.."), Wait(1.0), Func(text.setText, "loading..."), Func(self.loadNextLevel),Wait(3.0),Func(transition.fadeIn),Func(textNodePath.remove), Func(black.destroy)).start()
elif(self.currentLevel=="asia"):
Sequence(Func(transition.fadeOut),Func(black.reparentTo, aspect2d),Func(transition.fadeIn),Func(textNodePath.reparentTo,aspect2d, 10),Func(text.setText, "loading"),Wait(1.0),Func(text.setText, "loading."),
Wait(1.0),Func(text.setText, "loading.."), Wait(1.0), Func(text.setText, "loading..."), Func(self.loadNextLevel),Wait(3.0),Func(transition.fadeIn),Func(textNodePath.remove), Func(black.destroy)).start()
else:
Sequence(Func(transition.fadeOut),Func(black.reparentTo, aspect2d),Func(transition.fadeIn),Func(textNodePath.reparentTo,aspect2d, 10),Func(text.setText, "loading"),Wait(0.5),Func(text.setText, "loading."),
Wait(0.5),Func(text.setText, "loading.."), Wait(0.5), Func(text.setText, "loading..."), Func(self.loadNextLevel),Wait(1.5),Func(transition.fadeIn),Func(textNodePath.remove), Func(black.destroy)).start()
def cutScene(self):
self.destroyLevel()
self.stopAllSounds()
self.cut = OnscreenImage("GUI/bossKilled.png",scale = Vec3(1.6, 0, 1.0),pos = Vec3(0, 0,0))
self.cut.reparentTo(aspect2d)
self.cut.setTransparency(1)
transition = Transitions(loader)
transition.setFadeColor(0, 0, 0)
self.cheer.play()
if(self.currentLevel=="rainforest"):
Sequence(Wait(2.0),Func(transition.fadeOut),Wait(1.0),Func(transition.fadeIn),Func(self.cut.setImage,"GUI/map_11.png"),
Wait(1.5),Func(self.cut.setImage, "GUI/map_12.png"),Wait(0.5),Func(self.cut.setImage,"GUI/map_13.png"),
Wait(0.5),Func(self.cut.setImage,"GUI/map_14.png"),Wait(0.5),Func(self.cut.setImage,"GUI/map_15.png"),
Wait(0.5),Func(self.cut.setImage,"GUI/map_16.png"),Wait(3.5),Func(self.cut.destroy), Func(transition.fadeOut), Func(self.loadingScreen), Wait(1.0),Func(transition.fadeIn)).start()
elif(self.currentLevel=="africa"):
Sequence(Wait(2.0),Func(transition.fadeOut),Wait(1.0),Func(transition.fadeIn),Func(self.cut.setImage,"GUI/map_21.png"),
Wait(1.5),Func(self.cut.setImage, "GUI/map_22.png"),Wait(0.5),Func(self.cut.setImage,"GUI/map_23.png"),
Wait(0.5),Func(self.cut.setImage,"GUI/map_24.png"),Wait(0.5),Func(self.cut.setImage,"GUI/map_25.png"),
Wait(0.5),Func(self.cut.setImage,"GUI/map_26.png"), Wait(3.5),Func(self.cut.destroy), Func(transition.fadeOut),Func(self.loadingScreen), Wait(1.0),Func(transition.fadeIn)).start()
elif(self.currentLevel=="asia"):
Sequence(Wait(2.0),Func(transition.fadeOut),Wait(1.0),Func(transition.fadeIn),Func(self.cut.setImage,"GUI/map_31.png"),
Wait(1.5),Func(self.cut.setImage, "GUI/map_32.png"),Wait(0.5),Func(self.cut.setImage,"GUI/map_33.png"),
Wait(0.5),Func(self.cut.setImage,"GUI/map_34.png"),Wait(0.5),Func(self.cut.setImage,"GUI/map_35.png"),
Wait(0.5),Func(self.cut.setImage,"GUI/map_36.png"),Wait(3.5),Func(self.cut.destroy), Func(transition.fadeOut),Func(self.loadingScreen), Wait(1.0),Func(transition.fadeIn)).start()
elif(self.currentLevel=="newyork"):
Sequence(Wait(2.0),Func(transition.fadeOut),Wait(1.0),Func(transition.fadeIn),Func(self.cut.setImage,"GUI/win.png"),
Wait(6.5),Func(self.cut.destroy), Func(transition.fadeOut),Func(self.loadingScreen), Wait(1.0),Func(transition.fadeIn)).start()
def loadNextLevel(self):
if(self.currentLevel=="start"):
self.loadRainforestLevel()
elif(self.currentLevel=="rainforest"):
self.loadAfricaLevel()
elif(self.currentLevel=="africa"):
self.loadAsiaLevel()
elif(self.currentLevel=="asia"):
self.loadNewYorkLevel()
else:
self.MainMenu()
def destroyLevel(self):
self.mainMenuBtn.destroy()
taskMgr.remove("moveTask")
taskMgr.remove("bossTask")
taskMgr.remove("myFunction")
self.alien.cleanup()
for enemy in self.crAct:
enemy.cleanup()
enemy.remove()
self.alien.cleanup()
self.alien.remove()
for element in self.extraElements:
element.removeNode()
for beam in self.beamC:
beam.removeNode()
self.render.clearFog
self.laserBeam2.removeNode()
self.environ.removeNode()
self.crAct[:] = []
self.extraElements[:] = []
self.laserAmo[:] =[]
self.laserAmoCount = 0
def loadBossActor(self):
self.bossLvl = True
###Load Ralph Boss actor###
difficult = 10
taskMgr.remove("moveTask")
taskMgr.remove("myFunction")
self.health['value'] = 100
self.energy['value'] = 100
if(self.bossDead is False):
self.bossImage = OnscreenImage("GUI/bossLoad.png",scale = Vec3(1.6, 0, 1.0),pos = Vec3(0, 0,0))
self.bossImage.reparentTo(aspect2d)
self.bossImage.setTransparency(1)
self.ralphBoss = EnemyActor(1,difficult,True)
self.ralphBoss.enemy.setScale(2.0)
self.crAct.append(self.ralphBoss)
Sequence(Wait(3.0), Func(self.bossImage.destroy), Func(self.crAct[0].showHealthBar)).start()
self.extraElements.append(self.crAct[0].bossHud)
self.extraElements.append(self.crAct[0].health)
self.crAct[0].setAiPursue(self.alien)
self.pusher.addCollider(self.crAct[0].getFromObj(), self.crAct[0].enemy)
base.cTrav.addCollider(self.crAct[0].getFromObj(), self.pusher)
gunTex = loader.loadTexture('models/gun_tex.png')
if(self.currentLevel == "rainforest"):
dec = 5
self.ralphBoss.enemy.setPos(0,90,0)
ralphTex = loader.loadTexture('models/ralph2rainforest.png')
self.ralphBoss.enemy.setTexture(ralphTex, 1)
self.ralphBoss.gunPos.setTexture(gunTex, 1)
elif(self.currentLevel == "africa"):
dec = 4
self.ralphBoss.enemy.setPos(-100,-90,0)
ralphTex = loader.loadTexture('models/ralph2egypt.png')
self.ralphBoss.enemy.setTexture(ralphTex, 1)
self.ralphBoss.gunPos.setTexture(gunTex, 1)
elif(self.currentLevel == "asia"):
dec = 3
self.ralphBoss.enemy.setPos(0,0,0)
ralphTex = loader.loadTexture('models/ralph2asia.png')
self.ralphBoss.enemy.setTexture(ralphTex, 1)
self.ralphBoss.gunPos.setTexture(gunTex, 1)
elif(self.currentLevel == "newyork"):
dec = 2
self.ralphBoss.enemy.setPos(120,10,0)
taskMgr.add(self.bossLvlTask,"bossTask", extraArgs = [dec], appendTask=True)
taskMgr.doMethodLater(1,self.myFunction,"myFunction")
def loadRainforestLevel(self):
self.keyMap = {"left":0, "right":0, "forward":0, "backward":0,
"cam-left":0, "cam-right":0, "cam-up":0, "cam-down":0,
"fire-down":0, "p":0}
self.pause = False
self.currentLevel = "rainforest"
self.destroyIntro()
difficulty = 2
self.bossLvl = False
self.bossDead = False
###Load alien###
startPos = Point3(0,0,0)
self.loadAlien(startPos)
self.rainforestMusic.play()
###Load the enemies###
ralphTex = loader.loadTexture('models/ralph2rainforest.png')
gunTex = loader.loadTexture('models/gun_tex.png')
for i in range(0,2):
enemy = EnemyActor(i, difficulty, False)
enemy.enemy.setTexture(ralphTex, 1)
enemy.gunPos.setTexture(gunTex, 1)
enemy.setX(random.randint(-50,50))
enemy.setY(random.randint(-50,50))
enemy.setZ(0)
self.crAct.append(enemy)
self.crAct[i].setAiPursue(self.alien)
self.pusher.addCollider(self.crAct[i].getFromObj(), self.crAct[i].enemy)
base.cTrav.addCollider(self.crAct[i].getFromObj(), self.pusher)
taskMgr.add(self.move,"moveTask")
taskMgr.doMethodLater(3,self.myFunction,"myFunction")
self.loadLaser2()
self.loadLaser()
###Load the environment###
self.loadEnviron("models/south_america/rainforest", 5)
self.plants = self.loader.loadModel("models/south_america/rainforest-nocollision")
self.plants.reparentTo(self.render)
self.plants.setScale(4)
self.plants.setTwoSided(True)
self.extraElements.append(self.plants)
self.myFog = Fog("FOG")
self.myFog.setColor(0.5,0.6,0.5)
self.myFog.setExpDensity(0.005)
render.setFog(self.myFog)
self.audio.attachSoundToObject(self.sound, self.environ)
self.audio.setSoundVelocityAuto(self.sound)
self.audio.setListenerVelocityAuto()
self.sound.play()
def loadAfricaLevel(self):
self.keyMap = {"left":0, "right":0, "forward":0, "backward":0,
"cam-left":0, "cam-right":0, "cam-up":0, "cam-down":0,
"fire-down":0, "p":0}
self.pause = False
self.currentLevel="africa"
difficulty = 3
self.bossLvl = False
self.bossDead = False
###Load alien###
startPos = Point3(-130,-130,0)
self.loadAlien(startPos)
self.alien.setH(-40)
###Load the enemies###
ralphTex = loader.loadTexture('models/ralph2egypt.png')
gunTex = loader.loadTexture('models/gun_tex.png')
for i in range(0,3):
enemy = EnemyActor(i, difficulty, False)
enemy.enemy.setTexture(ralphTex, 1)
enemy.gunPos.setTexture(gunTex, 1)
enemy.setX(random.randint(-170,-50))
enemy.setY(random.randint(-170,-50))
enemy.setZ(0)
self.crAct.append(enemy)
self.crAct[i].setAiPursue(self.alien)
self.pusher.addCollider(self.crAct[i].getFromObj(), self.crAct[i].enemy)
base.cTrav.addCollider(self.crAct[i].getFromObj(), self.pusher)
taskMgr.add(self.move,"moveTask")
taskMgr.doMethodLater(3,self.myFunction,"myFunction")
self.loadLaser2()
self.loadLaser()
###Load environment###
self.loadEnviron("models/africa/egypt", 7)
self.egypt_nc = self.loader.loadModel("models/africa/egypt-nocollision")
self.egypt_nc.reparentTo(self.render)
self.egypt_nc.setPos(0,0,0)
self.egypt_nc.setScale(7)
self.extraElements.append(self.egypt_nc)
self.sphinx = self.loader.loadModel("models/africa/sphinx")
self.sphinx.setPos(0,80,0)
self.sphinx.setH(180)
self.sphinx.setScale(0.12)
self.sphinx.reparentTo(self.render)
self.extraElements.append(self.sphinx)
cs = CollisionSphere(0,0,0,200)
nodePath = self.sphinx.attachNewNode(CollisionNode('nodePath'))
nodePath.node().addSolid(cs)
self.gust.play()
self.audio.attachSoundToObject(self.egyptMusic, self.environ)
self.audio.setSoundVelocityAuto(self.egyptMusic)
self.audio.setListenerVelocityAuto()
self.egyptMusic.play()
def loadAsiaLevel(self):
self.keyMap = {"left":0, "right":0, "forward":0, "backward":0,
"cam-left":0, "cam-right":0, "cam-up":0, "cam-down":0,
"fire-down":0, "p":0}
self.pause = False
self.currentLevel = "asia"
difficulty = 4
self.bossLvl = False
self.bossDead = False
###Load alien###
startPos = Point3(190,-140,0)
self.loadAlien(startPos)
###Load the enemies###
ralphTex = loader.loadTexture('models/ralph2asia.png')
gunTex = loader.loadTexture('models/gun_tex.png')
for i in range(0,4):
enemy = EnemyActor(i, difficulty, False)
enemy.enemy.setTexture(ralphTex, 1)
enemy.gunPos.setTexture(gunTex, 1)
enemy.setX(random.randint(0,100))
enemy.setY(random.randint(-150,-50))
enemy.setZ(0)
self.crAct.append(enemy)
self.crAct[i].setAiPursue(self.alien)
self.pusher.addCollider(self.crAct[i].getFromObj(), self.crAct[i].enemy)
base.cTrav.addCollider(self.crAct[i].getFromObj(), self.pusher)
taskMgr.add(self.move,"moveTask")
taskMgr.doMethodLater(3,self.myFunction,"myFunction")
self.loadLaser2()
self.loadLaser()
###Load the environment###
self.loadEnviron("models/asia/asia2", 5)
self.asia_nc = self.loader.loadModel("models/asia/asia-nocollision")
self.asia_nc.reparentTo(self.render)
self.asia_nc.setPos(0,0,0)
self.asia_nc.setScale(5)
self.extraElements.append(self.asia_nc)
self.myFog = Fog("FOG")
self.myFog.setColor(0.8,0.8,0.8)
self.myFog.setExpDensity(0.002)
render.setFog(self.myFog)
self.bonzai = self.loader.loadModel("models/asia/bonzai")
self.bonzai.reparentTo(self.render)
self.bonzai.setPos(170,20,0)
self.bonzai.setScale(0.015)
self.bonzai.setH(90)
self.extraElements.append(self.bonzai)
cs = CollisionSphere(0,0,200,200)
nodePath = self.bonzai.attachNewNode(CollisionNode('nodePath'))
nodePath.node().addSolid(cs)
self.pusher.addCollider(nodePath, self.bonzai)
self.waterfall = self.loader.loadModel("models/asia/waterFall")
self.waterfall.reparentTo(self.render)
self.waterfall.setPos(200,80,-.5)
self.waterfall.setScale(0.25)
self.waterfall.setH(180)
self.extraElements.append(self.waterfall)
cs = CollisionSphere(0,15,-5,130)
nodePath = self.waterfall.attachNewNode(CollisionNode('nodePath'))
nodePath.node().addSolid(cs)
self.pusher.addCollider(nodePath, self.waterfall)
self.waterfallSound.setLoop(True)
self.audio.attachSoundToObject(self.waterfallSound,self.waterfall)
self.audio.setSoundVelocityAuto(self.waterfallSound)
self.audio.setListenerVelocityAuto()
self.audio.setDistanceFactor(1.5)
self.waterfallSound.play()
self.tree1 = self.loader.loadModel("models/asia/bamboo")
self.tree1.reparentTo(self.render)
self.tree1.setPos(-50,-50,0)
self.tree1.setScale(0.6,0.6,0.6)
self.tree1.setBillboardAxis()
self.extraElements.append(self.tree1)
#Child bamboos scattered around
placeholder = render.attachNewNode("Bamboo-Placeholder")
placeholder.setPos(180,-40,0)
placeholder.setScale(0.8)
self.tree1.instanceTo(placeholder)
self.extraElements.append(placeholder)
placeholder = render.attachNewNode("Babmboo-Placeholder")
placeholder.setPos(-20,-120,0)
placeholder.setScale(1.0)
self.tree1.instanceTo(placeholder)
self.extraElements.append(placeholder)
placeholder = render.attachNewNode("Bamboo-Placeholder")
placeholder.setPos(-50,180,0)
placeholder.setScale(1.0)
self.tree1.instanceTo(placeholder)
self.extraElements.append(placeholder)
placeholder = render.attachNewNode("Bamboo-Placeholder")
placeholder.setPos(-60,165,0)
placeholder.setScale(0.6)
self.tree1.instanceTo(placeholder)
self.extraElements.append(placeholder)
placeholder = render.attachNewNode("Bamboo-Placeholder")
placeholder.setPos(-110,70,0)
placeholder.setScale(1.0)
self.tree1.instanceTo(placeholder)
self.extraElements.append(placeholder)
placeholder = render.attachNewNode("Bamboo-Placeholder")
placeholder.setPos(-100,-50,0)
placeholder.setScale(1.6)
self.tree1.instanceTo(placeholder)
self.extraElements.append(placeholder)
self.asiaMusic.play()
def loadNewYorkLevel(self):
self.keyMap = {"left":0, "right":0, "forward":0, "backward":0,
"cam-left":0, "cam-right":0, "cam-up":0, "cam-down":0,
"fire-down":0,"p":0}
self.pause = False
self.currentLevel = "newyork"
#self.destroyMainMenuLevels()
difficulty = 5
###Load alien###
startPos = Point3(20,10,0)
self.loadAlien(startPos)
self.alien.setH(90)
base.camera.setH(90)
self.bossLvl = False
self.bossDead = False
###Load the enemies###
for i in range(0,5):
enemy = EnemyActor(i, difficulty, False)
enemy.setX(random.randint(-100,100))
enemy.setY(random.randint(8,12))
enemy.setZ(0)
self.crAct.append(enemy)
self.crAct[i].setAiPursue(self.alien)
self.pusher.addCollider(self.crAct[i].getFromObj(), self.crAct[i].enemy)
base.cTrav.addCollider(self.crAct[i].getFromObj(), self.pusher)
taskMgr.add(self.move,"moveTask")
taskMgr.doMethodLater(2,self.myFunction, "myFunction")
self.loadLaser2()
self.loadLaser()
###Load the environment###
self.loadEnviron("models/america/newyork", 4)
self.ny_nc = self.loader.loadModel("models/america/newyork-nocollision")
self.ny_nc.reparentTo(self.render)
self.ny_nc.setScale(4)
self.extraElements.append(self.ny_nc)
self.statue = self.loader.loadModel("models/america/statue")
self.statue.reparentTo(self.render)
self.statue.setPos(270,-100,13)
self.statue.setScale(1)
self.statue.setBillboardAxis()
self.statue.setTwoSided(True)
self.extraElements.append(self.statue)
self.myFog = Fog("FOG")
self.myFog.setColor(0.3,0.3,0.3)
self.myFog.setExpDensity(0.005)
render.setFog(self.myFog)
self.siren.play()
self.newyorkMusic.play()
class Menu(DirectObject):
def __init__(self):
#self.accept("RatioChanged", self.recalcAspectRatio)
self.accept("window-event", self.recalcAspectRatio)
self.frameMain = DirectFrame(
# size of the frame
frameSize = (base.a2dLeft, base.a2dRight,
base.a2dTop, base.a2dBottom),
# position of the frame
pos = (0, 0, 0),
# tramsparent bg color
frameColor = (0, 0, 0, 0),
sortOrder = 0)
self.background = OnscreenImage("MenuBGLogo.png")
self.background.reparentTo(self.frameMain)
self.nowPlaying = DirectLabel(
scale = 0.05,
text = "Now Playing: Eraplee Noisewall Orchestra - Bermuda Fire",
pos = (base.a2dLeft + 0.025, 0.0, base.a2dBottom + 0.05),
text_align = TextNode.ALeft,
frameColor = (0, 0, 0, 0),
text_fg = (1,1,1,1)
)
self.nowPlaying.setTransparency(1)
self.nowPlaying.reparentTo(self.frameMain)
maps = loader.loadModel('button_maps.egg')
btnGeom = (maps.find('**/ButtonReady'),
maps.find('**/ButtonClick'),
maps.find('**/ButtonRollover'),
maps.find('**/ButtonDisabled'))
self.btnStart = self.createButton("Start", btnGeom, 0.25, self.btnStart_Click)
self.btnStart.reparentTo(self.frameMain)
self.btnQuit = self.createButton("Quit", btnGeom, -0.25, self.btnQuit_Click)
self.btnQuit.reparentTo(self.frameMain)
self.recalcAspectRatio(base.win)
# hide all buttons at startup
self.hide()
def show(self):
self.frameMain.show()
self.recalcAspectRatio(base.win)
def hide(self):
self.frameMain.hide()
def recalcAspectRatio(self, window):
"""get the new aspect ratio to resize the mainframe"""
screenResMultiplier = window.getXSize() / window.getYSize()
self.frameMain["frameSize"] = (
base.a2dLeft, base.a2dRight,
base.a2dTop, base.a2dBottom)
self.btnQuit["text_scale"] = (0.5*screenResMultiplier, 0.5, 0.5)
self.btnStart["text_scale"] = (0.5*screenResMultiplier, 0.5, 0.5)
def createButton(self, text, btnGeom, yPos, command):
btn = DirectButton(
scale = (0.25, 0.25, 0.25),
# some temp text
text = text,
text_scale = (0.5, 0.5, 0.5),
# set the alignment to right
text_align = TextNode.ACenter,
# put the text on the right side of the button
text_pos = (0, -0.15),
# set the text color to black
text_fg = (1,1,0,1),
text_shadow = (0.3, 0.3, 0.1, 1),
text_shadowOffset = (0.05, 0.05),
# set the buttons images
geom = btnGeom,
relief = 1,
frameColor = (0,0,0,0),
pressEffect = False,
pos = (0, 0, yPos),
command = command,
rolloverSound = None,
clickSound = None)
btn.setTransparency(1)
return btn
def btnStart_Click(self):
base.messenger.send("start")
def btnQuit_Click(self):
base.messenger.send("quit")
class PlayerHUD():
def __init__(self):
#
# Player status section
#
heartscale = (0.1, 1, 0.1)
self.heart1 = OnscreenImage(image="HeartIcon.png",
scale=heartscale,
pos=(0.2, 0, -0.15))
self.heart1.setTransparency(True)
self.heart1.reparentTo(base.a2dTopLeft)
self.heart2 = OnscreenImage(image="HeartIcon.png",
scale=heartscale,
pos=(0.45, 0, -0.15))
self.heart2.setTransparency(True)
self.heart2.reparentTo(base.a2dTopLeft)
self.heart3 = OnscreenImage(image="HeartIcon.png",
scale=heartscale,
pos=(0.7, 0, -0.15))
self.heart3.setTransparency(True)
self.heart3.reparentTo(base.a2dTopLeft)
self.keys = DirectLabel(text="x0",
frameColor=(0, 0, 0, 0),
text_fg=(1, 1, 1, 1),
text_scale=1.8,
text_pos=(1, -0.25, 0),
text_align=TextNode.ALeft,
image="Keys.png",
pos=(0.2, 0, -0.4))
self.keys.setScale(0.085)
self.keys.setTransparency(True)
self.keys.reparentTo(base.a2dTopLeft)
self.actionKey = DirectLabel(frameColor=(0, 0, 0, 0),
text_fg=(1, 1, 1, 1),
scale=0.15,
pos=(0, 0, 0.15),
text=_("Action: E/Enter"))
self.actionKey.setTransparency(True)
self.actionKey.reparentTo(base.a2dBottomCenter)
self.actionKey.hide()
def show(self):
self.keys.show()
def hide(self):
self.heart1.hide()
self.heart2.hide()
self.heart3.hide()
self.keys.hide()
self.hideActionKey()
def setHealthStatus(self, value):
"""this function will set the health image in the top righthand corner
according to the given value, where value is a integer between 0 and 100
"""
if value >= 1: self.heart1.show()
else: self.heart1.hide()
if value >= 2: self.heart2.show()
else: self.heart2.hide()
if value >= 3: self.heart3.show()
else: self.heart3.hide()
def showActionKey(self):
self.actionKey.show()
def hideActionKey(self):
self.actionKey.hide()
def updateKeyCount(self, numKeys):
self.keys["text"] = "x%d" % numKeys
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 App(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self._setup_menu()
self.disableMouse()
self.stop_loop = False
self.loading = False
base.accept(S.control_keys['close_window'], self.esc_handler)
if S.show_control_keys:
display_control_keys(S)
def _load_map_infos(self):
for fname in sorted(glob(os.path.join(S.map_dir, '*.yaml'))):
with open(fname, 'r') as f:
map_data = yaml.load(f)
title = map_data.get('title', 'unnamed').capitalize()
ident = os.path.basename(fname)
thumbnail = S.map_thumbnail(map_data.get('thumbnail', 'unknown'))
yield dict(title=title,
thumbnail=thumbnail,
ident=ident)
def _setup_menu(self):
parent = render2d.attachNewNode(PGTop('menu_node'))
parent.node().setMouseWatcher(base.mouseWatcherNode)
OnscreenImage(image=S.menu_backg, scale=(1, 1, 1)).reparentTo(parent)
def start():
if self.loading:
return
self.loading = True
parent.removeNode()
self.set_manager(self.map_infos[0]['ident'])
DirectButton(command=start,
text='Start',
borderWidth=(0, 0),
frameColor=(1, 1, 1, 1),
pos=(0, 0, -0.4),
scale=0.1).reparentTo(parent)
self._make_exit_button(parent)
self.map_infos = map_infos = deque(self._load_map_infos())
self.map_thumbnail = OnscreenImage(image=map_infos[0]['thumbnail'],
scale=0.3)
self.map_thumbnail.reparentTo(parent)
self.map_title = OnscreenText(text=map_infos[0]['title'],
pos=(0, 0.35),
fg=(1, 1, 1, 1),
scale = 0.05)
self.map_title.reparentTo(parent)
self._make_switch_button(True, parent)
self._make_switch_button(False, parent)
def _make_switch_button(self, right, parent):
def switch():
self.map_infos.rotate(-1 if right else 1)
self.map_thumbnail.setImage(self.map_infos[0]['thumbnail'])
self.map_title.setText(self.map_infos[0]['title'])
DirectButton(command=switch,
text='>' if right else '<',
borderWidth=(0, 0),
frameColor=(1, 1, 1, 1),
pos=(0.4 if right else -0.4, 0, 0),
scale=0.1).reparentTo(parent)
def _make_exit_button(self, parent):
def exit():
self.stop_loop = True
DirectButton(command=exit,
text='Exit',
borderWidth=(0, 0),
frameColor=(1, 1, 1, 1),
pos=(0, 0, -0.52),
scale=0.1).reparentTo(parent)
def set_manager(self, *args, **kwargs):
preloader = OnscreenImage(image=S.preloader, scale=(1, 1, 1))
preloader.reparentTo(render2d)
def callback(task):
self.manager = Manager(*args, **kwargs)
taskMgr.add(self.manager, 'manager')
preloader.destroy()
taskMgr.doMethodLater(0.1, callback, 'set_manager')
def finish_game(self, win):
taskMgr.remove('manager')
parent = render2d.attachNewNode(PGTop('finish_node'))
parent.node().setMouseWatcher(base.mouseWatcherNode)
backg = S.win_backg if win else S.fail_backg
OnscreenImage(image=backg, scale=(1, 1, 1)).reparentTo(parent)
self._make_exit_button(parent)
def esc_handler(self):
def handler(yes):
if yes:
self.stop_loop = True
else:
dialog.cleanup()
dialog = YesNoDialog(dialogName="ExitDialog",
text="Do you want to exit?",
command=handler)
def loop(self):
while not self.stop_loop:
taskMgr.step()
class InventoryGUI(Menu):
def __init__(self, mainInventory):
Menu.__init__(self)
self.mainInventory = mainInventory
self.itemComponentInventory = Inventory(3, 1)
self.itemResultInventory = Inventory(3, 1)
self.weaponCraftInventory = Inventory(3, 1)
self.topAttachmentInventory = Inventory(1, 1)
self.bottomAttachmentInventory = Inventory(1, 1)
self.frontAttachmentInventory = Inventory(1, 1)
#self.node = aspect2d.attachNewNode('Inventory GUI', sort = 0)#GUIOrder.ORDER[GUIOrder.HUD])
self.inventories = [self.mainInventory,
self.itemComponentInventory,
self.itemResultInventory,
self.weaponCraftInventory,
self.topAttachmentInventory,
self.bottomAttachmentInventory,
self.frontAttachmentInventory]
self.selectedItemStack = None
self.LoadContent()
def Update(self):
for inventory in self.inventories:
if(inventory.IsDirty()):
self.UpdateIcons(inventory)
inventory.SetDirty(False)
if(self.selectedItemStack is not None):
mousePos = Globals.GetAspect2DMousePos()
self.selectedItemStack.GetItem().GetItemIcon().SetPos(VBase3(mousePos[0], 0, mousePos[1]))
def UpdateIcons(self, inventory):
itemStacks = inventory.GetItemStacks()
for itemStack in itemStacks:
item = itemStack.GetItem()
item.LoadIcon(self.node)
itemIcon = item.GetItemIcon()
parentSlots = itemStack.GetParentSlots()
# Average the positions of the slots the itemstack belongs to
pos = VBase3(0, 0, 0)
numSlots = 0
for parentSlot in parentSlots:
numSlots += 1
pos += parentSlot.GetInventorySlotButton().GetPos()
pos /= 1.0 * numSlots
itemIcon.SetPos(pos)
def LoadContent(self):
# Load the dark background
blackBG = OnscreenImage(image = 'Assets/Images/Inventory/BlackScreen.png', scale = (2, 1, 1))
blackBG.setTransparency(TransparencyAttrib.MAlpha)
blackBG.reparentTo(self.node)
# Load the inventory image
self.inventoryBackground = OnscreenImage(image = 'Assets/Images/Inventory/inventory.png')
self.inventoryBackground.setTransparency(TransparencyAttrib.MAlpha)
self.inventoryBackground.reparentTo(self.node)
# Load the button for changing the firemode
self.fmButton = FireModeButton(self.node)
# Load the inventory slots
startPos = [[263, 524], [622, 440], [622, 282], [372, 361], [406, 282], [406, 440], [293, 361]]
padding = 69
for i, inventory in enumerate(self.inventories):
invSlots = inventory.GetInventorySlots()
for x in xrange(len(invSlots)):
for y in xrange(len(invSlots[0])):
inventorySlot = invSlots[x][y]
if(isinstance(inventory, MainInventory)):
if(y == 0):
button = InventorySlotButton(x, y, startPos[i][0], 741, padding, x, 0, inventorySlot, inventory, self.OnInventorySlotButtonClick)
else:
button = InventorySlotButton(x, y, startPos[i][0], startPos[i][1], padding, x, y - 1, inventorySlot, inventory, self.OnInventorySlotButtonClick)
else:
button = InventorySlotButton(x, y, startPos[i][0], startPos[i][1], padding, x, y, inventorySlot, inventory, self.OnInventorySlotButtonClick)
button.ReparentTo(self.node)
inventorySlot.SetInventorySlotButton(button)
self.node.hide()
def Show(self):
self.node.show()
def Hide(self):
self.node.hide()
def CheckItemComponentInventoryForCompletion(self):
items = [x.GetItem() for x in self.itemComponentInventory.GetItemStacks()]
itemClasses = sorted([x.__class__ for x in items])
for item in items:
for possibleItem in item.GetPossibleItems():
obj = possibleItem()
if(sorted(obj.GetRecipe()) == itemClasses):
print 'created', obj
obj.LoadIcon(self.node)
self.itemResultInventory.AddItemStack(ItemStack(obj))
return
else:
obj.Destroy()
del obj
def PreviewOnItemStackPickedUp(self, itemStack, inventory):
if(inventory == self.weaponCraftInventory):
item = itemStack.GetItem()
indices = inventory.GetIndices(itemStack)
fm = self.fmButton.GetMode()
result = item.GetWeapon(fm)
if(result is not None):
inventory.Clear()
item = result()
item.LoadIcon(self.node)
inventory.PlaceItemStack(ItemStack(item), indices[0], indices[1])
if(inventory == self.itemComponentInventory):
self.itemResultInventory.Clear()
self.CheckItemComponentInventoryForCompletion()
def OnItemStackPickedUp(self, itemStack, inventory):
itemStack.GetItem().GetItemIcon().setBin('fixed', GUIOrder.ORDER[GUIOrder.INV_HIGH])
if(inventory == self.itemComponentInventory):
self.itemResultInventory.Clear()
self.CheckItemComponentInventoryForCompletion()
if(inventory == self.itemResultInventory):
self.itemComponentInventory.Clear()
def OnItemStackPlaced(self, itemStack, inventory):
itemStack.GetItem().GetItemIcon().setBin('fixed', GUIOrder.ORDER[GUIOrder.INV_LOW])
if(inventory == self.weaponCraftInventory):
weapon = itemStack.GetItem()
if(isinstance(weapon, Weapon)):
fm = weapon.GetFireMode()
baseWeapon = weapon.GetBaseWeapon()
if(baseWeapon is not None):
inventory.Clear()
item = baseWeapon()
if(inventory.AddItemStack(ItemStack(item))):
item.LoadIcon(self.node)
self.fmButton.SetMode(fm)
elif(inventory == self.itemResultInventory):
item = itemStack.GetItem()
for component in item.GetRecipe():
item = component()
item.LoadIcon(self.node)
self.itemComponentInventory.AddItemStack(ItemStack(item))
elif(inventory == self.itemComponentInventory):
print itemStack.GetItem()
self.itemResultInventory.Clear()
self.CheckItemComponentInventoryForCompletion()
def OnInventorySlotButtonClick(self, invSlotButton):
parentInventory = invSlotButton.GetParentInventory()
inventorySlot = invSlotButton.GetInventorySlot()
itemStackAtSlot = inventorySlot.GetItemStack()
if(itemStackAtSlot is None):
if(self.selectedItemStack):
if(self.CanPlaceItem(parentInventory)):
indices = invSlotButton.GetSlotIndices()
x = indices[0]
y = indices[1]
dx = 0
itemWidth = self.selectedItemStack.GetItem().GetItemWidth()
if(itemWidth > 2):
dx = 2 - itemWidth
x += dx
if(x < 0):
x = 0
if(parentInventory.PlaceItemStack(self.selectedItemStack, x, y)):
self.OnItemStackPlaced(self.selectedItemStack, parentInventory)
self.selectedItemStack = None
else:
if(dx > 0 and parentInventory.PlaceItemStack(self.selectedItemStack, x+ 1, y)):
self.OnItemStackPlaced(self.selectedItemStack, parentInventory)
self.selectedItemStack = None
else:
if(self.selectedItemStack is None):
indices = invSlotButton.GetSlotIndices()
print 'picking up', itemStackAtSlot.GetItem()
self.PreviewOnItemStackPickedUp(itemStackAtSlot, parentInventory)
self.selectedItemStack = parentInventory.GetItemStack(indices[0], indices[1])
parentInventory.RemoveItemStack(indices[0], indices[1])
self.OnItemStackPickedUp(self.selectedItemStack, parentInventory)
def CanPlaceItem(self, inventory):
if(inventory == self.itemResultInventory and (not self.itemComponentInventory.IsEmpty() or not self.itemResultInventory.IsEmpty())):
return False
if(inventory == self.weaponCraftInventory and (not self.weaponCraftInventory.IsEmpty())):
return False
return True
def Destroy(self):
for inventory in self.inventories:
inventory.Destroy()
del inventory
self.node.removeNode()
del self.node
class World:
def __init__(self, actor, state, lvl):
#Setzte die Parameter
self.CActor = actor #Spieler erstellen
self.CGame = state #FSM - Gamestate erstellen
self.mission = lvl #Aktuelle Mission
self.mMission = None
#Grundeinstellen fuer die Welt
base.disableMouse() #Mouse ausmachen
self.slowdown = 1 #Schnelligkeitsfaktor 1=Normal
self.hud = False
file, filename, description = imp.find_module("mission" +
str(self.mission))
self.mMission = imp.load_module("mission" + str(self.mission), file,
filename, description)
#SPIELER - Variablen
self.oldactorlevel = self.CActor.getLevel()
self.CActor.CActorShip.setX(
-165) #Setze den Spieler links im Bildschirm
self.CActor.CActorShip.setY(0)
self.CActor.nActorShip.reparentTo(render)
self.CActor.CActorShip.getWeapon().setWeapon(
"laserGun") #Standardwaffe setzen
self.maxshield = self.CActor.CActorShip.getShield(
) #Schild speichern um Prozent berechnen zu koennen
self.hitted = False #Variable um abzufragen ob man getroffen wurde
self.dead = False #Spieler lebt
self.lbullets = [] #Spielerbullets
self.lbulletsspeed = []
self.lcanon = [] #Spielercanonbullets
self.lcanonspeed = []
self.cameraeffectx = 0 #X-Wert der Camera um eine Sinuskurve zu implementieren
self.cameraeffectamplitude = 5 #Die Amplitude der Sinuswelle - Maxima
self.exppercent = (self.CActor.getExperience() * 100
) / self.CActor.getMaxExperience() #EXP in Prozent
self.oldcash = self.CActor.getMoney()
self.secweapon = 3
#Resultattexte, wenn die Mission zu ende ist
self.txtresultmission = addText(-0.15, 0.35, "")
self.txtresultkills = addText(-0.15, 0.25, "")
self.txtresultleft = addText(-0.15, 0.20, "")
self.txtresultcash = addText(-0.15, 0.15, "")
self.txtresultlevel = addText(-0.15, 0.10, "")
self.txtresultmessage = addText(-0.15, 0.0, "")
#ALLES FUER MOTION BLUR ***********************************************************************
#Eine Texture erstellen, welches in das Hauptfenster kopiert wird
self.CTex = Texture()
self.CTex.setMinfilter(Texture.FTLinear)
base.win.addRenderTexture(self.CTex,
GraphicsOutput.RTMTriggeredCopyTexture)
#Eine andere 2D Kamera erstellen, welches vor der Hauptkamera gerendert wird
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)
#Zwei Texturekarten ersten. Eins bevor, eins danach
self.bcard = base.win.getTextureCard()
self.bcard.reparentTo(self.background)
self.bcard.setTransparency(1)
self.fcard = base.win.getTextureCard()
self.fcard.reparentTo(render2d)
self.fcard.setTransparency(1)
#**********************************************************************************************
#Drops als Liste
self.ldrop = []
#Explosionen - oder besser gesagt Splittereffekt als Liste
self.lexplosions = []
#Soundklasse erstellen um Zugriff auf die Sound zu haben
self.CSound = SoundMng()
self.CSound.sndFlyAmbience.play()
#GEGNER - Variablen
self.destroyedenemy = 0
self.lostenemy = 0
self.lenemys = [] #Gegnerspeicher
self.lbulletsenemy = [] #Gegnerbullets
self.newwave = False #Boolean,welches eine neue Gegnerwelle angibt
#Effekte
self.CEffects = Effects() #Effektklasse erstellen
#self.CEffects.createSpaceStars("particle/background.ptf") #Hintergrundeffekt erstellen
#Die Game-Loop Voreinstellungen
self.gameTask = taskMgr.add(self.gameLoop, "gameLoop")
self.gameTask.last = 0
self.gameTask.nextbullet = 0 #Timer wann geschossen werden darf, vom Spieler
self.gameTask.gotHit = 0
self.gameTask.lnextenemybullet = [
] #Timer wann geschossen werden darf, unabhaengig von welche Gegner
self.gameTask.resultkills = 0 #Timer fuer die Kills, im Resultat
self.gameTask.resultleft = 0 #Timer fuer die geflohenen Gegner, im Resultat
self.gameTask.introduction = 0
self.gameTask.introdelete = 0
self.gameTask.won = 0
self.resultcounter = 0 #Zeahler der die Nummern der Kills im Result aktualisiert
self.resultcounterleft = 0 #Zeahler der die Nummern der geflohenen Gegner im Result aktualisiert
self.introcounter = 0
self.ldata = []
self.readytospawn = False
self.musicplayed = False
self.musicplayed2 = False
self.resultplayed = False
#2D Kamera erstellen
lens = OrthographicLens()
lens.setFilmSize(350, 250)
base.cam.node().setLens(lens)
def gameLoop(self, task):
#Clock fuer FPS unabhaengige Bewegung
elapsed = globalClock.getDt()
if task.time > task.introduction:
if (self.mMission.getIntroduction(self.introcounter) == True):
self.introcounter += 1
task.introduction = task.time + 0.1
else:
task.introdelete = task.introduction + 3
if task.time > task.introdelete:
if self.musicplayed == False:
self.CSound.sndMusic.play()
self.musicplayed = True
self.toogleHud()
self.mMission.removeIntroduction()
if self.mMission.getSituation(task.time) == True:
for i in range(3):
self.ldata.append(self.mMission.getEnemies(i))
self.createEnemys(self.ldata[len(self.ldata) - 3],
self.ldata[len(self.ldata) - 1])
self.spawnEnemys(200, self.ldata[len(self.ldata) - 2])
#Die Position der Gegner aktualisieren
for obj in self.lenemys:
self.updatePosEnemy(obj, elapsed)
if obj.nEnemyShip.isEmpty() == 0:
if obj.CEnemyShip.getX() < -180:
obj.nEnemyShip.removeNode()
self.lostenemy += 1
if obj.CEnemyShip.getX() > 170:
obj.nEnemyShip.detachNode()
if obj.CEnemyShip.getX() < 170 and obj.CEnemyShip.getX(
) > -150:
obj.nEnemyShip.reparentTo(render)
if self.destroyedenemy + self.lostenemy == self.mMission.MAX_ENEMYS:
if task.won == 0:
task.won = task.time + 3
if task.won < task.time and self.musicplayed2 == False:
self.CSound.sndMusic.stop()
self.musicplayed2 = True
task.won = task.time + 3
if task.won < task.time:
if self.resultplayed == False:
self.CSound.sndResult.play()
self.CSound.sndFlyAmbience.stop()
self.resultplayed = True
for drop in self.ldrop:
drop.remove()
self.txthp.destroy()
self.txtshield.destroy()
self.txtlvl.destroy()
self.imgHud.destroy()
self.imgExp.destroy()
self.txtresultmission.setText("Mission: " + str(self.mission) +
" Complete")
if task.time > task.resultkills:
if self.resultcounter < self.destroyedenemy:
self.resultcounter += 1
self.txtresultkills.setText("Killed Enemies: " +
str(self.resultcounter))
self.CSound.sndTipp.play()
task.resultkills = task.time + 0.1
if self.resultcounter == self.destroyedenemy:
if task.time > task.resultleft:
if self.resultcounterleft < self.lostenemy:
self.resultcounterleft += 1
self.txtresultleft.setText(
"Left Enemies: " +
str(self.resultcounterleft))
task.resultleft = task.time + 0.1
self.CSound.sndTipp.play()
if self.resultcounterleft == self.lostenemy:
self.txtresultcash.setText(
"Geldstand: " + str(self.CActor.getMoney()) +
"$ (+" +
str(self.CActor.getMoney() - self.oldcash) +
"$)")
self.txtresultlevel.setText(
"Dein Level: " + str(self.CActor.getLevel()) +
" (+" + str(self.CActor.getLevel() -
self.oldactorlevel) + ")")
self.txtresultmessage.setText(
"Druecke Enter um fortzufahren")
if self.CActor.keyMap["entr"] != 0:
self.CActor.CActorShip.setShield(
self.maxshield)
self.CActor.setHP(self.CActor.getMaxHP())
taskMgr.remove('gameLoop')
self.CGame.request("GameMenue", self.CActor,
self.CGame)
if self.dead == True:
render.node().removeAllChildren()
taskMgr.remove("gameLoop")
self.CGame.request("MainMenue", self.CGame)
#Falls nextEnemyBullet-Timer NULL ist, so erstelle fuer jeden Gegner einen eigenen Timer
if (self.newwave == True):
for i in range(len(self.lenemys)):
task.lnextenemybullet.append(i)
self.newwave = False
#Gegnerfeuer erstellen und mit einem Zufallsalgorythmus schiessen lassen
for i in range(len(self.lenemys)):
posEnemyX = self.lenemys[i].CEnemyShip.getX()
#Erst schiessen lassen, wenn sie im Spielbereich sind
if posEnemyX < 170 and posEnemyX > -180 and self.lenemys[
i].nEnemyShip.hasParent() == True:
if task.time > task.lnextenemybullet[i]:
task.lnextenemybullet[i] = task.time + choice(
range(4, 7) + range(4, 7))
self.enemyShot(self.lenemys[i])
self.lenemys[i].CEnemyShip.getWeapon().sndGun.setVolume(
0.5)
self.lenemys[i].CEnemyShip.getWeapon().sndGun.play()
#Nachdem der Spieler die Schiesstaste gedrueckt hat, wird ein Timer aktiviert der nach eine Zeit
#immer wieder aktualisiert wird, damit der Spieler den naechsten Schuss abfeuern kann
if (self.CActor.keyMap["arr_up"] != 0 and task.time > task.nextbullet):
if self.dead == False:
task.nextbullet = task.time + 1.25**(-1.5 *
self.CActor.getAgility())
self.playerShot("laserGun")
self.CActor.CActorShip.getWeapon().sndGun.play()
#Nachdem der Spieler die Schiesstaste gedrueckt hat, wird ein Timer aktiviert der nach eine Zeit
#immer wieder aktualisiert wird, damit der Spieler den naechsten Schuss abfeuern kann
if (self.CActor.keyMap["arr_right"] != 0
and task.time > task.nextbullet):
if self.dead == False:
task.nextbullet = task.time + 1 + 1.25**(
-1.5 * self.CActor.getAgility())
self.playerShot("canonGun")
self.CActor.CActorShip.getWeapon().sndGun.play()
#Ein Array, um abgeschossen Patronen festzuhalten: vom Spieler
lnewbullet = []
#Funktion um die Bullets zu aktualsieren
for i in range(len(self.lbullets)):
self.updateBulletPlayer(self.lbullets[i], self.lbulletsspeed[i],
elapsed)
if self.lbullets[i].isEmpty() == 0:
if (self.lbullets[i].getX() < 180):
lnewbullet.append(self.lbullets[i])
else:
self.lbullets[i].remove()
self.lbullets = lnewbullet
lnewcanon = []
#Funktion um die Bullets zu aktualsieren
for i in range(len(self.lcanon)):
self.updateBulletPlayer(self.lcanon[i], self.lcanonspeed[i],
elapsed)
if self.lcanon[i].isEmpty() == 0:
if (self.lcanon[i].getX() < 180):
lnewcanon.append(self.lcanon[i])
else:
self.lcanon[i].remove()
self.lcanon = lnewcanon
#Ein Array, um abgeschossen Patronen festzuhalten: vom Gegner
lnewenemybullet = []
#Funktion um die Bullets der Gegner zu aktualsieren
for obj in self.lbulletsenemy:
self.updateBulletEnemy(obj, elapsed)
if obj.isEmpty() == 0:
if (obj.getX() > -180):
lnewenemybullet.append(obj)
else:
obj.remove()
self.lbulletsenemy = lnewenemybullet
#Funktion fuer die Kollision mit dem Gegner
for obj in self.lbullets:
self.enemyHit(obj)
for obj in self.lcanon:
self.enemyHit(obj)
#Funktion fuer die Kollision mit dem Spieler
if self.playerHit() == True:
self.hitted = True
#Funktion fuer die Kollision mit dem Schiff
if self.getShipHit() == True:
self.hitted = True
self.dropHit()
#Falls Spieler getroffen wird, so mache ein Cameraeffekt
if self.hitted == True:
if self.CActor.CActorShip.getShield() > 0:
self.cameraeffectamplitude = 5
base.camera.setZ(base.camera.getZ() +
self.cameraeffectamplitude *
math.sin(self.cameraeffectx))
self.cameraeffectx = self.cameraeffectx + 1
if self.cameraeffectx == 20:
self.hitted = False
self.cameraeffectx = 0
base.camera.setZ(0)
else:
if (self.dead == False):
self.cameraeffectamplitude = 2
base.camera.setZ(base.camera.getZ() +
self.cameraeffectamplitude *
math.sin(self.cameraeffectx))
self.cameraeffectx = self.cameraeffectx + 1
else:
self.hitted = False
for obj in self.ldrop:
if obj != None:
if obj.isEmpty() == 0:
obj.setHpr(obj.getH() - 1, 0, 0)
for obj in self.lexplosions:
if obj != None:
if obj.isEmpty() == 0:
posy = obj.getZ()
self.updateExplosion(
obj, elapsed, -3,
choice(range(-11, 11) + range(-11, 11)))
if obj.getX() < -180:
obj.remove()
return Task.cont
def updateExplosion(self, obj, dt, x, y):
if obj.isEmpty() == 0:
newposx = obj.getX() + (self.slowdown * dt * 35 * 3) * x
newposy = obj.getZ() + (self.slowdown * dt * 35 * 3) * y
obj.setX(newposx)
obj.setZ(newposy)
def updateBulletPlayer(self, obj, spe, dt):
if obj.isEmpty() == 0:
newpos = obj.getX() + (self.slowdown * dt * 35 * spe)
obj.setX(newpos)
def updateBulletEnemy(self, obj, dt):
if obj.isEmpty() == 0:
newpos = obj.getX() - (
self.slowdown * dt * 35 *
self.CEnemy.CEnemyShip.getWeapon().getWeaponSpeed())
obj.setX(newpos)
def updatePosEnemy(self, obj, dt):
if obj.nEnemyShip.isEmpty() == 0:
obj.CEnemyShip.setX(obj.CEnemyShip.getX() - self.slowdown * dt *
15 * obj.CEnemyShip.getSpeed())
obj.CEnemyShip.setY(obj.CEnemyShip.getY() +
self.slowdown * dt * 15 *
(math.sin(0.1 * obj.CEnemyShip.getX())))
def playerShot(self, gun):
bullet = self.CActor.CActorShip.getWeapon().setWeapon(gun)
if bullet.isEmpty() == 0:
if self.secweapon == 3:
bullet.setPos(self.CActor.CActorShip.getX() + 10, 500,
self.CActor.CActorShip.getY() + self.secweapon)
self.secweapon = -4
else:
bullet.setPos(self.CActor.CActorShip.getX() + 10, 500,
self.CActor.CActorShip.getY() + self.secweapon)
self.secweapon = 3
print self.CActor.CActorShip.getWeapon().getWeapon()
if self.CActor.CActorShip.getWeapon().getWeapon() == "laserGun":
self.lbullets.append(bullet)
self.lbulletsspeed.append(
self.CActor.CActorShip.getWeapon().getWeaponSpeed())
elif self.CActor.CActorShip.getWeapon().getWeapon() == "canonGun":
self.lcanon.append(bullet)
self.lcanonspeed.append(
self.CActor.CActorShip.getWeapon().getWeaponSpeed())
del bullet
def enemyShot(self, obj):
bullet = obj.CEnemyShip.getWeapon().setWeapon("laserGun")
if obj.nEnemyShip.isEmpty() == 0:
bullet.setPos(obj.nEnemyShip.getPos())
self.lbulletsenemy.append(bullet)
del bullet
def addDrop(self, pos):
drp = self.CEffects.getDrop("models/heal", 19, pos)
if (drp == None):
return False
else:
self.ldrop.append(drp)
return True
def explode(self, pos):
expl = self.CEffects.getExplosion(pos)
self.lexplosions.append(expl)
def enemyHit(self, bullet):
for enmy in self.lenemys:
if enmy.nEnemyShip.isEmpty() == 0 and bullet.isEmpty() == 0:
#Falls Gegner getroffen wird
if (bullet.getPos() -
enmy.nEnemyShip.getPos()).lengthSquared() < 85:
#Bullet loesche
bullet.remove()
self.explode(enmy.nEnemyShip.getPos())
enmy.CEnemyShip.setShield(
enmy.CEnemyShip.getShield() -
self.CActor.CActorShip.getWeapon().getWeaponStrength())
self.CSound.sndHit.play()
#Falls kein Schild mehr vorhanden -> Loeschen
if enmy.CEnemyShip.getShield() <= 0:
self.addDrop(enmy.nEnemyShip.getPos())
for i in range(5):
self.explode(enmy.nEnemyShip.getPos())
enmy.nEnemyShip.removeNode()
self.CSound.sndExplosion.play()
self.destroyedenemy += 1
self.CActor.setExperience(self.CActor.getExperience() +
(enmy.getExpDrop()))
self.exppercent = (self.CActor.getExperience() * 100
) / self.CActor.getMaxExperience()
if self.imgExp.isEmpty() == 0:
self.imgExp.setScale(
0.01, 0.2, ((2.0 * self.exppercent) / 100.0))
self.CActor.setMoney(self.CActor.getMoney() +
enmy.getCashDrop())
if self.CActor.getLevelUp() == True:
self.txtlvl.setText(str(self.CActor.getLevel()))
self.CActor.setExperience(self.CActor.getExperience() +
(enmy.getExpDrop() / 2))
self.exppercent = (self.CActor.getExperience() * 100
) / self.CActor.getMaxExperience()
self.imgExp.setScale(0.01, 0.2, 0.002)
def playerHit(self):
for bullet in self.lbulletsenemy:
if self.CActor.nActorShip.isEmpty() == 0 and bullet.isEmpty() == 0:
#Falls Spieler getroffen wird
if ((bullet.getPos() -
self.CActor.nActorShip.getPos()).lengthSquared() < 85):
#Bullet loeschen
bullet.remove()
#Funktion aufrufen - Parameter: Schaden
if self.actorHurt(self.CEnemy.CEnemyShip.getWeapon(
).getWeaponStrength() + self.CEnemy.getStrength()) == True:
return True
def getShipHit(self):
for enmy in self.lenemys:
if enmy.nEnemyShip.isEmpty(
) == 0 and self.CActor.nActorShip.isEmpty() == 0:
#Falls das Spielerschiff einen Gegnerschiff trifft
if ((enmy.nEnemyShip.getPos() -
self.CActor.nActorShip.getPos()).lengthSquared() < 85):
for i in range(5):
self.explode(enmy.nEnemyShip.getPos())
enmy.nEnemyShip.removeNode()
#self.CSound.sndExplosion.play()
self.destroyedenemy += 1
self.CActor.setExperience(self.CActor.getExperience() +
(enmy.getExpDrop() / 2))
self.exppercent = (self.CActor.getExperience() *
100) / self.CActor.getMaxExperience()
if self.CActor.getLevelUp() == True:
self.txtlvl.setText(str(self.CActor.getLevel()))
self.CActor.setExperience(self.CActor.getExperience() +
(enmy.getExpDrop() / 2))
self.exppercent = (self.CActor.getExperience() * 100
) / self.CActor.getMaxExperience()
#Schaden ist gleich der Staerke vom gegnerischen Schiff
if self.actorHurt(enmy.getStrength()) == True:
return True
def createEnemys(self, amount, kind):
for i in range(amount):
#Gegner erstellen
self.CEnemy = Enemy(kind)
self.lenemys.append(self.CEnemy)
def spawnEnemys(self, start, width):
for obj in self.lenemys:
if obj.CEnemyShip.getY() > 101 and obj.nEnemyShip.isEmpty() == 0:
obj.CEnemyShip.setX(
choice(range(start, width) + range(start, width)))
obj.CEnemyShip.setY(choice(range(-100, 0) + range(0, 100)))
self.newwave = True
def dropHit(self):
for obj in self.ldrop:
if obj.isEmpty() == 0 and self.CActor.nActorShip.isEmpty() == 0:
if ((obj.getPos() -
self.CActor.nActorShip.getPos()).lengthSquared() < 86):
obj.remove()
if self.CActor.getHP() < self.CActor.getMaxHP():
self.CActor.setHP(self.CActor.getHP() + 20)
self.txthp.setText(
str((self.CActor.getHP() * 100) /
self.CActor.getMaxHP()))
def actorHurt(self, dmg):
if (self.CActor.CActorShip.getShield() <= 0):
self.txtshield.setText("0")
self.CActor.CActorShip.setShield(0)
self.CActor.setHP(self.CActor.getHP() - dmg * 20)
self.CSound.sndCrit.play()
if (self.CActor.getHP() <= 0):
#Der Spieler ist tot und hat verloren
self.txthp.setText("0")
self.dead = True
#self.CFilters.setBloom(blend=(0,0,0,1), desat=-0.5, intensity=5.0, size="small")
self.slowdown = 1
self.CActor.slowdown = self.slowdown
taskMgr.remove("takeSnapShot")
self.clickrate = 0
self.fcard.hide()
for i in range(5):
self.explode(self.CActor.nActorShip.getPos())
self.CActor.nActorShip.detachNode()
return True
if (self.CActor.getHP() <= 50):
self.CSound.sndExplosion.setPlayRate(0.5)
self.CSound.sndMusic.setPlayRate(0.5)
self.CSound.sndFlyAmbience.setPlayRate(0.5)
self.CSound.sndHit.setPlayRate(0.5)
self.CActor.CActorShip.getWeapon().sndGun.setPlayRate(0.5)
taskMgr.add(self.takeSnapShot, "takeSnapShot")
self.chooseEffectGhost()
self.slowdown = 0.5
self.CActor.setSlowDown(self.slowdown)
#self.CFilters.delBloom()
self.explode(self.CActor.nActorShip.getPos())
self.txthp.setText(
str((self.CActor.getHP() * 100) / self.CActor.getMaxHP()))
return True
else:
self.CActor.CActorShip.setShield(
self.CActor.CActorShip.getShield() - dmg)
self.txtshield.setText(
str((self.CActor.CActorShip.getShield() * 100) /
self.maxshield))
self.explode(self.CActor.nActorShip.getPos())
return True
#Screenshots erstellen um MotionBlur Effekt zu erreichen
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
#MotionBlur Effekt
def chooseEffectGhost(self):
base.setBackgroundColor(0, 0, 0, 1)
self.bcard.hide()
self.fcard.show()
self.fcard.setColor(1.0, 1.0, 1.0, 0.99)
self.fcard.setScale(1.00)
self.fcard.setPos(0, 0, 0)
self.fcard.setR(0)
self.clickrate = 100
self.nextclick = 0
def toogleHud(self):
if self.hud == False:
#Hudeinstellung *******************************************************************************
self.imgHud = OnscreenImage(image='images/hud.png',
pos=(-1.09, 0, -0.01),
scale=(0.185, 0.5, 1))
self.imgHud.reparentTo(aspect2d)
self.imgHud.setTransparency(TransparencyAttrib.MAlpha)
#EXP Leiste
self.imgExp = OnscreenImage(image='images/exp.png',
pos=(-1.2645, 0, -1),
scale=(0.01, 0.2, 0.001))
self.imgExp.reparentTo(aspect2d)
#Texte der HUD
self.txthp = addText(
-1.03, 0.966,
str((self.CActor.getHP() * 100) / self.CActor.getMaxHP()))
self.txtshield = addText(
-1.03, 0.9151,
str((self.CActor.CActorShip.getShield() * 100) /
self.maxshield))
self.txtlvl = addText(-1.19, 0.80, str(self.CActor.getLevel()))
self.hud = True
class miniMap(object):
def __init__(self, mainActor):
self.teamMateImage = 'models/hexahedron.png'
self.heroImage = 'models/mainHero2.png'
self.miniMapImage = 'models/miniMap000.png'
self.towerImage = 'models/tower_neitral.png'
self.towerRed = 'models/tower_red.png'
self.towerBlue = 'models/tower_blue.png'
self.map = OnscreenImage(image = self.miniMapImage, pos=(-0.7, 0, 0.8),
scale=(MAP_SCALEX, 0, MAP_SCALEY))
self.map.setTransparency(1)
#self.map.reparentTo(rander)
self.hero = OnscreenImage(image=self.heroImage, pos=(mainActor.getX()/525, 0, mainActor.getY()/160),
scale=(HERO_SCALE, 1, HERO_SCALE),
hpr=(0, 0, mainActor.getH()))
self.hero.reparentTo(self.map)
self.hero.setTransparency(1)
self.npc = {}
self.tower = {}
self.team = {}
def resizeScreen(self, x, y):
if x != 800 and y != 600:
self.map.setPos(-1.4, 0, 0.8)
else:
self.map.setPos(-0.7, 0, 0.8)
def setMap(self, mapScale, x, y):
self.map = OnscreenImage(image = self.miniMapImage, pos=(x, 0, y),
scale=(mapScale, mapScale, mapScale))
return self.map
def setHero(self, heroScale, x, y, h):
self.hero = OnscreenImage(image=self.heroImage, pos=(x, 0, y),
scale=(heroScale, 1, heroScale),
hpr=(0, 0, h))
return self.hero
def updateHeroPos(self, getX, getY):
if getX <= 0 and getY <= 0:
ay = (MAP_AY + (getY))/MAP_AY
y = MAP_SCALEY-(ay*MAP_SCALEY)
ax = (MAP_AX + (getX))/MAP_AX
x = MAP_SCALEX-(ax*MAP_SCALEX)
elif getX > 0 and getY < 0:
ay = (MAP_AY + (getY))/MAP_AY
y = MAP_SCALEY-(ay*MAP_SCALEY)
ax = (MAP_BX - (getX))/MAP_BX
x = -MAP_SCALEX+(ax*MAP_SCALEX)
elif getX < 0 and getY > 0:
ay = (MAP_BY - (getY))/MAP_BY
y = -MAP_SCALEY+(ay*MAP_SCALEY)
ax = (MAP_AX + (getX))/MAP_AX
x = MAP_SCALEX-(ax*MAP_SCALEX)
else:
ay = (MAP_BY - (getY))/MAP_BY
y = -MAP_SCALEY+(ay*MAP_SCALEY)
ax = (MAP_BX - (getX))/MAP_BX
x = -MAP_SCALEX+(ax*MAP_SCALEX)
self.hero.setPos(x, 0, y)
def updateHeroHpr(self, getH):
h = -getH
self.hero.setHpr(0, 0, h)
def setNpc(self, npcName, npcImage, npcScale, x, y):
self.Nps = OnscreenImage(image=npcImage, pos=(x, 0, y),
scale=(npcScale*MAP_SCALEY, 1, npcScale*MAP_SCALEX))
self.Nps.reparentTo(self.map)
self.Nps.setTransparency(1)
self.npc[npcName] = self.Nps
return self.npc
def delNpc(self, npcName):
del self.npc[npcName]
def setTower(self, towerName, towerScale, getX, getY):
if getX <= 0 and getY <= 0:
ay = (MAP_AY + (getY))/MAP_AY
y = MAP_SCALEY-(ay*MAP_SCALEY)
ax = (MAP_AX + (getX))/MAP_AX
x = MAP_SCALEX-(ax*MAP_SCALEX)
elif getX > 0 and getY < 0:
ay = (MAP_AY + (getY))/MAP_AY
y = MAP_SCALEY-(ay*MAP_SCALEY)
ax = (MAP_BX - (getX))/MAP_BX
x = -MAP_SCALEX+(ax*MAP_SCALEX)
elif getX < 0 and getY > 0:
ay = (MAP_BY - (getY))/MAP_BY
y = -MAP_SCALEY+(ay*MAP_SCALEY)
ax = (MAP_AX + (getX))/MAP_AX
x = MAP_SCALEX-(ax*MAP_SCALEX)
else:
ay = (MAP_BY - (getY))/MAP_BY
y = -MAP_SCALEY+(ay*MAP_SCALEY)
ax = (MAP_BX - (getX))/MAP_BX
x = -MAP_SCALEX+(ax*MAP_SCALEX)
self.tower_ = OnscreenImage(image=self.towerImage, pos=(x, 0, y),
scale=(towerScale*MAP_SCALEY, 1, towerScale*MAP_SCALEX))
self.tower_.reparentTo(self.map)
self.tower_.setTransparency(1)
self.tower[towerName] = self.tower_
return self.tower
def changeTowerColor(self, towerName, towerImage):
self.tower[towerName].setImage(towerImage)
def delTower(self, towerName):
del self.tower[towerName]
def setTeamMate(self, mateName, mateScale, getX, getY):
if getX <= 0 and getY <= 0:
ay = (MAP_AY + (getY))/MAP_AY
y = MAP_SCALEY-(ay*MAP_SCALEY)
ax = (MAP_AX + (getX))/MAP_AX
x = MAP_SCALEX-(ax*MAP_SCALEX)
elif getX > 0 and getY < 0:
ay = (MAP_AY + (getY))/MAP_AY
y = MAP_SCALEY-(ay*MAP_SCALEY)
ax = (MAP_BX - (getX))/MAP_BX
x = -MAP_SCALEX+(ax*MAP_SCALEX)
elif getX < 0 and getY > 0:
ay = (MAP_BY - (getY))/MAP_BY
y = -MAP_SCALEY+(ay*MAP_SCALEY)
ax = (MAP_AX + (getX))/MAP_AX
x = MAP_SCALEX-(ax*MAP_SCALEX)
else:
ay = (MAP_BY - (getY))/MAP_BY
y = -MAP_SCALEY+(ay*MAP_SCALEY)
ax = (MAP_BX - (getX))/MAP_BX
x = -MAP_SCALEX+(ax*MAP_SCALEX)
self.teamMate = OnscreenImage(image=self.teamMateImage,
pos=(x, 0, y),
scale=(mateScale*MAP_SCALEY, 1, mateScale*MAP_SCALEX))
self.teamMate.reparentTo(self.map)
self.teamMate.setTransparency(1)
self.team[mateName] = self.teamMate
return self.team
def updateTeamMatePos(self, mateName, getX, getY):
if getX <= 0 and getY <= 0:
ay = (MAP_AY + (getY))/MAP_AY
y = MAP_SCALEY-(ay*MAP_SCALEY)
ax = (MAP_AX + (getX))/MAP_AX
x = MAP_SCALEX-(ax*MAP_SCALEX)
elif getX > 0 and getY < 0:
ay = (MAP_AY + (getY))/MAP_AY
y = MAP_SCALEY-(ay*MAP_SCALEY)
ax = (MAP_BX - (getX))/MAP_BX
x = -MAP_SCALEX+(ax*MAP_SCALEX)
elif getX < 0 and getY > 0:
ay = (MAP_BY - (getY))/MAP_BY
y = -MAP_SCALEY+(ay*MAP_SCALEY)
ax = (MAP_AX + (getX))/MAP_AX
x = MAP_SCALEX-(ax*MAP_SCALEX)
else:
ay = (MAP_BY - (getY))/MAP_BY
y = -MAP_SCALEY+(ay*MAP_SCALEY)
ax = (MAP_BX - (getX))/MAP_BX
x = -MAP_SCALEX+(ax*MAP_SCALEX)
self.team[mateName].setPos(x, 0, y)
def updateTeamMateHpr(self, mateName, getH):
h = -getH
self.team[mateName].setHpr(0, 0, h)
def delTeamMate(self, mateName):
del self.team[mateName]
class InfoGUI(DirectFrame, StateData.StateData):
notify = DirectNotifyGlobal.directNotify.newCategory('InfoGUI')
def __init__(self, avChooser):
DirectFrame.__init__(self,
pos=(0, 0, 0.05),
relief=None,
image=DGG.getDefaultDialogGeom(),
image_scale=(2.2, 1, 1.4),
image_pos=(0, 0, -0.05),
image_color=ToontownGlobals.GlobalDialogColor,
text=TTLocalizer.AvatarChooserInfo,
text_scale=0.12,
text_pos=(0, 0.5),
borderWidth=(0.01, 0.01))
StateData.StateData.__init__(self, 'info-gui-done')
self.isLoaded = False
self.setBin('gui-popup', 0)
self.initialiseoptions(InfoGUI)
self.avChooser = avChooser
self.textRolloverColor = Vec4(1, 1, 0, 1)
self.textDownColor = Vec4(0.5, 0.9, 1, 1)
self.textDisabledColor = Vec4(0.4, 0.8, 0.4, 1)
self.descPos = (0.485, 0, -0.2)
self.halloweenMiniserver = None
self.halloweenMiniserverSeq = None
return
def unload(self):
if not self.isLoaded:
return
self.isLoaded = False
self.exit()
DirectFrame.destroy(self)
def load(self):
if self.isLoaded:
return
self.isLoaded = True
gui = loader.loadModel('phase_3.5/models/gui/friendslist_gui')
guiButton = loader.loadModel('phase_3/models/gui/quit_button')
if base.cr.holidayValue == 1:
ImagePath = 'phase_14.5/maps/halloween_server_1.png'
else:
if base.cr.holidayValue == 2:
ImagePath = 'phase_14.5/maps/halloween_server_3.png'
else:
if base.cr.holidayValue == 3:
ImagePath = 'phase_14.5/maps/halloween_server_5.png'
else:
if base.cr.holidayValue == 4:
ImagePath = 'phase_14.5/maps/halloween_server_2.png'
else:
if base.cr.holidayValue == 5:
ImagePath = 'phase_14.5/maps/halloween_server_4.png'
else:
if base.cr.holidayValue == 6:
ImagePath = 'phase_14.5/maps/halloween_server_4.png'
self.sname = DirectLabel(parent=self,
text=TTLocalizer.ServerPageName %
base.cr.serverName,
relief=None,
pos=(0.0, 0.0, 0.35),
scale=0.079,
text_fg=Vec4(0, 0, 0, 1),
text_align=TextNode.ACenter,
text_font=ToontownGlobals.getToonFont())
self.description = DirectLabel(parent=self,
text=TTLocalizer.InfoDescription +
base.cr.serverDescription,
relief=None,
pos=(0.0, 0.0, 0.25),
scale=0.069,
text_fg=Vec4(0, 0, 0, 1),
text_wordwrap=24,
text_align=TextNode.ACenter,
text_font=ToontownGlobals.getToonFont())
self.cancel = DirectButton(parent=self,
relief=None,
text=TTLocalizer.DisplaySettingsCancel,
image=(guiButton.find('**/QuitBtn_UP'),
guiButton.find('**/QuitBtn_DN'),
guiButton.find('**/QuitBtn_RLVR')),
image_scale=(0.6, 1, 1),
text_scale=TTLocalizer.DSDcancel,
text_pos=TTLocalizer.DSDcancelPos,
pos=(0.93, 0, -0.65),
command=self.__cancel)
if base.cr.isHalloween and base.cr.holidayValue != 0:
self.halloweenMiniserver = OnscreenImage(image=ImagePath,
pos=(0.0, 0, -0.13),
scale=(0.3125, 0.3125,
0.25))
self.halloweenMiniserver.reparentTo(self)
self.halloweenMiniserver.setTransparency(TransparencyAttrib.MAlpha)
self.halloweenMiniserverSeq = Sequence(
self.halloweenMiniserver.scaleInterval(3, (0.5, 0.5, 0.4),
blendType='easeInOut'),
self.halloweenMiniserver.scaleInterval(3,
(0.3125, 0.3125, 0.25),
blendType='easeInOut'))
self.halloweenMiniserverSeq.loop()
self.event = DirectLabel(
text='A unqiue Halloween event is\nactive on this Mini-Server!',
relief=None,
pos=(0.0, 0.0, -0.6),
scale=0.069,
text_fg=Vec4(0, 0, 0, 1),
text_align=TextNode.ACenter,
text_font=ToontownGlobals.getToonFont())
self.event.reparentTo(self)
self.eventSeq = Sequence(
Wait(1.4), Func(self.event.setColorScale, 1, 1, 1, 0),
Wait(1.4), Func(self.event.setColorScale, 1, 1, 1, 1))
self.eventSeq.loop()
gui.removeNode()
guiButton.removeNode()
self.hide()
return
def enter(self):
if self.isEntered == 1:
return
self.isEntered = 1
if self.isLoaded == 0:
self.load()
base.transitions.fadeScreen(0.5)
self.show()
def exit(self):
if self.isEntered == 0:
return
self.isEntered = 0
base.transitions.noTransitions()
self.ignoreAll()
self.hide()
def __cancel(self):
self.exit()
class world(ShowBase):
def __init__(self):
try:
ShowBase.__init__(self)
except:
sys.exit("[WARNING]: unknown error: Showbase initialisation failed")
# ------------------------------- Begin of parameter variables (pretty messy actually) ------------------------------------
#debug ------
self.debug=False #[ /!\ IMPORTANT /!\ ] do not leave this value to True when you commit the code to github, as it is impossible to change once ingame, and modifies quite a lot of graphical parameters
#debug ------
self.stored_collisions=[] # this counts the amount of collisions and allows us to detect the income of a new collision in order to create a new particle effect when it appears
self.timescale=5 # this can be changed at any moment, it represents the speed of the ingame time
self.worldscale=0.1 # currently useless
self.camera_delta=0.5 # camera delta displacement
self.sensitivity_x,self.sensitivity_y=20,20
self.watched=None # watched object (object focused by the cursor)
self.state=['paused','free',None] # state of things: [simulation paused/running,camera following object/free,followed object/None]
print('free mode on')
self.iteration=0 #iteration for the menu to be drawn once
self.collision_status=False # Keep this on False, that's definitely not a setting # currently useless
self.u_constant=6.67408*10**(-11) #just a quick reminder
self.u_radius=5 #just what I said earlier
# ------------------------------- End of parameter variables (sry for the mess) --------------------------------------------
self.Game_state=state()
self.Game_state.cleanup() # better safe than sorry
self.taskMgr.add(self.wait,'wait_task')
self.setBackgroundColor(0,0,0)
def wait(self,task):
if not(task.time):
self.screen_fill=OnscreenImage(image=str(MAINDIR)+"/Engine/main_page.png",pos = (0, 0, 0),scale=(1.77777778,1,1))
elif task.time>4:
self.taskMgr.remove('wait_task')
self.screen_fill.destroy()
self.menu()
return None
return task.cont
def menu(self):
# loading time
# music
self.menu_music=self.loader.loadSfx(str(MAINDIR)+'/Sound/deadmau5-cabin.mp3')
self.menu_music.setLoop(True)
self.menu_music.play()
# filters
try:
self.filters = CommonFilters(self.win, self.cam)
except: pass
self.Game_state.root_node.setAntialias(AntialiasAttrib.MAuto)
def quit():
sys.exit(0)
button_block_pos=(-1.2,0.35,0.25)
maps_start=loader.loadModel(str(MAINDIR)+'/Engine/start.egg')
maps_quit=loader.loadModel(str(MAINDIR)+'/Engine/quit.egg')
maps_set=loader.loadModel(str(MAINDIR)+'/Engine/set.egg')
self.start_button=DirectButton(pos=button_block_pos,frameColor=(0,0,0,0),scale=(0.717,0.4,0.221),geom=(maps_start.find('**/Start'),maps_start.find('**/Start_push'),maps_start.find('**/Start_on'),maps_start.find('**/Start')),command=self.loadgame)
self.quit_button=DirectButton(pos=(button_block_pos[0]+0.135,button_block_pos[1],button_block_pos[2]-0.4),frameColor=(0,0,0,0),scale=(1,0.4,0.221),geom=(maps_quit.find('**/Quit'),maps_quit.find('**/Quit_push'),maps_quit.find('**/Quit_on'),maps_quit.find('**/Quit')),command=quit)
self.settings_button=DirectButton(pos=(button_block_pos[0]-0.075,button_block_pos[1],button_block_pos[2]-0.2),frameColor=(0,0,0,0),scale=(0.56,0.4,0.221),geom=(maps_set.find('**/Set'),maps_set.find('**/Set_push'),maps_set.find('**/Set_on'),maps_set.find('**/Set')),command=self.not_implemented_yet) # settings not implemented yet
self.title_pic=OnscreenImage(image=str(MAINDIR)+'/Engine/title.png',pos=(0,0.35,0), scale=(0.51,1,0.5))
self.title_pic.setTransparency(TransparencyAttrib.MAlpha)
pannel_pos_x=1.25
self.activity_log=OnscreenImage(image=str(MAINDIR)+'/Engine/activity_log.png',pos=(pannel_pos_x,0.35,0.30),scale=(0.375,0.75,0.086775))
self.activity_log.setTransparency(TransparencyAttrib.MAlpha)
#self.activity_log_bg=OnscreenImage(image=str(MAINDIR)+'/Engine/activity_log_bg.png',pos=(pannel_pos_x,-0.35,-0.3),scale=(0.5,0.4,0.675))
#self.activity_log_bg.setTransparency(TransparencyAttrib.MAlpha)
#spaces compensate the center text effect
self.logs=OnscreenText(text=' PyOS v0.11 \n\n Added main menu in last update\n Particle support has now become reality\n but still needs some improvement\n\n\n Feature in progress:\n collision animation\n\n\nRelease date >>',pos=(pannel_pos_x-0.3,0.11,0.2), scale=(0.05,0.05,0.05),fg=(1,1,1,1))
self.shrug=OnscreenImage(image=str(MAINDIR)+'/Engine/shrug.png',pos=(pannel_pos_x-0.35,0.35,-0.48),scale=(0.1,1,0.0317))
self.shrug.setTransparency(TransparencyAttrib.MAlpha)
self.backgrnd=OnscreenImage(image=str(MAINDIR)+'/Engine/Stars.png',scale=(85.44,1,48),pos=(0,60,0))
self.backgrnd.reparentTo(self.Game_state.root_node)
#self.filters.set_gamma_adjust(0.9)
self.moon=self.loader.loadModel(str(MAINDIR)+"/Engine/Icy.egg")
self.moon.setScale(0.2,0.2,0.2)
self.moon.setPos(0,50,0) # radius of orbit equals 50 units
self.moon.reparentTo(self.Game_state.root_node)
self.intro_planet=self.loader.loadModel(str(MAINDIR)+"/Engine/tessena.egg")
self.intro_planet_atm=self.loader.loadModel(str(MAINDIR)+"/Engine/tessena_atm.egg")
self.intro_planet.setPos(0,-35,0)
self.intro_planet_atm.setPos(0,-35,0)
self.intro_planet.reparentTo(self.Game_state.root_node)
self.intro_planet_atm.reparentTo(self.Game_state.root_node)
self.intro_planet.setHpr(-110,0,0)
self.intro_planet_atm.setHpr(-110,0,0)
self.cam.setPos(0,-70,0)
self.disable_mouse()
# lighting
d=DirectionalLight('menu_dlight')
d.setColor(VBase4(0.631,0.369,1,1))
dlight=self.Game_state.root_node.attachNewNode(d)
dlight.setHpr(60,-30,0)
e=DirectionalLight('menu_dlight2')
e.setColor(VBase4(1,1,1,1))
elight=self.Game_state.root_node.attachNewNode(e)
elight.setHpr(60,-30,0)
self.moon.setLight(elight)
self.intro_planet.setLight(dlight)
self.intro_planet_atm.setLight(dlight)
self.task_mgr.add(self.rotate,'rotationtask') # penser a l'enlever
def rotate(self,task):
self.intro_planet.setHpr(self.intro_planet,(0.1,0,0))
self.intro_planet_atm.setHpr(self.intro_planet_atm,(0.07,0,0))
self.moon.setHpr(self.moon,(0.2,0,0))
self.moon.setPos(50*sin(task.time*0.02),50*cos(task.time*0.02),0)
return task.cont
# end of menu subfunctions
def loadgame(self):
# transition phase
self.menu_music.setLoop(False)
self.menu_music.stop()
self.taskMgr.remove('rotationtask')
self.cam.setPos(0,0,0)
self.Game_state.cleanup()
self.activity_log.hide()
#self.activity_log_bg.hide()
self.logs.hide()
self.shrug.hide()
self.start_button.hide()
self.quit_button.hide()
self.settings_button.hide()
self.title_pic.hide()
# end of transition phase
# Mouse parameters
self.hidden_mouse=True
wp = WindowProperties()
wp.setCursorHidden(self.hidden_mouse)
self.win.requestProperties(wp)
# preparing the menu text list:
quit_to_desk=self.loader.loadModel(str(MAINDIR)+"/Engine/quit_to_desktop.egg")
quit_to_menu=self.loader.loadModel(str(MAINDIR)+"/Engine/quit_to_menu.egg")
resume=self.loader.loadModel(str(MAINDIR)+"/Engine/resume.egg")
self.paused_menu_text=[]
global_tempPosx=-1
self.paused_menu_text.append(DirectButton(pos=(global_tempPosx-0.065,0,-0.2),frameColor=(0,0,0,0),scale=(1,0.4,0.211),geom=(quit_to_desk.find('**/quit_to_desktop'),quit_to_desk.find('**/quit_to_desktop_push'),quit_to_desk.find('**/quit_to_desktop_on'),quit_to_desk.find('**/quit_to_desktop')),command=self.system_break))
self.paused_menu_text.append(DirectButton(pos=(global_tempPosx,0,0),frameColor=(0,0,0,0),scale=(1.12,0.4,0.211),geom=(quit_to_menu.find('**/quit_to_menu'),quit_to_menu.find('**/quit_to_menu_push'),quit_to_menu.find('**/quit_to_menu_on'),quit_to_menu.find('**/quit_to_menu')),command=self.ingame_back_to_menu))
self.paused_menu_text.append(DirectButton(pos=(global_tempPosx-0.325,0,0.2),frameColor=(0,0,0,0),scale=(0.47,0.4,0.211),geom=(resume.find('**/resume'),resume.find('**/resume_push'),resume.find('**/resume_on'),resume.find('**/resume')),command=self.toggle_pause))
# btw I found something about energy transmission through thermal radiation. I think it uses some Boltzmann formula stuff. Link here:
# https://fr.wikibooks.org/wiki/Plan%C3%A9tologie/La_temp%C3%A9rature_de_surface_des_plan%C3%A8tes#Puissance_re%C3%A7ue_par_la_Terre
# Defining important data lists
# music imports (paths)
self.sounds=[str(MAINDIR)+"/Sound/001.mp3",
str(MAINDIR)+"/Sound/Blazing-Stars.mp3",
str(MAINDIR)+"/Sound/Cold-Moon.mp3",
str(MAINDIR)+"/Sound/Light-Years_v001.mp3",
str(MAINDIR)+"/Sound/The-Darkness-Below.mp3",
str(MAINDIR)+"/Sound/Retro-Sci-Fi-Planet.mp3",
str(MAINDIR)+"/Sound/droid-bishop-nightland.mp3",
str(MAINDIR)+"/Sound/interstellar-ost-03-dust-by-hans-zimmer.mp3",
str(MAINDIR)+"/Sound/interstellar-ost-04-day-one-by-hans-zimmer.mp3",
str(MAINDIR)+"/Sound/ascendant-remains-2015.mp3",
str(MAINDIR)+"/Sound/droid-bishop-nightland.mp3",
str(MAINDIR)+"/Sound/john-carpenter-utopian-facade-official-music-video.mp3",
str(MAINDIR)+"/Sound/stranger-things-2-eulogy.mp3",
str(MAINDIR)+"/Sound/interstellar-ost-07-the-wormhole-by-hans-zimmer.mp3"]
self.collision_solids=[] #collision related stuff - comments are useless - just RTFM
self.light_Mngr=[]
self.data=[
[0,0,0,-0.00,0.003,0,0.30,0.30,0.30,100000.00,True,[self.loader.loadModel(str(MAINDIR)+"/Engine/lp_planet_0.egg"),(0.1,0,0),self.loader.loadModel(str(MAINDIR)+"/Engine/lp_planet_1.egg"),(0.14,0,0)],"low_poly_planet01",False,0.1]
,[10,0,0,0,0.003,0,0.05,0.05,0.05,20.00,True,[self.loader.loadModel(str(MAINDIR)+"/Engine/Icy.egg"),(0.05,0,0)],"Ottilia_modified",False,0.1]
,[0,70,10,0,0.005,0,0.1,0.1,0.1,40.00,True,[self.loader.loadModel(str(MAINDIR)+"/Engine/asteroid_1.egg"),(0,0,0.2)],"Selena",False,1]
,[100,0,10,0,0,0,5,5,5,1000000,True,[self.loader.loadModel(str(MAINDIR)+"/Engine/sun1.egg"),(0.01,0,0),self.loader.loadModel(str(MAINDIR)+"/Engine/sun1_atm.egg"),(0.01,0,0)],"Sun",True,0.1]
,[-100,50,70,0,0,0.003,0.15,0.15,0.15,1000.00,True,[self.loader.loadModel(str(MAINDIR)+"/Engine/Earth2.egg"),(-0.1,0,0),self.loader.loadModel(str(MAINDIR)+"/Engine/Earth2_atm.egg"),(-0.15,0,0)],"big_fucking_planet",False,0.1]
,[200,0,0,-0.001,0,0.01,0.1,0.1,0.1,100000,False,[self.loader.loadModel(MAINDIR+"/Engine/realistic_asteroid.egg"),(0,0.01,0)],"spaceship",False,0]
,[0,-120,0,0.004,0,0,0.3,0.3,0.3,100000,True,[self.loader.loadModel(str(MAINDIR)+"/Engine/FG1.egg"),(0.01,0,0),self.loader.loadModel(str(MAINDIR)+"/Engine/FG2.egg"),(0.01,0,0),self.loader.loadModel(str(MAINDIR)+"/Engine/FG3.egg"),(0.01,0,0),self.loader.loadModel(str(MAINDIR)+"/Engine/FG4.egg"),(0.01,0,0),self.loader.loadModel(str(MAINDIR)+"/Engine/FG5.egg"),(0.01,0,0)],"Frozen_giant",False,0.1]
# insert your 3d models here, following the syntax (this is the default scene that will be loaded on startup)
]
# the correct reading syntax is [x,y,z,l,m,n,scale1,scale2,scale3,mass,static,[file,(H,p,r),file,(H,p,r)...],id,lightsource,brakeforce] for each body - x,y,z: position - l,m,n: speed - scale1,scale2,scale3: obvious (x,y,z) - mass: kg - static: boolean - [files]: panda3d readfiles list (first file must be the ground, the others are atmosphere models)
#id: str - lightsource: boolean -
#if you want the hitbox to be correctly scaled,and your body to have reasonable proportions, your 3d model must be a 5*5 sphere, or at least have these proportions
# create the real data list, the one used by the program
self.bodies=[]
for c in self.data:
temp=body()
temp.fill_entries(c)
self.bodies.append(temp)
temp=None
#self.bodies.reverse()
# Quick presetting
self.setBackgroundColor(0,0,0,True)
# enable particles
self.enableParticles()
self.toggle_particles() # debug
# create particle class object
self.particle=particle()
# intialize object:
self.particle.config_path='/Engine/destruction_sphere.ptf' # the MAINDIR is already included inside the class definition
# non-body type structures loading
if SKYBOX=='sky':
self.isphere=self.loader.loadModel(str(MAINDIR)+"/Engine/InvertedSphere.egg") #loading skybox structure
self.tex=loader.loadCubeMap(str(MAINDIR)+'/Engine/Skybox4/skybox_#.png')
elif SKYBOX=='arena':
self.box=self.loader.loadModel(str(MAINDIR)+"/Engine/arena.egg")
#load shaders (optionnal)
'''
sun_shader=Shader.load(Shader.SLGLSL,MAINDIR+'/Engine/Shaders/flare_v.glsl',MAINDIR+'/Engine/Shaders/flare_f.glsl')
'''
self.camLens.setNearFar(0.5, 100000)
self.orbit_lines=[] #under developement
# see https://www.panda3d.org/manual/?title=Collision_Solids for further collision interaction informations
base.graphicsEngine.openWindows()
try:
print('\n[Loader manager]:\n')
'''
self.filters.setBlurSharpen(amount=0) # just messing around
'''
if not self.debug:
self.filters.set_gamma_adjust(1.0) # can be usefull
self.filters.set_bloom(intensity=1,size="medium")
for c in self.bodies: # loading and displaying the preloaded planets and bodies
if c.is_lightSource and not self.debug:
# VM filtering
self.filters.setVolumetricLighting(c.filelist[0],numsamples=50,density=0.5,decay=0.95,exposure=0.035)
#c.filelist[u].set_shader(sun_shader)
if BLUR: self.filters.setCartoonInk()
for u in range(0,len(c.filelist),2): # loading each sub-file
c.filelist[u].reparentTo(self.Game_state.root_node)
c.filelist[u].setScale(tuple(c.scale))
c.filelist[u].setPos(tuple(c.position))
if u==0 and not(c.is_lightSource):
c.filelist[u].setShaderAuto() #activate auto shading for compact, non translucent bodies
#setting the collision solid up
temp=hitbox()
temp.Volume=CollisionSphere(0,0,0,self.u_radius)
temp.NodePath=c.filelist[0].attachNewNode(CollisionNode(c.id))
temp.CollisionNode=temp.NodePath.node()
self.collision_solids.append(temp) #the radius is calculated by using the average scale + the self.u_radius
# the structure of the collision_solids list will be: [temp1,temp2,...]
# asteroids and irregular shapes must be slightly bigger than their hitbox in order to avoid visual glitches
self.collision_solids[len(self.collision_solids)-1].CollisionNode.addSolid(self.collision_solids[len(self.collision_solids)-1].Volume) #I am definitely not explaining that
temp=None
if self.debug:
loadPrcFileData("", "show-frame-rate-meter 1")
self.collision_solids[len(self.collision_solids)-1].NodePath.show() # debugging purposes only
print("collision: ok")
print("placing body: done")
if c.is_lightSource:
self.light_Mngr.append([PointLight(c.id+"_other")])
self.light_Mngr[len(self.light_Mngr)-1].append(self.Game_state.root_node.attachNewNode(self.light_Mngr[len(self.light_Mngr)-1][0]))
self.light_Mngr[len(self.light_Mngr)-1][1].setPos(tuple(c.position))
# shadow stuff
self.light_Mngr[len(self.light_Mngr)-1][1].node().setShadowCaster(True)
'''
self.light_Mngr[len(self.light_Mngr)-1][1].node().getLens().setFov(40)
self.light_Mngr[len(self.light_Mngr)-1][1].node().getLens().setNearFar(10, 100)
'''
self.Game_state.root_node.setLight(self.light_Mngr[len(self.light_Mngr)-1][1])
self.light_Mngr.append([AmbientLight(c.id+"_self")])
self.light_Mngr[len(self.light_Mngr)-1][0].setColorTemperature(3000)
self.light_Mngr[len(self.light_Mngr)-1].append(self.Game_state.root_node.attachNewNode(self.light_Mngr[len(self.light_Mngr)-1][0]))
for u in range(0,len(c.filelist),2):
c.filelist[u].setLight(self.light_Mngr[len(self.light_Mngr)-1][1])
print("lights: done")
else:
self.light_Mngr.append([]) #create an empty list, so that the coordinates of the data in the list is the same as in self.bodies (easier for further analysis and potential deletion)
self.light_Mngr.append([])
print("loaded new body, out: done")
if SKYBOX=='sky':
self.isphere.setTexGen(TextureStage.getDefault(), TexGenAttrib.MWorldCubeMap) # *takes a deep breath* cubemap stuff !
self.isphere.setTexProjector(TextureStage.getDefault(), self.Game_state.root_node, self.isphere)
self.isphere.setTexPos(TextureStage.getDefault(), 0, 0, 0)
self.isphere.setTexScale(TextureStage.getDefault(), .5) # that's a thing...
self.isphere.setTexture(self.tex)# Create some 3D texture coordinates on the sphere. For more info on this, check the Panda3D manual.
self.isphere.setLightOff()
self.isphere.setScale(10000) #hope this is enough
self.isphere.reparentTo(self.Game_state.root_node)
elif SKYBOX=='arena':
self.box.setPos(0,0,0)
self.box.setScale(100)
self.box.reparentTo(self.Game_state.root_node)
# collision traverser and other collision stuff # that's super important, and super tricky to explain so just check the wiki
self.ctrav = CollisionTraverser()
self.queue = CollisionHandlerQueue()
for n in self.collision_solids:
self.ctrav.add_collider(n.NodePath,self.queue)
# the traverser will be automatically updated, no need to repeat this every frame
# debugging only
if self.debug:
self.ctrav.showCollisions(self.Game_state.root_node)
# play a random music
self.current_playing=random.randint(0,len(self.sounds)-1)
self.current_song=self.loader.loadSfx(self.sounds[self.current_playing])
self.current_song.play()
# task manager stuff comes here
self.intro_loop()
except:
sys.exit(":( something went wrong: files could not be loaded")
# key bindings
self.accept('escape',self.toggle_pause)
self.accept('mouse1',self.handle_select,[True])
self.accept('wheel_up',self.handle_scrolling,[True]) # center button (just a quick test)
self.accept('wheel_down',self.handle_scrolling,[False])
self.accept('z',self.move_camera,[0,True])
self.accept('q',self.move_camera,[1,True])
self.accept('s',self.move_camera,[2,True])
self.accept('d',self.move_camera,[3,True])
self.accept('a',self.move_camera,[4,True])
self.accept('e',self.move_camera,[5,True])
self.accept('arrow_right',self.time_change,[True])
self.accept('arrow_left',self.time_change,[False])
self.accept('z-up',self.move_camera,[0,False])
self.accept('q-up',self.move_camera,[1,False])
self.accept('s-up',self.move_camera,[2,False])
self.accept('d-up',self.move_camera,[3,False])
self.accept('a-up',self.move_camera,[4,False])
self.accept('e-up',self.move_camera,[5,False])
self.keymap=['z',0,'q',0,'s',0,'d',0,'a',0,'e',0,'mouse1',0]
if self.debug:
# draw axis
coord=[(1,0,0),(0,1,0),(0,0,1)]
axis=[]
for c in range(3):
axis.append(LineSegs())
axis[c].moveTo(0,0,0)
axis[c].drawTo(coord[c])
axis[c].setThickness(3)
axis[c].setColor(tuple([coord[c][u]*255 for u in range(len(coord[c]))] +[True]))
NodePath(axis[c].create()).reparent_to(self.Game_state.root_node)
# camera positionning -------
self.focus_point=[0,0,0] # point focused: can become a body's coordinates if the user tells the program to do so
self.zoom_distance=30 # distance to the focus point in common 3D units (can be modified by scrolling)
self.cam_Hpr=[0,0,0] # phi, alpha, theta - aka yaw, pitch, roll
self.cam_Hpr=[self.cam_Hpr[n]*pi/180 for n in range(len(self.cam_Hpr))] # convert to rad
phi,alpha,theta,zoom,object=self.cam_Hpr[0]*pi/180,self.cam_Hpr[1]*pi/180,self.cam_Hpr[2]*pi/180,self.zoom_distance,self.state[2] # temporary vars
if self.state[1]=='free':
self.camera_pos=[0,0,0]
self.camera.setPos(tuple(self.camera_pos))
elif self.state[1]=='linked':
# find the object (self.state[2]) in the data list
list_pos=[self.bodies[n].filelist[0] for n in range(len(self.bodies))].index(object.getParent())
self.focus_point=self.bodies[list_pos].position # take the focused object's coordinates
self.camera_pos=[self.focus_point[0]+sin(phi)*cos(-alpha)*zoom,self.focus_point[1]-cos(phi)*cos(-alpha)*zoom,self.focus_point[2]+sin(-alpha)*zoom] #keep it up to date so that it's not hard to find whend switching modes
self.camera.setPos(tuple(self.camera_pos))
self.camera.setHpr(self.cam_Hpr)
# cursor
self.cursor=self.showsimpletext('.',(0,0),(0.08,0.08),None,(1,1,1,True)) # yeah, you can laugh, but this still works so I don't care
self.pointerNode=CollisionNode('cursor')
self.pointerNP=camera.attachNewNode(self.pointerNode)
self.pointerNode.setFromCollideMask(BitMask32.bit(1)) # separate collisions (in order to avoid mistakes during physical calculations)
self.cursor_ray=CollisionRay() # create the mouse control ray
self.pointerNode.addSolid(self.cursor_ray)
self.ctrav.add_collider(self.pointerNP,self.queue)
#self.screen_fill.destroy() # delete the displayed picture
return None
def showsimpletext(self,content,pos,scale,bg,fg): #shows a predefined, basic text on the screen (variable output only)
return OnscreenText(text=content,pos=pos,scale=scale,bg=bg,fg=fg)
def intro_loop(self):
self.taskMgr.add(self.mouse_check,'mousePositionTask')
self.taskMgr.add(self.placement_Mngr,'frameUpdateTask')
self.taskMgr.add(self.Sound_Mngr,'MusicHandle')
self.taskMgr.add(self.camera_update,'cameraPosition')
self.taskMgr.remove('showIntroPic')
return None
def placement_Mngr(self,task): # void main = main game mechanics, frame updating function (kinda, all pausing and menu functions must be applied here)
if self.state[0]=='running' or not task.time:
self.ctrav.traverse(self.Game_state.root_node)
#self.queue = CollisionHandlerQueue() # update the collision queue
brakeforce=[0 for n in range(len(self.bodies))] # create an empty brakeforce list
if self.queue.getNumEntries():
if self.debug:
print(self.queue.getNumEntries()) # debug, shows only one digit most of the time
# now we have to create a temp list containing only the Entries that refer to collisions between bodies,
# not cursor-type collisions:
temp1,temp2=[],[]
for count in range(len(self.queue.getEntries())):
if self.queue.getEntries()[count].getFromNodePath()!=self.pointerNP: temp1.append(self.queue.getEntries()[count])
else: temp2.append(self.queue.getEntries()[count])
# the temp1 and temp2 lists have been created
# run the check for the body-with-body collisions
if len(temp1)>len(self.stored_collisions):
print('[WARNING]: New collision') # debugging , detects when a collision occurs AND IT F*****G WORKS BITCH !! (actually I created this system so that the particles linked to the collision are only created once)
self.particle.add_particle(temp1[len(self.stored_collisions):])
#b=len(temp1[self.stored_collisions:len(temp1)])
for x in temp1[len(self.stored_collisions):]:
self.particle.activate(x.getIntoNodePath().getParent(),self.Game_state.root_node)
elif len(temp1)<len(self.stored_collisions):
print('Collision ended')
a=self.stored_collisions[len(temp1):]
for x in a:
self.particle.deactivate(x.getIntoNodePath().getParent())
self.particle.deactivate(x.getFromNodePath().getParent())
# at this point we should probably delete the particle object, as if we don't, it might still be updated, even if the collision doesn't exist in the self.queue anymore
self.stored_collisions=temp1 #else do nothing
for c in range(0,len(temp1),2):
entry=temp1[c]
brakeforce=self.collision_log(entry,brakeforce)
# run the check for the cursor-with-body collisions
for c in range(len(temp2)):
entry=temp2[c]
self.watched=entry.getIntoNodePath()
# print "out"
# update the collider list
self.ctrav.clear_colliders()
self.queue = CollisionHandlerQueue()
for n in self.collision_solids:
self.ctrav.add_collider(n.NodePath,self.queue)
self.ctrav.add_collider(self.pointerNP,self.queue) # add the cursor ray again
else:
self.watched=None
# collision events are now under constant surveillance
acceleration=[]
for c in range(len(self.bodies)): #selects the analysed body
var=self.bodies[c]
Bdf=[0,0,0] #Bdf stands for 'bilan des forces' in french, it's the resulting acceleration
for d in self.bodies[0:c]+self.bodies[c+1:len(self.bodies)-1]: #selects the body which action on the analysed body we're studying...not sure about that english sentence though
S,M=[d.mass]+d.position,[var.mass]+var.position
temp=self.dual_a(S,M)
Bdf=[Bdf[x]+temp[x] for x in range(3)] # list sum
# add the result to the global save list
acceleration.append(Bdf)
#update the bodies' position
self.speed_update(acceleration,brakeforce)
self.pos_update()
self.apply_update()
elif self.state[0]=='paused':
self.handle_menu(self.iteration)
self.iteration+=1
return task.cont
def speed_update(self,a,brakeforce):
for c in range(len(self.bodies)): #the function updates the speed tuple accordingly
self.bodies[c].speed[0]+=self.timescale*a[c][0]
#self.bodies[c].speed[0]/=brakeforce[c]+1 # aero/lytho braking has to be applied to the colliding object
# actually, speed isn't applied that way
self.bodies[c].speed[1]+=self.timescale*a[c][1]
#self.bodies[c].speed[1]/=brakeforce[c]+1
self.bodies[c].speed[2]+=self.timescale*a[c][2]
#self.bodies[c].speed[2]/=brakeforce[c]+1
return 0
def pos_update(self): #updates the positional coordinates
for c in range(len(self.bodies)):
self.bodies[c].position[0]+=self.timescale*self.bodies[c].speed[0]
self.bodies[c].position[1]+=self.timescale*self.bodies[c].speed[1]
self.bodies[c].position[2]+=self.timescale*self.bodies[c].speed[2]
return 0
def apply_update(self): #actually moves the hole 3d stuff around
count=0 #local counter
for c in self.bodies:
for u in range(len(c.filelist)):
if u%2!=0:
c.filelist[u-1].setHpr(c.filelist[u-1],tuple([self.timescale*i for i in c.filelist[u]]))
else:
c.filelist[u].setPos(tuple(c.position))
if c.is_lightSource:
self.light_Mngr[count][1].setPos(tuple(c.position))
count+=2
return 0
def camera_update(self,task):
phi,alpha,theta,zoom,object=self.cam_Hpr[0]*pi/180,self.cam_Hpr[1]*pi/180,self.cam_Hpr[2]*pi/180,self.zoom_distance,self.state[2]
if self.state[1]=='free':
self.camera.setPos(tuple(self.camera_pos))
elif self.state[1]=='linked':
# find the object (self.state[2]) in the data list
list_pos=[self.bodies[n].filelist[0] for n in range(len(self.bodies))].index(object.getParent())
self.focus_point=self.bodies[list_pos].position # take the focused object's coordinates
self.camera_pos=[self.focus_point[0]+sin(phi)*cos(-alpha)*zoom,self.focus_point[1]-cos(phi)*cos(-alpha)*zoom,self.focus_point[2]+sin(-alpha)*zoom]
self.camera.setPos(tuple(self.camera_pos))
self.camera.setHpr(tuple(self.cam_Hpr))
# collision cursor stuff goes here:
self.cursor_ray.setFromLens(self.camNode,0,0)
# relatively to the camera, the cursor position will always be 0,0 which is the position of the
# white point on the screen
if self.keymap!=['z',0,'q',0,'s',0,'d',0]:
for x in range(1,len(self.keymap),2):
if self.keymap[x]:
self.move_camera(int((x-1)/2),True) # why (x-1)/2 ? because we have to make the tow readable as a key number, like 0,1,2,3
return task.cont
def dual_a(self,S,M): #S is the "static object", the one that applies the force to the "moving" object M
O=[] #This will be the list with the accelerations for an object
d=sqrt((S[1]-M[1])**2+(S[2]-M[2])**2+(S[3]-M[3])**2)
x=(self.u_constant*S[0]*(S[1]-M[1]))/d**2
y=(self.u_constant*S[0]*(S[2]-M[2]))/d**2
z=(self.u_constant*S[0]*(S[3]-M[3]))/d**2
O.append(x)
O.append(y)
O.append(z)
return O
def collision_log(self,entry,brakeforce):
from_pos=[self.bodies[n].filelist[0] for n in range(len(self.bodies))].index(entry.getFromNodePath().getParent())
into_pos=[self.bodies[n].filelist[0] for n in range(len(self.bodies))].index(entry.getIntoNodePath().getParent()) #find the nodepath in the list
f_radius=sum(self.bodies[from_pos].scale)*self.u_radius/3
i_radius=sum(self.bodies[into_pos].scale)*self.u_radius/3
if max(f_radius,i_radius)==f_radius:
inverted=True
into_pos,from_pos=from_pos,into_pos
else:
inverted=False # currently useless
brakeforce[from_pos]=self.bodies[from_pos].brakeforce # get the force given in the data list
# those are the two positions of the nodepaths, now we need to know which one is bigger, in order to obtain the fusion effect
# from_pos is the smaller body, into_pos is the bigger one
self.collision_gfx(self.momentum_transfer(from_pos,into_pos,entry,inverted),f_radius,i_radius) #some useless data remains from version 0.9
return brakeforce
def momentum_transfer(self,f_pos,i_pos,entry,inverted):
if self.debug:
print("colliding") # debug, makes the game laggy (only activated when the self.debug var is on)
interior = entry.getInteriorPoint(self.Game_state.root_node) # default
surface = entry.getSurfacePoint(self.Game_state.root_node)
if self.debug:
print((interior - surface).length()) # debug, doesn't slow the game down too much so I haven't removed it
if (interior - surface).length() >= self.u_radius*2*sum(self.bodies[f_pos].scale)/3: # this is the body deletion routine
if self.state[2]==self.collision_solids[f_pos].NodePath:
self.state[1]='free'
self.state[2]=None
# Lighting
if self.bodies[f_pos].is_lightSource:
self.Game_state.root_node.clearLight(self.light_Mngr[2*f_pos][1])
self.Game_state.root_node.clearLight(self.light_Mngr[2*f_pos][1])
self.filters.delVolumetricLighting() #temp
self.ctrav.remove_collider(self.collision_solids[f_pos].NodePath)
self.bodies[f_pos].delete_body()
self.bodies[i_pos].scale[0]*=(self.bodies[i_pos].mass+self.bodies[f_pos].mass)/self.bodies[i_pos].mass
self.bodies[i_pos].scale[1]*=(self.bodies[i_pos].mass+self.bodies[f_pos].mass)/self.bodies[i_pos].mass
self.bodies[i_pos].scale[2]*=(self.bodies[i_pos].mass+self.bodies[f_pos].mass)/self.bodies[i_pos].mass
self.bodies[i_pos].mass+=self.bodies[f_pos].mass
# particle deletion
self.particle.deactivate(self.collision_solids[f_pos].NodePath.getParent())
self.particle.deactivate(self.collision_solids[i_pos].NodePath.getParent())
# scale updating ()
''' temporarly removed
for c in range(0,len(self.bodies[i_pos].filelist),2):
self.bodies[i_pos].filelist[c].setScale(tuple(self.bodies[i_pos].scale))
'''
# deleting the destroyed planet's data
self.bodies=self.bodies[:f_pos]+self.bodies[f_pos+1:len(self.bodies)]
self.collision_solids=self.collision_solids[:f_pos]+self.collision_solids[f_pos+1:len(self.collision_solids)]
# update the light list
self.light_Mngr=self.light_Mngr[:2*f_pos]+self.light_Mngr[2*f_pos+2:len(self.light_Mngr)]
# just a quick test
if self.debug:
self.ctrav.showCollisions(self.Game_state.root_node)
if self.debug:
print("planet destroyed")
return interior,surface # used for the collision gfx calculations
def printScene(self): #debug
file=open("scenegraph.txt","a")
ls = LineStream()
self.Game_state.root_node.ls(ls)
while ls.isTextAvailable():
file.write(ls.getLine())
file.write("\n")
file.write("\n")
file.write("END\n")
file.write("\n")
file.close()
def Sound_Mngr(self,task):
if self.current_song.length()-self.current_song.getTime()==0: #could have just used not()
self.current_playing=random.choice(list(range(0,self.current_playing))+list(range(self.current_playing+1,len(self.sounds))))
self.current_song=self.loader.loadSfx(self.sounds[self.current_playing])
self.current_song.play()
print(self.current_playing)
return task.cont
def collision_gfx(self,points,Rf,Ri): # collision animation calculations
# section size calculation
# we know the depth of penetration (no silly jokes please), which allows us, knowing the radius of each body,
# to calculate the radius of the section (I've got no idea how to say that in correct english)
# the display of the particles all over this circle will be a piece of cake (at least I hope so) - edit - it wasn't
# see documents in the screenshot folder for more informations about the maths
'''
interior,surface=points[0],points[1]
p=(interior - surface).length()
p2=(p**2-2*Ri*p)/(2*Ri-2*p-2*Rf)
p1=p-p2
''' #currently useless
self.update_particle_pos()
# now we know everything about our impact section (the circle that defines the contact between the two bodies)
# we just have to find the coord of the circle's center: we will take the surfacepoint impact point
return 0
def create_crater(self): # see project for more informations
return None
def toggle_pause(self):
self.toggle_particles() # pause the particles
temp=['paused','running']
self.state[0]=temp[self.state[0]==temp[0]] # switches between paused and running
self.iteration=0
if self.state[0]=='paused':
# discord rpc updating
try:
RPC.update(state="Version: 0.11", details="In the menus",large_image="logo",small_image=None)
except: pass
self.handle_menu(self.iteration)
else:
# discord RPC updating
try:
RPC.update(state="Version: 0.11", details="In a simulation",large_image="logo",small_image=None)
except: pass
self.filters.del_blur_sharpen()
self.filters.set_gamma_adjust(1)
# make the mouse invisible
self.hidden_mouse=True
wp = WindowProperties()
wp.setCursorHidden(self.hidden_mouse)
# set the mouse pos to 0
self.center_mouse()
self.win.requestProperties(wp)
for u in self.paused_menu_text:
u.hide()
return None
def handle_menu(self,iteration):
if not iteration:
self.accept('escape',self.toggle_pause)
self.draw_menu()
# make the mouse visible
self.hidden_mouse=False
wp = WindowProperties()
wp.setCursorHidden(self.hidden_mouse)
self.win.requestProperties(wp)
else:
a=1 # indentation (temporary)
#put your mouse detection stuff here
# menu stuff
# menu stuff
# please use directGui for that purpose (better rendering performances)
# the menu doesn't actually work, as the whole clicking reaction routine is not implemented
return None
def draw_menu(self):
self.filters.setBlurSharpen(amount=0)
self.filters.set_gamma_adjust(1.7)
for u in self.paused_menu_text:
u.show()
return None
def show_credits(self):
print("created by l3alr0g, zudo and Fang (at least this part) --> I'll do something better later")
return None
def system_break(self):
# place your data saving routines here
print("system exit successful, data saved")
print("executing sys.exit()")
print("out: done")
sys.exit(0)
return None
def handle_scrolling(self,up): # up is a boolean: up=True means up, up=False means down
if up and self.state[0]=='running':
if self.state[1]=='linked':
self.zoom_distance*=0.95
else:
self.camera_delta*=1.1
elif not up and self.state[0]=='running':
if self.state[1]=='linked':
self.zoom_distance/=0.95
else:
self.camera_delta/=1.1
return None
def rotate_camera(self):
self.camera.setHpr(tuple(self.cam_Hpr))
return None
def move_camera(self,tow,pressed): # tow stands for towards, pressed is a boolean which indicates the state of the key
if pressed:
self.keymap[2*tow+1]=1
self.state[1]='free'
#print('free mode on')
self.state[2]=None
else:
self.keymap[2*tow+1]=0
if self.keymap[2*tow+1]:
phi,alpha,theta,delta,zoom=self.cam_Hpr[0]*pi/180,self.cam_Hpr[1]*pi/180,self.cam_Hpr[2]*pi/180,self.camera_delta,self.zoom_distance
if self.keymap[2*tow]=='q':
if self.state[1]=='free':
self.camera_pos=[self.camera_pos[0]-cos(phi)*cos(theta)*delta,self.camera_pos[1]-sin(phi)*cos(theta)*delta,self.camera_pos[2]+sin(theta)*delta] # moving the camera
if self.keymap[2*tow]=='z':
if self.state[1]=='free':
self.camera_pos=[self.camera_pos[0]-sin(phi)*cos(alpha)*delta,self.camera_pos[1]+cos(phi)*cos(alpha)*delta,self.camera_pos[2]+sin(alpha)*delta]
if self.keymap[2*tow]=='s':
if self.state[1]=='free':
self.camera_pos=[self.camera_pos[0]+sin(phi)*cos(alpha)*delta,self.camera_pos[1]-cos(phi)*cos(alpha)*delta,self.camera_pos[2]-sin(alpha)*delta]
if self.keymap[2*tow]=='d':
if self.state[1]=='free':
self.camera_pos=[self.camera_pos[0]+cos(phi)*cos(theta)*delta,self.camera_pos[1]+sin(phi)*cos(theta)*delta,self.camera_pos[2]-sin(theta)*delta]
if self.keymap[2*tow]=='a':
self.cam_Hpr[2]-=1
if self.keymap[2*tow]=='e':
self.cam_Hpr[2]+=1
return None
def mouse_check(self,task): # gets the mouse's coordinates
mwn = self.mouseWatcherNode
if mwn.hasMouse():
x,y=mwn.getMouseX(),mwn.getMouseY()
#print(x,y) # debug
# focus_point coordinates modifier code here:
if self.state==['running','free',None]:
self.cam_Hpr[0]-=x*self.sensitivity_x # the - fixes a bug I can't solve
# sensitivity is a coefficient used for mouse displacement routines
self.cam_Hpr[1]+=y*self.sensitivity_y # those formulas do not work when theta (self.cam_Hpr[2]) changes
self.rotate_camera()
self.center_mouse()
elif self.state[0]=='running' and self.state[1]=='linked':
self.cam_Hpr[0]-=x*self.sensitivity_x
self.cam_Hpr[1]-=y*self.sensitivity_y
self.rotate_camera()
self.center_mouse()
'''
if self.debug:
print(self.cam_Hpr,self.camera_pos) # debug
'''
return task.cont
def center_mouse(self):
self.win.movePointer(0,
int(self.win.getProperties().getXSize() / 2),
int(self.win.getProperties().getYSize() / 2)) # move mouse back to center --> careful ! this makes the delta calculation code buggy
def handle_select(self,is_clicked):
if is_clicked and self.watched!=None:
self.state[1]='linked' # toggle following mode
self.state[2]=self.watched
print('linked mode on, focusing: ',self.watched)
#else: # do nothing actually
return None
def update_particle_pos(self): # harder than I thought
for x in range(len(self.particle.particle_list)):
a=[i.getIntoNodePath() for i in self.queue.getEntries()].index(self.particle.particle_list[x][1]) # finding the intonodepath inside self.queue.getEntries()
self.particle.particle_list[x][0].setPos(self.queue.getEntries()[a].getSurfacePoint(self.Game_state.root_node)) # all particles are being displaced to the position of the surface impact point
tempvar=self.queue.getEntries()[a].getSurfacePoint(self.Game_state.root_node) - self.queue.getEntries()[a].getIntoNodePath().getParent().getPos()
H,P,R=-atan(tempvar[0]/tempvar[1])*180/pi+180,(-atan(tempvar[2]/tempvar[1])+pi/2)*180/pi,0
self.particle.particle_list[x][0].setHpr(H,P,R)
# self.queue.getEntries()[a].getIntoNodePath().getParent().getPos()
# +self.queue.getEntries()[a].getSurfacePoint(self.queue.getEntries()[a].getIntoNodePath())
return None
def time_change(self,income): # income is a boolean, True means speed up, False means speed down
if income:
self.timescale*=1.2
else:
self.timescale*=0.80
return None
def not_implemented_yet(self): # comes with self.follow function
self.sign=OnscreenImage(image=str(MAINDIR)+"/Engine/not_implemented_yet.png",pos=(0,0,0),scale=(0.5,0.5,0.5)) # scale is useless: already at scale (the pic is square shaped)
self.sign.setTransparency(TransparencyAttrib.MAlpha)
self.accept("escape",self.follow)
self.quit_button['state']=DGG.DISABLED
self.settings_button['state']=DGG.DISABLED
self.start_button['state']=DGG.DISABLED
return None
def follow(self): # dependencies of the not_implemented_yet function
self.ignore("escape")
self.sign.destroy()
self.quit_button['state']=DGG.NORMAL
self.settings_button['state']=DGG.NORMAL
self.start_button['state']=DGG.NORMAL
return None
def easter_egg(self):
return "please be patient, our hens are working on it" # I am not responsible for the bad quality of my humor
def ingame_back_to_menu(self): # large name, I know, I had no ideas
self.filters.set_gamma_adjust(1)
for u in self.paused_menu_text:
u.hide()
self.filters.del_blur_sharpen()
self.Game_state.cleanup()
# we have to delete all the taskManager routines we implemented during the simulation
# here comes the whole stuff:
self.taskMgr.remove('mousePositionTask')
self.taskMgr.remove('frameUpdateTask')
self.taskMgr.remove('MusicHandle')
self.taskMgr.remove('cameraPosition')
# end of task manager stuff
self.stored_collisions=[]
self.watched=None
self.state=['paused','free',None]
self.iteration=0
self.filters.delVolumetricLighting() # temporary, as I have to implement multiple light source handling
# music
self.current_song.stop()
self.menu()
return None
class miniMap(object):
def __init__(self, mainActor):
self.teamMateImage = 'models/teamMate.png'
self.heroImage = 'models/mainHero.png'
self.miniMapImage = 'models/miniMapImage.png'
self.map = OnscreenImage(image = self.miniMapImage, pos=(-1, 0, 0.6),
scale=(0.3, 0.3, 0.3))
self.map.setTransparency(1)
self.hero = OnscreenImage(image=self.heroImage, pos=(mainActor.getX()/200, 0, mainActor.getY()/100),
scale=(0.045, 0.045, 0.045),
hpr=(0, 0, mainActor.getH()))
self.hero.reparentTo(self.map)
self.hero.setTransparency(1)
self.npc = {}
self.team = {}
def setMap(self, mapScale, x, y):
map = OnscreenImage(image = self.miniMapImage, pos=(x, 0, y),
scale=(mapScale, mapScale, mapScale))
return map
def setHero(self, heroScale, x, y, h):
hero = OnscreenImage(image=self.heroImage, pos=(x, 0, y),
scale=(heroScale, heroScale, heroScale),
hpr=(0, 0, h))
return hero
def setNpc(self, npcName, npcImage, npcScale, x, y):
self.Nps = OnscreenImage(image=npcImage, pos=(x, 0, y),
scale=(npcScale, npcScale, npcScale))
self.Nps.reparentTo(self.map)
self.Nps.setTransparency(1)
self.npc[npcName] = self.Nps
return self.npc
def delNpc(self, npcName):
del self.npc[npcName]
def setTeamMate(self, mateName, mateScale, getX, getY):
ay = ((70+(getY))*100)/120
y = -1+(ay*2)/100
ax = ((127+(getX))*100)/172
x = -1+(ax*2)/100
self.teamMate = OnscreenImage(image=self.teamMateImage,
pos=(x, 0, y),
scale=(mateScale, mateScale, mateScale))
self.teamMate.reparentTo(self.map)
self.teamMate.setTransparency(1)
self.team[mateName] = self.teamMate
return self.team
def delTeamMate(self, mateName):
del self.team[mateName]
def updateHeroPos(self, getX, getY):
ay = ((70+(getY))*100)/120
y = -1+(ay*2)/100
ax = ((127+(getX))*100)/172
x = -1+(ax*2)/100
self.hero.setPos(x, 0, y)
def updateHeroHpr(self, getH):
h = -getH
self.hero.setHpr(0, 0, h)
def updateTeamMatePos(self, mateName, getX, getY):
ay = ((70+(getY))*100)/120
y = -1+(ay*2)/100
ax = ((127+(getX))*100)/172
x = -1+(ax*2)/100
self.team[mateName].setPos(x, 0, y)
def updateTeamMateHpr(self, mateName, getH):
h = -getH
self.team[mateName].setHpr(0, 0, h)
def changeTowerColor(self, npcName, toverImage):
self.npc[npcName].setImage(toverImage)
class miniMap(object):
def __init__(self, mainActor):
self.teamMateImage = 'models/teamMate.png'
self.heroImage = 'models/mainHero.png'
self.miniMapImage = 'models/miniMapImage.png'
self.map = OnscreenImage(image=self.miniMapImage,
pos=(-1, 0, 0.6),
scale=(0.3, 0.3, 0.3))
self.map.setTransparency(1)
self.hero = OnscreenImage(image=self.heroImage,
pos=(mainActor.getX() / 200, 0,
mainActor.getY() / 100),
scale=(0.045, 0.045, 0.045),
hpr=(0, 0, mainActor.getH()))
self.hero.reparentTo(self.map)
self.hero.setTransparency(1)
self.npc = {}
self.team = {}
def setMap(self, mapScale, x, y):
map = OnscreenImage(image=self.miniMapImage,
pos=(x, 0, y),
scale=(mapScale, mapScale, mapScale))
return map
def setHero(self, heroScale, x, y, h):
hero = OnscreenImage(image=self.heroImage,
pos=(x, 0, y),
scale=(heroScale, heroScale, heroScale),
hpr=(0, 0, h))
return hero
def setNpc(self, npcName, npcImage, npcScale, x, y):
self.Nps = OnscreenImage(image=npcImage,
pos=(x, 0, y),
scale=(npcScale, npcScale, npcScale))
self.Nps.reparentTo(self.map)
self.Nps.setTransparency(1)
self.npc[npcName] = self.Nps
return self.npc
def delNpc(self, npcName):
del self.npc[npcName]
def setTeamMate(self, mateName, mateScale, getX, getY):
ay = ((70 + (getY)) * 100) / 120
y = -1 + (ay * 2) / 100
ax = ((127 + (getX)) * 100) / 172
x = -1 + (ax * 2) / 100
self.teamMate = OnscreenImage(image=self.teamMateImage,
pos=(x, 0, y),
scale=(mateScale, mateScale, mateScale))
self.teamMate.reparentTo(self.map)
self.teamMate.setTransparency(1)
self.team[mateName] = self.teamMate
return self.team
def delTeamMate(self, mateName):
del self.team[mateName]
def updateHeroPos(self, getX, getY):
ay = ((70 + (getY)) * 100) / 120
y = -1 + (ay * 2) / 100
ax = ((127 + (getX)) * 100) / 172
x = -1 + (ax * 2) / 100
self.hero.setPos(x, 0, y)
def updateHeroHpr(self, getH):
h = -getH
self.hero.setHpr(0, 0, h)
def updateTeamMatePos(self, mateName, getX, getY):
ay = ((70 + (getY)) * 100) / 120
y = -1 + (ay * 2) / 100
ax = ((127 + (getX)) * 100) / 172
x = -1 + (ax * 2) / 100
self.team[mateName].setPos(x, 0, y)
def updateTeamMateHpr(self, mateName, getH):
h = -getH
self.team[mateName].setHpr(0, 0, h)
def changeTowerColor(self, npcName, toverImage):
self.npc[npcName].setImage(toverImage)
class SceneManager(ShowBase):
def __init__(self,scene_nodes):
ShowBase.__init__(self)
self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
self.static_objects = []
self.dynamic_objects = []
self.actors = []
self.actions = []
self.scene_nodes = scene_nodes
for scene in scene_nodes:
self.load_background(scene.scene_tag,scene.time)
self.load_terrain(scene.scene_tag)
self.load_static_objects(scene.static_objects)
self.load_Actors(scene.Actors)
self.satisfy_scene_constrains(scene.initial_constrains)
self.add_weather()
# Now we need to play the animations
# First: instantiate the actions
for subscene in scene.subscenes:
subscene_object = namedtuple("SubScene",subscene.keys(),*subscene.values())
actions = subscene_object.actions
for action in actions:
a = namedtuple("Action",action.keys(),*action.values())
act = ActionFactory.create_action(a,self.actors)
self.actions.append(act)
# Second: Play the animations
for action in self.actions:
action.play_action()
def load_background(self,scene_tag,scene_time):
#TODO : Add dummy background to load in case there is no background
background_dir_path = os.path.join("../../backgrounds",scene_tag)
images = [str(image) for image in os.listdir(self.background_dir_path)]
#pick random background from the given images
if len(images)>0:
imageindex = random.randint(0,len(images)-1)
image = images[imageindex]
self.background_path=os.path.join(background_dir_path,image)
else:
self.background_path=DEFAULTBACKGROUND
#TODO: Adjust the image brightness to match day or night(scene_time)
self.b=OnscreenImage(parent=self.render2d, image =self.background_path)
self.b.reparentTo(self.render2d)
self.cam2d.node().getDisplayRegion(0).setSort(-20)
def load_terrain(self,scene_tag):
print(scene_tag)
def load_static_objects(self,static_objects):
print(static_objects)
def load_Actors(self,actors):
self.actors = dict([(actor["id"],ActorFactory.create_actor(actor)) for actor in actors])
#TODO : Actors positioning required
#Now reparent each actor to render
for actor in self.actors.values():
actor.reparentTo(self.render)
def satisfy_scene_constrains(self,initial_constrains):
print(initial_constrains)
def add_weather(self):
print("weather")
#TODO: Define a procedure to move the camera instead of this
def spinCameraTask(self, task):
angleDegrees = task.time * 6.0
angleRadians = angleDegrees * (pi / 180.0)
self.camera.setPos(20 * sin(angleRadians), -20.0 * cos(angleRadians), -20)
self.camera.setHpr(angleDegrees, 0, 0)
return Task.cont
class GuiButton2:
def __init__(self, hugpos, offset, aspect, plane, name):
self.enabled = True
self.name = name
self.frame = DirectFrame( relief = DGG.FLAT
, frameColor = (0, 0, 0, 0)
, scale = 1
, frameSize = (-0.3, 0.3, -0.3, 0.3) ) #32/600=0.05333
self.frame.setScale(0.0533)
self.imageObject = OnscreenImage(image = name+".png", pos = (0, 0, 0))
self.imageObject.setTransparency(TransparencyAttrib.MAlpha)
self.imageObject.setAlphaScale(1)
self.imageObject.reparentTo(self.frame)
self.hugpos = hugpos
self.offset = offset
self.redraw(aspect)
def redraw(self, aspect, flag="wide"):
if self.hugpos == "top":
p = base.a2dTopLeft.getPos()#@UndefinedVariable
p.setX(p.getX() + self.offset.getX() + 0.05)
p.setZ(p.getZ() + self.offset.getZ() - GUI_TOP_OFFSET - 0.05)
elif self.hugpos == "bottom":
p = base.a2dBottomLeft.getPos()#@UndefinedVariable
p.setX(p.getX() + self.offset.getX() + 0.05)
p.setZ(p.getZ() + self.offset.getZ() + GUI_BOTTOM_OFFSET - 0.05)
elif self.hugpos == "right":
p = base.a2dBottomRight.getPos()#@UndefinedVariable
p.setX(p.getX() + self.offset.getX() + 0.05)
p.setZ(p.getZ() + self.offset.getZ() + GUI_BOTTOM_OFFSET - 0.05)
self.frame.setPos(p)
if flag == "wide":
posx, posy = self.frame.getTightBounds()
self.pos_min_x = posx.getX() / aspect
self.pos_min_y = posx.getZ()
self.pos_max_x = posy.getX() / aspect
self.pos_max_y = posy.getZ()
elif flag == "tall":
posx, posy = self.frame.getTightBounds()
self.pos_min_x = posx.getX()
self.pos_min_y = posx.getZ() / aspect
self.pos_max_x = posy.getX()
self.pos_max_y = posy.getZ() / aspect
def turnOn(self):
self.imageObject.setImage(self.name+"_on.png")#@UndefinedVariable
self.imageObject.setTransparency(TransparencyAttrib.MAlpha)
def turnOff(self):
self.imageObject.setImage(self.name+".png")#@UndefinedVariable
self.imageObject.setTransparency(TransparencyAttrib.MAlpha)
def enable(self):
self.imageObject.setImage(self.name+".png")#@UndefinedVariable
self.imageObject.setTransparency(TransparencyAttrib.MAlpha)
self.enabled = True
def disable(self):
self.imageObject.setImage("empty.png")#@UndefinedVariable
self.imageObject.setTransparency(TransparencyAttrib.MAlpha)
self.enabled = False
def removeNode(self):
self.frame.removeNode()
def setAbility(self, ability):
self.name = ability
self.imageObject.setImage(self.name+".png")
self.imageObject.setTransparency(TransparencyAttrib.MAlpha)
self.imageObject.setAlphaScale(1)
class EnemyFireIndicator(DirectObject):
def __init__(self):
self.node = aspect2d.attachNewNode('hudhealth')#GUIOrder.ORDER[GUIOrder.HUD])
self.node.setBin('fixed', GUIOrder.ORDER[GUIOrder.HUD])
self.lastAttacker = None
self.indicator = OnscreenImage(image = 'Assets/Images/HUD/EnemyFireIndicator.png')
self.indicator.setTransparency(TransparencyAttrib.MAlpha)
self.indicator.reparentTo(self.node)
self.alphaSeq = Sequence(Wait(0.75),
LerpColorInterval(self.node, 0.75, Vec4(1, 1, 1, 0), Vec4(1, 1, 1, 1)),
Func(self.Hide))
self.node.hide()
self.accept(PlayerHitEvent.EventName, self.OnPlayerHitEvent)
def Hide(self):
self.node.hide()
self.lastAttacker = None
def Show(self):
self.node.show()
self.node.setColor(Vec4(1, 1, 1, 1))
def Update(self):
if(self.lastAttacker):
self.node.setR(self.GetTheta(self.me, self.lastAttacker))
def GetTheta(self, victim, attacker):
victimLookingDir = victim.GetPlayerState().GetValue(PlayerState.LOOKING_DIRECTION)
victimLookingDir.setZ(0)
victimLookingDir.normalize()
victimLookingDir = Vec3(victimLookingDir)
attackerToVictimVector = victim.GetPos() - attacker.GetPos()
attackerToVictimVector.setZ(0)
attackerToVictimVector.normalize()
attackerToVictimVector = Vec3(attackerToVictimVector)
return attackerToVictimVector.signedAngleDeg(victimLookingDir, Globals.UP_VECTOR)
def OnPlayerHitEvent(self, event):
victim = event.GetVictim()
attacker = event.GetAttacker()
if(victim and victim.GetPlayerState().GetValue(PlayerState.PID) == Globals.MY_PID):
self.me = victim
self.lastAttacker = attacker
theta = self.GetTheta(victim, attacker)
self.node.setR(theta)
self.Show()
self.alphaSeq.start(startT = 0)
def Destroy(self):
self.alphaSeq.finish()
self.ignoreAll()
self.indicator.removeNode()
self.node.removeNode()
class Mission(object):
def __init__(self, p, m):
self.menu = m
self.player = p
self.memoryNum = 0
self.password = None
self.passwordExit = None
self.bookIndex = 0
# self.manager = GoodsManager()
self.manager = self.player.goodmanager
self.tutorialText = range(10)
self.plotText = [[0] * 10] * 10
self.memoryText = [[0] * 10] * 10
self.kuraText = range(10)
self.initTutorial()
self.initPlot()
self.initMemory()
self.initKuraMessage()
self.paperState = True
def initTutorial(self):
self.tutorialText[0] = ""
self.tutorialText[1] = "被Erosion感染的人存在侵蚀度这个概念。侵蚀度越高你的身体机能也就越强，\n" \
"但是一定不要为了力量而盲目提升侵蚀度，因为你的侵蚀度达到100%之后意识" \
"就会立刻消亡，成为Erosion病毒的傀儡。"
self.tutorialText[2] = "如果真的需要力量的话，可以发动技能入魔，通过提升侵蚀度的代价短暂提升\n" \
"自身的速度，同时随着侵蚀度上升可以做一些平时力量达不到的事情。但是一\n" \
"定给我不要滥用啊，不然的话就去死吧，笨蛋。"
self.tutorialText[3] = "你终于想起来一些事情了呢~这个房间中有好多能让你找回记忆的东西。找到\n" \
"那些东西，也是拯救我们的办法呢。"
self.tutorialText[4] = "我们这种被Erosion寄生的人呢，在危险的时候会有一种直觉，这种直觉会让\n" \
"你在遭遇危险时听到自己的心跳声。说来，为什么我的心跳这么剧烈呢…"
self.tutorialText[5] = "在遇到无法通过的障碍时，使用侵蚀之门可以在空间中制造通道从而进行穿梭。\n" \
"我先在这里制造一扇给你示范一下，看好了哦。"
self.menu.nextButton['command'] = self.hideTutorial
self.menu.nextButton['extraArgs'] = []
def initPlot(self):
self.plotText[0][0] = "终于醒了啊。估计你也想不起来过去的事情了，那我就重新介绍一下自己吧"
self.plotText[0][1] = "我叫Kura。当时有一群人冲向我们，你给自己注射了Erosion，\n然后杀掉了那些人呢。"
self.plotText[0][2] = "那些…人？Kura？不行，我还是想不起来……。"
self.plotText[0][3] = "只有你知道治疗Erosion的办法，所以能从病毒中拯救我们的…也就只有你了。\n" \
"因为我被感染的时间比较长，所以只能保持清醒状态很短时间…务必要从这里逃\n" \
"出去然后找到解药，不然我们恐怕都要迷失在这里了…我会在这里等你的。"
self.plotText[1] = "刚一踏出房间，房间的门就被重重的锁上了。无论我怎么叫喊，里面都没有回应。" \
"我尽可能不去想最糟糕的情况，大概kura不会有什么问题的吧。"
def initMemory(self):
self.memoryText[5][0] = "这个合影……我依稀记得这是我和女儿一起照的……感觉……记忆在涌上来"
self.memoryText[5][1] = "她应该也在这个实验室中……在不久之前她被一些实验体咬伤了\n……不行，" \
"我一定要活着出去，并且找到她……"
self.memoryText[5][2] = "说起来kura，你长的真的很像我的女儿呢。可是你为什么会在这里呢？\n"
self.memoryText[5][3] = "是吗？那你就把我当成你的女儿呗，爸爸。"
self.memoryText[5][4] = "……"
self.memoryText[5][5] = "当然是开玩笑的啦，我也不知道我为什么在这里，我只知道我也\n" \
"被Erosion感染了。不管这些，你一定要逃出去哦，无论是为了你\n" \
"的女儿亦或是你自己，或者说……为了我？"
self.memoryText[5][6] = "嗯，一定。"
def initKuraMessage(self):
self.kuraText[0] = "呜……真是的…干嘛突然用\n手电筒照我呀，好刺眼的……"
self.kuraText[1] = "……呜…又来…恶作剧也要有\n个限度呀………人家也是会生气的哦…"
self.kuraText[2] = "…不是说过了么…恶作剧什么的，要有个…限度呢。\n...\n去死吧你这可恶的人类！"
self.kuraText[3] = "我记得那边有个八音盒哦。\n这个发条应该和那个八音盒有关"
def interactiveWith(self, goods):
self.player.walksound.stop()
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.player.endTask()
self.goods = goods
if goods.Name == "box":
self.menu.selectDialog.show()
if goods.state == "smashed":
self.menu.textLabel['text'] = "这个箱子已经被砸碎了，没必要再去探索了。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
elif goods.state == "moved":
if self.player.EROSION >= 50:
self.menu.textLabel['text'] = "你无法控制暴怒，砸坏了箱子。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"箱子中掉出了一张合影。", goods, "smashed", ["groupPhoto"], 3, -15
]
self.menu.aButton['text'] = "查看箱子"
self.menu.bButton.hide()
else:
self.menu.textLabel['text'] = "这个箱子背后已经没有什么可以探索的了。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
else:
if self.player.EROSION < 5:
self.menu.textLabel[
'text'] = "这个箱子太重了，我推不动它。\n可能我还需要更强的力量。"
self.menu.aButton['command'] = self.showTutorial
self.menu.aButton['extraArgs'] = [2]
self.menu.aButton['text'] = "暂时离开"
self.menu.bButton.hide()
elif self.player.EROSION < 50:
self.menu.textLabel['text'] = "看起来很重的箱子，\n是否要搬开看看？"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"从箱子的后面发现了一个手电筒，\n似乎还有着一点电量。", goods, "moved",
["torch"]
]
self.menu.aButton['text'] = "搬开"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "不搬开"
else:
self.menu.textLabel['text'] = "你无法控制暴怒，砸坏了箱子。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"箱子中掉出了一张合影，并且\n"
"从箱子的后面发现了一个手电筒，\n"
"似乎还有着一点电量。", goods, "smashed",
["torch", "groupPhoto"], 3, -15
]
self.menu.aButton['text'] = "查看箱子"
self.menu.bButton.hide()
elif goods.Name == "yaoshui":
self.menu.selectDialog.show()
if goods.state == "":
self.showTutorial(4)
self.menu.nextButton['command'] = self.hideTutorial
self.menu.nextButton['extraArgs'] = []
goods.state = "skipTutorial"
if goods.state == "shined":
self.menu.textLabel['text'] = "这瓶蓝色药水没什么用了。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
else:
# if self.player.bag.haveItem("res/models/items/" + "torch" + ".png"):
# self.menu.textLabel['text'] = "桌子上怎么有瓶蓝色药水？"
# self.menu.aButton['command'] = self.showInfo
# self.menu.aButton['extraArgs'] = ["不对…头好晕…这药水有毒！ ", goods, "drinked", None, None, 100]
# self.menu.aButton['text'] = "喝一口"
# self.menu.bButton['command'] = self.changWord
# self.menu.bButton['extraArgs'] = ["后方墙上的一些文字在光芒照射下\n变成了蓝色。手电筒电量耗尽了。", goods, "shined"]
# self.menu.bButton['text'] = "用手电筒照一下."
# else:
self.menu.textLabel['text'] = "桌子上怎么有瓶蓝色药水？"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"不对…头好晕…这药水有毒！", goods, "drinked", None, None, 100
]
self.menu.aButton['text'] = "喝一口"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "放弃"
elif goods.Name == "toilet_door":
self.menu.selectDialog.show()
if self.player.EROSION >= 50 and self.goods.state == "":
self.menu.textLabel['text'] = "你的焦虑影响了你的思维。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"你用力向前一拍，砸碎了厕所的门。", goods, "unlockedOpen"
]
self.menu.aButton['text'] = "我..."
self.menu.bButton.hide()
self.goods.OnClick()
self.password = Password()
self.password.passwordFrame.hide()
self.password.unloadLeap()
self.password.passState = True
else:
if self.goods.state == "unlockedOpen":
self.menu.textLabel['text'] = "厕所门上现在没有上锁。"
self.menu.aButton['command'] = self.openDoor
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "关闭厕所门"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "离开"
elif self.goods.state == "unlockedClose":
self.menu.textLabel['text'] = "厕所门上现在没有上锁。"
self.menu.aButton['command'] = self.openDoor
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "打开厕所门"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "离开"
else:
self.menu.textLabel['text'] = "厕所门上有一个四位数的密码锁。"
self.menu.aButton['command'] = self.openDoor
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "输入密码"
self.menu.bButton['command'] = self.showInfo
self.menu.bButton['extraArgs'] = [
"这个密码到底是什么呢……", goods, ""
]
self.menu.bButton['text'] = "暂时离开"
elif goods.Name == "matong_box3":
self.menu.selectDialog.show()
if goods.state == "searched":
self.menu.textLabel['text'] = "这个马桶已经被调查过了。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
else:
self.menu.textLabel['text'] = "上完厕所后冲了一下水，\n发现一个发条卡在马桶的排水口。"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"获得发条", goods, "searched", ["spring"]
]
self.menu.aButton['text'] = "拿起发条"
self.menu.bButton.hide()
self.getSpringSound = loader.loadSfx("res/sounds/toilte.mp3")
self.getSpringSound.setPlayRate(1.5)
self.getSpringSound.play()
elif goods.Name == "bookshelf_box":
self.menu.selectDialog.show()
if self.bookIndex == 3:
self.bookIndex = 0
if self.bookIndex == 0:
self.menu.textLabel['text'] = "《Erosion研究报告IV》根据我对数据研究证明，被Erosion侵蚀的人在晚期\n" \
"会看到海市蜃楼景象，甚至分不清什么是真实什么是虚妄的幻境。如果没人\n" \
"提醒，那些人会沉湎在幻想美梦中而无法醒来，从而被Erosion完全控制。"
elif self.bookIndex == 1:
self.menu.textLabel[
'text'] = "《格林童话集》为什么这个房间会有这种书？但是我没时间在这里浪费了。"
elif self.bookIndex == 2:
self.menu.textLabel[
'text'] = "《人民日报》上面日期写着2011年2月5日。\n报纸都泛黄了，似乎已经过去了很久。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
self.bookIndex += 1
elif goods.Name == "bed_box":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "一点都不困，还是不要睡了。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
elif goods.Name == "xishoupen":
self.menu.selectDialog.show()
if goods.state is not "searched":
self.menu.textLabel['text'] = "洗手台里好像有什么东西？"
self.menu.aButton['command'] = self.showInfo
self.menu.aButton['extraArgs'] = [
"在洗手台的上方\n发现了一支抑制剂。", goods, "searched", ["injection"]
]
self.menu.aButton['text'] = "查看"
self.menu.bButton.hide()
else:
self.menu.textLabel['text'] = "洗手台里什么都没有了。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "离开"
self.menu.bButton.hide()
elif goods.Name == "MusicBox":
self.menu.selectDialog.show()
self.menu.textLabel['text'] = "一个装饰精美的八音盒，貌似缺少了什么。"
self.menu.aButton['command'] = self.doNothing
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "暂时离开"
self.menu.bButton.hide()
elif goods.Name == "Scene1_Exit":
self.menu.selectDialog.show()
if self.goods.state == "unlockedOpen":
self.menu.textLabel['text'] = "房间门上现在没有上锁。"
self.menu.aButton['command'] = self.openExitDoor
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "关闭房间门"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "离开"
elif self.goods.state == "unlockedClose":
self.menu.textLabel['text'] = "房间门上现在没有上锁。"
self.menu.aButton['command'] = self.openExitDoor
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "打开房间门"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
self.menu.bButton['text'] = "离开"
else:
self.menu.textLabel['text'] = "房间门上有一个密码锁。"
self.menu.aButton['command'] = self.openExitDoor
self.menu.aButton['extraArgs'] = []
self.menu.aButton['text'] = "输入密码"
self.menu.bButton['command'] = self.showInfo
self.menu.bButton['extraArgs'] = ["这个密码到底是什么呢……", goods, ""]
self.menu.bButton['text'] = "暂时离开"
elif goods.Name == "Scene1_wallword_1":
self.menu.selectDialog.show()
if goods.state == "changed":
self.menu.textLabel['text'] = "之前我记得有这么几道文字被凸显了出来"
self.menu.aButton['text'] = "查看文字"
self.menu.aButton['extraArgs'] = []
self.menu.aButton['command'] = self.showWordAfter
self.menu.bButton['text'] = "离开"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
else:
if (self.player.bag.haveItem("res/models/items/" + "torch" +
".png")):
self.menu.textLabel['text'] = "文字并没有发生任何变化"
else:
self.menu.textLabel['text'] = "墙上这些文字和鬼画符一样，用肉眼难以看懂"
self.menu.aButton['text'] = "查看文字"
self.menu.aButton['command'] = self.showWordBefore
self.menu.aButton['extraArgs'] = []
self.menu.bButton['text'] = "离开"
self.menu.bButton['command'] = self.doNothing
self.menu.bButton['extraArgs'] = []
elif goods.Name == "enemy":
self.menu.infoDialog.show()
if goods.state == 1:
self.showTutorial(1)
self.showTips('系统提示：请时刻注意你的侵蚀度。')
goods.state = 2
elif goods.state == 2:
self.showTutorial(2)
self.showTips('系统提示：按下Space发动入魔。')
goods.state = 3
elif goods.state == 3:
self.showTutorial(3)
self.showTips('系统提示：在侵蚀度高于50%时你会有破坏\n' '东西的冲动和焦虑感，可能会影响剧情的发展。')
goods.state = 4
elif goods.state == 4:
self.showTutorial(4)
self.showTips('系统提示：留意自己的心跳声。')
goods.state = 5
elif goods.state == 5:
self.showTutorial(5)
self.showTips('系统提示：按下鼠标右键可以\n'
'向前方发射侵蚀之门，如果场景中\n'
'存在两个侵蚀之门即可互相穿梭。')
goods.state = 1
else:
self.resume()
def waitPaper(self, task):
if self.paperState == True:
base.accept("mouse1", self.player.__setattr__, ["LeftButton", 1])
base.accept("mouse1-up", self.player.__setattr__,
["LeftButton", 0])
base.accept("escape", self.player.game.pauseGame)
self.player.bag.paperFrame.hide()
self.player.mission.paperState = True
self.player.initTask()
return task.done
return task.cont
'''
wall word
'''
def showWordBefore(self):
self.menu.selectDialog.hide()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.wordframe = DirectFrame(frameColor=(0, 0, 0, 1),
frameSize=(-2, 2, -2, 2),
pos=(0, 0, 0))
self.wordImage = OnscreenImage(
'res/models/SceneJPG/Scene1_Wall_Hall.png',
pos=(0, 0, 0),
scale=(1.4, 1, 1))
self.wordImage.reparentTo(self.wordframe)
# self.leaveButton=DirectButton
self.wordframe.show()
self.player.initTask()
base.accept("mouse1", self.wordReturn)
base.accept("escape", self.wordReturn)
def showWordAfter(self):
self.menu.selectDialog.hide()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.wordframe = DirectFrame(frameColor=(0, 0, 0, 1),
frameSize=(-2, 2, -2, 2),
pos=(0, 0, 0))
self.wordImage = OnscreenImage(
'res/models/SceneJPG/Scene1_Wall_Hall2.png',
pos=(0, 0, 0),
scale=(1.4, 1, 1))
self.wordImage.reparentTo(self.wordframe)
# self.wordImage.removeNode()
self.wordframe.show()
self.player.initTask()
base.accept("escape", self.wordReturn)
base.accept("mouse1", self.wordReturn)
def wordReturn(self):
self.wordframe.hide()
self.resume()
self.player.initTask()
base.accept("mouse1", self.player.__setattr__, ["LeftButton", 1])
base.accept('escape', self.player.game.pauseGame)
def changWord(self, info, goods, state, items=None):
goods.state = state
self.manager.GoodsIta["Scene1_wallword_1"].CloseHighLight()
self.manager.GoodsIta["Scene1_wallword_1"].Node.hide()
self.manager.GoodsIta["Scene1_wallword_1"].state = "changed"
self.manager.GoodsIta["Scene1_wallword_2"].Node.show()
self.menu.infoLabel['text'] = info
self.menu.infoDialog.show()
self.resume()
self.player.initTask()
'''
password door
'''
def openDoor(self):
if self.password is None:
self.password = Password()
self.password.password = "******"
else:
self.password.reloadLeap()
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.player.endTask()
if self.password.passState == False:
self.password.passwordFrame.show()
self.menu.selectDialog.hide()
taskMgr.add(self.waitPass, "waitPass")
base.accept('escape', self.waitPassReturn)
def waitPass(self, task):
if self.password.passState:
self.password.passwordFrame.hide()
self.password.unloadLeap()
self.goods = self.player.goodmanager.GoodsIta['toilet_door']
self.goods.OnClick()
if self.goods.state == "unlockedOpen":
self.goods.state = "unlockedClose"
else:
self.goods.state = "unlockedOpen"
self.resume()
self.player.initTask()
base.accept('escape', self.player.game.pauseGame)
return
if self.password.wrongTime == 1:
self.password.passwordFrame.hide()
self.password.wrongTime = 0
self.password.unloadLeap()
self.showInfo("密码错误，侵蚀度+5", self.goods, "", None, None, 5)
base.accept('escape', self.player.game.pauseGame)
return task.done
return task.cont
def waitPassReturn(self):
self.resume()
self.player.initTask()
base.accept('escape', self.player.game.pauseGame)
self.password.unloadLeap()
self.password.passwordFrame.hide()
def openExitDoor(self):
if self.passwordExit is None:
self.passwordExit = Gpassword()
else:
self.passwordExit.reloadLeap()
base.accept('b', self.menu.nothing)
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.player.endTask()
self.passwordExit.passwordFrame.show()
self.menu.selectDialog.hide()
taskMgr.add(self.waitExitPass, "waitExitPass")
base.accept('escape', self.waitExitPassReturn)
def waitExitPass(self, task):
if self.passwordExit.passState:
self.passwordExit.passwordFrame.hide()
self.passwordExit.unloadLeap()
base.accept("mouse1", self.player.__setattr__, ["LeftButton", 1])
base.accept("mouse1-up", self.player.__setattr__,
["LeftButton", 0])
self.goods.OnClick()
if self.goods.state == "unlockedOpen":
self.goods.state = "unlockedClose"
else:
self.goods.state = "unlockedOpen"
self.resume()
self.player.initTask()
base.accept('escape', self.player.game.pauseGame)
# self.moveToLevelTwo()
self.player.mouseIconNormal.show()
self.player.mouseIconWatch.hide()
self.player.isInteractive = False
self.player.node.setPos(-250, 265, 0)
self.menu.passFrame.show()
taskMgr.add(self.fadeMove, "fadeMove")
self.resume()
return
if self.passwordExit.wrongTime == 1:
self.passwordExit.passwordFrame.hide()
self.passwordExit.wrongTime = 0
self.passwordExit.clear()
self.passwordExit.unloadLeap()
base.accept("mouse1", self.player.__setattr__, ["LeftButton", 1])
base.accept("mouse1-up", self.player.__setattr__,
["LeftButton", 0])
self.showInfo("房间门没有任何反应。", self.goods, "")
base.accept('escape', self.player.game.pauseGame)
return task.done
return task.cont
def waitExitPassReturn(self):
self.resume()
self.player.initTask()
base.accept("mouse1", self.player.__setattr__, ["LeftButton", 1])
base.accept("mouse1-up", self.player.__setattr__, ["LeftButton", 0])
# self.player.game.
base.accept('escape', self.player.game.pauseGame)
base.accept('b', self.player.game.openBag)
self.passwordExit.unloadLeap()
self.passwordExit.clear()
self.passwordExit.passwordFrame.hide()
def doNothing(self):
self.resume()
self.player.initTask()
def showTutorial(self, tutorialIndex):
self.menu.selectDialog.hide()
self.menu.tutorialDialog.show()
self.menu.nextButton['text'] = self.tutorialText[tutorialIndex]
def hideTutorial(self):
self.menu.bButton.show()
self.menu.selectDialog.hide()
self.menu.tutorialDialog.hide()
self.skip()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
base.win.movePointer(0,
base.win.getXSize() / 2,
base.win.getYSize() / 2)
self.player.initTask()
def hideOcanio(self):
self.menu.tutorialDialog.hide()
self.menu.ocanioDialog.hide()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
base.win.movePointer(0,
base.win.getXSize() / 2,
base.win.getYSize() / 2)
self.player.initTask()
def showInfo(self,
info,
goods,
state,
items=None,
index=None,
addErosion=None):
self.menu.infoDialog.show()
goods.state = state
self.menu.infoLabel['text'] = info
if items is not None:
for item in items:
if item == "paper":
self.player.bag.addItem(
Goods("res/models/items/" + item + ".png",
self.player.bag.paper, "一张纸条"))
elif item == "torch":
self.player.bag.addItem(
Goods("res/models/items/" + item + ".png",
self.player.bag.torch, "一个手电筒"))
elif item == "groupPhoto":
self.player.bag.addItem(
Goods("res/models/items/" + item + ".png",
self.player.bag.photo, "一张合影"))
self.memoryNum = 1
elif item == "injection":
self.player.bag.addItem(
Goods("res/models/items/" + item + ".png",
self.player.bag.injection, "抑制剂"))
elif item == "spring":
self.player.bag.addItem(
Goods("res/models/items/" + item + ".png",
self.player.bag.spring, "发条"))
else:
self.player.bag.addItem(
Goods("res/models/items/" + item + ".png",
self.player.bag.panda, "这是啥？"))
if index is not None:
if index == 3:
self.beginMemory(0)
self.menu.selectDialog.hide()
self.skip()
else:
self.showTutorial(index)
self.skip()
else:
self.resume()
self.player.initTask()
if addErosion is not None:
if self.player.EROSION + addErosion < 0:
self.player.EROSION = 0
elif self.player.EROSION + addErosion > 100:
self.player.EROSION = 100
else:
self.player.EROSION += addErosion
def beginMemory(self, index):
if index < 3 or index == 4:
self.menu.tutorialDialog.hide()
self.menu.ocanioDialog.show()
self.menu.ocanioButton['text'] = self.memoryText[5][index]
self.menu.ocanioButton['command'] = self.beginMemory
self.menu.ocanioButton['extraArgs'] = [index + 1]
elif index == 3 or index == 5:
self.menu.tutorialDialog.show()
self.menu.ocanioDialog.hide()
self.menu.nextButton['text'] = self.memoryText[5][index]
self.menu.nextButton['command'] = self.beginMemory
self.menu.nextButton['extraArgs'] = [index + 1]
elif index == 6:
self.menu.tutorialDialog.hide()
self.menu.ocanioDialog.show()
self.menu.ocanioButton['text'] = self.memoryText[5][index]
self.menu.ocanioButton['command'] = self.hideOcanio
self.menu.ocanioButton['extraArgs'] = []
def aCommand(self):
self.resume()
self.player.initTask()
def bCommand(self):
self.menu.infoDialog.show()
self.menu.infoLabel['text'] = "get something!"
self.resume()
self.player.initTask()
def skip(self):
taskMgr.add(self.fadeTask, "fadeTask")
def fadeTask(self, task):
if task.time < 1.0:
return task.cont
self.menu.infoDialog.hide()
return task.done
def showTips(self, tips):
self.menu.infoDialog.hide()
self.menu.tipDialog.show()
self.menu.tipLabel['text'] = tips
taskMgr.add(self.fadeTipsTask, 'fadeTipsTask')
def fadeTipsTask(self, task):
if task.time < 3.0:
return task.cont
self.menu.tipDialog.hide()
return task.done
def resume(self):
self.menu.bButton.show()
self.menu.selectDialog.hide()
# self.menu.tutorialDialog.hide()
taskMgr.remove("fadeTask")
self.skip()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
base.win.movePointer(0,
base.win.getXSize() / 2,
base.win.getYSize() / 2)
def end(self, fun="endB"):
self.endFun = fun
self.menu.tutorialDialog.hide()
taskMgr.add(self.fadeEnd, "fadeEnd")
self.player.erosionFrame.hide()
self.player.currentItemFrame.hide()
self.menu.passFrame.show()
def fadeEnd(self, task):
if task.time < 1.0:
self.menu.passFrame['frameColor'] = (0, 0, 0, task.time)
return task.cont
self.menu.passFrame.hide()
self.menu.infoDialog.hide()
if self.endFun == "endA":
self.endA()
self.showEndPicture('deadend_text.png')
elif self.endFun == "end1":
self.end1()
self.showEndPicture('deadend_text.png')
elif self.endFun == "endB":
self.endB()
self.showEndPicture('end_text.png')
elif self.endFun == "endC":
self.endC()
self.showEndPicture('deadend+_text.png')
elif self.endFun == "endD":
self.endD()
elif self.endFun == "endE":
self.endE()
elif self.endFun == "endF":
self.endF()
elif self.endFun == "endG":
self.endG()
self.showEndPicture('deadend2+.png')
elif self.endFun == "trueEnd":
self.trueEnd()
return task.done
else:
return task.done
self.menu.mainFrame.hide()
base.accept('mouse1-up', self.removeEndPicture)
return task.done
def removeEndPicture(self):
self.menu.endPictureFrame.hide()
self.menu.mainFrame.show()
def endA(self):
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.player.endTask()
self.menu.mainFrame.show()
self.menu.infoDialog.show()
self.player.erosionFrame.hide()
self.player.currentItemFrame.hide()
self.menu.infoLabel['text'] = "Erosion max!"
self.menu.infoDialog.hide()
self.skip()
def endB(self):
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.player.endTask()
self.menu.mainFrame.show()
self.menu.infoLabel['text'] = "Kura被你吓死了！"
self.menu.infoDialog.show()
self.player.erosionFrame.hide()
self.player.currentItemFrame.hide()
self.menu.tutorialDialog.hide()
self.skip()
def endC(self):
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.player.endTask()
self.menu.mainFrame.show()
self.menu.infoLabel['text'] = '谁动了我的蛋糕?'
self.menu.infoDialog.show()
self.player.erosionFrame.hide()
self.player.currentItemFrame.hide()
self.menu.tutorialDialog.hide()
self.skip()
def endD(self):
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.player.endTask()
self.menu.mainFrame.show()
self.menu.infoLabel['text'] = '活该'
self.menu.infoDialog.show()
self.player.erosionFrame.hide()
self.player.currentItemFrame.hide()
self.menu.tutorialDialog.hide()
self.skip()
def endE(self):
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.player.endTask()
self.menu.mainFrame.show()
self.menu.infoLabel['text'] = '活该'
self.menu.infoDialog.show()
self.player.erosionFrame.hide()
self.player.currentItemFrame.hide()
self.menu.tutorialDialog.hide()
self.skip()
def endF(self):
self.resume()
self.player.initTask()
def endG(self):
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.player.endTask()
self.menu.mainFrame.show()
self.menu.infoLabel['text'] = '书不能乱读'
self.menu.infoDialog.show()
self.player.erosionFrame.hide()
self.player.currentItemFrame.hide()
self.menu.tutorialDialog.hide()
self.skip()
def end1(self):
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.player.endTask()
self.menu.mainFrame.show()
self.menu.infoLabel['text'] = "Erosion max!"
self.menu.infoDialog.hide()
self.player.erosionFrame.hide()
self.player.currentItemFrame.hide()
self.skip()
def showEndPicture(self, pic):
self.menu.endBackground.setImage('res/end/' + pic)
self.menu.endPictureFrame.show()
base.accept('mouse1-up', self.removeEndPicture)
# def fadeEnd(self, task):
# if task.time < 2.0:
# self.menu.passFrame['frameColor'] = (0, 0, 0, task.time)
# return task.cont
# self.menu.passFrame.hide()
# self.menu.infoDialog.hide()
# if self.endFun == "endA":
# self.endA()
# elif self.endFun == "end1":
# self.end1()
# elif self.endFun == "endB":
# self.endB()
# return task.done
#
# def endA(self):
# props = WindowProperties()
# props.setCursorHidden(False)
# base.win.requestProperties(props)
# self.player.endTask()
# self.menu.mainFrame.show()
# self.menu.infoDialog.show()
# self.player.erosionFrame.hide()
# self.player.currentItemFrame.hide()
# self.menu.infoLabel['text'] = "Erosion max!"
# self.skip()
#
# def endB(self):
# props = WindowProperties()
# props.setCursorHidden(False)
# base.win.requestProperties(props)
# self.player.endTask()
# self.menu.mainFrame.show()
# self.menu.infoDialog.show()
# self.player.erosionFrame.hide()
# self.player.currentItemFrame.hide()
# self.menu.tutorialDialog.hide()
# self.menu.infoDialog['text'] = "Kura被你吓死了！"
# self.skip()
def moveToLevelTwo(self):
self.removeGame()
self.player.erosionFrame.hide()
self.player.currentItemFrame.hide()
self.player.shoot.TwoBullet[0].Disappera()
self.player.shoot.TwoBullet[1].Disappera()
self.menu.selectedSave = 2
self.menu.tempPlayer = self.player
self.menu.loadSave()
def removeGame(self):
'''
释放内存
'''
names = [
'wall', 'bed_box', 'bookshelf_box', 'box', 'chair1', 'chair2',
'chair3', 'chair4', 'desk2', 'desk3_2', 'matong_box3', 'xishoupen',
'yaoshui', 'Scene1_Exit', 'Scene1_wallword_1', 'Scene1_wallword_2',
'MusicBox', 'toilet_door', 'enemy'
]
for name in names:
self.player.goodmanager.UnLoad(name)
def fadeMove(self, task):
if task.time < 1.0:
self.menu.passFrame['frameColor'] = (0, 0, 0, task.time)
return task.cont
else:
self.menu.passFrame.hide()
self.moveToLevelTwo()
return task.done
