Compare commits

..

No commits in common. "main" and "1.02" have entirely different histories.
main ... 1.02

5040 changed files with 8199 additions and 71105 deletions

View File

@ -1,26 +1,28 @@
[package] [package]
name = "Realms of Trinity II [PRC8]" name = "Realms of Trinity II [PRC8]"
description = "Realms of Trinity II with PRC8 & other enhancements" description = "Realms of Trinity II with PRC8& other enhancements"
version = "2.02prc8" version = "2.01"
url = "https://discord.gg/gZtMe894eh" url = "https://discord.gg/gZtMe894eh"
author = "Jaysyn904 <68194417+Jaysyn904@users.noreply.github.com>" author = "Jaysyn904 <68194417+Jaysyn904@users.noreply.github.com>"
author = "Tab" author = "Tab"
[package.sources] [Sources]
include = "src/module/**/*.{nss.json}" include = "src/mod/**/*.{nss,json,sq3}"
include = "src/include/**/*.{nss}"
[package.rules] [Rules]
"*" = "src/module/$ext" "*.ndb" = "debugSymbols"
"*" = "unknown"
[Target] [Target]
name = "default" name = "default"
file = "Realms of Trinity II [PRC8].mod" file = "Realms of Trinity II [PRC8].mod"
description = "Realms of Trinity II with PRC8 & other enhancements" description = "Realms of Trinity II with PRC8& other enhancements"
[target.sources] [target.sources]
include = "src/module/**/*" include = "src/mod/**/*"
include = "src/include/**/*" include = "src/prc8/include/**/*"
filter = "nui_i_library.nss"
filter = "util_i_library.nss"
filter = "bnd_inc_bndfunc.nss" filter = "bnd_inc_bndfunc.nss"
filter = "bnd_vestig_const.nss" filter = "bnd_vestig_const.nss"
filter = "inc_2dacache.nss" filter = "inc_2dacache.nss"
@ -228,20 +230,4 @@ description = "Realms of Trinity II with PRC8 & other enhancements"
filter = "x2_inc_cutscenep.nss" filter = "x2_inc_cutscenep.nss"
filter = "x2_inc_spellhook.nss" filter = "x2_inc_spellhook.nss"
filter = "x3_inc_horse.nss" filter = "x3_inc_horse.nss"
filter = "prc_inc_string.nss"
filter = "prc_nui_sc_inc.nss"
filter = "prc_nui_scd_inc.nss"
filter = "prc_nui_consts.nss"
filter = "nw_inc_nui"
filter = "xchst_inc.nss" filter = "xchst_inc.nss"
filter = "nui_i_library.nss"
[target]
name = "pepshak"
file = "peps_prc8.hak"
description = "PEPS hakpak for PRC8 version of Realms of Trinity II."
[target.sources]
include = "src/hakpak/peps_prc8/**/*"
[target.rules]
"*" = "src/hakpak/peps_prc8/$ext"

View File

@ -1 +0,0 @@
nasher pack pepshak --verbose

View File

@ -1 +0,0 @@
nasher pack default --verbose

8
src/.gitignore vendored Normal file
View File

@ -0,0 +1,8 @@
# Ignore packed files
*.erf
*.hak
*.mod
*.tlk
# Ignore the nasher directory
.nasher/

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

View File

@ -1,49 +0,0 @@
2DA V2.0
Message_Type Text
0 AI_Message "Picking up too much junk? Adjust the loot filter."
1 AI_Message "Try the AI on your player for a different experience!"
2 AI_Message "Does your associates talk to much? Reduce their speech."
3 AI_Message "Modes will keep your character engaged in that task."
4 AI_Message "Give Thieves picks to your rogues, they will use them."
5 AI_Message "Want your associates using more magic? Up their magic level."
6 AI_Message "Using up spells too fast? Control what they can cast!"
7 AI_Message "You can adjust when associates heal in and out of combat."
8 AI_Message "Don't want to be a team player? Turn party healing off."
9 AI_Message "Need help picking up all that loot? Turn Auto looting on."
10 Widget_Message "Place your widgets then lock'em into place!"
11 Widget_Message "Like an associates settings? Copy them to other associates."
12 Widget_Message "Use action button to control your associates actions."
13 Widget_Message "'All' commands are good for getting control of the party."
14 Widget_Message "Normal mode clears any specific commands."
15 Widget_Message "Follow command makes them stop fighting and follow!"
16 Widget_Message "Have traps? You can make a skilled associate use them."
17 Widget_Message "Put the camera focus on an associate to get better control."
18 Widget_Message "Don't like your associates familiar? Change it!"
19 Widget_Message "Don't like your associates animal companion? Change it!"
20 General_Message "Right click on the widget portrait to open the AI menu."
21 General_Message "Give your associates magic items, they can use more now!"
22 General_Message "Use the boxes to the right to add commands to your widgets."
23 General_Message "Use the mouse wheel to change a button's [values]."
24 General_Message "Use the mouse wheel to change a button's [values]."
25 General_Message "Use the mouse wheel to change a button's [values]."
26 General_Message "Want a module supported? Ask on Discord or the Vault."
27 Rule_Message "Allow more henchman into your party, upto 12 can join!"
28 Rule_Message "Too many widgets? You can turn your associate widgets off!"
29 Rule_Message "Party too big and can't get down the hall? Use Ghost mode!"
30 Rule_Message "Is the game too easy? Goto Main Options and change the RULES!"
31 Rule_Message "Increase the difficulty, make monster attack weaker targets."
32 Rule_Message "Monsters too powerful? Turn on moral checks."
33 Rule_Message "Allow casters to prebuff for stronger opponents."
34 Rule_Message "Allow casters to presummon for more enemy support."
35 Rule_Message "Change up your opponents tactics. Turn on monster tactics."
36 Rule_Message "Allow enemies to have their familiars and animal companions."
37 Rule_Message "Make summons more powerful, stop unsummons on master's death!"
38 Rule_Message "Want a pile on? Increase the distance monsters can respond!"
39 Rule_Message "Monster's perception can be changed up or down!"
40 Rule_Message "Want to see a massacre! Set the enemy corpses to remain."
41 Rule_Message "Looking for variety? Turn on wandering to get a surprise!"
42 Rule_Message "Not hard enough? Up the number of monsters you fight!"
43 Rule_Message "Monsters just falling over? Increase their health!"
44 Widget_Message "Change your associates memorized spells to what you need!"
45 Widget_message "Control the spells your party uses by turning on the Quick use widget!"

File diff suppressed because it is too large Load Diff

Binary file not shown.

Before

Width:  |  Height:  |  Size: 176 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 176 KiB

View File

@ -1,623 +0,0 @@
// This is a helper library for advanced use: It allows constructing arbitrary gff data.
// You can then spawn your object via JsonToObject().
//
// The data format is the same as https://github.com/niv/neverwinter.nim@1.4.3+.
//
// Example:
//
// json j = GffCreateObject(OBJECT_TYPE_ITEM);
// j = GffAddInt(j, "BaseItem", BASE_ITEM_BELT);
// j = GffAddInt(j, "ModelPart1", 12);
// j = GffAddLocString(j, "LocalizedName", "hi!");
// object belt = JsonToObject(j, GetLocation(OBJECT_SELF));
const string GFF_FIELD_TYPE_STRUCT = "struct";
const string GFF_FIELD_TYPE_LIST = "list";
const string GFF_FIELD_TYPE_BYTE = "byte";
const string GFF_FIELD_TYPE_CHAR = "char";
const string GFF_FIELD_TYPE_WORD = "word";
const string GFF_FIELD_TYPE_SHORT = "short";
const string GFF_FIELD_TYPE_DWORD = "dword";
const string GFF_FIELD_TYPE_INT = "int";
const string GFF_FIELD_TYPE_DWORD64 = "dword64";
const string GFF_FIELD_TYPE_INT64 = "int64";
const string GFF_FIELD_TYPE_FLOAT = "float";
const string GFF_FIELD_TYPE_DOUBLE = "double";
const string GFF_FIELD_TYPE_RESREF = "resref";
const string GFF_FIELD_TYPE_STRING = "cexostring";
const string GFF_FIELD_TYPE_LOC_STRING = "cexolocstring";
// Create a empty object of the given type. You need to manually fill in all
// GFF data with GffAddXXX. This will require understanding of the GFF file format
// and what data fields each object type requires.
json GffCreateObject(int nObjectType);
// Create a combined area format(CAF) object. You need to manually create the ARE and GIT objects with their required data fields.
json GffCreateArea(json jARE, json jGIT);
// Returns the OBJECT_TYPE_* of jGff.
// Note: Will return 0 for invalid object types, including areas.
int GffGetObjectType(json jGff);
// Returns TRUE if jGff is a combined area format(CAF) object.
int GffGetIsArea(json jGff);
// Returns TRUE if a field named sLabel of sType exists in jGff.
// * sLabel: Can be a json pointer(path) without the starting /, see the documentation of JsonPointer() for details.
// * sType: An optional GFF_FIELD_TYPE_*, leave empty to check if sLabel exists regardless of type.
int GffGetFieldExists(json jGff, string sLabel, string sType = "");
// Add a new field, will overwrite any existing fields with the same label even if the type is different.
// Returns a json null value on error with GetJsonError() filled in.
//
// sLabel can be a json pointer(path) without the starting /, see the documentation of JsonPointer() for details.
// For example, to add the tag of an area to an empty combined area format(CAF) object you can do the following:
// json jArea = GffCreateArea(JsonObject(), JsonObject());
// jArea = GffAddString(jArea, "ARE/value/Tag", "AREA_TAG");
json GffAddStruct(json jGff, string sLabel, json jStruct, int nType = -1);
json GffAddList(json jGff, string sLabel, json jList);
json GffAddByte(json jGff, string sLabel, int v);
json GffAddChar(json jGff, string sLabel, int v);
json GffAddWord(json jGff, string sLabel, int v);
json GffAddShort(json jGff, string sLabel, int v);
// Note: Only data of type int32 will fit, because that's all that NWScript supports.
json GffAddDword(json jGff, string sLabel, int v);
json GffAddInt(json jGff, string sLabel, int v);
// Note: Only data of type int32 will fit, because that's all that NWScript supports.
json GffAddDword64(json jGff, string sLabel, int v);
// Note: Only data of type int32 will fit, because that's all that NWScript supports.
json GffAddInt64(json jGff, string sLabel, int v);
json GffAddFloat(json jGff, string sLabel, float v);
// Note: Only data of type float will fit, because that's all that NWScript supports.
json GffAddDouble(json jGff, string sLabel, float v);
json GffAddResRef(json jGff, string sLabel, string v);
json GffAddString(json jGff, string sLabel, string v);
json GffAddLocString(json jGff, string sLabel, string v, int nStrRef = -1);
// Replace a field, the type must match and the field must exist.
// Returns a json null value on error with GetJsonError() filled in.
//
// sLabel can be a json pointer(path) without the starting /, see the documentation of JsonPointer() for details.
// For example, to replace the name of an area in a combined area format(CAF) object you can do the following:
// json jArea = ObjectToStruct(GetFirstArea());
// jArea = GffReplaceLocString(jArea, "ARE/value/Name", "New Area Name");
json GffReplaceStruct(json jGff, string sLabel, json jStruct);
json GffReplaceList(json jGff, string sLabel, json jList);
json GffReplaceByte(json jGff, string sLabel, int v);
json GffReplaceChar(json jGff, string sLabel, int v);
json GffReplaceWord(json jGff, string sLabel, int v);
json GffReplaceShort(json jGff, string sLabel, int v);
// Note: Only data of type int32 will fit, because that's all that NWScript supports.
json GffReplaceDword(json jGff, string sLabel, int v);
json GffReplaceInt(json jGff, string sLabel, int v);
// Note: Only data of type int32 will fit, because that's all that NWScript supports.
json GffReplaceDword64(json jGff, string sLabel, int v);
// Note: Only data of type int32 will fit, because that's all that NWScript supports.
json GffReplaceInt64(json jGff, string sLabel, int v);
json GffReplaceFloat(json jGff, string sLabel, float v);
// Note: Only data of type float will fit, because that's all that NWScript supports.
json GffReplaceDouble(json jGff, string sLabel, float v);
json GffReplaceResRef(json jGff, string sLabel, string v);
json GffReplaceString(json jGff, string sLabel, string v);
json GffReplaceLocString(json jGff, string sLabel, string v, int nStrRef = -1);
// Remove a field, the type must match and the field must exist.
// Returns a json null value on error with GetJsonError() filled in.
//
// sLabel can be a json pointer(path) without the starting /, see the documentation of JsonPointer() for details.
// For example, to remove all placeables from an area in a combined area format(CAF) object you can do the following:
// json jArea = ObjectToStruct(GetFirstArea());
// jArea = GffRemoveList(jArea, "GIT/value/Placeable List");
json GffRemoveStruct(json jGff, string sLabel);
json GffRemoveList(json jGff, string sLabel);
json GffRemoveByte(json jGff, string sLabel);
json GffRemoveChar(json jGff, string sLabel);
json GffRemoveWord(json jGff, string sLabel);
json GffRemoveShort(json jGff, string sLabel);
json GffRemoveDword(json jGff, string sLabel);
json GffRemoveInt(json jGff, string sLabel);
json GffRemoveDword64(json jGff, string sLabel);
json GffRemoveInt64(json jGff, string sLabel);
json GffRemoveFloat(json jGff, string sLabel);
json GffRemoveDouble(json jGff, string sLabel);
json GffRemoveResRef(json jGff, string sLabel);
json GffRemoveString(json jGff, string sLabel);
json GffRemoveLocString(json jGff, string sLabel);
// Get a field's value as json object.
// Returns a json null value on error with GetJsonError() filled in.
//
// Note: Json types do not implicitly convert between types, this means you cannot convert a JsonInt to a string with JsonGetString(), etc.
// You may need to check the type with JsonGetType() and then do the appropriate cast yourself.
// For GffGet*() functions the json type returned is noted in the function description.
//
// Example:
// INCORRECT: string s = JsonGetString(GffGetInt());
// CORRECT: string s = IntToString(JsonGetInt(GffGetInt()));
//
// sLabel can be a json pointer(path) without the starting /, see the documentation of JsonPointer() for details.
// For example, to get the resref of an area in a combined area format(CAF) object you can do the following:
// json jResRef = GffGetResRef(ObjectToStruct(GetFirstArea()), "ARE/value/ResRef");
// if (jResRef != JsonNull())
// {
// string sResRef = JsonGetString(jResRef);
// }
// else
// WriteTimestampedLogEntry("Failed to get area ResRef: " + JsonGetError(jResRef));
// Returns the struct as JsonObject() on success.
json GffGetStruct(json jGff, string sLabel);
// Returns a JsonArray() with all the list elements on success.
json GffGetList(json jGff, string sLabel);
// Returns a JsonInt() on success.
json GffGetByte(json jGff, string sLabel);
// Returns a JsonInt() on success.
json GffGetChar(json jGff, string sLabel);
// Returns a JsonInt() on success.
json GffGetWord(json jGff, string sLabel);
// Returns a JsonInt() on success.
json GffGetShort(json jGff, string sLabel);
// Returns a JsonInt() on success.
json GffGetDword(json jGff, string sLabel);
// Returns a JsonInt() on success.
json GffGetInt(json jGff, string sLabel);
// Returns a JsonInt() on success.
json GffGetDword64(json jGff, string sLabel);
// Returns a JsonInt() on success.
json GffGetInt64(json jGff, string sLabel);
// Returns a JsonFloat() on success.
json GffGetFloat(json jGff, string sLabel);
// Returns a JsonFloat() on success.
json GffGetDouble(json jGff, string sLabel);
// Returns a JsonString() on success.
json GffGetResRef(json jGff, string sLabel);
// Returns a JsonString() on success.
json GffGetString(json jGff, string sLabel);
// Returns a JsonObject() on success.
// Key "0" will have a JsonString() with the string, if set.
// Key "id" will have a JsonInt() with the strref, if set.
json GffGetLocString(json jGff, string sLabel);
// *** Internal Helper Functions
json AddPatchOperation(json jPatchArray, string sOp, string sPath, json jValue)
{
json jOperation = JsonObject();
jOperation = JsonObjectSet(jOperation, "op", JsonString(sOp));
jOperation = JsonObjectSet(jOperation, "path", JsonString(sPath));
jOperation = JsonObjectSet(jOperation, "value", jValue);
return JsonArrayInsert(jPatchArray, jOperation);
}
json GffAddField(json jGff, string sLabel, string sType, json jValue, int nType = -1)
{
json jField = JsonObject();
jField = JsonObjectSet(jField, "type", JsonString(sType));
jField = JsonObjectSet(jField, "value", jValue);
if (sType == GFF_FIELD_TYPE_STRUCT && nType != -1)
jField = JsonObjectSet(jField, "__struct_id", JsonInt(nType));
return JsonPatch(jGff, AddPatchOperation(JsonArray(), "add", "/" + sLabel, jField));
}
json GffReplaceField(json jGff, string sLabel, string sType, json jValue)
{
json jPatch = JsonArray();
jPatch = AddPatchOperation(jPatch, "test", "/" + sLabel + "/type", JsonString(sType));
jPatch = AddPatchOperation(jPatch, "replace", "/" + sLabel + "/value", jValue);
return JsonPatch(jGff, jPatch);
}
json GffRemoveField(json jGff, string sLabel, string sType)
{
json jPatch = JsonArray();
jPatch = AddPatchOperation(jPatch, "test", "/" + sLabel + "/type", JsonString(sType));
jPatch = AddPatchOperation(jPatch, "remove", "/" + sLabel, JsonNull());
return JsonPatch(jGff, jPatch);
}
json GffGetFieldType(json jGff, string sLabel)
{
return JsonPointer(jGff, "/" + sLabel + "/type");
}
json GffGetFieldValue(json jGff, string sLabel)
{
return JsonPointer(jGff, "/" + sLabel + "/value");
}
json GffGetField(json jGff, string sLabel, string sType)
{
json jType = GffGetFieldType(jGff, sLabel);
if (jType == JsonNull())
return jType;
else if (jType != JsonString(sType))
return JsonNull("field type does not match");
else
return GffGetFieldValue(jGff, sLabel);
}
json GffLocString(string v, int nStrRef = -1)
{
json jLocString = JsonObject();
if (v != "")
jLocString = JsonObjectSet(jLocString, "0", JsonString(v)); // english/any
if (nStrRef != -1)
jLocString = JsonObjectSet(jLocString, "id", JsonInt(nStrRef));
return jLocString;
}
//***
json GffCreateObject(int nObjectType)
{
string ot;
if (nObjectType == OBJECT_TYPE_CREATURE) ot = "UTC ";
else if (nObjectType == OBJECT_TYPE_ITEM) ot = "UTI ";
else if (nObjectType == OBJECT_TYPE_TRIGGER) ot = "UTT ";
else if (nObjectType == OBJECT_TYPE_DOOR) ot = "UTD ";
else if (nObjectType == OBJECT_TYPE_WAYPOINT) ot = "UTW ";
else if (nObjectType == OBJECT_TYPE_PLACEABLE) ot = "UTP ";
else if (nObjectType == OBJECT_TYPE_STORE) ot = "UTM ";
else if (nObjectType == OBJECT_TYPE_ENCOUNTER) ot = "UTE ";
if (ot == "") return JsonNull("invalid object type");
json ret = JsonObject();
ret = JsonObjectSet(ret, "__data_type", JsonString(ot));
return ret;
}
json GffCreateArea(json jARE, json jGIT)
{
json jCAF = JsonObject();
jCAF = JsonObjectSet(jCAF, "__data_type", JsonString("CAF "));
jCAF = GffAddStruct(jCAF, "ARE", jARE, 0);
jCAF = GffAddStruct(jCAF, "GIT", jGIT, 1);
return jCAF;
}
int GffGetObjectType(json jGff)
{
json jDataType = JsonObjectGet(jGff, "__data_type");
if (jDataType == JsonNull())
return 0;
else
{
string sObjectType = JsonGetString(jDataType);
if (sObjectType == "UTC ") return OBJECT_TYPE_CREATURE;
else if (sObjectType == "UTI ") return OBJECT_TYPE_ITEM;
else if (sObjectType == "UTT ") return OBJECT_TYPE_TRIGGER;
else if (sObjectType == "UTD ") return OBJECT_TYPE_DOOR;
else if (sObjectType == "UTW ") return OBJECT_TYPE_WAYPOINT;
else if (sObjectType == "UTP ") return OBJECT_TYPE_PLACEABLE;
else if (sObjectType == "UTM ") return OBJECT_TYPE_STORE;
else if (sObjectType == "UTE ") return OBJECT_TYPE_ENCOUNTER;
}
return 0;
}
int GffGetIsArea(json jGff)
{
return JsonObjectGet(jGff, "__data_type") == JsonString("CAF ");
}
int GffGetFieldExists(json jGff, string sLabel, string sType = "")
{
json jFieldType = GffGetFieldType(jGff, sLabel);
return sType == "" ? jFieldType != JsonNull() : jFieldType == JsonString(sType);
}
json GffAddStruct(json jGff, string sLabel, json jStruct, int nType = -1)
{
return GffAddField(jGff, sLabel, GFF_FIELD_TYPE_STRUCT, jStruct, nType);
}
json GffAddList(json jGff, string sLabel, json jList)
{
return GffAddField(jGff, sLabel, GFF_FIELD_TYPE_LIST, jList);
}
json GffAddByte(json jGff, string sLabel, int v)
{
return GffAddField(jGff, sLabel, GFF_FIELD_TYPE_BYTE, JsonInt(v));
}
json GffAddChar(json jGff, string sLabel, int v)
{
return GffAddField(jGff, sLabel, GFF_FIELD_TYPE_CHAR, JsonInt(v));
}
json GffAddWord(json jGff, string sLabel, int v)
{
return GffAddField(jGff, sLabel, GFF_FIELD_TYPE_WORD, JsonInt(v));
}
json GffAddShort(json jGff, string sLabel, int v)
{
return GffAddField(jGff, sLabel, GFF_FIELD_TYPE_SHORT, JsonInt(v));
}
json GffAddDword(json jGff, string sLabel, int v)
{
return GffAddField(jGff, sLabel, GFF_FIELD_TYPE_DWORD, JsonInt(v));
}
json GffAddInt(json jGff, string sLabel, int v)
{
return GffAddField(jGff, sLabel, GFF_FIELD_TYPE_INT, JsonInt(v));
}
json GffAddDword64(json jGff, string sLabel, int v)
{
return GffAddField(jGff, sLabel, GFF_FIELD_TYPE_DWORD64, JsonInt(v));
}
json GffAddInt64(json jGff, string sLabel, int v)
{
return GffAddField(jGff, sLabel, GFF_FIELD_TYPE_INT64, JsonInt(v));
}
json GffAddFloat(json jGff, string sLabel, float v)
{
return GffAddField(jGff, sLabel, GFF_FIELD_TYPE_FLOAT, JsonFloat(v));
}
json GffAddDouble(json jGff, string sLabel, float v)
{
return GffAddField(jGff, sLabel, GFF_FIELD_TYPE_DOUBLE, JsonFloat(v));
}
json GffAddResRef(json jGff, string sLabel, string v)
{
return GffAddField(jGff, sLabel, GFF_FIELD_TYPE_RESREF, JsonString(v));
}
json GffAddString(json jGff, string sLabel, string v)
{
return GffAddField(jGff, sLabel, GFF_FIELD_TYPE_STRING, JsonString(v));
}
json GffAddLocString(json jGff, string sLabel, string v, int nStrRef = -1)
{
return GffAddField(jGff, sLabel, GFF_FIELD_TYPE_LOC_STRING, GffLocString(v, nStrRef));
}
json GffReplaceStruct(json jGff, string sLabel, json jStruct)
{
return GffReplaceField(jGff, sLabel, GFF_FIELD_TYPE_STRUCT, jStruct);
}
json GffReplaceList(json jGff, string sLabel, json jList)
{
return GffReplaceField(jGff, sLabel, GFF_FIELD_TYPE_LIST, jList);
}
json GffReplaceByte(json jGff, string sLabel, int v)
{
return GffReplaceField(jGff, sLabel, GFF_FIELD_TYPE_BYTE, JsonInt(v));
}
json GffReplaceChar(json jGff, string sLabel, int v)
{
return GffReplaceField(jGff, sLabel, GFF_FIELD_TYPE_CHAR, JsonInt(v));
}
json GffReplaceWord(json jGff, string sLabel, int v)
{
return GffReplaceField(jGff, sLabel, GFF_FIELD_TYPE_WORD, JsonInt(v));
}
json GffReplaceShort(json jGff, string sLabel, int v)
{
return GffReplaceField(jGff, sLabel, GFF_FIELD_TYPE_SHORT, JsonInt(v));
}
json GffReplaceDword(json jGff, string sLabel, int v)
{
return GffReplaceField(jGff, sLabel, GFF_FIELD_TYPE_DWORD, JsonInt(v));
}
json GffReplaceInt(json jGff, string sLabel, int v)
{
return GffReplaceField(jGff, sLabel, GFF_FIELD_TYPE_INT, JsonInt(v));
}
json GffReplaceDword64(json jGff, string sLabel, int v)
{
return GffReplaceField(jGff, sLabel, GFF_FIELD_TYPE_DWORD64, JsonInt(v));
}
json GffReplaceInt64(json jGff, string sLabel, int v)
{
return GffReplaceField(jGff, sLabel, GFF_FIELD_TYPE_INT64, JsonInt(v));
}
json GffReplaceFloat(json jGff, string sLabel, float v)
{
return GffReplaceField(jGff, sLabel, GFF_FIELD_TYPE_FLOAT, JsonFloat(v));
}
json GffReplaceDouble(json jGff, string sLabel, float v)
{
return GffReplaceField(jGff, sLabel, GFF_FIELD_TYPE_DOUBLE, JsonFloat(v));
}
json GffReplaceResRef(json jGff, string sLabel, string v)
{
return GffReplaceField(jGff, sLabel, GFF_FIELD_TYPE_RESREF, JsonString(v));
}
json GffReplaceString(json jGff, string sLabel, string v)
{
return GffReplaceField(jGff, sLabel, GFF_FIELD_TYPE_STRING, JsonString(v));
}
json GffReplaceLocString(json jGff, string sLabel, string v, int nStrRef = -1)
{
return GffReplaceField(jGff, sLabel, GFF_FIELD_TYPE_LOC_STRING, GffLocString(v, nStrRef));
}
json GffRemoveStruct(json jGff, string sLabel)
{
return GffRemoveField(jGff, sLabel, GFF_FIELD_TYPE_STRUCT);
}
json GffRemoveList(json jGff, string sLabel)
{
return GffRemoveField(jGff, sLabel, GFF_FIELD_TYPE_LIST);
}
json GffRemoveByte(json jGff, string sLabel)
{
return GffRemoveField(jGff, sLabel, GFF_FIELD_TYPE_BYTE);
}
json GffRemoveChar(json jGff, string sLabel)
{
return GffRemoveField(jGff, sLabel, GFF_FIELD_TYPE_CHAR);
}
json GffRemoveWord(json jGff, string sLabel)
{
return GffRemoveField(jGff, sLabel, GFF_FIELD_TYPE_WORD);
}
json GffRemoveShort(json jGff, string sLabel)
{
return GffRemoveField(jGff, sLabel, GFF_FIELD_TYPE_SHORT);
}
json GffRemoveDword(json jGff, string sLabel)
{
return GffRemoveField(jGff, sLabel, GFF_FIELD_TYPE_DWORD);
}
json GffRemoveInt(json jGff, string sLabel)
{
return GffRemoveField(jGff, sLabel, GFF_FIELD_TYPE_INT);
}
json GffRemoveDword64(json jGff, string sLabel)
{
return GffRemoveField(jGff, sLabel, GFF_FIELD_TYPE_DWORD64);
}
json GffRemoveInt64(json jGff, string sLabel)
{
return GffRemoveField(jGff, sLabel, GFF_FIELD_TYPE_INT64);
}
json GffRemoveFloat(json jGff, string sLabel)
{
return GffRemoveField(jGff, sLabel, GFF_FIELD_TYPE_FLOAT);
}
json GffRemoveDouble(json jGff, string sLabel)
{
return GffRemoveField(jGff, sLabel, GFF_FIELD_TYPE_DOUBLE);
}
json GffRemoveResRef(json jGff, string sLabel)
{
return GffRemoveField(jGff, sLabel, GFF_FIELD_TYPE_RESREF);
}
json GffRemoveString(json jGff, string sLabel)
{
return GffRemoveField(jGff, sLabel, GFF_FIELD_TYPE_STRING);
}
json GffRemoveLocString(json jGff, string sLabel)
{
return GffRemoveField(jGff, sLabel, GFF_FIELD_TYPE_LOC_STRING);
}
json GffGetStruct(json jGff, string sLabel)
{
return GffGetField(jGff, sLabel, GFF_FIELD_TYPE_STRUCT);
}
json GffGetList(json jGff, string sLabel)
{
return GffGetField(jGff, sLabel, GFF_FIELD_TYPE_LIST);
}
json GffGetByte(json jGff, string sLabel)
{
return GffGetField(jGff, sLabel, GFF_FIELD_TYPE_BYTE);
}
json GffGetChar(json jGff, string sLabel)
{
return GffGetField(jGff, sLabel, GFF_FIELD_TYPE_CHAR);
}
json GffGetWord(json jGff, string sLabel)
{
return GffGetField(jGff, sLabel, GFF_FIELD_TYPE_WORD);
}
json GffGetShort(json jGff, string sLabel)
{
return GffGetField(jGff, sLabel, GFF_FIELD_TYPE_SHORT);
}
json GffGetDword(json jGff, string sLabel)
{
return GffGetField(jGff, sLabel, GFF_FIELD_TYPE_DWORD);
}
json GffGetInt(json jGff, string sLabel)
{
return GffGetField(jGff, sLabel, GFF_FIELD_TYPE_INT);
}
json GffGetDword64(json jGff, string sLabel)
{
return GffGetField(jGff, sLabel, GFF_FIELD_TYPE_DWORD64);
}
json GffGetInt64(json jGff, string sLabel)
{
return GffGetField(jGff, sLabel, GFF_FIELD_TYPE_INT64);
}
json GffGetFloat(json jGff, string sLabel)
{
return GffGetField(jGff, sLabel, GFF_FIELD_TYPE_FLOAT);
}
json GffGetDouble(json jGff, string sLabel)
{
return GffGetField(jGff, sLabel, GFF_FIELD_TYPE_DOUBLE);
}
json GffGetResRef(json jGff, string sLabel)
{
return GffGetField(jGff, sLabel, GFF_FIELD_TYPE_RESREF);
}
json GffGetString(json jGff, string sLabel)
{
return GffGetField(jGff, sLabel, GFF_FIELD_TYPE_STRING);
}
json GffGetLocString(json jGff, string sLabel)
{
return GffGetField(jGff, sLabel, GFF_FIELD_TYPE_LOC_STRING);
}

File diff suppressed because it is too large Load Diff

Binary file not shown.

View File

@ -1,530 +0,0 @@
#include "prc_nui_consts"
#include "inc_newspellbook"
#include "psi_inc_psifunc"
#include "inc_lookups"
#include "nw_inc_nui"
//
// GetCurrentSpellLevel
// Gets the current spell level the class can achieve at the current
// caster level (ranging from 0-9)
//
// Arguments:
// nClass:int the ClassID
// nLevel:int the caster level
//
// Returns:
// int the circle the class can achieve currently
//
int GetCurrentSpellLevel(int nClass, int nLevel);
//
// GetMaxSpellLevel
// Gets the highest possible circle the class can achieve (from 0-9)
//
// Arguments:
// nClass:int the ClassID
//
// Returns:
// int the highest circle that can be achieved
//
int GetMaxSpellLevel(int nClass);
//
// GetMinSpellLevel
// Gets the lowest possible circle the class can achieve (from 0-9)
//
// Arguments:
// nClass:int the ClassID
//
// Returns:
// int the lowest circle that can be achieved
//
int GetMinSpellLevel(int nClass);
//
// GetHighestLevelPossibleInClass
// Given a class Id this will determine what the max level of a class can be
// achieved
//
// Arguments:
// nClass:int the ClassID
//
// Returns:
// int the highest possible level the class can achieve
//
int GetHighestLevelPossibleInClass(int nClass);
//
// GetClassSpellbookFile
// Gets the class 2da spellbook/ability for the given class Id
//
// Arguments:
// nClass:int the classID
//
// Returns:
// string the 2da file name for the spell/abilities of the ClassID
//
string GetClassSpellbookFile(int nClass);
//
// GetBinderSpellToFeatDictionary
// Sets up the Binder Spell Dictionary that is used to match a binder's vestige
// to their feat. This is constructed based off the binder's known location of
// their feat and spell ranges in the base 2das respectivly. After constructing
// this it will be saved to the player locally as a cached result since we do
// not need to call this again.
//
// Argument:
// oPlayer:object the player
//
// Returns:
// json:Dictionary<String,Int> a dictionary of mapping between the SpellID
// and the FeatID of a vestige ability
//
json GetBinderSpellToFeatDictionary(object oPlayer=OBJECT_SELF);
//
// GetSpellLevelIcon
// Takes the spell circle int and gets the icon appropriate for it (i.e. 0 turns
// into "ir_cantrips"
//
// Arguments:
// spellLevel:int the spell level we want the icon for
//
// Returns:
// string the spell level icon
//
string GetSpellLevelIcon(int spellLevel);
//
// GetSpellLevelToolTip
// Gets the spell level tool tip text based on the int spell level provided (i.e.
// 0 turns into "Cantrips")
//
// Arguments:
// spellLevel:int the spell level we want the tooltip for
//
// Returns:
// string the spell level toop tip
//
string GetSpellLevelToolTip(int spellLevel);
//
// GetSpellIcon
// Gets the spell icon based off the spellId, or featId supplied
//
// Arguments:
// nClass:int the class Id
// featId:int the featId we can use the icon for
// spellId:int the spell Id we want the icon for
//
// Returns:
// json:String the string of the icon we want.
//
json GetSpellIcon(int spellId, int featId=0, int nClass=0);
string GetSpellName(int spellId, int realSpellID=0, int featId=0, int nClass=0);
//
// GreyOutButton
// Takes NUI Button along with it's width and height and greys it out it with a drawn
// colored rectangle to represent it's not been selected or not valid.
//
// Arguments:
// jButton:json the NUI Button
// w:float the width of the button
// h:float the height of the button
//
// Returns:
// json the NUI button greyed out
//
json GreyOutButton(json jButton, float w, float h);
//
// CreateGreyOutRectangle
// Creates a grey out rectangle for buttons
//
// Arguments:
// w:float the width of the button
// h:float the height of the button
//
// Returns:
// json the transparant black rectangle
//
json CreateGreyOutRectangle(float w, float h);
void CreateSpellDescriptionNUI(object oPlayer, int featID, int spellId=0, int realSpellId=0, int nClass=0);
void ClearSpellDescriptionNUI(object oPlayer=OBJECT_SELF);
int GetCurrentSpellLevel(int nClass, int nLevel)
{
int currentLevel = nLevel;
// ToB doesn't have a concept of spell levels, but still match up to it
if(nClass == CLASS_TYPE_WARBLADE
|| nClass == CLASS_TYPE_SWORDSAGE
|| nClass == CLASS_TYPE_CRUSADER
|| nClass == CLASS_TYPE_SHADOWCASTER)
{
return 9;
}
// Binders don't really have a concept of spell level
if (nClass == CLASS_TYPE_BINDER
|| nClass == CLASS_TYPE_DRAGON_SHAMAN) // they can only reach 1st circle
return 1;
//Shadowsmith has no concept of spell levels
if (nClass == CLASS_TYPE_SHADOWSMITH)
return 2;
if (nClass == CLASS_TYPE_WARLOCK
|| nClass == CLASS_TYPE_DRAGONFIRE_ADEPT)
return 4;
// Spont casters have their own function
if(GetSpellbookTypeForClass(nClass) == SPELLBOOK_TYPE_SPONTANEOUS
|| nClass == CLASS_TYPE_ARCHIVIST)
{
int maxLevel = GetMaxSpellLevelForCasterLevel(nClass, currentLevel);
return maxLevel;
}
else
{
// everyone else uses this
string spellLevel2da = GetAMSKnownFileName(nClass);
currentLevel = nLevel - 1; // Level is 1 off of the row in the 2da
if (nClass == CLASS_TYPE_FIST_OF_ZUOKEN
|| nClass == CLASS_TYPE_PSION
|| nClass == CLASS_TYPE_PSYWAR
|| nClass == CLASS_TYPE_WILDER
|| nClass == CLASS_TYPE_PSYCHIC_ROGUE
|| nClass == CLASS_TYPE_WARMIND)
currentLevel = GetManifesterLevel(OBJECT_SELF, nClass, TRUE) - 1;
int totalLevel = Get2DARowCount(spellLevel2da);
// in case we somehow go over bounds just don't :)
if (currentLevel >= totalLevel)
currentLevel = totalLevel - 1;
//Psionics have MaxPowerLevel as their column name
string columnName = "MaxPowerLevel";
//Invokers have MaxInvocationLevel
if (nClass == CLASS_TYPE_WARLOCK
|| nClass == CLASS_TYPE_DRAGON_SHAMAN
|| nClass == CLASS_TYPE_DRAGONFIRE_ADEPT)
columnName = "MaxInvocationLevel";
// Truenamers have 3 sets of utterances, ranging from 1-6, EvolvingMind covers the entire range
if (nClass == CLASS_TYPE_TRUENAMER)
{
columnName = "EvolvingMind";
spellLevel2da = "cls_true_maxlvl"; //has a different 2da we want to look at
}
if (nClass == CLASS_TYPE_BINDER)
{
columnName = "VestigeLvl";
spellLevel2da = "cls_bind_binder";
}
// ToB doesn't have a concept of this, but we don't care.
int maxLevel = StringToInt(Get2DACache(spellLevel2da, columnName, currentLevel));
return maxLevel;
}
}
int GetMinSpellLevel(int nClass)
{
// again sponts have their own function
if(GetSpellbookTypeForClass(nClass) == SPELLBOOK_TYPE_SPONTANEOUS
|| nClass == CLASS_TYPE_ARCHIVIST)
{
return GetMinSpellLevelForCasterLevel(nClass, GetHighestLevelPossibleInClass(nClass));
}
else
{
if (nClass == CLASS_TYPE_FIST_OF_ZUOKEN
|| nClass == CLASS_TYPE_PSION
|| nClass == CLASS_TYPE_PSYWAR
|| nClass == CLASS_TYPE_WILDER
|| nClass == CLASS_TYPE_PSYCHIC_ROGUE
|| nClass == CLASS_TYPE_WARMIND
|| nClass == CLASS_TYPE_WARBLADE
|| nClass == CLASS_TYPE_SWORDSAGE
|| nClass == CLASS_TYPE_CRUSADER
|| nClass == CLASS_TYPE_WARLOCK
|| nClass == CLASS_TYPE_DRAGONFIRE_ADEPT
|| nClass == CLASS_TYPE_DRAGON_SHAMAN
|| nClass == CLASS_TYPE_SHADOWCASTER
|| nClass == CLASS_TYPE_SHADOWSMITH
|| nClass == CLASS_TYPE_BINDER)
return 1;
return GetCurrentSpellLevel(nClass, 1);
}
}
int GetMaxSpellLevel(int nClass)
{
if (nClass == CLASS_TYPE_WILDER
|| nClass == CLASS_TYPE_PSION)
return 9;
if (nClass == CLASS_TYPE_PSYCHIC_ROGUE
|| nClass == CLASS_TYPE_FIST_OF_ZUOKEN
|| nClass == CLASS_TYPE_WARMIND)
return 5;
if (nClass == CLASS_TYPE_PSYWAR)
return 6;
return GetCurrentSpellLevel(nClass, GetHighestLevelPossibleInClass(nClass));
}
int GetHighestLevelPossibleInClass(int nClass)
{
string sFile;
//sponts have their spells in the classes.2da
if(GetSpellbookTypeForClass(nClass) == SPELLBOOK_TYPE_SPONTANEOUS
|| nClass == CLASS_TYPE_ARCHIVIST)
{
sFile = Get2DACache("classes", "SpellGainTable", nClass);
}
else
{
// everyone else uses this
sFile = GetAMSKnownFileName(nClass);
if (nClass == CLASS_TYPE_TRUENAMER)
{
sFile = "cls_true_maxlvl"; //has a different 2da we want to look at
}
if (nClass == CLASS_TYPE_BINDER)
{
sFile = "cls_bind_binder";
}
}
return Get2DARowCount(sFile);
}
string GetClassSpellbookFile(int nClass)
{
string sFile;
// Spontaneous casters use a specific file name structure
if(GetSpellbookTypeForClass(nClass) == SPELLBOOK_TYPE_SPONTANEOUS
|| nClass == CLASS_TYPE_ARCHIVIST)
{
sFile = GetFileForClass(nClass);
}
// everyone else uses this structure
else
{
sFile = GetAMSDefinitionFileName(nClass);
if (nClass == CLASS_TYPE_BINDER)
{
sFile = "vestiges";
}
}
return sFile;
}
string GetSpellLevelIcon(int spellLevel)
{
switch (spellLevel)
{
case 0: return "ir_cantrips";
case 1: return "ir_level1";
case 2: return "ir_level2";
case 3: return "ir_level3";
case 4: return "ir_level4";
case 5: return "ir_level5";
case 6: return "ir_level6";
case 7: return "ir_level789";
case 8: return "ir_level789";
case 9: return "ir_level789";
}
return "";
}
string GetSpellLevelToolTip(int spellLevel)
{
switch (spellLevel)
{
case 0: return "Cantrips";
case 1: return "Level 1";
case 2: return "Level 2";
case 3: return "Level 3";
case 4: return "Level 4";
case 5: return "Level 5";
case 6: return "Level 6";
case 7: return "Level 7";
case 8: return "Level 8";
case 9: return "Level 9";
}
return "";
}
json GetSpellIcon(int spellId,int featId=0,int nClass=0)
{
// Binder's spells don't have the FeatID on the spells.2da, so we have to use
// the mapping we constructed to get it.
if (nClass == CLASS_TYPE_BINDER)
{
json binderDict = GetBinderSpellToFeatDictionary();
int nFeatID = JsonGetInt(JsonObjectGet(binderDict, IntToString(spellId)));
return JsonString(Get2DACache("feat", "Icon", featId));
}
if (featId)
return JsonString(Get2DACache("feat", "Icon", featId));
int masterSpellID = StringToInt(Get2DACache("spells", "Master", spellId));
// if this is a sub radial spell, then we use spell's icon instead
if (masterSpellID)
return JsonString(Get2DACache("spells", "IconResRef", spellId));
// the FeatID holds the accurate spell icon, not the SpellID
int nFeatID = StringToInt(Get2DACache("spells", "FeatID", spellId));
return JsonString(Get2DACache("feat", "Icon", nFeatID));
}
string GetSpellName(int spellId, int realSpellID=0, int featId=0, int nClass=0)
{
if ((nClass == CLASS_TYPE_SHADOWSMITH
|| nClass == CLASS_TYPE_SHADOWCASTER) && spellId)
return GetStringByStrRef(StringToInt(Get2DACache("spells", "Name", spellId)));
if (nClass == CLASS_TYPE_TRUENAMER && featId)
return GetStringByStrRef(StringToInt(Get2DACache("feat", "FEAT", featId)));
if (realSpellID)
return GetStringByStrRef(StringToInt(Get2DACache("spells", "Name", realSpellID)));
if (spellId)
return GetStringByStrRef(StringToInt(Get2DACache("spells", "Name", spellId)));
if (featId)
return GetStringByStrRef(StringToInt(Get2DACache("feat", "FEAT", featId)));
return GetStringByStrRef(StringToInt(Get2DACache("spells", "Name", spellId)));
}
json GetBinderSpellToFeatDictionary(object oPlayer=OBJECT_SELF)
{
// a dictionary of <SpellID, FeatID>
json binderDict = GetLocalJson(oPlayer, NUI_SPELLBOOK_BINDER_DICTIONARY_CACHE_VAR);
// if this hasn't been created, create it now.
if (binderDict == JsonNull())
binderDict = JsonObject();
else
return binderDict;
// the starting row for binder spells
int spellIndex = 19070;
// the starting row for binder feats
int featIndex = 9030;
//the end of the binder spells/feats
while (spellIndex <= 19156 && featIndex <= 9104)
{
// get the SpellID tied to the feat
int spellID = StringToInt(Get2DACache("feat", "SPELLID", featIndex));
// if the spellID matches the current index, then this is the spell
// attached to the feat
if (spellID == spellIndex)
{
binderDict = JsonObjectSet(binderDict, IntToString(spellID), JsonInt(featIndex));
// move to next spell/feat
featIndex++;
spellIndex++;
}
// else we have reached a subdial spell
else
{
// loop through until we reach back at spellID
while (spellIndex < spellID)
{
int masterSpell = StringToInt(Get2DACache("spells", "Master", spellIndex));
// add the sub radial to the dict, tied to the master's FeatID
int featId = JsonGetInt(JsonObjectGet(binderDict, IntToString(masterSpell)));
binderDict = JsonObjectSet(binderDict, IntToString(spellIndex), JsonInt(featId));
spellIndex++;
}
// some feats overlap the same FeatID, can cause this to get stuck.
// if it happens then move on
if (spellIndex > spellID)
featIndex++;
}
}
// cache the result
SetLocalJson(oPlayer, NUI_SPELLBOOK_BINDER_DICTIONARY_CACHE_VAR, binderDict);
return binderDict;
}
json GreyOutButton(json jButton, float w, float h)
{
json retValue = jButton;
json jBorders = JsonArray();
jBorders = JsonArrayInsert(jBorders, CreateGreyOutRectangle(w, h));
return NuiDrawList(jButton, JsonBool(FALSE), jBorders);
}
json CreateGreyOutRectangle(float w, float h)
{
// set the points of the button shape
json jPoints = JsonArray();
jPoints = JsonArrayInsert(jPoints, JsonFloat(0.0));
jPoints = JsonArrayInsert(jPoints, JsonFloat(0.0));
jPoints = JsonArrayInsert(jPoints, JsonFloat(0.0));
jPoints = JsonArrayInsert(jPoints, JsonFloat(h));
jPoints = JsonArrayInsert(jPoints, JsonFloat(w));
jPoints = JsonArrayInsert(jPoints, JsonFloat(h));
jPoints = JsonArrayInsert(jPoints, JsonFloat(w));
jPoints = JsonArrayInsert(jPoints, JsonFloat(0.0));
jPoints = JsonArrayInsert(jPoints, JsonFloat(0.0));
jPoints = JsonArrayInsert(jPoints, JsonFloat(0.0));
return NuiDrawListPolyLine(JsonBool(TRUE), NuiColor(0, 0, 0, 127), JsonBool(TRUE), JsonFloat(2.0), jPoints);
}
void CreateSpellDescriptionNUI(object oPlayer, int featID, int spellId=0, int realSpellId=0, int nClass=0)
{
SetLocalInt(oPlayer, NUI_SPELL_DESCRIPTION_FEATID_VAR, featID);
SetLocalInt(oPlayer, NUI_SPELL_DESCRIPTION_SPELLID_VAR, spellId);
SetLocalInt(oPlayer, NUI_SPELL_DESCRIPTION_REAL_SPELLID_VAR, realSpellId);
SetLocalInt(oPlayer, NUI_SPELL_DESCRIPTION_CLASSID_VAR, nClass);
ExecuteScript("prc_nui_dsc_view", oPlayer);
}
void ClearSpellDescriptionNUI(object oPlayer=OBJECT_SELF)
{
DeleteLocalInt(oPlayer, NUI_SPELL_DESCRIPTION_FEATID_VAR);
DeleteLocalInt(oPlayer, NUI_SPELL_DESCRIPTION_SPELLID_VAR);
DeleteLocalInt(oPlayer, NUI_SPELL_DESCRIPTION_REAL_SPELLID_VAR);
DeleteLocalInt(oPlayer, NUI_SPELL_DESCRIPTION_CLASSID_VAR);
}

View File

@ -1,158 +0,0 @@
//::///////////////////////////////////////////////
//:: NUI Constants
//:: prc_nui_consts
//:://////////////////////////////////////////////
/*
This file holds all the constants used by the various PRC NUI scripts.
*/
//:://////////////////////////////////////////////
//:: Created By: Rakiov
//:: Created On: 24.05.2005
//:://////////////////////////////////////////////
const int NUI_PAYLOAD_BUTTON_LEFT_CLICK = 0;
const int NUI_PAYLOAD_BUTTON_MIDDLE_CLICK = 1;
const int NUI_PAYLOAD_BUTTON_RIGHT_CLICK = 2;
//////////////////////////////////////////////////
// //
// NUI Spellbook //
// //
//////////////////////////////////////////////////
// This is the NUI Spellbook window ID
const string PRC_SPELLBOOK_NUI_WINDOW_ID = "prcSpellbookNui";
// This is the base Id for the Class buttons in the NUI Spellbook, the ID will
// have the ClassID attached to it (i.e. spellbookClassButton_123)
const string PRC_SPELLBOOK_NUI_CLASS_BUTTON_BASEID = "spellbookClassButton_";
// This is the base Id for the Spell Circle buttons in the NUI Spellbook, the ID will
// have the Circle attached to it (i.e. spellbookCircleButton__6)
const string PRC_SPELLBOOK_NUI_CIRCLE_BUTTON_BASEID = "spellbookCircleButton_";
// This is the base Id for the Spell Buttons in the NUI Spellbook, the ID will
// have the SpellbookId (the row of the class's spell's 2da or equivalent)
// attached to it (i.e. spellbookSpellButton_6)
const string PRC_SPELLBOOK_NUI_SPELL_BUTTON_BASEID = "spellbookSpellButton_";
// This is the base Id for the Meta Feat buttons in the NUI Spellbook, the ID will
// have the FeatID attached to it (i.e. spellbookMetaButton_12345)
const string PRC_SPELLBOOK_NUI_META_BUTTON_BASEID = "spellbookMetaButton_";
// This is the selected ClassID var used to store what class was selected to the Player
// locally
const string PRC_SPELLBOOK_SELECTED_CLASSID_VAR = "prcSpellbookSelectedClassID";
// This is the selected Circle var used to store what spell circle was selected
// to the Player locally
const string PRC_SPELLBOOK_SELECTED_CIRCLE_VAR = "prcSpellbookSelectedCircle";
// This is the Spellbook NUI geomeotry var, used to allow the location and sizing
// of the NUI to be remembered if it is ever rerendered.
const string PRC_SPELLBOOK_NUI_GEOMETRY_VAR = "sbNuiGeometry";
// This is the Selected SpellID Var, used to tell the OnTarget script what spell
// we are using after manual targetting
const string NUI_SPELLBOOK_SELECTED_SPELLID_VAR = "NUI_Spellbook_SpellId";
// This is the Selected FeatID Var, used to tell the OnTarget script what feat
// we are using after manual targetting
const string NUI_SPELLBOOK_SELECTED_FEATID_VAR = "NUI_Spellbook_FeatID";
// This is the Selected SubSpellID Var, used in conjuncture with the Selected FeatID
// to allow radial spells to work (it needs the master spell's featID and the sub spell's
// SpellID for it to work.
const string NUI_SPELLBOOK_SELECTED_SUBSPELL_SPELLID_VAR = "NUI_Spellbook_SubSpellID";
// This is the OnTarget action var saved to the player locally to say if we are
// using the NUI Spellbook spell or not.
const string NUI_SPELLBOOK_ON_TARGET_ACTION_VAR = "ONPLAYERTARGET_ACTION";
// This is a Boolean to tell the target script if the selected feat is a persoanl feat
// and can only be used on the executing object.
const string NUI_SPELLBOOK_ON_TARGET_IS_PERSONAL_FEAT = "NUI_Spellbook_IsPersonalFeat";
const string NUI_SPELL_DESCRIPTION_WINDOW_ID = "NUI_Spell_Description";
const string NUI_SPELL_DESCRIPTION_OK_BUTTON = "NUIDescriptionOKButton";
// This is the limit of how many spell buttons we can have in a row before we
// need to start a new row on the NUI Spellbook.
const int NUI_SPELLBOOK_SPELL_BUTTON_LENGTH = 9;
const string NUI_SPELLBOOK_BINDER_DICTIONARY_CACHE_VAR = "NUI_Spellbook_GetBinderSpellToFeatDictionaryCache";
const string NUI_SPELLBOOK_CLASS_STANCES_CACHE_BASE_VAR = "NUI_Spellbook_GetToBStanceSpellListCache_";
const string NUI_SPELLBOOK_CLASS_SHAPES_CACHE_BASE_VAR = "NUI_Spellbook_GetInvokerShapeSpellListCache_";
const string NUI_SPELLBOOK_CLASS_ESSENCE_CACHE_BASE_VAR = "NUISpellbookClassEssence_";
//////////////////////////////////////////////////
// //
// NUI Power Attack //
// //
//////////////////////////////////////////////////
// The Window ID for the Power Attack NUI
const string NUI_PRC_POWER_ATTACK_WINDOW = "nui_prc_power_attack_window";
// LocalVar for the geometry of the Power Attack NUI window
const string NUI_PRC_PA_GEOMETRY_VAR = "paNuiGeometry";
// Event For Left "-" button of the Power Attack NUI
const string NUI_PRC_PA_LEFT_BUTTON_EVENT = "nui_prc_pa_left_button_event";
// Event For Right "+" Button of the Power Attack NUI
const string NUI_PRC_PA_RIGHT_BUTTON_EVENT = "nui_prc_pa_right_button_event";
// Bind for Text of the Power Attack NUI saying what the current Power Attack level is
const string NUI_PRC_PA_TEXT_BIND = "nui_prc_pa_text_bind";
// Left Button Enabled Bind for Power Attack NUI
const string NUI_PRC_PA_LEFT_BUTTON_ENABLED_BIND = "leftButtonEnabled";
// Right Button Enabled Bind for Power Attack NUI
const string NUI_PRC_PA_RIGHT_BUTTON_ENABLED_BIND = "rightButtonEnabled";
//////////////////////////////////////////////////
// //
// NUI Level Up //
// //
//////////////////////////////////////////////////
const string NUI_LEVEL_UP_WINDOW_ID = "prcLevelUpNui";
const string NUI_LEVEL_UP_SPELL_CIRCLE_BUTTON_BASEID = "NuiLevelUpCircleButton_";
const string NUI_LEVEL_UP_SPELL_BUTTON_BASEID = "NuiLevelUpSpellButton_";
const string NUI_LEVEL_UP_SPELL_DISABLED_BUTTON_BASEID = "NuiLevelUpDisabledSpellButton_";
const string NUI_LEVEL_UP_SPELL_CHOSEN_BUTTON_BASEID = "NuiLevelUpChosenSpellButton_";
const string NUI_LEVEL_UP_SPELL_CHOSEN_DISABLED_BUTTON_BASEID = "NuiLevelUpDisabledChosenSpellButton_";
const string NUI_LEVEL_UP_DONE_BUTTON = "NuiLevelUpDoneButton";
const string NUI_LEVEL_UP_RESET_BUTTON = "NuiLevelUpResetButton";
const string NUI_LEVEL_UP_SELECTED_CLASS_VAR = "NUILevelUpSelectedClass";
const string NUI_LEVEL_UP_SELECTED_CIRCLE_VAR = "NUILevelUpSelectedCircle";
const string NUI_LEVEL_UP_KNOWN_SPELLS_VAR = "NUILevelUpKnownSpells";
const string NUI_LEVEL_UP_CHOSEN_SPELLS_VAR = "NUILevelUpChosenSpells";
const string NUI_LEVEL_UP_EXPANDED_KNOW_LIST_VAR = "NUILevelUpExpKnowList";
const string NUI_LEVEL_UP_POWER_LIST_VAR = "NUILevelUpPowerList";
const string NUI_LEVEL_UP_DISCIPLINE_INFO_VAR = "GetDisciplineInfoObjectCache_";
const string NUI_LEVEL_UP_SPELLID_LIST_VAR = "NUILevelUpSpellIDList_";
const string NUI_LEVEL_UP_REMAINING_CHOICES_CACHE_VAR = "NUIRemainingChoicesCache";
const string NUI_LEVEL_UP_RELEARN_LIST_VAR = "NUILevelUpRelearnList";
const string NUI_LEVEL_UP_ARCHIVIST_NEW_SPELLS_LIST_VAR = "NUILevelUpArchivistNewSpellsList";
const string NUI_LEVEL_UP_EXPANDED_CHOICES_VAR = "NUIExpandedChoices";
const string NUI_LEVEL_UP_EPIC_EXPANDED_CHOICES_VAR = "NUIEpicExpandedChoices";
const int NUI_LEVEL_UP_MANEUVER_PREREQ_LIMIT = 6;
const string NUI_LEVEL_UP_MANEUVER_TOTAL = "ManeuverTotal";
const string NUI_LEVEL_UP_STANCE_TOTAL = "StanceTotal";
const string NUI_LEVEL_UP_SPELLBOOK_OBJECT_CACHE_VAR = "GetSpellListObjectCache_";
const string NUI_LEVEL_UP_KNOWN_INVOCATIONS_CACHE_VAR = "GetInvokerKnownListObjectCache_";
const string NUI_SPELL_DESCRIPTION_FEATID_VAR = "NUISpellDescriptionFeatID";
const string NUI_SPELL_DESCRIPTION_CLASSID_VAR = "NUISpellDescriptionClassID";
const string NUI_SPELL_DESCRIPTION_SPELLID_VAR = "NUISpellDescriptionSpellID";
const string NUI_SPELL_DESCRIPTION_REAL_SPELLID_VAR = "NUISpellDescriptionRealSpellID";

File diff suppressed because it is too large Load Diff

View File

@ -1,845 +0,0 @@
//::///////////////////////////////////////////////
//:: PRC Spellbook Script
//:: prc_nui_sb_inc
//:://////////////////////////////////////////////
/*
This is the script that handles some backend work for the PRC Spellbook
NUI View
*/
//:://////////////////////////////////////////////
//:: Created By: Rakiov
//:: Created On: 24.05.2005
//:://////////////////////////////////////////////
#include "prc_nui_com_inc"
//
// GetSpellListForCircle
// Gets the spell list for a specified class at the specified circle.
//
// Arguments:
// oPlayer:object the player
// nClass:int the ClassID
// circle:int the circle we want to grab for
//
// Returns:
// json:Array<int> a list of all the spellIDs of the given circle
//
json GetSpellListForCircle(object oPlayer, int nClass, int circle);
//
// GetSupportedNUISpellbookClasses
// Gets the list of support PRC classes that can use the NUi spellbook that
// the player has.
//
// Arguments:
// oPlayer:object the player this is being determined for
//
// Returns:
// json:int list of class ids that have the player has that can use the
// NUI spellbook.
//
json GetSupportedNUISpellbookClasses(object oPlayer);
//
// IsSpellKnown
// Returns whether the player with the given class, spell file, and spellbook id
// knows the spell or not
//
// Arguments:
// oPlayer;Object the player
// nClass:int the class ID
// spellId:int the spell ID to check
//
// Returns:
// int:Boolean TRUE if spell is known, FALSE otherwise
//
int IsSpellKnown(object oPlayer, int nClass, int spellId);
//
// IsClassAllowedToUseNUISpellbook
// Takes a player and a classId and determines if thee class is allowed to
// be using the NUI spellbook.
//
// Arguments:
// oPlayer:Object the player
// nClass:int the ClassID
//
// Returns:
// int:Boolean TRUE if allowed to use the spellbook, FALSE otherwise
//
int IsClassAllowedToUseNUISpellbook(object oPlayer, int nClass);
//
// CanClassUseMetamagicFeats
// Given a class id determines if it is allowed to use the Metamagic feats
//
// Arguments:
// nClass:int the ClassID
//
// Returns:
// int:Boolean TRUE if allowed to use the set of feats, FALSE otherwise
//
int CanClassUseMetamagicFeats(int nClass);
//
// CanClassUseSuddenMetamagicFeats
// Given a class id determines if it is allowed to use the Sudden Metamagic feats
//
// Arguments:
// nClass:int the ClassID
//
// Returns:
// int:Boolean TRUE if allowed to use the set of feats, FALSE otherwise
//
int CanClassUseSuddenMetamagicFeats(int nClass);
//
// CanClassUseMetaPsionicFeats
// Given a class id determines if it is allowed to use the MetaPsionic feats
//
// Arguments:
// nClass:int the ClassID
//
// Returns:
// int:Boolean TRUE if allowed to use the set of feats, FALSE otherwise
//
int CanClassUseMetaPsionicFeats(int nClass);
//
// CanClassUseMetaMysteryFeats
// Given a class id determines if it is allowed to use the MetaMystery feats
//
// Arguments:
// nClass:int the ClassID
//
// Returns:
// int:Boolean TRUE if allowed to use the set of feats, FALSE otherwise
//
int CanClassUseMetaMysteryFeats(int nClass);
//
// GetMetaMagicFeatList
// Gets the list of MetaMagic featIDs
//
// Returns:
// json:Array<int> the list of FeatIDs associated with the meta feats
//
json GetMetaMagicFeatList();
//
// GetSuddenMetaMagicFeatList
// Gets the list of Sudden MetaMagic featIDs
//
// Returns:
// json:Array<int> the list of FeatIDs associated with the meta feats
//
json GetSuddenMetaMagicFeatList();
//
// GetMetaPsionicFeatList
// Gets the list of MetaPsionic featIDs
//
// Returns:
// json:Array<int> the list of FeatIDs associated with the meta feats
//
json GetMetaPsionicFeatList();
//
// GetMetaMagicMysteryList
// Gets the list of MetaMystery featIDs
//
// Returns:
// json:Array<int> the list of FeatIDs associated with the meta feats
//
json GetMetaMysteryFeatList();
//
// GetTrueClassIfRHD
// Checks to make sure if the provided RHD class and player's race
// match up to give them their proper spell caster class (ie Glouras have
// bard spells and thus should be treated like a bard class)
//
// Arguments:
// oPlayer:object the player
// nClass:int the ClassID
//
// Returns:
// int the true ClassID to use, otherwise nClass
//
int GetTrueClassIfRHD(object oPlayer, int nClass);
//
// ShouldAddSpell
// Given a spellId and a class, determines if the spell should be added to the
// spellbook (as some are added in it's own special row or for other reasons)
//
// Arguments:
// nClass:int the ClassID
// spellId:int the SpellID
// oPlayer:object the player
//
// Returns:
// int:Boolean TRUE if the spell should be added, FALSE otherwise
//
int ShouldAddSpell(int nClass, int spellId, object oPlayer=OBJECT_SELF);
//
// GetToBStanceSpellList
// Gets the ToB Stance Spell List for the given class
//
// Arguments:
// nClass:int ClassID
// oPlayer:object the player
//
// Returns:
// json:Array<Int> the list of stances' SpellIDs
//
json GetToBStanceSpellList(int nClass, object oPlayer=OBJECT_SELF);
//
// GetInvokerShapeSpellList
// Gets the Invoker Shapes Spell List for the given class
//
// Arguments:
// nClass:int ClassID
// oPlayer:object the player
//
// Returns:
// json:Array<Int> the list of shapes' SpellIDs
//
json GetInvokerShapeSpellList(int nClass, object oPlayer=OBJECT_SELF);
//
// GetInvokerEssenceSpellList
// Gets the Invoker Essences Spell List for the given class
//
// Arguments:
// nClass:int ClassID
// oPlayer:object the player
//
// Returns:
// json:Array<Int> the list of essences' SpellIDs
//
json GetInvokerEssenceSpellList(int nClass, object oPlayer=OBJECT_SELF);
//
// JsonArrayContainsInt
// A helper function that takes a json array list and sees if the int item is within i
//
// Arguments:
// list:json:Array<Int> the list of ints
// item:int the item we are looking for
//
// Returns:
// int:Boolean TRUE if item is found, FALSE otherwise
//
int JsonArrayContainsInt(json list, int item);
//
// IsSpellbookNUIOpen
// Checks to see if the Spellbook NUI is open on a given player.
//
// Arguments:
// oPC:object the player
//
// Returns:
// int:Boolean TRUE if window is open, FALSE otherwise
//
int IsSpellbookNUIOpen(object oPC);
json GetSpellListForCircle(object oPlayer, int nClass, int circle)
{
json retValue = JsonArray();
string sFile = GetClassSpellbookFile(nClass);
int totalSpells;
json binderDictKeys;
//Special case for Binder since they don't have their own spellbook 2da
if (nClass == CLASS_TYPE_BINDER)
{
json binderDict = GetBinderSpellToFeatDictionary(oPlayer);
// we loop through the list of SpellIDs
binderDictKeys = JsonObjectKeys(binderDict);
totalSpells = JsonGetLength(binderDictKeys);
}
else
totalSpells = Get2DARowCount(sFile);
int i;
for (i = 0; i < totalSpells; i++)
{
int currentSpell;
if (nClass == CLASS_TYPE_BINDER)
currentSpell = StringToInt(JsonGetString(JsonArrayGet(binderDictKeys, i)));
else
currentSpell = StringToInt(Get2DACache(sFile, "SpellID", i));
if (ShouldAddSpell(nClass, currentSpell, oPlayer))
{
string sSpellLevel = Get2DACache("spells", "Innate", currentSpell);
int iSpellLevel = StringToInt(sSpellLevel);
if (nClass == CLASS_TYPE_BINDER && IsSpellKnown(oPlayer, nClass, currentSpell))
{
retValue = JsonArrayInsert(retValue, JsonInt(currentSpell));
}
else if ((iSpellLevel == circle && IntToString(iSpellLevel) == sSpellLevel))
{
// We add the spell if it is known and is not a radial master spell (since those don't work)
if (IsSpellKnown(oPlayer, nClass, currentSpell))
retValue = JsonArrayInsert(retValue, JsonInt(i));
}
}
}
return retValue;
}
int ShouldAddSpell(int nClass, int spellId, object oPlayer=OBJECT_SELF)
{
int isRadialMasterSpell = StringToInt(Get2DACache("spells", "SubRadSpell1", spellId));
// We don't add radial master spells
if (isRadialMasterSpell)
return FALSE;
// we don't add essences and shapes
if (nClass == CLASS_TYPE_WARLOCK
|| nClass == CLASS_TYPE_DRAGONFIRE_ADEPT
|| nClass == CLASS_TYPE_DRAGON_SHAMAN)
{
json ignoreList = GetInvokerShapeSpellList(nClass, oPlayer);
if (JsonArrayContainsInt(ignoreList, spellId))
return FALSE;
ignoreList = GetInvokerEssenceSpellList(nClass, oPlayer);
if (JsonArrayContainsInt(ignoreList, spellId))
return FALSE;
}
// we don't add stances
if (nClass == CLASS_TYPE_WARBLADE
|| nClass == CLASS_TYPE_SWORDSAGE
|| nClass == CLASS_TYPE_CRUSADER)
{
json ignoreList = GetToBStanceSpellList(nClass, oPlayer);
if (JsonArrayContainsInt(ignoreList, spellId))
return FALSE;
}
return TRUE;
}
json GetSupportedNUISpellbookClasses(object oPlayer)
{
json retValue = JsonArray();
int i = 1;
while(i >= 1)
{
int classId = GetClassByPosition(i, oPlayer);
if (classId != CLASS_TYPE_INVALID)
{
if (IsClassAllowedToUseNUISpellbook(oPlayer, classId))
{
classId = GetTrueClassIfRHD(oPlayer, classId);
retValue = JsonArrayInsert(retValue, JsonInt(classId));
}
i++;
}
else
{
i = -1;
}
}
return retValue;
}
int IsSpellKnown(object oPlayer, int nClass, int spellId)
{
// special case for Binders since they don't have a spell book 2da.
if (nClass == CLASS_TYPE_BINDER)
{
json binderDict = GetBinderSpellToFeatDictionary(oPlayer);
int featID = JsonGetInt(JsonObjectGet(binderDict, IntToString(spellId)));
return GetHasFeat(featID, oPlayer);
}
int currentSpell = spellId;
int masterSpell = StringToInt(Get2DACache("spells", "Master", currentSpell));
if (masterSpell) // If this is not 0 then this is a radial spell, check the radial master
currentSpell = masterSpell;
string sFeatID = Get2DACache("spells", "FeatID", currentSpell);
int iFeatID = StringToInt(sFeatID);
if (IntToString(iFeatID) == sFeatID)
return GetHasFeat(iFeatID, oPlayer);
return FALSE;
}
int IsClassAllowedToUseNUISpellbook(object oPlayer, int nClass)
{
// This controls who can use the Spellbook NUI, if for some reason you don't
// want a class to be allowed to use this you can comment out their line here
// Bard and Sorc are allowed if they took a PRC that makes them use the spellbook
if ((nClass == CLASS_TYPE_BARD || nClass == CLASS_TYPE_SORCERER)
&& GetPrCAdjustedClassLevel(nClass, oPlayer) > GetLevelByClass(nClass, oPlayer))
return TRUE;
// Arcane Spont
if (nClass == CLASS_TYPE_BEGUILER
|| nClass == CLASS_TYPE_CELEBRANT_SHARESS
|| nClass == CLASS_TYPE_DREAD_NECROMANCER
|| nClass == CLASS_TYPE_DUSKBLADE
|| nClass == CLASS_TYPE_HARPER
|| nClass == CLASS_TYPE_HEXBLADE
|| nClass == CLASS_TYPE_KNIGHT_WEAVE
|| nClass == CLASS_TYPE_SHADOWLORD
|| nClass == CLASS_TYPE_SUBLIME_CHORD
|| nClass == CLASS_TYPE_SUEL_ARCHANAMACH
|| nClass == CLASS_TYPE_WARMAGE)
return TRUE;
// Psionics
if (nClass == CLASS_TYPE_FIST_OF_ZUOKEN
|| nClass == CLASS_TYPE_PSION
|| nClass == CLASS_TYPE_PSYWAR
|| nClass == CLASS_TYPE_WILDER
|| nClass == CLASS_TYPE_PSYCHIC_ROGUE
|| nClass == CLASS_TYPE_WARMIND)
return TRUE;
// Invokers
if (nClass == CLASS_TYPE_WARLOCK
|| nClass == CLASS_TYPE_DRAGON_SHAMAN
|| nClass == CLASS_TYPE_DRAGONFIRE_ADEPT)
return TRUE;
// Divine Spont
if (nClass == CLASS_TYPE_ARCHIVIST //while technically prepared, they use the spont system of casting
|| nClass == CLASS_TYPE_FAVOURED_SOUL
|| nClass == CLASS_TYPE_JUSTICEWW)
return TRUE;
// ToB Classes
if (nClass == CLASS_TYPE_WARBLADE
|| nClass == CLASS_TYPE_SWORDSAGE
|| nClass == CLASS_TYPE_CRUSADER)
return TRUE;
// Mystery Classes
if (nClass == CLASS_TYPE_SHADOWCASTER
|| nClass == CLASS_TYPE_SHADOWSMITH)
return TRUE;
// Truenamers
if (nClass == CLASS_TYPE_TRUENAMER)
return TRUE;
// RHD Casters
if ((nClass == CLASS_TYPE_SHAPECHANGER
&& GetRacialType(oPlayer) == RACIAL_TYPE_ARANEA
&& !GetLevelByClass(CLASS_TYPE_SORCERER))
|| (nClass == CLASS_TYPE_OUTSIDER
&& GetRacialType(oPlayer) == RACIAL_TYPE_RAKSHASA
&& !GetLevelByClass(CLASS_TYPE_SORCERER))
|| (nClass == CLASS_TYPE_ABERRATION
&& GetRacialType(oPlayer) == RACIAL_TYPE_DRIDER
&& !GetLevelByClass(CLASS_TYPE_SORCERER))
|| (nClass == CLASS_TYPE_MONSTROUS
&& GetRacialType(oPlayer) == RACIAL_TYPE_ARKAMOI
&& !GetLevelByClass(CLASS_TYPE_SORCERER))
|| (nClass == CLASS_TYPE_MONSTROUS
&& GetRacialType(oPlayer) == RACIAL_TYPE_HOBGOBLIN_WARSOUL
&& !GetLevelByClass(CLASS_TYPE_SORCERER))
|| (nClass == CLASS_TYPE_MONSTROUS
&& GetRacialType(oPlayer) == RACIAL_TYPE_REDSPAWN_ARCANISS
&& !GetLevelByClass(CLASS_TYPE_SORCERER))
|| (nClass == CLASS_TYPE_MONSTROUS
&& GetRacialType(oPlayer) == RACIAL_TYPE_MARRUTACT
&& !GetLevelByClass(CLASS_TYPE_SORCERER))
|| (nClass == CLASS_TYPE_FEY
&& GetRacialType(oPlayer) == RACIAL_TYPE_GLOURA
&& !GetLevelByClass(CLASS_TYPE_BARD)))
return TRUE;
// Binders
if (nClass == CLASS_TYPE_BINDER)
return TRUE;
return FALSE;
}
int GetTrueClassIfRHD(object oPlayer, int nClass)
{
if (nClass == CLASS_TYPE_SHAPECHANGER
&& GetRacialType(oPlayer) == RACIAL_TYPE_ARANEA)
return CLASS_TYPE_SORCERER;
if (nClass == CLASS_TYPE_OUTSIDER
&& GetRacialType(oPlayer) == RACIAL_TYPE_RAKSHASA)
return CLASS_TYPE_SORCERER;
if (nClass == CLASS_TYPE_ABERRATION
&& GetRacialType(oPlayer) == RACIAL_TYPE_DRIDER)
return CLASS_TYPE_SORCERER;
if (nClass == CLASS_TYPE_MONSTROUS
&& GetRacialType(oPlayer) == RACIAL_TYPE_ARKAMOI)
return CLASS_TYPE_SORCERER;
if (nClass == CLASS_TYPE_MONSTROUS
&& GetRacialType(oPlayer) == RACIAL_TYPE_HOBGOBLIN_WARSOUL)
return CLASS_TYPE_SORCERER;
if (nClass == CLASS_TYPE_MONSTROUS
&& GetRacialType(oPlayer) == RACIAL_TYPE_REDSPAWN_ARCANISS)
return CLASS_TYPE_SORCERER;
if (nClass == CLASS_TYPE_MONSTROUS
&& GetRacialType(oPlayer) == RACIAL_TYPE_MARRUTACT)
return CLASS_TYPE_SORCERER;
if (nClass == CLASS_TYPE_FEY
&& GetRacialType(oPlayer) == RACIAL_TYPE_GLOURA)
return CLASS_TYPE_BARD;
return nClass;
}
int CanClassUseMetamagicFeats(int nClass)
{
// I don't want to spend the time looping through each class's
// feat 2da so this is the list of all classes that are allowed to use the
// Spellbook NUI and can use Metamagic
return (nClass == CLASS_TYPE_BARD
|| nClass == CLASS_TYPE_SORCERER
|| nClass == CLASS_TYPE_BEGUILER
|| nClass == CLASS_TYPE_DREAD_NECROMANCER
|| nClass == CLASS_TYPE_DUSKBLADE
|| nClass == CLASS_TYPE_HEXBLADE
|| nClass == CLASS_TYPE_JUSTICEWW
|| nClass == CLASS_TYPE_SUBLIME_CHORD
|| nClass == CLASS_TYPE_SUEL_ARCHANAMACH
|| nClass == CLASS_TYPE_FAVOURED_SOUL
|| nClass == CLASS_TYPE_WARMAGE);
}
int CanClassUseSuddenMetamagicFeats(int nClass)
{
// I don't want to spend the time looping through each class's
// feat 2da so this is the list of all classes that are allowed to use the
// Spellbook NUI and can use Sudden Metamagic
return (nClass == CLASS_TYPE_SHADOWLORD
|| nClass == CLASS_TYPE_ARCHIVIST
|| nClass == CLASS_TYPE_BARD
|| nClass == CLASS_TYPE_BEGUILER
|| nClass == CLASS_TYPE_DREAD_NECROMANCER
|| nClass == CLASS_TYPE_DUSKBLADE
|| nClass == CLASS_TYPE_FAVOURED_SOUL
|| nClass == CLASS_TYPE_HEXBLADE
|| nClass == CLASS_TYPE_JUSTICEWW
|| nClass == CLASS_TYPE_KNIGHT_WEAVE
|| nClass == CLASS_TYPE_SUBLIME_CHORD
|| nClass == CLASS_TYPE_SORCERER
|| nClass == CLASS_TYPE_SUEL_ARCHANAMACH
|| nClass == CLASS_TYPE_WARMAGE);
}
int CanClassUseMetaPsionicFeats(int nClass)
{
// I don't want to spend the time looping through each class's
// feat 2da so this is the list of all classes that are allowed to use the
// Spellbook NUI and can use Metapsionics
return (nClass == CLASS_TYPE_FIST_OF_ZUOKEN
|| nClass == CLASS_TYPE_PSION
|| nClass == CLASS_TYPE_PSYCHIC_ROGUE
|| nClass == CLASS_TYPE_PSYWAR
|| nClass == CLASS_TYPE_WARMIND
|| nClass == CLASS_TYPE_WILDER);
}
int CanClassUseMetaMysteryFeats(int nClass)
{
// I don't want to spend the time looping through each class's
// feat 2da so this is the list of all classes that are allowed to use the
// Spellbook NUI and can use Metamysteries
return (nClass == CLASS_TYPE_SHADOWCASTER
|| nClass == CLASS_TYPE_SHADOWSMITH);
}
json GetMetaMagicFeatList()
{
json metaFeats = JsonArray();
int spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_EXTEND_SPELL_ABILITY));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_EMPOWER_SPELL_ABILITY));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_MAXIMIZE_SPELL_ABILITY));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_QUICKEN_SPELL_ABILITY));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_STILL_SPELL_ABILITY));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_SILENT_SPELL_ABILITY));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
return metaFeats;
}
json GetSuddenMetaMagicFeatList()
{
json metaFeats = JsonArray();
int spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_SUDDEN_EXTEND));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_SUDDEN_EMPOWER));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_SUDDEN_MAXIMIZE));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_SUDDEN_WIDEN));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
return metaFeats;
}
json GetMetaPsionicFeatList()
{
json metaFeats = JsonArray();
int spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_EXTEND_POWER));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_EMPOWER_POWER));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_MAXIMIZE_POWER));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_QUICKEN_POWER));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_WIDEN_POWER));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_CHAIN_POWER));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_TWIN_POWER));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_SPLIT_PSIONIC_RAY));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
return metaFeats;
}
json GetMetaMysteryFeatList()
{
json metaFeats = JsonArray();
int spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_EXTEND_MYSTERY));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_EMPOWER_MYSTERY));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_MAXIMIZE_MYSTERY));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_QUICKEN_MYSTERY));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_STILL_MYSTERY));
metaFeats = JsonArrayInsert(metaFeats, JsonInt(spellId));
return metaFeats;
}
json GetToBStanceSpellList(int nClass, object oPlayer=OBJECT_SELF)
{
// caching
json stanceSpells = GetLocalJson(oPlayer, NUI_SPELLBOOK_CLASS_STANCES_CACHE_BASE_VAR + IntToString(nClass));
if (stanceSpells == JsonNull())
stanceSpells = JsonArray();
else
return stanceSpells;
string sFile = GetClassSpellbookFile(nClass);
int totalRows = Get2DARowCount(sFile);
int i;
for (i = 0; i < totalRows; i++)
{
int Type = StringToInt(Get2DACache(sFile, "Type", i));
if (Type == 1)
{
int spellId = StringToInt(Get2DACache(sFile, "SpellID", i));
stanceSpells = JsonArrayInsert(stanceSpells, JsonInt(spellId));
}
}
SetLocalJson(oPlayer, NUI_SPELLBOOK_CLASS_STANCES_CACHE_BASE_VAR + IntToString(nClass), stanceSpells);
return stanceSpells;
}
json GetInvokerShapeSpellList(int nClass, object oPlayer=OBJECT_SELF)
{
// caching
json shapeSpells = GetLocalJson(oPlayer, NUI_SPELLBOOK_CLASS_SHAPES_CACHE_BASE_VAR + IntToString(nClass));
if (shapeSpells == JsonNull())
shapeSpells = JsonArray();
else
return shapeSpells;
string sFile = GetClassSpellbookFile(nClass);
int totalRows = Get2DARowCount(sFile);
if (nClass == CLASS_TYPE_WARLOCK)
{
// Add the ELdritch Blast shapes
// TODO: Replace these magic SpellID ints with consts
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(INVOKE_ELDRITCH_BLAST));
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(18216)); // Eldritch Chain
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(18245)); // Eldritch Cone
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(18261)); // Eldritch Doom
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(18172)); // Glaive
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(18246)); // Eldritch Line
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(18173)); // Eldritch Spear
}
if (nClass == CLASS_TYPE_DRAGON_SHAMAN)
{
// Add the Dragon Shaman Auras
int spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_DRAGONSHAMAN_AURA_ENERGY));
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_DRAGONSHAMAN_AURA_ENERGYSHLD));
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_DRAGONSHAMAN_AURA_INSIGHT));
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_DRAGONSHAMAN_AURA_MAGICPOWER));
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_DRAGONSHAMAN_AURA_POWER));
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_DRAGONSHAMAN_AURA_PRESENCE));
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_DRAGONSHAMAN_AURA_RESISTANCE));
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_DRAGONSHAMAN_AURA_RESOLVE));
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_DRAGONSHAMAN_AURA_SENSES));
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_DRAGONSHAMAN_AURA_STAMINA));
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_DRAGONSHAMAN_AURA_SWIFTNESS));
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_DRAGONSHAMAN_AURA_TOUGHNESS));
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_DRAGONSHAMAN_AURA_VIGOR));
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(spellId));
}
if (nClass == CLASS_TYPE_DRAGONFIRE_ADEPT)
{
// Add Dragon Adept Breaths
// TODO: Replace these magic SpellID ints with consts
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(2102)); // Fire Cone
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(2103)); // Fire Line
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(2104)); // Frost Cone
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(2105)); // Electric Line
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(2106)); // Sickness Cone
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(2108)); // Acid Cone
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(2109)); // Acid Line
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(2111)); // Slow Cone
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(2112)); // Weakening Cone
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(2115)); // Sleep Cone
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(2116)); // Thunder Cone
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(2117)); // Bahamut Line
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(2118)); // Force Line
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(2119)); // Paralyzation Line
shapeSpells = JsonArrayInsert(shapeSpells, JsonInt(2120)); // Tiamat Breath
}
SetLocalJson(oPlayer, NUI_SPELLBOOK_CLASS_SHAPES_CACHE_BASE_VAR + IntToString(nClass), shapeSpells);
return shapeSpells;
}
json GetInvokerEssenceSpellList(int nClass, object oPlayer=OBJECT_SELF)
{
//caching
json essenceSpells = GetLocalJson(oPlayer, NUI_SPELLBOOK_CLASS_ESSENCE_CACHE_BASE_VAR + IntToString(nClass));
if (essenceSpells == JsonNull())
essenceSpells = JsonArray();
else
return essenceSpells;
if (nClass == CLASS_TYPE_WARLOCK)
{
// Add Eldritch Essences
// TODO: Replace these magic SpellID ints with consts
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18177)); // Hideous Blow
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18189)); // Baneful Abberation
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18190)); // Baneful Beast
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18191)); // Baneful Construct
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18192)); // Baneful Dragon
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18193)); // Baneful Dwarf
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18194)); // Baneful Elemental
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18195)); // Baneful Elf
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18196)); // baneful Fey
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18197)); // Baneful Giant
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18198)); // Baneful Goblinoid
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18199)); // Baneful Gnome
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18200)); // Baneful Halfling
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18201)); // Baneful Human
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18202)); // Baneful Monsterous
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18203)); // Baneful Orc
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18204)); // Baneful Outsider
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18205)); // Baneful Plant
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18206)); // Baneful Reptilian
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18207)); // Baneful Shapechanger
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18208)); // Baneful Undead
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18209)); // Baneful Vermin
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18210)); // Beshadowed Blast
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18240)); // Bewitching Blast
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18257)); // Binding Blast
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18211)); // Brimstone Blast
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18175)); // Frightful Blast
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18176)); // Hammer Blast
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18183)); // Sickening Blast
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(INVOKE_HEALING_BLAST));
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(INVOKE_HELLFIRE_BLAST));
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(INVOKE_HELLFIRE_BLOW));
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(INVOKE_HELLFIRE_CHAIN));
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(INVOKE_HELLFIRE_CONE));
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(INVOKE_HELLFIRE_DOOM));
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(INVOKE_HELLFIRE_GLAIVE));
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(INVOKE_HELLFIRE_LINE));
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(INVOKE_HELLFIRE_SPEAR));
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18220)); // Hellrime Blast
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18177)); // Hideous Blow
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18249)); // Hindering Blast
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18251)); // Noxious Blast
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18253)); // Penetrating Blast
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18267)); // Utterdark Blast
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(18255)); // Vitriolic Blast
}
if (nClass == CLASS_TYPE_DRAGONFIRE_ADEPT)
{
// Add the Dragonfire Adept Shapes
int spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_SHAPED_ADEPTBREATH));
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_CLOUD_ADEPTBREATH));
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(spellId));
spellId = StringToInt(Get2DACache("feat", "SPELLID", FEAT_ENDURE_ADEPTBREATH));
essenceSpells = JsonArrayInsert(essenceSpells, JsonInt(spellId));
}
SetLocalJson(oPlayer, NUI_SPELLBOOK_CLASS_ESSENCE_CACHE_BASE_VAR + IntToString(nClass), essenceSpells);
return essenceSpells;
}
int JsonArrayContainsInt(json list, int item)
{
int totalCount = JsonGetLength(list);
int i;
for (i = 0; i < totalCount; i++)
{
if (JsonGetInt(JsonArrayGet(list, i)) == item)
return TRUE;
}
return FALSE;
}
int IsSpellbookNUIOpen(object oPC)
{
int nPreviousToken = NuiFindWindow(oPC, PRC_SPELLBOOK_NUI_WINDOW_ID);
if (nPreviousToken != 0)
{
return TRUE;
}
return FALSE;
}

Some files were not shown because too many files have changed in this diff Show More