cam_linting

assets/kits/base_kit.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:e1d3fa914e577d76f1aafa98bb2c4eb255af844b759d277c13d8d075a28d3dff
-size 20186144
+oid sha256:62549263728c2ef7660fbcdce7d2b5b9619860e5d4627d6610562078ce8e1891
+size 26221544

assets/materials/base_m_kit.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:da2b7a5bdd1d133e398ceb3abdfaeca7d98b3f1092ef55adf0589756a1528a5a
-size 18290540
+oid sha256:50c185109ee56fcb1bbbba94987bdd7ae0ea73ab2e35ad91a7af8b0a758a57f6
+size 22674664

assets/user2.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:6bfcbe11735b600e9920ff042ea0093c974a8f42f8a66943da148a70b178a8ed
-size 36542248
+oid sha256:5463f5a80d4070c362d7d2b03aaab46ee722af0993cade6b8f3961187adbb1f2
+size 36552232

scripts/camera.py

 from mathutils import *
 scene = bge.logic.getCurrentScene()
 import camFSM
-#cont = bge.logic.getCurrentController()
-#own = cont.owner
+
 def main(cont):
     #camFSM.main(cont)
     own = cont.owner
-    dict = bge.logic.globalDict 
+    dict = bge.logic.globalDict
     camempty = scene.objects['camEmpty.001']
     controlcube = scene.objects['control_cube.002']
-    
     camCube = scene.objects['camCube']
-    
     dropinCol = controlcube.sensors['dropinCol']
     LAST_GRIND = controlcube['LAST_GRIND']
     up = cont.sensors['up']
     cam = cont.actuators["Camera"]
     near = cont.sensors["Near"]
     move = own.actuators["move"]
-    #match camera actuaotor
-    cam_def_height = dict['cam_height'] #-.1 #-.6
-    #cam_def_min = 1.6
-    #cam_def_max = 2.4
+    cam_def_height = dict['cam_height']
     cam_def_min = dict['cam_min']
     cam_def_max = dict['cam_max']
-    cam_height = cam.height 
-    cam_min = cam.min   
+    cam_height = cam.height
+    cam_min = cam.min
     cam_max = cam.max
     lasty = controlcube['lasty']
     cam_moved = 0
     ccheight = controlcube.worldPosition[2]
     camwpz = own.worldPosition[2]
     zdist = camwpz - ccheight
-    
     cam1 = scene.objects['Camera.003']
     cam2 = scene.objects['freecam']
     cam3 = scene.objects['followcam']
-    
     camList = scene.cameras
-    freecam = camList["freecam"]     
-    
+    freecam = camList["freecam"]
+
     if 'init' not in own:
         own['init'] = 1
         own['last_move_x'] = 0
         own['last_rot_y'] = 0
         own['last_rot_z'] = 0
         own['idlecampos_x'] = 0
-        own['speed_mult'] = 1.00 
-        controlcube['driving'] = False  
+        own['speed_mult'] = 1.00
+        controlcube['driving'] = False
         dict['cur_ccH_min'] = dict['cam_walk_min']
         dict['cur_ccH_max'] = dict['cam_walk_max']
         cam.height = dict['cam_height']
     acam = scene.active_camera
 
-
-    
-    #if 1 == 1:
-    #if own['playback'] == False:
     if controlcube['driving'] == False:
         LAST_GRIND = False
         if down.triggered == True and LAST_GRIND == False and walk == 0:
             hitPosition = down.hitPosition
             distance = own.getDistanceTo(hitPosition)
-            cam_moved = 1  
-            if 'vert' not in down.hitObject:     
+            cam_moved = 1
+            if 'vert' not in down.hitObject:
                 if distance < .2:
                     camempty['hitdown'] = True
                     cam.height = cam_height + .3
-                    cam.damping = .0 
+                    cam.damping = .0
                     print("raise cam")
                 if zdist < -.2:
                     cam.height = lastCamheight + .01
                     cam.damping = .0
-                    raised = 1    
+                    raised = 1
                 if (distance > .4 and distance < .6) and zdist > -.2 and raised == 0:
                     camheight2 = cam.height - .001
-                    if cam.height < .2: 
+                    if cam.height < .2:
                         cam.height = camheight2
-                        #print("slow lower")
                 if distance >= .6 and zdist > -.2 and raised == 0:
                     cam.height = cam.height - .02
-                    #print("slow lower2")           
         if down.triggered == False and LAST_GRIND == False and cam_moved == 0 and walk == 0:
             camempty['hitdown'] = False
             if cam_height > (cam_def_height + .06) and zdist > -.2 and raised == 0:
                 cam.height = cam_height - .02
         if cam_height < -.6 and cam_moved == 0 and LAST_GRIND == False and zdist > -.2 and raised == 0 and walk == 0:
-            cam_height = .1  
+            cam_height = .1
         if LAST_GRIND == True and walk == 0:
             if cam.height < -.5 or zdist < -.2:
                 cam.height = cam.height + .013
             if cam.height >= -.5 and not down.triggered:
                 pass
-        
+
         if walk == 1:
             if dropinCol.positive == True and lasty == True:
-                pass 
+                pass
             else:
-                pass   
-        controlcube['lastCamheight'] = cam.height    
-        #########
-        #cam.min = dict['cam_min']
-        #cam.max = dict['cam_max']
-        cont.activate(own.actuators['Camera'])  
-        ########
-        
+                pass
+        controlcube['lastCamheight'] = cam.height
+        #activating######
+        cont.activate(own.actuators['Camera'])
+        #################
         if near.triggered == True and walk == 0:
             #print("near")
             if cam.min < 1:
             print('moving cam up')
             cam.damping = .001
             cont.activate(move)
-            
+
         else:
             #print("far")
             cont.deactivate(move)
             if cam.min > cam_def_min:
                 cam.min = cam.min - .05
-                cam.max = cam.max - .05 
-            cam.damping = .0          
+                cam.max = cam.max - .05
+            cam.damping = .0
         if cam.damping != 0 and down.triggered == False and near.triggered == False:
-            cam.damping = 0.91             
+            cam.damping = 0.91
 
         obj = cont.owner
         cube = controlcube
         to = cube
-        #print(to.worldPosition)
         to2 = to.worldPosition
         pos = [to.worldPosition.x, to.worldPosition.y, to.worldPosition.z]
-        
         pos[2] = pos[2] - .2
-        #print(pos)
-
         from2 = obj
-        #print(from2)
         from3 = [from2.worldPosition.x, from2.worldPosition.y, from2.worldPosition.z]
         from3[2] = from3[2] - .2
         distance = 0.0
         xray = 0
         poly = 0
         hit = obj.rayCast( pos, from3, distance, property, face, xray, poly)
-        #bge.render.drawLine(pos,from3, [1,0,0])
         control = "control_cube.002"
         hitobj = hit[0]
         hitobj = str(hitobj)
+        if 'ragdoll_active' not in controlcube:
+            controlcube['ragdoll_active'] = False
         if hit[0]:
             if hitobj != control and walk == 0 and 'vert' not in hit[0] and 'ground' in hit[0] and controlcube['ragdoll_active'] == False:
-                
-                cam.damping = .0 
+                cam.damping = .0
                 if cam.height < 2:
                     cam.height = cam_height + .1
                     cam.max = cam.max - .2
                     print('small move')
                 elif cam.height >= 2 and cam.height < 4:
                     cam.height = cam_height + .05
-                    cam.max = cam.max - .05                
+                    cam.max = cam.max - .05
                     print('big move')
-        
+
     if dict['menu_idle_timer'] > 300:
         move_len = 2048
         if own['idlecampos_x'] < move_len:
             own['idlecampos_x'] += 1
         if own['idlecampos_x'] == move_len:
-           own['idlecampos_x'] = 0     
-            
+           own['idlecampos_x'] = 0
+
         if own['idlecampos_x'] < (move_len / 2):
             move = [.0001, 0, 0]
             freecam.applyMovement( move, True)
-            freecam.applyRotation([.0001, 0, .0001],True)
+            freecam.applyRotation([.0001, 0, .0001], True)
         if own['idlecampos_x'] > (move_len / 2):
             move = [-.0001, 0, 0]
-            freecam.applyMovement( move, True)
-            freecam.applyRotation([-.0001, 0, -.0001],True)        
-        
+            freecam.applyMovement(move, True)
+            freecam.applyRotation([-.0001, 0, -.0001], True)
+
     if dict['npause'] == True:
         cont.deactivate(own.actuators['Camera'])
         controlcube['camera'] = 2
     if controlcube['camera'] == 2 and dict['joy_con'] == 1:
         cont.deactivate(own.actuators['Camera'])
-        scene.active_camera = freecam 
-        cont.activate(cube.actuators['freecam']) 
-        #print('activating camera', freecam)  
-#####        
-    #get value 0-100    
+        scene.active_camera = freecam
+        cont.activate(cube.actuators['freecam'])
         lLR = dict['lLR'] / .082 * 100
         lUD = dict['lUD'] / .082 * 100 - 20 / 80
         rLR = dict['rLR'] / .082 * 100 - 20 / 80
         rUD = dict['rUD'] / .082 * 100 - 20 / 80
         lTrig = dict['lTrig'] / .082 * 100 - 20 / 80
         rTrig = dict['rTrig'] / .082 * 100 - 20 / 80
-#        lBump = dict['lBump']
-#        rBump = dict['rBump']
-        
+
         if lLR < -20:
-            lmLR = round((lLR + 20) / 80 * 100, 0) 
+            lmLR = round((lLR + 20) / 80 * 100, 0)
         elif lLR > 20:
             lmLR = round((lLR - 20) / 80 * 100, 0)
-        else: lmLR = 0  
-              
+        else: lmLR = 0
+
         if lUD > 20:
             lmUD = round((lUD - 20) / 80 * 100, 0)
         elif lUD < -20:
             lmUD = round((lUD + 20) / 80 * 100, 0)
-        else: lmUD = 0 
+        else: lmUD = 0
 
         if rLR < -20:
             rmLR = round((rLR + 20) / 80 * 100, 0)
         elif rLR > 20:
             rmLR = round((rLR - 20) / 80 * 100, 0)
-        else: rmLR = 0         
-        
+        else: rmLR = 0
+
         if rUD > 20:
             rmUD = round((rUD - 20) / 80 * 100, 0)
         elif rUD < -20:
             rmUD = round((rUD + 20) / 80 * 100, 0)
-        else: rmUD = 0 
-      
+        else: rmUD = 0
+
         if lTrig > 3:
             mTrig = lTrig * -1
         elif rTrig > 3:
-            mTrig = rTrig    
+            mTrig = rTrig
         else: mTrig = 0
 
         #move camera
         move_x = lmUD * mult
         move_y = lmLR * mult
         move_z = (mTrig * -mult) / 2#4
-        
+
         rot_mult = -.00015 * own['speed_mult']
         rot_x = rmUD * rot_mult
         rot_y = rmLR * rot_mult
-        
+
         if move_x == 0 and own['last_move_x'] != 0:
             move_x = own['last_move_x'] * damping
         if move_y == 0 and own['last_move_y'] != 0:
-            move_y = own['last_move_y'] * damping 
+            move_y = own['last_move_y'] * damping
         if move_z == 0 and own['last_move_z'] != 0:
-            move_z = own['last_move_z'] * damping         
+            move_z = own['last_move_z'] * damping
         if rot_x == 0 and own['last_rot_x'] != 0:
             rot_x = own['last_rot_x'] * damping
         if rot_y == 0 and own['last_rot_y'] != 0:
-            rot_y = own['last_rot_y'] * damping         
-                             
+            rot_y = own['last_rot_y'] * damping
+
         move = [move_y, 0, move_x]
-        freecam.applyMovement( move, True)
-        freecam.applyMovement([0, 0, move_z], False)    
-        freecam.applyRotation([rot_x, 0, 0],True)
-        freecam.applyRotation([0, 0, rot_y],False)
-       
-        
-################    
-    #print(dict['walk'], 'walk')
+        freecam.applyMovement(move, True)
+        freecam.applyMovement([0, 0, move_z], False)
+        freecam.applyRotation([rot_x, 0, 0], True)
+        freecam.applyRotation([0, 0, rot_y], False)
+
+
+################
     multer = .02
-    if dict['walk'] == 1 and controlcube['ragdoll_active'] == False:
+    if dict['walk'] == 1 and not controlcube['ragdoll_active']:
         if dict['cur_ccH_targetHeight'] < dict['cam_walk_height']:
             dist = dict['cam_walk_height'] - dict['cur_ccH_targetHeight']
-            
+
             dict['cur_ccH_targetHeight'] = dict['cur_ccH_targetHeight'] + (dist * multer)
             if dict['cur_ccH_targetHeight'] > dict['cam_walk_height']:
                 dict['cur_ccH_targetHeight'] = dict['cam_walk_height']
-                
-        cam.min = dict['cam_walk_min'] 
-        cam.max = dict['cam_walk_max'] 
 
-        #print('walk cam')       
-        #ccH_targetHeight = .9
-    else:  
+        cam.min = dict['cam_walk_min']
+        cam.max = dict['cam_walk_max']
+
+    else:
 
         if dict['cur_ccH_targetHeight'] < dict['cch_targetHeight']:
             dist = dict['cur_ccH_targetHeight'] - dict['cch_targetHeight']
             dict['cur_ccH_targetHeight'] = dict['cur_ccH_targetHeight'] - (dist * multer)
             if dict['cur_ccH_targetHeight'] > dict['cch_targetHeight'] - .001:
-                dict['cur_ccH_targetHeight'] = dict['cch_targetHeight']             
+                dict['cur_ccH_targetHeight'] = dict['cch_targetHeight']
 
         if dict['cur_ccH_targetHeight'] > dict['cch_targetHeight']:
-            dist = dict['cch_targetHeight'] - dict['cur_ccH_targetHeight'] 
+            dist = dict['cch_targetHeight'] - dict['cur_ccH_targetHeight']
             dict['cur_ccH_targetHeight'] = dict['cur_ccH_targetHeight'] + (dist * multer)
             if dict['cur_ccH_targetHeight'] < dict['cch_targetHeight'] + .001:
-                dict['cur_ccH_targetHeight'] = dict['cch_targetHeight']             
-        
-        
-    ccH_targetHeight = dict['cur_ccH_targetHeight']  
-    #print(dict['cur_ccH_targetHeight'])    
-    #dict['cur_ccH_targetHeight'] =            
-    #ccH_targetHeight = .3
+                dict['cur_ccH_targetHeight'] = dict['cch_targetHeight']
+
+
+    ccH_targetHeight = dict['cur_ccH_targetHeight']
+
     ccH = camCube.worldPosition.z
     pH = camCube.parent.worldPosition.z
     ccheight = (round((ccH - pH), 2) - .4)
-    #print(ccheight, 'camera target height')
-    
+
     localPos = camCube.localPosition.z
-    #print(localPos, 'local position')
     if localPos != ccH_targetHeight:
         num = ccH_targetHeight - localPos
         camCube.localPosition.z += num
     #if camHeightSet not in own:
-    if 1 == 1:    
+    if 1 == 1:
         num = ccH_targetHeight - ccheight
     else:
-        own['camHeightSet'] = True    
-    try:       
+        own['camHeightSet'] = True
+    try:
         if dict['npause'] == False and controlcube['ragdoll_active'] == False:
-            cont.activate(own.actuators['Camera']) 
-            controlcube['camera'] = 0    
+            cont.activate(own.actuators['Camera'])
+            controlcube['camera'] = 0
         if controlcube['ragdoll_active'] == True:
             #print('ragdoll_camera', own.actuators['Camera'].object)
             own.actuators['Camera'].object = scene.objects['ragdoll_parent']
-            cont.activate(own.actuators['Camera']) 
+            cont.activate(own.actuators['Camera'])
             controlcube['camera'] = 0
     except:
         pass
     cur_lens = cam1.lens
     cur_min = cam.min
     cur_max = cam.max
-    #print(cur_lens)
     inc = .025
     if walk == 1:
         #lens
             new_lens = cur_lens + inc
         else:
             new_lens = cur_lens - inc
-        if cur_lens  > (dict['walk_focal_length'] - .1) and cur_lens  < (dict['walk_focal_length'] + .1):
-            new_lens = dict['walk_focal_length']  
-            
-        #distance      
-        inc = .025   
+        if cur_lens > (dict['walk_focal_length'] - .1) and cur_lens < (dict['walk_focal_length'] + .1):
+            new_lens = dict['walk_focal_length']
+
+        #distance
+        inc = .025
         if cur_min > (dict['cam_walk_min'] - inc):
             new_min = cur_min - inc
         if cur_min < (dict['cam_walk_min'] + inc):
-            new_min = cur_min + inc 
+            new_min = cur_min + inc
         if cur_max > (dict['cam_walk_max'] - inc):
             new_max = cur_min - inc
         if cur_max < (dict['cam_walk_max'] + inc):
-            new_max = cur_min + inc           
+            new_max = cur_min + inc
     else:
         #lens
         if dict['focal_length'] > cur_lens:
             new_lens = cur_lens + inc
         else:
-            new_lens = cur_lens - inc 
-        if cur_lens  > (dict['focal_length'] - .1) and cur_lens  < (dict['focal_length'] + .1):
-            new_lens = dict['focal_length'] 
-            
-        #distance  
-        inc = .025   
+            new_lens = cur_lens - inc
+        if cur_lens > (dict['focal_length'] - .1) and cur_lens < (dict['focal_length'] + .1):
+            new_lens = dict['focal_length']
+
+        #distance
+        inc = .025
         if cur_min > (dict['cam_min'] - inc):
             new_min = cur_min - inc
         if cur_min < (dict['cam_min'] + inc):
-            new_min = cur_min + inc 
+            new_min = cur_min + inc
         if cur_max > (dict['cam_max'] - inc):
             new_max = cur_min - inc
         if cur_max < (dict['cam_max'] + inc):
-            new_max = cur_min + inc        
-            
-        
-            
-                                         
-        
+            new_max = cur_min + inc
+
     focallength = new_lens
     cam1.lens = focallength
     cam2.lens = focallength
     cam3.lens = focallength
     try:
         cam.min = new_min
-        cam.max = new_max  
-        #print(new_min, new_max)     
+        cam.max = new_max
     except:
-        pass    
-    
-                    
-#main()
+        pass

shuvit.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:bdeaa0427d6e0e146db9c836a1d79536092099f6776c06faae6236b91d1c00fd
-size 144952188
+oid sha256:146e177ff6c51f8476150c3ae08c0df75f7274c9893e79a4fbab99622939c07f
+size 145082860