def start(self):
self.resetCamera()
self.loadPlanet()
self.loadShips()
self.loadPlayers()
self.loadStars()
self.loadHUD()
light = DirectionalLight('light')
light.setDirection(Vec3(-1, .1, -.5))
light.setColor(Vec4(.7, .6, .6, 0))
light.setSpecularColor(Vec4(.3, .5, .7, 0))
lightnode = render.attachNewNode(light)
render.setLight(lightnode)
render.setShaderAuto()
render.setShaderInput('light', lightnode)
render.setAntialias(AntialiasAttrib.MAuto)
# TODO: it might be necessary here to check that the task
# does not already exist in the task manager because the
# unit tests at the moment call the start method
# continuously.
taskMgr.add(self.tick, "gameloop")
self.time = self.getTime()
self.registerListeners()
self.state = Game.STATE_RUNNING
# Load music
self.music = loader.loadSfx('MVi - Ilwrath Are Watching.mp3')
self.music.setLoop(True)
self.music.setVolume(0.5)
self.music.play()
def start(self):
self.resetCamera()
self.loadPlanet()
self.loadShips()
self.loadPlayers()
self.loadStars()
self.loadHUD()
light = DirectionalLight('light')
light.setDirection( Vec3(-1, .1, -.5) )
light.setColor( Vec4(.7, .6, .6, 0) )
light.setSpecularColor( Vec4(.3, .5, .7, 0) )
lightnode = render.attachNewNode(light)
render.setLight(lightnode)
render.setShaderAuto()
render.setShaderInput('light', lightnode)
render.setAntialias(AntialiasAttrib.MAuto)
# TODO: it might be necessary here to check that the task
# does not already exist in the task manager because the
# unit tests at the moment call the start method
# continuously.
taskMgr.add(self.tick, "gameloop")
self.time = self.getTime()
self.registerListeners()
self.state = Game.STATE_RUNNING
# Load music
self.music = loader.loadSfx('MVi - Ilwrath Are Watching.mp3')
self.music.setLoop(True)
self.music.setVolume(0.5)
self.music.play()
def create( self, lightAttrib ):
#create directional light
directionalLight = DirectionalLight( self.name )
directionalLight.setDirection( self.direction )
directionalLight.setColor( self.color * self.intensity )
directionalLight.setSpecularColor( Vec4(0.5,0.5,0.5,0.5) )
lightAttrib = lightAttrib.addLight( directionalLight )
#attach lights to scene graph
render.attachNewNode( directionalLight )
self.directionalLight = directionalLight
return lightAttrib
def create(self, lightAttrib):
#create directional light
directionalLight = DirectionalLight(self.name)
directionalLight.setDirection(self.direction)
directionalLight.setColor(self.color * self.intensity)
directionalLight.setSpecularColor(Vec4(0.5, 0.5, 0.5, 0.5))
lightAttrib = lightAttrib.addLight(directionalLight)
#attach lights to scene graph
render.attachNewNode(directionalLight)
self.directionalLight = directionalLight
return lightAttrib
def __init_kepler_scene(self):
self.hud_count_down = 0
self.alpha = 0.
self.beta = 0.
self._set_title("Hugomatic 3D sim")
self.alpha_rot_speed = 0.
self.beta_rot_speed = 0.
#This code puts the standard title and instruction text on screen
self.title = OnscreenText(text="Kepler simulation tool 1",
style=1, fg=(1,1,1,1),
pos=(0.7,-0.95), scale = .07, font = font)
self.instructions = OnscreenText(text="alpha: 0.000\nbeta: 0.000",
pos = (-1.3, .95), fg=(1,1,1,1), font = font,
align = TextNode.ALeft, scale = .05)
if DISABLE_MOUSE:
base.disableMouse() #Disable mouse-based camera control
camera.setPosHpr(-10, -10, 25, 0, -90, 0) #Place the camera
#Load the maze and place it in the scene
self.maze = loader.loadModel("models/maze")
process_model(self.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 visible 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
if VISIBLE_WALLS:
self.walls.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.
if VISIBLE_WALLS:
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
lAttrib = LightAttrib.makeAllOff()
ambientLight = AmbientLight( "ambientLight" )
ambientLight.setColor( Vec4(.55, .55, .55, 1) )
lAttrib = lAttrib.addLight( ambientLight )
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))
lAttrib = lAttrib.addLight( directionalLight )
self.ballRoot.node().setAttrib( lAttrib )
#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 start(self):
#The maze model also has a locator in it for where to start the ball
#To access it we use the find command
startPos = (0,0,0)#= self.maze.find("**/start").getPos()
self.ballRoot.setPos(startPos) #Set the ball in the starting position
self.ballV = Vec3(0,0,0) #Initial velocity is 0
self.accelV = Vec3(0,0,0) #Initial acceleration is 0
#For a traverser to actually do collisions, you need to call
#traverser.traverse() on a part of the scene. Fortunatly, base has a
#task that does this for the entire scene once a frame. This sets up our
#traverser as the one to be called automatically
base.cTrav = self.cTrav
