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 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
class HUD():
def __init__(self):
self.speedometer = OnscreenImage(image = 'img/speedometerDial.png', pos = (-1, 0, -.7) )
self.speedometer.setScale(.25)
self.speedometer.setTransparency(TransparencyAttrib.MAlpha)
self.speedPin = OnscreenImage(image = 'img/speedometerNeedle.png', pos = (-1, 0, -.7))
self.speedPin.setScale(.10)
self.speedPin.setTransparency(TransparencyAttrib.MAlpha)
self.speedPin.setHpr(0, 0, 0)
self.minimap = OnscreenImage(image = 'img/minimap.png', pos = (1.05, 0, -.65))
self.minimap.setScale(.19, .19, .3)
self.dot = OnscreenImage(image = 'img/dot.png', pos = (1.01, 0, -.55))
self.dot.setScale(.025)
font1 = loader.loadFont('img/goodfish.ttf')
self.lapText = OnscreenText(text = "0/10", font = font1, pos = (1, -.1, 0), fg = (1, 1, 1, 1) )
self.lapText.setScale(.05)
self.placeText = OnscreenText(text = "", font = font1, pos = (1, -.2, 0), fg = (1, 1, 1, 1))
self.placeText.setScale(.05)
self.timerText = OnscreenText(text = "Time: ", font = font1, pos = (1, -.3, 0), fg = (1, 1, 1, 1))
def update(self, velocity, x, y, laps, place, time):
if velocity < 0:
velocity = -velocity
self.dot.setPos(1.01+(x/4250), 0, -.55+(y/4250))
self.lapText.setText("Laps: " + str(laps)+"/3")
self.speedPin.setHpr(0, 0, 4*velocity)
self.placeText.setText("Position: "+str(place))
self.timerText.setText("Time: "+ str(round(time)))
"""def getDist(self, x, y, checkpoint):
cx = checkpoint[0]
cy = checkpoint[1]
dist = math.sqrt((cx-x)**2 + (cy-y)**2)
rotAngle = math.atan2(-y,x)
newX = x*math.cos(rotAngle) - y*math.sin(rotAngle)
dToCheckpoint = dist - newX
return dToCheckpoint"""
"""def updateMiniMap(self, x, y):
self.dot.setPos(1+(x/1000), 0, -.7+(y/1000))"""
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)
class English(HUDElement):
def __init__(self):
HUDElement.__init__(self)
self.dir = ani.model_dir / 'hud' / 'english'
self.text_scale = 0.2
self.text_color = (1, 1, 1, 1)
self.circle = OnscreenImage(image=panda_path(self.dir / 'circle.png'),
parent=self.dummy_right,
scale=0.15)
self.circle.setTransparency(TransparencyAttrib.MAlpha)
autils.alignTo(self.circle, self.dummy_right, autils.CL, autils.C)
self.circle.setZ(-0.65)
self.crosshairs = OnscreenImage(image=panda_path(self.dir /
'crosshairs.png'),
pos=(0, 0, 0),
parent=self.circle,
scale=0.14)
self.crosshairs.setTransparency(TransparencyAttrib.MAlpha)
self.text = OnscreenText(
text="(0.00, 0.00)",
pos=(0, -1.15),
scale=self.text_scale,
fg=self.text_color,
align=TextNode.ACenter,
mayChange=True,
parent=self.circle,
)
def set(self, a, b):
self.crosshairs.setPos(-a, 0, b)
self.text.setText(f"({a:.2f},{b:.2f})")
def init(self):
self.show()
def show(self):
self.circle.show()
def hide(self):
self.circle.hide()
def destroy(self):
self.hide()
del self.text
del self.crosshairs
del self.circle
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
class Switches(ServiceScreenBase):
def __init__(self, screen_manager):
super(Switches, self).__init__(screen_manager, "Switch Test")
self.current_switch = OnscreenText(
"",
1,
fg=(1, 1, 1, 1),
pos=(-1.3, 0.60),
align=TextNode.ALeft,
scale=.10,
mayChange=True,
# font = base.fontLoader.load('Arial Bold.ttf'),
parent=self.node2d)
self.switches = OnscreenImage(parent=self.node2d,
image="assets/images/switch_matrix.jpg",
scale=(1, 1, 0.8))
# Size
# (0.15, 0, 0.174)
self.switch_active = OnscreenImage(
parent=self.node2d,
image="assets/images/switch_active.png",
scale=(0.075, 0.1, 0.087),
pos=(-0.456, 0, 0.52156))
self.switch_active.setTransparency(TransparencyAttrib.MAlpha)
def set_active(self, swnum):
swnum = swnum - 11
base_pos = (-0.456, 0, 0.52156)
pos = (base_pos[0], 0, base_pos[2] - (swnum * 0.174) + 0.005)
self.switch_active.setPos(pos)
def img_size(self, model):
min, max = model.getTightBounds()
return max - min
def set_switch(self, text):
self.current_switch.setText(text)
def show(self):
super(Switches, self).show()
self.switches.show()
self.switch_active.show()
def hide(self):
super(Switches, self).hide()
self.switches.hide()
self.switch_active.hide()
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 Menu(DirectObject):
def __init__(self):
self.title = OnscreenImage(image = 'img/titleScreen.png', pos = (0, 0, 0) )
self.pointer = OnscreenImage(image = 'img/titleSelector.png', pos = (-.2, 0 ,-.63))
self.pointer.setScale(.05)
self.start = False
self.instructions = False
self.pointerPosition = 1
self.pointer.setTransparency(TransparencyAttrib.MAlpha)
self.accept("enter", self.screenHandler)
self.accept("arrow_up", self.movePointerUp)
self.accept("arrow_down", self.movePointerDown)
self.accept("backspace", self.back)
self.accept("escape", sys.exit)
def screenHandler(self):
if self.pointerPosition == 1:
self.start = True
self.title.destroy()
self.pointer.destroy()
else:
self.instructions = True
self.title.setImage('img/instructions.png')
def back(self):
if self.instructions == True:
self.instructions = False
self.title.setImage('img/titleScreen.png')
self.pointer.setImage('img/titleSelector.png')
def movePointerUp(self):
if self.pointerPosition == 2:
self.pointer.setPos(-.2, 0, -.63)
self.pointerPosition = 1
def movePointerDown(self):
if self.pointerPosition == 1:
self.pointer.setPos(-.2, 0, -.8)
self.pointerPosition = 2
def destroy(self):
self.ignoreAll()
class Cursor:
def __init__(self, path, scale, hotspot):
if not path:
return
self.__set_standard_curson(False)
self.cursor_img = OnscreenImage(path)
self.cursor_img.setTransparency(True)
self.cursor_img.setScale(scale)
self.cursor_img.setBin('gui-popup', 50)
self.hotspot_dx = scale[0] * (1 - 2 * hotspot[0])
self.hotspot_dy = scale[2] * (1 - 2 * hotspot[1])
eng.event.attach(self.on_frame)
def __set_standard_curson(self, show):
props = WindowProperties()
props.setCursorHidden(not show)
base.win.requestProperties(props)
def show(self):
self.cursor_img.show()
def show_standard(self):
self.__set_standard_curson(True)
def hide(self):
self.cursor_img.hide()
def hide_standard(self):
self.__set_standard_curson(False)
def cursor_top(self):
self.cursor_img.reparent_to(self.cursor_img.get_parent())
def on_frame(self):
if base.mouseWatcherNode.hasMouse():
x = base.mouseWatcherNode.getMouseX()
y = base.mouseWatcherNode.getMouseY()
h_x = x * base.getAspectRatio() + self.hotspot_dx
self.cursor_img.setPos(h_x, 0, y - self.hotspot_dy)
class 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 BetterOnscreenImage(DebugObject):
""" Simple wrapper arroun OnscreenImage, providing a simpler interface and
better visuals """
def __init__(self,
image=None,
parent=None,
x=0,
y=0,
w=10,
h=10,
transparent=True,
nearFilter=True,
anyFilter=True):
""" Creates a new image, taking (x,y) as topleft coordinates.
When nearFilter is set to true, a near filter will be set to the
texture passed. This provides sharper images.
When anyFilter is set to false, the passed image won't be modified at
all. This enables you to display existing textures, otherwise the
texture would get a near filter in the 3D View, too. """
DebugObject.__init__(self, "BetterOnscreenImage")
self.w, self.h = w, h
self.initialPos = self.translatePos(x, y)
self._node = OnscreenImage(image=image,
parent=parent,
pos=self.initialPos,
scale=(w / 2.0, 1, h / 2.0))
if transparent:
self._node.setTransparency(TransparencyAttrib.MAlpha)
tex = self._node.getTexture()
if nearFilter and anyFilter:
tex.setMinfilter(Texture.FTNearest)
tex.setMagfilter(Texture.FTNearest)
if anyFilter:
tex.setAnisotropicDegree(8)
tex.setWrapU(Texture.WMClamp)
tex.setWrapV(Texture.WMClamp)
def getInitialPos(self):
""" Returns the initial position of the image. This can be used for
animations """
return self.initialPos
def posInterval(self, *args, **kwargs):
""" Returns a pos interval, this is a wrapper around
NodePath.posInterval """
return self._node.posInterval(*args, **kwargs)
def hprInterval(self, *args, **kwargs):
""" Returns a hpr interval, this is a wrapper around
NodePath.hprInterval """
return self._node.hprInterval(*args, **kwargs)
def setImage(self, img):
""" Sets the current image """
self._node.setImage(img)
def setPos(self, x, y):
""" Sets the position """
self.initialPos = self.translatePos(x, y)
self._node.setPos(self.initialPos)
def translatePos(self, x, y):
""" Converts 2d coordinates to pandas coordinate system """
return Vec3(x + self.w / 2.0, 1, -y - self.h / 2.0)
def remove(self):
self._node.remove()
def hide(self):
self._node.hide()
def show(self):
self._node.show()
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 Proyecto(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
#Instrucciones
self.ralph_escape = addInstructions(.06, "[ESC]: Para Salir")
self.ralph_run = addInstructions(.12, "[A]: Para Correr")
self.ralph_saluda = addInstructions(.18, "[S]: Para Saludar")
self.ralph_giraD = addInstructions(.24, "[E]: Girar a la derecha")
self.ralph_giraI = addInstructions(.30, "[Q]: Girar a la izquierda")
# Carga de Actor
"""self.Ralph = Actor("models/ralph",
{"run": "models/ralph-run",
"walk": "models/ralph-walk"})
self.Ralph.setScale(.5,.5,.5)
self.Ralph.reparentTo(self.render)
self.Ralph.setPos(0,10,-1) # X,Y,Z"""
# Carga de imágenes
self.Perro = OnscreenImage(image='src/images/Dog.png')
self.Vaca = OnscreenImage(image='src/images/Cow.png')
self.Leon = OnscreenImage(image='src/images/Lion.png')
self.Perro.setScale(.2, .2, .2)
self.Vaca.setScale(.2, .2, .2)
self.Leon.setScale(.2, .2, .2)
self.Perro.setPos(-1, 0, 0)
self.Vaca.setPos(0, 0, 0)
self.Leon.setPos(1, 0, 0)
# Carga de audio
self.audioPerro = loader.loadSfx("src/sounds/Dog.mp3")
self.audioPerro.play()
#self.audioPerro.play()
# Definir articulaciones con Joint
"""self.BrazoDerecho = self.Ralph.controlJoint(None, 'modelRoot', 'RightShoulder')
self.BrazoIzquierdo = self.Ralph.controlJoint(None, 'modelRoot', 'LeftShoulder')
# Movimientos con el brazo derecho
self.moverBrazoDerechoAbajo = self.BrazoDerecho.hprInterval(1.0, Point3(72.2059, 106.186,-45))
self.moverBrazoDerechoArriba = self.BrazoDerecho.hprInterval(1.0, Point3(72.2059, 76.186, 6.02231))
self.Secuencia1 = Sequence(self.moverBrazoDerechoAbajo, self.moverBrazoDerechoArriba)
# Movimientos con el brazo izquierdo
self.moverBrazoIzquierdoAbajo = self.BrazoIzquierdo.hprInterval(1.0, Point3(160.1401, -22.1706, 6.55722))
self.moverBrazoIzquierdoArriba = self.BrazoIzquierdo.hprInterval(1.0, Point3(80.1401, -52.1706, 6.55722))
self.Secuencia2 = Sequence(self.moverBrazoIzquierdoAbajo, self.moverBrazoIzquierdoArriba)
# Movimientos paralelos
self.Paralelo = Parallel(self.Secuencia1, self.Secuencia2)"""
# Add Eventos
self.accept("escape", sys.exit)
self.accept("a", self.ralphRun)
self.accept("s", self.ralphSaluda)
self.accept("q", self.ralphGiraI)
self.accept("e", self.ralphGiraD)
def ralphRun(self):
self.Ralph.loop("run")
def ralphSaluda(self):
if self.Paralelo.isPlaying():
self.Paralelo.finish()
else:
self.Paralelo.loop()
def ralphGiraI(self):
i = self.Ralph.getH()
self.Ralph.setHpr(i - 10, 0, 0)
def ralphGiraD(self):
i = self.Ralph.getH()
self.Ralph.setHpr(i + 10, 0, 0)
class 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 Timer:
def __init__(self, style):
"""
Timer class with fun pictures
@param style: 0 = SUN, 1 = MOON, 2 = GUN
@type style: int
"""
self.style = style
VirtualFileSystem.getGlobalPtr().mount(Filename("mf/timer.mf"), ".", VirtualFileSystem.MFReadOnly)
self.egg = loader.loadModel("timer.egg")
self.img = None
self.interval = None
self.types[style](self)
def create_sun(self):
"""
Creates the sun timer
"""
# load image
self.img = OnscreenImage(image=self.egg.find('**/sun'), pos=(1.15, 0, 0.75),
color=(255, 255, 0, 1), scale=0.25)
# interval
self.interval = LerpFunc(self.run_interval, fromData=1, toData=0, duration=TIME)
self.interval.start()
return
def create_moon(self):
"""
Creates the moon timer
"""
# load image
self.img = OnscreenImage(image=self.egg.find('**/moon-quarter'), pos=(0, 0, 0),
color=(1, 1, 1, 1), scale=0.25)
# interval
self.interval = LerpFunc(self.run_interval, fromData=1, toData=0, duration=TIME)
self.interval.start()
return
def create_gun(self):
"""
Creates the gun timer
"""
# load image
self.img = OnscreenImage(image=self.egg.find('**/gun-0'), pos=(1.05, 0, 0.75), scale=0.25)
# interval
self.interval = LerpFunc(self.run_interval, fromData=1, toData=0, duration=TIME)
self.interval.start()
return
def run_interval(self, c):
if self.style == SUN:
self.img.setColor((1, c, 0, 1))
self.img.setPos(1.15-(c/4), 0, 0.75+(math.sin(math.pi*c)/10))
elif self.style == MOON:
self.img.setColor((1, c, c, 1))
self.img.setPos(0.9+(c/4), 0, 0.75+(math.sin(math.pi*c)/10))
elif self.style == GUN:
self.img.setHpr(0, 0, 360*(1-c)-60)
if c % (1 / 6) < 0.05:
if c % (1 / 6) > 0.025:
self.img.setColor((1, 40*(c % (1 / 6)), 40*(c % (1 / 6)), 1))
else:
self.img.setImage(self.egg.find('**/gun-{}'.format(6 - (round(c / (1 / 6))))))
self.img.setColor((1, 1-40*(c % (1 / 6)), 1-40*(c % (1 / 6)), 1))
else:
self.img.setColor((1, 1, 1, 1))
def annihilate(self):
self.interval.finish()
self.img.destroy()
loader.unloadModel(self.egg)
VirtualFileSystem.getGlobalPtr().unmount("mf/timer.mf")
del self
types = {
SUN: create_sun,
MOON: create_moon,
GUN: create_gun
}
class Player(object):
"""
Player is the main actor in the fps game
"""
HP = 100
EROSION = 0
updateTime = 0
speed = 10
FORWARD = Vec3(0, 2, 0)
BACK = Vec3(0, -1, 0)
LEFT = Vec3(-1, 0, 0)
RIGHT = Vec3(1, 0, 0)
STOP = Vec3(0)
walk = STOP
strafe = STOP
readyToJump = False
jump = 0
state = ''
cameraState = 1
visionState = 0
RightButton = 0
LeftButton = 0
goodmanager = None
isInteractive = False
SLOW = 1
End = 0
Begin = 1
TaskState = End
def __init__(self, goodmanager, m, g):
""" inits the player """
# 6/17
self.walksound = loader.loadSfx("res/sounds/footstep.mp3")
self.goodmanager = goodmanager
self.menu = m
self.game = g
self.loadModel()
self.setUpCamera()
self.setMouseIcon()
self.createCollisions()
self.attachControls()
self.initSkill()
self.shoot = Shoot()
# init mouse update task
self.initSave()
self.initTask()
self.initMission()
def initMission(self):
if self.game.levelName == "tutorial":
self.mission = Mission(self, self.menu)
elif self.game.levelName == "levelTwo":
self.mission = MissionTwo(self, self.menu)
elif self.game.levelName == "levelThree":
self.mission = MissionThree(self, self.menu)
def initSave(self):
self.erosionFrame = DirectFrame(frameColor=(0, 0, 0, 0),
frameSize=(-1, 1, -1, 1),
pos=(-1.2, 0, 0))
self.erosionFrame.hide()
self.erosionFrame.setScale(.02, 1, .4)
self.background = OnscreenImage('res/erosion_bar.png',
pos=(0, 0, 0),
scale=(1, 1, 1))
self.background.setTransparency(TransparencyAttrib.MAlpha)
self.background.reparentTo(self.erosionFrame)
# self.erosionBar = DirectWaitBar(value=self.EROSION, pos=(0, 0, 0), barTexture='res/erosion_value.png',
# relief=None)
# self.erosionBar.setHpr(0, 0, -90)
# self.erosionBar.setScale(0.98, 1, 10)
# self.erosionBar.hide()
# self.erosionBar.reparentTo(self.erosionFrame)
self.erosionBar = OnscreenImage('res/erosion_value.png',
pos=(0, 0, 0),
scale=(1, 1, 1))
self.erosionBar.setScale(1)
self.erosionBar.setTransparency(TransparencyAttrib.MAlpha)
self.erosionBar.reparentTo(self.erosionFrame)
self.currentItemFrame = DirectFrame(
frameColor=(0, 0, 0, 0),
frameSize=(-2, 2, -2, 2),
pos=(-1.2, 0, .8),
image='res/models/items/injection.png',
scale=(.1))
self.currentItemFrame.setTransparency(TransparencyAttrib.MAlpha)
self.currentItemFrame.hide()
# self.currentItemFrame.show()
def initTask(self):
if self.TaskState == self.Begin: return
self.TaskState = self.Begin
self.state = ''
self.game.gameState = ''
self.mouseIconNormal.show()
taskMgr.add(self.mouseUpdate, "mouse-task")
taskMgr.add(self.moveUpdate, "move-task")
taskMgr.add(self.jumpUpdate, 'jump-task')
taskMgr.add(self.erosionUpdate, "erosion-task")
def endTask(self):
if self.TaskState == self.End: return
self.TaskState = self.End
self.state = 'pause'
self.mouseIconWatch.hide()
self.mouseIconNormal.hide()
taskMgr.remove('mouse-task')
taskMgr.remove('move-task')
taskMgr.remove('jump-task')
taskMgr.remove('erosion-task')
# reset update time
self.updateTime = 5
def loadModel(self):
""" make the nodepath for player """
# self.playerModel = Actor("res/models/ralph", {"run": "res/models/ralph-run", "walk": "res/models/ralph-walk"})
self.playerModel = Actor("res/models/hitman-model5", {
"walk": "res/models/hitman-walk5",
"stand": "res/models/hitman-stand"
})
# self.playerModel = Actor("res/models/hitman2-model", {"walk": "res/models/hitman2-walk", "stand":"res/models/hitman-stand"})
self.playerModel.setH(180)
self.playerModel.setZ(0)
self.playerModel.setScale(1.1)
# self.playerModel.hide()
self.node = NodePath("player")
self.node.reparentTo(render)
self.playerModel.reparentTo(self.node)
# self.node.setPos(0, 0, 10)
self.node.setPos(-250, 265, 0)
self.node.setHpr(150, 0, 0)
self.node.setScale(20)
self.node.hide(BitMask32.bit(0))
self.node.hide(BitMask32.bit(1))
def setMouseIcon(self):
self.mouseIconNormal = OnscreenImage(image="res/mouse/mouse1.png",
pos=(0, 1.1, 0))
self.mouseIconNormal.setTransparency(TransparencyAttrib.MAlpha)
self.mouseIconNormal.setScale(0.02)
self.mouseIconNormal.setLightOff()
self.mouseIconNormal.setSa(0.5)
self.mouseIconWatch = OnscreenImage(image="res/mouse/mouse2.png",
pos=(0, 1.1, 0))
self.mouseIconWatch.setTransparency(TransparencyAttrib.MAlpha)
self.mouseIconWatch.setScale(0.05)
self.mouseIconWatch.setSa(0.5)
self.mouseIconWatch.setLightOff()
self.mouseIconNormal.reparentTo(base.camera)
self.mouseIconWatch.reparentTo(base.camera)
self.mouseIconWatch.hide()
def SetMouseModeNormal(self, mode):
if mode == 'Watch':
self.mouseIconWatch.show()
self.mouseIconNormal.hide()
elif mode == 'Normal':
self.mouseIconNormal.show()
self.mouseIconWatch.hide()
def setUpCamera(self):
""" puts camera at the players node """
pl = base.cam.node().getLens()
pl.setFov(70)
base.cam.node().setLens(pl)
base.camera.reparentTo(self.node)
base.cam.node().setCameraMask(BitMask32.bit(3))
self.oldcameraState = 0
self.cameranewPos = None
self.cameranewH = None
self.changeCamera()
# 6/17
def createCollisions(self):
""" create a collision solid and ray for the player """
cn = CollisionNode('PlayerCollideNode')
cn.addSolid(CollisionSphere(0, 0, 4, 1))
solid = self.node.attachNewNode(cn)
solid.setScale(1, 1, 1)
solid.setPos(0, 0, 0)
# solid.show()
base.cTrav.addCollider(solid, base.pusher)
base.pusher.addCollider(solid, self.node, base.drive.node())
# init players floor collisions
ray = CollisionRay()
ray.setOrigin(0, 0, 3)
ray.setDirection(0, 0, -1)
cn = CollisionNode('playerRay')
cn.addSolid(ray)
cn.setFromCollideMask(BitMask32.bit(0))
cn.setIntoCollideMask(BitMask32.allOff())
solid = self.node.attachNewNode(cn)
# solid.show()
base.cTrav.setRespectPrevTransform(True)
self.nodeGroundHandler = CollisionHandlerQueue()
base.cTrav.addCollider(solid, self.nodeGroundHandler)
# init players Forward Ray
ForwardSegment = CollisionSegment(0, 2, 0, 0, 20, 0)
cn = CollisionNode('playerForwardSegment')
cn.addSolid(ForwardSegment)
cn.setFromCollideMask(BitMask32.bit(0))
cn.setIntoCollideMask(BitMask32.allOff())
solid = base.camera.attachNewNode(cn)
# solid.show()
base.cTrav.addCollider(solid, self.nodeGroundHandler)
# repair cross wall
ForwardSegment = CollisionSegment(0, -4, 3, 0, 4, 3)
cn = CollisionNode('PlayerMoveForwardSegment')
cn.addSolid(ForwardSegment)
cn.setFromCollideMask(BitMask32.bit(0))
cn.setIntoCollideMask(BitMask32.allOff())
solid = self.node.attachNewNode(cn)
# solid.show()
base.cTrav.addCollider(solid, self.nodeGroundHandler)
# init play Right Ray
ForwardSegment = CollisionSegment(-2, 0, 3, 2, 0, 3)
cn = CollisionNode('PlayerMoveRightSegment')
cn.addSolid(ForwardSegment)
cn.setFromCollideMask(BitMask32.bit(0))
cn.setIntoCollideMask(BitMask32.allOff())
solid = self.node.attachNewNode(cn)
# solid.show()
base.cTrav.addCollider(solid, self.nodeGroundHandler)
def attachControls(self):
""" attach key events """
# base.accept("space", self.__setattr__, ["readyToJump", True])
# base.accept("space-up", self.__setattr__, ["readyToJump", False])
self.keyEven = [
"s", "s-up", "w", "w-up", "a", "d", "a-up", "d-up", "c", "o",
"mouse3", "mouse3-up", "mouse1", "mouse1-up"
]
base.accept("s", self.__setattr__, ["walk", self.STOP])
base.accept("w", self.__setattr__, ["walk", self.FORWARD])
base.accept("s", self.__setattr__, ["walk", self.BACK])
base.accept("s-up", self.__setattr__, ["walk", self.STOP])
base.accept("w-up", self.__setattr__, ["walk", self.STOP])
base.accept("a", self.__setattr__, ["strafe", self.LEFT])
base.accept("d", self.__setattr__, ["strafe", self.RIGHT])
base.accept("a-up", self.__setattr__, ["strafe", self.STOP])
base.accept("d-up", self.__setattr__, ["strafe", self.STOP])
base.accept("c", self.changeCamera)
base.accept("o", self.doubleVision)
base.accept("mouse3", self.__setattr__, ["RightButton", 1])
base.accept("mouse3-up", self.__setattr__, ["RightButton", 0])
base.accept("mouse1", self.__setattr__, ["LeftButton", 1])
base.accept("mouse1-up", self.__setattr__, ["LeftButton", 0])
def IgnoreControls(self):
for name in self.keyEven:
base.ignore(name)
print base.getAllAccepting()
def initSkill(self):
self.tex = Texture()
self.tex.setMinfilter(Texture.FTLinear)
base.win.addRenderTexture(self.tex,
GraphicsOutput.RTMTriggeredCopyTexture)
self.tex.setClearColor((0, 0, 0, 1))
self.tex.clearImage()
# Create another 2D camera. Tell it to render before the main camera.
self.backcam = base.makeCamera2d(base.win, sort=-10)
self.background = NodePath("background")
self.backcam.reparentTo(self.background)
self.background.setDepthTest(0)
self.background.setDepthWrite(0)
self.backcam.node().getDisplayRegion(0).setClearDepthActive(0)
self.bcard = base.win.getTextureCard()
self.bcard.reparentTo(base.render2d)
self.bcard.setTransparency(1)
self.fcard = base.win.getTextureCard()
self.fcard.reparentTo(base.render2d)
self.fcard.setTransparency(1)
# Add the task that initiates the screenshots.
taskMgr.add(self.takeSnapShot, "takeSnapShot")
if base.win.getGsg().getCopyTextureInverted():
# print("Copy texture is inverted.")
self.bcard.setScale(1, 1, -1)
self.fcard.setScale(1, 1, -1)
self.bcard.hide()
self.fcard.hide()
self.nextclick = 0
self.clickrate = 10000
def takeSnapShot(self, task):
if task.time > self.nextclick:
self.nextclick += 1.0 / self.clickrate
if self.nextclick < task.time:
self.nextclick = task.time
base.win.triggerCopy()
return task.cont
def doubleVision(self):
self.visionState = 1 - self.visionState
if self.visionState == 1:
self.bcard.show()
self.bcard.setColor(1, 1, 1, 0.60)
self.bcard.setScale(1.0)
self.bcard.setPos(-0.05, 0, 0)
self.bcard.setR(0)
self.fcard.show()
self.fcard.setColor(1, 1, 1, 0.60)
self.fcard.setScale(1.0)
self.fcard.setPos(0.05, 0, 0)
self.fcard.setR(0)
self.clickrate = 10000
self.nextclick = 0
else:
self.bcard.hide()
self.fcard.hide()
def changeCamera(self):
if self.cameraState == 1:
self.cameraState = 0
else:
self.cameraState = 1
self.setCamera()
def setCamera(self):
self.cameraoldPos = base.camera.getPos()
self.cameraoldNear = base.cam.node().getLens().getNear()
if self.cameraState == 0:
self.cameranewPos = Vec3(0, -5, 10)
pl = base.cam.node().getLens()
self.cameranewNear = 1
base.cam.node().setLens(pl)
elif self.cameraState == 1:
self.cameranewPos = Vec3(0, -1, 8)
self.cameranewNear = 1
# self.playerModel.hide()
self.playerModel.hide(BitMask32.bit(3))
elif self.cameraState == 2:
self.cameranewPos = Vec3(0, -1.5, 8)
self.cameranewNear = 1
taskMgr.add(self.updatecamera, "updatecamera")
def updatecamera(self, task):
if task.time < 0.2:
camera.setPos(
(self.cameraoldPos * (0.2 - task.time) + self.cameranewPos *
(task.time)) / 0.2)
return task.cont
if self.cameraState == 1:
self.playerModel.hide(BitMask32.bit(3))
else:
self.playerModel.show(BitMask32.bit(3))
pl = base.cam.node().getLens()
pl.setNear(self.cameraoldNear)
base.cam.node().setLens(pl)
return
def erosionUpdate(self, task):
if self.EROSION >= 100:
self.mission.end("endA")
return
if self.EROSION >= 80:
self.visionState = 0
self.doubleVision()
else:
self.visionState = 1
self.doubleVision()
# self.erosionBar['value'] = self.EROSION
self.erosionBar.setScale(1, 1, self.EROSION / 100)
self.erosionBar.setPos(0, 0, -1 + self.EROSION / 100)
if task.time > self.updateTime:
self.EROSION = math.pow(2,
(self.EROSION / 20 - 1)) / 6 + self.EROSION
# print task.time, 'time'
# print self.EROSION
self.updateTime += 10
# print self.updateTime
return task.cont
def erosionUpdateTemp(self):
if self.EROSION >= 100:
if self.game.levelName == 'levelThree':
self.mission.chessBoard.hide()
self.mission.end("endA")
return
if self.EROSION >= 80:
self.visionState = 0
self.doubleVision()
else:
self.visionState = 1
self.doubleVision()
# self.erosionBar['value'] = self.EROSION
self.erosionBar.setScale(1, 1, self.EROSION / 100)
self.erosionBar.setPos(0, 0, -1 + self.EROSION / 100)
def mouseUpdate(self, task):
""" this task updates the mouse """
if self.state == '':
md = base.win.getPointer(0)
x = md.getX()
y = md.getY()
if base.win.movePointer(0,
base.win.getXSize() / 2,
base.win.getYSize() / 2):
self.node.setH(self.node.getH() -
(x - base.win.getXSize() / 2) * 0.1)
base.camera.setP(base.camera.getP() -
(y - base.win.getYSize() / 2) * 0.1)
if (base.camera.getP() < -45.): base.camera.setP(-45)
if (base.camera.getP() > 45.): base.camera.setP(45)
if self.RightButton == 1:
self.shoot.MouseDown(self.node)
self.EROSION += 5
self.RightButton = 0
# check Interactive Goods
nearest = 1000.0
goods = None
for i in range(self.nodeGroundHandler.getNumEntries()):
entry = self.nodeGroundHandler.getEntry(i)
IntoName = entry.getIntoNode().getName()
FromName = entry.getFromNode().getName()
if FromName == 'playerForwardSegment':
if entry.getSurfacePoint(base.camera).getY() < nearest:
nearest = entry.getSurfacePoint(base.camera).getY()
goods = self.goodmanager.GoodsIta.get(IntoName)
if goods and goods.Interactive == True:
# print goods.Name
self.SetMouseModeNormal('Watch')
self.isInteractive = True
self.currentInteract = goods
else:
self.SetMouseModeNormal('Normal')
self.isInteractive = False
self.currentInteract = None
if self.LeftButton == 1 and self.isInteractive:
print 'trigger interactive event'
print goods.Name
self.mission.interactiveWith(goods)
return task.cont
def moveUpdate(self, task):
""" this task makes the player move """
# move where the keys set it
# print self.node.getPos()
nearestForward = 1000.0
nearestRight = 1000.0
RightEntry = None
ForwardEntry = None
for i in range(self.nodeGroundHandler.getNumEntries()):
entry = self.nodeGroundHandler.getEntry(i)
IntoName = entry.getIntoNode().getName()
FromName = entry.getFromNode().getName()
if FromName == 'PlayerMoveForwardSegment' and (
IntoName != 'PlayerCollideNode'):
if entry.getSurfacePoint(self.node).getY() < nearestForward:
nearestForward = entry.getSurfacePoint(self.node).getY()
ForwardEntry = entry
if FromName == 'PlayerMoveRightSegment' and (IntoName !=
'PlayerCollideNode'):
if abs(entry.getSurfacePoint(self.node).getX()) < nearestRight:
nearestRight = abs(entry.getSurfacePoint(self.node).getX())
RightEntry = entry
if nearestForward < 2 and nearestForward > -2:
self.SLOW = abs(nearestForward) * 0.2
self.node.setPos(self.node.getPos() +
ForwardEntry.getSurfaceNormal(render))
else:
self.SLOW = 1
if nearestRight < 2:
self.node.setPos(self.node.getPos() +
RightEntry.getSurfaceNormal(render))
if (nearestForward < 0 and nearestForward > -5.) or nearestRight < 5:
if self.cameraState == 0:
self.cameraState = 2
self.setCamera()
else:
if self.cameraState == 2:
self.cameraState = 0
self.setCamera()
if self.state == '':
self.walksound.setLoop(False)
#self.walksound.stop()
if ((self.walk == self.FORWARD)
and (self.playerModel.getAnimControl('walk').isPlaying()
== False)):
self.walksound.setLoop(True)
self.walksound.setVolume(0.5)
self.walksound.play()
self.playerModel.getAnimControl('walk').play()
elif self.walk == self.STOP and self.playerModel.getAnimControl(
'stand').isPlaying() == False:
self.playerModel.getAnimControl('stand').play()
self.playerModel.getAnimControl('walk').stop()
self.walksound.setLoop(False)
self.walksound.stop()
if self.strafe == LVector3f(
-1, 0, 0) or self.strafe == LVector3f(1, 0, 0):
self.walksound.setLoop(True)
# self.walksound.setVolume(0.5)
self.walksound.play()
elif self.strafe == LVector3f(0, 0, 0):
self.walksound.setLoop(False)
self.walksound.stop()
#elif self.walk == self.BACK:
#self.walksound.setLoop(True)
#self.walksound.setVolume(0.5)
#self.walksound.play()
self.node.setFluidPos(
self.node,
self.walk * globalClock.getDt() * self.speed * self.SLOW)
self.node.setFluidPos(
self.node,
self.strafe * globalClock.getDt() * self.speed * self.SLOW)
return task.cont
# 6/17
def jumpUpdate(self, task):
""" this task simulates gravity and makes the player jump """
# get the highest Z from the down casting ray
highestZ = -100
for i in range(self.nodeGroundHandler.getNumEntries()):
entry = self.nodeGroundHandler.getEntry(i)
# print entry
z = entry.getSurfacePoint(render).getZ()
# if z > highestZ and entry.getFromNode().getName() == 'playerRay' and entry.getIntoNode().getName() != "PlayerCollideNode":
if z > highestZ and entry.getFromNode().getName(
) == 'playerRay' and entry.getIntoNode().getName() == "floor":
highestZ = z
# print highestZ
# gravity effects and jumps
self.node.setZ(self.node.getZ() +
self.jump * globalClock.getDt() * 600)
self.jump -= 1 * globalClock.getDt()
if highestZ > self.node.getZ():
self.jump = 0
self.node.setZ(highestZ)
if self.readyToJump:
self.jump = 1
return task.cont
class ParallaxBackground(object):
__gameEngine = None
__base = None
__gui = None
background = None
background1 = None
background2 = None
backgroundPos = LVector3f(0.0,0.0,0.0)
background1Pos = LVector3f(0.0,0.0,0.0)
background2Pos = LVector3f(0.0,0.0,0.0)
speed1 = LVector3f(0.01,0.0,0.0)
speed2 = LVector3f(0.02, 0.0, 0.0)
speed3 = LVector3f(0.04, 0.0, 0.0)
def __init__(self, gameEngine, base):
self.__base = base
self.__gameEngine = gameEngine
self.loadBackground("textures/back.jpg", "textures/back1.png", "textures/back2.png")
def loadBackground(self, imagepath, imagepath1, imagepath2):
self.background = OnscreenImage(parent=self.__base.render2dp, image=imagepath, pos=self.backgroundPos)
self.preserveImageAspect(self.background)
self.background1 = OnscreenImage(parent=self.__base.render2dp, image=imagepath1, pos=self.backgroundPos)
self.background1.setTransparency(TransparencyAttrib.MAlpha)
self.preserveImageAspect(self.background1)
self.background2 = OnscreenImage(parent=self.__base.render2dp, image=imagepath2, pos=self.backgroundPos)
self.background2.setTransparency(TransparencyAttrib.MAlpha)
self.preserveImageAspect(self.background2)
self.__base.cam2dp.node().getDisplayRegion(0).setSort(-20) # Force the rendering to render the background image first (so that it will be put to the bottom of the scene since other models will be necessarily drawn on top)
def preserveImageAspect(self, image):
image.setScale(float(image.getTexture().getXSize())/self.__base.win.getXSize(), 1, float(image.getTexture().getYSize())/self.__base.win.getYSize())
def updateBackground(self, movementX, elTime):
if (movementX > 0):
self.moveLeft(elTime)
elif (movementX<0):
self.moveRight(elTime)
def moveLeft(self, deltaTime):
newPosX = self.backgroundPos.x + (self.speed1.x) * deltaTime
self.backgroundPos = LVector3f(newPosX, self.backgroundPos.y, self.backgroundPos.z)
self.background.setPos(self.backgroundPos)
newPos1X = self.background1Pos.x + (self.speed2.x) * deltaTime
self.background1Pos = LVector3f(newPos1X, self.background1Pos.y, self.background1Pos.z)
self.background1.setPos(self.background1Pos)
newPos2X = self.background2Pos.x + (self.speed3.x) * deltaTime
self.background2Pos = LVector3f(newPos2X, self.background2Pos.y, self.background2Pos.z)
self.background2.setPos(self.background2Pos)
def moveRight(self, deltaTime):
newPosX = self.backgroundPos.x + -(self.speed1.x) * deltaTime
self.backgroundPos = LVector3f(newPosX, self.backgroundPos.y, self.backgroundPos.z)
self.background.setPos(self.backgroundPos)
newPos1X = self.background1Pos.x + -(self.speed2.x) * deltaTime
self.background1Pos = LVector3f(newPos1X, self.background1Pos.y, self.background1Pos.z)
self.background1.setPos(self.background1Pos)
newPos2X = self.background2Pos.x + -(self.speed3.x) * deltaTime
self.background2Pos = LVector3f(newPos2X, self.background2Pos.y, self.background2Pos.z)
self.background2.setPos(self.background2Pos)
class Jugador(DirectObject):
# Les variables que tinguin un # son canviables, i les que tinguin ## depenen de la nau
WIN_WIDTH = 800 #
H_WIDTH = WIN_WIDTH / 2
WIN_HEIGHT = 600 #
H_HEIGHT = WIN_HEIGHT / 2
CAM_FOV = 51.0
CAM_FOV_RAD = radians(CAM_FOV) / 2
CAM_FOV_RAD_TAN = tan(CAM_FOV_RAD)
VEL_MAX_AVIO = 100 ##
VEL_MIN_AVIO = 30 ##
VEL_AVIO_RECTE = 40.0 ##
VEL_TOMBA_AVIO = 90.0 ##
VEL_COSTAT = 30.0 ##
ACCELERACIO = 35 ##
CAMERA_Y = -9 ##
BALA_VEL_BASE = 500 ##
QUIT_KEY = "escape" #
ACCELERATE_KEY = "w" #
DECELERATE_KEY = "s" #
RIGHT_KEY = "d" #
LEFT_KEY = "a" #
CENTRA_RATA_KEY = "c" #
SHOOT_KEYS = ["mouse1", "e"] #
SHOOT_TIME = 0.15 ##
def __init__(self, base, ini_pos=Point3(0, 100, 100), tipus="kamikaze", wwidth=None, wheight=None):
DirectObject.__init__(self)
if wwidth and wheight:
self.WIN_WIDTH = wwidth
self.H_WIDTH = self.WIN_WIDTH / 2
self.WIN_HEIGHT = wheight
self.H_HEIGHT = self.WIN_HEIGHT / 2
self.keyMap = {"shoot": 0, "centerPointer": 0, "turn": 0}
self.bulletClock = 0.0
self.overheatClock = 0.0
self.BALA_VEL = self.BALA_VEL_BASE + self.VEL_MIN_AVIO
ambient = AmbientLight("alight")
ambientNp = render.attachNewNode(ambient)
ambient.setColor(VBase4(0.3, 0.3, 0.3, 1.0))
self.avio = render.attachNewNode("avio")
self.avio.setHpr(randint(0, 359), randint(0, 359), randint(0, 359))
self.avio.setPos(ini_pos)
self.avioR = self.avio.attachNewNode("avioDum2")
if tipus == "kamikaze":
self.modelAvio = base.loader.loadModel("prova/avio1blend")
else:
self.modelAvio = base.loader.loadModel("prova/avio1blend")
self.modelAvio.reparentTo(self.avioR)
self.avioVel = self.VEL_MIN_AVIO
self.balaDreta = self.modelAvio.find("**/BalaDreta")
self.balaEsquerra = self.modelAvio.find("**/BalaEsquerra")
self.avio.setLight(ambientNp)
self.avio.setAntialias(AntialiasAttrib.MMultisample)
self.modelAvio.setColor(1, 1, 0, 1)
self.modelAvio.setScale(0.51)
lightBales = AmbientLight("dlight")
self.lightBalesNp = base.camera.attachNewNode(lightBales)
self.lightBalesNp.setHpr(0, 0, 0)
# -#-#-#-configuracio de camara
base.disableMouse()
# ~ self.oobe()
base.camera.reparentTo(self.avio)
base.camera.setHpr(self.avio, 0, 0, 0)
base.camera.setPos(self.avio, 0, self.CAMERA_Y, 1.5)
base.camLens.setFov(self.CAM_FOV * (4.0 / 3.0), self.CAM_FOV)
self.mirilla2 = OnscreenImage(image="prova/textures/areatir2.png", parent=pixel2d)
self.mirilla2.setScale(128)
self.mirilla2.setTransparency(1)
self.mirilla2.setPos(self.H_WIDTH, 0, -self.H_HEIGHT)
self.mirilla = base.loader.loadModel("prova/textures/fixador.egg")
self.mirilla.reparentTo(pixel2d)
self.mirilla.setScale(64.0)
self.mirilla.setPos(0, 0, 0)
self.mirilla.find("**/+SequenceNode").node().pose(0)
self.cursorGirar = pixel2d.attachNewNode("cursorGirar")
self.cursorGirarImage = OnscreenImage(image="prova/textures/fletxa.png", parent=self.cursorGirar)
self.cursorGirarImage.setScale(16.0 / 2, 1.0, 32.0 / 2)
self.cursorGirarImage.setPos(0, 0, 0)
self.cursorGirarImage.setHpr(-90, 0, -90)
self.cursorGirarImage.setTransparency(1)
cursorGirarEffect = BillboardEffect.make(
up_vector=Vec3(0, 0, 1),
eye_relative=False,
axial_rotate=False,
offset=0.0,
look_at=self.mirilla2,
look_at_point=Point3(0, 0, 0),
)
self.cursorGirar.setEffect(cursorGirarEffect)
self.overheats = []
for i in range(8):
if i % 2 == 0:
self.overheats.append(OnscreenImage(image="prova/textures/overheat1.png", parent=pixel2d))
else:
self.overheats.append(OnscreenImage(image="prova/textures/overheat2.png", parent=pixel2d))
self.overheats[i].setScale(32.0, 1.0, 32.0)
self.overheats[i].setTransparency(1)
self.overheats[i].hide()
self.overheats[0].setPos(self.H_WIDTH + 36, 0, -self.H_HEIGHT + 36)
self.overheats[0].setHpr(0, 0, 0)
self.overheats[1].setPos(self.H_WIDTH + 36, 0, -self.H_HEIGHT + 36)
self.overheats[1].setHpr(0, 0, 0)
self.overheats[2].setPos(self.H_WIDTH + 36, 0, -self.H_HEIGHT - 36)
self.overheats[2].setHpr(0, 0, 90)
self.overheats[3].setPos(self.H_WIDTH + 36, 0, -self.H_HEIGHT - 36)
self.overheats[3].setHpr(0, 0, 90)
self.overheats[4].setPos(self.H_WIDTH - 36, 0, -self.H_HEIGHT - 36)
self.overheats[4].setHpr(0, 0, 180)
self.overheats[5].setPos(self.H_WIDTH - 36, 0, -self.H_HEIGHT - 36)
self.overheats[5].setHpr(0, 0, 180)
self.overheats[6].setPos(self.H_WIDTH - 36, 0, -self.H_HEIGHT + 36)
self.overheats[6].setHpr(0, 0, -90)
self.overheats[7].setPos(self.H_WIDTH - 36, 0, -self.H_HEIGHT + 36)
self.overheats[7].setHpr(0, 0, -90)
# PARTICLE SYSTEM SETUP
self.particlesDummy = render.attachNewNode("particlesDummy")
self.particlesDummy.setPosHprScale(0, 0, 0, 0, 0, 0, 1, 1, 1)
self.particlesDummy.clearLight(render.find("dlight"))
self.particlesDummy.setLight(self.lightBalesNp)
base.enableParticles()
# COLLISIONS
base.cTrav = CollisionTraverser()
base.cTrav.setRespectPrevTransform(True)
self.balaCol = CollisionNode("balaCol")
self.balaCol.setIntoCollideMask(BitMask32.allOff())
self.balaCol.setFromCollideMask(BitMask32(0x00000001))
balaColSolid = CollisionSphere(0.0, 0.0, 0.0, 0.2)
self.balaCol.addSolid(balaColSolid)
self.pickRay = CollisionNode("pickRay")
self.pickRayNp = base.camera.attachNewNode(self.pickRay)
self.pickRay.setIntoCollideMask(BitMask32.allOff())
self.pickRay.setFromCollideMask(BitMask32(0x00000002))
self.pickRayCHandler = CollisionHandlerQueue()
self.mouseRay = CollisionRay()
self.pickRay.addSolid(self.mouseRay)
self.mouseRay.setOrigin(0, 0, 0)
base.cTrav.addCollider(self.pickRayNp, self.pickRayCHandler)
# ~ self.nearPlane = CollisionNode("nearPlane")
# ~ self.nearPlaneNp = base.camera.attachNewNode(self.nearPlane)
# ~ base.camRays.setIntoCollideMask(BitMask32(0x00000001))
# ~ self.nearPlaneNp.setPos(0, 1, 0)
# ~ self.nearPlaneColSolid = CollisionPlane(Plane(Vec3(0, -1, 0), Point3(0, 1, 0)))
# ~ self.nearPlane.addSolid(self.nearPlaneColSolid)
def giraAvio(task):
timeVar = globalClock.getDt()
point = base.win.getPointer(0)
pointerx = point.getX()
pointery = point.getY()
self.mouseRay.setFromLens(base.camNode, pointerx, pointery)
# Cursors de la pantalla
self.mirilla.setPos(pointerx, 0, -pointery)
self.cursorGirar.setPos(pointerx, 0, -pointery)
r = pow(abs(pointery - self.H_HEIGHT), 2) + pow(abs(pointerx - self.H_WIDTH), 2)
if r > 8000:
self.mirilla.hide()
self.cursorGirar.show()
else:
self.mirilla.show()
self.cursorGirar.hide()
# 3D
pointerx = pointerx - self.H_WIDTH
pointery = pointery - self.H_HEIGHT
self.avioR.setX(self.avio, -pointerx * 3.0 / float(self.WIN_WIDTH))
self.avioR.setZ(self.avio, pointery * 3.0 / (self.WIN_HEIGHT))
self.avio.setH(self.avio, -pointerx * 256.0 / self.WIN_WIDTH * timeVar)
self.avio.setP(self.avio, -pointery * 256.0 / self.WIN_HEIGHT * timeVar)
self.avioR.setR(self.avio, pointerx / 10.0)
self.avioR.setP(self.avio, pointery / 70.0)
self.avioR.setH(self.avio, -pointerx / 50.0)
# ~ self.avioVel += self.avioAcc*timeVar
# ~ self.avio.setPos(self.avio, self.avioVel*timeVar)
return task.cont
def propulsaAvio(acceleracio, task):
self.avioVel += acceleracio * globalClock.getDt()
if self.avioVel < self.VEL_MIN_AVIO:
self.avioVel = self.VEL_MIN_AVIO
elif self.avioVel > self.VEL_MAX_AVIO:
self.avioVel = self.VEL_MAX_AVIO
self.BALA_VEL = self.BALA_VEL_BASE + self.avioVel
# MOSTRA LA VELOCITAT
pos = float(self.avioVel - self.VEL_MIN_AVIO) / (self.VEL_MAX_AVIO - self.VEL_MIN_AVIO)
base.camera.setY(self.CAMERA_Y - pos * 4)
# ~ self.marcaVelocitat.setX(MARCAVEL_INI_X+pos*137.)
return task.cont
self.haCremat = False
def mouAvio(task):
timeVar = globalClock.getDt()
self.avio.setPos(self.avio, 0, self.avioVel * timeVar, 0)
if self.keyMap["shoot"] == 1:
if self.bulletClock <= 0.0:
self.bulletClock = self.SHOOT_TIME
if not self.haCremat:
if self.overheatClock > 16:
self.haCremat = True
self.overheatClock = 18
else:
self.overheatClock += self.SHOOT_TIME
shoot()
else:
self.bulletClock -= timeVar
else:
self.bulletClock = 0.0
self.overheatClock -= timeVar
if self.overheatClock < 16:
self.haCremat = False
if self.haCremat:
self.overheatClock -= timeVar
if self.overheatClock < 0:
self.overheatClock = 0
elif self.overheatClock < 2:
self.overheats[0].hide()
elif self.overheatClock < 4:
self.overheats[1].hide()
self.overheats[0].show()
elif self.overheatClock < 6:
self.overheats[2].hide()
self.overheats[1].show()
elif self.overheatClock < 8:
self.overheats[3].hide()
self.overheats[2].show()
elif self.overheatClock < 10:
self.overheats[4].hide()
self.overheats[3].show()
elif self.overheatClock < 12:
self.overheats[5].hide()
self.overheats[4].show()
elif self.overheatClock < 14:
self.overheats[6].hide()
self.overheats[5].show()
self.overheats[7].hide()
elif self.overheatClock < 16:
self.overheats[7].hide()
self.overheats[6].show()
else:
self.overheats[7].show()
if self.keyMap["turn"] == 1:
self.avio.setX(self.avio, -self.VEL_COSTAT * timeVar)
elif self.keyMap["turn"] == -1:
self.avio.setX(self.avio, self.VEL_COSTAT * timeVar)
return task.cont
def avioRecte(task):
p = self.avio.getP(render)
if p > 170 or p < -170:
return task.cont
timeVar = globalClock.getDt()
roll = self.avio.getR(render)
if roll < -self.VEL_AVIO_RECTE * timeVar:
self.avio.setR(render, roll + self.VEL_AVIO_RECTE * timeVar)
elif roll <= self.VEL_AVIO_RECTE * timeVar:
self.avio.setR(render, 0)
else:
self.avio.setR(render, roll - self.VEL_AVIO_RECTE * timeVar)
return task.cont
self.balaPositiu = True
def shoot():
bala = self.particlesDummy.attachNewNode("balaDummy")
balaImage = OnscreenImage(image="prova/textures/bala.png", parent=bala)
balaImage.setTransparency(1)
balaImage.setScale(0.1, 1.0, 0.2)
balaImage.setBillboardPointEye()
bala.setQuat(self.modelAvio.getQuat(render))
if self.balaPositiu:
bala.setPos(self.balaDreta.getPos(render))
self.balaPositiu = False
else:
bala.setPos(self.balaEsquerra.getPos(render))
self.balaPositiu = True
balaSphere = bala.attachNewNode(self.balaCol)
balaColHandler = CollisionHandlerQueue()
base.cTrav.addCollider(balaSphere, balaColHandler)
# ~ if type(self.shootPoint) == 'libpanda.Point3':
# ~ bala.lookAt(self.shootPoint)
# ~ else: bala.setH(bala, 180.)
taskMgr.add(mouBala, "moubala", extraArgs=[bala, balaImage, self.BALA_VEL, balaColHandler], appendTask=True)
def mouBala(bala, balaImage, vel, queue, task):
if task.time > 3:
balaImage.detachNode()
expbala = ParticleEffect()
expbala.reparentTo(self.particlesDummy)
expbala.loadConfig("explosio.ptf")
expbala.start(bala)
taskMgr.doMethodLater(0.25, suprimir, "suprimir", extraArgs=[bala, expbala])
return task.done
if queue.getNumEntries() != 0:
balaImage.detachNode()
entry = queue.getEntry(0)
bala.setPos(entry.getSurfacePoint(self.particlesDummy))
expbala = ParticleEffect()
expbala.reparentTo(self.particlesDummy)
expbala.loadConfig("explosio.ptf")
expbala.start(bala)
taskMgr.doMethodLater(0.25, suprimir, "suprimir", extraArgs=[bala, expbala])
return task.done
bala.setFluidPos(bala, 0, vel * globalClock.getDt(), 0)
balaImage.setR(balaImage, 1000 * globalClock.getDt())
return task.cont
def suprimir(bala, expbala):
bala.detachNode()
expbala.cleanup()
expbala.detachNode()
def setKey(key, value):
self.keyMap[key] = value
def centraRatoli():
point = base.win.getPointer(0)
x = point.getX()
y = point.getY()
x -= self.H_WIDTH
y -= self.H_HEIGHT
r = sqrt(pow(abs(y), 2) + pow(abs(x), 2))
def centra(t, x, y):
base.win.movePointer(0, trunc(x * t) + self.H_WIDTH, trunc(y * t) + self.H_HEIGHT)
i = LerpFunc(
centra,
fromData=1.0,
toData=0.0,
duration=r / 700.0,
blendType="easeInOut",
extraArgs=[x, y],
name="centraRata",
)
i.start()
self.previousPos = 0
self.interval01 = LerpPosHprInterval(
self.modelAvio,
0.5,
Point3(3, 0, 0),
VBase3(0, 0, 70),
Point3(0, 0, 0),
VBase3(0, 0, 0),
blendType="easeInOut",
)
self.interval10 = LerpPosHprInterval(
self.modelAvio,
0.5,
Point3(0, 0, 0),
VBase3(0, 0, 0),
Point3(-3, 0, 0),
VBase3(0, 0, -70),
blendType="easeInOut",
)
self.interval02 = LerpPosHprInterval(
self.modelAvio,
0.5,
Point3(-3, 0, 0),
VBase3(0, 0, -70),
Point3(0, 0, 0),
VBase3(0, 0, 0),
blendType="easeInOut",
)
self.interval20 = LerpPosHprInterval(
self.modelAvio,
0.5,
Point3(0, 0, 0),
VBase3(0, 0, 0),
Point3(3, 0, 0),
VBase3(0, 0, 70),
blendType="easeInOut",
)
self.interval12 = LerpPosHprInterval(
self.modelAvio,
1.0,
Point3(-3, 0, 0),
VBase3(0, 0, -70),
Point3(3, 0, 0),
VBase3(0, 0, 70),
blendType="easeInOut",
)
self.interval21 = LerpPosHprInterval(
self.modelAvio,
1.0,
Point3(3, 0, 0),
VBase3(0, 0, 70),
Point3(-3, 0, 0),
VBase3(0, 0, -70),
blendType="easeInOut",
)
def allIntervalsStopped():
if (
self.interval01.isStopped()
and self.interval10.isStopped()
and self.interval02.isStopped()
and self.interval20.isStopped()
and self.interval12.isStopped()
and self.interval21.isStopped()
):
return True
else:
return False
def tombaAvio(task):
if self.keyMap["turn"] == 0 and self.previousPos != 0 and allIntervalsStopped():
if self.previousPos == 1:
self.interval10.start()
else:
self.interval20.start()
self.previousPos = 0
elif self.keyMap["turn"] == -1 and self.previousPos != -1 and allIntervalsStopped():
if self.previousPos == 0:
self.interval01.start()
else:
self.interval21.start()
self.previousPos = -1
elif self.keyMap["turn"] == 1 and self.previousPos != 1 and allIntervalsStopped():
if self.previousPos == 0:
self.interval02.start()
else:
self.interval12.start()
self.previousPos = 1
return task.cont
def anim1():
self.mirilla.find("**/+SequenceNode").node().setPlayRate(1.0)
self.mirilla.find("**/+SequenceNode").node().play(0, 3)
def anim2():
self.mirilla.find("**/+SequenceNode").node().setPlayRate(1.0)
self.mirilla.find("**/+SequenceNode").node().play(4, 8)
def anim3():
self.mirilla.find("**/+SequenceNode").node().setPlayRate(-1.0)
self.mirilla.find("**/+SequenceNode").node().play(0, 3)
def anim4():
self.mirilla.find("**/+SequenceNode").node().setPlayRate(-1.0)
self.mirilla.find("**/+SequenceNode").node().play(3, 8)
# events
self.accept(self.QUIT_KEY, sysExit, [0])
self.accept(
self.ACCELERATE_KEY,
taskMgr.add,
[propulsaAvio, "propulsaAvio1", None, [self.ACCELERACIO], None, None, True],
)
self.accept(self.ACCELERATE_KEY + "-up", taskMgr.remove, ["propulsaAvio1"])
self.accept(
self.DECELERATE_KEY,
taskMgr.add,
[propulsaAvio, "propulsaAvio2", None, [-self.ACCELERACIO], None, None, True],
)
self.accept(self.DECELERATE_KEY + "-up", taskMgr.remove, ["propulsaAvio2"])
for key in self.SHOOT_KEYS:
self.accept(key, setKey, ["shoot", 1])
self.accept(key + "-up", setKey, ["shoot", 0])
self.accept(self.RIGHT_KEY, setKey, ["turn", -1])
self.accept(self.LEFT_KEY, setKey, ["turn", 1])
self.accept(self.RIGHT_KEY + "-up", setKey, ["turn", 0])
self.accept(self.LEFT_KEY + "-up", setKey, ["turn", 0])
self.accept(self.CENTRA_RATA_KEY, centraRatoli)
self.accept("n", anim1)
self.accept("m", anim2)
self.accept("v", anim3)
self.accept("b", anim4)
taskMgr.add(giraAvio, "GiraAvio")
taskMgr.add(mouAvio, "MouAvio")
taskMgr.add(avioRecte, "avioRecte")
taskMgr.add(tombaAvio, "tombaAvio")
class Drive(ShowBase):
def __init__(self):
ShowBase.__init__(self)
#Setup
scene = BulletWorld()
scene.setGravity(Vec3(0, 0, -9.81))
base.setBackgroundColor(0.6,0.9,0.9)
fog = Fog("The Fog")
fog.setColor(0.9,0.9,1.0)
fog.setExpDensity(0.003)
render.setFog(fog)
#Lighting
#Sun light
sun = DirectionalLight("The Sun")
sun_np = render.attachNewNode(sun)
sun_np.setHpr(0,-60,0)
render.setLight(sun_np)
#Ambient light
amb = AmbientLight("The Ambient Light")
amb.setColor(VBase4(0.39,0.39,0.39, 1))
amb_np = render.attachNewNode(amb)
render.setLight(amb_np)
#Variables
self.gear = 0
self.start = 0
self.Pbrake = 0
self.terrain_var = 1
self.time = 0
self.headlight_var = 0
self.RPM = 0
self.clutch = 0
self.carmaxspeed = 100 #KPH
self.carmaxreversespeed = -40 #KPH
self.steering = 0
#Functions
def V1():
camera.setPos(0.25,-1.2,0.5)
camera.setHpr(0,-13,0)
def V2():
camera.setPos(0,-15,3)
camera.setHpr(0,-10,0)
def V3():
camera.setPos(0,0,9)
camera.setHpr(0,-90,0)
def up():
self.gear = self.gear -1
if self.gear < -1:
self.gear = -1
def down():
self.gear = self.gear +1
if self.gear > 1:
self.gear = 1
def start_function():
self.start = 1
self.start_sound.play()
self.engine_idle_sound.play()
self.RPM = 1000
def stop_function():
self.start = 0
self.engine_idle_sound.stop()
def parkingbrake():
self.Pbrake = (self.Pbrake + 1) % 2
def rotate():
Car_np.setHpr(0, 0, 0)
def horn():
self.horn_sound.play()
def set_time():
if self.time == -1:
sun.setColor(VBase4(0.4, 0.3, 0.3, 1))
base.setBackgroundColor(0.8,0.7,0.7)
if self.time == 0:
sun.setColor(VBase4(0.7, 0.7, 0.7, 1))
base.setBackgroundColor(0.6,0.9,0.9)
if self.time == 1:
sun.setColor(VBase4(0.2, 0.2, 0.2, 1))
base.setBackgroundColor(0.55,0.5,0.5)
if self.time == 2:
sun.setColor(VBase4(0.02, 0.02, 0.05, 1))
base.setBackgroundColor(0.3,0.3,0.3)
if self.time == -2:
self.time = -1
if self.time == 3:
self.time = 2
def time_forward():
self.time = self.time + 1
def time_backward():
self.time = self.time -1
def set_terrain():
if self.terrain_var == 1:
self.ground_model.setTexture(self.ground_tex, 1)
self.ground_model.setScale(3)
if self.terrain_var == 2:
self.ground_model.setTexture(self.ground_tex2, 1)
self.ground_model.setScale(3)
if self.terrain_var == 3:
self.ground_model.setTexture(self.ground_tex3, 1)
self.ground_model.setScale(4)
if self.terrain_var == 4:
self.terrain_var = 1
if self.terrain_var == 0:
self.terrain_var = 3
def next_terrain():
self.terrain_var = self.terrain_var + 1
def previous_terrain():
self.terrain_var = self.terrain_var - 1
def show_menu():
self.menu_win.show()
self.a1.show()
self.a2.show()
self.a3.show()
self.a4.show()
self.t1.show()
self.t2.show()
self.ok.show()
self.exit_button.show()
def hide_menu():
self.menu_win.hide()
self.a1.hide()
self.a2.hide()
self.a3.hide()
self.a4.hide()
self.ok.hide()
self.t1.hide()
self.t2.hide()
self.exit_button.hide()
def Menu():
self.menu_win = OnscreenImage(image = "Textures/menu.png", pos = (0.9,0,0), scale = (0.5))
self.menu_win.setTransparency(TransparencyAttrib.MAlpha)
#The Arrow Buttons
self.a1 = DirectButton(text = "<", scale = 0.2, pos = (0.55,0,0.25), command = previous_terrain)
self.a2 = DirectButton(text = ">", scale = 0.2, pos = (1.15,0,0.25), command = next_terrain)
self.a3 = DirectButton(text = "<", scale = 0.2, pos = (0.55,0,0.0), command = time_backward)
self.a4 = DirectButton(text = ">", scale = 0.2, pos = (1.15,0,0.0), command = time_forward)
#The Text
self.t1 = OnscreenText(text = "Terrain", pos = (0.85,0.25,0), scale = 0.1, fg = (0.4,0.4,0.5,1))
self.t2 = OnscreenText(text = "Time", pos = (0.85,0,0), scale = 0.1, fg = (0.4,0.4,0.5,1))
#The Buttons
self.ok = DirectButton(text = "Okay", scale = 0.11, pos = (0.87,0,-0.25), command = hide_menu)
self.exit_button = DirectButton(text = "Quit", scale = 0.11, pos = (0.87,0,-0.42), command = sys.exit)
Menu()
def take_screenshot():
base.screenshot("Screenshot")
def set_headlights():
if self.headlight_var == 1:
Headlight1.setColor(VBase4(9.0,8.9,8.9,1))
Headlight2.setColor(VBase4(9.0,8.9,8.9,1))
if self.headlight_var == 0:
Headlight1.setColor(VBase4(0,0,0,1))
Headlight2.setColor(VBase4(0,0,0,1))
def headlights():
self.headlight_var = (self.headlight_var + 1) % 2
def update_rpm():
#Simulate RPM
if self.start == 1:
if self.gear == 0:
self.RPM = self.RPM - self.RPM / 400
else:
self.RPM = self.RPM + self.carspeed / 9
self.RPM = self.RPM - self.RPM / 200
#Reset RPM to 0 when engine is off
if self.start == 0:
if self.RPM > 0.0:
self.RPM = self.RPM - 40
if self.RPM < 10:
self.RPM = 0.0
#Idle RPM power
if self.start == 1:
if self.RPM < 650:
self.RPM = self.RPM + 4
if self.RPM < 600:
self.clutch = 1
else:
self.clutch = 0
#RPM limit
if self.RPM > 6000:
self.RPM = 6000
#Controls
inputState.watchWithModifiers("F", "arrow_up")
inputState.watchWithModifiers("B", "arrow_down")
inputState.watchWithModifiers("L", "arrow_left")
inputState.watchWithModifiers("R", "arrow_right")
do = DirectObject()
do.accept("escape", show_menu)
do.accept("1", V1)
do.accept("2", V2)
do.accept("3", V3)
do.accept("page_up", up)
do.accept("page_down", down)
do.accept("x-repeat", start_function)
do.accept("x", stop_function)
do.accept("p", parkingbrake)
do.accept("backspace", rotate)
do.accept("enter", horn)
do.accept("f12", take_screenshot)
do.accept("h", headlights)
#The ground
self.ground = BulletPlaneShape(Vec3(0, 0, 1,), 1)
self.ground_node = BulletRigidBodyNode("The ground")
self.ground_node.addShape(self.ground)
self.ground_np = render.attachNewNode(self.ground_node)
self.ground_np.setPos(0, 0, -2)
scene.attachRigidBody(self.ground_node)
self.ground_model = loader.loadModel("Models/plane.egg")
self.ground_model.reparentTo(render)
self.ground_model.setPos(0,0,-1)
self.ground_model.setScale(3)
self.ground_tex = loader.loadTexture("Textures/ground.png")
self.ground_tex2 = loader.loadTexture("Textures/ground2.png")
self.ground_tex3 = loader.loadTexture("Textures/ground3.png")
self.ground_model.setTexture(self.ground_tex, 1)
#The car
Car_shape = BulletBoxShape(Vec3(1, 2.0, 1.0))
Car_node = BulletRigidBodyNode("The Car")
Car_node.setMass(1200.0)
Car_node.addShape(Car_shape)
Car_np = render.attachNewNode(Car_node)
Car_np.setPos(0,0,3)
Car_np.setHpr(0,0,0)
Car_np.node().setDeactivationEnabled(False)
scene.attachRigidBody(Car_node)
Car_model = loader.loadModel("Models/Car.egg")
Car_model.reparentTo(Car_np)
Car_tex = loader.loadTexture("Textures/Car1.png")
Car_model.setTexture(Car_tex, 1)
self.Car_sim = BulletVehicle(scene, Car_np.node())
self.Car_sim.setCoordinateSystem(ZUp)
scene.attachVehicle(self.Car_sim)
#The inside of the car
Car_int = loader.loadModel("Models/inside.egg")
Car_int.reparentTo(Car_np)
Car_int_tex = loader.loadTexture("Textures/inside.png")
Car_int.setTexture(Car_int_tex, 1)
Car_int.setTransparency(TransparencyAttrib.MAlpha)
#The steering wheel
Sw = loader.loadModel("Models/Steering wheel.egg")
Sw.reparentTo(Car_np)
Sw.setPos(0.25,0,-0.025)
#The first headlight
Headlight1 = Spotlight("Headlight1")
lens = PerspectiveLens()
lens.setFov(180)
Headlight1.setLens(lens)
Headlight1np = render.attachNewNode(Headlight1)
Headlight1np.reparentTo(Car_np)
Headlight1np.setPos(-0.8,2.5,-0.5)
Headlight1np.setP(-15)
render.setLight(Headlight1np)
#The second headlight
Headlight2 = Spotlight("Headlight2")
Headlight2.setLens(lens)
Headlight2np = render.attachNewNode(Headlight2)
Headlight2np.reparentTo(Car_np)
Headlight2np.setPos(0.8,2.5,-0.5)
Headlight2np.setP(-15)
render.setLight(Headlight2np)
#Sounds
self.horn_sound = loader.loadSfx("Sounds/horn.ogg")
self.start_sound = loader.loadSfx("Sounds/enginestart.ogg")
self.engine_idle_sound = loader.loadSfx("Sounds/engineidle.ogg")
self.engine_idle_sound.setLoop(True)
self.accelerate_sound = loader.loadSfx("Sounds/enginethrottle.ogg")
#Camera
base.disableMouse()
camera.reparentTo(Car_np)
camera.setPos(0,-15,3)
camera.setHpr(0,-10,0)
#Wheel function
def Wheel(pos, np, r, f):
w = self.Car_sim.createWheel()
w.setNode(np.node())
w.setChassisConnectionPointCs(pos)
w.setFrontWheel(f)
w.setWheelDirectionCs(Vec3(0, 0, -1))
w.setWheelAxleCs(Vec3(1, 0, 0))
w.setWheelRadius(r)
w.setMaxSuspensionTravelCm(40)
w.setSuspensionStiffness(120)
w.setWheelsDampingRelaxation(2.3)
w.setWheelsDampingCompression(4.4)
w.setFrictionSlip(50)
w.setRollInfluence(0.1)
#Wheels
w1_np = loader.loadModel("Models/Lwheel")
w1_np.reparentTo(render)
w1_np.setColorScale(0,6)
Wheel(Point3(-1,1,-0.6), w1_np, 0.4, False)
w2_np = loader.loadModel("Models/Rwheel")
w2_np.reparentTo(render)
w2_np.setColorScale(0,6)
Wheel(Point3(-1.1,-1.2,-0.6), w2_np, 0.4, True)
w3_np = loader.loadModel("Models/Lwheel")
w3_np.reparentTo(render)
w3_np.setColorScale(0,6)
Wheel(Point3(1.1,-1,-0.6), w3_np, 0.4, True)
w4_np = loader.loadModel("Models/Rwheel")
w4_np.reparentTo(render)
w4_np.setColorScale(0,6)
Wheel(Point3(1,1,-0.6), w4_np, 0.4, False)
#The engine and steering
def processInput(dt):
#Vehicle properties
self.steeringClamp = 35.0
self.steeringIncrement = 70
engineForce = 0.0
brakeForce = 0.0
#Get the vehicle's current speed
self.carspeed = self.Car_sim.getCurrentSpeedKmHour()
#Engage clutch when in gear 0
if self.gear == 0:
self.clutch = 1
#Slow the steering when at higher speeds
self.steeringIncrement = self.steeringIncrement - self.carspeed / 1.5
#Reset the steering
if not inputState.isSet("L") and not inputState.isSet("R"):
if self.steering < 0.00:
self.steering = self.steering + 0.6
if self.steering > 0.00:
self.steering = self.steering - 0.6
if self.steering < 1.0 and self.steering > -1.0:
self.steering = 0
#Slow the car down while it's moving
if self.clutch == 0:
brakeForce = brakeForce + self.carspeed / 5
else:
brakeForce = brakeForce + self.carspeed / 15
#Forward
if self.start == 1:
if inputState.isSet("F"):
self.RPM = self.RPM + 35
self.accelerate_sound.play()
if self.clutch == 0:
if self.gear == -1:
if self.carspeed > self.carmaxreversespeed:
engineForce = -self.RPM / 3
if self.gear == 1:
if self.carspeed < self.carmaxspeed:
engineForce = self.RPM / 1
#Brake
if inputState.isSet("B"):
engineForce = 0.0
brakeForce = 12.0
if self.gear != 0 and self.clutch == 0:
self.RPM = self.RPM - 20
#Left
if inputState.isSet("L"):
if self.steering < 0.0:
#This makes the steering reset at the correct speed when turning from right to left
self.steering += dt * self.steeringIncrement + 0.6
self.steering = min(self.steering, self.steeringClamp)
else:
#Normal steering
self.steering += dt * self.steeringIncrement
self.steering = min(self.steering, self.steeringClamp)
#Right
if inputState.isSet("R"):
if self.steering > 0.0:
#This makes the steering reset at the correct speed when turning from left to right
self.steering -= dt * self.steeringIncrement + 0.6
self.steering = max(self.steering, -self.steeringClamp)
else:
#Normal steering
self.steering -= dt * self.steeringIncrement
self.steering = max(self.steering, -self.steeringClamp)
#Park
if self.Pbrake == 1:
brakeForce = 10.0
if self.gear != 0 and self. clutch == 0:
self.RPM = self.RPM - 20
#Apply forces to wheels
self.Car_sim.applyEngineForce(engineForce, 0);
self.Car_sim.applyEngineForce(engineForce, 3);
self.Car_sim.setBrake(brakeForce, 1);
self.Car_sim.setBrake(brakeForce, 2);
self.Car_sim.setSteeringValue(self.steering, 0);
self.Car_sim.setSteeringValue(self.steering, 3);
#Steering wheel
Sw.setHpr(0,0,-self.steering*10)
#The HUD
self.gear_hud = OnscreenImage(image = "Textures/gear_hud.png", pos = (-1,0,-0.85), scale = (0.2))
self.gear_hud.setTransparency(TransparencyAttrib.MAlpha)
self.gear2_hud = OnscreenImage(image = "Textures/gear2_hud.png", pos = (-1,0,-0.85), scale = (0.2))
self.gear2_hud.setTransparency(TransparencyAttrib.MAlpha)
self.starter = OnscreenImage(image = "Textures/starter.png", pos = (-1.2,0,-0.85), scale = (0.15))
self.starter.setTransparency(TransparencyAttrib.MAlpha)
self.park = OnscreenImage(image = "Textures/pbrake.png", pos = (-0.8,0,-0.85), scale = (0.1))
self.park.setTransparency(TransparencyAttrib.MAlpha)
self.rev_counter = OnscreenImage(image = "Textures/dial.png", pos = (-1.6, 0.0, -0.70), scale = (0.6,0.6,0.4))
self.rev_counter.setTransparency(TransparencyAttrib.MAlpha)
self.rev_needle = OnscreenImage(image = "Textures/needle.png", pos = (-1.6, 0.0, -0.70), scale = (0.5))
self.rev_needle.setTransparency(TransparencyAttrib.MAlpha)
self.rev_text = OnscreenText(text = " ", pos = (-1.6, -0.90, 0), scale = 0.05)
self.speedometer = OnscreenImage(image = "Textures/dial.png", pos = (-1.68, 0.0, -0.10), scale = (0.7,0.7,0.5))
self.speedometer.setTransparency(TransparencyAttrib.MAlpha)
self.speedometer_needle = OnscreenImage(image = "Textures/needle.png", pos = (-1.68, 0.0, -0.10), scale = (0.5))
self.speedometer_needle.setTransparency(TransparencyAttrib.MAlpha)
self.speedometer_text = OnscreenText(text = " ", pos = (-1.68, -0.35, 0), scale = 0.05)
#Update the HUD
def Update_HUD():
#Move gear selector
if self.gear == -1:
self.gear2_hud.setPos(-1,0,-0.785)
if self.gear == 0:
self.gear2_hud.setPos(-1,0,-0.85)
if self.gear == 1:
self.gear2_hud.setPos(-1,0,-0.91)
#Rotate starter
if self.start == 0:
self.starter.setHpr(0,0,0)
else:
self.starter.setHpr(0,0,45)
#Update the parking brake light
if self.Pbrake == 1:
self.park.setImage("Textures/pbrake2.png")
self.park.setTransparency(TransparencyAttrib.MAlpha)
else:
self.park.setImage("Textures/pbrake.png")
self.park.setTransparency(TransparencyAttrib.MAlpha)
#Update the rev counter
self.rev_needle.setR(self.RPM/22)
rev_string = str(self.RPM)[:4]
self.rev_text.setText(rev_string+" RPM")
#Update the speedometer
if self.carspeed > 0.0:
self.speedometer_needle.setR(self.carspeed*2.5)
if self.carspeed < 0.0:
self.speedometer_needle.setR(-self.carspeed*2.5)
speed_string = str(self.carspeed)[:3]
self.speedometer_text.setText(speed_string+" KPH")
#Update the program
def update(task):
dt = globalClock.getDt()
processInput(dt)
Update_HUD()
set_time()
set_terrain()
set_headlights()
update_rpm()
scene.doPhysics(dt, 5, 1.0/180.0)
return task.cont
taskMgr.add(update, "Update")
class DemoBase(ShowBase, ABC):
def __init__(self):
super().__init__()
# Allow panda to synthesize shaders. Make sure hardware-animated-vertices is set
# to true in panda config.
render.setShaderAuto()
# Show FPS
self.setFrameRateMeter(True)
# Load character
self.character = Actor('data/character/character')
self.character.reparentTo(self.render)
self.joints = []
for name in JOINT_NAMES:
j = self.character.controlJoint(None, 'modelRoot', name)
j.reparentTo(self.render)
self.joints.append(j)
# Add lights
dlight = core.DirectionalLight('DirectionalLight')
dlight.setDirection(core.LVector3(2, 0, -1))
dlight.setColor(core.LColor(1, 1, 1, 1))
dlnp = self.render.attachNewNode(dlight)
self.render.setLight(dlnp)
alight = core.AmbientLight('AmbientLight')
alight.setColor(core.LColor(0.6, 0.6, 0.6, 1))
alnp = self.render.attachNewNode(alight)
self.render.setLight(alnp)
# Camera angle in xy-plane (degrees)
self.camera_angle = 0
# Camera control
self.cam_left_pressed, self.cam_right_pressed = 0, 0
self.accept('a', self.set_cam_left_pressed, [1])
self.accept('a-up', self.set_cam_left_pressed, [0])
self.accept('d', self.set_cam_right_pressed, [1])
self.accept('d-up', self.set_cam_right_pressed, [0])
# Pad display
self.pad_radius = 60
self.pad_outline = OnscreenImage('project/data/pad/pad_outline.png',
(0, 0, 0))
self.pad_outline.setTransparency(core.TransparencyAttrib.MAlpha)
self.pad_outline.hide()
self.pad_response_circle = OnscreenImage(
'project/data/pad/pad_response_indicator.png', (0, 0, 0))
self.pad_response_circle.setTransparency(
core.TransparencyAttrib.MAlpha)
self.pad_response_circle.hide()
self.accept('window-event', self.handle_window_event)
# Pad control
self.mouse1_pressed, self.controlling_pad = False, False
self.accept('mouse1', self.set_mouse1_pressed, [True])
self.accept('mouse1-up', self.set_mouse1_pressed, [False])
# Load terrain
self.heightmaps = {}
self.set_heightmap('hmap2', 'project/data/heightmaps/hmap2.npy')
# Heightmap choice
self.accept('1', self.set_heightmap,
['hmap1', 'project/data/heightmaps/hmap1.npy'])
self.accept('2', self.set_heightmap,
['hmap2', 'project/data/heightmaps/hmap2.npy'])
self.accept('3', self.set_heightmap,
['hmap3', 'project/data/heightmaps/hmap3.npy'])
self.accept('4', self.set_heightmap,
['hmap4', 'project/data/heightmaps/hmap4.npy'])
self.accept('5', self.set_heightmap,
['hmap5', 'project/data/heightmaps/hmap5.npy'])
# Tasks
self.taskMgr.add(self.update_pad, 'UpdatePadTask', sort=1)
self.last_update_char_time = 0
self.taskMgr.add(self.update_character, 'UpdateCharacterTask', sort=2)
self.last_update_cam_time = 0
self.taskMgr.add(self.update_camera, 'UpdateCameraTask', sort=3)
def set_cam_left_pressed(self, val):
self.cam_left_pressed = val
def set_cam_right_pressed(self, val):
self.cam_right_pressed = val
def set_mouse1_pressed(self, val):
self.mouse1_pressed = val
if self.mouse1_pressed and self.mouseWatcherNode.hasMouse():
mpos = self.screen_coords_to_pixels(
self.mouseWatcherNode.getMouse())
diff = mpos - self.pad_center
self.controlling_pad = diff.lengthSquared() <= self.pad_radius**2
else:
self.controlling_pad = False
def handle_window_event(self, window):
self.window_w, self.window_h = window.getSize()
min_dim = min(self.window_w, self.window_h)
self.pad_radius = min_dim * 0.1
if self.window_w < 1300:
self.pad_center = core.LVector2(min_dim * 0.15, min_dim * 0.15)
else:
self.pad_center = core.LVector2(self.window_w * 0.75,
self.window_h * 0.5)
self.pad_outline.setPos(self.pixels_to_im_coords(self.pad_center))
self.pad_outline.setScale(2 * self.pad_radius / min_dim)
self.pad_outline.show()
self.pad_response_circle.setScale(0.2 * self.pad_radius / min_dim)
# Propagate event
self.windowEvent(window)
# Converts from screen coords in the [-1, 1] range to pixel coords
def screen_coords_to_pixels(self, point):
x_frac, y_frac = (point + 1.0) / 2.0
return core.LVector2(x_frac * self.window_w,
(1 - y_frac) * self.window_h)
# Converts from pixel coords to coords that can be passed in to OnscreenImage.setPos()
def pixels_to_im_coords(self, point):
px, py = point
px, py = px - self.window_w / 2, py - self.window_h / 2
return core.LVector3(px, 0,
-py) * (2.0 / min(self.window_w, self.window_h))
def update_pad(self, task):
if self.controlling_pad and self.mouseWatcherNode.hasMouse():
mpos = self.screen_coords_to_pixels(
self.mouseWatcherNode.getMouse())
pad_input = (mpos - self.pad_center) * PAD_SENSITIVITY
if pad_input.lengthSquared() > 1:
pad_input.normalize()
resp_circle_pos = self.pad_center + pad_input * (self.pad_radius *
0.9)
self.pad_response_circle.setPos(
self.pixels_to_im_coords(resp_circle_pos))
self.pad_response_circle.show()
else:
pad_input = core.LVector2()
self.pad_response_circle.hide()
pad_input.setY(-pad_input.getY()) # flip y
self.pad_input = pad_input
return Task.cont
def set_joint_global_xforms(self, global_xforms):
# Invert global transforms
inverse_global_xforms = [None] * NUM_JOINTS
for i in PARENT_JOINTS:
inverse_global_xforms[i] = core.LMatrix4()
inverse_global_xforms[i].invertAffineFrom(global_xforms[i])
# Use each joint's global xform and the inverse of its parent's global xform to
# compute and apply its local xform
self.joints[0].setMat(global_xforms[0])
for i in range(1, NUM_JOINTS):
local_xform = global_xforms[i] * inverse_global_xforms[
JOINT_PARENTS[i]]
self.joints[i].setMat(local_xform)
def update_character(self, task):
dt = task.time - self.last_update_char_time
self._update_character(task.time, dt)
self.character.setPos(self.char_pos)
self.set_joint_global_xforms([
core.LMatrix4(*m)
for m in self.joint_global_xforms.reshape(31, 16)
])
self.last_update_char_time = task.time
return Task.cont
@abstractmethod
def _update_character(self, t, dt):
'''Should set self.char_pos and self.joint_global_xforms.'''
raise NotImplementedError()
def update_camera(self, task):
dt = task.time - self.last_update_cam_time
# Update camera angle
self.camera_angle += 90 * (self.cam_right_pressed -
self.cam_left_pressed) * dt
# Reposition camera
ang_rads = self.camera_angle * pi / 180
cam_offset = core.LVector3(300 * cos(ang_rads), 300 * sin(ang_rads),
320)
self.camera.setPos(self.char_pos + cam_offset)
self.camera.lookAt(self.char_pos + core.LVector3(0, 0, 80),
core.LVector3(0, 0, 1))
self.last_update_cam_time = task.time
return Task.cont
def set_heightmap(self, name, fname):
if name not in self.heightmaps:
self.heightmaps[name] = Heightmap(name, fname, self.render)
reset = False
if hasattr(self, 'heightmap'):
self.heightmap.model_np.stash()
reset = True
self.heightmap = self.heightmaps[name]
self.heightmap.model_np.unstash()
if reset: self.reset_level()
def reset_level(self):
self.camera_angle = 0
self.char_pos = core.LVector3()
class GUI(object):
__selected = None
__gameEngine = None
__gameState = None
__base = None
__screenImage = None
__titleImage = None
__newGameImage = None
__selectedImage = None
__quitImage = None
__screenImagePath = "textures/back.jpg"
__titleImagePath = "textures/title.png"
__newGameImagePath = "textures/newgame.png"
__quitImagePath = "textures/quit.png"
__selectedImagePath = "textures/selected.png"
__gameOverText = None
__backToMenuText = None
__tryAgainText = None
def __init__(self, gameEngine, base, gameState):
self.__gameEngine = gameEngine
self.__base = base
self.__gameState = gameState
self.__selected = EnumMenuOptions.NEW_GAME
def showMenu(self):
self.__screenImage = OnscreenImage(parent=self.__base.render2d, image=self.__screenImagePath, pos=(0,0,0))
self.preserveImageAspect(self.__screenImage)
self.__selectedImage = OnscreenImage(parent=self.__base.render2d, image=self.__selectedImagePath)
self.__selectedImage.setTransparency(TransparencyAttrib.MAlpha)
self.preserveImageAspect(self.__selectedImage)
self.__titleImage = OnscreenImage(parent=self.__base.render2d, image=self.__titleImagePath)
self.__titleImage.setTransparency(TransparencyAttrib.MAlpha)
self.__titleImage.setPos(0,0,0.5)
self.preserveImageAspect(self.__titleImage)
self.__newGameImage = OnscreenImage(parent=self.__base.render2d, image=self.__newGameImagePath)
self.__newGameImage.setTransparency(TransparencyAttrib.MAlpha)
self.__newGameImage.setPos(0,0,0.0)
self.preserveImageAspect(self.__newGameImage)
self.__quitImage = OnscreenImage(parent=self.__base.render2d, image=self.__quitImagePath)
self.__quitImage.setTransparency(TransparencyAttrib.MAlpha)
self.__quitImage.setPos(0,0,-0.2)
self.preserveImageAspect(self.__quitImage)
self.changeSelected(EnumMenuOptions.NEW_GAME)
def hideMenu(self):
self.__screenImage.removeNode()
self.__titleImage.removeNode()
self.__newGameImage.removeNode()
self.__quitImage.removeNode()
self.__selectedImage.removeNode()
def hideGameOver(self):
if self.__gameOverText != None:
self.__gameOverText.removeNode()
if self.__tryAgainText != None:
self.__tryAgainText.removeNode()
if self.__backToMenuText != None:
self.__backToMenuText.removeNode()
def update (self, elapsedTime):
is_down = self.__base.mouseWatcherNode.is_button_down
if (is_down(KeyboardButton.up()) and (self.__selected > 0)):
self.changeSelected(self.__selected - 1)
elif (is_down(KeyboardButton.down()) and (self.__selected < 1)):
self.changeSelected(self.__selected + 1)
elif is_down(KeyboardButton.enter()):
self.runSelectedOption()
pass
def runSelectedOption(self):
if self.__selected == EnumMenuOptions.NEW_GAME:
self.hideMenu()
self.__gameState.setGameState(EnumGameStates.PLAY)
elif self.__selected == EnumMenuOptions.QUIT:
self.__gameState.setGameState(EnumGameStates.EXITING)
def backToMenu(self):
self.hideGameOver()
self.__gameState.setGameState(EnumGameStates.MENU)
def preserveImageAspect(self, image):
image.setScale(float(image.getTexture().getXSize())/self.__base.win.getXSize(), 1, float(image.getTexture().getYSize())/self.__base.win.getYSize())
def changeSelected(self, menuOption):
if self.__gameState.getGameState() == EnumGameStates.MENU:
if menuOption == EnumMenuOptions.NEW_GAME:
self.__selectedImage.setPos(self.__newGameImage.getPos())
elif menuOption == EnumMenuOptions.QUIT:
self.__selectedImage.setPos(self.__quitImage.getPos())
self.__selected = menuOption
else:
pass
def showGameOver(self):
self.__gameOverText = OnscreenText(text = 'GAME OVER',
pos = (0.0, 0.4),
scale = 0.1,
parent = self.__base.render2d,
fg = (1,0,0,1),
shadow = (0,0,0,1))
self.__tryAgainText = OnscreenText(text = '"R" - try this level again',
pos = (0.0, 0.2),
scale = 0.07,
parent = self.__base.render2d,
fg = (1,0,0,1),
shadow = (0,0,0,1))
self.__backToMenuText = OnscreenText(text = '"Esc" - back to menu',
pos = (0.0, 0.0),
scale = 0.07,
parent = self.__base.render2d,
fg = (1,0,0,1),
shadow = (0,0,0,1))
class miniMap(object):
def __init__(self, mainActor):
self.teamMateImage = 'models/hexahedron_blue.png'
self.heroImage = 'models/mainHero2.png'
self.miniMapImage = 'models/miniMap000.png'
self.towerImage = 'models/tower_neitral.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)
return self.map
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, x, y):
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 BetterOnscreenImage(DebugObject):
""" Simple wrapper arroun OnscreenImage, providing a simpler interface and
better visuals """
def __init__(self, image=None, parent=None, x=0, y=0, w=10, h=10,
transparent=True, nearFilter=True, anyFilter=True):
""" Creates a new image, taking (x,y) as topleft coordinates.
When nearFilter is set to true, a near filter will be set to the
texture passed. This provides sharper images.
When anyFilter is set to false, the passed image won't be modified at
all. This enables you to display existing textures, otherwise the
texture would get a near filter in the 3D View, too. """
DebugObject.__init__(self, "BetterOnscreenImage")
self.w, self.h = w, h
self.initialPos = self.translatePos(x, y)
self._node = OnscreenImage(
image=image, parent=parent, pos=self.initialPos,
scale=(w / 2.0, 1, h / 2.0))
if transparent:
self._node.setTransparency(TransparencyAttrib.MAlpha)
tex = self._node.getTexture()
if nearFilter and anyFilter:
tex.setMinfilter(Texture.FTNearest)
tex.setMagfilter(Texture.FTNearest)
if anyFilter:
tex.setAnisotropicDegree(8)
tex.setWrapU(Texture.WMClamp)
tex.setWrapV(Texture.WMClamp)
def getInitialPos(self):
""" Returns the initial position of the image. This can be used for
animations """
return self.initialPos
def posInterval(self, *args, **kwargs):
""" Returns a pos interval, this is a wrapper arround
NodePath.posInterval """
return self._node.posInterval(*args, **kwargs)
def setImage(self, img):
""" Sets the current image """
self._node.setImage(img)
def setPos(self, x, y):
""" Sets the position """
self.initialPos = self.translatePos(x, y)
self._node.setPos(self.initialPos)
def translatePos(self, x, y):
""" Converts 2d coordinates to pandas coordinate system """
return Vec3(x + self.w / 2.0, 1, -y - self.h / 2.0)
def hide(self):
self._node.hide()
def show(self):
self._node.show()
class MousePointerDisplay:
def __init__(self, game):
self.log = logging.getLogger('pano.mouseDisplay')
self.game = game
self.resources = game.getResources()
self.defaultScale = 0.05
self.pointer = None
#the parent node of the mouse pointer
self.pointerParentNP = None
#the mouse pointer node, it can be a ModelNode if the cursor is animated and was read by an .egg file
#or it can be a OnScreenImage if the cursor is static
self.mousePointer = None
#True if the pointer is a static image and therefore is rendered through a OnScreenImage object
self.isImagePointer = False
#True if the mouse pointer is hidden
self.mouseHidden = True
# the name of the image used as a pointer through a call to setImageAsPointer
self.pointerImage = None
def initialize(self):
self.pointerParentNP = render2d.attachNewNode('mousePointer')
# create a GUI Layer for the pointer
CullBinManager.getGlobalPtr().addBin(PanoConstants.MOUSE_CULL_BIN_NAME, CullBinManager.BTUnsorted, PanoConstants.MOUSE_CULL_BIN_VAL)
# add task that updates the location of the mouse pointer
taskMgr.add(self.updatePointerLocationTask, PanoConstants.TASK_MOUSE_POINTER)
def isShown(self):
return not self.mouseHidden
def show(self):
self.mouseHidden = False
self.pointerParentNP.show()
def hide(self):
"""
Hides the mouse pointer.
For image based pointers, the associated OnScreenImage is destroyed with a call to the member function destroy().
While for model based pointers the associated model node is simply removed from the scenegraph.
"""
self.mouseHidden = True
self.pointerParentNP.hide()
def _destroyPointer(self):
if self.mousePointer is not None:
if self.isImagePointer:
self.mousePointer.destroy()
self.mousePointer = None
else:
self.mousePointer.removeNode()
# self.mousePointer.detachNode()
if self.pointerParentNP is not None:
self.pointerParentNP.node().removeAllChildren()
self.isImagePointer = False
self.pointerImage = None
self.mousePointer = None
self.pointer = None
self.mouseHidden = True
def getScale(self):
return self.scale
def setScale(self, scale):
self.scale = scale
def setByName(self, pointerName):
"""
Sets and displays the specified mouse pointer. If None is passed in place
of the pointerName parameter, then the mouse pointer is hidden.
Convention: A texture file or egg file with a base name equal
to pointerName must exist in one of the resource locations
associated with the cursors resource type.
Convention: If the pointer name corresponds to an egg file, then
the pointer is assumed to be animated. Otherwise the pointer is
assumed to be a static image.
Returns True if the pointer was set successfully and False if otherwise.
"""
pointerChanged = (self.pointer is None) or (pointerName != self.pointer.getName())
if (pointerName is None) or pointerChanged:
self._destroyPointer()
if pointerChanged:
self.pointer = self.game.getResources().loadPointer(pointerName)
if self.pointer is None:
self.log.error("Could'nt find pointer: %s", pointerName)
return False
if self.pointer.getModelFile() is not None:
self.isImagePointer = False
self.mousePointer = self.game.getResources().loadModel(self.pointer.getModelFile())
self.mousePointer.setScale(self.pointer.getScale() if self.pointer.getScale() is not None else self.defaultScale)
self.mousePointer.setTag('model', 'True')
self.mousePointer.reparentTo(self.pointerParentNP)
self.isImagePointer = False
self.pointerImage = None
else:
self.setImageAsPointer(self.pointer.getTexture(), self.pointer.getScale())
self.mousePointer.setTransparency(TransparencyAttrib.MAlpha)
self.mousePointer.setBin("fixed", PanoConstants.RENDER_ORDER_MOUSE_POINTER)
self.mousePointer.setDepthTest(False)
self.mousePointer.setDepthWrite(False)
self.mouseHidden = False
self.show()
return True
def setImageAsPointer(self, image, scale = None):
self._destroyPointer()
self.isImagePointer = True
texPath = self.game.getResources().getResourceFullPath(PanoConstants.RES_TYPE_TEXTURES, image)
if texPath is not None:
x, y = 0, 0
if base.mouseWatcherNode.hasMouse():
x=base.mouseWatcherNode.getMouseX()
y=base.mouseWatcherNode.getMouseY()
self.mousePointer = OnscreenImage(
parent=self.pointerParentNP,
image = texPath,
pos = Point3(x, 0, y),
scale = scale if scale is not None else self.defaultScale
)
self.pointerImage = image
self.mousePointer.setTransparency(TransparencyAttrib.MAlpha)
self.mousePointer.setBin("fixed", PanoConstants.RENDER_ORDER_MOUSE_POINTER)
self.mousePointer.setDepthTest(False)
self.mousePointer.setDepthWrite(False)
self.mouseHidden = False
self.show()
return True
else:
return False
def getPosition(self):
'''
Returns the current location of the mouse pointer.
@return: A (x, y) tuple containing the coordinates of the pointers in the coordinate of the render node.
'''
if self.mousePointer is not None:
pos = self.mousePointer.getPos(render)
return (pos[0], pos[2])
else:
return (-1, 1)
def updatePointerLocationTask(self, task):
if base.mouseWatcherNode.hasMouse():
if self.mousePointer is not None and not self.mouseHidden and base.mouseWatcherNode.hasMouse() and not self.game.isPaused():
x=base.mouseWatcherNode.getMouseX()
y=base.mouseWatcherNode.getMouseY()
self.mousePointer.setPos(Point3(x, 0, y))
return Task.cont
def persistState(self, persistence):
ctx = persistence.createContext('mouse_pointer')
ctx.addVar('is_image', self.isImagePointer)
ctx.addVar('scale', self.scale)
ctx.addVar('pointer_name', self.pointer.getName() if self.pointer is not None else '')
ctx.addVar('image', self.pointerImage if self.pointer is None else '')
return ctx
def resumeState(self, persistence):
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 Jugador(DirectObject):
#Les variables que tinguin un # son canviables, i les que tinguin ## depenen de la nau
WIN_WIDTH = 800 #
H_WIDTH = WIN_WIDTH / 2
WIN_HEIGHT = 600 #
H_HEIGHT = WIN_HEIGHT / 2
CAM_FOV = 51.
CAM_FOV_RAD = radians(CAM_FOV) / 2
CAM_FOV_RAD_TAN = tan(CAM_FOV_RAD)
VEL_MAX_AVIO = 100 ##
VEL_MIN_AVIO = 30 ##
VEL_AVIO_RECTE = 40. ##
VEL_TOMBA_AVIO = 90. ##
VEL_COSTAT = 30. ##
ACCELERACIO = 35 ##
CAMERA_Y = -9 ##
BALA_VEL_BASE = 500 ##
QUIT_KEY = "escape" #
ACCELERATE_KEY = "w" #
DECELERATE_KEY = "s" #
RIGHT_KEY = "d" #
LEFT_KEY = "a" #
CENTRA_RATA_KEY = "c" #
SHOOT_KEYS = ["mouse1", "e"] #
SHOOT_TIME = .15 ##
def __init__(self,
base,
ini_pos=Point3(0, 100, 100),
tipus="kamikaze",
wwidth=None,
wheight=None):
DirectObject.__init__(self)
if wwidth and wheight:
self.WIN_WIDTH = wwidth
self.H_WIDTH = self.WIN_WIDTH / 2
self.WIN_HEIGHT = wheight
self.H_HEIGHT = self.WIN_HEIGHT / 2
self.keyMap = {"shoot": 0, "centerPointer": 0, "turn": 0}
self.bulletClock = 0.
self.overheatClock = 0.
self.BALA_VEL = self.BALA_VEL_BASE + self.VEL_MIN_AVIO
ambient = AmbientLight("alight")
ambientNp = render.attachNewNode(ambient)
ambient.setColor(VBase4(.3, .3, .3, 1.))
self.avio = render.attachNewNode("avio")
self.avio.setHpr(randint(0, 359), randint(0, 359), randint(0, 359))
self.avio.setPos(ini_pos)
self.avioR = self.avio.attachNewNode("avioDum2")
if tipus == "kamikaze":
self.modelAvio = base.loader.loadModel('prova/avio1blend')
else:
self.modelAvio = base.loader.loadModel('prova/avio1blend')
self.modelAvio.reparentTo(self.avioR)
self.avioVel = self.VEL_MIN_AVIO
self.balaDreta = self.modelAvio.find("**/BalaDreta")
self.balaEsquerra = self.modelAvio.find("**/BalaEsquerra")
self.avio.setLight(ambientNp)
self.avio.setAntialias(AntialiasAttrib.MMultisample)
self.modelAvio.setColor(1, 1, 0, 1)
self.modelAvio.setScale(.51)
lightBales = AmbientLight('dlight')
self.lightBalesNp = base.camera.attachNewNode(lightBales)
self.lightBalesNp.setHpr(0, 0, 0)
#-#-#-#-configuracio de camara
base.disableMouse()
#~ self.oobe()
base.camera.reparentTo(self.avio)
base.camera.setHpr(self.avio, 0, 0, 0)
base.camera.setPos(self.avio, 0, self.CAMERA_Y, 1.5)
base.camLens.setFov(self.CAM_FOV * (4. / 3.), self.CAM_FOV)
self.mirilla2 = OnscreenImage(image="prova/textures/areatir2.png",
parent=pixel2d)
self.mirilla2.setScale(128)
self.mirilla2.setTransparency(1)
self.mirilla2.setPos(self.H_WIDTH, 0, -self.H_HEIGHT)
self.mirilla = base.loader.loadModel("prova/textures/fixador.egg")
self.mirilla.reparentTo(pixel2d)
self.mirilla.setScale(64.)
self.mirilla.setPos(0, 0, 0)
self.mirilla.find('**/+SequenceNode').node().pose(0)
self.cursorGirar = pixel2d.attachNewNode("cursorGirar")
self.cursorGirarImage = OnscreenImage(
image="prova/textures/fletxa.png", parent=self.cursorGirar)
self.cursorGirarImage.setScale(16. / 2, 1., 32. / 2)
self.cursorGirarImage.setPos(0, 0, 0)
self.cursorGirarImage.setHpr(-90, 0, -90)
self.cursorGirarImage.setTransparency(1)
cursorGirarEffect = BillboardEffect.make(up_vector=Vec3(0, 0, 1),
eye_relative=False,
axial_rotate=False,
offset=0.,
look_at=self.mirilla2,
look_at_point=Point3(0, 0, 0))
self.cursorGirar.setEffect(cursorGirarEffect)
self.overheats = []
for i in range(8):
if i % 2 == 0:
self.overheats.append(
OnscreenImage(image="prova/textures/overheat1.png",
parent=pixel2d))
else:
self.overheats.append(
OnscreenImage(image="prova/textures/overheat2.png",
parent=pixel2d))
self.overheats[i].setScale(32., 1., 32.)
self.overheats[i].setTransparency(1)
self.overheats[i].hide()
self.overheats[0].setPos(self.H_WIDTH + 36, 0, -self.H_HEIGHT + 36)
self.overheats[0].setHpr(0, 0, 0)
self.overheats[1].setPos(self.H_WIDTH + 36, 0, -self.H_HEIGHT + 36)
self.overheats[1].setHpr(0, 0, 0)
self.overheats[2].setPos(self.H_WIDTH + 36, 0, -self.H_HEIGHT - 36)
self.overheats[2].setHpr(0, 0, 90)
self.overheats[3].setPos(self.H_WIDTH + 36, 0, -self.H_HEIGHT - 36)
self.overheats[3].setHpr(0, 0, 90)
self.overheats[4].setPos(self.H_WIDTH - 36, 0, -self.H_HEIGHT - 36)
self.overheats[4].setHpr(0, 0, 180)
self.overheats[5].setPos(self.H_WIDTH - 36, 0, -self.H_HEIGHT - 36)
self.overheats[5].setHpr(0, 0, 180)
self.overheats[6].setPos(self.H_WIDTH - 36, 0, -self.H_HEIGHT + 36)
self.overheats[6].setHpr(0, 0, -90)
self.overheats[7].setPos(self.H_WIDTH - 36, 0, -self.H_HEIGHT + 36)
self.overheats[7].setHpr(0, 0, -90)
#PARTICLE SYSTEM SETUP
self.particlesDummy = render.attachNewNode("particlesDummy")
self.particlesDummy.setPosHprScale(0, 0, 0, 0, 0, 0, 1, 1, 1)
self.particlesDummy.clearLight(render.find("dlight"))
self.particlesDummy.setLight(self.lightBalesNp)
base.enableParticles()
#COLLISIONS
base.cTrav = CollisionTraverser()
base.cTrav.setRespectPrevTransform(True)
self.balaCol = CollisionNode("balaCol")
self.balaCol.setIntoCollideMask(BitMask32.allOff())
self.balaCol.setFromCollideMask(BitMask32(0x00000001))
balaColSolid = CollisionSphere(0., 0., 0., .2)
self.balaCol.addSolid(balaColSolid)
self.pickRay = CollisionNode("pickRay")
self.pickRayNp = base.camera.attachNewNode(self.pickRay)
self.pickRay.setIntoCollideMask(BitMask32.allOff())
self.pickRay.setFromCollideMask(BitMask32(0x00000002))
self.pickRayCHandler = CollisionHandlerQueue()
self.mouseRay = CollisionRay()
self.pickRay.addSolid(self.mouseRay)
self.mouseRay.setOrigin(0, 0, 0)
base.cTrav.addCollider(self.pickRayNp, self.pickRayCHandler)
#~ self.nearPlane = CollisionNode("nearPlane")
#~ self.nearPlaneNp = base.camera.attachNewNode(self.nearPlane)
#~ base.camRays.setIntoCollideMask(BitMask32(0x00000001))
#~ self.nearPlaneNp.setPos(0, 1, 0)
#~ self.nearPlaneColSolid = CollisionPlane(Plane(Vec3(0, -1, 0), Point3(0, 1, 0)))
#~ self.nearPlane.addSolid(self.nearPlaneColSolid)
def giraAvio(task):
timeVar = globalClock.getDt()
point = base.win.getPointer(0)
pointerx = point.getX()
pointery = point.getY()
self.mouseRay.setFromLens(base.camNode, pointerx, pointery)
#Cursors de la pantalla
self.mirilla.setPos(pointerx, 0, -pointery)
self.cursorGirar.setPos(pointerx, 0, -pointery)
r = pow(abs(pointery - self.H_HEIGHT), 2) + pow(
abs(pointerx - self.H_WIDTH), 2)
if r > 8000:
self.mirilla.hide()
self.cursorGirar.show()
else:
self.mirilla.show()
self.cursorGirar.hide()
#3D
pointerx = (pointerx - self.H_WIDTH)
pointery = (pointery - self.H_HEIGHT)
self.avioR.setX(self.avio, -pointerx * 3. / float(self.WIN_WIDTH))
self.avioR.setZ(self.avio, pointery * 3. / (self.WIN_HEIGHT))
self.avio.setH(self.avio,
-pointerx * 256. / self.WIN_WIDTH * timeVar)
self.avio.setP(self.avio,
-pointery * 256. / self.WIN_HEIGHT * timeVar)
self.avioR.setR(self.avio, pointerx / 10.)
self.avioR.setP(self.avio, pointery / 70.)
self.avioR.setH(self.avio, -pointerx / 50.)
#~ self.avioVel += self.avioAcc*timeVar
#~ self.avio.setPos(self.avio, self.avioVel*timeVar)
return task.cont
def propulsaAvio(acceleracio, task):
self.avioVel += acceleracio * globalClock.getDt()
if self.avioVel < self.VEL_MIN_AVIO:
self.avioVel = self.VEL_MIN_AVIO
elif self.avioVel > self.VEL_MAX_AVIO:
self.avioVel = self.VEL_MAX_AVIO
self.BALA_VEL = self.BALA_VEL_BASE + self.avioVel
#MOSTRA LA VELOCITAT
pos = float(self.avioVel - self.VEL_MIN_AVIO) / (
self.VEL_MAX_AVIO - self.VEL_MIN_AVIO)
base.camera.setY(self.CAMERA_Y - pos * 4)
#~ self.marcaVelocitat.setX(MARCAVEL_INI_X+pos*137.)
return task.cont
self.haCremat = False
def mouAvio(task):
timeVar = globalClock.getDt()
self.avio.setPos(self.avio, 0, self.avioVel * timeVar, 0)
if self.keyMap["shoot"] == 1:
if self.bulletClock <= 0.:
self.bulletClock = self.SHOOT_TIME
if not self.haCremat:
if self.overheatClock > 16:
self.haCremat = True
self.overheatClock = 18
else:
self.overheatClock += self.SHOOT_TIME
shoot()
else:
self.bulletClock -= timeVar
else:
self.bulletClock = 0.
self.overheatClock -= timeVar
if self.overheatClock < 16: self.haCremat = False
if self.haCremat: self.overheatClock -= timeVar
if self.overheatClock < 0:
self.overheatClock = 0
elif self.overheatClock < 2:
self.overheats[0].hide()
elif self.overheatClock < 4:
self.overheats[1].hide()
self.overheats[0].show()
elif self.overheatClock < 6:
self.overheats[2].hide()
self.overheats[1].show()
elif self.overheatClock < 8:
self.overheats[3].hide()
self.overheats[2].show()
elif self.overheatClock < 10:
self.overheats[4].hide()
self.overheats[3].show()
elif self.overheatClock < 12:
self.overheats[5].hide()
self.overheats[4].show()
elif self.overheatClock < 14:
self.overheats[6].hide()
self.overheats[5].show()
self.overheats[7].hide()
elif self.overheatClock < 16:
self.overheats[7].hide()
self.overheats[6].show()
else:
self.overheats[7].show()
if self.keyMap["turn"] == 1:
self.avio.setX(self.avio, -self.VEL_COSTAT * timeVar)
elif self.keyMap["turn"] == -1:
self.avio.setX(self.avio, self.VEL_COSTAT * timeVar)
return task.cont
def avioRecte(task):
p = self.avio.getP(render)
if p > 170 or p < -170: return task.cont
timeVar = globalClock.getDt()
roll = self.avio.getR(render)
if roll < -self.VEL_AVIO_RECTE * timeVar:
self.avio.setR(render, roll + self.VEL_AVIO_RECTE * timeVar)
elif roll <= self.VEL_AVIO_RECTE * timeVar:
self.avio.setR(render, 0)
else:
self.avio.setR(render, roll - self.VEL_AVIO_RECTE * timeVar)
return task.cont
self.balaPositiu = True
def shoot():
bala = self.particlesDummy.attachNewNode("balaDummy")
balaImage = OnscreenImage(image="prova/textures/bala.png",
parent=bala)
balaImage.setTransparency(1)
balaImage.setScale(.1, 1., .2)
balaImage.setBillboardPointEye()
bala.setQuat(self.modelAvio.getQuat(render))
if self.balaPositiu:
bala.setPos(self.balaDreta.getPos(render))
self.balaPositiu = False
else:
bala.setPos(self.balaEsquerra.getPos(render))
self.balaPositiu = True
balaSphere = bala.attachNewNode(self.balaCol)
balaColHandler = CollisionHandlerQueue()
base.cTrav.addCollider(balaSphere, balaColHandler)
#~ if type(self.shootPoint) == 'libpanda.Point3':
#~ bala.lookAt(self.shootPoint)
#~ else: bala.setH(bala, 180.)
taskMgr.add(
mouBala,
"moubala",
extraArgs=[bala, balaImage, self.BALA_VEL, balaColHandler],
appendTask=True)
def mouBala(bala, balaImage, vel, queue, task):
if task.time > 3:
balaImage.detachNode()
expbala = ParticleEffect()
expbala.reparentTo(self.particlesDummy)
expbala.loadConfig('explosio.ptf')
expbala.start(bala)
taskMgr.doMethodLater(.25,
suprimir,
"suprimir",
extraArgs=[bala, expbala])
return task.done
if queue.getNumEntries() != 0:
balaImage.detachNode()
entry = queue.getEntry(0)
bala.setPos(entry.getSurfacePoint(self.particlesDummy))
expbala = ParticleEffect()
expbala.reparentTo(self.particlesDummy)
expbala.loadConfig('explosio.ptf')
expbala.start(bala)
taskMgr.doMethodLater(.25,
suprimir,
"suprimir",
extraArgs=[bala, expbala])
return task.done
bala.setFluidPos(bala, 0, vel * globalClock.getDt(), 0)
balaImage.setR(balaImage, 1000 * globalClock.getDt())
return task.cont
def suprimir(bala, expbala):
bala.detachNode()
expbala.cleanup()
expbala.detachNode()
def setKey(key, value):
self.keyMap[key] = value
def centraRatoli():
point = base.win.getPointer(0)
x = point.getX()
y = point.getY()
x -= self.H_WIDTH
y -= self.H_HEIGHT
r = sqrt(pow(abs(y), 2) + pow(abs(x), 2))
def centra(t, x, y):
base.win.movePointer(0,
trunc(x * t) + self.H_WIDTH,
trunc(y * t) + self.H_HEIGHT)
i = LerpFunc(centra,
fromData=1.,
toData=0.,
duration=r / 700.,
blendType='easeInOut',
extraArgs=[x, y],
name="centraRata")
i.start()
self.previousPos = 0
self.interval01 = LerpPosHprInterval(self.modelAvio,
.5,
Point3(3, 0, 0),
VBase3(0, 0, 70),
Point3(0, 0, 0),
VBase3(0, 0, 0),
blendType='easeInOut')
self.interval10 = LerpPosHprInterval(self.modelAvio,
.5,
Point3(0, 0, 0),
VBase3(0, 0, 0),
Point3(-3, 0, 0),
VBase3(0, 0, -70),
blendType='easeInOut')
self.interval02 = LerpPosHprInterval(self.modelAvio,
.5,
Point3(-3, 0, 0),
VBase3(0, 0, -70),
Point3(0, 0, 0),
VBase3(0, 0, 0),
blendType='easeInOut')
self.interval20 = LerpPosHprInterval(self.modelAvio,
.5,
Point3(0, 0, 0),
VBase3(0, 0, 0),
Point3(3, 0, 0),
VBase3(0, 0, 70),
blendType='easeInOut')
self.interval12 = LerpPosHprInterval(self.modelAvio,
1.,
Point3(-3, 0, 0),
VBase3(0, 0, -70),
Point3(3, 0, 0),
VBase3(0, 0, 70),
blendType='easeInOut')
self.interval21 = LerpPosHprInterval(self.modelAvio,
1.,
Point3(3, 0, 0),
VBase3(0, 0, 70),
Point3(-3, 0, 0),
VBase3(0, 0, -70),
blendType='easeInOut')
def allIntervalsStopped():
if self.interval01.isStopped() and self.interval10.isStopped(
) and self.interval02.isStopped() and self.interval20.isStopped(
) and self.interval12.isStopped() and self.interval21.isStopped():
return True
else:
return False
def tombaAvio(task):
if self.keyMap[
"turn"] == 0 and self.previousPos != 0 and allIntervalsStopped(
):
if self.previousPos == 1: self.interval10.start()
else: self.interval20.start()
self.previousPos = 0
elif self.keyMap[
"turn"] == -1 and self.previousPos != -1 and allIntervalsStopped(
):
if self.previousPos == 0: self.interval01.start()
else: self.interval21.start()
self.previousPos = -1
elif self.keyMap[
"turn"] == 1 and self.previousPos != 1 and allIntervalsStopped(
):
if self.previousPos == 0: self.interval02.start()
else: self.interval12.start()
self.previousPos = 1
return task.cont
def anim1():
self.mirilla.find('**/+SequenceNode').node().setPlayRate(1.)
self.mirilla.find('**/+SequenceNode').node().play(0, 3)
def anim2():
self.mirilla.find('**/+SequenceNode').node().setPlayRate(1.)
self.mirilla.find('**/+SequenceNode').node().play(4, 8)
def anim3():
self.mirilla.find('**/+SequenceNode').node().setPlayRate(-1.)
self.mirilla.find('**/+SequenceNode').node().play(0, 3)
def anim4():
self.mirilla.find('**/+SequenceNode').node().setPlayRate(-1.)
self.mirilla.find('**/+SequenceNode').node().play(3, 8)
#events
self.accept(self.QUIT_KEY, sysExit, [0])
self.accept(self.ACCELERATE_KEY, taskMgr.add, [
propulsaAvio, "propulsaAvio1", None, [self.ACCELERACIO], None,
None, True
])
self.accept(self.ACCELERATE_KEY + "-up", taskMgr.remove,
["propulsaAvio1"])
self.accept(self.DECELERATE_KEY, taskMgr.add, [
propulsaAvio, "propulsaAvio2", None, [-self.ACCELERACIO], None,
None, True
])
self.accept(self.DECELERATE_KEY + "-up", taskMgr.remove,
["propulsaAvio2"])
for key in self.SHOOT_KEYS:
self.accept(key, setKey, ["shoot", 1])
self.accept(key + "-up", setKey, ["shoot", 0])
self.accept(self.RIGHT_KEY, setKey, ["turn", -1])
self.accept(self.LEFT_KEY, setKey, ["turn", 1])
self.accept(self.RIGHT_KEY + "-up", setKey, ["turn", 0])
self.accept(self.LEFT_KEY + "-up", setKey, ["turn", 0])
self.accept(self.CENTRA_RATA_KEY, centraRatoli)
self.accept("n", anim1)
self.accept("m", anim2)
self.accept("v", anim3)
self.accept("b", anim4)
taskMgr.add(giraAvio, "GiraAvio")
taskMgr.add(mouAvio, "MouAvio")
taskMgr.add(avioRecte, "avioRecte")
taskMgr.add(tombaAvio, "tombaAvio")
