class Eve(Character):
#----- CLASS VARIABLES -----#
HEIGHT = 21.00
WIDTH = 5.0
INITIAL_HEADING = 90
MAX_JUMP_HEIGHT = 200.0
JUMP_SPEED = 70
RUNNING_SPEED = 40.0
INITIAL_ROLL_SPEED = 200.0
ROLL_ANIM_RATE = 15
OMEGA = 60.0
#----- CONSTRUCTOR -----#
def __init__(self,game,render,world,accept,health=100,damage=0):
super(Eve,self).__init__('Eve',health,damage)
#----- INSTANCE VARIABLES -----#
self.state = {'normal': True, 'jumping' : False, 'rolling' : False}
self.speed = Vec3(0, 0, 0)
self.omega = 0.0
self.tiresCollected = 0
self.accept = accept
self.ready = True
#----- PRIVATE INSTANCE VARIABLES -----#
self.__render = render
self.__world = world
self.__game = game
#----- ACTOR SETUP -----#
self.actorNP1 = Actor('models/eve/eve.egg', {
'run' : 'models/eve/eve-run.egg',
'walk' : 'models/eve/eve-walk.egg',
'jump' : 'models/eve/eve-jump.egg'})
self.actorNP2 = Actor('models/eve/eve-tireroll.egg', {'roll' : 'models/eve/eve-tireroll.egg'})
self.actorNP1.setPlayRate(2,'walk')
#----- PREPARE SFX -----#
self.jump = base.loader.loadSfx("sfx/jump.wav")
self.jump.setVolume(.1)
self.running = base.loader.loadSfx("sfx/walking.wav")
self.running.setLoop(True)
self.running.setPlayRate(1.55)
self.running.setVolume(.08)
self.land = base.loader.loadSfx("sfx/land.flac")
self.land.setLoop(False)
self.land.setVolume(.05)
self.roll = base.loader.loadSfx("sfx/rolling.wav")
self.roll.setLoop(True)
self.roll.setVolume(.09)
self.ouch = base.loader.loadSfx("sfx/ouch.wav")
self.ouch.setLoop(False)
self.ouch.setVolume(.75)
self.ouch.setPlayRate(1.25)
self.throw = base.loader.loadSfx("sfx/throw.wav")
self.throw.setLoop(False)
self.throw.setVolume(.75)
self.blocked = base.loader.loadSfx("sfx/blocked.wav")
self.blocked.setVolume(.05)
#----- SETUP CONTROL FOR EVE -----#
inputState.watchWithModifiers('forward', 'w')
inputState.watchWithModifiers('turnLeft', 'a')
inputState.watchWithModifiers('turnRight', 'd')
inputState.watchWithModifiers('backwards', 's')
def render_eve(self,pos):
self.searchMode(pos,Eve.INITIAL_HEADING)
# Changing jump animation play rate
self.currentNode.setPlayRate(1,'jump')
self.__game.taskMgr.add(self.process_contacts,'attacks')
def disable_character_controls(self):
self.accept('m', self.do_nothing)
self.accept('space', self.do_nothing)
self.accept('enter',self.do_nothing)
def enable_character_controls(self):
self.accept('m', self.toggle_modes)
self.accept('space', self.doJump)
self.accept('enter',self.attack)
def do_nothing(self):
pass
#------ METHODS USED TO MODIFY JUMP ANIMATION ------#
def firstPart(self): self.currentNode.play('jump', fromFrame=0)
def stopInJump(self):
self.currentNode.stop()
def finishJump(self):
self.currentNode.play('jump', fromFrame=11)
self.land.play()
#self.currentNode.play('jump', fromFrame=self.currentNode.getCurrentFrame('jump'))
def doJump(self):
if self.currentControllerNode.isOnGround() is True:
if self.currentState() is 'normal':
if self.speed.getY() > 0: self.running.stop()
self.state['jumping'] = True
self.jump.play()
self.currentControllerNode.doJump()
#sequence = Sequence(Func(self.firstPart),Wait(.3),Func(self.stopInJump),Wait(2.95),Func(self.finishJump))
sequence = Sequence(Func(self.firstPart),Wait(.3),Func(self.stopInJump),Wait(2.95))
sequence.start()
def searchMode(self,location,heading):
self.state['normal'] = True
self.state['rolling'] = False
(self.init_x,self.init_y,self.init_z) = location
self.__capsule_shape = BulletCapsuleShape(Eve.WIDTH, Eve.HEIGHT - 2 * Eve.WIDTH, ZUp)
# Create bullet character controller
self.character1= BulletCharacterControllerNode(self.__capsule_shape,0.4,self.name)
#self.character1.setMaxJumpHeight(Eve.MAX_JUMP_HEIGHT)
self.character1.setJumpSpeed(Eve.JUMP_SPEED)
self.character1.setGravity(70)
self.characterNP1 = self.__render.attachNewNode(self.character1)
self.characterNP1.setPos(self.init_x,self.init_y,self.init_z)
self.characterNP1.setH(heading)
self.characterNP1.setCollideMask(BitMask32.allOn())
self.__world.attachCharacter(self.character1)
self.actorNP1.reparentTo(self.characterNP1)
self.actorNP1.setScale(4.0)
self.actorNP1.setH(180)
self.actorNP1.setPos(0,0,-9)
self.currentNode = self.actorNP1
self.currentNP = self.characterNP1
self.currentControllerNode = self.character1
# Create a cylindrical collision shape
collisionShape = BulletCylinderShape(6.5,3,XUp)
# Create a ghost node and attach to render
self.ghostNode = BulletGhostNode('Weapon')
self.ghostNode.addShape(collisionShape)
self.weaponNP = self.__game.render.attachNewNode(self.ghostNode)
self.weaponNP.setCollideMask(BitMask32.allOff())
self.weaponNP.setPos(self.init_x, self.init_y, self.init_z)
self.__game.world.attachGhost(self.ghostNode)
self.weapon = self.__game.loader.loadModel('models/environ/tire/tire.egg')
self.weapon.setScale(4,4,4)
self.weapon.setPos(-.5,0,0)
self.weapon.reparentTo(self.weaponNP)
self.weapon.hide()
self.__game.taskMgr.add(self.update_weapon_pos,"weapon")
def reset(self):
self.characterNP1.setPos(self.init_x,self.init_y,self.init_z)
def update_weapon_pos(self,task):
self.weaponNP.setPos(self.characterNP1.getX(),self.characterNP1.getY(), self.characterNP1.getZ() + 5)
self.weaponNP.setH(self.characterNP1.getH())
return task.cont
def attack(self):
if self.tiresCollected > 0 and self.ready is True:
self.throw.play()
self.weapon.show()
xpos = 100 * cos((90 - self.characterNP1.getH()) * (pi / 180.0))
ypos = -100 * sin((90 - self.characterNP1.getH()) * (pi / 180.0))
trajectory = ProjectileInterval(self.weaponNP,
startPos = self.weaponNP.getPos(),
endPos = Point3(self.weaponNP.getX() - xpos,self.weaponNP.getY() - ypos, self.weaponNP.getZ()-10), duration = .5, gravityMult = 15)
Sequence(Func(self.set_weapon_busy),trajectory,Func(self.weapon.hide),Func(self.set_weapon_ready)).start()
self.tiresCollected -= 1
else:
self.blocked.play()
def set_weapon_ready(self):
self.ready = True
def set_weapon_busy(self):
self.ready = False
def process_contacts(self,task):
for enemy in self.__game.e.enemies:
self.check_impact(enemy)
return task.cont
def check_impact(self,enemy):
result = self.__game.world.contactTestPair(self.ghostNode,enemy.np.node())
if len(result.getContacts()) > 0:
if self.weapon.isHidden() is False:
self.weapon.hide()
if self.ready is False:
enemy.take_damage(self.damage)
def attackMode(self,location,heading):
self.state['normal'] = False
self.state['rolling'] = True
(self.init_x,self.init_y,self.init_z) = location
self.__cylinder_shape = BulletCylinderShape(Eve.WIDTH + 2, Eve.HEIGHT - 4, XUp)
# Create bullet character controller
self.character2= BulletCharacterControllerNode(self.__cylinder_shape,0.4,self.name)
self.characterNP2 = self.__render.attachNewNode(self.character2)
self.characterNP2.setPos(self.init_x,self.init_y,self.init_z-2)
self.characterNP2.setH(heading)
self.characterNP2.setCollideMask(BitMask32.allOn())
self.__world.attachCharacter(self.character2)
self.character2.setGravity(70)
self.actorNP2.reparentTo(self.characterNP2)
self.actorNP2.setScale(4.0)
self.actorNP2.setH(180)
self.actorNP2.setPos(0,0,0)
self.currentNode = self.actorNP2
self.currentNP = self.characterNP2
self.currentControllerNode = self.character2
# Set play rate of the rolling animation
self.currentNode.setPlayRate(15,'roll')
def is_attack_mode(self):
return self.state['rolling']
def toggle_modes(self):
if self.is_attack_mode() is False:
loc = (self.characterNP1.getX(),self.characterNP1.getY(),self.characterNP1.getZ())
heading = self.characterNP1.getH()
self.__world.removeCharacter(self.character1)
self.character1.removeChild(0)
self.attackMode(loc,heading)
else:
loc = (self.characterNP2.getX(),self.characterNP2.getY(),self.characterNP2.getZ())
heading = self.characterNP2.getH()
self.__world.removeCharacter(self.character2)
self.character2.removeChild(0)
self.searchMode(loc,heading)
def processEveInput(self):
if self.currentControllerNode.isOnGround() is True:
self.speed = Vec3(0, 0, 0)
self.omega = 0.0
if inputState.isSet('forward'):
if self.state['rolling'] == True:
self.speed.setY( Eve.INITIAL_ROLL_SPEED)
else:
self.speed.setY( Eve.RUNNING_SPEED)
self.currentNode.setP(15)
if inputState.isSet('backwards'):
if self.state['rolling'] == True:
self.speed.setY( Eve.INITIAL_ROLL_SPEED - 300)
else:
self.speed.setY(-1 * Eve.RUNNING_SPEED - 10)
if inputState.isSet('turnLeft'):
self.omega = Eve.OMEGA
if self.speed.getY() == 0:
self.currentNode.setR(0)
else:
self.currentNode.setR(15)
if inputState.isSet('turnRight'):
self.omega = Eve.OMEGA * -1
if self.speed.getY() == 0:
self.currentNode.setR(0)
else:
self.currentNode.setR(-15)
self.currentControllerNode.setAngularMovement(self.omega)
if self.currentControllerNode.isOnGround() is False:
self.currentControllerNode.setAngularMovement(0.0)
self.currentControllerNode.setLinearMovement(self.speed, True)
self.currentNode.setR(0)
if self.currentControllerNode.isOnGround() is True and self.currentNode.getCurrentAnim() == 'jump':
self.currentNode.setR(0)
self.currentControllerNode.setAngularMovement(0.0)
self.currentControllerNode.setLinearMovement(0.0, True)
if self.currentControllerNode.isOnGround() is True and self.currentNode.getCurrentAnim() != 'jump':
self.currentControllerNode.setAngularMovement(self.omega)
self.currentControllerNode.setLinearMovement(self.speed, True)
def currentState(self):
if self.state['rolling'] is True:
return 'rolling'
else:
return 'normal'
def updateEveAnim(self):
self.processEveInput()
if self.currentControllerNode.isOnGround() is True and self.currentNode.getCurrentAnim() != 'jump':
if self.speed.getY() > 0:
if self.omega == 0.0: self.currentNode.setR(0)
if self.currentState() is 'rolling':
if self.running.status() == self.running.PLAYING: self.running.stop()
if self.roll.status() != self.roll.PLAYING: self.roll.play()
if self.currentNode.getCurrentAnim() != 'roll': self.currentNode.loop('roll')
elif self.currentState() is 'normal':
if self.roll.status() == self.roll.PLAYING: self.roll.stop()
if self.running.status() != self.running.PLAYING: self.running.play()
if self.currentNode.getCurrentAnim() != 'run': self.currentNode.loop('run')
elif self.speed.getY() < 0:
if self.currentState() is 'rolling':
if self.running.status() == self.running.PLAYING: self.running.stop()
if self.roll.status() != self.roll.PLAYING: self.roll.play()
if self.currentNode.getCurrentAnim() != 'roll': self.currentNode.loop('roll')
elif self.currentState() is 'normal':
if self.roll.status() == self.roll.PLAYING: self.roll.stop()
if self.running.status() != self.running.PLAYING: self.running.play()
if self.currentNode.getCurrentAnim() != 'walk': self.currentNode.loop('walk')
else:
if self.omega != 0:
if self.currentState() is 'rolling':
if self.currentNode.getCurrentAnim() != 'roll': self.currentNode.loop('roll')
elif self.currentState() is 'normal':
if self.currentNode.getCurrentAnim() != 'walk':
self.actorNP1.setPlayRate(1,'walk')
self.currentNode.loop('walk')
else:
self.currentNode.stop(self.currentNode.getCurrentAnim())
self.actorNP1.setPlayRate(2,'walk')
self.currentNode.setP(0)
self.currentNode.setR(0)
if self.running.status() == self.running.PLAYING: self.running.stop()
if self.roll.status() == self.roll.PLAYING: self.roll.stop()
if self.state['rolling'] is True:
frame = self.currentNode.getCurrentFrame('roll')
if frame is None: frame = 0
else: frame = self.currentNode.getCurrentFrame('roll')
self.currentNode.pose('roll',frame)
elif self.state['normal'] is True:
self.currentNode.pose('walk',5)
elif self.currentControllerNode.isOnGround() is False and self.state['jumping'] is False:
self.currentNode.pose('jump',7)
def take_damage(self,damage):
self.ouch.play()
color_scale_interval1 = LerpColorScaleInterval(self.currentNode, .5, (1,0,0,.1), (1,0,0,0))
Sequence(color_scale_interval1,Wait(.005),Func(self.currentNode.clearColorScale)).start()
self.health -= damage
class Game(DirectObject):
def __init__(self):
#ShowBase.__init__(self)
base.setBackgroundColor(0.1, 0.1, 0.8, 1)
base.setFrameRateMeter(True)
base.cam.setPos(0, -20, 4)
base.cam.lookAt(0, 0, 0)
# 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('f5', self.doScreenshot)
#self.accept('space', self.doJump)
#self.accept('c', self.doCrouch)
inputState.watchWithModifiers('forward', 'w')
inputState.watchWithModifiers('left', 'a')
inputState.watchWithModifiers('reverse', 's')
inputState.watchWithModifiers('right', 'd')
inputState.watchWithModifiers('turnLeft', 'q')
inputState.watchWithModifiers('turnRight', 'e')
# Task
taskMgr.add(self.update, 'updateWorld')
# Physics
self.setup()
# _____HANDLER_____
def doExit(self):
self.cleanup()
sys.exit(1)
def doReset(self):
self.cleanup()
self.setup()
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.player.setMaxJumpHeight(5.0)
# self.player.setJumpSpeed(8.0)
# self.player.doJump()
#def doCrouch(self):
# self.crouching = not self.crouching
# sz = self.crouching and 0.6 or 1.0
# self.playerNP2.setScale(Vec3(1, 1, sz))
# ____TASK___
def processInput(self, dt):
speed = Vec3(0, 0, 0)
omega = 0.0
if inputState.isSet('forward'): speed.setY(2.0 * dt * 60.0)
if inputState.isSet('reverse'): speed.setY(-2.0)
if inputState.isSet('left'): speed.setX(-2.0)
if inputState.isSet('right'): speed.setX(2.0)
if inputState.isSet('turnLeft'): omega = 120.0
if inputState.isSet('turnRight'): omega = -120.0
self.player.setAngularMovement(omega)
self.player.setLinearMovement(speed, True)
def update(self, task):
dt = globalClock.getDt()
self.processInput(dt)
self.world.doPhysics(dt, 4, 1. / 240.)
self.updateCamera()
return task.cont
def cleanup(self):
self.world = None
self.worldNP.removeNode()
def updateCamera(self):
camvec = self.playerNP.getPos() - self.camera.getPos()
camvec.setZ(0)
camdist = camvec.length()
camvec.normalize()
if camdist > 10.0:
self.camera.setPos(self.camera.getPos() + camvec * (camdist - 10))
camdist = 10.0
if camdist < 5.0:
self.camera.setPos(self.camera.getPos() - camvec * (5 - camdist))
camdist = 5.0
self.camera.setZ(self.playerNP.getZ() + 2)
self.camera.lookAt(self.playerNP)
###################################
############## SETUP ##############
###################################
def setup(self):
self.worldNP = render.attachNewNode('World')
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.show()
####### MV
self.environ = loader.loadModel("world/world")
self.environ.reparentTo(render)
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)
#actor = Actor('world/world')
mesh = BulletTriangleMesh()
###### create terrein colligion shape
geomNodeCollection = self.environ.findAllMatches('**/+GeomNode')
for nodePath in geomNodeCollection: #.asList():
geomNode = nodePath.node()
print("here1")
for i in range(geomNode.getNumGeoms()):
geom = geomNode.getGeom(i)
print("here2")
print(geom)
mesh.addGeom(geom)
shape = BulletTriangleMeshShape(mesh, dynamic=False)
shape.set_margin(0.0)
#print(geomNodeCollection)
# for geom in actor.getGeomNode().get_geoms():
# mesh.addGeom(geom)
# shape = BulletTriangleMeshShape(mesh, dynamic=False)
#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, 0) #-1)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# Box
shape = BulletBoxShape(Vec3(1.0, 3.0, 0.3))
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
np.node().setMass(50.0)
np.node().addShape(shape)
np.setPos(3, 0, 7)
np.setH(0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# Character
h = 1.75
w = 0.4
shape = BulletCapsuleShape(w, h - 2 * w, ZUp)
self.player = BulletCharacterControllerNode(
shape, 0.4,
'Player') #MV was: BulletCharacterNode(shape, 0.4, 'Player')
#self.player.setMass(20.0)
self.player.setMaxSlope(70.0)
self.player.setGravity(9.81)
#self.player.setFrictionSlip(100.0)
self.playerNP = self.worldNP.attachNewNode(self.player)
#self.playerNP.setMass(20.0)
self.playerNP.setPos(-2, 0, 10)
self.playerNP.setH(-90)
self.playerNP.setCollideMask(BitMask32.allOn())
#self.playerNP.flattenLight()
self.world.attachCharacter(self.player)
self.ralph = Actor("ralph/ralph", {
"run": "ralph/ralph-run",
"walk": "ralph/ralph-walk"
})
self.ralph.reparentTo(render)
self.ralph.setScale(0.3048)
self.ralph.setPos(0, 0, -1)
self.ralph.setH(180)
self.ralph.reparentTo(self.playerNP)
## Camera
self.camera = base.cam
base.disableMouse()
self.camera.setPos(self.playerNP.getX(), self.playerNP.getY() + 10, 2)
self.camera.lookAt(self.playerNP)
class Player():
model = 0
counter = 0
def __init__(self,ppos, world, worldNP):
self.traptime = 0
self.world = world
self.worldNP = worldNP
if not Player.model:
Player.model = Model("../assets/3d/Actors/robot rig 10 coll.egg")#NPC_robot_mesh.egg")
#Player.model.modelRoot.find("**/body_coll").show()
self.instance = Player.model.createInstance(pos=ppos)
self.velocity = (0,0,0)
self.prevTime = 0
taskMgr.add(self.fpMove,"moveTask")
self.projectiles = list()
self.projTime = 0.0
pnode = ModelRoot("player")
self.player = render.attachNewNode(pnode)
pc = self.player.attachNewNode(CollisionNode("playerCollision"))
pc.node().addSolid(CollisionRay(0,0,-1,0,0,1))
self.playerCnode = pc
self.id = Player.counter
Player.counter = Player.counter + 1
def fpMove(self,task):
#CONSTANTS
ACCELERATION = 0.6
MINDISTANCE = 150
MAXSPEED = 100
THROWPERIOD = 5.0
#Function
dt = task.time-self.prevTime
self.instance.setZ(self.instance.getZ())
self.prevTime = task.time
target = camera
targetPos = target.getPos()
pos = self.characterNP.getPos()
vector2Target = self.normalize(targetPos - pos)
#notarget = 0
#if notarget == 1:
# return task.cont
#gogo trigonometry
angle = 90 + ( atan2(vector2Target[1],vector2Target[0])*180 / math.pi )
angle2 = ( atan2(-vector2Target[2],sqrt(pow(vector2Target[1], 2) + pow(vector2Target[0], 2)))*180 / math.pi )
self.instance.setH(angle)
self.instance.setP(angle2)
#curSpeed = sqrt(pow(self.velocity[0],2)+pow(self.velocity[1],2)+pow(self.velocity[2],2))
#Use Distance formula, if further than MINDISTANCE, keep moving, otherwise stop
distance = sqrt(pow(target.getX()-self.instance.getX(),2)+pow(target.getY()-self.instance.getY(),2)+pow(target.getZ()-self.instance.getZ(),2))
if(distance<MINDISTANCE):
ACCELERATION = 0.0
#get the velocity
self.velocity = (self.velocity[0] + ACCELERATION * vector2Target[0], self.velocity[1] + ACCELERATION * vector2Target[1], self.velocity[2] + ACCELERATION * vector2Target[2])
self.velocity = (min(MAXSPEED,self.velocity[0]),min(MAXSPEED,self.velocity[1]),min(MAXSPEED,self.velocity[2]))
#get displacement
dis = (self.velocity[0]*dt,self.velocity[1]*dt,self.velocity[2]*dt)
#update position
#self.player.setPos(pos[0]+dis[0],pos[1]+dis[1],pos[2]+dis[2])
#self.instance.setPos(self.player.getX(),self.player.getY(),self.player.getZ())
self.character.setAngularMovement(0)
self.character.setLinearMovement(self.velocity, True)
self.instance.setPos(pos[0]+dis[0],pos[1]+dis[1],pos[2]+dis[2]-self.radius*.7)
#if self.id == 0:
# print pos[0]+dis[0]
# print pos[1]+dis[1]
# print pos[2]+dis[2]
# print str(self.id) + " Z Displacement:" + str(dis[2]) + " distance:" + str(distance)
self.projTime += dt
if self.projTime >= THROWPERIOD:
self.projTime -= THROWPERIOD
self.projectiles.append(Projectile(self.instance.getPos(),deg2Rad(180+angle),deg2Rad(angle2),self,self.velocity, self.world, self.worldNP))
return task.cont
def bulletInit(self,world,pos):
oldpath = self.instance.find("**/body_coll")
self.radius = oldpath.node().getSolid(0).getRadius()
shape = BulletSphereShape(self.radius)
self.character = BulletCharacterControllerNode(shape, 0.4, 'AI'+str(Player.counter))
self.characterNP = render.attachNewNode(self.character)
self.characterNP.setPos(pos[0],pos[1],pos[2])
self.character.setGravity(0)
self.characterNP.setCollideMask(BitMask32.allOn())
world.attachCharacter(self.character)
def normalize(self, vector):
return vector / sqrt(pow(vector[0],2) + pow(vector[1], 2) + pow(vector[2], 2))
def die(self,event):
base.cTrav.removeCollider(self.wheelsphere)
self.instance.node().getChild(0).removeChild(0)
print "Computer player eliminated!"
def trap1(self):
self.velocity = map(lambda x: x*.25, self.vel)
self.traptime = self.traptime + 20
return
def trap2(self):
self.velocity = (0,0,0)
self.traptime = self.traptime + 20
return
def impact(self,vel):
diff = map(lambda i: self.velocity[i]-vel[i], range(3))
self.velocity = map(lambda i: self.velocity[i]-diff[i], range(3))
class EccoGame(ShowBase):
def __init__(self):
ShowBase.__init__(self)
base.setBackgroundColor(0, 0, 0)
game_title = "ECCO"
titleN = TextNode('game-title')
font = loader.loadFont("font/Caveman.ttf")
titleN.setFont(font)
titleN.setText(game_title)
titleN.setTextColor(1, 1, 1, 1)
titleN.setSlant(0.1)
titleN.setShadow(0.05)
titleN.setShadowColor(0, 0, 200, 1)
titleN.setFrameColor(0, 0, 255, 1)
titleN.setFrameLineWidth(5.0)
textNodePath = self.aspect2d.attachNewNode(titleN)
textNodePath.setPos(-0.4, 1.5, 0.5)
textNodePath.setScale(0.2)
self.level1Button = DirectButton(text=("Level 1"), scale=.1, pos=(0, 0, 0.2), command=self.level1)
self.level2Button = DirectButton(text=("Level 2"), scale=.1, pos=(0, 0, 0), command=self.level2)
def level1(self):
titleNp = self.aspect2d.find('game-title')
titleNp.removeNode()
self.level1Button.destroy()
self.level2Button.destroy()
self.sizescale = 0.6
self.setupWorld()
self.setupSky()
self.setupFloor()
self.setupCharacter()
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[Left key]: Turn Ecco Left")
self.inst3 = addInstructions(0.85, "[Right key]: Turn Ecco Right")
self.inst4 = addInstructions(0.80, "[Up key]: Jump Ecco")
inputState.watchWithModifiers('esc', 'escape')
inputState.watchWithModifiers('w', 'w')
inputState.watchWithModifiers('arrow_left', 'arrow_left')
inputState.watchWithModifiers('arrow_right', 'arrow_right')
inputState.watchWithModifiers('pause', 'p')
inputState.watchWithModifiers('space', 'space')
inputState.watchWithModifiers('arrow_up', 'arrow_up')
inputState.watchWithModifiers('cam-left', 'z')
inputState.watchWithModifiers('cam-right', 'x')
inputState.watchWithModifiers('cam-forward', 'c')
inputState.watchWithModifiers('cam-backward', 'v')
taskMgr.add(self.update, "update")
# Game state variables
self.isMoving = False
# display framerate
self.setFrameRateMeter(True)
# Set up the camera
self.disableMouse()
self.camera.setPos(self.characterNP.getX(), self.characterNP.getY() - 30, 4)
self.setupSound()
# coins variables
self.coinsCollected = 0
self.dictOfCoins = {}
self.coins = []
# Set up Coins as Collectables
self.setupCoins()
# Set up Obstacles
self.setupObstacles()
# Setup Level Display
self.setupLevelDisplay()
self.counter = 0
def setupLevelDisplay(self):
LEVEL_1 = "Level 1"
levelDisplay(LEVEL_1)
levelN = TextNode('level-display')
levelN.setText(LEVEL_1)
font = loader.loadFont("font/Caveman.ttf")
levelN.setFont(font)
levelN.setTextColor(1, 1, 1, 1)
levelN.setSlant(0.1)
levelN.setShadow(0.05)
levelN.setShadowColor(255, 0, 0, 1)
textNodePath = self.aspect2d.attachNewNode(levelN)
textNodePath.setPos(-0.45, 0, 0)
textNodePath.setScale(0.2)
def update(self, task):
dt = globalClock.getDt()
self.pos = self.characterNP.getPos()
self.counter = self.counter + 1
if self.counter == 150:
levelNp = self.aspect2d.find('level-display')
levelNp.removeNode()
self.setUpCamera()
self.processInput(dt)
self.processContacts()
self.coinScoreDisplay()
self.checkIfEccoDied()
self.world.doPhysics(dt, 10, 1 / 230.0)
return task.cont
def setupWorld(self):
# create bullet world
self.debugNP = self.render.attachNewNode(BulletDebugNode('Debug'))
#self.debugNP.show()
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
def setupSky(self):
self.milkyWayNp = render.attachNewNode('milkyway')
self.milkyWay_2Np = render.attachNewNode('milkyway_2')
self.marsNp = render.attachNewNode('mars')
self.sunNp = render.attachNewNode('sun')
# Load the model for the sky
# self.sky = loader.loadModel("models/sky/solar_sky_sphere")
self.sky = loader.loadModel("models/sky/solar_sky_sphere")
# Load the texture for the sky.
self.sky_tex = loader.loadTexture("models/sky/stars_1k_tex.jpg")
# Set the sky texture to the sky model
self.sky.setTexture(self.sky_tex, 1)
# Parent the sky model to the render node so that the sky is rendered
self.sky.reparentTo(self.render)
# Scale the size of the sky.
self.sky.setScale(15000)
x = 0.005
y = 1700.0
z = 0.0
self.sky.setPos(x, y, 0)
# #milkyway 1
self.milkyWay = loader.loadModel("models/sky/planet_sphere")
self.milkWay_tex = loader.loadTexture("models/sky/milkyway_tex.jpg")
self.milkyWay.setTexture(self.milkWay_tex, 1)
self.milkyWay.reparentTo(self.milkyWayNp)
self.milkyWay.setScale(200)
self.milkyWay.setPos(x + 2000, y + 10000, z - 500)
# milkyway 2
self.milkyWay_2 = loader.loadModel("models/sky/planet_sphere")
self.milkWay_2_tex = loader.loadTexture("models/sky/milkyway_2_tex.jpg")
self.milkyWay_2.setTexture(self.milkWay_2_tex, 1)
self.milkyWay_2.reparentTo(self.milkyWay_2Np)
self.milkyWay_2.setScale(400)
self.milkyWay_2.setPos(x - 3000, y + 10000, z + 500)
# sun
self.sun = loader.loadModel("models/sky/planet_sphere")
self.sun_tex = loader.loadTexture("models/sky/sun_2_tex.jpg")
self.sun.setTexture(self.sun_tex, 1)
self.sun.reparentTo(self.sunNp)
self.sun.setScale(600)
self.sun.setPos(x + 1000, y + 10000, z + 1000)
#
# Load Mars
self.mars = loader.loadModel("models/sky/planet_sphere")
self.mars_tex = loader.loadTexture("models/sky/mars_1k_tex.jpg")
self.mars.setTexture(self.mars_tex, 1)
self.mars.reparentTo(self.marsNp)
self.mars.setScale(200)
self.mars.setPos(x + 3000, y + 10000, z + 500)
def setupSound(self):
# Set up sound
mySound = base.loader.loadSfx("sounds/Farm Morning.ogg")
mySound.play()
mySound.setVolume(3.0)
mySound.setLoop(True)
footsteps = base.loader.loadSfx("sounds/Footsteps_on_Cement-Tim_Fryer.wav")
footsteps.play()
footsteps.setVolume(0.8)
footsteps.setLoop(True)
self.jumpSound = base.loader.loadSfx("sounds/Jump-SoundBible.com-1007297584.wav")
self.jumpSound.setVolume(0.2)
self.collectSound = base.loader.loadSfx("sounds/pin_dropping-Brian_Rocca-2084700791.wav")
self.gameOverSound = base.loader.loadSfx("sounds/Bike Horn-SoundBible.com-602544869.wav")
self.levelCompleteSound = base.loader.loadSfx("sounds/Ta Da-SoundBible.com-1884170640.wav")
def setupFloor(self):
size = Vec3(7.5, 3000, 1.81818)
shape = BulletBoxShape(size * 0.55)
# shape = BulletPlaneShape(Vec3(0, 0, 1), 0)
node = BulletRigidBodyNode('Box-Floor')
node.addShape(shape)
node.setMass(0)
stairNP = self.render.attachNewNode(node)
stairNP.setPos(0, 0, 0)
stairNP.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(stairNP.node())
modelNP = loader.loadModel('models/box.egg')
modelNP.reparentTo(stairNP)
modelNP.setPos(-size.x / 2.0, -size.y / 2.0, -size.z / 2.0)
modelNP.setScale(size)
def setupCharacter(self):
# Character
h = 1.75
w = 0.4
shape = BulletCapsuleShape(w, h - 2 * w, ZUp)
self.character = BulletCharacterControllerNode(shape, 0.4, 'Player')
self.character.setGravity(35)
self.characterNP = self.render.attachNewNode(self.character)
self.characterNP.setPos(0, 10, 5)
self.characterNP.setCollideMask(BitMask32.allOn())
self.world.attachCharacter(self.character)
self.ecco = Actor('ralph-models/ralph.egg.pz', {
'run': 'ralph-models/ralph-run.egg',
'jump': 'ralph/ralph-run.egg',
'damage': 'models/lack-damage.egg'})
self.ecco.reparentTo(self.characterNP)
self.ecco.setScale(0.7048)
self.ecco.setH(180)
def setUpCamera(self):
# If the camera is too far from ecco, move it closer.
# If the camera is too close to ecco, move it farther.
camvec = self.characterNP.getPos() - self.camera.getPos()
camvec.setZ(0.0)
camdist = camvec.length()
camvec.normalize()
if camdist > 10.0:
self.camera.setPos(self.camera.getPos() + camvec * (camdist - 40))
camdist = 10.0
if camdist < 5.0:
self.camera.setPos(self.camera.getPos() - camvec * (35 - camdist))
camdist = 5.0
def processInput(self, dt):
speed = Vec3(0, 0, 0)
if inputState.isSet('esc'): sys.exit()
if inputState.isSet('w'): speed.setY(35.0)
if inputState.isSet('arrow_left'): speed.setX(-35.0)
if inputState.isSet('arrow_right'): speed.setX(35.0)
if inputState.isSet('space'):
self.jump()
self.jumpSound.play()
if inputState.isSet('arrow_up'):
self.jump()
self.jumpSound.play()
if inputState.isSet('cam-left'): self.camera.setX(self.camera, -20 * dt)
if inputState.isSet('cam-right'): self.camera.setX(self.camera, +20 * dt)
if inputState.isSet('cam-forward'): self.camera.setY(self.camera, -200 * dt)
if inputState.isSet('cam-backward'): self.camera.setY(self.camera, +200 * dt)
# Make Ecco run
if self.isMoving is False:
self.ecco.loop("run")
self.isMoving = True
if self.pos.getY() > 1450.0:
speed.setY(0.0)
else:
speed.setY(40.0)
self.character.setLinearMovement(speed, True)
def jump(self):
self.character.setMaxJumpHeight(3.0)
self.character.setJumpSpeed(25.0)
self.character.doJump()
def setupCoins(self):
# display coins = 0
textN = TextNode('coin-score')
textN.setText(str("Coins: " + str(self.coinsCollected)))
textN.setSlant(0.1)
textNodePath = self.aspect2d.attachNewNode(textN)
textNodePath.setPos(0, 0.95, 0.9)
textNodePath.setScale(0.08)
randNum = random.sample(range(0, 1500, 200), 6)
# coins
for i in range(6):
randX = random.uniform(-3.0, 3.2)
randY = float(randNum[i])
shape = BulletSphereShape(0.3)
coinNode = BulletGhostNode('Coin-' + str(i))
coinNode.addShape(shape)
np = self.render.attachNewNode(coinNode)
np.setCollideMask(BitMask32.allOff())
np.setPos(randX, randY, 2)
# Adding sphere model
sphereNp = loader.loadModel('models/smiley.egg')
sphereNp_tex = loader.loadTexture("models/sky/coin_2_tex.jpg")
sphereNp.setTexture(sphereNp_tex, 1)
sphereNp.reparentTo(np)
sphereNp.setScale(0.45)
sphereNp.hprInterval(2.5, Vec3(360, 0, 0)).loop()
self.world.attachGhost(coinNode)
self.coins.append(coinNode)
print "node name:" + str(coinNode.getName())
def processContacts(self):
for coin in self.coins:
self.testWithSingleBody(coin)
self.coinsCollected = len(self.dictOfCoins)
def testWithSingleBody(self, secondNode):
contactResult = self.world.contactTestPair(self.character, secondNode)
if contactResult.getNumContacts() > 0:
self.collectSound.play()
for contact in contactResult.getContacts():
cp = contact.getManifoldPoint()
node0 = contact.getNode0()
node1 = contact.getNode1()
self.dictOfCoins[node1.getName()] = 1
np = self.render.find(node1.getName())
np.node().removeAllChildren()
self.world.removeGhost(np.node())
def setupObstacles(self):
# Obstacle
origin = Point3(2, 0, 0)
size = Vec3(2, 2.75, 1.5)
shape = BulletBoxShape(size * 0.55)
randNum1 = random.sample(range(0, 1500, 300), 3)
randNum2 = random.sample(range(0, 1500, 500), 3)
for i in range(2):
randX = random.uniform(-3.5, 3.5)
randY = float(randNum1[i])
pos = origin + size * i
ObstacleNP = self.render.attachNewNode(BulletRigidBodyNode('Obstacle%i' % i))
ObstacleNP.node().addShape(shape)
ObstacleNP.node().setMass(1.0)
ObstacleNP.setPos(randX, randY, 3)
ObstacleNP.setCollideMask(BitMask32.allOn())
modelNP = loader.loadModel('models/box.egg')
modelNP_tex = loader.loadTexture("models/sky/milkyway_tex.jpg")
modelNP.setTexture(modelNP_tex, 1)
modelNP.reparentTo(ObstacleNP)
# modelNP.setPos(0, 0, 0)
modelNP.setPos(-size.x / 2.0, -size.y / 2.0, -size.z / 2.0)
modelNP.setScale(size)
self.world.attachRigidBody(ObstacleNP.node())
size_2 = Vec3(3, 2.75, 1.5)
shape2 = BulletBoxShape(size_2 * 0.55)
for i in range(2):
randX = random.uniform(-3.5, 3.5)
randY = float(randNum2[i])
pos = origin + size_2 * i
pos.setY(0)
ObstacleNP = self.render.attachNewNode(BulletRigidBodyNode('ObstacleSmall%i' % i))
ObstacleNP.node().addShape(shape2)
ObstacleNP.node().setMass(1.0)
ObstacleNP.setPos(randX, randY, 2)
ObstacleNP.setCollideMask(BitMask32.allOn())
modelNP = loader.loadModel('models/box.egg')
modelNP_tex = loader.loadTexture("models/sky/moon_1k_tex.jpg")
modelNP.setTexture(modelNP_tex, 1)
modelNP.reparentTo(ObstacleNP)
# modelNP.setPos(0, 0, 0)
modelNP.setPos(-size_2.x / 2.0, -size_2.y / 2.0, -size_2.z / 2.0)
modelNP.setScale(size_2)
self.world.attachRigidBody(ObstacleNP.node())
def checkIfEccoDied(self):
print "position" + str(self.pos.getY())
if self.pos.getZ() > -50.0 and self.pos.getZ() < 0.0:
title = "Game Over"
levelCompleteN = TextNode('ecco-died')
font = loader.loadFont("font/Caveman.ttf")
levelCompleteN.setFont(font)
levelCompleteN.setText(title)
levelCompleteN.setTextColor(1, 1, 1, 1)
levelCompleteN.setSlant(0.1)
levelCompleteN.setShadow(0.03)
levelCompleteN.setShadowColor(0, 0, 200, 1)
# levelN.setFrameAsMargin(0, 0, 0, 0)
levelCompleteN.setFrameColor(200, 0, 0, 1)
levelCompleteN.setFrameLineWidth(5.0)
# textNp.node().setGlyphShift(1.0)
textNodePath = self.aspect2d.attachNewNode(levelCompleteN)
textNodePath.setPos(-0.9, 1.5, 0.5)
textNodePath.setScale(0.2)
if self.pos.getZ() < -49.0:
self.gameOverSound.play()
elif self.pos.getZ() < -50.0:
if self.gameOverSound.status() != self.gameOverSound.PLAYING:
sys.exit(1)
elif self.pos.getY() > 1300.0:
title = "Level 1 \n Complete"
levelCompleteN = TextNode('level-complete')
font = loader.loadFont("font/Caveman.ttf")
levelCompleteN.setFont(font)
levelCompleteN.setText(title)
levelCompleteN.setTextColor(1, 1, 1, 1)
levelCompleteN.setSlant(0.1)
levelCompleteN.setShadow(0.03)
levelCompleteN.setShadowColor(0, 0, 200, 1)
# levelN.setFrameAsMargin(0, 0, 0, 0)
levelCompleteN.setFrameColor(200, 0, 0, 1)
levelCompleteN.setFrameLineWidth(5.0)
# textNp.node().setGlyphShift(1.0)
textNodePath = self.aspect2d.attachNewNode(levelCompleteN)
textNodePath.setPos(-0.6, 1.5, 0.5)
textNodePath.setScale(0.2)
if self.levelCompleteSound.status() != self.levelCompleteSound.PLAYING:
self.levelCompleteSound.play()
else:
pass
def coinScoreDisplay(self):
textNp = self.aspect2d.find('coin-score')
textNp.node().clearText()
textNp.node().setText(str("Coins: " + str(self.coinsCollected)))
#Level 2
def level2(self):
titleNp2 = self.aspect2d.find('game-title')
titleNp2.removeNode()
self.level1Button.destroy()
self.level2Button.destroy()
self.sizescale2 = 0.6
self.setupWorld2()
self.setupSky2()
self.setupFloor2()
self.setupCharacter2()
# self.title = addTitle(" ")
self.inst12 = addInstructions(0.95, "[ESC]: Quit")
self.inst22 = addInstructions(0.90, "[Left key]: Turn Ecco Left")
self.inst32 = addInstructions(0.85, "[Right key]: Turn Ecco Right")
self.inst42 = addInstructions(0.80, "[Up key]: Jump Ecco")
inputState.watchWithModifiers('esc', 'escape')
inputState.watchWithModifiers('w', 'w')
inputState.watchWithModifiers('arrow_left', 'arrow_left')
inputState.watchWithModifiers('arrow_right', 'arrow_right')
inputState.watchWithModifiers('pause', 'p')
inputState.watchWithModifiers('space', 'space')
inputState.watchWithModifiers('arrow_up', 'arrow_up')
inputState.watchWithModifiers('cam-left', 'z')
inputState.watchWithModifiers('cam-right', 'x')
inputState.watchWithModifiers('cam-forward', 'c')
inputState.watchWithModifiers('cam-backward', 'v')
taskMgr.add(self.update2, "update")
# Game state variables
self.isMoving2 = False
# display framerate
self.setFrameRateMeter(True)
# Set up the camera
self.disableMouse()
self.camera.setPos(self.characterNP2.getX(), self.characterNP2.getY() - 30, 4)
self.setupSound2()
# coins variables
self.coinsCollected2 = 0
self.dictOfCoins2 = {}
self.coins2 = []
# Set up Coins as Collectables
self.setupCoins2()
# Set up Floaters with coins
self.setupFloaters2()
# Set up Obstacles
self.setupObstacles2()
# Setup Level Display
self.setupLevelDisplay2()
self.counter2 = 0
def setupLevelDisplay2(self):
LEVEL_2 = "Level 2"
levelDisplay(LEVEL_2)
levelN = TextNode('level-display')
levelN.setText(LEVEL_2)
# www.webpagepublicity.com
font = loader.loadFont("font/Caveman.ttf")
levelN.setFont(font)
levelN.setTextColor(1, 1, 1, 1)
levelN.setSlant(0.1)
levelN.setShadow(0.05)
levelN.setShadowColor(255, 0, 0, 1)
# levelN.setFrameAsMargin(0, 0, 0, 0)
# levelN.setFrameColor(0, 0, 255, 1)
# levelN.setFrameLineWidth(5.0)
# # textNp.node().setGlyphShift(1.0)
textNodePath = self.aspect2d.attachNewNode(levelN)
textNodePath.setPos(-0.45, 0, 0)
textNodePath.setScale(0.2)
def update2(self, task):
dt = globalClock.getDt()
self.pos2 = self.characterNP2.getPos()
self.counter2 = self.counter2 + 1
if self.counter2 == 150:
levelNp = self.aspect2d.find('level-display')
levelNp.removeNode()
self.setUpCamera2()
self.processInput2(dt)
self.processContacts2()
self.coinScoreDisplay2()
self.checkIfEccoDied2()
self.world2.doPhysics(dt, 10, 1 / 230.0)
return task.cont
def setupWorld2(self):
# create bullet world
self.debugNP = self.render.attachNewNode(BulletDebugNode('Debug'))
#self.debugNP.show()
self.world2 = BulletWorld()
self.world2.setGravity(Vec3(0, 0, -9.81))
self.world2.setDebugNode(self.debugNP.node())
def setupSky2(self):
self.milkyWayNp = render.attachNewNode('milkyway')
self.milkyWay_2Np = render.attachNewNode('milkyway_2')
self.marsNp = render.attachNewNode('mars')
self.sunNp = render.attachNewNode('sun')
# Load the model for the sky
# self.sky = loader.loadModel("models/sky/solar_sky_sphere")
self.sky = loader.loadModel("models/sky/solar_sky_sphere")
# Load the texture for the sky.
self.sky_tex = loader.loadTexture("models/sky/stars_1k_tex.jpg")
# Set the sky texture to the sky model
self.sky.setTexture(self.sky_tex, 1)
# Parent the sky model to the render node so that the sky is rendered
self.sky.reparentTo(self.render)
# Scale the size of the sky.
self.sky.setScale(15000)
x = 0.005
y = 1700.0
z = 0.0
self.sky.setPos(x, y, 0)
# #milkyway 1
self.milkyWay = loader.loadModel("models/sky/planet_sphere")
self.milkWay_tex = loader.loadTexture("models/sky/milkyway_tex.jpg")
self.milkyWay.setTexture(self.milkWay_tex, 1)
self.milkyWay.reparentTo(self.milkyWayNp)
self.milkyWay.setScale(200)
self.milkyWay.setPos(x + 2000, y + 10000, z - 500)
# milkyway 2
self.milkyWay_2 = loader.loadModel("models/sky/planet_sphere")
self.milkWay_2_tex = loader.loadTexture("models/sky/milkyway_2_tex.jpg")
self.milkyWay_2.setTexture(self.milkWay_2_tex, 1)
self.milkyWay_2.reparentTo(self.milkyWay_2Np)
self.milkyWay_2.setScale(400)
self.milkyWay_2.setPos(x - 3000, y + 10000, z + 500)
# sun
self.sun = loader.loadModel("models/sky/planet_sphere")
self.sun_tex = loader.loadTexture("models/sky/sun_2_tex.jpg")
self.sun.setTexture(self.sun_tex, 1)
self.sun.reparentTo(self.sunNp)
self.sun.setScale(600)
self.sun.setPos(x + 1000, y + 10000, z + 1000)
#
# Load Mars
self.mars = loader.loadModel("models/sky/planet_sphere")
self.mars_tex = loader.loadTexture("models/sky/mars_1k_tex.jpg")
self.mars.setTexture(self.mars_tex, 1)
self.mars.reparentTo(self.marsNp)
self.mars.setScale(200)
self.mars.setPos(x + 3000, y + 10000, z + 500)
def setUpCamera2(self):
# If the camera is too far from ecco, move it closer.
# If the camera is too close to ecco, move it farther.
camvec = self.characterNP2.getPos() - self.camera.getPos()
camvec.setZ(0.0)
camdist = camvec.length()
camvec.normalize()
if camdist > 10.0:
self.camera.setPos(self.camera.getPos() + camvec * (camdist - 40))
camdist = 10.0
if camdist < 5.0:
self.camera.setPos(self.camera.getPos() - camvec * (35 - camdist))
camdist = 5.0
def setupSound2(self):
# Set up sound
mySound = base.loader.loadSfx("sounds/Farm Morning.ogg")
mySound.play()
mySound.setVolume(3.0)
mySound.setLoop(True)
footsteps = base.loader.loadSfx("sounds/Footsteps_on_Cement-Tim_Fryer.wav")
footsteps.play()
footsteps.setVolume(0.8)
footsteps.setLoop(True)
self.jumpSound2 = base.loader.loadSfx("sounds/Jump-SoundBible.com-1007297584.wav")
self.jumpSound2.setVolume(0.2)
self.collectSound2 = base.loader.loadSfx("sounds/pin_dropping-Brian_Rocca-2084700791.wav")
self.gameOverSound2 = base.loader.loadSfx("sounds/Bike Horn-SoundBible.com-602544869.wav")
self.levelCompleteSound2 = base.loader.loadSfx("sounds/Ta Da-SoundBible.com-1884170640.wav")
def setupFloor2(self):
size = Vec3(7.5, 3000, 1.81818)
shape = BulletBoxShape(size * 0.55)
# shape = BulletPlaneShape(Vec3(0, 0, 1), 0)
node = BulletRigidBodyNode('Box-Floor')
node.addShape(shape)
node.setMass(0)
stairNP = self.render.attachNewNode(node)
stairNP.setPos(0, 0, 0)
stairNP.setCollideMask(BitMask32.allOn())
self.world2.attachRigidBody(stairNP.node())
modelNP = loader.loadModel('models/box.egg')
modelNP.reparentTo(stairNP)
modelNP.setPos(-size.x / 2.0, -size.y / 2.0, -size.z / 2.0)
modelNP.setScale(size)
def setupCharacter2(self):
# Character
h = 1.75
w = 0.4
shape = BulletCapsuleShape(w, h - 2 * w, ZUp)
self.character2 = BulletCharacterControllerNode(shape, 0.4, 'Player')
self.character2.setGravity(35)
self.characterNP2 = self.render.attachNewNode(self.character2)
self.characterNP2.setPos(0, 10, 5)
self.characterNP2.setCollideMask(BitMask32.allOn())
self.world2.attachCharacter(self.character2)
self.ecco2 = Actor('ralph-models/ralph.egg.pz', {
'run': 'ralph-models/ralph-run.egg',
'jump': 'ralph/ralph-run.egg',
'damage': 'models/lack-damage.egg'})
self.ecco2.reparentTo(self.characterNP2)
self.ecco2.setScale(0.7048)
self.ecco2.setH(180)
def processInput2(self, dt):
speed = Vec3(0, 0, 0)
if inputState.isSet('esc'): sys.exit()
if inputState.isSet('w'): speed.setY(35.0)
if inputState.isSet('arrow_left'): speed.setX(-35.0)
if inputState.isSet('arrow_right'): speed.setX(35.0)
if inputState.isSet('space'):
self.jump2()
self.jumpSound2.play()
if inputState.isSet('arrow_up'):
self.jump2()
self.jumpSound2.play()
if inputState.isSet('cam-left'): self.camera.setX(self.camera, -20 * dt)
if inputState.isSet('cam-right'): self.camera.setX(self.camera, +20 * dt)
if inputState.isSet('cam-forward'): self.camera.setY(self.camera, -200 * dt)
if inputState.isSet('cam-backward'): self.camera.setY(self.camera, +200 * dt)
# Make Ecco run
if self.isMoving2 is False:
self.ecco2.loop("run")
self.isMoving2 = True
if self.pos2.getY() > 1450.0:
speed.setY(0.0)
else:
speed.setY(40.0)
self.character2.setLinearMovement(speed, True)
def jump2(self):
self.character2.setMaxJumpHeight(3.0)
self.character2.setJumpSpeed(25.0)
self.character2.doJump()
def setupCoins2(self):
# display coins = 0
textN = TextNode('coin-score')
textN.setText(str("Coins: " + str(self.coinsCollected2)))
textN.setSlant(0.1)
textNodePath = self.aspect2d.attachNewNode(textN)
textNodePath.setPos(0, 0.95, 0.9)
textNodePath.setScale(0.08)
randNum = random.sample(range(0, 1500, 200), 6)
# coins
for i in range(6):
randX = random.uniform(-3.0, 3.2)
randY = float(randNum[i])
shape = BulletSphereShape(0.3)
coinNode = BulletGhostNode('Coin-' + str(i))
coinNode.addShape(shape)
np = self.render.attachNewNode(coinNode)
np.setCollideMask(BitMask32.allOff())
np.setPos(randX, randY, 2)
# Adding sphere model
sphereNp = loader.loadModel('models/smiley.egg')
sphereNp_tex = loader.loadTexture("models/sky/coin_2_tex.jpg")
sphereNp.setTexture(sphereNp_tex, 1)
sphereNp.reparentTo(np)
sphereNp.setScale(0.45)
sphereNp.hprInterval(2.5, Vec3(360, 0, 0)).loop()
self.world2.attachGhost(coinNode)
self.coins2.append(coinNode)
print "node name:" + str(coinNode.getName())
def setupObstacles2(self):
# Obstacle
origin = Point3(2, 0, 0)
size = Vec3(2, 2.75, 1.5)
shape = BulletBoxShape(size * 0.55)
randNum1 = random.sample(range(0, 1500, 300), 3)
randNum2 = random.sample(range(0, 1500, 500), 3)
for i in range(2):
randX = random.uniform(-3.5, 3.5)
randY = float(randNum1[i])
pos = origin + size * i
ObstacleNP = self.render.attachNewNode(BulletRigidBodyNode('Obstacle%i' % i))
ObstacleNP.node().addShape(shape)
ObstacleNP.node().setMass(1.0)
ObstacleNP.setPos(randX, randY, 3)
ObstacleNP.setCollideMask(BitMask32.allOn())
modelNP = loader.loadModel('models/box.egg')
modelNP_tex = loader.loadTexture("models/sky/milkyway_tex.jpg")
modelNP.setTexture(modelNP_tex, 1)
modelNP.reparentTo(ObstacleNP)
# modelNP.setPos(0, 0, 0)
modelNP.setPos(-size.x / 2.0, -size.y / 2.0, -size.z / 2.0)
modelNP.setScale(size)
self.world2.attachRigidBody(ObstacleNP.node())
size_2 = Vec3(3, 2.75, 1.5)
shape2 = BulletBoxShape(size_2 * 0.55)
for i in range(2):
randX = random.uniform(-3.5, 3.5)
randY = float(randNum2[i])
pos = origin + size_2 * i
pos.setY(0)
ObstacleNP = self.render.attachNewNode(BulletRigidBodyNode('ObstacleSmall%i' % i))
ObstacleNP.node().addShape(shape2)
ObstacleNP.node().setMass(1.0)
ObstacleNP.setPos(randX, randY, 2)
ObstacleNP.setCollideMask(BitMask32.allOn())
modelNP = loader.loadModel('models/box.egg')
modelNP_tex = loader.loadTexture("models/sky/moon_1k_tex.jpg")
modelNP.setTexture(modelNP_tex, 1)
modelNP.reparentTo(ObstacleNP)
# modelNP.setPos(0, 0, 0)
modelNP.setPos(-size_2.x / 2.0, -size_2.y / 2.0, -size_2.z / 2.0)
modelNP.setScale(size_2)
self.world2.attachRigidBody(ObstacleNP.node())
def setupFloaters2(self):
size = Vec3(3.5, 5.5, 0.3)
randNum = random.sample(range(10, 1500, 500), 3)
for i in range(3):
randX = random.randrange(-2, 3, 10)
randY = float(randNum[i])
# randY = random.randint(1000, 1500)
shape = BulletBoxShape(size * 0.55)
node = BulletRigidBodyNode('Floater')
node.setMass(0)
node.addShape(shape)
np = self.render.attachNewNode(node)
# np.setPos(9, 30, 3)
np.setPos(randX, randY, 6)
np.setR(0)
self.world2.attachRigidBody(node)
dummyNp = self.render.attachNewNode('milkyway')
dummyNp.setPos(randX, randY, 6)
modelNP = loader.loadModel('models/box.egg')
modelNP_tex = loader.loadTexture("models/sky/moon_tex.jpg")
modelNP.setTexture(modelNP_tex, 1)
modelNP.reparentTo(dummyNp)
modelNP.setPos(-1, 0, -1)
modelNP.setPos(-size.x / 2.0, -size.y / 2.0, -size.z / 2.0)
modelNP.setScale(size)
dummyNp.hprInterval(2.5, Vec3(360, 0, 0)).loop()
# Put A Coin On the Floater
shape = BulletSphereShape(0.75)
coinNode = BulletGhostNode('FloaterCoin-' + str(i))
coinNode.addShape(shape)
np = self.render.attachNewNode(coinNode)
np.setCollideMask(BitMask32.allOff())
# np.setPos(randX, randY, 2)
np.setPos(randX, randY, 7.0)
# Adding sphere model
sphereNp = loader.loadModel('models/smiley.egg')
sphereNp_tex = loader.loadTexture("models/sky/coin_2_tex.jpg")
sphereNp.setTexture(sphereNp_tex, 1)
sphereNp.reparentTo(np)
sphereNp.setScale(0.85)
sphereNp.hprInterval(1.5, Vec3(360, 0, 0)).loop()
self.world2.attachGhost(coinNode)
self.coins2.append(coinNode)
print "node name:" + str(coinNode.getName())
def processContacts2(self):
for coin in self.coins2:
self.testWithSingleBody2(coin)
self.coinsCollected2 = len(self.dictOfCoins2)
def testWithSingleBody2(self, secondNode):
contactResult = self.world2.contactTestPair(self.character2, secondNode)
if contactResult.getNumContacts() > 0:
self.collectSound2.play()
for contact in contactResult.getContacts():
cp = contact.getManifoldPoint()
node0 = contact.getNode0()
node1 = contact.getNode1()
self.dictOfCoins2[node1.getName()] = 1
np = self.render.find(node1.getName())
np.node().removeAllChildren()
self.world2.removeGhost(np.node())
def checkIfEccoDied2(self):
print "position" + str(self.pos2.getY())
if self.pos2.getZ() > -50.0 and self.pos2.getZ() < 0.0:
title = "Game Over"
levelCompleteN = TextNode('ecco-died')
font = loader.loadFont("font/Caveman.ttf")
levelCompleteN.setFont(font)
levelCompleteN.setText(title)
levelCompleteN.setTextColor(1, 1, 1, 1)
levelCompleteN.setSlant(0.1)
levelCompleteN.setShadow(0.03)
levelCompleteN.setShadowColor(0, 0, 200, 1)
# levelN.setFrameAsMargin(0, 0, 0, 0)
levelCompleteN.setFrameColor(200, 0, 0, 1)
levelCompleteN.setFrameLineWidth(5.0)
# textNp.node().setGlyphShift(1.0)
textNodePath = self.aspect2d.attachNewNode(levelCompleteN)
textNodePath.setPos(-0.9, 1.5, 0.5)
textNodePath.setScale(0.2)
if self.pos2.getZ() < -49.0:
self.gameOverSound2.play()
elif self.pos2.getZ() < -50.0:
if self.gameOverSound2.status() != self.gameOverSound2.PLAYING:
sys.exit(1)
elif self.pos2.getY() > 1300.0:
title = "Level 2 \n Complete"
levelCompleteN = TextNode('level-complete')
font = loader.loadFont("font/Caveman.ttf")
levelCompleteN.setFont(font)
levelCompleteN.setText(title)
levelCompleteN.setTextColor(1, 1, 1, 1)
levelCompleteN.setSlant(0.1)
levelCompleteN.setShadow(0.03)
levelCompleteN.setShadowColor(0, 0, 200, 1)
# levelN.setFrameAsMargin(0, 0, 0, 0)
levelCompleteN.setFrameColor(200, 0, 0, 1)
levelCompleteN.setFrameLineWidth(5.0)
# textNp.node().setGlyphShift(1.0)
textNodePath = self.aspect2d.attachNewNode(levelCompleteN)
textNodePath.setPos(-0.6, 1.5, 0.5)
textNodePath.setScale(0.2)
if self.levelCompleteSound2.status() != self.levelCompleteSound2.PLAYING:
self.levelCompleteSound2.play()
else:
pass
def coinScoreDisplay2(self):
textNp = self.aspect2d.find('coin-score')
textNp.node().clearText()
textNp.node().setText(str("Coins: " + str(self.coinsCollected2)))
class Human():
def __init__(self,parent, world, worldNP):
"""__init__
parameters:
self
parent: the World object
world: bullet world
worldNP: where in the world to put it
returns:
none
Description:
Create the human player
"""
self.traptime = 0
self.world = world
self.worldNP = worldNP
self.projectiles = list()
self.floatTraps = list()
self.keymap = {"left": 0, "right":0, "up":0,"down":0, "m1":0}
self.prevTime = 0
# panda walk
parent.accept("w",self.setKey,["up",1])
parent.accept("w-up",self.setKey,["up",0])
parent.accept("s",self.setKey,["down",1])
parent.accept("s-up",self.setKey,["down",0])
parent.accept("a",self.setKey,["left",1])
parent.accept("a-up",self.setKey,["left",0])
parent.accept("d",self.setKey,["right",1])
parent.accept("d-up",self.setKey,["right",0])
parent.accept("mouse1", self.setKey, ["m1",1])
self.velocity = 0
self.dir = (0,0,0)
self.vel = (0,0,0)
taskMgr.add(self.fpMove,"moveTask",sort=50)
taskMgr.add(self.mouseTask, 'mouseTask')
self.parent = parent
#self.human = self.parent.human
#self.human = collision.loadAndPositionModelFromFile("../assets/3d/Actors/robot rig 10 coll.egg",scale=.07,show=0)
self.human = Actor('../assets/3d/Actors/robot_idle_final_actor.egg', {
'idle':'../assets/3d/Actors/robot_idle_final_anim.egg',
# 'throw':'../assets/3d/Actors/animation eggs/robot_throw_final.egg',
# 'place':'../assets/3d/Actors/animation eggs/robot_place_final.egg',
# 'death':'../assets/3d/Actors/animation eggs/robot_death_final.egg',
})
#print self.human.find("**/eyes_sphere").getPos()
#self.human.flattenLight()
print self.human.ls()
#self.human.node().getChild(0).removeChild(0)
self.human.setH(camera.getH()+180)
campos = self.human.getPos()
campos[2] = campos[2]-5
camera.lookAt(campos)
pnode = ModelRoot("player")
self.player = render.attachNewNode(pnode)
pc = self.player.attachNewNode(CollisionNode("playerCollision"))
pc.node().addSolid(CollisionRay(0,0,-1,0,0,1))
self.playerCnode = pc
self.player.setPos(0,0,1)
#self.human.play('idle')
self.human.loop('idle')
def bulletInit(self,world,pos):
"""bulletInit
parameters:
self
task: the tskMgr structure
returns:
none
Description:
The rest of init requires bullet things
"""
oldpath = self.human.find("**/body_coll")
self.shape = BulletSphereShape(10)#oldpath.node().getSolid(0).getRadius())
self.character = BulletCharacterControllerNode(self.shape, 0.4, 'Human')
self.characterNP = render.attachNewNode(self.character)
self.characterNP.setPos(pos[0],pos[1],pos[2])
self.character.setGravity(0)
#self.human.setPos(pos)
self.human.reparentTo(self.characterNP)
self.human.hide()
#self.player.setPos(pos)
self.player.reparentTo(self.characterNP)
self.characterNP.setCollideMask(BitMask32.allOn())
world.attachCharacter(self.character)
def fpMove(self,task):
"""fpMove
parameters:
self
task: the taskMgr structure
returns:
none
Description:
player movement
"""
dt = task.time-self.prevTime
camera.setPos(self.player.getPos()+(0,0,1))
damp = (1.-(.2*dt))
self.vel = map(lambda x: damp*x, self.vel)
if self.traptime>0:
self.traptime = self.traptime-dt
#self.human.setZ(self.player.getZ()-.5)
#if not self.parent.editMode:
#camera.setPos(self.player.getPos()-(0.0264076, 4.60993, -10.0715))
self.prevTime = task.time
pos = self.player.getParent().getPos()
delta = 10*dt
h = deg2Rad(camera.getH())
p = deg2Rad(camera.getP())
# player control
if self.keymap["up"] and self.traptime<=0:
dir = (-cos(p)*sin(h), cos(p)*cos(h), sin(p))
self.vel = map(lambda i: self.vel[i]+dir[i]*delta, range(3))
if self.keymap["down"] and self.traptime<=0:
dir = (-cos(p)*sin(h), cos(p)*cos(h), sin(p))
self.vel = map(lambda i: self.vel[i]-dir[i]*delta, range(3))
if self.keymap["m1"] and self.traptime<=0:
weapon = self.parent.overlay.wepCounter
if self.parent.overlay.wepAmmo[weapon] > 0:
self.parent.overlay.changeAmmo(weapon, -1)
if weapon == 0:
self.launch()
dir = (-cos(p)*sin(h), cos(p)*cos(h), sin(p))
self.vel = map(lambda i: self.vel[i]-dir[i]*100, range(3))
elif weapon == 1:
self.placeFloatTrap()
elif weapon == 2:
self.placeClawTrap()
self.keymap["m1"] = 0
self.character.setAngularMovement(0)
self.character.setLinearMovement(LVector3(self.vel[0],self.vel[1],self.vel[2]),True)
#get displacement
dis = (self.vel[0]*dt,self.vel[1]*dt,self.vel[2]*dt)
#set the new position
self.player.setPos(pos[0]+dis[0],pos[1]+dis[1],pos[2]+dis[2])
self.human.setPos(pos[0]+dis[0],pos[1]+dis[1],pos[2]+dis[2])
#self.human.setX(self.player.getX()+sin(deg2Rad(camera.getH())+math.pi))
#self.human.setY(self.player.getY()-cos(deg2Rad(camera.getH())+math.pi))
return task.cont
def launch(self):
"""launch
parameters:
self
returns:
none
Description:
Fire a projectile
"""
self.projectiles.append(Projectile(self.player.getPos(),deg2Rad(camera.getH()),deg2Rad(camera.getP()),self,self.vel, self.world, self.worldNP))
def placeFloatTrap(self):
"""placeFloatTrap
parameters:
self
returns:
none
Description:
Place a float trap
"""
self.floatTraps.append(floatTrap(self.player.getPos(),self.world,self.worldNP))
def placeClawTrap(self):
"""placeClawTrap
parameters:
self
returns:
none
Description:
Place a claw trap
"""
trap = clawTrap(self.world,self.worldNP)
weapon = self.parent.overlay.wepCounter
self.parent.overlay.changeAmmo(weapon, trap.failed)
def setKey(self,key,value):
self.keymap[key] = value
def mouseTask(self,task):
"""mouseTask
parameters:
self
task: the tskMgr structure
returns:
none
Description:
Keep track of the mouse and record its movement
"""
global mousePos, mousePrevPos
if (not base.mouseWatcherNode.hasMouse() ): return Task.cont
# Get mouse coordinates from mouse watcher
x=base.mouseWatcherNode.getMouseX()
y=base.mouseWatcherNode.getMouseY()
mousePos = [x,y]
# Calculate mouse movement from last frame and output (print)
move = [mousePos[0],mousePos[1]]
if move==[0,0]: return Task.cont
#print "Moved:\t %f right, \t %f up." %(move[0], move[1])
base.win.movePointer(0, base.win.getXSize() / 2, base.win.getYSize() / 2)
# Save current position for next calculation
mousePrevPos = mousePos
camera.setP(camera.getP()+75*move[1])
camera.setH(camera.getH()-75*move[0])
self.human.setH(camera.getH()+180)
self.human.setX(self.player.getX()+sin(deg2Rad(camera.getH()+180)))
self.human.setY(self.player.getY()-cos(deg2Rad(camera.getH()+180)))
contacts = self.world.contactTest(self.character).getContacts()
for c in contacts:
contactObject = c.getNode0()
if c.getNode0().getName()=="Human":
contactObject = c.getNode1()
if contactObject.getName()=="env":
self.vel = map(lambda x: x*.9, self.vel)
return Task.cont
def die(self,event):
"""die
parameters:
self
task: the tskMgr structure
returns:
none
Description:
Kill the player
"""
#base.cTrav.removeCollider(self.wheelsphere)
self.human.node().getChild(0).removeChild(0)
self.filters.setInverted()
print "You Died!"
def trap1(self):
"""trap1
parameters:
self
returns:
none
Description:
Inflict the floating trap penalty
"""
self.vel = map(lambda x: x*.25, self.vel)
self.traptime = self.traptime + 20
return
def trap2(self):
"""trap2
parameters:
self
returns:
none
Description:
Inflict the claw trap penalty
"""
self.vel = (0,0,0)
self.traptime = self.traptime + 30
return
def impact(self,vel):
diff = map(lambda i: self.vel[i]-vel[i], range(3))
self.vel = map(lambda i: self.vel[i]-diff[i], range(3))
