Example #1
0
class SpotLight:
    """Creates a simple spot light"""
    def __init__(self, manager, xml):
        self.light = PSpotLight('slight')
        lens = PerspectiveLens()
        self.light.setLens(lens)
        self.lightNode = render.attachNewNode(self.light)

        self.reload(manager, xml)

    def reload(self, manager, xml):
        color = xml.find('color')
        if color != None:
            self.light.setColor(
                VBase4(float(color.get('r')), float(color.get('g')),
                       float(color.get('b')), 1.0))

        pos = xml.find('pos')
        if pos != None:
            self.lightNode.setPos(render, float(pos.get('x')),
                                  float(pos.get('y')), float(pos.get('z')))

        lookAt = xml.find('lookAt')
        if lookAt != None:
            self.lightNode.lookAt(render, float(lookAt.get('x')),
                                  float(lookAt.get('y')),
                                  float(lookAt.get('z')))

    def start(self):
        render.setLight(self.lightNode)

    def stop(self):
        render.clearLight(self.lightNode)
Example #2
0
    def addLight(self, id, parent, attenuation, position, color, specular, stroboscopic, spot, lookat):
        if spot:
            slight = Spotlight(id)
            slight.setColor(VBase4(1, 1, 1, 1))
            lens = PerspectiveLens()
            slight.setLens(lens)
            light = render.attachNewNode(slight)
            light.setPos(LVector3(position[0], position[1], position[2]))
            if lookat == None:
                light.lookAt(parent)
            else:
                light.lookAt(render.find("**/"+lookat))
        else:
            light = parent.attachNewNode(PointLight(id))
            light.node().setAttenuation(attenuation)
            light.setPos(LVector3(position[0], position[1], position[2]))
        light.node().setColor(color)
        light.node().setSpecularColor(specular)
        render.setLight(light)
        self.light_elements[id] = light
        if stroboscopic:
            self.stroboscopic_lights.append(id)

        if id:
            self.nodes_by_id[id] = light
        return light
Example #3
0
 def generate(self):
     data = CIGlobals.SuitBodyData[self.SUIT]
     type = data[0]
     team = data[1]
     self.team = team
     self.level = 12
     self.suit = type
     Suit.generate(self, SuitBank.MrHollywood, 0, hideFirst=False)
     self.suit = type
     base.taskMgr.add(self.__viewDistance, self.viewDistanceTaskName)
     self.setPythonTag('guard', self)
     self.eyeLight = Spotlight('eyes')
     self.eyeLens = PerspectiveLens()
     self.eyeLens.setMinFov(90.0 / (4.0 / 3.0))
     self.eyeLight.setLens(self.eyeLens)
     self.eyeNode = self.headModel.attachNewNode(self.eyeLight)
     self.eyeNode.setZ(-5)
     self.eyeNode.setY(-4.5)
     self.trav = CollisionTraverser(self.uniqueName('eyeTrav'))
     ray = CollisionRay(0, 0, 0, 0, 1, 0)
     rayNode = CollisionNode('ToonFPS.rayNode')
     rayNode.addSolid(ray)
     rayNode.setFromCollideMask(CGG.GuardBitmask | CIGlobals.WallBitmask)
     rayNode.setIntoCollideMask(BitMask32.allOff())
     self.rayNP = base.camera.attachNewNode(rayNode)
     self.rayNP.setZ(3)
     self.queue = CollisionHandlerQueue()
     self.trav.addCollider(self.rayNP, self.queue)
     self.trav.addCollider(self.gameWorld.mg.avatarBody, self.queue)
     self.request('Guard')
Example #4
0
        def toggle_flashlight():
            current_flashlight = self.render.find_all_matches("**/flashlight")

            if self.flashlight_state == 0:
                if len(current_flashlight) == 0:
                    self.slight = 0
                    self.slight = Spotlight('flashlight')
                    self.slight.set_shadow_caster(True, 1024, 1024)
                    self.slight.set_color(VBase4(0.5, 0.6, 0.6,
                                                 1))  # slightly bluish
                    lens = PerspectiveLens()
                    lens.set_near_far(0.5, 5000)
                    self.slight.set_lens(lens)
                    self.slight.set_attenuation((0.5, 0, 0.0000005))
                    self.slight = self.render.attach_new_node(self.slight)
                    self.slight.set_pos(-0.1, 0.3, -0.4)
                    self.slight.reparent_to(self.camera)
                    self.flashlight_state = 1
                    self.render.set_light(self.slight)

                elif len(current_flashlight) > 0:
                    self.render.set_light(self.slight)
                    self.flashlight_state = 1

            elif self.flashlight_state > 0:
                self.render.set_light_off(self.slight)
                self.flashlight_state = 0
Example #5
0
def launch_panda_window(panda_widget, size) :
    """
    Configure and create Panda window
    Connect to the gtk widget resize event
    Load a panda
    """
    props = WindowProperties().getDefault()
    props.setOrigin(0, 0)
    props.setSize(*size)
    props.setParentWindow(panda_widget.window.xid)
    base.openDefaultWindow(props=props)
    # ==
    panda_widget.connect("size_allocate", resize_panda_window)
    # ==
    panda = loader.loadModel("panda")
    panda.reparentTo(render)
    panda.setPos(0, 40, -5)

    pl = render.attachNewNode( PointLight( "redPointLight" ) )
    pl.node().setColor( Vec4( .9, .8, .8, 1 ) )
    render.setLight(pl)
    pl.node().setAttenuation( Vec3( 0, 0, 0.05 ) ) 


    slight = Spotlight('slight')
    slight.setColor(VBase4(1, 1, 1, 1))
    lens = PerspectiveLens()
    slight.setLens(lens)
    slnp = render.attachNewNode(slight)
    slnp.setPos(2, 20, 0)
    mid = PandaNode('mid')
    panda.attachNewNode(mid)
#    slnp.lookAt(mid)
    render.setLight(slnp)
Example #6
0
    def __init__(self):

        loadPrcFile('config.prc')
        ShowBase.__init__(self)

        base.disableMouse()
        self.render.setShaderAuto()
        self.accept("escape", sys.exit)
        # Model
        model = self.loader.loadModel("twisted")
        model.reparent_to(self.render)
        self.model = model # For reference in the rotation task
        # Light
        light = Spotlight('light')
        light_np = self.render.attachNewNode(light)
        light_np.set_pos(25, 25, 25)
        light_np.look_at(0, 0, 0)
        # Model-light interaction
        light.setShadowCaster(True)
        light.getLens().setNearFar(1, 50)
        self.render.setLight(light_np)
        # Camera
        self.camera.set_pos(0, -60, 30)
        self.camera.look_at(0, 0, 0)
        # Rotating the object
        self.taskMgr.add(self.rotate_object, 'rotate object')
        self.render.setAntialias(AntialiasAttrib.MMultisample)
Example #7
0
    def setupLights(self):
        panda = self.app.panda

        panda.setBackgroundColor(.9, .9, .9, 1)
        panda.render.clearLight()

        keylight = Spotlight('keylight')
        keylight.setLens(PerspectiveLens())
        np = self._insertLight(
            keylight,
            colour=(1, 1, 1, 1),
            pos=(0, -5, 2),
        )
        np.lookAt((0, 0, 0.9))
        # Turn off shadows until we have fix for
        # https://bugs.launchpad.net/panda3d/+bug/1212752
        # keylight.setShadowCaster(True, 512, 512)

        sunlight = PointLight('sunlight')
        self._insertLight(
            sunlight,
            colour=(1, 1, 1, 1),
            pos=(1, -2, 20),
        )

        self._insertLight(
            AmbientLight('ambientLight'),
            colour=(.25, .25, .25, 1),
        )
 def generate(self):
     self.level = 12
     self.maxHealth = 200
     self.health = 200
     Suit.generate(self,
                   FactorySneakGuardSuit.SUIT,
                   FactorySneakGuardSuit.VARIANT,
                   hideFirst=False)
     self.setName(self.suitPlan.getName(), None)
     self.cleanupPropeller()
     base.taskMgr.add(self.__viewDistance, self.viewDistanceTaskName)
     self.setPythonTag('guard', self)
     self.eyeLight = Spotlight('eyes')
     self.eyeLens = PerspectiveLens()
     self.eyeLens.setMinFov(90.0 / (4. / 3.))
     self.eyeLight.setLens(self.eyeLens)
     self.eyeNode = self.headModel.attachNewNode(self.eyeLight)
     self.eyeNode.setZ(-5)
     self.eyeNode.setY(-4.5)
     self.trav = CollisionTraverser(self.uniqueName('eyeTrav'))
     ray = CollisionRay(0, 0, 0, 0, 1, 0)
     rayNode = CollisionNode('ToonFPS.rayNode')
     rayNode.addSolid(ray)
     rayNode.setFromCollideMask(CGG.GuardBitmask | CIGlobals.WallBitmask)
     rayNode.setIntoCollideMask(BitMask32.allOff())
     self.rayNP = base.camera.attachNewNode(rayNode)
     self.rayNP.setZ(3)
     self.queue = CollisionHandlerQueue()
     self.trav.addCollider(self.rayNP, self.queue)
     self.trav.addCollider(self.gameWorld.mg.avatarBody, self.queue)
     self.request('Guard')
Example #9
0
	def initLights(self):
		# Create some lighting

		#self.environ.ls()

		#print(self.environ.findAllMatches("**/Spot"))

		ambientLight = AmbientLight("ambientLight")
		ambientLight.setColor(Vec4(0.8, 0.8, 0.8, 0.65))

		"""
		directionalLight = DirectionalLight("directionalLight")
		directionalLight.setDirection(Vec3(-10, -10, 5))
		directionalLight.showFrustum()
		directionalLight.setColor(Vec4(1, 1, 1, 1))
		directionalLight.setSpecularColor(Vec4(1, 1, 1, 1))
		dirnp = render.attachNewNode(directionalLight)
		dirnp.setPos(10, 0, 6)
		"""

		plight1 = PointLight('plight1')
		plight1.setColor(VBase4(1, 1, 1, 1))
		plight1.showFrustum()
		#plight1.setShadowCaster(True)
		plnp1 = render.attachNewNode(plight1)
		plnp1.setPos(26.71, -33.2, 26)

		plight2 = PointLight('plight2')
		plight2.setColor(VBase4(1, 1, 1, 1))
		plight2.showFrustum()
		plnp2 = render.attachNewNode(plight2)
		plnp2.setPos(-25, 25, 25)

		slight = Spotlight('slight')
		slight.setColor(VBase4(1, 1, 1, 1))
		lens = PerspectiveLens()
		lens.setFilmSize(1, 1)  # Or whatever is appropriate for your scene
		slight.setLens(lens)
		slight.setShadowCaster(True, 512, 512)
		slight.showFrustum()
		slnp = render.attachNewNode(slight)
		slnp.setPos(0, 0, 100)

		slnp.lookAt(Vec3(0,0,0))

		render.setLight(slnp)
		render.setLight(plnp1)
		render.setLight(plnp2)
		#render.setLight(render.attachNewNode(ambientLight))

		#render.setLight(dirnp)

		render.setShaderAuto()

		#render.setLight(render.attachNewNode(directionalLight))

		"""
Example #10
0
 def buildSubType(self):
     """Build the light with the given subType"""
     
     if self.subType == "pointType":
         # make a point light
         c = self.color
         pointLight = PointLight(self.name)
         pointLight.setColor(VBase4(c[0], c[1], c[2], c[3]))
         plnp = self.renderObjectsLight.attachNewNode(pointLight)
         plnp.setPos(self.position)
         self.lightNP = plnp
         self.setLightSwitch(True)
         
     if self.subType == "directType":
         # make a directional light
         c = self.color
         directLight = DirectionalLight(self.name)
         directLight.setColor(VBase4(c[0], c[1], c[2], c[3]))
         dlnp = self.renderObjectsLight.attachNewNode(directLight)
         dlnp.setHpr(0, -60, 0) # no idea why its like that.. but it works
         self.lightNP = dlnp
         self.setLightSwitch(True)
         
         
     if self.subType == "ambientType":
         # make a ambient light
         c = self.color
         ambientLight = AmbientLight(self.name)
         ambientLight.setColor(VBase4(c[0], c[1],c[2], c[3]))
         alnp = self.renderObjectsLight.attachNewNode(ambientLight)
         self.lightNP = alnp
         self.setLightSwitch(True)
         
     if self.subType == "spotType":
         # make a spot light
         # lookAtObj = _object.getTag("lookAt") get rid of this.
         c = self.color
         spotLight = Spotlight(self.name)
         spotLight.setColor(VBase4(c[0], c[1], c[2], c[3]))
         lens = PerspectiveLens()
         spotLight.setLens(lens)
         slnp = self.renderObjectsLight.attachNewNode(spotLight)
         slnp.setPos(self.position)
         slnp.setHpr(self.hpr)
         # Find out if this is really the only option
         # because setHpr doesnt seem to have any effect.
         # lookAt would be okay but that means adding anothe type
         #slnp.lookAt(self.main.GameObjects["player"].collisionBody)
         self.lightNP = slnp
         self.setLightSwitch(True)
Example #11
0
    def __init__(self):
        self.testTexture = loader.loadTexture("maps/envir-reeds.png")
        self.accept("1", self.toggleTex)
        self.accept("2", self.toggleLightsSide)
        self.accept("3", self.toggleLightsUp)

        self.LightsOn = False
        self.LightsOn1 = False
        slight = Spotlight('slight')
        slight.setColor((1, 1, 1, 1))
        lens = PerspectiveLens()
        slight.setLens(lens)
        self.slnp = render.attachNewNode(slight)
        self.slnp1 = render.attachNewNode(slight)
Example #12
0
    def setupLights(self):
        """Setup extrnal lights"""

        # ambient light
        alight = AmbientLight('alight')
        alight.setColor((0.2, 0.2, 0.2, 1))
        alnp = self.render.attachNewNode(alight)
        self.render.setLight(alnp)

        # directional light
        dlight = DirectionalLight('dlight')
        dlight.setColor((0.8, 0.8, 0.5, 1))
        lens = PerspectiveLens()
        lens.setNearFar(1, 5)
        dlight.setLens(lens)
        dlight.setShadowCaster(True, args.shadow_resolution,
                               args.shadow_resolution)
        dlnp = self.render.attachNewNode(dlight)
        dlnp.setPos(2, -2, 3)
        dlnp.lookAt(0, 0, 0)
        self.render.setLight(dlnp)

        # spotlight
        slight = Spotlight('slight')
        slight.setColor((0.7, 0.7, 1.0, 1))
        lens = PerspectiveLens()
        lens.setNearFar(1, 5)
        slight.setLens(lens)
        slight.setShadowCaster(True, args.shadow_resolution,
                               args.shadow_resolution)
        slnp = self.render.attachNewNode(slight)
        slnp.setPos(1, 1, 2)
        slnp.lookAt(0, 0, 0)
        self.render.setLight(slnp)
Example #13
0
 def set_spotlight(self, col, exp, cutoff, pos, look_at):
     lgt = Spotlight('spotlight')
     lgt.setColor(col)
     lgt.setExponent(exp)
     lgt.getLens().setFov(cutoff, cutoff)
     self.__set_lgt(lgt)
     self.lights[-1].setPos(*pos)
     self.lights[-1].lookAt(*look_at)
Example #14
0
 def _make_light_direct(self, index, color, pos, target=(0, 0, 0)):
     if self._spotlight:
         light = Spotlight('Spotlight {:02d}'.format(index))
     else:
         light = DirectionalLight('Directional Light{:02d}'.format(index))
     light.set_color(Vec3(*color))
     light.set_camera_mask(self.LightMask)
     light.set_shadow_buffer_size((self._shadow_size, self._shadow_size))
     lens = light.get_lens()
     lens.set_film_size(5.5, 5.5)
     lens.set_near_far(10, 30)
     node = self.render.attach_new_node(light)
     node.set_pos(*pos)
     node.look_at(*target)
     return node
Example #15
0
    def __init__(self, manager, xml):
        self.light = PSpotLight('slight')
        lens = PerspectiveLens()
        self.light.setLens(lens)
        self.lightNode = render.attachNewNode(self.light)

        self.reload(manager, xml)
Example #16
0
    def __init__(self, screen_manager):
        '''
        Creates a new trunk screen with a reference to the given screen manager.
        This function also loads all of our models and stage backgrounds and positions them on the scene accordingly
        '''
        super(TrunkScreen, self).__init__(screen_manager, "trunk_screen")

        # Load our trunk model
        self.cube = base.loader.loadModel("assets/models/trunk.egg")
        # Set its position to:
        # X: -0.4 (just to the left of h-center)
        # Y: 40 (way far back away from the viewer)
        # Z: 0 (vertically center)
        self.cube.setPos(-0.4, 40, 0)
        # Set the scaling size of the trunk
        self.cube.setScale(1.5, 1.5, 1.5)

        if base.displayFlipped:
            self.cube.setAttrib(
                CullFaceAttrib.make(CullFaceAttrib.MCullCounterClockwise))

        # Insert the trunk into this screen's rendering tree
        self.cube.reparentTo(self.node)

        # Set up a splotlight to project onto the trunk
        self.dlight = Spotlight('my dlight')
        # Associate the spotlight to the rendering system
        self.dlnp = render.attachNewNode(self.dlight)
        # Set this trunk's light explicitly so it only takes light from this light
        self.cube.setLight(self.dlnp)

        # Load the curtain background
        self.loadBackground("assets/images/stage-background.png")
	def __init__(self, name, owner, scene, pos, fov=60, near=0.01, far=100, resol=(1920, 1080)):
		self.owner = owner
		self.scene = scene
		
		self.last      = 0.0
		self.power     = 1.0
		self.on        = True
		self.powerrate = Flashlight.POWER_DRAIN_RATE 

		#TODO: Change lens parameters for a unique 'lens' parameter
		lens = PerspectiveLens()
		lens.setFov(fov)
		lens.setNearFar(near, far)
		lens.setFilmSize(resol[0], resol[1])

		self.light = Spotlight(name + '/wide')
		self.light.setLens(lens)
		#TODO: Shadows don't work well anymore
		#self.light.setShadowCaster(True, resol[0], resol[1])
		self.light.setColor(Flashlight.COLOR)
		self.light.setExponent(40)
		
		self.nodepath = owner.cam.attachNewNode(self.light)
		self.nodepath.setPos(pos)
		self.nodepath.setHpr((5,5,0))
		
		self.scene.setLight(self.nodepath)
Example #18
0
    def set_spotlight(self):
        self.light = self.render.attachNewNode(Spotlight("Spot"))
        self.light.node().setScene(self.render)
        self.light.node().setShadowCaster(True)
        self.light.node().setColor(Vec4(0.1, 0.1, 0.1, 1))
        # self.light.node().showFrustum()
        self.light.node().getLens().setFov(40)
        self.light.node().getLens().setNearFar(10, 10000)
        pos = self.box.center.copy()
        if self.box.dimensions < 3:
            pos = self._project3d(pos)
        pos[1] = -500
        pos[2] = 3000
        self.light.setPos(*pos[:3])
        # self.light.setP(-60)
        self.light.setHpr(45, -80, 0)
        self.render.setLight(self.light)

        self.alight = self.render.attachNewNode(AmbientLight("Ambient"))
        self.alight.node().setColor(Vec4(0.2, 0.2, 0.2, 1))
        self.render.setLight(self.alight)

        # Important! Enable the shader generator.
        self.render.setShaderAuto()

        # default values
        self.cameraSelection = 0
        self.lightSelection = 0
Example #19
0
 def setup_lights(self):
     pl = PointLight('pl')
     pl.setColor((1, 1, 1, 1))
     plNP = self.render.attachNewNode(pl)
     plNP.setPos(-10, -10, 10)
     self.render.setLight(plNP)
     pos = [[[0, 0, 50], [0, 0, -10]],
            [[0, -50, 0], [0, 10, 0]],
            [[-50, 0, 0], [10, 0, 0]]]
     for i in pos:
         dl = Spotlight('dl')
         dl.setColor((1, 1, 1, 1))
         dlNP = self.render.attachNewNode(dl)
         dlNP.setPos(*i[0])
         dlNP.lookAt(*i[1])
         dlNP.node().setShadowCaster(False)
         self.render.setLight(dlNP)
Example #20
0
 def makeSpot(parent, color=VBase4(1, 1, 1, 1), fov=8, atten=.003):
     x = parent.attachNewNode(Spotlight("spot"))
     x.node().setColor(color)
     lens = PerspectiveLens()
     lens.setFov(fov)
     x.node().setLens(lens)
     x.node().setAttenuation(VBase3(0, 0, atten))
     return x
Example #21
0
    def __init__(self, _base):
        self.game = _base

        # Player object
        self.playerObject = self.game.meotech.engine.GameObjects["player"]

        # Attach the flashlight cone to the player (self, _height, _radius, _pos, _hpr)
        self.flashlightConeBody = self.game.meotech.engine.factory.basePhysics.buildConeShape(10.0, 1.5,
                                                                                              self.playerObject.bulletBody.getPos(), self.playerObject.bulletBody.getHpr())

        # Attach the flashlight model to the player
        self.flashlight = loader.loadModel("game/models/flashlight")
        self.flashlight.setScale(0.2)
        self.flashlight.reparentTo(self.flashlightConeBody)

        # Attach the light to the flashlight model
        slight = Spotlight('slight')
        slight.setColor(VBase4(1, 1, 1, 1))
        lens = PerspectiveLens()
        lens.setFar(25)
        lens.setFov(40, 40)
        slight.setLens(lens)
        slight.setShadowCaster(True, 512, 512)
        self.flashlightLight = render.attachNewNode(slight)
        self.flashlightLight.reparentTo(self.flashlight.find("LightPos"))
        render.setLight(self.flashlightLight)

        self.flashlightConeBody.reparentTo(self.playerObject.bulletBody)
        self.flashlightConeBody.setPos(base.cam.getPos())
Example #22
0
    def __create_spot_light(self,
                            lightId,
                            lightColor,
                            lightPos,
                            targetId,
                            shadow = True):

        spotLight = Spotlight(lightId)
        spotLight.setColor(lightColor)
        spotLight.setLens(PerspectiveLens())
        spotLight.setShadowCaster(shadow)

        spotLightNP = NodePath(spotLight)

        spotLightNP.setPos(lightPos)

        if isinstance(targetId, list) is True:
            spotLightNP.lookAt(self.__sceneMgr.get_res(targetId[0]))
        else:
            spotLightNP.lookAt(self.__sceneMgr.get_res(targetId))

        if self.__targetMap.has_key(lightId) is False:

            self.__targetMap[lightId] = []

        self.__targetMap[lightId].append(targetId)

        return spotLightNP
Example #23
0
    def __init__(self):
        ShowBase.__init__(self)

        ambLight = AmbientLight("ambient")
        ambLight.setColor(Vec4(0.1,0.11,0.12,1.0))
        ambNode = render.attachNewNode(ambLight)
        render.setLight(ambNode)

        dirLight = DirectionalLight("directional")
        dirLight.setColor(Vec4(0.7,0.7,0.68,1.0))
        dirNode = render.attachNewNode(dirLight)
        dirNode.setHpr(60,-40,90)
        render.setLight(dirNode)

        sptLight = Spotlight("spot")
        sptLens = PerspectiveLens()
        sptLight.setLens(sptLens)
        sptLight.setColor(Vec4(0.6,0.6,0.6,1.0))
        sptLight.setShadowCaster(True)
        sptNode = render.attachNewNode(sptLight)
        sptNode.setPos(0,0,20)
        sptNode.lookAt(0,0,0)
        render.setLight(sptNode)

        render.setShaderAuto()

        base.camLens.setFov(70)
        base.camLens.setNear(0.1)
        base.camLens.setFar(50)

        self.cam.setPos(-1,-4,4)
        self.cam.lookAt(0,-1,1)
    def __setSpotlight(self, props):
        light = Spotlight(props['name'])
        light.setShadowCaster(props['castShadows'], 2048, 2048)
        light.setAttenuation(props['attenuation'])
        lens = PerspectiveLens()

        fov = math.degrees(props['range'].x)
        lens.setFov(fov)
        lens.setFilmSize(5096)
        light.setLens(lens)
        return self.__createLight(light, props)
	def __init__(self):
		ShowBase.__init__(self)

		self.gameTask = taskMgr.add(self.gameLoop, "gameLoop")

		base.disableMouse()
		
		base.camera.setPos(500, 500, 2000)
		base.camera.lookAt(500,500,0)

		slight = Spotlight('slight')
		slight.setColor(VBase4(1, 1, 1, 1))
		lens = PerspectiveLens()
		slight.setLens(lens)

		# create rebel ships
		self.rebels = [Xwing('xwing' + str(x)) for x in xrange(20)]
		self.rebels += [Ywing('ywing' + str(x)) for x in xrange(20)]
		self.rebels += [Awing('awing' + str(x)) for x in xrange(20)]
		self.rebels += [Bwing('bwing' + str(x)) for x in xrange(20)]

		# create imperial ships
		self.imperials = [TieFighter('tiefighter' + str(x)) for x in xrange(80)]
		self.imperials += [TieInterceptor('tieinterceptor' + str(x)) for x in xrange(80)]

		self.shipList = []
		self.shipList += self.rebels + self.imperials

		for i, ship in enumerate(self.shipList):
			ship.reparentTo(render)
			ship.setScale(2)
			ship.setPos(Point3(random()*1000,
							   random()*1000,
							   random()*1000))

			directionalLight = DirectionalLight('directionalLight')
			directionalLightNP = render.attachNewNode(directionalLight)

			directionalLightNP.setHpr(180, -20, 0)
			ship.setLight(directionalLightNP)

		self.outFile = open('rebels_20_each_imperial_80_each_ship2ship','w')

		self.camFilter = LpfVec3(Vec3(0,0,0),20)
Example #26
0
 def init_light(self, x, y, z):
     light = self.base.render.attachNewNode(Spotlight("Spot"))
     light.node().setScene(self.base.render)
     light.node().setShadowCaster(True, 1024 * 2, 1024 * 2)
     light.node().getLens().setFov(35)
     #light.node().showFrustum()
     light.node().getLens().setNearFar(10, 30)
     light.setPos(x, y, z)
     light.lookAt(0, 0, 0)
     return light
	def __init__(self, name, root, route, mass, movforce, maxforce):
		AICharacter.__init__(self, name, root, mass, movforce, maxforce)
		
		self.state = Hooded.STATE_PATROL
		
		self.initTimer = True
		self.attackTimer = True

		# we create a spotlight that will be the sentinel's eye and will be used to fire the inView method
		self.slight = Spotlight('slight')
		self.slight.setColor((1, 1, 1, 1))
		lens = PerspectiveLens()
		lens.setNear(0.1)
		lens.setFar(Hooded.SIGHT)
		lens.setFov(Hooded.FOV)
		
		self.slight.setLens(lens)
		self.slnp = self.get_node_path().attachNewNode(self.slight)
		#TODO: Substitute for a collision polygon, so that the player class alerts an enemy of its presence
		#self.slight.showFrustum()
		
		self.slnp.setH(self.slnp.getH()-180)
		self.slnp.setPos(0, 0, Hooded.HEIGHT)
		
		self.hearing = 5.0
		self.dynamicObstacles = []

		self.detected = False
		self.pathfinding = False
		self.lostTarget = False
		self.countTime = False
		self.goingBack = False
		self.heard = False
		self.isProtected = False
		self.attacked = False
		self.started = False

		self.sentinelHandler = CollisionHandlerQueue()
		
		#TODO: Intruders should be added via an external method
		self.intruders = []

		# this is important: as we said the inView method don't cull geometry but take everything is in sight frustum - therefore to simulate an hide and seek feature we gotta cheat a little: this ray is masked to collide with walls and so if the avatar is behind a wall the ray will be 'deflected' (we'll see how later in the sent_traverse function) - so we know who's behind a wall but we fake we can't see it.
		sentraygeom = CollisionSegment(0, 0, Hooded.HEIGHT, 0, Hooded.SIGHT, Hooded.HEIGHT)
		sentinelRay = self.get_node_path().attachNewNode(CollisionNode('sentinelray'))
		sentinelRay.node().addSolid(sentraygeom)
		# we set to the ray a cumulative masking using the or operator to detect either the avatar's body and the wall geometry
		sentinelRay.node().setFromCollideMask(CollisionMask.PLAYER)
		sentinelRay.node().setIntoCollideMask(CollisionMask.NONE)
		# we add the ray to the sentinel collider and now it is ready to go
		base.cTrav.addCollider(sentinelRay, self.sentinelHandler)
		
		self.screechsound = loader.loadSfx("assets/sounds/enemies/nazgul_scream.mp3")
		
		self.setPatrolPos(route)
Example #28
0
def launch_panda_window(panda_widget, size):
    """
    Configure and create Panda window
    Connect to the gtk widget resize event
    Load a panda
    """
    props = WindowProperties().getDefault()
    props.setOrigin(0, 0)
    props.setSize(*size)
    props.setParentWindow(panda_widget.window.xid)
    base.openDefaultWindow(props=props)
    # ==
    panda_widget.connect("size_allocate", resize_panda_window)
    # ==
    panda = loader.loadModel("panda")
    panda.reparentTo(render)
    panda.setPos(0, 40, -5)

    pl = render.attachNewNode(PointLight("redPointLight"))
    pl.node().setColor(Vec4(.9, .8, .8, 1))
    render.setLight(pl)
    pl.node().setAttenuation(Vec3(0, 0, 0.05))

    slight = Spotlight('slight')
    slight.setColor(VBase4(1, 1, 1, 1))
    lens = PerspectiveLens()
    slight.setLens(lens)
    slnp = render.attachNewNode(slight)
    slnp.setPos(2, 20, 0)
    mid = PandaNode('mid')
    panda.attachNewNode(mid)
    #    slnp.lookAt(mid)
    render.setLight(slnp)
Example #29
0
    def initLights(self):
        torches = self.level.findAllMatches("**/TorchTop*")
        self.lights = []
        for torch in torches:
            tLight = PointLight(torch.getName())
            tLight.setColor((.4, .2, .0, 1))
            tlnp = render.attachNewNode(tLight)
            tlnp.setPos(torch.getPos(render))
            render.setLight(tlnp)
            self.lights.append(tlnp)

        windows = self.level.findAllMatches("**/Window*")
        plates = self.level.findAllMatches("**/Plate*")
        spikes = self.level.findAllMatches("**/Spikes*")
        for window in windows:
            wLight = Spotlight(window.getName())
            lens = PerspectiveLens()
            wLight.setLens(lens)
            wLight.setColor((0.5, 0.4, 0.5, 1))
            wlnp = render.attachNewNode(wLight)
            wlnp.setPos(window.getPos(render))
            wlnp.lookAt((0, window.getY(), 0))
            for plate in plates:
                plate.setLight(wlnp)
            self.lights.append(wlnp)

        ambientLight = AmbientLight("ambientLight")
        ambientLight.setColor((.1, .1, .025, 1))
        render.setLight(render.attachNewNode(ambientLight))
Example #30
0
    def addLight(self, id, parent, attenuation, position, color, specular,
                 stroboscopic, spot, lookat):
        if spot:
            slight = Spotlight(id)
            slight.setColor(VBase4(1, 1, 1, 1))
            lens = PerspectiveLens()
            slight.setLens(lens)
            light = render.attachNewNode(slight)
            light.setPos(LVector3(position[0], position[1], position[2]))
            if lookat == None:
                light.lookAt(parent)
            else:
                light.lookAt(render.find("**/" + lookat))
        else:
            light = parent.attachNewNode(PointLight(id))
            light.node().setAttenuation(attenuation)
            light.setPos(LVector3(position[0], position[1], position[2]))
        light.node().setColor(color)
        light.node().setSpecularColor(specular)
        render.setLight(light)
        self.light_elements[id] = light
        if stroboscopic:
            self.stroboscopic_lights.append(id)

        if id:
            self.nodes_by_id[id] = light
        return light
Example #31
0
    def setup_world_lightning(self):
        """
        Sets up the ambient and specular lighting of the world
        :return:
        """
        ambientLight = AmbientLight("ambientLight")
        ambientLight.setColor((2, 2, 2, 1))
        directionalLight = DirectionalLight("directionalLight")
        directionalLight.setShadowCaster(True)
        directionalLight.setDirection(LVector3(-1, -1, -1))
        directionalLight.setColor((.5, .5, .5, 1))

        dir_light_node = self.render.attachNewNode(directionalLight)
        # dir_light_node.setPos(10, 2, 7)
        # dir_light_node.lookAt(2, 2, 0)
        self.render.setLight(dir_light_node)
        self.render.setLight(self.render.attachNewNode(ambientLight))
        spot = Spotlight("Spot")
        spot.setColorTemperature(9000)
        spot.setColor(LVector3(1, 1, 1))
        light = self.render.attachNewNode(spot)
        light.node().setScene(self.render)
        light.node().setShadowCaster(True)
        # light.node().showFrustum()
        light.node().getLens().setFov(40)
        light.node().getLens().setNearFar(2, 100)
        # light.setPos(10, 2, 7)
        light.setPos(10, 20, 20)
        light.lookAt(2, 2, 0)
        self.render.setLight(light)
Example #32
0
    def __init__(self):
        """initialise and start the Game"""
        ShowBase.__init__(self)

        self.accept("escape", exit)
        render.setShaderAuto(True)

        #
        # SIMPLE LEVEL SETUP
        #
        self.ralph = Actor("Ralph", {
            "idle": "Ralph-Idle",
            "walk": "Ralph-Walk",
            "run": "Ralph-Run"
        })
        self.ralph.loop("idle")
        self.ralph.reparentTo(render)
        self.ralph.setPos(0, 3, -2)
        #self.ralph.setScale(10)
        self.ralphIval = self.ralph.hprInterval(5.0, Vec3(-360, 0, 0))
        self.ralphIval.loop()
        #self.ralph.setH(-20)

        self.environment = loader.loadModel("environment")
        self.environment.reparentTo(render)
        self.environment.setScale(0.08)
        self.environment.setPos(-0.5, 15, -2)

        base.trackball.node().setHpr(0, 22, 0)

        #
        # Lights
        #
        alight = AmbientLight("Ambient")
        alight.setColor(VBase4(0.3, 0.3, 0.3, 1))
        alnp = render.attachNewNode(alight)
        render.setLight(alnp)

        slight = Spotlight("slight")
        slight.setColor(VBase4(1, 1, 1, 1))
        # Use a 512x512 resolution shadow map
        slight.setShadowCaster(True, 2048, 2048)
        lens = PerspectiveLens()
        lens.setFov(45)
        slight.setLens(lens)
        slnp = render.attachNewNode(slight)
        slnp.setPos(5, -10, 5)
        slnp.lookAt(0, 3, -2)
        render.setLight(slnp)
	def __setSpotlight(self,props):
		light = Spotlight(props['name'])
		light.setShadowCaster(props['castShadows'],2048,2048)
		light.setAttenuation(props['attenuation'])		
		lens = PerspectiveLens()

		fov = math.degrees( props['range'].x )		
		lens.setFov(fov)
		lens.setFilmSize(5096); 
		light.setLens(lens)
		return self.__createLight(light,props)
Example #34
0
    def setup_lights(self):

        pl = PointLight('pl')
        pl.setColor((1, 1, 1, 1))
        plNP = render.attachNewNode(pl)
        plNP.setPos(0, 0, 0)
        render.setLight(plNP)
        # make shadows less black
        al = AmbientLight('al')
        al.setColor((0.1, 0.1, 0.1, 1))
        alNP = render.attachNewNode(al)
        render.setLight(alNP)
        positions = [[[0, 0, 3], [0, 0, -1]], [[0, -3, 0], [0, 1, 0]],
                     [[-3, 0, 0], [1, 0, 0]]]
        # set up directional lights (shadow casting)
        for i in positions:
            dl = Spotlight('dl')
            dl.setColor((1, 1, 1, 1))
            dlNP = render.attachNewNode(dl)
            dlNP.setPos(*i[0])  # unpack the args
            dlNP.lookAt(*i[1])
            dlNP.node().setShadowCaster(True)
            render.setLight(dlNP)
Example #35
0
def makeSpotlight(name, color, pos, hpr):
    spot = Spotlight(name + "-spotlight")
    spot.setColor(color)
    if metadata.USE_REAL_SHADOWS:
        spot.setShadowCaster(True, 512, 512)
    snp = render.attachNewNode(spot)
    snp.setHpr(hpr)
    snp.setPos(pos)
    return snp
Example #36
0
    def __init__(self):
        ShowBase.__init__(self)
        #setting background

        self.environ = self.loader.loadModel("models/world")

        #Reparent the model to render
        #self.environ.reparentTo(self.render)
        #Apply scale and position transforms on the model

        self.environ.setScale(1000, 1000, 1000)
        self.environ.setPos(0, 0, 0)

        self.gameTask = taskMgr.add(self.gameLoop, "gameLoop")

        base.disableMouse()

        base.camera.setPos(0, -300, 100)
        base.camera.lookAt(0, 0, 0)

        slight = Spotlight('slight')
        slight.setColor(VBase4(1, 1, 1, 1))
        lens = PerspectiveLens()
        slight.setLens(lens)

        self.shipList = [
            Xwing("xwing1"),
            # Ywing("ywing1"),
            # Awing("awing1")#,
            # Bwing("bwing1"),
            # TieFighter("tiefighter1"),
            # TieInterceptor("tieinterceptor1")
        ]

        lightColors = [
            Vec4(0.9, 0.9, 0.9, 1),
            Vec4(1, 1, 0, 1),
            Vec4(1, 0, 0, 1),
            Vec4(0, 0, 1, 1),
            Vec4(0.4, 0.4, 0.4, 1),
            Vec4(0.1, 0.1, 0.1, 1)
        ]

        for i, ship in enumerate(self.shipList):
            ship.reparentTo(render)
            ship.setPos(Point3(i * 10, 0, 0))

            directionalLight = DirectionalLight('directionalLight')
            directionalLight.setColor(lightColors[i])
            directionalLightNP = render.attachNewNode(directionalLight)

            directionalLightNP.setHpr(180, -20, 0)
            ship.setLight(directionalLightNP)

        self.count = 0

        self.fire = False
Example #37
0
 def generate(self):
     data = CIGlobals.SuitBodyData[self.SUIT]
     type = data[0]
     team = data[1]
     self.generateSuit(type, self.SUIT, team, self.MAX_HP, 0, False)
     base.taskMgr.add(self.__viewDistance, self.viewDistanceTaskName)
     self.setPythonTag('guard', self)
     self.eyeLight = Spotlight('eyes')
     self.eyeLens = PerspectiveLens()
     self.eyeLens.setMinFov(90.0 / (4.0 / 3.0))
     self.eyeLight.setLens(self.eyeLens)
     self.eyeNode = self.headModel.attachNewNode(self.eyeLight)
     self.eyeNode.setZ(-5)
     self.eyeNode.setY(-4.5)
     self.request('Guard')
Example #38
0
 def setup_spot_light(self, x, y, z):
     slight = Spotlight('slight')
     slight.setColor(VBase4(1, 1, 1, 1))
     lens = self.base.camLens
     slight.setLens(lens)
     light = self.base.render.attachNewNode(slight)
     light.setPos(x, y, z)
     light.lookAt(0, 0, 0)
     self.direct_light.append(light)
     self.base.render.setLight(light)
    def __init__(self, screen_size=84):
        ShowBase.__init__(self, windowType='offscreen')

        # Spotlight
        self.light = Spotlight('light')
        self.lightNP = self.render.attachNewNode(self.light)
        self.lightNP.setPos(0, 10, 10)
        self.lightNP.lookAt(0, 0, 0)
        self.render.setLight(self.lightNP)

        # Block
        node = PandaNode('Block')
        block_np = self.render.attachNewNode(node)
        model = loader.loadModel('box.egg')
        model.reparentTo(block_np)

        self.start_time = time.time()
    def __init__(self):
        """initialise and start the Game"""
        ShowBase.__init__(self)

        self.accept("escape", exit)
        render.setShaderAuto(True)

        #
        # SIMPLE LEVEL SETUP
        #
        self.ralph = Actor("Ralph",
                           {"idle": "Ralph-Idle",
                            "walk": "Ralph-Walk",
                            "run": "Ralph-Run"})
        self.ralph.loop("idle")
        self.ralph.reparentTo(render)
        self.ralph.setPos(0, 3, -2)
        #self.ralph.setScale(10)
        self.ralphIval = self.ralph.hprInterval(5.0, Vec3(-360, 0, 0))
        self.ralphIval.loop()
        #self.ralph.setH(-20)

        self.environment = loader.loadModel("environment")
        self.environment.reparentTo(render)
        self.environment.setScale(0.08)
        self.environment.setPos(-0.5, 15, -2)

        base.trackball.node().setHpr(0, 22, 0)

        #
        # Lights
        #
        alight = AmbientLight("Ambient")
        alight.setColor(VBase4(0.3, 0.3, 0.3, 1))
        alnp = render.attachNewNode(alight)
        render.setLight(alnp)

        slight = Spotlight("slight")
        slight.setColor(VBase4(1, 1, 1, 1))
        # Use a 512x512 resolution shadow map
        slight.setShadowCaster(True, 2048, 2048)
        lens = PerspectiveLens()
        lens.setFov(45)
        slight.setLens(lens)
        slnp = render.attachNewNode(slight)
        slnp.setPos(5, -10, 5)
        slnp.lookAt(0, 3, -2)
        render.setLight(slnp)
Example #41
0
    def __init__(self,filename):
        self.height = 0
        self.width = 0
        self.waterheight = 0
        self.countries = []
        self.tileList = []
        self.tileReference = {}
        self.node = render.attachNewNode('BaseMap')
        
        self.snow = loader.loadModel("data/models/snow.bam")
        self.ice = loader.loadModel("data/models/ice.bam")
        self.plains = loader.loadModel("data/models/plains.bam")
        self.forest = loader.loadModel("data/models/forest.bam")
        self.jaggedrocks = loader.loadModel("data/models/jaggedrocks.bam")
        self.mountain = loader.loadModel("data/models/mountains.bam")
        self.desert = loader.loadModel("data/models/desert.bam")
        self.hills = loader.loadModel("data/models/hills.bam")
        self.water = loader.loadModel("data/models/water.bam")
        self.water.setTransparency(TransparencyAttrib.MAlpha)

        self.watertop = loader.loadModel("data/models/watertop.bam")
        self.waterbottom = loader.loadModel("data/models/waterbottom.bam")
        
        render.setShaderAuto()
        
        self.spot = Spotlight('World spot')
        self.spot.setColor((.7,.7,.7,1))
        self.spot.getLens().setFov(180)
        self.spot.getLens().setNearFar(1,10000000)
        self.spotNode = render.attachNewNode(self.spot)
        self.spotNode.setPos(2000,2000,5000)
        self.spotNode.lookAt(self.node)
        render.setLight(self.spotNode)
        
        self.createMap(filename)
        
        self.watertop.reparentTo(self.node)
        self.watertop.setScale(9,9,9)
        self.watertop.setPos((self.width*60)/2,-(self.height*17)/2,5)
        
        self.waterbottom.reparentTo(self.node)
        self.waterbottom.setScale(9,9,9)
        self.waterbottom.setPos((self.width*60)/2,-(self.height*17)/2,1)
Example #42
0
    def __init__(self):
        self.accept("1", self.breakProgram)

        #lighting
        slight = Spotlight('slight')
        slight.setColor((1, 1, 1, 1))
        lens = PerspectiveLens()
        slight.setLens(lens)
        #attaching lighting
        self.slnp = render.attachNewNode(slight)
        self.slnp1 = render.attachNewNode(slight)

        #runs as a thread to change the HPR of the plane
        taskMgr.add(rotatemycube)
Example #43
0
    def __init__(self):
        self.testTexture = loader.loadTexture("maps/envir-reeds.png")
        self.accept("1", self.toggleTex)
        self.accept("2", self.toggleLightsSide)
        self.accept("3", self.toggleLightsUp)

        self.LightsOn = False
        self.LightsOn1 = False
        slight = Spotlight('slight')
        slight.setColor((1, 1, 1, 1))
        lens = PerspectiveLens()
        slight.setLens(lens)
        self.slnp = render.attachNewNode(slight)
        self.slnp1 = render.attachNewNode(slight)
Example #44
0
    def __set_light(self):
        if self.props.shaders:
            eng.set_amb_lgt((.15, .15, .15, 1))
            eng.set_dir_lgt((.8, .8, .8, 1), (-25, -65, 0))
            return
        ambient_lgt = AmbientLight('ambient light')
        ambient_lgt.setColor((.7, .7, .55, 1))
        self.ambient_np = render.attachNewNode(ambient_lgt)
        render.setLight(self.ambient_np)

        self.spot_lgt = render.attachNewNode(Spotlight('Spot'))
        self.spot_lgt.node().setScene(render)
        self.spot_lgt.node().setShadowCaster(True, 1024, 1024)
        self.spot_lgt.node().getLens().setFov(40)
        self.spot_lgt.node().getLens().setNearFar(20, 200)
        self.spot_lgt.node().setCameraMask(BitMask32.bit(0))
        self.spot_lgt.setPos(*self.props.shadow_src)
        self.spot_lgt.lookAt(0, 0, 0)
        render.setLight(self.spot_lgt)
        render.setShaderAuto()
Example #45
0
    def buildSubType(self):
        """Build the light with the given subType"""

        if self.subType == "pointType":
            # make a point light
            c = self.color
            pointLight = PointLight(self.name)
            pointLight.setColor(VBase4(c[0], c[1], c[2], c[3]))
            plnp = self.renderObjectsLight.attachNewNode(pointLight)
            plnp.setPos(self.position)
            self.lightNP = plnp
            self.setLightSwitch(True)

        if self.subType == "directType":
            # make a directional light
            c = self.color
            directLight = DirectionalLight(self.name)
            directLight.setColor(VBase4(c[0], c[1], c[2], c[3]))
            dlnp = self.renderObjectsLight.attachNewNode(directLight)
            dlnp.setHpr(0, -60, 0)  # no idea why its like that.. but it works
            self.lightNP = dlnp
            self.setLightSwitch(True)

        if self.subType == "ambientType":
            # make a ambient light
            c = self.color
            ambientLight = AmbientLight(self.name)
            ambientLight.setColor(VBase4(c[0], c[1], c[2], c[3]))
            alnp = self.renderObjectsLight.attachNewNode(ambientLight)
            self.lightNP = alnp
            self.setLightSwitch(True)

        if self.subType == "spotType":
            # make a spot light
            # lookAtObj = _object.getTag("lookAt") get rid of this.
            c = self.color
            spotLight = Spotlight(self.name)
            spotLight.setColor(VBase4(c[0], c[1], c[2], c[3]))
            lens = PerspectiveLens()
            spotLight.setLens(lens)
            slnp = self.renderObjectsLight.attachNewNode(spotLight)
            slnp.setPos(self.position)
            slnp.setHpr(self.hpr)
            # Find out if this is really the only option
            # because setHpr doesnt seem to have any effect.
            # lookAt would be okay but that means adding anothe type
            #slnp.lookAt(self.main.GameObjects["player"].collisionBody)
            self.lightNP = slnp
            self.setLightSwitch(True)
Example #46
0
class FactorySneakGuardSuit(Suit, FSM):
    notify = directNotify.newCategory('FactorySneakGuardSuit')
    SUIT = 'mrhollywood'
    VIEW_DISTANCE_TASK_NAME = 'ViewDistanceTask'
    MAX_VIEW_DISTANCE = 100.0
    GUARD_DIED_DELAY = 6.0
    MAX_HP = 200
    IN_VIEW = 'somethingInSight'
    HEARD = 'heard'
    TRY_TO_CONFIRM_TIME = 5.0

    def __init__(self, world, guardKey):
        Suit.__init__(self)
        FSM.__init__(self, 'FactorySneakGuardSuit')
        self.gameWorld = world
        self.guardKey = guardKey
        self.viewDistanceTaskName = self.VIEW_DISTANCE_TASK_NAME + '-' + str(id(self))
        self.diedTaskName = 'GuardDied-' + str(id(self))
        self.health = 0
        self.maxHealth = self.MAX_HP
        self.eyeLight = None
        self.eyeLens = None
        self.eyeNode = None
        self.moveTrack = None
        return

    def enterGuard(self):
        self.loop('neutral')
        pos, hpr = CGG.FactoryGuardPoints[self.guardKey]
        self.setHpr(hpr - (180, 0, 0))
        self.setPos(pos)
        base.taskMgr.add(self.__guard, self.taskName('guard'))

    def __guard(self, task):
        if self.eyeNode.node().isInView(base.localAvatar.getPos(self.eyeNode)):
            self.request('SeekTarget', self.IN_VIEW)
            return task.done
        return task.cont

    def exitGuard(self):
        base.taskMgr.remove(self.taskName('guard'))

    def enterTurnToGuardSpot(self):
        self.loop('walk')
        _, hpr = CGG.FactoryGuardPoints[self.guardKey]
        self.moveTrack = LerpHprInterval(self, duration=1.0, hpr=hpr, startHpr=self.getHpr())
        self.moveTrack.setDoneEvent(self.uniqueName('TurnedToGuardSpot'))
        self.acceptOnce(self.moveTrack.getDoneEvent(), self.request, ['Guard'])
        self.moveTrack.start()

    def exitTurnToGuardSpot(self):
        if self.moveTrack:
            self.ignore(self.moveTrack.getDoneEvent())
            self.moveTrack.finish()
            self.moveTrack = None
        return

    def enterSeekTarget(self, event):
        dialogue = random.choice(CGG.GuardDialog[event])
        self.setChat(dialogue)
        self.loop('walk')
        self.moveTrack = NPCLookInterval(self, base.localAvatar)
        self.moveTrack.setDoneEvent(self.uniqueName('SeekLocalAvatar'))
        self.acceptOnce(self.moveTrack.getDoneEvent(), self.request, ['TryToConfirmTarget'])
        self.moveTrack.start()

    def exitSeekTarget(self):
        if self.moveTrack:
            self.ignore(self.moveTrack.getDoneEvent())
            self.moveTrack.finish()
            self.moveTrack = None
        return

    def enterTryToConfirmTarget(self):
        self.loop('neutral')
        base.taskMgr.add(self.__tryToConfirmTarget, self.uniqueName('TryToConfirmTarget'))

    def __tryToConfirmTarget(self, task):
        if task.time >= self.TRY_TO_CONFIRM_TIME:
            chat = random.choice(CGG.GuardDialog['disregard'])
            self.setChat(chat)
            self.request('TurnToGuardSpot')
            return task.done
        if self.eyeNode.node().isInView(base.localAvatar.getPos(self.eyeNode)):
            chat = random.choice(CGG.GuardDialog['spot'])
            self.setChat(chat)
            return task.done
        return task.cont

    def exitTryToConfirmTarget(self):
        base.taskMgr.remove(self.uniqueName('TryToConfirmTarget'))

    def uniqueName(self, name):
        return self.taskName(name)

    def taskName(self, name):
        return name + '-' + str(id(self))

    def setHealth(self, hp):
        self.health = hp

    def getHealth(self):
        return self.health

    def shot(self):
        dialogue = random.choice(CGG.GuardDialog['shot'])
        self.setChat(dialogue)

    def dead(self):
        self.animFSM.request('die')
        base.taskMgr.doMethodLater(self.GUARD_DIED_DELAY, self.__diedDone, self.diedTaskName)

    def __diedDone(self, task):
        self.gameWorld.deleteGuard(self)
        return task.done

    def generate(self):
        data = CIGlobals.SuitBodyData[self.SUIT]
        type = data[0]
        team = data[1]
        self.generateSuit(type, self.SUIT, team, self.MAX_HP, 0, False)
        base.taskMgr.add(self.__viewDistance, self.viewDistanceTaskName)
        self.setPythonTag('guard', self)
        self.eyeLight = Spotlight('eyes')
        self.eyeLens = PerspectiveLens()
        self.eyeLens.setMinFov(90.0 / (4.0 / 3.0))
        self.eyeLight.setLens(self.eyeLens)
        self.eyeNode = self.headModel.attachNewNode(self.eyeLight)
        self.eyeNode.setZ(-5)
        self.eyeNode.setY(-4.5)
        self.request('Guard')

    def __viewDistance(self, task):
        if self.getDistance(base.localAvatar) > self.MAX_VIEW_DISTANCE:
            if not self.isHidden():
                self.hide()
        elif self.isHidden():
            self.show()
        task.delayTime = 1.0
        return task.again

    def disable(self):
        base.taskMgr.remove(self.diedTaskName)
        base.taskMgr.remove(self.viewDistanceTaskName)
        if self.eyeNode:
            self.eyeNode.removeNode()
            self.eyeNode = None
            self.eyeLens = None
            self.eyeLight = None
        self.viewDistanceTaskName = None
        self.guardKey = None
        self.gameWorld = None
        Suit.disable(self)
        return
class Hooded(AICharacter):
	
	SIGHT=7.5
	FOV=60.0
	
	HEIGHT = 1.3
	
	STATE_PATROL = 0
	STATE_SEARCH = 1
	STATE_WANDER = 2
	STATE_ATTACK = 3
	STATE_PAUSED = 4
	
	class StatePatrol:
		pass

	def __init__(self, name, root, route, mass, movforce, maxforce):
		AICharacter.__init__(self, name, root, mass, movforce, maxforce)
		
		self.state = Hooded.STATE_PATROL
		
		self.initTimer = True
		self.attackTimer = True

		# we create a spotlight that will be the sentinel's eye and will be used to fire the inView method
		self.slight = Spotlight('slight')
		self.slight.setColor((1, 1, 1, 1))
		lens = PerspectiveLens()
		lens.setNear(0.1)
		lens.setFar(Hooded.SIGHT)
		lens.setFov(Hooded.FOV)
		
		self.slight.setLens(lens)
		self.slnp = self.get_node_path().attachNewNode(self.slight)
		#TODO: Substitute for a collision polygon, so that the player class alerts an enemy of its presence
		#self.slight.showFrustum()
		
		self.slnp.setH(self.slnp.getH()-180)
		self.slnp.setPos(0, 0, Hooded.HEIGHT)
		
		self.hearing = 5.0
		self.dynamicObstacles = []

		self.detected = False
		self.pathfinding = False
		self.lostTarget = False
		self.countTime = False
		self.goingBack = False
		self.heard = False
		self.isProtected = False
		self.attacked = False
		self.started = False

		self.sentinelHandler = CollisionHandlerQueue()
		
		#TODO: Intruders should be added via an external method
		self.intruders = []

		# this is important: as we said the inView method don't cull geometry but take everything is in sight frustum - therefore to simulate an hide and seek feature we gotta cheat a little: this ray is masked to collide with walls and so if the avatar is behind a wall the ray will be 'deflected' (we'll see how later in the sent_traverse function) - so we know who's behind a wall but we fake we can't see it.
		sentraygeom = CollisionSegment(0, 0, Hooded.HEIGHT, 0, Hooded.SIGHT, Hooded.HEIGHT)
		sentinelRay = self.get_node_path().attachNewNode(CollisionNode('sentinelray'))
		sentinelRay.node().addSolid(sentraygeom)
		# we set to the ray a cumulative masking using the or operator to detect either the avatar's body and the wall geometry
		sentinelRay.node().setFromCollideMask(CollisionMask.PLAYER)
		sentinelRay.node().setIntoCollideMask(CollisionMask.NONE)
		# we add the ray to the sentinel collider and now it is ready to go
		base.cTrav.addCollider(sentinelRay, self.sentinelHandler)
		
		self.screechsound = loader.loadSfx("assets/sounds/enemies/nazgul_scream.mp3")
		
		self.setPatrolPos(route)
		
	def __del__(self):
		self.slnp.removeNode()
		
	def addIntruder(self, intruder):
		self.intruders.append(intruder)

	def setPatrolPos(self, route):
		self.currentTarget = 0
		self.route = route
		self.numTargets = len(route)
		self.increment = 1
		self.getAiBehaviors().seek(self.route[0])
		
	#to update the AIWorld	  
   
	def update(self):
		if (self.started == False):
			return False
		captured = self.sent_detect()
		if (captured):
			if (self.isProtected):
				self.state = Hooded.STATE_PAUSED
			elif (self.state != Hooded.STATE_SEARCH):
				self.state = Hooded.STATE_SEARCH
				self.getAiBehaviors().pauseAi("all")
			self.lostTarget = False
			self.heard = False
			self.resetTimer()
		"""elif (self.heard):
			self.heard = False
			self.pursueTarget = self.hearingPos
			self.getAiBehaviors().pauseAi("all")
			self.state = Hooded.STATE_SEARCH
		elif (self.state == Hooded.STATE_SEARCH and self.lostTarget == False and self.goingBack == False):
			self.startTimer(1.5)
			hasFinished = self.timer()
			if (hasFinished == True):
				self.lostTarget = True
				self.getAiBehaviors().pauseAi("all")
				#self.state = 4
				self.pursueTarget = self.TargetPos
			else:
				self.lostTarget = False"""
				
		if self.state == Hooded.STATE_PATROL:
			self.patrol()
		elif self.state == Hooded.STATE_SEARCH:
			self.pursue()
		elif self.state == Hooded.STATE_WANDER:
			self.wander()
		elif self.state == Hooded.STATE_ATTACK:
			self.kill()
		elif self.state == Hooded.STATE_PAUSED:
			self.pause()


		#elif self.state == Hooded.STATE_SEARCH:
			#self.pathfind()
			
		if (self.attacked):
			self.attacked = False
			return True
		return False
 
 	#TODO: Patrol is ready for refactoring, if needed
 	PATROL_PAUSE = 3.0
 	PATROL_DISTANCE = 1.0
	def patrol(self):
		distance = self.get_node_path().getDistance(self.route[self.currentTarget])
		if (distance < Hooded.PATROL_DISTANCE):
			self.startTimer(Hooded.PATROL_PAUSE)
			self.getAiBehaviors().pauseAi("all")
			if self.timer():
				self.currentTarget = (self.currentTarget + 1) % len(self.route)
				self.resetTimer()
				self.getAiBehaviors().pauseAi("all")
				self.getAiBehaviors().seek(self.route[self.currentTarget])
				self.getAiBehaviors().resumeAi("seek")

	def pathfind(self):
		if (not self.getAiBehaviors().behaviorStatus("pathfollow") in ["active", "done"]):
			self.getAiBehaviors().initPathFind("assets/navmesh.csv")
			self.getAiBehaviors().pauseAi("all")
			if isinstance(self.pursueTarget, NodePath):
				self.getAiBehaviors().pathFindTo(self.pursueTarget)
			else:
				self.getAiBehaviors().pathFindTo(self.pursueTarget.getNodePath())
			for i in self.dynamicObstacles:
				self.getAiBehaviors().addDynamicObstacle(i)

		#self.pathfinding = True
		currentPos = self.get_node_path().getPos(render)

		if (isinstance(self.pursueTarget, NodePath)):
			self.TargetPos = self.pursueTarget
		else:
			self.TargetPos = self.pursueTarget.getNodePath()

# 		print currentPos, self.TargetPos
		distance = self.get_node_path().getDistance(self.TargetPos)
			
		if (self.getAiBehaviors().behaviorStatus("pathfollow") == "done"):
			if (distance > 5):
				self.getAiBehaviors().pauseAi("all")
				return

			if (self.lostTarget == False):
				if (self.goingBack == True):
					self.getAiBehaviors().pauseAi("all")
					self.getAiBehaviors().seek(self.route[self.currentTarget])
					self.state = Hooded.STATE_PATROL
					self.getAiBehaviors().resumeAi("seek")
					self.resetTimer()
					self.goingBack = False
				elif (self.heard == True):
						if (isinstance(self.pursueTarget, NodePath)):
							self.getAiBehaviors().pauseAi("all")
							self.state = Hooded.STATE_ATTACK
						else:
							self.startTimer(5)
							self.countTime = True
							self.pathfinding = False
							self.state = Hooded.STATE_WANDER
							self.radius = 5
							self.aoe = 10
				else:
					self.getAiBehaviors().pauseAi("all")
					self.state = Hooded.STATE_ATTACK
			else:
				self.startTimer(5)
				self.countTime = True
				self.pathfinding = False
				self.state = Hooded.STATE_WANDER
				self.radius = 5
				self.aoe = 10

	def wander(self):
		if (self.getAiBehaviors().behaviorStatus("wander") != "active"):
			self.getAiBehaviors().pauseAi("all")
			self.getAiBehaviors().wander(self.radius, 0,self.aoe, 1.0)
			#self.getAiBehaviors().resumeAi("wander")

		if (self.lostTarget == True and self.countTime == True):
			self.startTimer(5)
			hasFinished = self.timer()
			if (hasFinished == True):
				self.currentTarget += self.increment
				if (self.currentTarget == self.numTargets - 1):
					self.increment = -1
				else:
					if (self.currentTarget == 0):
						self.increment = 1
				self.pursueTarget = self.route[self.currentTarget]
				self.state = Hooded.STATE_SEARCH
				self.goingBack = True
				self.lostTarget= False
				self.getAiBehaviors().pauseAi("all")

				#self.getAiBehaviors().seek(self.route[self.currentTarget])
		
	def kill(self):
		if (self.attackTimer):
			self.attacked = True
			self.attackTimer = False
			self.startTimer(3)
			self.pause()
		else:
			hasFinished = self.timer()
			if (hasFinished):
				self.attackTimer = True
				self.resetTimer()
				self.state = Hooded.STATE_SEARCH
			else:
				self.attacked = False

	#TODO: Use event handling, instead?
	def sent_traverse(self, suspect):
		if (self.sentinelHandler.getNumEntries() > 0):
			self.sentinelHandler.sortEntries()
# 			for i in range(self.sentinelHandler.getNumEntries()):
# 				print self.sentinelHandler.getEntry(i)
			entry = self.sentinelHandler.getEntry(0)
			self.sentinelHandler.clearEntries()
			colliderNP = entry.getIntoNodePath()
			if colliderNP.getParent() == suspect.getNodePath():
# 				self = False
				if self.detected == False:
					self.detected = True
					self.screechsound.play()
					suspect.boo()
				return True
			#TODO: This was meant for the implementation of safe areas, where the player could not be reached
			elif colliderNP.getName() == 'lightarea':
				newEntry = self.sentinelHandler.getEntry(1)
				newColliderNode = newEntry.getIntoNode()
				if (newColliderNode.getName() == 'playercol'):
					#check if player is really inside light area
					self.isProtected = True
					return True
		return False

	#** Here then we'll unleash the power of isInView method - this function is just a query if a 3D point is inside its frustum so it works for objects with lens, such as cameras or even, as in this case, a spotlight. But to make this happen, we got cheat a little, knowing in advance who we're going to seek, to query its position afterwards, and that's what the next line is about: to collect all the references for objects named 'smiley'
   
	def sent_detect(self):
		for o in self.intruders:
		# query the spotlight if something listed as 'intruders' is-In-View at its position and if this is the case we'll call the traverse function above to see if is open air or hidden from the sentinel's sight
			if self.slnp.node().isInView(o.getNodePath().getPos(self.slnp)):
				self.get_node_path().lookAt(o.getNodePath())
				if self.sent_traverse(o):
					self.pursueTarget = o
					return True
		return False

	def timer(self):
		currentTime = time.time()
		diff = currentTime - self.time
		if (diff > self.interval):
			self.initTimer = True
			return True
		else:
			return False

	def resetTimer(self):
		self.initTimer = True

	def startTimer(self, interval):
		if (self.initTimer == True):
			self.interval = interval
			self.initTimer = False
			self.time = time.time()

	def addDynamicObject(self, dynamicObject):
		self.dynamicObstacles.append(dynamicObject)

	def hear(self, noisePos):
		dist = self.get_node_path().getDistance(noisePos)
		if (dist <= self.hearing):
			self.heard = True
			self.hearingPos = noisePos

	def pause(self):
		self.getAiBehaviors().pauseAi("all")
		#print "nao pausei?"

	def start(self):
		self.started = True

	def stop(self):
		self.started = False

	def clean(self):
		loader.unloadSfx(self.screechsound)

	def pursue(self):
		self.getAiBehaviors().pursue(self.pursueTarget.getNodePath())
		if (self.get_node_path().getDistance(self.pursueTarget.getNodePath()) < 1):
			self.state = Hooded.STATE_ATTACK
Example #48
0
class Map:
    def __init__(self,filename):
        self.height = 0
        self.width = 0
        self.waterheight = 0
        self.countries = []
        self.tileList = []
        self.tileReference = {}
        self.node = render.attachNewNode('BaseMap')
        
        self.snow = loader.loadModel("data/models/snow.bam")
        self.ice = loader.loadModel("data/models/ice.bam")
        self.plains = loader.loadModel("data/models/plains.bam")
        self.forest = loader.loadModel("data/models/forest.bam")
        self.jaggedrocks = loader.loadModel("data/models/jaggedrocks.bam")
        self.mountain = loader.loadModel("data/models/mountains.bam")
        self.desert = loader.loadModel("data/models/desert.bam")
        self.hills = loader.loadModel("data/models/hills.bam")
        self.water = loader.loadModel("data/models/water.bam")
        self.water.setTransparency(TransparencyAttrib.MAlpha)

        self.watertop = loader.loadModel("data/models/watertop.bam")
        self.waterbottom = loader.loadModel("data/models/waterbottom.bam")
        
        render.setShaderAuto()
        
        self.spot = Spotlight('World spot')
        self.spot.setColor((.7,.7,.7,1))
        self.spot.getLens().setFov(180)
        self.spot.getLens().setNearFar(1,10000000)
        self.spotNode = render.attachNewNode(self.spot)
        self.spotNode.setPos(2000,2000,5000)
        self.spotNode.lookAt(self.node)
        render.setLight(self.spotNode)
        
        self.createMap(filename)
        
        self.watertop.reparentTo(self.node)
        self.watertop.setScale(9,9,9)
        self.watertop.setPos((self.width*60)/2,-(self.height*17)/2,5)
        
        self.waterbottom.reparentTo(self.node)
        self.waterbottom.setScale(9,9,9)
        self.waterbottom.setPos((self.width*60)/2,-(self.height*17)/2,1)
        
    def getCountry(self,countryNum):
        return self.countries[countryNum]
        
    def drawMap(self):
        pass
        
    def createMap(self,filename):
        filein = open(filename,"rb")
        countryCounter = 0
        tileCounter = 0
        countryTiles = []
        countryIncome = 0
        
        for line in filein:
            words = line.split()
            if len(words) > 0:
                if words[0] == "<map>":
                    pass
                elif words[0] == "<height>":
                    self.height = eval(words[1])
                elif words[0] == "<width>":
                    self.width = eval(words[1])
                elif words[0] == "<waterheight>":
                    self.waterheight = eval(words[1])
                elif words[0] == "<tile>":
                    terrainType = eval(words[1])
                    newNode = self.node.attachNewNode('terrain'+str(tileCounter))
                    newNode.setTag('tile',str(tileCounter))
                    if terrainType == TERRAIN_WATER:
                        self.water.instanceTo(newNode)
                    elif terrainType == TERRAIN_SNOW:
                        self.snow.instanceTo(newNode)
                    elif terrainType == TERRAIN_ICE:
                        self.ice.instanceTo(newNode)
                    elif terrainType == TERRAIN_PLAINS:
                        self.plains.instanceTo(newNode)
                    elif terrainType == TERRAIN_FOREST:
                        self.forest.instanceTo(newNode)
                    elif terrainType == TERRAIN_JAGGEDROCKS:
                        self.jaggedrocks.instanceTo(newNode)
                    elif terrainType == TERRAIN_MOUNTAIN:
                        self.mountain.instanceTo(newNode)
                    elif terrainType == TERRAIN_DESERT:
                        self.desert.instanceTo(newNode)
                    elif terrainType == TERRAIN_HILLS:
                        self.hills.instanceTo(newNode)
                    x = (tileCounter % self.width)
                    y = (tileCounter / self.width)
                    if y % 2 == 0:
                        newNode.setPos(x*60,-y*17,0)
                    else:
                        newNode.setPos(x*60+30,-y*17,0)
                    newTile = Tile(terrainType,newNode,x,y,tileCounter)
                    self.tileList.append(newTile)
                    tileCounter += 1
                elif words[0] == "<income>":
                    countryIncome = eval(words[1])
                elif words[0] == "<tileNum>":
                    countryTiles.append(self.tileList[eval(words[1])])
                elif words[0] == "</country>":
                    newCountry = Country(countryTiles,countryIncome)
                    self.countries.append(newCountry)
                    countryCounter += 1
                    countryTiles = []
                    countryIncome = 0
                else:
                    pass
        #end loop
        
        for country in range(len(self.countries)):
            for tile in self.countries[country].getTiles():
                x = tile.getX()
                y = tile.getY()
                self.tileReference[(x,y)]=country
        filein.close()
        #end init   
    def getTile(self,x,y):
        #get the tile from the country it is in from spectile
        return self.countries[self.tileReference[(x,y)]].getSpecTile(x,y)
        
    def getPlayerCountries(self,playerNum):
        #return the list of countries that belong to that player
        playerCountries = []
        for country in self.countries:
            if country.getOwner() == playerNum:
                playerCountries.append(country)
        return playerCountries
        
        
    
        
        
Example #49
0
            # just make another branch connected to this one with a small
            # variation in direction
            makeFractalTree(bodydata, nodePath, length, newPos,
                            numIterations - 1, numCopies, smallRandomAxis(vecList))

    else:
        drawBody(nodePath, bodydata, pos, vecList, length.getX(), False)
        drawLeaf(nodePath, bodydata, pos, vecList)


alight = AmbientLight('alight')
alight.setColor((0.5, 0.5, 0.5, 1))
alnp = render.attachNewNode(alight)
render.setLight(alnp)

slight = Spotlight('slight')
slight.setColor((1, 1, 1, 1))
lens = PerspectiveLens()
slight.setLens(lens)
slnp = render.attachNewNode(slight)
render.setLight(slnp)

slnp.setPos(0, 0, 40)

# rotating light to show that normals are calculated correctly
def updateLight(task):
    global slnp
    currPos = slnp.getPos()
    currPos.setX(100 * math.cos(task.time) / 2)
    currPos.setY(100 * math.sin(task.time) / 2)
    slnp.setPos(currPos)
		else:
			#just make another branch connected to this one with a small variation in direction
			makeFractalTree(bodydata, nodePath,length,newPos, numIterations-1,numCopies,smallRandomAxis(vecList))

	else:
		drawBody(nodePath,bodydata, pos, vecList, length.getX(),False)
		drawLeaf(nodePath,bodydata, pos,vecList)



alight = AmbientLight('alight')
alight.setColor(Vec4(0.5, 0.5, 0.5, 1))
alnp = render.attachNewNode(alight)
render.setLight(alnp)

slight = Spotlight('slight')
slight.setColor(Vec4(1, 1, 1, 1))
lens = PerspectiveLens()
slight.setLens(lens)
slnp = render.attachNewNode(slight)
render.setLight(slnp)

slnp.setPos(0, 0,40)

#rotating light to show that normals are calculated correctly
def updateLight(task):
	global slnp
	currPos=slnp.getPos()
	currPos.setX(100*math.cos(task.time)/2)
	currPos.setY(100*math.sin(task.time)/2)
	slnp.setPos(currPos)
Example #51
0
 def parse_scene(self,scene,parent=None):
     tmp_statics = scene["statics"]; lst_statics = {}; it = 0
     for elt in tmp_statics["sol"]:
         if not self.dic_statics.has_key(elt): self.dic_statics[elt] = base.loader.loadModel(elt+".bam")
         for posrot in tmp_statics["sol"][elt]:
             tmp_inst = render.attachNewNode("sol_"+str(it)); self.dic_statics[elt].instanceTo(tmp_inst)
             tmp_inst.setPos(posrot[0][0]*4.8,posrot[0][1]*4.8,posrot[0][2]*4.8); tmp_inst.setHpr(posrot[1][0],posrot[1][1],posrot[1][2])
             tmp_inst.reparentTo(render); lst_statics["sol_"+str(it)] = tmp_inst
             #
             # TODO : génération de la carte si besoin
             #
             # TODO : voir pour le navigational mesh ici
             #
             it += 1
     for key in ["nord","sud","est","ouest"]:
         for elt in tmp_statics["bords"][key]:
             #
             print elt
             #
             if key == "nord":
                 #
                 #
                 pass
             elif key == "sud":
                 #
                 #
                 pass
             elif key == "est":
                 #
                 #
                 pass
             elif key == "ouest":
                 #
                 #
                 pass
             #
             pass
         for elt in tmp_statics["murs"][key]:
             #
             print elt
             #
             #
             pass
         for elt in tmp_statics["decors"][key]:
             #
             print elt
             #
             #
             pass
     #
     # TODO : chargement des animations
     #
     tmp_dynamics = scene["dynamics"]; lst_dynamics = {}
     #
     for elt in tmp_dynamics:
         #
         #
         #
         pass
     #
     #
     tmp_lights = scene["lights"]; lst_lights = {}
     for lght in tmp_lights:
         tmp_lght = None
         if lght[0] == 0:
             spot_light = Spotlight("spotlight"); spot_light.setColor(Vec4(lght[1][0],lght[1][1],lght[1][2],lght[1][3]))
             lens = PerspectiveLens(); spot_light.setLens(lens); tmp_lght = render.attachNewNode(spot_light)
             tmp_lght.lookAt(lght[3][0],lght[3][1],lght[3][2]); tmp_lght.setPos(lght[2][0],lght[2][1],lght[2][2])
         elif lght[0] == 1:
             dir_light = DirectionalLight("dir_light"); dir_light.setColor(Vec4(lght[1][0],lght[1][1],lght[1][2],lght[1][3]))
             tmp_lght = render.attachNewNode(dir_light); tmp_lght.setHpr(lght[3][0],lght[3][1],lght[3][2])
         if lght[4]:
             if lght[5] != None: lght[5].setLight(tmp_lght)
             else: render.setLight(tmp_lght)
         lst_lights[lght[6]] = tmp_lght
     #
     #
     #
     return lst_statics, lst_dynamics, lst_lights
def runViewer(mesh):
    scene_members = getSceneMembers(mesh)
    
    loadPrcFileData('', 'win-size 300 300')
    base = ShowBase()
    globNode = GeomNode("collada")
    nodePath = base.render.attachNewNode(globNode)
    
    rotateNode = GeomNode("rotater")
    rotatePath = nodePath.attachNewNode(rotateNode)
    matrix = numpy.identity(4)
    if mesh.assetInfo.upaxis == collada.asset.UP_AXIS.X_UP:
        r = collada.scene.RotateTransform(0,1,0,90)
        matrix = r.matrix
    elif mesh.assetInfo.upaxis == collada.asset.UP_AXIS.Y_UP:
        r = collada.scene.RotateTransform(1,0,0,90)
        matrix = r.matrix
    rotatePath.setMat(Mat4(*matrix.T.flatten().tolist()))
    
    basecollada = GeomNode("basecollada")
    basecolladaNP = rotatePath.attachNewNode(basecollada)
    for geom, renderstate, mat4 in scene_members:
        node = GeomNode("primitive")
        node.addGeom(geom)
        if renderstate is not None:
            node.setGeomState(0, renderstate)
        geomPath = basecolladaNP.attachNewNode(node)
        geomPath.setMat(mat4)

    for boundlight in mesh.scene.objects('light'):
        
        if len(boundlight.color) == 3:
            color = (boundlight.color[0], boundlight.color[1], boundlight.color[2], 1)
        else:
            color = boundlight.color
        
        if isinstance(boundlight, collada.light.BoundDirectionalLight):
            dl = DirectionalLight('dirLight')
            dl.setColor(Vec4(color[0], color[1], color[2], color[3]))
            lightNP = rotatePath.attachNewNode(dl)
            lightNP.lookAt(Point3(boundlight.direction[0],boundlight.direction[1],boundlight.direction[2]))
        elif isinstance(boundlight, collada.light.BoundAmbientLight):
            ambientLight = AmbientLight('ambientLight')
            ambientLight.setColor(Vec4(color[0], color[1], color[2], color[3]))
            lightNP = rotatePath.attachNewNode(ambientLight)
        elif isinstance(boundlight, collada.light.BoundPointLight):
            pointLight = PointLight('pointLight')
            pointLight.setColor(Vec4(color[0], color[1], color[2], color[3]))
            pointLight.setAttenuation(Vec3(boundlight.constant_att, boundlight.linear_att, boundlight.quad_att))
            lightNP = rotatePath.attachNewNode(pointLight)
            lightNP.setPos(Vec3(boundlight.position[0], boundlight.position[1], boundlight.position[2]))
        elif isinstance(boundlight, collada.light.BoundSpotLight):
            spotLight = Spotlight('spotLight')
            spotLight.setColor(Vec4(color[0], color[1], color[2], color[3]))
            spotLight.setAttenuation(Vec3(boundlight.constant_att, boundlight.linear_att, boundlight.quad_att))
            spotLight.setExponent(boundlight.falloff_exp)
            lightNP = rotatePath.attachNewNode(spotLight)
            lightNP.setPos(Vec3(boundlight.position[0], boundlight.position[1], boundlight.position[2]))
            lightNP.lookAt(Point3(boundlight.direction[0], boundlight.direction[1], boundlight.direction[2]),
                               Vec3(boundlight.up[0], boundlight.up[1], boundlight.up[2]))
        else:
            print('Unknown light type', boundlight)
            continue
            
        base.render.setLight(lightNP)

    for boundcam in mesh.scene.objects('camera'):
        if isinstance(boundcam, collada.camera.BoundPerspectiveCamera):
            base.camera.reparentTo(rotatePath)
            base.camLens.setNear(boundcam.znear)
            base.camLens.setFar(boundcam.zfar)
            
            if boundcam.xfov is not None and boundcam.yfov is not None:
                #xfov + yfov
                base.camLens.setFov(boundcam.xfov, boundcam.yfov)
            elif boundcam.xfov is not None and boundcam.aspect_ratio is not None:
                #xfov + aspect_ratio
                base.camLens.setFov(boundcam.xfov)
                base.camLens.setAspectRatio(boundcam.aspect_ratio)
            elif boundcam.yfov is not None and boundcam.aspect_ratio is not None:
                #yfov + aspect_ratio
                #aspect_ratio = tan(0.5*xfov) / tan(0.5*yfov)
                xfov = math.degrees(2.0 * math.atan(boundcam.aspect_ratio * math.tan(math.radians(0.5 * boundcam.yfov))))
                base.camLens.setFov(xfov, boundcam.yfov)
            elif boundcam.yfov is not None:
                #yfov only
                #aspect_ratio = tan(0.5*xfov) / tan(0.5*yfov)
                xfov = math.degrees(2.0 * math.atan(base.camLens.getAspectRatio() * math.tan(math.radians(0.5 * boundcam.yfov))))
                base.camLens.setFov(xfov, boundcam.yfov)
            elif boundcam.xfov is not None:
                base.camLens.setFov(boundcam.xfov)
            
            base.camera.setPos(Vec3(boundcam.position[0], boundcam.position[1], boundcam.position[2]))
            base.camera.lookAt(Point3(boundcam.direction[0], boundcam.direction[1], boundcam.direction[2]),
                               Vec3(boundcam.up[0], boundcam.up[1], boundcam.up[2]))
        elif isinstance(boundcam, collada.camera.BoundOrthographicCamera):
            
            lens = OrthographicLens()
            base.cam.node().setLens(lens)
            base.camLens = lens
            base.camera.reparentTo(rotatePath)
            base.camLens.setNear(boundcam.znear)
            base.camLens.setFar(boundcam.zfar)
            
            if boundcam.xmag is not None and boundcam.ymag is not None:
                #xmag + ymag
                base.camLens.setFilmSize(boundcam.xmag, boundcam.ymag)
            elif boundcam.xmag is not None and boundcam.aspect_ratio is not None:
                #xmag + aspect_ratio
                base.camLens.setFilmSize(boundcam.xmag)
                base.camLens.setAspectRatio(boundcam.aspect_ratio)
            elif boundcam.ymag is not None and boundcam.aspect_ratio is not None:
                #ymag + aspect_ratio
                xmag = boundcam.aspect_ratio * boundcam.ymag
                base.camLens.setFilmSize(xmag, boundcam.ymag)
            elif boundcam.ymag is not None:
                #ymag only
                xmag = base.camLens.getAspectRatio() * boundcam.ymag
                base.camLens.setFilmSize(xmag, boundcam.ymag)
            elif boundcam.xmag is not None:
                base.camLens.setFilmSize(boundcam.xmag)
            
            base.camera.setPos(Vec3(boundcam.position[0], boundcam.position[1], boundcam.position[2]))
            base.camera.lookAt(Point3(boundcam.direction[0], boundcam.direction[1], boundcam.direction[2]),
                               Vec3(boundcam.up[0], boundcam.up[1], boundcam.up[2]))
            
        else:
            print('Unknown camera type', boundcam)
            continue

    base.disableMouse()
    base.render.setShaderAuto()
    base.render.setTransparency(TransparencyAttrib.MDual, 1)
    
    KeyboardMovement()
    MouseDrag(basecolladaNP)
    MouseScaleZoom(basecolladaNP)
    
    base.run()
	def __init__(self):
		ShowBase.__init__(self)

		self.gameTask = taskMgr.add(self.flyCircles, "circles")

		base.disableMouse()
		
		base.camera.setPos(-400, 00, 400)
		base.camera.lookAt(00, 000, 0)

		slight = Spotlight('slight')
		slight.setColor(VBase4(1, 1, 1, 1))
		lens = PerspectiveLens()
		slight.setLens(lens)

		self.rebels = []
		self.imperials = []

		# add rebel ships
		self.rebels += [Xwing('xwing' + str(x)) for x in xrange(1)]
		#self.rebels += [Ywing('ywing' + str(x)) for x in xrange(1)]
		#self.rebels += [Awing('awing' + str(x)) for x in xrange(1)]
		#self.rebels += [Bwing('bwing' + str(x)) for x in xrange(1)]

		# add imperial ships
		self.imperials += [TieFighter('tiefighter' + str(x)) for x in xrange(1)]
		#self.imperials += [TieInterceptor('tieinterceptor' + str(x)) for x in xrange(2)]

		# add rebel ships
		self.rebels += [Xwing('xwing' + str(x) + 'second') for x in xrange(1)]
		#self.rebels += [Ywing('ywing' + str(x) + 'second') for x in xrange(1)]
		#self.rebels += [Awing('awing' + str(x) + 'second') for x in xrange(1)]
		#self.rebels += [Bwing('bwing' + str(x) + 'second') for x in xrange(1)]

		# add more imperial ships
		#self.imperials += [TieFighter('tiefighter' + str(x) + 'second') for x in xrange(2)]
		self.imperials += [TieInterceptor('tieinterceptor' + str(x) + 'second') for x in xrange(1)]
		
		# create ship list
		self.shipList = self.rebels + self.imperials

		#self.shipList = [
		#	Xwing("xwing1"), TieFighter("tie1"), Bwing("xwing2")]

		lightColors = [
			Vec4(0.9, 0.9, 0.9, 1),
			Vec4(0.9, 0.9, 0.9, 1),]

		for i, ship in enumerate(self.shipList):
			ship.reparentTo(render)
			ship.setScale(2)
			ship.setPos(Point3(i*50+50,i*100+100,i*50+50))

			directionalLight = DirectionalLight('directionalLight')
			directionalLightNP = render.attachNewNode(directionalLight)

			directionalLightNP.setHpr(180, -20, 0)
			ship.setLight(directionalLightNP)
			#ship.navSystem.setPursue()

		self.count = 0

		self.iter = 0

		camera.lookAt(self.shipList[1].getPos())
Example #54
0
	def __init__(self):
		ShowBase.__init__(self)
		
		#Setup
		scene = BulletWorld()
		scene.setGravity(Vec3(0, 0, -9.81))
		base.setBackgroundColor(0.6,0.9,0.9)
		fog = Fog("The Fog")
		fog.setColor(0.9,0.9,1.0)
		fog.setExpDensity(0.003)
		render.setFog(fog)
		#Lighting
		
		#Sun light
		sun = DirectionalLight("The Sun")
		sun_np = render.attachNewNode(sun)
		sun_np.setHpr(0,-60,0)
		render.setLight(sun_np)
		
		#Ambient light
		amb = AmbientLight("The Ambient Light")
		amb.setColor(VBase4(0.39,0.39,0.39, 1))
		amb_np = render.attachNewNode(amb)
		render.setLight(amb_np)
		
		#Variables
		self.gear = 0
		
		self.start = 0
		
		self.Pbrake = 0
		
		self.terrain_var = 1
		
		self.time = 0
		
		self.headlight_var = 0
		
		self.RPM = 0
		
		self.clutch = 0
		
		self.carmaxspeed = 100 #KPH
		
		self.carmaxreversespeed = -40 #KPH
		
		self.steering = 0
		
		
		#Functions
		def V1():
			camera.setPos(0.25,-1.2,0.5)
			camera.setHpr(0,-13,0)
			
		def V2():
			camera.setPos(0,-15,3)
			camera.setHpr(0,-10,0)
			
		def V3():
			camera.setPos(0,0,9)
			camera.setHpr(0,-90,0)
			
		def up():
			self.gear = self.gear -1
			if self.gear < -1:
				self.gear = -1
				
		def down():
			self.gear = self.gear +1
			if self.gear > 1:
				self.gear = 1
				
		def start_function():
			self.start = 1
			self.start_sound.play()
			self.engine_idle_sound.play()
			self.RPM = 1000
			
		def stop_function():
			self.start = 0
			self.engine_idle_sound.stop()
				
		def parkingbrake():
			self.Pbrake = (self.Pbrake + 1) % 2
			
		def rotate():
			Car_np.setHpr(0, 0, 0)
			
		def horn():
			self.horn_sound.play()
			
		def set_time():
			if self.time == -1:
				sun.setColor(VBase4(0.4, 0.3, 0.3, 1))
				base.setBackgroundColor(0.8,0.7,0.7)
			if self.time == 0:
				sun.setColor(VBase4(0.7, 0.7, 0.7, 1))
				base.setBackgroundColor(0.6,0.9,0.9)
			if self.time == 1:
				sun.setColor(VBase4(0.2, 0.2, 0.2, 1))
				base.setBackgroundColor(0.55,0.5,0.5)
			if self.time == 2:
				sun.setColor(VBase4(0.02, 0.02, 0.05, 1))
				base.setBackgroundColor(0.3,0.3,0.3)
				
			if self.time == -2:
				self.time = -1
			if self.time == 3:
				self.time = 2
			
		def time_forward():
			self.time = self.time + 1
			
		def time_backward():
			self.time = self.time -1
			
		def set_terrain():
			if self.terrain_var == 1:
				self.ground_model.setTexture(self.ground_tex, 1)
				self.ground_model.setScale(3)
			if self.terrain_var == 2:
				self.ground_model.setTexture(self.ground_tex2, 1)
				self.ground_model.setScale(3)
			if self.terrain_var == 3:
				self.ground_model.setTexture(self.ground_tex3, 1)
				self.ground_model.setScale(4)
				
			if self.terrain_var == 4:
				self.terrain_var = 1
			if self.terrain_var == 0:
				self.terrain_var = 3
			
		def next_terrain():
			self.terrain_var = self.terrain_var + 1
			
		def previous_terrain():
			self.terrain_var = self.terrain_var - 1
			
		def show_menu():
			self.menu_win.show()
			self.a1.show()
			self.a2.show()
			self.a3.show()
			self.a4.show()
			self.t1.show()
			self.t2.show()
			self.ok.show()
			self.exit_button.show()
			
		def hide_menu():
			self.menu_win.hide()
			self.a1.hide()
			self.a2.hide()
			self.a3.hide()
			self.a4.hide()
			self.ok.hide()
			self.t1.hide()
			self.t2.hide()
			self.exit_button.hide()
		
		def Menu():
			self.menu_win = OnscreenImage(image = "Textures/menu.png", pos = (0.9,0,0), scale = (0.5))
			self.menu_win.setTransparency(TransparencyAttrib.MAlpha)
			
			#The Arrow Buttons
			self.a1 = DirectButton(text = "<", scale = 0.2, pos = (0.55,0,0.25), command = previous_terrain)
			self.a2 = DirectButton(text = ">", scale = 0.2, pos = (1.15,0,0.25), command = next_terrain)
			self.a3 = DirectButton(text = "<", scale = 0.2, pos = (0.55,0,0.0), command = time_backward)
			self.a4 = DirectButton(text = ">", scale = 0.2, pos = (1.15,0,0.0), command = time_forward)
			
			#The Text
			self.t1 = OnscreenText(text = "Terrain", pos = (0.85,0.25,0), scale = 0.1, fg = (0.4,0.4,0.5,1))
			self.t2 = OnscreenText(text = "Time", pos = (0.85,0,0), scale = 0.1, fg = (0.4,0.4,0.5,1))
			
			#The Buttons
			self.ok = DirectButton(text = "Okay", scale = 0.11, pos = (0.87,0,-0.25), command = hide_menu)
			self.exit_button = DirectButton(text = "Quit", scale = 0.11, pos = (0.87,0,-0.42), command = sys.exit)
			
		Menu()
		
		
		def take_screenshot():
			base.screenshot("Screenshot")
			
		def set_headlights():
			if self.headlight_var == 1:
				Headlight1.setColor(VBase4(9.0,8.9,8.9,1))
				Headlight2.setColor(VBase4(9.0,8.9,8.9,1))
			if self.headlight_var == 0:
				Headlight1.setColor(VBase4(0,0,0,1))
				Headlight2.setColor(VBase4(0,0,0,1))
			
		def headlights():
			self.headlight_var = (self.headlight_var + 1) % 2
			
		def update_rpm():
			
			#Simulate RPM
			if self.start == 1:
				if self.gear == 0:
					self.RPM = self.RPM - self.RPM / 400
				else:
					self.RPM = self.RPM + self.carspeed / 9
					self.RPM = self.RPM - self.RPM / 200
			
			#Reset RPM to 0 when engine is off
			if self.start == 0:
				if self.RPM > 0.0:
					self.RPM = self.RPM - 40
				if self.RPM < 10:
					self.RPM = 0.0
								
			#Idle RPM power
			if self.start == 1:
				if self.RPM < 650:
					self.RPM = self.RPM + 4
				if self.RPM < 600:
					self.clutch = 1
				else:
					self.clutch = 0
					
			#RPM limit		
			if self.RPM > 6000:
				self.RPM = 6000
				

		#Controls 
		inputState.watchWithModifiers("F", "arrow_up")
		inputState.watchWithModifiers("B", "arrow_down")
		inputState.watchWithModifiers("L", "arrow_left")
		inputState.watchWithModifiers("R", "arrow_right")
		
		do = DirectObject()
		
		do.accept("escape", show_menu)
		do.accept("1", V1)
		do.accept("2", V2)
		do.accept("3", V3)
		do.accept("page_up", up)
		do.accept("page_down", down)
		do.accept("x-repeat", start_function)
		do.accept("x", stop_function)
		do.accept("p", parkingbrake)
		do.accept("backspace", rotate)
		do.accept("enter", horn)
		do.accept("f12", take_screenshot)
		do.accept("h", headlights)
		
		#The ground
		self.ground = BulletPlaneShape(Vec3(0, 0, 1,), 1)
		self.ground_node = BulletRigidBodyNode("The ground")
		self.ground_node.addShape(self.ground)
		self.ground_np = render.attachNewNode(self.ground_node)
		self.ground_np.setPos(0, 0, -2)
		scene.attachRigidBody(self.ground_node)
		
		self.ground_model = loader.loadModel("Models/plane.egg")
		self.ground_model.reparentTo(render)
		self.ground_model.setPos(0,0,-1)
		self.ground_model.setScale(3)
		self.ground_tex = loader.loadTexture("Textures/ground.png")
		self.ground_tex2 = loader.loadTexture("Textures/ground2.png")
		self.ground_tex3 = loader.loadTexture("Textures/ground3.png")
		self.ground_model.setTexture(self.ground_tex, 1)
		
		#The car
		Car_shape = BulletBoxShape(Vec3(1, 2.0, 1.0))
		Car_node = BulletRigidBodyNode("The Car")
		Car_node.setMass(1200.0)
		Car_node.addShape(Car_shape)
		Car_np = render.attachNewNode(Car_node)
		Car_np.setPos(0,0,3)
		Car_np.setHpr(0,0,0)
		Car_np.node().setDeactivationEnabled(False)
		scene.attachRigidBody(Car_node)
		
		Car_model = loader.loadModel("Models/Car.egg")
		Car_model.reparentTo(Car_np)
		Car_tex = loader.loadTexture("Textures/Car1.png")
		Car_model.setTexture(Car_tex, 1)
		
		self.Car_sim = BulletVehicle(scene, Car_np.node())
		self.Car_sim.setCoordinateSystem(ZUp)
		scene.attachVehicle(self.Car_sim)
		
		#The inside of the car
		Car_int = loader.loadModel("Models/inside.egg")
		Car_int.reparentTo(Car_np)
		Car_int_tex = loader.loadTexture("Textures/inside.png")
		Car_int.setTexture(Car_int_tex, 1)
		Car_int.setTransparency(TransparencyAttrib.MAlpha)
		
		#The steering wheel
		Sw = loader.loadModel("Models/Steering wheel.egg")
		Sw.reparentTo(Car_np)
		Sw.setPos(0.25,0,-0.025)
		
		#The first headlight
		Headlight1 = Spotlight("Headlight1")
		lens = PerspectiveLens()
		lens.setFov(180)
		Headlight1.setLens(lens)
		Headlight1np = render.attachNewNode(Headlight1)
		Headlight1np.reparentTo(Car_np)
		Headlight1np.setPos(-0.8,2.5,-0.5)
		Headlight1np.setP(-15)
		render.setLight(Headlight1np)
		
		#The second headlight
		Headlight2 = Spotlight("Headlight2")
		Headlight2.setLens(lens)
		Headlight2np = render.attachNewNode(Headlight2)
		Headlight2np.reparentTo(Car_np)
		Headlight2np.setPos(0.8,2.5,-0.5)
		Headlight2np.setP(-15)
		render.setLight(Headlight2np)
		
		#Sounds
		self.horn_sound = loader.loadSfx("Sounds/horn.ogg")
		self.start_sound = loader.loadSfx("Sounds/enginestart.ogg")
		self.engine_idle_sound = loader.loadSfx("Sounds/engineidle.ogg")
		self.engine_idle_sound.setLoop(True)
		self.accelerate_sound = loader.loadSfx("Sounds/enginethrottle.ogg")
				
		#Camera
		base.disableMouse()
		camera.reparentTo(Car_np)
		camera.setPos(0,-15,3)
		camera.setHpr(0,-10,0)
		
		#Wheel function
		def Wheel(pos, np, r, f):
			w = self.Car_sim.createWheel()
			w.setNode(np.node())
			w.setChassisConnectionPointCs(pos)
			w.setFrontWheel(f)
			w.setWheelDirectionCs(Vec3(0, 0, -1))
			w.setWheelAxleCs(Vec3(1, 0, 0))
			w.setWheelRadius(r)
			w.setMaxSuspensionTravelCm(40)
			w.setSuspensionStiffness(120)
			w.setWheelsDampingRelaxation(2.3)
			w.setWheelsDampingCompression(4.4)
			w.setFrictionSlip(50)
			w.setRollInfluence(0.1)
		
		#Wheels	
		w1_np = loader.loadModel("Models/Lwheel")
		w1_np.reparentTo(render)
		w1_np.setColorScale(0,6)
		Wheel(Point3(-1,1,-0.6), w1_np, 0.4, False)
		
		w2_np = loader.loadModel("Models/Rwheel")
		w2_np.reparentTo(render)
		w2_np.setColorScale(0,6)
		Wheel(Point3(-1.1,-1.2,-0.6), w2_np, 0.4, True)
		
		w3_np = loader.loadModel("Models/Lwheel")
		w3_np.reparentTo(render)
		w3_np.setColorScale(0,6)
		Wheel(Point3(1.1,-1,-0.6), w3_np, 0.4, True)
		
		w4_np = loader.loadModel("Models/Rwheel")
		w4_np.reparentTo(render)
		w4_np.setColorScale(0,6)
		Wheel(Point3(1,1,-0.6), w4_np, 0.4, False)
		

		
		#The engine and steering
		def processInput(dt):
			
			#Vehicle properties
			self.steeringClamp = 35.0
			self.steeringIncrement = 70
			engineForce = 0.0
			brakeForce = 0.0
			
			
			#Get the vehicle's current speed
			self.carspeed = self.Car_sim.getCurrentSpeedKmHour()
			
			
			#Engage clutch when in gear 0
			if self.gear == 0:
				self.clutch = 1
			
			
			#Slow the steering when at higher speeds
			self.steeringIncrement = self.steeringIncrement - self.carspeed / 1.5
			
			
			#Reset the steering
			if not inputState.isSet("L") and not inputState.isSet("R"):
				
				if self.steering < 0.00:
					self.steering = self.steering + 0.6
				if self.steering > 0.00:
					self.steering = self.steering - 0.6
					
				if self.steering < 1.0 and self.steering > -1.0:
					self.steering = 0
			
			
			#Slow the car down while it's moving
			if self.clutch == 0:
				brakeForce = brakeForce + self.carspeed / 5
			else:
				brakeForce = brakeForce + self.carspeed / 15
		
			
			#Forward
			if self.start == 1:
				if inputState.isSet("F"):
					self.RPM = self.RPM + 35
					self.accelerate_sound.play()
				if self.clutch == 0:
					
					if self.gear == -1:
						if self.carspeed > self.carmaxreversespeed:	
							engineForce = -self.RPM / 3
							
					if self.gear == 1:
						if self.carspeed < self.carmaxspeed:
							engineForce = self.RPM / 1

			
			#Brake	
			if inputState.isSet("B"):
				engineForce = 0.0
				brakeForce = 12.0
				if self.gear != 0 and self.clutch == 0:
					self.RPM = self.RPM - 20
				
			#Left	
			if inputState.isSet("L"):
				if self.steering < 0.0:
					#This makes the steering reset at the correct speed when turning from right to left
					self.steering += dt * self.steeringIncrement + 0.6
					self.steering = min(self.steering, self.steeringClamp)
				else:
					#Normal steering
					self.steering += dt * self.steeringIncrement
					self.steering = min(self.steering, self.steeringClamp)
			
			#Right	
			if inputState.isSet("R"):
				if self.steering > 0.0:
					#This makes the steering reset at the correct speed when turning from left to right
					self.steering -= dt * self.steeringIncrement + 0.6
					self.steering = max(self.steering, -self.steeringClamp)
				else:
					#Normal steering
					self.steering -= dt * self.steeringIncrement
					self.steering = max(self.steering, -self.steeringClamp)
			
			#Park
			if self.Pbrake == 1:
				brakeForce = 10.0
				if self.gear != 0 and self. clutch == 0:
					self.RPM = self.RPM - 20
				
				
			#Apply forces to wheels	
			self.Car_sim.applyEngineForce(engineForce, 0);
			self.Car_sim.applyEngineForce(engineForce, 3);
			self.Car_sim.setBrake(brakeForce, 1);
			self.Car_sim.setBrake(brakeForce, 2);
			self.Car_sim.setSteeringValue(self.steering, 0);
			self.Car_sim.setSteeringValue(self.steering, 3);
			
			#Steering wheel
			Sw.setHpr(0,0,-self.steering*10)
		
		
		#The HUD
		self.gear_hud = OnscreenImage(image = "Textures/gear_hud.png", pos = (-1,0,-0.85), scale = (0.2))
		self.gear_hud.setTransparency(TransparencyAttrib.MAlpha)
		
		self.gear2_hud = OnscreenImage(image = "Textures/gear2_hud.png", pos = (-1,0,-0.85), scale = (0.2))
		self.gear2_hud.setTransparency(TransparencyAttrib.MAlpha)
		
		self.starter = OnscreenImage(image = "Textures/starter.png", pos = (-1.2,0,-0.85), scale = (0.15))
		self.starter.setTransparency(TransparencyAttrib.MAlpha)
		
		self.park = OnscreenImage(image = "Textures/pbrake.png", pos = (-0.8,0,-0.85), scale = (0.1))
		self.park.setTransparency(TransparencyAttrib.MAlpha)
		
		self.rev_counter = OnscreenImage(image = "Textures/dial.png", pos = (-1.6, 0.0, -0.70), scale = (0.6,0.6,0.4))
		self.rev_counter.setTransparency(TransparencyAttrib.MAlpha)
		
		self.rev_needle = OnscreenImage(image = "Textures/needle.png", pos = (-1.6, 0.0, -0.70), scale = (0.5))
		self.rev_needle.setTransparency(TransparencyAttrib.MAlpha)
		
		self.rev_text = OnscreenText(text = " ", pos = (-1.6, -0.90, 0), scale = 0.05)
		
		self.speedometer = OnscreenImage(image = "Textures/dial.png", pos = (-1.68, 0.0, -0.10), scale = (0.7,0.7,0.5))
		self.speedometer.setTransparency(TransparencyAttrib.MAlpha)
		
		self.speedometer_needle = OnscreenImage(image = "Textures/needle.png", pos = (-1.68, 0.0, -0.10), scale = (0.5))
		self.speedometer_needle.setTransparency(TransparencyAttrib.MAlpha)
		
		self.speedometer_text = OnscreenText(text = " ", pos = (-1.68, -0.35, 0), scale = 0.05)
		
		
		#Update the HUD
		def Update_HUD():
			
			#Move gear selector
			if self.gear == -1:
				self.gear2_hud.setPos(-1,0,-0.785)
			if self.gear == 0:
				self.gear2_hud.setPos(-1,0,-0.85)
			if self.gear == 1:
				self.gear2_hud.setPos(-1,0,-0.91)
				
			#Rotate starter
			if self.start == 0:
				self.starter.setHpr(0,0,0)
			else:
				self.starter.setHpr(0,0,45)	
				
			#Update the parking brake light
			if self.Pbrake == 1:
				self.park.setImage("Textures/pbrake2.png")
				self.park.setTransparency(TransparencyAttrib.MAlpha)
			else:
				self.park.setImage("Textures/pbrake.png")
				self.park.setTransparency(TransparencyAttrib.MAlpha)	
				
			#Update the rev counter
			self.rev_needle.setR(self.RPM/22)	
			rev_string = str(self.RPM)[:4]
			self.rev_text.setText(rev_string+" RPM")
			
			#Update the speedometer
			if self.carspeed > 0.0:
				self.speedometer_needle.setR(self.carspeed*2.5)
			if self.carspeed < 0.0:
				self.speedometer_needle.setR(-self.carspeed*2.5)
			speed_string = str(self.carspeed)[:3]
			self.speedometer_text.setText(speed_string+" KPH")
					
					
						
		#Update the program
		def update(task):
			dt = globalClock.getDt() 
			processInput(dt)
			Update_HUD()
			set_time()
			set_terrain()
			set_headlights()
			update_rpm()
			scene.doPhysics(dt, 5, 1.0/180.0)
			return task.cont
			
		taskMgr.add(update, "Update")
class Flashlight:

	POWER_MIN  = 0.06
	POWER_DRAIN_RATE = -1/240.0
	POWER_GAIN_RATE  =  1/480.0
	
	EXPONENET = 40 
	
	COLOR = Vec4(1.0, 1.0, 0.9, 1)
	
	ATT_CONST = 0
	ATT_LIN   = 0.3
	ATT_QUAD  = 0.05
	
	def __init__(self, name, owner, scene, pos, fov=60, near=0.01, far=100, resol=(1920, 1080)):
		self.owner = owner
		self.scene = scene
		
		self.last      = 0.0
		self.power     = 1.0
		self.on        = True
		self.powerrate = Flashlight.POWER_DRAIN_RATE 

		#TODO: Change lens parameters for a unique 'lens' parameter
		lens = PerspectiveLens()
		lens.setFov(fov)
		lens.setNearFar(near, far)
		lens.setFilmSize(resol[0], resol[1])

		self.light = Spotlight(name + '/wide')
		self.light.setLens(lens)
		#TODO: Shadows don't work well anymore
		#self.light.setShadowCaster(True, resol[0], resol[1])
		self.light.setColor(Flashlight.COLOR)
		self.light.setExponent(40)
		
		self.nodepath = owner.cam.attachNewNode(self.light)
		self.nodepath.setPos(pos)
		self.nodepath.setHpr((5,5,0))
		
		self.scene.setLight(self.nodepath)

	def __del__(self):
		self.nodepath.removeNode()

	def toggle(self):
		self.on = not self.on
		if self.on:
			self.scene.setLight(self.nodepath)
			self.powerrate = Flashlight.POWER_DRAIN_RATE
		else:
			self.scene.clearLight(self.nodepath)
			self.powerrate = Flashlight.POWER_GAIN_RATE

	def updatePower(self, task):
		elapsed = task.time - self.last
		
		self.last = task.time
		self.power = max(Flashlight.POWER_MIN, min(1.0, self.power + elapsed * self.powerrate))
		
		self.light.setAttenuation((Flashlight.ATT_CONST, Flashlight.ATT_LIN, Flashlight.ATT_QUAD / self.power))

		return task.cont
	
	def getNodePath(self):
		return self.nodepath
	
	def setHpr(self, vec):
		self.nodepath.setHpr(vec)

	def isOn(self):
		return self.on