class Game(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.loc_text = addTextField(0.45, "[LOC]: ")
self.imageObject = OnscreenImage(image='models/intro.jpg',
pos=(-0, 0, 0.02))
self.imageObject.setScale(1.6, 1.2, 1.2)
base.graphicsEngine.renderFrame()
base.graphicsEngine.renderFrame()
base.graphicsEngine.renderFrame()
base.graphicsEngine.renderFrame()
base.setBackgroundColor(0, 0, 0, 0)
base.setFrameRateMeter(True)
_sky = Vec4(0.01, 0.01, 0.01, 0.01)
_clouds = Vec4(0.01, 0.01, 0.01, 0.01) # vx, vy, vx, vy
base.cam.setPos(0, -20, 4)
base.cam.lookAt(0, 0, 0)
self.skyNP = loader.loadModel('models/sky')
self.skyNP.reparentTo(render)
self.skyNP.setScale(1000, 1000, 300)
self.skyNP.setPos(0, 0, 0)
self.skyNP.setTexture(loader.loadTexture('models/clouds.jpg'))
self.skyNP.setShader(loader.loadShader('shaders/sky.sha'))
self.skyNP.setShaderInput('sky', _sky)
self.skyNP.setShaderInput('clouds', _clouds)
# Light
alight = AmbientLight('ambientLight')
alight.setColor(Vec4(0.5, 0.5, 0.5, 1))
alightNP = render.attachNewNode(alight)
dlight = DirectionalLight('directionalLight')
dlight.setDirection(Vec3(1, 1, -1))
dlight.setColor(Vec4(0.7, 0.7, 0.7, 1))
dlightNP = render.attachNewNode(dlight)
render.clearLight()
render.setLight(alightNP)
render.setLight(dlightNP)
# Input
self.accept('escape', self.doExit)
self.accept('r', self.doReset)
self.accept('f1', self.toggleWireframe)
self.accept('f2', self.toggleTexture)
self.accept('f3', self.toggleDebug)
self.accept('s', self.doScreenshot)
self.accept('space', self.doJump)
inputState.watchWithModifiers('forward', 'arrow_up')
#inputState.watchWithModifiers('left', 'arrow_left')
inputState.watchWithModifiers('reverse', 'arrow_down')
#inputState.watchWithModifiers('right', 'arrow_right')
inputState.watchWithModifiers('turnLeft', 'arrow_left')
inputState.watchWithModifiers('turnRight', 'arrow_right')
# Task
taskMgr.add(self.update, 'updateWorld')
# Physics
self.worldNP = render.attachNewNode('World')
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.show()
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
# self.world.setDebugNode(self.debugNP.node())
# Ground
shape = BulletPlaneShape(Vec3(0, 0, 1), 0)
#img = PNMImage(Filename('models/elevation2.png'))
#shape = BulletHeightfieldShape(img, 1.0, ZUp)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Ground'))
np.node().addShape(shape)
np.setPos(0, 0, -100)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# Box
# Character
self.crouching = False
h = 2.75
w = 0.9
shape = BulletCapsuleShape(w, h - 2 * w, ZUp)
self.character = BulletCharacterControllerNode(shape, 0.4, 'Player')
self.characterNP = self.worldNP.attachNewNode(self.character)
self.characterNP.setPos(-2, 0, 14)
#self.characterNP.setPos(-4, 75, 74)
self.characterNP.setCollideMask(BitMask32.allOn())
self.world.attachCharacter(self.character)
base.cam.reparentTo(self.characterNP)
self.pvisualNP = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.pvisualNP.clearModelNodes()
self.pvisualNP.setScale(0.003)
self.pvisualNP.setZ(-1.2)
self.pvisualNP.reparentTo(self.characterNP)
self.pvisualNP.setH(180)
#self.pvisualNP.loop("walk")
self.accept('arrow_up', self.pandawalk)
self.accept('arrow_up-up', self.pandastop)
self.accept('arrow_down', self.pandawalk)
self.accept('arrow_down-up', self.pandastop)
'''
visualNP.reparentTo(self.characterNP)
visualNP = loader.loadModel('models/pilot-model')
visualNP.clearModelNodes()
visualNP.setScale(0.05)
visualNP.setZ(-1.1)
visualNP.setH(190)
visualNP.reparentTo(self.characterNP)
'''
shape = BulletBoxShape(Vec3(2, 2, 0.2))
self.Elev = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
self.Elev.node().setMass(0)
self.Elev.node().addShape(shape)
self.Elev.setPos(-0.4, 90, 5)
self.Elev.setScale(2)
self.Elev.setCollideMask(BitMask32.allOn())
#self.boxNP.node().setDeactivationEnabled(False)
self.world.attachRigidBody(self.Elev.node())
visualNP = loader.loadModel('models/elevator')
visualNP.clearModelNodes()
visualNP.reparentTo(self.Elev)
visualNP.setScale(0.5)
shape = BulletBoxShape(Vec3(2, 2, 0.2))
self.Elev2 = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
self.Elev2.node().setMass(0)
self.Elev2.node().addShape(shape)
self.Elev2.setPos(0, 0, 28)
self.Elev2.setScale(2)
self.Elev2.setH(180)
self.Elev2.setCollideMask(BitMask32.allOn())
#self.boxNP.node().setDeactivationEnabled(False)
self.world.attachRigidBody(self.Elev2.node())
visualNP = loader.loadModel('models/elevator')
visualNP.clearModelNodes()
visualNP.reparentTo(self.Elev2)
visualNP.setScale(0.5)
#self.makeblockwood(1,1,1,1,1,1)
self.makeblock(0, 0, 0, 5, 5, 0.5)
self.makeblock(0, 10, -1, 2, 20, 0.5)
self.makeblock(0, 20, 0, 2, 3, 0.5)
self.makeblock(0, 25, 1, 2, 3, 0.5)
self.makeblock(0, 30, 2, 2, 3, 0.5)
self.makeblock(0, 35, 3, 2, 3, 0.5)
self.makeblock(0, 40, 4, 2, 3, 0.5)
self.makeblock(0, 50, 4, 10, 20, 0.5)
self.makeblockgold(-1, 50, 5, 1, 1, 1)
self.makeblockcrate(0, 50, 6, 0.7, 0.7, 0.7)
self.makeblockwood(1, 50, 5, 1, 1, 1)
self.makeblocksilver(-2.5, 50, 5, 1, 1, 1)
self.makeblockstone(2.5, 50, 5, 1, 1, 1)
self.makeblock(0, 70, 4, 2, 20, 0.5)
self.makeblock(0, 90, 4, 20, 20, 0.5)
self.makeblock(0, 75, 20, 20, 20, 0.5)
self.makeblockcrate(-1, 75, 25, 1, 1, 1)
self.makeblockwood(-1, 75, 28, 1, 1, 1)
self.makeblocksilver(-1, 75, 31, 1, 1, 1)
self.makeblockgold(-1, 75, 34, 1, 1, 1)
self.makeblockstone(-1, 75, 38, 1, 1, 1)
self.makeblock(-0.53, 50, 21.58, 2, 20, 0.5)
self.makeblock(0, 40, 23, 5, 5, 0.5)
self.makeblock(0, 20, 23, 5, 5, 0.5)
self.makeblock(0, 0, 23, 5, 5, 0.5)
self.makeblock(0, 0, 26, 20, 20, 0.5)
self.makeblock(0, 25, 46, 50, 50, 0.5)
self.imageObject.hide()
# _____HANDLER_____
def doExit(self):
self.cleanup()
sys.exit(1)
def pandawalk(self):
self.pvisualNP.loop("walk")
def pandastop(self):
self.pvisualNP.stop()
def doReset(self):
self.characterNP.setPos(-2, 0, 14)
self.Elev.setPos(-0.4, 90, 5)
self.Elev2.setPos(0, 0, 28)
def toggleWireframe(self):
base.toggleWireframe()
def toggleTexture(self):
base.toggleTexture()
def toggleDebug(self):
if self.debugNP.isHidden():
self.debugNP.show()
else:
self.debugNP.hide()
def doScreenshot(self):
base.screenshot('Bullet')
def doJump(self):
self.character.setMaxJumpHeight(5.0)
self.character.setJumpSpeed(8.0)
self.character.doJump()
def doCrouch(self):
self.crouching = not self.crouching
sz = self.crouching and 0.6 or 1.0
self.characterNP.setScale(Vec3(1, 1, sz))
#self.character.getShape().setLocalScale(Vec3(1, 1, sz))
#self.characterNP.setScale(Vec3(1, 1, sz) * 0.3048)
#self.characterNP.setPos(0, 0, -1 * sz)
# ____TASK___
def processInput(self, dt):
speed = Vec3(0, 0, 0)
omega = 0.0
if inputState.isSet('forward'): speed.setY(20.0)
if inputState.isSet('reverse'): speed.setY(-20.0)
if inputState.isSet('left'): speed.setX(-10.0)
if inputState.isSet('right'): speed.setX(10.0)
if inputState.isSet('turnLeft'): omega = 120.0
if inputState.isSet('turnRight'): omega = -120.0
self.character.setAngularMovement(omega)
self.character.setLinearMovement(speed, True)
def update(self, task):
dt = globalClock.getDt()
# self.characterNP.setHpr(0,0,0)
base.cam.setHpr(0, -5, 0)
self.processInput(dt)
self.world.doPhysics(dt, 4, 1. / 240.)
render.setShaderInput('time', task.time)
#charpos = self.characterNP.getPos()
# self.Elev.setHpr(0,0,0)
self.Elevtask()
self.Elevtask2()
#import pickle
#gg = pickle.dumps(charpos)
# self.title.setText(gg)
self.loc_text.setText('[LOC] : %03.2f, %03.2f,%03.2f ' % \
( self.characterNP.getX(), self.characterNP.getY(), self.characterNP.getZ() ) )
return task.cont
def Elevtask(self):
if not self.characterNP.node() or not self.Elev.node():
return
result = self.world.contactTestPair(self.characterNP.node(),
self.Elev.node())
for contact in result.getContacts():
cp = contact.getManifoldPoint()
node0 = contact.getNode0()
node1 = contact.getNode1()
dt = globalClock.getDt()
# print('HI')
#force = Vec3(0, 0, 0)
self.ElevZ = self.Elev.getZ()
print(self.ElevZ)
#force.setZ( 100.0)
#force *= 30.0
#force = render.getRelativeVector(self.Elev, force)
self.Elev.setZ(self.Elev.getZ() + 4 * dt)
#self.characterNP.setZ(self.Elev.getZ() + 30 * dt)
#self.characterNP.setH(180)
def Elevtask2(self):
if not self.characterNP.node() or not self.Elev2.node():
return
result = self.world.contactTestPair(self.characterNP.node(),
self.Elev2.node())
for contact in result.getContacts():
cp = contact.getManifoldPoint()
node0 = contact.getNode0()
node1 = contact.getNode1()
dt = globalClock.getDt()
# print('HI')
#force = Vec3(0, 0, 0)
self.ElevZ2 = self.Elev2.getZ()
print(self.ElevZ2)
#force.setZ( 100.0)
#force *= 30.0
#force = render.getRelativeVector(self.Elev, force)
self.Elev2.setZ(self.Elev2.getZ() + 4 * dt)
#self.characterNP.setZ(self.Elev.getZ() + 30 * dt)
#self.characterNP.setH(180)
def cleanup(self):
self.world = None
self.worldNP.removeNode()
def makeblock(self, x, y, z, xs, ys, zs):
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
self.boxNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
self.boxNP.node().setMass(0.0)
self.boxNP.node().addShape(shape)
self.boxNP.setX(x)
self.boxNP.setY(y)
self.boxNP.setZ(z)
self.boxNP.setScale(xs, ys, zs)
self.boxNP.setCollideMask(BitMask32.allOn())
#self.boxNP.node().setDeactivationEnabled(False)
self.world.attachRigidBody(self.boxNP.node())
visualNP = loader.loadModelCopy('models/blockmetal')
visualNP.clearModelNodes()
visualNP.reparentTo(self.boxNP)
visualNP.setScale(0.5)
def makeblockwood(self, x, y, z, xs, ys, zs):
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
self.boxNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
self.boxNP.node().setMass(10.2)
self.boxNP.node().addShape(shape)
self.boxNP.setX(x)
self.boxNP.setY(y)
self.boxNP.setZ(z)
self.boxNP.setScale(xs, ys, zs)
self.boxNP.setCollideMask(BitMask32.allOn())
#self.boxNP.node().setDeactivationEnabled(False)
self.world.attachRigidBody(self.boxNP.node())
visualNP = loader.loadModelCopy('models/blockwood')
visualNP.clearModelNodes()
visualNP.reparentTo(self.boxNP)
visualNP.setScale(0.5)
def makeblockgold(self, x, y, z, xs, ys, zs):
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
self.boxNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
self.boxNP.node().setMass(10.2)
self.boxNP.node().addShape(shape)
self.boxNP.setX(x)
self.boxNP.setY(y)
self.boxNP.setZ(z)
self.boxNP.setScale(xs, ys, zs)
self.boxNP.setCollideMask(BitMask32.allOn())
#self.boxNP.node().setDeactivationEnabled(False)
self.world.attachRigidBody(self.boxNP.node())
visualNP = loader.loadModelCopy('models/blockgold')
visualNP.clearModelNodes()
visualNP.reparentTo(self.boxNP)
visualNP.setScale(0.5)
def makeblocksilver(self, x, y, z, xs, ys, zs):
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
self.boxNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
self.boxNP.node().setMass(10.2)
self.boxNP.node().addShape(shape)
self.boxNP.setX(x)
self.boxNP.setY(y)
self.boxNP.setZ(z)
self.boxNP.setScale(xs, ys, zs)
self.boxNP.setCollideMask(BitMask32.allOn())
#self.boxNP.node().setDeactivationEnabled(False)
self.world.attachRigidBody(self.boxNP.node())
visualNP = loader.loadModelCopy('models/blocksilver')
visualNP.clearModelNodes()
visualNP.reparentTo(self.boxNP)
visualNP.setScale(0.5)
def makeblockstone(self, x, y, z, xs, ys, zs):
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
self.boxNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
self.boxNP.node().setMass(10.2)
self.boxNP.node().addShape(shape)
self.boxNP.setX(x)
self.boxNP.setY(y)
self.boxNP.setZ(z)
self.boxNP.setScale(xs, ys, zs)
self.boxNP.setCollideMask(BitMask32.allOn())
#self.boxNP.node().setDeactivationEnabled(False)
self.world.attachRigidBody(self.boxNP.node())
visualNP = loader.loadModelCopy('models/blockstone')
visualNP.clearModelNodes()
visualNP.reparentTo(self.boxNP)
visualNP.setScale(0.5)
def makeblockcrate(self, x, y, z, xs, ys, zs):
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
self.boxNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
self.boxNP.node().setMass(10.2)
self.boxNP.node().addShape(shape)
self.boxNP.setX(x)
self.boxNP.setY(y)
self.boxNP.setZ(z)
self.boxNP.setScale(xs, ys, zs)
self.boxNP.setCollideMask(BitMask32.allOn())
#self.boxNP.node().setDeactivationEnabled(False)
self.world.attachRigidBody(self.boxNP.node())
visualNP = loader.loadModelCopy('models/crate')
visualNP.clearModelNodes()
visualNP.reparentTo(self.boxNP)
visualNP.setScale(0.5)
class Player:
def __init__(self, bController, model, scale):
#(self, model, run, walk, startPos, scale):
"""Initialise the character.
Arguments:
bController -- The bullet character controller assigned to this player
model -- The path to the character's model file (string)
"""
self.bController = bController
#Define movement map and speeds
self.speedSprint = 20
self.speedWalk = 5
self.speedCrouch = 5
self.speed = self.speedWalk
#Capture control status
"""
Handled by bulletController?
"""
self.isMoving = False
self.isJumping = False
self.isIdle = False
self.isCrouching = False
self.movementMap = {"forward":Vec3(0,-self.speed,0),
"back":Vec3(0,self.speed,0),
"left":Vec3(self.speed,0,0),
"right":Vec3(-self.speed,0,0),
"crouch":0,
"sprint":0,
"jump":1,
"punch":0,
"kick":0,
"stop":Vec3(0),
"changeView":0
}
#Set up key state variables
self.strafe_left = self.movementMap["stop"]
self.strafe_right = self.movementMap["stop"]
self.forward = self.movementMap["stop"]
self.back = self.movementMap["stop"]
self.jump = False
self.sprint = False
self.crouch = False
#Stop player by default
self.move = self.movementMap["stop"]
#Define the actor and his animations
self.actor = Actor(model,
{"run":model + "-Run",
"walk":model + "-Walk",
"idle":model + "-Idle",
"jump":model + "-Jump",
"idleCrouch":model + "-IdleCrouch",
"walkCrouch":model + "-WalkCrouch"})
#self.actor.enableBlend()
self.actor.clearModelNodes()
#Reparent the visual actor node path to the bullet collision node path
#this is so when we move the bullet sphere node path, our actor will move
self.actor.reparentTo(self.bController.capsuleNP)
self.actor.setBlend(frameBlend = True)#Enable interpolation
#self.actor.reparentTo(render)
self.actor.setScale(scale)
#Set up FSM controller
self.FSM = ActorFSM(self.actor, self.bController)
taskMgr.add(self.processInput,"processInput")
def processInput(self, task):
#Calculate movement & do animations and stuff
self.move = self.forward + self.back + self.strafe_right + self.strafe_left
# move the character if any of the move controls are activated.
self.bController.setLinearMovement(self.move, True)
"""
#############################################################################
CALL CONTROLLER CLASS AND CALL FSM's INSTEAD OF DOING IT HERE
#############################################################################
"""
#Decide what type of movement anim to use
if(self.sprint is True):
#If we are sprinting..
self.walkAnim = 'Run'
self.speed = self.speedSprint
elif(self.crouch is True): # Can't sprint while crouching ;)
#If we are crouching..
print ("Crouching!")
self.walkAnim = "WalkCrouch"
self.idleAnim = "IdleCrouch"
self.speed = self.speedCrouch
else:
#Otherwise were walking..
self.walkAnim = 'Walk'
self.idleAnim = 'Idle'
self.speed = self.speedWalk
"""
Idling
"""
if(self.isJumping is False and self.isMoving is False and self.isIdle is True and self.FSM.state != self.idleAnim):
#If were not moving and not jumping and were supposed to be idle, play the idle anim if we aren't already
self.FSM.request(self.idleAnim,1)
#We are idle, feel free to do something else, setting isIdle = False.
print ("We are Idle but ready to do something: isIdle = False")
elif(self.isJumping is False and self.isMoving is False and self.isIdle is False):
#If were not moving or jumping, were not doing anything, we should probably be idle if we aren't already
self.isIdle = True
"""
Locomotion
"""
#TODO: Separate out into animations for forward, back and side stepping
if(self.move != self.movementMap["stop"] and self.isJumping is False):
#Check if actor is walking forward/back
if(self.move != self.movementMap["stop"]):
if(self.isMoving is False or self.FSM.state != self.walkAnim):
self.isMoving = True # were now moving
self.isIdle = False # were not idle right now
self.FSM.request(self.walkAnim,1)
print ("Started running or walking")
elif(self.isMoving is True and self.isIdle is False):
#Only switch of isMoving if we were moving and not idle
self.isMoving = False
print ("Finished walking")
#if were moving, set isMoving = 1 and call walking FSM
'''
Jumping
Check if the user is jumping, if they currently aren't jumping:
make them not idle and mark them as jumping and request the Jump FSM.
If the jump anim isn't playing but we were jumping, mark actor as not jumping.
'''
if(self.jump is True):
#if user pressed jump and were not already jumping, jump
if(self.isJumping is False and self.FSM.state != 'Jump'):
self.isJumping = True # were jumping
self.isIdle = False # were not idle right now
self.FSM.request('Jump',1)
print ("Started jumping")
#if we are jumping, check the anim has finished and stop jumping
self.JumpQuery = self.actor.getAnimControl('jump')
if(self.isJumping is True and self.JumpQuery.isPlaying() is False):
self.isJumping = False # finished jumping
print ("Finished Jumping")
"""
#############################################################################
CALL CONTROLLER CLASS AND CALL FSM's INSTEAD OF DOING IT HERE
#############################################################################
"""
return Task.cont
def setMove(self, key, moveType):
""" Used by keyboard setup
This gets the input from keyBoardSetup and will capture inputs
"""
if (moveType == "strafe_left"):
self.strafe_left = self.movementMap[key]
if (moveType == "strafe_right"):
self.strafe_right = self.movementMap[key]
if (moveType == "forward"):
self.forward = self.movementMap[key]
if (moveType == "back"):
self.back = self.movementMap[key]
if (moveType == "sprint"):
self.sprint = key
if (moveType == "jump"):
self.jump = key
if (moveType == "crouch"):
self.crouch = key
class Entity(NodePath, Precacheable):
notify = directNotify.newCategory("Entity")
NeedNode = True
def __init__(self, initNode=True):
if initNode:
NodePath.__init__(self, ModelNode("entity"))
self.loaded = False
self.cEntity = None
self.outputs = []
self.bspLoader = None
self.spawnflags = 0
self.entState = 0
self.nextThink = 0.0
self.lastThink = 0.0
self.targetName = ""
self.entnum = 0
self.entStateTime = 0.0
self.modelPath = ""
self.modelIsAnimating = False
self.modelOrigin = Point3(0)
self.modelAngles = Vec3(0)
self.modelScale = Point3(1)
self.model = None
self.sequence = None
self.mapEnt = False
self.sounds = {}
def getIsMapEnt(self):
return self.mapEnt
def parentGenerated(self):
print("Parent generated for", self, self.getParentEntity())
self.tryEntityParent()
def tryEntityParent(self):
if not self.NeedNode:
return
try:
parent = self.getParentEntity()
if parent == render:
self.reparentTo(render)
else:
self.wrtReparentTo(parent)
except:
self.reparentTo(render)
def setupBrushEntityPhysics(self):
pass
#base.brushCollisionMaterialData.update(PhysicsUtils.makeBulletCollFromGeoms(self.cEntity.getModelNp()))
def hasParentEntity(self):
return len(self.getEntityValue("parent")) > 0
def getParentEntity(self):
if not self.hasParentEntity():
return render
return self.bspLoader.getPyEntityByTargetName(
self.getEntityValue("parent"))
def transitionXform(self, destLandmarkNP, mat):
self.setMat(destLandmarkNP, mat)
def isPreservable(self):
return False
def getModel(self):
return [self.modelPath, self.modelIsAnimating]
def getModelScale(self):
return [self.modelScale[0], self.modelScale[1], self.modelScale[2]]
def getModelOrigin(self):
return [self.modelOrigin[0], self.modelOrigin[1], self.modelOrigin[2]]
def getModelAngles(self):
return [self.modelAngles[0], self.modelAngles[1], self.modelAngles[2]]
def getFrameTime(self):
return globalClock.getFrameTime()
def getSound(self, name):
return self.sounds[name]
def isSoundPlaying(self, name):
if name in self.sounds and self.sounds[name]:
return self.sounds[name].status() == AudioSound.PLAYING
return False
def addSound(self,
name,
soundPath,
spatialized=True,
setLoop=False,
node=None):
if not node:
node = self
if spatialized:
self.sounds[name] = base.loadSfxOnNode(soundPath, node)
else:
self.sounds[name] = loader.loadSfx(soundPath)
self.sounds[name].setLoop(setLoop)
def stopSound(self, name):
if name in self.sounds and self.sounds[name]:
self.sounds[name].stop()
def stopAllSounds(self):
if self.sounds:
for sound in self.sounds.values():
sound.stop()
def playSound(self, name, volume=1.0):
if name in self.sounds:
self.sounds[name].setVolume(volume)
self.sounds[name].setLoop(False)
self.sounds[name].play()
def loopSound(self, name, volume=1.0):
if name in self.sounds:
self.sounds[name].setVolume(volume)
self.sounds[name].setLoop(True)
self.sounds[name].play()
def clearSequence(self):
if self.sequence:
self.sequence.finish()
self.sequence = None
def setSequence(self, seq, loop=False, startNow=True):
self.clearSequence()
self.sequence = seq
if startNow:
if loop:
self.sequence.loop()
else:
self.sequence.start()
def clearModel(self):
if self.model:
if isinstance(self.model, Actor):
self.model.cleanup()
else:
self.model.removeNode()
self.model = None
def setModel(self, mdlPath, animating=False):
self.clearModel()
self.modelIsAnimating = animating
if isinstance(mdlPath, str):
self.modelPath = mdlPath
if len(mdlPath) == 0:
return
if animating:
self.model = Actor(mdlPath, flattenable=0)
else:
self.model = loader.loadModel(mdlPath)
else:
# Assume it's an already loaded Actor/Model.
self.model = mdlPath
self.model.reparentTo(self)
def enableModelCollisions(self):
if self.model:
base.createAndEnablePhysicsNodes(self.model)
def disableModelCollisions(self):
if self.model:
base.disableAndRemovePhysicsNodes(self.model)
def setModelOrigin(self, origin):
self.modelOrigin = Point3(origin)
if self.model:
self.model.setPos(origin)
def setModelAngles(self, angles):
self.modelAngles = Vec3(angles)
if self.model:
self.model.setHpr(angles)
def setModelScale(self, scale):
self.modelScale = Point3(scale)
if self.model:
self.model.setScale(scale)
def optimizeModel(self):
if self.model:
self.model.clearModelNodes()
self.model.flattenStrong()
def getModelNP(self):
return self.model
def getTargetName(self):
return self.targetName
def setNextThink(self, delay):
self.nextThink = delay
self.lastThink = globalClock.getFrameTime()
def getNextThink(self):
return self.nextThink
def shouldThink(self):
return self.nextThink >= 0 and globalClock.getFrameTime(
) - self.lastThink >= self.nextThink
def setEntityState(self, state):
self.entState = state
self.entStateTime = globalClock.getFrameTime()
def getEntityStateElapsed(self):
return globalClock.getFrameTime() - self.entStateTime
def getEntityState(self):
return self.entState
def __thinkTask(self, task):
if self.shouldThink():
self.lastThink = globalClock.getFrameTime()
self.nextThink = 0.0
self.think()
return task.cont
def think(self):
pass
def hasSpawnFlags(self, flags):
return (self.spawnflags & flags) != 0
def getCEntity(self):
return self.cEntity
def getLoader(self):
return self.bspLoader
def entityTaskName(self, taskName):
if hasattr(self, 'doId'):
entnum = self.doId
else:
entnum = self.getEntnum()
return taskName + "-entity_" + str(entnum)
def getEntnum(self):
return self.entnum
def getEntityValue(self, key):
assert self.cEntity
return self.cEntity.getEntityValue(key)
def getEntityValueInt(self, key):
assert self.cEntity
try:
return int(self.cEntity.getEntityValue(key))
except:
return 0
def getEntityValueBool(self, key):
assert self.cEntity
try:
return bool(int(self.cEntity.getEntityValue(key)))
except:
return False
def getEntityValueFloat(self, key):
assert self.cEntity
try:
return float(self.cEntity.getEntityValue(key))
except:
return 0.0
def getEntityValueVector(self, key):
assert self.cEntity
return self.cEntity.getEntityValueVector(key)
def getEntityValueColor(self, key):
assert self.cEntity
return self.cEntity.getEntityValueColor(key)
def task_dispatchOutput(self, target, op, extraArgs, task):
param = op['parameter']
params = param.split(';') if len(param) > 0 else []
params += extraArgs
getattr(target, op['input']).__call__(*params)
return task.done
def dispatchOutput(self, outputName, extraArgs=[]):
for op in self.outputs:
if op['output'] == outputName and op['active']:
target = None
if 'targetName' in op:
target = self.bspLoader.getPyEntityByTargetName(
op['targetName'])
elif 'target' in op:
target = op['target']
if target:
if hasattr(target, op['input']) and callable(
getattr(target, op['input'])):
taskMgr.doMethodLater(
op['delay'],
self.task_dispatchOutput,
"dispatchOutput-" + str(id(op)),
extraArgs=[target, op, extraArgs],
appendTask=True)
if op['once']:
op['active'] = False
def connectOutput(self,
outputName,
inputEntity,
inputName,
parameter="",
onceOnly=False,
delay=0.0):
self.outputs.append({
'output': outputName,
'target': inputEntity,
'input': inputName,
'parameter': parameter,
'delay': delay,
'once': onceOnly,
'active': True
})
def load(self):
self.loaded = True
if hasattr(base, 'bspLoader') and not self.bspLoader:
self.bspLoader = base.bspLoader
self.entnum = self.cEntity.getBspEntnum()
keyvalues = []
self.bspLoader.getEntityKeyvalues(keyvalues,
self.cEntity.getBspEntnum())
for k, v in keyvalues:
if k[:2] != "On":
continue
data = v.split(',')
if len(data) != 5:
continue
self.outputs.append({
'output': k,
'targetName': data[0],
'input': data[1],
'parameter': data[2],
'delay': float(data[3]),
'once': bool(int(data[4])),
'active': True
})
self.spawnflags = self.getEntityValueInt("spawnflags")
self.dispatchOutput("OnSpawn")
def enableThink(self):
taskMgr.add(self.__thinkTask, self.entityTaskName("think"))
def unload(self):
taskMgr.remove(self.entityTaskName("think"))
self.stopAllSounds()
self.sounds = None
self.clearSequence()
self.disableModelCollisions()
self.clearModel()
self.loaded = None
self.cEntity = None
self.outputs = None
self.bspLoader = None
self.spawnflags = None
self.entState = None
self.nextThink = None
self.lastThink = None
self.targetName = None
self.entnum = None
self.modelOrigin = None
self.modelAngles = None
self.modelScale = None
self.modelPath = None
self.modelIsAnimating = None
from panda3d.core import *
from direct.actor.Actor import Actor
actor = Actor()
actor.loadModel("phase_3/models/char/tt_a_chr_dgm_shorts_legs_1000.bam", "legs")
actor.find("**/boots_long").removeNode()
actor.find("**/boots_short").removeNode()
actor.find("**/shoes").removeNode()
actor.loadModel("phase_3/models/char/tt_a_chr_dgm_skirt_head_1000.bam", "head")
actor.loadAnims({"neutral": "phase_3/models/char/tt_a_chr_dgm_shorts_legs_neutral.bam"}, "legs")
actor.loadModel("phase_3/models/char/tt_a_chr_dgm_shorts_torso_1000.bam", "torso")
actor.loadAnims({"neutral": "phase_3/models/char/tt_a_chr_dgm_shorts_torso_1000.bam"}, "torso")
#actor.loadModel("phase_3/models
actor.getPart("torso").reparentTo(actor.find("**/joint_hips"))
actor.getPart("head").reparentTo(actor.getPart("torso").find("**/def_head"))
#actor.getGeomNode().setScale(0.85)
actor.clearModelNodes()
actor.flattenLight()
actor.postFlatten()
actor.ls()
#actor.listJoints()
actor.writeBamFile("flippy.bam")
#head = Loader.getGlobalPtr().loadSync("phase_3/models/char/tt_a_chr_dgm_skirt_head_1000.bam")
#NodePath(head).writeBamFile("flippy_head.bam")
