my FPS script awsd+jumping wall sliding

kind of a noob question…

I am trying to use the script to control my own model, here is the code :

class FPS(object,DirectObject):

    def __init__(self):
        
        self.initCollision()
        self.loadLevel()
        self.initPlayer()
        self.camera()
        
    
    def initCollision(self):
        #initialize traverser
        base.cTrav = CollisionTraverser()
        base.cTrav.setRespectPrevTransform(True)
#         base.cTrav.showCollisions(render)
        #initialize pusher
        self.pusher = CollisionHandlerPusher()
        # collision bits
        self.groundCollBit = BitMask32.bit(0)
        self.collBitOff = BitMask32.allOff()

    
    def loadLevel(self):

        level = loader.loadModel('mine/road.egg')
        level.reparentTo(render)
        level.setPos(-10,-10,-6)
        level.setColor(1,1,1,.5)
        level.setScale(10)
    
    def initPlayer(self) :
        self.man = Actor("mine/toxotis",
                                 {"run":"mine/toxotis_run",
                                  "walk":"mine/toxotis_idle"})
        self.man.reparentTo(render)
        self.man.setScale(1)
        #self.man.setPos(0,0,-0.02)

        #create a collsion solid around the man
        manC = self.man.attachCollisionSphere('manSphere', 0,0,1, .4, self.groundCollBit,self.collBitOff)
        self.pusher.addCollider(manC,self.man)
        base.cTrav.addCollider(manC,self.pusher)

        speed = 6
        Forward = Vec3(0,-speed*2,0)
        Back = Vec3(0,speed,0)
        Left = Vec3(-speed,0,0)
        Right = Vec3(speed,0,0)
        Stop = Vec3(0)
        self.walk = Stop
        self.strife = Stop
        self.jump = 0
        taskMgr.add(self.move, 'move-task')
        self.jumping = LerpFunc( Functor(self.__setattr__,"jump"),
                                 duration=.25, fromData=.25, toData=0)
        self.accept( "escape",sys.exit )
        self.accept( "space" , self.startJump)
        self.accept( "s" , self.__setattr__,["walk",Back] )
        self.accept( "w" , self.__setattr__,["walk",Forward])
        self.accept( "s-up" , self.__setattr__,["walk",Stop] )
        self.accept( "w-up" , self.__setattr__,["walk",Stop] )
        self.accept( "a" , self.__setattr__,["strife",Left])
        self.accept( "d" , self.__setattr__,["strife",Right] )
        self.accept( "a-up" , self.__setattr__,["strife",Stop] )
        self.accept( "d-up" , self.__setattr__,["strife",Stop] )

        self.manGroundColNp = self.man.attachCollisionRay( 'manRay',
                                                           0,0,.6, 0,0,-1,
                                                           self.groundCollBit,self.collBitOff)
        self.manGroundHandler = CollisionHandlerGravity()
        self.manGroundHandler.addCollider(self.manGroundColNp,self.man)
        base.cTrav.addCollider(self.manGroundColNp, self.manGroundHandler)
        
           
            

    def startJump(self):
        if self.manGroundHandler.isOnGround():
           self.jumping.start()

    def move(self,task):
        dt=globalClock.getDt()
        # mouse
        md = base.win.getPointer(0)
        x = md.getX()
        y = md.getY()
        
        # move where the keys set it
        moveVec=(self.walk+self.strife)*dt # horisontal
        moveVec.setZ( self.jump )          # vertical
        self.man.setFluidPos(self.man,moveVec)
        # jump damping
        if self.jump>0:
           self.jump = clampScalar( 0,1, self.jump*.9 )
        
        # If man is moving, loop the run animation.
        # If he is standing still, stop the animation.
        
        if self.walk == Forward:
            self.man.loop("run")
                       
        return task.cont
    
    def camera(self) :
    
        # Create a floater object.  We use the "floater" as a temporary
        # variable in a variety of calculations.
        
        #self.floater = NodePath(PandaNode("floater"))
        #self.floater.reparentTo(render)

        # Set up the camera
        
        #base.disableMouse()
        #base.camera.setPos(-100,-20,20)
        #base.camera.setPos(self.man.getX(),self.man.getY()+10,2)
        
        
        

        # If the camera is too far from ralph, move it closer.
        # If the camera is too close to ralph, move it farther.

        camvec = self.man.getPos() - base.camera.getPos()
        camvec.setZ(0)
        camdist = camvec.length()
        camvec.normalize()
        if (camdist > 10.0):
            base.camera.setPos(base.camera.getPos() + camvec*(camdist-10))
            camdist = 10.0
        if (camdist < 5.0):
            base.camera.setPos(base.camera.getPos() - camvec*(5-camdist))
            camdist = 5.0

               
        # The camera should look in ralph's direction,
        # but it should also try to stay horizontal, so look at
        # a floater which hovers above ralph's head.
        
        #self.floater.setPos(self.man.getPos())
        #self.floater.setZ(self.man.getZ() + 2.0)
        base.camera.lookAt(self.man)

        
        return Task.cont


FPS()
render.setShaderAuto()
run()

I now try to loop the animation of the model and I go to the move function, and I say :


if self.walk == Forward:
   self.man.loop("run")

An error is produced because Forward is not a global variable. I realize that is only declared in the function initplayer. How can i declare it glabally?

thanx!