Is a Node an object instance of the script it is attached to, or simply a separate object?

Nodes and scripts are two separate things. You can see it in inheritance chains: Object -> Reference -> Resource -> Script Object -> Node So only by looking at this we can conclude that no node can ever be an instance of the Script class because Node class doesn't inherit from the Script class. Nor it can be the other way around. They are in separate branches of inheritance tree.

Script's new() behaves in a different way than in other classes. It will instantiate an object of a built-in class that Script's source code states it extends from. And it will set new object's script property to refer to it (the Script object that created it). Script.new() will not make a new instance of itself. If you're big on design patterns, Script in fact behaves like the factory pattern.

Let's for example take this source code stored in file script.gd

class_name CookieJar
extends Spatial
var cookie

Now we can do the following:

# create a Script object containing the above source code
var script_foo = load("res://script.gd") 
print(script_foo)

# create a Spatial node using Script.new()
# its script property will refer to script_foo object that created it
var spatial_foo = script_foo.new()

# now let's duplicate the Spatial node
# The duplicate will refer to the same script node as the original
var spatial_bar = spatial_foo.duplicate()

# It's exactly the same as creating a new Spatial without any script
# and then simply attaching a Script to it.
var spatial_baz = Spatial.new()
spatial_baz.script = script_foo

# let's print it out
print(spatial_foo, " ", spatial_foo.script)
print(spatial_bar, " ", spatial_bar.script)
print(spatial_baz, " ", spatial_baz.script)

# nodes have the script attached
# so this will work
spatial_foo.cookie
spatial_bar.cookie
spatial_baz.cookie

# now lets remove the script reference from nodes
spatial_foo.script = null
spatial_bar.script = null
spatial_baz.script = null

# and lets print it out
print(spatial_foo, " ", spatial_foo.script)
print(spatial_bar, " ", spatial_bar.script)
print(spatial_baz, " ", spatial_baz.script)

# nodes are fine but this won't work anymore
spatial_foo.cookie
spatial_bar.cookie
spatial_baz.cookie

Can you guess the output?

![GDScript:1953] ![Spatial:1954] [GDScript:1953] ![Spatial:1955] [GDScript:1953] ![Spatial:1956] [GDScript:1953] ![Spatial:1954] [Object:null] ![Spatial:1955] [Object:null] ![Spatial:1956] [Object:null] !Invalid get index 'cookie' (on base: 'Spatial')

!There's only one Script object [GDScript:1953] in existence the whole time

Your rooms all have the same script. The Script object only contains the source code that defines properties and methods. It doesn't actually store these properties. Instead they are added to the object each time script is assigned to it.

Let's suppose this is room.gd:

class_name Room
extends Node
var chair = true

When you do this:

specific_room_1 = Room.new()
specific_room_2 = Room.new()

It's exactly same as doing this:

room_script = load("room.gd")
specific_room_1 = Node.new()
spacific_room_2 = Node.new()
specific_room_1.script = room_script
specific_room_2.script = room_script

Which is again same as doing this:

specific_room_1 = Room.new()
specific_room_2 = specific_room_1.duplicate()

In each case you end up with two instances of Node object, each referring to the same Script object.

When you attach the script to a node, which happens in all of the above cases, the properties defined in script's source code will be added to the node itself. Script just tells it what properties to add. It could be seen as sort of pseudo-inheritance. However, when you remove the script from the node, script's properties will be removed as well.

room_script = load("room.gd")

specific_room_1 = Node.new() # no script
print(specific_room_1.get_property_list()) # no chair property

specific_room_1.script = room_script # script attached
print(specific_room_1.get_property_list()) # contains chair property

specific_room_1.script = null # script removed
print(specific_room_1.get_property_list()) # chair property removed

So, again, Script object doesn't contain any data. It merely defines it. Actual data is created in the scripted object whenever the script is attached to it. You can attach the same script to millions of object and each of these object will make its own storage according to definitions found in the script source.

In your printout you can see exactly which class is each object an instance of. Bunker and Attic are both instances of native Node class. They have their functionality extended via different custom script classes. The inheritance chains of these scripts doesn't affect the actual type of scripted object. Godot makes it appear to be a regular class instantiation system, but it actually isn't. If you look at it as such, you might miss to fully understand what's happening under the hood

class_name Room
extends Spatial

class_name Bunker
extends Room

class_name Attic
extends Room

All three above script classes will instantiate an object of the native Spatial class, but each of these Spatial instances will have its functionality extended by a different script class.

There are two actual inheritance systems at play in Godot. Built in classes (Node, Spatial etc), and custom script classes. Each object is seen as an instance of a built in class as well as a sort of an instance of a script class. During the runtime you can change object's script class but can't change its native class. So it's conceptually problematic to call that object an instance of a script class. Consider this:

var room = Bunker.new()
print(room is Bunker) # True
print(room is Spatial) # True
room.script = null
print(room is Bunker) # False
print(room is Spatial) # True
room.script = Attic
print(room is Attic) # True
print(room is Bunker) # False
print(room is Spatial) # True

So which class is the room instance of? The only sure and invariant thing is that it's an instance of Spatial class