class Enemy:
def __init__(self, game, hp, mana, speed, attackSpeed, name):
self.game = game
self.name = name
self.model = "models/%s" % self.name
self.modelWalk = "models/%s-walk" % self.name
self.hp = hp
self.mana = mana
self.speed = speed
self.attackSpeed = attackSpeed
self.enemyActor = Actor({"body": self.model}, {"body": {"walk": self.modelWalk}})
self.enemyActor.setHpr(0, 0, 0)
self.enemyActor.setPos(0, 0, 5)
self.enemyActor.setScale(0.5)
self.enemyActor.reparentTo(render)
self.setupAI()
def getName(self):
return self.name
def attacked(self, damage):
print("man pegao")
self.hp -= damage
if self.hp <= 0:
self.enemyActor.detachNode()
self.enemyActor.removeNode()
self.game.taskMgr.remove("%sTask" % self.name)
def setupAI(self):
self.enemyActor.loop("walk")
self.AIchar = AICharacter("enemy", self.enemyActor, 60, 0.05, 5)
self.game.AIworld.addAiChar(self.AIchar)
self.AIbehaviors = self.AIchar.getAiBehaviors()
self.AIbehaviors.wander(10, 0, 15, 1.0)
# Path follow (note the order is reveresed)
"""
self.AIbehaviors.pathFollow(1)
self.AIbehaviors.addToPath((0,-20,0))
self.AIbehaviors.addToPath((0,20,0))
self.AIbehaviors.addToPath((20,-10,0))
self.AIbehaviors.addToPath((15,-20,0))
self.AIbehaviors.startFollow()
"""
def update(self, Task):
self.AIworld.update()
return Task.cont
class Food():
def __init__(self, showbase, num, addToCollisions):
self.addToCollisions = addToCollisions
self.num = num
# Load food model
self.model = Actor('panda-model', {'Walk': 'models/panda-walk4'})
# Set Scale of food
self.model.setScale(0.0065, 0.0065, 0.0065)
# Set animation loop to Walk
self.model.loop('Walk')
# Reparent the model to render.
self.model.reparentTo(showbase.render)
self.model.collisionNode = initCollisionSphere(self.model,
'Food-' + str(num), 0.6)
# Add head to collision detection
self.addToCollisions(self.model.collisionNode)
self.reset()
def destroy(self):
self.model.detachNode()
def update(self, dt):
self.model.setPos(self.model, 0, 0.1 * dt, 0)
def reset(self):
# Set position of centipede head
self.model.setX(random.random() * 1000 - 500)
self.model.setY(random.random() * 1000 - 500)
# Set rotation of centipede head
self.model.setH(random.random() * 360)
class Food():
def __init__(self, showbase, num, addToCollisions):
self.addToCollisions = addToCollisions
self.num = num
# Load food model
self.model = Actor('panda-model',
{'Walk': 'models/panda-walk4'})
# Set Scale of food
self.model.setScale(0.0065, 0.0065, 0.0065)
# Set animation loop to Walk
self.model.loop('Walk')
# Reparent the model to render.
self.model.reparentTo(showbase.render)
self.model.collisionNode = initCollisionSphere(self.model, 'Food-' + str(num), 0.6)
# Add head to collision detection
self.addToCollisions(self.model.collisionNode)
self.reset()
def destroy(self):
self.model.detachNode()
def update(self, dt):
self.model.setPos(self.model, 0, 0.1 * dt, 0)
def reset(self):
# Set position of centipede head
self.model.setX(random.random() * 1000 - 500)
self.model.setY(random.random() * 1000 - 500)
# Set rotation of centipede head
self.model.setH(random.random() * 360)
class Pokemao():#Inimigos):
def __init__(self,render, num):
self.nome = "Pokemao"
self.agi = 10
self.hp = 10
self.int = 5
self.str = 1
self.dano = 5
self.bloqueio = False
self.bloqueado = False
self.velocAtaque = 0.5
self.arma = None
self.escudo = None
self.armadura = None
self.delete = False
self.render = render
self.loadModels(num)
self.setAI()
def getPos(self):
return self.pokemao.getPos()
def loadModels(self,num):
# Seeker
pokemaoPos = Vec3(-10,-30.0,2.10)
self.pokemao = Actor('personagens/Modelos/Pokeperna/p1',
{"andar" :"personagens/Modelos/Pokeperna/p1-andar.egg",
"saltar" :"personagens/Modelos/Pokeperna/p1-saltar.egg",
"correr" : "personagens/Modelos/Pokeperna/p1-correr",
"abaixar" : "personagens/Modelos/Pokeperna/p1-abaixar"})
self.pokemao.reparentTo(self.render)
#self.wanderer.setScale(0.5)
self.pokemao.setPos(pokemaoPos)
self.pokemao.setTag("inimigo",str(num))
def setAI(self):
#Creating AI World
self.AIworld = AIWorld(self.render)
self.AIchar = AICharacter("wanderer",self.pokemao, 100, 0.05, 5)
self.AIworld.addAiChar(self.AIchar)
self.AIbehaviors = self.AIchar.getAiBehaviors()
self.AIbehaviors.wander(5, 0, 10, 1.0)
self.pokemao.loop("correr")
#AI World update
taskMgr.add(self.AIUpdate,"AIUpdate")
#to update the AIWorld
def AIUpdate(self,task):
if self.hp < 1:
#self.cleanup()
self.pokemao.detachNode()
self.delete = True
self.AIworld.update()
return Task.cont
class MapObject(MapObjectBase):
"""MapObject can't move or change map in game"""
def __init__(self, map, genre, name):
MapObjectBase.__init__(self, name)
self.map = map # reference to the Map the object belongs to
self.genre = genre # NPC, building, decor, item, warp...
self.name = name
self.model = None
self.modelPath = None
self.texturePath = None
self.state = None
self.data = {}
self.dialog = None
self.task = None
self.posTask = None
if self.genre in mapObjectDB:
self.loadModel(mapObjectDB[self.genre][0], mapObjectDB[self.genre][1])
self.addCollision(mapObjectDB[self.genre][2])
#self.oldPos= Point3()
'''
if self.genre is not "NPC":
print("\n\n- mapObject init : %s, pos = %s" % (self.name, self.getPos()))
self.posTask = taskMgr.add(self.checkPosTask, "posTask")
else:
self.posTask = None
'''
def checkPosTask(self, task):
if self.getPos() != self.oldPos:
print "WARNING : map object pos changed from %s to %s, correcting" % (self.oldPos, self.getPos())
#self.oldPos = self.getPos()
self.setPos(self.oldPos)
#else:
# print "%s pos is still %s" % (self.name, self.oldPos)
return task.cont
def addCollision(self, pos):
self.colSphere = CollisionSphere(pos[0],pos[1],pos[2],pos[3])
#self.colSphere = CollisionTube(0,0,0,0,0,1.8,0.4)
self.colNodepath = CollisionNode(self.name)
self.colNode = self.model.attachNewNode(self.colNodepath)
self.colNode.node().addSolid(self.colSphere)
def loadModel(self, modelPath, texturePath=None):
if self.model:
self.model.remove()
self.modelPath = modelPath
self.model = loader.loadModel(modelPath)
self.model.setTransparency(TransparencyAttrib.MAlpha)
if texturePath:
tex = loader.loadTexture(texturePath)
self.texturePath = texturePath
self.model.setTexture(tex)
self.model.reparentTo(self)
def loadActor(self, modelPath, animDic={}, texturePath=None):
if self.model is not None:
self.model.remove()
self.model = Actor(modelPath, animDic)
#self.model.setTransparency(True)
if texturePath is not None:
self.tex = loader.loadTexture(texturePath)
#self.model.clearTexture(TextureStage.getDefault())
self.model.clearTexture()
self.model.setTexture(TextureStage.getDefault(), self.tex)
self.currentAnim = None
self.model.reparentTo(self)
#def reparentTo(self, np):
# self.model.reparentTo(np)
#if self.genre is not "NPC":
# print "Reparenting %s to %s, pos is now %s" % (self.name, str(np), self.getPos())
def getSaveData(self):
data = []
data.append(self.name)
data.append(self.genre)
data.append(self.model.getPos())
data.append(self.model.getHpr())
data.append(self.model.getScale())
return data
#-------------------------------------------------------------------
# Pos
def setPos(self, pos):
#self.model.setPos(pos[0], pos[1], pos[2])
'''
if self.genre is not "NPC":
print "- mapObject (%s): set pos, oldpos = %s, newpos = %s" % (self.name, self.getPos(), pos)
'''
self.model.setPos(pos)
'''
if self.genre is not "NPC":
print "--- after setPos, mapObject pos = %s" % (self.getPos())
self.oldPos = pos
'''
def getPos(self):
if self.model: return self.model.getPos()
else: return None
def setZ(self, z):
self.model.setZ(z)
def getZ(self):
return self.model.getZ()
def setTilePos(self, x, y):
self.setPos((x+0.5, y+0.5, self.model.getZ()))
def getTilePos(self):
return int(self.model.getX()), int(self.model.getY())
def moveZ(self, dt=0.01):
self.model.setZ(self.model.getZ()+dt)
#-------------------------------------------------------------------
# Hpr
def setHpr(self, hpr):
self.model.setHpr(hpr)
def getRot(self):
return self.model.getH()
def setRot(self, n):
self.model.setH(n)
def rotate(self, dt=0.01):
self.model.setH(self.model.getH()+dt*50)
#-------------------------------------------------------------------
# Scale
def setScale(self, scale):
self.model.setScale(scale)
def getScale(self):
return self.model.getScale()
def getScaleX(self):
return self.model.getSx()
def scale(self, dt=0.01):
self.model.setScale(self.model.getSx() + dt)
def destroy(self):
if self.task:
taskMgr.remove(self.task)
if self.posTask:
taskMgr.remove(self.posTask)
if self.model:
self.model.detachNode()
self.model.remove()
class Agent:
def __init__( self, _name ):
print "Creating agent " + _name
self.name = _name
self.loadLightingFromConfig = 0
self.createShadowMap = 0
def setDataPath( self, _dataPath ):
self.dataPath = _dataPath;
def setActor( self, _modelFileName, _animationFileNames, _morphTargetsFileName ):
self.modelFileName = _modelFileName;
self.animationFileNames = _animationFileNames;
self.morphTargetsFileName = _morphTargetsFileName;
def setRealizer( self, _realizer ):
self.realizer = _realizer;
def setCameraMask( self, _mask ):
self.cameraMask = _mask
def setShadowMapParameters( self, _index, _distance ):
self.createShadowMap = 1
self.shadowMapIndex = _index
self.shadowMapDistance = _distance
def setTransform( self, x, y, z, rx, ry, rz, scale ):
self.agent.setPos( x, y, z )
self.agent.setScale( scale )
self.agent.setHpr( rx, ry, rz )
self.positionX = x
self.positionY = y
self.positionZ = z
def getPosition( self ):
return self.agent.getPos()
def setLightingConfiguration( self, _config, _name ):
self.lightingConfig = _config
self.lightingConfigName = _name
self.loadLightingFromConfig = 1
def init( self ):
#load the agent and parent it to the world
#The joints of this agent will reference Panda NodePaths, it will be possible to play animations on it
self.animationAgent = Actor( self.modelFileName, self.animationFileNames )
self.agent = Actor( self.modelFileName, self.morphTargetsFileName )
self.targets = {#'Basis':[],
'ExpSmileClosed':[],
'ExpAnger':[],
'ExpDisgust':[],
'ExpFear':[],
'ExpSad':[],
'ExpSurprise':[],
'ExpSmileOpen':[],
'ModBlinkLeft':[],
'ModBlinkRight':[],
'ModBrowDownLeft':[],
'ModBrowDownRight':[],
'ModBlinkRight':[],
'ModBrowInRight':[],
'ModBrowInLeft':[],
'ModBrowUpLeft':[],
'ModBrowUpRight':[],
'ModEarsOut':[],
'ModEyeSquintLeft':[],
'ModEyeSquintRight':[],
'ModLookDown':[],
'ModLookLeft':[],
'ModLookRight':[],
'ModLookUp':[],
'ModBlinkLeft':[],
'Phonaah':[],
'PhonB,M,P':[],
'Phonbigaah':[],
'Phonch,J,sh':[],
'PhonD,S,T':[],
'Phonee':[],
'Phoneh':[],
'PhonF,V':[],
'Phoni':[],
'PhonK':[],
'PhonN':[],
'Phonoh':[],
'Phonooh,Q':[],
'PhonR':[],
'Phonth':[],
'PhonW':[]}
iter = self.targets.iteritems()
while True :
try: morphsItem = iter.next()
except StopIteration:break
for i in range(2,7):
#print (str(i)+'_'+morphsItem[0])
blendShape = self.agent.controlJoint(None, 'modelRoot', str(i)+'_'+morphsItem[0])
if(blendShape):
morphsItem[1].append(blendShape)
self.targets['inspire'] = [self.agent.controlJoint(None, 'modelRoot', 'inspire')]
#instanciate a list in order to keep track of kinematic joints joints
#in python runtime
#if nothing points towards those joints, they get flushed by
#python's garbage collector
self.jointList = []
self.jointFKList = []
self.agentControlJoints = []
self.agentNodePaths = []
self.agentSMRSkel = SMRPy.SMRSkeleton(True,True,'agent')
self.createSkel( self.agent, self.agentSMRSkel, 'root', '' )
#pascal: output of both skeletons amber and alfonse as chracter.bvh
#SMRPy.exportSkeletonToBvh(self.name + '.bvh',self.agentSMRSkel);
self.newSkeleton = SMRPy.SMRSkeleton(True,True,'pose')
self.createFKSkel(self.animationAgent, self.newSkeleton, "root", '')
self.realizer.addCharacter( self.name, self.agentSMRSkel );
for key in self.targets.keys():
self.realizer.addMorphTarget( self.name, key ) #TODO: declare morph targets into CharacterConfigurationFile
self.realizer.addShaderParameter( self.name, 'blushing' ) #TODO: declare shader inputs into CharacterConfiguration file
self.agent.reparentTo( render )
#self.agent.hide( BitMask32.bit( self.cameraMask ) )
#set lighting
ambientColor = Vec4(0.0,0.0,0.0,0.0)
self.lighting = shaders.Lighting( ambientColor )
if self.loadLightingFromConfig == 1:
self.lighting.loadFromConfig( self.lightingConfig, self.lightingConfigName )
#shadow map
if self.createShadowMap == 1:
self.shadowMap = shadowmap.ShadowMap( self.shadowMapIndex, self.dataPath )
def setShaders( self, _shaders ):
self.shaders = _shaders
def update( self ):
self.realizer.skeletonRequested()
self.updatePandaSkeleton(self.agentControlJoints, self.agentSMRSkel)
for key in self.targets.keys():
#print(key, "\n")
weight = self.realizer.getMorphTargetWeight( self.name, key )
morphTargets = self.targets[key]
for morphTarget in morphTargets :
#print(weight, "\n")
morphTarget.setX(weight)
#blushingValue = self.realizer.getShaderParameterValue( self.name, 'blushing' )
#self.shaders.headShader.blushing.set( blushingValue )
self.lighting.update()
if self.createShadowMap == 1:
self.shaders.update()
self.shadowMap.setLighting( self.lighting, Vec3( self.positionX, self.positionY, self.positionZ ), self.shadowMapDistance )
self.shaders.updateWithShadows( self.shadowMap )
else:
self.shaders.update()
def addAnimation(self,_actorName,_animationName):
self.animationAgent.reparentTo(render)
self.animationAgent.setScale(10)
self.realizer.addAnimation(_actorName, _animationName)
for i in range (self.animationAgent.getNumFrames(_animationName)):
self.animationAgent.pose(_animationName,i)
base.graphicsEngine.renderFrame()
self.updateSMRSkeleton(self.agentNodePaths, self.newSkeleton)
self.realizer.addPoseToAnimation(_actorName, _animationName, self.newSkeleton)
self.animationAgent.detachNode()
print "animation",_animationName,"added"
def addAnimationWE(self,_actorName,_animationName):
self.animationAgent.reparentTo(render)
self.animationAgent.setScale(10)
agentSMRMotion = SMRPy.SMRMotion()
agentSMRMotion.setTimeStep(0.04)
self.realizer.addAnimation(_actorName, _animationName)
for i in range (self.animationAgent.getNumFrames(_animationName)):
self.animationAgent.pose(_animationName,i)
base.graphicsEngine.renderFrame()
self.updateSMRSkeleton(self.agentNodePaths, self.newSkeleton)
self.realizer.addPoseToAnimation(_actorName, _animationName, self.newSkeleton)
agentSMRMotion.insertSkeleton(self.newSkeleton)
self.animationAgent.detachNode()
print "animation",_animationName,"added"
SMRPy.exportMotionToBvh(_animationName+".bvh",agentSMRMotion)
def createSkel(self, _pandaAgent, _smrSkel, _initialJointName, _parentName):
#get the agent's currentJoint
currentPandaJoint = _pandaAgent.getJoints(None,_initialJointName)
currentPandaCJoint = _pandaAgent.controlJoint(None, 'modelRoot', _initialJointName)
self.agentControlJoints.append(currentPandaCJoint)
#get the first joint's position
position = currentPandaCJoint.getPos()
if (currentPandaJoint[0].getNumChildren() == 0):
newJoint = SMRPy.SMRJoint(True)
newJoint.setEndVect(position.getX(),position.getY(),position.getZ());
else:
newJoint = SMRPy.SMRJoint(False)
rotZ = (currentPandaCJoint.getH()/180.0)*3.14159;
rotX = (currentPandaCJoint.getP()/180.0)*3.14159;
rotY = (currentPandaCJoint.getR()/180.0)*3.14159;
quatZ = SMRPy.SMRQuaternion(SMRPy.SMRVector3(0.0,0.0,1.0),rotZ)
quatX = SMRPy.SMRQuaternion(SMRPy.SMRVector3(1.0,0.0,0.0),rotX)
quatY = SMRPy.SMRQuaternion(SMRPy.SMRVector3(0.0,1.0,0.0),rotY)
quatRot = quatZ.multiply(quatX)
quatRot = quatRot.multiply(quatY)
quatRot.normalize();
#quatRot = currentPandaCJoint.getQuat()
newJoint.setPos(position.getX(),position.getY(),position.getZ())
#newJoint.setRotQuat(quatRot.getR(),quatRot.getI(),quatRot.getJ(),quatRot.getK())
newJoint.setRotQuat(quatRot.getW(),quatRot.getX(),quatRot.getY(),quatRot.getZ())
newJoint.setParentName(_parentName)
newJoint.setName(_initialJointName)
#print _initialJointName, 'numchildren : ', currentPandaJoint[0].getNumChildren()
self.jointList.append(newJoint)
_smrSkel.insertJoint(newJoint)
for i in range(currentPandaJoint[0].getNumChildren()):
childJoint = currentPandaJoint[0].getChild(i)
childName = childJoint.getName()
#print(childName)
self.createSkel(_pandaAgent, _smrSkel, childName, _initialJointName)
def createFKSkel(self, _pandaAgent, _smrSkel, _initialJointName, _parentName):
#get the agent's currentJoint
currentPandaJoint = _pandaAgent.getJoints(None, _initialJointName)
currentPandaJointPath = _pandaAgent.exposeJoint(None, 'modelRoot', _initialJointName, "lodRoot", True)
self.agentNodePaths.append(currentPandaJointPath)
#get the first joint's position
position = currentPandaJointPath.getPos()
if (currentPandaJoint[0].getNumChildren() == 0):
newJoint = SMRPy.SMRJoint(True)
newJoint.setEndVect(position.getX(),position.getY(),position.getZ());
else:
newJoint = SMRPy.SMRJoint(False)
quatRot = currentPandaJointPath.getQuat()
newJoint.setPos(position.getX(),position.getY(),position.getZ())
newJoint.setRotQuat(quatRot.getR(),quatRot.getI(),quatRot.getJ(),quatRot.getK())
newJoint.setParentName(_parentName)
newJoint.setName(_initialJointName)
#print _initialJointName, 'numchildren : ', currentPandaJoint[0].getNumChildren()
self.jointFKList.append(newJoint)
_smrSkel.insertJoint(newJoint)
for i in range(currentPandaJoint[0].getNumChildren()):
childJoint = currentPandaJoint[0].getChild(i)
childName = childJoint.getName()
#print(childName)
self.createFKSkel(_pandaAgent, _smrSkel, childName, _initialJointName)
def updatePandaSkeleton(self, agentControlJoints, _smrSkeleton):
#synchronize root joint
SMRJoint = _smrSkeleton.getJoint(0)
PANDAJoint = agentControlJoints[0]
#position = SMRJoint.getPos()
#PANDAJoint.setPos(position.X(),position.Y(),position.Z());
for i in range(_smrSkeleton.getNumjoints()):
SMRJoint = _smrSkeleton.getJoint(i)
PANDAJoint = agentControlJoints[i]
self.synchronize(PANDAJoint,SMRJoint)
def updateSMRSkeleton(self, agentNodePaths, _smrSkeleton):
#synchronize root joint
SMRJoint = _smrSkeleton.getJoint(0)
PANDAJoint = agentNodePaths[0]
position = PANDAJoint.getPos()
SMRJoint.setPos(position.getX(),position.getY(),position.getZ());
for i in range(_smrSkeleton.getNumjoints()):
SMRJoint = _smrSkeleton.getJoint(i)
PANDAJoint = agentNodePaths[i]
self.synchronizePandaToSMR(SMRJoint,PANDAJoint)
def synchronizePandaToSMR(self, _SMRJoint, _PANDAJoint):
pandaQuaternion = _PANDAJoint.getQuat()
x = pandaQuaternion.getI()
y = pandaQuaternion.getJ()
z = pandaQuaternion.getK()
w = pandaQuaternion.getR()
_SMRJoint.setRotQuat(w,x,y,z)
def synchronize(self, _pandaCJoint, _smrJoint):
smrQuaternion = _smrJoint.getRot()
pandaQuaternion = Quat()
pandaQuaternion.setI(smrQuaternion.getX())
pandaQuaternion.setJ(smrQuaternion.getY())
pandaQuaternion.setK(smrQuaternion.getZ())
pandaQuaternion.setR(smrQuaternion.getW())
if not(pandaQuaternion.isNan()):
_pandaCJoint.setQuat(pandaQuaternion)
class Labrintth(ShowBase):
def __init__(self):
#from panda3d bump mapping demo
# Configure the parallax mapping settings (these are just the defaults)
loadPrcFileData("", "parallax-mapping-samples 3\n"
"parallax-mapping-scale 0.1")
# Initialize the ShowBase class from which we inherit, which will
# create a window and set up everything we need for rendering into it.
ShowBase.__init__(self)
#titles from panda3d bumb mapping demo
# Check video card capabilities.
if not self.win.getGsg().getSupportsBasicShaders():
addTitle("Bump Mapping: "
"Video driver reports that Cg shaders are not supported.")
return
self.playerHealth = 10
self.loseHealth = True
brickTexture = loader.loadTexture("models/brick-c.jpg")
self.lstWalls = makeMaze()
self.ptGrid = makePointGrid()
#self.camera.setPos(self.ptGrid[len(self.ptGrid)-1][0])
self.focus = LVector3(0,1000,30)
for row in range(len(self.ptGrid)):
for col in range(len(self.ptGrid[row])):
for n in range(2):
#wall model made by 'TheCreator', https://free3d.com/3d-model/brick-wall-51172.html
self.wall = loader.loadModel("models/walls")
self.wall.setTexture(brickTexture)
self.wall.setScale(25.3)
self.wall.setPos(self.ptGrid[row][col])
self.wallC = self.wall.find("**/collideWall")
self.wallC.node().setIntoCollideMask(BitMask32.bit(0))
self.wallC.show()
#right of cell
if n == 0:
if self.lstWalls[row][col][n] == 1:
self.wall.setX(self.wall, 1.05)
self.wall.setZ(5)
self.wall.reparentTo(render)
#down of cell
else:
if self.lstWalls[row][col][n] == 1:
self.wall.setHpr(90,0,0)
self.wall.setX(self.wall, -3)
self.wall.setZ(5)
self.wall.reparentTo(render)
self.spacing = self.ptGrid[0][1][0] - self.ptGrid[0][0][0]
self.exit = loader.loadModel('models/walls')
self.exit.setScale(25.3)
self.exit.setColorScale(0.6,0.6,1,1)
self.exitCoord, wall = generateDoor(self.ptGrid, self.lstWalls)
self.exitPos = self.ptGrid[self.exitCoord[0]][self.exitCoord[1]]
self.exit.setPos(self.exitPos)
for n in range(2):
if n == 0:
if wall[n] == 2:
self.exit.setX(self.exit, 1.15)
self.exit.setZ(5)
#down of cell
else:
if wall[n] == 2:
self.exit.setHpr(90,0,0)
self.exit.setX(self.exit, -3.2)
self.exit.setZ(5)
self.exit.reparentTo(render)
self.exit.detachNode()
numPpl = 15 #make first pos minotaur
pplLst = []
pplLst = generatePosLst(pplLst, numPpl, self.ptGrid, self.spacing)
targetPos = pplLst[random.randint(1, len(pplLst)-1)]
print('target:',targetPos)
#ball model from panda3D ball in maze demo
num = 0
for pos in range(1, len(pplLst)):
num += 1
#if the person in the list is the minotaur's target, set it's
#name to self.target
if pplLst[pos] == targetPos:
self.target = loader.loadModel("models/alfred")
self.target.setPos(pplLst[pos])
self.target.setScale(5)
self.target.reparentTo(render)
self.targetK = self.target.attachNewNode(CollisionNode('targetDie'))
self.targetK.node().addSolid(CollisionSphere(0, 0, 5, 6))
self.targetK.node().setIntoCollideMask(BitMask32.bit(2))
#self.targetK.show()
self.targetS = self.target.attachNewNode(CollisionNode('targetSave'))
self.targetS.node().addSolid(CollisionSphere(0, 0, 5, 6))
self.targetS.node().setIntoCollideMask(BitMask32.bit(1))
#self.targetS.show()
#otherwise, keep it as a self.ppl
else:
self.ppl = loader.loadModel("models/alfred")
self.ppl.setPos(pplLst[pos])
self.ppl.setScale(5)
#put a tag on each person so we can tell them apart
self.ppl.setTag('personNum', str(num))
self.ppl.reparentTo(render)
#make it so that the people can be collision detected
self.pplC = self.ppl.attachNewNode(CollisionNode('pplCollision'))
self.pplC.node().addSolid(CollisionSphere(0, 0, 5, 7))
self.pplC.node().setIntoCollideMask(BitMask32.bit(1))
self.pplC.setTag('personCNum', str(num))
#self.pplC.show()
#first index in pplLst = minotar
minotaurPos = pplLst[0]
#Minotaur 3d model by 'Clint Bellanger' https://opengameart.org/content/minotaur
self.minotaur = Actor("models/TheMinotaur")
self.minotaur.setPos(minotaurPos)
self.minotaur.setScale(25)
self.minotaur.reparentTo(render)
minotaurTexture = loader.loadTexture("models/catfur.jpg")
self.minotaur.setTexture(minotaurTexture)
self.minC = self.minotaur.attachNewNode(CollisionNode('minCollision'))
self.minC.node().addSolid(CollisionSphere(0 , 0, 1, 0.5))
self.minC.node().setFromCollideMask(BitMask32.bit(2))
#self.minC.node().setIntoCollideMask(BitMask32.bit(1))
#self.minC.show()
self.minBat = self.minotaur.attachNewNode(CollisionNode('battle'))
self.minBat.node().addSolid(CollisionSphere(0, 0, 1, 4.3))
self.minBat.node().setIntoCollideMask(BitMask32.bit(1))
self.minBat.show()
self.minHit = self.minotaur.attachNewNode(CollisionNode('hit'))
self.minHit.node().addSolid(CollisionSphere(0, 0, 1.5, 0.4))
self.minHit.node().setIntoCollideMask(BitMask32.bit(3))
self.minAtk = self.minotaur.attachNewNode(CollisionNode('attack'))
self.minAtk.node().addSolid(CollisionSphere(0, 0, 1.85, 0.4))
self.minAtk.node().setIntoCollideMask(BitMask32.bit(4))
self.minAtk.show()
self.cTrav = CollisionTraverser()
self.cHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.minC, self.cHandler)
self.cTrav.addCollider(self.minAtk, self.cHandler)
self.minotaurObj = Minotaur(self.minotaur.getPos())
#find the path the minotaur takes to kill the person
self.killPath = self.minotaurObj.findPerson(minotaurPos, targetPos, self.ptGrid, self.lstWalls, self.spacing)
self.minSpeed = 1
self.sleepDelay = 13
self.killFlag = True
self.killDone = False
self.killPause = False
self.killPaused = False
self.hit = False
self.hurtTime = 0
self.minDied = False
self.minTimeDied = 0
self.attackTrig = False
self.warningTrig = True
taskMgr.add(self.minotaurKilling, "minotaurKilling")
taskMgr.add(self.minotaurDie, 'minotaurDied')
taskMgr.add(self.pauseKill, 'pauseKill')
self.saved = 0
self.addSaved = False
self.saveTrig = False
taskMgr.add(self.displaySaved, "saved")
#collisions
#create a ball for collisions
self.camBall = loader.loadModel("models/ball")
self.camBall.setPos(self.spacing/2, self.spacing/2, -1)
self.camBall.setScale(10)
#self.camBall.setColorScale(0, 1, 0.7, 1)
self.camBall.reparentTo(render)
self.playerPos = (0,0,0)
self.camBallC = self.camBall.find("**/ball")
#self.camBallC = self.camBall.attachNewNode(CollisionNode('camCollision'))
#self.camBallC.node().addSolid(CollisionSphere(0, 0, 0, 1.2))
self.camBallC.node().setFromCollideMask(BitMask32.bit(0))
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(self.camBallC, self.camBall)
self.cTrav.addCollider(self.camBallC, self.pusher)
self.camBallC.setPos(0,0.0002,0)
self.camC = self.camera.attachNewNode(CollisionNode('cameraCollision'))
self.camC.node().addSolid(CollisionSphere(0, 0, 0, 0.01))
self.camC.node().setFromCollideMask(BitMask32.bit(1))
self.camC.node().setIntoCollideMask(BitMask32.bit(4))
self.camC.show()
self.cTrav.addCollider(self.camC, self.cHandler)
taskMgr.add(self.disappear, "disappear")
#sting-sword model created by KangaroOz 3D, from: https://www.turbosquid.com/FullPreview/Index.cfm/ID/1125944
self.sword = loader.loadModel('models/sting-sword')
self.sword.wrtReparentTo(self.camBall)
self.sword.detachNode()
self.sword.setY(1)
self.sword.setX(0.5)
self.sword.setZ(0.2)
self.sword.setScale(0.07)
self.swordC = self.sword.attachNewNode(CollisionNode('stab'))
self.swordC.node().addSolid(CollisionSphere(0, 25, 0, 2))
self.swordC.node().setFromCollideMask(BitMask32.bit(3))
#self.swordC.show()
self.attacked = False
self.stabbing = False
self.cTrav.add_collider(self.swordC, self.cHandler)
swordTexture = loader.loadTexture("models/Sting_Emissive.png")
self.sword.setTexture(swordTexture)
self.stabDelay = 0
self.redBarL = loader.loadModel('models/walls')
self.redBarL.setScale(3)
self.redBarL.setColorScale(250,0,0,1)
self.redBarL.setPos(38.5, 60,5)
self.redBarL.wrtReparentTo(self.camBall)
self.redBarL.detachNode()
self.redBarR = loader.loadModel('models/walls')
self.redBarR.setScale(3)
self.redBarR.setColorScale(250,0,0,1)
self.redBarR.setPos(55.7,60,5)
self.redBarR.wrtReparentTo(self.camBall)
self.redBarR.detachNode()
self.hurtTimeP = 0
#make list of controls
self.keyMap = {
"left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0,\
"cam-right": 0, "stab":0, "map": 0, "instrMode":0, "gameMode":0}
# Make the mouse invisible, turn off normal mouse controls
self.disableMouse()
props = WindowProperties()
props.setCursorHidden(True)
# Set the current viewing target
self.heading = 0
self.pitch = 0
self.last = 0
self.startMode = True
self.startTrig = True
self.startDestroy = True
self.instrMode = False
self.instrTrig = True
self.instrShown = False
self.instrDestroy = True
self.gameMode = False
self.bkGround = loader.loadModel('models/walls')
self.bkGround.reparentTo(self.camBall)
self.bkGround.setColorScale(0,0.5,0.55,1)
self.bkGround.setPos(-1,3,0)
taskMgr.add(self.showStart, "start-screen")
taskMgr.add(self.controlCamera, "camera-task")
self.accept("escape", sys.exit, [0])
self.accept("o", self.setKey, ["instrMode", True])
self.accept("p", self.setKey, ["gameMode", True])
self.accept("arrow_left", self.setKey, ["left", True])
self.accept("arrow_right", self.setKey, ["right", True])
self.accept("arrow_up", self.setKey, ["forward", True])
self.accept("arrow_down", self.setKey, ["backward", True])
self.accept("w", self.setKey, ["stab", True])
self.accept("s", self.setKey, ["down", True])
self.accept("arrow_left-up", self.setKey, ["left", False])
self.accept("arrow_right-up", self.setKey, ["right", False])
self.accept("arrow_up-up", self.setKey, ["forward", False])
self.accept("arrow_down-up", self.setKey, ["backward", False])
self.accept("w-up", self.setKey, ["stab", False])
self.accept("s-up", self.setKey, ["down", False])
self.accept("a", self.setKey, ["cam-left", True])
self.accept("d", self.setKey, ["cam-right", True])
self.accept("a-up", self.setKey, ["cam-left", False])
self.accept("d-up", self.setKey, ["cam-right", False])
self.accept("space", self.setKey, ["map", True])
self.accept("space-up", self.setKey, ["map", False])
def setKey(self, key, value):
self.keyMap[key] = value
def startKill(self):
try:
self.target.setColorScale(250,0,0,1)
except:
pass
intervalL = self.intervalLst()
self.kill = Sequence(intervalL[0], name = 'kill person')
for i in range(1, len(intervalL)):
self.kill.append(intervalL[i])
self.kill.start()
def pauseKill(self, task):
print(self.killPaused, self.killPause)
if self.gameMode == True:
if self.killDone == True:
self.kill.finish()
if self.killPaused == False and self.killPause == True:
print('hmmmmmmmmmmmm')
self.kill.pause()
self.killPaused = True
if self.killPaused == True and self.killPause == False:
self.kill.resume()
self.killPaused = False
return Task.cont
def intervalLst(self):
intervals = []
for i in range(len(self.killPath)):
intervals += [self.minotaur.posInterval(self.minSpeed, Point3(self.killPath[i]))]
return intervals
def stab(self, task):
timer = globalClock.getFrameTime()
speed = 0.2
stabIn = LerpPosInterval(self.sword, speed, Point3(0,4,0.2))
stabOut = LerpPosInterval(self.sword, speed, Point3(0.5,1,0.2))
stab = Sequence(stabIn, stabOut, name = 'stab')
stab.start()
self.stabbing = True
if self.hit == True:
self.minotaurObj.hit()
self.hurtTime = globalClock.getFrameTime()
self.hurtShow(task)
self.hit = False
self.stabbing = False
def hurtShow(self, task):
if self.hit == True:
timer = globalClock.getFrameTime()
if timer - self.hurtTime < 2:
self.minotaur.setColorScale(180,0,0,1)
return Task.cont
def attack(self, task):
if self.attackTrig == True:
speed = 1
turnSpeed = 0.5
attackPos, distance, direction = self.minotaurObj.attack(self.camera.getPos(), self.minotaur.getPos(), \
self.ptGrid, self.spacing, self.lstWalls)
origPt = self.minotaur.getPos()
if attackPos != None:
attack = LerpPosInterval(self.minotaur, speed, Point3(attackPos))
turnToPlayer = LerpHprInterval(self.minotaur, turnSpeed, self.minotaurObj.facePlayer(direction))
if distance == 'short':
retract = LerpPosInterval(self.minotaur, speed, origPt)
attackSeq = Sequence(turnToPlayer, attack, retract, name = 'attack')
attackSeq.start()
else:
attackSeq = Sequence(turnToPlayer, attack, name = 'attack')
attackSeq.start()
self.attackTrig = False
def attackShow(self, task):
if self.attacked == True:
timer = globalClock.getFrameTime()
if timer - self.hurtTimeP < 2:
self.redBarL.reparentTo(self.camBall)
self.redBarR.reparentTo(self.camBall)
if self.loseHealth == True:
self.playerHealth -= 10
print(self.playerHealth)
self.loseHealth = False
return Task.cont
def displaySaved(self, task):
if self.gameMode == True:
if self.saved == 0 and self.saveTrig == False:
msg = 'Saved: ' + str(self.saved)
self.displSaved = OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), scale=.05,
shadow=(0, 0, 0, 1),parent=base.a2dTopLeft, align=TextNode.ALeft,
pos=(0.05, -1.9))
self.saveTrig = True
if self.addSaved == True and self.saveTrig == True and self.saved > 0:
print('here')
self.displSaved.destroy()
msg = 'Saved: ' + str(self.saved)
self.displSaved = OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), scale=.05,
shadow=(0, 0, 0, 1),parent=base.a2dTopLeft, align=TextNode.ALeft,
pos=(0.05, -1.9))
self.addSaved = False
return Task.cont
def minotaurKilling(self, task):
if self.gameMode == True:
#timer for minotaur sleeping
timer = globalClock.getFrameTime()
timeLeft = self.sleepDelay - int(timer)
#put up the instructions before the minotaur wakes up
if timeLeft >= 0:
if self.warningTrig == True:
if timeLeft == 1:
msg = "You have 1 second to find the Minotaur before he wakes up!"
elif timeLeft == 0:
msg = "He's awake!"
else:
msg = "You have " + str(timeLeft) + " seconds to find the Minotaur before he wakes up!"
self.warning = OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), scale=0.08,
shadow=(0, 0, 0, 1),parent=base.a2dTopLeft, align=TextNode.ALeft,
pos=(0.05, -0.08))
self.displayWarning = timer
self.warningTrig = False
if timer - self.displayWarning > 0.92:
self.warning.destroy()
self.warningTrig = True
if timeLeft < 0:
self.warning.destroy()
#wake the minotaur up after time ends
if timeLeft < 0 and self.killFlag == True:
self.startKill()
self.killFlag = False
#make sure minotaur is always the right color
if timer - self.hurtTime > 2:
self.minotaur.setColorScaleOff()
if timer - self.hurtTimeP > 2:
self.redBarL.detachNode()
self.redBarR.detachNode()
if self.minDied == True:
if timer - self.minTimeDied > 20:
self.minotaur.detachNode()
self.exit.reparentTo(render)
self.showRopes()
if timer - self.hurtTimeP > 2:
self.loseHealth = True
return Task.cont
def minotaurDie(self, task):
if self.minotaurObj.health <= 0 and self.minDied == False:
dieSpeed = 3
die = LerpHprInterval(self.minotaur, dieSpeed, (self.camera.getX(), 90, 5))
die.start()
self.minDied = True
self.minTimeDied = globalClock.getDt()
return Task.cont
def showropes(self):
ropeHeight = 30
lastRope = findExitPos(self.exitPos, self.ptGrid, self.spacing)
playerPos = findPlayerPos(self.camera.getPos(), self.spacing)
playerPos = (playerPos[0], playerPos[1], ropeHeight)
ropePath, ropeDir = findExit(playerPos, lastRope, self.ptGrid, self.lstWalls, self.spacing)
lastDir = findDir(self.exitCoord, self.ptGrid)
if ropeDir != None:
ropeDir += [lastDir]
#gold texture found at https://www.google.com/url?sa=i&source=images&cd=&cad=r\
#ja&uact=8&ved=2ahUKEwjw76Lbv4rfAhVpvFkKHY3JDPYQjRx6BAgBEAU&url=http%3A%2F\
#%2Fmetal.graphics%2Fgraphic%2Fbrushed%2Fgold-texture%2F&psig=AOvVaw1q3Yu\
#xuuGvetU4fhA1cIqh&ust=1544161415078294
goldTexture = loader.loadTexture("models/gold.jpg")
if ropePath != None:
#rope model by Robert J. Smith, https://www.cgtrader.com/free-3d-models/industrial/tool/knot-rope
for pos in range(len(ropePath)):
rope = loader.loadModel("models/rope1")
rope.setPos(ropePath[pos])
rope.setScale(3.6)
rope.setZ(-5)
if pos < len(ropeDir):
if ropeDir[pos] == 'e':
rope.setHpr(76,0,0)
rope.setX(rope.getX() + 75)
rope.setY(rope.getY() + 5)
if ropeDir[pos] == 'n':
rope.setHpr(166,0,0)
rope.setY(rope.getY() + 65)
if ropeDir[pos] == 'w':
rope.setHpr(256,0,0)
rope.setX(rope.getX() - 60)
rope.setY(rope.getY() - 9)
if ropeDir[pos] == 's':
rope.setHpr(-14,0,0)
rope.setY(rope.getY() - 70)
rope.setX(rope.getX() + 15)
rope.setTexture(goldTexture)
rope.reparentTo(render)
def lostGame(self):
lose = loader.loadModel('models/walls')
lose.reparentTo(self.camBall)
lose.setColorScale(0.1,0.1,0.1,1)
lose.setPos(-1,3,0)
def showStart(self, task):
startMsg = "Welcome to Daedalus's Creation."
startMsg2 = "You have to kill the minotaur, navegate the labyrinth, and save the others."+"You have 30 seconds to find the Minotaur before he wakes up and starts killing your people."
startMsg3 = "Good luck doing what no man has done before."
startMsg4 = "Press 'o' for instructions on how to play."
if self.startMode == True and self.startTrig == True:
self.start = OnscreenText(text=startMsg, style=1, fg=(1, 1, 1, 1), scale=0.08,
shadow=(0, 0, 0, 1),parent=base.aspect2d, pos = (0,0.5), align=TextNode.ACenter, wordwrap= 15)
self.start2 = OnscreenText(text=startMsg2, style=1, fg=(1, 1, 1, 1), scale=0.08,
shadow=(0, 0, 0, 1),parent=base.aspect2d, align=TextNode.ACenter, pos = (0,0.2), wordwrap= 20)
self.start3 = OnscreenText(text=startMsg3, style=1, fg=(1, 1, 1, 1), scale=0.08,
shadow=(0, 0, 0, 1),parent=base.aspect2d, align=TextNode.ACenter, pos = (0,-0.2), wordwrap= 25)
self.start4 = OnscreenText(text=startMsg4, style=1, fg=(1, 1, 1, 1), scale=0.1,
shadow=(0, 0, 0, 1),parent=base.aspect2d, align=TextNode.ACenter, pos = (0,-0.5), wordwrap= 25)
self.startTrig = False
if self.startMode == False and self.startDestroy == True:
self.start.destroy()
self.start2.destroy()
self.start3.destroy()
self.start4.destroy()
self.startDestroy = False
task.remove()
return Task.cont
def showInstr(self):
instrMsg = "Press the right and left arrow keys to move right and left."
instrMsg1 = "Press the up and down arrow keys to move forwards and backwards."
instrMsg2 = "Press the 'a' key to turn the camera left."
instrMsg3 = "Press the 'd' key to turn the camera right."
instrMsg4 = "Press the space key for a map of the labyrinth"
instrMsg5 = "Press the 'w' key to attack."
instrMsg6 = "Press the 'p' key to start the game."
if self.instrMode == True and self.instrTrig == True:
self.instr = OnscreenText(text=instrMsg, style=1, fg=(1, 1, 1, 1), scale=0.08,
shadow=(0, 0, 0, 1),parent=base.aspect2d, pos = (0,0.7), align=TextNode.ACenter, wordwrap= 30)
self.instr1 = OnscreenText(text=instrMsg1, style=1, fg=(1, 1, 1, 1), scale=0.08,
shadow=(0, 0, 0, 1),parent=base.aspect2d, pos = (0,0.5), align=TextNode.ACenter, wordwrap= 20)
self.instr2 = OnscreenText(text=instrMsg2, style=1, fg=(1, 1, 1, 1), scale=0.08,
shadow=(0, 0, 0, 1),parent=base.aspect2d, align=TextNode.ACenter, pos = (0,0.2), wordwrap= 20)
self.instr3 = OnscreenText(text=instrMsg3, style=1, fg=(1, 1, 1, 1), scale=0.08,
shadow=(0, 0, 0, 1),parent=base.aspect2d, align=TextNode.ACenter, pos = (0,0), wordwrap= 25)
self.instr4 = OnscreenText(text=instrMsg4, style=1, fg=(1, 1, 1, 1), scale=0.08,
shadow=(0, 0, 0, 1),parent=base.aspect2d, align=TextNode.ACenter, pos = (0,-0.2), wordwrap= 25)
self.instr5 = OnscreenText(text=instrMsg5, style=1, fg=(1, 1, 1, 1), scale=0.08,
shadow=(0, 0, 0, 1),parent=base.aspect2d, align=TextNode.ACenter, pos = (0,-0.4), wordwrap= 25)
self.instr6 = OnscreenText(text=instrMsg6, style=1, fg=(1, 1, 1, 1), scale=0.1,
shadow=(0, 0, 0, 1),parent=base.aspect2d, align=TextNode.ACenter, pos = (0,-0.6), wordwrap= 25)
self.instrTrig = False
self.instrShown = True
def endInstr(self):
if self.instrMode == False and self.instrDestroy == True and self.instrShown == True:
self.instr.destroy()
self.instr1.destroy()
self.instr2.destroy()
self.instr3.destroy()
self.instr4.destroy()
self.instr5.destroy()
self.instr6.destroy()
self.instrDestroy = False
#make the person disappear when it's touched
def disappear(self,task):
for i in range(self.cHandler.getNumEntries()):
entry = self.cHandler.getEntry(i)
fromNode = entry.getFromNodePath()
intoNode = entry.getIntoNodePath()
intoName = entry.getIntoNode().getName()
fromName = entry.getFromNode().getName()
#if the collision was with a person
if (intoName == 'pplCollision' and fromName == 'cameraCollision'):
num = intoNode.getTag("personCNum")
tag = '**/=personNum=' + num
#finds the person player collided into and removes them
person = render.find(tag)
person.removeNode()
#add one to saved counter
self.saved += 1
self.addSaved = True
self.displSaved.destroy()
return Task.cont
if intoName == 'targetSave' and fromName == 'cameraCollision':
print('saved!')
self.target.removeNode()
self.saved += 1
self.addSaved = True
return Task.cont
if intoName == 'targetDie' and fromName == 'minCollision':
print('ahhhhhhhhh!')
self.target.removeNode()
self.killDone = True
return Task.cont
#if minotaur gets stabbed by player
if intoName == 'hit' and fromName == 'stab':
if self.stabbing == True:
self.hit = True
return Task.cont
if intoName == 'cameraCollision' and fromName == 'attack':
print('attacked!!!!!')
self.attacked = True
self.hurtTimeP = globalClock.getFrameTime()
self.attackShow(task)
if self.playerHealth < 0:
self.lostGame()
return Task.cont
if (intoName == 'battle' and fromName == 'cameraCollision' and self.killFlag == False) \
or (intoName == 'minCollision' and fromName == 'cameraCollision' and self.killFlag == False):
print('pause')
self.killPause = True
return Task.cont
else:
print('hereeeee')
self.killPause = False
print('killPause', self.killPause)
return Task.cont
#structure from panda3d bump mapping demo
def controlCamera(self, task):
dt = globalClock.getDt()
self.camera.setHpr(self.heading, self.pitch, 0)
self.camBall.setHpr(self.heading, self.pitch, 0)
dir = self.camera.getMat().getRow3(1)
camPos = (self.camBall.getPos()[0], self.camBall.getPos()[1], 6)
self.camera.setPos(camPos)
if self.keyMap["instrMode"] == True:
self.startMode = False
self.instrMode = True
self.showInstr()
if self.keyMap["gameMode"] == True:
self.instrMode = False
self.gameMode = True
self.bkGround.detachNode()
self.endInstr()
if self.gameMode == True:
#move camera right and left
if self.keyMap["left"]:
self.camBall.setX(self.camBall, -10*dt)
if self.keyMap["right"]:
self.camBall.setX(self.camBall, +10*dt)
if self.keyMap["forward"]:
self.camBall.setY(self.camBall, +10*dt)
if self.keyMap["backward"]:
self.camBall.setY(self.camBall, -10*dt)
#rotate camera
if self.keyMap["cam-right"]:
self.heading = self.heading - 100*dt
if self.keyMap["cam-left"]:
self.heading = self.heading + 100*dt
self.focus = self.camera.getPos() + (dir * 5)
self.last = task.time
if self.keyMap['stab']:
timer = globalClock.getFrameTime()
if timer - self.stabDelay > 0.5:
self.stab(task)
self.stabDelay = timer
self.attack(task)
self.attackTrig = True
#show map
if self.keyMap["map"] == True:
center = (len(self.ptGrid))/2*self.spacing
self.camera.setPos(center,center, 1.8*len(self.ptGrid)*self.spacing)
self.camera.lookAt(center, center, 0)
self.sword.detachNode()
if self.killFlag == False and self.killPause == True:
self.kill.pause()
self.camBall.reparentTo(render)
self.camBall.setScale(20)
self.camBall.setColorScale(0, 0.5, 1, 1)
if self.keyMap["map"] == False and self.startMode == False and self.instrMode == False:
self.sword.reparentTo(self.camBall)
self.camBall.setColorScaleOff()
self.camBall.setScale(10)
return Task.cont
class MapObject(MapObjectBase):
"""MapObject can't move or change map in game"""
def __init__(self, map, genre, name):
MapObjectBase.__init__(self, name)
self.map = map # reference to the Map the object belongs to
self.genre = genre # NPC, building, decor, item, warp...
self.name = name
self.model = None
self.modelPath = None
self.texturePath = None
self.state = None
self.data = {}
self.dialog = None
self.task = None
self.posTask = None
if self.genre in mapObjectDB:
self.loadModel(mapObjectDB[self.genre][0],
mapObjectDB[self.genre][1])
self.addCollision(mapObjectDB[self.genre][2])
#self.oldPos= Point3()
'''
if self.genre is not "NPC":
print("\n\n- mapObject init : %s, pos = %s" % (self.name, self.getPos()))
self.posTask = taskMgr.add(self.checkPosTask, "posTask")
else:
self.posTask = None
'''
def checkPosTask(self, task):
if self.getPos() != self.oldPos:
print "WARNING : map object pos changed from %s to %s, correcting" % (
self.oldPos, self.getPos())
#self.oldPos = self.getPos()
self.setPos(self.oldPos)
#else:
# print "%s pos is still %s" % (self.name, self.oldPos)
return task.cont
def addCollision(self, pos):
self.colSphere = CollisionSphere(pos[0], pos[1], pos[2], pos[3])
#self.colSphere = CollisionTube(0,0,0,0,0,1.8,0.4)
self.colNodepath = CollisionNode(self.name)
self.colNode = self.model.attachNewNode(self.colNodepath)
self.colNode.node().addSolid(self.colSphere)
def loadModel(self, modelPath, texturePath=None):
if self.model:
self.model.remove()
self.modelPath = modelPath
self.model = loader.loadModel(modelPath)
self.model.setTransparency(TransparencyAttrib.MAlpha)
if texturePath:
tex = loader.loadTexture(texturePath)
self.texturePath = texturePath
self.model.setTexture(tex)
self.model.reparentTo(self)
def loadActor(self, modelPath, animDic={}, texturePath=None):
if self.model is not None:
self.model.remove()
self.model = Actor(modelPath, animDic)
#self.model.setTransparency(True)
if texturePath is not None:
self.tex = loader.loadTexture(texturePath)
#self.model.clearTexture(TextureStage.getDefault())
self.model.clearTexture()
self.model.setTexture(TextureStage.getDefault(), self.tex)
self.currentAnim = None
self.model.reparentTo(self)
#def reparentTo(self, np):
# self.model.reparentTo(np)
#if self.genre is not "NPC":
# print "Reparenting %s to %s, pos is now %s" % (self.name, str(np), self.getPos())
def getSaveData(self):
data = []
data.append(self.name)
data.append(self.genre)
data.append(self.model.getPos())
data.append(self.model.getHpr())
data.append(self.model.getScale())
return data
#-------------------------------------------------------------------
# Pos
def setPos(self, pos):
#self.model.setPos(pos[0], pos[1], pos[2])
'''
if self.genre is not "NPC":
print "- mapObject (%s): set pos, oldpos = %s, newpos = %s" % (self.name, self.getPos(), pos)
'''
self.model.setPos(pos)
'''
if self.genre is not "NPC":
print "--- after setPos, mapObject pos = %s" % (self.getPos())
self.oldPos = pos
'''
def getPos(self):
if self.model: return self.model.getPos()
else: return None
def setZ(self, z):
self.model.setZ(z)
def getZ(self):
return self.model.getZ()
def setTilePos(self, x, y):
self.setPos((x + 0.5, y + 0.5, self.model.getZ()))
def getTilePos(self):
return int(self.model.getX()), int(self.model.getY())
def moveZ(self, dt=0.01):
self.model.setZ(self.model.getZ() + dt)
#-------------------------------------------------------------------
# Hpr
def setHpr(self, hpr):
self.model.setHpr(hpr)
def getRot(self):
return self.model.getH()
def setRot(self, n):
self.model.setH(n)
def rotate(self, dt=0.01):
self.model.setH(self.model.getH() + dt * 50)
#-------------------------------------------------------------------
# Scale
def setScale(self, scale):
self.model.setScale(scale)
def getScale(self):
return self.model.getScale()
def getScaleX(self):
return self.model.getSx()
def scale(self, dt=0.01):
self.model.setScale(self.model.getSx() + dt)
def destroy(self):
if self.task:
taskMgr.remove(self.task)
if self.posTask:
taskMgr.remove(self.posTask)
if self.model:
self.model.detachNode()
self.model.remove()
class Enemy():
def __init__(self, game, hp, mana, speed, attackSpeed, name):
self.game = game
self.name = name
self.model = "models/%s" % self.name
self.modelWalk = "models/%s-walk" % self.name
self.hp = hp
self.mana = mana
self.speed = speed
self.attackSpeed = attackSpeed
self.enemyActor = Actor({
"body": self.model,
}, {
"body": {
"walk": self.modelWalk
},
})
self.enemyActor.setHpr(0, 0, 0)
self.enemyActor.setPos(0, 0, 5)
self.enemyActor.setScale(0.5)
self.enemyActor.reparentTo(render)
self.setupAI()
def getName(self):
return self.name
def attacked(self, damage):
print("man pegao")
self.hp -= damage
if self.hp <= 0:
self.enemyActor.detachNode()
self.enemyActor.removeNode()
self.game.taskMgr.remove("%sTask" % self.name)
def setupAI(self):
self.enemyActor.loop("walk")
self.AIchar = AICharacter("enemy", self.enemyActor, 60, 0.05, 5)
self.game.AIworld.addAiChar(self.AIchar)
self.AIbehaviors = self.AIchar.getAiBehaviors()
self.AIbehaviors.wander(10, 0, 15, 1.0)
#Path follow (note the order is reveresed)
"""
self.AIbehaviors.pathFollow(1)
self.AIbehaviors.addToPath((0,-20,0))
self.AIbehaviors.addToPath((0,20,0))
self.AIbehaviors.addToPath((20,-10,0))
self.AIbehaviors.addToPath((15,-20,0))
self.AIbehaviors.startFollow()
"""
def update(self, Task):
self.AIworld.update()
return Task.cont
class DistributedCannonDefenseShip(DistributedNPCSimpleShip):
__module__ = __name__
specialHitSfx = {}
coldShotHitSfx = None
sharkChompSfx = {}
def __init__(self, cr):
DistributedNPCSimpleShip.__init__(self, cr)
self.goldStolenlbl = None
self.hasGoldlbl = None
self.hasBNote = None
self.textureCard = None
self.goldIcon = None
self.flameEffects = []
self.isSinkingWhileOnFire = False
self.healthModifier = 0
self.modifierSet = False
self.shipStatsSet = False
self.shipStatIndex = None
self.initHealthBar()
self.initIndicatorIcons()
self.sinkTimeScale = CannonDefenseGlobals.SHIP_SINK_DURATION_SCALE
self.sharkActor = Actor(
'models/char/pir_r_gam_fsh_lgComTshark.bam',
{'attack': 'models/char/pir_a_gam_fsh_lgComTshark_attack.bam'})
self.sharkParallel = None
self.fader = None
if not self.coldShotHitSfx:
DistributedCannonDefenseShip.specialHitSfx = {
InventoryType.DefenseCannonMineInWater:
loadSfx(SoundGlobals.SFX_MINIGAME_CANNON_MINE_HIT),
InventoryType.DefenseCannonBomb:
loadSfx(SoundGlobals.SFX_MINIGAME_CANNON_BOMB_HIT),
InventoryType.DefenseCannonHotShot:
loadSfx(SoundGlobals.SFX_MINIGAME_CANNON_HOTSHOT_HIT),
InventoryType.DefenseCannonFireStorm:
loadSfx(SoundGlobals.SFX_MINIGAME_CANNON_FIRESTORM_HIT),
InventoryType.DefenseCannonChumShot:
loadSfx(SoundGlobals.SFX_MINIGAME_CANNON_SHARK)
}
DistributedCannonDefenseShip.coldShotHitSfx = loadSfx(
SoundGlobals.SFX_MINIGAME_CANNON_ICE_HIT)
DistributedCannonDefenseShip.sharkChompSfxs = [
loadSfx(SoundGlobals.SFX_MONSTER_SMASH_01),
loadSfx(SoundGlobals.SFX_MONSTER_SMASH_02),
loadSfx(SoundGlobals.SFX_MONSTER_SMASH_03)
]
return
def buildShip(self):
DistributedNPCSimpleShip.buildShip(self)
self.model.sfxAlternativeStyle = True
def setupLocalStats(self):
DistributedNPCSimpleShip.setupLocalStats(self)
def setShipStatIndex(self, statIndex):
self.shipStatsSet = True
self.shipStatIndex = statIndex
self.maxHp = CannonDefenseGlobals.shipStats[
self.shipStatIndex]['shipHp']
self.maxMastHealth = CannonDefenseGlobals.shipStats[
self.shipStatIndex]['mastHp']
self.healthBar.setPos(
0.0, 0.0, CannonDefenseGlobals.shipStats[self.shipStatIndex]
['healthBarHeight'])
if self.modifierSet:
self.calcModifiedHealth()
def setHealthModifier(self, modifier):
self.modifierSet = True
self.healthModifier = modifier
if self.shipStatsSet:
self.calcModifiedHealth()
def calcModifiedHealth(self):
if self.healthModifier == 0:
return
self.maxHp += self.healthModifier * (
self.maxHp * CannonDefenseGlobals.ENEMY_DIFFICULTY_INCREASE)
mastList = CannonDefenseGlobals.shipStats[self.shipStatIndex]['mastHp']
mastFinalHp = []
for mastHealth in mastList:
hp = mastHealth
hp += self.healthModifier * (
mastHealth * CannonDefenseGlobals.ENEMY_DIFFICULTY_INCREASE)
mastFinalHp.append(hp)
self.maxMastHealth = mastFinalHp
def setLogo(self, logo):
self.logo = logo
def setStyle(self, style):
self.style = style
def announceGenerate(self):
DistributedNPCSimpleShip.announceGenerate(self)
rad = (self.model.dimensions / 2.0).length()
cn = NodePath(CollisionNode('c'))
cs = CollisionSphere(0, 0, 0, rad)
cn.node().addSolid(cs)
cn.reparentTo(self.model.modelCollisions)
cn.setTransform(self.model.center.getTransform(self))
cn.node().setIntoCollideMask(PiratesGlobals.GenericShipBitmask)
self.model.defendSphere = cn
self.model.modelRoot.setScale(CannonDefenseGlobals.SHIP_SCALE)
self.fadeIn(CannonDefenseGlobals.SHIP_FADEIN)
self.smoother.setExpectedBroadcastPeriod(0.3)
self.smoother.setDelay(2)
self.healthBar.reparentTo(self.model.modelRoot)
def initHealthBar(self):
self.healthBar = DirectWaitBar(frameSize=(-0.35, 0.35, -0.04, 0.04),
relief=DGG.FLAT,
frameColor=(0.0, 0.0, 0.0, 0.0),
borderWidth=(0.0, 0.0),
barColor=(0.0, 1.0, 0.0, 1.0),
scale=100)
self.healthBar.setBillboardPointEye()
self.healthBar['value'] = 100
self.healthBar.hide(OTPRender.ReflectionCameraBitmask)
self.healthBar.setLightOff()
def initIndicatorIcons(self):
self.textureCard = loader.loadModel(
'models/textureCards/pir_m_gam_can_ship_icons')
if self.textureCard:
self.goldIcon = self.textureCard.find('**/pir_t_shp_can_gold*')
self.goldStolenlbl = DirectLabel(
parent=self.healthBar,
relief=None,
pos=(0, 0, 0.2),
text_align=TextNode.ACenter,
text_scale=0.5,
textMayChange=0,
text='!',
text_fg=PiratesGuiGlobals.TextFG23,
text_shadow=PiratesGuiGlobals.TextShadow,
text_font=PiratesGlobals.getPirateBoldOutlineFont(),
sortOrder=2)
self.goldStolenlbl.setTransparency(1)
self.goldStolenlbl.hide()
self.hasGoldlbl = DirectLabel(parent=self.healthBar,
relief=None,
pos=(0, 0, 0.35),
image=self.goldIcon,
image_scale=0.5,
image_pos=(0, 0, 0),
sortOrder=2)
self.hasGoldlbl.setTransparency(1)
self.hasGoldlbl.hide()
self.hasBNote = self.healthBar.attachNewNode('noteIndicator')
self.bnoteBack = loader.loadModel(
'models/textureCards/skillIcons').find(
'**/pir_t_gui_can_moneyIcon').copyTo(self.hasBNote)
self.hasBNote.setZ(0.35)
self.hasBNote.setScale(0.6)
self.hasBNote.hide()
return
def getHealthBarColor(self, health):
return CannonDefenseGlobals.SHIP_HEALTH_COLORS[int(
health / 100.0 *
(len(CannonDefenseGlobals.SHIP_HEALTH_COLORS) - 1))]
def setHealthState(self, health):
DistributedNPCSimpleShip.setHealthState(self, health)
self.healthBar['value'] = health
self.healthBar['barColor'] = self.getHealthBarColor(health)
def setCurrentState(self, state):
if state == CannonDefenseGlobals.SHIP_STATE_STEALING:
self.goldStolenlbl.show()
else:
if state == CannonDefenseGlobals.SHIP_STATE_HASTREASURE:
self.hasGoldlbl.show()
self.goldStolenlbl.hide()
else:
if state == CannonDefenseGlobals.SHIP_STATE_HASBNOTES:
self.hasBNote.show()
self.goldStolenlbl.hide()
else:
self.hasGoldlbl.hide()
self.hasBNote.hide()
self.goldStolenlbl.hide()
rad = (self.model.dimensions / 2.0).length()
cn = NodePath(CollisionNode('c'))
cs = CollisionSphere(0, 0, 0, rad)
cn.node().addSolid(cs)
cn.reparentTo(self.model.modelCollisions)
cn.setTransform(self.model.center.getTransform(self))
cn.node().setIntoCollideMask(PiratesGlobals.GenericShipBitmask)
self.model.defendSphere = cn
self.model.modelRoot.setScale(CannonDefenseGlobals.SHIP_SCALE)
self.fadeIn(CannonDefenseGlobals.SHIP_FADEIN)
self.smoother.setExpectedBroadcastPeriod(0.3)
self.smoother.setDelay(2)
self.healthBar.reparentTo(self.model.modelRoot)
def initHealthBar(self):
self.healthBar = DirectWaitBar(frameSize=(-0.35, 0.35, -0.04, 0.04),
relief=DGG.FLAT,
frameColor=(0.0, 0.0, 0.0, 0.0),
borderWidth=(0.0, 0.0),
barColor=(0.0, 1.0, 0.0, 1.0),
scale=100)
self.healthBar.setBillboardPointEye()
self.healthBar['value'] = 100
self.healthBar.hide(OTPRender.ReflectionCameraBitmask)
self.healthBar.setLightOff()
def initIndicatorIcons(self):
self.textureCard = loader.loadModel(
'models/textureCards/pir_m_gam_can_ship_icons')
if self.textureCard:
self.goldIcon = self.textureCard.find('**/pir_t_shp_can_gold*')
self.goldStolenlbl = DirectLabel(
parent=self.healthBar,
relief=None,
pos=(0, 0, 0.2),
text_align=TextNode.ACenter,
text_scale=0.5,
textMayChange=0,
text='!',
text_fg=PiratesGuiGlobals.TextFG23,
text_shadow=PiratesGuiGlobals.TextShadow,
text_font=PiratesGlobals.getPirateBoldOutlineFont(),
sortOrder=2)
self.goldStolenlbl.setTransparency(1)
self.goldStolenlbl.hide()
self.hasGoldlbl = DirectLabel(parent=self.healthBar,
relief=None,
pos=(0, 0, 0.35),
image=self.goldIcon,
image_scale=0.5,
image_pos=(0, 0, 0),
sortOrder=2)
self.hasGoldlbl.setTransparency(1)
self.hasGoldlbl.hide()
self.hasBNote = self.healthBar.attachNewNode('noteIndicator')
self.bnoteBack = loader.loadModel(
'models/textureCards/skillIcons').find(
'**/pir_t_gui_can_moneyIcon').copyTo(self.hasBNote)
self.hasBNote.setZ(0.35)
self.hasBNote.setScale(0.6)
self.hasBNote.hide()
return
def getHealthBarColor(self, health):
return CannonDefenseGlobals.SHIP_HEALTH_COLORS[int(
health / 100.0 *
(len(CannonDefenseGlobals.SHIP_HEALTH_COLORS) - 1))]
def setHealthState(self, health):
DistributedNPCSimpleShip.setHealthState(self, health)
self.healthBar['value'] = health
self.healthBar['barColor'] = self.getHealthBarColor(health)
def setCurrentState(self, state):
if state == CannonDefenseGlobals.SHIP_STATE_STEALING:
self.goldStolenlbl.show()
else:
if state == CannonDefenseGlobals.SHIP_STATE_HASTREASURE:
self.hasGoldlbl.show()
self.goldStolenlbl.hide()
else:
if state == CannonDefenseGlobals.SHIP_STATE_HASBNOTES:
self.hasBNote.show()
self.goldStolenlbl.hide()
else:
self.hasGoldlbl.hide()
self.hasBNote.hide()
self.goldStolenlbl.hide()
def calculateLook(self):
pass
def playProjectileHitSfx(self, ammoSkillId, hitSail):
if ammoSkillId in [
InventoryType.DefenseCannonColdShotInWater,
InventoryType.DefenseCannonSmokePowder
]:
return
if ammoSkillId in self.specialHitSfx:
sfx = self.specialHitSfx[ammoSkillId]
base.playSfx(sfx, node=self, cutoff=2000)
return
DistributedNPCSimpleShip.playProjectileHitSfx(self, ammoSkillId,
hitSail)
def projectileWeaponHit(self,
skillId,
ammoSkillId,
skillResult,
targetEffects,
pos,
normal,
codes,
attacker,
itemEffects=[]):
DistributedNPCSimpleShip.projectileWeaponHit(self, skillId,
ammoSkillId, skillResult,
targetEffects, pos,
normal, codes, attacker,
itemEffects)
def sinkingBegin(self):
self.healthBar.reparentTo(hidden)
if len(self.flameEffects) > 0:
self.isSinkingWhileOnFire = True
DistributedNPCSimpleShip.sinkingBegin(self)
def sinkingEnd(self):
while len(self.flameEffects) > 0:
effect = self.flameEffects.pop()
effect.stopLoop()
DistributedNPCSimpleShip.sinkingEnd(self)
def addStatusEffect(self,
effectId,
attackerId,
duration=0,
timeLeft=0,
timestamp=0,
buffData=[0]):
if effectId == WeaponGlobals.C_CANNON_DEFENSE_FIRE:
self.addFireEffect(self.getModelRoot().getPos())
if effectId == WeaponGlobals.C_CANNON_DEFENSE_ICE:
base.playSfx(self.coldShotHitSfx, node=self, cutoff=2000)
DistributedNPCSimpleShip.addStatusEffect(self, effectId, attackerId,
duration, timeLeft, timestamp,
buffData)
def removeStatusEffect(self, effectId, attackerId):
DistributedNPCSimpleShip.removeStatusEffect(self, effectId, attackerId)
if effectId == WeaponGlobals.C_CANNON_DEFENSE_FIRE:
if not self.isSinkingWhileOnFire:
while len(self.flameEffects) > 0:
effect = self.flameEffects.pop()
effect.stopLoop()
def addFireEffect(self, pos):
fireEffect = ShipFire.getEffect()
if fireEffect:
fireEffect.reparentTo(self.getModelRoot())
fireEffect.setPos(pos)
fireEffect.setHpr(90, -15, 0)
fireEffect.startLoop()
fireEffect.setEffectScale(20.0)
self.flameEffects.append(fireEffect)
def playSharkAttack(self, pos):
if self.sharkActor.getCurrentAnim() == None:
self.sharkActor.wrtReparentTo(self.getModelRoot())
self.sharkActor.setPos(self, pos)
self.sharkActor.setScale(20)
self.sharkActor.play('attack')
sharkAttackEffect = None
if base.options.getSpecialEffectsSetting(
) >= base.options.SpecialEffectsLow:
effect = CannonSplash.getEffect()
if effect:
effect.reparentTo(base.effectsRoot)
effect.setPos(self, pos)
effect.setZ(1)
effect.play()
sharkAttackEffect = Func(self.playAttackEffect, pos)
hprIvalShip = LerpHprInterval(self.getModelRoot(),
duration=3,
hpr=(0, 0, -180))
s1 = Sequence(Wait(0.75), hprIvalShip,
Func(self.getModelRoot().stash))
s2 = Sequence(Wait(0.75), sharkAttackEffect, Wait(0.5),
sharkAttackEffect)
self.sharkParallel = Parallel(s1, s2)
self.sharkParallel.start()
taskMgr.doMethodLater(self.sharkActor.getDuration('attack'),
self.detachShark,
self.uniqueName('playSharkAttack'),
extraArgs=[])
return
def playAttackEffect(self, pos):
effect = BulletEffect.getEffect()
if effect:
effect.reparentTo(base.effectsRoot)
effect.setPos(self, pos)
effect.loadObjects(6)
effect.play()
sfx = random.choice(self.sharkChompSfxs)
base.playSfx(sfx, node=self.getModelRoot(), cutoff=2000)
def detachShark(self):
self.sharkActor.detachNode()
def delete(self):
if self.fader:
self.fader.pause()
self.fader = None
DistributedNPCSimpleShip.delete(self)
return
def destroy(self):
if self.goldStolenlbl:
self.goldStolenlbl.destroy()
self.goldStolenlbl = None
if self.hasGoldlbl:
self.hasGoldlbl.destroy()
self.hasGoldlbl = None
if self.textureCard:
self.textureCard.removeNode()
self.textureCard = None
self.goldIcon = None
if self.healthBar:
self.healthBar.destroy()
if self.sharkActor:
self.sharkActor.cleanUp()
self.sharkActor.removeNode()
if self.sharkParallel:
self.sharkParallel.pause()
self.sharkParallel = None
DistributedNPCSimpleShip.destroy(self)
return
def fadeIn(self, length):
if self.fader:
self.fader.finish()
self.fader = None
self.setTransparency(1)
self.fader = Sequence(
self.colorScaleInterval(length, Vec4(1, 1, 1, 1), Vec4(1, 1, 1,
0)),
Func(self.clearTransparency))
self.fader.start()
return
def fadeOut(self, length):
if self.fader:
self.fader.finish()
self.fader = None
self.setTransparency(1)
self.fader = Sequence(
self.colorScaleInterval(length, Vec4(1, 1, 1, 0), Vec4(1, 1, 1,
1)),
Func(self.hide), Func(self.clearTransparency))
self.fader.start()
return
class Npc():
def __init__(self,controlPointId,id, anchorx, anchory, anchorz,render,team):
self.id = id
self.anchorx = anchorx
self.anchory = anchory
self.anchorz = anchorz
self.controlPointId = controlPointId
self.target = None
self.isMoving = False
self.health = 200
self.isCurrentUser = False
self.damage = 8
self.attackTimer = 0
self._is_dead = False
self._team = team
self.render = render
'''Initializing NPC actors'''
self.npc = Actor("models/priest",
{"walk": "models/priest-walk", "attack":"models/priest-attack", "hurt":"models/priest-hit", "die":"models/priest-die"})
if self._team==0:
self.npcTex = loader.loadTexture("models/tex/guard_red.png")
else:
self.npcTex = loader.loadTexture("models/tex/guard_blue.png")
self.npc.setTexture(self.npcTex)
self.npc.setScale(0.5, 0.5, 0.5)
self.npc.clearColor()
self.npc.clearColorScale()
self.npc.setColor(255, 0, 0, 0)
self.npc.setColorScale(255, 0, 0, 0)
self.npc.reparentTo(self.render)
self.npc.setPos(anchorx,anchory,anchorz)
self.AIchar = AICharacter("npc"+str(self.id),self.npc, 100, 0.05, 5)
self.AIbehaviors = self.AIchar.getAiBehaviors()
self.hb = HealthBar(1.5, value=self.health)
#self._floater = NodePath(PandaNode("char_info"))
#self._floater.reparentTo(self.npc)
self.hb.setPos(0, 0, 11.9)
self.hb.reparentTo(self.npc)
#self.hb.reparentTo(self.npc)
def renderBlue(self,AIworld):
if not self._is_dead:
self.AIbehaviors.removeAi("pursue")
self.npc.detachNode()
print "Started delete procedure for npc ",
print self.id
self.npc.delete()
self.npc = Actor("models/priest",
{"walk": "models/priest-walk", "attack":"models/priest-attack", "hurt":"models/priest-hit", "die":"models/priest-die"})
self.npcTex = loader.loadTexture("models/tex/guard_blue.png")
self.npc.setTexture(self.npcTex)
self.npc.setScale(0.5, 0.5, 0.5)
self.npc.clearColor()
self.npc.clearColorScale()
self.npc.setColor(255, 0, 0, 0)
self.npc.setColorScale(255, 0, 0, 0)
self.npc.reparentTo(self.render)
self.npc.setPos(self.anchorx,self.anchory,self.anchorz)
AIworld.removeAiChar("npc"+str(self.id))
self.AIchar = AICharacter("npc"+str(self.id),self.npc, 100, 0.05, 5)
self.AIbehaviors = self.AIchar.getAiBehaviors()
AIworld.addAiChar(self.AIchar)
self.hb = HealthBar(1.5, value=self.health)
self.hb.setPos(0, 0, 18.1)
self.hb.reparentTo(self.npc)
#self.hb.reparentTo(self.npc)
def renderRed(self,AIworld):
if not self._is_dead:
self.AIbehaviors.removeAi("pursue")
self.npc.detachNode()
self.npc.delete()
self.npc = Actor("models/priest",
{"walk": "models/priest-walk", "attack":"models/priest-attack", "hurt":"models/priest-hit", "die":"models/priest-die"})
self.npcTex = loader.loadTexture("models/tex/guard_red.png")
self.npc.setTexture(self.npcTex)
self.npc.setScale(0.5, 0.5, 0.5)
self.npc.clearColor()
self.npc.clearColorScale()
self.npc.setColor(255, 0, 0, 0)
self.npc.setColorScale(255, 0, 0, 0)
self.npc.reparentTo(self.render)
self.npc.setPos(self.anchorx,self.anchory,self.anchorz)
AIworld.removeAiChar("npc"+str(self.id))
self.AIchar = AICharacter("npc"+str(self.id),self.npc, 100, 0.05, 5)
self.AIbehaviors = self.AIchar.getAiBehaviors()
AIworld.addAiChar(self.AIchar)
AIworld.update()
self.hb = HealthBar(1.5, value=self.health)
self.hb.setPos(0, 0, 8.1)
self.hb.reparentTo(self.npc)
def switchTeam(self,AIworld):
print self.id,
print " from team ",
print self._team,
print " getting deleted."
if self._team==0:
self._team=1
self.renderBlue(AIworld)
else:
self._team=0
self.renderRed(AIworld)
if self.isCurrentUser:
main.freeDeadNpc(self.id)
self.target = None
self.isMoving = False
self.health = 200
self.isCurrentUser = False
self.damage = 8
self.attackTimer = 0
self._is_dead = False
def set_health(self, health):
self.health = health
def take_damage(self, health_change):
health = self.health
if health <= health_change and not self._is_dead:
self.killNpc()
else:
health = health-health_change
self.set_health(health)
self.hb.setValue(self.health)
self.npc.play("hurt")
def killNpc(self):
self.set_health(0)
self.hb.setValue(0)
self.AIbehaviors.removeAi("pursue")
hurt_interval = self.npc.actorInterval("hurt")
death_interval = self.npc.actorInterval("die")
seq = Sequence(hurt_interval, death_interval)
seq.start()
self.npc.pose("die",45)
self._is_dead = True
self.npc.detachNode()
if self.isCurrentUser:
main.freeDeadNpc(self.id)
#main.cManager.sendRequest(Constants.CMSG_NPCDEATH, [self.id])
print Constants.CMSG_NPCDEATH,
print " + ",
print self.id
def chaseTarget(self, target, status = False):
if(not self.isMoving):
self.target = target
self.AIbehaviors.pursue(self.target)
self.npc.loop("walk")
self.isMoving = True
self.isCurrentUser = status
def stopChase(self):
#self.AIbehaviors.pauseAi("pursue")
if not self._is_dead:
self.AIbehaviors.removeAi("pursue")
p1 = LerpHprInterval(self.npc, 4, Point3(180,0,0))
p2 = LerpPosInterval(self.npc, 4, Point3(self.anchorx, self.anchory, self.anchorz))
animInterval = self.npc.actorInterval("walk", loop = 1, duration=4)
p2.start()
p1.start()
animInterval.start()
self.isMoving = False
self.target = None
self.isCurrentUser = False
def givNPCDistance(self,charachter):
x = self.npc.getX()
y = self.npc.getY()
z = self.npc.getZ()
minDist = math.sqrt( (charachter.getX()-x)*(charachter.getX()-x) + (charachter.getY()-y)*(charachter.getY()-y) + (charachter.getZ()-z)*(charachter.getZ()-z) )
return minDist
def checkNpcIsAlive(self):
if(self.health>0):
return True
else:
return False
def shouldAttack(self,currentTime,cManager):
if not self._is_dead:
if self.isMoving:
if self.attackTimer>0:
self.attackTimer = self.attackTimer-currentTime
#print self.attackTimer
if self.AIbehaviors.behaviorStatus("pursue")=="done":
#self.npc.stop("walk")
#print self.npc.getAnimControl("walk")
if self.attackTimer<=0:
if self.npc.getAnimControl("walk").isPlaying():
self.npc.stop("walk")
if not self.npc.getAnimControl("attack").isPlaying():
#self.npc.loop("attack")
self.npc.play("attack")
self.attackTimer = 2
#myInterval = self.npc.actorInterval("attack")
#seq = Sequence(myInterval)
#seq.append(Wait(3))
#seq.start()
if self.isCurrentUser:
cManager.sendRequest(Constants.CMSG_NPCATTACK, [self.id, self.damage])
if self.AIbehaviors.behaviorStatus("pursue")=="active":
if self.npc.getAnimControl("attack").isPlaying():
self.npc.stop("attack")
if not self.npc.getAnimControl("walk").isPlaying():
self.npc.loop("walk")
class MyApp(ShowBase):
def center_mouse(self):
self.win.movePointer(0,self.win.getXSize()/2,self.win.getYSize()/2)
def __init__(self):
#Game variables
self.health = 100
self.panda_kill_count = 0
self.level = 0
#Implementation variables
#self.color = [Vec4((204.0/255), (255.0/255), (204/255), 0.1),Vec4((0/255), (255.0/255), (255.0/255), 0.1),Vec4((255.0/255), (51.0/255), (255.0/255), 0.1),Vec4((153.0/255), (255.0/255), (153.0/255), 0.1),Vec4((255.0/255), (178.0/255), (102.0/255), 0.1),Vec4((229.0/255), (204.0/255), (255.0/255), 0.1)]
self.color = [Vec4(0.4,0.4,0.4,0.1)]
self.mirror=False
self.paused=False
self.displayed=False
self.game_started=False
self.randomthings_ = randomthings.RandomThings(self)
self.shifted_cam=False
self.is_firstP=False
self.old_anim2 = None
self.old_anim=None
self.timeout=False
(self.r,self.f,self.b,self.l)=(0,0,0,0)
self.inside_level=False
self.move_anim_queue=[]
self.anim_queue=[]
self.prev_time=0.0
self.bullets = []
self.rightspeed=0
self.forwardspeed=0
ShowBase.__init__(self)
self.makeDefaultPipe()
bb=self.pipe.getDisplayHeight()
aa=self.pipe.getDisplayWidth()
self.openDefaultWindow(size=(aa, bb))
import layer2d
self.layer2d = layer2d
self.layer2d.update_info('Loading...')
self.keyreader= ReadKeys(self,layer2d)
#Sounds
self.gunshot = self.loader.loadSfx("sounds/gunshot_se.ogg")
self.gunshot.setLoop(False)
self.music = self.loader.loadSfx("sounds/music.ogg")
self.music.setLoop(True)
self.zombie_die = self.loader.loadSfx('sounds/zombie_die.ogg')
self.zombie_die.setLoop(False)
self.kicked = self.loader.loadSfx('sounds/kicked.ogg')
self.kicked.setLoop(False)
self.hurt_sound = self.loader.loadSfx('sounds/hurt.ogg')
self.hurt_sound.setLoop(False)
self.dead_sound = self.loader.loadSfx('sounds/dead.ogg')
self.dead_sound.setLoop(False)
self.intro_sound = self.loader.loadSfx('sounds/intro.ogg')
self.intro_sound.setLoop(False)
self.intro_sound.play()
self.enableParticles()
self.center_mouse()
#self.disableMouse()
self.prev_pos = None
if base.mouseWatcherNode.hasMouse():
x=base.mouseWatcherNode.getMouseX()
y=base.mouseWatcherNode.getMouseY()
self.prev_pos = (x,y)
#Hide cursor
props = WindowProperties()
props.setCursorHidden(True)
self.win.requestProperties(props)
self.environ = self.loader.loadModel('models/ourworld')
self.environ.setPos(0,0,0)
self.environ.reparentTo(self.render)
self.pandaActor = Actor("models/hero_anim", {'kick':'models/hero_anim-kick','unready_to_shoot':'models/hero_anim-unready_to_shoot','jump':'models/hero_anim-jump',"shooting":"models/hero_anim-shooting","ready_to_shoot":"models/hero_anim-ready_to_shoot","ready_to_walk":"models/hero_anim-ready_to_run","ready_to_run":"models/hero_anim-ready_to_run","walk4":"models/hero_anim-walk1", "breathe": "models/hero_anim-breathe", "run": "models/hero_anim-walk"})
self.pandaActor.setPlayRate(3,'ready_to_shoot')
self.pandaActor.setPlayRate(-1.0,"ready_to_walk")
self.pandaActor.setPlayRate(1.5,'run')
self.pandaActor.setPlayRate(1.5,'ready_to_run')
self.pandaActor.reparentTo(self.render)
self.pandaActor.setPos(self.environ,0,0,100)
self.pandaActor.loop("breathe")
self.phy = NodePath("PhysicsNode")
self.phy.reparentTo(self.render)
self.pandaAN = ActorNode("PandaActor")
self.pandaActorPhysicsP = self.phy.attachNewNode(self.pandaAN)
self.physicsMgr.attachPhysicalNode(self.pandaAN)
self.pandaActor.reparentTo(self.pandaActorPhysicsP)
#set mass of panda
self.pandaAN.getPhysicsObject().setMass(100)
#apply gravity
self.gravityFN=ForceNode('world-forces')
self.gravityFNP=self.environ.attachNewNode(self.gravityFN)
self.gravityForce=LinearVectorForce(0,0,-30.81) #gravity acceleration
self.gravityFN.addForce(self.gravityForce)
self.physicsMgr.addLinearForce(self.gravityForce)
#camera stuff
self.camera.reparentTo(self.pandaActor)
self.camera.lookAt(self.pandaActor)
self.taskMgr.add(self.spinCameraTask, "zombieTask_SpinCameraTask")
self.taskMgr.doMethodLater(0.01,self.movePandaTask,"zombieTask_movePandaTask")
#Collision Handling
self.cTrav = CollisionTraverser()
self.collisionHandler = CollisionHandlerEvent()
#Add collider for terrain
self.groundCollider = self.environ.find("**/terrain")
#Add walker for panda
self.collision_sphere = CollisionSphere(0,0,1,1)
self.collNode = CollisionNode('pandaWalker')
self.cnodePath = self.pandaActor.attachNewNode(self.collNode)
self.cnodePath.node().addSolid(self.collision_sphere)
#AddZombieDetector for panda
self.zombie_sphere = CollisionSphere(0,0,3,1)
self.zomb_detector_node = CollisionNode('zombieDetector')
self.zomb_detector_NP = self.pandaActor.attachNewNode(self.zomb_detector_node)
self.zomb_detector_NP.node().addSolid(self.zombie_sphere)
#self.zomb_detector_NP.show()
#Add pusher against gravity
self.pusher = PhysicsCollisionHandler()
self.pusher.addCollider(self.cnodePath, self.pandaActorPhysicsP)
self.pusher.addCollider(self.zomb_detector_NP,self.pandaActorPhysicsP)
self.cTrav.addCollider(self.cnodePath,self.pusher)
self.cTrav.addCollider(self.zomb_detector_NP,self.pusher)
self.pusher.addInPattern('%fn-into-%in')
self.pusher.addAgainPattern('%fn-again-%in')
#Add collision handler patterns
self.collisionHandler.addInPattern('%fn-into-%in')
self.collisionHandler.addAgainPattern('%fn-again-%in')
self.abientLight = AmbientLight("ambientLight")
self.abientLight.setColor(Vec4(0.1, 0.1, 0.1, 1))
self.directionalLight = DirectionalLight("directionalLight")
self.directionalLight.setDirection(Vec3(-5, -5, -5))
self.directionalLight.setColor(Vec4((229.0/255), (204.0/255), (255.0/255), 0.7))
self.directionalLight.setSpecularColor(Vec4(0.4, 0.4, 0.4, 0.1))
self.directionalLight.setShadowCaster(True,512,512)
self.render.setLight(self.render.attachNewNode(self.abientLight))
self.render.setLight(self.render.attachNewNode(self.directionalLight))
self.render.setShaderAuto()
#create zombie land
self.zombieland = zombie.Zombies(self)
self.taskMgr.doMethodLater(0.01,self.zombieland.moveZombie, "zombieTask_ZombieMover")
layer2d.incBar(self.health)
self.taskMgr.add(self.game_monitor,"zombieTask_gameMonitor")
self.taskMgr.doMethodLater(2.7,self.music_play, "zombieTask_music")
#Add random useless things:
self.randomthings_.add_random_things()
def music_play(self,task):
self.music.play()
return Task.done
#def get_color(self):
# return self.color[min(len(self.color)-1,self.level)]
#GameMonitor
def game_monitor(self,task):
if self.paused:
return Task.cont
#Update Score
self.layer2d.update_score(self.panda_kill_count)
#Check for health of actor
if self.health <= 0:
self.dead_sound.play()
self.pandaActor.detachNode()
print "LOL u ded"
self.info = """Game Over..
Score: """ + str(self.panda_kill_count) + """
Press alt+f4 to quit the game.
"""
self.layer2d.update_info(self.info)
self.taskMgr.removeTasksMatching('zombieTask_*')
if self.game_started<>True:
if not self.displayed:
self.display_information()
self.pandaActor.setPos(self.pandaActorPhysicsP.getRelativePoint(self.render,Point3(10,10,100)))
return Task.cont
#Check if user is inside some level. if yes, pass.
if self.inside_level or self.timeout:
return Task.cont
self.inside_level = True
#self.health=100
self.timeout=True
print ".."
#The next lines will be executed only when the user is in between two levels (or at the beginning of the game)
#Display information based on game level
self.display_information()
print "HUEHUEHUEHUE"
#Schedule wave of zombies
self.taskMgr.doMethodLater(10,self.addWave, "zombieTask_ZombieAdder")
return Task.cont
def addWave(self,task):
##add a wave of 5 zombies, depending on the level.
##speed of zombie increases with each level
##durability of zombie increases with each level.
##Wave ends when all zombies die.
self.directionalLight.setSpecularColor(Vec4(0.4, 0.4, 0.4, 0.1))
self.layer2d.update_info("level"+str(self.level))
self.timeout=False
self.zombieland.add(5)
return Task.done
#information displayer
def display_information(self):
#display information based on levels.
print self.game_started
self.displayed=True
if self.game_started==False:
info = """
Welcome to PandaLand. Once upon a time, there used to be these cute
little creatures called Pandas. They were lazy, funny, and
adorable. But that is what we humans thought. Pandas are
actually an evil alien race that spread from planet to planet,
spreading destruction and terror everywhere. They ruled earth
several billion years ago. But our super ancestors (Dinosaurs)
fought agaisnt them with great valour and selflessness; and managed
to save planet Earth from doom. But the pandas went into hiding
(and became cute); until few days back! Now they seek to kill all.
You, the Joker, are our only hope,since Batman has retired.
Go Kill Pandas.For Mother Earth!
"""
self.layer2d.information['bg'] = (0,0,0,0.8)
else:
self.layer2d.update_info('')
if self.level==0:
info="""
Your game will start in a few seconds.
This is the first level. Pandas will spawn
and follow you. Shoot to kill.
Test out your controls while
they are still cute and harmless :)
Jump: Space
Shoot: LeftClick
Kick: RightClick
Walk: A/W/S/D
For more information, press P.
"""
self.layer2d.information['bg'] = (0,0,0,0.6)
elif self.level==1:
info="""
Level 0 Completed!
Starting Level 1.
Pandas have turned evil
and stronger. They will try
to eat you up.
To run:
Press Shift + A/S/W/D
"""
elif self.level==2:
info="""
Level 1 Completed!
Starting Level 2.
Pandas are even stronger now.
They will get stronger by
each level.
Your automatic shooting speed has
also improved due to experience
gained.
"""
elif self.level==3:
info="""
Level 2 Completed!
Starting Level 3.
Pandas also move faster
by each level. They really
want to eat you.
But don't worry, you also
run faster as the levels
proceed.
"""
else:
info = """
Level """ + str(self.level-1) + """ Completed!
Starting """ + str(self.level) + """ .
Well done!
Keep fighting, our fate lies
in your hands.
"""
self.layer2d.update_info(info)
#self.create_bullet()
def create_bullet(self):
self.bullet = self.loader.loadModel('models/gun/bullet')
self.gunshot.play()
self.bulletAN = ActorNode("BulletNode")
self.bulletActorPhysicsP = self.phy.attachNewNode(self.bulletAN)
self.physicsMgr.attachPhysicalNode(self.bulletAN)
self.bullet.reparentTo(self.bulletActorPhysicsP)
self.bulletAN.getPhysicsObject().setMass(1)
self.bullet.setPos(self.pandaActor,0,-3,3.5)
self.bullet.setScale(0.1,0.1,0.1)
self.bullet.setHpr(self.pandaActor,0,90,0)
self.bullet.setP(self.camera.getP()+90)
self.bullet_sphere = CollisionSphere(0,0,0,0.2)
self.bullet_collNode = CollisionNode('bullet')
self.bullet_cnodePath = self.bullet.attachNewNode(self.bullet_collNode)
self.bullet_cnodePath.node().addSolid(self.bullet_sphere)
#self.pusher.addCollider(self.bullet_cnodePath,self.bulletActorPhysicsP)
self.cTrav.addCollider(self.bullet_cnodePath,self.collisionHandler)
#self.bullet_cnodePath.show()
self.bullets += [self.bullet]
def bulletKiller(self,task):
if self.paused:
return Task.cont
self.bullets[0].remove_node()
self.bullets = self.bullets[1:]
return Task.done
def bulletThrower(self,task):
if self.paused:
return Task.cont
#make bullet move
if self.pandaActor.getCurrentAnim()<>'shooting' and self.pandaActor.getCurrentAnim()<>'ready_to_shoot':
self.pandaActor.play('shooting')
print "loL"
self.create_bullet()
self.bulletAN.getPhysicsObject().setVelocity(self.render.getRelativeVector(self.camera,Vec3(0,200,0)))
self.taskMgr.doMethodLater(max(0.05,0.1*(5-self.level)),self.bulletThrower, "zombieTask_bulletThrower")
self.taskMgr.doMethodLater(0.5,self.bulletKiller, "zombieTask_bulletKiller")
self.prev=True
if self.old_anim2==None:
self.old_anim2='breathe'
if self.old_anim2 not in ['run','walk4']:
self.old_anim2='breathe'
self.anim_queue = [(self.pandaActor,True,'unready_to_shoot'),(self.pandaActor,False,self.old_anim2)]
return Task.done
def movePandaTask(self,task):
if self.paused:
return Task.cont
tempos = self.pandaActor.getPos()
speed = 0.1
if self.run_:
speed+=0.3*self.level
self.rightspeed = -(self.r-self.l)*speed
self.forwardspeed = -(self.f-self.b)*speed
if (self.r-self.l)<>0 and (self.f-self.b)<>0:
#print self.forwardspeed
#print self.rightspeed
#sys.exit(0)
self.rightspeed *= 0.7
self.forwardspeed *= 0.7
self.pandaActor.setPos(self.pandaActor,self.rightspeed, self.forwardspeed,0)
return Task.again
def spinCameraTask(self, task):
if self.paused:
return Task.cont
if self.render.getRelativePoint(self.pandaActorPhysicsP,self.pandaActor.getPos())[2] < -10:
self.pandaAN.getPhysicsObject().setVelocity(0,0,30)
#self.pandaActor.setPos(self.pandaActorPhysicsP.getRelativePoint(self.render,Point3(10,10,100)))
self.prev_time=task.time
#play queued animations:
for x in self.move_anim_queue+self.anim_queue:
if x[0].getCurrentAnim()==None:
if x[1]:
x[0].play(x[2])
else:
x[0].loop(x[2])
if x in self.move_anim_queue:
self.move_anim_queue.remove(x)
elif x in self.anim_queue:
self.anim_queue.remove(x)
#Do other stuff
if self.mouseWatcherNode.hasMouse():
x=base.mouseWatcherNode.getMouseX()
y=base.mouseWatcherNode.getMouseY()
if self.prev_pos==None:
self.prev_pos = (x,y)
xx = self.prev_pos[0] - x
yy = self.prev_pos[1] + y
self.prev_pos = (xx,yy)
self.pandaActor.setHpr(self.pandaActor,-20*(pi/2.0)*x,0,0)
#self.camera.setHpr(self.pandaActor, 20*(pi/2.0)*x, 20*(pi/2.0)*yy, 0)
if self.is_firstP:
self.camera.lookAt(self.pandaActor)
self.camera.setPos(self.pandaActor,0,0,4)
self.camera.setHpr(self.camera,180,0,0)
else:
self.camera.setPos(self.pandaActor,0,8,5)
self.camera.lookAt(self.pandaActor)
if self.mirror:
self.camera.setY(-self.camera.getY())
self.camera.lookAt(self.pandaActor)
self.camera.setHpr(self.camera,0,20*(pi/2.0)*yy,0)
self.center_mouse()
#zombie collisions
return Task.cont
#User Actions:
def meelee(self):
#Make actor stomp here. or something
#Load animation
self.zombieland.meelee()
self.anim_queue += [(self.pandaActor,True,self.pandaActor.getCurrentAnim())]
self.pandaActor.play('kick')
#pass
def ranged_start(self):
#put animation here
self.old_anim = self.pandaActor.getCurrentAnim()
if self.old_anim not in ['shooting','unready_to_shoot','ready_to_shoot'] :
self.old_anim2 = self.old_anim
if self.old_anim not in ['ready_to_shoot','shooting','unready_to_shoot']:
self.pandaActor.play('ready_to_shoot')
self.taskMgr.add(self.bulletThrower, "zombieTask_bulletThrower")
def ranged_stop(self,task=None):
if self.paused:
return Task.cont
#stop animation here
if self.pandaActor.getCurrentAnim()<>'shooting' and task==None:
self.pandaActor.play('shooting')
self.taskMgr.remove("zombieTask_bulletThrower")
self.taskMgr.doMethodLater(0.5,self.ranged_stop,'zombieTask_rangedStop')
return Task.done
self.taskMgr.remove("zombieTask_bulletThrower")
return Task.done
class Lvl01(DirectObject):
#constructor
def start(self):
base.disableMouse() #turn off mouse camera control
#camera.setPosHpr(Vec3(93,-90,0), Vec3(0,0,0))
# Turn off the default camera and replace it with two new cameras, with
# side-by-side DisplayRegions.
base.camNode.setActive(0)
base.makeCamera(base.win, displayRegion = (0, 0.48, 0, 1))
base.makeCamera(base.win, displayRegion = (0.52, 1, 0, 1))
base.makeCamera(base.win, displayRegion = (0.48,0.52,0,1))
base.camList[3].setPos(Vec3(144,0,-1000))
self.gameLen = 100
self.numActuator = 10
self.music = loader.loadMusic("models/gamedev/AD.mp3")
self.music.play()
globalClock.reset()
self.timer = OnscreenText("%d" % (self.gameLen-globalClock.getRealTime(),), pos = (98,145), scale = 18.0)
self.timer.setColor(1,1,1)
taskMgr.add(self.clockTask,"clockTask")
self.actCount = 0
self.speed1 = 3
self.speed2 = 3
self.climbSpeed1 = 1
self.climbSpeed2 = 1
self.climbing1 = 0
self.climbing2 = 0
self.array = []
self.loadModels()
self.setupLighting()
self.setupStage()
self.setupCollisions()
self.setupIntervals()
self.player1Score = 0
self.player2Score = 0
self.dir1 = 1
self.dir2 = 1
self.nodeCount1 = 0
self.nodeCount2 = 0
taskMgr.add(self.cameraFollowTask,"cameraFollowTask")
taskMgr.add(self.boulderTask,"boulderTask")
taskMgr.doMethodLater(self.gameLen,self.endGame,'endGame')
#setup key controls
self.accept("escape",sys.exit)
#self.accept("w",self.rise)
#self.accept("o",self.rise2)
#Player 1 movement keys
#self.accept("s",self.fall)
self.acceptOnce("a",self.left)
self.acceptOnce("d",self.right)
self.accept("a-up",self.stopLeft)
self.accept("d-up",self.stopRight)
self.acceptOnce("w", self.jump)
self.acceptOnce("o", self.jumpT2)
#Player 2 movement keys
#self.accept("l",self.fall2)
self.acceptOnce("k",self.left2)
self.acceptOnce(";",self.right2)
self.accept("k-up",self.stopLeft2)
self.accept(";-up",self.stopRight2)
self.jumpOK = 1
def loadModels(self):
print "start loadModels"
self.playerModel = Actor("models/gamedev/redguy-model",{"walk":"models/gamedev/redguyrun",
"jump":"models/gamedev/redguy-jump","climb":"models/gamedev/redguy-climb"})
self.playerModel.reparentTo(render)
self.playerModel.setScale(.7)
self.playerModel.setPosHpr(Vec3(46,0,0),Vec3(0,0,0))
self.playerModel.setH(90)
self.playerModel2 = Actor("models/gamedev/bluegirl-model",{"walk2":"models/gamedev/bluegirlrun",
"jump2":"models/gamedev/bluegirl-jump","climb2":"models/gamedev/bluegirl-climb"})
self.playerModel2.reparentTo(render)
self.playerModel2.setScale(.7)
self.playerModel2.setPosHpr(Vec3(333,0,0),Vec3(0,0,0))
self.playerModel2.setH(270)
self.divider = loader.loadModel("models/gamedev/divider")
self.divider.setPos(144,0,-1000)
self.divider.setScale(5.0)
self.divider.reparentTo(render)
self.boulder1 = loader.loadModel("models/gamedev/boulder")
self.boulder1.reparentTo(render)
self.boulder1.setScale(7)
self.boulder1.setPos(46,0,-50)
self.boulder2 = loader.loadModel("models/gamedev/boulder")
self.boulder2.reparentTo(render)
self.boulder2.setScale(7)
self.boulder2.setPos(333,0,-50)
#loader.loadModel("models/gamedev/actuatorOn")
bounds = self.boulder1.getChild(0).getBounds()
center = bounds.getCenter()
radius = bounds.getRadius()*.7
cSphere = CollisionSphere(center,radius)
cNode = CollisionNode("boulder")
cNode.addSolid(cSphere)
cNodePath = self.boulder1.attachNewNode(cNode)
#cNodePath.show()
cNodePath = self.boulder2.attachNewNode(cNode)
#cNodePath.show()
print "end loadModels"
def setupStage(self):
print "start setupStage"
self.background = OnscreenImage(image = 'models/gamedev/lvl1background.jpg', pos = (175,5,0),scale=500)
self.background.reparentTo(render)
x1= 4.9
x2 = -4.9
len = 9.8
h = 0
a = 0
p = 0
j=0
m=0
x1b=0
x2b=0
while self.actCount < self.numActuator:
if j > 0:
lOld = l
rOld = r
x1Old = x1
x2Old = x2
x1 = (x1Old+x2Old)/2 + 4.9
x2 = (x1Old+x2Old)/2 - 4.9
x1o=x1
x2o=x2
for count in range(1):
l = random.randint(0,(10-lOld)+((10+rOld)-(10-lOld))/2)
r = random.randint(0,20-((10-lOld)+((10+rOld)-(10-lOld))/2))
if r+2 <= 20-((10-lOld)+((10+rOld)-(10-lOld))/2):
r += 2
if l+2 < (10-lOld)+((10+rOld)-(10-lOld))/2:
l += 2
if l+r < 4:
count = 0
p = random.randint(0,1)
else:
l = 10
r = 10
c = 10
#while a == 0:
a = random.randint(-l,r)
if j > 0:
if j % 2 == 0:
self.ladder = loader.loadModel("models/gamedev/ladder")
self.ladder.reparentTo(render)
self.ladder.setScale(1.5)
self.ladder.setPos(x1+m,0,h-20)
self.ladder2 = loader.loadModel("models/gamedev/ladder")
self.ladder2.reparentTo(render)
self.ladder2.setScale(1.5)
self.ladder2.setPos(x1+286+m,0,h-20)
self.array.append(self.ladder)
self.array.append(self.ladder2)
else:
self.ladder = loader.loadModel("models/gamedev/ladder")
self.ladder.reparentTo(render)
self.ladder.setScale(1.5)
self.ladder.setPos(x2,0,h-20)
self.ladder2 = loader.loadModel("models/gamedev/ladder")
self.ladder2.reparentTo(render)
self.ladder2.setScale(1.5)
self.ladder2.setPos(x2+286,0,h-20)
self.array.append(self.ladder)
self.array.append(self.ladder2)
k=-10
while k <= 13:
cSphere = CollisionSphere(Point3(1.5,0,k),.5)
cNode = CollisionNode("ladder")
cNode.addSolid(cSphere)
cNodePath = self.ladder.attachNewNode(cNode)
cNodePath = self.ladder2.attachNewNode(cNode)
#cNodePath.show()
k+=1
self.array.append(self.ladder)
#cSphere = CollisionSphere(Point3(1.5,0,h-40),.5)
#cNodeB = CollisionNode("canWalk")
#cNodeB.addSolid(cSphere)
#cNodePath = self.ladder.attachNewNode(cNodeB)
#cNodePath = self.ladder2.attachNewNode(cNodeB)
for i in range(r):
'''Right half of stage'''
self.environment = loader.loadModel("models/gamedev/platform")
self.environment.reparentTo(render)
self.environment.setScale(5)
self.environment.setPos(x1,0,h)
self.environment2 = loader.loadModel("models/gamedev/platform")
self.environment2.reparentTo(render)
self.environment2.setScale(5)
self.environment2.setPos(x1+286,0,h)
self.array.append(self.environment)
self.array.append(self.environment2)
#if i == 0 and j > 0:
# cSphere = CollisionSphere(Point3((m/9.8)*1.9,0,0),.5)
# cNode = CollisionNode("platform")
# cNode.addSolid(cSphere)
# cNodePath = self.environment.attachNewNode(cNode)
# cNodePath = self.environment2.attachNewNode(cNode)
# cNodePath.show()
if r == i+1:
cSphere = CollisionSphere(Point3(2,0,0),2)
if i == 9:
cNode = CollisionNode("rwall")
else:
cNode = CollisionNode("redge")
cNode.addSolid(cSphere)
cNodePath = self.environment.attachNewNode(cNode)
cNodePath = self.environment2.attachNewNode(cNode)
#cNodePath.show()
if a == i:
self.actCount+=1
self.actuator = Actor("models/gamedev/actuator")
self.actuator.reparentTo(render)
self.actuator.setPos(self.environment.getPos())
if p == 1:
self.actuator.setZ(self.actuator.getZ())
self.actuator.setP(self.actuator.getP()+180)
self.actuator.setScale(2)
self.actuator.setH(self.actuator.getH()+180)
self.array.append(self.actuator)
bounds = self.actuator.getChild(0).getBounds()
center = bounds.getCenter()
radius = bounds.getRadius()-.5
cSphere = CollisionSphere(center,radius)
cNode = CollisionNode("actuator")
cNode.addSolid(cSphere)
cNodePath = self.actuator.attachNewNode(cNode)
#cNodePath.show()
self.actuator2 = Actor("models/gamedev/actuator")
self.actuator2.reparentTo(render)
self.actuator2.setPos(self.environment2.getPos())
if p == 1:
self.actuator2.setZ(self.actuator2.getZ())
self.actuator2.setP(self.actuator2.getP()+180)
self.actuator2.setScale(2)
self.actuator2.setH(self.actuator2.getH()+180)
self.array.append(self.actuator2)
bounds = self.actuator2.getChild(0).getBounds()
center = bounds.getCenter()
radius = bounds.getRadius()-.5
cSphere = CollisionSphere(center,radius)
cNode = CollisionNode("actuator")
cNode.addSolid(cSphere)
cNodePath = self.actuator2.attachNewNode(cNode)
#cNodePath.show()
x1 = x1 + len
for i in range(l):
'''Left Half of stage'''
self.environment = loader.loadModel("models/gamedev/platform")
self.environment.reparentTo(render)
self.environment.setScale(5)
self.environment.setPos(x2,0,h)
self.array.append(self.environment)
self.environment2 = loader.loadModel("models/gamedev/platform")
self.environment2.reparentTo(render)
self.environment2.setScale(5)
self.environment2.setPos(x2+286,0,h)
self.array.append(self.environment2)
if l == i+1:
cSphere = CollisionSphere(Point3(-2,0,0),2)
if i == 9:
cNode = CollisionNode("lwall")
else:
cNode = CollisionNode("ledge")
cNode.addSolid(cSphere)
cNodePath = self.environment.attachNewNode(cNode)
cNodePath = self.environment2.attachNewNode(cNode)
#cNodePath.show()
if a == -i:
self.actCount+=1
self.actuator = Actor("models/gamedev/actuator")
self.actuator.reparentTo(render)
self.actuator.setPos(self.environment.getPos())
self.actuator.setScale(2)
self.array.append(self.actuator)
bounds = self.actuator.getChild(0).getBounds()
center = bounds.getCenter()
radius = bounds.getRadius()-.5
cSphere = CollisionSphere(center,radius)
cNode = CollisionNode("actuator")
cNode.addSolid(cSphere)
cNodePath = self.actuator.attachNewNode(cNode)
#cNodePath.show()
self.actuator = Actor("models/gamedev/actuator")
self.actuator.reparentTo(render)
self.actuator.setPos(self.environment2.getPos())
self.actuator.setScale(2)
self.array.append(self.actuator)
bounds = self.actuator.getChild(0).getBounds()
center = bounds.getCenter()
radius = bounds.getRadius()-.5
cSphere = CollisionSphere(center,radius)
cNode = CollisionNode("actuator")
cNode.addSolid(cSphere)
cNodePath = self.actuator.attachNewNode(cNode)
#cNodePath.show()
x2 = x2 - len
j+=1
h = h+40
#x1 = 4.9
#x2 = -4.9
a = 0
self.h = h+50
x2b=x2o
x1b=x1o
print "end setupStage"
def setupLighting(self):
print "start setupLighting"
ambientLight = AmbientLight('ambientLight')
ambientLight.setColor(Vec4(0.55,0.55,0.55,1.0))
ambientLightNP = render.attachNewNode(ambientLight)
render.setLight(ambientLightNP)
dirLight = DirectionalLight('dirLight')
dirLight.setColor(Vec4(0.6,0.6,0.6,1))
dirLightNP = render.attachNewNode(dirLight)
dirLightNP.setHpr(Vec3(0.0,-26.0,0.0))
render.setLight(dirLightNP)
print "end setupLighting"
def setupIntervals(self):
print "start setupIntervals"
self.charWalk1 = self.playerModel.actorInterval("walk")
self.charWalk1.loop( )
self.charWalk1.pause( )
self.charWalk2 = self.playerModel2.actorInterval("walk2")
self.charWalk2.loop( )
self.charWalk2.pause( )
self.jump1 = self.playerModel.actorInterval("jump")
self.jump1.loop()
self.jump1.pause()
self.jump2 = self.playerModel2.actorInterval("jump2")
self.jump2.loop()
self.jump2.pause()
self.climb1 = self.playerModel.actorInterval("climb")
self.climb1.loop()
self.climb1.pause()
self.climb2 = self.playerModel2.actorInterval("climb2")
self.climb2.loop()
self.climb2.pause()
print "end setupIntervals"
# PLAYER ONE #
def left(self):
taskMgr.add(self.leftTask,'leftTask')
self.charWalk1.loop()
#end left
def leftTask(self,task):
if self.climbing1 == 0:
self.playerModel.setH(270)
self.playerModel.setPos(Vec3(self.playerModel.getX()-self.speed1, self.playerModel.getY(), self.playerModel.getZ()))
return Task.cont
def right(self):
taskMgr.add(self.rightTask,'rightTask')
self.charWalk1.loop()
#end right
def rightTask(self,task):
if self.climbing1 == 0:
self.playerModel.setH(90)
self.playerModel.setPos(Vec3(self.playerModel.getX()+self.speed1, self.playerModel.getY(), self.playerModel.getZ()))
return Task.cont
def climbable(self,cEntry):
self.nodeCount1+=1
print self.nodeCount1
self.ignore("w")
self.ignore("w-up")
self.ignore("s")
self.ignore("s-up")
self.acceptOnce("w",self.climb,[1])
self.accept("w-up",self.noClimb)
self.acceptOnce("s",self.climb,[-1])
self.accept("s-up",self.noClimb)
def climb(self,dir):
self.dir1 = dir
self.climbing1 = 1
self.climbSpeed1 = 1
self.ignore("a")
self.ignore("a-up")
self.ignore("d")
self.ignore("d-up")
taskMgr.add(self.climbTask,'climbTask')
self.climb1.loop()
def noClimb(self):
taskMgr.remove('climbTask')
self.climb1.pause()
if self.nodeCount1 == 0:
self.climbing = 0
self.climbSpeed1 = 0
self.acceptOnce("w",self.climb,[1])
self.acceptOnce("s",self.climb,[-1])
def jumpable(self,cEntry):
self.nodeCount1+=-1
print self.nodeCount1
if self.nodeCount1 == 0:
taskMgr.remove('climbTask')
self.ignore("w")
self.ignore("w-up")
self.ignore("s")
self.ignore("s-up")
self.acceptOnce("w",self.jump)
self.acceptOnce("a",self.left)
self.acceptOnce("d",self.right)
self.accept("a-up",self.stopLeft)
self.accept("d-up",self.stopRight)
self.climbing1 = 0
self.climbSpeed1 = 0
self.climb1.pause()
def walkable(self,cEntry):
self.ignore("w")
self.ignore("w-up")
self.ignore("s")
self.ignore("s-up")
self.acceptOnce("w",self.climb,[1])
self.accept("w-up",self.noClimb)
self.acceptOnce("s",self.climb,[-1])
self.accept("s-up",self.noClimb)
self.acceptOnce("a",self.left)
self.acceptOnce("d",self.right)
self.accept("a-up",self.stopLeft)
self.accept("d-up",self.stopRight)
self.climbing1 = 0
self.climbSpeed1 = 0
self.climb1.pause()
def climbTask(self,task):
if self.playerModel.getZ() >=0:
self.playerModel.setH(0)
self.playerModel.setPos(Vec3(self.playerModel.getX(), self.playerModel.getY(), self.playerModel.getZ()+self.climbSpeed1*self.dir1))
return Task.cont
def jump(self):
if self.nodeCount1 == 0:
self.ignore("w")
self.ignore("w-up")
z = self.playerModel.getZ()
j = ProjectileInterval(self.playerModel, startPos = self.playerModel.getPos(), startVel = Point3(0,0,27), endZ = z)
j.start()
taskMgr.doMethodLater(3,self.jumpTask,"jumpTask")
else:
self.acceptOnce("w",self.climb,[1])
def jumpTask(self, task):
if self.climbing1 == 0:
self.jump1.pause()
self.acceptOnce("w",self.jump)
#return task.cont
def allowRight(self):
self.acceptOnce("d",self.right)
def noRight(self):
taskMgr.remove('rightTask')
self.charWalk1.pause()
self.acceptOnce("d",self.right)
def stopRight(self):
self.noRight()
#self.allowRight()
def rightWall(self,cEntry):
self.ignore("d")
self.noRight()
def rightEdge(self,cEntry):
self.ignore("d")
self.noRight()
def rightOK(self,cEntry):
self.allowRight()
def allowLeft(self):
self.acceptOnce("a",self.left)
def noLeft(self):
taskMgr.remove('leftTask')
self.charWalk1.pause()
self.acceptOnce("a",self.left)
def stopLeft(self):
self.noLeft()
#self.allowLeft()
def leftWall(self,cEntry):
self.ignore("a")
self.noLeft()
def leftEdge(self,cEntry):
self.ignore("a")
self.noLeft()
def leftOK(self,cEntry):
self.allowLeft()
# PLAYERTWO #
def left2(self):
taskMgr.add(self.leftTask2,'leftTask2')
self.charWalk2.loop()
#end left
def leftTask2(self,task):
if self.climbing2 == 0:
self.playerModel2.setH(0)
self.playerModel2.setPos(Vec3(self.playerModel2.getX()-self.speed2, self.playerModel2.getY(), self.playerModel2.getZ()))
return Task.cont
def right2(self):
taskMgr.add(self.rightTask2,'rightTask2')
self.charWalk2.loop()
#end right
def rightTask2(self,task):
if self.climbing2 == 0:
self.playerModel2.setH(180)
self.playerModel2.setPos(Vec3(self.playerModel2.getX()+self.speed2, self.playerModel2.getY(), self.playerModel2.getZ()))
return Task.cont
def climbable2(self,cEntry):
self.nodeCount2+=1
#print self.nodeCount1
self.ignore("o")
self.ignore("o-up")
self.ignore("l")
self.ignore("l-up")
self.acceptOnce("o",self.climbT2,[1])
self.accept("o-up",self.noClimb2)
self.acceptOnce("l",self.climbT2,[-1])
self.accept("l-up",self.noClimb2)
def climbT2(self,dir):
self.dir2 = dir
self.climbing2 = 1
self.climbSpeed2 = 1
self.ignore("k")
self.ignore("k-up")
self.ignore(";")
self.ignore(";-up")
taskMgr.add(self.climbTask2,'climbTask2')
self.climb2.loop()
def noClimb2(self):
taskMgr.remove('climbTask2')
self.climb2.pause()
if self.nodeCount2 == 0:
self.climbing2 = 0
self.climbSpeed2 = 0
self.acceptOnce("o",self.climbT2,[1])
self.acceptOnce("l",self.climbT2,[-1])
def jumpable2(self,cEntry):
self.nodeCount2+=-1
#print self.nodeCount2
if self.nodeCount2 == 0:
taskMgr.remove('climbTask2')
self.ignore("o")
self.ignore("o-up")
self.ignore("l")
self.ignore("l-up")
self.acceptOnce("o",self.jumpT2)
self.acceptOnce("k",self.left2)
self.acceptOnce(";",self.right2)
self.accept("k-up",self.stopLeft2)
self.accept(";-up",self.stopRight2)
self.climbing2 = 0
self.climbSpeed2 = 0
self.climb2.pause()
def walkable2(self,cEntry):
self.ignore("o")
self.ignore("o-up")
self.ignore("l")
self.ignore("l-up")
self.acceptOnce("o",self.climbT2,[1])
self.accept("o-up",self.noClimb2)
self.acceptOnce("l",self.climbT2,[-1])
self.accept("l-up",self.noClimb2)
self.acceptOnce("k",self.left2)
self.acceptOnce(";",self.right2)
self.accept("k-up",self.stopLeft)
self.accept(";-up",self.stopRight)
self.climbing2 = 0
self.climbSpeed2 = 0
self.climb2.pause()
def climbTask2(self,task):
if self.playerModel2.getZ() >=0:
self.playerModel2.setH(90)
self.playerModel2.setPos(Vec3(self.playerModel2.getX(), self.playerModel2.getY(), self.playerModel2.getZ()+self.climbSpeed2*self.dir2))
return Task.cont
def jumpT2(self):
if self.nodeCount2 == 0:
self.ignore("o")
self.ignore("o-up")
z = self.playerModel2.getZ()
j = ProjectileInterval(self.playerModel2, startPos = self.playerModel2.getPos(), startVel = Point3(0,0,27), endZ = z)
j.start()
taskMgr.doMethodLater(3,self.jumpTask2,"jumpTask2")
else:
self.acceptOnce("w",self.climb,[1])
def jumpTask2(self, task):
if self.climbing2 == 0:
self.jump2.pause()
self.acceptOnce("o",self.jumpT2)
#return task.cont
def allowRight2(self):
self.acceptOnce(";",self.right2)
def noRight2(self):
taskMgr.remove('rightTask2')
self.charWalk2.pause()
self.acceptOnce(";",self.right2)
def stopRight2(self):
self.noRight2()
#self.allowRight()
def rightWall2(self,cEntry):
self.ignore(";")
self.noRight2()
def rightEdge2(self,cEntry):
self.ignore(";")
self.noRight2()
def rightOK2(self,cEntry):
self.allowRight2()
def allowLeft2(self):
self.acceptOnce("k",self.left2)
def noLeft2(self):
taskMgr.remove('leftTask2')
self.charWalk2.pause()
self.acceptOnce("k",self.left2)
def stopLeft2(self):
self.noLeft2()
#self.allowLeft()
def leftWall2(self,cEntry):
self.ignore("k")
self.noLeft2()
def leftEdge2(self,cEntry):
self.ignore("k")
self.noLeft2()
def leftOK2(self,cEntry):
self.allowLeft2()
def cameraFollowTask(self,task):
base.camList[1].setPos(Vec3(self.playerModel.getX(),-200,self.playerModel.getZ()+30))
base.camList[2].setPos(Vec3(self.playerModel2.getX(),-200,self.playerModel2.getZ()+30))
return task.cont
def activate(self,cEntry):
i = cEntry.getIntoNodePath().getParent()
where = i.getPos()
which = i.getHpr()
i.detachNode()
i = Actor("models/gamedev/actuatorOn")
i.setName("actuatorOn")
i.setPosHpr(where,which)
i.setScale(2)
i.reparentTo(render)
self.array.append(i)
if i.getX() < 144:
self.player1Score += 3
else:
self.player2Score += 3
def stun(self,cEntry):
ow = Sequence(Func(self.startStun), Wait(3), Func(self.stopStun))
ow.start()
def startStun(self):
self.speed1 = 0
self.climbspeed1 = 0
self.ignore("w")
self.ignore("w-up")
self.ignore("a")
self.ignore("d")
self.ignore("a-up")
self.ignore("d-up")
taskMgr.remove('leftTask')
taskMgr.remove('rightTask')
taskMgr.remove('climbTask')
taskMgr.remove('jumpTask')
self.playerModel.stop()
#self.ignore("player1-ladder")
def stopStun(self):
self.speed1 = 3
self.climbspeed1 = 1
self.acceptOnce("a",self.left)
self.acceptOnce("d",self.right)
self.accept("a-up",self.stopLeft)
self.accept("d-up",self.stopRight)
self.acceptOnce("w",self.jump)
#self.accept("player1-ladder", self.climbable)
def stun2(self,cEntry):
ow = Sequence(Func(self.startStun2), Wait(3), Func(self.stopStun2))
ow.start()
def startStun2(self):
self.speed2 = 0
self.climbspeed2 = 0
self.ignore("k")
self.ignore(";")
self.ignore("k-up")
self.ignore(";-up")
self.ignore("o")
self.ignore("o-up")
taskMgr.remove('leftTask2')
taskMgr.remove('rightTask2')
taskMgr.remove('climbTask2')
taskMgr.remove('jumpTask2')
self.playerModel2.stop()
#self.ignore("player2-ladder")
def stopStun2(self):
self.speed2 = 3
self.climbspeed2 = 1
self.acceptOnce("k",self.left2)
self.acceptOnce(";",self.right2)
self.accept("k-up",self.stopLeft2)
self.accept(";-up",self.stopRight2)
self.acceptOnce("o",self.jumpT2)
#self.accept("player2-ladder", self.climbable2)
def setupCollisions(self):
print "start setupCollisions"
self.cHandler = CollisionHandlerEvent()
self.cHandler = CollisionHandlerEvent()
self.cHandler.setInPattern("%fn-%in")
self.cHandler.setAgainPattern("%fn-is-on-%in")
self.cHandler.setOutPattern("%fn-left-%in")
self.cTrav = CollisionTraverser()
base.cTrav = self.cTrav
#Player 1 collision solid
bounds = self.playerModel.getChild(0).getBounds()
center = bounds.getCenter()-Vec3(0,0,12.5)
radius = bounds.getRadius()-21
cSphere = CollisionSphere(center,radius)
cNode = CollisionNode("player1")
cNode.addSolid(cSphere)
centerB = bounds.getCenter()-Vec3(0,0,-11)
radiusB = bounds.getRadius()-21
cSphereB = CollisionSphere(centerB,radiusB)
cNode.addSolid(cSphereB)
cNodePath = self.playerModel.attachNewNode(cNode)
#cNodePath.show()
#centerBB = bounds.getCenter()-Vec3(0,0,25)
#radiusBB = bounds.getRadius()-28
#cSphereBB = CollisionSphere(centerB,radiusB)
#cNodeT = CollisionNode("player1B")
#cNodeT.addSolid(cSphereBB)
#cNodePath = self.playerModel.attachNewNode(cNodeT)
#cNodePath.show()
#Player 2 collision solid
bounds2 = self.playerModel2.getChild(0).getBounds()
center2 = bounds2.getCenter()-Vec3(0,0,12.5)
radius2 = bounds2.getRadius()-21
cSphere2 = CollisionSphere(center2,radius2)
cNode2 = CollisionNode("player2")
cNode2.addSolid(cSphere2)
bounds2B = self.playerModel2.getChild(0).getBounds()
center2B = bounds2B.getCenter()-Vec3(0,0,-11)
radius2B = bounds2B.getRadius()-21
cSphere2B = CollisionSphere(center2B,radius2B)
cNode2.addSolid(cSphere2B)
cNodePath2 = self.playerModel2.attachNewNode(cNode2)
#cNodePath2.show()
self.cTrav.addCollider(cNodePath,self.cHandler)
self.cTrav.addCollider(cNodePath2,self.cHandler)
self.cTrav.addCollider(cNodePath,self.cHandler)
self.cTrav.addCollider(cNodePath2,self.cHandler)
self.accept("player1-ladder", self.climbable)
self.accept("player1-left-ladder", self.jumpable)
#self.accept("player1b-canWalk", self.walkable)
self.accept("player2-ladder", self.climbable2)
self.accept("player2-left-ladder", self.jumpable2)
#self.accept("player1-platform", self.climbable)
#self.accept("player1-left-platform",self.
#self.accept("player1-left-ladder-down", self.noDrop)
#self.accept("player2-ladder-down", self.drop2)
#self.accept("player2-left-ladder-down", self.noDrop2)
self.accept("player1-actuator", self.activate)
self.accept("player2-actuator", self.activate)
self.accept("player1-boulder", self.stun)
self.accept("player2-boulder", self.stun2)
self.accept("boulder-player1", self.stun)
self.accept("boulder-player2", self.stun2)
self.accept("player1-is-on-ledge", self.leftEdge)
self.accept("player2-is-on-ledge", self.leftEdge2)
self.accept("player1-is-on-redge", self.rightEdge)
self.accept("player2-is-on-redge", self.rightEdge2)
self.accept("player1-is-on-lwall", self.leftWall)
self.accept("player2-is-on-lwall", self.leftWall2)
self.accept("player1-is-on-rwall", self.rightWall)
self.accept("player2-is-on-rwall", self.rightWall2)
self.accept("player1-left-ledge", self.leftOK)
self.accept("player2-left-ledge", self.leftOK2)
self.accept("player1-left-redge", self.rightOK)
self.accept("player2-left-redge", self.rightOK2)
self.accept("player1-left-lwall", self.leftOK)
self.accept("player2-left-lwall", self.leftOK2)
self.accept("player1-left-rwall", self.rightOK)
self.accept("player2-left-rwall", self.rightOK2)
print "end setupCollisions"
def boulderTask(self,task):
drop1 = ProjectileInterval(self.boulder1, startPos = Point3(46+random.randint(-9,9)*9.8,0,self.h), startVel = Point3(0,0,0), endZ = -50)
drop2 = ProjectileInterval(self.boulder2, startPos = Point3(253+random.randint(-9,9)*9.8,0,self.h),startVel = Point3(0,0,0), endZ = -50)
dropBoth = Parallel(drop1,drop2)
if self.boulder1.getZ() <= -50.0:
drop1.start()
if self.boulder2.getZ() <= -50.0:
drop2.start()
return task.cont
def clockTask(self,task):
self.timer.detachNode()
self.timer = OnscreenText("%d" % (self.gameLen-globalClock.getRealTime(),), pos = (98,145), scale = 18.0)
self.timer.setColor(1,1,1)
self.timer.reparentTo(render)
return Task.cont
def endGame(self,task):
taskMgr.removeTasksMatching('cameraFollowTask')
taskMgr.removeTasksMatching('boulderTask')
taskMgr.removeTasksMatching('clockTask')
#base.camList[3].removeNode()
#base.camList[2].removeNode()
#base.camList[1].removeNode()
base.makeCamera(base.win, displayRegion = (0, 1, 0, 1))
self.music.stop()
#self.destroy()
self.music3 = loader.loadMusic("models/gamedev/CSTAR.mp3")
self.music3.play()
def getScores(self):
return (self.player1Score, self.player2Score)
def getGameLen(self):
return self.gameLen
def stopMusic(self):
self.music3.stop()
def destroy(self):
self.playerModel.detachNode()
self.playerModel2.detachNode()
self.divider.detachNode()
self.background.destroy()
self.timer.destroy()
while len(self.array) > 0:
print len(self.array)
self.array[0].remove()
del self.array[0]
#world = World()
#run()
class Agent:
def __init__( self, _name ):
print "Creating agent " + _name
self.name = _name
def setDataPath( self, _dataPath ):
self.dataPath = _dataPath;
def setActor( self, _modelFileName, _animationFileNames, _morphTargetsFileName ):
self.modelFileName = _modelFileName;
self.animationFileNames = _animationFileNames;
self.morphTargetsFileName = _morphTargetsFileName;
def setRealizer( self, _realizer ):
self.realizer = _realizer;
def setTransform( self, x, y, z, rx, ry, rz, scale ):
self.agent.setPos( x, y, z )
self.agent.setScale( scale )
self.agent.setHpr( rx, ry, rz )
self.positionX = x
self.positionY = y
self.positionZ = z
def getPosition( self ):
return self.agent.getPos()
def init( self ):
#load the agent and parent it to the world
#The joints of this agent will reference Panda NodePaths, it will be possible to play animations on it
self.animationAgent = Actor( self.modelFileName, self.animationFileNames )
self.agent = Actor( self.modelFileName, self.morphTargetsFileName )
maxMorphTargets={'MT_Jaw_Open':self.agent.controlJoint(None, 'modelRoot', 'MT_Jaw_Open'),
'MT_Jaw_L':self.agent.controlJoint(None, 'modelRoot', 'MT_Jaw_L'),
'MT_Jaw_R':self.agent.controlJoint(None, 'modelRoot', 'MT_Jaw_R'),
'MT_Jaw_Fwd':self.agent.controlJoint(None, 'modelRoot', 'MT_Jaw_Fwd'),
'MT_WideL':self.agent.controlJoint(None, 'modelRoot', 'MT_WideL'),
'MT_WideR':self.agent.controlJoint(None, 'modelRoot', 'MT_WideR'),
'MT_NarrowL':self.agent.controlJoint(None, 'modelRoot', 'MT_NarrowL'),
'MT_NarrowR':self.agent.controlJoint(None, 'modelRoot', 'MT_NarrowR'),
'MT_FrownL':self.agent.controlJoint(None, 'modelRoot', 'MT_FrownL'),
'MT_FrownR':self.agent.controlJoint(None, 'modelRoot', 'MT_FrownR'),
'MT_SneerL':self.agent.controlJoint(None, 'modelRoot', 'MT_SneerL'),
'MT_SneerR':self.agent.controlJoint(None, 'modelRoot', 'MT_SneerR'),
'MT_SquintL':self.agent.controlJoint(None, 'modelRoot', 'MT_SquintL'),
'MT_SquintR':self.agent.controlJoint(None, 'modelRoot', 'MT_SquintR'),
'MT_BrowUpL':self.agent.controlJoint(None, 'modelRoot', 'MT_BrowUpL'),
'MT_BrowUpR':self.agent.controlJoint(None, 'modelRoot', 'MT_BrowUpR'),
'MT_BrowDnL':self.agent.controlJoint(None, 'modelRoot', 'MT_BrowDnL'),
'MT_BrowDnR':self.agent.controlJoint(None, 'modelRoot', 'MT_BrowDnR'),
'MT_MBrowUp':self.agent.controlJoint(None, 'modelRoot', 'MT_MBrowUp'),
'MT_BrowDnR':self.agent.controlJoint(None, 'modelRoot', 'MT_BrowDnR'),
'MT_BrowDnL':self.agent.controlJoint(None, 'modelRoot', 'MT_BrowDnL'),
'MT_MBrowDn':self.agent.controlJoint(None, 'modelRoot', 'MT_MBrowDn'),
'MT_BrowSqueeze':self.agent.controlJoint(None, 'modelRoot', 'MT_BrowSqueeze'),
'MT_MouthL':self.agent.controlJoint(None, 'modelRoot', 'MT_MouthL'),
'MT_MouthR':self.agent.controlJoint(None, 'modelRoot', 'MT_MouthR'),
'MT_UprLipUpL':self.agent.controlJoint(None, 'modelRoot', 'MT_UprLipUpL'),
'MT_UprLipUpR':self.agent.controlJoint(None, 'modelRoot', 'MT_UprLipUpR'),
'MT_UprLipDnL':self.agent.controlJoint(None, 'modelRoot', 'MT_UprLipDnL'),
'MT_UprLipDnR':self.agent.controlJoint(None, 'modelRoot', 'MT_UprLipDnR'),
'MT_LwrLipUpL':self.agent.controlJoint(None, 'modelRoot', 'MT_LwrLipUpL'),
'MT_LwrLipUpR':self.agent.controlJoint(None, 'modelRoot', 'MT_LwrLipUpR'),
'MT_LwrLipDnL':self.agent.controlJoint(None, 'modelRoot', 'MT_LwrLipDnL'),
'MT_LwrLipDnR':self.agent.controlJoint(None, 'modelRoot', 'MT_LwrLipDnR'),
'MT_BlowCheeksL':self.agent.controlJoint(None, 'modelRoot', 'MT_BlowCheeksL'),
'MT_BlowCheeksR':self.agent.controlJoint(None, 'modelRoot', 'MT_BlowCheeksR'),
'MT_TongueOut':self.agent.controlJoint(None, 'modelRoot', 'MT_TongueOut'),
'MT_TongueUp':self.agent.controlJoint(None, 'modelRoot', 'MT_TongueUp'),
'MT_TongueTipUp':self.agent.controlJoint(None, 'modelRoot', 'MT_TongueTipUp'),
'MT_TongueL':self.agent.controlJoint(None, 'modelRoot', 'MT_TongueL'),
'MT_TongueR':self.agent.controlJoint(None, 'modelRoot', 'MT_TongueR'),
'MT_Blink_L':self.agent.controlJoint(None, 'modelRoot', 'MT_Blink_L'),
'MT_Blink_R':self.agent.controlJoint(None, 'modelRoot', 'MT_Blink_R')}
self.targets = {#'Basis':[],
'ExpSmileClosed':{maxMorphTargets['MT_WideR']:1.0,maxMorphTargets['MT_WideL']:1.0},
'ExpAnger':{maxMorphTargets['MT_Jaw_Open']:-0.07,maxMorphTargets['MT_Jaw_Fwd']:0.25,maxMorphTargets['MT_NarrowL']:0.30,maxMorphTargets['MT_NarrowR']:0.30,maxMorphTargets['MT_SquintL']:0.60,maxMorphTargets['MT_SquintR']:0.60,maxMorphTargets['MT_MBrowDn']:1.0,maxMorphTargets['MT_BrowDnL']:0.7,maxMorphTargets['MT_BrowDnR']:0.7,maxMorphTargets['MT_SneerL']:0.8,maxMorphTargets['MT_SneerR']:0.8,maxMorphTargets['MT_FrownL']:0.2,maxMorphTargets['MT_FrownR']:0.2,maxMorphTargets['MT_UprLipDnL']:0.45,maxMorphTargets['MT_UprLipDnR']:0.45,maxMorphTargets['MT_LwrLipUpL']:1.0,maxMorphTargets['MT_LwrLipUpR']:1.0},
'ExpDisgust':{maxMorphTargets['MT_WideL']:0.25,maxMorphTargets['MT_WideR']:0.15,maxMorphTargets['MT_SquintL']:0.40,maxMorphTargets['MT_SquintR']:0.40,maxMorphTargets['MT_MBrowDn']:0.25,maxMorphTargets['MT_BrowSqueeze']:0.45,maxMorphTargets['MT_WideL']:0.25,maxMorphTargets['MT_BrowDnL']:0.50,maxMorphTargets['MT_BrowDnR']:0.50,maxMorphTargets['MT_SneerL']:2.0,maxMorphTargets['MT_SneerR']:2.0,maxMorphTargets['MT_FrownL']:0.25,maxMorphTargets['MT_FrownR']:0.25,maxMorphTargets['MT_UprLipUpL']:0.66,maxMorphTargets['MT_UprLipUpR']:0.33,maxMorphTargets['MT_LwrLipUpL']:0.40,maxMorphTargets['MT_LwrLipUpR']:0.40 },
'ExpFear':{maxMorphTargets['MT_Jaw_Open']:0.15,maxMorphTargets['MT_Jaw_Fwd']:-0.3,maxMorphTargets['MT_NarrowL']:0.24,maxMorphTargets['MT_NarrowR']:0.24,maxMorphTargets['MT_SquintL']:-0.4,maxMorphTargets['MT_SquintR']:-0.4,maxMorphTargets['MT_BrowUpL']:0.36,maxMorphTargets['MT_BrowUpR']:0.36,maxMorphTargets['MT_MBrowUp']:1.30,maxMorphTargets['MT_BrowSqueeze']:0.40,maxMorphTargets['MT_FrownL']:0.35,maxMorphTargets['MT_FrownR']:0.35,maxMorphTargets['MT_UprLipDnL']:0.25,maxMorphTargets['MT_UprLipDnR']:0.25,maxMorphTargets['MT_LwrLipUpL']:0.35,maxMorphTargets['MT_LwrLipUpR']:0.35},
'ExpSad':{maxMorphTargets['MT_NarrowL']:0.20,maxMorphTargets['MT_NarrowR']:0.20,maxMorphTargets['MT_SquintL']:0.20,maxMorphTargets['MT_SquintR']:0.20,maxMorphTargets['MT_MBrowUp']:0.40,maxMorphTargets['MT_BrowSqueeze']:0.66,maxMorphTargets['MT_BrowDnL']:0.66,maxMorphTargets['MT_BrowDnR']:0.66,maxMorphTargets['MT_BlowCheeksL']:-0.25,maxMorphTargets['MT_BlowCheeksR']:-0.25,maxMorphTargets['MT_FrownL']:0.66,maxMorphTargets['MT_FrownR']:0.66,maxMorphTargets['MT_UprLipDnL']:0.50,maxMorphTargets['MT_UprLipDnR']:0.50,maxMorphTargets['MT_LwrLipUpL']:0.66,maxMorphTargets['MT_LwrLipUpR']:0.66},
'ExpSurprise':{maxMorphTargets['MT_Jaw_Open']:0.25,maxMorphTargets['MT_NarrowL']:0.24,maxMorphTargets['MT_NarrowR']:0.24,maxMorphTargets['MT_SquintL']:-0.20,maxMorphTargets['MT_SquintR']:-0.20,maxMorphTargets['MT_BrowUpL']:0.92,maxMorphTargets['MT_BrowUpR']:0.92,maxMorphTargets['MT_MBrowUp']:0.66},
'ExpSmileOpen':{maxMorphTargets['MT_Jaw_Open']:0.16,maxMorphTargets['MT_WideL']:0.740,maxMorphTargets['MT_WideR']:0.740,maxMorphTargets['MT_SneerL']:0.280,maxMorphTargets['MT_SneerR']:0.280,maxMorphTargets['MT_BrowUpL']:0.360,maxMorphTargets['MT_BrowUpR']:0.360},
'ExpHappy':{maxMorphTargets['MT_Jaw_Open']:0.22,maxMorphTargets['MT_WideL']:0.75,maxMorphTargets['MT_WideR']:0.75,maxMorphTargets['MT_SquintL']:0.35,maxMorphTargets['MT_SquintR']:0.35,maxMorphTargets['MT_BrowDnL']:0.08,maxMorphTargets['MT_BrowDnR']:0.08,maxMorphTargets['MT_UprLipUpL']:0.15,maxMorphTargets['MT_UprLipUpR']:0.15,maxMorphTargets['MT_LwrLipUpL']:0.15,maxMorphTargets['MT_LwrLipUpR']:0.15,maxMorphTargets['MT_BrowUpL']:0.360,maxMorphTargets['MT_BrowUpR']:0.360},
'ModBlinkLeft':{maxMorphTargets['MT_Blink_L']:1.0},
'ModBlinkRight':{maxMorphTargets['MT_Blink_R']:1.0},
'ModBrowDownLeft':{maxMorphTargets['MT_BrowDnL']:1.0},
'ModBrowDownRight':{maxMorphTargets['MT_BrowDnR']:1.0},
'ModBrowInRight':{maxMorphTargets['MT_BrowSqueeze']:1.0},
'ModBrowInLeft':{maxMorphTargets['MT_BrowSqueeze']:1.0},
'ModBrowUpLeft':{maxMorphTargets['MT_BrowUpL']:1.0},
'ModBrowUpRight':{maxMorphTargets['MT_BrowUpR']:1.0},
#'ModEarsOut':[],
'ModEyeSquintLeft':{maxMorphTargets['MT_SquintL']:1.0},
'ModEyeSquintRight':{maxMorphTargets['MT_SquintR']:1.0},
'Phonaah':{maxMorphTargets['MT_Jaw_Open']:1.0},
'PhonB,M,P':{maxMorphTargets['MT_WideL']:0.5,maxMorphTargets['MT_WideR']:0.5},
'Phonbigaah':{maxMorphTargets['MT_Jaw_Open']:1.0},
'Phonch,J,sh':{maxMorphTargets['MT_WideL']:0.5,maxMorphTargets['MT_WideR']:0.5},
'PhonD,S,T':{maxMorphTargets['MT_WideL']:0.5,maxMorphTargets['MT_WideR']:0.5,maxMorphTargets['MT_Jaw_Open']:0.2 },
'Phonee':{maxMorphTargets['MT_WideL']:0.5,maxMorphTargets['MT_WideR']:0.5},
'Phoneh':{maxMorphTargets['MT_WideL']:0.5,maxMorphTargets['MT_WideR']:0.5,maxMorphTargets['MT_Jaw_Open']:0.2 },
'PhonF,V':{maxMorphTargets['MT_WideL']:0.2,maxMorphTargets['MT_WideR']:0.2,maxMorphTargets['MT_Jaw_Open']:0.3,maxMorphTargets['MT_UprLipDnL']:0.3,maxMorphTargets['MT_UprLipDnR']:0.3},
'Phoni':{maxMorphTargets['MT_WideL']:0.2,maxMorphTargets['MT_WideR']:0.2,maxMorphTargets['MT_Jaw_Open']:0.3 },
'PhonK':{maxMorphTargets['MT_Jaw_Open']:0.4},
'PhonN':{maxMorphTargets['MT_WideL']:0.5,maxMorphTargets['MT_WideR']:0.5},
'Phonoh':{maxMorphTargets['MT_Jaw_Open']:0.4,maxMorphTargets['MT_NarrowL']:0.55,maxMorphTargets['MT_NarrowR']:0.55},
'Phonooh,Q':{maxMorphTargets['MT_Jaw_Open']:0.4,maxMorphTargets['MT_NarrowL']:0.55,maxMorphTargets['MT_NarrowR']:0.55},
'PhonR':{maxMorphTargets['MT_WideL']:0.5,maxMorphTargets['MT_WideR']:0.5,maxMorphTargets['MT_Jaw_Open']:0.2 },
'Phonth':{maxMorphTargets['MT_WideL']:0.5,maxMorphTargets['MT_WideR']:0.5,maxMorphTargets['MT_Jaw_Open']:0.2 },
'PhonW':{maxMorphTargets['MT_Jaw_Open']:0.3,maxMorphTargets['MT_NarrowL']:0.7,maxMorphTargets['MT_NarrowR']:0.7},
'AU26_MT_Jaw_Open':{maxMorphTargets['MT_Jaw_Open']:1.0},
'AU30_MT_Jaw_L':{maxMorphTargets['MT_Jaw_L']:1.0},
'AU30_MT_Jaw_R':{maxMorphTargets['MT_Jaw_R']:1.0},
'AU31_MT_Jaw_Fwd':{maxMorphTargets['MT_Jaw_Fwd']:1.0},
'AU27_MT_WideL':{maxMorphTargets['MT_WideL']:1.0},
'AU27_MT_WideR':{maxMorphTargets['MT_WideR']:1.0},
'AU18_MT_NarrowL':{maxMorphTargets['MT_NarrowL']:1.0},
'AU18_MT_NarrowR':{maxMorphTargets['MT_NarrowL']:1.0},
'AU42_MT_FrownL':{maxMorphTargets['MT_FrownL']:1.0},
'AU42_MT_FrownR':{maxMorphTargets['MT_FrownR']:1.0},
'AU9_MT_SneerL':{maxMorphTargets['MT_SneerL']:1.0},
'AU9_MT_SneerR':{maxMorphTargets['MT_SneerR']:1.0},
'AU46_MT_SquintL':{maxMorphTargets['MT_SquintL']:1.0},
'AU46_MT_SquintR':{maxMorphTargets['MT_SquintR']:1.0},
'AU2_MT_BrowUpL':{maxMorphTargets['MT_BrowUpL']:1.0},
'AU2_MT_BrowUpR':{maxMorphTargets['MT_BrowUpR']:1.0},
'AU4_MT_BrowDnL':{maxMorphTargets['MT_BrowDnL']:1.0},
'AU4_MT_BrowDnR':{maxMorphTargets['MT_BrowDnR']:1.0},
'AU4_MT_MBrowUp':{maxMorphTargets['MT_MBrowUp']:1.0},
'AU1_MT_BrowDnR':{maxMorphTargets['MT_BrowDnR']:1.0},
'AU1_MT_BrowDnL':{maxMorphTargets['MT_BrowDnL']:1.0},
'AU1_MT_MBrowDn':{maxMorphTargets['MT_MBrowDn']:1.0},
'AU44_MT_BrowSqueeze':{maxMorphTargets['MT_BrowSqueeze']:1.0},
'AU12_MT_MouthL':{maxMorphTargets['MT_MouthL']:1.0},
'AU12_MT_MouthR':{maxMorphTargets['MT_MouthR']:1.0},
'AU5_MT_UprLipUpL':{maxMorphTargets['MT_UprLipUpL']:1.0},
'AU5_MT_UprLipUpR':{maxMorphTargets['MT_UprLipUpR']:1.0},
'MT_UprLipDnL':{maxMorphTargets['MT_UprLipDnL']:1.0},
'MT_UprLipDnR':{maxMorphTargets['MT_UprLipDnR']:1.0},
'MT_LwrLipUpL':{maxMorphTargets['MT_LwrLipUpL']:1.0},
'MT_LwrLipUpR':{maxMorphTargets['MT_LwrLipUpR']:1.0},
'MT_LwrLipDnL':{maxMorphTargets['MT_LwrLipDnL']:1.0},
'MT_LwrLipDnR':{maxMorphTargets['MT_LwrLipDnR']:1.0},
'AU33_MT_BlowCheeksL':{maxMorphTargets['MT_BlowCheeksL']:1.0},
'AU33_MT_BlowCheeksR':{maxMorphTargets['MT_BlowCheeksR']:1.0},
'AU36_MT_TongueOut':{maxMorphTargets['MT_TongueOut']:1.0},
'AU36_MT_TongueUp':{maxMorphTargets['MT_TongueUp']:1.0},
'AU36_MT_TongueTipUp':{maxMorphTargets['MT_TongueTipUp']:1.0},
'AU36_MT_TongueL':{maxMorphTargets['MT_TongueL']:1.0},
'AU36_MT_TongueR':{maxMorphTargets['MT_TongueR']:1.0},
'AU45_MT_Blink_L':{maxMorphTargets['MT_Blink_L']:1.0},
'AU45_MT_Blink_R':{maxMorphTargets['MT_Blink_R']:1.0}
}
#instanciate a list in order to keep track of kinematic joints joints
#in python runtime
#if nothing points towards those joints, they get flushed by
#python's garbage collector
self.jointList = []
self.jointFKList = []
self.agentControlJoints = []
self.agentNodePaths = []
self.agentSMRSkel = SMRPy.SMRSkeleton(True,True,'agent')
self.createSkel( self.agent, self.agentSMRSkel, 'root', '' )
#Pascal: output of both skeletons amber and alfonse as chracter.bvh
#SMRPy.exportSkeletonToBvh(self.name + '.bvh',self.agentSMRSkel);
self.newSkeleton = SMRPy.SMRSkeleton(True,True,'pose')
self.createFKSkel(self.animationAgent, self.newSkeleton, "root", '')
self.realizer.addCharacter( self.name, self.agentSMRSkel );
for key in self.targets.keys():
self.realizer.addMorphTarget( self.name, key ) #TODO: declare morph targets into CharacterConfigurationFile
#self.realizer.addShaderParameter( self.name, 'blushing' ) #TODO: declare shader inputs into CharacterConfiguration file
self.realizer.addBVHMotionToCharacter(self.name, 'hands_claw', open('./animations/hands_claw.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_index', open('./animations/hands_index.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_open-relaxed', open('./animations/hands_open-relaxed.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_open-spread', open('./animations/hands_open-spread.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_open-straight', open('./animations/hands_open-straight.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_purse', open('./animations/hands_purse.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ring', open('./animations/hands_ring.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'poseNeutral', open('./animations/poseNeutral.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'shrug', open('./animations/shrug.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_A', open('./animations/hands_DGS_A.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_B', open('./animations/hands_DGS_B.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_C', open('./animations/hands_DGS_C.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_D', open('./animations/hands_DGS_D.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_E', open('./animations/hands_DGS_E.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_F', open('./animations/hands_DGS_F.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_G', open('./animations/hands_DGS_G.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_H', open('./animations/hands_DGS_H.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_I', open('./animations/hands_DGS_I.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_J', open('./animations/hands_DGS_J.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_K', open('./animations/hands_DGS_K.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_L', open('./animations/hands_DGS_L.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_M', open('./animations/hands_DGS_M.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_N', open('./animations/hands_DGS_N.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_O', open('./animations/hands_DGS_O.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_P', open('./animations/hands_DGS_P.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_Q', open('./animations/hands_DGS_Q.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_R', open('./animations/hands_DGS_R.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_T', open('./animations/hands_DGS_T.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_U', open('./animations/hands_DGS_U.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_W', open('./animations/hands_DGS_W.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_X', open('./animations/hands_DGS_X.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_Y', open('./animations/hands_DGS_Y.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_Z', open('./animations/hands_DGS_Z.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_DGS_SCH', open('./animations/hands_DGS_SCH.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_A', open('./animations/hands_ASL_A.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_B', open('./animations/hands_ASL_B.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_C', open('./animations/hands_ASL_C.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_D', open('./animations/hands_ASL_D.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_E', open('./animations/hands_ASL_E.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_F', open('./animations/hands_ASL_F.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_G', open('./animations/hands_ASL_G.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_H', open('./animations/hands_ASL_H.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_I', open('./animations/hands_ASL_I.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_J', open('./animations/hands_ASL_J.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_K', open('./animations/hands_ASL_K.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_L', open('./animations/hands_ASL_L.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_M', open('./animations/hands_ASL_M.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_N', open('./animations/hands_ASL_N.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_O', open('./animations/hands_ASL_O.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_P', open('./animations/hands_ASL_P.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_Q', open('./animations/hands_ASL_Q.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_R', open('./animations/hands_ASL_R.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_T', open('./animations/hands_ASL_T.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_U', open('./animations/hands_ASL_U.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_V', open('./animations/hands_ASL_V.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_W', open('./animations/hands_ASL_W.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_X', open('./animations/hands_ASL_X.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_Y', open('./animations/hands_ASL_Y.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_Z', open('./animations/hands_ASL_Z.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_1CL', open('./animations/hands_ASL_1CL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_2CL', open('./animations/hands_ASL_2CL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_3CL', open('./animations/hands_ASL_3CL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_4CL', open('./animations/hands_ASL_4CL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_5aCL', open('./animations/hands_ASL_5aCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_5bCL', open('./animations/hands_ASL_5bCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_ACL', open('./animations/hands_ASL_ACL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_BCL', open('./animations/hands_ASL_BCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_CCL', open('./animations/hands_ASL_CCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_FCL', open('./animations/hands_ASL_FCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_ICL', open('./animations/hands_ASL_ICL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_ILYCL', open('./animations/hands_ASL_ILYCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_SCL', open('./animations/hands_ASL_SCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_VaCL', open('./animations/hands_ASL_VaCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_VbCL', open('./animations/hands_ASL_VbCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_YCL', open('./animations/hands_ASL_YCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_CbCL', open('./animations/hands_ASL_CbCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(self.name, 'hands_ASL_TCL', open('./animations/hands_ASL_TCL.bvh', "r").read())
firingstevenhigh = open('./animations/alfonse-FiringStevenHigh.bvh', "r").read()
self.realizer.addBVHMotionToCharacter(self.name, 'FiringStevenHigh', firingstevenhigh )
print("done")
self.agent.reparentTo( render )
def update( self ):
self.realizer.skeletonRequested()
skeletonHasBeenUpdated = False
while(not skeletonHasBeenUpdated):
#wait until skeleton can be displayed
if(self.realizer.skeletonIsReadyToBeDisplayed(self.name)):
self.updatePandaSkeleton(self.agentControlJoints, self.agentSMRSkel)
skeletonHasBeenUpdated = True
for key in self.realizer.getModifiedMorphTargets(self.name): #self.targets.keys(): # Only update the targets that have actually changed here
#print key, "\n"
weight = self.realizer.getMorphTargetWeight( self.name, key )
morphTargets = self.targets[key]
for morphTargetKey in morphTargets.keys() :
#print(weight*morphTargets[morphTargetKey])
morphTargetKey.setX(weight*morphTargets[morphTargetKey])
#blushingValue = self.realizer.getShaderParameterValue( self.name, 'blushing' )
#self.shaders.headShader.blushing.set( blushingValue )
def addAnimation(self,_actorName,_animationName):
self.animationAgent.reparentTo(render)
self.animationAgent.setScale(10)
self.realizer.addAnimation(_actorName, _animationName)
for i in range (self.animationAgent.getNumFrames(_animationName)):
self.animationAgent.pose(_animationName,i)
base.graphicsEngine.renderFrame()
self.updateSMRSkeleton(self.agentNodePaths, self.newSkeleton)
self.realizer.addPoseToAnimation(_actorName, _animationName, self.newSkeleton)
self.animationAgent.detachNode()
print "animation",_animationName,"added"
def addAnimationWE(self,_actorName,_animationName):
self.animationAgent.reparentTo(render)
self.animationAgent.setScale(10)
agentSMRMotion = SMRPy.SMRMotion()
agentSMRMotion.setTimeStep(0.04)
self.realizer.addAnimation(_actorName, _animationName)
for i in range (self.animationAgent.getNumFrames(_animationName)):
self.animationAgent.pose(_animationName,i)
base.graphicsEngine.renderFrame()
self.updateSMRSkeleton(self.agentNodePaths, self.newSkeleton)
self.realizer.addPoseToAnimation(_actorName, _animationName, self.newSkeleton)
agentSMRMotion.insertSkeleton(self.newSkeleton)
self.animationAgent.detachNode()
print "animation",_animationName,"added"
SMRPy.exportMotionToBvh(_animationName+".bvh",agentSMRMotion)
def createSkel(self, _pandaAgent, _smrSkel, _initialJointName, _parentName):
#get the agent's currentJoint
currentPandaJoint = _pandaAgent.getJoints(None,_initialJointName)
currentPandaCJoint = _pandaAgent.controlJoint(None, 'modelRoot', _initialJointName)
self.agentControlJoints.append(currentPandaCJoint)
#get the first joint's position
position = currentPandaCJoint.getPos()
if (currentPandaJoint[0].getNumChildren() == 0):
newJoint = SMRPy.SMRJoint(True)
newJoint.setEndVect(position.getX(),position.getY(),position.getZ());
else:
newJoint = SMRPy.SMRJoint(False)
rotZ = (currentPandaCJoint.getH()/180.0)*3.14159;
rotX = (currentPandaCJoint.getP()/180.0)*3.14159;
rotY = (currentPandaCJoint.getR()/180.0)*3.14159;
quatZ = SMRPy.SMRQuaternion(SMRPy.SMRVector3(0.0,0.0,1.0),rotZ)
quatX = SMRPy.SMRQuaternion(SMRPy.SMRVector3(1.0,0.0,0.0),rotX)
quatY = SMRPy.SMRQuaternion(SMRPy.SMRVector3(0.0,1.0,0.0),rotY)
quatRot = quatZ.multiply(quatX)
quatRot = quatRot.multiply(quatY)
quatRot.normalize();
newJoint.setPos(position.getX(),position.getY(),position.getZ())
newJoint.setRotQuat(quatRot.getW(),quatRot.getX(),quatRot.getY(),quatRot.getZ())
newJoint.setParentName(_parentName)
newJoint.setName(_initialJointName)
self.jointList.append(newJoint)
_smrSkel.insertJoint(newJoint)
for i in range(currentPandaJoint[0].getNumChildren()):
childJoint = currentPandaJoint[0].getChild(i)
childName = childJoint.getName()
#print(childName)
self.createSkel(_pandaAgent, _smrSkel, childName, _initialJointName)
def createFKSkel(self, _pandaAgent, _smrSkel, _initialJointName, _parentName):
#get the agent's currentJoint
currentPandaJoint = _pandaAgent.getJoints(None, _initialJointName)
currentPandaJointPath = _pandaAgent.exposeJoint(None, 'modelRoot', _initialJointName, "lodRoot", True)
self.agentNodePaths.append(currentPandaJointPath)
#get the first joint's position
position = currentPandaJointPath.getPos()
if (currentPandaJoint[0].getNumChildren() == 0):
newJoint = SMRPy.SMRJoint(True)
newJoint.setEndVect(position.getX(),position.getY(),position.getZ());
else:
newJoint = SMRPy.SMRJoint(False)
quatRot = currentPandaJointPath.getQuat()
newJoint.setPos(position.getX(),position.getY(),position.getZ())
newJoint.setRotQuat(quatRot.getR(),quatRot.getI(),quatRot.getJ(),quatRot.getK())
newJoint.setParentName(_parentName)
newJoint.setName(_initialJointName)
self.jointFKList.append(newJoint)
_smrSkel.insertJoint(newJoint)
for i in range(currentPandaJoint[0].getNumChildren()):
childJoint = currentPandaJoint[0].getChild(i)
childName = childJoint.getName()
#print(childName)
self.createFKSkel(_pandaAgent, _smrSkel, childName, _initialJointName)
def updatePandaSkeleton(self, agentControlJoints, _smrSkeleton):
#synchronize root joint
SMRJoint = _smrSkeleton.getJoint(0)
PANDAJoint = agentControlJoints[0]
position = SMRJoint.getPos()
PANDAJoint.setPos(position.X(),position.Y(),position.Z());
for i in range(_smrSkeleton.getNumjoints()):
SMRJoint = _smrSkeleton.getJoint(i)
PANDAJoint = agentControlJoints[i]
self.synchronize(PANDAJoint,SMRJoint)
def updateSMRSkeleton(self, agentNodePaths, _smrSkeleton):
#synchronize root joint
SMRJoint = _smrSkeleton.getJoint(0)
PANDAJoint = agentNodePaths[0]
position = PANDAJoint.getPos()
SMRJoint.setPos(position.getX(),position.getY(),position.getZ());
for i in range(_smrSkeleton.getNumjoints()):
SMRJoint = _smrSkeleton.getJoint(i)
PANDAJoint = agentNodePaths[i]
self.synchronizePandaToSMR(SMRJoint,PANDAJoint)
def synchronizePandaToSMR(self, _SMRJoint, _PANDAJoint):
pandaQuaternion = _PANDAJoint.getQuat()
x = pandaQuaternion.getI()
y = pandaQuaternion.getJ()
z = pandaQuaternion.getK()
w = pandaQuaternion.getR()
_SMRJoint.setRotQuat(w,x,y,z)
def synchronize(self, _pandaCJoint, _smrJoint):
smrQuaternion = _smrJoint.getRot()
pandaQuaternion = Quat()
pandaQuaternion.setI(smrQuaternion.getX())
pandaQuaternion.setJ(smrQuaternion.getY())
pandaQuaternion.setK(smrQuaternion.getZ())
pandaQuaternion.setR(smrQuaternion.getW())
if not(pandaQuaternion.isNan()):
_pandaCJoint.setQuat(pandaQuaternion)
class Centipede():
index = 0
def __init__(self, showbase, numPlayers, addToCollisions):
self.addToCollisions = addToCollisions
# Load centipede model
self.head = Actor('models/centipede')
# Set animation loop to Walk
self.head.loop('Walk')
# Reparent the model to render.
self.head.reparentTo(showbase.render)
self.h = 360.0 / numPlayers
self.h *= (Centipede.index + 1)
Centipede.index += 1
self.head.setH(self.h)
self.head.setPos(self.head, 0, -100, 0)
self.x = self.head.getX()
self.y = self.head.getY()
min, max = self.head.getTightBounds()
self.length = (max - min).getX() * 0.5
self.head.collisionNode = initCollisionSphere(self.head, 'Head', 0.65)
# Add head to collision detection
addToCollisions(self.head.collisionNode)
self.body = []
# Load centipede model
self.tail = Actor('models/centipede')
# Set animation loop to Walk
self.tail.loop('Walk')
# Reparent the model to render.
self.tail.reparentTo(showbase.render)
self.tail.collisionNode = initCollisionSphere(self.tail, 'Tail', 0.65)
# Add tail to collision detection
addToCollisions(self.tail.collisionNode)
self.destinationNode = showbase.render.attachNewNode('Destination' + str(Centipede.index - 1))
self.reset()
def destroy(self):
self.reset()
self.head.detachNode()
self.tail.detachNode()
def reset(self):
for node in self.body:
node.detachNode()
self.body = []
# Set position of centipede head
self.head.setX(self.x)
self.head.setY(self.y)
# Set rotation of centipede head
self.head.setH(self.h)
self.tail.setH(self.h)
# Set tail position
self.tail.setPos(self.head, 0, -self.length, 0)
self.destinationNode.setPos(self.head, 0, 1, 0)
def update(self, dt):
self.updateRotation(dt)
self.moveForwards(dt, 1.0)
def updateRotation(self, dt):
oldH = self.head.getH()
self.head.headsUp(self.destinationNode)
newH = self.head.getH()
self.head.setH(oldH)
newH = fitDestAngle2Src(oldH, newH)
if newH - oldH < 0.0:
change = -dt * 90.0
else:
change = dt * 90.0
if abs(newH - oldH) < abs(change):
self.head.setH(newH)
self.destinationNode.setPos(self.head, 0, 1, 0)
else:
self.head.setH(self.head.getH() + change)
def moveForwards(self, dt, multi):
# Update centipede position
self.head.setPos(self.head, 0, dt * multi * 25, 0)
for i in range(len(self.body)):
# Calculate new heading angle for body part
# And update body position
if i == 0:
self.body[i].headsUp(self.head)
self.body[i].setPos(self.body[i], 0, self.body[i].getDistance(self.head) - self.length, 0)
else:
self.body[i].headsUp(self.body[i - 1])
self.body[i].setPos(self.body[i], 0, self.body[i].getDistance(self.body[i - 1]) - self.length, 0)
if len(self.body) > 0:
# Update Tail Heading
self.tail.headsUp(self.body[len(self.body) - 1])
# Update body position
self.tail.setPos(self.tail, 0, self.body[len(self.body) - 1].getDistance(self.tail) - self.length, 0)
else:
# Update Tail Heading
self.tail.headsUp(self.head)
# Update body position
self.tail.setPos(self.tail, 0, self.head.getDistance(self.tail) - self.length, 0)
def addLength(self, showbase):
# Load centipede model
node = Actor('models/centipede')
# Set animation loop to Walk
node.loop('Walk')
# Reparent the model to render.
node.reparentTo(showbase.render)
# Set body rotation
node.setH(self.tail.getH())
# Set body position
node.setPos(self.tail.getPos())
node.collisionNode = initCollisionSphere(node, 'Body-' + str(len(self.body)), 0.65)
self.addToCollisions(node.collisionNode)
# Insert into body list
self.body.append(node)
# Set tail position
self.tail.setPos(node, 0, -0.5, 0)
# for client to attach ring below clients head
def attachRing(self, showbase):
self.ringNode = showbase.loader.loadModel('media/warlock/warlock_ring')
self.ringNode.setPos(-Vec3(0, 0, 1.25))
self.ringNode.reparentTo(self.head)
def setDestination(self, destination):
self.destination = Vec3(destination[0], destination[1], 0)
self.destinationNode.setPos(self.destination)
def getDestinationUpdate(self):
return self.destination.getX(), self.destination.getY()
class Centipede():
index = 0
def __init__(self, showbase, numPlayers, addToCollisions):
self.addToCollisions = addToCollisions
# Load centipede model
self.head = Actor('models/centipede')
# Set animation loop to Walk
self.head.loop('Walk')
# Reparent the model to render.
self.head.reparentTo(showbase.render)
self.h = 360.0 / numPlayers
self.h *= (Centipede.index + 1)
Centipede.index += 1
self.head.setH(self.h)
self.head.setPos(self.head, 0, -100, 0)
self.x = self.head.getX()
self.y = self.head.getY()
min, max = self.head.getTightBounds()
self.length = (max - min).getX() * 0.5
self.head.collisionNode = initCollisionSphere(self.head, 'Head', 0.65)
# Add head to collision detection
addToCollisions(self.head.collisionNode)
self.body = []
# Load centipede model
self.tail = Actor('models/centipede')
# Set animation loop to Walk
self.tail.loop('Walk')
# Reparent the model to render.
self.tail.reparentTo(showbase.render)
self.tail.collisionNode = initCollisionSphere(self.tail, 'Tail', 0.65)
# Add tail to collision detection
addToCollisions(self.tail.collisionNode)
self.destinationNode = showbase.render.attachNewNode(
'Destination' + str(Centipede.index - 1))
self.reset()
def destroy(self):
self.reset()
self.head.detachNode()
self.tail.detachNode()
def reset(self):
for node in self.body:
node.detachNode()
self.body = []
# Set position of centipede head
self.head.setX(self.x)
self.head.setY(self.y)
# Set rotation of centipede head
self.head.setH(self.h)
self.tail.setH(self.h)
# Set tail position
self.tail.setPos(self.head, 0, -self.length, 0)
self.destinationNode.setPos(self.head, 0, 1, 0)
def update(self, dt):
self.updateRotation(dt)
self.moveForwards(dt, 1.0)
def updateRotation(self, dt):
oldH = self.head.getH()
self.head.headsUp(self.destinationNode)
newH = self.head.getH()
self.head.setH(oldH)
newH = fitDestAngle2Src(oldH, newH)
if newH - oldH < 0.0:
change = -dt * 90.0
else:
change = dt * 90.0
if abs(newH - oldH) < abs(change):
self.head.setH(newH)
self.destinationNode.setPos(self.head, 0, 1, 0)
else:
self.head.setH(self.head.getH() + change)
def moveForwards(self, dt, multi):
# Update centipede position
self.head.setPos(self.head, 0, dt * multi * 25, 0)
for i in range(len(self.body)):
# Calculate new heading angle for body part
# And update body position
if i == 0:
self.body[i].headsUp(self.head)
self.body[i].setPos(
self.body[i], 0,
self.body[i].getDistance(self.head) - self.length, 0)
else:
self.body[i].headsUp(self.body[i - 1])
self.body[i].setPos(
self.body[i], 0,
self.body[i].getDistance(self.body[i - 1]) - self.length,
0)
if len(self.body) > 0:
# Update Tail Heading
self.tail.headsUp(self.body[len(self.body) - 1])
# Update body position
self.tail.setPos(
self.tail, 0,
self.body[len(self.body) - 1].getDistance(self.tail) -
self.length, 0)
else:
# Update Tail Heading
self.tail.headsUp(self.head)
# Update body position
self.tail.setPos(self.tail, 0,
self.head.getDistance(self.tail) - self.length, 0)
def addLength(self, showbase):
# Load centipede model
node = Actor('models/centipede')
# Set animation loop to Walk
node.loop('Walk')
# Reparent the model to render.
node.reparentTo(showbase.render)
# Set body rotation
node.setH(self.tail.getH())
# Set body position
node.setPos(self.tail.getPos())
node.collisionNode = initCollisionSphere(node,
'Body-' + str(len(self.body)),
0.65)
self.addToCollisions(node.collisionNode)
# Insert into body list
self.body.append(node)
# Set tail position
self.tail.setPos(node, 0, -0.5, 0)
# for client to attach ring below clients head
def attachRing(self, showbase):
self.ringNode = showbase.loader.loadModel('media/warlock/warlock_ring')
self.ringNode.setPos(-Vec3(0, 0, 1.25))
self.ringNode.reparentTo(self.head)
def setDestination(self, destination):
self.destination = Vec3(destination[0], destination[1], 0)
self.destinationNode.setPos(self.destination)
def getDestinationUpdate(self):
return self.destination.getX(), self.destination.getY()
class Agent:
def __init__(self, _name):
print "Creating agent " + _name
self.name = _name
self.loadLightingFromConfig = 0
self.createShadowMap = 0
def setDataPath(self, _dataPath):
self.dataPath = _dataPath
def setActor(self, _modelFileName, _animationFileNames, _morphTargetsFileName):
self.modelFileName = _modelFileName
self.animationFileNames = _animationFileNames
self.morphTargetsFileName = _morphTargetsFileName
def setRealizer(self, _realizer):
self.realizer = _realizer
def setCameraMask(self, _mask):
self.cameraMask = _mask
def setShadowMapParameters(self, _index, _distance):
self.createShadowMap = 1
self.shadowMapIndex = _index
self.shadowMapDistance = _distance
def setTransform(self, x, y, z, rx, ry, rz, scale):
self.agent.setPos(x, y, z)
self.agent.setScale(scale)
self.agent.setHpr(rx, ry, rz)
self.positionX = x
self.positionY = y
self.positionZ = z
def getPosition(self):
return self.agent.getPos()
def setLightingConfiguration(self, _config, _name):
self.lightingConfig = _config
self.lightingConfigName = _name
self.loadLightingFromConfig = 1
def init(self):
# load the agent and parent it to the world
# The joints of this agent will reference Panda NodePaths, it will be possible to play animations on it
self.animationAgent = Actor(self.modelFileName, self.animationFileNames)
self.agent = Actor(self.modelFileName, self.morphTargetsFileName)
self.targets = { #'Basis':[],
"ExpSmileClosed": [],
"ExpAnger": [],
"ExpDisgust": [],
"ExpFear": [],
"ExpSad": [],
"ExpSurprise": [],
"ExpSmileOpen": [],
"ModBlinkLeft": [],
"ModBlinkRight": [],
"ModBrowDownLeft": [],
"ModBrowDownRight": [],
"ModBlinkRight": [],
"ModBrowInRight": [],
"ModBrowInLeft": [],
"ModBrowUpLeft": [],
"ModBrowUpRight": [],
"ModEarsOut": [],
"ModEyeSquintLeft": [],
"ModEyeSquintRight": [],
"ModLookDown": [],
"ModLookLeft": [],
"ModLookRight": [],
"ModLookUp": [],
"ModBlinkLeft": [],
"Phonaah": [],
"PhonB,M,P": [],
"Phonbigaah": [],
"Phonch,J,sh": [],
"PhonD,S,T": [],
"Phonee": [],
"Phoneh": [],
"PhonF,V": [],
"Phoni": [],
"PhonK": [],
"PhonN": [],
"Phonoh": [],
"Phonooh,Q": [],
"PhonR": [],
"Phonth": [],
"PhonW": [],
}
iter = self.targets.iteritems()
while True:
try:
morphsItem = iter.next()
except StopIteration:
break
for i in range(2, 7):
# print (str(i)+'_'+morphsItem[0])
blendShape = self.agent.controlJoint(None, "modelRoot", str(i) + "_" + morphsItem[0])
if blendShape:
morphsItem[1].append(blendShape)
self.targets["inspire"] = [self.agent.controlJoint(None, "modelRoot", "inspire")]
# instanciate a list in order to keep track of kinematic joints joints
# in python runtime
# if nothing points towards those joints, they get flushed by
# python's garbage collector
self.jointList = []
self.jointFKList = []
self.agentControlJoints = []
self.agentNodePaths = []
self.agentSMRSkel = SMRPy.SMRSkeleton(True, True, "agent")
self.createSkel(self.agent, self.agentSMRSkel, "root", "")
# SMRPy.exportSkeletonToBvh('exportedPose.bvh',self.agentSMRSkel);
self.newSkeleton = SMRPy.SMRSkeleton(True, True, "pose")
self.createFKSkel(self.animationAgent, self.newSkeleton, "root", "")
self.realizer.addCharacter(self.name, self.agentSMRSkel)
for key in self.targets.keys():
self.realizer.addMorphTarget(self.name, key)
self.realizer.addShaderParameter(self.name, "blushing")
self.addAnimation(self.name, "breathing")
self.addAnimation(self.name, "hands_claw")
self.addAnimation(self.name, "hands_fist")
self.addAnimation(self.name, "hands_index")
self.addAnimation(self.name, "hands_open-relaxed")
self.addAnimation(self.name, "hands_open-spread")
self.addAnimation(self.name, "hands_open-straight")
self.addAnimation(self.name, "hands_purse")
self.addAnimation(self.name, "hands_ring")
self.addAnimation(self.name, "poseNeutral")
# self.addAnimation(self.name,'endian')
if "default" in self.animationFileNames:
self.addAnimation(self.name, "default")
# self.realizer.addCharacterSkeleton( self.name, );
self.agent.reparentTo(render)
self.agent.hide(BitMask32.bit(self.cameraMask))
# set lighting
ambientColor = Vec4(0.0, 0.0, 0.0, 0.0)
self.lighting = shaders.Lighting(ambientColor, self.agent)
if self.loadLightingFromConfig == 1:
self.lighting.loadFromConfig(self.lightingConfig, self.lightingConfigName)
# shadow map
if self.createShadowMap == 1:
self.shadowMap = shadowmap.ShadowMap(self.shadowMapIndex, self.dataPath)
def setShaders(self, _shaders):
self.shaders = _shaders
def update(self):
self.realizer.skeletonRequested()
self.updatePandaSkeleton(self.agentControlJoints, self.agentSMRSkel)
for key in self.targets.keys():
# print(key, "\n")
weight = self.realizer.getMorphTargetWeight(self.name, key)
morphTargets = self.targets[key]
for morphTarget in morphTargets:
# print(weight, "\n")
morphTarget.setX(weight)
# blushingValue = self.realizer.getShaderParameterValue( self.name, 'blushing' )
# self.shaders.headShader.blushing.set( blushingValue )
self.lighting.update()
if self.createShadowMap == 1:
self.shadowMap.setLighting(
self.lighting, Vec3(self.positionX, self.positionY, self.positionZ), self.shadowMapDistance
)
self.shaders.updateWithShadows(self.shadowMap)
else:
self.shaders.update()
def addAnimation(self, _actorName, _animationName):
self.animationAgent.reparentTo(render)
self.animationAgent.setScale(10)
self.realizer.addAnimation(_actorName, _animationName)
for i in range(self.animationAgent.getNumFrames(_animationName)):
self.animationAgent.pose(_animationName, i)
base.graphicsEngine.renderFrame()
self.updateSMRSkeleton(self.agentNodePaths, self.newSkeleton)
self.realizer.addPoseToAnimation(_actorName, _animationName, self.newSkeleton)
self.animationAgent.detachNode()
print "animation", _animationName, "added"
def createSkel(self, _pandaAgent, _smrSkel, _initialJointName, _parentName):
# get the agent's currentJoint
currentPandaJoint = _pandaAgent.getJoints(None, _initialJointName)
currentPandaCJoint = _pandaAgent.controlJoint(None, "modelRoot", _initialJointName)
self.agentControlJoints.append(currentPandaCJoint)
# get the first joint's position
position = currentPandaCJoint.getPos()
if currentPandaJoint[0].getNumChildren() == 0:
newJoint = SMRPy.SMRJoint(True)
newJoint.setEndVect(position.getX(), position.getY(), position.getZ())
else:
newJoint = SMRPy.SMRJoint(False)
rotZ = (currentPandaCJoint.getH() / 180.0) * 3.14159
rotX = (currentPandaCJoint.getP() / 180.0) * 3.14159
rotY = (currentPandaCJoint.getR() / 180.0) * 3.14159
quatZ = SMRPy.SMRQuaternion(SMRPy.SMRVector3(0.0, 0.0, 1.0), rotZ)
quatX = SMRPy.SMRQuaternion(SMRPy.SMRVector3(1.0, 0.0, 0.0), rotX)
quatY = SMRPy.SMRQuaternion(SMRPy.SMRVector3(0.0, 1.0, 0.0), rotY)
quatRot = quatZ.multiply(quatX)
quatRot = quatRot.multiply(quatY)
quatRot.normalize()
newJoint.setPos(position.getX(), position.getY(), position.getZ())
newJoint.setRotQuat(quatRot.getW(), quatRot.getX(), quatRot.getY(), quatRot.getZ())
newJoint.setParentName(_parentName)
newJoint.setName(_initialJointName)
# print _initialJointName, 'numchildren : ', currentPandaJoint[0].getNumChildren()
self.jointList.append(newJoint)
_smrSkel.insertJoint(newJoint)
for i in range(currentPandaJoint[0].getNumChildren()):
childJoint = currentPandaJoint[0].getChild(i)
childName = childJoint.getName()
# print(childName)
self.createSkel(_pandaAgent, _smrSkel, childName, _initialJointName)
def createFKSkel(self, _pandaAgent, _smrSkel, _initialJointName, _parentName):
# get the agent's currentJoint
currentPandaJoint = _pandaAgent.getJoints(None, _initialJointName)
currentPandaJointPath = _pandaAgent.exposeJoint(None, "modelRoot", _initialJointName, "lodRoot", True)
# currentPandaCJoint = _pandaAgent.controlJoint(None, 'modelRoot', _initialJointName)
# if (_parentName == 'root' or _parentName == '' or _parentName == 'Bone.001'):
# currentPandaJointPath = _pandaAgent.exposeJoint(None, 'modelRoot', _initialJointName)
# else:
# print(_parentName)
# currentPandaJointPath = _pandaAgent.exposeJoint(None, _parentName, _initialJointName)
# if (_initialJointName == "lhand"):
# self.rhand = currentPandaJointPath
self.agentNodePaths.append(currentPandaJointPath)
# get the first joint's position
position = currentPandaJointPath.getPos()
if currentPandaJoint[0].getNumChildren() == 0:
newJoint = SMRPy.SMRJoint(True)
newJoint.setEndVect(position.getX(), position.getY(), position.getZ())
else:
newJoint = SMRPy.SMRJoint(False)
quatRot = currentPandaJointPath.getQuat()
newJoint.setPos(position.getX(), position.getY(), position.getZ())
newJoint.setRotQuat(quatRot.getR(), quatRot.getI(), quatRot.getJ(), quatRot.getK())
newJoint.setParentName(_parentName)
newJoint.setName(_initialJointName)
# print _initialJointName, 'numchildren : ', currentPandaJoint[0].getNumChildren()
self.jointFKList.append(newJoint)
_smrSkel.insertJoint(newJoint)
for i in range(currentPandaJoint[0].getNumChildren()):
childJoint = currentPandaJoint[0].getChild(i)
childName = childJoint.getName()
# print(childName)
self.createFKSkel(_pandaAgent, _smrSkel, childName, _initialJointName)
def updatePandaSkeleton(self, agentControlJoints, _smrSkeleton):
# synchronize root joint
SMRJoint = _smrSkeleton.getJoint(0)
PANDAJoint = agentControlJoints[0]
position = SMRJoint.getPos()
# PANDAJoint.setPos(position.X() + 0.65 ,position.Y()-0.35,position.Z() - 1.4);
PANDAJoint.setPos(position.X(), position.Y(), position.Z())
for i in range(_smrSkeleton.getNumjoints()):
SMRJoint = _smrSkeleton.getJoint(i)
PANDAJoint = agentControlJoints[i]
self.synchronize(PANDAJoint, SMRJoint)
def updateSMRSkeleton(self, agentNodePaths, _smrSkeleton):
# synchronize root joint
SMRJoint = _smrSkeleton.getJoint(0)
PANDAJoint = agentNodePaths[0]
position = PANDAJoint.getPos()
SMRJoint.setPos(position.getX(), position.getY(), position.getZ())
for i in range(_smrSkeleton.getNumjoints()):
SMRJoint = _smrSkeleton.getJoint(i)
PANDAJoint = agentNodePaths[i]
self.synchronizePandaToSMR(SMRJoint, PANDAJoint)
def synchronizePandaToSMR(self, _SMRJoint, _PANDAJoint):
pandaQuaternion = _PANDAJoint.getQuat()
x = pandaQuaternion.getI()
y = pandaQuaternion.getJ()
z = pandaQuaternion.getK()
w = pandaQuaternion.getR()
_SMRJoint.setRotQuat(w, x, y, z)
def synchronize(self, _pandaCJoint, _smrJoint):
smrQuaternion = _smrJoint.getRot()
pandaQuaternion = Quat()
pandaQuaternion.setI(smrQuaternion.getX())
pandaQuaternion.setJ(smrQuaternion.getY())
pandaQuaternion.setK(smrQuaternion.getZ())
pandaQuaternion.setR(smrQuaternion.getW())
if not (pandaQuaternion.isNan()):
_pandaCJoint.setQuat(pandaQuaternion)
class Lvl03(DirectObject):
def start(self):
base.disableMouse() #turn off mouse camera control
base.enableParticles()
self.music = loader.loadMusic("models/gamedev/DEC.mp3")
self.music.play()
camera.setPosHpr(Vec3(98,-390,90), Vec3(0,-5,0))
self.ballNum = 10
self.setupStage()
self.loadModels()
self.setupLighting()
self.setupCollisions()
self.setupIntervals()
taskMgr.add(self.ballMovementTask,'ballMoveTask')
self.gameLen = 30
self.player1Weapon = ""
self.player2Weapon = ""
#hud = OnscreenImage(image = 'models/gamedev/lvl2hud.jpg', pos = (0,1,20),scale=5.0)
#hud.reparentTo(render)
globalClock.reset()
self.timer = OnscreenText("%d" % (self.gameLen-globalClock.getRealTime(),), pos = (98,145), scale = 18.0)
self.timer.setColor(1,1,1)
taskMgr.add(self.clockTask,"clockTask")
self.player1Score = 0
self.player2Score = 0
self.nodeCount1 = 0
self.nodeCount2 = 0
self.player1Invincible = 0
self.player2Invincible = 0
self.jNP = self.playerModel.exposeJoint(None,"modelRoot","ikHandle2")
self.jNP2 = self.playerModel2.exposeJoint(None,"modelRoot","ikHandle2")
self.climbing1 = 0
self.climbing2 = 0
self.speed1 = 3.0
self.speed2 = 3.0
self.ignoreColl= 0
self.player1IsColliding = 0
self.player2IsColliding = 0
taskMgr.doMethodLater(self.gameLen, self.endGame,'gameFinished')
#taskMgr.doMethodLater(self.gameLen/2.0,self.changeMusic,'musicSwitch')
#setup key controls
self.accept("escape",sys.exit)
#self.acceptOnce("space",self.drop)
# Player 1 movement
self.acceptOnce("a",self.left)
self.acceptOnce("d",self.right)
self.accept("a-up",self.stopLeft)
self.accept("d-up",self.stopRight)
self.acceptOnce("w", self.jump)
#Player 2 movement keys
#self.accept("l",self.fall2)
self.acceptOnce("k",self.left2)
self.acceptOnce(";",self.right2)
self.accept("k-up",self.stopLeft2)
self.accept(";-up",self.stopRight2)
self.acceptOnce("o", self.jumpT2)
def setupStage(self):
self.ball = []
self.movement = []
for i in range(self.ballNum+1):
z=random.randint(1,2)
if z ==1:
z=-1
else:
z=1
weapBalls.define(self.ball,i,render)
self.movement.append(Vec3(random.random()*z,0,random.random()*z))
#self.movement[i].Vec3(random.randint(1,3),0,random.randint(1,3))
self.background2 = OnscreenImage(image = 'models/gamedev/frozenbg.JPG', pos = (98,10,0),scale=500)
self.background2.detachNode()
self.background = OnscreenImage(image = 'models/gamedev/moltenbg.JPG', pos = (98,10,0),scale=500)
self.background.reparentTo(render)
self.lava = loader.loadModel("models/gamedev/lava")
self.lava.setPosHpr(Vec3(98,0,-18),Vec3(0,5,0))
self.lava.setScale(50)
self.lava.reparentTo(render)
x1= 196
x2 = 0
m1 = 98
m2 = 107.8
len = 9.8
h = 0
a = 0
p = 0
for j in range(4):
if j > 0:
x1Old = x1
x2Old = x2
x1 = 196-(random.randint(0,3)*9.8)
x2 = 0+random.randint(0,3)*9.8
m1=98-(random.randint(0,3)*9.8)
m2= 107.8+random.randint(0,3)*9.8
for count in range(1):
l = random.randint(2,5)
r = random.randint(2,5)
c1 = random.randint(2,5)
c2 = random.randint(2,5)
if l+r < 4:
count = 0
else:
l = 4
r = 4
c1 = 2
c2 = 2
'''
if j ==1 or j == 3:
self.ladder = loader.loadModel("models/gamedev/ladder")
self.ladder.reparentTo(render)
self.ladder.setScale(1.5)
self.ladder.setPos(x2+4.9,0,h-20)
self.ladder2 = loader.loadModel("models/gamedev/ladder")
self.ladder2.reparentTo(render)
self.ladder2.setScale(1.5)
self.ladder2.setPos(x1-4.9,0,h-20)
if j == 2:
self.ladder = loader.loadModel("models/gamedev/ladder")
self.ladder.reparentTo(render)
self.ladder.setScale(1.5)
self.ladder.setPos(m1-4.9,0,h-20)
self.ladder2 = loader.loadModel("models/gamedev/ladder")
self.ladder2.reparentTo(render)
self.ladder2.setScale(1.5)
self.ladder2.setPos(m2+4.9,0,h-20)
'''
self.first = 1
for i in range(r):
'''Right half of stage'''
self.environment = loader.loadModel("models/gamedev/platform")
self.environment.reparentTo(render)
self.environment.setScale(5)
self.environment.setPos(x1,0,h)
if self.first == 1:
self.first = 0
bounds = self.environment.getChild(0).getBounds()
center = bounds.getCenter()
poly1 = Point3(center.getX()+1, center.getY()-.5, center.getZ()+.2)
poly2 = Point3(center.getX()-(2*r-1), center.getY()-.5, center.getZ()+.2)
poly3 = Point3(center.getX()+1, center.getY()+.5, center.getZ()+.2)
poly4 = Point3(center.getX()-(2*r-1), center.getY()+.5, center.getZ()+.2)
cPoly = CollisionPolygon(poly4, poly2, poly1, poly3)
cNode = CollisionNode("platform")
cNode.addSolid(cPoly)
cNodePath = self.environment.attachNewNode(cNode)
cNodePath.show()
x1 = x1 - len
self.first = 1
for i in range(l):
'''Left Half of stage'''
self.environment = loader.loadModel("models/gamedev/platform")
self.environment.reparentTo(render)
self.environment.setScale(5)
self.environment.setPos(x2,0,h)
if self.first == 1:
self.first = 0
bounds = self.environment.getChild(0).getBounds()
center = bounds.getCenter()
poly1 = Point3(center.getX()+(2*l-1), center.getY()-.5, center.getZ()+.2)
poly2 = Point3(center.getX()-1, center.getY()-.5, center.getZ()+.2)
poly3 = Point3(center.getX()+(2*l-1), center.getY()+.5, center.getZ()+.2)
poly4 = Point3(center.getX()-1, center.getY()+.5, center.getZ()+.2)
cPoly = CollisionPolygon(poly4, poly2, poly1, poly3)
cNode = CollisionNode("platform")
cNode.addSolid(cPoly)
cNodePath = self.environment.attachNewNode(cNode)
cNodePath.show()
x2 = x2 + len
self.first = 1
for i in range(c1):
'''Right half of stage'''
self.environment = loader.loadModel("models/gamedev/platform")
self.environment.reparentTo(render)
self.environment.setScale(5)
self.environment.setPos(m1,0,h)
if self.first == 1:
self.first = 0
bounds = self.environment.getChild(0).getBounds()
center = bounds.getCenter()
poly1 = Point3(center.getX()+1, center.getY()-.5, center.getZ()+.2)
poly2 = Point3(center.getX()-(2*c1-1), center.getY()-.5, center.getZ()+.2)
poly3 = Point3(center.getX()+1, center.getY()+.5, center.getZ()+.2)
poly4 = Point3(center.getX()-(2*c1-1), center.getY()+.5, center.getZ()+.2)
cPoly = CollisionPolygon(poly4, poly2, poly1, poly3)
cNode = CollisionNode("platform")
cNode.addSolid(cPoly)
cNodePath = self.environment.attachNewNode(cNode)
cNodePath.show()
m1 = m1 - len
self.first = 1
for i in range(c2):
'''Left Half of stage'''
self.environment = loader.loadModel("models/gamedev/platform")
self.environment.reparentTo(render)
self.environment.setScale(5)
self.environment.setPos(m2,0,h)
if self.first == 1:
self.first = 0
bounds = self.environment.getChild(0).getBounds()
center = bounds.getCenter()
poly1 = Point3(center.getX()+(2*c2-1), center.getY()-.5, center.getZ()+.2)
poly2 = Point3(center.getX()-1, center.getY()-.5, center.getZ()+.2)
poly3 = Point3(center.getX()+(2*c2-1), center.getY()+.5, center.getZ()+.2)
poly4 = Point3(center.getX()-1, center.getY()+.5, center.getZ()+.2)
cPoly = CollisionPolygon(poly4, poly2, poly1, poly3)
cNode = CollisionNode("platform")
cNode.addSolid(cPoly)
cNodePath = self.environment.attachNewNode(cNode)
cNodePath.show()
m2 = m2 + len
h = h+40
a = 0
def loadModels(self):
# ** Load female character that will represent first player** #
self.playerModel = Actor("models/gamedev/redguy-model",{"walk":"models/gamedev/redguy-run"})
self.playerModel.reparentTo(render)
self.playerModel.setScale(.6)
self.playerModel.setH(90)
# ** Position player at center of the field with it lying directly above the field. ** #
self.playerModel.setPos(0,0,1.76)
# ** Load female character that will represent second player** #
self.playerModel2 = Actor("models/gamedev/bluegirl-model",{"walk2":"models/gamedev/bluegirl-run"})
self.playerModel2.reparentTo(render)
self.playerModel2.setScale(.6)
self.playerModel2.setH(0)
# ** Position player at center of the field with it lying directly above the field. ** #
self.playerModel2.setPos(196,0,2.0)
def reset(self):
self.an1.getPhysicsObject().setVelocity(Vec3(0,0,0))
self.an2.getPhysicsObject().setVelocity(Vec3(0,0,0))
self.an1.getPhysicsObject().setPosition(Point3(0,0,11.76))
self.an2.getPhysicsObject().setPosition(Point3(196,0,22.0))
self.playerModel.setH(90)
self.playerModel.detachNode()
self.playerModel.setPos(0,0,1.76)
self.anp.setFluidPos(Point3(0,0,1.76))
self.playerModel.reparentTo(self.anp)
self.playerModel2.setH(0)
self.playerModel2.detachNode()
self.playerModel2.setPos(196,0,22.0)
self.anp2.setFluidPos(Point3(196,0,22.0))
self.playerModel2.reparentTo(self.anp2)
def setupLighting(self):
ambientLight = AmbientLight('ambientLight')
ambientLight.setColor(Vec4(0.55,0.55,0.55,1.0))
ambientLightNP = render.attachNewNode(ambientLight)
render.setLight(ambientLightNP)
dirLight = DirectionalLight('dirLight')
dirLight.setColor(Vec4(0.6,0.6,0.6,1))
dirLightNP = render.attachNewNode(dirLight)
dirLightNP.setHpr(Vec3(0.0,-26.0,0.0))
render.setLight(dirLightNP)
def setupIntervals(self):
self.charWalk1l = self.playerModel.actorInterval("walk")
self.charWalk1l.loop( )
self.charWalk1l.pause( )
self.charWalk1r = self.playerModel.actorInterval("walk")
self.charWalk1r.loop( )
self.charWalk1r.pause( )
self.charWalk2l = self.playerModel2.actorInterval("walk2")
self.charWalk2l.loop( )
self.charWalk2l.pause( )
self.charWalk2r = self.playerModel2.actorInterval("walk2")
self.charWalk2r.loop( )
self.charWalk2r.pause( )
self.jump1 = self.playerModel.actorInterval("jump")
self.jump1.loop()
self.jump1.pause()
self.jump2 = self.playerModel2.actorInterval("jump2")
self.jump2.loop()
self.jump2.pause()
self.climb1 = self.playerModel.actorInterval("climb")
self.climb1.loop()
self.climb1.pause()
self.climb2 = self.playerModel2.actorInterval("climb2")
self.climb2.loop()
self.climb2.pause()
# end setupIntervals
# ############################
# Actual Working movement code
# ############################
def rise(self):
dist = 40
self.playerModel.setH(0)
playerJump = self.playerModel.posInterval(1.0,Vec3(self.playerModel.getX(), self.playerModel.getY(),self.playerModel.getZ()+dist))
playerJump.start()
def rise2(self):
dist = 40
self.playerModel2.setH(90)
playerJump2 = self.playerModel2.posInterval(1.0,Vec3(self.playerModel2.getX(), self.playerModel2.getY(),self.playerModel2.getZ()+dist))
playerJump2.start()
# PLAYER ONE #
def left(self):
taskMgr.add(self.leftTask,'leftTask')
self.charWalk1l.loop()
#end left
def leftTask(self,task):
if self.climbing1 == 0:
self.playerModel.setH(270)
self.playerModel.setPos(Vec3(self.playerModel.getX()-self.speed1, self.playerModel.getY(), self.playerModel.getZ()))
return Task.cont
def right(self):
taskMgr.add(self.rightTask,'rightTask')
self.charWalk1r.loop()
#end right
def rightTask(self,task):
if self.climbing1 == 0:
self.playerModel.setH(90)
self.playerModel.setPos(Vec3(self.playerModel.getX()+self.speed1, self.playerModel.getY(), self.playerModel.getZ()))
return Task.cont
def climbable(self,cEntry):
self.nodeCount1+=1
print self.nodeCount1
self.ignore("w")
self.ignore("w-up")
self.ignore("s")
self.ignore("s-up")
self.acceptOnce("w",self.climb,[1])
self.accept("w-up",self.noClimb)
self.acceptOnce("s",self.climb,[-1])
self.accept("s-up",self.noClimb)
def climb(self,dir):
self.dir1 = dir
self.climbing1 = 1
self.climbSpeed1 = 1
self.ignore("a")
self.ignore("a-up")
self.ignore("d")
self.ignore("d-up")
taskMgr.add(self.climbTask,'climbTask')
self.climb1.loop()
def noClimb(self):
taskMgr.remove('climbTask')
self.climb1.pause()
if self.nodeCount1 == 0:
self.climbing = 0
self.climbSpeed1 = 0
self.acceptOnce("w",self.climb,[1])
self.acceptOnce("s",self.climb,[-1])
def jumpable(self,cEntry):
self.nodeCount1+=-1
print self.nodeCount1
if self.nodeCount1 == 0:
taskMgr.remove('climbTask')
self.ignore("w")
self.ignore("w-up")
self.ignore("s")
self.ignore("s-up")
self.acceptOnce("w",self.jump)
self.acceptOnce("a",self.left)
self.acceptOnce("d",self.right)
self.accept("a-up",self.stopLeft)
self.accept("d-up",self.stopRight)
self.climbing1 = 0
self.climbSpeed1 = 0
self.climb1.pause()
def walkable(self,cEntry):
self.ignore("w")
self.ignore("w-up")
self.ignore("s")
self.ignore("s-up")
self.acceptOnce("w",self.climb,[1])
self.accept("w-up",self.noClimb)
self.acceptOnce("s",self.climb,[-1])
self.accept("s-up",self.noClimb)
self.acceptOnce("a",self.left)
self.acceptOnce("d",self.right)
self.accept("a-up",self.stopLeft)
self.accept("d-up",self.stopRight)
self.climbing1 = 0
self.climbSpeed1 = 0
self.climb1.pause()
def climbTask(self,task):
if self.playerModel.getZ() >=0:
self.playerModel.setH(0)
self.playerModel.setPos(Vec3(self.playerModel.getX(), self.playerModel.getY(), self.playerModel.getZ()+self.climbSpeed1*self.dir1))
return Task.cont
def jump(self):
if self.nodeCount1 == 0:
self.ignore("w")
self.ignore("w-up")
z = self.playerModel.getZ()
j = ProjectileInterval(self.playerModel, startPos = self.playerModel.getPos(), startVel = Point3(5,0,30), duration = 2.0)
j.start()
taskMgr.doMethodLater(2,self.jumpTask,"jumpTask")
else:
self.acceptOnce("w",self.climb,[1])
def jumpTask(self, task):
if self.climbing1 == 0:
self.jump1.pause()
self.acceptOnce("w",self.jump)
#return task.cont
def allowRight(self):
self.acceptOnce("d",self.right)
def noRight(self):
taskMgr.remove('rightTask')
self.charWalk1r.pause()
self.acceptOnce("d",self.right)
def stopRight(self):
self.noRight()
#self.allowRight()
def rightWall(self,cEntry):
self.ignore("d")
self.noRight()
def rightEdge(self,cEntry):
self.ignore("d")
self.noRight()
def rightOK(self,cEntry):
self.allowRight()
def allowLeft(self):
self.acceptOnce("a",self.left)
def noLeft(self):
taskMgr.remove('leftTask')
self.charWalk1l.pause()
self.acceptOnce("a",self.left)
def stopLeft(self):
self.noLeft()
#self.allowLeft()
def leftWall(self,cEntry):
self.ignore("a")
self.noLeft()
def leftEdge(self,cEntry):
self.ignore("a")
self.noLeft()
def leftOK(self,cEntry):
self.allowLeft()
# PLAYERTWO #
def left2(self):
taskMgr.add(self.leftTask2,'leftTask2')
self.charWalk2l.loop()
#end left
def leftTask2(self,task):
if self.climbing2 == 0:
self.playerModel2.setH(0)
self.playerModel2.setPos(Vec3(self.playerModel2.getX()-self.speed2, self.playerModel2.getY(), self.playerModel2.getZ()))
return Task.cont
def right2(self):
taskMgr.add(self.rightTask2,'rightTask2')
self.charWalk2r.loop()
#end right
def rightTask2(self,task):
if self.climbing2 == 0:
self.playerModel2.setH(180)
self.playerModel2.setPos(Vec3(self.playerModel2.getX()+self.speed2, self.playerModel2.getY(), self.playerModel2.getZ()))
return Task.cont
def climbable2(self,cEntry):
self.nodeCount2+=1
#print self.nodeCount1
self.ignore("o")
self.ignore("o-up")
self.ignore("l")
self.ignore("l-up")
self.acceptOnce("o",self.climbT2,[1])
self.accept("o-up",self.noClimb2)
self.acceptOnce("l",self.climbT2,[-1])
self.accept("l-up",self.noClimb2)
def climbT2(self,dir):
self.dir2 = dir
self.climbing2 = 1
self.climbSpeed2 = 1
self.ignore("k")
self.ignore("k-up")
self.ignore(";")
self.ignore(";-up")
taskMgr.add(self.climbTask2,'climbTask2')
self.climb2.loop()
def noClimb2(self):
taskMgr.remove('climbTask2')
self.climb2.pause()
if self.nodeCount2 == 0:
self.climbing2 = 0
self.climbSpeed2 = 0
self.acceptOnce("o",self.climbT2,[1])
self.acceptOnce("l",self.climbT2,[-1])
def jumpable2(self,cEntry):
self.nodeCount2+=-1
#print self.nodeCount2
if self.nodeCount2 == 0:
taskMgr.remove('climbTask2')
self.ignore("o")
self.ignore("o-up")
self.ignore("l")
self.ignore("l-up")
self.acceptOnce("o",self.jumpT2)
self.acceptOnce("k",self.left2)
self.acceptOnce(";",self.right2)
self.accept("k-up",self.stopLeft2)
self.accept(";-up",self.stopRight2)
self.climbing2 = 0
self.climbSpeed2 = 0
self.climb2.pause()
def walkable2(self,cEntry):
self.ignore("o")
self.ignore("o-up")
self.ignore("l")
self.ignore("l-up")
self.acceptOnce("o",self.climbT2,[1])
self.accept("o-up",self.noClimb2)
self.acceptOnce("l",self.climbT2,[-1])
self.accept("l-up",self.noClimb2)
self.acceptOnce("k",self.left2)
self.acceptOnce(";",self.right2)
self.accept("k-up",self.stopLeft)
self.accept(";-up",self.stopRight)
self.climbing2 = 0
self.climbSpeed2 = 0
self.climb2.pause()
def climbTask2(self,task):
if self.playerModel2.getZ() >=0:
self.playerModel2.setH(90)
self.playerModel2.setPos(Vec3(self.playerModel2.getX(), self.playerModel2.getY(), self.playerModel2.getZ()+self.climbSpeed2*self.dir2))
return Task.cont
def jumpT2(self):
if self.nodeCount2 == 0:
self.ignore("o")
self.ignore("o-up")
z = self.playerModel2.getZ()
j = ProjectileInterval(self.playerModel2, startPos = self.playerModel2.getPos(), startVel = Point3(3,0,30), duration = 2.0)
j.start()
taskMgr.doMethodLater(3,self.jumpTask2,"jumpTask2")
else:
self.acceptOnce("w",self.climb,[1])
def jumpTask2(self, task):
if self.climbing2 == 0:
self.jump2.pause()
self.acceptOnce("o",self.jumpT2)
#return task.cont
def allowRight2(self):
self.acceptOnce(";",self.right2)
def noRight2(self):
taskMgr.remove('rightTask2')
self.charWalk2r.pause()
self.acceptOnce(";",self.right2)
def stopRight2(self):
self.noRight2()
#self.allowRight()
def rightWall2(self,cEntry):
self.ignore(";")
self.noRight2()
def rightEdge2(self,cEntry):
self.ignore(";")
self.noRight2()
def rightOK2(self,cEntry):
self.allowRight2()
def allowLeft2(self):
self.acceptOnce("k",self.left2)
def noLeft2(self):
taskMgr.remove('leftTask2')
self.charWalk2l.pause()
self.acceptOnce("k",self.left2)
def stopLeft2(self):
self.noLeft2()
#self.allowLeft()
def leftWall2(self,cEntry):
self.ignore("k")
self.noLeft2()
def leftEdge2(self,cEntry):
self.ignore("k")
self.noLeft2()
def leftOK2(self,cEntry):
self.allowLeft2()
def setupCollisions(self):
self.cHandler = PhysicsCollisionHandler()
#self.cHandler.setInPattern("ate-%in")
self.cHandler.addInPattern('%fn-into-%in')
#self.cHandler2.addInPattern('%fn-into-%in')
self.cHandler.setAgainPattern('%fn-again-%in')
self.cHandler.setOutPattern('%fn-outof-%in')
self.cTrav = CollisionTraverser()
#self.cTrav2 = CollisionTraverser()
base.cTrav = self.cTrav
#Player 1 collision solid
bounds = self.playerModel.getChild(0).getBounds()
center = bounds.getCenter()-Vec3(0,0,12)
radius = bounds.getRadius()-18
boundsB = self.playerModel.getChild(0).getBounds()
centerB = bounds.getCenter()-Vec3(0,0,-4)
radiusB = bounds.getRadius()-20
cSphere = CollisionSphere(center,radius)
cSphereB = CollisionSphere(centerB,radiusB)
cNode = CollisionNode("player1")
#print radius, radiusB
cNode.addSolid(cSphere)
cNode.addSolid(cSphereB)
cNodePath = self.playerModel.attachNewNode(cNode)
cNodePath.show()
Node=NodePath(PandaNode("PhysicsNode"))
Node.reparentTo(render)
self.an1=ActorNode("player1-physics")
self.anp=Node.attachNewNode(self.an1)
base.physicsMgr.attachPhysicalNode(self.an1)
self.playerModel.reparentTo(self.anp)
#self.anp.reparentTo(self.playerModel)
#Player 2 collision solid
bounds2 = self.playerModel2.getChild(0).getBounds()
center2 = bounds2.getCenter()-Vec3(0,0,-4)
radius2 = bounds2.getRadius()-20
cSphere2 = CollisionSphere(center2,radius2)
bounds2B = self.playerModel2.getChild(0).getBounds()
center2B = bounds2B.getCenter()-Vec3(0,0,12)
radius2B = bounds2B.getRadius()-18
cSphere2B = CollisionSphere(center2B,radius2B)
cNode2 = CollisionNode("player2")
#print radius2, radius2B
cNode2.addSolid(cSphere2)
cNode2.addSolid(cSphere2B)
cNodePath2 = self.playerModel2.attachNewNode(cNode2)
cNodePath2.show()
Node2=NodePath(PandaNode("PhysicsNode"))
Node2.reparentTo(render)
self.an2=ActorNode("player2-physics")
self.anp2=Node2.attachNewNode(self.an2)
base.physicsMgr.attachPhysicalNode(self.an2)
self.playerModel2.reparentTo(self.anp2)
#self.anp2.reparentTo(self.playerModel2)
gravityFN=ForceNode('world-forces')
gravityFNP=render.attachNewNode(gravityFN)
gravityForce=LinearVectorForce(0,0,-9.8) #gravity acceleration
gravityFN.addForce(gravityForce)
base.physicsMgr.addLinearForce(gravityForce)
self.an1.getPhysicsObject().setMass(15)
self.an2.getPhysicsObject().setMass(15)
gravityForce.setMassDependent(1)
self.cHandler.addCollider(cNodePath, self.anp)
self.cHandler.addCollider(cNodePath2, self.anp2)
self.cTrav.addCollider(cNodePath,self.cHandler)
self.cTrav.addCollider(cNodePath2,self.cHandler)
self.cTrav.addCollider(cNodePath,self.cHandler)
self.cTrav.addCollider(cNodePath2,self.cHandler)
#self.cTrav.addCollider(cNodePath,self.cHandler2)
#self.cTrav.addCollider(cNodePath2,self.cHandler2)
#self.cTrav2.addCollider(cNodePath,self.cHandler2)
#self.cTrav2.addCollider(cNodePath2,self.cHandler2)
#cHandler2 = CollisionHandlerEvent()
#cHandler2.addInPattern('%fn-into-%in')
#self.cTrav.addCollider(cNodePath1,cHandler2)
#self.cTrav.addCollider(cNodePath2,cHandler2)
for i in range(self.ballNum+1):
boundsB = self.ball[i].getChild(0).getBounds()
centerB = boundsB.getCenter()
radiusB = boundsB.getRadius()*0.65
cSphereB = CollisionSphere(centerB,radiusB)
cNodeB = CollisionNode("ball")
cNodeB.addSolid(cSphereB)
cNodePathB = self.ball[i].attachNewNode(cNodeB)
#self.cTrav.addCollider(cNodePathB,self.cHandler)
#cNodePathB.show()
self.accept("player1-into-ball",self.acquire1)
#self.accept("ball-into-player1",self.acquire1)
self.accept("player2-into-ball",self.acquire2)
#self.accept("ball-into-player2",self.acquire2)
#self.accept( 'player1-into2-platform', self.wall1)
#self.accept( 'player2-into2-platform', self.wall2)
def wall1(self,cEntry):
self.an1.getPhysicsObject().setVelocity(Vec3(0,0,0))
def wall2(self,cEntry):
self.an2.getPhysicsObject().setVelocity(Vec3(0,0,0))
def player1Wins(self,cEntry):
if self.player2Invincible == 0:
self.player1Score+=10
self.reset()
def player2Wins(self,cEntry):
if self.player1Invincible == 0:
self.player2Score+=10
self.reset()
def acquire1(self,cEntry):
self.playerModel.setY(0)
if str(cEntry.getIntoNodePath().getParent()) == "render/sawball":
self.player1Weapon = "saw"
saw = loader.loadModel("models/gamedev/saw")
saw.setScale(2.5)
self.jNP.getChildren().detach()
saw.reparentTo(self.jNP)
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/moltovball":
self.player1Weapon = "molotov"
molo = loader.loadModel("models/gamedev/moltov")
molo.setScale(2.5)
#self.jNP = self.playerModel.exposeJoint(None,"modelRoot","ikHandle2")
self.jNP.getChildren().detach()
molo.reparentTo(self.jNP)
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/grenadeball":
self.player1Weapon = "grenade"
gren = loader.loadModel("models/gamedev/grenade")
gren.setScale(2.5)
#self.jNP = self.playerModel.exposeJoint(None,"modelRoot","ikHandle2")
self.jNP.getChildren().detach()
gren.reparentTo(self.jNP)
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/pogo": #done
self.jNP.getChildren().detach()
self.player1Weapon = "jump"
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/golden": #done
self.jNP.getChildren().detach()
self.player1Weapon = "speedUp"
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/crystalball":
self.jNP.getChildren().detach()
self.player1Weapon = "icestage"
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/fireball": #done
self.jNP.getChildren().detach()
self.player1Weapon = "meteo"
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/blackball": #done
self.jNP.getChildren().detach()
self.player1Weapon = "blind"
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/translucent":
self.jNP.getChildren().detach()
self.player1Weapon = "invis"
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/superball": #done
self.jNP.getChildren().detach()
self.player1Weapon = "invincible"
self.acceptOnce("e",self.useWeapon1)
self.acceptOnce("q",self.useWeapon1)
elif str(cEntry.getIntoNodePath().getParent()) == "render/death": #done
self.jNP.getChildren().detach()
if self.player1Invincible == 0:
self.player2Deaths+= 1
self.reset()
cEntry.getIntoNodePath().getParent().removeNode()
#Drop a New Ball
self.ballNum+=1
z=random.randint(1,2)
if z ==1:
z=-1
else:
z=1
self.movement.append(Vec3(random.random()*z,0,random.random()*z))
weapBalls.define(self.ball,self.ballNum,render)
boundsB = self.ball[self.ballNum].getChild(0).getBounds()
centerB = boundsB.getCenter()
radiusB = boundsB.getRadius()*.65
cSphereB = CollisionSphere(centerB,radiusB)
cNodeB = CollisionNode("ball")
cNodeB.addSolid(cSphereB)
cNodePathB = self.ball[self.ballNum].attachNewNode(cNodeB)
def acquire2(self,cEntry):
if str(cEntry.getIntoNodePath().getParent()) == "render/sawball":
self.player2Weapon = "saw"
saw = loader.loadModel("models/gamedev/saw")
saw.setScale(2.5)
self.jNP2.getChildren().detach()
saw.reparentTo(self.jNP2)
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/moltovball":
self.player2Weapon = "molotov"
molo = loader.loadModel("models/gamedev/moltov")
molo.setScale(2.5)
#self.jNP = self.playerModel.exposeJoint(None,"modelRoot","ikHandle2")
self.jNP.getChildren().detach()
molo.reparentTo(self.jNP)
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/grenadeball":
self.player2Weapon = "grenade"
gren = loader.loadModel("models/gamedev/grenade")
gren.setScale(2.5)
#self.jNP = self.playerModel.exposeJoint(None,"modelRoot","ikHandle2")
self.jNP.getChildren().detach()
gren.reparentTo(self.jNP)
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/pogo": #done
self.jNP.getChildren().detach()
self.player2Weapon = "jump"
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/golden": #done
self.jNP.getChildren().detach()
self.player2Weapon = "speedUp"
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/crystalball":
self.jNP.getChildren().detach()
self.player2Weapon = "icestage"
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/fireball": #done
self.jNP.getChildren().detach()
self.player2Weapon = "meteo"
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/blackball": #done
self.jNP.getChildren().detach()
self.player2Weapon = "blind"
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/translucent":
self.jNP.getChildren().detach()
self.player2Weapon = "invis"
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/superball": #done
self.jNP.getChildren().detach()
self.player2Weapon = "invincible"
self.acceptOnce("e",self.useWeapon2)
self.acceptOnce("q",self.useWeapon2)
elif str(cEntry.getIntoNodePath().getParent()) == "render/death": #done
self.jNP.getChildren().detach()
if self.player2Invincible == 0:
self.player1Score+=3
self.reset()
cEntry.getIntoNodePath().getParent().removeNode()
#Drop a New Ball
self.ballNum+=1
z=random.randint(1,2)
if z ==1:
z=-1
else:
z=1
self.movement.append(Vec3(random.random()*z,0,random.random()*z))
weapBalls.define(self.ball,self.ballNum,render)
boundsB = self.ball[self.ballNum].getChild(0).getBounds()
centerB = boundsB.getCenter()
radiusB = boundsB.getRadius()*.65
cSphereB = CollisionSphere(centerB,radiusB)
cNodeB = CollisionNode("ball")
cNodeB.addSolid(cSphereB)
cNodePathB = self.ball[self.ballNum].attachNewNode(cNodeB)
def useWeapon1(self):
if self.player1Weapon == "meteo":
fireRain = Sequence(Func(self.rain), Wait(.5), Func(self.rain), Wait(.5), Func(self.rain), Wait(.5),
Func(self.rain), Wait(.5), Func(self.rain), Wait(.5), Func(self.rain), Wait(.5), Func(self.rain), Wait(.5), Func(self.rain))
fireRain.start()
elif self.player1Weapon == "jump":
self.playerModel.detachNode()
self.playerModel.reparentTo(render)
angle = (self.playerModel.getH())*math.pi/180.0
ProjectileInterval(self.playerModel, startPos = Point3(self.playerModel.getPos()),startVel = Point3(math.sin(angle)*30,0,100), duration= 4.0).start()
elif self.player1Weapon == "speedUp":
self.speed1 = 6
taskMgr.doMethodLater(5,self.restoreSpeedBG,"restoreStuff")
elif self.player1Weapon == "blind":
camera.setPos(Vec3(-50,0,0))
taskMgr.doMethodLater(5,self.restoreCamera,"restoreCamera")
elif self.player1Weapon == "invincible":
self.player1Invincible = 1
taskMgr.doMethodLater(5,self.notInvince1,"mortal1")
elif self.player1Weapon == "grenade":
self.jNP.getChildren().detach()
gren = loader.loadModel("models/gamedev/grenade")
gren.setScale(2.5)
gren.reparentTo(render)
angle = (self.playerModel.getH())*math.pi/180.0
ProjectileInterval(gren, startPos = Point3(self.playerModel.getPos()),startVel = Point3(math.sin(angle)*30,0,10), endZ = -50).start()
if gren.getZ() == -50:
gren.removeNode()
cHandler = CollisionHandlerEvent()
cHandler.addInPattern('%fn-into-%in')
boundsB = gren.getChild(0).getBounds()
centerB = boundsB.getCenter()
radiusB = boundsB.getRadius()*0.65
cSphereB = CollisionSphere(centerB,radiusB)
cNodeB = CollisionNode("grenade")
cNodeB.addSolid(cSphereB)
cNodePathB = gren.attachNewNode(cNodeB)
self.cTrav.addCollider(cNodePathB,cHandler)
self.acceptOnce("grenade-into-platform",self.explode)
elif self.player1Weapon == "molotov":
self.jNP.getChildren().detach()
elif self.player1Weapon == "saw":
self.jNP.getChildren().detach()
elif self.player1Weapon == "invis":
self.jNP.getChildren().detach()
self.playerModel2.hide()
taskMgr.doMethodLater(4.0,self.showPlayer,"showPlayer")
elif self.player1Weapon == "icestage":
self.jNP.getChildren().detach()
self.speed1 = 6
self.speed2 = 6
self.background.detachNode()
self.background2.reparentTo(render)
taskMgr.doMethodLater(5,self.restoreSpeedBG,"restoreStuff")
def restoreSpeedBG(self,task):
self.speed1 = 3
self.speed2 = 3
self.background2.detachNode()
self.background.reparentTo(render)
def showPlayer(self,task):
self.playerModel.show()
self.playerModel2.show()
def useWeapon2(self):
if self.player2Weapon == "meteo":
fireRain = Sequence(Func(self.rain), Wait(.5), Func(self.rain), Wait(.5), Func(self.rain), Wait(.5),
Func(self.rain), Wait(.5), Func(self.rain), Wait(.5), Func(self.rain), Wait(.5), Func(self.rain), Wait(.5), Func(self.rain))
fireRain.start()
elif self.player2Weapon == "jump":
angle = self.playerModel2.getH()/90
ProjectileInterval(self.playerModel2, startPos = Point3(self.playerModel2.getPos()),startVel = Point3(angle*30,0,100), endZ = self.playerModel2.getZ()).start()
elif self.player2Weapon == "speedUp":
self.speed2 = 6
elif self.player2Weapon == "blind":
camera.setPos(Vec3(-50,0,0))
taskMgr.doMethodLater(5,self.restoreCamera,"restoreCamera")
elif self.player2Weapon == "invincible":
self.player2Invincible = 1
taskMgr.doMethodLater(5,self.notInvince2,"mortal2")
elif self.player2Weapon == "grenade":
self.jNP2.getChildren().detach()
gren = loader.loadModel("models/gamedev/grenade")
gren.setScale(2.5)
gren.reparentTo(render)
angle = (self.playerModel2.getH())*math.pi/180.0
ProjectileInterval(gren, startPos = Point3(self.playerModel2.getPos()),startVel = Point3(math.sin(angle)*30,0,10), endZ = -50).start()
if gren.getZ() == -50:
gren.removeNode()
cHandler = CollisionHandlerEvent()
cHandler.addInPattern('%fn-into-%in')
boundsB = gren.getChild(0).getBounds()
centerB = boundsB.getCenter()
radiusB = boundsB.getRadius()*0.65
cSphereB = CollisionSphere(centerB,radiusB)
cNodeB = CollisionNode("grenade")
cNodeB.addSolid(cSphereB)
cNodePathB = gren.attachNewNode(cNodeB)
self.cTrav.addCollider(cNodePathB,cHandler)
self.acceptOnce("grenade-into-platform",self.explode)
elif self.player2Weapon == "molotov":
self.jNP.getChildren().detach()
elif self.player2Weapon == "saw":
self.jNP.getChildren().detach()
elif self.player2Weapon == "invis":
self.jNP.getChildren().detach()
self.playerModel1.hide()
taskMgr.doMethodLater(4.0,self.showPlayer,"showPlayer")
elif self.player2Weapon == "icestage":
self.jNP2.getChildren().detach()
self.speed1 = 6
self.speed2 = 6
self.background.detachNode()
self.background2.reparentTo(render)
taskMgr.doMethodLater(5,self.restoreSpeedBG,"restoreStuff")
def rain(self):
meteoBall = Actor("models/gamedev/fireball")
meteoBall.reparentTo(render)
meteoBall.setScale(2)
meteoBall.setH(-15)
boundsB = meteoBall.getChild(0).getBounds()
centerB = boundsB.getCenter()
radiusB = boundsB.getRadius()*0.65
cSphereB = CollisionSphere(centerB,radiusB)
cNodeB = CollisionNode("meteor")
cNodeB.addSolid(cSphereB)
cNodePathB = meteoBall.attachNewNode(cNodeB)
#cNodePathB.show()
ProjectileInterval(meteoBall, startPos = Point3(random.randint(15,211),0,170),startVel = Point3(-12,0,0), endZ = -50).start()
cHandler = CollisionHandlerEvent()
cHandler.addInPattern('%fn-into-%in')
self.cTrav.addCollider(cNodePathB,cHandler)
self.accept("meteor-into-player1",self.player2Wins)
self.accept("meteor-into-player2",self.player1Wins)
def showBalls(self,task):
for i in self.ball:
i.show()
def notInvince1(self,task):
self.player1Invincible = 0
def notInvince2(self,task):
self.player2Invincible = 0
def restoreCamera(self,task):
camera.setPosHpr(Vec3(98,-390,90), Vec3(0,-5,0))
def switch(self,task):
self.environment.setColor(0,1,0.3)
def colliding1( self, collEntry ): # accept a collision entry argument
if self.ignoreColl == 0:
self.player1IsColliding = 1 # we are colliding
self.stopWalk( ) # pause all walking animation and movement
disp = ( collEntry.getSurfacePoint( render ) - collEntry.getInteriorPoint( render ) )
newPos = self.playerModel2.getPos( ) + disp # get new position
self.playerModel2.setPos( newPos ) # and set it to tiny's position
# end colliding
def notColliding1( self, collEntry ):
self.player1IsColliding = 0
def colliding2( self, collEntry ): # accept a collision entry argument
if self.ignoreColl == 0:
self.player2IsColliding = 1 # we are colliding
self.stopWalk2( ) # pause all walking animation and movement
disp = ( collEntry.getSurfacePoint( render ) - collEntry.getInteriorPoint( render ) )
newPos = self.playerModel2B.getPos( ) + disp # get new position
self.playerModel2B.setPos( newPos ) # and set it to tiny's position
# end colliding
def notColliding2( self, collEntry ):
self.player2IsColliding = 0
def returnSpeeds(self,task):
self.speed1 = 8.0
self.speed2 = 8.0
self.turnSpeed1 = 80.0
self.turnSpeed2 = 80.0
def returnSpeeds2(self,task):
self.acceptOnce("w",self.walk)
self.acceptOnce("o",self.walk2)
self.speed1 = 8.0
self.speed2 = 8.0
self.turnSpeed1 = 80.0
self.turnSpeed2 = 80.0
def returnSpeeds3(self,task):
self.speed1 = 8.0
self.speed2 = 8.0
self.turnSpeed1 = 80.0
self.turnSpeed2 = 80.0
def changeMusic(self,task):
self.music.stop()
self.music2 = loader.loadMusic("models/gamedev/ADRENALINE.mp3")
self.music2.play()
def clockTask(self,task):
self.timer.detachNode()
self.timer = OnscreenText("%d" % (self.gameLen-globalClock.getRealTime(),), pos = (98,145), scale = 18.0)
self.timer.setColor(1,1,1)
self.timer.reparentTo(render)
return Task.cont
def ballMovementTask(self,task):
self.anp.setY(0)
self.anp2.setY(0)
for i in range(self.ballNum+1):
if i < len(self.ball):
if self.ball[i].getX() > 234 or self.ball[i].getX() < -38 or self.ball[i].getZ() < -10 or self.ball[i].getZ() > 132:
self.ball[i].setPos(self.ball[i].getPos()/1.005)
z=random.randint(1,2)
if z ==1:
z=-1
else:
z=1
self.movement[i]=Vec3(random.random()*z,0,random.random()*z)
else:
self.ball[i].setPos(self.ball[i].getPos()+self.movement[i])
return Task.cont
def fire(self):
self.fire = ParticleEffect()
self.fire.reset()
self.fire.setPos(0.000, 0.000, 0.000)
self.fire.setHpr(0.000, 0.000, 0.000)
self.fire.setScale(10.000, 10.000, 10.000)
p0 = Particles('particles-1')
# Particles parameters
p0.setFactory("PointParticleFactory")
p0.setRenderer("SpriteParticleRenderer")
p0.setEmitter("DiscEmitter")
p0.setPoolSize(1024)
p0.setBirthRate(0.0200)
p0.setLitterSize(10)
p0.setLitterSpread(0)
p0.setSystemLifespan(1200.0000)
p0.setLocalVelocityFlag(1)
p0.setSystemGrowsOlderFlag(0)
# Factory parameters
p0.factory.setLifespanBase(2.0000)
p0.factory.setLifespanSpread(0.0000)
p0.factory.setMassBase(1.0000)
p0.factory.setMassSpread(0.0000)
p0.factory.setTerminalVelocityBase(400.0000)
p0.factory.setTerminalVelocitySpread(0.0000)
# Point factory parameters
# Renderer parameters
p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
p0.renderer.setUserAlpha(0.22)
# Sprite parameters
p0.renderer.addTextureFromFile('models/gamedev/sparkle.png')
p0.renderer.setColor(Vec4(1.00, 1.00, 1.00, 1.00))
p0.renderer.setXScaleFlag(1)
p0.renderer.setYScaleFlag(1)
p0.renderer.setAnimAngleFlag(0)
p0.renderer.setInitialXScale(0.5000)
p0.renderer.setFinalXScale(2.0000)
p0.renderer.setInitialYScale(1.0000)
p0.renderer.setFinalYScale(2.0000)
p0.renderer.setNonanimatedTheta(0.0000)
p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPNOBLEND)
p0.renderer.setAlphaDisable(0)
# Emitter parameters
p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
p0.emitter.setAmplitude(1.0000)
p0.emitter.setAmplitudeSpread(0.0000)
p0.emitter.setOffsetForce(Vec3(0.0000, 0.0000, 3.0000))
p0.emitter.setExplicitLaunchVector(Vec3(1.0000, 0.0000, 0.0000))
p0.emitter.setRadiateOrigin(Point3(0.0000, 0.0000, 0.0000))
# Disc parameters
p0.emitter.setRadius(0.5000)
self.fire.addParticles(p0)
self.fire.setPos(self.playerModel2.getPos())
t = Sequence(Func(self.fire.start, render, render),Wait(20),Func(self.cleanFire))
t.start()
def cleanFire(self):
self.fire.cleanup()
def explode(self,cEntry):
self.explosion = ParticleEffect()
self.explosion.reset()
self.explosion.setPos(cEntry.getIntoNodePath().getParent().getPos())
self.explosion.setHpr(0.000, 0.000, 0.000)
self.explosion.setScale(10.000, 10.000, 10.000)
p0 = Particles('particles-1')
# Particles parameters
p0.setFactory("PointParticleFactory")
p0.setRenderer("LineParticleRenderer")
p0.setEmitter("SphereVolumeEmitter")
p0.setPoolSize(10000)
p0.setBirthRate(0.0500)
p0.setLitterSize(10000)
p0.setLitterSpread(0)
p0.setSystemLifespan(2.0000)
p0.setLocalVelocityFlag(1)
p0.setSystemGrowsOlderFlag(1)
# Factory parameters
p0.factory.setLifespanBase(2.0000)
p0.factory.setLifespanSpread(0.0000)
p0.factory.setMassBase(.5000)
p0.factory.setMassSpread(0.0500)
p0.factory.setTerminalVelocityBase(400.0000)
p0.factory.setTerminalVelocitySpread(0.0000)
# Point factory parameters
# Renderer parameters
p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
p0.renderer.setUserAlpha(1.00)
# Line parameters
p0.renderer.setHeadColor(Vec4(1.00, 0.00, 0.00, 1.00))
p0.renderer.setTailColor(Vec4(1.00, 1.00, 0.00, 1.00))
p0.renderer.setLineScaleFactor(3.00)
# Emitter parameters
p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
p0.emitter.setAmplitude(10.0000)
p0.emitter.setAmplitudeSpread(0.0000)
p0.emitter.setOffsetForce(Vec3(0.0000, 0.0000, -0.4930))
p0.emitter.setExplicitLaunchVector(Vec3(1.0000, 0.0000, 0.0000))
p0.emitter.setRadiateOrigin(Point3(0.0000, 0.0000, 0.0000))
# Sphere Volume parameters
p0.emitter.setRadius(0.5000)
self.explosion.addParticles(p0)
f0 = ForceGroup('gravity')
# Force parameters
self.explosion.addForceGroup(f0)
cHandler = CollisionHandlerEvent()
cHandler.addInPattern('%fn-into-%in')
cSphereB = CollisionSphere(cEntry.getIntoNodePath().getParent().getPos(),1)
cNodeB = CollisionNode("explosion")
cNodeB.addSolid(cSphereB)
cNodePathB = self.explosion.attachNewNode(cNodeB)
self.cTrav.addCollider(cNodePathB,cHandler)
cNodePathB.show()
self.accept("player1-into-explosion",self.player2Wins)
self.accept("player2-into-explosion",self.player1Wins)
#f.reparentTo(self.playerModel)
#self.explosion.setPos(self.playerModel.getPos())
t = Sequence(Func(self.explosion.start, render, render),Wait(2),Func(self.cleanExplo))
t.start()
cEntry.getFromNodePath().getParent().removeNode()
def cleanExplo(self):
self.explosion.cleanup()
def endGame(self,task):
taskMgr.removeTasksMatching('returnSpeedsToNormal')
taskMgr.removeTasksMatching('restoreCamera')
taskMgr.removeTasksMatching('clockTask')
taskMgr.removeTasksMatching('ballMoveTask')
self.music.stop()
self.music3 = loader.loadMusic("models/gamedev/CSTAR.mp3")
self.music3.play()
self.speed1 = 0
self.speed2 = 0
def getScores(self):
return (self.player1Score, self.player2Score)
def getGameLen(self):
return self.gameLen
def stopMusic(self):
self.music3.stop()
def destroy(self):
self.playerModel.detachNode()
self.playerModel2.detachNode()
self.background.destroy()
self.lava.detachNode()
self.ladder.detachNode()
self.ladder2.detachNode()
for i in range(self.ballNum+1):
self.ball[i].detachNode()
def stopMusic(self):
self.music3.stop()
#world = Lvl03()
#world.start()
#run()
class Agent:
def __init__(self, _name):
print "Creating agent " + _name
self.name = _name
def setDataPath(self, _dataPath):
self.dataPath = _dataPath
def setActor(self, _modelFileName, _animationFileNames,
_morphTargetsFileName):
self.modelFileName = _modelFileName
self.animationFileNames = _animationFileNames
self.morphTargetsFileName = _morphTargetsFileName
def setRealizer(self, _realizer):
self.realizer = _realizer
def setTransform(self, x, y, z, rx, ry, rz, scale):
self.agent.setPos(x, y, z)
self.agent.setScale(scale)
self.agent.setHpr(rx, ry, rz)
self.positionX = x
self.positionY = y
self.positionZ = z
def getPosition(self):
return self.agent.getPos()
def init(self):
#load the agent and parent it to the world
#The joints of this agent will reference Panda NodePaths, it will be possible to play animations on it
self.animationAgent = Actor(self.modelFileName,
self.animationFileNames)
self.agent = Actor(self.modelFileName, self.morphTargetsFileName)
maxMorphTargets = {
'MT_Jaw_Open':
self.agent.controlJoint(None, 'modelRoot', 'MT_Jaw_Open'),
'MT_Jaw_L':
self.agent.controlJoint(None, 'modelRoot', 'MT_Jaw_L'),
'MT_Jaw_R':
self.agent.controlJoint(None, 'modelRoot', 'MT_Jaw_R'),
'MT_Jaw_Fwd':
self.agent.controlJoint(None, 'modelRoot', 'MT_Jaw_Fwd'),
'MT_WideL':
self.agent.controlJoint(None, 'modelRoot', 'MT_WideL'),
'MT_WideR':
self.agent.controlJoint(None, 'modelRoot', 'MT_WideR'),
'MT_NarrowL':
self.agent.controlJoint(None, 'modelRoot', 'MT_NarrowL'),
'MT_NarrowR':
self.agent.controlJoint(None, 'modelRoot', 'MT_NarrowR'),
'MT_FrownL':
self.agent.controlJoint(None, 'modelRoot', 'MT_FrownL'),
'MT_FrownR':
self.agent.controlJoint(None, 'modelRoot', 'MT_FrownR'),
'MT_SneerL':
self.agent.controlJoint(None, 'modelRoot', 'MT_SneerL'),
'MT_SneerR':
self.agent.controlJoint(None, 'modelRoot', 'MT_SneerR'),
'MT_SquintL':
self.agent.controlJoint(None, 'modelRoot', 'MT_SquintL'),
'MT_SquintR':
self.agent.controlJoint(None, 'modelRoot', 'MT_SquintR'),
'MT_BrowUpL':
self.agent.controlJoint(None, 'modelRoot', 'MT_BrowUpL'),
'MT_BrowUpR':
self.agent.controlJoint(None, 'modelRoot', 'MT_BrowUpR'),
'MT_BrowDnL':
self.agent.controlJoint(None, 'modelRoot', 'MT_BrowDnL'),
'MT_BrowDnR':
self.agent.controlJoint(None, 'modelRoot', 'MT_BrowDnR'),
'MT_MBrowUp':
self.agent.controlJoint(None, 'modelRoot', 'MT_MBrowUp'),
'MT_BrowDnR':
self.agent.controlJoint(None, 'modelRoot', 'MT_BrowDnR'),
'MT_BrowDnL':
self.agent.controlJoint(None, 'modelRoot', 'MT_BrowDnL'),
'MT_MBrowDn':
self.agent.controlJoint(None, 'modelRoot', 'MT_MBrowDn'),
'MT_BrowSqueeze':
self.agent.controlJoint(None, 'modelRoot', 'MT_BrowSqueeze'),
'MT_MouthL':
self.agent.controlJoint(None, 'modelRoot', 'MT_MouthL'),
'MT_MouthR':
self.agent.controlJoint(None, 'modelRoot', 'MT_MouthR'),
'MT_UprLipUpL':
self.agent.controlJoint(None, 'modelRoot', 'MT_UprLipUpL'),
'MT_UprLipUpR':
self.agent.controlJoint(None, 'modelRoot', 'MT_UprLipUpR'),
'MT_UprLipDnL':
self.agent.controlJoint(None, 'modelRoot', 'MT_UprLipDnL'),
'MT_UprLipDnR':
self.agent.controlJoint(None, 'modelRoot', 'MT_UprLipDnR'),
'MT_LwrLipUpL':
self.agent.controlJoint(None, 'modelRoot', 'MT_LwrLipUpL'),
'MT_LwrLipUpR':
self.agent.controlJoint(None, 'modelRoot', 'MT_LwrLipUpR'),
'MT_LwrLipDnL':
self.agent.controlJoint(None, 'modelRoot', 'MT_LwrLipDnL'),
'MT_LwrLipDnR':
self.agent.controlJoint(None, 'modelRoot', 'MT_LwrLipDnR'),
'MT_BlowCheeksL':
self.agent.controlJoint(None, 'modelRoot', 'MT_BlowCheeksL'),
'MT_BlowCheeksR':
self.agent.controlJoint(None, 'modelRoot', 'MT_BlowCheeksR'),
'MT_TongueOut':
self.agent.controlJoint(None, 'modelRoot', 'MT_TongueOut'),
'MT_TongueUp':
self.agent.controlJoint(None, 'modelRoot', 'MT_TongueUp'),
'MT_TongueTipUp':
self.agent.controlJoint(None, 'modelRoot', 'MT_TongueTipUp'),
'MT_TongueL':
self.agent.controlJoint(None, 'modelRoot', 'MT_TongueL'),
'MT_TongueR':
self.agent.controlJoint(None, 'modelRoot', 'MT_TongueR'),
'MT_Blink_L':
self.agent.controlJoint(None, 'modelRoot', 'MT_Blink_L'),
'MT_Blink_R':
self.agent.controlJoint(None, 'modelRoot', 'MT_Blink_R')
}
self.targets = { #'Basis':[],
'ExpSmileClosed': {
maxMorphTargets['MT_WideR']: 1.0,
maxMorphTargets['MT_WideL']: 1.0
},
'ExpAnger': {
maxMorphTargets['MT_Jaw_Open']: -0.07,
maxMorphTargets['MT_Jaw_Fwd']: 0.25,
maxMorphTargets['MT_NarrowL']: 0.30,
maxMorphTargets['MT_NarrowR']: 0.30,
maxMorphTargets['MT_SquintL']: 0.60,
maxMorphTargets['MT_SquintR']: 0.60,
maxMorphTargets['MT_MBrowDn']: 1.0,
maxMorphTargets['MT_BrowDnL']: 0.7,
maxMorphTargets['MT_BrowDnR']: 0.7,
maxMorphTargets['MT_SneerL']: 0.8,
maxMorphTargets['MT_SneerR']: 0.8,
maxMorphTargets['MT_FrownL']: 0.2,
maxMorphTargets['MT_FrownR']: 0.2,
maxMorphTargets['MT_UprLipDnL']: 0.45,
maxMorphTargets['MT_UprLipDnR']: 0.45,
maxMorphTargets['MT_LwrLipUpL']: 1.0,
maxMorphTargets['MT_LwrLipUpR']: 1.0
},
'ExpDisgust': {
maxMorphTargets['MT_WideL']: 0.25,
maxMorphTargets['MT_WideR']: 0.15,
maxMorphTargets['MT_SquintL']: 0.40,
maxMorphTargets['MT_SquintR']: 0.40,
maxMorphTargets['MT_MBrowDn']: 0.25,
maxMorphTargets['MT_BrowSqueeze']: 0.45,
maxMorphTargets['MT_WideL']: 0.25,
maxMorphTargets['MT_BrowDnL']: 0.50,
maxMorphTargets['MT_BrowDnR']: 0.50,
maxMorphTargets['MT_SneerL']: 2.0,
maxMorphTargets['MT_SneerR']: 2.0,
maxMorphTargets['MT_FrownL']: 0.25,
maxMorphTargets['MT_FrownR']: 0.25,
maxMorphTargets['MT_UprLipUpL']: 0.66,
maxMorphTargets['MT_UprLipUpR']: 0.33,
maxMorphTargets['MT_LwrLipUpL']: 0.40,
maxMorphTargets['MT_LwrLipUpR']: 0.40
},
'ExpFear': {
maxMorphTargets['MT_Jaw_Open']: 0.15,
maxMorphTargets['MT_Jaw_Fwd']: -0.3,
maxMorphTargets['MT_NarrowL']: 0.24,
maxMorphTargets['MT_NarrowR']: 0.24,
maxMorphTargets['MT_SquintL']: -0.4,
maxMorphTargets['MT_SquintR']: -0.4,
maxMorphTargets['MT_BrowUpL']: 0.36,
maxMorphTargets['MT_BrowUpR']: 0.36,
maxMorphTargets['MT_MBrowUp']: 1.30,
maxMorphTargets['MT_BrowSqueeze']: 0.40,
maxMorphTargets['MT_FrownL']: 0.35,
maxMorphTargets['MT_FrownR']: 0.35,
maxMorphTargets['MT_UprLipDnL']: 0.25,
maxMorphTargets['MT_UprLipDnR']: 0.25,
maxMorphTargets['MT_LwrLipUpL']: 0.35,
maxMorphTargets['MT_LwrLipUpR']: 0.35
},
'ExpSad': {
maxMorphTargets['MT_NarrowL']: 0.20,
maxMorphTargets['MT_NarrowR']: 0.20,
maxMorphTargets['MT_SquintL']: 0.20,
maxMorphTargets['MT_SquintR']: 0.20,
maxMorphTargets['MT_MBrowUp']: 0.40,
maxMorphTargets['MT_BrowSqueeze']: 0.66,
maxMorphTargets['MT_BrowDnL']: 0.66,
maxMorphTargets['MT_BrowDnR']: 0.66,
maxMorphTargets['MT_BlowCheeksL']: -0.25,
maxMorphTargets['MT_BlowCheeksR']: -0.25,
maxMorphTargets['MT_FrownL']: 0.66,
maxMorphTargets['MT_FrownR']: 0.66,
maxMorphTargets['MT_UprLipDnL']: 0.50,
maxMorphTargets['MT_UprLipDnR']: 0.50,
maxMorphTargets['MT_LwrLipUpL']: 0.66,
maxMorphTargets['MT_LwrLipUpR']: 0.66
},
'ExpSurprise': {
maxMorphTargets['MT_Jaw_Open']: 0.25,
maxMorphTargets['MT_NarrowL']: 0.24,
maxMorphTargets['MT_NarrowR']: 0.24,
maxMorphTargets['MT_SquintL']: -0.20,
maxMorphTargets['MT_SquintR']: -0.20,
maxMorphTargets['MT_BrowUpL']: 0.92,
maxMorphTargets['MT_BrowUpR']: 0.92,
maxMorphTargets['MT_MBrowUp']: 0.66
},
'ExpSmileOpen': {
maxMorphTargets['MT_Jaw_Open']: 0.16,
maxMorphTargets['MT_WideL']: 0.740,
maxMorphTargets['MT_WideR']: 0.740,
maxMorphTargets['MT_SneerL']: 0.280,
maxMorphTargets['MT_SneerR']: 0.280,
maxMorphTargets['MT_BrowUpL']: 0.360,
maxMorphTargets['MT_BrowUpR']: 0.360
},
'ExpHappy': {
maxMorphTargets['MT_Jaw_Open']: 0.22,
maxMorphTargets['MT_WideL']: 0.75,
maxMorphTargets['MT_WideR']: 0.75,
maxMorphTargets['MT_SquintL']: 0.35,
maxMorphTargets['MT_SquintR']: 0.35,
maxMorphTargets['MT_BrowDnL']: 0.08,
maxMorphTargets['MT_BrowDnR']: 0.08,
maxMorphTargets['MT_UprLipUpL']: 0.15,
maxMorphTargets['MT_UprLipUpR']: 0.15,
maxMorphTargets['MT_LwrLipUpL']: 0.15,
maxMorphTargets['MT_LwrLipUpR']: 0.15,
maxMorphTargets['MT_BrowUpL']: 0.360,
maxMorphTargets['MT_BrowUpR']: 0.360
},
'ModBlinkLeft': {
maxMorphTargets['MT_Blink_L']: 1.0
},
'ModBlinkRight': {
maxMorphTargets['MT_Blink_R']: 1.0
},
'ModBrowDownLeft': {
maxMorphTargets['MT_BrowDnL']: 1.0
},
'ModBrowDownRight': {
maxMorphTargets['MT_BrowDnR']: 1.0
},
'ModBrowInRight': {
maxMorphTargets['MT_BrowSqueeze']: 1.0
},
'ModBrowInLeft': {
maxMorphTargets['MT_BrowSqueeze']: 1.0
},
'ModBrowUpLeft': {
maxMorphTargets['MT_BrowUpL']: 1.0
},
'ModBrowUpRight': {
maxMorphTargets['MT_BrowUpR']: 1.0
},
#'ModEarsOut':[],
'ModEyeSquintLeft': {
maxMorphTargets['MT_SquintL']: 1.0
},
'ModEyeSquintRight': {
maxMorphTargets['MT_SquintR']: 1.0
},
'Phonaah': {
maxMorphTargets['MT_Jaw_Open']: 1.0
},
'PhonB,M,P': {
maxMorphTargets['MT_WideL']: 0.5,
maxMorphTargets['MT_WideR']: 0.5
},
'Phonbigaah': {
maxMorphTargets['MT_Jaw_Open']: 1.0
},
'Phonch,J,sh': {
maxMorphTargets['MT_WideL']: 0.5,
maxMorphTargets['MT_WideR']: 0.5
},
'PhonD,S,T': {
maxMorphTargets['MT_WideL']: 0.5,
maxMorphTargets['MT_WideR']: 0.5,
maxMorphTargets['MT_Jaw_Open']: 0.2
},
'Phonee': {
maxMorphTargets['MT_WideL']: 0.5,
maxMorphTargets['MT_WideR']: 0.5
},
'Phoneh': {
maxMorphTargets['MT_WideL']: 0.5,
maxMorphTargets['MT_WideR']: 0.5,
maxMorphTargets['MT_Jaw_Open']: 0.2
},
'PhonF,V': {
maxMorphTargets['MT_WideL']: 0.2,
maxMorphTargets['MT_WideR']: 0.2,
maxMorphTargets['MT_Jaw_Open']: 0.3,
maxMorphTargets['MT_UprLipDnL']: 0.3,
maxMorphTargets['MT_UprLipDnR']: 0.3
},
'Phoni': {
maxMorphTargets['MT_WideL']: 0.2,
maxMorphTargets['MT_WideR']: 0.2,
maxMorphTargets['MT_Jaw_Open']: 0.3
},
'PhonK': {
maxMorphTargets['MT_Jaw_Open']: 0.4
},
'PhonN': {
maxMorphTargets['MT_WideL']: 0.5,
maxMorphTargets['MT_WideR']: 0.5
},
'Phonoh': {
maxMorphTargets['MT_Jaw_Open']: 0.4,
maxMorphTargets['MT_NarrowL']: 0.55,
maxMorphTargets['MT_NarrowR']: 0.55
},
'Phonooh,Q': {
maxMorphTargets['MT_Jaw_Open']: 0.4,
maxMorphTargets['MT_NarrowL']: 0.55,
maxMorphTargets['MT_NarrowR']: 0.55
},
'PhonR': {
maxMorphTargets['MT_WideL']: 0.5,
maxMorphTargets['MT_WideR']: 0.5,
maxMorphTargets['MT_Jaw_Open']: 0.2
},
'Phonth': {
maxMorphTargets['MT_WideL']: 0.5,
maxMorphTargets['MT_WideR']: 0.5,
maxMorphTargets['MT_Jaw_Open']: 0.2
},
'PhonW': {
maxMorphTargets['MT_Jaw_Open']: 0.3,
maxMorphTargets['MT_NarrowL']: 0.7,
maxMorphTargets['MT_NarrowR']: 0.7
},
'AU26_MT_Jaw_Open': {
maxMorphTargets['MT_Jaw_Open']: 1.0
},
'AU30_MT_Jaw_L': {
maxMorphTargets['MT_Jaw_L']: 1.0
},
'AU30_MT_Jaw_R': {
maxMorphTargets['MT_Jaw_R']: 1.0
},
'AU31_MT_Jaw_Fwd': {
maxMorphTargets['MT_Jaw_Fwd']: 1.0
},
'AU27_MT_WideL': {
maxMorphTargets['MT_WideL']: 1.0
},
'AU27_MT_WideR': {
maxMorphTargets['MT_WideR']: 1.0
},
'AU18_MT_NarrowL': {
maxMorphTargets['MT_NarrowL']: 1.0
},
'AU18_MT_NarrowR': {
maxMorphTargets['MT_NarrowL']: 1.0
},
'AU42_MT_FrownL': {
maxMorphTargets['MT_FrownL']: 1.0
},
'AU42_MT_FrownR': {
maxMorphTargets['MT_FrownR']: 1.0
},
'AU9_MT_SneerL': {
maxMorphTargets['MT_SneerL']: 1.0
},
'AU9_MT_SneerR': {
maxMorphTargets['MT_SneerR']: 1.0
},
'AU46_MT_SquintL': {
maxMorphTargets['MT_SquintL']: 1.0
},
'AU46_MT_SquintR': {
maxMorphTargets['MT_SquintR']: 1.0
},
'AU2_MT_BrowUpL': {
maxMorphTargets['MT_BrowUpL']: 1.0
},
'AU2_MT_BrowUpR': {
maxMorphTargets['MT_BrowUpR']: 1.0
},
'AU4_MT_BrowDnL': {
maxMorphTargets['MT_BrowDnL']: 1.0
},
'AU4_MT_BrowDnR': {
maxMorphTargets['MT_BrowDnR']: 1.0
},
'AU4_MT_MBrowUp': {
maxMorphTargets['MT_MBrowUp']: 1.0
},
'AU1_MT_BrowDnR': {
maxMorphTargets['MT_BrowDnR']: 1.0
},
'AU1_MT_BrowDnL': {
maxMorphTargets['MT_BrowDnL']: 1.0
},
'AU1_MT_MBrowDn': {
maxMorphTargets['MT_MBrowDn']: 1.0
},
'AU44_MT_BrowSqueeze': {
maxMorphTargets['MT_BrowSqueeze']: 1.0
},
'AU12_MT_MouthL': {
maxMorphTargets['MT_MouthL']: 1.0
},
'AU12_MT_MouthR': {
maxMorphTargets['MT_MouthR']: 1.0
},
'AU5_MT_UprLipUpL': {
maxMorphTargets['MT_UprLipUpL']: 1.0
},
'AU5_MT_UprLipUpR': {
maxMorphTargets['MT_UprLipUpR']: 1.0
},
'MT_UprLipDnL': {
maxMorphTargets['MT_UprLipDnL']: 1.0
},
'MT_UprLipDnR': {
maxMorphTargets['MT_UprLipDnR']: 1.0
},
'MT_LwrLipUpL': {
maxMorphTargets['MT_LwrLipUpL']: 1.0
},
'MT_LwrLipUpR': {
maxMorphTargets['MT_LwrLipUpR']: 1.0
},
'MT_LwrLipDnL': {
maxMorphTargets['MT_LwrLipDnL']: 1.0
},
'MT_LwrLipDnR': {
maxMorphTargets['MT_LwrLipDnR']: 1.0
},
'AU33_MT_BlowCheeksL': {
maxMorphTargets['MT_BlowCheeksL']: 1.0
},
'AU33_MT_BlowCheeksR': {
maxMorphTargets['MT_BlowCheeksR']: 1.0
},
'AU36_MT_TongueOut': {
maxMorphTargets['MT_TongueOut']: 1.0
},
'AU36_MT_TongueUp': {
maxMorphTargets['MT_TongueUp']: 1.0
},
'AU36_MT_TongueTipUp': {
maxMorphTargets['MT_TongueTipUp']: 1.0
},
'AU36_MT_TongueL': {
maxMorphTargets['MT_TongueL']: 1.0
},
'AU36_MT_TongueR': {
maxMorphTargets['MT_TongueR']: 1.0
},
'AU45_MT_Blink_L': {
maxMorphTargets['MT_Blink_L']: 1.0
},
'AU45_MT_Blink_R': {
maxMorphTargets['MT_Blink_R']: 1.0
}
}
#instanciate a list in order to keep track of kinematic joints joints
#in python runtime
#if nothing points towards those joints, they get flushed by
#python's garbage collector
self.jointList = []
self.jointFKList = []
self.agentControlJoints = []
self.agentNodePaths = []
self.agentSMRSkel = SMRPy.SMRSkeleton(True, True, 'agent')
self.createSkel(self.agent, self.agentSMRSkel, 'root', '')
#Pascal: output of both skeletons amber and alfonse as chracter.bvh
#SMRPy.exportSkeletonToBvh(self.name + '.bvh',self.agentSMRSkel);
self.newSkeleton = SMRPy.SMRSkeleton(True, True, 'pose')
self.createFKSkel(self.animationAgent, self.newSkeleton, "root", '')
self.realizer.addCharacter(self.name, self.agentSMRSkel)
for key in self.targets.keys():
self.realizer.addMorphTarget(
self.name, key
) #TODO: declare morph targets into CharacterConfigurationFile
#self.realizer.addShaderParameter( self.name, 'blushing' ) #TODO: declare shader inputs into CharacterConfiguration file
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_claw',
open('./animations/hands_claw.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_index',
open('./animations/hands_index.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_open-relaxed',
open('./animations/hands_open-relaxed.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_open-spread',
open('./animations/hands_open-spread.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_open-straight',
open('./animations/hands_open-straight.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_purse',
open('./animations/hands_purse.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ring',
open('./animations/hands_ring.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'poseNeutral',
open('./animations/poseNeutral.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'shrug',
open('./animations/shrug.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_A',
open('./animations/hands_DGS_A.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_B',
open('./animations/hands_DGS_B.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_C',
open('./animations/hands_DGS_C.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_D',
open('./animations/hands_DGS_D.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_E',
open('./animations/hands_DGS_E.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_F',
open('./animations/hands_DGS_F.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_G',
open('./animations/hands_DGS_G.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_H',
open('./animations/hands_DGS_H.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_I',
open('./animations/hands_DGS_I.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_J',
open('./animations/hands_DGS_J.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_K',
open('./animations/hands_DGS_K.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_L',
open('./animations/hands_DGS_L.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_M',
open('./animations/hands_DGS_M.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_N',
open('./animations/hands_DGS_N.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_O',
open('./animations/hands_DGS_O.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_P',
open('./animations/hands_DGS_P.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_Q',
open('./animations/hands_DGS_Q.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_R',
open('./animations/hands_DGS_R.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_T',
open('./animations/hands_DGS_T.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_U',
open('./animations/hands_DGS_U.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_W',
open('./animations/hands_DGS_W.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_X',
open('./animations/hands_DGS_X.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_Y',
open('./animations/hands_DGS_Y.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_Z',
open('./animations/hands_DGS_Z.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_DGS_SCH',
open('./animations/hands_DGS_SCH.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_A',
open('./animations/hands_ASL_A.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_B',
open('./animations/hands_ASL_B.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_C',
open('./animations/hands_ASL_C.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_D',
open('./animations/hands_ASL_D.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_E',
open('./animations/hands_ASL_E.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_F',
open('./animations/hands_ASL_F.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_G',
open('./animations/hands_ASL_G.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_H',
open('./animations/hands_ASL_H.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_I',
open('./animations/hands_ASL_I.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_J',
open('./animations/hands_ASL_J.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_K',
open('./animations/hands_ASL_K.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_L',
open('./animations/hands_ASL_L.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_M',
open('./animations/hands_ASL_M.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_N',
open('./animations/hands_ASL_N.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_O',
open('./animations/hands_ASL_O.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_P',
open('./animations/hands_ASL_P.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_Q',
open('./animations/hands_ASL_Q.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_R',
open('./animations/hands_ASL_R.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_T',
open('./animations/hands_ASL_T.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_U',
open('./animations/hands_ASL_U.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_V',
open('./animations/hands_ASL_V.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_W',
open('./animations/hands_ASL_W.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_X',
open('./animations/hands_ASL_X.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_Y',
open('./animations/hands_ASL_Y.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_Z',
open('./animations/hands_ASL_Z.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_1CL',
open('./animations/hands_ASL_1CL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_2CL',
open('./animations/hands_ASL_2CL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_3CL',
open('./animations/hands_ASL_3CL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_4CL',
open('./animations/hands_ASL_4CL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_5aCL',
open('./animations/hands_ASL_5aCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_5bCL',
open('./animations/hands_ASL_5bCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_ACL',
open('./animations/hands_ASL_ACL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_BCL',
open('./animations/hands_ASL_BCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_CCL',
open('./animations/hands_ASL_CCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_FCL',
open('./animations/hands_ASL_FCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_ICL',
open('./animations/hands_ASL_ICL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_ILYCL',
open('./animations/hands_ASL_ILYCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_SCL',
open('./animations/hands_ASL_SCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_VaCL',
open('./animations/hands_ASL_VaCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_VbCL',
open('./animations/hands_ASL_VbCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_YCL',
open('./animations/hands_ASL_YCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_CbCL',
open('./animations/hands_ASL_CbCL.bvh', "r").read())
self.realizer.addBVHMotionToCharacter(
self.name, 'hands_ASL_TCL',
open('./animations/hands_ASL_TCL.bvh', "r").read())
firingstevenhigh = open('./animations/alfonse-FiringStevenHigh.bvh',
"r").read()
self.realizer.addBVHMotionToCharacter(self.name, 'FiringStevenHigh',
firingstevenhigh)
print("done")
self.agent.reparentTo(render)
def update(self):
self.realizer.skeletonRequested()
skeletonHasBeenUpdated = False
while (not skeletonHasBeenUpdated):
#wait until skeleton can be displayed
if (self.realizer.skeletonIsReadyToBeDisplayed(self.name)):
self.updatePandaSkeleton(self.agentControlJoints,
self.agentSMRSkel)
skeletonHasBeenUpdated = True
for key in self.realizer.getModifiedMorphTargets(
self.name
): #self.targets.keys(): # Only update the targets that have actually changed here
#print key, "\n"
weight = self.realizer.getMorphTargetWeight(self.name, key)
morphTargets = self.targets[key]
for morphTargetKey in morphTargets.keys():
#print(weight*morphTargets[morphTargetKey])
morphTargetKey.setX(weight * morphTargets[morphTargetKey])
#blushingValue = self.realizer.getShaderParameterValue( self.name, 'blushing' )
#self.shaders.headShader.blushing.set( blushingValue )
def addAnimation(self, _actorName, _animationName):
self.animationAgent.reparentTo(render)
self.animationAgent.setScale(10)
self.realizer.addAnimation(_actorName, _animationName)
for i in range(self.animationAgent.getNumFrames(_animationName)):
self.animationAgent.pose(_animationName, i)
base.graphicsEngine.renderFrame()
self.updateSMRSkeleton(self.agentNodePaths, self.newSkeleton)
self.realizer.addPoseToAnimation(_actorName, _animationName,
self.newSkeleton)
self.animationAgent.detachNode()
print "animation", _animationName, "added"
def addAnimationWE(self, _actorName, _animationName):
self.animationAgent.reparentTo(render)
self.animationAgent.setScale(10)
agentSMRMotion = SMRPy.SMRMotion()
agentSMRMotion.setTimeStep(0.04)
self.realizer.addAnimation(_actorName, _animationName)
for i in range(self.animationAgent.getNumFrames(_animationName)):
self.animationAgent.pose(_animationName, i)
base.graphicsEngine.renderFrame()
self.updateSMRSkeleton(self.agentNodePaths, self.newSkeleton)
self.realizer.addPoseToAnimation(_actorName, _animationName,
self.newSkeleton)
agentSMRMotion.insertSkeleton(self.newSkeleton)
self.animationAgent.detachNode()
print "animation", _animationName, "added"
SMRPy.exportMotionToBvh(_animationName + ".bvh", agentSMRMotion)
def createSkel(self, _pandaAgent, _smrSkel, _initialJointName,
_parentName):
#get the agent's currentJoint
currentPandaJoint = _pandaAgent.getJoints(None, _initialJointName)
currentPandaCJoint = _pandaAgent.controlJoint(None, 'modelRoot',
_initialJointName)
self.agentControlJoints.append(currentPandaCJoint)
#get the first joint's position
position = currentPandaCJoint.getPos()
if (currentPandaJoint[0].getNumChildren() == 0):
newJoint = SMRPy.SMRJoint(True)
newJoint.setEndVect(position.getX(), position.getY(),
position.getZ())
else:
newJoint = SMRPy.SMRJoint(False)
rotZ = (currentPandaCJoint.getH() / 180.0) * 3.14159
rotX = (currentPandaCJoint.getP() / 180.0) * 3.14159
rotY = (currentPandaCJoint.getR() / 180.0) * 3.14159
quatZ = SMRPy.SMRQuaternion(SMRPy.SMRVector3(0.0, 0.0, 1.0), rotZ)
quatX = SMRPy.SMRQuaternion(SMRPy.SMRVector3(1.0, 0.0, 0.0), rotX)
quatY = SMRPy.SMRQuaternion(SMRPy.SMRVector3(0.0, 1.0, 0.0), rotY)
quatRot = quatZ.multiply(quatX)
quatRot = quatRot.multiply(quatY)
quatRot.normalize()
newJoint.setPos(position.getX(), position.getY(), position.getZ())
newJoint.setRotQuat(quatRot.getW(), quatRot.getX(), quatRot.getY(),
quatRot.getZ())
newJoint.setParentName(_parentName)
newJoint.setName(_initialJointName)
self.jointList.append(newJoint)
_smrSkel.insertJoint(newJoint)
for i in range(currentPandaJoint[0].getNumChildren()):
childJoint = currentPandaJoint[0].getChild(i)
childName = childJoint.getName()
#print(childName)
self.createSkel(_pandaAgent, _smrSkel, childName,
_initialJointName)
def createFKSkel(self, _pandaAgent, _smrSkel, _initialJointName,
_parentName):
#get the agent's currentJoint
currentPandaJoint = _pandaAgent.getJoints(None, _initialJointName)
currentPandaJointPath = _pandaAgent.exposeJoint(
None, 'modelRoot', _initialJointName, "lodRoot", True)
self.agentNodePaths.append(currentPandaJointPath)
#get the first joint's position
position = currentPandaJointPath.getPos()
if (currentPandaJoint[0].getNumChildren() == 0):
newJoint = SMRPy.SMRJoint(True)
newJoint.setEndVect(position.getX(), position.getY(),
position.getZ())
else:
newJoint = SMRPy.SMRJoint(False)
quatRot = currentPandaJointPath.getQuat()
newJoint.setPos(position.getX(), position.getY(), position.getZ())
newJoint.setRotQuat(quatRot.getR(), quatRot.getI(), quatRot.getJ(),
quatRot.getK())
newJoint.setParentName(_parentName)
newJoint.setName(_initialJointName)
self.jointFKList.append(newJoint)
_smrSkel.insertJoint(newJoint)
for i in range(currentPandaJoint[0].getNumChildren()):
childJoint = currentPandaJoint[0].getChild(i)
childName = childJoint.getName()
#print(childName)
self.createFKSkel(_pandaAgent, _smrSkel, childName,
_initialJointName)
def updatePandaSkeleton(self, agentControlJoints, _smrSkeleton):
#synchronize root joint
SMRJoint = _smrSkeleton.getJoint(0)
PANDAJoint = agentControlJoints[0]
position = SMRJoint.getPos()
PANDAJoint.setPos(position.X(), position.Y(), position.Z())
for i in range(_smrSkeleton.getNumjoints()):
SMRJoint = _smrSkeleton.getJoint(i)
PANDAJoint = agentControlJoints[i]
self.synchronize(PANDAJoint, SMRJoint)
def updateSMRSkeleton(self, agentNodePaths, _smrSkeleton):
#synchronize root joint
SMRJoint = _smrSkeleton.getJoint(0)
PANDAJoint = agentNodePaths[0]
position = PANDAJoint.getPos()
SMRJoint.setPos(position.getX(), position.getY(), position.getZ())
for i in range(_smrSkeleton.getNumjoints()):
SMRJoint = _smrSkeleton.getJoint(i)
PANDAJoint = agentNodePaths[i]
self.synchronizePandaToSMR(SMRJoint, PANDAJoint)
def synchronizePandaToSMR(self, _SMRJoint, _PANDAJoint):
pandaQuaternion = _PANDAJoint.getQuat()
x = pandaQuaternion.getI()
y = pandaQuaternion.getJ()
z = pandaQuaternion.getK()
w = pandaQuaternion.getR()
_SMRJoint.setRotQuat(w, x, y, z)
def synchronize(self, _pandaCJoint, _smrJoint):
smrQuaternion = _smrJoint.getRot()
pandaQuaternion = Quat()
pandaQuaternion.setI(smrQuaternion.getX())
pandaQuaternion.setJ(smrQuaternion.getY())
pandaQuaternion.setK(smrQuaternion.getZ())
pandaQuaternion.setR(smrQuaternion.getW())
if not (pandaQuaternion.isNan()):
_pandaCJoint.setQuat(pandaQuaternion)
class Npc():
def __init__(self, controlPointId, id, anchorx, anchory, anchorz, render,
team):
self.id = id
self.anchorx = anchorx
self.anchory = anchory
self.anchorz = anchorz
self.controlPointId = controlPointId
self.target = None
self.isMoving = False
self.health = 200
self.isCurrentUser = False
self.damage = 8
self.attackTimer = 0
self._is_dead = False
self._team = team
self.render = render
'''Initializing NPC actors'''
self.npc = Actor(
"models/priest", {
"walk": "models/priest-walk",
"attack": "models/priest-attack",
"hurt": "models/priest-hit",
"die": "models/priest-die"
})
if self._team == 0:
self.npcTex = loader.loadTexture("models/tex/guard_red.png")
else:
self.npcTex = loader.loadTexture("models/tex/guard_blue.png")
self.npc.setTexture(self.npcTex)
self.npc.setScale(0.5, 0.5, 0.5)
self.npc.clearColor()
self.npc.clearColorScale()
self.npc.setColor(255, 0, 0, 0)
self.npc.setColorScale(255, 0, 0, 0)
self.npc.reparentTo(self.render)
self.npc.setPos(anchorx, anchory, anchorz)
self.AIchar = AICharacter("npc" + str(self.id), self.npc, 100, 0.05, 5)
self.AIbehaviors = self.AIchar.getAiBehaviors()
self.hb = HealthBar(1.5, value=self.health)
#self._floater = NodePath(PandaNode("char_info"))
#self._floater.reparentTo(self.npc)
self.hb.setPos(0, 0, 11.9)
self.hb.reparentTo(self.npc)
#self.hb.reparentTo(self.npc)
def renderBlue(self, AIworld):
if not self._is_dead:
self.AIbehaviors.removeAi("pursue")
self.npc.detachNode()
print "Started delete procedure for npc ",
print self.id
self.npc.delete()
self.npc = Actor(
"models/priest", {
"walk": "models/priest-walk",
"attack": "models/priest-attack",
"hurt": "models/priest-hit",
"die": "models/priest-die"
})
self.npcTex = loader.loadTexture("models/tex/guard_blue.png")
self.npc.setTexture(self.npcTex)
self.npc.setScale(0.5, 0.5, 0.5)
self.npc.clearColor()
self.npc.clearColorScale()
self.npc.setColor(255, 0, 0, 0)
self.npc.setColorScale(255, 0, 0, 0)
self.npc.reparentTo(self.render)
self.npc.setPos(self.anchorx, self.anchory, self.anchorz)
AIworld.removeAiChar("npc" + str(self.id))
self.AIchar = AICharacter("npc" + str(self.id), self.npc, 100, 0.05, 5)
self.AIbehaviors = self.AIchar.getAiBehaviors()
AIworld.addAiChar(self.AIchar)
self.hb = HealthBar(1.5, value=self.health)
self.hb.setPos(0, 0, 18.1)
self.hb.reparentTo(self.npc)
#self.hb.reparentTo(self.npc)
def renderRed(self, AIworld):
if not self._is_dead:
self.AIbehaviors.removeAi("pursue")
self.npc.detachNode()
self.npc.delete()
self.npc = Actor(
"models/priest", {
"walk": "models/priest-walk",
"attack": "models/priest-attack",
"hurt": "models/priest-hit",
"die": "models/priest-die"
})
self.npcTex = loader.loadTexture("models/tex/guard_red.png")
self.npc.setTexture(self.npcTex)
self.npc.setScale(0.5, 0.5, 0.5)
self.npc.clearColor()
self.npc.clearColorScale()
self.npc.setColor(255, 0, 0, 0)
self.npc.setColorScale(255, 0, 0, 0)
self.npc.reparentTo(self.render)
self.npc.setPos(self.anchorx, self.anchory, self.anchorz)
AIworld.removeAiChar("npc" + str(self.id))
self.AIchar = AICharacter("npc" + str(self.id), self.npc, 100, 0.05, 5)
self.AIbehaviors = self.AIchar.getAiBehaviors()
AIworld.addAiChar(self.AIchar)
AIworld.update()
self.hb = HealthBar(1.5, value=self.health)
self.hb.setPos(0, 0, 8.1)
self.hb.reparentTo(self.npc)
def switchTeam(self, AIworld):
print self.id,
print " from team ",
print self._team,
print " getting deleted."
if self._team == 0:
self._team = 1
self.renderBlue(AIworld)
else:
self._team = 0
self.renderRed(AIworld)
if self.isCurrentUser:
main.freeDeadNpc(self.id)
self.target = None
self.isMoving = False
self.health = 200
self.isCurrentUser = False
self.damage = 8
self.attackTimer = 0
self._is_dead = False
def set_health(self, health):
self.health = health
def take_damage(self, health_change):
health = self.health
if health <= health_change and not self._is_dead:
self.killNpc()
else:
health = health - health_change
self.set_health(health)
self.hb.setValue(self.health)
self.npc.play("hurt")
def killNpc(self):
self.set_health(0)
self.hb.setValue(0)
self.AIbehaviors.removeAi("pursue")
hurt_interval = self.npc.actorInterval("hurt")
death_interval = self.npc.actorInterval("die")
seq = Sequence(hurt_interval, death_interval)
seq.start()
self.npc.pose("die", 45)
self._is_dead = True
self.npc.detachNode()
if self.isCurrentUser:
main.freeDeadNpc(self.id)
#main.cManager.sendRequest(Constants.CMSG_NPCDEATH, [self.id])
print Constants.CMSG_NPCDEATH,
print " + ",
print self.id
def chaseTarget(self, target, status=False):
if (not self.isMoving):
self.target = target
self.AIbehaviors.pursue(self.target)
self.npc.loop("walk")
self.isMoving = True
self.isCurrentUser = status
def stopChase(self):
#self.AIbehaviors.pauseAi("pursue")
if not self._is_dead:
self.AIbehaviors.removeAi("pursue")
p1 = LerpHprInterval(self.npc, 4, Point3(180, 0, 0))
p2 = LerpPosInterval(
self.npc, 4, Point3(self.anchorx, self.anchory, self.anchorz))
animInterval = self.npc.actorInterval("walk", loop=1, duration=4)
p2.start()
p1.start()
animInterval.start()
self.isMoving = False
self.target = None
self.isCurrentUser = False
def givNPCDistance(self, charachter):
x = self.npc.getX()
y = self.npc.getY()
z = self.npc.getZ()
minDist = math.sqrt((charachter.getX() - x) * (charachter.getX() - x) +
(charachter.getY() - y) * (charachter.getY() - y) +
(charachter.getZ() - z) * (charachter.getZ() - z))
return minDist
def checkNpcIsAlive(self):
if (self.health > 0):
return True
else:
return False
def shouldAttack(self, currentTime, cManager):
if not self._is_dead:
if self.isMoving:
if self.attackTimer > 0:
self.attackTimer = self.attackTimer - currentTime
#print self.attackTimer
if self.AIbehaviors.behaviorStatus("pursue") == "done":
#self.npc.stop("walk")
#print self.npc.getAnimControl("walk")
if self.attackTimer <= 0:
if self.npc.getAnimControl("walk").isPlaying():
self.npc.stop("walk")
if not self.npc.getAnimControl("attack").isPlaying():
#self.npc.loop("attack")
self.npc.play("attack")
self.attackTimer = 2
#myInterval = self.npc.actorInterval("attack")
#seq = Sequence(myInterval)
#seq.append(Wait(3))
#seq.start()
if self.isCurrentUser:
cManager.sendRequest(Constants.CMSG_NPCATTACK,
[self.id, self.damage])
if self.AIbehaviors.behaviorStatus("pursue") == "active":
if self.npc.getAnimControl("attack").isPlaying():
self.npc.stop("attack")
if not self.npc.getAnimControl("walk").isPlaying():
self.npc.loop("walk")
class Agent:
def __init__(self, _name):
print "Creating agent " + _name
self.name = _name
self.loadLightingFromConfig = 0
self.createShadowMap = 0
def setDataPath(self, _dataPath):
self.dataPath = _dataPath
def setActor(self, _modelFileName, _animationFileNames,
_morphTargetsFileName):
self.modelFileName = _modelFileName
self.animationFileNames = _animationFileNames
self.morphTargetsFileName = _morphTargetsFileName
def setRealizer(self, _realizer):
self.realizer = _realizer
def setCameraMask(self, _mask):
self.cameraMask = _mask
def setShadowMapParameters(self, _index, _distance):
self.createShadowMap = 1
self.shadowMapIndex = _index
self.shadowMapDistance = _distance
def setTransform(self, x, y, z, rx, ry, rz, scale):
self.agent.setPos(x, y, z)
self.agent.setScale(scale)
self.agent.setHpr(rx, ry, rz)
self.positionX = x
self.positionY = y
self.positionZ = z
def getPosition(self):
return self.agent.getPos()
def setLightingConfiguration(self, _config, _name):
self.lightingConfig = _config
self.lightingConfigName = _name
self.loadLightingFromConfig = 1
def init(self):
#load the agent and parent it to the world
#The joints of this agent will reference Panda NodePaths, it will be possible to play animations on it
self.animationAgent = Actor(self.modelFileName,
self.animationFileNames)
self.agent = Actor(self.modelFileName, self.morphTargetsFileName)
self.targets = { #'Basis':[],
'ExpSmileClosed': [],
'ExpAnger': [],
'ExpDisgust': [],
'ExpFear': [],
'ExpSad': [],
'ExpSurprise': [],
'ExpSmileOpen': [],
'ModBlinkLeft': [],
'ModBlinkRight': [],
'ModBrowDownLeft': [],
'ModBrowDownRight': [],
'ModBlinkRight': [],
'ModBrowInRight': [],
'ModBrowInLeft': [],
'ModBrowUpLeft': [],
'ModBrowUpRight': [],
'ModEarsOut': [],
'ModEyeSquintLeft': [],
'ModEyeSquintRight': [],
'ModLookDown': [],
'ModLookLeft': [],
'ModLookRight': [],
'ModLookUp': [],
'ModBlinkLeft': [],
'Phonaah': [],
'PhonB,M,P': [],
'Phonbigaah': [],
'Phonch,J,sh': [],
'PhonD,S,T': [],
'Phonee': [],
'Phoneh': [],
'PhonF,V': [],
'Phoni': [],
'PhonK': [],
'PhonN': [],
'Phonoh': [],
'Phonooh,Q': [],
'PhonR': [],
'Phonth': [],
'PhonW': []
}
iter = self.targets.iteritems()
while True:
try:
morphsItem = iter.next()
except StopIteration:
break
for i in range(2, 7):
#print (str(i)+'_'+morphsItem[0])
blendShape = self.agent.controlJoint(
None, 'modelRoot',
str(i) + '_' + morphsItem[0])
if (blendShape):
morphsItem[1].append(blendShape)
self.targets['inspire'] = [
self.agent.controlJoint(None, 'modelRoot', 'inspire')
]
#instanciate a list in order to keep track of kinematic joints joints
#in python runtime
#if nothing points towards those joints, they get flushed by
#python's garbage collector
self.jointList = []
self.jointFKList = []
self.agentControlJoints = []
self.agentNodePaths = []
self.agentSMRSkel = SMRPy.SMRSkeleton(True, True, 'agent')
self.createSkel(self.agent, self.agentSMRSkel, 'root', '')
#SMRPy.exportSkeletonToBvh('exportedPose.bvh',self.agentSMRSkel);
self.newSkeleton = SMRPy.SMRSkeleton(True, True, 'pose')
self.createFKSkel(self.animationAgent, self.newSkeleton, "root", '')
self.realizer.addCharacter(self.name, self.agentSMRSkel)
for key in self.targets.keys():
self.realizer.addMorphTarget(self.name, key)
self.realizer.addShaderParameter(self.name, 'blushing')
self.addAnimation(self.name, 'breathing')
self.addAnimation(self.name, 'hands_claw')
self.addAnimation(self.name, 'hands_fist')
self.addAnimation(self.name, 'hands_index')
self.addAnimation(self.name, 'hands_open-relaxed')
self.addAnimation(self.name, 'hands_open-spread')
self.addAnimation(self.name, 'hands_open-straight')
self.addAnimation(self.name, 'hands_purse')
self.addAnimation(self.name, 'hands_ring')
self.addAnimation(self.name, 'poseNeutral')
#self.addAnimation(self.name,'endian')
if 'default' in self.animationFileNames:
self.addAnimation(self.name, 'default')
#self.realizer.addCharacterSkeleton( self.name, );
self.agent.reparentTo(render)
self.agent.hide(BitMask32.bit(self.cameraMask))
#set lighting
ambientColor = Vec4(0.0, 0.0, 0.0, 0.0)
self.lighting = shaders.Lighting(ambientColor, self.agent)
if self.loadLightingFromConfig == 1:
self.lighting.loadFromConfig(self.lightingConfig,
self.lightingConfigName)
#shadow map
if self.createShadowMap == 1:
self.shadowMap = shadowmap.ShadowMap(self.shadowMapIndex,
self.dataPath)
def setShaders(self, _shaders):
self.shaders = _shaders
def update(self):
self.realizer.skeletonRequested()
self.updatePandaSkeleton(self.agentControlJoints, self.agentSMRSkel)
for key in self.targets.keys():
#print(key, "\n")
weight = self.realizer.getMorphTargetWeight(self.name, key)
morphTargets = self.targets[key]
for morphTarget in morphTargets:
#print(weight, "\n")
morphTarget.setX(weight)
#blushingValue = self.realizer.getShaderParameterValue( self.name, 'blushing' )
#self.shaders.headShader.blushing.set( blushingValue )
self.lighting.update()
if self.createShadowMap == 1:
self.shadowMap.setLighting(
self.lighting,
Vec3(self.positionX, self.positionY, self.positionZ),
self.shadowMapDistance)
self.shaders.updateWithShadows(self.shadowMap)
else:
self.shaders.update()
def addAnimation(self, _actorName, _animationName):
self.animationAgent.reparentTo(render)
self.animationAgent.setScale(10)
self.realizer.addAnimation(_actorName, _animationName)
for i in range(self.animationAgent.getNumFrames(_animationName)):
self.animationAgent.pose(_animationName, i)
base.graphicsEngine.renderFrame()
self.updateSMRSkeleton(self.agentNodePaths, self.newSkeleton)
self.realizer.addPoseToAnimation(_actorName, _animationName,
self.newSkeleton)
self.animationAgent.detachNode()
print "animation", _animationName, "added"
def createSkel(self, _pandaAgent, _smrSkel, _initialJointName,
_parentName):
#get the agent's currentJoint
currentPandaJoint = _pandaAgent.getJoints(None, _initialJointName)
currentPandaCJoint = _pandaAgent.controlJoint(None, 'modelRoot',
_initialJointName)
self.agentControlJoints.append(currentPandaCJoint)
#get the first joint's position
position = currentPandaCJoint.getPos()
if (currentPandaJoint[0].getNumChildren() == 0):
newJoint = SMRPy.SMRJoint(True)
newJoint.setEndVect(position.getX(), position.getY(),
position.getZ())
else:
newJoint = SMRPy.SMRJoint(False)
rotZ = (currentPandaCJoint.getH() / 180.0) * 3.14159
rotX = (currentPandaCJoint.getP() / 180.0) * 3.14159
rotY = (currentPandaCJoint.getR() / 180.0) * 3.14159
quatZ = SMRPy.SMRQuaternion(SMRPy.SMRVector3(0.0, 0.0, 1.0), rotZ)
quatX = SMRPy.SMRQuaternion(SMRPy.SMRVector3(1.0, 0.0, 0.0), rotX)
quatY = SMRPy.SMRQuaternion(SMRPy.SMRVector3(0.0, 1.0, 0.0), rotY)
quatRot = quatZ.multiply(quatX)
quatRot = quatRot.multiply(quatY)
quatRot.normalize()
newJoint.setPos(position.getX(), position.getY(), position.getZ())
newJoint.setRotQuat(quatRot.getW(), quatRot.getX(), quatRot.getY(),
quatRot.getZ())
newJoint.setParentName(_parentName)
newJoint.setName(_initialJointName)
#print _initialJointName, 'numchildren : ', currentPandaJoint[0].getNumChildren()
self.jointList.append(newJoint)
_smrSkel.insertJoint(newJoint)
for i in range(currentPandaJoint[0].getNumChildren()):
childJoint = currentPandaJoint[0].getChild(i)
childName = childJoint.getName()
#print(childName)
self.createSkel(_pandaAgent, _smrSkel, childName,
_initialJointName)
def createFKSkel(self, _pandaAgent, _smrSkel, _initialJointName,
_parentName):
#get the agent's currentJoint
currentPandaJoint = _pandaAgent.getJoints(None, _initialJointName)
currentPandaJointPath = _pandaAgent.exposeJoint(
None, 'modelRoot', _initialJointName, "lodRoot", True)
#currentPandaCJoint = _pandaAgent.controlJoint(None, 'modelRoot', _initialJointName)
#if (_parentName == 'root' or _parentName == '' or _parentName == 'Bone.001'):
# currentPandaJointPath = _pandaAgent.exposeJoint(None, 'modelRoot', _initialJointName)
#else:
# print(_parentName)
# currentPandaJointPath = _pandaAgent.exposeJoint(None, _parentName, _initialJointName)
#if (_initialJointName == "lhand"):
# self.rhand = currentPandaJointPath
self.agentNodePaths.append(currentPandaJointPath)
#get the first joint's position
position = currentPandaJointPath.getPos()
if (currentPandaJoint[0].getNumChildren() == 0):
newJoint = SMRPy.SMRJoint(True)
newJoint.setEndVect(position.getX(), position.getY(),
position.getZ())
else:
newJoint = SMRPy.SMRJoint(False)
quatRot = currentPandaJointPath.getQuat()
newJoint.setPos(position.getX(), position.getY(), position.getZ())
newJoint.setRotQuat(quatRot.getR(), quatRot.getI(), quatRot.getJ(),
quatRot.getK())
newJoint.setParentName(_parentName)
newJoint.setName(_initialJointName)
#print _initialJointName, 'numchildren : ', currentPandaJoint[0].getNumChildren()
self.jointFKList.append(newJoint)
_smrSkel.insertJoint(newJoint)
for i in range(currentPandaJoint[0].getNumChildren()):
childJoint = currentPandaJoint[0].getChild(i)
childName = childJoint.getName()
#print(childName)
self.createFKSkel(_pandaAgent, _smrSkel, childName,
_initialJointName)
def updatePandaSkeleton(self, agentControlJoints, _smrSkeleton):
#synchronize root joint
SMRJoint = _smrSkeleton.getJoint(0)
PANDAJoint = agentControlJoints[0]
position = SMRJoint.getPos()
#PANDAJoint.setPos(position.X() + 0.65 ,position.Y()-0.35,position.Z() - 1.4);
PANDAJoint.setPos(position.X(), position.Y(), position.Z())
for i in range(_smrSkeleton.getNumjoints()):
SMRJoint = _smrSkeleton.getJoint(i)
PANDAJoint = agentControlJoints[i]
self.synchronize(PANDAJoint, SMRJoint)
def updateSMRSkeleton(self, agentNodePaths, _smrSkeleton):
#synchronize root joint
SMRJoint = _smrSkeleton.getJoint(0)
PANDAJoint = agentNodePaths[0]
position = PANDAJoint.getPos()
SMRJoint.setPos(position.getX(), position.getY(), position.getZ())
for i in range(_smrSkeleton.getNumjoints()):
SMRJoint = _smrSkeleton.getJoint(i)
PANDAJoint = agentNodePaths[i]
self.synchronizePandaToSMR(SMRJoint, PANDAJoint)
def synchronizePandaToSMR(self, _SMRJoint, _PANDAJoint):
pandaQuaternion = _PANDAJoint.getQuat()
x = pandaQuaternion.getI()
y = pandaQuaternion.getJ()
z = pandaQuaternion.getK()
w = pandaQuaternion.getR()
_SMRJoint.setRotQuat(w, x, y, z)
def synchronize(self, _pandaCJoint, _smrJoint):
smrQuaternion = _smrJoint.getRot()
pandaQuaternion = Quat()
pandaQuaternion.setI(smrQuaternion.getX())
pandaQuaternion.setJ(smrQuaternion.getY())
pandaQuaternion.setK(smrQuaternion.getZ())
pandaQuaternion.setR(smrQuaternion.getW())
if not (pandaQuaternion.isNan()):
_pandaCJoint.setQuat(pandaQuaternion)
class Character(Body):
maxHearts = 6
clock = ClockObject()
def __init__(self, filename):
Body.__init__(self, filename, 'Character')
self.level = 1
self.hearts = Character.maxHearts
self.slots = []
self.currentSlot = 0
self.lifting = None
self.animations = { 'walk' : (0,38) , 'standing' : (50,400) ,
'hit' : (440,470) , 'kick' : (480,491), 'lift' : (500,520) ,
'throw' : (530,552) , 'attack' : (560,573)
}
self.model = Actor(self.data["render"]["model"], self.data["render"]["animation"])
self.name = self.data["name"]
self.maxSlots = self.data["slots"]
self.stop()
self.isMoving = False
self.tryToMove = []
self.tryToDo = None
self.readRenderData()
self.calculateDimensions()
self.last_step = Character.clock.getRealTime()
self.stunned = False
self.stunTime = 0
# THE CODE DOWN HERE SUX, BUT WE NEED THIS TO FRIDAY'S PRESENTATION, I'M SORRY DUDES
file = open("model/stun.json")
sdata = json.loads(file.read())
file.close()
self.stunModel = Actor(sdata["render"]["model"], sdata["render"]["animation"])
self.stunModel.setScale(*sdata["render"]["scale"])
self.stunModel.setHpr(*sdata["render"]["hpr"])
#self.stunModel.setPos(*sdata["render"]["pos"])
# end
self.healthChanged = False
def stop(self):
Body.stop(self)
self.model.stop()
#self.model.pose("walk",5) #transition between run and stop, if actor was looping 'run' animation
def getCollisionPos(self, direction):
angles = {"up": 270, "left": 0, "down": 90, "right": 180}
try:
self.turn(angles[direction])
futPos = Body.getCollisionPos(self, direction)
self.turn(angles[self.direction])
return futPos
except Exception as e:
print('Na colisao', e)
return self.getPos()
def move(self, direction):
angles = {"up": 270, "left": 0, "down": 90, "right": 180}
self.tryToRecover()
if not self.stunned:
self.setDirection(direction)
if self.isMoving is False:
self.model.loop("walk")
Body.move(self, direction)
def setDirection(self, direction):
Body.setDirection(self, direction)
angles = {"up": 270, "left": 0, "down": 90, "right": 180}
#colocar no json depois...
self.turn(angles[direction])
def changeSlot(self):
self.currentSlot += 1
if self.currentSlot >= len(self.slots):
self.currentSlot = 0
def pickItem(self, item):
self.tryToRecover()
if not self.stunned:
GameLoader.music.playSfx(item.sfx)
if len(self.slots) < self.maxSlots:
self.slots.append(item)
return None
else:
oldItem = self.slots[self.currentSlot]
self.slots[self.currentSlot] = item
return oldItem
def destroyCurrentItem(self):
self.slots.pop(self.currentSlot)
if len(self.slots) > 0:
self.currentSlot = self.currentSlot % len(self.slots)
else:
self.currentSlot = 0
def currentItem(self):
self.tryToRecover()
if (not self.stunned) and (len(self.slots) >= 1):
return self.slots[self.currentSlot].name
else:
return None
def getStatus(self):
#should draw character status...
slots = '[ '
i = 0
for s in self.slots:
if i == self.currentSlot:
slots += '>'
else:
slots += ' '
slots += str(s.name) + ' '
i += 1
slots += ']'
return "%s %s" % (self.name,slots)
def takeDamage(self, damage):
self.healthChanged = True
pos = self.getPos()
newdir = opposite(self.direction)
self.setPos( pos + self.speed[newdir]*5 )
self.hearts -= damage
if self.hearts < 0:
self.hearts = 0
def isAlive(self):
return self.hearts > 0
def enemy_move(self,dir):
#TODO later we'll subclass enemy and everything will be alright
if Character.clock.getRealTime() - self.last_step > 1:
self.move(dir)
self.last_step = Character.clock.getRealTime()
else:
self.move(self.direction)
def pick(self, liftable):
self.lifting = liftable
liftable.setPos(self.getPos())
liftable.setHeight(-0.07)
def stun(self):
self.stunned = True
self.stunTime = Character.clock.getRealTime()
self.stunModel.setPos(self.model.getPos())
self.stunModel.reparentTo(self.stunRender)
self.stunModel.play("stun")
def tryToRecover(self):
if self.stunned and (Character.clock.getRealTime() - self.stunTime > 1):
self.stunned = False
self.stunModel.detachNode()
print('no longer stunned')
