BlenderDumbass/DanisRace
1
2
Fork 1
Code Issues 38 Pull requests Projects Releases 1 Packages Wiki Activity Actions
DanisRace/Scripts/LEGACY_Car_controll.py

1770 lines
65 KiB
Python
Raw Normal View History

07-07-24
2024-07-13 15:15:50 +02:00
import bge
import time
import math
import bpy
import random
import numpy
import aud
import mathutils
import inspect
import Reuse
import Distraction
import Opt
import Character_Controll
deleteAtDistance = 500
fixGaragePosition = [-754.61, -1043.9, 409.32]
raceNames = {"RedKissBox":"Tali",
"NeonSpeedsterBox":"Jack"}
def start_car():
# This function runs when the car is created.
# It creates the Bullet Physics RayCast Vehicle
# wrapper for the car.
# Getting basic things
cont = bge.logic.getCurrentController()
scene = bge.logic.getCurrentScene()
car = cont.owner
# Creating the vehicle constraint itself
vehicle = bge.constraints.createVehicle(car.getPhysicsId())
# Saving the ID of the constraint so we could access it later.
car["cid"] = vehicle.getConstraintId()
bge.logic.globalDict[car["cid"]] = {"wheels":[]}
###### SETTING UP WHEELS #####
# LEFT BACK
wheel0 = car.children[car.get("wheelsname", "Wheel")+""]
bge.logic.globalDict[car["cid"]]["wheels"].append(wheel0)
wheel0.removeParent()
vehicle.addWheel(wheel0,
[car.get("wheelswidth", 0.89), car.get("wheelsback", 1.65), car.get("wheelsdown", -0.1)], # Pos Local
[0, 0, -1], # Dir Local
[-1, 0, 0], # Axl Local
0.2, # Suspention length
car.get("wheelradius", 0.42), # Wheel Radius
1
)
# RIGHT BACK
wheel1 = car.children[car.get("wheelsname", "Wheel")+".001"]
bge.logic.globalDict[car["cid"]]["wheels"].append(wheel1)
wheel1.removeParent()
vehicle.addWheel(wheel1,
[-car.get("wheelswidth", 0.89), car.get("wheelsback", 1.65), car.get("wheelsdown", -0.1)], # Pos Local
[0, 0, -1], # Dir Local
[-1, 0, 0], # Axl Local
0.2, # Suspention length
car.get("wheelradius", 0.42), # Wheel Radius
1
)
# LEFT FRONT
wheel2 = car.children[car.get("wheelsname", "Wheel")+".002"]
bge.logic.globalDict[car["cid"]]["wheels"].append(wheel2)
wheel2.removeParent()
vehicle.addWheel(wheel2,
[car.get("wheelswidth", 0.89), car.get("wheelsfront", -1.25), car.get("wheelsdown", -0.1)], # Pos Local
[0, 0, -1], # Dir Local
[-1, 0, 0], # Axl Local
0.2, # Suspention length
car.get("wheelradius", 0.42), # Wheel Radius
1
)
# RIGHT FRONT
wheel3 = car.children[car.get("wheelsname", "Wheel")+".003"]
bge.logic.globalDict[car["cid"]]["wheels"].append(wheel3)
wheel3.removeParent()
vehicle.addWheel(wheel3,
[-car.get("wheelswidth", 0.89), car.get("wheelsfront", -1.25), car.get("wheelsdown", -0.1)], # Pos Local
[0, 0, -1], # Dir Local
[-1, 0, 0], # Axl Local
0.2, # Suspention length
car.get("wheelradius", 0.42), # Wheel Radius
1
)
# Setting up wheel physics characteristics.
# ( NOTE: ) This is not the only place where those are set.
# Damage and Rescue functions update those values.
car["suspensions"] = []
for i in range(4):
vehicle.setSuspensionStiffness(car.get("suspension", 200), i)
car["suspensions"].append(car.get("suspension", 200))
vehicle.setTyreFriction(car.get("friction", 1), i)
vehicle.setRollInfluence(car.get("roll", 0), i)
##### SETTING UP THE DAMAGE MODEL #####
def collision_callback(object, point, normal):
# This function will run whenever the car colides with anything.
# Dani object ( main human character )
dani = scene.objects["Dani_Box"]
toFPS = Opt.ToFPS()
# Near misses - when the player drives quickly
# near a different vehicle. If colision happens,
# near misses are canceled.
car["veryclose"] = None
# If anywhere within the proximity of the car,
# an explosion was set off ( car colided with the shockwave sphere ).
# we want to setup a timer, to blow car up in a few ticks after that.
# Doing it immediately makes the second explosion almost inconciaveable.
if object.get("explosion"):
car["blowuptimer"] = 20
# Canceling the rest of the calculation if we can't see it, or it is too far from the camera.
cam = scene.active_camera
if car.getDistanceTo("Dani_Box") > 20 or cam.pointInsideFrustum(car.worldPosition) == cam.OUTSIDE:
return
# If human pushes the car, there is no damage
if dani == object:
return
# Separation is an invisible object that bots see to navigate.
# We don't want it to cause damage.
if "Separation" in object.name:
return
#### WATER INTERACTIONS ####
if object.name == "Water":
car["underwater"] = True
if car["active"]:
dani["underwater"] = True
# Sound
device = bge.logic.globalDict["SoundDevice"]
s = "//sfx/splash.ogg"
code = s+str(car["cid"])
if code not in bge.logic.globalDict["sounds"]:
bge.logic.globalDict["sounds"][code] = {"sound":aud.Sound(bge.logic.expandPath(s)),
"play":None}
sound = bge.logic.globalDict["sounds"][code]
if not sound["play"] or not sound["play"].status:
sound["play"] = device.play(sound["sound"])
sound["play"].location = point
sound["play"].velocity = car.getLinearVelocity()
sound["play"].relative = False
sound["play"].distance_maximum = 100
sound["play"].distance_reference = 1
sound["play"].attenuation = 1
return
# Returning if performance is not good
if not Opt.GoodFPS("Car Collisions", 0.9) and not car.get("active"):
return
# Velocity of the car
cv = car.getLinearVelocity()
# Averagin the values
av = sum(cv) / 3
if av < 0: av *= -1
av /= (toFPS ** 2)
# Setting off sparks if the velocity is beyond a certain amount
if av > 0.1:
Distraction.particles("Sparkle", point,
despawn = random.randint(30, 100),
amount = random.randint(0, 3),
max = 50,
spread = 0,
normal = 0.04,
velocity = cv * 0.015)
# Restricting all the rest of the calculations based on a timer
# between the colisions.
if car.get("lastdamage"):
return
car["lastdamage"] = random.randint(10, 60)
# Adding nitro on colision ( based on the speed of the car )
car["nitro"] += av*20
#### ENEMY VOICES ####
# NPC cars might get angry and start attacking you if you hit them.
# When they get angry they swear at you. This is the logic of the
# swearing sounds. And the getting angry logic.
if object.get("engine") and car.get("npc") and car.get("npc") != "racer" and object.get("enemy") != car:
device = bge.logic.globalDict["SoundDevice"]
if not car["npc"] == "enemy":
sound = random.choice(bge.logic.globalDict["sounds_angry_start"])
sound = bge.logic.globalDict["sounds"][sound]
sound["play"] = device.play(sound["sound"])
sound["play"].location = car.position
sound["play"].relative = False
sound["play"].distance_maximum = 50
sound["play"].distance_reference = 5
sound["play"].attenuation = 1
sound["play"].volume = 1.5
car["enemysound"] = sound["play"]
if object.get("active"):
scene.objects["Angry_pusuit"]["pusuit"] = True
if not dani.get("active_sound"):
dani["active_sound"] = device.play(bge.logic.globalDict["sounds"]["dani_ohno"]["sound"])
bge.logic.globalDict["sounds"]["dani_ohno"]["play"] = dani["active_sound"]
dani["active_sound_is"] = "dani_ohno"
elif car["enemy"] == object and ( not car.get("enemysound") or not car["enemysound"].status ):
sound = random.choice(bge.logic.globalDict["sounds_angry_hit"])
sound = bge.logic.globalDict["sounds"][sound]
sound["play"] = device.play(sound["sound"])
sound["play"].location = car.position
sound["play"].relative = False
sound["play"].distance_maximum = 50
sound["play"].distance_reference = 5
sound["play"].attenuation = 1
sound["play"].volume = 1.5
car["enemysound"] = sound["play"]
if object.get("active") and not dani.get("active_sound_is") == "dani_ohnoindeed" and not dani.get("active_sound"):
dani["active_sound"] = device.play(bge.logic.globalDict["sounds"]["dani_ohnoindeed"]["sound"])
bge.logic.globalDict["sounds"]["dani_ohnoindeed"]["play"] = dani["active_sound"]
dani["active_sound_is"] = "dani_ohnoindeed"
# Getting angry
car["npc"] = "enemy"
car["enemy"] = object
object["chased"] = True
# Getting car's body.
rig = car.children[car.get("rig","RIG")]
body = rig.children["Car_body"]
# Getting the velocity of the colision ( comparing to the valocity of the object we are coliding with )
ov = object.getLinearVelocity()
ov /= (toFPS ** 2)
sp = cv - ov
# We can't simply average the velocity since it could be negative.
sm = 0
for i in sp:
if i > 0:
sm += i
else:
sm += i*-1
sp = sm / 3
# Adding the mass of both objects to the calculation
obmass = object.mass
if not obmass: obmass = 1
breakMultiply = max(0, min(1, 1-(sp * obmass)/55)) ** 0.05
breakMultiply *= (toFPS ** 2)
# Blow up when getting a 0 breakMultiply
if not breakMultiply:
car["blowuptimer"] = 10
####### BREAKING THE CAR #######
if breakMultiply < 0.999 or object.get("explosion"):
# Hit sound
device = bge.logic.globalDict["SoundDevice"]
# Hit versus scrape sound
if breakMultiply < 0.98:
s = "//sfx/hit.ogg"
else:
s = "//sfx/scrape.ogg"
code = s+str(car["cid"])
if code not in bge.logic.globalDict["sounds"]:
bge.logic.globalDict["sounds"][code] = {"sound":aud.Sound(bge.logic.expandPath(s)),
"play":None}
sound = bge.logic.globalDict["sounds"][code]
sound["play"] = device.play(sound["sound"])
sound["play"].location = point
sound["play"].relative = False
sound["play"].distance_maximum = 100
sound["play"].distance_reference = 1
sound["play"].attenuation = 1
sound["play"].pitch = random.choice([1, 0.8, 1.2, 0.6, 1.4])
sound["play"].volume = 1 / max(0.1, breakMultiply )
# slecting what area of the car to effect
areas = {"Front_Left" : normal[0] < 0.1 and normal[1] < 0.1,
"Front_Right": normal[0] < 0.1 and normal[1] > -0.1,
"Back_Left" : normal[0] > -0.1 and normal[1] < 0.1,
"Back_Right" : normal[0] > -0.1 and normal[1] < 0.1}
wheels = {"Front_Left" : 2,
"Front_Right": 3,
"Back_Left" : 0,
"Back_Right" : 1}
for area in areas:
if ( areas[area] and car[area] > 0 ) or object.get("explosion"):
# Reducing health
car[area] *= breakMultiply
# If broken toally we pop a wheel
if car[area] <= 0.01:
# We can't simply undo the wheel from the constraint. But
# we can do the next best thing.
bge.logic.globalDict[car["cid"]]["wheels"][wheels[area]].setVisible(False)
vehicle.applyBraking(10, wheels[area])
vehicle.setSuspensionStiffness(0,wheels[area])
# If it is an npc, we make him give up trying to drive.
if not car.get("racing"):
car["npc"] = ""
# Tire Pop
sound = bge.logic.globalDict["sounds"]["tire_pop"]
sound["play"] = device.play(sound["sound"])
sound["play"].location = point
sound["play"].relative = False
sound["play"].distance_maximum = 100
sound["play"].distance_reference = 1
sound["play"].attenuation = 1
sound["play"].volume = 2
# If we are not totally broken, make the wheel worse handeling-wise.
elif car["Front_Left"] < 0.7:
vehicle.setSuspensionStiffness(car.get("suspension", 200)*car["Front_Left"],wheels[area])
vehicle.setRollInfluence(1-car[area], wheels[area])
# If below a certain health, we make the car body look borked
if car[area] < 0.7:
body.replaceMesh(car.get("borked", "Borked"))
# If the heal even lower.
if car[area] < 0.3:
# Removing left door.
if "Left" in area:
try:
door = rig.children["Door_Pease.001"]
door.visible = False
except:
pass
# Removing right door.
elif "Right" in area:
try:
door = rig.children["Door_Pease"]
door.visible = False
except:
pass
# Adding the collision function to the car's collision functions.
car.collisionCallbacks.append(collision_callback)
def update():
# This function is called on ever game logic tick for every car
# in the scene. This is the logic of the car.
# BGE logic stuff
cont = bge.logic.getCurrentController()
scene = bge.logic.getCurrentScene()
car = cont.owner
toFPS = Opt.ToFPS()
carRacing = car.get("racing")
carEnemy = car.get("enemy")
carBehaviour = car.get("npc")
carActive = car.get("active")
carSpeed = car.get("speed")
rig = car.children[car.get("rig","RIG")]
cam = scene.active_camera
camtarget = car.children["CarCamTarget"]
# Is the car in view
distanceToCam = car.getDistanceTo(cam)
inview = ( cam.pointInsideFrustum(car.worldPosition) == cam.INSIDE and distanceToCam < deleteAtDistance / 2 ) or distanceToCam < deleteAtDistance / 3 or distanceToCam > deleteAtDistance
# Dani related things
dani = scene.objects["Dani_Box"]
# Delete vehicle ( at distance, usually done for NPC cars ).
if car.getDistanceTo(cam) > deleteAtDistance and not carRacing and car in bge.logic.globalDict["allcars"]:
def RemovingTheCar(car, dani):
# If car is waiting for a race to start, we don't delete it
if carBehaviour == "racer":
racename = car["race"]
race = bge.logic.globalDict["races"][racename]
starter = race["starters"][0]
if dani.getDistanceTo(starter["location"]) < deleteAtDistance or car["racing"]:
return
print("Removing Car:", car)
# Making sure it can be respawned
if car.get("spawnPoint"):
car["spawnPoint"]["to_spawn"] = True
# Removing the car from races
for racename in bge.logic.globalDict["races"]:
race = bge.logic.globalDict["races"][racename]
try:
race["racers"].remove(car)
except:
pass
if car in bge.logic.globalDict["allcars"]:
bge.logic.globalDict["allcars"].remove(car)
# Removing from cache if too many cars in cache
if Reuse.reuse.get(car.name):# or len(bge.logic.globalDict["allcars"]) > bge.logic.globalDict["maxCars"]:
for i in bge.logic.globalDict[car["cid"]]["wheels"]:
i.endObject()
Reuse.EndObject(car)
# Otherwise storing it for later.
else:
Reuse.Delete(car, inactive=True)
# Undoing angry pursuit
try:
if car["enemy"]["active"]:
scene.objects["Angry_pusuit"]["pusuit"] = False
except:
pass
if Reuse.reuse.get(car.name) or len(bge.logic.globalDict["allcars"]) > bge.logic.globalDict["maxCars"]:
Opt.ScheduleTask("Removing Car ["+car.name+"]", 1.0, RemovingTheCar, car, dani)
else: RemovingTheCar(car, dani)
# Cutting down on unnesesary running of the script
if ( not carRacing and not carActive ) and ( not inview ):
car["deactivated"] = True
car.suspendPhysics()
return
elif car.get("deactivated"):
car.restorePhysics()
car["deactivated"] = False
# Physics constraint for the vehicle
vehicle = bge.constraints.getVehicleConstraint(car["cid"])
# Sound device for sounds.
device = bge.logic.globalDict["SoundDevice"]
# Car's health
health = sum([car["Front_Left"], car["Front_Right"], car["Back_Left"], car["Back_Right"]])/4
engineHealth = ( car["Front_Left"] + car["Front_Right"] ) / 2
car["health"] = health
# Fixing the car ( when in the garage)
if distanceToCam < 30 and car.getDistanceTo(fixGaragePosition) < 2 and health < 1:
bge.logic.globalDict["print"] = "Press F to fix the car."
# Fix car if F is pressed
if 28 in bge.logic.globalDict["keys"]:
body = rig.children["Car_body"]
body.replaceMesh( body["good"] )
for i in range(4):
vehicle.setSuspensionStiffness(car.get("suspension", 200), i)
vehicle.applyBraking(0, i)
vehicle.setTyreFriction(car.get("friction", 1), i)
vehicle.setRollInfluence(car.get("roll", 0), i)
bge.logic.globalDict[car["cid"]]["wheels"][i].setVisible(True)
for i in ["Front_Right", "Front_Left", "Back_Left", "Back_Right"]:
car[i] = 1
# Doors ( some cars have them falling )
try:
rig.children["Door_Pease.001"].visible = True
rig.children["Door_Pease"].visible = True
except:
pass
elif carActive and health < 0.98:
toprint = "You can fix the car in the garage at home."
if toprint not in bge.logic.globalDict["done-prints"]:
bge.logic.globalDict["print"] = toprint
# Whether the car is on graound.
graypos = car.position.copy()
graypos[2] -= 1.5
onGround = car.rayCastTo(graypos)
# Car's rotation
rot = car.localOrientation.to_euler()
upsideDown = not ( -2.5 < rot[0] < 2.5 and -2.5 < rot[1] < 2.5 )
# Colision timer
if car.get("lastdamage"):
car["lastdamage"] -= 1
# Lauchtime timer
if "launchtime" not in car:
car["launchtime"] = 300
car["launchtime"] -= 1
# Water boyancy
if car.position[2] < -9.5 and car.get("underwater"):
car.applyForce([0,0,-5*(car.position[2]+9.5)])
if car["speed"] < -1.5:
car.applyForce([0,-80,0], True)
car.orientation = [0,0,rot[2]]
elif car.position[2] > -9.5:
car["underwater"] = False
# Speed calculation
psp = vehicle.getWheelRotation(0)+vehicle.getWheelRotation(1)
sp = psp - car["prevwheelrot"]
car["prevwheelrot"] = psp
car["speed"] = sp
# sp will be speed normalized
if sp < 0: sp *= -1
# Down Force
dforce = -5*sp*car.get("downforce", 1)
if onGround:
dforce = min(-5, dforce)
car.applyForce([0,0, Opt.Force(dforce)], True)
# Gage
if carActive:
gagerotation = sp * 0.214 # 400 km/h == 4.27 radiance on the gage
gage = scene.objects["Gage_Arrow"]
gage.orientation = [0,0,-gagerotation]
gage_health = scene.objects["Gage_Health"]
gage_health["Health"] = int(( (health ** 2 ** 3) / (1 ** 2 ** 3 ) )*100)
###### NITRO ######
# Making sure that nitro isn't overboard.
car["nitro"] = max(0,min(10000, car.get("nitro", 0.0)))
if carActive:
gage_nitro = scene.objects["Gage_Nitro"]
gage_nitro["Nitro"] = car["nitro"]/100
# Function activated when Nitro is used
def nitro():
if car["nitro"] <= 0:
stopNitro()
return
# Actual Nitro Effect on the car
#if car["engine"] < car.get("maxengine", 2)-0.1:
car["engine"] += car.get("maxaccel",0.003)* 5 * toFPS
#else:
# car["engine"] = car.get("maxengine", 2)*1.5
car["nitro"] -= 20
# Anti bank
if car.get("roll",0):
car.applyRotation([0.05*car.get("roll",0),0,0], True)
car.applyForce([0,0, -20*car.get("roll",0)], True)
# Nitro Sound
s = "//sfx/nitro.ogg"
code = s+str(car["cid"])
if code not in bge.logic.globalDict["sounds"]:
bge.logic.globalDict["sounds"][code] = {"sound":aud.Sound(bge.logic.expandPath(s)),
"play":None}
sound = bge.logic.globalDict["sounds"][code]
if not sound["play"] or not sound["play"].status:
sound["play"] = device.play(sound["sound"])
sound["play"].location = car.position
sound["play"].relative = False
sound["play"].distance_maximum = 100
sound["play"].distance_reference = 1
sound["play"].attenuation = 1
sound["play"].pitch = 1
sound["play"].volume = 5
car["nitroing"] = True
if not carActive and not Opt.GoodFPS("Nitro", 0.9):
return
for nitroObject in car.children:
if "nitro" in nitroObject.name:
if not nitroObject.get("nitroCone"):
nitroCone = Reuse.Create("NitroCone")
nitroObject["nitroCone"] = nitroCone
nitroCone.position = nitroObject.worldPosition
nitroCone.orientation = nitroObject.worldOrientation
nitroCone.setParent(nitroObject)
# Camera effect
if carActive:
camtarget = car.children["CarCamTarget"]
if not car.get("zoom"):
car["zoom"] = camtarget.scaling[0]
camtarget.scaling *= 1.02
# Unction activated when nitro isn't used.
def stopNitro():
# Grpaphics stop
for nitroObject in car.children:
if "nitro" in nitroObject.name:
if nitroObject.get("nitroCone"):
nitroObject["nitroCone"].removeParent()
Reuse.Delete(nitroObject["nitroCone"])
nitroObject["nitroCone"] = None
# Sound stop
s = "//sfx/nitro.ogg"
code = s+str(car["cid"])
if code in bge.logic.globalDict["sounds"]:
sound = bge.logic.globalDict["sounds"][code]
try:
if sound["play"].volume > 0:
sound["play"].volume -= 0.5
else:
sound["play"].stop()
except:
pass
# Activating nitro
if carActive and 48 in bge.logic.globalDict["keys"]:
# 48 is Z
nitro()
else:
stopNitro()
if not onGround:
car["nitro"] += 5
# Telling the player that the car is availble
if dani.get("doesntknowhowtositintocars", True) and not dani["driving"] and distanceToCam < 7:
bge.logic.globalDict["print"] = "Press E to sit into the car."
dani["doesntknowhowtositintocars"] = False
# Camera changes ( help camera show you where you are going ).
if carActive and not upsideDown and sp > 0.1:
dontseecar = cam.rayCastTo(car) != car
if dontseecar and camtarget.scaling[0] > 0.1:
if not car.get("zoom"):
car["zoom"] = camtarget.scaling[0]
camtarget.scaling *= 0.97
elif car.get("zoom") and scene.objects["SecondaryCamSensor"].rayCastTo(car) == car:
newzoom = camtarget.scaling[0] + (( car["zoom"] - camtarget.scaling[0] ) / ( 30 / toFPS ) )
camtarget.scaling = [ newzoom, newzoom, newzoom ]
if camtarget.scaling[0] == car["zoom"]:
car["zoom"] = False
camrot = mathutils.Vector(camtarget.localOrientation.to_euler())
reference = car.getVectTo(car.position + car.getLinearVelocity())[2]
rotref = car.localAngularVelocity
backorfoth = ((reference[1]+1)/2)
if backorfoth > 0.6: backorforth = 1
else: backorforth = 0
if camtarget["back"] and backorforth: backorforth = 0
elif camtarget["back"]: backorforth = 1
camnewrot = mathutils.Vector( [ 0.3 - max(-0.1, min(0.2, rotref[0]/2)),# - (car["engine"]*0.005),
0 - (rotref[2]/10) - (rotref[1]/6),
( math.pi * backorforth ) - (rotref[2]/4)] )
if backorforth and camrot[2] < 0:
camnewrot[2] -= math.pi * 2
camnewrot = mathutils.Vector(camnewrot)
camrot = camrot + (( camnewrot - camrot ) / 10 )
camtarget.localOrientation = camrot
elif carActive and cam.rayCastTo(car) != car:
camrot = camtarget.localOrientation.to_euler()
camrot[0] -= 0.02
#camrot[2] += 0.01
camtarget.localOrientation= camrot
# Smoke ( if health too low )
if not car["underwater"] and inview:
smokeCoefitient = max(0, 1-engineHealth*1.1)*0.2
fireCoefitient = max(0, 1-engineHealth*2)*0.2
smokeemiter = car.children["SmokeEmmiter"]
Distraction.Smoke(smokeemiter.position, smokeCoefitient)
Distraction.Fire(smokeemiter.position, fireCoefitient)
# Exposion
if engineHealth < 0.2 and not car.get("blown"):
boompos = smokeemiter.position.copy()
boompos[2] -= 2
Distraction.Explosion(boompos, mass=0.5, size=2)
car["blown"] = True
# Blowuptimer
if car.get("blowuptimer") != None:
if car["blowuptimer"] == 0 and not car.get("blown"):
Distraction.Explosion(car.children["SmokeEmmiter"].position.copy(), mass=0.5, size=2)
car["blown"] = True
else:
car["blowuptimer"] -= 1
######### SOUND ########
if carActive:
# Dani yelling when in air
if not onGround and not car["underwater"] and not dani.get("active_sound"):
dani["active_sound"] = device.play(bge.logic.globalDict["sounds"]["dani_yelling"]["sound"])
bge.logic.globalDict["sounds"]["dani_yelling"]["play"] = dani["active_sound"]
dani["active_sound_is"] = "dani_yelling"
elif onGround and dani["active_sound"] and dani["active_sound_is"] == "dani_yelling":
dani["active_sound"].stop()
dani["active_sound"] = None
# Sinking
if car.get("underwater") and not dani.get("active_sound") and not dani.get("active_sound_is") == "dani_wearesinking" and dani.get("sinking_timer", 0) < time.time():
dani["active_sound"] = device.play(bge.logic.globalDict["sounds"]["dani_wearesinking"]["sound"])
bge.logic.globalDict["sounds"]["dani_wearesinking"]["play"] = dani["active_sound"]
dani["active_sound_is"] = "dani_wearesinking"
dani["sinking_timer"] = time.time() + 40
# Very close to another car
try:
for i in bge.logic.globalDict["allcars"]:
if i != car and i.getDistanceTo(car) < 6:
car["veryclose"] = i
break
except:
pass
if sp < 0.3:
car["veryclose"] = None
elif car.get("veryclose") and car["veryclose"].getDistanceTo(car) > 7:
if not dani.get("active_sound"):
dani["active_sound"] = device.play(bge.logic.globalDict["sounds"]["dani_ohgod"]["sound"])
bge.logic.globalDict["sounds"]["dani_ohgod"]["play"] = dani["active_sound"]
dani["active_sound_is"] = "dani_ohgod"
car["nitro"] += 200
car["veryclose"] = None
if not dani.get("active_sound") or not dani["active_sound"].status:
dani["active_sound"] = None
# Engine sound
s = car.get("engine_sound","//sfx/engines/neonspeedster.ogg")
code = s+str(car["cid"])
if code not in bge.logic.globalDict["sounds"]:
bge.logic.globalDict["sounds"][code] = {"sound":aud.Sound(bge.logic.expandPath(s)),
"play":None}
sound = bge.logic.globalDict["sounds"][code]
esp = car["engine"]
if esp < 0: esp *= -1
esp = math.log1p(esp) * 5
if 0.01 < esp or car.get("engineStarted"):
car["engineStarted"] = True
if not sound["play"] or not sound["play"].status:
sound["play"] = device.play(sound["sound"])
sound["play"].location = car.worldPosition
sound["play"].velocity = car.getLinearVelocity()
sound["play"].relative = False
sound["play"].distance_maximum = 200
sound["play"].distance_reference = 1
sound["play"].attenuation = 1
revs = ( esp + ( esp % 1.5 ) ) * 0.5
sound["play"].pitch = max(0.4, revs )
sound["play"].volume = engineHealth * 1
if carActive:
scene.objects["Gage_Tachometer"]["Health"] = revs * 30
else:
try:
bge.logic.globalDict["sounds"][code]["play"].stop()
except:
pass
# Grind sound
s = "//sfx/grind.ogg"
code = s+str(car["cid"])
if code not in bge.logic.globalDict["sounds"]:
bge.logic.globalDict["sounds"][code] = {"sound":aud.Sound(bge.logic.expandPath(s)),
"play":None}
sound = bge.logic.globalDict["sounds"][code]
if 0.01 < sp:
if not sound["play"] or not sound["play"].status:
sound["play"] = device.play(sound["sound"])
sound["play"].location = car.worldPosition
sound["play"].velocity = car.getLinearVelocity()
sound["play"].relative = False
sound["play"].distance_maximum = 200
sound["play"].distance_reference = 1
sound["play"].attenuation = 1
sound["play"].pitch = max(0.3, engineHealth) * 2
sound["play"].volume = (1-engineHealth) * min(1.5, sp *8) * 1
else:
try:
bge.logic.globalDict["sounds"][code]["play"].stop()
except:
pass
# Drift sound
s = "//sfx/drift.ogg"
code = s+str(car["cid"])
if code not in bge.logic.globalDict["sounds"]:
bge.logic.globalDict["sounds"][code] = {"sound":aud.Sound(bge.logic.expandPath(s)),
"play":None}
slide = car.localLinearVelocity[0]
if car.get("deccelerating"):
slide = car.localLinearVelocity[1]
if slide < 0:
slide *= -1
sound = bge.logic.globalDict["sounds"][code]
if slide > 1 and -0.5 < rot[0] < 0.5 and -0.5 < rot[1] < 0.5 and onGround:
car["nitro"] += 2
if not sound["play"] or not sound["play"].status:
sound["play"] = device.play(sound["sound"])
sound["play"].location = car.worldPosition
sound["play"].velocity = car.getLinearVelocity()
sound["play"].relative = False
sound["play"].distance_maximum = 200
sound["play"].distance_reference = 1
sound["play"].attenuation = 1
#sound["play"].pitch = 0.8
sound["play"].volume = min(2, slide / 5) / 5
else:
try:
bge.logic.globalDict["sounds"][code]["play"].stop()
except:
pass
#### RACE RESCUE FUNCTION ####
def rescue():
if car.get("launchtime", 0) > 0:
return
# Sparkles on disappearing positiong
Distraction.particles("Sparkle", car.position.copy(),
despawn = random.randint(30, 100),
amount = 30,
max = 30,
spread = 2,
normal = 0.05,
scale = 7)
# Camera
if carActive:
def resetCarZoom():
car["zoom"] = False
Character_Controll.ChangeCameraTarget(car.children["CarCamTarget"], 100, [3,3,3],callable=resetCarZoom)
car.children["CarCamTarget"].orientation = [0.2,0,0]
# Teleportation
car.position = car["rescue"]
car.localLinearVelocity = [0,0,0]
car["checkpoint"] = ( car.get("rescueTo", car["checkpoint"]-1) + 1 ) % len(bge.logic.globalDict["races"][car.get("race")]["checkpoints"])
nextcheckpointn = car["checkpoint"]
nextcheckpoint = bge.logic.globalDict["races"][car.get("race")]["checkpoints"][ nextcheckpointn ]["location"]
prevcheckpoint = ( car["checkpoint"]-2 ) % len(bge.logic.globalDict["races"][car.get("race")]["checkpoints"])
car["prevrescue"] = bge.logic.globalDict["races"][car.get("race")]["checkpoints"][ prevcheckpoint ]["location"]
print("Rescue at: Car:", car, "Checkpoint:", car["checkpoint"])
# Sparkles on the new position
Distraction.particles("Sparkle", car.position,
despawn = random.randint(30, 100),
amount = 50,
max = 100,
spread = 2,
normal = 0.05,
scale = 5)
# Rotation the car based on the locations of checkpoints.
tocheck = car.getVectTo(nextcheckpoint)
car.alignAxisToVect(tocheck[1], 1, 1.0)
car.alignAxisToVect( (0,0,1), 2, 1.0 )
# Rotating the car 180 degrees since forward it -Y not Y.
rot = car.worldOrientation.to_euler()
car.worldOrientation = [rot[0], rot[1], rot[2]+math.pi]
# Adding the rotation of the previous checkpoint.
# if car.get("prevrescue"):
# tocheck = car.getVectTo(car.get("prevrescue"))
# car.alignAxisToVect(tocheck[1], 1, 0.7)
# car.alignAxisToVect( (0,0,1), 2, 1.0 )
# Putting the car a bit higher than the road.
car.position[2] += 2
car["launchtime"] = 200
car["nitro"] = max(1000, car["nitro"])
car["underwater"] = False
car["engine"] = 0
# Restoring the wheels.
for i in range(4):
#vehicle.setSuspensionStiffness(car.get("suspension", 200), i)
car["suspensions"][i] = car.get("suspension", 200)
vehicle.applyBraking(0, i)
vehicle.setTyreFriction(car.get("friction", 1), i)
vehicle.setRollInfluence(car.get("roll", 0), i)
bge.logic.globalDict[car["cid"]]["wheels"][i].setVisible(True)
for i in ["Front_Right", "Front_Left", "Back_Left", "Back_Right"]:
car[i] = max(0.8, car[i])
# Rescuing the active car in the race when pressing Backspace ( code 59 )
if carActive and dani.get("race") and dani.get("rescue") and ( ( car["speed"] > -0.02 and car["engine"] > 0.5 ) or engineHealth <= 0.2 or car["underwater"]):
#if carActive and dani.get("race") and dani.get("rescue") and 59 in bge.logic.globalDict["keys"] and car["launchtime"] <=0:
if not car.get("toresquetimer", 50):
nextcheckpoint = bge.logic.globalDict["races"][dani.get("race")]["checkpoints"][ ( dani.get("checkpoint") + 1 ) % len(bge.logic.globalDict["races"][dani.get("race")]["checkpoints"]) ]["location"]
car["rescue"] = dani["rescue"]
car["race"] = dani["race"]
car["checkpoint"] = dani["checkpoint"]
car["rescueTo"] = dani["rescueTo"]
car["prevrescue"] = dani["prevrescue"]
rescue()
car["toresquetimer"] = 50
else:
car["toresquetimer"] = car.get("toresquetimer", 50) -1
bge.logic.globalDict["cheat"] = [0]
###### NPC LOGIC #######
if car.get("npc") and bge.logic.globalDict["derby-cheat"]:
debryclosest = None
derbydistance = 1000
for i in scene.objects:
if "speed" in i and i != car:
idist = car.getDistanceTo(i)
if idist < derbydistance and car.rayCastTo(i.position) == i:
derbydistance = idist
debryclosest = i
if derbydistance < 10:
break
if debryclosest:
car["npc"] = "enemy"
car["enemy"] = debryclosest
## NPC PREPARATIONS ##
if car.get("npc"):
#### CAR VISION OF THE ROAD AND OBSTACLES ####
# To make the vision work we are going to use Ray Casting
# but instead of doing a whole path tracing thing to see
# everything in front of the car ( which you be slow )
# instead we trace only 5 specifically chosen points.
# Each car model has those 5 points positioned by hand
# in respecive car blend files. Those 5 points are.
left = 50 # To the forward - left diagonal \
# } On the height of the car
right = 50 # To the forward - right diagonal /
leftf = 50 # To the forward - left diagonal \
# } Slightly lower than the car ( to scan road )
rightf = 50 # To the forward - right diagonal /
forward = 50 # Directly in front of the car.
forwardData = None # Data of the ray casting for the forward.
leftm = "" # Material on the left of the car
rightm = "" # Material on the right of the car
# Each ray has it's default value be 50. During ray casting, the value will
# change to the distance of whatever the car "sees". If it sees nothing, the
# values will stay 50.
# Few more things to consider.
road = "Track2" # Material of the road ( to ignore )
separator = "Track_light" # Material of the separator line ( drawn in the middle of the road ).
separator_object = "Separation" # Name of an invisible object sticking out of this separator line.
# Left, slightly lower ray
ray = car.rayCast(car.children["Left"], car, poly=True)
# rayCast returns a list of values [ Hit Object , Hit Location, Hit Angle, Hit Polygon ]
# If we have any hit object ( exluding the road separator line if the car is a racing npc )
if ray[1] and ( not carRacing or not str(ray[0]) == separator_object ):
# Excluding if the Polygon's material is road material
if not ray[3] or road not in str(ray[3].material):
# Getting the distance to the hit location and storing it as both
left = car.getDistanceTo(ray[1]) # left and
leftf = left # leftf
try: leftm = str(ray[3].material)# And storing the material name for later
except: pass
# Doing something similar to the left point on the same heigh as the car
ray = car.rayCast(car.children["Left.001"],car, poly=True)
if ray[1] and ( not carRacing or not str(ray[0]) == separator_object ):
if not ray[3] or road not in str(ray[3].material):
# Only instead of doing the complex appending, we only
# overwrite the left variable, if the distance is lower.
# Basically left will end up the closest visible point from
# the left of the car. And leftf will be the original left.
left = min(car.getDistanceTo(ray[1]), left)
# Doing something similar for the right side as well
ray = car.rayCast(car.children["Right"],car, poly=True)
# Only now we exclude the separator line regardless if it
# is a racer or not. So if the car ends up on the wrong
# side of the road and goes British, it could find its way
# back to the right side of the road.
if ray[1] and not str(ray[0]) == separator_object:
if not ray[3] or road not in str(ray[3].material) :
right = car.getDistanceTo(ray[1])
rightf = right
try: rightm = str(ray[3].material)
except: pass
# And we slightly enfoce it to go to the right side of
# the road. By folling it to think that there is something
# of the left.
elif not carRacing and str(ray[0]) == separator_object:
left = min(car.getDistanceTo(ray[1]), left)
# And now for the slightly higher point on the right.
ray = car.rayCast(car.children["Right.001"],car, poly=True)
if ray[1] and not str(ray[0]) == separator_object:
if not ray[3] or road not in str(ray[3].material):
right = min(car.getDistanceTo(ray[1]), right)
elif not carRacing and str(ray[0]) == separator_object:
left = min(car.getDistanceTo(ray[1]), left)
# And for the forward.
ray = car.rayCast(car.children["Forward"],car, poly=True)
forwardData = ray
if ray[1] and str(ray[0]) == separator_object:
if not ray[3] or road not in str(ray[3].material):
forward = car.getDistanceTo(ray[1])
# Minimum value will be the smallest distance out of all of them
# which is useful for all sorts of things.
minimum = min(left, right, forward)
# And now we calculate how much the car needs to actually turn.
turn = max(-0.8, min(0.8, (( max(0, min(1, (right/12))) - max(0, min(1, (left/12))) ) *-2 )))
## NORMAL NPC CARS ##
if car.get("npc") == "npc":
# Normal NPC cars are those you can see driving around the city
# at a regular speed.
# Activate enemy logic when pursuit cheat is enabled
if distanceToCam < 100 and bge.logic.globalDict["pursuit-cheat"]:
car["npc"] = "enemy"
for i in scene.objects:
if i.get("active"):
car["enemy"] = i
break
# Applying the turn calculated in vision step
car["turn"] = turn
# Accelerating the car, with the target speed based on distance
# to the closest seen point.
targetSpeed = 4 * ((minimum/12)-0.4)
# We also ignore target speed, and make the car drive as fast
# as it can, when it is chased by somebody.
if (sp < targetSpeed or car.get("chased")) and minimum > 2:
accelerate(car)
else:
deccelerate(car)
# To help it avoid obstacles better.
if minimum < 2 and car.get("accelerating"):
car["turn"] = -0.8
# If we about to hit a car head first
if forwardData[0] and forwardData[0].get("speed"):
turn = max(-0.8, min(0.8, turn*10))
car["engine"] = car["speed"]*10
# Cliffs
# turnback = True
# if rot[0] > 0.1 and not car.get("chased"):
# accelerate(car)
# elif rot[0] < -0.9 and sp < 0.9 and onGround:
# car.applyForce([0,-20, 0], True)
# turnback = False
#
#
#
# if minimum < 5:
# deccelerate(car)
# if 0.9 < turn or turn < -0.9:
# car["turn"] = turn *-1
# car.applyTorque([0.0,0.0,turn*-30],1)
#
# elif turnback:
# car["turn"] = 0.3
# car.applyTorque([0.0,0.0,car["turn"]*30],1)
#
# if "launchtime" not in car:
# car["launchtime"] = 300
# car["launchtime"] -= 1
# if 0.03 > sp and ( car["engine"] / max(0.1, engineHealth) > 1 ) and car["launchtime"] < 0:
# if not rot[0] < -0.1 and (leftm or rightm):
# car.applyTorque([0.0,0.0,50],1)
# car.position[2] += 0.05
#
#
# if sp > 2.8 and (0.3 < turn or turn < -0.3):
# for i in range(4):
# vehicle.applyEngineForce(car["speed"]*5* toFPS, i)
# if sp < 0: sp *= -1
# car.applyTorque([0.0,0.0,car["turn"]*sp*5* toFPS],1)
#
#for i in range(4):
# vehicle.applyEngineForce(car["engine"], i)
## ANGRY CARS GUIDED TO A POINT ##
elif car.get("npc") == "enemy" or ( car.get("npc") == "racer" and car.get("racing")):
# If racing
if car.get("npc") == "racer":
checkpoint = bge.logic.globalDict["races"][car.get("race")]["checkpoints"][car.get("checkpoint")].copy()
if "raceData" in bge.logic.globalDict["races"][car.get("race")]:
raceData = bge.logic.globalDict["races"][car.get("race")]["raceData"]
targetTime = raceData["times"][car["checkpoint"]]
try: prevTime = raceData["times"][car["checkpoint"]-1]
except: prevTime = 0
lastCheckPointTime = car.get("last-checkpoint-time", bge.logic.globalDict["races"][car.get("race")]["start-time"])
currentTime = bge.logic.getRealTime() - bge.logic.globalDict["races"][car.get("race")]["start-time"]
targetTimeToCheckpoint = targetTime - prevTime
currentTimeToCheckpoint = currentTime - lastCheckPointTime
else:
targetTimeToCheckpoint = 1
currentTimeToCheckpoint = 1
car["enemy"] = checkpoint["location"]
# If the racing bot is following the player, it will mimic the player
#racePositions = bge.logic.globalDict["races"][car.get("race")].get("positions", [dani, car])
#if dani in racePositions and dani.get("driving") != car and racePositions.index(dani) < racePositions.index(car):
# car["enemy"] = dani["driving"]
# If reached checkpoint
if car.getDistanceTo(car["enemy"]) < checkpoint["radius"]:
if not checkpoint.get("OnLoop"):
car["prevrescue"] = car["rescue"]
car["rescue"] = checkpoint["location"]
car["rescueTo"] = car["checkpoint"]
# Printing if the bot is on time
if "raceData" in bge.logic.globalDict["races"][car.get("race")]:
car["last-checkpoint-time"] = currentTime
print("Race Time of [", car, "]:", round(currentTimeToCheckpoint, 2), round(targetTimeToCheckpoint - currentTimeToCheckpoint, 2))
# Calibrating the stopping distance
if checkpoint.get("Uturn"):
targetSpeed = -checkpoint.get("Uturn") * toFPS
car["stopdistance"] = car.get("stopdistance", -18) * ( car["speed"] / targetSpeed )
print("Race Stopping Calibration [", car, "]:", car.get("stopdistance", -18), int( ( car["speed"] / targetSpeed ) * 100), "%")
car["checkpoint"] = car["checkpoint"]+1
car["launchtime"] = 50
try:
car["distanceBetweenCheckpoints"] = car.getDistanceTo(bge.logic.globalDict["races"][car.get("race")]["checkpoints"][car.get("checkpoint")]["location"])
except:
pass
# If finished lap
if car.get("checkpoint") == len(bge.logic.globalDict["races"][car.get("race")]["checkpoints"]):
print(car, "LAP")
car["checkpoint"] = 0
car["lap"] += 1
# If finished race
if car["lap"] == bge.logic.globalDict["races"][car.get("race")]["laps"]:
car["racing"] = False
car["npc"] = ""
bge.logic.globalDict["print"] = raceNames.get(car.name, car.name) + " finished race!"
# Making rescuing less sensitive when passing a Uturn
if bge.logic.globalDict["races"][car.get("race")]["checkpoints"][car.get("checkpoint")].get("Uturn"):
car["launchtime"] = 500
nextcheckpoint = bge.logic.globalDict["races"][car.get("race")]["checkpoints"][ ( car.get("checkpoint") + 1 ) % len(bge.logic.globalDict["races"][car.get("race")]["checkpoints"]) ]["location"]
tonextcheckpoint = car.getVectTo(nextcheckpoint)
# Moving the indicator
car["beam"].position = car.position
car["beam"].position[2] += 1
tocam = car["beam"].getVectTo(cam)
car["beam"].alignAxisToVect(tocam[1], 1, 1.0)
car["beam"].alignAxisToVect( (0,0,1), 2, 1.0 )
beamscale = max( 0.2, car.getDistanceTo(dani) / 100 )
car["beam"].scaling = [beamscale, beamscale, beamscale]
try:
toenemy = car.getVectTo(car.get("enemy", dani))
if car.get("npc") == "enemy" and sum([car["enemy"].get("Front_Right"), car["enemy"].get("Front_Left"), car["enemy"].get("Back_Right"), car["enemy"].get("Back_Left")])/4 < 0.2:
car["npc"] = "npc"
car["enemy"] = ""
except:
car["npc"] = "npc"
car["enemy"] = ""
return
enemyturn = min(0.8, toenemy[2][0]*2)
onenemy = toenemy[2][1] *-1
oldenemyturn = enemyturn
onoldenemy = onenemy
# If we are too slow. NITRO
if car.get("npc") == "racer":
betweencheckpoints = car.get("distanceBetweenCheckpoints", toenemy[0]) - checkpoint["radius"]
fractionDistance = 1 - (toenemy[0] / betweencheckpoints)
if ( currentTimeToCheckpoint * 1.2 > targetTimeToCheckpoint * fractionDistance or onenemy > 0.6 ) and not car.get("deccelerating") and onGround:
nitro()
else:
stopNitro()
try:
tonext = 1-min(1, toenemy[0]/(car["speed"]*-50) ) ** 0.2
except:
tonext = 0
if type(tonext) == complex:
tonext = float(tonext.real)
targetSpeed = 0
if car.get("npc") == "racer":
if "raceData" in bge.logic.globalDict["races"][car.get("race")]:
raceData = bge.logic.globalDict["races"][car.get("race")]["raceData"]
checkpoint["Uturn"] = raceData["targetSpeed"][car.get("checkpoint")]
if checkpoint.get("Uturn"):
# At current configuration car looses 1 speed at about 12.2 units of distance
targetSpeed = -checkpoint.get("Uturn") * toFPS
brakingDistance = ( car["speed"] - targetSpeed ) * -18# car.get("stopdistance", -18)
if toenemy[0] <= brakingDistance and car["speed"] < targetSpeed:
deccelerate(car)
# We want to record the stopdistance
# if targetSpeed <= car["speed"]:
# car["stopdistance"] = car.get("stopdistance", -18) + toenemy[0]
# print(car, "stopdistance Calibrated at:", car["stopdistance"])
# elif car["speed"] > targetSpeed and onenemy > 0.8:
# nitro()
if onenemy > 0.7 and minimum > 7:
nextenemyturn = min(0.8, tonextcheckpoint[2][0]*2)
nextonenemy = tonextcheckpoint[2][1] *-1
enemyturn = enemyturn + ( ( nextenemyturn - enemyturn ) * tonext )
onenemy = onenemy + ( ( nextonenemy - onenemy ) * tonext )
if type(onenemy) == complex:
onenemy = float(onenemy.real)
enemyturn = float(enemyturn.real)
if car["speed"] > -0.2 or engineHealth <= 0.2 or car["underwater"]:# or onenemy < 0.4:
rescue()
smartturn = ( turn * onoldenemy ) + ( oldenemyturn * onenemy) + ( enemyturn ) / ( onoldenemy + onenemy + 1)
#if onenemy < 0.6:
# smartturn = oldenemyturn
#if toenemy[0] < 60:
#smartturn = enemyturn
#if onenemy < 0.9:
# smartturn = enemyturn
#if onoldenemy < 0.7:
# smartturn = oldenemyturn
# If we about to hit a car head first
#if forwardData[0] and forwardData[0].get("speed"):
# handbreak(car)
# turn = max(-0.8, min(0.8, turn*-1000))
# smartturn = turn
if (( minimum < 10 and onenemy > 0.3 ) or ( minimum < 5 and onenemy > 0.1 )) and toenemy[0] > 50:
smartturn = turn
if minimum < 7:
car["turn"] = max(-0.5, min( 0.8 , car["turn"] * 1.5 ))
if carRacing: angleAt = -0.7
else: angleAt = 0
if onenemy > angleAt:
car["turn"] = smartturn
t = car["turn"]
if t < 0: t *= -1
# If we turning, turn harder
if t > 0.3 and car["speed"] < -1:
car["turn"] *= 3
# If we are turning hard enough, drift
#if t > 0.4 and car["speed"] < -2 and car["speed"] < targetSpeed / 2:
# handbreak(car)
# If we are turning very hard, use breaks
if t > 0.4 and car["speed"] < -1.5 and car["speed"] < targetSpeed:
deccelerate(car)
if not car.get("deccelerating"):
accelerate(car)
else:
if car.get("npc") == "racer":
rescue()
car["turn"] = enemyturn *-1
deccelerate(car)
#for i in range(4):
# vehicle.applyEngineForce(car["engine"], i)
################### APPLYING ##########################
# This is here to trigger an error for if car's object
# has been deleted from the game during the execution
# of this script. Otherwise, applying things to the vehicle
# constraints might result in Segmentation Fault ( the engine
# crashing ).
car.position
# Auto deceleration
if not car.get("accelerating") and car["engine"] > 0:
car["engine"] -= car.get("maxaccel",2) * toFPS
elif not car.get("accelerating") and car["engine"] < 0:
car["engine"] += car.get("maxaccel",2) * toFPS
else:
car["accelerating"] = False
# Auto going straiter
if not car.get("turning"):
car["turn"] *= 0.5 ** toFPS
else:
car["turning"] = False
ApplyEnginePower(car, vehicle)
# if not car.get("deccelerating"):
# minusfrac = 1
# if car["engine"] < 0: minusfrac = -1
# applyforce = math.log1p(car["engine"]*minusfrac) / 4
# if -0.05 < applyforce < 0.05:
# applyforce = 0
# else:
# #applyforce = Opt.Force(applyforce**0.1*3*minusfrac)
# applyforce = Opt.Force(HorsePowerToNewton(applyforce))*minusfrac
#
# if car.get("nitroing"):
# applyforce *= Opt.Force(0.3)
#
# vehicle.applyEngineForce(applyforce*car["Back_Left"], 0)
# vehicle.applyEngineForce(applyforce*car["Back_Right"], 1)
# vehicle.applyEngineForce(0, 2)
# vehicle.applyEngineForce(0, 3)
if not car.get("nitroing"):
car["engine"] = min( car.get("maxengine", 800)*engineHealth, max( -car.get("maxengine", 800)*engineHealth, car["engine"]))
else:
car["nitroing"] = False
if car.get("deccelerating"):
car["deccelerating"] = False
# Making sure the car is not turning more than it is possible.
car["turn"] = max(-0.8, min(0.8, car["turn"]))
# Suspension updates ( important due to FPS flactuations )
ApplySuspension(car, vehicle)
# Turning Force Update
vehicle.setSteeringValue(car["turn"]*car["Front_Left"] , 2)
vehicle.setSteeringValue(car["turn"]*car["Front_Left"] , 3)
# Adding fake torque to the car, to make it easier to turn
#if carSpeed < -0.05 and onGround:
# car.applyTorque([0.0,0.0,Opt.Force(car["turn"]*10)],1)
#elif carSpeed > 0.05 and onGround:
# car.applyTorque([0.0,0.0,Opt.Force(car["turn"]*-10)],1)
def ApplySuspension(car, vehicle):
for i in range(4):
suspension = car["suspensions"][i] / 100
suspense = Opt.Force(suspension*car.mass)
damping = 0.3
vehicle.setSuspensionCompression(1, i)
vehicle.setSuspensionStiffness(suspense, i)
vehicle.setSuspensionDamping(1, i)
def ApplyEnginePower(car, vehicle):
if not car.get("deccelerating"):
# minusfrac = 1
# if car["engine"] < 0: minusfrac = -1
# applyforce = math.log1p(car["engine"]*minusfrac) / 4
# if -0.05 < applyforce < 0.05:
# applyforce = 0
# else:
# #applyforce = Opt.Force(applyforce**0.1*3*minusfrac)
# applyforce = Opt.Force(HorsePowerToNewton(applyforce))*minusfrac
#
# if car.get("nitroing"):
# applyforce *= Opt.Force(0.3)
# Getting car's horse power
horses = car.get("horses", 750)
rpm = car["engine"]
maxrpm = car.get("maxengine", 800)
horses = EngineCurve(rpm, maxrpm, horses)
if car["active"]:
print(horses)
applyforce = Opt.Force(HorsePowerToNewton(horses / 2000))
vehicle.applyEngineForce(0, 0)
vehicle.applyEngineForce(0, 1)
vehicle.applyEngineForce(applyforce*car["Front_Left"], 2)
vehicle.applyEngineForce(applyforce*car["Front_Left"], 3)
def HorsePowerToNewton(value):
return value * 745.6998715823
def EngineCurve(rpm, maxrpm, horses):
# This function draws a simulated
# Engine RPM curve and outputs
# house power.
return math.sin(rpm/maxrpm*(math.pi/4*3))*horses
def accelerate(car):
if type(car) == bge.types.SCA_PythonController:
cont = bge.logic.getCurrentController()
scene = bge.logic.getCurrentScene()
car = cont.owner
if not car["active"]:
return
toFPS = Opt.ToFPS()
vehicle = bge.constraints.getVehicleConstraint(car["cid"])
car["engine"] += car.get("maxaccel",2) * toFPS
if car["engine"] > 0 and car["speed"] <= 0.2:
car["accelerating"]= True
else:
car["engine"] *= 0.95 ** toFPS
car["deccelerating"]= True
for i in range(4):
vehicle.applyEngineForce(Opt.Force(car["speed"]*5*car.mass), i)
def deccelerate(car):
if type(car) == bge.types.SCA_PythonController:
cont = bge.logic.getCurrentController()
scene = bge.logic.getCurrentScene()
car = cont.owner
if not car["active"]:
return
toFPS = Opt.ToFPS()
vehicle = bge.constraints.getVehicleConstraint(car["cid"])
car["engine"] -= car.get("maxaccel",0.003) * toFPS
if car["engine"] < 0 and car["speed"] >= -0.2:
car["accelerating"]= True
else:
car["engine"] *= 0.95 ** toFPS
car["deccelerating"]= True
for i in range(4):
vehicle.applyEngineForce(Opt.Force(car["speed"]*5*car.mass), i)
def turn():
cont = bge.logic.getCurrentController()
scene = bge.logic.getCurrentScene()
car = cont.owner
if not car["active"]:
return
toFPS = Opt.ToFPS()
if car["turn"] < 0: car["turn"] = 0
car["turn"] += 0.005 * toFPS
car["turning"]= True
def unturn():
cont = bge.logic.getCurrentController()
scene = bge.logic.getCurrentScene()
car = cont.owner
if not car["active"]:
return
toFPS = Opt.ToFPS()
if car["turn"] > 0: car["turn"] = 0
car["turn"] -= 0.005 * toFPS
car["turning"]= True
def handbreak(car):
if type(car) == bge.types.SCA_PythonController:
cont = bge.logic.getCurrentController()
scene = bge.logic.getCurrentScene()
car = cont.owner
if not car["active"]:
return
toFPS = Opt.ToFPS()
vehicle = bge.constraints.getVehicleConstraint(car["cid"])
for i in range(4):
vehicle.applyEngineForce(Opt.Force(car["speed"]*2*car.mass), i)
car["deccelerating"]= True
sp = car["speed"]
if sp < 0: sp *= -1
car.applyTorque([0.0,0.0,Opt.Force(car["turn"]*sp*2*car.mass)],1)
def get_in():
return
# This function has been moved to Character Controlls
Reference in a new issue Copy permalink