示例#1
0
    def mousePressed(self, event):
        print 'got mouse pressed event from', event.sender
        if (not self.enabled
                or event.modifiers.isDown(KeyboardButton.control())):
            print 'short circuiting'
            return

        shiftDown = event.modifiers.isDown(KeyboardButton.shift())
        if event.sender == self.engine:
            if not shiftDown:
                self.deselectAll()
        else:
            self._setEditMode(event.modifiers.isDown(MouseButton.three()))
            node = event.sender
            if shiftDown:
                # Shift-clicking a node toggles its selected state.
                if node.isSelected():
                    self.selection.remove(node)
                    node.setSelected(False)
                else:
                    self.selection.append(node)
                    node.setSelected(True)
            elif len(self.selection) == 1 and node.isSelected():
                # This is already the only node selected.
                return
            else:
                print 'selecting', node
                self.deselectAll()
                node.setSelected(True)
                self.selection.append(node)
        if self.editMode:
            self.handle.setClients([NodePath(n) for n in self.selection],
                                   self.getSelectionCenter())
        else:
            self.handle.setClients([])
示例#2
0
 def poll_keyboard(self, velocity):
     # under normal circumstances, use median of joytick output
     x_speed = 0.5
     y_speed = 0.5
     # checks keyboard, not mouse, in this case
     is_down = self.base.mouseWatcherNode.is_button_down
     # Instead of usual movement, exactly counteract joystick,
     # if using joystick and currently moving
     if self.joystick:
         if abs(velocity.x) > self.threshold:
             if velocity.x > 0:
                 x_speed = velocity.x
             else:
                 x_speed = -velocity.x
         if abs(velocity.y) > self.threshold:
             if velocity.y > 0:
                 y_speed = velocity.y
             else:
                 y_speed = -velocity.y
     else:
         velocity.x = 0
         velocity.y = 0
     if is_down(KeyboardButton.up()):
         velocity.y += y_speed
     if is_down(KeyboardButton.down()):
         velocity.y -= y_speed
     if is_down(KeyboardButton.left()):
         velocity.x -= x_speed
         # print 'keyboard'
     if is_down(KeyboardButton.right()):
         velocity.x += x_speed
     return velocity
示例#3
0
    def __init__( self, node, mouseWatcherNode ):

        self.node = node
        self.focusNode = render.attachNewNode("CameraFocusNode")
        self.attachmentNode = None
        self.attached = True

        self.focusPoint = LPoint3()

        self.mouseWatcherNode = mouseWatcherNode

        self.bForward = KeyboardButton.ascii_key('w')
        self.bBackward = KeyboardButton.ascii_key('s')
        self.bLeft = KeyboardButton.ascii_key('a')
        self.bRight = KeyboardButton.ascii_key('d')
        self.bSpeed = KeyboardButton.lshift()

        self.speed = 0.2

        self.zoom = 10

        self.ang = 0
        self.angY = math.pi*0.5

        self.lastMousePos = (0,0)
示例#4
0
 def __init__(self, base):
     self.base = base
     self.is_down = base.mouseWatcherNode.is_button_down
     self.forward_button = KeyboardButton.ascii_key(b'w')
     self.backward_button = KeyboardButton.ascii_key(b's')
     self.strafe_left_button = KeyboardButton.ascii_key(b'a')
     self.strafe_right_button = KeyboardButton.ascii_key(b'd')
示例#5
0
    def mousePressed(self, event):
        print 'got mouse pressed event from', event.sender
        if (not self.enabled or
                event.modifiers.isDown(KeyboardButton.control())):
            print 'short circuiting'
            return

        shiftDown = event.modifiers.isDown(KeyboardButton.shift())
        if event.sender == self.engine:
            if not shiftDown:
                self.deselectAll()
        else: 
            self._setEditMode(event.modifiers.isDown(MouseButton.three()))
            node = event.sender
            if shiftDown:
                # Shift-clicking a node toggles its selected state.
                if node.isSelected():
                    self.selection.remove(node)
                    node.setSelected(False)
                else:
                    self.selection.append(node)
                    node.setSelected(True)
            elif len(self.selection) == 1 and node.isSelected():
                # This is already the only node selected.
                return
            else:
                print 'selecting', node
                self.deselectAll()
                node.setSelected(True)
                self.selection.append(node)
        if self.editMode:
            self.handle.setClients([NodePath(n) for n in self.selection],
                    self.getSelectionCenter())
        else:
            self.handle.setClients([])
示例#6
0
 def _saveLayout(self):
     if self.modButtons.isDown(KeyboardButton.control()):
         self.modButtons.buttonUp(KeyboardButton.control())
         self.modButtons.buttonUp(KeyboardButton.asciiKey('s'))
         filename = asksaveasfilename(filetypes=[('plist files', '*.plist')])
         if filename:
             self.layout.save(filename)
             AppPreferences.set('last_layout', filename)
示例#7
0
 def _saveLayout(self):
     if self.modButtons.isDown(KeyboardButton.control()):
         self.modButtons.buttonUp(KeyboardButton.control())
         self.modButtons.buttonUp(KeyboardButton.asciiKey('s'))
         filename = asksaveasfilename(filetypes=[('plist files',
                                                  '*.plist')])
         if filename:
             self.layout.save(filename)
             AppPreferences.set('last_layout', filename)
示例#8
0
 def read_keys(self):
     self.upArrowIsPressed = base.mouseWatcherNode.isButtonDown(
         KeyboardButton.up())
     self.downArrowIsPressed = base.mouseWatcherNode.isButtonDown(
         KeyboardButton.down())
     self.rightArrowIsPressed = base.mouseWatcherNode.isButtonDown(
         KeyboardButton.right())
     self.leftArrowIsPressed = base.mouseWatcherNode.isButtonDown(
         KeyboardButton.left())
示例#9
0
    def __init__(self):
        self.instructionText = addInstructions(0.95,
                                               '[ESC]: Leave Mouselook mode.')
        self.eventDispatcher = EventDispatcher()
        self.cameraMode = None
        self.clickPos = Vec2()
        self.lastMousePos = Vec2()
        self.focus = Vec3()
        self.mouseDown = False
        self.initialPos = Vec3()
        self.initialHpr = Vec3()
        self.initialMat = None

        # Disable the built-in mouse camera control (it sucks).
        base.disableMouse()
        self.setCameraMode(TRACKBALL)

        # Set the camera's initial position.
        base.camera.setPosHpr(0, 12, 30, 180, -70, 0)

        # Turn off events generated with modifier buttons, e.g. 'shift-a'
        # This is to keep keyboard control working after you alt-tab out
        # of the app.
        base.mouseWatcherNode.setModifierButtons(ModifierButtons())
        base.buttonThrowers[0].node().setModifierButtons(ModifierButtons())

        # This is a diagonal matrix that keeps track of movement key
        # state. The first three diagonal entries can be 1, 0, or -1.
        self.mouseLookTransMat = Mat4.scaleMat(Vec3(0.0, 0.0, 0.0))

        # Keep track of how many movement keys are currently pressed. This
        # lets us short-circuit past a lot of math when no keys are held.
        self.keysHeld = 0

        # Handle events for the movement keys.
        for key, value in key2MatArgs.items():
            self.accept(key, self._moveKeyHandler, value)

        self.accept('escape', self._escKeyHandler)
        self.accept('m', self._mKeyHandler)
        self.accept('mouse1', self._mouseDownHandler, [1])
        self.accept('mouse1-up', self._mouseUpHandler, [1])
        self.accept('mouse2', self._mouseDownHandler, [2])
        self.accept('mouse2-up', self._mouseUpHandler, [2])
        self.accept('wheel_up', self._mouseWheelHandler, [1])
        self.accept('wheel_down', self._mouseWheelHandler, [-1])

        self.modButtons = ModifierButtons()
        self.modButtons.addButton(KeyboardButton.control())
        self.accept('control', self.modButtons.buttonDown,
                    [KeyboardButton.control()])
        self.accept('control-up', self.modButtons.buttonUp,
                    [KeyboardButton.control()])

        self.accept(base.win.getWindowEvent(), self._windowHandler)
示例#10
0
    def __init__(self):
        self.instructionText = addInstructions(0.95,
                '[ESC]: Leave Mouselook mode.')
        self.eventDispatcher = EventDispatcher()
        self.cameraMode = None
        self.clickPos = Vec2()
        self.lastMousePos = Vec2()
        self.focus = Vec3()
        self.mouseDown = False
        self.initialPos = Vec3()
        self.initialHpr = Vec3()
        self.initialMat = None

        # Disable the built-in mouse camera control (it sucks).
        base.disableMouse()
        self.setCameraMode(TRACKBALL)

        # Set the camera's initial position.
        base.camera.setPosHpr(0, 12, 30, 180, -70, 0)
        
        # Turn off events generated with modifier buttons, e.g. 'shift-a'
        # This is to keep keyboard control working after you alt-tab out
        # of the app.
        base.mouseWatcherNode.setModifierButtons(ModifierButtons())
        base.buttonThrowers[0].node().setModifierButtons(ModifierButtons())

        # This is a diagonal matrix that keeps track of movement key
        # state. The first three diagonal entries can be 1, 0, or -1.
        self.mouseLookTransMat = Mat4.scaleMat(Vec3(0.0, 0.0, 0.0))
        
        # Keep track of how many movement keys are currently pressed. This
        # lets us short-circuit past a lot of math when no keys are held.
        self.keysHeld = 0

        # Handle events for the movement keys.       
        for key, value in key2MatArgs.items():
            self.accept(key, self._moveKeyHandler, value)

        self.accept('escape', self._escKeyHandler)
        self.accept('m', self._mKeyHandler)
        self.accept('mouse1', self._mouseDownHandler, [1])
        self.accept('mouse1-up', self._mouseUpHandler, [1])
        self.accept('mouse2', self._mouseDownHandler, [2])
        self.accept('mouse2-up', self._mouseUpHandler, [2])
        self.accept('wheel_up', self._mouseWheelHandler, [1])
        self.accept('wheel_down', self._mouseWheelHandler, [-1])

        self.modButtons = ModifierButtons()
        self.modButtons.addButton(KeyboardButton.control())
        self.accept('control', self.modButtons.buttonDown,
                [KeyboardButton.control()])
        self.accept('control-up', self.modButtons.buttonUp,
                [KeyboardButton.control()])

        self.accept(base.win.getWindowEvent(), self._windowHandler)
示例#11
0
 def _openLayout(self):
     if self.modButtons.isDown(KeyboardButton.control()):
         self.modButtons.buttonUp(KeyboardButton.control())
         self.modButtons.buttonUp(KeyboardButton.asciiKey('o'))
         filename = askopenfilename(filetypes=[('plist files', '*.plist')])
         if filename:
             if self.layout:
                 NodePath(self.layout).detachNode()
             self.layout = MissionLayout.loadLayout(filename)
             render.attachNewNode(self.layout)
             AppPreferences.set('last_layout', filename)
示例#12
0
 def _openLayout(self):
     if self.modButtons.isDown(KeyboardButton.control()):
         self.modButtons.buttonUp(KeyboardButton.control())
         self.modButtons.buttonUp(KeyboardButton.asciiKey('o'))
         filename = askopenfilename(filetypes=[('plist files', '*.plist')])
         if filename:
             if self.layout:
                 NodePath(self.layout).detachNode()
             self.layout = MissionLayout.loadLayout(filename)
             render.attachNewNode(self.layout)
             AppPreferences.set('last_layout', filename)
def rotate_tree(task):
    global tree_root

    rot_speed = 360 / 3
    dt = globalClock.dt
    turn = 0
    if base.mouseWatcherNode.is_button_down(KeyboardButton.ascii_key('a')):
        turn += rot_speed * dt
    if base.mouseWatcherNode.is_button_down(KeyboardButton.ascii_key('d')):
        turn -= rot_speed * dt
    tree_root.set_h(tree_root, turn)
    return task.cont
示例#14
0
    def __init__(self):
        render.setAntialias(AntialiasAttrib.MAuto)

        # Enable physics - perhaps this should go someplace else, but it must
        # be done before the Vehicle is initialized.
        base.enableParticles()
        aei = AngularEulerIntegrator()
        base.physicsMgr.attachAngularIntegrator(aei)

        SelectionEngine.getDefault().enable()
        SelectionManager.getDefault().enable()
        
        # Make the environment and the vehicle model.
        makeEnvironment()
        self.vehicle = Vehicle(render)

        MissionElement.loadElementConfig('mission_elements.plist')

        #layoutName = AppPreferences.get('last_layout', 'defaultLayout.plist')
        if len(sys.argv) == 2:
            layoutName = sys.argv[1]
            print "Using command line argument %s for layout" %layoutName
        else:
            print "Using default layout file"
            print "Use ./sim2.py [layout file] to use a different layout"
            print "Or press Ctrl+O to open a new layout in the simulator"
            layoutName = 'defaultLayout.plist'

        self.layout = MissionLayout.loadLayout(layoutName)
        render.attachNewNode(self.layout)

        self.vehicle.setLayout(self.layout) #Link the layout 

        # Set up render buffer viewer, to aide debugging.
        self.accept("v", base.bufferViewer.toggleEnable)
        self.accept("V", base.bufferViewer.toggleEnable)
        base.bufferViewer.setPosition("llcorner")
        
        # Set up file saver
        self.accept('s', self._saveLayout)
        self.accept('o', self._openLayout)
        self.accept('f', self._setFreq)
        root = Tk()
        root.withdraw()
        self.modButtons = ModifierButtons()
        self.modButtons.addButton(KeyboardButton.control())
        self.accept('control', self.modButtons.buttonDown,
                [KeyboardButton.control()])
        self.accept('control-up', self.modButtons.buttonUp,
                [KeyboardButton.control()])
        # Add GUI Controls
        '''
示例#15
0
    def __init__(self):
        render.setAntialias(AntialiasAttrib.MAuto)

        # Enable physics - perhaps this should go someplace else, but it must
        # be done before the Vehicle is initialized.
        base.enableParticles()
        aei = AngularEulerIntegrator()
        base.physicsMgr.attachAngularIntegrator(aei)

        SelectionEngine.getDefault().enable()
        SelectionManager.getDefault().enable()

        # Make the environment and the vehicle model.
        makeEnvironment()
        self.vehicle = Vehicle(render)

        MissionElement.loadElementConfig('mission_elements.plist')

        #layoutName = AppPreferences.get('last_layout', 'defaultLayout.plist')
        if len(sys.argv) == 2:
            layoutName = sys.argv[1]
            print "Using command line argument %s for layout" % layoutName
        else:
            print "Using default layout file"
            print "Use ./sim2.py [layout file] to use a different layout"
            print "Or press Ctrl+O to open a new layout in the simulator"
            layoutName = 'defaultLayout.plist'

        self.layout = MissionLayout.loadLayout(layoutName)
        render.attachNewNode(self.layout)

        self.vehicle.setLayout(self.layout)  #Link the layout

        # Set up render buffer viewer, to aide debugging.
        self.accept("v", base.bufferViewer.toggleEnable)
        self.accept("V", base.bufferViewer.toggleEnable)
        base.bufferViewer.setPosition("llcorner")

        # Set up file saver
        self.accept('s', self._saveLayout)
        self.accept('o', self._openLayout)
        self.accept('f', self._setFreq)
        root = Tk()
        root.withdraw()
        self.modButtons = ModifierButtons()
        self.modButtons.addButton(KeyboardButton.control())
        self.accept('control', self.modButtons.buttonDown,
                    [KeyboardButton.control()])
        self.accept('control-up', self.modButtons.buttonUp,
                    [KeyboardButton.control()])
        # Add GUI Controls
        '''
示例#16
0
 def poll_keyboard(self):
     x_speed = 0.5
     y_speed = 0.5
     velocity = LVector3(0)
     # poorly named, checks keyboard, not mouse, in this case
     is_down = base.mouseWatcherNode.is_button_down
     if is_down(KeyboardButton.up()):
         velocity.y += y_speed
     if is_down(KeyboardButton.down()):
         velocity.y -= y_speed
     if is_down(KeyboardButton.left()):
         velocity.x -= x_speed
     if is_down(KeyboardButton.right()):
         velocity.x += x_speed
     return velocity
示例#17
0
 def poll_keyboard(self):
     x_speed = 0.5
     y_speed = 0.5
     velocity = LVector3(0)
     # poorly named, checks keyboard, not mouse, in this case
     is_down = base.mouseWatcherNode.is_button_down
     if is_down(KeyboardButton.up()):
         velocity.y += y_speed
     if is_down(KeyboardButton.down()):
         velocity.y -= y_speed
     if is_down(KeyboardButton.left()):
         velocity.x -= x_speed
     if is_down(KeyboardButton.right()):
         velocity.x += x_speed
     return velocity
    def camera_move(self, task):
        """
        Moves the camera about the quadcopter
        """

        keys_vs_moves = {'k': i,
                         'h': -i,
                         'i': j,
                         'y': -j,
                         'u': k,
                         'j': -k
                         }

        mat = np.array(self.cam.getMat())[0:3, 0:3]
        move_total = LPoint3f(0, 0, 0)

        for key, move in keys_vs_moves.items():
            pressed_key = self.mouseWatcherNode.is_button_down(KeyboardButton.asciiKey(key))
            if pressed_key:
                move = LPoint3f(move)
                move_total += move

        # if any([abs(coordinate) > 0 for coordinate in move_total]):
        # ROTATE COORDINATE SYSTEM (TO CAMERA)
        move_total = LPoint3f(*tuple(np.dot(mat.T, np.array(move_total))))
        proportionality_constant = 0.05
        cam_pos = self.cam.getPos() + move_total * proportionality_constant
        self.cam.setPos(cam_pos)
        self.cam.lookAt(self.quad_model)

        return task.cont
示例#19
0
文件: ball.py 项目: janEntikan/wecs
 def update(self, entities_by_filter):
     start_balls = base.mouseWatcherNode.is_button_down(
         KeyboardButton.space(), )
     if start_balls:
         for entity in set(entities_by_filter['ball']):
             entity.remove_component(Resting)
             entity.add_component(Movement(value=Vec3(-1, 0, 0)))
示例#20
0
    def keystroke(self, key):
        key = str(KeyboardButton.asciiKey(key))

        if key == None:
            return
        if key == 'space':
            key = ' '
        if len(key) != 1:
            return

        if not application.paused:
            if hasattr(__main__, 'keystroke'):
                __main__.keystroke(key)

        for entity in scene.entities:
            if entity.enabled == False or entity.ignore or entity.ignore_input:
                continue
            if application.paused and entity.ignore_paused == False:
                continue

            if hasattr(entity, 'keystroke') and callable(entity.keystroke):
                entity.keystroke(key)

            if hasattr(entity, 'scripts'):
                for script in entity.scripts:
                    if script.enabled and hasattr(script,
                                                  'keystroke') and callable(
                                                      script.keystroke):
                        script.keystroke(key)
示例#21
0
class StartBallMotion(System):
    """
    StartBallMotion ensures that the game restarts after the start key is pressed.
    """
    entity_filters = {
        'ball': and_filter([
            Proxy('model'),
            Resting,
            Ball,
        ]),
    }
    start_key = KeyboardButton.space()

    def update(self, entities_by_filter):
        """
        Check whether the resting ball should be started?
        Note that restarting the ball's movement means removing the Entity's
        Resting Component, and adding it's Movement component with the desired
        direction.
        """

        start_key_is_pressed = base.mouseWatcherNode.is_button_down(
            StartBallMotion.start_key)

        if start_key_is_pressed:
            for entity in set(entities_by_filter['ball']):
                del entity[Resting]
                entity[Movement] = Movement(
                    direction=Vec3(-0.1 * randrange(5, 10), 0, 0))
示例#22
0
 def acceptMovement(self):
     # accept movement
     (x, y, z) = self.camera.getPos()
     (dx, dy, dz) = self.cameraSpeed
     (newX, newY, newZ) = (x + dx, y + dy, z + dz)
     forward_button = KeyboardButton.ascii_key('w')
     backward_button = KeyboardButton.ascii_key('s')
     leftward_button = KeyboardButton.ascii_key('a')
     rightward_button = KeyboardButton.ascii_key('d')
     # next line is from panda3D website
     is_down = self.mouseWatcherNode.is_button_down
     if is_down(forward_button): self.accForward()
     elif is_down(backward_button): self.accBackward()
     elif is_down(leftward_button): self.accLeftward()
     elif is_down(rightward_button): self.accRightward()
     else: self.cameraSpeed = (0, 0, dz)
示例#23
0
 def __init__(self):
     self.panra = 1
     self.pwa = KeyboardButton.ascii_key("w")
     self.sano = Actor("HailPar.egg", {"Anaib": "Sbig-Armsjin"})
     self.thago = threading.Thread(target=self.run)
     self.thago.start()
     self.sano.reparentTo(render)
示例#24
0
    def onMouseMoveTransforming3D(self, vp):
        now = self.getPointOnGizmo()

        gizmoOrigin = self.getGizmoOrigin()
        gizmoDir = self.getGizmoDirection(self.widget.activeAxis.axisIdx)
        ref = Vec3.forward()
        if gizmoDir == ref:
            ref = Vec3.right()

        nowVec = Vec3(now - gizmoOrigin).normalized()
        origVec = Vec3(self.transformStart - gizmoOrigin).normalized()

        axisToHprAxis = {
            0: 1,  # pitch
            1: 2,  # roll
            2: 0  # yaw
        }

        snap = not vp.mouseWatcher.isButtonDown(KeyboardButton.shift())

        origAngle = origVec.signedAngleDeg(
            ref, self.getGizmoDirection(self.widget.activeAxis.axisIdx))
        angle = nowVec.signedAngleDeg(
            ref, self.getGizmoDirection(self.widget.activeAxis.axisIdx))
        hpr = Vec3(0)
        if snap:
            ang = round(-(angle - origAngle) / 15) * 15
        else:
            ang = -(angle - origAngle)
        hpr[axisToHprAxis[self.widget.activeAxis.axisIdx]] = ang
        self.toolVisRoot.setHpr(hpr)
示例#25
0
    def update_thruster(self, task):
        heating = 0.33
        cooling = 0.04
        thruster_ramp_time = 0.4
        thrusting = base.mouseWatcherNode.is_button_down(
            KeyboardButton.ascii_key(b's'), )
        overheated = self.thruster_heat > 1.0
        if overheated and not self.overheated:
            self.thruster_overheat_sound.play()
        self.overheated = overheated

        if thrusting and not overheated:
            self.thruster_power += (1 / thruster_ramp_time) * globalClock.dt
        else:
            self.thruster_power -= (1 / thruster_ramp_time) * globalClock.dt
        if self.thruster_power < 0.0:
            self.thruster_power = 0.0
        if self.thruster_power > 1.0:
            self.thruster_power = 1.0
        power = self.thruster_power
        self.thruster_heat += (-cooling *
                               (1 - power) + heating * power) * globalClock.dt
        if self.thruster_heat < 0.0:
            self.thruster_heat = 0.0
        self.thruster_sound.set_volume(self.thruster_power * 2)
        self.thruster_sound.set_play_rate(0.1 + ((random() / 50) +
                                                 (self.thruster_power / 120)))
        self.thruster_heat_bar['value'] = self.thruster_heat * 100
        self.thruster_heat_bar['text'] = "{:3.0f}%".format(
            self.thruster_power * 100, )
        if self.thruster_heat > 1.0:
            self.thruster_heat_bar['barColor'] = (1, 1, 1, 1)
        else:
            self.thruster_heat_bar['barColor'] = (1, 0, 0, 1)
        return task.cont
示例#26
0
    def _dragStart(self, nodeFrame, event):
        # Mark this node as selected
        base.messenger.send("selectNode", [
            self, True,
            base.mouseWatcherNode.isButtonDown(KeyboardButton.shift()), True
        ])
        # tell everyone we started to drag this node
        base.messenger.send("dragNodeStart", [self])

        # Remove any previous started drag tasks
        taskMgr.remove("dragNodeDropTask")

        # get some positions
        vWidget2render2d = nodeFrame.getPos(render2d)
        vMouse2render2d = Point3(0)
        if event is not None:
            # we get the mouse position from the event
            vMouse2render2d = Point3(event.getMouse()[0], 0,
                                     event.getMouse()[1])
        else:
            # we try to get the current mouse position from the mouse watcher
            mwn = base.mouseWatcherNode
            if mwn.hasMouse():
                vMouse2render2d = Point3(mwn.getMouse()[0], 0,
                                         mwn.getMouse()[1])
        editVec = Vec3(vWidget2render2d - vMouse2render2d)
        self.hasMoved = False

        # Initiate the task to move the node and pass it some initial values
        t = taskMgr.add(self.dragTask, "dragNodeDropTask")
        t.nodeFrame = nodeFrame
        t.editVec = editVec
        t.mouseVec = vMouse2render2d
示例#27
0
 def acceptMovement(self):
     # accept movement
     (x, y, z) = self.camera.getPos()
     (dx, dy, dz) = self.cameraSpeed
     (newX, newY, newZ) = (x+dx, y+dy, z+dz)
     forward_button = KeyboardButton.ascii_key('w')
     backward_button = KeyboardButton.ascii_key('s')
     leftward_button = KeyboardButton.ascii_key('a')
     rightward_button = KeyboardButton.ascii_key('d')
     # next line is from panda3D website
     is_down = self.mouseWatcherNode.is_button_down
     if is_down(forward_button): self.accForward()
     elif is_down(backward_button): self.accBackward()
     elif is_down(leftward_button): self.accLeftward()
     elif is_down(rightward_button): self.accRightward()
     else: self.cameraSpeed = (0, 0, dz)
示例#28
0
    def __init__(self):
        #Modify the Panda3D config on-the-fly
        #In this case, edit the window title
        load_prc_file_data(
            "", """window-title PoultryGeist
								  threading-model /Draw
								  multisamples 2
								  framebuffer-multisample 1
							   """)

        # Construct and create the pipeline
        self.render_pipeline = RenderPipeline()
        self.render_pipeline.create(self)

        self.width, self.height = (800, 600)
        render.setAntialias(AntialiasAttrib.MAuto)

        # Set the model quality, (low or high)
        self.quality = "low"
        print("[>] PoultryGeist:\t      Setting Model Resolution to {}".format(
            self.quality.upper()))

        # Set the time
        self.render_pipeline.daytime_mgr.time = "20:15"

        # Turn off normal mouse controls
        self.disableMouse()

        # Hide the cursor
        props = WindowProperties()
        props.setCursorHidden(True)
        props.setMouseMode(WindowProperties.M_relative)
        # Lower the FOV to make the game more difficult
        self.win.requestProperties(props)
        self.camLens.setFov(90)

        # Register the buttons for movement
        self.w_button = KeyboardButton.ascii_key('w'.encode())
        self.s_button = KeyboardButton.ascii_key('s'.encode())

        self.switch_button = KeyboardButton.ascii_key('p'.encode())

        # Initialise the SceneManager
        self.sceneMgr = SceneManager(self)

        # Add the sceneMgr events to run as a task
        taskMgr.add(self.sceneMgr.runSceneTasks, "scene-tasks")
示例#29
0
 def _mouseDownHandler(self, button):
     if base.mouseWatcherNode.hasMouse():
         if button == 2 or self.modButtons.isDown(KeyboardButton.control()):
             self.clickPos = Vec2(base.mouseWatcherNode.getMouse())
             self.mouseDown = True
             offset = self.focus - base.camera.getPos()
             self.initialTranslation = offset.length()
             self.initialHpr = base.camera.getHpr()
示例#30
0
    def __init__(self, base):
        self.base = base
        self.forward = KeyboardButton.ascii_key('w')
        self.backward = KeyboardButton.ascii_key('s')
        self.left = KeyboardButton.ascii_key('a')
        self.right = KeyboardButton.ascii_key('d')

        self.node = self.base.loader.loadModel(self.model_path)
        self.node.reparentTo(self.base.render)

        # set initial position
        # x, y, z
        self.set_pos(0, 15, -1)
        self.set_rot(20, 10, 0)

        # create a task to check for movement
        self.add_task(self.check_movement, 'detect_player_movement')
示例#31
0
 def _mouseDownHandler(self, button):
     if base.mouseWatcherNode.hasMouse():
         if button == 2 or self.modButtons.isDown(KeyboardButton.control()):
             self.clickPos = Vec2(base.mouseWatcherNode.getMouse())
             self.mouseDown = True
             offset = self.focus - base.camera.getPos()
             self.initialTranslation = offset.length()
             self.initialHpr = base.camera.getHpr()
示例#32
0
    def __init__(self, game, character):
        self.game = game
        self.character = character

        # class properties
        self.buttons = {
            "forward": KeyboardButton.ascii_key("w"),
            "backward": KeyboardButton.ascii_key("s"),
            "left": KeyboardButton.ascii_key("a"),
            "right": KeyboardButton.ascii_key("d"),
            "sprint": KeyboardButton.shift(),
        }
        self.moved = False

        # start movement task
        taskMgr.add(self.move, "Player.move")
        taskMgr.doMethodLater(1.0 / Constants.TICKRATE, self.sendLoc, "Player.sendLoc")
示例#33
0
    def __init__(self, base):
        self.base = base
        self.forward = KeyboardButton.ascii_key('w')
        self.backward = KeyboardButton.ascii_key('s')
        self.left = KeyboardButton.ascii_key('a')
        self.right = KeyboardButton.ascii_key('d')

        self.node = self.base.loader.loadModel(self.model_path)
        self.node.reparentTo(self.base.render)

        # set initial position
        # x, y, z
        self.set_pos(0, 15, -1)
        self.set_rot(20, 10, 0)

        # create a task to check for movement
        self.add_task(self.check_movement, 'detect_player_movement')
示例#34
0
def update(task):
    if s.mouseWatcherNode.is_button_down(KeyboardButton.up()):
        pingPong("accelerate", -1)
    elif s.mouseWatcherNode.is_button_down(KeyboardButton.down()):
        pingPong("accelerate", 1)
    else:
        pingPong("accelerate", 0)

    if s.mouseWatcherNode.is_button_down(KeyboardButton.right()):
        pingPong("turn", -1)
    elif s.mouseWatcherNode.is_button_down(KeyboardButton.left()):
        pingPong("turn", 1)
    else:
        pingPong("turn", 0)

    if s.mouseWatcherNode.is_button_down(KeyboardButton.ascii_key(b'd')):
        pingPong("strafe", -1)
    elif s.mouseWatcherNode.is_button_down(KeyboardButton.ascii_key(b'a')):
        pingPong("strafe", 1)
    else:
        pingPong("strafe", 0)

    if s.mouseWatcherNode.is_button_down(KeyboardButton.ascii_key(b's')):
        pingPong("hover", 1, 0, 0, 20)
    else:
        pingPong("hover", 0, 0, 0, 20)

    return task.cont
示例#35
0
文件: ball.py 项目: Schwarzbaer/wecs
    def update(self, entities_by_filter):
        # Should resting balls be started?
        start_key = KeyboardButton.space()
        start_balls = base.mouseWatcherNode.is_button_down(start_key)

        if start_balls:
            for entity in set(entities_by_filter['ball']):
                del entity[Resting]
                entity[Movement] = Movement(value=Vec3(-1, 0, 0))
示例#36
0
 def poll_keyboard(self):
     # under normal circumstances, use median of joytick output
     x_speed = 0.5
     y_speed = 0.5
     # checks keyboard, not mouse, in this case
     is_down = self.base.mouseWatcherNode.is_button_down
     if not self.joystick:
         self.velocity.x = 0
         self.velocity.y = 0
     if is_down(KeyboardButton.up()):
         self.velocity.y += y_speed
     if is_down(KeyboardButton.down()):
         self.velocity.y -= y_speed
     if is_down(KeyboardButton.left()):
         self.velocity.x -= x_speed
         # print 'keyboard'
     if is_down(KeyboardButton.right()):
         self.velocity.x += x_speed
示例#37
0
 def poll_keyboard(self):
     # under normal circumstances, use median of joytick output
     x_speed = 0.5
     y_speed = 0.5
     # checks keyboard, not mouse, in this case
     is_down = self.base.mouseWatcherNode.is_button_down
     if not self.joystick:
         self.velocity.x = 0
         self.velocity.y = 0
     if is_down(KeyboardButton.up()):
         self.velocity.y += y_speed
     if is_down(KeyboardButton.down()):
         self.velocity.y -= y_speed
     if is_down(KeyboardButton.left()):
         self.velocity.x -= x_speed
         # print 'keyboard'
     if is_down(KeyboardButton.right()):
         self.velocity.x += x_speed
示例#38
0
 def __init__(self, charNr):
     FSM.__init__(self, "FSM-Player%d"%charNr)
     charPath = "characters/character%d/" % charNr
     self.character = Actor(
         charPath + "char"#, {
             #"Idle":charPath + "idle",
             #"walk":charPath + "walk",
             #"punch_l":charPath + "punch_l",
             #"punch_r":charPath + "punch_r",
             #"kick_l":charPath + "kick_l",
             #"kick_r":charPath + "kick_r",
             #"defend":charPath + "defend"
         #}
     )
     self.character.reparentTo(render)
     self.character.hide()
     self.walkSpeed = 5.0 # units per second
     self.leftButton = KeyboardButton.asciiKey('a')
     self.rightButton = KeyboardButton.asciiKey('d')
示例#39
0
    def update(self, entities_by_filter):
        left = 0
        if base.mouseWatcherNode.is_button_down(
                KeyboardButton.ascii_key(b'w')):
            left += 1
        if base.mouseWatcherNode.is_button_down(
                KeyboardButton.ascii_key(b's')):
            left -= 1

        right = 0
        if base.mouseWatcherNode.is_button_down(KeyboardButton.up()):
            right += 1
        if base.mouseWatcherNode.is_button_down(KeyboardButton.down()):
            right -= 1

        for entity in entities_by_filter['paddle']:
            if entity.get_component(Paddle).player == 0:
                entity.get_component(Movement).value.z = left
            elif entity.get_component(Paddle).player == 1:
                entity.get_component(Movement).value.z = right
示例#40
0
def update(task):
    global thrust
    if thrust > 0:
        thrust -= 1
    if s.mouseWatcherNode.is_button_down(KeyboardButton.space()):
        if thrust < 15:
            thrust += 2

    for beam in beams:
        beam.setScale(thrust / 8)

    return task.cont
示例#41
0
 def select(self, event):
     modifiers = event.getModifierButtons()
     if modifiers.isDown(KeyboardButton.shift()):
         incr = -1
     else:
         incr = 1
     new_selection = self.current_selection + incr
     if new_selection < 0:
         new_selection = len(self.current_list) - 1
     if new_selection >= len(self.current_list):
         new_selection = 0
     self.current_selection = new_selection
     self.update_suggestions()
示例#42
0
 def move_camera(self, task):
     rot = globalClock.get_dt() * 360.0 / 3.0
     up_down = 0
     left_right = 0
     if base.mouseWatcherNode.is_button_down(KeyboardButton.up()):
         up_down -= 1
     if base.mouseWatcherNode.is_button_down(KeyboardButton.down()):
         up_down += 1
     if base.mouseWatcherNode.is_button_down(KeyboardButton.left()):
         left_right -=1
     if base.mouseWatcherNode.is_button_down(KeyboardButton.right()):
         left_right +=1
     if self.rotation_mode and base.mouseWatcherNode.has_mouse():
         mouse_pos = base.mouseWatcherNode.get_mouse()
         mouse_delta = mouse_pos - self.mouse_pos
         self.mouse_pos = Point2(mouse_pos)
         up_down += mouse_delta.get_y() * 50
         left_right += mouse_delta.get_x() * -50
     self.camera_orbit.set_h(self.camera_orbit, left_right * rot)
     new_pitch = self.camera_pitch.get_p() + up_down * rot
     self.camera_pitch.set_p(min(max(new_pitch, -89), 89))
     return Task.cont
示例#43
0
    def update(self, entities_by_filter):
        for entity in entities_by_filter['paddle']:
            paddle = entity[Paddle]
            movement = entity[Movement]

            # What keys does the player use?
            if paddle.player == Players.LEFT:
                up_key = KeyboardButton.ascii_key(b'w')
                down_key = KeyboardButton.ascii_key(b's')
            elif paddle.player == Players.RIGHT:
                up_key = KeyboardButton.up()
                down_key = KeyboardButton.down()

            # Read player input
            delta = 0
            if base.mouseWatcherNode.is_button_down(up_key):
                delta += 1
            if base.mouseWatcherNode.is_button_down(down_key):
                delta -= 1

            # Store movement
            movement.value.z = delta
示例#44
0
    def __init__(self):
        #
        # MODEL AND ANIMATION
        #
        # The players model file path
        self.basePath = "character/"
        self.model = self.basePath + "character"
        # Paths of the animation files
        self.anim_idle = self.basePath + "character-Idle"
        self.anim_walk = self.basePath + "character-Walk"
        self.anim_plant = self.basePath + "character-Plant"
        # NOTE: This should always be enabled to smoth the transition within
        #       animations. For example for the accleration of the character
        #       untill it reaches full pace.
        self.enable_interpolation = True

        #
        # AUDIO
        #
        self.sfxPath = "sfx/"
        self.walk_sound = loader.loadSfx(self.sfxPath + "step.ogg")
        self.walk_sound.setLoop(True)


        #
        # CONTROLS
        #
        self.key_forward = KeyboardButton.asciiKey('w')
        self.key_backward = KeyboardButton.asciiKey('s')
        self.key_left = KeyboardButton.asciiKey('a')
        self.key_right = KeyboardButton.asciiKey('d')
        self.key_plant = KeyboardButton.space()
        self.key_center_camera = KeyboardButton.home()
        # accleration for the various states
        self.accleration = 3.5
        # the speed of how fast the player deacclerates
        self.deaccleration = 16.0
        # maximum acclerations at the various states
        self.max_accleration = 8.0
        # the speed for how fast the player is generally moving
        self.speed = 0.7

        #
        # GAME SPECIFIC
        #
        # planting possibility
        self.planting_enabled = False
        self.carry_seed = False

        #
        # CAMERA CONTROL VARIABLES
        #
        # Camera basics
        self.cam_near_clip = 0.5
        self.cam_far_clip = 5000
        self.cam_fov = 70
        # Mouse camera movement
        # enables the camera control via the mouse
        self.enable_mouse = True
        # invert vertical camera movements
        self.mouse_invert_vertical = False
        # screen sizes
        self.win_width_half = base.win.getXSize() / 2
        self.win_height_half = base.win.getYSize() / 2
        # mouse speed
        self.mouse_speed_x = 150.0
        self.mouse_speed_y = 80.0
        # the next two vars will set the min and max distance the cam can have
        # to the node it is attached to
        self.max_cam_distance = 5.0
        self.min_cam_distance = 2.0
        # the initial cam distance
        self.cam_distance = (self.max_cam_distance - self.min_cam_distance) / 2.0 + self.min_cam_distance
        # the maximum distance on the Z-Axis to the player
        self.max_cam_height_distance = 2.0
        # the minimum distance on the Z-Axis to the player
        self.min_cam_height_distance = 0.15
        # the average camera height
        self.cam_height_avg = (self.max_cam_height_distance - self.min_cam_height_distance) / 2.0 + self.min_cam_height_distance
        # the initial cam height
        self.cam_height = self.cam_height_avg
        # the speed of the cameras justification movement towards
        # the average height
        self.cam_z_justification_speed = 1
        # a floater which hovers over the player and is used as a
        # look at position for the camera
        self.cam_floater_pos = Point3F(0, 0, 1.5)

        #
        # PHYSICS
        #
        # show collision solids
        self.show_collisions = False
        # The physical physic_world which will be responsible for collision checks and
        # physic updates
        self.physic_world = None
        # the name of the collision solids that surround the character
        self.char_collision_name = "CharacterCollisions"
        # the mass of the character
        self.player_mass = 25
        # the heights of the various player states
        # normal height
        self.player_height = 1.186
        # the radius of the players collision shape
        self.player_radius = self.player_height / 4.0
        # step height
        self.stepheight = 0.7
示例#45
0
    def __init__(self, mainWin=base.win, mainCam=base.cam, scene=render):
        self.lastMousePos = Vec2(-2, -2)
        self.lastId = 0
        self.pressedNode = None
        self.mDownId = 0
        self.idStack = range(1, 256)
        self.idTable = {}
        self.aspectRatio = 1
        self.checkCursorTask = Task(self.checkCursor, 'checkCursorTask')
        self.enabled = True
        self.mouseListeners = []

        self.mainCam = mainCam
        mainCam.node().setCameraMask(BitMask32(1))

        tempnode = NodePath(PandaNode('temp node'))
        tempnode.setShaderAuto()
        tempnode.setShaderInput('hi_id', Vec4(0, 0, 0, 0), 2)
        mainCam.node().setInitialState(tempnode.getState())
        
        # Set up a node with the silhouetteGen shader. We'll apply this node's
        # state to custom cameras below.
        tempnode.setShader(loader.loadShader('silhouetteGen.sha'), 100)
        tempnode.setShaderInput('hi_id', Vec4(0, 0, 0, 0), 0)
        tempnode.setAntialias(AntialiasAttrib.MNone, 100)
        tempnode.setBin('inactive', 0, 1)
        initialState = tempnode.getState()
        tempnode.setBin('opaque', 0, 1)
        selnodeState = tempnode.getState()

        # We'll be using this a few times, so make an easy name for it.
        mainLens = mainCam.node().getLens()

        # Set up a buffer to which we draw a silhouette of any geometry that
        # we want to outline. We draw the outline by applying a Sobel edge
        # detection shader to the contents of this buffer.
        silhouetteBuffer = mainWin.makeTextureBuffer('silhouetteBuffer', 0, 0)
        silhouetteBuffer.setClearColor(Vec4(0, 0, 0, 1))
        self.silhouetteBuffer = silhouetteBuffer
        silhouetteCamera = base.makeCamera(silhouetteBuffer, lens=mainLens)
        silhouetteCamera.node().setScene(scene)
        silhouetteCamera.node().setInitialState(initialState)
        silhouetteCamera.node().setTagState('sel', selnodeState)
        silhouetteCamera.node().setTagStateKey('sel')
        silhouetteCamera.node().setCameraMask(BitMask32(8))

        tempnode.setShader(loader.loadShader('mousePicker.sha'), 100)
        selnodeState = tempnode.getState()
        tempnode.setBin('inactive', 0, 1)
        initialState = tempnode.getState()

        # Set up a 1-by-1 buffer to which we'll just render the pixel under
        # the mouse.
        selectBuffer = mainWin.makeTextureBuffer('selectBuffer', 1, 1)
        selectBuffer.setClearColor(Vec4(0, 0, 0, 1))
        self.selectBuffer = selectBuffer
        selectLens = PerspectiveLens()
        selectLens.setNearFar(mainLens.getNear(), mainLens.getFar())
        selectLens.setFocalLength(mainLens.getFocalLength())
        selectCamera = base.makeCamera(selectBuffer, lens=selectLens)
        selectCamera.node().setScene(scene)
        selectCamera.node().setInitialState(initialState)
        selectCamera.node().setTagState('sel', selnodeState)
        selectCamera.node().setTagStateKey('sel')
        selectCamera.node().setCameraMask(BitMask32(16))
        self.selectLens = selectLens

        self.selectTex = selectBuffer.getTexture()
        self.selectTex.makeRamImage()
        self.gsg = mainWin.getGsg()

        # Set up a texture card to render the silhouette texture with the
        # Sobel shader, which will draw the edges of the silhouettes.
        silhouetteCard = silhouetteBuffer.getTextureCard()
        silhouetteCard.setTransparency(1)
        inkGen = loader.loadShader('sobel.sha')
        silhouetteCard.setShader(inkGen)
        silhouetteCard.setShaderInput('separation', 0.001, 0)
        silhouetteCard.reparentTo(render2d)
        self.silhouetteCard = silhouetteCard
        
        self.accept(mainWin.getWindowEvent(), self.windowEventHandler)
        self.accept('mouse1', self.mouseDownHandler, ['l'])
        self.accept('mouse1-up', self.mouseUpHandler, ['l'])
        self.accept('mouse3', self.mouseDownHandler, ['r'])
        self.accept('mouse3-up', self.mouseUpHandler, ['r'])
        self.buttonWatcher = ButtonWatcher([
                KeyboardButton.shift(),
                KeyboardButton.control(),
                MouseButton.one(),
                MouseButton.three(),
            ])
        
        CameraController.getInstance().addEventHandler(EVT_CAMERA_MODE,
                self._cameraModeHandler)
        
        self.enable(False)
示例#46
0
    def __init__(self, charId, charNr, controls):
        FSM.__init__(self, "FSM-Player{}".format(charNr))
        self.charId = charId
        charPath = "characters/character{}/".format(charNr)
        self.character = Actor(
            charPath + "char",
            {
                "Idle": charPath + "idle",
                "Walk": charPath + "walk",
                "Walk_back": charPath + "walk_back",
                "Punch_l": charPath + "punch_l",
                "Punch_r": charPath + "punch_r",
                "Kick_l": charPath + "kick_l",
                "Kick_r": charPath + "kick_r",
                "Defend": charPath + "defend",
                "Hit": charPath + "hit",
                "Defeated": charPath + "defeated",
            },
        )
        self.character.reparentTo(render)
        self.character.hide()
        self.walkSpeed = 2.0  # units per second
        if controls == "p1":
            self.character.setH(90)
            self.leftButton = KeyboardButton.asciiKey("d")
            self.rightButton = KeyboardButton.asciiKey("f")
            self.punchLButton = KeyboardButton.asciiKey("q")
            self.punchRButton = KeyboardButton.asciiKey("w")
            self.kickLButton = KeyboardButton.asciiKey("a")
            self.kickRButton = KeyboardButton.asciiKey("s")
            self.defendButton = KeyboardButton.asciiKey("e")
        elif controls == "p2":
            self.character.setH(-90)
            self.leftButton = KeyboardButton.right()
            self.rightButton = KeyboardButton.left()
            self.punchLButton = KeyboardButton.asciiKey("i")
            self.punchRButton = KeyboardButton.asciiKey("o")
            self.kickLButton = KeyboardButton.asciiKey("k")
            self.kickRButton = KeyboardButton.asciiKey("l")
            self.defendButton = KeyboardButton.asciiKey("p")

        self.getPos = self.character.getPos
        self.getX = self.character.getX

        characterSphere = CollisionSphere(0, 0, 1.0, 0.5)
        self.collisionNodeName = "character{}Collision".format(charId)
        characterColNode = CollisionNode(self.collisionNodeName)
        characterColNode.addSolid(characterSphere)
        self.characterCollision = self.character.attachNewNode(characterColNode)
        # Uncomment this line to show collision solids
        # self.characterCollision.show()
        base.pusher.addCollider(self.characterCollision, self.character)
        base.cTrav.addCollider(self.characterCollision, base.pusher)

        characterHitRay = CollisionSegment(0, -0.5, 1.0, 0, -0.8, 1.0)
        characterColNode.addSolid(characterHitRay)

        self.audioStep = base.audio3d.loadSfx("assets/audio/step.ogg")
        self.audioStep.setLoop(True)
        base.audio3d.attachSoundToObject(self.audioStep, self.character)

        self.audioHit = base.audio3d.loadSfx("assets/audio/hit.ogg")
        self.audioHit.setLoop(False)
        base.audio3d.attachSoundToObject(self.audioStep, self.character)
示例#47
0
    def movePlayer(self, player, dt):
        mw = self.base.mouseWatcherNode

        heading = self.headingTurner.getHeading()  # Heading is the roll value for this model
        lookAngle = player.getP()

        # y is forward/back, x is left/right, z is up/down 
        
        curVel = self.getVelocity(player)
        
        # Accelerate in the direction the player is currently facing
        y = 0
        if self.keys["front"]:
            y = 1
        elif self.keys["back"]:
            y = -1
        x = 0
        if self.keys["strafeLeft"]:
            x = -1
        elif self.keys["strafeRight"]:
            x = 1
        
        z = 0
        if self.keys["up"]:
            z = 1
        elif self.keys["down"]:
            z = -1
        
        if mw.isButtonDown(KeyboardButton.shift()):
            x *= 2
            y *= 2
            
        if self.keys["jump"]:
            if not self.jumping:
                self.jumpTime = 0
                self.jumping = True
                self.jumpZ = 0

        now = globalClock.getFrameTime() 
        if x or y:
            if not self.walkCycle:
                self.walkCycle = now
            
        heading_rad = DEG_TO_RAD * (360 - heading)
        
        newFwdBack = Vec3(sin(heading_rad)*y, cos(heading_rad) * y, 0)
        
        if self.flyMode:
            newFwdBack.z = sin(DEG_TO_RAD * lookAngle) * y
         
        newStrafe = Vec3(-sin(heading_rad-pi/2) * x, -cos(heading_rad-pi/2)*x, 0)
        
        newUpDown = Vec3(0, 0, z)
        
        newVel = (newFwdBack + newStrafe + newUpDown) * ACCELERATION
        playerVel = (curVel * (STEPS-1) + newVel) / STEPS
        
        self.setVelocity(player, playerVel)
        
        if self.mouseLook and mw.hasMouse():
            x, y = mw.getMouseX(), mw.getMouseY()
            
            dx, dy = x, y
            
            self.headingTurner.setTurnRate(math.sin(dx) * -1440)
            #self.headingTurner.setTarget(dx / pi)
            self.lookTurner.setTurnRate(math.sin(dy) * 1440)
            #self.lookTurner.setTarget(y * 90)
            
            self.lastMouseX, self.lastMouseY = x, y
            
            if self.mouseGrabbed:
                self.base.win.movePointer(0, 
                                      int(self.base.win.getProperties().getXSize() / 2),
                                      int(self.base.win.getProperties().getYSize() / 2))

                
            
        # Change heading if left or right is being pressed
        now = globalClock.getFrameTime()
        if self.keys["turnRight"]:
            self.headingTurner.updateTurn(-1, dt)

        elif self.keys["turnLeft"]:
            self.headingTurner.updateTurn(1, dt)

        elif self.keys["reverse"]:
            self.headingTurner.setTarget(heading + 180)
            
        elif not self.mouseLook:
            self.headingTurner.unTurn(dt)
                
        heading = self.headingTurner.update(dt)
            
        # Adjust view angle
        
        if self.keys["lookDown"]:
            self.lookTurner.updateTurn(-1, dt)
            self.lookSticky = True
        elif self.keys["lookUp"]:
            self.lookTurner.updateTurn(1, dt)
            self.lookSticky = True
        elif self.keys["lookReset"]:
            self.lookTurner.setTarget(0)
            self.lookSticky = False
        elif not self.mouseLook:
            self.lookTurner.unTurn(dt)
    
            if self.lookTurner.getTurnRate() == 0:            
                if (x or y or self.jumpZ) and not self.mouseLook:
                    self.lookSticky = False

            if not self.lookSticky:
                self.lookTurner.setTarget(0)                    
            
        lookAngle = self.lookTurner.update(dt)
            

        player.setH(heading)
        
        player.setP(lookAngle)
        
        
        # Finally, update the position as with any other object
        self.updatePos(player, now, dt)