• Sometime between Blender 3 and Blender 4 the EEVEE rendering engine was re-written to be more useful for animation production. Technically speaking the engine is still blazing fast and useful for real-time stuff. But the newer engine is a bit slower. UPBGE 0.36.1 is the newest UPBGE that still has the old ( slightly faster ) implementation of EEVEE. ↩ Reply

• Sometime between 0.36.1 and 0.5 UPBGE devs started relying on AI-generated slop-code to add new features to the game-engine. In my opinion I should stay away from that sort of thing, specifically due to the reasons described inmy last article. ↩ Reply

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk

win = Gtk.Window()
win.set_title("Dani's Race")
win.set_size_request(799, 280)
win.connect("destroy", Gtk.main_quit)
win.set_default_icon_from_file("SettingUI/icon.png")
box = Gtk.VBox()
win.add(box)

win.show_all()
Gtk.main()

playbutton = Gtk.Button("🎮 Single Player")
playbutton.connect("clicked", play)
playbox.pack_start(playbutton, 0,5,5)

def play(w, multiplayer=False):

    data = load_settings()
    data["multiplayer"] = multiplayer
    save_settings(data)
    
    if data:
        blenderplayer = data.get("blenderplayer", "Engine/blenderplayer")

        try:
            os.system("chmod +x "+blenderplayer)
        except:
            pass

        command = ['stdbuf', '-o0', blenderplayer]

        if data.get("fullscreen", True):
            command.append("-f")
        else:
            command.append("-w")

        
        command.append(data.get("resolution", "1920:1080").split(":")[0])
        command.append(data.get("resolution", "1920:1080").split(":")[1])

        # The file of the game
        command.append(os.getcwd()+"/assembly.blend")
        process = subprocess.Popen(command, stdout=subprocess.PIPE, universal_newlines=True)
        

def play(w, multiplayer=False):

    data = load_settings()
    data["multiplayer"] = multiplayer
    save_settings(data)

        blenderplayer = data.get("blenderplayer", "Engine/blenderplayer")

        try:
            os.system("chmod +x "+blenderplayer)
        except:
            pass

        command = ['stdbuf', '-o0', blenderplayer]

        if data.get("fullscreen", True):
            command.append("-f")
        else:
            command.append("-w")

        
        command.append(data.get("resolution", "1920:1080").split(":")[0])
        command.append(data.get("resolution", "1920:1080").split(":")[1])

        # The file of the game
        command.append(os.getcwd()+"/assembly.blend")
        process = subprocess.Popen(command, stdout=subprocess.PIPE, universal_newlines=True)

Info: Read library:  '/home/vcs/Projects/Games/DanisRace/ast/veh/NeonSpeedster.blend', '//ast/veh/NeonSpeedster.blend', parent '<direct>'

def load_settings():

    folder = get_settings_folder()
    f      = folder+"/config.json"

    try:
        with open(f) as o:
            return json.load(o)
    except:
        try:
            with open("default_config.json") as o:
                return json.load(o)
        except:
            return {}

def get_settings_folder():

    game = "danisrace"
    
    try:
        data_dir = os.environ["XDG_DATA_HOME"] + "/" + game
    except:
        data_dir = os.path.expanduser("~/.local/share/"+game)

    try:
        os.makedirs(data_dir)
    except:
        pass

    return data_dir

 "config_name":"<your config name>",

def encode(data, send_raw=False):

    # This will encode data for sending.
    # Data should be a writable into JSON.

    if not send_raw:
        J = json.dumps(data).encode("utf-8")
    else:
        J = data.encode("utf-8")
    C = zlib.compress(J)

    zed = len(C)
    raw = len(J)

    # Sometime compressed is larger than raw.
    # We will add a byte saying 69 if it comressed
    # and a byte saying 0 if it not sexy like this.

    if not send_raw and zed < raw:
        return chr(69).encode("utf-8")  +  C
    else:
        return chr(0).encode("utf-8")   +  J

f61361b296062cc672427dc40f692588

        if car.get("active"):
            UserControl(car)

body = car.childrenRecursive["Car_body"]

{
    "name":"Neonspeedster",
    "probability":1,
    "type":"race-car",

        "material":{"MainColor"     :[0.051525, 0.514757, 1.000000],
                    "SecondaryColor":[0.051525, 0.514757, 1.000000]},
    "icon":[2,0],
    "cost":2990000,
        
        "wheels":[
            { "radius":0.42, "xyz":[ 0.89, -1.25, 0.150], "down":[0,0,-1], "axel":[-1,0,0], "suspensionRest": 0.2, "front":true , "object":""    , "drift_grip":0.2},
            { "radius":0.42, "xyz":[-0.89, -1.25, 0.150], "down":[0,0,-1], "axel":[-1,0,0], "suspensionRest": 0.2, "front":true , "object":".001", "drift_grip":0.2},
            { "radius":0.42, "xyz":[-0.89,  1.65, 0.150], "down":[0,0,-1], "axel":[-1,0,0], "suspensionRest": 0.2, "front":false, "object":".003", "drift_grip":0.1},
            { "radius":0.42, "xyz":[ 0.89,  1.65, 0.150], "down":[0,0,-1], "axel":[-1,0,0], "suspensionRest": 0.2, "front":false, "object":".002", "drift_grip":0.1}
        ],

        "mass"                : 1800    ,
        "hp"                  : 600     ,
        "torque"              : 120     ,
        "drag"                : 0.25    , 
        "roll"                : -0.4    ,
        "grip"                : 0.3     ,
        "maxturn"             : 0.8     ,
        "brakes"              : 2.0     ,
        "abs"                 : 0.01    ,
        "downforce"           : 2.0     ,
        "suspention"          : 200.0  ,
        "suspentionDamping"   : 0.6     ,
        "maxrpm"              : 8000    ,
        "idle"                : 1100    ,
        "redline"             : 6000    ,
        
        "gears":[
            5.00,
            3.00,
            2.00,
            1.00,
            0.75,
            0.50,
            0.25,
            0.20,
            0.15
        ]
    }

def UpdateCar(car):

    # This function runs on every frame for each car, 
    # making the car interactable in the game.

    # Clear the car and get the scene
    scene, car = GetSceneAndCar(car)
    dani = scene.objects["Dani_Box"]

def GetSceneAndCar(car):
    
    # This module parses the inputs of other modules.
    # And gives back bge.scene and the car object.
    
    # We don't know if what we get here is the controller
    # where the script is running, or the object itself.
    
    if type(car) == bge.types.SCA_PythonController:
        car = car.owner
        
    scene = bge.logic.getCurrentScene()
    
    return scene, car

carD = Opt.FastDict(car)

    initfirst = False
    if not getCarPhysics(car):
        InitCarPhysics(car)
        initfirst = True

def InitCarPhysics(car):
    
    # This part of code runs once per car. It generates the
    # Bullet Physics Vehicle Constraint setup.
    
    # Clear the car and get the scene
    scene, car = GetSceneAndCar(car)
    carD       = Opt.FastDict(car)
    
    # Get the data about this car
    car["specs"] = GetCarSpecs(car.get("carData", car)).copy()
    
    # Create a constraint
    carPhysics = bge.constraints.createVehicle(car.getPhysicsId())
    car["cid"] = carPhysics.getConstraintId()
    car["VehicleConstraintId"] = carPhysics.getConstraintId()

    
    # Adding wheels
    for n, wheel in enumerate(car["specs"]["wheels"]):
        AddWheelToCar(car, wheel)
        car["wheels"][n].position = carPhysics.getWheelPosition(n)

        
    # Connect doors and other hinged objects
    car["doors"] = []


    
    for obj in car.childrenRecursive:
        if obj.get("door"):
            car["doors"].append(obj)
            obj.suspendPhysics()
            
    
        
    # Init Various things we might need
    
    # Engine things
    carD["rpm"]    = float(0.0)
    carD["turn"]    = float(0.0)
    carD["prevF"]  = float(0.0)
    carD["prevT"]  = float(0.0)
    carD["health"] = float(1.0)
    carD["nitro"]  = float(0.0)
    
    carD["shake"]  = float(0.0)

    
    # Set the mass of the car. We divide the mass
    # by 10, since there is a limit of how strong
    # can be car's suspension. UPBGE does not provide
    # a way ( yet ) to override this limit.
    car.mass = car["specs"]["mass"] / 10

    # Create a callback for collisions
    def OnCollisionDo(obj, point, normal, points):
        
        # For readability reason, I put the code
        # for the task itself in a separate funtion
        # below.
        
        if car["active"] or (InView(car) and Opt.GoodFPS("Collision"),0.6):
            work_anyway = False
            if obj == "Explosion":
                work_anyway = True
                obj = {}
            OnCollision(car, obj, point, normal, points, work_anyway)

        # I would love to be able to do a Scheduling instead of simple
        # FPS checking for non player cars. But this results in Seg-Faults
        # because apperately the script tries to read "points" that are
        # freed after the simulation step of the collision is over.
            
    car.collisionCallbacks.append(OnCollisionDo)

    # For trucks
    UnloadCargo(car)

    
    car.angularVelocityMax = car["specs"].get("maxAngularVelocity", 1.5)
    

    
    print(consoleForm(car),clr["bold"]+clr["tdrd"],"Physics Initilized.", clr["norm"])
    

def HorsePowerToWatts(value):
    return value * 745.6998715823

        if car.get("active"):
            UserControl(car)
            
        elif carD.get("npc") == "npc":
            NormalNPC(car)

        elif carD.get("npc") == "pursuit":
            AngryPursuit(car)

        elif carD.get("npc") == "autopilot":
            TargetedNPC(car)
            
        elif carD.get("npc") == "goingToRace":
            TargetedNPC(car)
            Map.Show(car, color=GetColor(car))

        elif carD.get("npc") == "taxiComing":
            TargetedNPC(car)
            Map.Show(car, color=GetColor(car))

        elif carD.get("npc") == "story":
            pass # If it is controlled from story

        elif carD.get("npc") == "race_ghost":
            RacingGhost(car)
            
        elif car.get("racing"):
            RacingAI(car)

ApplyAnimation(dani, "Walk")
ApplyAnimation(dani, "AnswerPhone")

"AnswerPhone":{
        "Action":"DanisPhone",
        "Frames":[32, 100],
        "kwargs":{"layer":2},
        "Keep":true
    },

            driver  = car.get("targetDriver")
            officer = car.get("driver")
            police  = [139, -252.3, 40.6]
            prison  = [81.58, -242.6, 50.41]
            action = ["wait", 30,
                      ["grab", driver,
                       ["say", "police_miranda",
                        ["say", "police_incar",
                         ["drive", car, police,
                          ["grab", driver,
                           ["walk", "Police_Path", "important",
                            ["put", prison,
                             ["walk", "Police_Path", "important"]
                             ]
                            ]
                           ]
                          ]
                         ]
                        ]
                       ]
                      ]

• GoodFPS() is used to schedule execution of heavy operations. It does some analysis of the operations at hand. Let's them run a little towards the beginning of the game. And records how badly they impact the performance. Then it uses this data to prevent very bad function from running often, trying to massage functions into the available time, to try to hit the target FPS. ↩ Reply

• Address(), UpdateScene() and Precalculate() are used to do dynamic spawning and despawning of decorative dynamic or heavy objects, like breakable wood-fences. Address() is used to not try and measure distances to every single point where a wood-fence could be. But rather separate everything into chunks ( using Precalculate() ) and only check distances to objects within the same Address as the camera. ↩ Reply

• FastDict() gives each game-object in the game an assignable dict that works a bit faster than the built-in UPBGE one. ↩ Reply