Spaghetti code! The insidious thing that often happens even to the best of us. No wander that it happened to me. When programming you want to break your code into functions that could be called from many other places. Doing everything as one large function is a problem, because sometimes you might want to do the same operation or the same check, or whatever, again in another place, and that will require you to copy paste large chunks of code. And if suddenly you decide to change something about those checks, or functions, you have to change that something in all those places one after another. [Dani's Race](/games/Dani's_Race) my game, has a bit of a Spaghetti code problem. For the most part the game is rather nicely organized. The [Vehicle.py](https://forg.madiator.cloud/BlenderDumbass/DanisRace/src/branch/main/Scripts/Vehicle.py) file for example has tiny little functions and they reference each other all the time. For example the function that calculates the engine Torque is rather small and it looks like this: ``` def Torque(car): # This function calculates torque of # the car. Based on an estimate of # a torque curve. rpm = car["rpm"] maxrpm = car["specs"]["maxrpm"] torque = car["specs"]["torque"] health = car.get("health", 1) # Nitro if car.get("nitroing"): return torque * 10 return math.sin((rpm/maxrpm*(math.pi/4*3))+math.pi/4) * torque * health ``` As you can see it takes the car object as the input, finds the current RPM the engine makes at the moment, find all kinds of specs of this car, checks very quickly if the car does nitro and then does some math with it to output something roughly resembling the real life torque graphs I saw online. Which kind of resembles a portion of a sine-wave. Compare that to the [Main_Update.py](https://forg.madiator.cloud/BlenderDumbass/DanisRace/src/branch/main/Scripts/Main_update.py) where a single `main()` function spans 1645 lines of code in the released version on git right now, and 1683 lines in the current version I'm in the middle of developing. For some reason it even has sub-functions inside of it that could live just fine outside of the `main()` function. For example: ``` def GenerateDoorObject(i): # Location doesn't matter when you dealing with rotation doorObject = {"ClosedRotX":i.get("ClosedRotX", i.orientation.to_euler()[0]), "ClosedRotY":i.get("ClosedRotY", i.orientation.to_euler()[1]), "ClosedRotZ":i.get("ClosedRotZ", i.orientation.to_euler()[2]), "OpenRotX":i.get("OpenRotX", i.orientation.to_euler()[0]), "OpenRotY":i.get("OpenRotY", i.orientation.to_euler()[1]), "OpenRotZ":i.get("OpenRotZ", i.orientation.to_euler()[2]), "ClosedLocX":i.get("ClosedLocX", i.position[0]), "ClosedLocY":i.get("ClosedLocY", i.position[1]), "ClosedLocZ":i.get("ClosedLocZ", i.position[2]), "door": i } # But rotation and location both matter when you dealing with location move = [0,0,0] moveback = [0,0,0] for naxis, axis in enumerate(["X", "Y", "Z"]): code = "OpenLoc"+axis move[naxis] = i.get(code, 0) moveback[naxis] = -i.get(code, 0) i.applyMovement(move, True) for naxis, axis in enumerate(["X", "Y", "Z"]): code = "OpenLoc"+axis doorObject[code] = i.position[naxis] i.applyMovement(moveback, True) return doorObject ``` This function generates a door object, so that inside of the game, when Dani walks outside of his room, the door will automatically open up and stuff. It could live as its own function, somewhere in `Doors.py` but there is no `Doors.py`. And I nested it inside of `main()` like an idiot. But the stupidity of `main()` doesn't stop there. It has the logic of what to do when game starts in a simple `if` statement. Which is not short, since the game needs to do a lot of pre-calculations for various optimization techniques to work. Fine! In this part there are a lot of mentions of `Opt.RegisterObject()` function from [Opt.py](https://forg.madiator.cloud/BlenderDumbass/DanisRace/src/branch/main/Scripts/Opt.py) that looks like this: ``` def RegisterObject(object, precision, delete=True): # This will move an object from scene.objects into # chunks. So that they could be stored without # effecting the BGE Depsgraph performance. # Creating chunk addr = Address(object.position, precision) if addr not in chunks: chunks[addr] = {"loaded":False, "objects":[]} # Adding properties virtualObject = {} virtualObject["name"] = object.name virtualObject["position"] = object.position.copy() virtualObject["orientation"] = object.orientation.to_euler() virtualObject["scaling"] = object.scaling.copy() for i in object.blenderObject.game.properties: virtualObject[i.name] = i.value # Adding the object to the chunk chunks[addr]["objects"].append(virtualObject) # Deleting real object if delete: object.endObject() # Returning return virtualObject ``` As you can see, by itself it is not a large function, but it is mentioned at least 5 times in the `main()` making it very big to copy paste all around the place. So the fact that it is referenced instead of being copied around, is already good. It already saved numerous headaches for me. I already started some development on [Racing.py](https://forg.madiator.cloud/BlenderDumbass/DanisRace/src/branch/main/Scripts/Racing.py) which will be a place where I will put most of the racing code from `main()`. But the funny thing is, most of the racing code is still in `main()` like the very problematic way I check for whether I can even start a race, by doing these sets of checks: ``` after = race.get("after") during = race.get("during") duringcheck = dani.get("race") == after and Script.Story.get(during) aftercheck = duringcheck or after in Script.Story["passed"] or not after if ( not dani.get("race") and aftercheck and Money.Have(bid)) or duringcheck: Map.Show(race["starters"][0]["location"], icon="Map_Circle", color=[0.01,0.01,1], ID=racename) if not race["started"] and ( ( not dani.get("race") and Money.Have(bid) ) or duringcheck ) and race["racers"] and aftercheck: # Starting the race is possible now. ``` Similar code is copy-pasted into `Vehicle.py` too, since it needs to know when to spawn the racers to be around the racing circle. And I could instead have a function somewhere in the `Racing.py` that will check all it needs to check, and return a simple `True` or `False` back. Making the code so much less tedious to work with. ![Racers that spawned around the racing circle in the game.](https://files.mastodon.online/media_attachments/files/113/688/641/706/220/431/original/c1affecd02c6c233.png) The thing is, it is not as simple as whether the character is near the spawn location. Some races have bids, which means the player should have enough money to start the race, some races are only available after a certain mission in the story mode is passed. And sometimes it is a during-mission race which will be unlocked later, but has to be temporarily unlocked now. And there are [bugs](https://forg.madiator.cloud/BlenderDumbass/DanisRace/issues?state=open&type=all&labels=&milestone=0&project=0&assignee=0&poster=0&q=racing&fuzzy=false) with all that stuff because I coded incredible complexity and decided not to separate all this logic into it's own dedicated function. Am I crazy? To fix the bugs that I know are still happening with this racing logic, I need to first fix this Spaghetti code. The main problem though, I am procrastinating and also I am adding new spaghetti code to the `main()` like, I've added the whole time logic to the `main()`. I have a part of a hard to work with LOD system in the `main()`. I'm adding things into the `main()` while what I need to do is stop for a while and start moving those functions somewhere else. The `main()` should only do one thing. It should call functions from other places. And do nothing else. After [my last article about this game](/articles/the_challenge_of_writing_npc_characters_for_games) I started making the police station, where the main character would be taken by the police. Almost immediately I was challenged with changing something about how the game's LOD works. I had to add the police station into the `main()` into the long dictionary of places, which looks like this: ``` {"TheRacetrack":{ "object":scene.objects["TheRacetrack"], "high":"TheRacetrackHigh", "radius":1000, "now":"high", "name":"Papses Racetrack" }, "TheCity":{ "object":scene.objects["TheCity"], "high":"TheCityHigh", "radius":1500, "now":"high", "name":"Dune Town" }, "TheHouse":{ "object":scene.objects["TheHouse"], "high":"TheHouseGood", "low":"TheHouseBorked", "parent":"TheCity", "radius":200, "now":"high", "name":"Looparound 8\nDani's Home" }, "HallwayPictures":{ "object":scene.objects["HallwayPictures"], "high":"HallwayPictures", "parent":"TheHouse", "radius":180, "now":"high" }, "Computer":{ "object":scene.objects["Computer"], "high":"Computer", "parent":"TheHouse", "radius":180, "now":"high" }, "Just3000Wreck":{ "object":scene.objects["Just3000Wreck"], "high":"Just3000Wreck", "parent":"TheHouse", "radius":180, "now":"high" }, "KartingTrack":{ "object":scene.objects["KartingTrack"], "high":"KartingTrack_High", "low":"KartingTrack_Low", "parent":"TheCity", "radius":200, "now":"high", "name":"Karting Track" }, "Karting_Decorations":{ "object":scene.objects["Karting_Decorations"], "high":"Karting_Decorations", "parent":"KartingTrack", "radius":180, "now":"high" }, "KartingGamesCollider":{ "object":scene.objects["KartingGamesCollider"], "high":"KartingGamesCollider", "parent":"KartingTrack", "radius":180, "now":"high" }, "KartingGamesObject":{ "object":scene.objects["KartingGamesObject"], "high":"KartingGamesObject", "parent":"KartingTrack", "radius":180, "now":"high" }, "PoliceStation":{ "object":scene.objects["PoliceStation"], "high":"PoliceStationHigh", "low":"PoliceStationLow", "parent":"TheCity", "radius":180, "now":"high", "name":"Police Station" }, "PoliceStation_Ghost":{ "object":scene.objects["PoliceStation_Ghost"], "high":"PoliceStation_Ghost", "parent":"PoliceStation", "radius":180, "now":"high" }, } ``` Yeah this entire database is just there in `main()` on line 1473. And the funny thing is, I could somehow make this database be automatically generated by looking at the structure of the game's `.blend` file. But no, I made it a manual process to put buildings into a dictionary somewhere in a middle of a very long spaghetti text. I need to stop making the damn police station and clean the damn code of the game. Maybe this is what I will do on [my next few livestreams](https://peer.madiator.cloud/c/blender_dumbass/videos). Because if I keep procrastinating, the game will not go anywhere. Look at this website, in a few weeks I've done so much progress on it, because I decided to rewrite the entire [one file spaghetti code](https://codeberg.org/blenderdumbass/BDServer/src/branch/main/legacy_code) of a server software and make it instead [multiple files](https://codeberg.org/blenderdumbass/BDServer/) broken down into multiple functions. Now look at that beautiful code rendering with syntax highlighting and stuff. Look at the system underneath, the federation with [blog.madiator.com](https://blog.madiator.com) by @Madiator2011 because now he can use the same server software to build his own blog, the plugin system, the mastodon posts on the [home page](/), the livestream alerts. And all why? Because I stopped with the damn spaghetti code. Anyway. I think I need to stop writing this article and start working on the game, before this article turns into a spaghetti article. **Happy Hacking!!!** _____ [Spaghetti with bacon and spinach](https://openverse.org/image/183bdf40-8582-4241-be6a-6a59350ac229) by [mdid](https://openverse.org/image/collection?source=flickr&creator=mdid) ( CC-BY ) was used for the thumbnail. Also [Pasta Tomato](https://openverse.org/image/2c648211-6501-4a18-bab6-f1665bd98342?q=bowl+pasta&p=7) ( CC0 )