def generateToonMoveTrack(self, toon):
node = NodePath('tempNode')
displacement = Vec3(toon.getPos(render) - self.getPos(render))
displacement.setZ(0)
displacement.normalize()
movieDistance = self.movieNode.getDistance(self.rotateNode)
displacement *= movieDistance
node.reparentTo(render)
node.setPos(displacement + self.getPos(render))
node.lookAt(self)
heading = PythonUtil.fitDestAngle2Src(toon.getH(render),
node.getH(render))
hpr = toon.getHpr(render)
hpr.setX(heading)
finalX = node.getX(render)
finalY = node.getY(render)
finalZ = node.getZ(render)
node.removeNode()
toonTrack = Sequence(
Parallel(
ActorInterval(toon, 'walk', loop=True, duration=1),
Parallel(
LerpPosInterval(toon,
1.0,
Point3(finalX, finalY, toon.getZ(render)),
fluid=True,
bakeInStart=False)),
LerpHprInterval(toon, 1.0, hpr=hpr)),
Func(toon.loop, 'neutral'))
return toonTrack
def loadImageAsPlane(filepath, yresolution = 600):
tex = loader.loadTexture(filepath)
tex.setBorderColor(Vec4(0,0,0,0))
tex.setWrapU(Texture.WMBorderColor)
tex.setWrapV(Texture.WMBorderColor)
cm = CardMaker(filepath + ' card')
cm.setFrame(-tex.getOrigFileXSize(), tex.getOrigFileXSize(), -tex.getOrigFileYSize(), tex.getOrigFileYSize())
card = NodePath(cm.generate())
card.setTransparency(TransparencyAttrib.MAlpha)
card.setTexture(tex)
card.setZ(card.getZ()+0.018)
card.setScale(card.getScale()/ yresolution)
card.flattenLight() # apply scale
return card
class Ship:
def __init__(self, game):
self.game = game
self.shipPoint = NodePath(PandaNode("shipFloaterPoint"))
self.shipPoint.reparentTo(render)
self.x_pos = 0
self.z_pos = 0
self.x_speed = 0
self.z_speed = 0
self.x_pid = PID(3.0, 5.0, 1.0)
self.z_pid = PID(3.0, 5.0, 1.0)
self.model = Actor("data/ship.egg")
self.model.setPos(0, 0, 0)
self.model.setHpr(0, 0, 0)
self.normal_speed = 3.5
self.low_speed = 2
self.speed = self.normal_speed
self.cool_down = 0.1
self.last_shoot = 0
self.keyMap = {
"up": 0,
"down": 0,
"left": 0,
"right": 0,
"brake": 0,
"attack": 0,
}
# This list will stored fired bullets.
self.bullets = []
self.game.accept("mouse1", self.setKey, ["attack", 1])
self.game.accept("mouse1-up", self.setKey, ["attack", 0])
self.game.accept("shift-mouse1", self.setKey, ["attack", 1])
self.game.accept("shift-mouse1-up", self.setKey, ["attack", 0])
self.game.accept("x", self.setKey, ["attack", 1])
self.game.accept("x-up", self.setKey, ["attack", 0])
self.game.accept("c", self.setKey, ["brake", 1])
self.game.accept("c-up", self.setKey, ["brake", 0])
self.game.accept("arrow_up", self.setKey, ["up", 1])
self.game.accept("arrow_up-up", self.setKey, ["up", 0])
self.game.accept("arrow_down", self.setKey, ["down", 1])
self.game.accept("arrow_down-up", self.setKey, ["down", 0])
self.game.accept("arrow_left", self.setKey, ["left", 1])
self.game.accept("arrow_left-up", self.setKey, ["left", 0])
self.game.accept("arrow_right", self.setKey, ["right", 1])
self.game.accept("arrow_right-up", self.setKey, ["right", 0])
def setKey(self, key, value):
self.keyMap[key] = value
def draw(self):
self.model.reparentTo(render)
def update(self, task):
dt = globalClock.getDt()
# Movement
if self.keyMap["brake"]:
self.speed = self.low_speed
else:
self.speed = self.normal_speed
if self.game.ship_control_type == 0:
if self.keyMap["up"]:
self.model.setZ(self.model, self.speed * dt)
elif self.keyMap["down"]:
self.model.setZ(self.model, -self.speed * dt)
if self.keyMap["left"]:
self.model.setX(self.model, -self.speed * dt)
elif self.keyMap["right"]:
self.model.setX(self.model, self.speed * dt)
elif self.game.ship_control_type == 1:
self.x_pos = self.shipPoint.getX()
self.z_pos = self.shipPoint.getZ()
self.x_pid.setPoint(self.x_pos)
self.z_pid.setPoint(self.z_pos)
pid_x = self.x_pid.update(self.model.getX())
pid_z = self.z_pid.update(self.model.getZ())
self.x_speed_ = pid_x
self.z_speed = pid_z
self.x_speed_ = min(self.speed, self.x_speed_)
self.x_speed_ = max(-self.speed, self.x_speed_)
self.z_speed = min(self.speed, self.z_speed)
self.z_speed = max(-self.speed, self.z_speed)
self.model.setX(self.model, self.x_speed_ * dt)
self.model.setZ(self.model, self.z_speed * dt)
# Shoot
if self.keyMap["attack"]:
current_shoot_time = task.time
if current_shoot_time - self.last_shoot >= self.cool_down:
self.last_shoot = current_shoot_time
self.bullet = Bullet(self)
return task.cont
def generateNode(self):
self.destroy()
self.node = NodePath('gameobjectnode')
self.node.setTwoSided(True)
self.node.reparentTo(self.parent.node)
if self.properties['avoidable'] == True:
self.node.setTag("avoidable", 'true')
else:
self.node.setTag("avoidable", 'false')
#setting scripting part
self.node.setTag("onWalked", self.onWalked)
self.node.setTag("onPicked", self.onPicked)
#set unique id
self.node.setTag("id", self.properties['id'])
tex = loader.loadTexture(resourceManager.getResource(self.properties['url'])+'.png')
tex.setWrapV(Texture.WM_clamp)
tex.setWrapU(Texture.WM_clamp)
#this is true pixel art
#change to FTLinear for linear interpolation between pixel colors
tex.setMagfilter(Texture.FTNearest)
tex.setMinfilter(Texture.FTNearest)
xorig = tex.getOrigFileXSize() / self.baseDimension
yorig = tex.getOrigFileYSize() / self.baseDimension
xscaled = (tex.getOrigFileXSize() / self.baseDimension) * self.properties['scale']
yscaled = (tex.getOrigFileYSize() / self.baseDimension) * self.properties['scale']
self.node.setTag("xscaled", str(xscaled))
self.node.setTag("yscaled", str(yscaled))
cm = CardMaker("tileobject")
cm.setFrame(0,xorig,0,yorig)
ts = TextureStage('ts')
ts.setMode(TextureStage.MDecal)
# distinguish between 3d collisions (for objects with an height and sensible self.properties['inclination'])
# and 2d collisions for plain sprites
if self.properties['walkable'] == 'false':
if self.properties['collisionmode'] == "3d":
#must handle differently objects which are small and big
if xscaled < 1:
self.collisionTube = CollisionBox(LPoint3f(0.5 - xscaled/2 - self.properties['offsetwidth'],0,0),LPoint3f(0.5 + xscaled/2 + self.properties['offsetwidth'],0.1,0.3 + self.properties['offsetheight']))
if xscaled >= 1:
self.collisionTube = CollisionBox(LPoint3f(0 - self.properties['offsetwidth'],0,0),LPoint3f(xscaled + self.properties['offsetwidth'],0.1,0.3 + self.properties['offsetheight']))
self.collisionNode = CollisionNode('objectSphere')
self.collisionNode.addSolid(self.collisionTube)
self.collisionNodeNp = self.node.attachNewNode(self.collisionNode)
self.collisionNodeNp.setX(self.properties['offsethorizontal'])
self.collisionNodeNp.setZ(self.properties['offsetvertical'])
self.collisionNodeNp.setX(self.collisionNodeNp.getX()+self.properties['offsetcollisionh'])
self.collisionNodeNp.setZ(self.collisionNodeNp.getZ()+self.properties['offsetcollisionv']+0.1)
if main.editormode:
self.collisionNodeNp.show()
elif self.properties['collisionmode'] == "2d":
#must handle differently objects which are small and big
if xscaled < 1:
self.collisionTube = CollisionBox(LPoint3f(0.5 - xscaled/2 - self.properties['offsetwidth'],0,0),LPoint3f(0.5 + xscaled/2 + self.properties['offsetwidth'],yscaled + self.properties['offsetheight'],0.3))
if xscaled >= 1:
self.collisionTube = CollisionBox(LPoint3f(0 - self.properties['offsetwidth'],0,0),LPoint3f(xscaled + self.properties['offsetwidth'],yscaled + self.properties['offsetheight'],0.3))
self.collisionNode = CollisionNode('objectSphere')
self.collisionNode.addSolid(self.collisionTube)
self.collisionNodeNp = self.node.attachNewNode(self.collisionNode)
self.collisionNodeNp.setP(-(270-int(self.properties['inclination'])))
self.collisionNodeNp.setX(self.properties['offsethorizontal'])
self.collisionNodeNp.setZ(self.properties['offsetvertical'])
self.collisionNodeNp.setX(self.collisionNodeNp.getX()+self.properties['offsetcollisionh'])
self.collisionNodeNp.setZ(self.collisionNodeNp.getZ()+self.properties['offsetcollisionv']+0.1)
if main.editormode:
self.collisionNodeNp.show()
geomnode = NodePath(cm.generate())
if geomnode.node().isGeomNode():
vdata = geomnode.node().modifyGeom(0).modifyVertexData()
writer = GeomVertexWriter(vdata, 'vertex')
reader = GeomVertexReader(vdata, 'vertex')
'''
this part apply rotation flattening to the perspective view
by modifying directly structure vertices
'''
i = 0 #counter
while not reader.isAtEnd():
v = reader.getData3f()
x = v[0]
y = v[1]
z = v[2]
newx = x
newy = y
newz = z
if self.properties['rotation'] == -90.0:
if i == 0:
newx = math.fabs(math.cos(math.radians(self.properties['inclination']))) * z
newz = 0
ssen = math.fabs(math.sin(math.radians(self.properties['inclination']))) * z
sparsen = math.fabs(math.sin(math.radians(self.properties['inclination']))) * ssen
spercos = math.fabs(math.cos(math.radians(self.properties['inclination']))) * ssen
newy -= spercos
newz += sparsen
if i == 2:
newx += math.fabs(math.cos(math.radians(self.properties['inclination']))) * z
newz = 0
ssen = math.fabs(math.sin(math.radians(self.properties['inclination']))) * z
sparsen = math.fabs(math.sin(math.radians(self.properties['inclination']))) * ssen
spercos = math.fabs(math.cos(math.radians(self.properties['inclination']))) * ssen
newy -= spercos
newz += sparsen
writer.setData3f(newx, newy, newz)
i += 1 #increase vertex counter
if xscaled >= 1:
geomnode.setX(0)
if xscaled < 1:
geomnode.setX(0.5 - xscaled/2)
geomnode.setScale(self.properties['scale'])
geomnode.setX(geomnode.getX()+self.properties['offsethorizontal'])
geomnode.setZ(geomnode.getZ()+self.properties['offsetvertical'])
geomnode.setY(-self.properties['elevation'])
geomnode.setP(int(self.properties['inclination'])-360)
geomnode.setTexture(tex)
geomnode.setTransparency(TransparencyAttrib.MAlpha)
geomnode.reparentTo(self.node)
self.node.setR(self.properties['rotation'])
class Vehicle(ActorNode):
def __init__(self, parent=None):
'''
Create a new Vehicle node. Physics should be initialized before any
instances of Vehicle are created.
arguments:
parent -- A PandaNode for the vehicle to attach to. Default is None,
in which case the Vehicle should be added to the scene
graph via NodePath.attachNewNode().
'''
ActorNode.__init__(self, 'VehiclePhysics')
base.physicsMgr.attachPhysicalNode(self)
self.getPhysicsObject().setMass(MASS)
if parent:
self.myPath = parent.attachNewNode(self)
else:
self.myPath = NodePath(self)
# Load vehicle model and place in the transparent bin.
vehicleModel = loader.loadModel(MODEL_PATH)
hull = vehicleModel.find('**/Hull')
hull.setBin('transparent', 30)
pwnsEnclosure = vehicleModel.find('**/Pwns_Enclosure')
pwnsEnclosure.setBin('transparent', 30)
self.myPath.setPos(0, 0, -0.0)
selectable = self.myPath.attachNewNode(SelectableNode('vehicle sel'))
vehicleModel.reparentTo(selectable)
# ==== Initialize Physics ==== #
thrusterForceNode = ForceNode('ThrusterForce')
self.myPath.attachNewNode(thrusterForceNode)
self.linearForce = LinearVectorForce(0, 0, 0)
self.linearForce.setMassDependent(1)
self.angularForce = AngularVectorForce(0, 0, 0)
thrusterForceNode.addForce(self.linearForce)
thrusterForceNode.addForce(self.angularForce)
self.getPhysical(0).addLinearForce(self.linearForce)
self.getPhysical(0).addAngularForce(self.angularForce)
self.previousXY = (self.myPath.getX(), self.myPath.getY())
self.tm = ThrusterManager()
# Add self.updatePhysics to the task manager and run this task as
# frequently as possible.
self.updatePhysicsTask = taskMgr.add(self.updatePhysics,
'UpdatePhysics')
# ==== Initialize Cameras ==== #
lens = PerspectiveLens()
lens.setNearFar(0.05, 100.0)
#Use either FocalLength or Fov. Fov ~40 is about what actual forward cameras are
#lens.setFocalLength(0.8)
lens.setFov(70, 70)
camera = Camera("Forward_left", lens).getPath()
camera.reparentTo(vehicleModel.find('**/Forward_Camera'))
camera.setX(camera.getX() - 0.1) # Forward cameras 20cm apart
camera.setY(
camera.getY() +
0.05) # Move in front of torpedo tubes to avoid abstruction
camera.setHpr(0, 0, 0)
camera = Camera("Forward_right", lens).getPath()
camera.reparentTo(vehicleModel.find('**/Forward_Camera'))
camera.setX(camera.getX() + 0.1) # Forward cameras 20cm apart
camera.setY(
camera.getY() +
0.05) # Move in front of torpedo tubes to avoid abstruction
camera.setHpr(0, 0, 0)
lens = PerspectiveLens()
lens.setNearFar(0.05, 100.0)
lens.setFocalLength(0.8)
camera = Camera("Downward", lens).getPath()
camera.reparentTo(vehicleModel.find('**/Downward_Camera'))
camera.setHpr(0, -90, 0)
#Layout link (to access hydrophone information)
self.layout = None
#Hydrophone variables
self.start_time = time()
self.last_hydro_update = time()
def setLayout(self, layout):
#Add a link to the layout to allow for referencing other objects
#This is necessary for the hydrophone addition
self.layout = layout
def getDepth(self):
''' Returns the depth of the vehicle, in meters. '''
return -0.15 - self.myPath.getZ()
def getHeading(self):
''' Returns the heading of the vehicle, in clockwise degrees. '''
# Panda uses counter-clockwise degrees, with the range (-180, 180].
heading = self.myPath.getH()
if heading < 0:
return -heading
elif heading > 0:
return 360 - heading
else:
return 0
def updatePhysics(self, task):
'''
Use the motor PWM values calculated by the controller to apply forces
to the simulated vehicle.
This runs at every frame, so it needs to complete quickly.
'''
outputs = shm.kalman.get()
self.tm.update(outputs)
passive_wrench = vehicle.passive_forces(outputs, self.tm)
passive_forces, passive_torques = passive_wrench[:3], \
passive_wrench[3:]
# Get motor thrusts
thrusts = np.array(self.tm.get_thrusts())
# Add passive forces and torques to that produced by thrusters,
# converting them to sub space first.
force = self.tm.total_thrust(thrusts) + \
self.tm.orientation.conjugate() * passive_forces
torque = self.tm.total_torque(thrusts) + \
self.tm.orientation.conjugate() * passive_torques
# Finally apply forces and torques to the model
# we also need to account for panda3d's strange coordinate system
# (x and y are flipped and z points up (instead of down))
self.linearForce.setVector(force_subspace[1], \
force_subspace[0], \
-force_subspace[2])
# We're supposed to use axis angle here, but I'm being sneaky
# and using the torque vector directly, i.e. non normalized axis angle
# with the hopes that this LRotationf constructor will figure it out
self.angularForce.setQuat(\
LRotationf(LVector3f(torque_subspace[1], \
torque_subspace[0], \
-torque_subspace[2]), 1))
# Update shared variables for controller
outputs.heading = self.getHeading()
outputs.pitch = self.myPath.getP()
outputs.roll = self.myPath.getR()
# This velocity is in world space
# We need to put it into THRUST CONVENTION SPACE
# which we assume kalman outputs in...
velocity = self.getPhysicsObject().getVelocity()
# Bring the velocity into THRUST CONVENTION SPACE
# Don't forget to account for panda's coordinate system
velocity = self.tm.heading_quat.conjugate() * \
np.array((velocity.getY(), velocity.getX(), -velocity.getZ()))
outputs.velx = velocity[0]
outputs.vely = velocity[1]
outputs.depth_rate = velocity[2]
outputs.depth = self.getDepth()
outputs.north = self.myPath.getY()
outputs.east = self.myPath.getX()
dX = self.myPath.getX() - self.previousXY[0]
dY = self.myPath.getY() - self.previousXY[1]
# Forward and sway are in THRUST CONVENTION SPACE
# don't forget to account for panda's coordinate system
dF, dS, dD = self.tm.heading_quat.conjugate() * np.array((dY, dX, 0.0))
outputs.forward += dF
outputs.sway += dS
# Output some quaternions, accounting for Panda's coordinate system
outputs.q0, outputs.q2, outputs.q1, outputs.q3 = self.myPath.getQuat()
outputs.q3 *= -1.0
shm.kalman.set(outputs)
svHeadingInt.set(self.getHeading())
svDepth.set(self.getDepth())
#XXX: Approximate altitude assuming that the pool is 12 feet deep
svAltitude.set(3.6 - self.getDepth())
svDvlDmgNorth.set(self.myPath.getY())
svDvlDmgEast.set(self.myPath.getX())
self.previousXY = (self.myPath.getX(), self.myPath.getY()) #update
self.output_hydro_data()
return Task.cont
def output_hydro_data(self):
#Update simulated hydrophone values
pingers = [] #Get all pingers from the layout
for element in self.layout.elements:
if element.getTypeName() == "Pinger":
pingers.append(element)
HYDRO_TICK_PERIOD = 1
if time() - self.last_hydro_update > HYDRO_TICK_PERIOD:
dt = time() - self.last_hydro_update
self.last_hydro_update = time()
if shm.hydrophones_settings.dsp_mode.get() == 1: #Search mode
#Incr search count
shm.hydrophones_results.search_count.set(
shm.hydrophones_results.search_count.get() + 1)
#Generate proper "hydrophone bins" marks
sb = 0
for p in pingers:
f = p.pinger_frequency
dc = (f - (shm.hydrophones_settings.searchCenter.get() -
shm.hydrophones_settings.searchDelta.get())
) / shm.hydrophones_settings.searchStep.get() + 0.5
sb |= 1 << int(dc)
shm.hydrophones_results.search_bins.set(sb)
else: #Track Mode
#Incr ping count
shm.hydrophones_results.ping_count.set(
shm.hydrophones_results.ping_count.get() + 1)
#Determine which pinger we are actively tracking (within 0.7khz of target)
targetp = None
for p in pingers:
if abs(shm.hydrophones_settings.trackFrequency.get() -
p.pinger_frequency) < 700:
targetp = p
if targetp is not None:
shm.hydrophones_results.intensity.set(
int(shm.hydrophones_settings.trackMagThresh.get() +
1e4 * random()))
shm.hydrophones_results.ping_time.set(int(dt * 1000))
pp = targetp.path.getPos()
vv = vector.Vector(self.myPath.getY(), self.myPath.getX())
pv = vector.Vector(pp.getY(), pp.getX())
#heading
dv = pv - vv
ang = vector.GetAuvAngle(dv)
hdiff = helpers.heading_diff(self.getHeading(), ang)
shm.hydrophones_results.heading.set(hdiff)
#elevation
dh = self.myPath.getZ() - pp.getZ()
dist = vector.Length(dv)
elev = math.degrees(math.atan2(dist, dh))
elev = min(elev, 90)
shm.hydrophones_results.elevation.set(elev)
#phase calculations
dy = self.myPath.getY() - pp.getY()
dx = self.myPath.getX() - pp.getX()
yang = math.degrees(math.atan2(dist, dy))
xang = math.degrees(math.atan2(dist, dx))
shm.hydrophones_results.phaseX.set((90.0 - xang) / 90.0)
shm.hydrophones_results.phaseY.set((90.0 - yang) / 90.0)
shm.hydrophones_results.phaseZ.set((90.0 - elev) / 90.0)
else:
shm.hydrophones_results.heading.set(0)
shm.hydrophones_results.elevation.set(0)
shm.hydrophones_results.intensity.set(0)
shm.hydrophones_results.ping_time.set(0)
shm.hydrophones_results.uptime.set(int(time() - self.start_time))
def __del__(self):
''' Remove update tasks from the panda task manager. '''
taskMgr.remove(self.updatePhysicsTask)
ActorNode.__del__(self)
class CameraHandler():
"""Hold the different cameras"""
def __init__(self, _engine, _mode):
self.mode = _mode
self.engine = _engine
self.camDummy = None
player = self.engine.GameObjects["player"].bulletBody
if self.mode == "TPA":
self.initTPAMode(player)
else:
self.initTPSMode(player)
def update(self, dt):
if self.mode == "TPA":
self.followPlayerTPA(dt)
else:
self.followPlayerTPS(dt)
def stop(self):
base.camera.reparentTo(render)
base.camera.setPos(0,0,0)
#
# Third person shooter mode
#
def initTPSMode(self, player):
"""Sets the cam mode to a third person shooter mode, so the
cam will be up and behind the player as well as always look
in the direction the player faces"""
# Setup the camera so that its on the player
self.camDummy = NodePath(PandaNode("camDummy"))
self.camDummy.reparentTo(player.movementParent)
self.camDummy.setPos(0, 0, 1.8)
base.camera.reparentTo(self.camDummy)
base.camera.setPos(0, -8, 2)
def followPlayerTPS(self, dt):
player = self.engine.GameObjects["player"].bulletBody
ih = self.engine.inputHandler
if base.win.movePointer(0, ih.winXhalf, ih.winYhalf) \
and base.mouseWatcherNode.hasMouse():
cam = self.camDummy.getP() - (ih.mouseY - ih.winYhalf) * ih.mouseSpeedY
if cam <-80:
cam = -80
elif cam > 90:
cam = 90
self.camDummy.setP(cam)
base.camera.lookAt(self.camDummy)
#
# Third person adventure mode
#
def initTPAMode(self, player):
"""Sets the cam mode to a third person adventure mode, so the
cam will be up and behind the player and will be lazily move
behind the player."""
# create a new dummy node that the cam will look at
self.camDummy = NodePath(PandaNode("camDummy"))
self.camDummy.reparentTo(render)
# Setup the camera so that its on the player
base.camera.reparentTo(self.camDummy)
base.camera.setPos(player.getX(), player.getY() - 6.0, player.getZ() + 4.0)
def followPlayerTPA(self, dt):
player = self.engine.GameObjects["player"].bulletBody
base.camera.lookAt(player.getPos())
ih = self.engine.inputHandler
if base.win.movePointer(0, ih.winXhalf, ih.winYhalf) \
and base.mouseWatcherNode.hasMouse():
omega = (ih.mouseX - ih.winXhalf)*-ih.mouseSpeedX * dt * 0.25
if omega != 0.0:
base.camera.setX(base.camera, omega)
camvec = player.getPos() - base.camera.getPos()
camvec.setZ(0)
camdist = camvec.length()
camvec.normalize()
minCamDist = 2.0
maxCamDist = 8.0
if camdist > maxCamDist:
base.camera.setPos(base.camera.getPos() + camvec*(camdist-maxCamDist))
camdist = maxCamDist
if camdist < minCamDist:
base.camera.setPos(base.camera.getPos() - camvec*(minCamDist-camdist))
camdist = minCamDist
if base.camera.getZ() > self.camDummy.getZ() + 2:
base.camera.setZ(self.camDummy.getZ() + 2)
elif base.camera.getZ() < self.camDummy.getZ() + 1:
base.camera.setZ(self.camDummy.getZ() + 1)
self.camDummy.setPos(player.getPos())
self.camDummy.setZ(player.getZ() + 2.0)
base.camera.lookAt(self.camDummy)
def generateNode(self):
self.destroy()
self.node = NodePath('gameobjectnode')
self.node.setTwoSided(True)
self.node.reparentTo(self.parent.node)
if self.properties['avoidable'] == True:
self.node.setTag("avoidable", 'true')
else:
self.node.setTag("avoidable", 'false')
#setting scripting part
self.node.setTag("onWalked", self.onWalked)
self.node.setTag("onPicked", self.onPicked)
#set unique id
self.node.setTag("id", self.properties['id'])
tex = loader.loadTexture(resourceManager.getResource(self.properties['url'])+'.png')
tex.setWrapV(Texture.WM_clamp)
tex.setWrapU(Texture.WM_clamp)
#this is true pixel art
#change to FTLinear for linear interpolation between pixel colors
tex.setMagfilter(Texture.FTNearest)
tex.setMinfilter(Texture.FTNearest)
xorig = tex.getOrigFileXSize() / self.baseDimension
yorig = tex.getOrigFileYSize() / self.baseDimension
xscaled = (tex.getOrigFileXSize() / self.baseDimension) * self.properties['scale']
yscaled = (tex.getOrigFileYSize() / self.baseDimension) * self.properties['scale']
self.node.setTag("xscaled", str(xscaled))
self.node.setTag("yscaled", str(yscaled))
cm = CardMaker("tileobject")
cm.setFrame(0,xorig,0,yorig)
ts = TextureStage('ts')
ts.setMode(TextureStage.MDecal)
# distinguish between 3d collisions (for objects with an height and sensible self.properties['inclination'])
# and 2d collisions for plain sprites
if self.properties['walkable'] == 'false':
if self.properties['collisionmode'] == "3d":
#must handle differently objects which are small and big
if xscaled < 1:
self.collisionTube = CollisionBox(LPoint3f(0.5 - xscaled/2 - self.properties['offsetwidth'],0,0),LPoint3f(0.5 + xscaled/2 + self.properties['offsetwidth'],0.1,0.3 + self.properties['offsetheight']))
if xscaled >= 1:
self.collisionTube = CollisionBox(LPoint3f(0 - self.properties['offsetwidth'],0,0),LPoint3f(xscaled + self.properties['offsetwidth'],0.1,0.3 + self.properties['offsetheight']))
self.collisionNode = CollisionNode('objectSphere')
self.collisionNode.addSolid(self.collisionTube)
self.collisionNodeNp = self.node.attachNewNode(self.collisionNode)
self.collisionNodeNp.setX(self.properties['offsethorizontal'])
self.collisionNodeNp.setZ(self.properties['offsetvertical'])
self.collisionNodeNp.setX(self.collisionNodeNp.getX()+self.properties['offsetcollisionh'])
self.collisionNodeNp.setZ(self.collisionNodeNp.getZ()+self.properties['offsetcollisionv']+0.1)
if main.editormode:
self.collisionNodeNp.show()
elif self.properties['collisionmode'] == "2d":
#must handle differently objects which are small and big
if xscaled < 1:
self.collisionTube = CollisionBox(LPoint3f(0.5 - xscaled/2,0,0),LPoint3f(0.5 + xscaled/2,yscaled,0.3))
if xscaled >= 1:
self.collisionTube = CollisionBox(LPoint3f(0,0,0),LPoint3f(xscaled,yscaled,0.3))
self.collisionNode = CollisionNode('objectSphere')
self.collisionNode.addSolid(self.collisionTube)
self.collisionNodeNp = self.node.attachNewNode(self.collisionNode)
self.collisionNodeNp.setP(-(270-int(self.properties['inclination'])))
self.collisionNodeNp.setX(self.properties['offsethorizontal'])
self.collisionNodeNp.setZ(self.properties['offsetvertical'])
self.collisionNodeNp.setX(self.collisionNodeNp.getX()+self.properties['offsetcollisionh'])
self.collisionNodeNp.setZ(self.collisionNodeNp.getZ()+self.properties['offsetcollisionv']+0.1)
if main.editormode:
self.collisionNodeNp.show()
geomnode = NodePath(cm.generate())
if xscaled >= 1:
geomnode.setX(0)
if xscaled < 1:
geomnode.setX(0.5 - xscaled/2)
geomnode.setScale(self.properties['scale'])
geomnode.setX(geomnode.getX()+self.properties['offsethorizontal'])
geomnode.setZ(geomnode.getZ()+self.properties['offsetvertical'])
geomnode.setY(-self.properties['elevation'])
geomnode.setP(-(360-int(self.properties['inclination'])))
geomnode.setTexture(tex)
geomnode.setTransparency(TransparencyAttrib.MAlpha)
geomnode.reparentTo(self.node)
class Player():
def __init__(self, game, hp, mana, strength, dexterity, vigor, magic):
self.game = game
self.ori = 0.0
self.lastori = -1
self.zoomLevel = 0.0
self.nextAttack = 0.0
self.attacked = False
# Atributes
self.hp = hp
self.mana = mana
self.strength = strength
self.dexterity = dexterity
self.vigor = vigor
self.magic = magic
# Atributes calculated
self.attackDamage = random(1, 7) + self.strength/100 # physical dmg = weapon damage * %str
self.magicDamage = random(3, 12) + self.magic/100 # magic dmg = skill damage * %magic
self.speed = 15 + 0 # speed = base speed + item
self.runSpeed = 25 + 0 # run speed = base speed + item
self.lateralSpeed = 10 # speed when moving sidewards
self.lateralRunSpeed = 20 # run speed when moving sidewards
self.backwardsSpeed = 10 # speed when moving backwards
self.backwardsRunSpeed = 20 # run speed when moving backwards
self.defense = 5 + self.vigor/2 # defense = armour + 1/2 vigor
self.criticalChance = 10 + 0 # crit chance = base item + skill
self.criticalMultiplier = self.attackDamage*1.5 # crit mult = base item + skill
self.magicDefense = 2 + self.magic/2 # magic def = base item + 1/2 magic
self.attackSpeed = (0.2 * self.dexterity) / 60 # attack speed = base * dex / 60
self.keyMap = {
"left":0,
"right":0,
"forward":0,
"backward":0,
"cam-left":0,
"cam-right":0,
"jump":0,
"attack":0,
"run":0
}
# Player Parts
parts = ["head", "larm", "rarm", "lboot", "rboot", "lleg", "rleg", "lhand", "rhand", "torso"]
self.previousPart = { name: None for name in parts }
# Player Models & Animations
models = { name: "models/hero/%s" % name for name in parts }
animations = { name:{
"standby":"models/hero/%s-standby" % name,
"walk":"models/hero/%s-walk" % name,
"walk-back":"models/hero/%s-walk-back" % name,
"walk-side":"models/hero/%s-walk-side" % name,
"slash-front": "models/hero/%s-slash-front" % name
} for name in parts
}
for itemClass, items in self.game.items["items"].iteritems():
if itemClass == "armours":
for itemType, value in items["lightarmours"].iteritems():
modelName = value["model"]
for itemType, value in items["midarmours"].iteritems():
modelName = value["model"]
for itemType, value in items["heavyarmours"].iteritems():
modelName = value["model"]
models["torso-%s" % modelName] = "models/hero/torso-%s" % modelName
animations["torso-%s" % modelName] = {
"standby":"models/hero/torso-%s-standby" % modelName,
"walk":"models/hero/torso-%s-walk" % modelName,
"walk-back":"models/hero/torso-%s-walk-back" % modelName,
"walk-side":"models/hero/torso-%s-walk-side" % modelName,
"slash-front":"models/hero/torso-%s-slash-front" % modelName
}
for itemType, value in items["helmets"].iteritems():
modelName = value["model"]
models["head-%s" % modelName] = "models/hero/head-%s" % modelName
animations["head-%s" % modelName] = {
"standby":"models/hero/head-%s-standby" % modelName,
"walk":"models/hero/head-%s-walk" % modelName,
"walk-back":"models/hero/head-%s-walk-back" % modelName,
"walk-side":"models/hero/head-%s-walk-side" % modelName,
"slash-front":"models/hero/head-%s-slash-front" % modelName
}
# Init Actor
self.playerActor = Actor(models, animations)
# Hide All Player Parts
for itemClass, items in self.game.items["items"].iteritems():
if itemClass == "armours":
for itemType, value in items["lightarmours"].iteritems():
modelName = value["model"]
for itemType, value in items["midarmours"].iteritems():
modelName = value["model"]
for itemType, value in items["heavyarmours"].iteritems():
modelName = value["model"]
self.playerActor.hidePart("torso-%s" % modelName)
for itemType, value in items["helmets"].iteritems():
modelName = value["model"]
self.playerActor.hidePart("head-%s" % modelName)
#self.playerActor.ls()
# Shaders
self.shader = Shader.load("shaders/testShader.sha", Shader.SL_Cg)
#self.playerActor.setShader(self.shader)
# End shaders
self.moveFloater = NodePath(PandaNode("moveFloater"))
self.moveFloater.reparentTo(render)
self.moveFloater.setPos(self.game.playerStartPos)
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
#self.floater.setZ(8.0)
self.playerActor.setHpr(0,0,0)
self.playerActor.setScale(0.5)
self.playerActor.reparentTo(self.moveFloater)
#self.playerHand = self.playerActor.exposeJoint(None, 'body', 'manod')
#self.playerHead = self.playerActor.controlJoint(None, 'body', 'cabeza')
#self.playerHead.setScale(10,10,10)
self.inventory = [["0" for x in range(10)] for x in range(5)]
# COLS-ROWS # COLS-ROWS
self.inventory[0][3] = self.game.items["items"]["armours"]["heavyarmours"]["ironplate"]
self.inventory[0][4] = self.game.items["items"]["armours"]["heavyarmours"]["steelplate"]
self.inventory[0][5] = self.game.items["items"]["armours"]["heavyarmours"]["cuirass"]
self.inventory[3][3] = self.game.items["items"]["armours"]["midarmours"]["leatherarmour"]
self.inventory[0][0] = self.game.items["items"]["weapons"]["swords"]["longsword"]
self.inventory[1][0] = self.game.items["items"]["armours"]["midarmours"]["leatherarmour"]
self.inventory[0][8] = self.game.items["items"]["weapons"]["swords"]["longsword"]
self.inventory[0][7] = self.game.items["items"]["weapons"]["spears"]["ironspear"]
self.inventory[3][9] = self.game.items["items"]["armours"]["midarmours"]["leatherarmour"]
self.inventory[1][9] = self.game.items["items"]["armours"]["midarmours"]["leatherarmour"]
self.inventory[1][8] = self.game.items["items"]["armours"]["boots"]["leatherboots"]
self.inventory[1][7] = self.game.items["items"]["armours"]["helmets"]["woolchaco"]
self.inventory[0][6] = self.game.items["items"]["armours"]["helmets"]["goldencrown"]
self.inventory[0][8] = self.game.items["items"]["armours"]["helmets"]["ironhelmet"]
self.inventory[1][6] = self.game.items["items"]["armours"]["cloacks"]["woolcloack"]
self.inventory[2][9] = self.game.items["items"]["armours"]["midarmours"]["leatherarmour"]
self.inventory[2][8] = self.game.items["items"]["armours"]["boots"]["leatherboots"]
self.inventory[2][7] = self.game.items["items"]["armours"]["helmets"]["woolchaco"]
self.inventory[2][6] = self.game.items["items"]["armours"]["cloacks"]["woolcloack"]
self.inventory[2][5] = self.game.items["items"]["armours"]["gloves"]["woolgloves"]
self.inventory[1][5] = self.game.items["items"]["armours"]["gloves"]["woolgloves"]
self.inventory[2][4] = self.game.items["items"]["accesories"]["rings"]["simplering"]
self.inventory[1][4] = self.game.items["items"]["accesories"]["rings"]["simplering"]
self.inventory[2][3] = self.game.items["items"]["accesories"]["trinkets"]["rubyamulet"]
self.inventory[1][3] = self.game.items["items"]["accesories"]["trinkets"]["rubyamulet"]
self.inventory[2][2] = self.game.items["items"]["armours"]["shields"]["ironshield"]
self.inventory[1][2] = self.game.items["items"]["armours"]["shields"]["ironshield"]
self.equip = {
"armour":None,
"helmet":None,
"gloves":None,
"boots":None,
"cloack":None,
"ringLeft":None,
"ringRight":None,
"trinket":None,
"weapon":None,
"weaponLeft":None,
"weaponRight":None,
"shield":None
}
self.models = [] #A list that will store our models objects
items = [("models/sword1", (0.0, 0.6, 1.5), (0,-90,0), 0.2),
("models/maze", (0.0, 0.6, -1.5), (0,90,0), 0.2)]
"""
for row in items:
np = self.game.loader.loadModel(row[0]) #Load the model
np.setPos(row[1][0], row[1][1], row[1][2]) #Position it
np.setHpr(row[2][0], row[2][1], row[2][2]) #Rotate it
np.setScale(row[3]) #Scale it
np.reparentTo(self.playerHand)
#weaponNP.reparentTo(self.playerHand)
self.models.append(np) #Add it to our models list
"""
self.item = 0
self.isMovingForward = False
self.isMovingBackward = False
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingForwardLeft = False
self.isMovingForwardRight = False
self.isMovingSideRightUp = False
self.isMovingSideRightDown = False
self.isMovingSideLeftUp = False
self.isMovingSideLeftDown = False
self.isMovingBackwardLeft = False
self.isMovingBackwardRight = False
self.isAttacking = False
self.setupControls()
self.setupCamera()
self.playerActor.loop("standby", "head")
self.game.taskMgr.add(self.checkEquip, "checkTorsoTask", extraArgs=["torso", "armour"], appendTask=True)
self.game.taskMgr.add(self.checkEquip, "checkHeadTask", extraArgs=["head", "helmet"], appendTask=True)
def update(self, task):
self.playerActor.setShaderInput("timer", task.time)
return task.cont
def checkEquip(self, partName, equipPart, task):
# Check Equiped Parts
if self.previousPart[partName] != self.equip[equipPart]:
if self.equip[equipPart] != None and self.previousPart[partName] == None:
self.playerActor.hidePart(partName)
self.playerActor.showPart("%s-%s" % (partName, self.equip[equipPart]["model"]))
self.previousPart[partName] = self.equip[equipPart]
elif self.equip[equipPart] != None and self.previousPart[partName] != None:
self.playerActor.hidePart("%s-%s" % (partName, self.previousPart[partName]["model"]))
self.playerActor.showPart("%s-%s" % (partName, self.equip[equipPart]["model"]))
self.previousPart[partName] = self.equip[equipPart]
elif self.equip[equipPart] == None:
self.playerActor.hidePart("%s-%s" % (partName, self.previousPart[partName]["model"]))
self.playerActor.showPart(partName)
self.previousPart[partName] = None
return task.cont
def setupCamera(self):
self.game.disableMouse()
self.game.camera.setPos(self.playerActor.getPos()+50)
self.lens = OrthographicLens()
self.lens.setFilmSize(45+self.zoomLevel, 35+self.zoomLevel) # Or whatever is appropriate for your scene
self.game.cam.node().setLens(self.lens)
self.game.camLens.setFov(120)
def setupControls(self):
self.game.accept("a", self.setKey, ["left",1])
self.game.accept("shift-a", self.setKey, ["left",1])
self.game.accept("d", self.setKey, ["right",1])
self.game.accept("shift-d", self.setKey, ["right",1])
self.game.accept("w", self.setKey, ["forward",1])
self.game.accept("shift-w", self.setKey, ["forward",1])
self.game.accept("s", self.setKey, ["backward",1])
self.game.accept("shift-s", self.setKey, ["backward",1])
self.game.accept("a-up", self.setKey, ["left",0])
self.game.accept("d-up", self.setKey, ["right",0])
self.game.accept("w-up", self.setKey, ["forward",0])
self.game.accept("s-up", self.setKey, ["backward",0])
self.game.accept("mouse1", self.setKey, ["attack",1])
self.game.accept("mouse1-up", self.setKey, ["attack",0])
self.game.accept("shift-mouse1", self.setKey, ["attack",1])
self.game.accept("shift-mouse1-up", self.setKey, ["attack",0])
#self.game.accept("q", self.setKey, ["cam-left",1])
#self.game.accept("e", self.setKey, ["cam-right",1])
#self.game.accept("q-up", self.setKey, ["cam-left",0])
#self.game.accept("e-up", self.setKey, ["cam-right",0])
self.game.accept("space", self.setKey, ["jump",1])
self.game.accept("space-up", self.setKey, ["jump",0])
self.game.accept("shift", self.setKey, ["run",1])
self.game.accept("shift-up", self.setKey, ["run",0])
self.game.accept("wheel_up", self.moveCam, [1])
self.game.accept("wheel_down", self.moveCam, [0])
self.game.accept("shift-wheel_up", self.moveCam, [1])
self.game.accept("shift-wheel_down", self.moveCam, [0])
self.game.accept("t", self.toggleObject)
def moveCam(self, zoom):
if zoom == 0:
self.zoomLevel += 5
#if self.zoomLevel >= 30:
#self.zoomLevel = 30
elif zoom == 1:
self.zoomLevel -= 5
if self.zoomLevel <= 0:
self.zoomLevel = 0
#print self.zoomLevel
self.lens.setFilmSize(45+self.zoomLevel, 35+self.zoomLevel)
self.game.cam.node().setLens(self.lens)
#def checkAttack(self):
#animControl = self.playerActor.getAnimControl('slash', "body")
#return animControl.isPlaying()
def attack(self):
if self.isAttacking is False:
self.playerActor.play("slash-front")
self.isAttacking = True
self.isAttacking = False
def setKey(self, key, value):
self.keyMap[key] = value
def setObject(self, i):
for np in self.models: np.hide()
self.models[i].show()
self.item = i
def toggleObject(self):
if self.item == 1:
self.item = 0
else:
self.item = 1
for np in self.models: np.hide()
self.models[self.item].show()
def move(self, task):
#self.playerActor.setPos(self.moveFloater.getPos())
#self.playerActor.setZ(self.moveFloater.getZ())
dt = globalClock.getDt()
speed = 0
if (self.keyMap["left"]):
if (self.keyMap["run"]):
speed = self.runSpeed
#self.playerActor.setPlayRate(2.0, 'walk-side')
else:
speed = self.speed
#self.playerActor.setPlayRate(1.0, 'walk-side')
self.moveFloater.setX(self.moveFloater, speed * dt)
self.moveFloater.setY(self.moveFloater, -speed * dt)
if (self.keyMap["right"]):
if (self.keyMap["run"]):
speed = self.runSpeed
#self.playerActor.setPlayRate(2.0, 'walk-side')
else:
speed = self.lateralSpeed
#self.playerActor.setPlayRate(1.0, 'walk-side')
self.moveFloater.setX(self.moveFloater, -speed * dt)
self.moveFloater.setY(self.moveFloater, speed * dt)
if (self.keyMap["forward"]):
if (self.keyMap["run"]):
speed = self.runSpeed
#self.playerActor.setPlayRate(1.5, 'walk')
else:
speed = self.speed
#self.playerActor.setPlayRate(1.0, 'walk')
self.moveFloater.setY(self.moveFloater, -speed * dt)
self.moveFloater.setX(self.moveFloater, -speed * dt)
if (self.keyMap["backward"]):
if (self.keyMap["run"]):
speed = self.runSpeed
#self.playerActor.setPlayRate(2.0, 'walk-back')
else:
speed = self.speed
#self.playerActor.setPlayRate(1.0, 'walk-back')
self.moveFloater.setY(self.moveFloater, speed * dt)
self.moveFloater.setX(self.moveFloater, speed * dt)
if (self.keyMap["attack"]) and (task.time > self.nextAttack):
self.attack()
self.nextAttack = task.time + self.attackSpeed
self.keyMap["attack"] = 0
"""
if self.lastori != self.ori :
turn = Sequence(LerpQuatInterval(self.playerActor, duration=0.05, hpr=Vec3(self.ori, 0, 0), blendType='easeOut')).start()
self.lastori = self.ori
"""
self.playerActor.headsUp(self.game.lookPoint)
self.playerActor.setH(self.playerActor.getH()-180)
#print(self.playerActor.getH())
# If player is moving, loop the run animation.
# If he is standing still, stop the animation.
if self.keyMap["forward"] and self.keyMap["right"]:
if ((self.playerActor.getH() < -45) and (self.playerActor.getH() > -135)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk')
else:
self.playerActor.setPlayRate(1.0, 'walk')
if self.isMovingForward is False:
self.playerActor.stop()
self.playerActor.loop("walk")
self.isMovingForward = True
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -135) and (self.playerActor.getH() > -225)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideRight is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = True
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -225) and (self.playerActor.getH() > -315)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-back')
else:
self.playerActor.setPlayRate(1.0, 'walk-back')
if self.isMovingBackward is False:
self.playerActor.stop()
self.playerActor.loop("walk-back")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = True
elif (((self.playerActor.getH() < -315) and (self.playerActor.getH() < 0)) or ((self.playerActor.getH() < 0) and (self.playerActor.getH() > -45))):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideLeft is False:
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = True
self.isMovingBackward = False
elif self.keyMap["right"] and self.keyMap["backward"]:
if ((self.playerActor.getH() < -135) and (self.playerActor.getH() > -225)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk')
else:
self.playerActor.setPlayRate(1.0, 'walk')
if self.isMovingForward is False:
self.playerActor.stop()
self.playerActor.loop("walk")
self.isMovingForward = True
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -225) and (self.playerActor.getH() > -315)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideRight is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = True
self.isMovingSideLeft = False
self.isMovingBackward = False
elif (((self.playerActor.getH() < -315) and (self.playerActor.getH() < 0)) or ((self.playerActor.getH() < 0) and (self.playerActor.getH() > -45))):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-back')
else:
self.playerActor.setPlayRate(1.0, 'walk-back')
if self.isMovingBackward is False:
self.playerActor.stop()
self.playerActor.loop("walk-back")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = True
elif ((self.playerActor.getH() < -45) and (self.playerActor.getH() > -135)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideLeft is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = True
self.isMovingBackward = False
elif self.keyMap["backward"] and self.keyMap["left"]:
if ((self.playerActor.getH() < -225) and (self.playerActor.getH() > -315)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk')
else:
self.playerActor.setPlayRate(1.0, 'walk')
if self.isMovingForward is False:
self.playerActor.stop()
self.playerActor.loop("walk")
self.isMovingForward = True
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = False
elif (((self.playerActor.getH() < -315) and (self.playerActor.getH() < 0)) or ((self.playerActor.getH() < 0) and (self.playerActor.getH() > -45))):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideRight is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = True
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -45) and (self.playerActor.getH() > -135)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-back')
else:
self.playerActor.setPlayRate(1.0, 'walk-back')
if self.isMovingBackward is False:
self.playerActor.stop()
self.playerActor.loop("walk-back")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = True
elif ((self.playerActor.getH() < -135) and (self.playerActor.getH() > -225)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideLeft is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = True
self.isMovingBackward = False
elif self.keyMap["left"] and self.keyMap["forward"]:
if (((self.playerActor.getH() < -315) and (self.playerActor.getH() < 0)) or ((self.playerActor.getH() < 0) and (self.playerActor.getH() > -45))):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk')
else:
self.playerActor.setPlayRate(1.0, 'walk')
if self.isMovingForward is False:
self.playerActor.stop()
self.playerActor.loop("walk")
self.isMovingForward = True
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -45) and (self.playerActor.getH() > -135)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideRight is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = True
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -135) and (self.playerActor.getH() > -225)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-back')
else:
self.playerActor.setPlayRate(1.0, 'walk-back')
if self.isMovingBackward is False:
self.playerActor.stop()
self.playerActor.loop("walk-back")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = True
elif ((self.playerActor.getH() < -225) and (self.playerActor.getH() > -315)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideLeft is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = True
self.isMovingBackward = False
elif self.keyMap["forward"]:
if ((self.playerActor.getH() < 0) and (self.playerActor.getH() > -90)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk')
else:
self.playerActor.setPlayRate(1.0, 'walk')
if self.isMovingForward is False:
self.playerActor.stop()
self.playerActor.loop("walk")
self.isMovingForward = True
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -90) and (self.playerActor.getH() > -180)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideRight is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = True
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -180) and (self.playerActor.getH() > -270)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-back')
else:
self.playerActor.setPlayRate(1.0, 'walk-back')
if self.isMovingBackward is False:
self.playerActor.stop()
self.playerActor.loop("walk-back")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = True
elif ((self.playerActor.getH() < -270) and (self.playerActor.getH() < 0)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideLeft is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = True
self.isMovingBackward = False
elif self.keyMap["backward"]:
if ((self.playerActor.getH() < 0) and (self.playerActor.getH() > -90)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-back')
else:
self.playerActor.setPlayRate(1.0, 'walk-back')
if self.isMovingBackward is False:
self.playerActor.stop()
self.playerActor.loop("walk-back")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = True
elif ((self.playerActor.getH() < -90) and (self.playerActor.getH() > -180)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideRight is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = True
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -180) and (self.playerActor.getH() > -270)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk')
else:
self.playerActor.setPlayRate(1.0, 'walk')
if self.isMovingForward is False:
self.playerActor.stop()
self.playerActor.loop("walk")
self.isMovingForward = True
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -270) and (self.playerActor.getH() < 0)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideLeft is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = True
self.isMovingBackward = False
elif self.keyMap["left"]:
if ((self.playerActor.getH() < 0) and (self.playerActor.getH() > -90)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideRight is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = True
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -90) and (self.playerActor.getH() > -180)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-back')
else:
self.playerActor.setPlayRate(1.0, 'walk-back')
if self.isMovingBackward is False:
self.playerActor.stop()
self.playerActor.loop("walk-back")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = True
elif ((self.playerActor.getH() < -180) and (self.playerActor.getH() > -270)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideLeft is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = True
self.isMovingBackward = False
elif ((self.playerActor.getH() < -270) and (self.playerActor.getH() < 0)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk')
else:
self.playerActor.setPlayRate(1.0, 'walk')
if self.isMovingForward is False:
self.playerActor.stop()
self.playerActor.loop("walk")
self.isMovingForward = True
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = False
elif self.keyMap["right"]:
if ((self.playerActor.getH() < 0) and (self.playerActor.getH() > -90)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideLeft is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = True
self.isMovingBackward = False
elif ((self.playerActor.getH() < -90) and (self.playerActor.getH() > -180)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk')
else:
self.playerActor.setPlayRate(1.0, 'walk')
if self.isMovingForward is False:
self.playerActor.stop()
self.playerActor.loop("walk")
self.isMovingForward = True
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -180) and (self.playerActor.getH() > -270)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideRight is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = True
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -270) and (self.playerActor.getH() < 0)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-back')
else:
self.playerActor.setPlayRate(1.0, 'walk-back')
if self.isMovingBackward is False:
self.playerActor.stop()
self.playerActor.loop("walk-back")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = True
else:
if self.isMovingForward or self.isMovingBackward or self.isMovingSideLeft or self.isMovingSideRight:
self.playerActor.stop()
self.playerActor.loop("standby")
self.isMovingForward = False
self.isMovingBackward = False
self.isMovingSideLeft = False
self.isMovingSideRight = False
return task.cont
def updateCamera(self, task):
self.floater.setPos(self.moveFloater.getPos())
self.floater.setZ(self.moveFloater.getZ() + 2.0)
self.game.camera.setPos(self.floater.getPos()+50)
# The camera should look in player's direction,
# but it should also try to stay horizontal, so look at
# a floater which hovers above player's head.
self.game.camera.lookAt(self.floater)
return task.cont
class Ship:
def __init__(self, game):
self.game = game
self.shipPoint = NodePath(PandaNode("shipFloaterPoint"))
self.shipPoint.reparentTo(render)
self.x_pos = 0
self.z_pos = 0
self.x_speed = 0
self.z_speed = 0
self.x_pid = PID(3.0, 5.0, 1.0)
self.z_pid = PID(3.0, 5.0, 1.0)
self.model = Actor("data/ship.egg")
self.model.setPos(0, 0, 0)
self.model.setHpr(0, 0, 0)
self.normal_speed = 3.5
self.low_speed = 2
self.speed = self.normal_speed
self.cool_down = 0.1
self.last_shoot = 0
self.keyMap = {
"up": 0,
"down": 0,
"left": 0,
"right": 0,
"brake": 0,
"attack": 0,
}
# This list will stored fired bullets.
self.bullets = []
self.game.accept("mouse1", self.setKey, ["attack", 1])
self.game.accept("mouse1-up", self.setKey, ["attack", 0])
self.game.accept("shift-mouse1", self.setKey, ["attack", 1])
self.game.accept("shift-mouse1-up", self.setKey, ["attack", 0])
self.game.accept("x", self.setKey, ["attack", 1])
self.game.accept("x-up", self.setKey, ["attack", 0])
self.game.accept("c", self.setKey, ["brake", 1])
self.game.accept("c-up", self.setKey, ["brake", 0])
self.game.accept("arrow_up", self.setKey, ["up", 1])
self.game.accept("arrow_up-up", self.setKey, ["up", 0])
self.game.accept("arrow_down", self.setKey, ["down", 1])
self.game.accept("arrow_down-up", self.setKey, ["down", 0])
self.game.accept("arrow_left", self.setKey, ["left", 1])
self.game.accept("arrow_left-up", self.setKey, ["left", 0])
self.game.accept("arrow_right", self.setKey, ["right", 1])
self.game.accept("arrow_right-up", self.setKey, ["right", 0])
def setKey(self, key, value):
self.keyMap[key] = value
def draw(self):
self.model.reparentTo(render)
self.p = ParticleEffect()
self.p.loadConfig(Filename('data/particles/fireish.ptf'))
self.p.setR(180)
self.p.setScale(0.25)
# Sets particles to birth relative to the teapot, but to render at
# toplevel
self.p.start(self.model)
self.p.setPos(0.000, 0.000, 0.000)
def update(self, task):
dt = globalClock.getDt()
if self.model:
# Movement
if self.keyMap["brake"]:
self.speed = self.low_speed
else:
self.speed = self.normal_speed
if self.game.ship_control_type == 0:
if self.keyMap["up"]:
self.model.setZ(self.model, self.speed * dt)
elif self.keyMap["down"]:
self.model.setZ(self.model, -self.speed * dt)
if self.keyMap["left"]:
self.model.setX(self.model, -self.speed * dt)
elif self.keyMap["right"]:
self.model.setX(self.model, self.speed * dt)
elif self.game.ship_control_type == 1:
self.x_pos = self.shipPoint.getX()
self.z_pos = self.shipPoint.getZ()
self.x_pid.setPoint(self.x_pos)
self.z_pid.setPoint(self.z_pos)
pid_x = self.x_pid.update(self.model.getX())
pid_z = self.z_pid.update(self.model.getZ())
self.x_speed = pid_x
self.z_speed = pid_z
self.x_speed = min(self.speed, self.x_speed)
self.x_speed = max(-self.speed, self.x_speed)
self.z_speed = min(self.speed, self.z_speed)
self.z_speed = max(-self.speed, self.z_speed)
self.model.setX(self.model, self.x_speed * dt)
self.model.setZ(self.model, self.z_speed * dt)
self.model.setR(self.x_speed)
# Shoot
if self.keyMap["attack"]:
current_shoot_time = task.time
if current_shoot_time - self.last_shoot >= self.cool_down:
self.last_shoot = current_shoot_time
self.bullet = Bullet(self)
return task.cont
class Player(object):
"""
Player is the main actor in the fps game
"""
FORWARD = Vec3(0,2,0)
BACK = Vec3(0,-1,0)
LEFT = Vec3(-1,0,0)
RIGHT = Vec3(1,0,0)
FLYUP = Vec3(0,0,1)
FLYDN = Vec3(0,0,-1)
STOP = Vec3(0)
PORTAL_CYCLE = {
'blue' : 'orange',
'orange' : 'blue',
}
def __init__(self, base, fps, osd):
self.base = base
self.fps = fps
self.osd = osd
self.speed = RUN_SPEED
self.walk = self.STOP
self.readyToJump = False
self.intoPortal = None
self.mass = Mass()
self.origin = self.fps.level.settings.origin
self.bporigin = (999,999,999)
self.oporigin = (999,999,999)
self.current_target = None
self.canPortal = []
self.canSetTarget = True
self.selectedCubes = []
self.editorTextureStage = TextureStage('editor')
self.editorSelectedTexture = loader.loadTexture('models/tex/selected.png')
self.selectingForMulti = False
# Init functions
self.loadModel()
self.makePortals()
self.setUpCamera()
if self.fps.editor_mode:
self.createMouseCollisions()
self.speed = self.speed * 5
self.attachEditorControls()
self.attachEditorTasks()
else:
self.createCollisions()
self.attachStandardControls()
self.attachStandardTasks()
def loadModel(self):
""" make the nodepath for player """
self.node = NodePath('player')
self.node.reparentTo(render)
self.node.setPos(*self.origin)
self.node.setScale(0.05)
self.mass.pos = VBase3(self.node.getX(), self.node.getY(), self.node.getZ())
def makePortals(self):
# The BLUE CUBE
bpor = loader.loadModel("cube_nocol")
bpor.setTag('noportals', '1')
bpor.reparentTo(render)
bpor.setPos(*self.bporigin)
bpor.setScale(0.3,0.02,0.5)
# The BLUE CUBE's camera
bbuffer = self.base.win.makeTextureBuffer("B Buffer", 512, 512)
bbuffer.setSort(-100)
bcamera = self.base.makeCamera(bbuffer)
bcamera.node().getLens().setAspectRatio(0.3/0.5)
bcamera.node().getLens().setFov(15)
bcamera.reparentTo(bpor)
bcamera.node().setScene(render)
# The ORANGE CUBE
opor = loader.loadModel("cube_nocol")
opor.setTag('noportals', '1')
opor.reparentTo(render)
opor.setPos(*self.oporigin)
opor.setScale(0.3,0.02,0.5)
# The ORANGE CUBE's camera
obuffer = self.base.win.makeTextureBuffer("O Buffer", 512, 512)
obuffer.setSort(-100)
ocamera = self.base.makeCamera(obuffer)
ocamera.node().getLens().setAspectRatio(0.3/0.5)
ocamera.node().getLens().setFov(15)
ocamera.reparentTo(opor)
ocamera.node().setScene(render)
# Assign the textures
bpor.setTexture(obuffer.getTexture())
opor.setTexture(bbuffer.getTexture())
# Store the portals and theirs cameras
self.bluePortal = bpor
self.bluePortal.setHpr(0,90,0)
self.orangePortal = opor
self.orangePortal.setHpr(0,-90,0)
self.bcamera = bcamera
self.ocamera = ocamera
def setUpCamera(self):
""" puts camera at the players node """
pl = self.base.cam.node().getLens()
pl.setFov(70)
self.base.cam.node().setLens(pl)
self.base.camera.reparentTo(self.node)
self.base.camLens.setFov(100)
if self.fps.editor_mode:
self.node.lookAt(self.fps.level.cubes_hash.keys()[0])
def createCollisions(self):
self.createPlayerCollisions()
self.createMouseCollisions()
self.createPortalCollisions()
def createPlayerCollisions(self):
""" create a collision solid and ray for the player """
cn = CollisionNode('player')
cn.setFromCollideMask(COLLISIONMASKS['geometry'])
cn.setIntoCollideMask(COLLISIONMASKS['portals'] | COLLISIONMASKS['exit'] | COLLISIONMASKS['lava'])
cn.addSolid(CollisionSphere(0,0,0,3))
solid = self.node.attachNewNode(cn)
# TODO : find a way to remove that, it's the cause of the little
# "push me left" effect we see sometime when exiting a portal
self.base.cTrav.addCollider(solid,self.base.pusher)
self.base.pusher.addCollider(solid,self.node, self.base.drive.node())
# init players floor collisions
ray = CollisionRay()
ray.setOrigin(0,0,-.2)
ray.setDirection(0,0,-1)
cn = CollisionNode('playerRay')
cn.setFromCollideMask(COLLISIONMASKS['player'])
cn.setIntoCollideMask(BitMask32.allOff())
cn.addSolid(ray)
solid = self.node.attachNewNode(cn)
self.nodeGroundHandler = CollisionHandlerQueue()
self.base.cTrav.addCollider(solid, self.nodeGroundHandler)
# init players ceil collisions
ray = CollisionRay()
ray.setOrigin(0,0,.2)
ray.setDirection(0,0,1)
cn = CollisionNode('playerUpRay')
cn.setFromCollideMask(COLLISIONMASKS['player'])
cn.setIntoCollideMask(BitMask32.allOff())
cn.addSolid(ray)
solid = self.node.attachNewNode(cn)
self.ceilGroundHandler = CollisionHandlerQueue()
self.base.cTrav.addCollider(solid, self.ceilGroundHandler)
def createMouseCollisions(self):
# Fire the portals
firingNode = CollisionNode('mouseRay')
firingNP = self.base.camera.attachNewNode(firingNode)
firingNode.setFromCollideMask(COLLISIONMASKS['geometry'])
firingNode.setIntoCollideMask(BitMask32.allOff())
firingRay = CollisionRay()
firingRay.setOrigin(0,0,0)
firingRay.setDirection(0,1,0)
firingNode.addSolid(firingRay)
self.firingHandler = CollisionHandlerQueue()
self.base.cTrav.addCollider(firingNP, self.firingHandler)
def createPortalCollisions(self):
# Enter the portals
cn = CollisionNode('bluePortal')
cn.setFromCollideMask(COLLISIONMASKS['portals'])
cn.setIntoCollideMask(BitMask32.allOff())
np = self.bluePortal.attachNewNode(cn)
cn.addSolid(CollisionSphere(0,0,0,2))
h = CollisionHandlerEvent()
h.addInPattern('%fn-into-%in')
h.addOutPattern('%fn-outof-%in')
self.base.cTrav.addCollider(np, h)
cn = CollisionNode('orangePortal')
cn.setFromCollideMask(COLLISIONMASKS['portals'])
cn.setIntoCollideMask(BitMask32.allOff())
np = self.orangePortal.attachNewNode(cn)
cn.addSolid(CollisionSphere(0,0,0,2))
h = CollisionHandlerEvent()
h.addInPattern('%fn-into-%in')
h.addOutPattern('%fn-outof-%in')
self.base.cTrav.addCollider(np, h)
def attachCommonControls(self):
self.base.accept( "z" if AZERTY else "w" , self.addWalk,[self.FORWARD])
self.base.accept( "z-up" if AZERTY else "w-up" , self.addWalk,[-self.FORWARD] )
self.base.accept( "s" , self.addWalk,[self.BACK] )
self.base.accept( "s-up" , self.addWalk,[-self.BACK] )
self.base.accept( "q" if AZERTY else "a" , self.addWalk,[self.LEFT])
self.base.accept( "q-up" if AZERTY else "a-up" , self.addWalk,[-self.LEFT] )
self.base.accept( "d" , self.addWalk,[self.RIGHT] )
self.base.accept( "d-up" , self.addWalk,[-self.RIGHT] )
self.base.accept( "r-up" , self.resetPosition )
self.base.accept( "p-up" , self.showPosition )
self.base.accept( "b-up" , self.deBug )
def attachStandardControls(self):
self.attachCommonControls()
self.base.accept( "space" , self.__setattr__,["readyToJump",True])
self.base.accept( "space-up" , self.__setattr__,["readyToJump",False])
self.base.accept( "c-up" , self.__setattr__,["intoPortal",None] )
self.base.accept( "e-up" , self.erasePortals )
self.base.accept( "mouse1" , self.fireBlue )
self.base.accept( "mouse3" , self.fireOrange )
# Events
self.base.accept( "bluePortal-into-player" , self.enterPortal, ["blue"] )
self.base.accept( "orangePortal-into-player" , self.enterPortal, ["orange"] )
self.base.accept( "bluePortal-outof-player" , self.exitPortal, ["blue"] )
self.base.accept( "orangePortal-outof-player" , self.exitPortal, ["orange"] )
self.base.accept( "levelExit-into-player" , self.levelExit)
self.base.accept( "lava-into-player" , self.fallIntoLava)
def attachStandardTasks(self):
taskMgr.add(self.mouseUpdate, 'mouse-task')
taskMgr.add(self.moveUpdate, 'move-task')
taskMgr.add(self.jumpUpdate, 'jump-task')
def attachEditorControls(self):
self.attachCommonControls()
self.base.accept( "space" , self.__setattr__, ['selectingForMulti', 1])
self.base.accept( "space-up" , self.__setattr__, ['selectingForMulti', 0])
self.base.accept( "shift-space" , self.__setattr__, ['selectingForMulti', 2])
self.base.accept( "shift-space-up" , self.__setattr__, ['selectingForMulti', 0])
self.base.accept( "c-up" , self.clearMultiSelectedCubes)
self.base.accept( "mouse1" , self.selectCubeForCopy, [1])
self.base.accept( "wheel_up" , self.selectCubeForChange, [1] )
self.base.accept( "wheel_down" , self.selectCubeForChange, [-1] )
self.base.accept( "mouse3" , self.selectCubeForDelete )
self.base.accept("f11", self.saveLevel)
self.base.accept("x", self.selectCubeForRectangle)
self.base.accept("shift-x", self.selectCubeForRectangle, [True])
self.base.accept("l", self.addLightHere)
self.base.accept("u", self.fps.level.undo, [1])
for i in range(1,10):
self.base.accept( "%i-up" % (i,), self.selectCubeForCopy, [i])
for key, vec in [("a" if AZERTY else "q", self.FLYUP),("w" if AZERTY else "z", self.FLYDN)]:
self.base.accept(key, self.addWalk, [vec])
self.base.accept(key + "-up", self.addWalk, [-vec])
def attachEditorTasks(self):
taskMgr.add(self.mouseUpdate, 'mouse-task')
taskMgr.add(self.moveInEditor, 'move-task')
def deBug(self):
import pdb
pdb.set_trace()
def showPosition(self):
print self.node.getPos()
print self.mass
def fallIntoLava(self, *args, **kwargs):
# TODO : sound and message + little delay
self.erasePortals()
self.resetPosition()
def resetPosition(self, *args, **kwargs):
self.node.setHpr(VBase3(0,0,0))
self.mass.pos = VBase3(*self.origin)
self.mass.vel = VBase3(0,0,0)
self.mass.force = VBase3(0,0,0)
self.node.setPos(self.mass.pos)
def erasePortals(self):
self.bluePortal.setPos(*self.bporigin)
self.orangePortal.setPos(*self.oporigin)
self.bluePortal.detachNode()
self.orangePortal.detachNode()
self.intoPortal = None
self.canPortal = []
#@oldpostracker
def mouseUpdate(self,task):
""" this task updates the mouse """
md = self.base.win.getPointer(0)
x = md.getX()
y = md.getY()
if self.base.win.movePointer(0, self.base.win.getXSize()/2, self.base.win.getYSize()/2):
self.node.setH(self.node.getH() - (x - self.base.win.getXSize()/2)*0.1)
if self.fps.editor_mode:
self.node.setP(self.node.getP() - (y - self.base.win.getYSize()/2)*0.1)
else:
self.base.camera.setP(self.base.camera.getP() - (y - self.base.win.getYSize()/2)*0.1)
self.canSetTarget = True
self.bcamera.lookAt(self.bluePortal, self.node.getPos(self.orangePortal))
self.ocamera.lookAt(self.orangePortal, self.node.getPos(self.bluePortal))
#self.canPortal = ['blue','orange']
if self.fps.editor_mode:
cube, point, normal = self.selectCube()
self.osd.updateTargetPosition(cube)
if self.selectingForMulti:
self.selectCubeForMulti()
return task.cont
def addWalk(self, vec):
self.walk += vec
def moveUpdate(self,task):
""" this task makes the player move """
# move where the keys set it
self.node.setPos(self.node, self.walk*globalClock.getDt()*self.speed)
return task.cont
#@oldpostracker
def jumpUpdate(self,task):
""" this task simulates gravity and makes the player jump """
# get the highest Z from the down casting ray
highestZ = -100
lowestZ = 100
for i in range(self.nodeGroundHandler.getNumEntries()):
entry = self.nodeGroundHandler.getEntry(i)
z = entry.getSurfacePoint(render).getZ()
if z > highestZ and entry.getIntoNode().getName() in ( "CollisionStuff", "Plane", "Cube" ):
highestZ = z
for i in range(self.ceilGroundHandler.getNumEntries()):
entry = self.ceilGroundHandler.getEntry(i)
z = entry.getSurfacePoint(render).getZ()
if z < lowestZ and entry.getIntoNode().getName() in ( "CollisionStuff", "Plane", "Cube" ):
lowestZ = z
# gravity effects and jumps
self.mass.simulate(globalClock.getDt())
self.node.setZ(self.mass.pos.getZ())
if highestZ > self.node.getZ()-PLAYER_TO_FLOOR_TOLERANCE:
self.mass.zero()
self.mass.pos.setZ(highestZ+PLAYER_TO_FLOOR_TOLERANCE)
self.node.setZ(highestZ+PLAYER_TO_FLOOR_TOLERANCE)
if lowestZ < self.node.getZ()+PLAYER_TO_FLOOR_TOLERANCE:
self.mass.zero()
self.mass.pos.setZ(lowestZ-PLAYER_TO_FLOOR_TOLERANCE)
self.node.setZ(lowestZ-PLAYER_TO_FLOOR_TOLERANCE)
if self.readyToJump and self.node.getZ() < highestZ + PLAYER_TO_FLOOR_TOLERANCE_FOR_REJUMP:
self.mass.jump(JUMP_FORCE)
return task.cont
def firePortal(self, name, node):
def hasTagValue(node, tag, value):
if node.getTag(tag) == value:
return True
for pnum in range(node.getNumParents()):
return hasTagValue(node.getParent(pnum), tag, value)
return False
self.firingHandler.sortEntries()
if self.firingHandler.getNumEntries() > 0:
closest = self.firingHandler.getEntry(0)
if hasTagValue(closest.getIntoNode(), 'noportals', '1'):
return
point = closest.getSurfacePoint(render)
normal = closest.getSurfaceNormal(render)
node.setPos(point)
node.lookAt(point + normal)
node.reparentTo(render)
dest = self.PORTAL_CYCLE[name]
if dest not in self.canPortal:
self.canPortal.append(dest)
def fireBlue(self, *arg, **kwargs):
self.firePortal("blue", self.bluePortal)
def fireOrange(self, *arg, **kwargs):
self.firePortal("orange", self.orangePortal)
#@oldpostracker
def enterPortal(self, color, collision):
if self.intoPortal is None and color in self.canPortal:
self.intoPortal = color
portal = {"orange": self.bluePortal, "blue": self.orangePortal}.get(color)
otherportal = {"orange": self.orangePortal, "blue": self.bluePortal}.get(color)
# Handle horizontal portals :
if portal.getH() == 0:
self.node.setP(0)
self.node.setR(0)
elif otherportal.getH() == 0:
self.node.setH(portal.getH())
self.node.setP(0)
self.node.setR(0)
else:
# New HPR is relative to 'new' portal but it the 'same' value
# as the old HPR seen from the 'other' portal
oldh_fromportal = self.node.getH(otherportal)
self.node.setHpr(Vec3(0,0,0))
self.node.setH(portal, 180-oldh_fromportal)
newh_fromportal = self.node.getH(portal)
self.node.setPos(portal, self.walk * 10.)
self.mass.pos = self.node.getPos()
# Make half a turn (only if we straffing without walking)
if self.walk.getY() == 0 and self.walk.getX() != 0:
self.node.setH(self.node, 180)
self.node.setPos(self.node, self.walk * 10)
#@oldpostracker
def exitPortal(self, color, collision):
# When you entered the blue portal, you have to exit the orange one
if self.intoPortal != color:
self.intoPortal = None
def levelExit(self, event):
if self.fps.level.settings.next_level:
self.fps.level.loadlevel(self.fps.level.settings.next_level)
self.origin = self.fps.level.settings.origin
self.resetPosition()
self.erasePortals()
self.walk = self.STOP
else:
print "You won !"
sys.exit(0)
# EDITOR MODE
def selectCube(self):
self.firingHandler.sortEntries()
if self.firingHandler.getNumEntries() > 0:
closest = self.firingHandler.getEntry(0)
return closest.getIntoNodePath().getParent().getParent(), closest.getSurfacePoint(render), closest.getSurfaceNormal(render) # render/cube.egg/-PandaNode/-GeomNode
else:
return None, None, None
def clearMultiSelectedCubes(self):
for c in self.selectedCubes:
c.clearTexture(self.editorTextureStage)
self.selectedCubes = []
def selectCubeForMulti(self):
cube, point, normal = self.selectCube()
if cube:
if self.selectingForMulti == 1:
cube.setTexture(self.editorTextureStage, self.editorSelectedTexture)
if cube not in self.selectedCubes:
self.selectedCubes.append(cube)
elif cube in self.selectedCubes:
cube.clearTexture(self.editorTextureStage)
self.selectedCubes.remove(cube)
def selectCubeForCopy(self, qty = 1):
cube, point, normal = self.selectCube()
if not (cube and point and normal):
return
if self.selectedCubes:
for c in self.selectedCubes:
self.fps.level.copyCube(c, normal, qty)
self.clearMultiSelectedCubes()
else:
self.fps.level.copyCube(cube, normal, qty)
def selectCubeForDelete(self):
cube, point, normal = self.selectCube()
if not (cube and point and normal):
return
if self.selectedCubes:
for c in self.selectedCubes:
self.fps.level.deleteCube(c)
self.clearMultiSelectedCubes()
else:
self.fps.level.deleteCube(cube)
def selectCubeForChange(self, step = 1):
cube, point, normal = self.selectCube()
if not (cube and point and normal):
return
if self.selectedCubes:
for c in self.selectedCubes:
self.fps.level.changeCube(c, step)
else:
self.fps.level.changeCube(cube, step)
def selectCubeForRectangle(self, makeRoom = False):
cube, point, normal = self.selectCube()
if makeRoom:
self.fps.level.createRoom(cube, self.node) # creates a room from the selected cube to the player(camera) position
else:
self.fps.level.createRectangle(cube, self.node) # creates a rectangle from the selected cube to the player(camera) position
def saveLevel(self):
camerapos = [self.node.getX(), self.node.getY(), self.node.getZ()]
levelname = self.fps.levelname
self.fps.level.savelevel(levelname, camerapos)
def addLightHere(self):
camerapos = [self.node.getX(), self.node.getY(), self.node.getZ()]
self.fps.level.addLightHere(camerapos)
def moveInEditor(self,task):
self.node.setPos(self.node, self.walk*globalClock.getDt()*self.speed)
self.osd.updatePosition(self.node)
return task.cont
class Main(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.key = {
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"cam_left": 0,
"cam_right": 0,
"cam_down": 0,
"cam_up": 0,
"up": 0,
"down": 0
}
#####################
#
# Simply testing procedural cave generation
#
#####################
self.start = PlatformSeg(LVector3(0, 0, 0))
self.start.generateAllParts(render)
self.lostWood = LostWood(
LVector3(self.start.pos.x + 750,
self.start.parts[0].pos.y + self.start.parts[0].wid,
self.start.pos.z))
self.lostWood.generateAllParts(render)
self.cave = Cave(
LVector3(self.lostWood.pos.x + 1100,
self.lostWood.parts[6].pos.y + self.lostWood.parts[6].wid,
self.lostWood.pos.z))
self.cave.generateAllParts(render)
self.end = End(
LVector3(
self.cave.thirdRoomParts[8].pos.x - 200,
self.cave.thirdRoomParts[8].pos.y +
self.cave.thirdRoomParts[8].wid,
self.cave.thirdRoomParts[8].pos.z))
self.end.generate(render)
####################
#
# Setting light so that we could see the definition in the walls
#
####################
render.setShaderAuto()
self.dlight = DirectionalLight('dlight')
self.dlight.setColor(LVector4(0.3, 0.1, 0.7, 1))
dlnp = render.attachNewNode(self.dlight)
dlnp.setHpr(90, 20, 0)
render.setLight(dlnp)
self.alight = render.attachNewNode(AmbientLight("Ambient"))
self.alight.node().setColor(LVector4(0.5, 0.5, 1, .1))
render.setLight(self.alight)
base.disableMouse()
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
base.camera.reparentTo(self.floater)
base.camera.setPos(0, -20, 500)
base.camera.setP(-50)
self.bindKeys()
def setKey(self, key, value):
self.key[key] = value
def bindKeys(self):
self.accept("escape", sys.exit)
self.accept("a", self.setKey, ["left", True])
self.accept("a-up", self.setKey, ["left", False])
self.accept("d", self.setKey, ["right", True])
self.accept("d-up", self.setKey, ["right", False])
self.accept("w", self.setKey, ["forward", True])
self.accept("w-up", self.setKey, ["forward", False])
self.accept("s", self.setKey, ["backward", True])
self.accept("s-up", self.setKey, ["backward", False])
self.accept("space", self.setKey, ["down", True])
self.accept("space-up", self.setKey, ["down", False])
self.accept("shift", self.setKey, ["up", True])
self.accept("shift-up", self.setKey, ["up", False])
self.accept("arrow_up", self.setKey, ["cam_up", True])
self.accept("arrow_up-up", self.setKey, ["cam_up", False])
self.accept("arrow_down", self.setKey, ["cam_down", True])
self.accept("arrow_down-up", self.setKey, ["cam_down", False])
self.accept("arrow_left", self.setKey, ["cam_left", True])
self.accept("arrow_left-up", self.setKey, ["cam_left", False])
self.accept("arrow_right", self.setKey, ["cam_right", True])
self.accept("arrow_right-up", self.setKey, ["cam_right", False])
taskMgr.add(self.update, "update")
def update(self, task):
delta = globalClock.getDt()
WALKSPEED = 300
SPEED = 100
if self.key["left"]:
self.floater.setX(self.floater.getX() - WALKSPEED * delta)
if self.key["right"]:
self.floater.setX(self.floater.getX() + WALKSPEED * delta)
if self.key["forward"]:
self.floater.setY(self.floater.getY() + WALKSPEED * delta)
if self.key["backward"]:
self.floater.setY(self.floater.getY() - WALKSPEED * delta)
if self.key["up"]:
self.floater.setZ(self.floater.getZ() + WALKSPEED * delta)
if self.key["down"]:
self.floater.setZ(self.floater.getZ() - WALKSPEED * delta)
if self.key["cam_left"]:
base.camera.setH(base.camera.getH() + SPEED * delta)
if self.key["cam_right"]:
base.camera.setH(base.camera.getH() - SPEED * delta)
if self.key["cam_up"]:
base.camera.setP(base.camera.getP() + SPEED * delta)
if self.key["cam_down"]:
base.camera.setP(base.camera.getP() - SPEED * delta)
######################
#
# SIMPLE OCCLUSION FOR START AREA
#
######################
for p in self.start.parts:
if p.type == 'IceCube':
if math.fabs(
(math.sqrt((p.model.getX() * p.model.getX()) +
(p.model.getY() * p.model.getY())) -
math.sqrt(
(self.floater.getX() * self.floater.getX()) +
(self.floater.getY() * self.floater.getY())))) <= 400:
p.show()
#Ice cube movement
p.bob(delta)
else:
p.hide()
if p.type == 'Prism':
if p.type == 'Prism':
if math.fabs(
(math.sqrt((p.pos.x * p.pos.x) + (p.pos.y * p.pos.y)) -
math.sqrt(
(self.floater.getX() * self.floater.getX()) +
(self.floater.getY() * self.floater.getY()))
)) <= 1000:
p.show()
else:
p.hide()
######################
#
# SIMPLE OCCLUSION FOR CAVE PARTS
#
######################
for p in self.cave.parts:
if p.type == 'Prism':
if math.fabs(
(math.sqrt((p.pos.x * p.pos.x) + (p.pos.y * p.pos.y)) -
math.sqrt((self.floater.getX() * self.floater.getX()) +
(self.floater.getY() * self.floater.getY()))
)) <= 2200:
p.show()
else:
p.hide()
if p.type == 'IceCube':
if math.fabs(
(math.sqrt((p.model.getX() * p.model.getX()) +
(p.model.getY() * p.model.getY())) -
math.sqrt((self.floater.getX() * self.floater.getX()) +
(self.floater.getY() * self.floater.getY()))
)) <= 1250:
p.show()
#Ice cube movement
self.cave.moveIceCubes(delta / 25)
for p in self.cave.iceCubesThirdRoom:
p.bob(delta / 25)
for p in self.cave.iceCubesSecondRoom:
p.bob(delta / 25)
self.cave.bigCube.bob(delta / 25)
for p in self.start.iceCubes:
p.bob(delta)
else:
p.hide()
return task.cont
class KVProjectile(DirectObject):
#Property stuff
creaTime = time.clock()
dur = 1
vec = 0
delta = .5
prevtime = 0
flag = False
#defining the thing fired by whatever gun we have
def __init__(self, camera, look, id):
#nodepath of the projectile, give it a trajectory
self.projectileNode = NodePath('projectile'+str(id))
self.projectileNode.reparentTo(render)
#by passing the camera node form the camMov object, all projectiles are spawned 5 units in front of the camera
self.projectileNode.setHpr(look, 0, 0, 0)
self.projectileNode.setPos(camera,0,3, 3)
#fix z position to line up with gun
self.projectileNode.setScale(.1)
self.projectileModel = loader.loadModel("./resources/beam.egg")
self.projectileModel.reparentTo(self.projectileNode)
#must calculate unit vector based on direction
dir = render.getRelativeVector(look, Vec3(0, 1, 0))
#speed up or slow down projectiles here
dir = dir*5
self.vec = dir
#base.cTrav = CollisionTraverser()
cs = CollisionSphere(0, 0, 0, 2.5)
cnodepath = self.projectileNode.attachNewNode(CollisionNode('projNode'))
cnodepath.node().addSolid(cs)
self.collHand = CollisionHandlerEvent()
self.collHand.addInPattern('into'+str(id))
self.collHand.addOutPattern('outof')
#cTrav has the distinction of global colider handler
base.cTrav.addCollider(cnodepath, self.collHand)
self.acceptOnce('into'+str(id), self.hit)
#deal with colliding or special effects here.
#wanted projectiles to be short lived
#so i will make them delete themselves after impact or time expired
#writing a task that will rek the projectiles at the end of time
self.damage = 5
def moveTask(self, task):
#curtime = time.clock()
#self.delta = curtime-self.prevtime
if self.flag:
return task.done
velx = self.vec.x*self.delta
vely = self.vec.y*self.delta
velz = self.vec.z*self.delta
x = self.projectileNode.getX()
y = self.projectileNode.getY()
z = self.projectileNode.getZ()
self.projectileNode.setPos(x+velx, y+vely, z+velz)
#prevtime = time.clock()
if task.time < self.dur:
return task.cont
else:
self.flag = True
return task.done
def hit(self, collEntry):
#throw out a custom message for what hit
if collEntry.getIntoNodePath().getName() != 'projNode':
temp = collEntry.getIntoNodePath().getName()
messenger.send(temp, [self.damage])
#remove the impacting projectile
collEntry.getFromNodePath().getParent().getParent().removeNode()
self.flag = True
del self
class ChargeProjectile(DirectObject):
dur = 2
delta = .15
flag = False
def __init__(self, spawn, taregt, id):
self.projectileNode = NodePath('projectile'+str(id))
self.projectileNode.reparentTo(render)
self.projectileNode.setPos(spawn,0,-10, 0)
self.projectileNode.setScale(1.5)
self.projectileModel = Actor("./resources/sphereShot",{"grow":"./resources/sphereShot-grow"})
self.projectileModel.setColorScale(200, 0, 255, 100)
self.projectileModel.reparentTo(self.projectileNode)
self.projectileNode.setHpr(spawn, 0, 0, 0)
dir = render.getRelativeVector(spawn, Vec3(0, 1, 0))
self.vec = dir*-100
cs = CollisionSphere(0, 0, 0, 2.5)
cnodepath = self.projectileNode.attachNewNode(CollisionNode('projNode'))
cnodepath.node().addSolid(cs)
self.collHand = CollisionHandlerEvent()
self.collHand.addInPattern('bossProjectileinto'+str(id))
self.collHand.addOutPattern('outof')
base.cTrav.addCollider(cnodepath, self.collHand)
self.acceptOnce('bossProjectileinto'+str(id), self.hit)
self.damage = 15
def moveTask(self, task):
if self.flag:
return task.done
velx = self.vec.x*self.delta
vely = self.vec.y*self.delta
velz = self.vec.z*self.delta
x = self.projectileNode.getX()
y = self.projectileNode.getY()
z = self.projectileNode.getZ()
self.projectileNode.setPos(x+velx, y+vely, z+velz)
if task.time < self.dur:
return task.cont
else:
self.flag = True
return task.done
def hit(self, collEntry):
#throw out a custom message for what hit
if collEntry.getIntoNodePath().getName() != 'projNode':
temp = collEntry.getIntoNodePath().getName()
print temp
messenger.send(temp, [self.damage])
#remove the impacting projectile
collEntry.getFromNodePath().getParent().getParent().removeNode()
self.flag = True
del self
def wait(self, task):
if task.time > 2.24:
return task.done
return task.cont
class Ship:
set = 0
fuel = 1
air = 1
current = 0
acceleration = 0.002
max = 0.25
fall = 0.001
gravity = 0.3
steer = 0
steerspeed = 0.05
slide = 0
jumpheight = 0.2
jump = True
control = True
dead = False
under = None
def __init__(self, root, model):
self.root = root
self.node = NodePath("ship")
self.model = model
self.model.reparentTo(self.node)
self.node.reparentTo(render)
self.setColliders()
self.explosion = loader.loadModel("assets/models/explosion.bam")
self.explosion.reparentTo(render)
self.explosion.hide()
self.explosion.setLightOff()
self.loadAudio()
def loadAudio(self): # each ship has their own set of sounds
folder = "assets/audio/sfx/"
self.audio = {
"bounce":loader.loadSfx(folder+"bounce.wav"),
"engine":loader.loadSfx(folder+"engine.wav"),
"explode":loader.loadSfx(folder+"explode.wav"),
"land":loader.loadSfx(folder+"land.wav"),
"pickup":loader.loadSfx(folder+"pickup.wav"),
"shave":loader.loadSfx(folder+"shave.wav"),
}
def setColliders(self):
self.handlers = []
for i in range(3):
if i == 1: y = 0.2
else: y = -0.2
h = colRay(self.node, ((-1+i)/4, y, .1))
self.handlers.append(h)
self.colNose = colSpheres(self.node,
[((0,.1,.1),.02)])
self.colLeft = colSpheres(self.node,
[((-.15,-.1,.2), .1)])
self.colRight = colSpheres(self.node,
[((.15,-.1,.2), .1)])
self.colTop = colSpheres(self.node,
[((0,0.2,0.4), .1)])
def update(self):
self.control = True
self.air -= (1/5000)*self.o2drain
self.fuel -= (self.speed/1000)*self.fueldrain
if self.air <= 0.01 or self.fuel <= 0.01:
self.control = False
if not self.dead:
self.collide()
self.specialFloor()
# Set fw/bw speed
self.speed = clamp(self.speed, 0, self.max)
self.audio["engine"].setPlayRate((self.speed*7))
# Update node position
x = self.node.getX()+((self.steer+self.slide)*self.steerspeed)
y = self.node.getY()+self.speed
z = self.node.getZ()-self.fall
self.node.setFluidPos(x, y, z)
# Point nose to fall speed
self.model.setP(-(self.fall*300))
# Set flame color to speed
cc = (self.speed*7)-uniform(0,0.3)
self.model.getChild(0).setColorScale(cc*2,cc,cc,1)
# Respawn if fallen off.
if z < -20:
self.respawn()
self.setMeters()
def specialFloor(self):
f = self.under
if f:
if f == 1:
self.root.road.playNextMap()
self.respawn()
elif f == 2:
self.explode()
elif f == 3:
self.speed += self.acceleration*2
elif f == 4:
self.fuel = 0.99
self.air = 0.99
elif f == 5:
self.control = False
elif f == 6:
self.speed -= self.acceleration*2
def collide(self):
if self.colNose.getNumEntries() > 0:
if self.speed > 0.1: # full frontal crash
self.explode()
else: # full frontal bump
self.audio["shave"].play()
self.speed = 0
self.node.setY(self.node.getY()-0.2)
# bounce left and right
if self.colLeft.getNumEntries() > 0:
self.steer = 1
self.audio["shave"].play()
elif self.colRight.getNumEntries() > 0:
self.steer = -1
self.audio["shave"].play()
# connect to floor
self.grounded = False
self.under = under = None
self.root.cTrav.traverse(render)
hits = [0,0,0]
for h, handler in enumerate(self.handlers):
if len(list(handler.entries)) > 0:
handler.sortEntries()
entry = list(handler.entries)[0]
hitPos = entry.getSurfacePoint(render)
distToGround = self.node.getZ() - hitPos.getZ()
if distToGround < 0.03:
hits[h] = 1
if distToGround < self.fall+0.05:
if self.fall > 0.05: #go bounce
self.fall = -0.05
self.jump = True
self.audio["bounce"].play()
elif self.fall > 0: #land
self.fall = 0
self.jump = True
self.audio["land"].play()
if self.colTop.getNumEntries() > 0:
self.fall = 0
self.grounded = True
under = entry.getSurfacePoint(render)
self.node.setZ(hitPos.getZ()+0.01)
s = self.getSteerVal()
if hits == [1,0,0]:
self.slide += 0.01
elif hits == [0,0,1]:
self.slide -= 0.01
elif not hits == [0,0,0]:
self.slide = 0
# fall if not on floor
if not self.grounded:
self.fall += (self.gravity)/550
if self.colTop.getNumEntries() > 0:
if self.fall < 0:
self.fall = -self.fall
# else see what color the floor is
elif under:
x, y, z = under
x = round(x)
y = round(y/2)
z = round(z*2)-1
try:
color = self.root.road.map[y][x][z][1]
if color <= 8 :
self.under = color
except:
pass
def setMeters(self):
self.root.hud.setSpeed(self.speed*114)
self.root.hud.setAir(self.air*14)
self.root.hud.setFuel(self.fuel*14)
self.root.hud.setMiles(self.node.getY(), len(self.root.road.map))
self.root.hud.setGravity(self.gravity)
def explode(self):
Explosion(self, self.explosion)
self.audio["engine"].stop()
self.audio["explode"].play()
self.node.hide()
self.dead = True
def accelerate(self):
if not self.dead and self.control:
self.speed += self.acceleration
def decelerate(self):
if not self.dead and self.control:
self.speed -= self.acceleration
def getSteerVal(self):
return ((self.speed*4)+0.1)
def goLeft(self):
if not self.dead and self.control:
if self.grounded or self.fall < -0.07:
if self.colLeft.getNumEntries() == 0:
self.steer = -self.getSteerVal()
self.slide = 0
def goRight(self):
if not self.dead and self.control:
if self.grounded or self.fall < -0.07:
if self.colRight.getNumEntries() == 0:
self.steer = self.getSteerVal()
self.slide = 0.01
def jumpUp(self):
if self.gravity < 8:
if not self.dead and self.control:
if self.colTop.getNumEntries() == 0:
if self.jump and self.fall < 0.05:
self.fall = -0.1
self.jump = False
def respawn(self):
self.audio["engine"].setLoop(True)
self.audio["engine"].setVolume(1)
self.audio["engine"].play()
self.node.show()
self.node.setPos(4,0,0.7)
self.fall = 0
self.speed = 0
self.jump = True
self.control = True
self.dead = False
self.air = 1
self.fuel = 1
self.gravity = self.root.road.gravity
self.fueldrain = self.root.road.fueldrain
self.o2drain = self.root.road.o2drain
self.setMeters()
class Maleficium(ShowBase):
def __init__(self):
compressedTextures = ConfigVariableString('compressed-textures','1') # Compresses Textures on load (increases loadtime / framerate)
ShowBase.__init__(self)
## Debug Values (True/False)
self.fpsMeter = True
debug.checkDebugSettings(self)
self.KeyBindings()
## Load World
world.load('prisonCrater')
## Add Player to World
self.playerBox = NodePath('player')
self.player = Actor("data/models/hm.bam",
{"run":"data/models/hm-run.bam",
"idle":"data/models/hm.bam"})
self.player.reparentTo(self.playerBox)
self.player.setScale(.01)
self.playerBox.reparentTo(render)
self.isMoving = False
## Create Camera
base.disableMouse()
self.cameratarget = self.render.attachNewNode('Camera Target')
base.camera.setPos(self.playerBox.getX(),self.playerBox.getY()+20,self.playerBox.getZ()+5)
self.cameratarget.setPos(self.playerBox.getX(),self.playerBox.getY(),self.playerBox.getZ()+6)
self.radius = 10
self.XYAngle = .028
self.ZAngle = .01
## Set Up Ground Collisions
## Player Collision
base.cTrav = CollisionTraverser()
self.ColHandler = CollisionHandlerFloor()
self.colGroundRay = CollisionNode('colGroundRay')
self.colGroundRay.addSolid(CollisionRay(0,0,2,0,0,-1))
self.playerCol = self.playerBox.attachNewNode(self.colGroundRay)
base.cTrav.addCollider(self.playerCol,self.ColHandler)
self.ColHandler.addCollider(self.playerCol,self.playerBox)
## Add main Game Loop to taskmanager
taskMgr.add(self.gameLoop,'mainLoop')
### Input Structure; Coded by Darren Kent (Modeled after Roaming-Ralph by Ryan Myers)
def KeyBindings(self):
## Setup Map
self.startRightClick = True
self.keyMap = {
"forward":0,
"backward":0,
"turn_left":0,
"turn_right":0,
"strafe_left":0,
"strafe_right":0,
"cam_up":0,
"cam_down":0,
"cam_right":0,
"cam_left":0,
"zoom_in":0,
"zoom_out":0,
"right_click":0,
"wheel_zoom_in":0,
"wheel_zoom_out":0,
}
## Accept Keys
self.accept('escape',sys.exit)
self.accept('w', self.setKey, ['forward',1])
self.accept('w-up', self.setKey, ['forward',0])
self.accept('s', self.setKey, ['backward',1])
self.accept('s-up', self.setKey, ['backward',0])
self.accept('a', self.setKey, ['turn_left',1])
self.accept('a-up', self.setKey, ['turn_left',0])
self.accept('d', self.setKey, ['turn_right',1])
self.accept('d-up', self.setKey, ['turn_right',0])
self.accept('q', self.setKey, ['strafe_left',1])
self.accept('q-up', self.setKey, ['strafe_left',0])
self.accept('e', self.setKey, ['strafe_right',1])
self.accept('e-up', self.setKey, ['strafe_right',0])
self.accept('arrow_up', self.setKey, ['cam_down',1])
self.accept('arrow_up-up', self.setKey, ['cam_down',0])
self.accept('arrow_down', self.setKey, ['cam_up',1])
self.accept('arrow_down-up', self.setKey, ['cam_up',0])
self.accept('arrow_right', self.setKey, ['cam_right',1])
self.accept('arrow_right-up', self.setKey, ['cam_right',0])
self.accept('arrow_left', self.setKey, ['cam_left',1])
self.accept('arrow_left-up', self.setKey, ['cam_left',0])
self.accept('[', self.setKey, ['zoom_in',1])
self.accept('[-up', self.setKey, ['zoom_in',0])
self.accept(']', self.setKey, ['zoom_out',1])
self.accept(']-up', self.setKey, ['zoom_out',0])
## Accept Mouse
self.accept('mouse3',self.setKey, ['right_click',1])
self.accept('mouse3-up',self.setKey, ['right_click',0])
self.accept('wheel_up',self.setKey, ['wheel_zoom_in',1])
self.accept('wheel_down',self.setKey, ['wheel_zoom_out',1])
### Set Key Presses; Coded by Darren Kent (Modeled after Roaming-Ralph by Ryan Myers)
def setKey(self,key,value):
self.keyMap[key] = value
### Main Game Loop; Coded by Darren Kent
def gameLoop(self,task):
## Keyboard Camera Controls
if (self.keyMap["cam_left"]!=0):
self.XYAngle += .002
if (self.keyMap["cam_right"]!=0):
self.XYAngle -= .002
if (self.keyMap["cam_up"] != 0):
if self.ZAngle <= .045:
self.ZAngle += .001
if (self.keyMap["cam_down"] != 0):
if self.ZAngle >= .002:
self.ZAngle -= .001
if (self.keyMap["zoom_in"] != 0):
if self.radius >= 4:
self.radius -= 1
self.setRadius = self.radius
if (self.keyMap["zoom_out"] != 0):
if self.radius <= 40:
self.radius += 1
self.setRadius = self.radius
## Mouse Camera Controls
if (self.keyMap["right_click"]!=0):
if self.startRightClick == True:
self.startRightClick = False
self.tempMouseX = base.mouseWatcherNode.getMouseX()
self.tempMouseY = base.mouseWatcherNode.getMouseY()
self.tempXAngle = self.XYAngle
self.tempZAngle = self.ZAngle
self.tempPlayerH = self.playerBox.getH()
elif self.startRightClick == False:
Ztemp = self.tempZAngle + (base.mouseWatcherNode.getMouseY() - self.tempMouseY) / 20
self.XYAngle = self.tempXAngle - (base.mouseWatcherNode.getMouseX() - self.tempMouseX) / 20
if Ztemp >= .045:
Ztemp = .045
if Ztemp <= 0.002:
Ztemp = 0.002
self.ZAngle = Ztemp
else:
self.startRightClick = True
if (self.keyMap["wheel_zoom_in"] != 0):
if self.radius >= 7:
self.radius -= 3
self.setRadius = self.radius
if (self.keyMap["wheel_zoom_out"] != 0):
if self.radius <= 38:
self.radius += 2
self.setRadius = self.radius
self.setKey("wheel_zoom_out",0)
self.setKey("wheel_zoom_in", 0)
## Reposition Camera
x = self.cameratarget.getX() + self.radius * math.sin(math.degrees(self.ZAngle)) * math.cos(math.degrees(self.XYAngle))
y = self.cameratarget.getY() + self.radius * math.sin(math.degrees(self.ZAngle)) * math.sin(math.degrees(self.XYAngle))
z = self.cameratarget.getZ() + self.radius * math.cos(math.degrees(self.ZAngle))
base.camera.setPos(x,y,z)
base.camera.lookAt(self.cameratarget)
self.cameratarget.setPos(self.playerBox.getX(),self.playerBox.getY(),self.playerBox.getZ()+6)
## Keyboard Movement Controls
if (self.keyMap["turn_left"]!=0):
self.playerBox.setH(self.playerBox.getH() + 200 * globalClock.getDt())
if (self.keyMap["turn_right"]!=0):
self.playerBox.setH(self.playerBox.getH() - 200 * globalClock.getDt())
if (self.keyMap["strafe_left"]!=0):
self.playerBox.setX(self.playerBox, +20 * globalClock.getDt())
if (self.keyMap["strafe_right"]!=0):
self.playerBox.setX(self.playerBox, -20 * globalClock.getDt())
if (self.keyMap["forward"]!=0):
self.playerBox.setY(self.playerBox, -25 * globalClock.getDt())
if (self.keyMap["backward"] != 0):
self.playerBox.setY(self.playerBox, +15 * globalClock.getDt())
if (self.keyMap["forward"]!=0):
if self.isMoving == False:
self.player.setPlayRate(2.5,'run')
self.player.loop('run')
self.isMoving = True
else:
if self.isMoving:
self.player.setPlayRate(1,'idle')
self.player.loop('idle')
self.isMoving = False
## Check Collisions
return task.cont
class PartyCog(FSM):
notify = directNotify.newCategory('PartyCog')
HpTextGenerator = TextNode('HpTextGenerator')
hpText = None
height = 7
def __init__(self,
parentNode,
id,
bounceSpeed=3,
bounceHeight=1,
rotateSpeed=1,
heightShift=1,
xMoveSpeed=0,
xMoveDistance=0,
bounceOffset=0):
self.id = id
FSM.__init__(self, 'PartyCogFSM-%d' % self.id)
self.showFacingStatus = False
self.xMoveSpeed = xMoveSpeed
self.xMoveDistance = xMoveDistance
self.heightShift = heightShift
self.bounceSpeed = bounceSpeed
self.bounceHeight = bounceHeight
self.rotateSpeed = rotateSpeed
self.parentNode = parentNode
self.bounceOffset = bounceOffset
self.hitInterval = None
self.kaboomTrack = None
self.resetRollIval = None
self.netTimeSentToStartByHit = 0
self.load()
self.request('Down')
return
def load(self):
self.root = NodePath('PartyCog-%d' % self.id)
self.root.reparentTo(self.parentNode)
path = 'phase_13/models/parties/cogPinata_'
self.actor = Actor(
path + 'actor', {
'idle': path + 'idle_anim',
'down': path + 'down_anim',
'up': path + 'up_anim',
'bodyHitBack': path + 'bodyHitBack_anim',
'bodyHitFront': path + 'bodyHitFront_anim',
'headHitBack': path + 'headHitBack_anim',
'headHitFront': path + 'headHitFront_anim'
})
self.actor.reparentTo(self.root)
self.temp_transform = Mat4()
self.head_locator = self.actor.attachNewNode('temphead')
self.bodyColl = CollisionTube(0, 0, 1, 0, 0, 5.75, 0.75)
self.bodyColl.setTangible(1)
self.bodyCollNode = CollisionNode('PartyCog-%d-Body-Collision' %
self.id)
self.bodyCollNode.setCollideMask(ToontownGlobals.PieBitmask)
self.bodyCollNode.addSolid(self.bodyColl)
self.bodyCollNodePath = self.root.attachNewNode(self.bodyCollNode)
self.headColl = CollisionTube(0, 0, 3, 0, 0, 3.0, 1.5)
self.headColl.setTangible(1)
self.headCollNode = CollisionNode('PartyCog-%d-Head-Collision' %
self.id)
self.headCollNode.setCollideMask(ToontownGlobals.PieBitmask)
self.headCollNode.addSolid(self.headColl)
self.headCollNodePath = self.root.attachNewNode(self.headCollNode)
self.arm1Coll = CollisionSphere(1.65, 0, 3.95, 1.0)
self.arm1Coll.setTangible(1)
self.arm1CollNode = CollisionNode('PartyCog-%d-Arm1-Collision' %
self.id)
self.arm1CollNode.setCollideMask(ToontownGlobals.PieBitmask)
self.arm1CollNode.addSolid(self.arm1Coll)
self.arm1CollNodePath = self.root.attachNewNode(self.arm1CollNode)
self.arm2Coll = CollisionSphere(-1.65, 0, 3.45, 1.0)
self.arm2Coll.setTangible(1)
self.arm2CollNode = CollisionNode('PartyCog-%d-Arm2-Collision' %
self.id)
self.arm2CollNode.setCollideMask(ToontownGlobals.PieBitmask)
self.arm2CollNode.addSolid(self.arm2Coll)
self.arm2CollNodePath = self.root.attachNewNode(self.arm2CollNode)
splatName = 'splat-creampie'
self.splat = globalPropPool.getProp(splatName)
self.splat.setBillboardPointEye()
self.splatType = globalPropPool.getPropType(splatName)
self.pieHitSound = globalBattleSoundCache.getSound(
'AA_wholepie_only.ogg')
self.upSound = globalBattleSoundCache.getSound('AV_jump_to_side.ogg')
self.hole = loader.loadModel('phase_13/models/parties/cogPinataHole')
self.hole.setTransparency(True)
self.hole.setP(-90.0)
self.hole.setScale(3)
self.hole.setBin('ground', 3)
self.hole.reparentTo(self.parentNode)
def unload(self):
self.request('Off')
self.clearHitInterval()
if self.hole is not None:
self.hole.removeNode()
self.hole = None
if self.actor is not None:
self.actor.cleanup()
self.actor.removeNode()
self.actor = None
if self.root is not None:
self.root.removeNode()
self.root = None
if self.kaboomTrack is not None and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.kaboomTrack = None
if self.resetRollIval is not None and self.resetRollIval.isPlaying():
self.resetRollIval.finish()
self.resetRollIval = None
if self.hitInterval is not None and self.hitInterval.isPlaying():
self.hitInterval.finish()
self.hitInterval = None
del self.upSound
del self.pieHitSound
return
def enterStatic(self):
pass
def exitStatic(self):
pass
def enterActive(self, startTime):
self.root.setR(0.0)
updateTask = Task.Task(self.updateTask)
updateTask.startTime = startTime
taskMgr.add(updateTask, 'PartyCog.update-%d' % self.id)
def exitActive(self):
taskMgr.remove('PartyCog.update-%d' % self.id)
taskMgr.remove('PartyCog.bounceTask-%d' % self.id)
self.clearHitInterval()
self.resetRollIval = self.root.hprInterval(0.5,
Point3(
self.root.getH(), 0.0,
0.0),
blendType='easeInOut')
self.resetRollIval.start()
self.actor.stop()
def enterDown(self):
if self.oldState == 'Off':
downAnimControl = self.actor.getAnimControl('down')
self.actor.pose('down', downAnimControl.getNumFrames() - 1)
return
self.clearHitInterval()
startScale = self.hole.getScale()
endScale = Point3(5, 5, 5)
self.hitInterval = Sequence(
LerpFunc(self.setAlongSpline,
duration=1.0,
fromData=self.currentT,
toData=0.0),
LerpScaleInterval(self.hole,
duration=0.175,
scale=endScale,
startScale=startScale,
blendType='easeIn'),
Parallel(
SoundInterval(self.upSound,
volume=0.6,
node=self.actor,
cutOff=PartyGlobals.PARTY_COG_CUTOFF),
ActorInterval(self.actor, 'down', loop=0)),
LerpScaleInterval(self.hole,
duration=0.175,
scale=Point3(3, 3, 3),
startScale=endScale,
blendType='easeOut'))
self.hitInterval.start()
def exitDown(self):
self.root.setR(0.0)
self.root.setH(0.0)
self.targetDistance = 0.0
self.targetFacing = 0.0
self.currentT = 0.0
self.setAlongSpline(0.0)
self.clearHitInterval()
startScale = self.hole.getScale()
endScale = Point3(5, 5, 5)
self.hitInterval = Sequence(
LerpScaleInterval(self.hole,
duration=0.175,
scale=endScale,
startScale=startScale,
blendType='easeIn'),
Parallel(
SoundInterval(self.upSound,
volume=0.6,
node=self.actor,
cutOff=PartyGlobals.PARTY_COG_CUTOFF),
ActorInterval(self.actor, 'up', loop=0)),
Func(self.actor.loop, 'idle'),
LerpScaleInterval(self.hole,
duration=0.175,
scale=Point3(3, 3, 3),
startScale=endScale,
blendType='easeOut'))
self.hitInterval.start()
def filterDown(self, request, args):
if request == 'Down':
return None
else:
return self.defaultFilter(request, args)
return None
def setEndPoints(self, start, end, amplitude=1.7):
self.sinAmplitude = amplitude
self.sinPeriod = (end.getX() - start.getX()) / 2
self.sinDisplacement = start.getY()
self.startPoint = start
self.endPoint = end
self.currentT = 0.0
self.targetDistance = 0.0
self.currentFacing = 0.0
self.targetFacing = 0.0
self.setAlongSpline(self.currentT)
self.hole.setPos(self.root.getPos())
self.hole.setZ(0.02)
def rockBackAndForth(self, task):
t = task.startTime + task.time
angle = math.sin(t) * 20.0
self.root.setR(angle)
return task.cont
def updateDistance(self, distance):
self.targetDistance = clamp(distance, -1.0, 1.0)
def updateTask(self, task):
self.rockBackAndForth(task)
if self.targetDistance > self.currentT:
self.currentT += min(0.01, self.targetDistance - self.currentT)
self.setAlongSpline(self.currentT)
elif self.targetDistance < self.currentT:
self.currentT += max(-0.01, self.targetDistance - self.currentT)
self.setAlongSpline(self.currentT)
if self.currentT < 0.0:
self.targetFacing = -90.0
elif self.currentT > 0.0:
self.targetFacing = 90.0
else:
self.targetFacing = 0.0
if self.targetFacing > self.currentFacing:
self.currentFacing += min(10,
self.targetFacing - self.currentFacing)
elif self.targetFacing < self.currentFacing:
self.currentFacing += max(-10,
self.targetFacing - self.currentFacing)
self.root.setH(self.currentFacing)
return task.cont
def setAlongSpline(self, t):
t = t + 1.0
dist = (self.endPoint.getX() - self.startPoint.getX()) / 2.0
x = self.startPoint.getX() + t * dist
y = self.startPoint.getY() - math.sin(
t * 2 * math.pi) * self.sinAmplitude
self.root.setPos(x, y, 0)
def startBounce(self):
taskMgr.add(self.bounce, 'PartyCog.bounceTask-%d' % self.id)
def bounce(self, task):
self.root.setZ(
math.sin((self.bounceOffset + task.time) * self.bounceSpeed) *
self.bounceHeight + self.heightShift)
return task.cont
def setPos(self, position):
self.root.setPos(position)
def respondToPieHit(self, timestamp, position, hot=False, direction=1.0):
if self.netTimeSentToStartByHit < timestamp:
self.__showSplat(position, direction, hot)
if self.netTimeSentToStartByHit < timestamp:
self.netTimeSentToStartByHit = timestamp
else:
self.notify.debug(
'respondToPieHit self.netTimeSentToStartByHit = %s' %
self.netTimeSentToStartByHit)
def clearHitInterval(self):
if self.hitInterval is not None and self.hitInterval.isPlaying():
self.hitInterval.clearToInitial()
return
def __showSplat(self, position, direction, hot=False):
if self.kaboomTrack is not None and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.clearHitInterval()
splatName = 'splat-creampie'
self.splat = globalPropPool.getProp(splatName)
self.splat.setBillboardPointEye()
self.splat.reparentTo(render)
self.splat.setPos(self.root, position)
self.splat.setAlphaScale(1.0)
if not direction == 1.0:
self.splat.setColorScale(PartyGlobals.CogActivitySplatColors[0])
if self.currentFacing > 0.0:
facing = 'HitFront'
else:
facing = 'HitBack'
else:
self.splat.setColorScale(PartyGlobals.CogActivitySplatColors[1])
if self.currentFacing > 0.0:
facing = 'HitBack'
else:
facing = 'HitFront'
if hot:
targetscale = 0.75
part = 'head'
else:
targetscale = 0.5
part = 'body'
def setSplatAlpha(amount):
self.splat.setAlphaScale(amount)
self.hitInterval = Sequence(
ActorInterval(self.actor, part + facing, loop=0),
Func(self.actor.loop, 'idle'))
self.hitInterval.start()
self.kaboomTrack = Parallel(
SoundInterval(self.pieHitSound,
volume=1.0,
node=self.actor,
cutOff=PartyGlobals.PARTY_COG_CUTOFF),
Sequence(
Func(self.splat.showThrough),
Parallel(
Sequence(
LerpScaleInterval(self.splat,
duration=0.175,
scale=targetscale,
startScale=Point3(0.1, 0.1, 0.1),
blendType='easeOut'), Wait(0.175)),
Sequence(
Wait(0.1),
LerpFunc(setSplatAlpha,
duration=1.0,
fromData=1.0,
toData=0.0,
blendType='easeOut'))),
Func(self.splat.cleanup), Func(self.splat.removeNode)))
self.kaboomTrack.start()
return
def showHitScore(self, number, scale=1):
if number <= 0:
return
if self.hpText:
self.hideHitScore()
self.HpTextGenerator.setFont(ToontownGlobals.getSignFont())
if number < 0:
self.HpTextGenerator.setText(str(number))
else:
self.HpTextGenerator.setText('+' + str(number))
self.HpTextGenerator.clearShadow()
self.HpTextGenerator.setAlign(TextNode.ACenter)
r = 1
g = 1
b = 0
a = 1
self.HpTextGenerator.setTextColor(r, g, b, a)
self.hpTextNode = self.HpTextGenerator.generate()
self.hpText = render.attachNewNode(self.hpTextNode)
self.hpText.setScale(scale)
self.hpText.setBillboardPointEye()
self.hpText.setBin('fixed', 100)
self.hpText.setPos(self.root, 0, 0, self.height / 2)
seq = Sequence(
self.hpText.posInterval(
0.25,
Point3(self.root.getX(render), self.root.getY(render),
self.root.getZ(render) + self.height + 1.0),
blendType='easeOut'), Wait(0.25),
self.hpText.colorInterval(0.1, Vec4(r, g, b, 0)),
Func(self.hideHitScore))
seq.start()
def hideHitScore(self):
if self.hpText:
taskMgr.remove('PartyCogHpText' + str(self.id))
self.hpText.removeNode()
self.hpText = None
return
def getHeadLocation(self):
self.actor.getJoints(jointName='head')[0].getNetTransform(
self.temp_transform)
self.head_locator.setMat(self.temp_transform)
return self.head_locator.getZ(self.root)
class TextHistory(SogalForm):
'''
Text history form
'''
def __init__(self):
'''
Constructor
'''
SogalForm.__init__(self, fading = True, fading_duration = 0.3, enableMask = True,backgroundColor = (0,0,0,0.6))
self.reparentTo(aspect2d,sort = 101)
self.frame = DirectScrolledFrame(parent = self, canvasSize = CANVASSIZE,
frameSize = FRAMESIZE,
autoHideScrollBars = AUTO_HIDE_SCROLLBARS,
)
self.reloadTheme()
self.height = TOP
self.shiftedHeight = 0
self.shifter = NodePath('text_history_shifter')
self.shifter.reparentTo(self.frame.getCanvas())
if not prop_set_up:
nameprops = TextProperties() # @UndefinedVariable
nameprops.setTextScale(0.75)
TextPropertiesManager.getGlobalPtr().setProperties("th_name", nameprops) # @UndefinedVariable
self.labels = []
def destroy(self):
self.labels = []
self.shifter.removeNode()
SogalForm.destroy(self)
def append(self,text,speaker,voiceName):
if len(self.labels) >= MAXENTITIES:
self.removeHead()
label = TextHistoryLabel(text, speaker, voiceName, parent = self.shifter, height=self.height)
self.height += label.getLabelHeight() + SPACING
self.labels.append(label)
self.resetCanvasSize()
def removeHead(self):
removing = self.labels.pop(0)
h = removing.getLabelHeight() + SPACING
self.shiftedHeight += h
self.shifter.setZ(self.shifter.getZ() + h)
#shift the parent NodePath to move all labels up
removing.destroy()
self.frame.verticalScroll.setValue(1)
def resetCanvasSize(self):
self.frame['canvasSize'] = (CANVASSIZE[0],CANVASSIZE[1],- TOP - self.height + self.shiftedHeight, 0)
self.frame.verticalScroll.setValue(1)
def roll(self,value):
if self.labels:
self.frame.verticalScroll.setValue(self.frame.verticalScroll.getValue() + value*2.0/len(self.labels))
def focused(self):
self.accept('mouse1', self.hide)
self.accept('mouse2', self.hide)
self.accept('mouse3', self.hide)
self.accept('escape', self.hide)
self.accept('wheel_up', self.roll, [-1.0])
#self.accept('wheel_down', self.wheeldown)
self.accept('wheel_down', self.roll, [1.0])
self.accept('arrow_up-repeat', self.roll, [-1.0])
self.accept('arrow_down-repeat', self.roll, [1.0])
self.accept('arrow_up', self.roll, [-1.0])
self.accept('arrow_down', self.roll, [1.0])
self.accept('w-repeat', self.roll, [-1.0])
self.accept('s-repeat', self.roll, [1.0])
self.accept('w', self.roll, [-1.0])
self.accept('s', self.roll, [1.0])
SogalForm.focused(self)
def defocused(self):
self.ignore('mouse1')
self.ignore('mouse2')
self.ignore('mouse3')
self.ignore('escape')
self.ignore('wheel_up')
self.ignore('wheel_down')
self.ignore('arrow_up-repeat')
self.ignore('arrow_down-repeat')
self.ignore('arrow_up')
self.ignore('arrow_down')
self.ignore('w-repeat')
self.ignore('s-repeat')
self.ignore('w')
self.ignore('s')
SogalForm.defocused(self)
def hide(self):
self.removeFocus()
SogalForm.hide(self)
def wheeldown(self):
if self.frame.verticalScroll.getValue() < 1:
self.roll(1.0)
else: self.hide()
def reloadTheme(self):
di = base.getStyle('frame')
for key in di:
self.frame[key] = di[key]
class Player():
def __init__(self, game, hp, mana, strength, dexterity, vigor, magic):
self.game = game
self.ori = 0.0
self.lastori = -1
self.zoomLevel = 0.0
self.nextAttack = 0.0
self.attacked = False
# Atributes
self.hp = hp
self.mana = mana
self.strength = strength
self.dexterity = dexterity
self.vigor = vigor
self.magic = magic
# Atributes calculated
self.attackDamage = random(
1, 7) + self.strength / 100 # physical dmg = weapon damage * %str
self.magicDamage = random(
3, 12) + self.magic / 100 # magic dmg = skill damage * %magic
self.speed = 15 + 0 # speed = base speed + item
self.runSpeed = 25 + 0 # run speed = base speed + item
self.lateralSpeed = 10 # speed when moving sidewards
self.lateralRunSpeed = 20 # run speed when moving sidewards
self.backwardsSpeed = 10 # speed when moving backwards
self.backwardsRunSpeed = 20 # run speed when moving backwards
self.defense = 5 + self.vigor / 2 # defense = armour + 1/2 vigor
self.criticalChance = 10 + 0 # crit chance = base item + skill
self.criticalMultiplier = self.attackDamage * 1.5 # crit mult = base item + skill
self.magicDefense = 2 + self.magic / 2 # magic def = base item + 1/2 magic
self.attackSpeed = (
0.2 * self.dexterity) / 60 # attack speed = base * dex / 60
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"cam-left": 0,
"cam-right": 0,
"jump": 0,
"attack": 0,
"run": 0
}
# Player Parts
parts = [
"head", "larm", "rarm", "lboot", "rboot", "lleg", "rleg", "lhand",
"rhand", "torso"
]
self.previousPart = {name: None for name in parts}
# Player Models & Animations
models = {name: "models/hero/%s" % name for name in parts}
animations = {
name: {
"standby": "models/hero/%s-standby" % name,
"walk": "models/hero/%s-walk" % name,
"walk-back": "models/hero/%s-walk-back" % name,
"walk-side": "models/hero/%s-walk-side" % name,
"slash-front": "models/hero/%s-slash-front" % name
}
for name in parts
}
for itemClass, items in self.game.items["items"].items():
if itemClass == "armours":
for itemType, value in items["lightarmours"].items():
modelName = value["model"]
for itemType, value in items["midarmours"].items():
modelName = value["model"]
for itemType, value in items["heavyarmours"].items():
modelName = value["model"]
models["torso-%s" %
modelName] = "models/hero/torso-%s" % modelName
animations["torso-%s" % modelName] = {
"standby":
"models/hero/torso-%s-standby" % modelName,
"walk":
"models/hero/torso-%s-walk" % modelName,
"walk-back":
"models/hero/torso-%s-walk-back" % modelName,
"walk-side":
"models/hero/torso-%s-walk-side" % modelName,
"slash-front":
"models/hero/torso-%s-slash-front" % modelName
}
for itemType, value in items["helmets"].items():
modelName = value["model"]
models["head-%s" %
modelName] = "models/hero/head-%s" % modelName
animations["head-%s" % modelName] = {
"standby":
"models/hero/head-%s-standby" % modelName,
"walk":
"models/hero/head-%s-walk" % modelName,
"walk-back":
"models/hero/head-%s-walk-back" % modelName,
"walk-side":
"models/hero/head-%s-walk-side" % modelName,
"slash-front":
"models/hero/head-%s-slash-front" % modelName
}
# Init Actor
self.playerActor = Actor(models, animations)
# Hide All Player Parts
for itemClass, items in self.game.items["items"].items():
if itemClass == "armours":
for itemType, value in items["lightarmours"].items():
modelName = value["model"]
for itemType, value in items["midarmours"].items():
modelName = value["model"]
for itemType, value in items["heavyarmours"].items():
modelName = value["model"]
self.playerActor.hidePart("torso-%s" % modelName)
for itemType, value in items["helmets"].items():
modelName = value["model"]
self.playerActor.hidePart("head-%s" % modelName)
#self.playerActor.ls()
# Shaders
self.shader = Shader.load("shaders/testShader.sha", Shader.SL_Cg)
#self.playerActor.setShader(self.shader)
# End shaders
self.moveFloater = NodePath(PandaNode("moveFloater"))
self.moveFloater.reparentTo(render)
self.moveFloater.setPos(self.game.playerStartPos)
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
#self.floater.setZ(8.0)
self.playerActor.setHpr(0, 0, 0)
self.playerActor.setScale(0.5)
self.playerActor.reparentTo(self.moveFloater)
#self.playerHand = self.playerActor.exposeJoint(None, 'body', 'manod')
#self.playerHead = self.playerActor.controlJoint(None, 'body', 'cabeza')
#self.playerHead.setScale(10,10,10)
self.inventory = [["0" for x in range(10)] for x in range(5)]
# COLS-ROWS # COLS-ROWS
self.inventory[0][3] = self.game.items["items"]["armours"][
"heavyarmours"]["ironplate"]
self.inventory[0][4] = self.game.items["items"]["armours"][
"heavyarmours"]["steelplate"]
self.inventory[0][5] = self.game.items["items"]["armours"][
"heavyarmours"]["cuirass"]
self.inventory[3][3] = self.game.items["items"]["armours"][
"midarmours"]["leatherarmour"]
self.inventory[0][0] = self.game.items["items"]["weapons"]["swords"][
"longsword"]
self.inventory[1][0] = self.game.items["items"]["armours"][
"midarmours"]["leatherarmour"]
self.inventory[0][8] = self.game.items["items"]["weapons"]["swords"][
"longsword"]
self.inventory[0][7] = self.game.items["items"]["weapons"]["spears"][
"ironspear"]
self.inventory[3][9] = self.game.items["items"]["armours"][
"midarmours"]["leatherarmour"]
self.inventory[1][9] = self.game.items["items"]["armours"][
"midarmours"]["leatherarmour"]
self.inventory[1][8] = self.game.items["items"]["armours"]["boots"][
"leatherboots"]
self.inventory[1][7] = self.game.items["items"]["armours"]["helmets"][
"woolchaco"]
self.inventory[0][6] = self.game.items["items"]["armours"]["helmets"][
"goldencrown"]
self.inventory[0][8] = self.game.items["items"]["armours"]["helmets"][
"ironhelmet"]
self.inventory[1][6] = self.game.items["items"]["armours"]["cloacks"][
"woolcloack"]
self.inventory[2][9] = self.game.items["items"]["armours"][
"midarmours"]["leatherarmour"]
self.inventory[2][8] = self.game.items["items"]["armours"]["boots"][
"leatherboots"]
self.inventory[2][7] = self.game.items["items"]["armours"]["helmets"][
"woolchaco"]
self.inventory[2][6] = self.game.items["items"]["armours"]["cloacks"][
"woolcloack"]
self.inventory[2][5] = self.game.items["items"]["armours"]["gloves"][
"woolgloves"]
self.inventory[1][5] = self.game.items["items"]["armours"]["gloves"][
"woolgloves"]
self.inventory[2][4] = self.game.items["items"]["accesories"]["rings"][
"simplering"]
self.inventory[1][4] = self.game.items["items"]["accesories"]["rings"][
"simplering"]
self.inventory[2][3] = self.game.items["items"]["accesories"][
"trinkets"]["rubyamulet"]
self.inventory[1][3] = self.game.items["items"]["accesories"][
"trinkets"]["rubyamulet"]
self.inventory[2][2] = self.game.items["items"]["armours"]["shields"][
"ironshield"]
self.inventory[1][2] = self.game.items["items"]["armours"]["shields"][
"ironshield"]
self.equip = {
"armour": None,
"helmet": None,
"gloves": None,
"boots": None,
"cloack": None,
"ringLeft": None,
"ringRight": None,
"trinket": None,
"weapon": None,
"weaponLeft": None,
"weaponRight": None,
"shield": None
}
self.models = [] #A list that will store our models objects
items = [("models/sword1", (0.0, 0.6, 1.5), (0, -90, 0), 0.2),
("models/maze", (0.0, 0.6, -1.5), (0, 90, 0), 0.2)]
"""
for row in items:
np = self.game.loader.loadModel(row[0]) #Load the model
np.setPos(row[1][0], row[1][1], row[1][2]) #Position it
np.setHpr(row[2][0], row[2][1], row[2][2]) #Rotate it
np.setScale(row[3]) #Scale it
np.reparentTo(self.playerHand)
#weaponNP.reparentTo(self.playerHand)
self.models.append(np) #Add it to our models list
"""
self.item = 0
self.isMovingForward = False
self.isMovingBackward = False
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingForwardLeft = False
self.isMovingForwardRight = False
self.isMovingSideRightUp = False
self.isMovingSideRightDown = False
self.isMovingSideLeftUp = False
self.isMovingSideLeftDown = False
self.isMovingBackwardLeft = False
self.isMovingBackwardRight = False
self.isAttacking = False
self.setupControls()
self.setupCamera()
self.playerActor.loop("standby", "head")
self.game.taskMgr.add(self.checkEquip,
"checkTorsoTask",
extraArgs=["torso", "armour"],
appendTask=True)
self.game.taskMgr.add(self.checkEquip,
"checkHeadTask",
extraArgs=["head", "helmet"],
appendTask=True)
def update(self, task):
self.playerActor.setShaderInput("timer", task.time)
return task.cont
def checkEquip(self, partName, equipPart, task):
# Check Equiped Parts
if self.previousPart[partName] != self.equip[equipPart]:
if self.equip[equipPart] != None and self.previousPart[
partName] == None:
self.playerActor.hidePart(partName)
self.playerActor.showPart(
"%s-%s" % (partName, self.equip[equipPart]["model"]))
self.previousPart[partName] = self.equip[equipPart]
elif self.equip[equipPart] != None and self.previousPart[
partName] != None:
self.playerActor.hidePart(
"%s-%s" % (partName, self.previousPart[partName]["model"]))
self.playerActor.showPart(
"%s-%s" % (partName, self.equip[equipPart]["model"]))
self.previousPart[partName] = self.equip[equipPart]
elif self.equip[equipPart] == None:
self.playerActor.hidePart(
"%s-%s" % (partName, self.previousPart[partName]["model"]))
self.playerActor.showPart(partName)
self.previousPart[partName] = None
return task.cont
def setupCamera(self):
self.game.disableMouse()
self.game.camera.setPos(self.playerActor.getPos() + 50)
self.lens = OrthographicLens()
self.lens.setFilmSize(
45 + self.zoomLevel,
35 + self.zoomLevel) # Or whatever is appropriate for your scene
self.game.cam.node().setLens(self.lens)
self.game.camLens.setFov(120)
def setupControls(self):
self.game.accept("a", self.setKey, ["left", 1])
self.game.accept("shift-a", self.setKey, ["left", 1])
self.game.accept("d", self.setKey, ["right", 1])
self.game.accept("shift-d", self.setKey, ["right", 1])
self.game.accept("w", self.setKey, ["forward", 1])
self.game.accept("shift-w", self.setKey, ["forward", 1])
self.game.accept("s", self.setKey, ["backward", 1])
self.game.accept("shift-s", self.setKey, ["backward", 1])
self.game.accept("a-up", self.setKey, ["left", 0])
self.game.accept("d-up", self.setKey, ["right", 0])
self.game.accept("w-up", self.setKey, ["forward", 0])
self.game.accept("s-up", self.setKey, ["backward", 0])
self.game.accept("mouse1", self.setKey, ["attack", 1])
self.game.accept("mouse1-up", self.setKey, ["attack", 0])
self.game.accept("shift-mouse1", self.setKey, ["attack", 1])
self.game.accept("shift-mouse1-up", self.setKey, ["attack", 0])
#self.game.accept("q", self.setKey, ["cam-left",1])
#self.game.accept("e", self.setKey, ["cam-right",1])
#self.game.accept("q-up", self.setKey, ["cam-left",0])
#self.game.accept("e-up", self.setKey, ["cam-right",0])
self.game.accept("space", self.setKey, ["jump", 1])
self.game.accept("space-up", self.setKey, ["jump", 0])
self.game.accept("shift", self.setKey, ["run", 1])
self.game.accept("shift-up", self.setKey, ["run", 0])
self.game.accept("wheel_up", self.moveCam, [1])
self.game.accept("wheel_down", self.moveCam, [0])
self.game.accept("shift-wheel_up", self.moveCam, [1])
self.game.accept("shift-wheel_down", self.moveCam, [0])
self.game.accept("t", self.toggleObject)
def moveCam(self, zoom):
if zoom == 0:
self.zoomLevel += 5
#if self.zoomLevel >= 30:
#self.zoomLevel = 30
elif zoom == 1:
self.zoomLevel -= 5
if self.zoomLevel <= 0:
self.zoomLevel = 0
#print self.zoomLevel
self.lens.setFilmSize(45 + self.zoomLevel, 35 + self.zoomLevel)
self.game.cam.node().setLens(self.lens)
#def checkAttack(self):
#animControl = self.playerActor.getAnimControl('slash', "body")
#return animControl.isPlaying()
def attack(self):
if self.isAttacking is False:
self.playerActor.play("slash-front")
self.isAttacking = True
self.isAttacking = False
def setKey(self, key, value):
self.keyMap[key] = value
def setObject(self, i):
for np in self.models:
np.hide()
self.models[i].show()
self.item = i
def toggleObject(self):
if self.item == 1:
self.item = 0
else:
self.item = 1
for np in self.models:
np.hide()
self.models[self.item].show()
def move(self, task):
#self.playerActor.setPos(self.moveFloater.getPos())
#self.playerActor.setZ(self.moveFloater.getZ())
dt = globalClock.getDt()
speed = 0
if (self.keyMap["left"]):
if (self.keyMap["run"]):
speed = self.runSpeed
#self.playerActor.setPlayRate(2.0, 'walk-side')
else:
speed = self.speed
#self.playerActor.setPlayRate(1.0, 'walk-side')
self.moveFloater.setX(self.moveFloater, speed * dt)
self.moveFloater.setY(self.moveFloater, -speed * dt)
if (self.keyMap["right"]):
if (self.keyMap["run"]):
speed = self.runSpeed
#self.playerActor.setPlayRate(2.0, 'walk-side')
else:
speed = self.lateralSpeed
#self.playerActor.setPlayRate(1.0, 'walk-side')
self.moveFloater.setX(self.moveFloater, -speed * dt)
self.moveFloater.setY(self.moveFloater, speed * dt)
if (self.keyMap["forward"]):
if (self.keyMap["run"]):
speed = self.runSpeed
#self.playerActor.setPlayRate(1.5, 'walk')
else:
speed = self.speed
#self.playerActor.setPlayRate(1.0, 'walk')
self.moveFloater.setY(self.moveFloater, -speed * dt)
self.moveFloater.setX(self.moveFloater, -speed * dt)
if (self.keyMap["backward"]):
if (self.keyMap["run"]):
speed = self.runSpeed
#self.playerActor.setPlayRate(2.0, 'walk-back')
else:
speed = self.speed
#self.playerActor.setPlayRate(1.0, 'walk-back')
self.moveFloater.setY(self.moveFloater, speed * dt)
self.moveFloater.setX(self.moveFloater, speed * dt)
if (self.keyMap["attack"]) and (task.time > self.nextAttack):
self.attack()
self.nextAttack = task.time + self.attackSpeed
self.keyMap["attack"] = 0
"""
if self.lastori != self.ori :
turn = Sequence(LerpQuatInterval(self.playerActor, duration=0.05, hpr=Vec3(self.ori, 0, 0), blendType='easeOut')).start()
self.lastori = self.ori
"""
self.playerActor.headsUp(self.game.lookPoint)
self.playerActor.setH(self.playerActor.getH() - 180)
#print(self.playerActor.getH())
# If player is moving, loop the run animation.
# If he is standing still, stop the animation.
if self.keyMap["forward"] and self.keyMap["right"]:
if ((self.playerActor.getH() < -45)
and (self.playerActor.getH() > -135)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk')
else:
self.playerActor.setPlayRate(1.0, 'walk')
if self.isMovingForward is False:
self.playerActor.stop()
self.playerActor.loop("walk")
self.isMovingForward = True
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -135)
and (self.playerActor.getH() > -225)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideRight is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = True
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -225)
and (self.playerActor.getH() > -315)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-back')
else:
self.playerActor.setPlayRate(1.0, 'walk-back')
if self.isMovingBackward is False:
self.playerActor.stop()
self.playerActor.loop("walk-back")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = True
elif (((self.playerActor.getH() < -315) and
(self.playerActor.getH() < 0))
or ((self.playerActor.getH() < 0) and
(self.playerActor.getH() > -45))):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideLeft is False:
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = True
self.isMovingBackward = False
elif self.keyMap["right"] and self.keyMap["backward"]:
if ((self.playerActor.getH() < -135)
and (self.playerActor.getH() > -225)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk')
else:
self.playerActor.setPlayRate(1.0, 'walk')
if self.isMovingForward is False:
self.playerActor.stop()
self.playerActor.loop("walk")
self.isMovingForward = True
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -225)
and (self.playerActor.getH() > -315)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideRight is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = True
self.isMovingSideLeft = False
self.isMovingBackward = False
elif (((self.playerActor.getH() < -315) and
(self.playerActor.getH() < 0))
or ((self.playerActor.getH() < 0) and
(self.playerActor.getH() > -45))):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-back')
else:
self.playerActor.setPlayRate(1.0, 'walk-back')
if self.isMovingBackward is False:
self.playerActor.stop()
self.playerActor.loop("walk-back")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = True
elif ((self.playerActor.getH() < -45)
and (self.playerActor.getH() > -135)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideLeft is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = True
self.isMovingBackward = False
elif self.keyMap["backward"] and self.keyMap["left"]:
if ((self.playerActor.getH() < -225)
and (self.playerActor.getH() > -315)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk')
else:
self.playerActor.setPlayRate(1.0, 'walk')
if self.isMovingForward is False:
self.playerActor.stop()
self.playerActor.loop("walk")
self.isMovingForward = True
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = False
elif (((self.playerActor.getH() < -315) and
(self.playerActor.getH() < 0))
or ((self.playerActor.getH() < 0) and
(self.playerActor.getH() > -45))):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideRight is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = True
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -45)
and (self.playerActor.getH() > -135)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-back')
else:
self.playerActor.setPlayRate(1.0, 'walk-back')
if self.isMovingBackward is False:
self.playerActor.stop()
self.playerActor.loop("walk-back")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = True
elif ((self.playerActor.getH() < -135)
and (self.playerActor.getH() > -225)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideLeft is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = True
self.isMovingBackward = False
elif self.keyMap["left"] and self.keyMap["forward"]:
if (((self.playerActor.getH() < -315) and
(self.playerActor.getH() < 0))
or ((self.playerActor.getH() < 0) and
(self.playerActor.getH() > -45))):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk')
else:
self.playerActor.setPlayRate(1.0, 'walk')
if self.isMovingForward is False:
self.playerActor.stop()
self.playerActor.loop("walk")
self.isMovingForward = True
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -45)
and (self.playerActor.getH() > -135)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideRight is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = True
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -135)
and (self.playerActor.getH() > -225)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-back')
else:
self.playerActor.setPlayRate(1.0, 'walk-back')
if self.isMovingBackward is False:
self.playerActor.stop()
self.playerActor.loop("walk-back")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = True
elif ((self.playerActor.getH() < -225)
and (self.playerActor.getH() > -315)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideLeft is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = True
self.isMovingBackward = False
elif self.keyMap["forward"]:
if ((self.playerActor.getH() < 0)
and (self.playerActor.getH() > -90)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk')
else:
self.playerActor.setPlayRate(1.0, 'walk')
if self.isMovingForward is False:
self.playerActor.stop()
self.playerActor.loop("walk")
self.isMovingForward = True
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -90)
and (self.playerActor.getH() > -180)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideRight is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = True
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -180)
and (self.playerActor.getH() > -270)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-back')
else:
self.playerActor.setPlayRate(1.0, 'walk-back')
if self.isMovingBackward is False:
self.playerActor.stop()
self.playerActor.loop("walk-back")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = True
elif ((self.playerActor.getH() < -270)
and (self.playerActor.getH() < 0)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideLeft is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = True
self.isMovingBackward = False
elif self.keyMap["backward"]:
if ((self.playerActor.getH() < 0)
and (self.playerActor.getH() > -90)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-back')
else:
self.playerActor.setPlayRate(1.0, 'walk-back')
if self.isMovingBackward is False:
self.playerActor.stop()
self.playerActor.loop("walk-back")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = True
elif ((self.playerActor.getH() < -90)
and (self.playerActor.getH() > -180)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideRight is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = True
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -180)
and (self.playerActor.getH() > -270)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk')
else:
self.playerActor.setPlayRate(1.0, 'walk')
if self.isMovingForward is False:
self.playerActor.stop()
self.playerActor.loop("walk")
self.isMovingForward = True
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -270)
and (self.playerActor.getH() < 0)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideLeft is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = True
self.isMovingBackward = False
elif self.keyMap["left"]:
if ((self.playerActor.getH() < 0)
and (self.playerActor.getH() > -90)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideRight is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = True
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -90)
and (self.playerActor.getH() > -180)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-back')
else:
self.playerActor.setPlayRate(1.0, 'walk-back')
if self.isMovingBackward is False:
self.playerActor.stop()
self.playerActor.loop("walk-back")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = True
elif ((self.playerActor.getH() < -180)
and (self.playerActor.getH() > -270)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideLeft is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = True
self.isMovingBackward = False
elif ((self.playerActor.getH() < -270)
and (self.playerActor.getH() < 0)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk')
else:
self.playerActor.setPlayRate(1.0, 'walk')
if self.isMovingForward is False:
self.playerActor.stop()
self.playerActor.loop("walk")
self.isMovingForward = True
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = False
elif self.keyMap["right"]:
if ((self.playerActor.getH() < 0)
and (self.playerActor.getH() > -90)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideLeft is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = True
self.isMovingBackward = False
elif ((self.playerActor.getH() < -90)
and (self.playerActor.getH() > -180)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk')
else:
self.playerActor.setPlayRate(1.0, 'walk')
if self.isMovingForward is False:
self.playerActor.stop()
self.playerActor.loop("walk")
self.isMovingForward = True
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -180)
and (self.playerActor.getH() > -270)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-side')
else:
self.playerActor.setPlayRate(1.0, 'walk-side')
if self.isMovingSideRight is False:
self.playerActor.stop()
self.playerActor.loop("walk-side")
self.isMovingForward = False
self.isMovingSideRight = True
self.isMovingSideLeft = False
self.isMovingBackward = False
elif ((self.playerActor.getH() < -270)
and (self.playerActor.getH() < 0)):
if (self.keyMap["run"]):
self.playerActor.setPlayRate(2.0, 'walk-back')
else:
self.playerActor.setPlayRate(1.0, 'walk-back')
if self.isMovingBackward is False:
self.playerActor.stop()
self.playerActor.loop("walk-back")
self.isMovingForward = False
self.isMovingSideRight = False
self.isMovingSideLeft = False
self.isMovingBackward = True
else:
if self.isMovingForward or self.isMovingBackward or self.isMovingSideLeft or self.isMovingSideRight:
self.playerActor.stop()
self.playerActor.loop("standby")
self.isMovingForward = False
self.isMovingBackward = False
self.isMovingSideLeft = False
self.isMovingSideRight = False
return task.cont
def updateCamera(self, task):
self.floater.setPos(self.moveFloater.getPos())
self.floater.setZ(self.moveFloater.getZ() + 2.0)
self.game.camera.setPos(self.floater.getPos() + 50)
# The camera should look in player's direction,
# but it should also try to stay horizontal, so look at
# a floater which hovers above player's head.
self.game.camera.lookAt(self.floater)
return task.cont
class Game(ShowBase):
def __init__(self):
ShowBase.__init__(self)
#Background sound (does not play infinitely)
self.backgroundSound = base.loader.loadSfx("sounds/DireDireDocks.mp3")
taskMgr.add(self.update, "moveTask")
#Disable the mouse so that we may use it for our control scheme.
self.props = WindowProperties()
self.props.setSize(1920, 1080)
self.props.setFullscreen(True)
self.props.setCursorHidden(True)
base.win.requestProperties(self.props)
base.disableMouse()
self.buildKeyMap()
self.inMenu = True
self.menuScreen = OnscreenImage("titlescreen.png", (0, .01, 0))
self.menu()
def initialize(self):
self.timer = 0
base.enableParticles()
#base.setFrameRateMeter(True)
##########
#
# SETUP COLLISION HANDLERS AND FLAMIE'S MODEL
#
##########
#Create the collision handlers in order to build the level.
WALL_MASK = BitMask32.bit(2)
FLOOR_MASK = BitMask32.bit(1)
#Start up the collision system
self.cTrav = CollisionTraverser()
#Determine how collisions with walls will be handled
self.wallHandler = CollisionHandlerPusher()
self.bobbing = False
#Setup flamie's model
self.flamieNP = base.render.attachNewNode(ActorNode('flamieNP'))
self.flamieNP.reparentTo(base.render)
self.flamie = loader.loadModel('models/Flame/body')
self.flamie.setScale(.5)
self.flamie.setTransparency(TransparencyAttrib.MAlpha)
self.flamie.setAlphaScale(0)
self.flamie.reparentTo(self.flamieNP)
self.flamie.setCollideMask(BitMask32.allOff())
flameLight = DirectionalLight("flameLight")
fl = self.flamie.attachNewNode(flameLight)
fl.setColor(255, 255, 255, 1)
flameLight.setDirection((-5, -5, -5))
self.flamie.setLight(fl)
self.flamie2 = loader.loadModel("models/p.obj")
self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f7.png"))
self.flamie2.reparentTo(self.flamieNP)
self.flamie2.setScale(4)
self.flamie2OriZ = 2
self.flamie2.setPos(-6.5, 0, self.flamie2OriZ) #(length, depth, height)
self.flamie2.setLight(fl)
self.flamie2.setTransparency(TransparencyAttrib.MAlpha)
self.flamieFire = PointLight('fire')
self.flamieFire.setColor(VBase4(1,1,1,1))
self.flamieFire.setAttenuation((1,0,1))
plnp = render.attachNewNode(self.flamieFire)
plnp.setPos(self.flamieNP.getPos())
self.flamielight = AmbientLight('light')
self.flamielight.setColor(VBase4(1, 0.5, 0.6, 1))
self.flamielight = self.flamie2.attachNewNode(self.flamielight)
self.flamie2.setLight(self.flamielight)
self.flamie2.setLight(plnp)
self.mayFlamieBob = True
#self.flamie2.setAlphaScale(0.5)
'''self.tree = loader.loadModel("models/p2.obj")
self.tree.setTexture(loader.loadTexture("deadTree.png"))
self.tree.reparentTo(render)
self.tree.setScale(4)
self.tree.setPos(25,25,0) #(length, depth, height)
self.tree.setLight(fl)
self.tree.setTransparency(TransparencyAttrib.MAlpha)
self.treelight = AmbientLight('light')
self.treelight.setColor(VBase4(0.9, 0.9, 0.6, 1))
self.treelight = self.tree.attachNewNode(self.treelight)
self.tree.setLight(self.treelight)'''
x = 150
y = 20
offset1 = 0
treeList2 = [loader.loadModel("models/p2.obj") for i in range(7)]
for j in treeList2:
k = random.randint(1, 100)
if k%5 is 1 or k%5 is 2:
j.setTexture(loader.loadTexture("deadTree.png"))
else:
j.setTexture(loader.loadTexture("tree.png"))
j.reparentTo(render)
j.setScale(random.randint(4,7))
j.setTransparency(TransparencyAttrib.MAlpha)
j.setPos(x + 3*offset1, y + 4*offset1, 0)
treelight = AmbientLight('light')
treelight = j.attachNewNode(treelight)
j.setLight(treelight)
offset1 = offset1 + random.randint(4, 10)
x = 4
y = 90
offset1 = 0
treeList2 = [loader.loadModel("models/p2.obj") for i in range(6)]
for j in treeList2:
k = random.randint(1, 100)
if k%5 is 1 or k%5 is 2:
j.setTexture(loader.loadTexture("deadTree.png"))
else:
j.setTexture(loader.loadTexture("tree.png"))
j.reparentTo(render)
j.setScale(random.randint(4,7))
j.setTransparency(TransparencyAttrib.MAlpha)
j.setPos(x + 3*offset1, y + 4*offset1, 0)
treelight = AmbientLight('light')
treelight = j.attachNewNode(treelight)
j.setLight(treelight)
offset1 = offset1 + random.randint(4, 10)
x = 3
y = 120
offset1 = 0
treeList2 = [loader.loadModel("models/p2.obj") for i in range(4)]
for j in treeList2:
k = random.randint(1, 100)
if k%5 is 1 or k%5 is 2:
j.setTexture(loader.loadTexture("deadTree.png"))
else:
j.setTexture(loader.loadTexture("tree.png"))
j.reparentTo(render)
j.setScale(random.randint(4,7))
j.setTransparency(TransparencyAttrib.MAlpha)
j.setPos(x + 3*offset1, y + 4*offset1, 0)
treelight = AmbientLight('light')
treelight = j.attachNewNode(treelight)
j.setLight(treelight)
offset1 = offset1 + random.randint(4, 10)
x = 200
y = 20
offset1 = 0
treeList2 = [loader.loadModel("models/p2.obj") for i in range(4)]
for j in treeList2:
k = random.randint(1, 100)
if k%5 is 1 or k%5 is 2:
j.setTexture(loader.loadTexture("deadTree.png"))
else:
j.setTexture(loader.loadTexture("tree.png"))
j.reparentTo(render)
j.setScale(random.randint(4,7))
j.setTransparency(TransparencyAttrib.MAlpha)
j.setPos(x + 3*offset1, y + 4*offset1, 0)
treelight = AmbientLight('light')
treelight = j.attachNewNode(treelight)
j.setLight(treelight)
offset1 = offset1 + random.randint(4, 10)
### Something that should look like water ###
w = loader.loadModel("models/flatP.obj")
w.setTexture(loader.loadTexture("ice.png"))
w.reparentTo(render)
w.setScale(75)
w.setTransparency(TransparencyAttrib.MAlpha)
w.setAlphaScale(.7)
w.setLight(treelight)
w.setPos(-200, 0, -10)
self.waterOrigiZ = -10
self.waterSecZ = -95
self.waterThirdZ = -120
self.water = w
### Reskying the sky ###
w = loader.loadModel("models/biggerFlatP.obj")
w.setTexture(loader.loadTexture("models/n2.jpg"))
w.reparentTo(self.flamie2)
w.setScale(15)
w.setLight(treelight)
w.setPos(-200, 450, -200) #(length, depth, height)
#Give flamie gravity
self.floorHandler = CollisionHandlerGravity()
self.floorHandler.setGravity(9.81+100)
self.floorHandler.setMaxVelocity(100)
##########
#
# GENERATING LEVEL PARTS
#
##########
self.ice_reset = ()
self.start = PlatformSeg(LVector3(0,0,0))
self.start.generateAllParts(render)
self.checkpointCreator(70, 90, self.start.pos.z, 10)
self.floater = False
for p in self.start.parts:
if isinstance(p, Prism):
self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, p.dep, 'terraincollision', 'wallcollision')
if isinstance(p, Square):
self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, 3, 'terraincollision', 'wallcollision')
if isinstance(p, IceCube):
p.model.setCollideMask(BitMask32.allOff())
self.ice_reset += (p,)
iceCubefloor= p.model.find("**/iceFloor")
iceCubewall = p.model.find("**/iceWall")
iceCubefloor.node().setIntoCollideMask(FLOOR_MASK)
iceCubewall.node().setIntoCollideMask(WALL_MASK)
self.lostWood = LostWood(LVector3(self.start.pos.x + 750, self.start.parts[0].pos.y + self.start.parts[0].wid, self.start.pos.z))
self.lostWood.generateAllParts(render)
self.checkpointCreator(self.lostWood.pos.x+120, self.lostWood.pos.y+150, self.lostWood.pos.z,20)
self.checkpointCreator(self.lostWood.parts[6].pos.x + self.lostWood.parts[6].len/2, self.lostWood.parts[6].pos.y + self.lostWood.parts[6].wid/2, self.lostWood.pos.z, 40)
for p in self.lostWood.parts:
if isinstance(p, Prism):
self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, p.dep, 'terraincollision', 'wallcollision')
if isinstance(p, Square):
self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, 3, 'terraincollision', 'wallcollision')
if isinstance(p, IceCube):
p.model.setCollideMask(BitMask32.allOff())
self.ice_reset += (p,)
iceCubefloor= p.model.find("**/iceFloor")
iceCubewall = p.model.find("**/iceWall")
iceCubefloor.node().setIntoCollideMask(FLOOR_MASK)
iceCubewall.node().setIntoCollideMask(WALL_MASK)
self.cave = Cave(LVector3(self.lostWood.pos.x + 1100, self.lostWood.pos.y + 2000, self.lostWood.pos.z - 50))
self.cave.generateAllParts(render)
self.checkpointCreator(self.cave.thirdRoomParts[5].pos.x + self.cave.thirdRoomParts[5].len/2,
self.cave.thirdRoomParts[5].pos.y + self.cave.thirdRoomParts[5].wid/2,
self.cave.thirdRoomParts[5].pos.z, 30)
for p in self.cave.parts:
if isinstance(p, Prism):
self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, p.dep, 'terraincollision', 'wallcollision')
if isinstance(p, Square):
self.collisionBoxCreator(p.pos.x, p.pos.y, p.pos.z, p.len, p.wid, 3, 'terraincollision', 'wallcollision')
if isinstance(p, IceCube):
p.model.setCollideMask(BitMask32.allOff())
self.ice_reset += (p,)
iceCubefloor= p.model.find("**/iceFloor")
iceCubewall = p.model.find("**/iceWall")
iceCubefloor.node().setIntoCollideMask(FLOOR_MASK)
iceCubewall.node().setIntoCollideMask(WALL_MASK)
self.end = End(LVector3(self.cave.thirdRoomParts[8].pos.x - 200,
self.cave.thirdRoomParts[8].pos.y + self.cave.thirdRoomParts[8].wid,
self.cave.thirdRoomParts[8].pos.z))
self.end.generate(render)
self.collisionBoxCreator(self.end.floor.pos.x, self.end.floor.pos.y, self.end.floor.pos.z,
self.end.floor.len, self.end.floor.wid, self.end.floor.dep,
'terraincollision', 'wallcollision')
#########
# DRAWING THE CABIN AND FINAL CAMPFIRE
#########
self.checkpointCreator(self.end.floor.pos.x + self.end.floor.len/2,
self.end.floor.pos.y + self.end.floor.wid/2,
self.end.floor.pos.z, 30)
self.cabin = loader.loadModel("models/p2.obj")
self.cabin.setTexture(loader.loadTexture("models/cabin.png"))
self.cabin.setScale(50)
self.cabin.reparentTo(render)
self.cabin.setPos(self.end.floor.pos.x + self.end.floor.len/2,
self.end.floor.pos.y + self.end.floor.wid/1.1,
self.end.floor.pos.z)
self.cabin.setTransparency(TransparencyAttrib.MAlpha)
#Manually creating starting position. Copy and paste the first three parameters of the checkpoint you want to start at.
self.startPos = LVector3(70, 90, self.start.pos.z)
self.flamieNP.setPos(self.startPos)
'''#Testing the tree model
self.tree = loader.loadModel('models/Tree/log')
self.tree.reparentTo(render)
self.tree.setPos(-50,0,100)
self.tree.setScale(2)'''
'''#Add sky background
self.sky = loader.loadModel('models/sphere.obj')
self.sky.reparentTo(self.camera)
self.sky.set_two_sided(True)
self.skyTexture = loader.loadTexture("models/n2.jpg")
self.sky.setTexture(self.skyTexture)
self.sky.set_bin('background', 0)
self.sky.set_depth_write(False)
self.sky.set_compass()'''
##########
#
# CREATE FLAMIE'S COLLISION GEOMETRY
#
##########
#Give flamie a collision sphere in order to collide with walls
flamieCollider = self.flamie.attachNewNode(CollisionNode('flamiecnode'))
flamieCollider.node().addSolid(CollisionSphere(0,0,0,5))
flamieCollider.node().setFromCollideMask(WALL_MASK)
flamieCollider.node().setIntoCollideMask(BitMask32.allOff())
self.wallHandler.addCollider(flamieCollider, self.flamieNP)
self.cTrav.addCollider(flamieCollider, self.wallHandler)
#Give flamie a collision ray to collide with the floor
flamieRay = self.flamie.attachNewNode(CollisionNode('flamieRay'))
flamieRay.node().addSolid(CollisionRay(0,0,8,0,0,-1))
flamieRay.node().setFromCollideMask(FLOOR_MASK)
flamieRay.node().setIntoCollideMask(BitMask32.allOff())
self.floorHandler.addCollider(flamieRay, self.flamieNP)
self.cTrav.addCollider(flamieRay, self.floorHandler)
#Add a sensor that lets us melt ice cubes without standing on the cube.
meltSensor = self.flamie.attachNewNode(CollisionNode('meltSensor'))
cs = CollisionSphere(-2,0,10, 50)
meltSensor.node().addSolid(cs)
meltSensor.node().setFromCollideMask(WALL_MASK)
meltSensor.node().setIntoCollideMask(BitMask32.allOff())
cs.setTangible(0)
self.wallHandler.addCollider(meltSensor, self.flamieNP)
self.cTrav.addCollider(meltSensor, self.wallHandler)
self.wallHandler.addInPattern('%fn-into-%in')
self.wallHandler.addAgainPattern('%fn-again-%in')
self.accept('meltSensor-into-iceWall', self.melt)
self.accept('meltSensor-again-iceWall', self.melt)
self.accept('meltSensor-into-checkpointCol', self.newstart)
#Add in an event handle to prevent the jumping glitch found on the bobbing ice cubes.
self.floorHandler.addInPattern('%fn-into-%in')
self.floorHandler.addAgainPattern('%fn-again-%in')
self.floorHandler.addOutPattern('%fn-out-%in')
self.accept('flamieRay-into-iceFloor', self.jittercancel)
self.accept('flamieRay-again-iceFloor', self.jittercancel)
self.accept('flamieRay-out-iceFloor', self.jittercanceloff)
#Uncomment these lines to see flamie's collision geometry
#flamieCollider.show()
#flamieRay.show()
#meltSensor.show()
#Uncomment this line to see the actual collisions.
#self.cTrav.showCollisions(render)
#This plane is found at the very bottom of the level and adds global gravity.
killfloor = CollisionPlane(Plane(Vec3(0,0,1), Point3(0,0,-1000)))
killfloorCol = CollisionNode('kfcollision')
killfloorCol.addSolid(killfloor)
killfloorCol.setIntoCollideMask(BitMask32.bit(1))
killfloorColNp = self.render.attachNewNode(killfloorCol)
####################
#
# Setting light so that we could see the definition in the walls
#
####################
render.setShaderAuto()
self.dlight = DirectionalLight('dlight')
self.dlight.setColor(LVector4(0.3, 0.1, 0.7, 1))
dlnp = render.attachNewNode(self.dlight)
dlnp.setHpr(90, 20, 0)
render.setLight(dlnp)
self.alight = render.attachNewNode(AmbientLight("Ambient"))
self.alight.node().setColor(LVector4(0.5, 0.5, 1, .1))
render.setLight(self.alight)
self.snow = loader.loadTexture("models/ground.jpg")
#Create a floater object and have it float 2 units above fireball.
#And use this as a target for the camera to focus on.
#This idea is taken from the roaming ralph sample that came with the
#Panda3D SDK.
self.camFocus = NodePath(PandaNode("floater"))
self.camFocus.reparentTo(render)
self.camFocusCurrZ = self.flamie.getZ() + 10
#The camera is locked to the avatar so it always follows regardless of movement.
self.camera.reparentTo(render)
self.cameraTargetHeight = 8.0
self.cameraDistance = 100
self.cameraHeightModes = (self.start.parts[0].pos.z + 45, self.start.parts[0].pos.z + 125, self.camFocus.getZ() + 10, self.camFocus.getZ() + 150,
self.end.floor.pos.z + 10)
self.cameraHeight = self.cameraHeightModes[0]
#################
# Changes Camera orientation depending on where the player is in the stage to compensate for the fact that
# the player has no direct control of the camera.
# Checks using the arrays from the level parts.
##################
def cameraModes(self, delta):
#Is the fireball within the platforming section between the starting area and the lost woods?
#Is the fireball near the simple platforming sections of the LostWoods?
#Is the fireball near the drop off point into the cave?
#Is the fireball near the entrance to the second room in the cave?
#If yes to any of these, bring the camera up to give a bird's eye view of the platforming
if ((self.flamieNP.getX() > self.start.parts[1].pos.x and self.flamieNP.getY() > self.start.parts[1].pos.y - self.start.parts[1].wid
and self.flamieNP.getX() < self.lostWood.parts[0].pos.x)
or (self.flamieNP.getX() > self.lostWood.parts[0].pos.x + self.lostWood.parts[0].len/1.1
and self.flamieNP.getX() < self.lostWood.parts[2].pos.x + self.lostWood.parts[0].len/11
and self.flamieNP.getY() < self.lostWood.parts[0].pos.y + self.lostWood.parts[0].wid)
or (self.flamieNP.getY() > self.cave.parts[0].pos.y - 20 and self.flamieNP.getY() <= self.cave.parts[0].pos.y + self.cave.parts[0].wid/2)
or (self.flamieNP.getX() < self.cave.parts[1].pos.x + self.cave.parts[1].wid/10 and self.flamieNP.getY() >= self.cave.parts[1].pos.x)):
camMode = 1
#Is the fireball in the beginning of the cave area?
#If yes, bring the camera closer
elif self.flamieNP.getY() > self.cave.parts[1].pos.y - self.cave.parts[0].wid/2 and self.flamieNP.getY() < self.cave.thirdRoomParts[5].pos.y:
camMode = 2
else:
camMode = 0
if self.flamieNP.getY() >= self.cave.thirdRoomParts[6].pos.y:
self.cave.thirdRoomParts[0].hide()
camMode = 3
if self.flamieNP.getY() >= self.cave.thirdRoomParts[8].pos.y + self.cave.thirdRoomParts[8].wid/1.5:
camMode = 4
self.lerpCam(camMode, delta)
def lerpCam(self, camMode, delta):
CAMLERPSPEED = 25
if camMode == 0:
if not self.cameraHeight == self.cameraHeightModes[camMode]:
if self.cameraHeight - CAMLERPSPEED * delta <= self.cameraHeightModes[camMode]:
self.cameraHeight = self.cameraHeightModes[camMode]
else:
self.cameraHeight = self.cameraHeight - CAMLERPSPEED * delta
elif camMode == 1:
if not self.cameraHeight == self.cameraHeightModes[camMode]:
if self.cameraHeight - CAMLERPSPEED * delta >= self.cameraHeightModes[camMode]:
self.cameraHeight = self.cameraHeightModes[camMode]
else:
if self.cameraHeight < self.cameraHeightModes[camMode]:
self.cameraHeight = self.cameraHeight + CAMLERPSPEED * delta
else:
self.cameraHeight = self.cameraHeight - CAMLERPSPEED * delta
elif camMode == 2:
if not self.cameraHeight == self.cameraHeightModes[camMode]:
if self.cameraHeight - CAMLERPSPEED * delta <= self.cameraHeightModes[camMode]:
self.cameraHeight = self.cameraHeightModes[camMode]
self.camFocusCurrZ = self.flamieNP.getZ() + 10
else:
self.cameraHeight = self.cameraHeight - CAMLERPSPEED * delta
self.camFocusCurrZ = self.flamieNP.getZ() + 10
elif camMode == 3:
if not self.cameraHeight == self.cameraHeightModes[camMode]:
if self.cameraHeight + CAMLERPSPEED * 3 * delta >= self.cameraHeightModes[camMode]:
self.cameraHeight = self.cameraHeightModes[camMode]
else:
self.cameraHeight = self.cameraHeight + CAMLERPSPEED * 3 * delta
elif camMode == 4:
if not self.cameraHeight == self.cameraHeightModes[camMode]:
if self.cameraHeight - CAMLERPSPEED * 3 * delta <= self.cameraHeightModes[camMode]:
self.cameraHeight = self.cameraHeightModes[camMode]
else:
self.cameraHeight = self.cameraHeight - CAMLERPSPEED * 3 * delta
def waterControl(self, delta):
WATERLERPSPEED = .75
if self.flamieNP.getY() <= self.lostWood.parts[6].pos.y + self.lostWood.parts[6].wid/2:
if not self.water.getZ() == self.waterOrigiZ:
if self.water.getZ() - WATERLERPSPEED * delta < self.waterOrigiZ and self.water.getZ() > self.waterOrigiZ:
self.water.setZ(self.waterOrigiZ)
elif self.water.getZ() + WATERLERPSPEED * delta > self.waterOrigiZ and self.water.getZ() < self.waterOrigiZ:
self.water.setZ(self.waterOrigiZ)
else:
if self.water.getZ() > self.waterOrigiZ:
self.water.setZ(self.water, - WATERLERPSPEED * delta)
if self.water.getZ() < self.waterOrigiZ:
self.water.setZ(self.waterOrigiZ)
else:
self.water.setZ(self.water, + WATERLERPSPEED * delta)
if self.water.getZ() > self.waterOrigiZ:
self.water.setZ(self.waterOrigiZ)
elif self.flamieNP.getY() <= self.cave.parts[1].pos.y:
if not self.water.getZ() == self.waterSecZ:
if self.water.getZ() - WATERLERPSPEED * delta < self.waterSecZ:
self.water.setZ(self.waterSecZ)
else:
self.water.setZ(self.water, - WATERLERPSPEED * delta)
else:
if not self.water.getZ() == self.waterThirdZ:
if self.water.getZ() - WATERLERPSPEED * delta < self.waterThirdZ:
self.water.setZ(self.waterThirdZ)
else:
self.water.setZ(self.water, - WATERLERPSPEED * delta)
def reset(self):
self.flamieNP.setPos(self.startPos)
self.camFocusCurrZ = self.flamieNP.getZ() + 10
for p in self.ice_reset:
p.model.setScale(p.original_scale)
def jump(self, dt):
if self.bobbing:
if self.floorHandler.getAirborneHeight() < 0.15:
self.floorHandler.addVelocity(60)
elif self.floorHandler.isOnGround():
self.floorHandler.addVelocity(60)
def jittercancel(self, collEntry):
model = collEntry.getIntoNodePath().getParent()
modelRef = model.getPythonTag("iceRef")
if model.getScale()[0] > 1.2:
model.setScale(model.getScale()- modelRef.meltspeed)
self.bobbing = True
def jittercanceloff(self, collEntry):
self.bobbing = False
def melt(self, collEntry):
model = collEntry.getIntoNodePath().getParent()
modelRef = model.getPythonTag("iceRef")
if model.getScale()[0] > 1.2 and self.bobbing != True:
model.setScale(model.getScale()- modelRef.meltspeed)
def newstart(self, collEntry):
entry = collEntry.getInto().getCenter()
self.startPos = (entry[0]+10, entry[1]+10, entry[2] +10)
cp = loader.loadModel('models/Campfire/fire')
cp.setPos(entry[0],entry[1], entry[2])
cp.reparentTo(render)
def buildKeyMap(self):
self.keyMap = {"left": 0, "right": 0, "forward": 0, "back": 0, "down": 0, "up": 0, "lookUp": 0, "lookDown": 0, "lookLeft": 0, "lookRight": 0}
#I changed the control scheme let me know if you would like me to try something else.
#WASD for movement, space for jump
self.accept("escape", sys.exit)
self.accept("a", self.setKey, ["left", True])
self.accept("a-up", self.setKey, ["left", False])
self.accept("d", self.setKey, ["right", True])
self.accept("d-up", self.setKey, ["right", False])
self.accept("w", self.setKey, ["forward", True])
self.accept("w-up", self.setKey, ["forward", False])
self.accept("s", self.setKey, ["back", True])
self.accept("s-up", self.setKey, ["back", False])
self.accept("space", self.setKey, ["down", True])
self.accept("space-up", self.setKey, ["down", False])
self.accept("shift", self.setKey, ["up", True])
self.accept("shift-up", self.setKey, ["up", False])
def setKey(self, key, value):
self.keyMap[key] = value
def update(self, task):
delta = globalClock.getDt()
if not self.inMenu:
SPEED = 125
#Variable that holds what direction the player is inputting
fblr = 0
self.timer += delta * 25
self.killPlane = self.water.getZ() - 25
if self.flamieNP.getZ() < self.killPlane:
self.reset()
if self.keyMap["left"]:
fblr = 1
old_fblr = fblr
self.flamieNP.setX(self.flamie, - SPEED * delta)
if self.keyMap["right"]:
fblr = 2
old_fblr = fblr
self.flamieNP.setX(self.flamie, + SPEED * delta)
if self.keyMap["forward"]:
fblr = 3
old_fblr = fblr
self.flamieNP.setY(self.flamie, + SPEED * delta)
if self.keyMap["back"]:
fblr = 4
old_fblr = fblr
self.flamieNP.setY(self.flamie, - SPEED * delta)
if self.keyMap["up"]:
#self.flamieNP.setZ(self.flamie, - SPEED * dt)
self.reset()
#self.cameraDistance = 20+self.cameraDistance
if self.keyMap["down"] and self.timer > 1:
#self.flamieNP.setZ(self.flamie, + SPEED * dt)
self.timer = 0
self.jump(delta)
if fblr == 1:
self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f8.png"))
elif fblr == 2:
self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f6.png"))
elif fblr == 3:
if old_fblr == 1:
self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f1.png"))
elif old_fblr == 2:
self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f4.png"))
else:
self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f3.png"))
else:
self.flamie2.setTexture(loader.loadTexture("models/flamie2D/f7.png"))
if self.floorHandler.isOnGround:
self.flamieBob(delta)
#The camera control is borrowed from Kristina's Tech Demo
#This is also a demo found at: http://www.panda3d.org/forums/viewtopic.php?t=8452
'''# mouse-controlled camera begins
# Use mouse input to turn both the Character and the Camera
if base.mouseWatcherNode.hasMouse():
md = base.win.getPointer(0)
x = md.getX()
y = md.getY()
deltaX = md.getX() - 200
deltaY = md.getY() - 200
# reset mouse cursor position
base.win.movePointer(0, 200, 200)
# alter flamie's yaw by an amount proportionate to deltaX
self.flamie.setH(self.flamie.getH() - 0.3* deltaX)
# find the new camera pitch and clamp it to a reasonable range
self.cameraPitch = self.cameraPitch + 0.1 * deltaY
if (self.cameraPitch < -60): self.cameraPitch = -60
if (self.cameraPitch > 80): self.cameraPitch = 80
base.camera.setHpr(0,self.cameraPitch,0)
# set the camera at around ralph's middle
# We should pivot around here instead of the view target which is noticebly higher
base.camera.setPos(0,0,self.cameraTargetHeight/2)
# back the camera out to its proper distance
base.camera.setY(base.camera,self.cameraDistance)
# point the camera at the view target
viewTarget = Point3(0,0,self.cameraTargetHeight)
base.camera.lookAt(viewTarget)
# reposition the end of the camera's obstruction ray trace
#self.cameraRay.setPointB(base.camera.getPos())
# mouse-controlled camera ends'''
self.waterControl(delta)
self.water.setX(self.flamieNP.getX() - 250)
self.water.setY(self.flamieNP.getY() - 250)
self.cameraModes(delta)
base.camera.setPos(self.flamieNP.getX(), self.flamieNP.getY() - self.cameraDistance, self.cameraHeight)
self.camFocus.setPos(self.flamieNP.getX(), self.flamieNP.getY(), self.camFocusCurrZ)
base.camera.lookAt(self.camFocus)
'''
######################
#
# SIMPLE OCCLUSION FOR START AREA
#
######################
for p in self.start.parts:
if p.type == 'IceCube':
if math.fabs((math.sqrt((p.model.getX() * p.model.getX()) + (p.model.getY() * p.model.getY()))
- math.sqrt((self.camFocus.getX() * self.camFocus.getX()) + (self.camFocus.getY() * self.camFocus.getY())))) <= 400:
p.show()
#Ice cube movement
p.bob(delta)
else:
p.hide()
if p.type == 'Prism':
if p.type == 'Prism':
if math.fabs((math.sqrt((p.pos.x * p.pos.x) + (p.pos.y * p.pos.y))
- math.sqrt((self.camFocus.getX() * self.camFocus.getX()) + (self.camFocus.getY() * self.camFocus.getY())))) <= 1000:
p.show()
else:
p.hide()
######################
#
# SIMPLE OCCLUSION FOR CAVE PARTS
#
######################
for p in self.cave.parts:
if p.type == 'Prism':
if math.fabs((math.sqrt((p.pos.x * p.pos.x) + (p.pos.y * p.pos.y))
- math.sqrt((self.flamieNP.getX() * self.flamieNP.getX()) + (self.flamieNP.getY() * self.flamieNP.getY())))) <= 2500:
p.show()
else:
p.hide()
if p.type == 'IceCube':
if math.fabs((math.sqrt((p.model.getX() * p.model.getX()) + (p.model.getY() * p.model.getY()))
- math.sqrt((self.flamieNP.getX() * self.flamieNP.getX()) + (self.flamieNP.getY() * self.flamieNP.getY())))) <= 2000:
p.show()
#Ice cube movement
self.cave.moveIceCubes(delta/25)
for p in self.cave.iceCubesThirdRoom:
p.bob(delta/25)
for p in self.cave.iceCubesSecondRoom:
p.bob(delta/25)
self.cave.bigCube.bob(delta/25)
for p in self.start.iceCubes:
p.bob(delta)
else:
p.hide()
'''
#Ice cube movement
self.cave.moveIceCubes(delta)
for p in self.cave.iceCubesThirdRoom:
p.bob(delta)
for p in self.cave.iceCubesSecondRoom:
p.bob(delta)
self.cave.bigCube.bob(delta)
for p in self.start.iceCubes:
p.bob(delta)
elif self.inMenu:
self.menu()
if self.backgroundSound.status() is not self.backgroundSound.PLAYING:
self.backgroundSound.play()
return task.cont
def menu(self):
if self.keyMap["down"]:
self.inMenu = False
self.menuScreen.destroy()
self.initialize()
def flamieBob(self, delta):
if self.mayFlamieBob:
self.flamie2.setZ(self.flamie2.getZ() + .5*delta)
if self.flamie2.getZ() - self.flamie2OriZ > 1:
self.mayFlamieBob = False
else:
self.flamie2.setZ(self.flamie2.getZ() - .5*delta)
if self.flamie2.getZ() - self.flamie2OriZ < -2:
self.mayFlamieBob = True
#Function to create a box collision using six polygon. The top face is created as terrain and thus provides gravity.
#While the rest of the faces only act as wall pushers.
def collisionBoxCreator(self, posx, posy, posz, length, width, height, floorname, wallname):
ret = ()
#Create top face
terrain = CollisionPolygon(Point3(posx, posy+width, posz), Point3(posx, posy, posz),
Point3(posx+length, posy, posz), Point3(posx+length, posy+width, posz))
terrainCol = CollisionNode(floorname)
terrainCol.addSolid(terrain)
terrainCol.setIntoCollideMask(BitMask32.bit(1))
terrainColNp = self.render.attachNewNode(terrainCol)
self.cTrav.addCollider(terrainColNp, self.floorHandler)
ret += (terrainColNp,)
#Create left face
sideLeft = CollisionPolygon(Point3(posx, posy+width, posz-height), Point3(posx, posy, posz-height),
Point3(posx, posy, posz), Point3(posx, posy+width, posz))
sideLeftCol = CollisionNode(wallname)
sideLeftCol.addSolid(sideLeft)
sideLeftCol.setIntoCollideMask(BitMask32.bit(2))
sideLeftColNp = self.render.attachNewNode(sideLeftCol)
self.cTrav.addCollider(sideLeftColNp, self.wallHandler)
ret += (sideLeftColNp,)
#Create right face
sideRight = CollisionPolygon(Point3(posx+length, posy+width, posz), Point3(posx+length, posy, posz),
Point3(posx+length, posy, posz-height), Point3(posx+length, posy+width, posz-height))
sideRightCol = CollisionNode(wallname)
sideRightCol.addSolid(sideRight)
sideRightCol.setIntoCollideMask(BitMask32.bit(2))
sideRightColNp = self.render.attachNewNode(sideRightCol)
self.cTrav.addCollider(sideRightColNp, self.wallHandler)
ret += (sideRightColNp,)
#Create front face
sideFront = CollisionPolygon(Point3(posx, posy+width, posz-height), Point3(posx, posy+width, posz),
Point3(posx+length, posy+width, posz), Point3(posx+length, posy+width, posz-height))
sideFrontCol = CollisionNode(wallname)
sideFrontCol.addSolid(sideFront)
sideFrontCol.setIntoCollideMask(BitMask32.bit(2))
sideFrontColNp = self.render.attachNewNode(sideFrontCol)
self.cTrav.addCollider(sideFrontColNp, self.wallHandler)
ret += (sideFrontColNp,)
#Create back face
sideBack = CollisionPolygon(Point3(posx, posy, posz), Point3(posx, posy, posz-height),
Point3(posx+length, posy, posz-height), Point3(posx+length, posy, posz))
sideBackCol = CollisionNode(wallname)
sideBackCol.addSolid(sideBack)
sideBackCol.setIntoCollideMask(BitMask32.bit(2))
sideBackColNp = self.render.attachNewNode(sideBackCol)
self.cTrav.addCollider(sideBackColNp, self.wallHandler)
ret += (sideBackColNp,)
#Create bottom face
sideBot = CollisionPolygon(Point3(posx, posy, posz-height), Point3(posx, posy+width, posz-height),
Point3(posx+length, posy+width, posz-height), Point3(posx+length, posy, posz-height))
sideBotCol = CollisionNode(wallname)
sideBotCol.addSolid(sideBot)
sideBotCol.setIntoCollideMask(BitMask32.bit(2))
sideBotColNp = self.render.attachNewNode(sideBotCol)
self.cTrav.addCollider(sideBotColNp, self.wallHandler)
ret += (sideBotColNp,)
#Uncomment these lines to see the collision polygons.
'''terrainColNp.show()
sideLeftColNp.show()
sideRightColNp.show()
sideFrontColNp.show()
sideBackColNp.show()
sideBotColNp.show()'''
return ret
#Old way of creating box collisions (left here for reference)
'''box = CollisionBox((posx+(length/2), posy+(width/2),-(posz+height/2)), length/2, width/2, height/2)
boxCol = CollisionNode('testcollision')
boxCol.addSolid(box)
boxCol.setIntoCollideMask(BitMask32.bit(2))
boxColNp = self.render.attachNewNode(boxCol)
boxHandler = CollisionHandlerQueue()
self.cTrav.addCollider(boxColNp, self.wallHandler)
#Uncomment this line to see the collision solids.
#boxColNp.show()'''
def checkpointCreator(self, posx, posy, posz, radius):
cp = loader.loadModel('models/Campfire/logs')
cp.setPos(posx,posy, posz)
cp.reparentTo(render)
checkpoint = CollisionSphere(cp.getX(),cp.getY(),cp.getZ(),radius)
checkpoint.setTangible(0)
checkpointCol = CollisionNode('checkpointCol')
checkpointCol.addSolid(checkpoint)
checkpointCol.setIntoCollideMask(BitMask32.bit(2))
checkpointColNp = self.render.attachNewNode(checkpointCol)
self.cTrav.addCollider(checkpointColNp, self.wallHandler)
class Character(DirectObject, XMLExportable, PropertiesTableAbstract,
GameEntity):
def __init__(self, attributes, showCollisions, grid_currentx,
grid_currenty, grid_playable_pos, parent):
GameEntity.__init__(self, parent) #running parent constructor
self.movtask = 0
self.showCollisions = showCollisions
self.grid_currentx = grid_currentx
self.grid_currenty = grid_currenty
self.grid_playable_pos = grid_playable_pos
self.attributes = attributes
self.onPicked = ''
self.onWalked = ''
self.typeName = 'character'
self.properties = {
'url': '',
'onWalked': '',
'onPicked': '',
'id': '',
'inclination': '',
'scale': '',
'hitboxscale': '',
'speed': '',
'playable': '',
'direction': ''
}
if attributes.has_key('url'):
self.properties['url'] = attributes['url'].value
else:
print "WARNING: url not defined, loading placeholder"
self.properties['url'] = 'misc/placeholder'
if attributes.has_key('id'):
self.properties['id'] = attributes['id'].value
else:
self.properties['id'] = 'all'
if attributes.has_key('inclination'):
self.properties['inclination'] = float(
attributes['inclination'].value)
else:
self.properties['inclination'] = 30.0
if attributes.has_key('scale'):
self.properties['scale'] = float(attributes['scale'].value)
else:
self.properties['scale'] = 1.0
if attributes.has_key('hitboxscale'):
self.properties['hitboxscale'] = float(
attributes['hitboxscale'].value)
else:
self.properties['hitboxscale'] = 1.0
if attributes.has_key('speed'):
self.properties['speed'] = float(attributes['speed'].value)
else:
self.properties['speed'] = 1.0
#self.isNPC remains true while isPlayable is changable
if attributes.has_key('playable'):
self.playable = playable = attributes['playable'].value
if self.playable == 'false':
self.isNPC = False
#print "setting ", self.properties['id'], " to ", self.isNPC
else:
self.isNPC = True
#print "setting ", self.properties['id'], " to ", self.isNPC
else:
self.playable = playable = 'false'
self.isNPC = True
self.properties['playable'] = self.playable
if attributes.has_key('direction'):
self.properties['direction'] = attributes['direction'].value
else:
self.properties['direction'] = "down"
if attributes.has_key('onWalked'):
self.properties['onWalked'] = self.onWalked = attributes[
'onWalked'].value
else:
self.properties['onWalked'] = self.onWalked = ""
if attributes.has_key('onPicked'):
self.properties['onPicked'] = self.onPicked = attributes[
'onPicked'].value
self.generateNode(showCollisions)
def generateNode(self, showCollisions):
self.destroy()
#setting local variable
attributes = self.attributes
#defaulted to None
self.pickCTrav = None
#movement
self.state = "still"
self.showCollisions = showCollisions
self.movtask = 0
self.currentlydown = []
self.currentlyfollowed = 0
self.pickRequest = False
#public props
self.node = NodePath("characternode")
self.node.setTwoSided(True)
self.wtop = self.applyNearestFilter(
loader.loadModel(
resourceManager.getResource(self.properties['url']) +
'/wtop.egg'))
self.wdown = self.applyNearestFilter(
loader.loadModel(
resourceManager.getResource(self.properties['url']) +
'/wdown.egg'))
self.wleft = self.applyNearestFilter(
loader.loadModel(
resourceManager.getResource(self.properties['url']) +
'/wleft.egg'))
self.wright = self.applyNearestFilter(
loader.loadModel(
resourceManager.getResource(self.properties['url']) +
'/wright.egg'))
self.stop = self.applyNearestFilter(
loader.loadModel(
resourceManager.getResource(self.properties['url']) +
'/stop.egg'))
self.sdown = self.applyNearestFilter(
loader.loadModel(
resourceManager.getResource(self.properties['url']) +
'/sdown.egg'))
self.sleft = self.applyNearestFilter(
loader.loadModel(
resourceManager.getResource(self.properties['url']) +
'/sleft.egg'))
self.sright = self.applyNearestFilter(
loader.loadModel(
resourceManager.getResource(self.properties['url']) +
'/sright.egg'))
#Texture.FTNearest
self.wtop.reparentTo(self.node)
self.wdown.reparentTo(self.node)
self.wleft.reparentTo(self.node)
self.wright.reparentTo(self.node)
self.stop.reparentTo(self.node)
self.sdown.reparentTo(self.node)
self.sleft.reparentTo(self.node)
self.sright.reparentTo(self.node)
self.leftdown = False
self.rightdown = False
self.downdown = False
self.topdown = False
if self.playable == "true":
self.setPlayable(
False) #seems nonsense, triggered on grid.changeMap event
self.node.setTag(
"playable", "true"
) #setting this to make it recognizable from grid changeMap api
self.setCollisions(True)
self.setPickCollisions(True)
else:
self.setPlayable(False)
self.node.setTag("playable", "false")
self.setCollisions(False)
self.setPickCollisions(False)
#self.node.setX((-32/2)+0.5)
self.node.setP(-(360 - int(self.properties['inclination'])))
self.node.setScale(float(self.properties['scale']))
self.node.setTransparency(TransparencyAttrib.MAlpha)
self.lastpos = self.node.getPos()
self.showAllSubnodes()
#taskMgr.doMethodLater(4, self.face, 'charload'+self.properties['id'], [self.properties['direction']])
self.face(self.properties['direction'])
#set unique id
self.node.setTag("id", self.properties['id'])
#setting scripting part
self.node.setTag("onWalked", self.onWalked)
self.node.setTag("onPicked", self.onPicked)
#storing a pointer of the gamenode
self.node.setPythonTag("gamenode", self)
self.npc_walk_stack = []
self.npc_walk_happening = False
self.globalLock = False
self.setX(self.grid_currentx)
self.setY(self.grid_currenty)
if self.isNPC != True:
print "attempting creation of NPC in ", self.grid_currentx, "-", self.grid_currenty
if attributes.has_key('playable'):
if self.isNPC != False:
if ((self.grid_playable_pos.getX() != 0)
and (self.grid_playable_pos.getY() != 0)):
print 'GRID: moving player to ' + str(
self.grid_playable_pos)
self.setX(self.grid_playable_pos.getX())
self.setY(self.grid_playable_pos.getY())
#automatic reparenting (and showing) when (re)generating node
self.node.wrtReparentTo(self.parent.node)
def getName(self):
return 'Character: ' + self.properties['id']
def xmlAttributes(self):
return self.properties
def xmlTypeName(self):
return self.typeName
'''
Sanitize properties data to be of correct type from string
'''
def sanitizeProperties(self):
#sanitizing data
self.properties['inclination'] = float(self.properties['inclination'])
self.properties['hitboxscale'] = float(self.properties['hitboxscale'])
self.properties['speed'] = float(self.properties['speed'])
self.properties['scale'] = float(self.properties['scale'])
self.updateTilePosition()
#interface needed by PropertiesTable
# regenerates the node at every change
def onPropertiesUpdated(self):
self.sanitizeProperties()
self.generateNode(self.showCollisions)
#interface needed by PropertiesTable
#TODO: implement as real interface?
def getPropertyList(self):
return self.properties
#interface needed by PropertiesTable
def setProperty(self, key, value):
self.properties[key] = value
def setSpeed(self, s):
self.properties['speed'] = s
def applyNearestFilter(self, model):
for tex in model.findAllTextures():
tex.setMinfilter(Texture.FT_nearest)
tex.setMagfilter(Texture.FT_nearest)
return model
'''
make the npc walk in direction for units
'''
def npc_push_walk(self, direction, units):
#locking script execution
self.globalLock = True
script.addOneCustomLock(self)
#start the walking
self.npc_walk_stack.append([direction, units])
self.npc_walk_helper()
#apicall
def npc_walk_helper(self):
x = self.node.getX()
y = self.node.getZ()
#concurrent protection
if self.npc_walk_happening == True:
return
#returning if no movement has to be performed
if len(self.npc_walk_stack) < 0:
return
movement = self.npc_walk_stack.pop(0)
direction = movement[0]
units = movement[1]
self.npc_targetx = x
self.npc_targety = y
self.npc_direction = direction
if (direction == "down"):
self.npc_targety = self.npc_targety - units
elif (direction == "up"):
self.npc_targety = self.npc_targety + units
elif (direction == "left"):
self.npc_targetx = self.npc_targetx - units
elif (direction == "right"):
self.npc_targetx = self.npc_targetx + units
self.setAnim(direction)
self.npc_walk_happening = True
self.npc_movtask = taskMgr.add(self.npc_walk_task,
"npc_moveCharacterTask" +
self.properties['id'],
uponDeath=self.npc_walk_callback)
def npc_walk_task(self, task):
dt = globalClock.getDt()
if (self.npc_direction == 'left'):
self.node.setX(self.node.getX() -
1 * dt * self.properties['speed'])
currentx = self.node.getX()
if currentx <= self.npc_targetx:
return task.done
if (self.npc_direction == 'right'):
self.node.setX(self.node.getX() +
1 * dt * self.properties['speed'])
currentx = self.node.getX()
if currentx >= self.npc_targetx:
return task.done
if (self.npc_direction == 'up'):
self.node.setZ(self.node.getZ() +
1 * dt * self.properties['speed'])
currenty = self.node.getZ()
if currenty >= self.npc_targety:
return task.done
if (self.npc_direction == 'down'):
self.node.setZ(self.node.getZ() -
1 * dt * self.properties['speed'])
currenty = self.node.getZ()
if currenty <= self.npc_targety:
return task.done
return task.cont
def npc_walk_callback(self, task):
self.face(self.npc_direction)
#unlocking concurrent movement protection
self.npc_walk_happening = False
if len(self.npc_walk_stack) > 0:
self.npc_walk_helper()
else: #character ended walking, unlock
self.globalLock = False
'''
write destroyfunction
'''
def destroy(self):
#not accepting events
self.ignoreAll()
#destroying everything down
if self.node != None:
self.node.remove_node()
#removing all tasks
if self.movtask != 0:
taskMgr.remove(self.movtask)
self.movtask = 0
def face(self, direction):
if direction == "left":
self.hideAllSubnodes()
self.sleft.show()
if direction == "right":
self.hideAllSubnodes()
self.sright.show()
if direction == "top" or direction == "up": #let's keep retrocompatibility
self.hideAllSubnodes()
self.stop.show()
if direction == "down":
self.hideAllSubnodes()
self.sdown.show()
def setCollisions(self, value):
if value == True:
b = self.node.getBounds().getRadius()
self.cTrav = CollisionTraverser()
self.collisionTube = CollisionSphere(
b / 2, 0, b / 2, 0.035 * self.properties['hitboxscale'])
self.collisionNode = CollisionNode('characterTube')
self.collisionNode.addSolid(self.collisionTube)
self.collisionNodeNp = self.node.attachNewNode(self.collisionNode)
self.collisionHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.collisionNodeNp, self.collisionHandler)
if self.showCollisions == True or main.editormode:
# Uncomment this line to see the collision rays
self.collisionNodeNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
self.cTrav.showCollisions(render)
else:
b = self.node.getBounds().getRadius()
self.collisionTube = CollisionSphere(
b / 2, 0, b / 2, 0.035 * self.properties['hitboxscale'])
#allowing playables to collide with npcs
if self.isNPC == True: #TODO: fix because it's completely f****d up
self.collisionNode = CollisionNode('characterTube')
else:
self.collisionNode = CollisionNode('characterNPCTube')
self.collisionNode.addSolid(self.collisionTube)
self.collisionNodeNp = self.node.attachNewNode(self.collisionNode)
#set if camera has to effectively follow the character
#while it moves
def setFollowedByCamera(self, value):
#camera follow
if value:
if self.currentlyfollowed != True:
customCamera.follow(self)
self.currentlyfollowed = True
else:
if self.currentlyfollowed != False:
customCamera.dontFollow()
self.currentlyfollowed = False
def setPickCollisions(self, value):
if value:
print "setting pick collisions"
b = self.node.getBounds().getRadius()
self.pickCTrav = CollisionTraverser()
self.pickCollisionTube = CollisionSphere(
b / 2, 0, b / 2, 0.035 * self.properties['hitboxscale'] + 0.01)
self.pickCollisionNode = CollisionNode('characterPickTube')
self.pickCollisionNode.addSolid(self.pickCollisionTube)
self.pickCollisionNodeNp = NodePath(self.pickCollisionNode)
self.pickCollisionNodeNp.reparentTo(self.node)
self.pickCollisionHandler = CollisionHandlerQueue()
self.pickCTrav.addCollider(self.pickCollisionNodeNp,
self.pickCollisionHandler)
if self.showCollisions == True:
# Uncomment this line to see the collision rays
self.pickCollisionNodeNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
self.pickCTrav.showCollisions(render)
else:
#dereferincing all pick colliders (must be done in order not to collide onto NPCs)
self.pickCTrav = None
self.pickCollisionTube = None
self.pickCollisionNode = None
self.pickCollisionNodeNp = None
self.pickCollisionHandler = None
#used to set playability in real time
#useful when we want to switch context/scripted scenes
def setPlayable(self, value):
if self.isNPC != False:
if value == True:
#down events
self.accept("arrow_left", self.arrowLeftDown)
self.accept("arrow_right", self.arrowRightDown)
self.accept("arrow_up", self.arrowUpDown)
self.accept("arrow_down", self.arrowDownDown)
#up events
self.accept("arrow_left-up", self.arrowLeftUp)
self.accept("arrow_right-up", self.arrowRightUp)
self.accept("arrow_up-up", self.arrowUpUp)
self.accept("arrow_down-up", self.arrowDownUp)
self.accept("space", self.spaceDown)
self.node.setTag("playable", "true")
self.setFollowedByCamera(True)
self.accept("pauseGameplay", self.setPlayable,
[False]) #can pause play
else:
self.ignoreAll()
self.node.setTag("playable", "false")
self.setFollowedByCamera(False)
self.resetMovement() #reset every movement happening
self.accept("resumeGameplay", self.setPlayable,
[True]) #can resume play if not NPC
#estimate loading time 4 seconds... lol... UPDATE: seems fixed in newer panda versions, inspect
def showAllSubnodes(self):
self.wtop.show()
self.wdown.show()
self.wleft.show()
self.wright.show()
self.stop.show()
self.sdown.show()
self.sleft.show()
self.sright.show()
def hideAllSubnodes(self):
self.wtop.hide()
self.wdown.hide()
self.wleft.hide()
self.wright.hide()
self.stop.hide()
self.sdown.hide()
self.sleft.hide()
self.sright.hide()
def setMovement(self, value):
if value == True:
if self.movtask == 0:
self.movtask = taskMgr.add(self.moveCharacter,
"moveCharacterTask")
if value == False:
if self.movtask != 0:
if len(self.currentlydown) == 0:
taskMgr.remove(self.movtask)
self.movtask = 0
'''
reset every movement actually happening
'''
def resetMovement(self):
if self.leftdown == True:
self.face("left")
if self.rightdown == True:
self.face("right")
if self.downdown == True:
self.face("down")
if self.topdown == True:
self.face("top")
self.leftdown = False
self.rightdown = False
self.downdown = False
self.topdown = False
self.currentlydown = []
self.setMovement(False)
def setAnim(self, direction=''):
self.hideAllSubnodes()
if direction == '':
if len(self.currentlydown) > 0:
if self.currentlydown[-1] == 'left':
self.wleft.show()
if self.currentlydown[-1] == 'right':
self.wright.show()
if self.currentlydown[-1] == 'top':
self.wtop.show()
if self.currentlydown[-1] == 'down':
self.wdown.show()
else:
if direction == 'left':
self.wleft.show()
if direction == 'right':
self.wright.show()
if direction == 'up':
self.wtop.show()
if direction == 'down':
self.wdown.show()
#pick request function
def spaceDown(self):
self.pickRequest = True
#movement related functions
def arrowLeftDown(self):
#track key down
self.leftdown = True
self.setMovement(True)
#show changes to screen
self.currentlydown.append("left")
self.setAnim()
def arrowLeftUp(self):
self.leftdown = False
self.setMovement(False)
#show changes to screen
if len(self.currentlydown) == 1:
self.hideAllSubnodes()
self.sleft.show()
if "left" in self.currentlydown:
self.currentlydown.remove("left")
if len(self.currentlydown) > 0:
self.setAnim()
def arrowRightDown(self):
#track key down
self.rightdown = True
self.setMovement(True)
#show changes to screen
self.currentlydown.append("right")
self.setAnim()
def arrowRightUp(self):
self.setMovement(False)
self.rightdown = False
#show changes to screen
if len(self.currentlydown) == 1:
self.hideAllSubnodes()
self.sright.show()
if "right" in self.currentlydown:
self.currentlydown.remove("right")
if len(self.currentlydown) > 0:
self.setAnim()
def arrowDownDown(self):
#track key down
self.downdown = True
self.setMovement(True)
#show changes to screen
self.currentlydown.append("down")
self.setAnim()
def arrowDownUp(self):
self.downdown = False
self.setMovement(False)
#show changes to screen
if len(self.currentlydown) == 1:
self.hideAllSubnodes()
self.sdown.show()
if "down" in self.currentlydown:
self.currentlydown.remove("down")
if len(self.currentlydown) > 0:
self.setAnim()
def arrowUpDown(self):
#track key down
self.topdown = True
self.setMovement(True)
#show changes to screen
self.currentlydown.append("top")
self.setAnim()
def arrowUpUp(self):
self.topdown = False
self.setMovement(False)
#show changes to screen
if len(self.currentlydown) == 1:
self.hideAllSubnodes()
self.stop.show()
if "top" in self.currentlydown:
self.currentlydown.remove("top")
if len(self.currentlydown) > 0:
self.setAnim()
def moveCharacter(self, task):
dt = globalClock.getDt()
if len(self.currentlydown) > 0:
if self.currentlydown[-1] == 'left':
self.node.setX(self.node.getX() -
1 * dt * self.properties['speed'])
if self.currentlydown[-1] == 'right':
self.node.setX(self.node.getX() +
1 * dt * self.properties['speed'])
if self.currentlydown[-1] == 'top':
self.node.setZ(self.node.getZ() +
1 * dt * self.properties['speed'])
if self.currentlydown[-1] == 'down':
self.node.setZ(self.node.getZ() -
1 * dt * self.properties['speed'])
#check collisions
if self.cTrav != None:
self.cTrav.traverse(render)
if self.pickCTrav != None:
self.pickCTrav.traverse(render)
#entries python list
entries = list(self.collisionHandler.getEntries())
pickentries = list(self.pickCollisionHandler.getEntries())
for e in entries[:]:
if e.getIntoNodePath().getName() == "characterPickTube":
entries.remove(e)
for e in pickentries[:]:
if e.getIntoNodePath().getName() == "characterTube":
pickentries.remove(e)
if len(entries) == 0:
self.lastpos = self.node.getPos()
else:
sp = entries[0].getSurfacePoint(self.node) #surface point
objectNode = entries[0].getIntoNodePath().getParent(
) #into object node
groundNode = entries[0].getIntoNodePath() #into object node
if objectNode.hasTag("collideandwalk"):
if objectNode.getTag("collideandwalk") != "yes":
self.node.setPos(self.lastpos)
else:
self.node.setPos(self.lastpos)
#if node is a real object (not a wall)
if objectNode.hasTag("avoidable"):
if objectNode.getTag(
"avoidable"
) == "true": #see if object is intelligently avoidable
if objectNode.hasTag("xscaled") and objectNode.hasTag(
"yscaled"):
if len(
self.currentlydown
) > 0: #at least 1, avoids list index out of range exception
if self.currentlydown[
-1] == 'left' or self.currentlydown[
-1] == 'right': #TODO: fix the shiet, not always working
bottomObjPos = objectNode.getZ() - (
float(objectNode.getTag("yscaled")) / 2)
topObjPos = objectNode.getZ() + (
float(objectNode.getTag("yscaled")) / 2)
if self.node.getZ() < bottomObjPos:
self.node.setZ(self.node.getZ() - 1 * dt *
self.properties['speed'])
if self.node.getZ() > topObjPos:
self.node.setZ(self.node.getZ() + 1 * dt *
self.properties['speed'])
pass
if self.currentlydown[
-1] == 'top' or self.currentlydown[
-1] == 'down':
leftObjPos = objectNode.getX() - (
float(objectNode.getTag("xscaled")) / 2)
rightObjPos = objectNode.getX() + (
float(objectNode.getTag("xscaled")) / 2)
if self.node.getX() < leftObjPos:
self.node.setX(self.node.getX() - 1 * dt *
self.properties['speed'])
if self.node.getX() > rightObjPos:
self.node.setX(self.node.getX() + 1 * dt *
self.properties['speed'])
self.lastpos = self.node.getPos()
for entry in entries:
objectNode = entry.getIntoNodePath().getParent()
onWalked = objectNode.getTag("onWalked")
if len(onWalked) > 0:
eval(onWalked) #oh lol, danger detected here
evaluatedOnce = False
if self.pickRequest == True:
for entry in pickentries:
objectNode = entry.getIntoNodePath().getParent()
onPicked = objectNode.getTag("onPicked")
if len(onPicked) > 0 and evaluatedOnce == False:
eval(onPicked) #oh lol, danger detected again here
evaluatedOnce = True
else:
if hasattr(objectNode.getPythonTag('gamenode'), 'name'):
print "WARNING: picking on this object is not defined: ", objectNode.getPythonTag(
'gamenode').name
print "X: ", objectNode.getX()
print "Y: ", objectNode.getZ()
self.pickRequest = False #resetting request
#this is needed for empty pick
if self.pickRequest == True:
self.pickRequest = False #resetting request
return Task.cont
def getWorldPos(self):
return self.node.getPos(render)
def setX(self, x):
self.node.setX(x)
self.lastpos.setX(x)
def setY(self, y):
self.node.setZ(y)
self.lastpos.setZ(y)
#here for polymorph
def getTileX(self):
return self.parent.getX()
#here for polymorph
def getTileY(self):
return self.parent.getY()
class CreditsReel(object):
'''
Creates a Panda scene that's independent of the main render tree, so that
the credits can be displayed in a smaller display region within the main
screen.
'''
def __init__(self, app):
self.app = app
self.do = DirectObject()
self.running = False
self.displayRegion = None
self.root = NodePath('creditsRender')
self.camera = Camera('creditsCam')
self.cameraNP = NodePath(self.camera)
# Set parameters to match those of render2d
self.root.setDepthTest(0)
self.root.setDepthWrite(0)
self.root.setMaterialOff(1)
self.root.setTwoSided(1)
self.aspect2d = self.root # self.root.attachNewNode('creditsAspect')
lens = OrthographicLens()
lens.setFilmSize(2, 2)
lens.setFilmOffset(0, 0)
lens.setNearFar(-1000, 1000)
self.camera.setLens(lens)
self.cameraNP.reparentTo(self.root)
self.scrollTask = None
self.lastTime = None
self.creditsFileLoaded = False
def loadCreditsFileIfNeeded(self):
if self.creditsFileLoaded:
return
filePath = getPath(startupMenu, 'credits3d.txt')
with codecs.open(filePath, 'rU', encoding='utf-8') as f:
creditsLines = f.read().splitlines()
y = 0
for line in creditsLines:
if line.startswith('!!'):
font = self.app.fonts.creditsH1
line = line[len('!!'):]
elif line.startswith('!'):
font = self.app.fonts.creditsH2
line = line[len('!'):]
else:
font = self.app.fonts.creditsFont
lineHeight = font.getPandaLineHeight(self.app)
node = font.makeOnscreenText(
self.app,
text=line or ' ', # Prevents .getNumRows() bug
fg=self.app.theme.colours.mainMenuColour,
align=TextNode.ACenter,
pos=(0, y - lineHeight),
parent=self.aspect2d,
wordwrap=28,
)
y -= lineHeight * (node.textNode.getNumRows() + 0.2)
self.creditsFileLoaded = True
def stop(self):
if not self.running:
return
self.running = False
self.do.ignoreAll()
if self.scrollTask is not None:
self.app.panda.taskMgr.remove(self.scrollTask)
self.scrollTask = None
if self.displayRegion is not None:
self.displayRegion.setActive(False)
def start(self):
self.cameraNP.setPos((0, 0, 0))
if self.running:
return
self.running = True
self.loadCreditsFileIfNeeded()
if self.scrollTask is None:
self.scrollTask = self.app.panda.taskMgr.add(
self.updateCredits, 'creditsLoop')
self.lastTime = self.scrollTask.time
if self.displayRegion is None:
self.displayRegion = self.app.panda.win.makeDisplayRegion()
self.displayRegion.setSort(5)
self.displayRegion.setClearDepthActive(1)
self.displayRegion.setIncompleteRender(False)
self.displayRegion.setCamera(self.cameraNP)
self.displayRegion.setActive(True)
self.do.accept('aspectRatioChanged', self.aspectRatioChanged)
self.aspectRatioChanged()
def aspectRatioChanged(self):
# Scaling from -1 to +1
idealTop = 0.66
idealBottom = -0.74
aspectRatio = self.app.panda.getAspectRatio()
top = idealTop * min(aspectRatio * 3. / 4, 1)
bottom = idealBottom * min(aspectRatio * 3. / 4, 1)
self.displayRegion.setDimensions(0, 1, 0.5 * (1 + bottom),
0.5 * (1 + top))
windowRatio = 2 * aspectRatio / (top - bottom)
self.cameraNP.setScale(windowRatio * 3. / 4, 1.0, 1.0)
def updateCredits(self, task):
deltaT = task.time - self.lastTime
self.lastTime = task.time
z = self.cameraNP.getZ()
z -= deltaT * CREDITS_SCROLL_SPEED
self.cameraNP.setZ(z)
return Task.cont
class UpAllTheWay(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.setupLights()
self.setup()
# Accept the control keys for movement and rotation
self.accept('escape', self.doExit)
self.accept('f1', self.toggleHelp)
self.accept('f3', self.toggleDebug)
self.accept('space', self.player.doJump)
self.accept("a", self.player.setKey, ["left", True])
self.accept("a-up", self.player.setKey, ["left", False])
self.accept("d", self.player.setKey, ["right", True])
self.accept("d-up", self.player.setKey, ["right", False])
self.accept("w", self.player.setKey, ["forward", True])
self.accept("w-up", self.player.setKey, ["forward", False])
self.accept("s", self.player.setKey, ["reverse", True])
self.accept("s-up", self.player.setKey, ["reverse", False])
# Task
taskMgr.add(self.update, 'updateWorld')
base.setBackgroundColor(0.1, 0.1, 0.8, 1)
base.setFrameRateMeter(True)
# base.disableMouse()
base.camera.setPos(self.player.getCharacterNP().getPos())
base.camera.setHpr(self.player.getCharacterNP().getHpr())
base.camera.lookAt(self.player.getCharacterNP())
# Create a floater object. We use the "floater" as a temporary
# variable in a variety of calculations.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# Add environment
self.env = self.loader.loadModel("models/env/PeachSky")
self.env.reparentTo(render)
# Add text
self.collectibleCounter = 0
self.collectibleTotal = Data.collectibleTotal1
self.collectibleIndicator = "Level " + str(Data.currentLevel) + ": collectible items - " + str(self.collectibleCounter) + "/" + str(self.collectibleTotal)
self.timeIndicator = "Time left - " + str(Data.maxTime/Data.frameRate)
self.helpIndicator = "[F1] - Help"
self.inst1 = self.addInstructions(0.06, self.collectibleIndicator)
self.inst2 = self.addInstructions(0.12, self.timeIndicator)
self.inst3 = self.addInstructions(0.18, self.helpIndicator)
# Help variable
self.helpOn = False
# Function to put instructions on the screen.
def addInstructions(self, pos, msg):
return OnscreenText(text=msg, style=1, fg=(89/255, 255/255, 56/255, 1),
scale=.06, shadow=(0, 0, 0, 1), parent = base.a2dTopLeft,
pos=(0.04, -pos - 0.02), align = TextNode.ALeft)
def addVictoryText(self, msg):
return OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1),
scale=.25, shadow=(0, 0, 0, 1), parent = base.a2dTopLeft,
pos=(0.6, -1), align = TextNode.ALeft)
def doExit(self):
self.cleanup()
sys.exit(1)
def toggleHelp(self):
if (self.helpOn == False):
self.helpOn = True
taskMgr.remove('updateWorld')
self.inst1.destroy()
self.inst2.destroy()
self.inst3.destroy()
self.inst1 = self.addInstructions(0.06, "Game paused")
self.inst2 = self.addInstructions(0.12, "")
self.inst3 = self.addInstructions(0.18, "STORY")
self.inst4 = self.addInstructions(0.24, "Di is a CSULA CS graduate student fighting for his CS MS degree.")
self.inst5 = self.addInstructions(0.30, "He's on his journey to gain his degree, but it will not be easy.")
self.inst6 = self.addInstructions(0.36, "He needs to go upward and collect books as knowledge, and avoid professor attacks.")
self.inst7 = self.addInstructions(0.42, "Eventually he will reach a new height in life and collect his diploma in a magic box!")
self.inst8 = self.addInstructions(0.48, "")
self.inst9 = self.addInstructions(0.54, "ACTION KEYS")
self.inst10 = self.addInstructions(0.60, "[W] - forward, [S] - reverse, [A] - turn left, [D] - turn right, [SPACE] - jump")
else:
self.helpOn = False
taskMgr.add(self.update, 'updateWorld')
self.inst1.destroy()
self.inst2.destroy()
self.inst3.destroy()
self.inst4.destroy()
self.inst5.destroy()
self.inst6.destroy()
self.inst7.destroy()
self.inst8.destroy()
self.inst9.destroy()
self.inst10.destroy()
self.inst1 = self.addInstructions(0.06, self.collectibleIndicator)
self.inst2 = self.addInstructions(0.12, self.timeIndicator)
self.inst3 = self.addInstructions(0.18, self.helpIndicator)
def toggleDebug(self):
if self.debugNP.isHidden():
self.debugNP.show()
else:
self.debugNP.hide()
def level1Selector(self):
Data.maxTime = 7200
Data.detectDistance = 4
Data.dropRate = 60
self.collectibleTotal = Data.collectibleTotal1
self.player.resetCharacter()
self.level2Music.stop()
self.level1Music.play()
def level2Selector(self):
Data.maxTime = 9000
Data.detectDistance = 5
Data.dropRate = 30
self.collectibleTotal = Data.collectibleTotal2
self.player.resetCharacter()
self.level1Music.stop()
self.level2Music.play()
def createMainMenu(self):
self.v = [0]
self.myFrame = DirectFrame(frameColor = (0.8, 0.8, 0.8, 1), frameSize = (-0.5, 0.5, -0.3, 0.3), pos = (0, 0, 0))
self.myLabel = DirectLabel(text = 'MAIN MENU', scale = 0.1, pos = (0, 0, 0.16))
self.buttons = [
DirectRadioButton(text = 'Level 1', variable = self.v, value = [1], scale = 0.1, pos = (-0.2,0,-0.05), command = self.setLevel),
DirectRadioButton(text = 'Level 2', variable = self.v, value = [2], scale = 0.1, pos = (0.25,0,-0.05), command = self.setLevel)
]
for button in self.buttons:
button.setOthers(self.buttons)
self.start = DirectButton(text = "START", scale = 0.1, pos = (-0.2,0,-0.2), command = self.levelStart)
self.quit = DirectButton(text = "QUIT", scale = 0.1, pos = (0.2,0,-0.2), command = self.doExit)
def setLevel(self):
Data.currentLevel = self.v[0]
def levelStart(self):
self.myFrame.destroy()
self.myLabel.destroy()
self.buttons[0].destroy()
self.buttons[1].destroy()
self.start.destroy()
self.quit.destroy()
if (Data.currentLevel == 1):
self.level1Selector()
else:
self.level2Selector()
def update(self, task):
dt = globalClock.getDt()
self.player.move()
self.world.doPhysics(dt, 4, 1./240.)
self.processMovements()
self.countdown()
self.refreshCollectibleCount()
camvec = self.player.getCharacterNP().getPos() - base.camera.getPos()
camvec.setZ(0)
camdist = camvec.length()
camvec.normalize()
# If the camera is too far from Di, move it closer.
if (camdist > 25.0):
base.camera.setPos(base.camera.getPos() + camvec*(camdist-20))
camdist = 25.0
# If the camera is too close to Di, move it farther.
if (camdist < 5.0):
base.camera.setPos(base.camera.getPos() - camvec*(5-camdist))
camdist = 5.0
self.floater.setPos(self.player.getCharacterNP().getPos())
self.floater.setZ(self.player.getCharacterNP().getZ() + 2.0)
if (self.floater.getZ() > -20.0):
base.camera.setZ(self.floater.getZ() + 20.0)
else:
base.camera.setZ(0.0)
base.camera.lookAt(self.floater)
if (self.player.getCharacterNP().getZ() < -40):
self.player.resetCharacter()
self.laughSound.play()
return task.cont
def cleanup(self):
self.world = None
self.render.removeNode()
def setupLights(self):
# 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)
self.render.clearLight()
self.render.setLight(alightNP)
self.render.setLight(dlightNP)
def setup(self):
# World
self.debugNP = self.render.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.hide()
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Create starting platforms
Platform(self.render, self.world, self.loader, 0, 1, 2, 0, 0, -3)
Platform(self.render, self.world, self.loader, 0, 2, 2, 100, 100, -3)
# Generate platforms
PlatformFactory(self.render, self.world, self.loader)
# Create player character
self.player = Player(self.render, self.world, 0, 0, 0)
# Music and sound
self.level1Music = base.loader.loadSfx("sounds/level1.mp3")
self.level1Music.setLoop()
self.level1Music.setVolume(0.4)
self.level1Music.play()
self.level2Music = base.loader.loadSfx("sounds/level2.mp3")
self.level2Music.setLoop()
self.level2Music.setVolume(0.4)
self.winMusic = base.loader.loadSfx("sounds/win.ogg")
self.winMusic.setLoop()
self.winMusic.setVolume(0.4)
self.laughSound = base.loader.loadSfx("sounds/laugh.ogg")
self.collectSound = base.loader.loadSfx("sounds/collect.mp3")
self.createMainMenu()
# Handle contacts
def processMovements(self):
if (len(Data.books) > 0):
for book in Data.books:
self.distanceTest(book)
if (len(Data.door) > 0):
self.distanceTest(Data.door[0])
if (len(Data.akises) > 0):
for akis in Data.akises:
self.distanceTest(akis)
if (len(Data.kangs) > 0):
for kang in Data.kangs:
self.distanceTest(kang)
if (len(Data.balls) > 0):
for ball in Data.balls:
self.distanceTest(ball)
if (len(Data.magicBox) > 0):
self.distanceTest(Data.magicBox[0])
def distanceTest(self, secondObject):
name = secondObject.getActor().getName()
distance = self.getDistance(self.player.getCharacterNP(), secondObject.getNP())
if (distance > Data.contactDistance and distance <= Data.detectDistance):
if ("Akis" in name or "Kang" in name):
secondObject.move(self.player)
if ("Kang" in name and Data.maxTime % Data.dropRate == 0):
secondObject.drop(self.player)
if (distance <= Data.winningDistance):
if (self.collectibleCounter == self.collectibleTotal):
if ("Door" in name):
self.collectibleCounter = 0
Data.currentLevel = 2
self.level2Selector()
elif ("MagicBox" in name):
taskMgr.remove('updateWorld')
self.addVictoryText("GRADUATED!")
self.level2Music.stop()
self.winMusic.play()
if (distance <= Data.contactDistance):
if ("Collectible" in name):
secondObject.killNP()
secondObject.getActorModelNP().removeNode()
self.collectSound.play()
self.collectibleCounter += 1
elif ("Akis" in name or "Kang" in name or "Ball" in name):
self.player.resetCharacter()
self.laughSound.play()
def refreshCollectibleCount(self):
self.collectibleIndicator = "Level " + str(Data.currentLevel) + ": collectible items - " + str(self.collectibleCounter) + "/" + str(self.collectibleTotal)
self.inst1.destroy()
self.inst1 = self.addInstructions(0.06, self.collectibleIndicator)
# refresh time
self.timeIndicator = "Time left - " + str(Data.maxTime/Data.frameRate)
self.inst2.destroy()
self.inst2 = self.addInstructions(0.12, self.timeIndicator)
def countdown(self):
if (Data.maxTime > 0):
Data.maxTime -= 1
elif (Data.maxTime == 0):
taskMgr.remove('updateWorld')
self.addVictoryText("YOU LOST!!!")
# UTIL METHODS
def getDistance(self, one, two):
vec = one.getPos() - two.getPos()
return vec.length()
