joytimers rewrite

scripts/controller2.py

 from sys import platform
 from mathutils import Vector
 import mathutils
+import joytimers
 
 def main():
     scene = bge.logic.getCurrentScene()
 
-    #initialize quadrant variables
-    q1on = 0
-    q2on = 0
-    q3on = 0
-    q4on = 0
-    q5on = 0
-    q6on = 0
-    q7on = 0
-    q8on = 0
-    lq1on = 0
-    lq2on = 0
-    lq3on = 0
-    lq4on = 0
-    lq5on = 0
-    lq6on = 0
-    lq7on = 0
-    lq8on = 0
-
     #number of frames / length of the location timers
     countdown = 20
 
-
     cont = GameLogic.getCurrentController()
     char = bge.constraints.getCharacter
     own = cont.owner
     dict = bge.logic.globalDict #Get the global dictionary
-    #dict['trick_string'] = ''
 
     #last frame stuff
     lGRAB_ON = own["lGRAB_ON"]
     pumpon = own["Pump"]
     vib_countdown = own["vib_Countdown"]
     grindold = own['grindOld']
-    #grindHit = own["LAST_GRIND"]
     LAST_GRIND = own["LAST_GRIND"]
-    #grindTouch = cont.sensors['grindCol']
     grindTouch = cont.sensors['grindCol_bottom']
     touched = grindTouch.triggered
     leftgrabon = own["Leftgrabon"]
     pos = own.localPosition
     rot = own.getAxisVect([0.0, 0.0, 1.0])
     gray = cont.sensors["gRay"]
-    #airconst = cont.actuators["airConst"]
     pop = cont.actuators["pop"]
     grindHit = own["grindHit"]
     grindCement = cont.actuators["grind_cement"]
     own['grinding'] = False
     #own['fall'] = 0
 
-    #joystick location timers
-    q1oncd = own["Q1oncd"]
-    q2oncd = own["Q2oncd"]
-    q3oncd = own["Q3oncd"]
-    q4oncd = own["Q4oncd"]
-    q5oncd = own["Q5oncd"]
-    q6oncd = own["Q6oncd"]
-    q7oncd = own["Q7oncd"]
-    q8oncd = own["Q8oncd"]
-    q1oncdl = own["Q1oncdl"]
-    q2oncdl = own["Q2oncdl"]
-    q3oncdl = own["Q3oncdl"]
-    q4oncdl = own["Q4oncdl"]
-    q5oncdl = own["Q5oncdl"]
-    q6oncdl = own["Q6oncdl"]
-    q7oncdl = own["Q7oncdl"]
-    q8oncdl = own["Q8oncdl"]
     fliplay = 3
 
     #setable
     land_overRideLb = False
     land_overRideRb = False
 
-
-    #print(linVelocity, 'linvely')
+    joytimers.main(own)
+    sr = own['jsr']
+    sl = own['jsl']
 
     #2019 ground ray detection
     Axis = 2
         groundRay = own.rayCast(End, Start, 10,'ground', 1, 0, 0, 61439)
     grindRay = own.rayCast(End, Start, 1,'grind', 1, 1, 0, 61439)
     
-    #bge.render.drawLine(Start, End, [255,0,0])
-
     if groundRay[0]:
 
         localHitDist = (own.worldPosition - groundRay[1]).length
         if localHitDist < .4 and own['jump_timer'] < 32:
             onGround = True
-            #print('rayed', localHitDist)
         else:
-            
             onGround = False   
-            #print('jumptimer', own['jump_timer'])
-            #print('not on ground', localHitDist, own['jump_timer']) 
        
     else:
         #if own['LAST_GRIND'] == True:
             deck.stopAction(x)
             trucks.stopAction(x)
 
-    def reset_rtimers_done():
-        pass
-        #print('rtimer reset:', q1oncd, q2oncd, q3oncd, q4oncd, q5oncd, q6oncd, q7oncd, q8oncd)
-
-    def reset_rtimers():
-        own["Q1oncd"] = 0
-        own["Q2oncd"] = 0
-        own["Q3oncd"] = 0
-        own["Q4oncd"] = 0
-        own["Q5oncd"] = 0
-        own["Q6oncd"] = 0
-        own["Q7oncd"] = 0
-        own["Q8oncd"] = 0
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
-        reset_rtimers_done()
-
     def check_fall():
         playing_frame = 20
         #hitDistance = own.worldPosition.z - r_ground.hitPosition.z
                 jump_timer = 60
                 own['jump_timer'] = jump_timer
 
-                own["Q1oncd"] = 0
-            own["Q2oncd"] = 0
-            own["Q3oncd"] = 0
-            own["Q4oncd"] = 0
-            own["Q5oncd"] = 0
-            own["Q6oncd"] = 0
-            own["Q7oncd"] = 0
-            own["Q8oncd"] = 0
         if own['jump_timer'] == 60:
             own['jump_timer'] = 59
 
         pass
 
     def revert():
-        own["Q3oncdl"] = 0
-        own["Q4oncdl"] = 0
-        own["Q5oncdl"] = 0
-        own["Q6oncdl"] = 0
-        own["Q7oncdl"] = 0
         local = True
         rot = [0.0, 0.0, 3.14]
         own.applyRotation(rot, local)
         dict['trick_string'] = 'Revert'
 
     def revert2():
-        own["Q3oncdl"] = 0
-        own["Q4oncdl"] = 0
-        own["Q5oncdl"] = 0
-        own["Q6oncdl"] = 0
-        own["Q7oncdl"] = 0
         local = True
         rot = [0.0, 0.0, -3.14]
         own.applyRotation(rot, local)
         dict['trick_string'] = 'Revert'
 
     def revert3():
-        own["Q7oncdl"] = 0
-        own["Q8oncdl"] = 0
-        own["Q1oncdl"] = 0
-        own["Q2oncdl"] = 0
-        own["Q3oncdl"] = 0
         local = True
         rot = [0.0, 0.0, 3.14]
         own.applyRotation(rot, local)
         dict['trick_string'] = 'Revert'
 
     def revert4():
-        own["Q7oncdl"] = 0
-        own["Q8oncdl"] = 0
-        own["Q1oncdl"] = 0
-        own["Q2oncdl"] = 0
-        own["Q3oncdl"] = 0
         local = True
         rot = [0.0, 0.0, 3.14]
         own.applyRotation(rot, local)
     #    q6    q4
     #       q5
     ##################
-    #lq6
-    if lUD > .04 and lLR < -0.04:
-        lq6on = 1
-        q6oncdl = countdown
-        own["Q6oncdl"] = q6oncdl
-    elif q6oncdl > 0:
-        lq6on = 0
-        q6oncdl = q6oncdl - 1
-        own["Q6oncdl"] = q6oncdl
-    #lq8
-    if lUD < -.04 and lLR < -0.04:
-        lq8on = 1
-        q8oncdl = countdown
-        own["Q8oncdl"] = q8oncdl
-    elif q8oncdl > 0:
-        lq8on = 0
-        q8oncdl = q8oncdl - 1
-        own["Q8oncdl"] = q8oncdl
-    #lq2
-    if lUD < -.04 and lLR > 0.04:
-        lq2on = 1
-        q2oncdl = countdown
-        own["Q2oncdl"] = q2oncdl
-    elif q2oncdl > 0:
-        lq2on = 0
-        q2oncdl = q2oncdl - 1
-        own["Q2oncdl"] = q2oncdl
-    #q4
-    if lUD > 0.04 and lLR > 0.04:
-        lq4on = 1
-        q4oncdl = countdown
-        own["Q4oncdl"] = q4oncdl
-    elif q4oncdl > 0:
-        lq4on = 0
-        q4oncdl = q4oncdl - 1
-        own["Q4oncdl"] = q4oncdl
-    #q5
-    if lUD > .070 and lq4on == 0 and lq6on == 0:
-        lq5on = 1
-        q5oncdl = countdown
-        own["Q5oncdl"] = q5oncdl
-    elif q5oncdl > 0:
-        lq5on = 0
-        q5oncdl = q5oncdl - 1
-        own["Q5oncdl"] = q5oncdl
-    #q1
-    if lUD < -0.070 and lq8on != 1 and lq2on != 1:
-        lq1on = 1
-        q1oncdl = countdown
-        own["Q1oncdl"] = q1oncdl
-    elif q1oncdl > 0:
-        lq1on = 0
-        q1oncdl = q1oncdl - 1
-        own["Q1oncdl"] = q1oncdl
-    #q7
-    if lLR < -0.070 and lq8on != 1 and lq6on != 1:
-        lq7on = 1
-        q7oncdl = countdown
-        own["Q7oncdl"] = q7oncdl
-    elif q7oncdl > 0:
-        lq7on = 0
-        q7oncdl = q7oncdl - 1
-        own["Q7oncdl"] = q7oncdl
-    #q3
-    if lLR > 0.070 and lq2on != 1 and lq4on != 1:
-        lq3on = 1
-        q3oncdl = countdown
-        own["Q3oncdl"] = q3oncdl
-    elif q3oncdl > 0:
-        lq3on = 0
-        q3oncdl = q3oncdl - 1
-        own["Q3oncdl"] = q3oncdl
-
+    
     own['set_revert_timer'] = 0
     ground_since = own["framenum"] - own['lF_air_frame']
     if (ground_since > 80 and frames_since_grinding > 40) and ((rLR > -turnsens and rLR < turnsens and rUD > -turnsens and rUD < turnsens) or own['manual'] == 1):
 
-        if q3oncdl < q4oncdl < q5oncdl < q6oncdl < q7oncdl:
+        if sl.q3 < sl.q4 < sl.q5 < sl.q6 < sl.q7:
             if onGround:
                 revert()
+                sl.reset()
                 own['set_revert_timer'] = 1
-        if q3oncdl > q4oncdl > q5oncdl > q6oncdl > q7oncdl:
+        if sl.q3 > sl.q4 > sl.q5 > sl.q6 > sl.q7:
             if onGround:
                 revert2()
+                sl.reset()
                 own['set_revert_timer'] = 1
-        if q7oncdl < q8oncdl < q1oncdl < q2oncdl < q3oncdl:
+        if sl.q7 < sl.q8 < sl.q1 < sl.q2 < sl.q3:        
             if onGround:
                 revert3()
                 own['set_revert_timer'] = 1
-        if q7oncdl > q8oncdl > q1oncdl > q2oncdl > q3oncdl:
+                sl.reset()
+        if sl.q7 > sl.q8 > sl.q1 > sl.q2 > sl.q3:
             if onGround:
                 revert4()
                 own['set_revert_timer'] = 1
-    ################
-    #q6
-    if rUD > .04 and rLR < -0.04:
-        q6on = 1
-        q6oncd = countdown
-        own["Q6oncd"] = q6oncd
-        #print("q6on")
-    elif q6oncd > 0:
-        q6on = 0
-        q6oncd = q6oncd - 1
-        own["Q6oncd"] = q6oncd
-
-    #q8
-    if rUD < -.04 and rLR < -0.04:
-        q8on = 1
-        q8oncd = countdown
-        own["Q8oncd"] = q8oncd
-        #print("q8on")
-    elif q8oncd > 0:
-        q8on = 0
-        q8oncd = q8oncd - 1
-        own["Q8oncd"] = q8oncd
-    #q2
-    if rUD < -.04 and rLR > 0.04:
-        q2on = 1
-        q2oncd = countdown
-        own["Q2oncd"] = q2oncd
-        #print("q2on")
-    elif q2oncd > 0:
-        q2on = 0
-        q2oncd = q2oncd - 1
-        own["Q2oncd"] = q2oncd
-
-    #q4
-    if rUD > 0.04 and rLR > 0.04:
-        q4on = 1
-        q4oncd = countdown
-        own["Q4oncd"] = q4oncd
-        #print("q4on")
-    elif q4oncd > 0:
-        q4on = 0
-        q4oncd = q4oncd - 1
-        own["Q4oncd"] = q4oncd
-    #q5
+                sl.reset()
+
     if rUD > .070 or dict['kb_space'] == 2:
-        if q4on == 0 and q6on == 0:
-            #print("q5on")
-            q5on = 1
-            q5oncd = countdown
-            own["Q5oncd"] = q5oncd
         oposin()
-        #print('oposin')
     ground_since = own["framenum"] - own['lF_air_frame']
     if ((rTrig > 0.02 or dict['kb_lsh'] == 2) and GRAB_ON == False and onGround) or (lTrig > 0.02 and GRAB_ON == False and onGround) and ground_since > 10:
         pump()
                 if jumpstance == 1:
                     grindtype("fak_tailg")
 
-    if q5oncd > 0:
-        q5on = 0
-        q5oncd = q5oncd - 1
-        own["Q5oncd"] = q5oncd
+    #if q5oncd > 0:
+    if sl.q5 > 0:
         own["last_Opos"] = False
     #q1
     if rUD < -0.070:
-        if q2on == 0 and q8on == 0:
-            #print("q1on")
-            q1on = 1
-            q1oncd = countdown
-            own["Q1oncd"] = q1oncd
         noposin()
     if rUD < -0.020 and grindHit == True:
         grindpos = own['grindpos']
         jumpstance = own["jump_stance"]
         if LAST_GRIND == False:
             if grindpos == "reg_5050":
-                #print("nose something")
                 if jumpstance != 3:
                     if jumpstance == 0:
                         if rLR > .02:
         if own['grindpos'] == 'fak_5050':
             grindtype("fak_5050")
 
-    if q1oncd > 0:
-        q1on = 0
-        q1oncd = q1oncd - 1
-        own["Q1oncd"] = q1oncd
+    if sl.q1 > 0:
         own["last_nOpos"] = False
-    #q7
-    if rLR < -0.070:
-        if q8on == 0 and q6on == 0:
-            q7on = 1
-            q7oncd = countdown
-            own["Q7oncd"] = q7oncd
-    elif q7oncd > 0:
-        q7on = 0
-        q7oncd = q7oncd - 1
-        own["Q7oncd"] = q7oncd
-    #q3
-    if rLR > 0.070:
-        if q4on == 0 and q2on == 0:
-            q3on = 1
-            q3oncd = countdown
-            own["Q3oncd"] = q3oncd
-            #print("q3on")
-    elif q3oncd > 0:
-        q3on = 0
-        q3oncd = q3oncd - 1
-        own["Q3oncd"] = q3oncd
 
 ###keyboard fliptricks
     if dict['kb_space'] == 3:
 ##########################################
     #trick calls
 ##########################################
-
+    
     # hard flip
     # 6 > 5 > 8
-    if q6oncd > 0 and q5oncd > 0 and q8oncd > 0 and q6oncd <= q5oncd <= q8oncd:
-        print ("Hardflip")
+    if sr.q6 > 0 and sr.q5 > 0 and sr.q8 > 0 and sr.q6 <= sr.q5 <= sr.q8:   
+        print ("Hardflip --- 2")
         dict['trick_string'] = 'Hardflip'
         hardflip()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
 
     # inward heelflip
     # 4 > 5 > 2
-    if q4oncd > 0 and q5oncd > 0 and q2oncd > 0 and q4oncd <= q5oncd <= q2oncd:
-        print ("Inward Heelflip")
-        dict['trick_string'] = 'Inward Heelflip'
+    if sr.q4 > 0 and sr.q5 > 0 and sr.q2 > 0 and sr.q4 <= sr.q5 <= sr.q2:
         inward_heelflip()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
 
     # nollie hard flip
     # 8 > 1 > 6
-    if q8oncd > 0 and q1oncd > 0 and q6oncd > 0 and q8oncd <= q1oncd <= q6oncd:
-        print ("Nollie Hardflip")
-        dict['trick_string'] = 'Nollie Hardflip'
+    if sr.q8 > 0 and sr.q1 > 0 and sr.q6 > 0 and sr.q8 <= sr.q1 <= sr.q6:
         nollie_hardflip()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
 
     # nollie inward heelflip
     # 2 > 1 > 4
-    if q2oncd > 0 and q1oncd > 0 and q4oncd > 0 and q2oncd <= q1oncd <= q4oncd:
-        print ("Nollie Inward Heelflip")
-        dict['trick_string'] = 'Nollie Inward Heelflip'
+    if sr.q2 > 0 and sr.q1 > 0 and sr.q4 > 0 and sr.q2 <= sr.q1 <= sr.q4:
         nollie_inward_heelflip()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
 
     #nollie 360 shuvit
-    if q7oncd > 0 and q8oncd > 0 and q1oncd > 0 and q2oncd > 0 and q3oncd > 0 and q7oncd <= q8oncd <= q1oncd <= q2oncd <= q3oncd:
-        print ("Nollie 360 shuvit")
-        dict['trick_string'] = 'Nollie 360 shuvit'
+    if sr.q7 > 0 and sr.q8 > 0 and sr.q1 > 0 and sr.q2 > 0 and sr.q3 > 0 and sr.q7 <= sr.q8 <= sr.q1 <= sr.q2 <= sr.q3:
         nollie_shuvit360()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
+        print('*nollie 360 shuvit')
 
     #nollie fs 360 shuvit
-    if q7oncd > 0 and q8oncd > 0 and q1oncd > 0 and q2oncd > 0 and q3oncd > 0 and q3oncd <= q2oncd <= q1oncd <= q8oncd <= q7oncd:
-        #print("q4oncd: ", q4oncd, " q5oncd: ", q5oncd, " q6oncd: ", q6oncd)
-        print ("Nollie Front Side 360 shuvit")
-        dict['trick_string'] = 'Nollie FS 360 shuvit'
+    if sr.q7 > 0 and sr.q8 > 0 and sr.q1 > 0 and sr.q2 > 0 and sr.q3 > 0 and sr.q3 <= sr.q2 <= sr.q1 <= sr.q8 <= sr.q7:
         nollie_fsshuvit360()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
+        print('*nollie fs 360 shuvit')
 
     # varial heelflip
     # 7 < 6 < 2
-    if q7oncd > 0 and q6oncd > 0 and q2oncd > 0 and q7oncd < q6oncd < q2oncd:
-        dict['trick_string'] = 'Varial Heelflip'
+    if sr.q7 > 0 and sr.q6 > 0 and sr.q2 > 0 and sr.q7 <= sr.q6 <= sr.q2:
         varial_heelflip()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
 
     # varial kickflip
     # 3 < 4 < 8
-    if q3oncd > 0 and q4oncd > 0 and q8oncd > 0 and q3oncd < q4oncd < q8oncd:
-        dict['trick_string'] = 'Varial Kickflip'
+    if sr.q3 > 0 and sr.q4 > 0 and sr.q8 > 0 and sr.q3 <= sr.q4 <= sr.q8: 
         varial_kickflip()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
 
     # nollie varial kickflip
     # 3 < 2 < 6
-    if q3oncd > 0 and q2oncd > 0 and q6oncd > 0 and q3oncd <= q2oncd <= q6oncd:
-        dict['trick_string'] = 'Nollie Varial Kickflip'
-        print('Nollie Varial Kickflip')
+    if sr.q3 > 0 and sr.q2 > 0 and sr.q6 > 0 and sr.q3 <= sr.q2 <= sr.q6:
         nollie_varial_kickflip()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
 
     # nollie varial heelflip
     # 7 < 8 < 4
-    if q7oncd > 0 and q8oncd > 0 and q4oncd > 0 and q7oncd <= q8oncd <= q4oncd:
-        dict['trick_string'] = 'Nollie Varial Heelflip'
-        print('Nollie Varial Heelflip')
+    if sr.q7 > 0 and sr.q8 > 0 and sr.q4 > 0 and sr.q7 <= sr.q8 <= sr.q4: 
         nollie_varial_heelflip()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
 
     #360 shuvit
-    if q3oncd > 0 and q4oncd > 0 and q5oncd > 0 and q6oncd > 0 and q7oncd > 0 and q7oncd >= q6oncd >= q5oncd >= q4oncd >= q3oncd:
-    #    print("q4oncd: ", q4oncd, " q5oncd: ", q5oncd, " q6oncd: ", q6oncd)
-        #print ("______-------360 shuvit")
-        dict['trick_string'] = '360 shuvit'
+    if sr.q3 > 0 and sr.q4 > 0 and sr.q5 > 0 and sr.q6 > 0 and sr.q7 > 0 and sr.q7 <= sr.q6 <= sr.q5 <= sr.q4 <= sr.q3:
         shuvit360()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
 
     #360 fs shuvit
-    if q3oncd > 0 and q4oncd > 0 and q5oncd > 0 and q6oncd >= 0 and q7oncd > 0 and q7oncd <= q6oncd <= q5oncd <= q4oncd <= q3oncd:
-        dict['trick_string'] = '360 Frontside shuvit'
+    if sr.q3 > 0 and sr.q4 > 0 and sr.q5 > 0 and sr.q6 > 0 and sr.q7 > 0 and sr.q7 <= sr.q6 <= sr.q5 <= sr.q4 <= sr.q3:
         fsshuvit360()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
 
     #ollie
-    if q5oncd > 0 and q1oncd > 0 and q5oncd < q1oncd:
-        JUMPSTRENGTH = q1oncd - q5oncd
-        #4,7
-        if JUMPSTRENGTH <= 4:
-            JUMPSTRENGTH = 1.1
-        if JUMPSTRENGTH > 4 and JUMPSTRENGTH < 7:
-            JUMPSTRENGTH = 1
-        if JUMPSTRENGTH >= 7:
-            JUMPSTRENGTH = .9
+    if sr.q5 > 0 and sr.q1 > 0 and sr.q5 < sr.q1:
         aollie()
-        #varial_heelflip()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()        
+
     #nollie
-    if q5oncd > 0 and q1oncd > 0 and q5oncd > q1oncd:
-        JUMPSTRENGTH = q5oncd - q1oncd
-        #4,7
-        if JUMPSTRENGTH <= 4:
-           JUMPSTRENGTH = 1.1
-        if JUMPSTRENGTH > 4 and JUMPSTRENGTH < 7:
-           JUMPSTRENGTH = 1
-        if JUMPSTRENGTH >= 7:
-           JUMPSTRENGTH = .9
+    if sr.q5 > 0 and sr.q1 > 0 and sr.q5 < sr.q1:
         nollie()
-        reset_rtimers()
-        print("nollie")
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
+
     #kickflip
-    if q5oncd > 0 and q8oncd > 0 and q5oncd < q8oncd and q3oncd < 1:
+    if sr.q5 > 0 and sr.q8 > 0 and sr.q5 < sr.q8:
         kickflip()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
+
     #nollie kickflip
-    if q1oncd > 0 and q6oncd > 0 and q1oncd < q6oncd:
+    if sr.q1 > 0 and sr.q6 > 0 and sr.q2 < sr.q6:
         nollie_kickflip()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
+
     #heelflip
-    if q5oncd > 0 and q2oncd > 0 and q5oncd < q2oncd:
+    if sr.q5 > 0 and sr.q2 > 0 and sr.q5 < sr.q2:
         heelflip()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
+
     #nollie_heelflip
-    if q1oncd > 0 and q4oncd > 0 and q1oncd < q4oncd:
+    if sr.q1 > 0 and sr.q4 > 0 and sr.q1 < sr.q4:
         nollie_heelflip()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
 
     #shuvit
-    if q7oncd > 0 and q5oncd > 0 and q6oncd > 0 and q5oncd <= q6oncd <= q7oncd:# and q3oncd < 1:
+    if sr.q7 > 0 and sr.q5 > 0 and sr.q6 > 0 and sr.q5 <= sr.q6 <= sr.q7:
         shuvit()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
+
     #nollie_shuvit
-    if q7oncd > 0 and q1oncd > 0 and q8oncd > 0 and q1oncd <= q8oncd <= q7oncd:# and q3oncd == 0:
+    if sr.q7 > 0 and sr.q1 > 0 and sr.q8 > 0 and sr.q1 <= sr.q8 <= sr.q7:
         nollie_shuvit()
-        print('nollie shuvit')
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
+        print('*nollie shuvit')
+
     #fsshuvit
-    if q4oncd > 0 and q5oncd > 0 and q3oncd > 0 and q5oncd <= q4oncd <= q3oncd:# and q7oncd < 1:
+    if sr.q4 > 0 and sr.q5 > 0 and sr.q3 > 0 and sr.q5 <= sr.q4 <= sr.q3:
         fsshuvit()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
+
     #nollie_fsshuvit
-    if q3oncd > 0 and q1oncd > 0 and q2oncd > 0 and q1oncd <= q2oncd <= q3oncd:# and q7oncd == 0:
-        print ("nollie fsshuvit")
+    if sr.q3 > 0 and sr.q1 > 0 and sr.q2 > 0 and sr.q1 <= sr.q2 <= sr.q3:
         nollie_fsshuvit()
-        reset_rtimers()
-        q1oncd = 0
-        q2oncd = 0
-        q3oncd = 0
-        q4oncd = 0
-        q5oncd = 0
-        q6oncd = 0
-        q7oncd = 0
-        q8oncd = 0
+        sr.reset()
+        print('*nollie fs shuvit')
 
     def hippy_jump():
         STANCE = own["stance"]
             if 'reg' in own['l_actionState']:
                 STANCE = 0
             if own['grindpos'] == 'reg_5050':
-                if lq3on == 1 or lq2on or dict['kb_ra'] == 2:
+                if sl.q3 >= countdown or sl.q2 >= countdown or dict['kb_ra'] == 2:
+                #if lq3on == 1 or lq2on or dict['kb_ra'] == 2:
                     if own['gt_cd2'] == 0:
                         own['gt_cd2'] = 60
 
                         if own['grind_out_type'] == None:
                             own['grind_out_type'] = 'reg right'
                     own["grindoutturn"] = gotcd
-                if lq7on == 1 or lq8on or dict['kb_la'] == 2:
+                if sl.q7 >= countdown or sl.q8 >= countdown or dict['kb_la'] == 2:
+                #if lq7on == 1 or lq8on or dict['kb_la'] == 2:
                     if own['gt_cd2'] == 0:
                         own['gt_cd2'] = 60
                     if STANCE == True:
                         if own['grind_out_type'] == None:
                             own['grind_out_type'] = 'reg left'
                     own["grindoutturn"] = gotcd
-                if lq4on == 1:
+                #if lq4on == 1:
+                if sl.q4 >= countdown:   
                     if own['gt_cd2'] == 0:
                         own['gt_cd2'] = 60
                     if STANCE == True:
                         if own['grind_out_type'] == None:
                              own['grind_out_type'] = 'reg fak right'
                     own["grindoutturn"] = gotcd
-                if lq6on == 1:
+                #if lq6on == 1:
+                if sl.q6 >= countdown:
                     if own['gt_cd2'] == 0:
                         own['gt_cd2'] = 60
                     if STANCE == True:
                 outact.dRot = [0, 0, 0]
 
 
-                if lq5on == 1 or dict['kb_da'] == 2:
+                #if lq5on == 1 or dict['kb_da'] == 2:
+                if sl.q5 >= countdown or dict['kb_da'] == 2:
                     if own['gt_cd2'] == 0:
                         own['gt_cd2'] = 60
                     if STANCE == True:
                         print('board out')
                     own["grindoutturn"] = gotcd
                     own['invert_on'] = 0
-                if lq1on == 1 or dict['kb_ua'] == 2:
+                if sl.q1 >= countdown or dict['kb_ua'] == 2:
+                #if lq1on == 1 or dict['kb_ua'] == 2:
                     if own['gt_cd2'] == 0:
                         own['gt_cd2'] = 60
                     if STANCE == True:
                         #own.applyRotation((0, -.15, 0), True)
                     own["grindoutturn"] = gotcd
                     own['invert_on'] = 0
-            if lq1on or lq2on or lq3on or lq4on or lq5on or lq6on or lq7on or lq8on:
+            #if lq1on or lq2on or lq3on or lq4on or lq5on or lq6on or lq7on or lq8on:
+            if sl.q1 >= countdown or sl.q2 >= countdown or sl.q3 >= countdown or sl.q4 >= countdown or sl.q5 >= countdown or sl.q6 >= countdown or sl.q7 >= countdown:
                 gt_cd = own['gt_cd']
                 if gt_cd == 0:
                     gt_cd = 30
 
     def shutoff_timers():
         if (LAST_GRIND == False and grindHit == True) or (jump_timer > 10 and own['wallride'] == None):
-            own["Q1oncd"] = 0
-            own["Q2oncd"] = 0
-            own["Q3oncd"] = 0
-            own["Q4oncd"] = 0
-            own["Q5oncd"] = 0
-            own["Q6oncd"] = 0
-            own["Q7oncd"] = 0
-            own["Q8oncd"] = 0
+            sr.reset()
+            sl.reset()
 
     def grindout_cleanup():
         lgf = own['last_grind_frame']

scripts/joytimers.py

+#joytimers.py
+import bge
+countdown = 20
+
+def main(own):
+	
+	class stick:
+		def __init__(self, ud, lr):
+			self.q1 = 0
+			self.q2 = 0
+			self.q3 = 0
+			self.q4 = 0
+			self.q5 = 0
+			self.q6 = 0
+			self.q7 = 0
+			self.q8 = 0
+			self.ud = ud
+			self.lr = lr
+			self.qs = ['q6', 'q8', 'q2', 'q4', 'q5', 'q1', 'q3', 'q7']
+
+		def reset(self):
+			self.q1 = 0
+			self.q2 = 0
+			self.q3 = 0
+			self.q4 = 0
+			self.q5 = 0
+			self.q6 = 0
+			self.q7 = 0
+			self.q8 = 0			
+	
+		def update(self):
+			dict = bge.logic.globalDict
+	
+			def q6(val):
+				if dict[self.ud] > .04 and dict[self.lr] < -0.04:
+					return countdown
+				
+			def q8(val):
+				if dict[self.ud] < -.04 and dict[self.lr] < -0.04:
+					return countdown
+								
+			def q2(val):
+				if dict[self.ud] < -.04 and dict[self.lr] > 0.04:
+					return countdown
+
+			def q4(val):
+				if dict[self.ud] > .04 and dict[self.lr] > 0.04:
+					return countdown		
+
+			def q5(val):
+				if dict[self.ud] > .07 and self.q4 is not countdown and self.q6 is not countdown:
+					return countdown		
+
+			def q1(val):
+				if dict[self.ud] < -.07 and self.q8 is not countdown and self.q2 is not countdown:
+					return countdown		
+
+			def q3(val):
+				if dict[self.lr] > .07 and self.q2 is not countdown and self.q4 is not countdown:
+					return countdown				
+
+			def q7(val):
+				if dict[self.lr] < -.07 and self.q6 is not countdown and self.q8 is not countdown:
+					return countdown		
+
+			for cur_q in self.qs:
+				val = getattr(self, cur_q)
+				v2 = locals()[cur_q](val)
+				if v2 is not None:
+					setattr(self, cur_q, v2) 
+				elif val > 0:
+					setattr(self, cur_q, val - 1) 
+
+	if 'jt_inited' not in own:
+		own['jt_inited'] = True
+		own['jsl'] = stick('lUD', 'lLR')
+		own['jsr'] = stick('rUD', 'rLR')
+
+	own['jsl'].update()	
+	own['jsr'].update()