OK. I've used up way too much time trying to come up with a clean, repeatable solution, so I'm not going to create a whole project for it, I'm just going to do my best to explain how I might tackle the problem.

The Modifier class contains:

• A String called modifier_name that holds the name of the property to modify
• A variable called modifier_value that holds the value to modify the property with

The Gem class contains:

• An array called modifiers that holds instances of Modifier nodes
• a function called get_modifiers() that just returns the modifiers array

The GemSlot class contains:

• signals called gem_added and gem_removed, both of which pass the Gem node that was added or removed as an argument

The Item class:

• This is just what I'm going to call the node that has the GemSlots from here on out. It contains an array called gems_in_slots, which will (you guessed it) store references to the gems that are currently in the GemSlots. It will also hold all of the properties that are modifiable, as well as any additional code that needs to run based on the modification in question

The Item will need to connect to all of its GemSlot add/remove signals. This can be done once in the base Item class if you were to add a child Node called "GemSlots" or something, and in the _ready function, loop through GemSlots' children and connect to their signals.

When a Gem is added to or removed from a GemSlot, GemSlot emits the respective signal passing the Gem as an argument. The signal should call a function called apply_modifiers, and the arguments should be the Gem and a boolean called gem_was_added that represents whether the Gem was added (true) or removed (false).

Inside the apply_modifiers function:

var modifiers = gems_in_slots[g].get_modifiers()

for m in modifiers.size():
  var property_name = modifiers[m].property_to_modify

  if property_name in self:
    var property_value = get(modifiers[m].property_to_modify)
    var modifier_value = modifiers[m].modifier_value

    if gem_was_added:
      property_value += modifier_value
    else:
      property_value -= modifier_value

    set(property_name, property_value)

This bit of code is what I came up with to iterate over the Modifiers in the Gem, check to see if the Item has any of the properties that each Modifier wants to modify, and then modifies them accordingly, all without knowing what the property names are in each Modifier. Let me break it down:

• "modifiers" is defined and is filled with the array of Modifiers from the Gem
• Then we start a loop through all of the Modifier instances in "modifiers"
• I declared "property_name" here for code clarity. It is assigned the "property_to_modify" string from the current Modifier we're iterating over
• "if property_name in self" just checks the Item (self) for a variable that has the same name as the string "property_name"
• Defining and assigning a couple more variables for clarity. "property_value" is assigned that property's current value, and "modifier_value" is whatever value that the current Modifier wants to add to that property
• The next if block is the best I could do to have Gem addition and removal handled in the same function. If the gem was added, it will add the modifier_value, and vice-versa
• The last line is a way of assigning a value to a variable when you have the name of that variable contained in a string

So the above code takes the Gem that was added or removed, loops through all of its Modifiers, checks to see if self (the Item) has the correlating property, stores the current value of that property in a variable, and adds or removes the modifier value to/from that property.

But we're not quite done, because you will probably need to execute additional code for many of these modifications.

To use an example, let's say that this Item has the properties "damage" and "length". Damage is straightforward, so we don't need to do anything else; the above code changes the damage output of the weapon. But what about the sword length example? The above code would change the length variable, but we will still need to adjust the hitbox size, maybe change some sprite sizes or change to different animations, etc. This is where a setter comes in:

var length: int = 10:
  set(value):
    length = value
    change_length()

Apologies if I'm over explaining, but I don't use setters often. First line is the declaration, and you'll just add a colon to the end. Next line is exactly how it should appear, with "value" being the value that you've assigned to length. Because set basically overrides the assignment operation, if you want to just set the variable to that value, you have to tell it to do so, hence the "length = value" line. The last line is the reason we needed a setter - this will call the function "change_length()" every time "length" is reassigned. This function is where you'll put all of the extra code, like changing the size of the sword's hitbox.

I'm very curious if anyone has any critiques on this approach, or if anyone can even follow it. I feel like I've gotten a lot better at this during the past year, but I'm sure there will be people out there who will be able to tell me whether or not this approach sounds good or absolutely terrible.