def __init__(self):
self.setAI()
self.keyMap = {"left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0, "cam-right": 0}
base.win.setClearColor(Vec4(0, 0, 0, 1))
# the menu
self.loadAudio()
self.showMenu()
# keyboard and mouse events
self.accept("escape", sys.exit)
self.accept("w", self.setKey, ["forward", 1])
self.accept("a", self.setKey, ["left", 1])
self.accept("s", self.setKey, ["backward", 1])
self.accept("d", self.setKey, ["right", 1])
self.accept("w-up", self.setKey, ["forward", 0])
self.accept("a-up", self.setKey, ["left", 0])
self.accept("s-up", self.setKey, ["backward", 0])
self.accept("d-up", self.setKey, ["right", 0])
self.accept("arrow_left", self.setKey, ["cam-left", 1])
self.accept("arrow_left-up", self.setKey, ["cam-left", 0])
self.accept("arrow_right", self.setKey, ["cam-right", 1])
self.accept("arrow_right-up", self.setKey, ["cam-right", 0])
# create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(0.3, 0.3, 0.3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def createEnvironment(self):
# Fog to hide a performance tweak:
colour = (0.0, 0.0, 0.0)
expfog = Fog("scene-wide-fog")
expfog.setColor(*colour)
expfog.setExpDensity(0.001) # original : 0.004
render.setFog(expfog)
base.setBackgroundColor(*colour)
# Our sky
skydome = loader.loadModel('sky.egg')
skydome.setEffect(CompassEffect.make(self.render))
skydome.setScale(self.maxdistance / 2) # bit less than "far"
skydome.setZ(-65) # sink it
# NOT render - you'll fly through the sky!:
skydome.reparentTo(self.camera)
# Our lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.6, .6, .6, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(0, -10, -10))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def createLighting(self):
#creates lighting for the scene
aLightVal = 0.3
dLightVal1 = -5
dLightVal2 = 5
#set up the ambient light
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(aLightVal, aLightVal, aLightVal, 1))
ambientLight1 = AmbientLight("ambientLight1")
ambientLight1.setColor(Vec4(aLightVal, aLightVal, aLightVal, 1))
ambientLight2 = AmbientLight("ambientLight2")
ambientLight2.setColor(Vec4(aLightVal, aLightVal, aLightVal, 1))
#sets a directional light
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(dLightVal1, dLightVal1, dLightVal1))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(0, 0, 0, 1))
#sets a directional light
directionalLight1 = DirectionalLight("directionalLight2")
directionalLight1.setDirection(Vec3(dLightVal2, dLightVal1, dLightVal1))
directionalLight1.setColor(Vec4(1, 1, 1, 1))
directionalLight1.setSpecularColor(Vec4(1, 1, 1, 1))
#attaches lights to scene
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(ambientLight1))
render.setLight(render.attachNewNode(ambientLight1))
render.setLight(render.attachNewNode(directionalLight))
render.setLight(render.attachNewNode(directionalLight1))
def Start(self,pl_name,pl_char,pl_count,pl_list):
# Set up the environment
#
self.environ = loader.loadModel("models/square")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
self.environ.setScale(100,100,1)
self.moon_tex = loader.loadTexture("models/moon_1k_tex.jpg")
self.environ.setTexture(self.moon_tex, 1)
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# # add spheres
earth = Earth(self)
sun = Sun(self)
venus = Venus(self)
controls = Control()
chat = Chat(self)
if pl_char == "Panda1" or pl_char == "Panda2":
print "hi"
player = Panda(self)
elif pl_char == "Car":
player = Car(self)
else :
player = Ralph(self)
#player = Car(self)
# player = Panda(self)
# player = Car(self)
taskMgr.add(player.move,"moveTask" )
taskMgr.add(sun.rotatePlanets,"rotateSun", extraArgs = [self.sun,self.player], appendTask = True)
taskMgr.add(earth.rotatePlanets,"rotateEarth", extraArgs = [self.earth, self.player], appendTask = True)
taskMgr.add(venus.rotatePlanets,"rotateVenus", extraArgs = [self.venus, self.player], appendTask = True)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
base.win.setClearColor(Vec4(0, 0, 0, 1))
# Network Setup
print "before"
self.cManager = ConnectionManager(self)
self.startConnection()
print "after"
# Set up the environment
#
self.environ = loader.loadModel("models/square")
self.environ.reparentTo(render)
self.environ.setPos(0, 0, 0)
self.environ.setScale(100, 100, 1)
self.moon_tex = loader.loadTexture("models/moon_1k_tex.jpg")
self.environ.setTexture(self.moon_tex, 1)
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# add spheres
earth = Earth(self)
sun = Sun(self)
venus = Venus(self)
controls = Control()
chat = Chat(self)
player = Ralph(self)
# player = Panda(self)
# player = Car(self)
taskMgr.add(player.move, "moveTask")
taskMgr.add(sun.rotatePlanets,
"rotateSun",
extraArgs=[self.player],
appendTask=True)
taskMgr.add(earth.rotatePlanets,
"rotateEarth",
extraArgs=[self.player],
appendTask=True)
taskMgr.add(venus.rotatePlanets,
"rotateVenus",
extraArgs=[self.player],
appendTask=True)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
__builtin__.main = self
self.taskMgr = taskMgr
self.base = base
# Connect to the server
self.cManager = ConnectionManager()
self.startConnection()
self.characters = dict()
self.cpList = dict()
base.win.setClearColor(Vec4(0,0,0,1))
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
self.ralphStartPos = self.environ.find("**/start_point").getPos()
# 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)
self.accept("escape", sys.exit)
# Login as 'CPHandler'
# Temporary workaround, can add a seperate request/response for client/NPC client logins later
self.name = "CPHandler"
factionId = 0
self.cManager.sendRequest(Constants.CMSG_AUTH, [self.name, factionId])
# Create two control points
cp1 = ControlPoint(1, -107.575, 0.6066, 0.490075, 10, RED)
cp2 = ControlPoint(2, -100.575, -35.6066, 0.090075, 10, BLUE)
self.cpList[1] = cp1
self.cpList[2] = cp2
taskMgr.doMethodLater(0.1, self.refresh, "heartbeat")
taskMgr.doMethodLater(1, self.CPHandler, 'CPHandler')
# Set up the camera
base.disableMouse()
#base.camera.setPos(self.character.actor.getX(),self.character.actor.getY()+10,2)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def light(self):
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
__builtin__.main = self
self.taskMgr = taskMgr
self.base = base
# Connect to the server
self.cManager = ConnectionManager()
self.startConnection()
self.characters = dict()
self.cpList = dict()
base.win.setClearColor(Vec4(0, 0, 0, 1))
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0, 0, 0)
self.ralphStartPos = self.environ.find("**/start_point").getPos()
# 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)
self.accept("escape", sys.exit)
# Login as 'CPHandler'
# Temporary workaround, can add a seperate request/response for client/NPC client logins later
self.name = "CPHandler"
factionId = 0
self.cManager.sendRequest(Constants.CMSG_AUTH, [self.name, factionId])
# Create two control points
cp1 = ControlPoint(1, -107.575, 0.6066, 0.490075, 10, RED)
cp2 = ControlPoint(2, -100.575, -35.6066, 0.090075, 10, BLUE)
self.cpList[1] = cp1
self.cpList[2] = cp2
taskMgr.doMethodLater(0.1, self.refresh, "heartbeat")
taskMgr.doMethodLater(1, self.CPHandler, 'CPHandler')
# Set up the camera
base.disableMouse()
#base.camera.setPos(self.character.actor.getX(),self.character.actor.getY()+10,2)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self, aCol, dDir, dCol):
render.setAttrib(LightRampAttrib.makeHdr1())
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(aCol)
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(dDir)
directionalLight.setColor(dCol)
directionalLight.setSpecularColor(Vec4(2.0, 2.0, 2.0, 0))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self, aCol, dDir, dCol):
render.setAttrib(LightRampAttrib.makeHdr1())
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(aCol)
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(dDir)
directionalLight.setColor(dCol)
directionalLight.setSpecularColor(Vec4(2.0, 2.0, 2.0, 0))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def init(self):
# window setup
base.win.setClearColor(Vec4(0, 0, 0, 1))
# display instructions
addTitle("CS454 HW2")
addInstructions(0.95, "[ESC]: Quit")
addInstructions(0.90, "[Mouse Move]: Move camera")
addInstructions(0.85, "[Mouse Wheel]: Zoom camera")
addInstructions(0.80, "[W,A,S,D]: Move character")
addInstructions(0.75, "[T]: Open chat box")
addInstructions(0.70, "[Y]: Open whisper box")
addInstructions(0.65, "[Up,Down]: Select whisper target")
addInstructions(0.60, "[Tab]: Show players")
# create environment
environ = loader.loadModel("models/square")
environ.reparentTo(render)
environ.setPos(0, 0, 0)
environ.setScale(100, 100, 1)
environ.setTexture(loader.loadTexture("models/moon_1k_tex.jpg"), 1)
# create lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(0.3, 0.3, 0.3, 1))
render.setLight(render.attachNewNode(ambientLight))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(directionalLight))
# accept special keys
base.accept("escape", self.exit)
base.accept("shift-escape", self.exit)
# create spheres
sun = Sphere(self, "sun")
sun.model.setPos(-15, -15, 8)
earth = Sphere(self, "earth")
earth.model.setPos(-12, 12, 5)
venus = Sphere(self, "venus")
venus.model.setPos(10, 10, 3.5)
# track game entities
self.character = None
self.player = None
self.camera = None
self.characters = {}
self.chat = Chat(self)
self.playerList = PlayerList(self)
def __init__(self):
base.win.setClearColor(Vec4(0,0,0,1))
# Network Setup
print "before"
self.cManager = ConnectionManager(self)
self.startConnection()
print "after"
# Set up the environment
#
self.environ = loader.loadModel("models/square")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
self.environ.setScale(100,100,1)
self.moon_tex = loader.loadTexture("models/moon_1k_tex.jpg")
self.environ.setTexture(self.moon_tex, 1)
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# add spheres
earth = Earth(self)
sun = Sun(self)
venus = Venus(self)
controls = Control()
chat = Chat(self)
player = Ralph(self)
# player = Panda(self)
# player = Car(self)
taskMgr.add(player.move,"moveTask" )
taskMgr.add(sun.rotatePlanets,"rotateSun", extraArgs = [self.player], appendTask = True)
taskMgr.add(earth.rotatePlanets,"rotateEarth", extraArgs = [self.player], appendTask = True)
taskMgr.add(venus.rotatePlanets,"rotateVenus", extraArgs = [self.player], appendTask = True)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
self.root = render.attachNewNode("Root")
base.setBackgroundColor(0, 0, 0)
# This code puts the standard title and instruction text on screen
self.title = OnscreenText(text="Ball In Maze",
style=1,
fg=(1, 1, 0, 1),
pos=(0.7, -0.95),
scale=.07)
self.instructions = OnscreenText(text="Press Esc to exit",
pos=(-1.3, .95),
fg=(1, 1, 0, 1),
align=TextNode.ALeft,
scale=.05)
self.central_msg = OnscreenText(text="",
pos=(0, 0),
fg=(1, 1, 0, 1),
scale=.1)
self.central_msg.hide()
self.accept("escape", sys.exit) # Escape quits
base.disableMouse() # Disable mouse-based camera control
camera.setPosHpr(0, 0, 25, 0, -90, 0) # Place the camera
# Load the maze and place it in the scene
self.maze = loader.loadModel("models/maze")
self.maze.reparentTo(render)
# Load the ball and attach it to the scene
# It is on a root dummy node so that we can rotate the ball itself without
# rotating the ray that will be attached to it
self.ballRoot = render.attachNewNode("ballRoot")
self.ball = loader.loadModel("models/ball")
self.ball.reparentTo(self.ballRoot)
# This section deals with lighting for the ball. Only the ball was lit
# because the maze has static lighting pregenerated by the modeler
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.55, .55, .55, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(0, 0, -1))
directionalLight.setColor(Vec4(0.375, 0.375, 0.375, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
self.ballRoot.setLight(render.attachNewNode(ambientLight))
self.ballRoot.setLight(render.attachNewNode(directionalLight))
# This section deals with adding a specular highlight to the ball to make
# it look shiny
m = Material()
m.setSpecular(Vec4(1, 1, 1, 1))
m.setShininess(96)
self.ball.setMaterial(m, 1)
def setupLights(self):
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight1 = DirectionalLight("directionalLight")
directionalLight1.setDirection(Vec3(5, 5, -5))
directionalLight1.setColor(Vec4(1, 1, 1, 1))
directionalLight1.setSpecularColor(Vec4(1, 1, 1, 1))
directionalLight2 = DirectionalLight("directionalLight")
directionalLight2.setDirection(Vec3(5, -5, -5))
directionalLight2.setColor(Vec4(1, 1, 1, 1))
directionalLight2.setSpecularColor(Vec4(1, 1, 1, 1))
directionalLight3 = DirectionalLight("directionalLight")
directionalLight3.setDirection(Vec3(-5, -5, -5))
directionalLight3.setColor(Vec4(1, 1, 1, 1))
directionalLight3.setSpecularColor(Vec4(1, 1, 1, 1))
directionalLight4 = DirectionalLight("directionalLight")
directionalLight4.setDirection(Vec3(-5, 5, -5))
directionalLight4.setColor(Vec4(1, 1, 1, 1))
directionalLight4.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight1))
render.setLight(render.attachNewNode(directionalLight2))
render.setLight(render.attachNewNode(directionalLight3))
render.setLight(render.attachNewNode(directionalLight4))
def setup(self):
ambient_light = AmbientLight("ambientLight")
ambient_light.setColor(self.config.get('ambient_color'))
directional_light = DirectionalLight("directionalLight")
directional_light.setDirection(self.config.get('direction'))
directional_light.setColor(self.config.get('directional_color'))
directional_light.setSpecularColor(
self.config.get('directional_specular_color'))
# directionalLight.showFrustum()
self.render.setLight(self.render.attachNewNode(ambient_light))
self.render.setLight(self.render.attachNewNode(directional_light))
# Important! Enable the shader generator.
self.render.setShaderAuto()
def __init__(self):
self.root = render.attachNewNode("Root")
base.setBackgroundColor(0,0,0)
# This code puts the standard title and instruction text on screen
self.title = OnscreenText(text="Ball In Maze",
style=1, fg=(1,1,0,1),
pos=(0.7,-0.95), scale = .07)
self.instructions = OnscreenText(text="Press Esc to exit",
pos = (-1.3, .95), fg=(1,1,0,1),
align = TextNode.ALeft, scale = .05)
self.central_msg = OnscreenText(text="",
pos = (0, 0), fg=(1, 1, 0, 1),
scale = .1
)
self.central_msg.hide()
self.accept("escape", sys.exit) # Escape quits
base.disableMouse() # Disable mouse-based camera control
camera.setPosHpr(0, 0, 25, 0, -90, 0) # Place the camera
# Load the maze and place it in the scene
self.maze = loader.loadModel("models/maze")
self.maze.reparentTo(render)
# Load the ball and attach it to the scene
# It is on a root dummy node so that we can rotate the ball itself without
# rotating the ray that will be attached to it
self.ballRoot = render.attachNewNode("ballRoot")
self.ball = loader.loadModel("models/ball")
self.ball.reparentTo(self.ballRoot)
# This section deals with lighting for the ball. Only the ball was lit
# because the maze has static lighting pregenerated by the modeler
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.55, .55, .55, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(0, 0, -1))
directionalLight.setColor(Vec4(0.375, 0.375, 0.375, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
self.ballRoot.setLight(render.attachNewNode(ambientLight))
self.ballRoot.setLight(render.attachNewNode(directionalLight))
# This section deals with adding a specular highlight to the ball to make
# it look shiny
m = Material()
m.setSpecular(Vec4(1,1,1,1))
m.setShininess(96)
self.ball.setMaterial(m, 1)
def setup_lights(self):
render = self.render
ambientLight = AmbientLight('ambient')
ambientLight.setColor(Vec4(.5, .5, .5, 1))
render.setLight(render.attachNewNode(ambientLight))
directionalLight = DirectionalLight('directional')
directionalLight.setDirection(Vec3(10, 10, -10))
directionalLight.setColor(Vec4(.75, .6, .6, 1))
directionalLight.setSpecularColor(directionalLight.getColor())
render.setLight(render.attachNewNode(directionalLight))
skyLight = DirectionalLight('sky')
skyLight.setDirection(Vec3(-25, 10, -25))
skyLight.setColor(Vec4(.25, .25, .5, 1))
skyLight.setSpecularColor(skyLight.getColor())
render.setLight(render.attachNewNode(skyLight))
def start(self, myPlayerName, players):
"""
Takes a list of player names and positions,
initializes the players and sets up the scene
"""
# Load the environment model.
self.levelNode = render.attachNewNode("Level node")
self.level = LevelContainer(self.levelName)
self.level.render(self.levelNode, base.loader)
self.levelNode.setAttrib(ShadeModelAttrib.make(ShadeModelAttrib.MFlat))
base.win.setClearColor(Vec4(0,0,0,1))
self.title = addTitle("PushBack")
self.players = dict()
self.playersNode = render.attachNewNode("Players Root Node")
self.healthbar = DirectWaitBar(range=1.0, barColor=(1.0, 0.0, 0.0, 1.0),
value=1.0, frameSize=(-0.45,0.45,1.0,0.98))
base.disableMouse()
base.cam.reparentTo(self.playersNode)
base.cam.setCompass()
base.cam.setH(0)
base.cam.setZ(CAM_HEIGHT)
base.cam.setY(-CAM_HEIGHT)
base.cam.setP(-CAM_ANGLE)
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
skins = ["stony_green", "stony_red", "stony_blue", "bonbon_blue","bonbon_green", "red", "pushette", "blue"]
for player in players:
print "Init player %s" % player[0]
p = Player(player[0])
p.reparentTo(self.playersNode)
p.setPos(player[1])
p.setColor(skins.pop())
self.players[player[0]] = p
if myPlayerName == player[0]:
self.myPlayer = p
base.cam.reparentTo(self.myPlayer)
def setupSimpleLighting(self,
ambientLightLevel=.3,
directionalLightLevel=1):
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(
(ambientLightLevel, ambientLightLevel, ambientLightLevel, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((-5, -5, -5))
directionalLight.setColor(
(directionalLightLevel, directionalLightLevel,
directionalLightLevel, 1))
directionalLight.setSpecularColor(
(directionalLightLevel, directionalLightLevel,
directionalLightLevel, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
return [ambientLight, directionalLight]
def setUpWindow(self):
# set up the egg files needed
# since this method is made for python 2.7 but these objects are made for python 3.5, seems to be incompatible
#m = Mountain("TestMountain", 60)
#m.editFile()
#p = Pole("TestPole", 0, 0, 0)
#p.editFile()
#c = Car("TestCar", 0,0,0)
#c.editFile()
#b = BeaconLight("BeaconLight",0,0,0)
#b.editFile()
# Set up the window, camera, etc
ShowBase.__init__(self)
# Set the background color to black
self.win.setClearColor((0, 1, 1, 1))
# this is the model I created using mountainMaker.py
self.environ = loader.loadModel("TestMountain1")
self.environ.reparentTo(render)
self.car = loader.loadModel("TestCar")
# found how to solve the problem of only being able to see objects from
# certain angles with this:
# http://www.panda3d.org/manual/index.php/Backface_Culling_and_Frontface_Culling
self.car.setTwoSided(True)
self.car.reparentTo(render)
# Create some lighting
# this is a part that is completely unchanged from demo
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((-5, -5, -5))
directionalLight.setColor((1, 1, 1, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
# to get light from other direction to light up things on both sides
directionalLight2 = DirectionalLight("directionalLight")
directionalLight2.setDirection((5, 5, 5))
directionalLight2.setColor((1, 1, 1, 1))
directionalLight2.setSpecularColor((1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
render.setLight(render.attachNewNode(directionalLight2))
def __init__(self):
#Load switch model
self.glowswitch = loader.loadModel("glowswitch")
self.sphere=self.glowswitch.find("**/sphere") #finds a subcomponent of the .egg model... sphere is the name of the sphere geometry in the .egg file
self.glowswitch.reparentTo(render)
base.disableMouse() #mouse-controlled camera cannot be moved within the program
camera.setPosHpr( 0, -6.5, 1.4, 0, -2, 0)
#Light up everything an equal amount
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.95, .95, 1.05, 1))
render.setLight(render.attachNewNode(ambientLight))
#Add lighting that only casts light on one side of everything in the scene
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(.2, .2, .2, .1)) #keepin it dim
directionalLight.setSpecularColor(Vec4(0.2, 0.2, 0.2, 0.2))
render.setLight(render.attachNewNode(directionalLight))
#initalize sequence variable
self.ChangeColorSeq = Sequence(Wait(.1))
#start with blue by default
self.changeOrbColor(.1,0,.6,.3,.2,1)
#^(R min, Gmin, Bmin, Rmax, Gmax, Bmax)
#user controls
#note that changing the color means it will "pulse" that color and therefore needs a range of color values
self.accept("1", self.changeOrbColor,[.6,.1,.1,1,.3,.3]) #change orb color to red
self.accept("2", self.changeOrbColor,[.1,.6,.1,.3,1,.3])#change orb color to green
self.accept("3", self.changeOrbColor,[.1,0,.6,.3,.2,1]) #change orb color to blue
self.accept("escape", sys.exit)
instructions = OnscreenText(text="1: Change to red \n2: Change to Green \n3: Change to Blue \nEsc: Exit",
fg=(1,1,1,1), pos = (-1.3, -.82), scale = .05, align = TextNode.ALeft)
def loadBall(self):
self.ballRoot = render.attachNewNode("ballRoot")
self.ball = load_model("ball")
self.ball.reparentTo(self.ballRoot)
self.ball_tex = load_tex("pokeball.png")
self.ball.setTexture(self.ball_tex,1)
self.ball.setScale(0.8)
# Find the collision sphere for the ball in egg.
self.ballSphere = self.ball.find("**/ball")
self.ballSphere.node().setFromCollideMask(BitMask32.bit(0))
self.ballSphere.node().setIntoCollideMask(BitMask32.allOff())
#self.ballSphere.show()
# Now we create a ray to cast down at the ball.
self.ballGroundRay = CollisionRay()
self.ballGroundRay.setOrigin(0,0,10)
self.ballGroundRay.setDirection(0,0,-1)
# Collision solids go in CollisionNode
self.ballGroundCol = CollisionNode('groundRay')
self.ballGroundCol.addSolid(self.ballGroundRay)
self.ballGroundCol.setFromCollideMask(BitMask32.bit(1))
self.ballGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ballGroundColNp = self.ballRoot.attachNewNode(self.ballGroundCol)
# light
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.55, .55, .55, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(0,0,-1))
directionalLight.setColor(Vec4(0.375,0.375,0.375,1))
directionalLight.setSpecularColor(Vec4(1,1,1,1))
self.ballRoot.setLight(render.attachNewNode(ambientLight))
self.ballRoot.setLight(render.attachNewNode(directionalLight))
# material to the ball
m = Material()
m.setSpecular(Vec4(1,1,1,1))
m.setShininess(96)
self.ball.setMaterial(m,1)
def __init__(self):
#try:
#if(co == 0):
ShowBase.__init__(self)
# co += 1
self.disableMouse()
base.setBackgroundColor(0, 0, 1)
#camera.setPosHpr(45, -45, 45, 45, -45, 45)
self.accept("escape", sys.exit) # Escape quits
# Disable default mouse-based camera control. This is a method on the
# ShowBase class from which we inherit.
#self.disableMouse()
camera.setPosHpr(-10, -50, 10, -10, -7, 0)
#camera.setPosHpr(-50, 40, 0, 270, 0, 0)
#base.setBackgroundColor(0,1,0)
#base
net = loader.loadModel("models/drawnNet")
net.setColor(1, 1, 0)
net.setScale(2.5, 2.5, 1.5)
net.setPosHpr(0, 53, -2, 0, -10, 0)
net.reparentTo(render)
global targetY
targetY = 40
postR = loader.loadModel("models/box")
postR.setColor(0.75, 0, 0.25)
postR.setScale(0.03, 0.03, 1)
LidR = postR.find('**/lid')
PandaR = postR.find('**/turningthing')
HingeNodeR = postR.find('**/box').attachNewNode('nHingeNode')
HingeNodeR.setPos(.8659, 6.5, 5.4)
LidR.wrtReparentTo(HingeNodeR)
HingeNodeR.setHpr(0, 90, 0)
lidCloseR = Parallel(
LerpHprInterval(HingeNodeR, 2.0, (0, 90, 0),
blendType='easeInOut'))
postR.setPosHpr(18, 55.5, -2, 0, 0, 0)
postR.reparentTo(render)
postGR = loader.loadModel("models/box")
postGR.setColor(0.75, 0, 0.25)
postGR.setScale(0.03, 0.03, 1)
lidGR = postGR.find('**/lid')
PandaGR = postGR.find('**/turningthing')
HingeNodeGR = postGR.find('**/box').attachNewNode('nHingeNode')
HingeNodeGR.setPos(.8659, 6.5, 5.4)
#lidGR.wrtReparentTo(HingeNodeR)
HingeNodeGR.setHpr(0, 90, 0)
lidCloseGR = Parallel(
LerpHprInterval(HingeNodeGR,
2.0, (0, 90, 0),
blendType='easeInOut'))
postGR.setPosHpr(18, 58.5, -4, 90, 0, 90)
postGR.reparentTo(render)
postL = loader.loadModel("models/box")
postL.setColor(0.75, 0, 0.25)
postL.setScale(0.03, 0.03, 2)
LidL = postL.find('**/lid')
PandaL = postL.find('**/turningthing')
HingeNodeL = postL.find('**/box').attachNewNode('nHingeNode')
HingeNodeL.setPos(.8659, 6.5, 5.4)
LidL.wrtReparentTo(HingeNodeL)
HingeNodeL.setHpr(0, 90, 0)
lidCloseL = Parallel(
LerpHprInterval(HingeNodeL, 2.0, (90, 0, 0),
blendType='easeInOut'))
postL.setPosHpr(-18, 55.5, -1, 0, 0, 0)
postL.reparentTo(render)
postGL = loader.loadModel("models/box")
postGL.setColor(0.75, 0, 0.25)
postGL.setScale(0.03, 0.03, 1)
lidGL = postGL.find('**/lid')
PandaGL = postGL.find('**/turningthing')
HingeNodeGL = postGL.find('**/box').attachNewNode('nHingeNode')
HingeNodeGL.setPos(.8659, 6.5, 5.4)
#lidGR.wrtReparentTo(HingeNodeR)
HingeNodeGL.setHpr(0, 90, 0)
lidCloseGL = Parallel(
LerpHprInterval(HingeNodeGL,
2.0, (0, 90, 0),
blendType='easeInOut'))
postGL.setPosHpr(-18, 58.5, -4.5, 90, 0, 90)
postGL.reparentTo(render)
#camera.setPosHpr(20, 45, 0, 90, 0, 0)
postT = loader.loadModel("models/box")
postT.setColor(0.75, 0, 0.25)
postT.setScale(1.70, 0.03, 0.03)
LidT = postL.find('**/lid')
PandaT = postT.find('**/turningthing')
HingeNodeT = postT.find('**/box').attachNewNode('nHingeNode')
HingeNodeT.setPos(.8659, 6.5, 5.4)
LidT.wrtReparentTo(HingeNodeT)
HingeNodeT.setHpr(0, 90, 0)
lidCloseT = Parallel(
LerpHprInterval(HingeNodeT, 2.0, (0, 90, 0),
blendType='easeInOut'))
postT.setPosHpr(0, 55.5, 9.8, 0, 0, 0)
postT.reparentTo(render)
global ball
ballRoot = render.attachNewNode("ballRoot")
ball = loader.loadModel("models/ball")
ball.reparentTo(ballRoot)
#ball.setColor(0.5, 0, 1)
ball.setScale(6, 6, 6)
ball.setPosHpr(0, -12, -3, 0, -20, 0)
#self.kick.setPos(0, 40, 0)
ballTex = loader.loadTexture("pictures/ball.jpg")
ball.setTexture(ballTex)
ball.reparentTo(render)
ballSphere = ball.find("**/ball")
ballSphere.node().setFromCollideMask(BitMask32.bit(0))
ballSphere.node().setIntoCollideMask(BitMask32.allOff())
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.55, .55, .55, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(LVector3(0, 0, -1))
directionalLight.setColor((0.375, 0.375, 0.375, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
ballRoot.setLight(render.attachNewNode(ambientLight))
ballRoot.setLight(render.attachNewNode(directionalLight))
m = Material()
m.setSpecular((1, 1, 1, 1))
m.setShininess(96)
ball.setMaterial(m, 1)
cs = CollisionSphere(0, 0, 0, 0.41)
cNodePath = ball.attachNewNode(CollisionNode('cnode'))
cNodePath.node().addSolid(cs)
#cNodePath.show()
#0, 53, -2
cW = CollisionPolygon(Point3(-1, 40, -4), Point3(-1, 40, 8),
Point3(1, 40, 8), Point3(1, 40, -4))
cwNodePath = net.attachNewNode(CollisionNode('cwnode'))
cwNodePath.node().addSolid(cW)
#cwNodePath.show()
#queue = CollisionHandlerQueue()
#traverser.addCollider(cs, queue)
#traverser.traverse(render)
ground = loader.loadModel("models/square")
ground.setPosHpr(0, 35, -5, 0, 0, 0)
ground.setScale(120, 120, 120)
#ground.setColor(0.2, 1, 0)
grass = loader.loadTexture("pictures/grass_1.jpg")
ground.setTexture(grass)
ground.reparentTo(render)
wall = loader.loadModel("models/square")
wall.setPosHpr(5, 100, 18, 0, 90, 0)
wall.setScale(90, 50, 75)
#camera.setPos(0, -150, 0)
#wall.setColor(0.5, 0.5, 0.5)
crowd = loader.loadTexture("pictures/crowd.png")
wall.setTexture(crowd)
wall.reparentTo(render)
rightWall = loader.loadModel("models/square")
rightWall.setPosHpr(48, 45, 0, -90, 90, 0)
rightWall.setScale(100, 100, 100)
rightWall.setColor(0.75, 0.75, 0.75)
rightWall.reparentTo(render)
global angle
angle = loader.loadModel("models/box")
angle.setColor(0.25, 0.25, 0.25)
angle.setScale(1.0, 0.25, 0.03)
LidA = angle.find('**/lid')
PandaA = angle.find('**/turningthing')
HingeNodeA = angle.find('**/box').attachNewNode('nHingeNode')
HingeNodeA.setPos(.8659, 6.5, 5.4)
LidA.wrtReparentTo(HingeNodeA)
HingeNodeA.setHpr(0, 90, 0)
lidCloseA = Parallel(
LerpHprInterval(HingeNodeA, 2.0, (0, 90, 0),
blendType='easeInOut'))
angle.setPosHpr(0, 10.5, -3, 0, 90, 0)
#bar = loader.loadTexture("pictures/bar.png")
#angle.setTexture(bar)
angle.reparentTo(render)
global angleD
angleD = loader.loadModel("models/box")
angleD.setColor(0, 0, 1)
angleD.setScale(0.1, 0.25, 0.03)
LidD = angleD.find('**/lid')
PandaD = angleD.find('**/turningthing')
HingeNodeD = angleD.find('**/box').attachNewNode('nHingeNode')
HingeNodeD.setPos(.8659, 6.5, 5.4)
LidD.wrtReparentTo(HingeNodeD)
HingeNodeD.setHpr(0, 90, 0)
lidCloseD = Parallel(
LerpHprInterval(HingeNodeD, 2.0, (0, 90, 0),
blendType='easeInOut'))
angleD.setPosHpr(0, 10.4, -3, 0, 90, 0)
angleD.reparentTo(render)
global power
power = loader.loadModel("models/box")
power.setColor(0.25, 0.25, 0.25)
power.setScale(0.12, 2.2, 0.03)
LidP = power.find('**/lid')
PandaP = power.find('**/turningthing')
HingeNodeP = power.find('**/box').attachNewNode('nHingeNode')
HingeNodeP.setPos(.8659, 6.5, 5.4)
LidP.wrtReparentTo(HingeNodeP)
HingeNodeP.setHpr(0, 90, 0)
lidCloseP = Parallel(
LerpHprInterval(HingeNodeP, 2.0, (0, 90, 0),
blendType='easeInOut'))
power.setPosHpr(-18, 10.5, -3, 0, 90, 0)
global powerD
powerD = loader.loadModel("models/box")
powerD.setColor(1, 0, 0)
powerD.setScale(0.12, 0.05, 0.03)
LidD = power.find('**/lid')
PandaD = power.find('**/turningthing')
HingeNodeD = power.find('**/box').attachNewNode('nHingeNode')
HingeNodeD.setPos(.8659, 6.5, 5.4)
LidD.wrtReparentTo(HingeNodeD)
HingeNodeD.setHpr(0, 90, 0)
lidCloseD = Parallel(
LerpHprInterval(HingeNodeD, 2.0, (0, 90, 0),
blendType='easeInOut'))
powerD.setPosHpr(-18, 10, -4.5, 0, 50, 0)
global bishop
bishop = loader.loadModel("models/bishop")
bs = loader.loadTexture("pictures/bishop.png")
bishop.setTexture(bs)
bishop.setScale(10, 10, 10)
#bishop.setColor(0, 0.4, 1)
bishop.setPosHpr(0, 42, -5, 90, 0, 0)
bishop.reparentTo(render)
global bArmL
bArmL = loader.loadModel("models/bishop")
bArmL.setScale(2, 2, 4)
bishop.setTexture(bs)
#bArmL.setColor(0, 0.4, 1)
bArmL.setPos(-1, 55, 6)
#bArmL.reparentTo(render)
global bArmR
bArmR = loader.loadModel("models/bishop")
bArmR.setScale(2, 2, 4)
bishop.setTexture(bs)
#bArmR.setColor(0, 0.4, 1)
bArmR.setPos(1, 55, 6)
#bArmR.reparentTo(render)
global start
start = loader.loadModel("models/square")
start.setPosHpr(5, -25, 18, 0, 90, 0)
start.setScale(90, 50, 75)
#camera.setPos(0, -150, 0)
start.setColor(0.5, 0.5, 0.5)
#crowd = loader.loadTexture("pictures/crowd.png")
#start.setTexture(crowd)
start.reparentTo(render)
title = TextNode('title')
title.setText("Welcome to Penalty Kick!")
global textNodePath
textNodePath = aspect2d.attachNewNode(title)
textNodePath.setScale(0.25)
title.setWordwrap(8)
title.setCardColor(0, 0, 0, 0)
title.setCardAsMargin(0, 0, 0, 0)
title.setCardDecal(True)
textNodePath.setPos(-0.75, 0, 0.5)
self.instructions = \
OnscreenText(text="Press any key to begin",
parent=base.a2dBottomRight, align=TextNode.ARight,
pos=(-1, +0.08), fg=(1, 1, 1, 1), scale=.06,
shadow=(0, 0, 0, 0.5))
#self.accept('ball-into-net', ballCollideHandler)
base.buttonThrowers[0].node().setKeystrokeEvent('keystroke')
self.accept('keystroke', self.next)
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
# Set the background color to black
self.win.setClearColor((0, 0, 0, 1))
# Post the instructions
self.title = addTitle(
"Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)")
self.inst1 = addInstructions(0.06, "[ESC]: Quit")
self.inst2 = addInstructions(0.12, "[Left trackpad]: Rotate Left")
self.inst3 = addInstructions(0.18, "[Right trackpad]: Rotate Right")
self.inst4 = addInstructions(0.24, "[Up trackpad]: Walk Forward")
self.inst4 = addInstructions(0.30, "[Down trackpad]: Walk Backward")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
# Create the main character, Ralph
self.vr = RoamingRalphVR()
self.vr.init(msaa=4)
self.ralph = render.attachNewNode('ralph')
self.ralphStartPos = self.environ.find("**/start_point").getPos()
self.vr.tracking_space.setPos(self.ralphStartPos)
self.ralph.setPos(self.vr.hmd_anchor.getPos(render))
self.accept("escape", sys.exit)
taskMgr.add(self.collision, "collisionTask")
# Set up the camera
self.disableMouse()
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 9)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(CollideMask.bit(0))
self.ralphGroundCol.setIntoCollideMask(CollideMask.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((-5, -5, -5))
directionalLight.setColor((1, 1, 1, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
self.keyMap = {"left":0, "right":0, "forward":0, "cam-left":0, "cam-right":0}
base.win.setClearColor(Vec4(0,0,0,1))
self.speed = 0
self.font_digital = loader.loadFont('font/SFDigitalReadout-Heavy.ttf')
# Speedometer
self.speed_img = OnscreenImage(image="models/speedometer.png", scale=.5, pos=(1.1, 0, -.95))
self.speed_img.setTransparency(TransparencyAttrib.MAlpha)
OnscreenText(text="km\n/h", style=1, fg=(1, 1, 1, 1),
font=self.font_digital, scale=.07, pos=(1.25, -.92))
# Display Speed
self.display_speed = OnscreenText(text=str(self.speed), style=1, fg=(1, 1, 1, 1),
pos=(1.3, -0.95), align=TextNode.ARight, scale=.07, font=self.font_digital)
# Health Bar
self.bars = {'H' : 100, 'EH' : 0 ,'A' : 0 }
# bk_text = "This is my Demo"
# self.textObject = OnscreenText(text = bk_text, pos = (0.55,-0.05),scale = 0.07,fg=(1,0.5,0.5,1),align=TextNode.ACenter,mayChange=1)
self.Health_bar = DirectWaitBar(text = "", value = 100, pos = (0.280,0,0.475), barColor= (1,0,0,1), frameSize = (0,.705,.3,.35))
self.EHealth_bar = DirectWaitBar(text = "", value = 0, pos = (1,0,0.475), barColor= (0,1,0,1), frameSize = (0,.23,.3,.35),range = 50 )
self.Armour_bar = DirectWaitBar(text = "", value = 0, pos = (.43,0,.593), barColor= (159,0,255,1), frameSize = (0,.8,.3,.35))
self.Health = DirectWaitBar(text = "", value = 100, barColor= (1,0,0,1), frameSize = (-1,1,.3,.5),scale = 2)
# create a frame
# myFrame = DirectFrame(frameColor=(1, 0, 0, 1),
# frameSize=(0, .8, 0, .2))
# self.bar = DirectWaitBar(text = "hi",
# value = 0,
# range = 500,
# pos = ( 0,0,0),
# barColor = (0.97,0,0,1),
# frameSize = (-0.3,0.3,0.5,0.8),
# text_mayChange = 1,
# text_shadow =(0,0,0,0.8),
# text_fg = (0.9,0.9,0.9,1),
# text_scale = 0.025,
# text_pos = (0,0.01,0))
def getHealthStatus() :
return self.bars
def displayBars() :
health = getHealthStatus()
self.Health_bar['value'] = health['H']
self.EHealth_bar['value'] = health['EH']
self.Armour_bar['value'] = health['A']
self.Health['value'] = health['H']
def armourPickup() :
self.bars['A'] += 25
displayBars()
def healthPickup() :
self.bars['EH'] += 25
displayBars()
def decHealth() :
self.bars['H'] -= 10
displayBars()
def initialiseSound(audioManager):
"""Start the engine sound and set collision sounds"""
# Set sounds to play for collisions
# self.collisionSound = CollisionSound(
# nodePath=self.np,
# sounds=["data/sounds/09.wav"],
# thresholdForce=600.0,
# maxForce=800000.0)
# np - nodePath
self.engineSound = audioManager.loadSfx("sound/engine.wav")
audioManager.attachSoundToObject(self.engineSound, self.ralph)
self.engineSound.setLoop(True)
self.engineSound.setPlayRate(0.6)
self.engineSound.play()
# self.gearSpacing = (self.specs["sound"]["maxExpectedRotationRate"] /
# self.specs["sound"]["numberOfGears"])
self.gearSpacing = (150 / 4)
self.reversing = False
# Post the instructions
self.frame = OnscreenImage(image = "models/gframe.png", pos = (0,0,0), scale = (1.25, 1, 1) )
self.frame.setTransparency(TransparencyAttrib.MAlpha)
# self.title = addTitle("Panda3D Tutorial: Roaming Ralph (Walking on the Moon)")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.85, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.80, "[Up Arrow]: Run Ralph Forward")
self.inst6 = addInstructions(0.70, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.65, "[S]: Rotate Camera Right")
# Set up the environment
#
self.environ = loader.loadModel("models/square")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
self.environ.setScale(100,100,1)
self.moon_tex = loader.loadTexture("models/moon_1k_tex.jpg")
self.environ.setTexture(self.moon_tex, 1)
# Create the main character, Ralph
self.ralph = Actor("models/ralph",
{"run":"models/ralph-run",
"walk":"models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(0,0,0)
# # Load and place the model
# self.eNode = render.attachNewNode('enemyBaseNode')
# self.eNode.setPos( 0,0,0 )
# self.model = loader.loadModel( 'models/ralph' )
# self.model.reparentTo( self.eNode )
# # Setup the rest of what the enemy needs
# self.setupHealthBar()
# self.Health.setBillboardAxis()
# self.Health.setBillboardPointWorld()
# self.Health.setBillboardPointEye()
# self.Health.setLightOff()
self.Health.setPos(0, 0, 5)
self.Health.setBillboardPointEye()
self.Health.setBin('fixed', 0)
self.Health.setDepthWrite(False)
self.Health.reparentTo(self.ralph)
# myFrame.setPos(0, 0, 8)
# myFrame.setBillboardPointEye()
# myFrame.reparentTo(self.ralph)
# self.Health.clearBillboard()
# 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)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left",1])
self.accept("arrow_right", self.setKey, ["right",1])
self.accept("arrow_up", self.setKey, ["forward",1])
self.accept("a", self.setKey, ["cam-left",1])
self.accept("s", self.setKey, ["cam-right",1])
self.accept("arrow_left-up", self.setKey, ["left",0])
self.accept("arrow_right-up", self.setKey, ["right",0])
self.accept("arrow_up-up", self.setKey, ["forward",0])
self.accept("a-up", self.setKey, ["cam-left",0])
self.accept("s-up", self.setKey, ["cam-right",0])
self.accept("h", decHealth)
self.accept("j", healthPickup)
self.accept("k", armourPickup)
taskMgr.add(self.move,"moveTask")
taskMgr.doMethodLater(.1, self.show_speed, 'updateSpeed')
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.ralph.getX(),self.ralph.getY()+10,2)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
# Create an audio manager. This is attached to the camera for
# player 1, so sounds close to other players might not be very
# loud
self.audioManager = Audio3DManager.Audio3DManager(base.sfxManagerList[0],base.camera)
# Distance should be in m, not feet
self.audioManager.setDistanceFactor(3.28084)
initialiseSound(self.audioManager)
displayBars()
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
# This is used to store which keys are currently pressed.
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"cam-left": 0,
"cam-right": 0,
}
###########################################################################
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
# We do not have a skybox, so we will just use a sky blue background color
#self.setBackgroundColor(0.53, 0.80, 0.92, 1)
self.setBackgroundColor(.1, .1, .1, 1)
# Create the main character, person
#personStartPos = self.environ.find("**/start_point").getPos()
#self.person = Actor("models/panda",
# {"run": "models/panda-walk",
# "walk": "models/panda-walk"})
person2StartPos = self.environ.find("**/start_point").getPos()
self.person2 = Actor("models/passenger_penguin",
{"run": "models/passenger_penguin",
"walk": "models/passenger_penguin"})
self.person2.reparentTo(render)
self.person2.setScale(.1)
self.person2.setPos(person2StartPos + (px, py, 1))
person3StartPos = self.environ.find("**/start_point").getPos()
self.person3 = Actor("models/MagicBunny",
{"run": "models/MagicBunny",
"walk": "models/MagicBunny"})
#px = random.randint(-1,1)
#py = random.randint(-1,1)
self.person3.reparentTo(render)
self.person3.setScale(.04)
#self.person.setPos(personStartPos + (0, 0, 2))
self.person3.setPos(person3StartPos + (px/1.5+3, py/2, 0))
personStartPos = self.environ.find("**/start_point").getPos()
self.person = Actor("models/panda",
{"run": "models/panda-walk",
"walk": "models/panda-walk"})
self.person.reparentTo(render)
self.person.setScale(.1)
self.person.setPos(personStartPos + (0, 0, 1.5))
self.person.loop("run")
arenaStartPos = self.environ.find("**/start_point").getPos()
self.arena = Actor("models/FarmHouse")
self.arena.reparentTo(render)
self.arena.setScale(.1)
self.arena.setPos(arenaStartPos + (-1, 0, 0))
arena2StartPos = self.environ.find("**/start_point").getPos()
self.arena2 = Actor("models/fence")
self.arena2.reparentTo(render)
self.arena2.setScale(5.9)
self.arena.setPos(arenaStartPos + (px, py-12, 1))
self.arena2.setPos(arenaStartPos + (8, 5, -1))
arena2StartPos = self.environ.find("**/start_point").getPos()
self.arena3 = Actor("models/gate")
self.arena3.reparentTo(render)
self.arena3.setScale(.01)
self.arena3.setPos(arenaStartPos + (px/2+random.randint(12,15), py/2, -1))
self.arena4 = Actor("models/FarmHouse")
self.arena4.reparentTo(render)
self.arena4.setScale(.1)
self.arena4.setPos(arenaStartPos + (px/3-random.randint(18,22), py/3, -1))
self.arena5 = Actor("models/gate")
self.arena5.reparentTo(render)
self.arena5.setScale(.008)
self.arena5.setPos(arenaStartPos + (px/1.2-9, py/1.2, -1))
#####################################################################################################################################
base.enableParticles()
self.t = loader.loadModel("teapot") # for the particle enhancer
self.t.setScale(10)
self.t.setPos(-10, -20, -1)
self.t.reparentTo(render)
#self.setupLights()
self.p = ParticleEffect()
self.p.setScale(1000)
self.loadParticleConfig('smoke.ptf') # looks like a storm at night
self.p.setScale(20)
#################################################3
# Create a floater object, which floats 2 units above person. We
# use this as a target for the camera to look at.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.person)
self.floater.setZ(2.0)
# Accept the control keys for movement and rotation
taskMgr.add(self.move, "moveTask")
# Set up the camera
self.disableMouse()
self.camera.setPos(self.person.getX(), self.person.getY() + 10, 2)
self.cTrav = CollisionTraverser()
self.personCol = CollisionNode('person')
self.personCol.addSolid(CollisionSphere(center=(0, 0, 2), radius=1.5))
self.personCol.addSolid(CollisionSphere(center=(0, -0.25, 4), radius=1.5))
self.personCol.setFromCollideMask(CollideMask.bit(0))
self.personCol.setIntoCollideMask(CollideMask.allOff())
self.personColNp = self.person.attachNewNode(self.personCol)
self.personPusher = CollisionHandlerPusher()
self.personPusher.horizontal = True
self.personPusher.addCollider(self.personColNp, self.person)
self.cTrav.addCollider(self.personColNp, self.personPusher)
self.personGroundRay = CollisionRay()
self.personGroundRay.setOrigin(0, 0, 9)
self.personGroundRay.setDirection(0, 0, -1)
self.personGroundCol = CollisionNode('personRay')
self.personGroundCol.addSolid(self.personGroundRay)
self.personGroundCol.setFromCollideMask(CollideMask.bit(0))
self.personGroundCol.setIntoCollideMask(CollideMask.allOff())
self.personGroundColNp = self.person.attachNewNode(self.personGroundCol)
self.personGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.personGroundColNp, self.personGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 9)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(CollideMask.bit(0))
self.camGroundCol.setIntoCollideMask(CollideMask.allOff())
self.camGroundColNp = self.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.3, .3, .3, .2))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((-5, -5, -5))
directionalLight.setColor((.2, .2, .2, 1))
directionalLight.setSpecularColor((.1, .1, .1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
self.startvar = 0
self.startdialog = YesNoDialog(dialogName="START GAME",
text="START GAME",
command=self.endbox)
self.timepass = model()
self.timepass1 = model1()
self.keyMap = {"left": 0, "right": 0, "forward": 0, "backward": 0}
base.win.setClearColor(Vec4(0, 0, 0, 1))
# number of collectibles
self.numObjects = 0
#music
self.backmusic = base.loader.loadSfx("sounds/tales.mp3")
self.backmusic.setLoop(True)
self.backmusic.setVolume(0.2)
self.backmusic.play()
self.skatemusic = base.loader.loadSfx("sounds/skate.mp3")
self.skatemusic.setVolume(.65)
self.skatemusic.setLoop(True)
self.bombmusic = base.loader.loadSfx("sounds/bomb.mp3")
self.bombmusic.setVolume(.85)
self.springmusic = base.loader.loadSfx("sounds/spring.mp3")
self.springmusic.setVolume(.65)
self.springmusic.setLoop(True)
self.colmusic = base.loader.loadSfx("sounds/collect.mp3")
self.colmusic.setVolume(.65)
# print the number of objects
printNumObj(self.numObjects)
# Post the instructions
# self.title = addTitle("Roaming Ralph (Edited by Adam Gressen)")
# self.inst1 = addInstructions(0.95, "[ESC]: Quit")
# self.inst2 = addInstructions(0.90, "[A]: Rotate Ralph Left")
# self.inst3 = addInstructions(0.85, "[D]: Rotate Ralph Right")
# self.inst4 = addInstructions(0.80, "[W]: Run Ralph Forward")
# self.inst5 = addInstructions(0.75, "[S]: Run Ralph Backward")
# self.inst6 = addInstructions(0.70, "[Space]: Run, Ralph, Run")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0, 0, 0)
# Timer to increment in the move task
self.time = 0
# Get bounds of environment
min, max = self.environ.getTightBounds()
self.mapSize = max - min
# Create the main character, Ralph
self.ralphStartPos = self.environ.find("**/start_point").getPos()
self.ralph = Actor(
"models/ralph", {
"run": "models/ralph-run",
"jump": "models/ralph-jump",
"walk": "models/ralph-walk"
})
self.ralph.reparentTo(render)
self.ralph.setScale(.30)
self.ralph.setPos(self.ralphStartPos)
#skate
self.skate = loader.loadModel("models/Skateboard")
self.skate.reparentTo(render)
self.skate.setScale(.02)
self.skate.setPos(-random.randint(38, 50), -random.randint(15, 37),
-0.015)
# ralph's health
self.health = 100
#spring
self.spring = loader.loadModel("models/spring")
self.spring.reparentTo(render)
self.spring.setScale(.8)
self.spring.setPos(-random.randint(72, 78), -random.randint(10, 15),
6.715)
# ralph's stamina
self.stamina = 100
# 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)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
# these don't work well in combination with the space bar
self.accept("arrow_left", self.setKey, ["left", 1])
self.accept("arrow_right", self.setKey, ["right", 1])
self.accept("arrow_up", self.setKey, ["forward", 1])
self.accept("arrow_down", self.setKey, ["backward", 1])
self.accept("arrow_left-up", self.setKey, ["left", 0])
self.accept("arrow_right-up", self.setKey, ["right", 0])
self.accept("arrow_up-up", self.setKey, ["forward", 0])
self.accept("arrow_down-up", self.setKey, ["backward", 0])
self.accept("a", self.setKey, ["left", 1])
self.accept("d", self.setKey, ["right", 1])
self.accept("w", self.setKey, ["forward", 1])
self.accept("s", self.setKey, ["backward", 1])
self.accept("a-up", self.setKey, ["left", 0])
self.accept("d-up", self.setKey, ["right", 0])
self.accept("w-up", self.setKey, ["forward", 0])
self.accept("s-up", self.setKey, ["backward", 0])
# Game state variables
self.isMoving = False
self.isRunning = False
self.onboard = 0
self.boardtime = 0
self.onspring = 0
self.isjumping = False
# Set up the camera
base.disableMouse()
#base.camera.setPos(self.ralph.getX(),self.ralph.getY()+10,2)
base.camera.setPos(0, 0, 0)
base.camera.reparentTo(self.ralph)
base.camera.setPos(0, 40, 2)
base.camera.lookAt(self.ralph)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
base.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 300)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
base.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
# camera ground collision handler
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 300)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
base.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Place the health items
self.placeHealthItems()
# Place the collectibles
self.placeCollectibles()
# Place the bomb
self.placebombItems()
# Uncomment this line to show a visual representation of the
# collisions occuring
#base.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
#print self.startvar
taskMgr.add(self.move, "moveTask")
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
# Set the background color to black
self.win.setClearColor((0, 0, 0, 1))
# This is used to store which keys are currently pressed.
self.keyMap = {
"left": 0, "right": 0, "forward": 0, "cam-left": 0, "cam-right": 0}
# Post the instructions
self.title = addTitle(
"Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)")
self.inst1 = addInstructions(0.06, "[ESC]: Quit")
self.inst2 = addInstructions(0.12, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.18, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.24, "[Up Arrow]: Run Ralph Forward")
self.inst6 = addInstructions(0.30, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.36, "[S]: Rotate Camera Right")
self.dirText = addInstructions(0.42, "pos")
self.anglesText = addInstructions(0.48, "angle")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
#self.environ = loader.loadModel("models/world")
#self.environ.reparentTo(render)
self.createArm()
# Create the main character, Ralph
#ralphStartPos = self.environ.find("**/start_point").getPos()
self.ralph = Actor("models/ralph",
{"run": "models/ralph-run",
"walk": "models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
#self.ralph.setPos(ralphStartPos + (0, 0, 0.5))
# Create a floater object, which floats 2 units above ralph. We
# use this as a target for the camera to look at.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.ralph)
self.floater.setZ(2.0)
# Accept the control keys for movement and rotation
self.accept("escape", self.exitButton)
self.accept("arrow_left", self.setKey, ["left", True])
self.accept("arrow_right", self.setKey, ["right", True])
self.accept("arrow_up", self.setKey, ["forward", True])
self.accept("a", self.setKey, ["cam-left", True])
self.accept("s", self.setKey, ["cam-right", True])
self.accept("arrow_left-up", self.setKey, ["left", False])
self.accept("arrow_right-up", self.setKey, ["right", False])
self.accept("arrow_up-up", self.setKey, ["forward", False])
self.accept("a-up", self.setKey, ["cam-left", False])
self.accept("s-up", self.setKey, ["cam-right", False])
taskMgr.add(self.move, "moveTask")
# Game state variables
self.isMoving = False
# Set up the camera
self.disableMouse()
self.camera.setPos(15, 0, 3)#self.ralph.getX(), self.ralph.getY() + 10, 2)
self.camera.setHpr(90, -5, 0)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 9)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(CollideMask.bit(0))
self.ralphGroundCol.setIntoCollideMask(CollideMask.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 9)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(CollideMask.bit(0))
self.camGroundCol.setIntoCollideMask(CollideMask.allOff())
self.camGroundColNp = self.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((-5, -5, -5))
directionalLight.setColor((1, 1, 1, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"cam-left": 0,
"cam-right": 0
}
base.win.setClearColor(Vec4(0, 0, 0, 1))
self.speed = 0
self.font_digital = loader.loadFont('font/SFDigitalReadout-Heavy.ttf')
# Speedometer
self.speed_img = OnscreenImage(image="models/speedometer.png",
scale=.5,
pos=(1.1, 0, -.95))
self.speed_img.setTransparency(TransparencyAttrib.MAlpha)
OnscreenText(text="km\n/h",
style=1,
fg=(1, 1, 1, 1),
font=self.font_digital,
scale=.07,
pos=(1.25, -.92))
# Display Speed
self.display_speed = OnscreenText(text=str(self.speed),
style=1,
fg=(1, 1, 1, 1),
pos=(1.3, -0.95),
align=TextNode.ARight,
scale=.07,
font=self.font_digital)
# Health Bar
self.bars = {'H': 100, 'EH': 0, 'A': 0}
# bk_text = "This is my Demo"
# self.textObject = OnscreenText(text = bk_text, pos = (0.55,-0.05),scale = 0.07,fg=(1,0.5,0.5,1),align=TextNode.ACenter,mayChange=1)
self.Health_bar = DirectWaitBar(text="",
value=100,
pos=(0.280, 0, 0.475),
barColor=(1, 0, 0, 1),
frameSize=(0, .705, .3, .35))
self.EHealth_bar = DirectWaitBar(text="",
value=0,
pos=(1, 0, 0.475),
barColor=(0, 1, 0, 1),
frameSize=(0, .23, .3, .35),
range=50)
self.Armour_bar = DirectWaitBar(text="",
value=0,
pos=(.43, 0, .593),
barColor=(159, 0, 255, 1),
frameSize=(0, .8, .3, .35))
# self.bar = DirectWaitBar(text = "hi",
# value = 0,
# range = 500,
# pos = ( 0,0,0),
# barColor = (0.97,0,0,1),
# frameSize = (-0.3,0.3,0.5,0.8),
# text_mayChange = 1,
# text_shadow =(0,0,0,0.8),
# text_fg = (0.9,0.9,0.9,1),
# text_scale = 0.025,
# text_pos = (0,0.01,0))
def getHealthStatus():
return self.bars
def displayBars():
health = getHealthStatus()
self.Health_bar['value'] = health['H']
self.EHealth_bar['value'] = health['EH']
self.Armour_bar['value'] = health['A']
def armourPickup():
self.bars['A'] += 25
displayBars()
def healthPickup():
self.bars['EH'] += 25
displayBars()
def decHealth():
self.bars['H'] -= 10
displayBars()
# Post the instructions
self.frame = OnscreenImage(image="models/gframe.png",
pos=(0, 0, 0),
scale=(1.25, 1, 1))
self.frame.setTransparency(TransparencyAttrib.MAlpha)
# self.title = addTitle("Panda3D Tutorial: Roaming Ralph (Walking on the Moon)")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.85, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.80, "[Up Arrow]: Run Ralph Forward")
self.inst6 = addInstructions(0.70, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.65, "[S]: Rotate Camera Right")
# Set up the environment
#
self.environ = loader.loadModel("models/square")
self.environ.reparentTo(render)
self.environ.setPos(0, 0, 0)
self.environ.setScale(100, 100, 1)
self.moon_tex = loader.loadTexture("models/moon_1k_tex.jpg")
self.environ.setTexture(self.moon_tex, 1)
# Create the main character, Ralph
self.ralph = Actor("models/ralph", {
"run": "models/ralph-run",
"walk": "models/ralph-walk"
})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(0, 0, 0)
# 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)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left", 1])
self.accept("arrow_right", self.setKey, ["right", 1])
self.accept("arrow_up", self.setKey, ["forward", 1])
self.accept("a", self.setKey, ["cam-left", 1])
self.accept("s", self.setKey, ["cam-right", 1])
self.accept("arrow_left-up", self.setKey, ["left", 0])
self.accept("arrow_right-up", self.setKey, ["right", 0])
self.accept("arrow_up-up", self.setKey, ["forward", 0])
self.accept("a-up", self.setKey, ["cam-left", 0])
self.accept("s-up", self.setKey, ["cam-right", 0])
self.accept("h", decHealth)
self.accept("j", healthPickup)
self.accept("k", armourPickup)
taskMgr.add(self.move, "moveTask")
taskMgr.doMethodLater(.1, self.show_speed, 'updateSpeed')
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
self.audioManager = Audio(self)
self.audioManager.startAudioManager()
self.audioManager.initialiseSound(self.ralph)
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
base.render.setAttrib(LightRampAttrib.makeHdr0())
# Configure depth pre-pass
prepass_pass = lionrender.DepthScenePass()
# Configure scene pass
scene_fb_props = FrameBufferProperties()
scene_fb_props.set_rgb_color(True)
scene_fb_props.set_rgba_bits(8, 8, 8, 0)
scene_fb_props.set_depth_bits(32)
scene_pass = lionrender.ScenePass(
frame_buffer_properties=scene_fb_props,
clear_color=LColor(0.53, 0.80, 0.92, 1),
share_depth_with=prepass_pass)
scene_pass.node_path.set_depth_write(False)
# Configure post processing
filter_pass = lionrender.FilterPass(fragment_path='shaders/fsq.frag')
filter_pass.node_path.set_shader_input('inputTexture',
scene_pass.output)
# Enable FXAA
fxaa_pass = lionrender.FxaaFilterPass()
fxaa_pass.node_path.set_shader_input('inputTexture',
filter_pass.output)
# Output result
fxaa_pass.output_to(render2d)
# This is used to store which keys are currently pressed.
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"cam-left": 0,
"cam-right": 0,
}
# Post the instructions
self.title = addTitle(
"Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)")
self.inst1 = addInstructions(0.06, "[ESC]: Quit")
self.inst2 = addInstructions(0.12, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.18, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.24, "[Up Arrow]: Run Ralph Forward")
self.inst5 = addInstructions(0.30, "[Down Arrow]: Walk Ralph Backward")
self.inst6 = addInstructions(0.36, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.42, "[S]: Rotate Camera Right")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
# We do not have a skybox, so we will just use a sky blue background color
self.setBackgroundColor(0.53, 0.80, 0.92, 1)
# Create the main character, Ralph
ralphStartPos = self.environ.find("**/start_point").getPos()
self.ralph = Actor("models/ralph", {
"run": "models/ralph-run",
"walk": "models/ralph-walk"
})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos + (0, 0, 1.5))
# Create a floater object, which floats 2 units above ralph. We
# use this as a target for the camera to look at.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.ralph)
self.floater.setZ(2.0)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left", True])
self.accept("arrow_right", self.setKey, ["right", True])
self.accept("arrow_up", self.setKey, ["forward", True])
self.accept("arrow_down", self.setKey, ["backward", True])
self.accept("a", self.setKey, ["cam-left", True])
self.accept("s", self.setKey, ["cam-right", True])
self.accept("arrow_left-up", self.setKey, ["left", False])
self.accept("arrow_right-up", self.setKey, ["right", False])
self.accept("arrow_up-up", self.setKey, ["forward", False])
self.accept("arrow_down-up", self.setKey, ["backward", False])
self.accept("a-up", self.setKey, ["cam-left", False])
self.accept("s-up", self.setKey, ["cam-right", False])
self.accept("v", self.toggleCards)
taskMgr.add(self.move, "moveTask")
# Set up the camera
self.disableMouse()
self.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2)
self.cTrav = CollisionTraverser()
# Use a CollisionHandlerPusher to handle collisions between Ralph and
# the environment. Ralph is added as a "from" object which will be
# "pushed" out of the environment if he walks into obstacles.
#
# Ralph is composed of two spheres, one around the torso and one
# around the head. They are slightly oversized since we want Ralph to
# keep some distance from obstacles.
self.ralphCol = CollisionNode('ralph')
self.ralphCol.addSolid(CollisionSphere(center=(0, 0, 2), radius=1.5))
self.ralphCol.addSolid(
CollisionSphere(center=(0, -0.25, 4), radius=1.5))
self.ralphCol.setFromCollideMask(CollideMask.bit(0))
self.ralphCol.setIntoCollideMask(CollideMask.allOff())
self.ralphColNp = self.ralph.attachNewNode(self.ralphCol)
self.ralphPusher = CollisionHandlerPusher()
self.ralphPusher.horizontal = True
# Note that we need to add ralph both to the pusher and to the
# traverser; the pusher needs to know which node to push back when a
# collision occurs!
self.ralphPusher.addCollider(self.ralphColNp, self.ralph)
self.cTrav.addCollider(self.ralphColNp, self.ralphPusher)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height.
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 9)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(CollideMask.bit(0))
self.ralphGroundCol.setIntoCollideMask(CollideMask.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 9)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(CollideMask.bit(0))
self.camGroundCol.setIntoCollideMask(CollideMask.allOff())
self.camGroundColNp = self.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((-5, -5, -5))
directionalLight.setColor((1, 1, 1, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
# Clean up texture attributes
for texture in self.render.find_all_textures():
texture.set_format(Texture.F_srgb)
def __init__(self):
ShowBase.__init__(self)
self.dirTypes = ['heading', 'pitch', 'roll']
self.dirType = 0
# Display instructions
add_title("Panda3D Tutorial: Portal Culling")
add_instructions(0.06, "[Esc]: Quit")
self.posText = add_instructions(0.12, "pos")
self.anglesText = add_instructions(0.18, "angle")
self.armHprText = add_instructions(0.24, "hpr")
self.dirText = add_instructions(.30, self.dirTypes[0])
self.forearmText = add_instructions(0.36, "angle")
self.baseText = add_instructions(0.42, "angle")
"""add_instructions(0.12, "[W]: Move Forward")
add_instructions(0.18, "[A]: Move Left")
add_instructions(0.24, "[S]: Move Right")
add_instructions(0.30, "[D]: Move Back")
add_instructions(0.36, "Arrow Keys: Look Around")
add_instructions(0.42, "[F]: Toggle Wireframe")
add_instructions(0.48, "[X]: Toggle X-Ray Mode")
add_instructions(0.54, "[B]: Toggle Bounding Volumes")"""
# Setup controls
self.keys = {}
for key in ['arrow_left', 'arrow_right', 'arrow_up', 'arrow_down',
'a', 'd', 'w', 's', 'q', 'e']:
self.keys[key] = 0
self.accept(key, self.push_key, [key, 1])
self.accept('shift-%s' % key, self.push_key, [key, 1])
self.accept('%s-up' % key, self.push_key, [key, 0])
self.accept("b", self.push_key, ["Rleft", True])
self.accept("b-up", self.push_key, ["Rleft", False])
self.accept("n", self.push_key, ["Rright", True])
self.accept("n-up", self.push_key, ["Rright", False])
self.accept("h", self.push_key, ["Rforward", True])
self.accept("h-up", self.push_key, ["Rforward", False])
self.keys['Rleft'] = self.keys['Rright'] = self.keys['Rforward'] = 0
self.accept('escape', self.exitButton)
self.accept('p', self.selectDir)
self.accept('[', self.incDir, [-15])
self.accept(']', self.incDir, [15])
#self.disableMouse()
# Setup camera
lens = PerspectiveLens()
lens.setFov(60)
lens.setNear(0.01)
lens.setFar(1000.0)
self.cam.node().setLens(lens)
self.camera.setPos(-50, 0, 0)
self.pitch = 0.0
self.heading = 0
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((-5, -5, -5))
directionalLight.setColor((1, 1, 1, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
# Load level geometry
self.level = self.loader.loadModel('models/theater')
self.level.reparentTo(self.render)
self.isMoving = False
self.ralph = Actor("models/ralph",
{"run": "models/ralph-run",
"walk": "models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.arms = []
idMap = {0:9, 1:11, 2:17, 3:27, 4:29}
for node in self.level.get_children():
if not node.getName().startswith('arm'): continue
arm = Actor("models/robotarm")
self.arms.append(arm)
arm.reparentTo(render)
arm.setName(node.getName())
arm.setPos(node.getPos())
arm.setHpr(node.getHpr())
#arm.setScale(.2)
tokens = node.getName().split('.')
try: id = int(tokens[1])
except: id = 0
arm.baseID = idMap[id]
arm.jointForearm = arm.controlJoint(None, "modelRoot", "forearm")
arm.jointBase = arm.controlJoint(None, "modelRoot", "base")
print node.getName(), str(node.getPos()), str(node.getHpr())
taskMgr.add(self.printLoc, "printLoc")
taskMgr.add(self.monitorArms, "robot arms")
self.taskMgr.add(self.update, 'main loop')
def __init__(self):
self.room = loader.loadModel("models/world")
self.room.reparentTo(render)
self.room.setShaderAuto()
#self.room.setScale(100,100,100)
self.character = loader.loadModel("assets/characters/knight")
self.character.reparentTo(render)
self.character.setPos(0, 0, 0)
self.character2 = loader.loadModel("assets/characters/king")
self.character2.reparentTo(render)
self.character2.setPos(0, 0, 0)
self.character2.setColor((1, 0, 0, 1))
base.camera.reparentTo(self.character)
base.camera.setPos(0, -50, 5)
base.camera.lookAt(self.character)
# Make the mouse invisible, turn off normal mouse controls
base.disableMouse()
props = WindowProperties()
#props.setCursorHidden(True)
base.win.requestProperties(props)
# Set the current viewing target
self.focus = Vec3(0, 0, 0)
self.heading = 0
self.pitch = 0
self.mousex = 0
self.mousey = 0
self.last = 0
self.keys = {
'move forward': False,
'move backward': False,
'strafe left': False,
'strafe right': False,
'zoom-out': False
}
# Start the camera control task:
taskMgr.add(self.controlCamera, "camera-task")
self.accept("escape", sys.exit, [0])
#Define a keymap for 'WASD' Movement
self.accept("w", self.setKeys, ['move forward', True])
self.accept("w-up", self.setKeys, ['move forward', False])
self.accept("s", self.setKeys, ['move backward', True])
self.accept("s-up", self.setKeys, ['move backward', False])
self.accept("a", self.setKeys, ['strafe left', True])
self.accept("a-up", self.setKeys, ['strafe left', False])
self.accept("d", self.setKeys, ['strafe right', True])
self.accept("d-up", self.setKeys, ['strafe right', False])
self.accept("q", self.setKeys, ['zoom-out', True])
self.accept("q-up", self.setKeys, ['zoom-out', False])
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((-5, -5, -5))
directionalLight.setColor((1, 1, 1, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
## Add the default values to the dictionary.
self.keyMap = {"left":0, "right":0, "forward":0, \
"boost":0, "strafeL":0, "strafeR":0, \
"cam-left":0, "cam-right":0}
base.win.setClearColor(Vec4(0,0,0,1))
self.jump = False
self.jumped = False
# Post the instructions
self.title = addTitle("Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.85, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.80, "[Up Arrow]: Run Ralph Forward")
self.inst6 = addInstructions(0.70, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.65, "[D]: Rotate Camera Right")
self.inst8 = addInstructions(0.60, "[B]: Ralph Boost")
self.inst9 = addInstructions(0.55, "[V]: Strafe Left")
self.inst10 = addInstructions(0.50, "[N]: Strafe Right")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
## Stops the sound as soon as the world renders
## Note:Sound won't play very long becasue the game takes seconds to compile and load
## Remove loading screen after world is rendered and ready to go.
loadingText.cleanup()
mySound.stop()
# Create the main character, Ralph
ralphStartPos = self.environ.find("**/start_point").getPos()
self.ralph = Actor("models/ralph",
{"run":"models/ralph-run",
"walk":"models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos)
# 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)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left",1])
self.accept("arrow_right", self.setKey, ["right",1])
self.accept("arrow_up", self.setKey, ["forward",1])
self.accept("a", self.setKey, ["cam-left",1])
self.accept("d", self.setKey, ["cam-right",1])
self.accept("b", self.setKey, ["boost",1])
self.accept("v", self.setKey, ["strafeL",1])
self.accept("n", self.setKey, ["strafeR",1])
## -up to signify what happens when you let go of the key
self.accept("b-up", self.setKey, ["boost",0])
self.accept("v-up", self.setKey, ["strafeL",0])
self.accept("n-up", self.setKey, ["strafeR",0])
self.accept("arrow_left-up", self.setKey, ["left",0])
self.accept("arrow_right-up", self.setKey, ["right",0])
self.accept("arrow_up-up", self.setKey, ["forward",0])
self.accept("a-up", self.setKey, ["cam-left",0])
self.accept("d-up", self.setKey, ["cam-right",0])
taskMgr.add(self.move,"moveTask")
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.ralph.getX(),self.ralph.getY()+10,2)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0,0,1000)
self.ralphGroundRay.setDirection(0,0,-1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,1000)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
base.enableParticles()
self.keyMap = {"left":0, "right":0, "forward":0,"backward":0,
"upward":0, "downward":0, "leftward":0,"rightward":0,
"cam-left":0, "cam-right":0}
_GOLD_PARTICLES.start(parent=render, renderParent=render)
_GOLD_PARTICLES.setScale(200)
self.instStatus = "show"
self.musicCounter = 0
self.music = load_bgmusic(_BGMUSIC[0])
# self.music.play()
self.volume = 0
self.music.setVolume(self.volume)
base.win.setClearColor(Vec4(0,0,0,1))
self.above = 3.0
# load environment
self.loadEnviron()
# load ralph
self.loadRalph()
# load sky box
self.skyBoxLoad()
# load pokemon
self.loadPokemon()
self.displayInformation()
self.keyControl()
# 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)
taskMgr.add(self.move,"moveTask")
taskMgr.add(self.setAbove,"setAbove")
taskMgr.add(self.loadNextMusic, "loadRandomMusic")
taskMgr.add(self.gold, "gold")
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.ralph.getX(),self.ralph.getY(),2)
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0,0,1000)
self.ralphGroundRay.setDirection(0,0,-1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,1000)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
self.keyMap = {"left":0, "right":0, "forward":0, "cam-left":0, "cam-right":0}
base.win.setClearColor(Vec4(0,0,0,1))
# Post the instructions
self.title = addTitle("Panda3D Tutorial: Roaming Ralph (Walking on the Moon)")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.85, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.80, "[Up Arrow]: Run Ralph Forward")
self.inst6 = addInstructions(0.70, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.65, "[S]: Rotate Camera Right")
# Set up the environment
#
self.environ = loader.loadModel("models/square")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
self.environ.setScale(100,100,1)
self.moon_tex = loader.loadTexture("models/moon_1k_tex.jpg")
self.environ.setTexture(self.moon_tex, 1)
# Create the main character, Ralph
self.ralph = Actor("models/ralph",
{"run":"models/ralph-run",
"walk":"models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(10,10,0)
# Create 2 panda
# Actors at 000 and 10,0,0 position
self.pandaActor1 = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.pandaActor1.setScale(0.004)
self.pandaActor1.reparentTo(render)
self.pandaActor1.setPos(30,30,0)
self.pandaActor2 = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.pandaActor2.setScale(0.005, 0.005, 0.005)
self.pandaActor2.reparentTo(render)
self.pandaActor2.setPos(15,-15,0)
self.car = loader.loadModel("models/RaceCar")
self.car_tex = loader.loadTexture("models/tex/Mesh_3_TX.jpg")
self.car_tex = loader.loadTexture("models/tex/Cylinder_TX.jpg")
self.car_tex = loader.loadTexture("models/tex/Cylinder_2_TX.jpg")
self.car_tex = loader.loadTexture("models/tex/Mesh_3_TX_2.jpg")
self.car_tex = loader.loadTexture("models/tex/Mesh_3_TX_3.jpg")
# self.car.setScale(2.5)
self.car.reparentTo(render)
self.car.setPos(20,30,0)
self.x=0
# self.pandaActor1.loop("walk")
# self.pandaActor2.loop("walk")
self.panda1AnimControl=self.pandaActor1.getAnimControl("walk")
self.panda2AnimControl=self.pandaActor2.getAnimControl("walk")
# 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)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left",1])
self.accept("arrow_right", self.setKey, ["right",1])
self.accept("arrow_up", self.setKey, ["forward",1])
self.accept("a", self.setKey, ["cam-left",1])
self.accept("s", self.setKey, ["cam-right",1])
self.accept("arrow_left-up", self.setKey, ["left",0])
self.accept("arrow_right-up", self.setKey, ["right",0])
self.accept("arrow_up-up", self.setKey, ["forward",0])
self.accept("a-up", self.setKey, ["cam-left",0])
self.accept("s-up", self.setKey, ["cam-right",0])
taskMgr.add(self.move,"moveTask")
taskMgr.add(self.jump1, "jumpPanda1")
taskMgr.add(self.jump2, "jumpPanda2")
# Game state variables
self.isMoving = False
self.pandaisMoving = False
self.hasMoved = False
self.hasMoved1 = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.ralph.getX(),self.ralph.getY()+10,2)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
self.itemID = 0
self.switchState = True
self.iAktion = "E"
self.altIPos = [0,0]
self.switchCam = False
self.kampf = Battle.Kampf()
self.itemDa = False
self.keyMap = {"left":0, "right":0, "forward":0, "cam-left":0, "cam-right":0}
base.win.setClearColor(Vec4(0,0,0,1))
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
self.spieler = Players.Player(Actor("models/box.x"))
self.spieler.actor.reparentTo(render)
spielerStartPos = (-107.575, 26.6066, -0.490075)
self.spieler.actor.setPos(spielerStartPos)
self.textObjectSpieler = OnscreenText(text = self.spieler.name+": "+str(self.spieler.energie)+"/"+str(self.spieler.maxenergie)+" HP", pos = (-0.90, -0.98), scale = 0.07, fg = (1,0,0,1))
# Erstellt Gegner
self.gegnerStartPos = ([(-39.1143569946,25.1781406403,-0.136657714844),
(-102.375793457,-30.6321983337,0.0),
(-56.927986145, -34.6329650879, -0.16748046875),
(-79.6673126221,30.8231620789,2.89721679688),
(-4.37648868561,30.5158863068,2.18450927734),
(22.6527004242,4.99837779999,3.11364746094),
(-23.8257598877,-7.87773084641,1.36920166016),
(-80.6140823364,19.5769443512,4.70764160156),
(-75.0773696899,-15.2991075516,6.24676513672)
])
gegnerPos = random.choice(self.gegnerStartPos)
self.gegnerErstellen(gegnerPos)
self.textObjectGegner = OnscreenText(text = str(self.gegner.name)+": "+str(self.gegner.energie)+"/"+str(self.gegner.maxenergie)+" HP", pos = (0.90, -0.98), scale = 0.07, fg = (1,0,0,1))
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
self.item = None
# Handling der Usereingaben für Bewegung
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left",1])
self.accept("arrow_right", self.setKey, ["right",1])
self.accept("arrow_up", self.setKey, ["forward",1])
self.accept("a", self.setKey, ["cam-left",1])
self.accept("s", self.setKey, ["cam-right",1])
self.accept("i", self.setKey, ["inventar",1])
self.accept("arrow_left-up", self.setKey, ["left",0])
self.accept("arrow_right-up", self.setKey, ["right",0])
self.accept("arrow_up-up", self.setKey, ["forward",0])
self.accept("a-up", self.setKey, ["cam-left",0])
self.accept("s-up", self.setKey, ["cam-right",0])
self.accept("e", self.iAktionsHandler,["e"])
self.accept("v", self.iAktionsHandler,["v"])
self.accept("w", self.iAktionsHandler,["w"])
taskMgr.add(self.move,"moveTask")
taskMgr.add(self.erkenneKampf,"Kampferkennung")
taskMgr.add(self.screentexts,"Screentexte")
# Menü erstellen
self.createMenu()
# Kameraeinstellungen
base.disableMouse()
base.camera.setPos(self.spieler.actor.getX(),self.spieler.actor.getY()+10,2)
self.collisionInit();
self.setAI()
# Licht
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
# Hintergrund (Himmel)
self.setupSkySphere()
def __init__(self):
ShowBase.__init__(self)
# initalize the window
base.disableMouse()
self.win.setClearColor((0, 0, 0, 1))
props = WindowProperties()
props.setCursorHidden(True)
props.setSize(1700,1000)
base.win.requestProperties(props)
# store keys
self.keyMap = {
"left": 0, "right": 0, "forward": 0, "backward": 0,
"drift-left": 0, "drift-right": 0, "up": 0, "down": 0,
"restart": 0, "firstPerson": 0, "gravity": 0}
#instructions
self.ins2 = addInstructions(0.12, "[Left/Right Arrow]: Rotate Left/Right")
self.ins3 = addInstructions(0.18, "[Up/Down Arrow]: Fly Forward/Backward")
self.ins4 = addInstructions(0.24, "[A, D]: Move Camera")
self.ins5 = addInstructions(0.30, "[W, S]: Lift / Descent")
self.ins6 = addInstructions(0.36, "[F]: Toggle First Person/ Third Person")
self.ins7 = addInstructions(0.42, "[G]: Toggle Gravity")
self.ins8 = addInstructions(0.48, "[R]: Restart")
# Set up the playground
# other maps:
# models/toon/phase_15/hood/toontown_central.bam
# models/world
# CS_Map/myCSMAP.egg
# Race/RaceTrack/FullTrack.blend
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.mapScale = 1
"""
self.environ = loader.loadModel("The City/The City.obj")
self.environ.reparentTo(render)
myTexture = loader.loadTexture("The City/Maps/cty1.jpg")
self.environ.setTexture(myTexture)
self.environ.setHpr(0,90,0)
self.environ.setScale(.1)
"""
# Create drone and initalize drone position
self.Drone = Actor("models/mydrone.egg")
self.Drone.reparentTo(render)
# resize and reposition the drone
self.Drone.setScale(.1)
self.Drone.setPos(5,5,8)
self.Drone.setH(180)
# initial position is saved for restarting the game
self.DroneStartPos = self.Drone.getPos()
# User Controls
self.accept('escape', __import__('sys').exit, [0])
self.accept("arrow_left", self.setKey, ["left", True])
self.accept("arrow_right", self.setKey, ["right", True])
self.accept("arrow_up", self.setKey, ["forward", True])
self.accept("arrow_down", self.setKey, ["backward", True])
self.accept("a", self.setKey, ["drift-left", True])
self.accept("d", self.setKey, ["drift-right", True])
self.accept("arrow_left-up", self.setKey, ["left", False])
self.accept("arrow_right-up", self.setKey, ["right", False])
self.accept("arrow_up-up", self.setKey, ["forward", False])
self.accept("arrow_down-up", self.setKey, ["backward", False])
self.accept("a-up", self.setKey, ["drift-left", False])
self.accept("d-up", self.setKey, ["drift-right", False])
self.accept("w", self.setKey, ["up", True])
self.accept("w-up", self.setKey, ["up", False])
self.accept("s", self.setKey, ["down", True])
self.accept("s-up", self.setKey, ["down", False])
self.accept("r", self.setKey, ["restart", True])
self.accept("r-up", self.setKey, ["restart", False])
self.accept("f", self.setKey, ["firstPerson", True])
self.accept("f-up", self.setKey, ["firstPerson", False])
self.accept("g", self.setKey, ["gravity", True])
self.accept("g-up", self.setKey, ["gravity", False])
taskMgr.add(self.move, "moveTask")
# Disable Mouse
self.disableMouse()
# Camera settings
self.cameraDistance = 5
self.cameraPitch = -10
# create the collision box for the drone
# this collision box will be used for collision detection
self.droneBox = CollisionBox((0,0,2.5), 3, 3, 0.7)
self.cnodePath = self.Drone.attachNewNode(CollisionNode('cnode'))
self.cnodePath.node().addSolid(self.droneBox)
# collision detection set up
self.cTrav = CollisionTraverser()
self.queue = CollisionHandlerQueue()
self.cTrav.addCollider(self.cnodePath, self.queue)
self.cTrav.traverse(render)
# Lighting portion are modified from an example provided by Panda3d – Roaming Ralph
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((1, 1, 1, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((-5, -5, -5))
directionalLight.setColor((1, 1, 1, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
# Crashed Text
self.crashed = OnscreenText()
self.firstPerson = False
# HPR setting
self.angle = 0
self.angleChange = 0.5
self.maxAngle = 15
# Speed Control
self.FBSpeed = self.mapScale * 6
self.LRSpeed = self.mapScale * 4
self.turnSpeed = 80
self.liftSpeed = self.mapScale * 80
self.downSpeed = self.mapScale * 80
# AI set up
self.AI = True
if self.AI:
self.droneAI = Actor("models/mydrone.egg")
self.droneAI.reparentTo(render)
self.droneAI.setScale(.1)
self.droneAI.setPos(5,5,5)
self.AI_actions = open("AI/RoamingRalph/AI_easy.txt", "r").readlines()
#######################
# additional features #
#######################
# acceleration
self.FBacceleration = 0
self.LRacceleration = 0
self.accelMax = 40
self.accelIncrement = 2
# gravity
self.gravity = True
self.gravity_value = 15 * self.mapScale
def initWorld(self, playerId, chosenCharId, x, y, h):
self.keyMap = {"hello":0, "left":0, "right":0, "forward":0, "backward":0, "cam-left":0, "cam-right":0, "chat":0, "fast":0, "chat0": 0, "chat1": 0, "users": 0}
base.win.setClearColor(Vec4(0,0,0,1))
# chat box
self.chatbox = Chat(self.cManager, self)
self.activeUsers = Users(self.cManager, self)
taskMgr.add(self.message, 'message')
# Post the instructions
self.title = addTitle("Panda3D Tutorial: Roaming Ralph (Walking on the Moon)")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[A]: Rotate Ralph Left")
self.inst3 = addInstructions(0.85, "[D]: Rotate Ralph Right")
self.inst4 = addInstructions(0.80, "[W]: Run Ralph Forward")
self.inst4 = addInstructions(0.75, "[S]: Run Ralph Backward")
self.inst6 = addInstructions(0.70, "[Left Arrow]: Rotate Camera Left")
self.inst7 = addInstructions(0.65, "[Right Arrow]: Rotate Camera Right")
self.inst8 = addInstructions(0.60, "[0]: Toggle Chat Broadcast")
self.inst9 = addInstructions(0.55, "[1]: Toggle Private Chat - username/")
self.inst10 = addInstructions(0.50, "[L]: List Connected Users")
# Set up the environment
#
self.environ = loader.loadModel("models/square")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
self.environ.setScale(100,100,1)
self.moon_tex = loader.loadTexture("models/moon_1k_tex.jpg")
self.environ.setTexture(self.moon_tex, 1)
#Collision Code
# Initialize the collision traverser.
base.cTrav = CollisionTraverser()
# Initialize the Pusher collision handler.
self.pusher = CollisionHandlerPusher()
self.bTrav = base.cTrav
# Create the main character, Ralph
self.mainCharRef = Character(self, chosenCharId, True)
self.mainCharRef.setPlayerId(playerId)
self.characters.append(self.mainCharRef)
self.mainChar = self.mainCharRef.getActor()
#Create second bike
self.mainCharRef2 = Character(self, 3, True)
self.mainCharRef2.setPlayerId(2)
self.characters.append(self.mainCharRef2)
self.mainChar2 = self.mainCharRef2.getActor()
resetPos = True
if (x == 0 and y == 0):
resetPos = False
if resetPos:
self.mainChar.setPos(x, y, 0)
self.mainChar.setH(h)
self.cManager.sendRequest(Constants.CMSG_CREATE_CHARACTER, [playerId,
chosenCharId,
self.mainChar.getX(),
self.mainChar.getY(),
self.mainChar.getZ()])
self.previousPos = self.mainChar.getPos()
taskMgr.doMethodLater(.1, self.updateMove, 'updateMove')
# Creating Stationary spheres
self.spheres = []
self.sphereCount = 3
for x in range(self.sphereCount):
self.spheres.append(StationarySphere(self))
for sphere in self.spheres:
taskMgr.add(sphere.rotateForAll, "rotateSphere")
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
floorNode = render.attachNewNode("Floor NodePath")
# Create a collision plane solid.
collPlane = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))
# Call our function that creates a nodepath with a collision node.
floorCollisionNP = self.makeCollisionNodePath(floorNode, collPlane)
# Accept the control keys for movement and rotation
self.accept("escape", self.quitGame)
self.accept("a", self.setKey, ["left",1])
self.accept("d", self.setKey, ["right",1])
self.accept("w", self.setKey, ["forward",1])
self.accept("s", self.setKey, ["backward",1])
self.accept("lshift", self.setKey, ["fast", 1])
self.accept("arrow_left", self.setKey, ["cam-left",1])
self.accept("arrow_right", self.setKey, ["cam-right",1])
self.accept("a-up", self.setKey, ["left",0])
self.accept("d-up", self.setKey, ["right",0])
self.accept("w-up", self.setKey, ["forward",0])
self.accept("s-up", self.setKey, ["backward",0])
self.accept("lshift-up", self.setKey, ["fast", 0])
self.accept("arrow_left-up", self.setKey, ["cam-left",0])
self.accept("arrow_right-up", self.setKey, ["cam-right",0])
self.accept("h", self.setKey, ["hello",1])
self.accept("h-up", self.setKey, ["hello",0])
self.accept("0", self.setKey, ["chat0", 1])
self.accept("0-up", self.setKey, ["chat0", 0])
self.accept("1", self.setKey, ["chat1", 1])
self.accept("1-up", self.setKey, ["chat1", 0])
self.accept("l", self.setKey, ["users", 1])
self.accept("l-up", self.setKey, ["users", 0])
taskMgr.add(self.move,"moveTask")
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.mainChar.getX(),self.mainChar.getY()+10,2)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"cam-left": 0,
"cam-right": 0
}
base.win.setClearColor(Vec4(0, 0, 0, 1))
self.speed = 0
self.font_digital = loader.loadFont('font/SFDigitalReadout-Heavy.ttf')
# Speedometer
self.speed_img = OnscreenImage(image="models/speedometer.png",
scale=.5,
pos=(1.1, 0, -.95))
self.speed_img.setTransparency(TransparencyAttrib.MAlpha)
OnscreenText(text="km\n/h",
style=1,
fg=(1, 1, 1, 1),
font=self.font_digital,
scale=.07,
pos=(1.25, -.92))
# Display Speed
self.display_speed = OnscreenText(text=str(self.speed),
style=1,
fg=(1, 1, 1, 1),
pos=(1.3, -0.95),
align=TextNode.ARight,
scale=.07,
font=self.font_digital)
# Health Bar
self.bars = {'H': 100, 'EH': 0, 'A': 0}
# bk_text = "This is my Demo"
# self.textObject = OnscreenText(text = bk_text, pos = (0.55,-0.05),scale = 0.07,fg=(1,0.5,0.5,1),align=TextNode.ACenter,mayChange=1)
self.Health_bar = DirectWaitBar(text="",
value=100,
pos=(0.280, 0, 0.475),
barColor=(1, 0, 0, 1),
frameSize=(0, .705, .3, .35))
self.EHealth_bar = DirectWaitBar(text="",
value=0,
pos=(1, 0, 0.475),
barColor=(0, 1, 0, 1),
frameSize=(0, .23, .3, .35),
range=50)
self.Armour_bar = DirectWaitBar(text="",
value=0,
pos=(.43, 0, .593),
barColor=(159, 0, 255, 1),
frameSize=(0, .8, .3, .35))
self.Health = DirectWaitBar(text="",
value=100,
barColor=(1, 0, 0, 1),
frameSize=(-1, 1, .3, .5),
scale=2)
# create a frame
# myFrame = DirectFrame(frameColor=(1, 0, 0, 1),
# frameSize=(0, .8, 0, .2))
# self.bar = DirectWaitBar(text = "hi",
# value = 0,
# range = 500,
# pos = ( 0,0,0),
# barColor = (0.97,0,0,1),
# frameSize = (-0.3,0.3,0.5,0.8),
# text_mayChange = 1,
# text_shadow =(0,0,0,0.8),
# text_fg = (0.9,0.9,0.9,1),
# text_scale = 0.025,
# text_pos = (0,0.01,0))
def getHealthStatus():
return self.bars
def displayBars():
health = getHealthStatus()
self.Health_bar['value'] = health['H']
self.EHealth_bar['value'] = health['EH']
self.Armour_bar['value'] = health['A']
self.Health['value'] = health['H']
def armourPickup():
self.bars['A'] += 25
displayBars()
def healthPickup():
self.bars['EH'] += 25
displayBars()
def decHealth():
self.bars['H'] -= 10
displayBars()
def initialiseSound(audioManager):
"""Start the engine sound and set collision sounds"""
# Set sounds to play for collisions
# self.collisionSound = CollisionSound(
# nodePath=self.np,
# sounds=["data/sounds/09.wav"],
# thresholdForce=600.0,
# maxForce=800000.0)
# np - nodePath
self.engineSound = audioManager.loadSfx("sound/engine.wav")
audioManager.attachSoundToObject(self.engineSound, self.ralph)
self.engineSound.setLoop(True)
self.engineSound.setPlayRate(0.6)
self.engineSound.play()
# self.gearSpacing = (self.specs["sound"]["maxExpectedRotationRate"] /
# self.specs["sound"]["numberOfGears"])
self.gearSpacing = (150 / 4)
self.reversing = False
# Post the instructions
self.frame = OnscreenImage(image="models/gframe.png",
pos=(0, 0, 0),
scale=(1.25, 1, 1))
self.frame.setTransparency(TransparencyAttrib.MAlpha)
# self.title = addTitle("Panda3D Tutorial: Roaming Ralph (Walking on the Moon)")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.85, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.80, "[Up Arrow]: Run Ralph Forward")
self.inst6 = addInstructions(0.70, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.65, "[S]: Rotate Camera Right")
# Set up the environment
#
self.environ = loader.loadModel("models/square")
self.environ.reparentTo(render)
self.environ.setPos(0, 0, 0)
self.environ.setScale(100, 100, 1)
self.moon_tex = loader.loadTexture("models/moon_1k_tex.jpg")
self.environ.setTexture(self.moon_tex, 1)
# Create the main character, Ralph
self.ralph = Actor("models/ralph", {
"run": "models/ralph-run",
"walk": "models/ralph-walk"
})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(0, 0, 0)
# # Load and place the model
# self.eNode = render.attachNewNode('enemyBaseNode')
# self.eNode.setPos( 0,0,0 )
# self.model = loader.loadModel( 'models/ralph' )
# self.model.reparentTo( self.eNode )
# # Setup the rest of what the enemy needs
# self.setupHealthBar()
# self.Health.setBillboardAxis()
# self.Health.setBillboardPointWorld()
# self.Health.setBillboardPointEye()
# self.Health.setLightOff()
self.Health.setPos(0, 0, 5)
self.Health.setBillboardPointEye()
self.Health.setBin('fixed', 0)
self.Health.setDepthWrite(False)
self.Health.reparentTo(self.ralph)
# myFrame.setPos(0, 0, 8)
# myFrame.setBillboardPointEye()
# myFrame.reparentTo(self.ralph)
# self.Health.clearBillboard()
# 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)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left", 1])
self.accept("arrow_right", self.setKey, ["right", 1])
self.accept("arrow_up", self.setKey, ["forward", 1])
self.accept("a", self.setKey, ["cam-left", 1])
self.accept("s", self.setKey, ["cam-right", 1])
self.accept("arrow_left-up", self.setKey, ["left", 0])
self.accept("arrow_right-up", self.setKey, ["right", 0])
self.accept("arrow_up-up", self.setKey, ["forward", 0])
self.accept("a-up", self.setKey, ["cam-left", 0])
self.accept("s-up", self.setKey, ["cam-right", 0])
self.accept("h", decHealth)
self.accept("j", healthPickup)
self.accept("k", armourPickup)
taskMgr.add(self.move, "moveTask")
taskMgr.doMethodLater(.1, self.show_speed, 'updateSpeed')
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
# Create an audio manager. This is attached to the camera for
# player 1, so sounds close to other players might not be very
# loud
self.audioManager = Audio3DManager.Audio3DManager(
base.sfxManagerList[0], base.camera)
# Distance should be in m, not feet
self.audioManager.setDistanceFactor(3.28084)
initialiseSound(self.audioManager)
displayBars()
def __init__(self):
base.setBackgroundColor(0.1, 0.1, 0.8, 1)
base.setFrameRateMeter(True)
base.cam.setPosHpr(0, 0, 25, 0, -90, 0)
base.disableMouse()
# Input
self.accept('escape', self.exitGame)
self.accept('f1', self.toggleWireframe)
self.accept('f2', self.toggleTexture)
self.accept('f3', self.toggleDebug)
self.accept('f5', self.doScreenshot)
# Setup scene 1: World
self.debugNP = render.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.node().showWireframe(True)
self.debugNP.node().showConstraints(True)
self.debugNP.node().showBoundingBoxes(True)
self.debugNP.node().showNormals(True)
self.debugNP.show()
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Setup scene 2: Ball
visNP = loader.loadModel('models/ball.egg')
visNP.clearModelNodes()
bodyNPs = BulletHelper.fromCollisionSolids(visNP, True)
self.ballNP = bodyNPs[0]
self.ballNP.reparentTo(render)
self.ballNP.node().setMass(1.0)
self.ballNP.setPos(4, -4, 1)
self.ballNP.node().setDeactivationEnabled(False)
visNP.reparentTo(self.ballNP)
# Setup scene 3: Maze
visNP = loader.loadModel('models/maze.egg')
visNP.clearModelNodes()
visNP.reparentTo(render)
self.holes = []
self.maze = []
self.mazeNP = visNP
bodyNPs = BulletHelper.fromCollisionSolids(visNP, True)
for bodyNP in bodyNPs:
bodyNP.reparentTo(render)
if isinstance(bodyNP.node(), BulletRigidBodyNode):
bodyNP.node().setMass(0.0)
bodyNP.node().setKinematic(True)
self.maze.append(bodyNP)
elif isinstance(bodyNP.node(), BulletGhostNode):
self.holes.append(bodyNP)
# Lighting and material for the ball
ambientLight = AmbientLight('ambientLight')
ambientLight.setColor(Vec4(0.55, 0.55, 0.55, 1))
directionalLight = DirectionalLight('directionalLight')
directionalLight.setDirection(Vec3(0, 0, -1))
directionalLight.setColor(Vec4(0.375, 0.375, 0.375, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
self.ballNP.setLight(render.attachNewNode(ambientLight))
self.ballNP.setLight(render.attachNewNode(directionalLight))
m = Material()
m.setSpecular(Vec4(1, 1, 1, 1))
m.setShininess(96)
self.ballNP.setMaterial(m, 1)
# Startup
self.startGame()
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
# Set the background color to black
self.win.setClearColor((0, 1, 1, 1))
# This is used to store which keys are currently pressed.
self.keyMap = {
"left": 0, "right": 0, "forward": 0, "cam-left": 0, "cam-right": 0,
"backward": 0, "cam-up": 0, "cam-down": 0, "add-car": 0,
"switch-mode":0, "mouse-click":0}
# this is the egg that came with the module
# environ = loader.loadModel("models/world")
# this is the one I created using mountainMaker.py
self.environ = loader.loadModel("TestMountain1")
self.environ.reparentTo(render)
self.car = loader.loadModel("TestCar")
#self.car = loader.loadModel("testModel/ball")
self.car.reparentTo(render)
#instructions
self.inst = [""]*5
self.setUpFlyingInstructions()
# for adjusting so that the position is the center of the car
self.adjustedXForCenter = 10/2
self.adjustedYForCenter = 20/2
# important for setting the size relative to everything else
# found it here : https://www.panda3d.org/manual/index.php/Common_State_Changes
# set the mode that the player is currently in
self.mode = 0
self.modeFly = 0
self.modeRace = 1
# to ensure that when pressing h it only switches once each press
self.hasSwitched = False
self.carPositionX = 10
self.carPositionY = 10
self.carPositionZ = 100
# note for rotating camera: from this website:
# https://www.panda3d.org/manual/index.php/Common_State_Changes
# setHpr(Yaw, Pitch, Roll)
# setting up initial conditions for which way camera is rotated
self.carYaw = 0
self.carPitch = 0
self.setUpCarCollider()
self.setUpMouseCollider()
# make the rocks and other stuff that will show up
self.objects = []
# Accept the control keys for movement and rotation
#setting up keys for movement
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left", True])
self.accept("arrow_right", self.setKey, ["right", True])
self.accept("arrow_up", self.setKey, ["forward", True])
self.accept("arrow_down", self.setKey, ["backward", True])
self.accept("arrow_left-up", self.setKey, ["left", False])
self.accept("arrow_right-up", self.setKey, ["right", False])
self.accept("arrow_up-up", self.setKey, ["forward", False])
self.accept("arrow_down-up", self.setKey, ["backward", False])
# adding car
self.accept("mouse1", self.setKey, ["mouse-click", True])
self.accept("mouse1-up", self.setKey, ["mouse-click", False])
# setting up orientation of the camera
self.accept("a", self.setKey, ["cam-left", True])
self.accept("s", self.setKey, ["cam-down", True])
self.accept("a-up", self.setKey, ["cam-left", False])
self.accept("s-up", self.setKey, ["cam-down", False])
self.accept("d", self.setKey, ["cam-right", True])
self.accept("d-up", self.setKey, ["cam-right", False])
self.accept("w", self.setKey, ["cam-up", True])
self.accept("w-up", self.setKey, ["cam-up", False])
# to switch between tasks
self.accept("h", self.setKey, ["switch-mode", True])
self.accept("h-up", self.setKey, ["switch-mode", False])
taskMgr.add(self.move, "moveTask")
# Game state variables
self.isMoving = False
self.cameraPositionX = 0
self.cameraPositionY = 0
self.cameraPositionZ = 0
# note for rotating camera: from this website:
# https://www.panda3d.org/manual/index.php/Common_State_Changes
# setHpr(Yaw, Pitch, Roll)
# setting up initial conditions for which way camera is rotated
self.cameraYaw = 0
self.cameraPitch = 0
# Set up the camera
self.disableMouse()
# should probably clean up these magic numbers
self.camera.setPos(20, 20, 20)
# Create some lighting
# this is a part that is completely unchanged from demo
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((-5, -5, -5))
directionalLight.setColor((1, 1, 1, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
__builtin__.main = self
self.taskMgr = taskMgr
self.base = base
# Connect to the server
self.cManager = ConnectionManager()
self.startConnection()
self.characters = dict()
self.cpList = dict()
self.keyMap = {"left":0, "right":0, "forward":0, "cam-left":0, "cam-right":0}
base.win.setClearColor(Vec4(0,0,0,1))
# Post the instructions
self.title = addTitle("Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.85, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.80, "[Up Arrow]: Run Ralph Forward")
self.inst6 = addInstructions(0.70, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.65, "[S]: Rotate Camera Right")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
self.ralphStartPos = self.environ.find("**/start_point").getPos()
# 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)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left",1])
self.accept("arrow_right", self.setKey, ["right",1])
self.accept("arrow_up", self.setKey, ["forward",1])
self.accept("a", self.setKey, ["cam-left",1])
self.accept("s", self.setKey, ["cam-right",1])
self.accept("arrow_left-up", self.setKey, ["left",0])
self.accept("arrow_right-up", self.setKey, ["right",0])
self.accept("arrow_up-up", self.setKey, ["forward",0])
self.accept("a-up", self.setKey, ["cam-left",0])
self.accept("s-up", self.setKey, ["cam-right",0])
# Placeholder Login
self.name = str(raw_input("Name: "))
factionId = int(input("Faction ID: "))
self.cManager.sendRequest(Constants.CMSG_AUTH, [self.name, factionId])
# Create two control points
cp1 = ControlPoint(1, -107.575, 0.6066, 0.490075, 10, RED)
cp2 = ControlPoint(2, -100.575, -35.6066, 0.090075, 10, BLUE)
self.cpList[1] = cp1
self.cpList[2] = cp2
# Create the control point Bar UI
self.cp_bar = ControlPointBar()
self.resource_bar = ResourceBar()
taskMgr.doMethodLater(0.1, self.refresh, "heartbeat")
taskMgr.doMethodLater(1, self.CPHandler, "CPHandler")
taskMgr.doMethodLater(0.1, self.CPBarHandler, 'CPBarHandler')
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
#base.camera.setPos(self.character.actor.getX(),self.character.actor.getY()+10,2)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
# Initialize the ShowBase class from which we inherit, which will
# create a window and set up everything we need for rendering into it.
ShowBase.__init__(self)
base.setBackgroundColor(0, 0, 0)
self.accept("escape", sys.exit) # Escape quits
self.disableMouse()
camera.setPosHpr(0, 0, 0, 0, 0, 0)
lens = PerspectiveLens()
lens.setFov(90, 60)
lens.setNear(0.01)
lens.setFar(100000)
self.cam.node().setLens(lens)
self.ballSize = 0.025
self.cueLength = 0.2
# self.ballRoot = render.attachNewNode("ballRoot")
# #self.ball = loader.loadModel("models/ball")
# self.ball = loader.loadModel("models/ball_0_center.egg")
# #self.ball = loader.loadModel("models/ball.dae")
# self.ball.setScale(ballSize, ballSize, ballSize)
# self.ball.reparentTo(self.ballRoot)
# #print(self.ball.getBounds())
# #exit(1)
# #self.ballSphere = self.ball.find("**/ball")
# #print(self.ball.getScale()[0])
# cs = CollisionSphere(0, 0, 0, 1)
# self.ballSphere = self.ball.attachNewNode(CollisionNode('ball'))
# self.ballSphere.node().addSolid(cs)
# self.ballSphere.node().setFromCollideMask(BitMask32.bit(0))
# self.ballSphere.node().setIntoCollideMask(BitMask32.bit(1))
self.sceneIndex = 0
self.planeInfo = PlaneScene(self.sceneIndex)
self.planeScene = self.planeInfo.generateEggModel()
self.planeScene.setTwoSided(True)
self.planeScene.reparentTo(render)
self.planeScene.hide()
#get geometries from plane predictions
planeTriangles, horizontalPlaneTriangles, self.gravityDirection = self.planeInfo.getPlaneTriangles(
)
# add pool balls
self.ballRoots = []
self.balls = []
self.ballSpheres = []
self.ballGroundRays = []
for ballIndex in xrange(3):
ballRoot = render.attachNewNode("ballRoot_" + str(ballIndex))
ball = loader.loadModel("models/ball_" + str(ballIndex) +
"_center.egg")
ball.setScale(self.ballSize, self.ballSize, self.ballSize)
cs = CollisionSphere(0, 0, 0, 1)
ballSphere = ball.attachNewNode(
CollisionNode('ball_' + str(ballIndex)))
ballSphere.node().addSolid(cs)
ballSphere.node().setFromCollideMask(
BitMask32.bit(0) | BitMask32.bit(1) | BitMask32.bit(3)
| BitMask32.bit(4))
ballSphere.node().setIntoCollideMask(BitMask32.bit(1))
ball.reparentTo(ballRoot)
self.ballRoots.append(ballRoot)
self.balls.append(ball)
self.ballSpheres.append(ballSphere)
ballGroundRay = CollisionRay() # Create the ray
ballGroundRay.setOrigin(0, 0, 0) # Set its origin
ballGroundRay.setDirection(
self.gravityDirection[0], self.gravityDirection[1],
self.gravityDirection[2]) # And its direction
# Collision solids go in CollisionNode
# Create and name the node
ballGroundCol = CollisionNode('ball_ray_' + str(ballIndex))
ballGroundCol.addSolid(ballGroundRay) # Add the ray
ballGroundCol.setFromCollideMask(
BitMask32.bit(2)) # Set its bitmasks
ballGroundCol.setIntoCollideMask(BitMask32.allOff())
# Attach the node to the ballRoot so that the ray is relative to the ball
# (it will always be 10 feet over the ball and point down)
ballGroundColNp = ballRoot.attachNewNode(ballGroundCol)
self.ballGroundRays.append(ballGroundColNp)
ballRoot.hide()
continue
# Finally, we create a CollisionTraverser. CollisionTraversers are what
# do the job of walking the scene graph and calculating collisions.
# For a traverser to actually do collisions, you need to call
# traverser.traverse() on a part of the scene. Fortunately, ShowBase
# has a task that does this for the entire scene once a frame. By
# assigning it to self.cTrav, we designate that this is the one that
# it should call traverse() on each frame.
self.cTrav = CollisionTraverser()
# Collision traversers tell collision handlers about collisions, and then
# the handler decides what to do with the information. We are using a
# CollisionHandlerQueue, which simply creates a list of all of the
# collisions in a given pass. There are more sophisticated handlers like
# one that sends events and another that tries to keep collided objects
# apart, but the results are often better with a simple queue
self.cHandler = CollisionHandlerQueue()
# Now we add the collision nodes that can create a collision to the
# traverser. The traverser will compare these to all others nodes in the
# scene. There is a limit of 32 CollisionNodes per traverser
# We add the collider, and the handler to use as a pair
#self.cTrav.addCollider(self.ballSphere, self.cHandler)
for ballSphere in self.ballSpheres:
self.cTrav.addCollider(ballSphere, self.cHandler)
continue
for ballGroundRay in self.ballGroundRays:
self.cTrav.addCollider(ballGroundRay, self.cHandler)
continue
#self.cTrav.addCollider(self.ballGroundColNp, self.cHandler)
# Collision traversers have a built in tool to help visualize collisions.
# Uncomment the next line to see it.
#self.cTrav.showCollisions(render)
# This section deals with lighting for the ball. Only the ball was lit
# because the maze has static lighting pregenerated by the modeler
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.55, .55, .55, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(LVector3(0, 0, -1))
directionalLight.setColor((0.375, 0.375, 0.375, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
for ballRoot in self.ballRoots:
ballRoot.setLight(render.attachNewNode(ambientLight))
ballRoot.setLight(render.attachNewNode(directionalLight))
continue
# This section deals with adding a specular highlight to the ball to make
# it look shiny. Normally, this is specified in the .egg file.
m = Material()
m.setSpecular((1, 1, 1, 1))
m.setShininess(96)
for ball in self.balls:
ball.setMaterial(m, 1)
continue
# self.original = False
# if self.original:
# camera.setPosHpr(0, 0, 25, 0, -90, 0)
# self.maze = loader.loadModel("models/maze")
# self.maze.reparentTo(render)
# self.walls = self.maze.find("**/wall_collide")
# self.walls.node().setIntoCollideMask(BitMask32.bit(0))
# self.walls.show()
# pass
# create collision entities from plane predictions
self.triNPs = []
for triangleIndex, triangle in enumerate(planeTriangles):
#print(triangleIndex)
#for triangle in triangles:
#print(triangle)
tri = CollisionPolygon(
Point3(triangle[0][0], triangle[0][1], triangle[0][2]),
Point3(triangle[1][0], triangle[1][1], triangle[1][2]),
Point3(triangle[2][0], triangle[2][1], triangle[2][2]))
triNP = render.attachNewNode(
CollisionNode('tri_' + str(triangleIndex)))
triNP.node().setIntoCollideMask(BitMask32.bit(0))
triNP.node().addSolid(tri)
self.triNPs.append(triNP)
#triNP.show()
continue
# create special collision entities for horizontal planes so that balls can fall on one horizontal plane and bounce on it
for triangleIndex, triangle in enumerate(horizontalPlaneTriangles):
#print(triangleIndex)
#for triangle in triangles:
#print(triangle)
tri = CollisionPolygon(
Point3(triangle[0][0], triangle[0][1], triangle[0][2]),
Point3(triangle[1][0], triangle[1][1], triangle[1][2]),
Point3(triangle[2][0], triangle[2][1], triangle[2][2]))
triNP = render.attachNewNode(
CollisionNode('ground_' + str(triangleIndex)))
triNP.node().setIntoCollideMask(BitMask32.bit(2))
triNP.node().addSolid(tri)
self.triNPs.append(triNP)
#triNP.show()
continue
# tri = CollisionPolygon(Point3(-1, 4, -1), Point3(2, 4, -1), Point3(2, 4, 2))
# triNP = render.attachNewNode(CollisionNode('tri'))
# triNP.node().setIntoCollideMask(BitMask32.bit(0))
# triNP.node().addSolid(tri)
# triNP.show()
#self.planeScene.node().setIntoCollideMask(BitMask32.bit(0))
# roomRootNP = self.planeScene
# roomRootNP.flattenLight()
# mesh = BulletTriangleMesh()
# polygons = roomRootNP.findAllMatches("**/+GeomNode")
# # p0 = Point3(-10, 4, -10)
# # p1 = Point3(-10, 4, 10)
# # p2 = Point3(10, 4, 10)
# # p3 = Point3(10, 4, -10)
# # mesh.addTriangle(p0, p1, p2)
# # mesh.addTriangle(p1, p2, p3)
# print(polygons)
# for polygon in polygons:
# geom_node = polygon.node()
# #geom_node.reparentTo(self.render)
# #print(geom_node.getNumGeoms())
# ts = geom_node.getTransform()
# #print(ts)
# for geom in geom_node.getGeoms():
# mesh.addGeom(geom, ts)
# continue
# continue
# #self.scene = roomRootNP
# shape = BulletTriangleMeshShape(mesh, dynamic=False)
# #shape = BulletPlaneShape(Vec3(0, 0, 1), 1)
# room = BulletRigidBodyNode('scene')
# room.addShape(shape)
# #room.setLinearDamping(0.0)
# #room.setFriction(0.0)
# print(shape)
# room.setDeactivationEnabled(False)
# roomNP = render.attachNewNode(room)
# roomNP.setPos(0, 0, 0)
# roomNP.node().setIntoCollideMask(BitMask32.bit(0))
# self.world = BulletWorld()
# self.world.setGravity(Vec3(0, 0, 0))
# self.world.attachRigidBody(roomNP.node())
#room.setRestitution(1)
#self.roomNP = self.scene
# create the cue
self.cueRoot = render.attachNewNode("cueRoot")
self.cue = loader.loadModel("models/cue_center.egg")
self.cue.setScale(self.cueLength * 3, self.cueLength * 3,
self.cueLength)
self.cue.reparentTo(self.cueRoot)
self.cuePos = (10, 0, 0)
self.pickerNode = CollisionNode('mouseRay')
# Attach that node to the camera since the ray will need to be positioned
# relative to it
self.pickerNP = camera.attachNewNode(self.pickerNode)
# Everything to be picked will use bit 1. This way if we were doing other
# collision we could separate it
self.pickerNode.setFromCollideMask(BitMask32.bit(2))
self.pickerNode.setIntoCollideMask(BitMask32.allOff())
self.pickerRay = CollisionRay() # Make our ray
# Add it to the collision node
self.pickerNode.addSolid(self.pickerRay)
# Register the ray as something that can cause collisions
self.cTrav.addCollider(self.pickerNP, self.cHandler)
self.accept("mouse1", self.hit) # left-click grabs a piece
# create holes
self.holeLength = 0.06
holePos, holeHpr = self.planeInfo.getHolePos()
self.holeRoot = render.attachNewNode("holeRoot")
#self.hole = loader.loadModel("models/hole_horizontal_center.egg")
self.hole = loader.loadModel("models/hole_color.egg")
#self.hole = loader.loadModel("models/billiards_hole_center.egg")
self.hole.setScale(self.holeLength, self.holeLength, self.holeLength)
self.hole.reparentTo(self.holeRoot)
self.hole.setTwoSided(True)
self.holeRoot.setPos(holePos[0], holePos[1], holePos[2])
self.holeRoot.setHpr(holeHpr[0], holeHpr[1], holeHpr[2])
#tex = loader.loadTexture('models/Black_Hole.jpg')
#self.hole.setTexture(tex, 1)
self.holeRoot.hide()
ct = CollisionTube(0, 0, 0, 0, 0.001, 0, 0.5)
self.holeTube = self.hole.attachNewNode(CollisionNode('hole'))
self.holeTube.node().addSolid(ct)
self.holeTube.node().setFromCollideMask(BitMask32.allOff())
self.holeTube.node().setIntoCollideMask(BitMask32.bit(4))
#self.holeTube.show()
# create portals
inPortalPos, inPortalHpr, outPortalPos, outPortalHpr, self.portalNormal = self.planeInfo.getPortalPos(
)
self.portalLength = 0.06
self.inPortalRoot = render.attachNewNode("inPortalRoot")
self.inPortal = loader.loadModel("models/portal_2_center.egg")
self.inPortal.setScale(self.portalLength, self.portalLength,
self.portalLength)
self.inPortal.reparentTo(self.inPortalRoot)
self.inPortalRoot.setPos(inPortalPos[0], inPortalPos[1],
inPortalPos[2])
self.inPortalRoot.setHpr(inPortalHpr[0], inPortalHpr[1],
inPortalHpr[2])
self.inPortalRoot.hide()
ct = CollisionTube(0, 0, 0, 0, 0.001, 0, 1)
self.inPortalTube = self.inPortal.attachNewNode(
CollisionNode('portal_in'))
self.inPortalTube.node().addSolid(ct)
self.inPortalTube.node().setFromCollideMask(BitMask32.allOff())
self.inPortalTube.node().setIntoCollideMask(BitMask32.bit(3))
#self.inPortalTube.hide()
self.outPortalRoot = render.attachNewNode("outPortalRoot")
self.outPortal = loader.loadModel("models/portal_2_center.egg")
self.outPortal.setScale(self.portalLength, self.portalLength,
self.portalLength)
self.outPortal.reparentTo(self.outPortalRoot)
self.outPortalRoot.setPos(outPortalPos[0], outPortalPos[1],
outPortalPos[2])
self.outPortalRoot.setHpr(outPortalHpr[0], outPortalHpr[1],
outPortalHpr[2])
self.outPortalRoot.hide()
ct = CollisionTube(0, 0, 0, 0, 0.001, 0, 1)
self.outPortalTube = self.outPortal.attachNewNode(
CollisionNode('portal_out'))
self.outPortalTube.node().addSolid(ct)
self.outPortalTube.node().setFromCollideMask(BitMask32.allOff())
self.outPortalTube.node().setIntoCollideMask(BitMask32.bit(3))
#self.outPortalTube.hide()
#self.inPortalTube.show()
#self.outPortalTube.show()
#self.holeTube.show()
#self.cTrav.addCollider(self.holeTube, self.cHandler)
# create background image
background_image = loader.loadTexture('dump/' + str(self.sceneIndex) +
'_image.png')
cm = CardMaker('background')
cm.setHas3dUvs(True)
info = np.load('dump/' + str(self.sceneIndex) + '_info.npy')
#self.camera = getCameraFromInfo(self.info)
depth = 10.0
sizeU = info[2] / info[0] * depth
sizeV = info[6] / info[5] * depth
cm.setFrame(Point3(-sizeU, depth, -sizeV),
Point3(sizeU, depth, -sizeV), Point3(sizeU, depth, sizeV),
Point3(-sizeU, depth, sizeV))
self.card = self.render.attachNewNode(cm.generate())
self.card.setTransparency(True)
self.card.setTexture(background_image)
self.card.hide()
self.ballGroundMap = {}
self.ballBouncing = np.full(len(self.balls), 3)
self.started = False
self.start()
#self.hitIndex = -1
self.showing = 'parts'
self.showingProgress = 0
partsScene = PartsScene(self.sceneIndex)
self.planeNPs, self.planeCenters = partsScene.generateEggModel()
return
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
# Set the background color to black
self.win.setClearColor((0, 0, 0, 1))
# This is used to store which keys are currently pressed.
self.key_map = {"left": 0, "right": 0, "forward": 0, "cam-left": 0, "cam-right": 0}
# Post the Instruction
self.title = add_title("Panda 3D Demo")
# Instructions
self.inst1 = add_instructions(0.06, "[ESC]: Quit")
self.inst2 = add_instructions(0.12, "[Left Arrow]: Rotate Left")
self.inst3 = add_instructions(0.18, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = add_instructions(0.24, "[Up Arrow]: Run Ralph Forward")
# self.inst6 = add_instructions(0.30, "[A]: Rotate Camera Left")
# self.inst7 = add_instructions(0.36, "[S]: Rotate Camera Right")
# Load the Environment Model
self.environ = self.loader.loadModel(ENVIRONMENT)
# Reparent the model to the render controller
self.environ.reparentTo(render)
# Apply scale and position transform on the model
# self.environ.setScale(0.25, 0.25, 0.25)
# self.environ.setPos(-8, 42, 0)
# Create the Main Character
# Load and transform the panda actor
ralph_start_pos = self.environ.find("**/start_point").getPos()
self.ralph = Actor(RALPH_ACTOR, RALPH_ACTIONS)
# self.ralph.setScale(0.005, 0.005, 0.005)
self.ralph.reparentTo(render)
# Loop it's animation
self.ralph.setScale(0.2)
self.ralph.setPos(ralph_start_pos + (0, 0, 0.5))
# self.ralph.loop("walk")
# Create a floater object, which floats 2 units above rlaph. We use this as a target for the camera to look at
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.ralph)
# 2 Units above Ralph
self.floater.setZ(2.0)
# Configure the Camera
# Add the spin camera taks procedure to the taks manager
# self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
# Accept certain control keys
self.accept("escape", sys.exit)
self.accept("arrow_left", self.set_key, ["left", True])
self.accept("arrow_right", self.set_key, ["right", True])
self.accept("arrow_up", self.set_key, ["forward", True])
self.accept("a", self.set_key, ["cam-left", True])
self.accept("s", self.set_key, ["cam-right", True])
self.accept("arrow_left-up", self.set_key, ["left", False])
self.accept("arrow_right-up", self.set_key, ["right", False])
self.accept("arrow_up-up", self.set_key, ["forward", False])
self.accept("a-up", self.set_key, ["cam-left", False])
self.accept("s-up", self.set_key, ["cam-right", False])
# Game States
taskMgr.add(self.move, "moveTask")
self.is_moving = False
self.disableMouse()
self.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2)
self.camera.lookAt(self.floater)
"""
Detect the height of hte terrain by creating a collision ray and casting it down towards the terrain.
One ray will start above ralph's head and the other will start above the camera.
A ray may hit the terrain, or it may hit a rock or a tree.
If it hits the terrain we ca ndetect the height.
If it hits anything else, we rule that the move is illegal.
"""
self.cTrav = CollisionTraverser()
# Create a vector, it's location is at the top of ralph's head
self.ralph_ground_ray = CollisionRay()
self.ralph_ground_ray.setOrigin(0, 0, 9) # Top of ralph's head
self.ralph_ground_ray.setDirection(0, 0, -1) # Points -Z axis
# Create a Collision node
self.ralph_ground_col = CollisionNode("ralph_ray") # Give the node a name
self.ralph_ground_col.addSolid(self.ralph_ground_ray) # the vector from ralph's head to the ground is solid
self.ralph_ground_col.setFromCollideMask(CollideMask.bit(0)) # ??
self.ralph_ground_col.setIntoCollideMask(
CollideMask.allOff()
) # ?? This seems like it defines the behavior of ray
self.ralph_ground_col_np = self.ralph.attachNewNode(self.ralph_ground_col) # Attach the ray to ralph
self.ralph_ground_handler = (
CollisionHandlerQueue()
) # I think that when a collision occurs it sends through this
self.cTrav.addCollider(self.ralph_ground_col_np, self.ralph_ground_handler) # Attach the collision
"""
Attach the a camera ray to the camera
"""
self.cam_ground_ray = CollisionRay()
self.cam_ground_ray.setOrigin(0, 0, 9)
self.cam_ground_ray.setDirection(0, 0, -1)
self.cam_ground_col = CollisionNode("camera_ray")
self.cam_ground_col.addSolid(self.cam_ground_ray)
self.cam_ground_col.setFromCollideMask(CollideMask.bit(0))
self.cam_ground_col.setIntoCollideMask(CollideMask.allOff())
self.cam_ground_col_np = self.camera.attachNewNode(self.cam_ground_col)
self.cam_ground_handler = CollisionHandlerQueue()
self.cTrav.addCollider(self.cam_ground_col_np, self.cam_ground_handler)
# Uncomment the following lines to view the rays
self.ralph_ground_col_np.show()
self.cam_ground_col_np.show()
# Uncomment this line to show a visual representation of the Collision occuring
self.cTrav.showCollisions(render)
# Create some lighting
ambient_light = AmbientLight("ambient_light")
ambient_light.setColor((0.3, 0.3, 0.3, 1))
directional_light = DirectionalLight("directional_light")
directional_light.setDirection((-5, -5, -5))
directional_light.setColor((1, 1, 1, 1))
directional_light.setSpecularColor((1, 1, 1, 1))
render.setLight(render.attachNewNode(ambient_light))
render.setLight(render.attachNewNode(directional_light))
# Add Cube
X_OFFSET = 0
Y_OFFSET = -3
Z_OFFSET = 1
CUBE_SIZE = 2
x, y, z = ralph_start_pos
x += X_OFFSET
y += Y_OFFSET
z += Z_OFFSET
def __init__(self):
#create Queue to hold the incoming chat
#request the heartbeat so that the caht interface is being refreshed in order to get the message from other player
self.keyMap = {"left":0, "right":0, "forward":0, "cam-left":0, "cam-right":0, "charge":0}
base.win.setClearColor(Vec4(0,0,0,1))
self.cManager = ConnectionManager()
self.cManager.startConnection()
#------------------------------
#Chat
Chat(self.cManager)
#send dummy login info of the particular client
#send first chat info
#---------------------------------------
self.userName = username
dummy_login ={'user_id' : self.userName, 'factionId': faction, 'password': '******'}
self.cManager.sendRequest(Constants.RAND_STRING, dummy_login)
chat = { 'userName' : self.userName, #username
'message' : '-------Login------' }
self.cManager.sendRequest(Constants.CMSG_CHAT, chat)
#--------------------------------------
#self.minimap = OnscreenImage(image="images/minimap.png", scale=(0.2,1,0.2), pos=(-1.1,0,0.8))
#frame = DirectFrame(text="Resource Bar", scale=0.001)
resource_bar = DirectWaitBar(text="",
value=35, range=100, pos=(0,0,0.9), barColor=(255,255,0,1),
frameSize=(-0.3,0.3,0,0.03))
cp_bar = DirectWaitBar(text="",
value=70, range=100, pos=(1.0,0,0.9), barColor=(0,0,255,1),
frameSize=(-0.3,0.3,0,0.03), frameColor=(255,0,0,1))
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
# Create the main character, Ralph
ralphStartPos = self.environ.find("**/start_point").getPos()
self.ralph = Actor("models/ralph",
{"run":"models/ralph-run",
"walk":"models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos)
nameplate = TextNode('textNode username_' + str(self.userName))
nameplate.setText(self.userName)
npNodePath = self.ralph.attachNewNode(nameplate)
npNodePath.setScale(0.8)
npNodePath.setBillboardPointEye()
#npNodePath.setPos(1.0,0,6.0)
npNodePath.setZ(6.5)
bar = DirectWaitBar(value=100, scale=1.0)
bar.setColor(255,0,0)
#bar.setBarRelief()
bar.setZ(6.0)
bar.setBillboardPointEye()
bar.reparentTo(self.ralph)
# 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)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left",1])
self.accept("arrow_right", self.setKey, ["right",1])
self.accept("arrow_up", self.setKey, ["forward",1])
self.accept("a", self.setKey, ["cam-left",1])
self.accept("s", self.setKey, ["cam-right",1])
self.accept("arrow_left-up", self.setKey, ["left",0])
self.accept("arrow_right-up", self.setKey, ["right",0])
self.accept("arrow_up-up", self.setKey, ["forward",0])
self.accept("a-up", self.setKey, ["cam-left",0])
self.accept("s-up", self.setKey, ["cam-right",0])
self.accept("c", self.setKey, ["charge",1])
self.accept("c-up", self.setKey, ["charge",0])
taskMgr.add(self.move,"moveTask")
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.ralph.getX(),self.ralph.getY()+10,2)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0,0,1000)
self.ralphGroundRay.setDirection(0,0,-1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,1000)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
# Setup window size, title and so on
load_prc_file_data(
"", """
win-size 1600 900
window-title Render Pipeline - Roaming Ralph Demo
""")
if alt:
ShowBase.__init__(self)
self.render_pipeline = render_pipeline
self.render_pipeline.create(self)
else:
# ------ Begin of render pipeline code (else case) ------
# Insert the pipeline path to the system path, this is required to be
# able to import the pipeline classes
#pipeline_path = "../../"
# Just a special case for my development setup, so I don't accidentally
# commit a wrong path. You can remove this in your own programs.
#if not os.path.isfile(os.path.join(pipeline_path, "setup.py")):
pipeline_path = "../tobsprRenderPipeline"
sys.path.insert(0, pipeline_path)
from rpcore import RenderPipeline, SpotLight
self.render_pipeline = RenderPipeline()
self.render_pipeline.create(self)
# ------ End of render pipeline code, thats it! ------
# Set time of day
self.render_pipeline.daytime_mgr.time = "7:40"
# Use a special effect for rendering the scene, this is because the
# roaming ralph model has no normals or valid materials
self.render_pipeline.set_effect(
render, "roaming_ralph_pipeline_scene-effect.yaml", {}, sort=250)
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"cam-left": 0,
"cam-right": 0
}
self.speed = 1.0
base.win.setClearColor(Vec4(0, 0, 0, 1))
# Post the instructions
self.inst1 = addInstructions(0.95, "[ESC] Quit")
self.inst4 = addInstructions(0.90, "[W] Run Ralph Forward")
self.inst4 = addInstructions(0.85, "[S] Run Ralph Backward")
self.inst2 = addInstructions(0.80, "[A] Rotate Ralph Left")
self.inst3 = addInstructions(0.75, "[D] Rotate Ralph Right")
self.inst6 = addInstructions(0.70, "[Left Arrow] Rotate Camera Left")
self.inst7 = addInstructions(0.65,
"[Right Arrow] Rotate Camera Right")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel(
"roaming_ralph_pipeline_resources/world")
self.environ.reparentTo(render)
self.environ.setPos(0, 0, 0)
# Remove wall nodes
self.environ.find("**/wall").remove_node()
# Create the main character, Ralph
self.ralph = Actor(
"roaming_ralph_pipeline_resources/ralph", {
"run": "roaming_ralph_pipeline_resources/ralph-run",
"walk": "roaming_ralph_pipeline_resources/ralph-walk"
})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(Vec3(-110.9, 29.4, 1.8))
# 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)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("a", self.setKey, ["left", 1])
self.accept("d", self.setKey, ["right", 1])
self.accept("w", self.setKey, ["forward", 1])
self.accept("s", self.setKey, ["backward", 1])
self.accept("arrow_left", self.setKey, ["cam-left", 1])
self.accept("arrow_right", self.setKey, ["cam-right", 1])
self.accept("a-up", self.setKey, ["left", 0])
self.accept("d-up", self.setKey, ["right", 0])
self.accept("w-up", self.setKey, ["forward", 0])
self.accept("s-up", self.setKey, ["backward", 0])
self.accept("arrow_left-up", self.setKey, ["cam-left", 0])
self.accept("arrow_right-up", self.setKey, ["cam-right", 0])
self.accept("=", self.adjustSpeed, [0.25])
self.accept("+", self.adjustSpeed, [0.25])
self.accept("-", self.adjustSpeed, [-0.25])
taskMgr.add(self.move, "moveTask")
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.ralph.getX() + 10, self.ralph.getY() + 10, 2)
base.camLens.setFov(80)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 1000)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 1000)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
self.keyMap = {"left":0, "right":0, "forward":0,"backward":0,
"upward":0, "downward":0, "leftward":0,"rightward":0,
"cam-left":0, "cam-right":0}
base.win.setClearColor(Vec4(0,0,0,1))
self.above = 3.0
# Post the instructions
self.title = addTitle("My Pokemon - Roam Mode")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[Arrow Keys]: Move")
self.inst4 = addInstructions(0.85, "[w]: look up")
self.inst4 = addInstructions(0.80, "[s]: look down")
self.environ = load_model("secondWorld.egg")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
# Create the main character, Ralph
self.spaceSkyBox = load_model('skybox1.egg')
self.spaceSkyBox.setScale(150)
self.spaceSkyBox.setLightOff()
self.spaceSkyBox.reparentTo(render)
self.spaceSkyBox.setPos(0,0,-200)
self.spaceSkyBox.setHpr(0,0,0)
ralphStartPos = self.environ.find("**/start_point").getPos()
self.ralph = Actor("../google_drive/ball/data/models/ralph",
{"run":"../google_drive/ball/data/models/ralph-run",
"walk":"../google_drive/ball/data/models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos)
#self.ralph.hide()
self.pikachu = load_model("pikachu.egg")
self.pikachu.reparentTo(render)
self.pikachu.setScale(1)
self.pikachu.setPos(ralphStartPos)
self.Groudon = load_model("Groudon.egg")
self.Groudon.reparentTo(render)
self.Groudon.setPos(ralphStartPos)
# 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)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left",1])
self.accept("arrow_right", self.setKey, ["right",1])
self.accept("arrow_up", self.setKey, ["forward",1])
self.accept("arrow_left-up", self.setKey, ["left",0])
self.accept("arrow_right-up", self.setKey, ["right",0])
self.accept("arrow_up-up", self.setKey, ["forward",0])
self.accept("w",self.setKey,["upward",1])
self.accept("w-up",self.setKey,["upward",0])
self.accept("s",self.setKey,["downward",1])
self.accept("s-up",self.setKey,["downward",0])
taskMgr.add(self.move,"moveTask")
taskMgr.add(self.setAbove,"setAbove")
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.ralph.getX(),self.ralph.getY(),2)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0,0,1000)
self.ralphGroundRay.setDirection(0,0,-1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,1000)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
class RoamingRalphDemo(CosmoniumBase):
def get_local_position(self):
return base.camera.get_pos()
def create_terrain_appearance(self):
self.terrain_appearance.set_shadow(self.shadow_caster)
def create_terrain_heightmap(self):
self.heightmap = PatchedHeightmap('heightmap',
self.noise_size,
self.height_scale,
self.size,
self.size,
True,
ShaderHeightmapPatchFactory(self.noise))
def create_terrain_biome(self):
self.biome = PatchedHeightmap('biome',
self.biome_size,
1.0,
self.size,
self.size,
False,
ShaderHeightmapPatchFactory(self.biome_noise))
def create_terrain_shader(self):
# control4 = HeightColorMap('colormap',
# [
# ColormapLayer(0.00, top=LRGBColor(0, 0.1, 0.24)),
# ColormapLayer(0.40, top=LRGBColor(0, 0.1, 0.24)),
# ColormapLayer(0.49, top=LRGBColor(0, 0.6, 0.6)),
# ColormapLayer(0.50, bottom=LRGBColor(0.9, 0.8, 0.6), top=LRGBColor(0.5, 0.4, 0.3)),
# ColormapLayer(0.80, top=LRGBColor(0.2, 0.3, 0.1)),
# ColormapLayer(0.90, top=LRGBColor(0.7, 0.6, 0.4)),
# ColormapLayer(1.00, bottom=LRGBColor(1, 1, 1), top=LRGBColor(1, 1, 1)),
# ])
appearance = DetailMap(self.terrain_control, self.heightmap, create_normals=True)
data_source = [HeightmapDataSource(self.heightmap, PatchedGpuTextureSource, filtering=HeightmapDataSource.F_none),
HeightmapDataSource(self.biome, PatchedGpuTextureSource, filtering=HeightmapDataSource.F_none),
TextureDictionaryDataSource(self.terrain_appearance, TextureDictionaryDataSource.F_hash)]
if settings.allow_tesselation:
tesselation_control = ConstantTesselationControl(invert_v=False)
else:
tesselation_control = None
if self.fog is not None:
after_effects = [Fog(**self.fog)]
else:
after_effects = None
self.terrain_shader = BasicShader(appearance=appearance,
tesselation_control=tesselation_control,
geometry_control=DisplacementGeometryControl(self.heightmap),
data_source=data_source,
after_effects=after_effects)
def create_tile(self, x, y):
self.terrain_shape.add_root_patch(x, y)
def create_terrain(self):
self.tile_factory = TileFactory(self.tile_density, self.size, self.has_water, self.water)
self.terrain_shape = TiledShape(self.tile_factory, self.size, self.max_lod, lod_control=VertexSizeMaxDistancePatchLodControl(self.max_distance, self.max_vertex_size))
self.create_terrain_heightmap()
self.create_terrain_biome()
self.create_terrain_appearance()
self.create_terrain_shader()
self.terrain = HeightmapSurface(
'surface',
0,
self.terrain_shape,
self.heightmap,
self.biome,
self.terrain_appearance,
self.terrain_shader,
self.size,
clickable=False,
average=True)
self.terrain.set_parent(self)
self.terrain.create_instance()
def toggle_water(self):
if not self.has_water: return
self.water.visible = not self.water.visible
self.terrain_shape.check_settings()
def get_height(self, position):
height = self.terrain.get_height(position)
if self.has_water and self.water.visible and height < self.water.level:
height = self.water.level
return height
#Used by populator
def get_height_patch(self, patch, u, v):
height = self.terrain.get_height_patch(patch, u, v)
if self.has_water and self.water.visible and height < self.water.level:
height = self.water.level
return height
def skybox_init(self):
skynode = base.cam.attachNewNode('skybox')
self.skybox = loader.loadModel('ralph-data/models/rgbCube')
self.skybox.reparentTo(skynode)
self.skybox.setTextureOff(1)
self.skybox.setShaderOff(1)
self.skybox.setTwoSided(True)
# make big enough to cover whole terrain, else there'll be problems with the water reflections
self.skybox.setScale(1.5* self.size)
self.skybox.setBin('background', 1)
self.skybox.setDepthWrite(False)
self.skybox.setDepthTest(False)
self.skybox.setLightOff(1)
self.skybox.setShaderOff(1)
self.skybox.setFogOff(1)
#self.skybox.setColor(.55, .65, .95, 1.0)
self.skybox_color = LColor(pow(0.5, 1/2.2), pow(0.6, 1/2.2), pow(0.7, 1/2.2), 1.0)
self.skybox.setColor(self.skybox_color)
def objects_density_for_patch(self, patch):
scale = 1 << patch.lod
return int(self.objects_density / scale + 1.0)
def create_populator(self):
if settings.allow_instancing:
TerrainPopulator = GpuTerrainPopulator
else:
TerrainPopulator = CpuTerrainPopulator
self.rock_collection = TerrainPopulator(RockFactory(self), self.objects_density_for_patch, self.objects_density, RandomObjectPlacer(self))
self.tree_collection = TerrainPopulator(TreeFactory(self), self.objects_density_for_patch, self.objects_density, RandomObjectPlacer(self))
self.object_collection = MultiTerrainPopulator()
self.object_collection.add_populator(self.rock_collection)
self.object_collection.add_populator(self.tree_collection)
def set_light_angle(self, angle):
self.light_angle = angle
self.light_quat.setFromAxisAngleRad(angle * pi / 180, LVector3.forward())
self.light_dir = self.light_quat.xform(LVector3.up())
cosA = self.light_dir.dot(LVector3.up())
self.vector_to_star = self.light_dir
if self.shadow_caster is not None:
self.shadow_caster.set_direction(-self.light_dir)
if self.directionalLight is not None:
self.directionalLight.setDirection(-self.light_dir)
if cosA >= 0:
coef = sqrt(cosA)
self.light_color = (1, coef, coef, 1)
self.directionalLight.setColor(self.light_color)
self.skybox.setColor(self.skybox_color * cosA)
else:
self.light_color = (1, 0, 0, 1)
self.directionalLight.setColor(self.light_color)
self.skybox.setColor(self.skybox_color * 0)
self.update()
def update(self):
self.object_collection.update_instance()
self.terrain.update_instance(None, None)
def apply_instance(self, instance):
pass
def create_instance_delayed(self):
pass
def get_apparent_radius(self):
return 0
def get_name(self):
return "terrain"
def is_emissive(self):
return False
def __init__(self):
CosmoniumBase.__init__(self)
config = RalphConfigParser()
(self.noise, self.biome_noise, self.terrain_control, self.terrain_appearance, self.water, self.fog) = config.load_and_parse('ralph-data/ralph.yaml')
self.tile_density = 64
self.default_size = 128
self.max_vertex_size = 64
self.max_lod = 10
self.size = 128 * 8
self.max_distance = 1.001 * self.size * sqrt(2)
self.noise_size = 512
self.biome_size = 128
self.noise_scale = 0.5 * self.size / self.default_size
self.objects_density = int(25 * (1.0 * self.size / self.default_size) * (1.0 * self.size / self.default_size))
self.objects_density = 250
self.height_scale = 100 * 5.0
self.has_water = True
self.fullscreen = False
self.shadow_caster = None
self.light_angle = None
self.light_dir = LVector3.up()
self.vector_to_star = self.light_dir
self.light_quat = LQuaternion()
self.light_color = (1.0, 1.0, 1.0, 1.0)
self.directionalLight = None
self.shadow_size = self.default_size / 8
self.shadow_box_length = self.height_scale
self.observer = RalphCamera(self.cam, self.camLens)
self.observer.init()
self.distance_to_obs = float('inf')
self.height_under = 0.0
self.scene_position = LVector3()
self.scene_scale_factor = 1
self.scene_orientation = LQuaternion()
#Size of an edge seen from 4 units above
self.edge_apparent_size = (1.0 * self.size / self.tile_density) / (4.0 * self.observer.pixel_size)
print("Apparent size:", self.edge_apparent_size)
self.win.setClearColor((135.0/255, 206.0/255, 235.0/255, 1))
# This is used to store which keys are currently pressed.
self.keyMap = {
"left": 0, "right": 0, "forward": 0, "backward": 0,
"cam-left": 0, "cam-right": 0, "cam-up": 0, "cam-down": 0,
"sun-left": 0, "sun-right": 0,
"turbo": 0}
# Set up the environment
#
# Create some lighting
self.vector_to_obs = base.cam.get_pos()
self.vector_to_obs.normalize()
if True:
self.shadow_caster = ShadowCaster(1024)
self.shadow_caster.create()
self.shadow_caster.set_lens(self.shadow_size, -self.shadow_box_length / 2.0, self.shadow_box_length / 2.0, -self.light_dir)
self.shadow_caster.set_pos(self.light_dir * self.shadow_box_length / 2.0)
self.shadow_caster.bias = 0.1
else:
self.shadow_caster = None
self.ambientLight = AmbientLight("ambientLight")
self.ambientLight.setColor((settings.global_ambient, settings.global_ambient, settings.global_ambient, 1))
self.directionalLight = DirectionalLight("directionalLight")
self.directionalLight.setDirection(-self.light_dir)
self.directionalLight.setColor(self.light_color)
self.directionalLight.setSpecularColor(self.light_color)
render.setLight(render.attachNewNode(self.ambientLight))
render.setLight(render.attachNewNode(self.directionalLight))
render.setShaderAuto()
base.setFrameRateMeter(True)
self.create_terrain()
self.create_populator()
self.terrain_shape.set_populator(self.object_collection)
self.create_tile(0, 0)
self.skybox_init()
self.set_light_angle(45)
# Create the main character, Ralph
ralphStartPos = LPoint3()
self.ralph = Actor("ralph-data/models/ralph",
{"run": "ralph-data/models/ralph-run",
"walk": "ralph-data/models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos + (0, 0, 0.5))
self.ralph_shape = InstanceShape(self.ralph)
self.ralph_shape.parent = self
self.ralph_shape.set_owner(self)
self.ralph_shape.create_instance()
self.ralph_appearance = ModelAppearance(self.ralph)
self.ralph_appearance.set_shadow(self.shadow_caster)
self.ralph_shader = BasicShader()
self.ralph_appearance.bake()
self.ralph_appearance.apply(self.ralph_shape, self.ralph_shader)
self.ralph_shader.apply(self.ralph_shape, self.ralph_appearance)
self.ralph_shader.update(self.ralph_shape, self.ralph_appearance)
# Create a floater object, which floats 2 units above ralph. We
# use this as a target for the camera to look at.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.ralph)
self.floater.setZ(2.0)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("control-q", sys.exit)
self.accept("arrow_left", self.setKey, ["left", True])
self.accept("arrow_right", self.setKey, ["right", True])
self.accept("arrow_up", self.setKey, ["forward", True])
self.accept("arrow_down", self.setKey, ["backward", True])
self.accept("shift", self.setKey, ["turbo", True])
self.accept("a", self.setKey, ["cam-left", True], direct=True)
self.accept("s", self.setKey, ["cam-right", True], direct=True)
self.accept("u", self.setKey, ["cam-up", True], direct=True)
self.accept("u-up", self.setKey, ["cam-up", False])
self.accept("d", self.setKey, ["cam-down", True], direct=True)
self.accept("d-up", self.setKey, ["cam-down", False])
self.accept("o", self.setKey, ["sun-left", True], direct=True)
self.accept("o-up", self.setKey, ["sun-left", False])
self.accept("p", self.setKey, ["sun-right", True], direct=True)
self.accept("p-up", self.setKey, ["sun-right", False])
self.accept("arrow_left-up", self.setKey, ["left", False])
self.accept("arrow_right-up", self.setKey, ["right", False])
self.accept("arrow_up-up", self.setKey, ["forward", False])
self.accept("arrow_down-up", self.setKey, ["backward", False])
self.accept("shift-up", self.setKey, ["turbo", False])
self.accept("a-up", self.setKey, ["cam-left", False])
self.accept("s-up", self.setKey, ["cam-right", False])
self.accept("w", self.toggle_water)
self.accept("h", self.print_debug)
self.accept("f2", self.connect_pstats)
self.accept("f3", self.toggle_filled_wireframe)
self.accept("shift-f3", self.toggle_wireframe)
self.accept("f5", self.bufferViewer.toggleEnable)
self.accept("f8", self.terrain_shape.dump_tree)
self.accept('alt-enter', self.toggle_fullscreen)
taskMgr.add(self.move, "moveTask")
# Game state variables
self.isMoving = False
# Set up the camera
self.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2)
self.camera_height = 2.0
render.set_shader_input("camera", self.camera.get_pos())
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 9)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(CollideMask.bit(0))
self.ralphGroundCol.setIntoCollideMask(CollideMask.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
#self.terrain_shape.test_lod(LPoint3d(*self.ralph.getPos()), self.distance_to_obs, self.pixel_size, self.terrain_appearance)
#self.terrain_shape.update_lod(LPoint3d(*self.ralph.getPos()), self.distance_to_obs, self.pixel_size, self.terrain_appearance)
#self.terrain.shape_updated()
self.terrain.update_instance(LPoint3d(*self.ralph.getPos()), None)
# Records the state of the arrow keys
def setKey(self, key, value):
self.keyMap[key] = value
# Accepts arrow keys to move either the player or the menu cursor,
# Also deals with grid checking and collision detection
def move(self, task):
# Get the time that elapsed since last frame. We multiply this with
# the desired speed in order to find out with which distance to move
# in order to achieve that desired speed.
dt = globalClock.getDt()
# If the camera-left key is pressed, move camera left.
# If the camera-right key is pressed, move camera right.
if self.keyMap["cam-left"]:
self.camera.setX(self.camera, -20 * dt)
if self.keyMap["cam-right"]:
self.camera.setX(self.camera, +20 * dt)
if self.keyMap["cam-up"]:
self.camera_height *= (1 + 2 * dt)
if self.keyMap["cam-down"]:
self.camera_height *= (1 - 2 * dt)
if self.camera_height < 1.0:
self.camera_height = 1.0
if self.keyMap["sun-left"]:
self.set_light_angle(self.light_angle + 30 * dt)
if self.keyMap["sun-right"]:
self.set_light_angle(self.light_angle - 30 * dt)
# save ralph's initial position so that we can restore it,
# in case he falls off the map or runs into something.
startpos = self.ralph.getPos()
# If a move-key is pressed, move ralph in the specified direction.
delta = 25
if self.keyMap["turbo"]:
delta *= 10
if self.keyMap["left"]:
self.ralph.setH(self.ralph.getH() + 300 * dt)
if self.keyMap["right"]:
self.ralph.setH(self.ralph.getH() - 300 * dt)
if self.keyMap["forward"]:
self.ralph.setY(self.ralph, -delta * dt)
if self.keyMap["backward"]:
self.ralph.setY(self.ralph, delta * dt)
#self.limit_pos(self.ralph)
# If ralph is moving, loop the run animation.
# If he is standing still, stop the animation.
if self.keyMap["forward"] or self.keyMap["backward"] or self.keyMap["left"] or self.keyMap["right"]:
if self.isMoving is False:
self.ralph.loop("run")
self.isMoving = True
else:
if self.isMoving:
self.ralph.stop()
self.ralph.pose("walk", 5)
self.isMoving = False
# If the camera is too far from ralph, move it closer.
# If the camera is too close to ralph, move it farther.
camvec = self.ralph.getPos() - self.camera.getPos()
camvec.setZ(0)
camdist = camvec.length()
camvec.normalize()
if camdist > 10.0:
self.camera.setPos(self.camera.getPos() + camvec * (camdist - 10))
camdist = 10.0
if camdist < 5.0:
self.camera.setPos(self.camera.getPos() - camvec * (5 - camdist))
camdist = 5.0
# Normally, we would have to call traverse() to check for collisions.
# However, the class ShowBase that we inherit from has a task to do
# this for us, if we assign a CollisionTraverser to self.cTrav.
self.cTrav.traverse(render)
if False:
# Adjust ralph's Z coordinate. If ralph's ray hit anything, put
# him back where he was last frame.
entries = list(self.ralphGroundHandler.getEntries())
entries.sort(key=lambda x: x.getSurfacePoint(render).getZ())
if len(entries) > 0:
self.ralph.setPos(startpos)
ralph_height = self.get_height(self.ralph.getPos())
self.ralph.setZ(ralph_height)
# Keep the camera at one foot above the terrain,
# or two feet above ralph, whichever is greater.
camera_height = self.get_height(self.camera.getPos()) + 1.0
if camera_height < ralph_height + self.camera_height:
self.camera.setZ(ralph_height + self.camera_height)
else:
self.camera.setZ(camera_height)
#self.limit_pos(self.camera)
# The camera should look in ralph's direction,
# but it should also try to stay horizontal, so look at
# a floater which hovers above ralph's head.
self.camera.lookAt(self.floater)
#self.shadow_caster.set_pos(self.ralph.get_pos())
self.shadow_caster.set_pos(self.ralph.get_pos() - camvec * camdist + camvec * self.shadow_size / 2)
render.set_shader_input("camera", self.camera.get_pos())
self.vector_to_obs = base.cam.get_pos()
self.vector_to_obs.normalize()
if self.isMoving:
#self.terrain_shape.test_lod(LPoint3d(*self.ralph.getPos()), self.distance_to_obs, self.pixel_size, self.terrain_appearance)
pass#self.terrain_shape.update_lod(LPoint3d(*self.ralph.getPos()), self.distance_to_obs, self.pixel_size, self.terrain_appearance)
self.object_collection.update_instance()
self.terrain.update_instance(LPoint3d(*self.ralph.getPos()), None)
return task.cont
def print_debug(self):
print("Height:", self.get_height(self.ralph.getPos()), self.terrain.get_height(self.ralph.getPos()))
print("Ralph:", self.ralph.get_pos())
print("Camera:", base.camera.get_pos())
def __init__(self):
self.loading = LoadingScreen()
base.setFrameRateMeter(True)
#input states
inputState.watchWithModifiers('forward', 'w')
inputState.watchWithModifiers('left', 'a')
inputState.watchWithModifiers('brake', 's')
inputState.watchWithModifiers('right', 'd')
inputState.watchWithModifiers('turnLeft', 'q')
inputState.watchWithModifiers('turnRight', 'e')
self.keyMap = {"hello": 0, "left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0, "cam-right": 0,
"chat0": 0, "powerup": 0, "reset": 0}
base.win.setClearColor(Vec4(0, 0, 0, 1))
# Network Setup
self.cManager = ConnectionManager(self)
self.startConnection()
#self.cManager.sendRequest(Constants.CMSG_LOGIN, ["username", "password"])
# chat box
# self.chatbox = Chat(self.cManager, self)
# Set up the environment
#
self.initializeBulletWorld(False)
#self.createEnvironment()
Track(self.bulletWorld)
# Create the main character, Ralph
self.mainCharRef = Vehicle(self.bulletWorld, (0, 25, 16, 0, 0, 0), self.login)
#self.mainCharRef = Character(self, self.bulletWorld, 0, "Me")
self.mainChar = self.mainCharRef.chassisNP
#self.mainChar.setPos(0, 25, 16)
# self.characters.append(self.mainCharRef)
# self.TestChar = Character(self, self.bulletWorld, 0, "test")
# self.TestChar.actor.setPos(0, 0, 0)
self.previousPos = self.mainChar.getPos()
taskMgr.doMethodLater(.1, self.updateMove, 'updateMove')
# Set Dashboard
self.dashboard = Dashboard(self.mainCharRef, taskMgr)
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
# Accept the control keys for movement and rotation
self.accept("escape", self.doExit)
self.accept("a", self.setKey, ["left", 1])
self.accept("d", self.setKey, ["right", 1])
self.accept("w", self.setKey, ["forward", 1])
self.accept("s", self.setKey, ["backward", 1])
self.accept("arrow_left", self.setKey, ["cam-left", 1])
self.accept("arrow_right", self.setKey, ["cam-right", 1])
self.accept("a-up", self.setKey, ["left", 0])
self.accept("d-up", self.setKey, ["right", 0])
self.accept("w-up", self.setKey, ["forward", 0])
self.accept("s-up", self.setKey, ["backward", 0])
self.accept("arrow_left-up", self.setKey, ["cam-left", 0])
self.accept("arrow_right-up", self.setKey, ["cam-right", 0])
self.accept("h", self.setKey, ["hello", 1])
self.accept("h-up", self.setKey, ["hello", 0])
self.accept("0", self.setKey, ["chat0", 1])
self.accept("0-up", self.setKey, ["chat0", 0])
self.accept("1", self.setKey,["powerup", 1])
self.accept("1-up", self.setKey,["powerup", 0])
self.accept("2", self.setKey,["powerup", 2])
self.accept("2-up", self.setKey,["powerup", 0])
self.accept("3", self.setKey,["powerup", 3])
self.accept("3-up", self.setKey,["powerup", 0])
self.accept("r", self.doReset)
self.accept("p", self.setTime)
#self.loading.finish()
#taskMgr.doMethodLater(5, self.move, "moveTask")
# Game state variables
self.isMoving = False
# Sky Dome
self.sky = SkyDome()
# Set up the camera
self.camera = Camera(self.mainChar, self.bulletWorld)
#base.disableMouse()
#base.camera.setPos(self.mainChar.getX(), self.mainChar.getY() + 10, self.mainChar.getZ() + 2)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
directionalLight2 = DirectionalLight("directionalLight2")
directionalLight2.setDirection(Vec3(5, 5, -5))
directionalLight2.setColor(Vec4(1, 1, 1, 1))
directionalLight2.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
render.setLight(render.attachNewNode(directionalLight2))
# Game initialisation
self.gameState = self.gameStateDict["Login"]
self.responseValue = -1
self.cManager.sendRequest(Constants.CMSG_LOGIN,[self.login,"1234"])
taskMgr.add(self.enterGame,"EnterGame")
# Create Powerups
self.createPowerups()
taskMgr.add(self.powerups.checkPowerPickup, "checkPowerupTask")
taskMgr.add(self.usePowerup, "usePowerUp")
def __init__(self):
# This code puts the standard title and instruction text on screen
self.title = OnscreenText(text="Ball in Maze",
style=1,
fg=(1, 1, 1, 1),
pos=(0.7, -0.95),
scale=.07)
self.instructions = OnscreenText(text="Press Esc to exit.",
pos=(-1.3, .95),
fg=(1, 1, 1, 1),
align=TextNode.ALeft,
scale=.05)
base.setBackgroundColor(0, 0, 0)
self.central_msg = OnscreenText(text="",
pos=(0, 0),
fg=(1, 1, 0, 1),
scale=.1)
self.central_msg.hide()
self.accept("escape", sys.exit) # Escape quits
base.disableMouse() # Disable mouse-based camera control
camera.setPosHpr(0, 0, 25, 0, -90, 0) # Place the camera
# Load the maze and place it in the scene
self.maze = loader.loadModel("models/maze")
self.maze.reparentTo(render)
# Most times, you want collisions to be tested against invisible geometry
# rather than every polygon. This is because testing against every polygon
# in the scene is usually too slow. You can have simplified or approximate
# geometry for the solids and still get good results.
#
# Sometimes you'll want to create and position your own collision solids in
# code, but it's often easier to have them built automatically. This can be
# done by adding special tags into an egg file. Check maze.egg and ball.egg
# and look for lines starting with <Collide>. The part is brackets tells
# Panda exactly what to do. Polyset means to use the polygons in that group
# as solids, while Sphere tells panda to make a collision sphere around them
# Keep means to keep the polygons in the group as visable geometry (good
# for the ball, not for the triggers), and descend means to make sure that
# the settings are applied to any subgroups.
#
# Once we have the collision tags in the models, we can get to them using
# NodePath's find command
# Find the collision node named wall_collide
self.walls = self.maze.find("**/wall_collide")
# Collision objects are sorted using BitMasks. BitMasks are ordinary numbers
# with extra methods for working with them as binary bits. Every collision
# solid has both a from mask and an into mask. Before Panda tests two
# objects, it checks to make sure that the from and into collision masks
# have at least one bit in common. That way things that shouldn't interact
# won't. Normal model nodes have collision masks as well. By default they
# are set to bit 20. If you want to collide against actual visable polygons,
# set a from collide mask to include bit 20
#
# For this example, we will make everything we want the ball to collide with
# include bit 0
self.walls.node().setIntoCollideMask(BitMask32.bit(0))
# CollisionNodes are usually invisible but can be shown. Uncomment the next
# line to see the collision walls
# self.walls.show()
# We will now find the triggers for the holes and set their masks to 0 as
# well. We also set their names to make them easier to identify during
# collisions
self.loseTriggers = []
for i in range(6):
trigger = self.maze.find("**/hole_collide" + str(i))
trigger.node().setIntoCollideMask(BitMask32.bit(0))
trigger.node().setName("loseTrigger")
self.loseTriggers.append(trigger)
# Uncomment this line to see the triggers
# trigger.show()
# Ground_collide is a single polygon on the same plane as the ground in the
# maze. We will use a ray to collide with it so that we will know exactly
# what height to put the ball at every frame. Since this is not something
# that we want the ball itself to collide with, it has a different
# bitmask.
self.mazeGround = self.maze.find("**/ground_collide")
self.mazeGround.node().setIntoCollideMask(BitMask32.bit(1))
# Load the ball and attach it to the scene
# It is on a root dummy node so that we can rotate the ball itself without
# rotating the ray that will be attached to it
self.ballRoot = render.attachNewNode("ballRoot")
self.ball = loader.loadModel("models/ball")
self.ball.reparentTo(self.ballRoot)
# Find the collison sphere for the ball which was created in the egg file
# Notice that it has a from collision mask of bit 0, and an into collison
# mask of no bits. This means that the ball can only cause collisions, not
# be collided into
self.ballSphere = self.ball.find("**/ball")
self.ballSphere.node().setFromCollideMask(BitMask32.bit(0))
self.ballSphere.node().setIntoCollideMask(BitMask32.allOff())
# No we create a ray to start above the ball and cast down. This is to
# Determine the height the ball should be at and the angle the floor is
# tilting. We could have used the sphere around the ball itself, but it
# would not be as reliable
self.ballGroundRay = CollisionRay() # Create the ray
self.ballGroundRay.setOrigin(0, 0, 10) # Set its origin
self.ballGroundRay.setDirection(0, 0, -1) # And its direction
# Collision solids go in CollisionNode
self.ballGroundCol = CollisionNode(
'groundRay') # Create and name the node
self.ballGroundCol.addSolid(self.ballGroundRay) # Add the ray
self.ballGroundCol.setFromCollideMask(
BitMask32.bit(1)) # Set its bitmasks
self.ballGroundCol.setIntoCollideMask(BitMask32.allOff())
# Attach the node to the ballRoot so that the ray is relative to the ball
# (it will always be 10 feet over the ball and point down)
self.ballGroundColNp = self.ballRoot.attachNewNode(self.ballGroundCol)
# Uncomment this line to see the ray
# self.ballGroundColNp.show()
# Finally, we create a CollisionTraverser. CollisionTraversers are what
# do the job of calculating collisions
self.cTrav = CollisionTraverser()
# Collision traverservs tell collision handlers about collisions, and then
# the handler decides what to do with the information. We are using a
# CollisionHandlerQueue, which simply creates a list of all of the
# collisions in a given pass. There are more sophisticated handlers like
# one that sends events and another that tries to keep collided objects
# apart, but the results are often better with a simple queue
self.cHandler = CollisionHandlerQueue()
# Now we add the collision nodes that can create a collision to the
# traverser. The traverser will compare these to all others nodes in the
# scene. There is a limit of 32 CollisionNodes per traverser
# We add the collider, and the handler to use as a pair
self.cTrav.addCollider(self.ballSphere, self.cHandler)
self.cTrav.addCollider(self.ballGroundColNp, self.cHandler)
# Collision traversers have a built in tool to help visualize collisions.
# Uncomment the next line to see it.
# self.cTrav.showCollisions(render)
# This section deals with lighting for the ball. Only the ball was lit
# because the maze has static lighting pregenerated by the modeler
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.55, .55, .55, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(0, 0, -1))
directionalLight.setColor(Vec4(0.375, 0.375, 0.375, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
self.ballRoot.setLight(render.attachNewNode(ambientLight))
self.ballRoot.setLight(render.attachNewNode(directionalLight))
# This section deals with adding a specular highlight to the ball to make
# it look shiny
m = Material()
m.setSpecular(Vec4(1, 1, 1, 1))
m.setShininess(96)
self.ball.setMaterial(m, 1)
# Finally, we call start for more initialization
self.start()
def __init__(self):
#base = ShowBase()
ShowBase.__init__(self)
self.keyMap = {"left":0, "right":0, "forward":0, "cam-left":0, "cam-right":0}
base.win.setClearColor(Vec4(0,0,0,1))
self.texto1 = OnscreenText(text="Collect 8 balls and meet Sonic behind the building", style=1, fg=(1,1,1,1), pos=(0,-0.1), align=TextNode.ACenter, scale = .07)
self.texto2 = OnscreenText(text="Eat bananas for energy and avoid green stones", style=1, fg=(1,1,1,1), pos=(0,-0.2), align=TextNode.ACenter, scale = .07)
self.texto3 = OnscreenText(text="Arrow keys move the player", style=1, fg=(1,1,1,1), pos=(0,-0.3), align=TextNode.ACenter, scale = .07)
self.texto4 = OnscreenText(text="a and s help you view the scene", style=1, fg=(1,1,1,1), pos=(0,-0.4), align=TextNode.ACenter, scale = .07)
mySound = base.loader.loadSfx("models/Theme_song.ogg")
mySound.setLoop(True)
mySound.play()
#mySound.setLoop(true)
self.noOfbanana = self.makeStatusLabel(0)
self.noOfBalls = self.makeStatusLabel(1)
self.points = self.makeStatusLabel(2)
self.environ = self.loader.loadModel("models/moonsurface.egg")
self.environ.reparentTo(self.render)
self.environ.setScale(0.25, 0.25, 0.25)
self.environ.setPos(-8, 42, -3)
self.environ1 = self.loader.loadModel("models/env")
self.environ1.reparentTo(self.render)
self.environ1.setScale(50,50,30)
self.environ1.setPos(0, -170, -3)
#self.environ1.setHpr(90,0,0)
self.chair1=self.loader.loadModel("models/BeachChair")
#self.chair1=self.reaparentTo(self.render)
#self.setScale(1000)
#self.setPos(25,-160,-3)
#self.chair1.setHpr(90,0,0)
self.house1 = self.loader.loadModel("models/houses/church")
self.house1.reparentTo(self.render)
self.house1.setScale(0.30)
self.house1.setPos(25, -150, -3)
self.house1.setHpr(90,0,0)
self.house2 = self.loader.loadModel("models/houses/building")
self.house2.reparentTo(self.render)
self.house2.setScale(0.30)
self.house2.setPos(18, -200, -3)
self.house2.setHpr(180,0,0)
self.house3 = self.loader.loadModel("models/houses/farmhouse")
self.house3.reparentTo(self.render)
self.house3.setScale(0.30)
self.house3.setPos(20, -130, -3)
self.house3.setHpr(90,0,0)
self.house4 = self.loader.loadModel("models/houses/dojo")
self.house4.reparentTo(self.render)
self.house4.setScale(0.05)
self.house4.setPos(5, -220, -3)
self.house5 = self.loader.loadModel("models/houses/beachhouse2")
self.house5.reparentTo(self.render)
self.house5.setScale(0.30)
self.house5.setPos(-10, -180, -3)
self.house5.setHpr(-90,0,0)
self.house6 = self.loader.loadModel("models/houses/gazebo")
self.house6.reparentTo(self.render)
self.house6.setScale(0.50)
self.house6.setPos(-10, -200, -3)
self.house7 = self.loader.loadModel("models/houses/building")
self.house7.reparentTo(self.render)
self.house7.setScale(0.30)
self.house7.setPos(-10, -120, -3)
''' for x in range(0,8):
self.load4 = loader.loadModel("models/fence")
self.load4.reparentTo(render)
self.load4.setScale(.5, .5, 1.3)
self.load4.setPos(28-x*7,0,1.8)
cp = self.load4.attachNewNode(CollisionNode('box'))
cp.node().addSolid(CollisionPolygon(
Point3(-10.0,0.0,4),Point3(10,0,4),
Point3(10,-1,-2),Point3(-10,-1,-2))) '''
self.tunnel = [None for i in range(10)]
for x in range(10):
#Load a copy of the tunnel
self.tunnel[x] = loader.loadModel('models/tunnel')
self.tunnel[x].setHpr(0,90,0)
self.tunnel[x].setScale(0.5)
self.tunnel[x].setPos(0,177.5 + 25*x, 0)
self.tunnel[x].reparentTo(self.render)
## ###World specific-code
##
## #Create an instance of fog called 'distanceFog'.
## #'distanceFog' is just a name for our fog, not a specific type of fog.
## self.fog = Fog('distanceFog')
## #Set the initial color of our fog to black.
## self.fog.setColor(0, 0, 0)
## #Set the density/falloff of the fog. The range is 0-1.
## #The higher the numer, the "bigger" the fog effect.
## self.fog.setExpDensity(.08)
## #We will set fog on render which means that everything in our scene will
## #be affected by fog. Alternatively, you could only set fog on a specific
## #object/node and only it and the nodes below it would be affected by
## #the fog.
## render.setFog(self.fog)
self.banana = [None for i in range(20)]
self.flag = [0 for i in range(20)]
self.fla = [0 for i in range(5)]
self.fl = [0 for i in range(8)]
for x in range(10):
#Load a copy of the tunnel
self.banana[x] = loader.loadModel('models/banana/banana')
#self.banana[x].setHpr(0,90,0)
self.banana[x].setScale(0.7)
if(x%2==0):
self.banana[x].setPos(-1,180 + 25*x, -2)
else:
self.banana[x].setPos(1,177.5 + 25*x, -2)
self.banana[x].reparentTo(self.render)
self.banana[11] = self.loader.loadModel("models/banana/banana")
self.banana[11].reparentTo(self.render)
self.banana[11].setPos(12, 8, -2)
self.banana[12] = self.loader.loadModel("models/banana/banana")
self.banana[12].reparentTo(self.render)
self.banana[12].setPos(0, 120, -2)
self.banana[13] = self.loader.loadModel("models/banana/banana")
self.banana[13].reparentTo(self.render)
self.banana[13].setPos(12, 100, -2)
self.banana[14] = self.loader.loadModel("models/banana/banana")
self.banana[14].reparentTo(self.render)
self.banana[14].setPos(22, 80, -2)
self.banana[15] = self.loader.loadModel("models/banana/banana")
self.banana[15].reparentTo(self.render)
self.banana[15].setPos(12, 50, -2)
self.banana[16] = self.loader.loadModel("models/banana/banana")
self.banana[16].reparentTo(self.render)
self.banana[16].setPos(15, 30, -2)
self.banana[17] = self.loader.loadModel("models/banana/banana")
self.banana[17].reparentTo(self.render)
self.banana[17].setPos(-10, 8, -2)
self.banana[18] = self.loader.loadModel("models/banana/banana")
self.banana[18].reparentTo(self.render)
self.banana[18].setPos(-20, -30, -2)
self.banana[19] = self.loader.loadModel("models/banana/banana")
self.banana[19].reparentTo(self.render)
self.banana[19].setPos(-50, -50, -2)
self.candy = self.loader.loadModel("models/candy/candycane2")
self.candy.reparentTo(self.render)
self.candy.setScale(0.001)
self.candy.setPos(-6, 10, -2)
self.fire = self.loader.loadModel("models/candy/candycane2")
self.fire.reparentTo(self.render)
self.fire.setScale(0.001)
self.fire.setPos(0, 2, -2)
self.ball = [None for i in range(8)]
self.ball[0] = self.loader.loadModel("models/ball/soccerball")
self.ball[0].reparentTo(self.render)
self.ball[0].setPos(-6, 6, -2)
self.ball[0].setScale(0.7)
self.ball[1] = self.loader.loadModel("models/ball/soccerball")
self.ball[1].reparentTo(self.render)
self.ball[1].setPos(-6, -6, -2)
self.ball[1].setScale(0.7)
self.ball[2] = self.loader.loadModel("models/ball/soccerball")
self.ball[2].reparentTo(self.render)
self.ball[2].setPos(-15, 10, -2)
self.ball[2].setScale(0.7)
self.ball[3] = self.loader.loadModel("models/ball/soccerball")
self.ball[3].reparentTo(self.render)
self.ball[3].setPos(-19, 0, -2)
self.ball[3].setScale(0.7)
self.ball[4] = self.loader.loadModel("models/ball/soccerball")
self.ball[4].reparentTo(self.render)
self.ball[4].setPos(-6, -20, -2)
self.ball[4].setScale(0.7)
self.ball[5] = self.loader.loadModel("models/ball/soccerball")
self.ball[5].reparentTo(self.render)
self.ball[5].setPos(6, 6, -2)
self.ball[5].setScale(0.7)
self.ball[6] = self.loader.loadModel("models/ball/soccerball")
self.ball[6].reparentTo(self.render)
self.ball[6].setPos(19, 10, -2)
self.ball[6].setScale(0.7)
self.ball[7] = self.loader.loadModel("models/ball/soccerball")
self.ball[7].reparentTo(self.render)
self.ball[7].setPos(-15, 12, -2)
self.ball[7].setScale(0.7)
self.rock = [None for i in range(8)]
self.rock[0] = self.loader.loadModel("models/greencrystal")
self.rock[0].reparentTo(self.render)
self.rock[0].setPos(0,306, -4)
self.rock[0].setScale(0.007)
self.rock[0].setHpr(90,0,0)
self.rock[1] = self.loader.loadModel("models/greencrystal")
self.rock[1].reparentTo(self.render)
self.rock[1].setPos(-2, 150, -3)
self.rock[1].setScale(0.007)
self.rock[1].setHpr(90,0,0)
self.rock[2] = self.loader.loadModel("models/greencrystal")
self.rock[2].reparentTo(self.render)
self.rock[2].setPos(-10, 10, -3)
self.rock[2].setScale(0.007)
self.rock[2].setHpr(90,0,0)
self.rock[3] = self.loader.loadModel("models/greencrystal")
self.rock[3].reparentTo(self.render)
self.rock[3].setPos(5, 0, -3)
self.rock[3].setScale(0.007)
self.rock[3].setHpr(90,0,0)
self.rock[4] = self.loader.loadModel("models/greencrystal")
self.rock[4].reparentTo(self.render)
self.rock[4].setPos(-2, -120, -3)
self.rock[4].setScale(0.007)
self.rock[4].setHpr(90,0,0)
self.tire = self.loader.loadModel("models/tire/tire")
self.tire.reparentTo(self.render)
self.tire.setScale(0.25, 0.25, 0.25)
self.tire.setPos(-20, 3, -2)
self.bunny1 = self.loader.loadModel("models/bunny")
self.bunny1.reparentTo(self.render)
self.bunny1.setScale(0.2)
self.bunny1.setPos(15, -160, -3)
self.bunny1.setHpr(-60,0,0)
self.bunny2 = self.loader.loadModel("models/bunny")
self.bunny2.reparentTo(self.render)
self.bunny2.setScale(0.2)
self.bunny2.setPos(15, -161, -3)
self.bunny2.setHpr(-145,0,0)
# Add the spinCameraTask procedure to the task manager.
#self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
# Load and transform the panda actor.
self.pandaActor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.pandaActor.setScale(0.005, 0.005, 0.005)
#self.pandaActor.setPos(0,100,-3)
self.pandaActor.reparentTo(self.render)
# Loop its animation.
self.pandaActor.loop("walk")
# Create the four lerp intervals needed for the panda to
# walk back and forth.
pandaPosInterval1 = self.pandaActor.posInterval(20,
Point3(0, -110, -3),
startPos=Point3(0, -90, -3))
pandaPosInterval2 = self.pandaActor.posInterval(20,
Point3(0, -90, -3),
startPos=Point3(0, -110, -3))
pandaHprInterval1 = self.pandaActor.hprInterval(3,
Point3(180, 0, 0),
startHpr=Point3(0, 0, 0))
pandaHprInterval2 = self.pandaActor.hprInterval(3,
Point3(0, 0, 0),
startHpr=Point3(180, 0, 0))
# Create and play the sequence that coordinates the intervals.
self.pandaPace = Sequence(pandaPosInterval1,
pandaHprInterval1,
pandaPosInterval2,
pandaHprInterval2,
name="pandaPace")
self.pandaPace.loop()
self.eve = Actor("models/eve",
{"walk": "models/eve-walk"})
self.eve.setScale(0.5, 0.5, 0.5)
self.eve.setPos(-1,-140,-3)
self.eve.reparentTo(self.render)
# Loop its animation.
self.eve.loop("walk")
# Create the four lerp intervals needed for the panda to
# walk back and forth.
evePosInterval1 = self.eve.posInterval(20,
Point3(-1, -160, -3),
startPos=Point3(-1, -140, -3))
evePosInterval2 = self.eve.posInterval(20,
Point3(-1, -140, -3),
startPos=Point3(-1, -160, -3))
eveHprInterval1 = self.eve.hprInterval(3,
Point3(180, 0, 0),
startHpr=Point3(0, 0, 0))
eveHprInterval2 = self.eve.hprInterval(3,
Point3(0, 0, 0),
startHpr=Point3(180, 0, 0))
# Create and play the sequence that coordinates the intervals.
self.evePace = Sequence(evePosInterval1,eveHprInterval1,evePosInterval2,eveHprInterval2,name="evePace")
self.evePace.loop()
self.ralph = Actor("models/r/ralph",
{"run":"models/ralph-run",
"walk": "models/ralph-walk"})
self.ralph.setScale(0.5, 0.5, 0.5)
self.ralph.setPos(0, 420, -3)
self.ralph.reparentTo(self.render)
self.boy = Actor("models/soni/sonic",
{"anim":"models/soni/sonic-win"})
self.boy.setScale(0.05, 0.05, 0.05)
self.boy.setPos(33, -203, -2)
self.boy.setHpr(-90,0,0)
self.boy.reparentTo(self.render)
self.boy.loop("anim")
self.boy1 = Actor("models/boy/boymodel",
{"anim":"models/boy/boyanimation"})
self.boy1.setScale(0.007)
self.boy1.setPos(-5, -200, -2)
self.boy1.setHpr(180,0,0)
self.boy1.reparentTo(self.render)
self.boy1.loop("anim")
self.character=Actor()
self.character.loadModel('models/dancer')
self.character.setPos(3,150,-3)
self.character.reparentTo(render)
self.character.setHpr(180,0,0)
self.character.setScale(0.6)
self.character.loadAnims({'win':'models/dancer'})
self.character.loop('win')
self.character1=Actor()
self.character1.loadModel('models/gorillawalking')
self.character1.setPos(2,-13,-3)
self.character1.setScale(0.6)
self.character1.reparentTo(render)
self.character1.setHpr(180,0,0)
self.character1.loadAnims({'win':'models/gorillawalking'})
self.character1.loop('win')
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left",1])
self.accept("arrow_right", self.setKey, ["right",1])
self.accept("arrow_up", self.setKey, ["forward",1])
self.accept("a", self.setKey, ["cam-left",1])
self.accept("s", self.setKey, ["cam-right",1])
self.accept("arrow_left-up", self.setKey, ["left",0])
self.accept("arrow_right-up", self.setKey, ["right",0])
self.accept("arrow_up-up", self.setKey, ["forward",0])
self.accept("a-up", self.setKey, ["cam-left",0])
self.accept("s-up", self.setKey, ["cam-right",0])
taskMgr.add(self.move,"moveTask")
taskMgr.add(self.find,"fisdTask")
taskMgr.add(self.potask,"potaskTask")
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.ralph.getX(),self.ralph.getY()+10,-1)
#print self.ralph.getX(), self.ralph.getY()
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
self.updateStatusLabel()
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0,0,1000)
self.ralphGroundRay.setDirection(0,0,-1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,1000)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
def __init__(self):
# Set up the window, camera, etc.
ShowBase.__init__(self)
# Set the background color to black
self.win.setClearColor((0, 0, 0, 1))
# This is used to store which keys are currently pressed.
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"cam-left": 0,
"cam-right": 0
}
# Post the instructions
self.title = addTitle(
"Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)")
self.inst1 = addInstructions(0.06, "[ESC]: Quit")
self.inst2 = addInstructions(0.12, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.18, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.24, "[Up Arrow]: Run Ralph Forward")
self.inst6 = addInstructions(0.30, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.36, "[S]: Rotate Camera Right")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
# Create the main character, Ralph
ralphStartPos = self.environ.find("**/start_point").getPos()
self.ralph = Actor("models/ralph", {
"run": "models/ralph-run",
"walk": "models/ralph-walk"
})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos + (0, 0, 0.5))
# Create a floater object, which floats 2 units above ralph. We
# use this as a target for the camera to look at.
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.ralph)
self.floater.setZ(2.0)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left", True])
self.accept("arrow_right", self.setKey, ["right", True])
self.accept("arrow_up", self.setKey, ["forward", True])
self.accept("a", self.setKey, ["cam-left", True])
self.accept("s", self.setKey, ["cam-right", True])
self.accept("arrow_left-up", self.setKey, ["left", False])
self.accept("arrow_right-up", self.setKey, ["right", False])
self.accept("arrow_up-up", self.setKey, ["forward", False])
self.accept("a-up", self.setKey, ["cam-left", False])
self.accept("s-up", self.setKey, ["cam-right", False])
taskMgr.add(self.move, "moveTask")
# Game state variables
self.isMoving = False
# Set up the camera
self.disableMouse()
self.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 9)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(CollideMask.bit(0))
self.ralphGroundCol.setIntoCollideMask(CollideMask.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 9)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(CollideMask.bit(0))
self.camGroundCol.setIntoCollideMask(CollideMask.allOff())
self.camGroundColNp = self.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection((-5, -5, -5))
directionalLight.setColor((1, 1, 1, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
## Add the default values to the dictionary.
self.keyMap = {"left":0, "right":0, "forward":0, \
"boost":0, "strafeL":0, "strafeR":0, \
"cam-left":0, "cam-right":0}
base.win.setClearColor(Vec4(0, 0, 0, 1))
self.jump = False
self.jumped = False
# Post the instructions
self.title = addTitle(
"Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.85, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.80, "[Up Arrow]: Run Ralph Forward")
self.inst6 = addInstructions(0.70, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.65, "[D]: Rotate Camera Right")
self.inst8 = addInstructions(0.60, "[B]: Ralph Boost")
self.inst9 = addInstructions(0.55, "[V]: Strafe Left")
self.inst10 = addInstructions(0.50, "[N]: Strafe Right")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0, 0, 0)
## Stops the sound as soon as the world renders
## Note:Sound won't play very long becasue the game takes seconds to compile and load
## Remove loading screen after world is rendered and ready to go.
loadingText.cleanup()
mySound.stop()
# Create the main character, Ralph
ralphStartPos = self.environ.find("**/start_point").getPos()
self.ralph = Actor("models/ralph", {
"run": "models/ralph-run",
"walk": "models/ralph-walk"
})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos)
# 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)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left", 1])
self.accept("arrow_right", self.setKey, ["right", 1])
self.accept("arrow_up", self.setKey, ["forward", 1])
self.accept("a", self.setKey, ["cam-left", 1])
self.accept("d", self.setKey, ["cam-right", 1])
self.accept("b", self.setKey, ["boost", 1])
self.accept("v", self.setKey, ["strafeL", 1])
self.accept("n", self.setKey, ["strafeR", 1])
## -up to signify what happens when you let go of the key
self.accept("b-up", self.setKey, ["boost", 0])
self.accept("v-up", self.setKey, ["strafeL", 0])
self.accept("n-up", self.setKey, ["strafeR", 0])
self.accept("arrow_left-up", self.setKey, ["left", 0])
self.accept("arrow_right-up", self.setKey, ["right", 0])
self.accept("arrow_up-up", self.setKey, ["forward", 0])
self.accept("a-up", self.setKey, ["cam-left", 0])
self.accept("d-up", self.setKey, ["cam-right", 0])
taskMgr.add(self.move, "moveTask")
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 1000)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 1000)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
self.keyMap = {"left":0, "right":0, "forward":0, "cam-left":0, "cam-right":0}
base.win.setClearColor(Vec4(0,0,0,1))
# Post the instructions
self.title = addTitle("Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[Left Arrow]: Rotate Ralph Left")
self.inst3 = addInstructions(0.85, "[Right Arrow]: Rotate Ralph Right")
self.inst4 = addInstructions(0.80, "[Up Arrow]: Run Ralph Forward")
self.inst6 = addInstructions(0.70, "[A]: Rotate Camera Left")
self.inst7 = addInstructions(0.65, "[S]: Rotate Camera Right")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
# Create the main character, Ralph
ralphStartPos = self.environ.find("**/start_point").getPos()
#self.addRalph(ralphStartPos)
# 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)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left",1])
self.accept("arrow_right", self.setKey, ["right",1])
self.accept("arrow_up", self.setKey, ["forward",1])
self.accept("a", self.setKey, ["cam-left",1])
self.accept("s", self.setKey, ["cam-right",1])
self.accept("arrow_left-up", self.setKey, ["left",0])
self.accept("arrow_right-up", self.setKey, ["right",0])
self.accept("arrow_up-up", self.setKey, ["forward",0])
self.accept("a-up", self.setKey, ["cam-left",0])
self.accept("s-up", self.setKey, ["cam-right",0])
taskMgr.add(self.move,"moveTask")
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
# Add some text
'''
def __init__(self):
#Let's start the Music
mySound = base.loader.loadSfx("music/music.mp3")
mySound.setLoopCount(0) #And Keep it On Loop
mySound.play()
base.setFrameRateMeter(True) #Shows the FrameRate in The Top Corner
self.walking = Vec3()
self.isMoving = False
self.dest = None
base.win.setClearColor(Vec4(0,0,0,1))
self.keyMap = {"left":0, "right":0, "forward":0, "backward":0}
base.win.setClearColor(Vec4(0,0,0,1))
#Here is the number of collectibles in the game
self.rare = 1;
self.vasenum = 10;
self.coinnum = 30;
self.silvernum = 5;
self.chestnum = 2;
#Here is the Obstacles in the game
self.rocknum = 500;
#Here is the Score
self.score = 0;
#Here is the total Number of Objects to collect
self.numObjects = self.rare + self.vasenum + self.coinnum + self.silvernum + self.chestnum
# print the number of objects
printNumObj(self.score)
# Post the instructions
self.title = addTitle("Mighty Mountain")
self.inst1 = addInstructions(0.95, "[ESC]: Quit")
self.inst2 = addInstructions(0.90, "[A]: Rotate Ralph Left")
self.inst3 = addInstructions(0.85, "[D]: Rotate Ralph Right")
self.inst4 = addInstructions(0.80, "[W]: Run Ralph Forward")
self.inst5 = addInstructions(0.75, "[S]: Run Ralph Backward")
self.inst6 = addInstructions(0.70, "[Space]: Run, Ralph, Run")
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0,0,0)
# Timer to increment in the move task
self.time = 0
# Get bounds of environment
min, max = self.environ.getTightBounds()
self.mapSize = max-min
# Create the main character, Ralph
self.ralphStartPos = self.environ.find("**/start_point").getPos()
self.ralph = Actor("models/ralph",
{"run":"models/ralph-run",
"walk":"models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(self.ralphStartPos)
# ralph's stamina
self.stamina = 200
# 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)
# Accept the control keys for movement and rotation
self.accept("escape", self.endgame)
# these don't work well in combination with the space bar
self.accept("arrow_left", self.setKey, ["left",1])
self.accept("arrow_right", self.setKey, ["right",1])
self.accept("arrow_up", self.setKey, ["forward",1])
self.accept("arrow_down", self.setKey, ["backward",1])
self.accept("arrow_left-up", self.setKey, ["left",0])
self.accept("arrow_right-up", self.setKey, ["right",0])
self.accept("arrow_up-up", self.setKey, ["forward",0])
self.accept("arrow_down-up", self.setKey, ["backward",0])
self.accept("space", self.runRalph, [True])
self.accept("space-up", self.runRalph, [False])
self.accept("a", self.setKey, ["left",1])
self.accept("d", self.setKey, ["right",1])
self.accept("w", self.setKey, ["forward",1])
self.accept("s", self.setKey, ["backward",1])
self.accept("a-up", self.setKey, ["left",0])
self.accept("d-up", self.setKey, ["right",0])
self.accept("w-up", self.setKey, ["forward",0])
self.accept("s-up", self.setKey, ["backward",0])
# Game state variables
self.isMoving = False
self.isRunning = False
# Set up the camera
base.disableMouse()
#base.camera.setPos(self.ralph.getX(),self.ralph.getY()+10,2)
base.camera.setPos(0, 0, 0)
base.camera.reparentTo(self.ralph)
base.camera.setPos(0, 40, 2)
base.camera.lookAt(self.ralph)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
base.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0,0,300)
self.ralphGroundRay.setDirection(0,0,-1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
base.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
# camera ground collision handler
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,300)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
base.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Place the collectibles
self.placeCollectibles() #Platinum
self.placeVases()
self.placeCoins()
self.placeSilver()
self.placeGold()
self.placeChests()
#Place the obstacles
self.placeRocks() #Cactus
# Uncomment this line to show a visual representation of the
# collisions occuring
#base.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
taskMgr.add(self.move,"moveTask")
def __init__(self):
#create Queue to hold the incoming chat
#request the heartbeat so that the caht interface is being refreshed in order to get the message from other player
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"cam-left": 0,
"cam-right": 0,
"charge": 0
}
base.win.setClearColor(Vec4(0, 0, 0, 1))
self.cManager = ConnectionManager()
self.cManager.startConnection()
#------------------------------
#Chat
Chat(self.cManager)
#send dummy login info of the particular client
#send first chat info
#---------------------------------------
self.userName = username
dummy_login = {
'user_id': self.userName,
'factionId': faction,
'password': '******'
}
self.cManager.sendRequest(Constants.RAND_STRING, dummy_login)
chat = {
'userName': self.userName, #username
'message': '-------Login------'
}
self.cManager.sendRequest(Constants.CMSG_CHAT, chat)
#--------------------------------------
#self.minimap = OnscreenImage(image="images/minimap.png", scale=(0.2,1,0.2), pos=(-1.1,0,0.8))
#frame = DirectFrame(text="Resource Bar", scale=0.001)
resource_bar = DirectWaitBar(text="",
value=35,
range=100,
pos=(0, 0, 0.9),
barColor=(255, 255, 0, 1),
frameSize=(-0.3, 0.3, 0, 0.03))
cp_bar = DirectWaitBar(text="",
value=70,
range=100,
pos=(1.0, 0, 0.9),
barColor=(0, 0, 255, 1),
frameSize=(-0.3, 0.3, 0, 0.03),
frameColor=(255, 0, 0, 1))
# Set up the environment
#
# This environment model contains collision meshes. If you look
# in the egg file, you will see the following:
#
# <Collide> { Polyset keep descend }
#
# This tag causes the following mesh to be converted to a collision
# mesh -- a mesh which is optimized for collision, not rendering.
# It also keeps the original mesh, so there are now two copies ---
# one optimized for rendering, one for collisions.
self.environ = loader.loadModel("models/world")
self.environ.reparentTo(render)
self.environ.setPos(0, 0, 0)
# Create the main character, Ralph
ralphStartPos = self.environ.find("**/start_point").getPos()
self.ralph = Actor("models/ralph", {
"run": "models/ralph-run",
"walk": "models/ralph-walk"
})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos)
nameplate = TextNode('textNode username_' + str(self.userName))
nameplate.setText(self.userName)
npNodePath = self.ralph.attachNewNode(nameplate)
npNodePath.setScale(0.8)
npNodePath.setBillboardPointEye()
#npNodePath.setPos(1.0,0,6.0)
npNodePath.setZ(6.5)
bar = DirectWaitBar(value=100, scale=1.0)
bar.setColor(255, 0, 0)
#bar.setBarRelief()
bar.setZ(6.0)
bar.setBillboardPointEye()
bar.reparentTo(self.ralph)
# 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)
# Accept the control keys for movement and rotation
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left", 1])
self.accept("arrow_right", self.setKey, ["right", 1])
self.accept("arrow_up", self.setKey, ["forward", 1])
self.accept("a", self.setKey, ["cam-left", 1])
self.accept("s", self.setKey, ["cam-right", 1])
self.accept("arrow_left-up", self.setKey, ["left", 0])
self.accept("arrow_right-up", self.setKey, ["right", 0])
self.accept("arrow_up-up", self.setKey, ["forward", 0])
self.accept("a-up", self.setKey, ["cam-left", 0])
self.accept("s-up", self.setKey, ["cam-right", 0])
self.accept("c", self.setKey, ["charge", 1])
self.accept("c-up", self.setKey, ["charge", 0])
taskMgr.add(self.move, "moveTask")
# Game state variables
self.isMoving = False
# Set up the camera
base.disableMouse()
base.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2)
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0, 0, 1000)
self.ralphGroundRay.setDirection(0, 0, -1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0, 0, 1000)
self.camGroundRay.setDirection(0, 0, -1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
#self.ralphGroundColNp.show()
#self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
#self.cTrav.showCollisions(render)
# Create some lighting
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.3, .3, .3, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(-5, -5, -5))
directionalLight.setColor(Vec4(1, 1, 1, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambientLight))
render.setLight(render.attachNewNode(directionalLight))
def __init__(self):
# This code puts the standard title and instruction text on screen
self.title = OnscreenText(text="Panda3D: Tutorial - Collision Detection",
style=1, fg=(1,1,1,1),
pos=(0.7,-0.95), scale = .07)
self.instructions = OnscreenText(text="Mouse pointer tilts the board",
pos = (-1.3, .95), fg=(1,1,1,1),
align = TextNode.ALeft, scale = .05)
self.accept("escape", sys.exit) # Escape quits
base.disableMouse() # Disable mouse-based camera control
camera.setPosHpr(0, 0, 25, 0, -90, 0) # Place the camera
# Load the maze and place it in the scene
self.maze = loader.loadModel("models/maze")
self.maze.reparentTo(render)
# Most times, you want collisions to be tested against invisible geometry
# rather than every polygon. This is because testing against every polygon
# in the scene is usually too slow. You can have simplified or approximate
# geometry for the solids and still get good results.
#
# Sometimes you'll want to create and position your own collision solids in
# code, but it's often easier to have them built automatically. This can be
# done by adding special tags into an egg file. Check maze.egg and ball.egg
# and look for lines starting with <Collide>. The part is brackets tells
# Panda exactly what to do. Polyset means to use the polygons in that group
# as solids, while Sphere tells panda to make a collision sphere around them
# Keep means to keep the polygons in the group as visable geometry (good
# for the ball, not for the triggers), and descend means to make sure that
# the settings are applied to any subgroups.
#
# Once we have the collision tags in the models, we can get to them using
# NodePath's find command
# Find the collision node named wall_collide
self.walls = self.maze.find("**/wall_collide")
# Collision objects are sorted using BitMasks. BitMasks are ordinary numbers
# with extra methods for working with them as binary bits. Every collision
# solid has both a from mask and an into mask. Before Panda tests two
# objects, it checks to make sure that the from and into collision masks
# have at least one bit in common. That way things that shouldn't interact
# won't. Normal model nodes have collision masks as well. By default they
# are set to bit 20. If you want to collide against actual visable polygons,
# set a from collide mask to include bit 20
#
# For this example, we will make everything we want the ball to collide with
# include bit 0
self.walls.node().setIntoCollideMask(BitMask32.bit(0))
# CollisionNodes are usually invisible but can be shown. Uncomment the next
# line to see the collision walls
# self.walls.show()
# We will now find the triggers for the holes and set their masks to 0 as
# well. We also set their names to make them easier to identify during
# collisions
self.loseTriggers = []
for i in range(6):
trigger = self.maze.find("**/hole_collide" + str(i))
trigger.node().setIntoCollideMask(BitMask32.bit(0))
trigger.node().setName("loseTrigger")
self.loseTriggers.append(trigger)
# Uncomment this line to see the triggers
# trigger.show()
# Ground_collide is a single polygon on the same plane as the ground in the
# maze. We will use a ray to collide with it so that we will know exactly
# what height to put the ball at every frame. Since this is not something
# that we want the ball itself to collide with, it has a different
# bitmask.
self.mazeGround = self.maze.find("**/ground_collide")
self.mazeGround.node().setIntoCollideMask(BitMask32.bit(1))
# Load the ball and attach it to the scene
# It is on a root dummy node so that we can rotate the ball itself without
# rotating the ray that will be attached to it
self.ballRoot = render.attachNewNode("ballRoot")
self.ball = loader.loadModel("models/ball")
self.ball.reparentTo(self.ballRoot)
# Find the collison sphere for the ball which was created in the egg file
# Notice that it has a from collision mask of bit 0, and an into collison
# mask of no bits. This means that the ball can only cause collisions, not
# be collided into
self.ballSphere = self.ball.find("**/ball")
self.ballSphere.node().setFromCollideMask(BitMask32.bit(0))
self.ballSphere.node().setIntoCollideMask(BitMask32.allOff())
# No we create a ray to start above the ball and cast down. This is to
# Determine the height the ball should be at and the angle the floor is
# tilting. We could have used the sphere around the ball itself, but it
# would not be as reliable
self.ballGroundRay = CollisionRay() # Create the ray
self.ballGroundRay.setOrigin(0,0,10) # Set its origin
self.ballGroundRay.setDirection(0,0,-1) # And its direction
# Collision solids go in CollisionNode
self.ballGroundCol = CollisionNode('groundRay') # Create and name the node
self.ballGroundCol.addSolid(self.ballGroundRay) # Add the ray
self.ballGroundCol.setFromCollideMask(BitMask32.bit(1)) # Set its bitmasks
self.ballGroundCol.setIntoCollideMask(BitMask32.allOff())
# Attach the node to the ballRoot so that the ray is relative to the ball
# (it will always be 10 feet over the ball and point down)
self.ballGroundColNp = self.ballRoot.attachNewNode(self.ballGroundCol)
# Uncomment this line to see the ray
# self.ballGroundColNp.show()
# Finally, we create a CollisionTraverser. CollisionTraversers are what
# do the job of calculating collisions
self.cTrav = CollisionTraverser()
# Collision traverservs tell collision handlers about collisions, and then
# the handler decides what to do with the information. We are using a
# CollisionHandlerQueue, which simply creates a list of all of the
# collisions in a given pass. There are more sophisticated handlers like
# one that sends events and another that tries to keep collided objects
# apart, but the results are often better with a simple queue
self.cHandler = CollisionHandlerQueue()
# Now we add the collision nodes that can create a collision to the
# traverser. The traverser will compare these to all others nodes in the
# scene. There is a limit of 32 CollisionNodes per traverser
# We add the collider, and the handler to use as a pair
self.cTrav.addCollider(self.ballSphere, self.cHandler)
self.cTrav.addCollider(self.ballGroundColNp, self.cHandler)
# Collision traversers have a built in tool to help visualize collisions.
# Uncomment the next line to see it.
# self.cTrav.showCollisions(render)
# This section deals with lighting for the ball. Only the ball was lit
# because the maze has static lighting pregenerated by the modeler
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.55, .55, .55, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(0, 0, -1))
directionalLight.setColor(Vec4(0.375, 0.375, 0.375, 1))
directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
self.ballRoot.setLight(render.attachNewNode(ambientLight))
self.ballRoot.setLight(render.attachNewNode(directionalLight))
# This section deals with adding a specular highlight to the ball to make
# it look shiny
m = Material()
m.setSpecular(Vec4(1,1,1,1))
m.setShininess(96)
self.ball.setMaterial(m, 1)
# Finally, we call start for more initialization
self.start()
