Godot scripting paradigm?

Ves

I'm trying to move a project from Unity to Godot. I've read all the documentation, and have played around with each of the sample scenes. But I still cannot seem to wrap my head around the idiomatic way of scripting in Godot. It feels like I'm forced to dump everything into a single node script, and this bars me from reusing scripts I've already created. That is, say I have the player and a movement script which is generic enough to be used to move enemies. I would like to use it in both cases. I attempted to create scripts that did not live on any nodes, and instance them inside a "PlayerActor.gd" script, e.g.

var movement = preload(&#039;res://Movement.gd&#039;).new()

but I'm not getting any interaction between this "Movement.gd" script and the actual kinematic body in my scene, and I assume it's because the script isn't technically "attached" to the node. So my question is, what is the sanctioned way of coding in Godot? Put everything in a single script and have multiple variations for every application of the script? What about attaching e.g. an inventory, or some kind of stats system to each actor?

Akien

You could add a child node named "movement" to your player and enemy scenes which uses the "Movement.gd" script.Alternatively, you could make a MovingCharacter scene that has the movement logic and use scene inheritance to make the player and enemy scenes inherit from MovingCharacter.You could also have both the player and the enemy scripts extend from your movement script using ([tt]extends Movement.gd[/tt]), though you can only extend from one script per node, so it would likely be simpler to have a MovingCharacter.gd script with the movement logic for KinematicBody.

Kiori

Like Akien said, you have those 3 options.Thing is with unity you are used to clogging your gameobjects with scripts to get things done. In the end you will realize that's not necessarily the most effective design, it's more prone to crashes and performance issues.You have to let go of Unityism and embrace Godot's scene system. I would go with option number 2 of what Akien listed, it give your more moddability in the future, and opens up unprecedented possibilities.But it depends of course, creating a node and adding the script to it is simple enough.In unity fashion, if you wanna add 10 scripts to a "master node"/GO equivalent you would have to add 10 sub nodes.That seems cumbersome in unity fashion, but it's actually the result of better design.The 'scene factor' in my view is one of Godots strongest points... Once you get out of unity land that is. Till then you're still thinking like a Game Object.

touilleMan

Hi,I'm really interested by this topic given I have the same trouble than Ves doing factorisation inside Godot.Considering multiple traits you want to add to a scene (for example a car can move, a tank can move and shoot, a turret can only shoot, and all of them can be destroyed)I have 3 separate modules:- move: handle speed&acceleration and provide a single API to connect AI, inputs etc.- shoot: handle cooldowns and create projectiles with the right orientation and position- health management: decrease health when hit by projectile, start smoke particules if too low, destroy the vehicle node and replace by a wreckage sprite eventuallyIt seems Godot doesn't support multiple inheritance (in both GDscript and scene model).That means only one of the three modules can be inherited.I would naturally go with the move module, so creating a MovingCharacter scene (inheriting from KinematicBody) and making my tank and car scenes inherit from it (so just like Kiori stated). The remaining turret would be a regular KinematicBody.This being done, this only leave us with composition for the two remaining modules:- you can do script composition by creating a single child node for attaching each script (Akien's 1st solution)- you can do scene composition by directly adding the module scene as child of my main sceneIn fact both solutions seem really similar to me : scene is just a more visual (an less error prone ^⁾ way to do script.So anyway I end up with my two modules composed.But what about my turret ? I could make it inherit from the health manager module given it doesn't have to move, so I would end up doing composition with only the shoot module.However the health manager module was designed to have a parent module to work on (when the health goes under 0 it has to remove the parent node to destruct the turret). Now the module should only destroy it own node given it is the turret main node due to scene inheritance.tldr: it's cumbersome to write a module that works with both inheritance and composition. Given multiple inheritance is not allowed, we should go with composition which is the Unity way (considering a script and a scene is basically a different implementation of the same thing)... So what is the Godot way ?

Sakaki

Think about OOP in its finest: You can treat a scene as a behaviour you want to implement. Work on it. Export one NodePath variable to set which node will be treated in this behaviour, i.e. you can attach the behaviour node to your player's main node, so it will be a child of it. Then in the inspector you can select the RigidBody/KinematicBody to be the actual node to be working inside the Behaviour Script. Like this: <img alt="" src="https://s3.postimg.io/bbljx2zfn/print_Screen.png">