EC's Super Include.nss’s-super-include-access-100s-hidden-functions

Has anyone added to this?

I also remember there was a manner of fashion to get the include to compile. Anyone recall that at all?

if I remember, it was pretty darn comprehensive when it came out.

to compile, add to the bottom:

void main(){}

( and watch a whack of warnings and possibly errors pop )

ya that’s the vanilla super include

I remember it having a simple fix - it might have even been me that figured it out lol.

It’s all coming back to me over the passing days of pouring through all of that sort of content…

If you try to compile it you get the following error:

Which redirects you to line 66 of the ginc_param_const script.

Removing or commenting out the #include ginc_param_const will NOT fix the issue, because that script is probably included in some of the other include scripts.
What is the happening is that the function GetIntParam is being called in the other scripts, but with different arguments (definition and implementation differ) and this is what is causing the script to give a compilation error.

Is there something ‘more comprehensive’ now?

The first step to fixing it is to comment out (or removed) the gdm_inc include, since those functions are redifined later in ginc_param_const, however this is not the only error of this script.
After that a brand new duplicate function implementation from ginc_roster appears, if you comment it out, then another problem arises with gui_bheavior_inc arises with a missing definition, if you comment that out as well then another difference in implementation and definition pops up with the nw_i0_assoc script (which leads to another hunt to the script that had the older implementation and remove it).

In my opinion, this thing is not worth the trouble, too many differences in functions and implementations, can’t group together scripts from 2001 with scripts from 2007, there are bound to be functions with the same name, but different implementations…
This script probably used to work with older versions of the game, but with the final one, it appears to be a mess.

Worth updating?
I’d be interested in what has been added since my 2012 exit and my 2019 return to NWN2 building.
Compilation or not the basic function of having the includes remains useful in my view.

In my opinion, no. Too much work.
I honestly don’t see the need for a super include to begin with, get the include you need when you need it, includes are only there to make scripting “easier”, but they are not required nor mandatory to make things work, everything is based on the system functions anyway.

I see the whole thing as a resource - it is a library of what works in the game. if a whole include is not necessary, the likelihood of finding something that can be ‘data scraped’ into a more basic user defined script increases by a healthy margin - the theoretical math is simple: more examples = more options.

More examples with conflicting implementations are an option if they are separated includes (you decide which one to pick), but if they are crammed together into a single script, they will give compilation errors and stop working entirely, in that case more examples = more errors.

Makes sense. I still regard the super include as useful, if not fully current. It will help me get back into the NWN2 scripting mindset. Knowledge is power and there is no better way to learn what works, is to know what does not work as well.

I am talking about literally ripping from the includes - not using them as a use defined include - but taking individual functions and implement versions of them - not blindly trusting compilation success from the resource. successful scripting is being creative and knowing when to go cold or hot into getting the desired outcome from a complex scripting solution.

the humour in my diatribe is that right now, i cannot even - without examples - script a spawn object! XD

1 Like

purpose of the superinclude isn’t to #include

but when it’s loaded in the ScriptEditor, all those functions and constants appear in ScriptAssist … ie, #include only the files that are specifically needed for a script ofc.

uh my override/scripts folder …


I found the community script library a week or so ago
There is a metric tonne of examples in it

Anyone have feedback on it in relation to current script content being implemented and it’s potential for good or bad influences on a returning nwn2 module builder?

i think it’s mainly a thing for PersistentWorld builders, who want more intimate and extended control over mechanics of the game that are open to scripting.

for example (I’m sorta just gonna make this up) a monster could be tagged with a variable like


and it would automagically gain stuff like immunities from fire and/or fire-based enhancements …

plus lots more. It has fixes and utility functions etc. But i’ve always seen it as a persistent world thing; a basis that would take a lot of time to learn before one could be comfortable with its wiring/usage and what exactly it’s doing/changing …