grind stances

Settings.py

@@ -86,6 +86,7 @@ def readSettings():
     dict['focal_length'] = int(data[56])        
     dict['cam_min'] = float(data[57])
     dict['cam_max'] = float(data[58])
+    dict['music_player'] = int(data[60]) 
     
     
     #print('bc = ', dict['bc'])        
@@ -160,7 +161,8 @@ def writeSettings():
         writing.write(str(dict["focal_length"])+"\n") 
         writing.write(str(dict["cam_min"])+"\n")                 
         writing.write(str(dict["cam_max"])+"\n") 
-        
+        writing.write(str("//music player on / off")+"\n")
+        writing.write(str(dict["music_player"])+"\n")
         
         #writing.write(str(own["framerate"])+"\n")
         print("writing settings")

car.py

@@ -0,0 +1,890 @@
+"""
+
+CarSetup 
+
+
+"""
+
+#import blender game engine content
+from bge import logic, constraints
+
+#import other modules
+import math, mathutils
+
+
+os = 'Windows'
+from sys import platform
+if platform != "win32":
+ os = 'Linux'
+def onWindows():
+ return os == 'Windows'
+import bge
+import GameLogic
+import ctypes
+
+
+
+
+reduction = 400000
+axisTh = 0.03 
+
+cont = GameLogic.getCurrentController() 
+obj = bge.logic.getCurrentScene().objects
+own = cont.owner
+#Sensor logic bricks connected to the python Controller  
+aXis = cont.sensors["sCont"]
+bUtt = cont.sensors["sContb"]
+
+
+onW = onWindows()
+
+# windows stuff
+lar_lts = 0
+uad_lts = 1
+lt = 4 if onW else 2
+lar_rts = 2 if onW else 3
+uad_rts = 3 if onW else 4
+rt = 5
+
+a_but = 0 if onW else 0
+b_but = 1 if onW else 1
+x_but = 2 if onW else 2
+y_but = 3 if onW else 3
+l_bump = 9 if onW else 4
+r_bump = 10 if onW else 5
+bk_but = 4 if onW else 6
+st_but = 6 if onW else 7
+xb_but = 5 if onW else 8
+lts_pr = 7 if onW else 9
+rts_pr = 8 if onW else 10
+l_dp = 13 if onW else 11
+r_dp = 14 if onW else 12
+u_dp = 11 if onW else 13
+d_dp = 12 if onW else 14
+
+
+
+
+
+
+
+
+class CarSetup:
+    
+    def __init__(self):
+        
+        #list of cars
+        self.carList = {}
+        
+        #list of tires
+        self.tires = {}
+        
+        #car turn amount
+        self.turnAmount = {}
+    
+    
+    def carInitialized(self, car):
+        
+        #check for initialized property
+        if "initialized" in car:
+            
+            #check if car is initialized
+            if car["initialized"] == True:
+                
+                #car is initialized
+                return True
+        
+        #car is not initialized
+        return False
+    
+    
+    def carConstraint(self, car):
+        
+        #get physics ID
+        carPhysicsID = car.getPhysicsId()
+         
+        #create a vehicle constraint 
+        vehicleConstraint = constraints.createConstraint(carPhysicsID, 0, 11)
+         
+        #get the constraint ID
+        constraintID = vehicleConstraint.getConstraintId()
+          
+        #get the vehicle constraint ID
+        vehicleID =  constraints.getVehicleConstraint(constraintID)
+    
+        #save vehicle constraint ID as an object variable
+        car["vehicleID"] = vehicleID
+        
+        #return vehicle ID
+        return vehicleID
+    
+    
+    def positionTires(self, car):
+        
+        #get the list of tires
+        tireList = self.tires[car]
+        
+        tire1 = tireList["TireFD"]  #tire front drivers
+        tire2 = tireList["TireFP"]  #tire front passengers
+        tire3 = tireList["TireRD"]  #tire rear drivers
+        tire4 = tireList["TireRP"]  #tire rear passnengers
+        
+        tire1Pos = tire1.worldPosition  #tire front drivers
+        tire2Pos = tire2.worldPosition  #tire front passengers
+        tire3Pos = tire3.worldPosition  #tire rear drivers
+        tire4Pos = tire4.worldPosition  #tire rear passnengers
+        
+        #car position
+        carPos = car.worldPosition
+        
+        #tire front drivers
+        tire1Pos = [tire1Pos[0] - carPos[0],
+                    tire1Pos[1] - carPos[1],
+                    tire1Pos[2] - carPos[2]]
+        
+        #tire front passengers
+        tire2Pos = [tire2Pos[0] - carPos[0],
+                    tire2Pos[1] - carPos[1],
+                    tire2Pos[2] - carPos[2]]
+        
+        #tire rear drivers
+        tire3Pos = [tire3Pos[0] - carPos[0],
+                    tire3Pos[1] - carPos[1],
+                    tire3Pos[2] - carPos[2]]
+        
+        #tire rear passengers
+        tire4Pos = [tire4Pos[0] - carPos[0],
+                    tire4Pos[1] - carPos[1],
+                    tire4Pos[2] - carPos[2]]
+            
+        return (tire1Pos, tire2Pos, tire3Pos, tire4Pos)
+    
+    
+    def tireRadius(self, car):
+        
+        #get the list of tires
+        tireList = self.tires[car]
+        
+        tire1Radius = tireList["TireFD"].localScale[2]/2    #tire front drivers
+        tire2Radius = tireList["TireFP"].localScale[2]/2    #tire front passengers
+        tire3Radius = tireList["TireRD"].localScale[2]/2    #tire rear drivers
+        tire4Radius = tireList["TireRP"].localScale[2]/2    #tire rear passengers
+        
+        #check for radius override
+        if "Radius" in tireList["TireFD"]:
+            tire1Radius = tireList["TireFD"]["Radius"]
+            
+        if "Radius" in tireList["TireFP"]:
+            tire2Radius = tireList["TireFP"]["Radius"]
+            
+        if "Radius" in tireList["TireRD"]:
+            tire3Radius = tireList["TireRD"]["Radius"]
+            
+        if "Radius" in tireList["TireRP"]:
+            tire4Radius = tireList["TireRP"]["Radius"]
+        
+        #return (tire1Radius, tire2Radius, tire3Radius, tire4Radius)
+        return (.2, .2, .2, .2)
+    
+    
+    def suspensionHeight(self, car):
+        
+        tireList = self.tires[car]
+        
+        tire1height = 0.2   #tire front drivers
+        tire2height = 0.2   #tire front passengers
+        tire3height = 0.2   #tire rear drivers
+        tire4height = 0.2   #tire rear passengers
+        
+        #check for suspension height override
+        if "Height" in tireList["TireFD"]:
+            tire1height = tireList["TireFD"]["Height"]
+            
+        if "Height" in tireList["TireFP"]:
+            tire2height = tireList["TireFP"]["Height"]
+            
+        if "Height" in tireList["TireRD"]:
+            tire3height = tireList["TireRD"]["Height"]
+            
+        if "Height" in tireList["TireRP"]:
+            tire4height = tireList["TireRP"]["Height"]
+        
+        return (tire1height, tire2height, tire3height, tire4height)
+    
+    
+    def suspensionAngle(self):
+        
+        tire1Angle = [0, 0, -1] #tire front drivers
+        tire2Angle = [0, 0, -1] #tire front passengers
+        tire3Angle = [0, 0, -1] #tire rear drivers
+        tire4Angle = [0, 0, -1] #tire rear passengers
+        
+        return (tire1Angle, tire2Angle, tire3Angle, tire4Angle)
+    
+    
+    def tireAxis(self):
+        
+        tire1Axis = [-1, 0, 0]  #tire front drivers
+        tire2Axis = [-1, 0, 0]  #tire front passengers
+        tire3Axis = [-1, 0, 0]  #tire rear drivers
+        tire4Axis = [-1, 0, 0]  #tire rear passengers
+        
+        return (tire1Axis, tire2Axis, tire3Axis, tire4Axis)
+    
+    
+    def tireSteering(self):
+        
+        tire1Steer = True   #tire front drivers
+        tire2Steer = True   #tire front passengers
+        tire3Steer = False  #tire rear drivers
+        tire4Steer = False  #tire rear passengers
+        
+        return (tire1Steer, tire2Steer, tire3Steer, tire4Steer)
+    
+    
+    def addTires(self, car, vehicleID):
+        
+        #get the list of tires
+        tireList = self.tires[car]
+        
+        #list the tires
+        tires = [tireList["TireFD"],
+                 tireList["TireFP"],
+                 tireList["TireRD"],
+                 tireList["TireRP"]]
+        
+        #position the tires
+        tirePos = self.positionTires(car)
+        
+        #calculate tire radius
+        tireRadius = self.tireRadius(car)
+        
+        #get the suspension heght
+        suspensionHeight = self.suspensionHeight(car)
+        
+        #get the suspension angle
+        suspensionAngle = self.suspensionAngle()
+        
+        #get the tire axis
+        tireAxis = self.tireAxis()
+        
+        #get which wheels turn
+        tireSteer = self.tireSteering()
+        
+        for tire in range(0, 4):
+            
+            #tire object
+            obj = tires[tire]
+            
+            #tire position
+            pos = tirePos[tire]
+            
+            #tire suspension height
+            suspenHeight = suspensionHeight[tire]
+            
+            #angle of suspension
+            suspenAngle = suspensionAngle[tire]
+            
+            #tire rotation axis
+            axis = tireAxis[tire]
+            
+            #tire radius
+            radius = tireRadius[tire]
+            
+            #tire steering
+            steering = tireSteer[tire]
+            
+            #add wheel to car
+            vehicleID.addWheel(obj, pos, suspenAngle, axis, suspenHeight, radius, steering)
+            
+    
+    def tireGrip(self, car, vehicleID):
+        
+        #list of tires
+        tireList = self.tires[car]
+        #10
+        tire1Grip = 8  #tire front drivers
+        tire2Grip = 8  #tire front Passengers
+        tire3Grip = 8  #tire rear drivers
+        tire4Grip = 8  #tire rear passengers
+        
+        #check for grip override
+        if "Grip" in tireList["TireFD"]:
+            tire1Grip = tireList["TireFD"]["Grip"]
+            
+        if "Grip" in tireList["TireFP"]:
+            tire2Grip = tireList["TireFP"]["Grip"]
+            
+        if "Grip" in tireList["TireRD"]:
+            tire3Grip = tireList["TireRD"]["Grip"]
+            
+        if "Grip" in tireList["TireRP"]:
+            tire4Grip = tireList["TireRP"]["Grip"]
+        
+        vehicleID.setTyreFriction(tire1Grip, 0) #tire front drivers
+        vehicleID.setTyreFriction(tire2Grip, 1) #tire front Passengers
+        vehicleID.setTyreFriction(tire3Grip, 2) #tire rear drivers
+        vehicleID.setTyreFriction(tire4Grip, 3) #tire rear passengers
+        
+    
+    def suspensionCompression(self, car, vehicleID):
+        
+        #list of tires
+        tireList = self.tires[car]
+        #6
+        tire1Compress = 6   #tire front drivers
+        tire2Compress = 6   #tire front Passengers
+        tire3Compress = 6   #tire rear drivers
+        tire4Compress = 6   #tire rear passengers
+        
+        #check for compression override
+        if "Compression" in tireList["TireFD"]:
+            tire1Compress = tireList["TireFD"]["Compression"]
+            
+        if "Compression" in tireList["TireFP"]:
+            tire2Compress = tireList["TireFP"]["Compression"]
+            
+        if "Compression" in tireList["TireRD"]:
+            tire3Compress = tireList["TireRD"]["Compression"]
+            
+        if "Compression" in tireList["TireRP"]:
+            tire4Compress = tireList["TireRP"]["Compression"]
+        
+        vehicleID.setSuspensionCompression(tire1Compress, 0)    #tire front drivers
+        vehicleID.setSuspensionCompression(tire2Compress, 1)    #tire front Passengers
+        vehicleID.setSuspensionCompression(tire3Compress, 2)    #tire rear drivers
+        vehicleID.setSuspensionCompression(tire4Compress, 3)    #tire rear passengers
+    
+    
+    def suspensionDamping(self, car, vehicleID):
+        
+        #list of tires
+        tireList = self.tires[car]
+        
+        tire1Damp = 5   #tire front drivers
+        tire2Damp = 5   #tire front Passengers
+        tire3Damp = 5   #tire rear drivers
+        tire4Damp = 5   #tire rear passengers
+        
+        #check for damping override
+        if "Damping" in tireList["TireFD"]:
+            tire1Damp = tireList["TireFD"]["Damping"]
+            
+        if "Damping" in tireList["TireFP"]:
+            tire2Damp = tireList["TireFP"]["Damping"]
+            
+        if "Damping" in tireList["TireRD"]:
+            tire3Damp = tireList["TireRD"]["Damping"]
+            
+        if "Damping" in tireList["TireRP"]:
+            tire4Damp = tireList["TireRP"]["Damping"]
+        
+        vehicleID.setSuspensionDamping(tire1Damp, 0)    #tire front drivers
+        vehicleID.setSuspensionDamping(tire2Damp, 1)    #tire front Passengers
+        vehicleID.setSuspensionDamping(tire3Damp, 2)    #tire rear drivers
+        vehicleID.setSuspensionDamping(tire4Damp, 3)    #tire rear passengers
+    
+    
+    def suspensionStiffness(self, car, vehicleID):
+        
+        #list of tires
+        tireList = self.tires[car]
+        
+        tire1Stiffness = 12.5       #tire front drivers
+        tire2Stiffness = 12.5       #tire front Passengers
+        tire3Stiffness = 12.5       #tire rear drivers
+        tire4Stiffness = 12.5       #tire rear passengers
+        
+        #check for stiffness override
+        if "Stiffness" in tireList["TireFD"]:
+            tire1Stiffness = tireList["TireFD"]["Stiffness"]
+            
+        if "Stiffness" in tireList["TireFP"]:
+            tire2Stiffness = tireList["TireFP"]["Stiffness"]
+            
+        if "Stiffness" in tireList["TireRD"]:
+            tire3Stiffness = tireList["TireRD"]["Stiffness"]
+            
+        if "Stiffness" in tireList["TireRP"]:
+            tire4Stiffness = tireList["TireRP"]["Stiffness"]
+        
+        vehicleID.setSuspensionStiffness(tire1Stiffness, 0) #tire front drivers
+        vehicleID.setSuspensionStiffness(tire2Stiffness, 1) #tire front Passengers
+        vehicleID.setSuspensionStiffness(tire3Stiffness, 2) #tire rear drivers
+        vehicleID.setSuspensionStiffness(tire4Stiffness, 3) #tire rear passengers
+    
+    
+    def suspensionRollInfluence(self, car, vehicleID):
+        
+        #list of tires
+        tireList = self.tires[car]
+        
+        tire1Roll = -0.16   #tire front drivers
+        tire2Roll = -0.16   #tire front Passengers
+        tire3Roll = -0.16   #tire rear drivers
+        tire4Roll = -0.16   #tire rear passengers
+        
+        #check for roll influence override
+        if "RollInfluence" in tireList["TireFD"]:
+            tire1Roll = -tireList["TireFD"]["RollInfluence"]
+            
+        if "Roll" in tireList["TireFP"]:
+            tire2Roll = -tireList["TireFP"]["RollInfluence"]
+            
+        if "Roll" in tireList["TireRD"]:
+            tire3Roll = -tireList["TireRD"]["RollInfluence"]
+            
+        if "Roll" in tireList["TireRP"]:
+            tire4Roll = -tireList["TireRP"]["RollInfluence"]
+        
+        vehicleID.setRollInfluence(tire1Roll, 0)    #tire front drivers
+        vehicleID.setRollInfluence(tire2Roll, 1)    #tire front Passengers
+        vehicleID.setRollInfluence(tire3Roll, 2)    #tire rear drivers
+        vehicleID.setRollInfluence(tire4Roll, 3)    #tire rear passengers
+    
+    
+#create CarSetup object
+carsetup = CarSetup()
+
+
+def _initialize(controller):
+    
+    #get the car object
+    car = controller.owner
+    
+    #get current orientation
+    carOrient = car.worldOrientation
+    
+    #convert orientation to euler
+    carEuler = carOrient.to_euler()
+    newCarEuler = carOrient.to_euler()
+    
+    #set euler rotation
+    newCarEuler[0] = 0
+    newCarEuler[1] = 0
+    newCarEuler[2] = 0
+    
+    #set car orientation
+    car.worldOrientation = newCarEuler.to_matrix()
+    
+    if not car.name in carsetup.carList:
+        
+        #assign the car
+        carsetup.carList[car] = car
+        
+        tires = {}
+        
+        #look for tires
+        for c in car.children:
+            
+            tire = "Tire"
+            
+            #check if tire object
+            if "Tire" in c:
+                
+                #build the tire name
+                tire += c["Tire"]
+                
+                #add tire to list
+                tires[tire] = c
+                
+                #assign tires owner
+                c["owner"] = car.name
+                
+                #clear tire parent
+                c.removeParent()
+        
+        #add tires to list of tires
+        carsetup.tires[car] = tires
+        
+        #build the car constraint
+        vehicleID = carsetup.carConstraint(car)
+        
+        #add tires to car
+        carsetup.addTires(car, vehicleID)
+        
+        #set tire grip
+        carsetup.tireGrip(car, vehicleID)
+        
+        #set suspension compression
+        carsetup.suspensionCompression(car, vehicleID)
+        
+        #set suspension damping
+        carsetup.suspensionDamping(car, vehicleID)
+        
+        #set suspension stiffness
+        carsetup.suspensionStiffness(car, vehicleID)
+        
+        #set suspension roll influence
+        carsetup.suspensionRollInfluence(car, vehicleID)
+    
+    #set car orientation
+    car.worldOrientation = carEuler.to_matrix()
+    
+    #set car to initialized
+    car["initialized"] = True
+    
+    #set turn amount
+    carsetup.turnAmount[car] = 0
+    
+    #check for "TurnAmount" property in car
+    if not "TurnAmount" in car:
+        
+        #set default turn amount
+        car["TurnAmount"] = 50#35
+        
+    #check for "TurnSpeed" property in car
+    if not "TurnSpeed" in car:
+        
+        #set default turn speed
+        car["TurnSpeed"] = 1
+        car["TurnSpeed2"] = 20#2
+
+
+
+def _constraintID(car):
+        
+    # get saved vehicle Constraint ID
+    vehicleID = car["vehicleID"]
+    
+    return vehicleID
+
+
+def _powertrain(controller, car):
+    
+    #declare variables
+    gas = None
+    reverse = None
+    brake = None
+    ebrake = None
+    
+    #get the vehicl id
+    vehicleID = _constraintID(car)
+    
+    #engine power
+    power = 0
+    
+    #engine
+    engine = True
+    
+    #check for engine override
+    if "Engine" in car:
+        engine = car["Engine"]
+    
+    
+    
+    #set default values
+    forwardSpeed = 70
+    
+    reverseSpeed = 200
+    brakeAmount = 10
+    eBrakeAmount = 40
+    backdrive = True
+    frontdrive = False
+    
+    #check for forward speed override
+    if "ForwardSpeed" in car:
+        
+        #set forward speed
+        forwardSpeed = car["ForwardSpeed"]
+    
+    #check for reverse speed override
+    if "ReverseSpeed" in car:
+        
+        #set reverse speed
+        reverseSpeed = car["ReverseSpeed"]
+    
+    #check for brake amount override
+    if "BrakeAmount" in car:
+        
+        #set brake amount
+        brakeAmount = car["BrakeAmount"]
+    
+    #check for E-brake amount override
+    if "EBrakeAmount" in car:
+        
+        #set brake amount
+        eBrakeAmount = car["EBrakeAmount"]
+    
+    #check for BackWheelDrive override
+    if "BackWheelDrive" in car:
+        
+        #set back wheel drive
+        backdrive = car["BackWheelDrive"]
+    
+    #check for FrontWheelDrive override
+    if "FrontWheelDrive" in car:
+        
+        #set front wheel drive
+        frontdrive = car["FrontWheelDrive"]
+    
+    #check for gas sensor
+    if "Gas" in controller.sensors:
+        #gas = controller.sensors["Gas"]       
+        gas = own['gas']
+    #check for reverse sensor
+    #if "Reverse" in controller.sensors:
+        #reverse = controller.sensors["Reverse"]
+    reverse = own['reverse']
+    #check for brake sensor
+    #if "Brake" in controller.sensors:
+        #brake = controller.sensors["Brake"]
+    brake = own['brake']
+    #check for E-brake sensor
+    if "EBrake" in controller.sensors:
+        ebrake = controller.sensors["EBrake"]
+    
+    #check if gas exists
+    if gas:
+        
+        #check if gas is positive
+        if gas == 1:
+            
+            #check if engine is on
+            if engine:
+                #set power
+                power = -forwardSpeed
+    
+    #check if reverse exists
+    #if reverse:
+        
+    #check if reverse is positive
+    if reverse == 1:
+        
+        #check if engine is on
+        if engine:
+            
+            #set power
+            power = reverseSpeed
+            
+            #check if gas exists
+            if gas:
+                
+                #check if gas is positive
+                if gas == 1:
+                    
+                    #set power
+                    power = 0
+    
+    #check if brake exists
+    #if brake:
+        
+    #check if brake is positive
+    if brake == 1:
+        
+        #apply braking
+        vehicleID.applyBraking(brakeAmount, 2)
+        vehicleID.applyBraking(brakeAmount, 3)
+        
+        #set power
+        power = 0
+        
+    else:
+        #remove braking
+        vehicleID.applyBraking(0, 2)
+        vehicleID.applyBraking(0, 3)
+        
+    #check if e brake exists
+    if ebrake:
+        
+        #check if e brake is positive
+        if ebrake.positive:
+            
+            #apply braking
+            vehicleID.applyBraking(eBrakeAmount, 2)
+            vehicleID.applyBraking(eBrakeAmount, 3)
+            
+            #set power
+            power = 0
+    
+            
+    #check if back wheel drive
+    if backdrive:
+        
+        #apply power
+        vehicleID.applyEngineForce(-power, 2)
+        vehicleID.applyEngineForce(-power, 3)
+        
+    #check if front wheel drive
+    if frontdrive:
+        
+        #apply power
+        vehicleID.applyEngineForce(-power, 0)
+        vehicleID.applyEngineForce(-power, 1)
+
+
+def _steer(controller, car):
+    
+    #declare variables
+    #left = None
+    #right = None
+    left = own['left']
+    right = own['right']
+    #turn amount
+    turnAmount = math.radians(car["TurnAmount"])
+    
+    #get turn speed
+    turnSpeed = car["TurnSpeed"] * 0.01
+    turnSpeed2 = car["TurnSpeed2"] * 0.01
+    
+    #get vehicle id
+    vehicleID = _constraintID(car)
+    
+    #check for left sensor
+    #if "Left" in controller.sensors:
+        #left = controller.sensors["Left"]
+        
+    #check for right sensor
+    #if "Right" in controller.sensors:
+        #right = controller.sensors["Right"]
+    
+    #check if the sensors exist
+    #if left and right:
+        
+        #check if both are positive
+        #if left.positive and right.positive:
+            
+            #pass
+        
+        #check if left is positive
+        #elif left.positive and not right.positive:
+    if left == True:    
+        #check turn amount
+        if carsetup.turnAmount[car] < turnAmount:
+            
+            #add to turn value
+            carsetup.turnAmount[car] += turnSpeed
+            
+            #apply steering
+            vehicleID.setSteeringValue(carsetup.turnAmount[car],0)
+            vehicleID.setSteeringValue(carsetup.turnAmount[car],1)
+    
+    #check if right is positive
+    #elif not left.positive and right.positive:
+    elif right == True:    
+        #check turn amount
+        if carsetup.turnAmount[car] > -turnAmount:
+            
+            #subtract from turn value
+            carsetup.turnAmount[car] -= turnSpeed
+            
+            #apply steering
+            vehicleID.setSteeringValue(carsetup.turnAmount[car],0)
+            vehicleID.setSteeringValue(carsetup.turnAmount[car],1)
+            
+    #check if none are positive
+    #elif not left.positive and not right.positive:
+    elif right == 0 and left == 0:
+        #print(round(carsetup.turnAmount[car],2))
+        #check if steering right
+        if carsetup.turnAmount[car] <= -turnSpeed2:
+            #print("less than, subtract")
+            #add to turn value
+            carsetup.turnAmount[car] += turnSpeed2
+        #check if steering left
+        elif carsetup.turnAmount[car] > turnSpeed2:
+            #print("greater than add")
+            #subtract from turn value
+            carsetup.turnAmount[car] -= turnSpeed2
+        else:
+            carsetup.turnAmount[car] = 0
+            
+        #apply steering
+        vehicleID.setSteeringValue(carsetup.turnAmount[car],0)
+        vehicleID.setSteeringValue(carsetup.turnAmount[car],1)
+
+    
+def main(controller):
+
+    lLR = aXis.axisValues[lar_lts] / reduction
+    lUD = aXis.axisValues[uad_lts] / reduction
+    rLR = aXis.axisValues[lar_rts] / reduction
+    rUD = aXis.axisValues[uad_rts] / reduction
+    lTrig = aXis.axisValues[lt] / reduction
+    rTrig = aXis.axisValues[rt] / reduction
+    aBut = bUtt.getButtonStatus(a_but)
+    bBut = bUtt.getButtonStatus(b_but)
+    xBut = bUtt.getButtonStatus(x_but)
+    yBut = bUtt.getButtonStatus(y_but)
+    lBump = bUtt.getButtonStatus(l_bump)
+    rBump = bUtt.getButtonStatus(r_bump)
+    bkBut = bUtt.getButtonStatus(bk_but)
+    stBut = bUtt.getButtonStatus(st_but)
+    xbBut = bUtt.getButtonStatus(xb_but)
+    ltsBut = bUtt.getButtonStatus(lts_pr)
+    rtsBut = bUtt.getButtonStatus(rts_pr)
+    ldPad = bUtt.getButtonStatus(l_dp)
+    rdPad = bUtt.getButtonStatus(r_dp)
+    udPad = bUtt.getButtonStatus(u_dp)
+    ddPad = bUtt.getButtonStatus(d_dp)
+
+    #no input
+    def cutOff():    
+     if (abs(lLR) < axisTh 
+         and abs(lUD) < axisTh 
+         and abs(rLR) < axisTh 
+         and abs(rUD) < axisTh
+         and aBut == False):        
+      return True
+
+    #print(rTrig)
+    own['ForwardSpeed'] = rTrig * 6500
+    #if own['ForwardSpeed'] < 500:
+        #own['ForwardSpeed'] = 500:
+    if rTrig > .01:
+        own['gas'] = 1
+    else:
+        own['gas'] = 0 
+    if lTrig > .01:
+        own['brake'] = 1
+    else:
+        own['brake'] = 0 
+    if lLR > .04:
+        own['right'] = 1
+    else:
+        own['right'] = 0
+    if lLR < -.04:
+        own['left'] = 1
+    else:
+        own['left'] = 0
+    if aBut == 1:
+        own['reverse'] = 1
+    else:
+        own['reverse'] = 0         
+                                   
+    
+    #get the car object
+    car = controller.owner
+    
+    #check if car was initialized
+    if not carsetup.carInitialized(car):
+        
+        #initialize the car
+        _initialize(controller)
+        
+        #exit
+        return
+    
+    #build the car constraint
+    vehicleID = _constraintID(car)
+    
+    #set tire grip
+    carsetup.tireGrip(car, vehicleID)
+    
+    #set suspension compression
+    carsetup.suspensionCompression(car, vehicleID)
+    
+    #set suspension damping
+    carsetup.suspensionDamping(car, vehicleID)
+    
+    #set suspension stiffness
+    carsetup.suspensionStiffness(car, vehicleID)
+    
+    #set suspension roll influence
+    carsetup.suspensionRollInfluence(car, vehicleID)
+    
+    #run powertrain
+    _powertrain(controller, car)
+    
+    #run powertrain
+    _steer(controller, car)

controller2.py

@@ -563,11 +563,11 @@ def main():
         #revert_timer
         playing = deck.isPlayingAction(40)
         if own["revert_timer"] < 1 and own['manual_v2'] == 0 and playing == 0:
-            if inc == 1:
-                print('inc stance')
-                own['requestAction'] = 'reg_pump'
-            else:    
-                own['requestAction'] = 'reg_roll'
+#            if inc == 1:
+#                print('inc stance')
+#                own['requestAction'] = 'reg_pump'
+#            else:    
+            own['requestAction'] = 'reg_roll'
     def reg_stance_off():
         pass 
         
@@ -642,10 +642,10 @@ def main():
     def fak_stance_on(inc):
         playing = deck.isPlayingAction(40)
         if own['manual_v2'] == 0 and own["revert_timer"] < 1 and playing == 0 and own['gt_cd2'] < 1:
-            if inc == 1:
-                own['requestAction'] = 'fak_pump'
-            else:    
-                own['requestAction'] = 'fak_roll'
+#            if inc == 1:
+#                own['requestAction'] = 'fak_pump'
+#            else:    
+            own['requestAction'] = 'fak_roll'
     def fak_stance_off():
         pass
         
@@ -2090,18 +2090,18 @@ def main():
                 elif own['grindType'] == "reg_fsboard":
                     own['grind_stance'] = 0
                     own['requestAction'] = 'reg_fsboard'
-                elif own['grindType'] == "reg_tailg":
-                    own['requestAction'] = 'reg_tailg'
-                elif own['grindType'] == "reg_tailgR":
-                    own['requestAction'] = 'reg_tailgr'
-                elif own['grindType'] == "reg_tailgL":
-                    own['requestAction'] = 'reg_tailgl'
-                elif own['grindType'] == "reg_noseg":
-                    own['requestAction'] = 'reg_noseg'                
-                elif own['grindType'] == "reg_nosegR":
-                    own['requestAction'] = 'reg_nosegr'                
-                elif own['grindType'] == "reg_nosegL":
-                    own['requestAction'] = 'reg_nosegl'                
+#                elif own['grindType'] == "reg_tailg":
+#                    own['requestAction'] = 'reg_tailg'
+#                elif own['grindType'] == "reg_tailgR":
+#                    own['requestAction'] = 'reg_tailgr'
+#                elif own['grindType'] == "reg_tailgL":
+#                    own['requestAction'] = 'reg_tailgl'
+#                elif own['grindType'] == "reg_noseg":
+#                    own['requestAction'] = 'reg_noseg'                
+#                elif own['grindType'] == "reg_nosegR":
+#                    own['requestAction'] = 'reg_nosegr'                
+#                elif own['grindType'] == "reg_nosegL":
+#                    own['requestAction'] = 'reg_nosegl'                
                 elif own['grindType'] == "fak_noseg":
                     own['requestAction'] = 'fak_noseg'                
                 elif own['grindType'] == "fak_nosegR": 
@@ -2114,6 +2114,21 @@ def main():
                     own['requestAction'] = 'fak_tailgr'
                 elif own['grindType'] == "fak_tailgL":
                     own['requestAction'] = 'fak_tailgl'
+                
+                #33333333333    
+                elif own['grindType'] == "reg_tailg":
+                    own['requestAction'] = 'fak_noseg'
+                elif own['grindType'] == "reg_tailgR":
+                    own['requestAction'] = 'fak_nosegr'
+                elif own['grindType'] == "reg_tailgL":
+                    own['requestAction'] = 'fak_nosegl'
+                elif own['grindType'] == "reg_noseg":
+                    own['requestAction'] = 'fak_tailg'                
+                elif own['grindType'] == "reg_nosegR":
+                    own['requestAction'] = 'fak_tailgr'                
+                elif own['grindType'] == "reg_nosegL":
+                    own['requestAction'] = 'fak_tailgl'                        
+                #33333333333
                     
                 elif own['grindType'] == "reg_tailslide":
                     own['requestAction'] = 'reg_tailslide'
@@ -2164,18 +2179,18 @@ def main():
                     own['requestAction'] = 'reg_nosegr'             
                 elif own['grindType'] == "reg_nosegL":
                     own['requestAction'] = 'reg_nosegl'             
-                elif own['grindType'] == "fak_noseg":
-                    own['requestAction'] = 'fak_noseg'
-                elif own['grindType'] == "fak_nosegR": 
-                    own['requestAction'] = 'fak_nosegr'               
-                elif own['grindType'] == "fak_nosegL":
-                    own['requestAction'] = 'fak_nosegl'                
-                elif own['grindType'] == "fak_tailg":
-                    own['requestAction'] = 'fak_tailg'
-                elif own['grindType'] == "fak_tailgR": 
-                    own['requestAction'] = 'fak_tailgr'
-                elif own['grindType'] == "fak_tailgL":
-                    own['requestAction'] = 'fak_tailgl' 
+#                elif own['grindType'] == "fak_noseg":
+#                    own['requestAction'] = 'fak_noseg'
+#                elif own['grindType'] == "fak_nosegR": 
+#                    own['requestAction'] = 'fak_nosegr'               
+#                elif own['grindType'] == "fak_nosegL":
+#                    own['requestAction'] = 'fak_nosegl'                
+#                elif own['grindType'] == "fak_tailg":
+#                    own['requestAction'] = 'fak_tailg'
+#                elif own['grindType'] == "fak_tailgR": 
+#                    own['requestAction'] = 'fak_tailgr'
+#                elif own['grindType'] == "fak_tailgL":
+#                    own['requestAction'] = 'fak_tailgl' 
                 elif own['grindType'] == "reg_tailslide":
                     own['requestAction'] = 'reg_tailslide'
                 elif own['grindType'] == "reg_noseslide":
@@ -2185,6 +2200,23 @@ def main():
                 elif own['grindType'] == "fak_noseslide":
                     own['requestAction'] = 'fak_noseslide'                                        
                     
+                #3333333333
+                elif own['grindType'] == "fak_noseg":
+                    own['requestAction'] = 'reg_tailg'
+                elif own['grindType'] == "fak_nosegR": 
+                    own['requestAction'] = 'reg_tailgr'               
+                elif own['grindType'] == "fak_nosegL":
+                    own['requestAction'] = 'reg_tailgl'                
+                elif own['grindType'] == "fak_tailg":
+                    own['requestAction'] = 'reg_noseg'
+                elif own['grindType'] == "fak_tailgR": 
+                    own['requestAction'] = 'reg_nosegr'
+                elif own['grindType'] == "fak_tailgL":
+                    own['requestAction'] = 'reg_nosegl' 
+                #3333333    
+                    
+                    
+                    
                 elif own['grindType'] == "fak_tailslide" and edge == 1:
                     own['grind_stance'] = 1
                     own['requestAction'] = 'reg_noseslide'
@@ -2211,6 +2243,13 @@ def main():
                 own['lg_stance'] = 0
                 lg_stance = 0
                 #print('changing stance 0') 
+                
+#            if 'reg' in own['l_actionState'] and STANCE == 1:
+#                print('wrong grind stance', own['requestAction'])    
+#            else:
+#                print('ok')    
+                
+                
             own['stance'] = STANCE                         
                       
     def rotmult():

grindV2.py

@@ -509,7 +509,7 @@ def main():
         else:
             own['inverting'] = False
         grind_dist = .8#.6
-
+        #print(lastobj.worldPosition)
         if dist < grind_dist and dropin == 0 and manual == 0 and no_grind == 0 and own['grindoutturn'] == 0 and own['manual'] == 0 and own['gt_cd2'] < 40 and invert_on == False and own['air_mover'] == False and no_grind_pull == 0 and own['last_invert'] == False and own['grindjumpturn'] == 0 and grind_jump == 0 and own['airup'] == 0:
             #print('grind')      
             hitObject, hitPoint, hitNormal = own.rayCast(nearestObject.worldPosition, own.worldPosition, .0, 'grind')

music_player.py

@@ -31,6 +31,7 @@ def stop_music(sound):
     print("Stop music")    
     sound.pauseSound()
     dict['mu_stopped'] = 1
+    dict['music_player'] = 0
     
 def play_music():
 
@@ -42,7 +43,8 @@ def play_music():
     sound.startSound()
     dict['mu_stopped'] = 0
     dict['change_track'] = 0
-    dict['mu_track_time'] = 0   
+    dict['mu_track_time'] = 0 
+    dict['music_player'] = 1  
 
     try:
         tag = TinyTag.get(full_path)
@@ -141,11 +143,12 @@ def main(cont):
     sound.sound = aud.Factory(full_path)
     sound.mode = 1
     initer(cont)
-    if dict['mu_stopped'] == 0:        
-        sound.startSound()
-    if dict['change_track'] == 1:
-        dict['change_track'] = 0
-        next_track() 
+    if dict['music_player'] != 0:
+        if dict['mu_stopped'] == 0:        
+            sound.startSound()
+        if dict['change_track'] == 1:
+            dict['change_track'] = 0
+            next_track() 
 
     plist = dict['mu_playlist']  
     pl_length = len(dict['mu_playlist'])    

scene_init.py

@@ -153,5 +153,11 @@ def main():
     cam['bloom_on'] = dict['bloom_on'] 
     own['grindnew_timer'] = 0   
     own['last_ramp'] = 0
+    own['requestAction'] = ''
+    own['l_actionState'] = ''
+    own['actionState'] = ''
+    own['transition_timer'] = 0
+    own['transitioning'] = 0
+    own['driving'] = False
            
 main()

walk.py

@@ -376,7 +376,7 @@ def getonboard():
     #print(dict['kb_q'])
     getonboard = own['getonboard']
     fliplay2 = 50#8560
-    if yBut == True or dict['kb_q'] == 2:
+    if (yBut == True or dict['kb_q'] == 2) and cont.sensors["carNear"].positive == False:
         fliplay3 = fliplay2 + 1 
         if dropinCol.positive == True: 
             nearestObject = None
@@ -457,7 +457,7 @@ def getonboard():
         own['throw_deck'] = False 
         throw_deck_empty = scene.objects["throw_deck_empty"]
         throw_deck_empty['kill_deck'] = 1 
-    if (yBut == False and lasty == True) or dict['kb_q'] == 3:               
+    if ((yBut == False and lasty == True) or dict['kb_q'] == 3) and cont.sensors["carNear"].positive == False:               
         own['getonboard'] = 1 
         own['walk_idling'] = 0      
 
@@ -1056,7 +1056,29 @@ def onground():
     if cb.positive:
         if own['framenum'] - own['last_fall_frame'] < 90:
             own['lF_ground_frame'] = own['framenum']
-                                    
+
+def get_in_car():
+    carNear = cont.sensors["carNear"]
+    if carNear.positive:
+        obj = carNear.hitObject
+        if yBut == True:
+            obj['driving'] = True
+            own['driving'] = True
+            scene = bge.logic.getCurrentScene()
+            cam = scene.active_camera
+            #cam.target = obj
+            #cam.state = 2
+            cont.actuators['Camera'].object = obj
+            cont.actuators['Camera'].height = 3
+            cont.actuators['Camera'].min = 6
+            cont.actuators['Camera'].max = 10
+            own.state = 2
+        print('near car')  
+        
+def get_on_bike():
+    bikeCol = cont.sensors['bikeCol']
+    if bikeCol.positive and yBut == True:
+        print('bike')                                          
                 
 onboard() 
 jump()
@@ -1075,6 +1097,8 @@ idle_anim()
 sit()
 onground()
 focus_deck()
+get_in_car()
+
 #printplaying() 
 
 own.alignAxisToVect([0.0,0.0,1.0], 2, .03)