swg-source/dsrc
1
0
Fork 0
mirror of https://github.com/SWG-Source/dsrc.git synced 2026-07-13 22:01:04 -04:00
Code Issues Projects Releases Wiki Activity
Files
0336a2802fbc10bebb2a535f392aebabeb8deeaa
dsrc/sku.0/sys.server/compiled/game/script/library/dump.java
T
AconiteGodOfSWG 355796dd48 3.1 Config Refactor
2021-03-28 16:44:33 -04:00

1236 lines
52 KiB
Java
Executable File
Raw Blame History

package script.library;
import script.*;
import java.util.StringTokenizer;
import java.util.Vector;
public class dump extends script.base_script
{
public dump()
{
}
public static final String DATATABLE_FS_QUESTS = "datatables/player/quests.iff";
public static final String[] SPACE_QUEST_TYPES =
{
"assassinate",
"delivery",
"delivery_no_pickup",
"destroy",
"destroy_duty",
"destroy_surpriseattack",
"escort",
"escort_duty",
"inspect",
"patrol",
"recovery",
"recovery_duty",
"rescue",
"rescue_duty",
"space_battle",
"survival"
};
public static final String[][] KNOWN_CHARACTER_SLOTS =
{
{
"hat",
"earring_l",
"earring_r",
"eyes",
"neck",
"chest1",
"chest2",
"chest3_l",
"chest3_r",
"back",
"cloak",
"bicep_l",
"bicep_r",
"bracer_upper_r",
"bracer_lower_r",
"bracer_upper_l",
"bracer_lower_l",
"wrist_l",
"wrist_r",
"gloves",
"hold_r",
"hold_l",
"ring_l",
"ring_r",
"utility_belt",
"pants1",
"pants2",
"shoes"
},
{
"Hat: ",
"Left ear ring: ",
"Right ear ring: ",
"Eyes: ",
"Neck: ",
"Primary chest: ",
"Secondary chest: ",
"Trinary chest left",
"Trinary chest right",
"Back:",
"Cloak: ",
"Left bicep: ",
"Right bicep: ",
"Upper right bracer: ",
"Lower right bracer: ",
"Upper left bracer: ",
"Left lower bracer: ",
"Left wrist: ",
"Right wrist: ",
"Gloves: ",
"Holding right hand: ",
"Holding left hand: ",
"Left ring: ",
"Right ring: ",
"Belt: ",
"Primary pants: ",
"Secondary pants: ",
"Shoes: "
}
};
public static String getTargetInfoStringByLong(long lTarget) throws InterruptedException
{
obj_id target = obj_id.getObjId(lTarget);
if (!isIdValid(target))
{
return "";
}
return getTargetInfoString(target);
}
public static String getTargetInfoString(obj_id objTarget) throws InterruptedException
{
String strTest = "Object: " + objTarget + "\r\n";
if (isMob(objTarget) && !isPlayer(objTarget))
{
String creatureName = getCreatureName(objTarget);
if (creatureName != null && creatureName.length() > 0)
{
strTest += "Creature Name: " + creatureName + "\r\n";
}
}
if (static_item.isStaticItem(objTarget))
{
strTest += "Static Item: " + getStaticItemName(objTarget) + " (ver " + getStaticItemVersion(objTarget) + ")\r\n";
}
strTest += "Template: " + getTemplateName(objTarget) + "\r\n";
strTest += "Location: " + getClusterName() + " " + getLocation(objTarget) + "\r\n";
strTest += "---------------------CONTAINMENT-------------------------\r\n";
strTest += getReadableContainmentTree(objTarget);
strTest += "---------------------SCRIPTS-----------------------------\r\n";
strTest += getReadableScripts(objTarget);
strTest += "---------------------OBJVARS-----------------------------\r\n";
strTest += getReadableObjVars(objTarget);
strTest += "---------------------SCRIPTVARS--------------------------\r\n";
strTest += getReadableScriptVars(objTarget);
strTest += "\r\n";
strTest += "---------------------LOCALVARS---------------------------\r\n";
strTest += getReadableLocalVars(objTarget);
strTest += "\r\n";
strTest += "---------------------ENEMY FLAGS-------------------------\r\n";
strTest += getReadableEnemyFlags(objTarget);
if (isPlayer(objTarget))
{
strTest += "---------------------BOUNTY MISSIONS---------------------\r\n";
strTest += getReadableBountyMissions(objTarget);
strTest += "---------------------BOUNTIES----------------------------\r\n";
strTest += getReadableBounties(objTarget);
strTest += "---------------------BOUNTY HUNTERS WITH BOUNTIES ON ME--\r\n";
strTest += getReadableBountyHunters(objTarget);
strTest += "---------------------FS QUESTS---------------------------\r\n";
strTest += getReadableFsQuests(objTarget);
strTest += "---------------------FS BRANCHES UNLOCKED----------------\r\n";
strTest += getReadableFsBranchesUnlocked(objTarget);
strTest += "---------------------SPACE QUESTS------------------------\r\n";
strTest += getReadableSpaceQuests(objTarget);
}
if (space_utils.isShip(objTarget))
{
if (space_utils.isPlayerControlledShip(objTarget))
{
obj_id objPilot = getPilotId(objTarget);
if (isIdValid(objPilot))
{
strTest += "=====================PILOT BELOW HERE====================\r\n\r\n";
strTest += "Object is " + objPilot + "\r\n";
strTest += "Template of object is " + getTemplateName(objPilot) + "\r\n";
strTest += "Location of object is " + getClusterName() + " " + getLocation(objPilot) + "\r\n";
strTest += "---------------------SCRIPTS-----------------------------\r\n";
strTest += getReadableScripts(objPilot);
strTest += "---------------------OBJVARS-----------------------------\r\n";
strTest += getReadableObjVars(objPilot);
strTest += "---------------------SCRIPTVARS--------------------------\r\n";
strTest += getReadableScriptVars(objPilot);
strTest += "\r\n";
strTest += "---------------------LOCALVARS---------------------------\r\n";
strTest += getReadableLocalVars(objPilot);
strTest += "\r\n";
}
}
strTest += "=====================SHIP STATS BELOW====================\r\n";
int[] intSlots = space_crafting.getShipInstalledSlots(objTarget);
for (int intSlot : intSlots) {
strTest += getShipComponentDebugString(objTarget, intSlot) + "\r\n";
}
}
if (utils.hasScriptVar(objTarget, "spawnedBy"))
{
obj_id spawner = utils.getObjIdScriptVar(objTarget, "spawnedBy");
if (isIdValid(spawner) && exists(spawner) && spawner.isLoaded() && spawner != objTarget)
{
strTest += "=====================SPAWNER BELOW HERE==================\r\n";
strTest += getTargetInfoString(spawner);
}
}
return strTest;
}
public static String getReadableObjVars(obj_id objTarget) throws InterruptedException
{
String strObjVars = getPackedObjvars(objTarget);
String[] strSplit = split(strObjVars, '|');
String strTest = "";
if (strSplit.length > 2)
{
for (int intI = 0; intI < strSplit.length - 2; intI++)
{
strTest = strTest + strSplit[intI];
strTest = strTest + "=";
strTest = strTest + strSplit[intI + 2];
strTest = strTest + "\r\n";
intI = intI + 2;
}
}
return strTest;
}
public static String getReadableScripts(obj_id objTarget) throws InterruptedException
{
String[] strScriptArray = getScriptList(objTarget);
String strScripts = "";
for (String s : strScriptArray) {
String script = s;
if (script.contains("script.")) {
script = script.substring(7);
strScripts += script + "\r\n";
}
}
return strScripts;
}
public static String getReadableScriptVars(obj_id objTarget) throws InterruptedException
{
deltadictionary dctScriptVars = objTarget.getScriptVars();
return dctScriptVars.toString();
}
public static String getReadableLocalVars(obj_id objTarget) throws InterruptedException
{
dictionary dd = objTarget.getScriptDictionary();
return dd.toString();
}
public static String getReadableContainmentTree(obj_id objTarget) throws InterruptedException
{
final int MAX_DEPTH = 32;
String readableContainmentTree = "";
obj_id prevObject = objTarget;
obj_id container = getContainedBy(objTarget);
int depth = 0;
while (isIdValid(container) && container != prevObject && depth < MAX_DEPTH)
{
readableContainmentTree += getReadableContainer(container);
prevObject = container;
container = getContainedBy(container);
++depth;
}
obj_id topmost = getTopMostContainer(objTarget);
if (isIdValid(topmost) && topmost != container && topmost != prevObject)
{
readableContainmentTree += getReadableContainer(topmost);
}
readableContainmentTree += "<world>\n";
return readableContainmentTree;
}
public static String getReadableContainer(obj_id container) throws InterruptedException
{
int type = getContainerType(container);
String template = getTemplateName(container);
location loc = getLocation(container);
if (template.equals("object/cell/cell.iff"))
{
String cellName = getCellName(container);
if (cellName != null)
{
template += " name=" + cellName;
}
}
return container + " type=" + type + " " + template + "\n\t" + loc + "\n";
}
public static String getReadableEnemyFlags(obj_id objTarget) throws InterruptedException
{
String readableEnemyFlags = "";
String[] enemies = pvpGetEnemyFlags(objTarget);
if (enemies != null)
{
for (String enemy : enemies) {
StringTokenizer st = new StringTokenizer(enemy);
String sTarget = st.nextToken();
String sTargetName = getPlayerName(utils.stringToObjId(sTarget));
String sTefFac = st.nextToken();
int iTefFac = utils.stringToInt(sTefFac);
String sTefFacName = "<unknown>";
if (iTefFac == (-526735576)) {
sTefFacName = "battlefield";
} else if (iTefFac == (1183528962)) {
sTefFacName = "duel";
} else if (iTefFac == (-429740311)) {
sTefFacName = "bountyduel";
} else if (iTefFac == (221551254)) {
sTefFacName = "nonaggressive";
} else if (iTefFac == (-160237431)) {
sTefFacName = "unattackable";
} else if (iTefFac == (84709322)) {
sTefFacName = "bountytarget";
} else if (iTefFac == (-1526926610)) {
sTefFacName = "guildwarcooldownperiod";
} else if (iTefFac == (-615855020)) {
sTefFacName = "imperial";
} else if (iTefFac == (370444368)) {
sTefFacName = "rebel";
} else if (iTefFac == (-377582139)) {
sTefFacName = "bubblecombat";
}
String sExpiration = st.nextToken();
readableEnemyFlags += sTarget;
readableEnemyFlags += " (";
readableEnemyFlags += sTargetName;
readableEnemyFlags += "), ";
readableEnemyFlags += sTefFac;
readableEnemyFlags += " (";
readableEnemyFlags += sTefFacName;
readableEnemyFlags += "), ";
readableEnemyFlags += sExpiration;
readableEnemyFlags += "ms";
readableEnemyFlags += "\r\n";
}
}
if (readableEnemyFlags.equals(""))
{
readableEnemyFlags = "<>\r\n";
}
return readableEnemyFlags;
}
public static String getReadableBountyMissions(obj_id objTarget) throws InterruptedException
{
String readableBountyMissions = "";
obj_id[] objMissions = getMissionObjects(objTarget);
if (objMissions != null)
{
for (obj_id objMission : objMissions) {
String missionType = getMissionType(objMission);
if (missionType.equals("bounty")) {
readableBountyMissions += "mission id: ";
readableBountyMissions += objMission;
readableBountyMissions += ", target id: ";
if (hasObjVar(objMission, "objTarget")) {
readableBountyMissions += getObjIdObjVar(objMission, "objTarget");
} else {
readableBountyMissions += "NPC";
}
readableBountyMissions += ", target name: ";
if (hasObjVar(objMission, "strTargetName")) {
readableBountyMissions += getStringObjVar(objMission, "strTargetName");
} else {
readableBountyMissions += "<unset>";
}
readableBountyMissions += "\r\n";
}
}
}
if (readableBountyMissions.equals(""))
{
readableBountyMissions = "<>\r\n";
}
return readableBountyMissions;
}
public static String getReadableBounties(obj_id objTarget) throws InterruptedException
{
String readableBounties = "";
obj_id[] bounties = getBountyHunterBounties(objTarget);
if (bounties != null)
{
for (obj_id bounty : bounties) {
readableBounties += bounty;
readableBounties += " (";
readableBounties += getPlayerName(bounty);
readableBounties += ")";
readableBounties += "\r\n";
}
}
if (readableBounties.equals(""))
{
readableBounties = "<>\r\n";
}
return readableBounties;
}
public static String getReadableBountyHunters(obj_id objTarget) throws InterruptedException
{
String readableBountyHunters = "";
obj_id[] hunters = getJediBounties(objTarget);
if (hunters != null)
{
for (obj_id hunter : hunters) {
readableBountyHunters += hunter;
readableBountyHunters += " (";
readableBountyHunters += getPlayerName(hunter);
readableBountyHunters += ")";
readableBountyHunters += "\r\n";
}
}
if (readableBountyHunters.equals(""))
{
readableBountyHunters = "<>\r\n";
}
return readableBountyHunters;
}
public static String getReadableFsQuests(obj_id objTarget) throws InterruptedException
{
String readableFsQuests = "";
dictionary questMap = new dictionary();
int rows = dataTableGetNumRows(DATATABLE_FS_QUESTS);
for (int i = 0; i < rows; i++)
{
String questName = (quests.getDataEntry(i, "NAME")).trim();
String attachScript = (quests.getDataEntry(i, "ATTACH_SCRIPT")).trim();
String taskTarget = (quests.getDataEntry(i, "TARGET")).trim();
String taskParam = (quests.getDataEntry(i, "PARAMETER")).trim();
String parentQuest = (quests.getParentQuestName(questName)).trim();
dictionary d = new dictionary();
if (attachScript != null && !attachScript.equals(""))
{
d.put("attachScript", attachScript);
}
if (taskTarget != null && !taskTarget.equals(""))
{
d.put("taskTarget", taskTarget);
}
if (taskParam != null && !taskParam.equals(""))
{
d.put("taskParam", taskParam);
}
if (parentQuest != null && !parentQuest.equals(""))
{
d.put("parentQuest", parentQuest);
}
if (isQuestActive(objTarget, i))
{
d.put("isComplete", false);
questMap.put(questName, d);
}
else if (isQuestComplete(objTarget, i))
{
d.put("isComplete", true);
questMap.put(questName, d);
}
}
java.util.Enumeration enum_ = questMap.keys();
while (enum_.hasMoreElements())
{
String questName = (String)enum_.nextElement();
dictionary childQuestDict = questMap.getDictionary(questName);
String parentQuestName = childQuestDict.getString("parentQuest");
if (parentQuestName != null)
{
dictionary parentQuestDict = questMap.getDictionary(parentQuestName);
if (parentQuestDict != null)
{
Vector childArray = parentQuestDict.getResizeableStringArray("childQuests");
if (childArray == null)
{
childArray = new Vector();
}
childArray.add(questName);
parentQuestDict.put("childQuests", childArray);
}
}
}
enum_ = questMap.keys();
while (enum_.hasMoreElements())
{
String questName = (String)enum_.nextElement();
dictionary d = questMap.getDictionary(questName);
if (d.containsKey("parentQuest"))
{
continue;
}
readableFsQuests += getReadableFsQuest(questMap, questName, 0);
readableFsQuests += getReadableFsQuestChildren(questMap, questName, 1);
}
return readableFsQuests;
}
public static String getReadableFsQuestChildren(dictionary questMap, String questName, int indentLevel) throws InterruptedException
{
String readableFsQuestChildren = "";
dictionary d = questMap.getDictionary(questName);
String[] childQuests = d.getStringArray("childQuests");
if (childQuests != null)
{
for (String childQuest : childQuests) {
readableFsQuestChildren += getReadableFsQuest(questMap, childQuest, indentLevel);
readableFsQuestChildren += getReadableFsQuestChildren(questMap, childQuest, indentLevel + 1);
}
}
return readableFsQuestChildren;
}
public static String getReadableFsQuest(dictionary questMap, String questName, int indentLevel) throws InterruptedException
{
String readableFsQuest = "";
dictionary d = questMap.getDictionary(questName);
for (int i = 0; i < indentLevel; i++)
{
readableFsQuest += "\t";
}
if (d.getBoolean("isComplete"))
{
readableFsQuest += "[x] ";
}
else
{
readableFsQuest += "[ ] ";
}
readableFsQuest += questName;
if (d.containsKey("attachScript"))
{
readableFsQuest += " (" + d.getString("attachScript") + ")";
}
if (d.containsKey("taskTarget"))
{
readableFsQuest += " (" + d.getString("taskTarget") + ")";
}
if (d.containsKey("taskParam"))
{
readableFsQuest += " (" + d.getString("taskParam") + ")";
}
readableFsQuest += "\n";
return readableFsQuest;
}
public static String getReadableFsBranchesUnlocked(obj_id objTarget) throws InterruptedException
{
String branch_list = "";
for (int i = 0; i < 16; i++)
{
if (fs_quests.hasUnlockedBranch(objTarget, i))
{
String branch = fs_quests.getBranchFromId(i);
String branch_name = localize(new string_id("quest/force_sensitive/utils", branch));
if (branch != null)
{
branch_list += branch_name + "\n";
}
}
}
return branch_list;
}
public static String getReadableSpaceQuests(obj_id objTarget) throws InterruptedException
{
String readableSpaceQuests = "";
obj_var_list typeList = getObjVarList(objTarget, space_quest.QUEST_STATUS);
if (typeList != null)
{
java.util.Enumeration typeEnum = typeList.keys();
while (typeEnum.hasMoreElements())
{
String questType = (String)typeEnum.nextElement();
obj_var_list questList = typeList.getObjVarList(questType);
java.util.Enumeration questEnum = questList.keys();
while (questEnum.hasMoreElements())
{
String questName = (String)questEnum.nextElement();
readableSpaceQuests += getReadableSpaceQuest(objTarget, questType, questName);
}
}
}
return readableSpaceQuests;
}
public static String getReadableSpaceQuest(obj_id player, String questType, String questName) throws InterruptedException
{
String readableSpaceQuest = "";
obj_id questObject = space_quest._getQuest(player, questType, questName);
int questId = questGetQuestId("spacequest/" + questType + "/" + questName);
if (questIsQuestComplete(questId, player))
{
readableSpaceQuest += "[x]";
}
else if (questIsQuestActive(questId, player))
{
readableSpaceQuest += "[ ]";
}
else
{
readableSpaceQuest += "???";
}
readableSpaceQuest += " " + questName;
readableSpaceQuest += " type=" + questType;
if (!isIdNull(questObject))
{
readableSpaceQuest += " zone=" + utils.getStringObjVar(questObject, space_quest.QUEST_ZONE, "?");
readableSpaceQuest += " oid=" + questObject;
if (utils.getBooleanObjVar(questObject, space_quest.QUEST_DUTY, false))
{
readableSpaceQuest += " isDuty";
}
if (space_quest.isQuestInProgress(questObject))
{
readableSpaceQuest += " isInProgress";
}
}
if (space_quest.hasFailedQuest(player, questType, questName))
{
readableSpaceQuest += " hasFailed";
}
if (space_quest.hasWonQuest(player, questType, questName))
{
readableSpaceQuest += " hasWon";
}
if (space_quest.hasAbortedQuest(player, questType, questName))
{
readableSpaceQuest += " hasAborted";
}
if (space_quest.hasReceivedReward(player, questType, questName))
{
readableSpaceQuest += " hasReceivedReward";
}
string_id title = new string_id("spacequest/" + questType + "/" + questName, "title");
readableSpaceQuest += " title=<" + getString(title) + ">";
readableSpaceQuest += "\n";
return readableSpaceQuest;
}
public static String csTargetDump(obj_id self, obj_id objTarget, boolean colorFlag) throws InterruptedException
{
String strTest = "";
strTest += "OBJECT ID: \t\t\t";
strTest += objTarget + "\r\n";
strTest += "TEMPLATE NAME: \t\t";
strTest += getTemplateName(objTarget) + "\r\n";
if (!isMob(objTarget) && !isPlayer(objTarget))
{
if (getStaticItemName(objTarget) != null)
{
strTest += "STATIC ITEM NAME: \t";
strTest += getStaticItemName(objTarget) + "\r\n";
}
}
strTest += "SERVER CLUSTER: \t\t";
strTest += getClusterName() + "\r\n";
strTest += "LOCATION: \t\t\t";
strTest += getLocation(objTarget) + "\r\n";
if (isMob(objTarget) && !isPlayer(objTarget))
{
String codeString = getCreatureName(objTarget);
String localizedString = localize(new string_id("mob/creature_names", codeString));
if (localizedString == null)
{
localizedString = getEncodedName(objTarget);
}
strTest += "CREATURE NAME: \t\t";
strTest += localizedString + "\r\n";
strTest += "CREATURE CODE: \t\t";
strTest += codeString + "\r\n";
}
if (isPlayer(objTarget))
{
String playerFullName = getName(objTarget);
String playerCodeString = getPlayerName(objTarget);
strTest += "\nPLAYER FULL NAME: \t\t";
strTest += playerFullName + "\r\n";
strTest += "INTERNAL NAME: \t\t\t";
strTest += playerCodeString + "\r\n";
strTest += "ACCOUNT USERNAME: \t\t";
strTest += getPlayerAccountUsername(objTarget) + "\r\n";
strTest += "LOTS USED: \t\t\t\t" + getAccountNumLots(objTarget) + "\r\n";
strTest += "PLAYER PLAY TIME:\t\t" + getPlayerPlayedTime(objTarget) + "\r\n";
strTest += "PLAYER AGE: \t\t\t\t" + (getCurrentBirthDate() - getPlayerBirthDate(objTarget)) + "\r\n";
strTest += "PLAYER BIRTHDAY: \t\t" + getPlayerBirthDate(objTarget) + "\r\n\r\n";
}
if (isMob(objTarget) || isPlayer(objTarget))
{
int healthMax = getMaxAttrib(objTarget, HEALTH);
int healthCurrent = getAttrib(objTarget, HEALTH);
int actionMax = getMaxAttrib(objTarget, ACTION);
int actionCurrent = getAttrib(objTarget, ACTION);
int mindMax = getMaxAttrib(objTarget, MIND);
int mindCurrent = getAttrib(objTarget, MIND);
strTest += "STATS: \r\n\t\tHEALTH - \tMAX: \t";
strTest += healthMax + "\t";
strTest += "CURRENT: \t";
strTest += healthCurrent + "\r\n";
strTest += "\t\tACTION - \tMAX: \t";
strTest += actionMax + " \t";
strTest += "CURRENT: \t";
strTest += actionCurrent + "\r\n";
strTest += "\t\tMIND - \t\tMAX: \t";
strTest += mindMax + "\t\t";
strTest += "CURRENT: \t";
strTest += mindCurrent + "\r\n";
if (isPlayer(objTarget))
{
strTest += "\r\nGUILD:\r\n";
int guildId = getGuildId(objTarget);
if (guildId != 0)
{
strTest += "Guild ID: " + guildId + "\r\n";
strTest += "Guild Name: " + guildGetName(guildId) + "\r\n";
strTest += "Guild Abbrev.: " + guildGetAbbrev(guildId) + "\r\n";
strTest += "Guild Leader Name & OID: " + getName(guildGetLeader(guildId)) + " " + guildGetLeader(guildId) + "\r\n";
}
else
{
strTest += "No guild\r\n";
}
strTest += "\r\nPROFESSION AND WORKING SKILL:\r\n";
strTest += getSkillTemplate(objTarget) + "\r\n";
strTest += getWorkingSkill(objTarget) + "\r\n";
strTest += "\r\nBASE SKILL STATS:\r\n";
strTest += "(Review expertise and skill modifier sections below to see skill stat modifier data)\r\n";
String[] allSkillModsList = dataTableGetStringColumn("datatables/expertise/skill_mod_listing.iff", "skill_mod");
int arrayLength = allSkillModsList.length;
if (allSkillModsList != null)
{
if (arrayLength > 0)
{
for (String s : allSkillModsList) {
if (s.indexOf("_modified") > 0) {
int underscoreIdx = s.indexOf("_");
String nonModifiedSkillname = s.substring(0, underscoreIdx);
strTest += localize(new string_id("stat_n", s)) + ": " + getSkillStatisticModifier(objTarget, nonModifiedSkillname) + "\r\n";
}
}
}
}
strTest += "\r\nEXPERTISE:\r\n";
if (allSkillModsList != null)
{
if (arrayLength > 0)
{
for (String s : allSkillModsList) {
if (s.indexOf("expertise_") == 0) {
if (getSkillStatisticModifier(objTarget, s) > 0) {
strTest += localize(new string_id("stat_n", s)) + ": " + getSkillStatisticModifier(objTarget, s) + "\r\n";
}
}
}
}
}
strTest += "\r\nSKILL MODIFIERS:\r\n";
if (allSkillModsList != null)
{
if (arrayLength > 0)
{
for (String s : allSkillModsList) {
if (getEnhancedSkillStatisticModifierUncapped(objTarget, s) > 0) {
strTest += localize(new string_id("stat_n", s)) + " ( " + s + " ): " + getEnhancedSkillStatisticModifierUncapped(objTarget, s) + "\r\n";
}
}
}
}
strTest += "\r\nGCW INFO:\r\n";
int intPlayerFaction = pvpGetAlignedFaction(objTarget);
if (intPlayerFaction == (-615855020))
{
strTest += "current faction: Imperial \r\n";
}
else if (intPlayerFaction == (370444368))
{
strTest += "current faction: Rebel \r\n";
}
else
{
strTest += "current faction: Neutral \r\n";
}
strTest += "current GCW points: " + pvpGetCurrentGcwPoints(objTarget) + "\r\n";
strTest += "current GCW rating: " + pvpGetCurrentGcwRating(objTarget) + "\r\n";
strTest += "current GCW rank: " + pvpGetCurrentGcwRank(objTarget) + "\r\n";
strTest += "current PvP kills: " + pvpGetCurrentPvpKills(objTarget) + "\r\n";
strTest += "lifetime GCW points: " + pvpGetLifetimeGcwPoints(objTarget) + "\r\n";
strTest += "max GCW imperial rating: " + pvpGetMaxGcwImperialRating(objTarget) + "\r\n";
strTest += "max GCW imperial rank: " + pvpGetMaxGcwImperialRank(objTarget) + "\r\n";
strTest += "max GCW rebel rating: " + pvpGetMaxGcwRebelRating(objTarget) + "\r\n";
strTest += "max GCW rebel rank: " + pvpGetMaxGcwRebelRank(objTarget) + "\r\n";
strTest += "lifetime PvP kills: " + pvpGetLifetimePvpKills(objTarget) + "\r\n";
strTest += "next GCW rating calculation time: " + pvpGetNextGcwRatingCalcTime(objTarget) + "\r\n";
strTest += "\r\nBUFFS/STATES/DoTs, etc.:\r\n";
int[] buffs = _getAllBuffs(objTarget);
if (buffs != null && buffs.length != 0)
{
for (int b : buffs) {
obj_id buffOwner = null;
String buffName = buff.getBuffNameFromCrc(b);
float duration = buff.getDuration(buffName);
boolean debuff = buff.isDebuff(buffName);
boolean groupBuff = buff.isGroupBuff(buffName);
boolean ownedBuff = buff.isOwnedBuff(buffName);
if (ownedBuff) {
buffOwner = buff.getBuffOwner(objTarget, buffName);
}
strTest += buffName + "\r\nDuration: " + duration + "\r\n";
if (debuff) {
strTest += "Debuff: " + debuff + "\r\n";
}
if (groupBuff) {
strTest += "Group buff: " + debuff + "\r\n";
}
if (ownedBuff) {
strTest += "Owned buff: " + ownedBuff + "\r\n";
if (isIdValid(buffOwner)) {
strTest += "Buff Owner: " + getName(buffOwner) + "\r\n";
}
strTest += "Owner OID: " + buffOwner + "\r\n";
}
}
}
else
{
strTest += "No buffs" + "\r\n";
}
String[] collectionBooks = getAllCollectionBooks();
if (collectionBooks != null && collectionBooks.length > 0)
{
String allCompCollections = getAllCompletedCollections(objTarget, collectionBooks);
if (allCompCollections != null && !allCompCollections.equals(""))
{
strTest += "\r\nCOMPLETED COLLECTIONS:\r\n";
strTest += allCompCollections + "\r\n";
}
String allIncompCollections = getAllIncompleteCollections(objTarget, collectionBooks);
if (allIncompCollections != null && !allIncompCollections.equals(""))
{
strTest += "\r\nCOLLECTIONS STARTED BUT INCOMPLETE:\r\n";
strTest += allIncompCollections + "\r\n";
}
}
}
}
String readableScripts = getReadableScripts(objTarget);
if (!readableScripts.equals("<>") && !readableScripts.equals("") && readableScripts.length() > 5)
{
strTest += "\n\rATTACHED SCRIPTS:\r\n";
strTest += readableScripts;
strTest += "\n\r";
}
String objVars = getReadableObjVars(objTarget);
if (!objVars.equals("<>") && !objVars.equals("") && objVars.length() > 5)
{
strTest += "OBJVARS:\r\n";
strTest += objVars;
strTest += "\n\r";
}
String scriptVars = getReadableScriptVars(objTarget);
if (!scriptVars.equals("<>") && !scriptVars.equals("") && scriptVars.length() > 5)
{
strTest += "SCRIPTVARS:\r\n";
strTest += scriptVars;
strTest += "\n\r";
}
String localVars = getReadableLocalVars(objTarget);
if (!localVars.equals("<>") && !localVars.equals("") && localVars.length() > 5)
{
strTest += "LOCALVARS:\r\n";
strTest += localVars;
strTest += "\n\r";
sendSystemMessageTestingOnly(self, "LOCALVARS:" + localVars);
}
if (isPlayer(objTarget))
{
String[] skillList = getSkillListingForPlayer(objTarget);
if (skillList != null && skillList.length > 0)
{
strTest += "\r\nSKILLS:\r\n";
for (String s : skillList) {
strTest += s + "\r\n";
}
}
else
{
strTest += "\r\nSKILLS:\r\n";
strTest += "none\r\n";
}
String[] allQuests = gm.getAllQuests(self);
if (allQuests != null && allQuests.length > 0)
{
strTest += "\r\nGROUND AND SPACE QUESTS:\r\n";
for (String allQuest : allQuests) {
strTest += allQuest + "\r\n";
}
}
else
{
strTest += "\r\nGROUND AND SPACE QUESTS:\r\n";
strTest += "none\r\n";
}
strTest += "\r\nWEARABLES:\r\n";
if (KNOWN_CHARACTER_SLOTS != null)
{
for (int i = 0; i < KNOWN_CHARACTER_SLOTS[0].length; i++)
{
obj_id item = getObjectInSlot(objTarget, KNOWN_CHARACTER_SLOTS[0][i]);
if (isIdValid(item))
{
strTest += KNOWN_CHARACTER_SLOTS[1][i] + "\r\n";
if (getStaticItemName(item) != null)
{
strTest += "\tStatic Item Name: " + getStaticItemName(item) + "\r\n";
}
if (getTemplateName(item) != null)
{
strTest += "\tTemplate: " + getTemplateName(item) + "\r\n";
strTest += "\tOID: " + item + "\r\n";
strTest += getObjectVariables(self, item);
if (jedi.isLightsaber(item))
{
obj_id saberInv = getObjectInSlot(item, "saber_inv");
obj_id[] saberContents = utils.getContents(saberInv, true);
if (saberContents != null && saberContents.length > 0)
{
for (int s = 0; s < saberContents.length; s++)
{
if (isIdValid(saberContents[s]))
{
if (getTemplateName(saberContents[s]) != null)
{
strTest += "SABER SLOT " + (s + 1) + "\r\n";
strTest += "\tTemplate: " + getTemplateName(saberContents[s]) + "\r\n";
strTest += "\tOID: " + saberContents[s] + "\r\n";
strTest += getObjectVariables(self, saberContents[s]);
strTest += "\r\n";
}
}
}
}
else
{
strTest += "nothing in saber.\r\n";
}
}
}
}
}
}
strTest += "\r\nPLAYER DATAPAD:\r\n";
obj_id targetDatapad = utils.getPlayerDatapad(objTarget);
if (isIdValid(targetDatapad))
{
obj_id[] objContents = utils.getContents(targetDatapad, true);
if (objContents != null && objContents.length > 0)
{
for (obj_id objContent : objContents) {
if (isIdValid(objContent)) {
if (getTemplateName(objContent) != null) {
strTest += "\tTemplate: " + getTemplateName(objContent) + "\r\n";
strTest += "\tOID: " + objContent + "\r\n";
strTest += getObjectVariables(self, objContent);
strTest += "\r\n";
}
}
}
}
else
{
strTest += "no datpad items.\r\n";
}
}
strTest += "\r\nENEMY FLAGS:\r\n";
String enemyFlags = getReadableEnemyFlags(objTarget);
if (!enemyFlags.equals("<>") && !enemyFlags.equals("") && enemyFlags.length() > 5)
{
strTest += enemyFlags;
strTest += "\n\r";
}
else
{
strTest += "none\n\r";
}
strTest += "\r\nBOUNTY MISSIONS:\r\n";
String playerBountyMissions = getReadableBountyMissions(objTarget);
if (!playerBountyMissions.equals("<>") && !playerBountyMissions.equals("") && playerBountyMissions.length() > 5)
{
strTest += playerBountyMissions;
strTest += "\n\r";
}
else
{
strTest += "none\n\r";
}
strTest += "\r\nBOUNTIES:\r\n";
String playerBounties = getReadableBounties(objTarget);
if (!playerBounties.equals("<>") && !playerBounties.equals("") && playerBounties.length() > 5)
{
strTest += playerBounties;
strTest += "\n\r";
}
else
{
strTest += "none\n\r";
}
strTest += "\r\nBOUNTY HUNTERS WITH BOUNTIES ON ME:\r\n";
String huntersOfPlayer = getReadableBountyHunters(objTarget);
if (!huntersOfPlayer.equals("<>") && !huntersOfPlayer.equals("") && huntersOfPlayer.length() > 5)
{
strTest += huntersOfPlayer;
strTest += "\n\r";
}
else
{
strTest += "none\n\r";
}
strTest += "\r\nFS QUESTS:\r\n";
String fsQuestData = getReadableFsQuests(objTarget);
if (!fsQuestData.equals("<>") && !fsQuestData.equals("") && fsQuestData.length() > 5)
{
strTest += fsQuestData;
strTest += "\n\r";
}
else
{
strTest += "none\n\r";
}
strTest += "\r\nFS BRANCHES UNLOCKED:\r\n";
String fsBranchesUnlocked = getReadableFsBranchesUnlocked(objTarget);
if (!fsBranchesUnlocked.equals("<>") && !fsBranchesUnlocked.equals("") && fsBranchesUnlocked.length() > 5)
{
strTest += fsBranchesUnlocked;
strTest += "\n\r";
}
else
{
strTest += "none\n\r";
}
strTest += "\r\nGAME SUBSCRIPTION FEATURES:\r\n";
boolean boolHasCollectorEdition = features.hasCollectorEdition(objTarget);
boolean boolhasSpaceExpansion = features.hasSpaceExpansion(objTarget);
boolean boolhasSpaceExpansionPromotion = features.hasSpaceExpansionPromotion(objTarget);
boolean boolhasJapaneseCollectorEdition = features.hasJapaneseCollectorEdition(objTarget);
boolean boolhasEpisode3Expansion = features.hasEpisode3Expansion(objTarget);
boolean boolhasEpisode3PreOrderDigitalDownload = features.hasEpisode3PreOrderDigitalDownload(objTarget);
boolean boolhasEpisode3ExpansionRetail = features.hasEpisode3ExpansionRetail(objTarget);
boolean boolhasTrialsOfObiwanExpansionRetail = features.hasTrialsOfObiwanExpansionRetail(objTarget);
boolean boolhasTrialsOfObiwanExpansionPreorder = features.hasTrialsOfObiwanExpansionPreorder(objTarget);
boolean boolhasTrialsOfObiwanExpansion = features.hasTrialsOfObiwanExpansion(objTarget);
boolean boolhasMustafarExpansionRetail = features.hasMustafarExpansionRetail(objTarget);
boolean boolhasFreeTrial = features.hasFreeTrial(objTarget);
if (boolHasCollectorEdition)
{
strTest += "\t\t\tCollector's Edition\r\n";
}
if (boolhasSpaceExpansion)
{
strTest += "\t\t\tJTL SpaceExpansion\r\n";
}
if (boolhasSpaceExpansionPromotion)
{
strTest += "\t\t\tJTL Space Expansion Promotion\r\n";
}
if (boolhasJapaneseCollectorEdition)
{
strTest += "\t\t\tJapanese Collector's Edition:\r\n";
}
if (boolhasEpisode3Expansion)
{
strTest += "\t\t\tEpisode 3 Expansion\r\n";
}
if (boolhasEpisode3PreOrderDigitalDownload)
{
strTest += "\t\t\tEpisode 3 Expansion Preorder\r\n";
}
if (boolhasEpisode3ExpansionRetail)
{
strTest += "\t\t\tEpisode 3 Expansion Retail\r\n";
}
if (boolhasTrialsOfObiwanExpansionRetail)
{
strTest += "\t\t\tTrials of Obiwan Expansion Retail\r\n";
}
if (boolhasTrialsOfObiwanExpansionPreorder)
{
strTest += "\t\t\tTrials of Obiwan Expansion Preorder\r\n";
}
if (boolhasTrialsOfObiwanExpansion)
{
strTest += "\t\t\tTrials of Obiwan Expansion\r\n";
}
if (boolhasMustafarExpansionRetail)
{
strTest += "\t\t\tMustafar Expansion Retail\r\n";
}
if (boolhasFreeTrial)
{
strTest += "\t\t\tFree Trial\r\n";
}
}
if (space_utils.isShip(objTarget))
{
if (space_utils.isPlayerControlledShip(objTarget))
{
obj_id objPilot = getPilotId(objTarget);
if (isIdValid(objPilot))
{
strTest += "PILOT BELOW HERE\r\n\r\n";
strTest += "OBJECT IS: ";
strTest += objPilot;
strTest += "\n\r";
strTest += "Template of object is ";
strTest += getTemplateName(objPilot);
strTest += "\n\r";
strTest += "Location of object is ";
strTest += getClusterName() + " " + getLocation(objPilot);
strTest += "\n\r";
strTest += "SCRIPTS\r\n";
strTest += getReadableScripts(objPilot);
strTest += "\n\r";
strTest += "OBJVARS\r\n";
strTest += getReadableObjVars(objPilot);
strTest += "\n\r";
strTest += "SCRIPTVARS\r\n";
strTest += getReadableScriptVars(objPilot);
strTest += "\n\r";
strTest += "LOCALVARS\r\n";
strTest += getReadableLocalVars(objPilot);
strTest += "\n\r";
}
}
strTest += "SHIP STATS BELOW\r\n";
int[] intSlots = space_crafting.getShipInstalledSlots(objTarget);
for (int intSlot : intSlots) {
strTest += getShipComponentDebugString(objTarget, intSlot);
strTest += "\n\r";
}
}
String containmentTree = getReadableContainmentTree(objTarget);
if (!containmentTree.equals("<>") && !containmentTree.equals("") && containmentTree.length() > 5)
{
strTest += "\n\r";
strTest += "TARGET CONTAINMENT:\r\n";
strTest += containmentTree;
strTest += "\n\r";
}
if (utils.hasScriptVar(objTarget, "spawnedBy"))
{
obj_id spawner = utils.getObjIdScriptVar(objTarget, "spawnedBy");
if (isIdValid(spawner) && exists(spawner) && spawner.isLoaded() && spawner != objTarget)
{
strTest += "SPAWNER BELOW HERE\r\n";
strTest += getTargetInfoString(spawner);
}
}
return strTest;
}
public static String getObjectVariables(obj_id self, obj_id item) throws InterruptedException
{
String objvariable = "";
String strObjVars = getPackedObjvars(item);
String[] strSplit = split(strObjVars, '|');
if (strSplit.length > 2)
{
for (int intI = 0; intI < strSplit.length - 2; intI++)
{
objvariable += "\t";
objvariable += strSplit[intI];
objvariable += "=";
objvariable += strSplit[intI + 2];
objvariable += "\n\r";
intI = intI + 2;
}
}
return objvariable;
}
public static obj_id findDumpTarget(obj_id self) throws InterruptedException
{
obj_id intendedTarget = getIntendedTarget(self);
obj_id lookAtTarget = getLookAtTarget(self);
obj_id finalTarget = null;
if (isIdValid(intendedTarget))
{
finalTarget = intendedTarget;
}
else if (isIdValid(lookAtTarget))
{
finalTarget = lookAtTarget;
}
return finalTarget;
}
public static String getAllCompletedCollections(obj_id player, String[] collectionBooks) throws InterruptedException
{
if (!isValidId(player) || !exists(player))
{
return null;
}
if (collectionBooks == null || collectionBooks.length <= 0)
{
return null;
}
String retrunString = "";
for (String collectionBook : collectionBooks) {
String[] completedCollections = getCompletedCollectionsInBook(player, collectionBook);
if (completedCollections == null || completedCollections.length <= 0) {
continue;
} else {
retrunString += "\t" + collectionBook + "\r\n";
for (String completedCollection : completedCollections) {
int sizeOf = completedCollection.length();
retrunString += "\t\t" + completedCollection + "\r\n";
}
}
}
return retrunString;
}
public static String getAllIncompleteCollections(obj_id player, String[] collectionBooks) throws InterruptedException
{
if (!isValidId(player) || !exists(player))
{
return null;
}
if (collectionBooks == null || collectionBooks.length <= 0)
{
return null;
}
String returnString = "";
for (String collectionBook : collectionBooks) {
returnString += "\t" + collectionBook + "\r\n";
String[] allCollections = getAllCollectionsInBook(collectionBook);
if (allCollections == null || allCollections.length <= 0) {
continue;
}
boolean hasCollectionDataForBook = false;
for (String allCollection : allCollections) {
if (hasCompletedCollection(player, allCollection)) {
continue;
}
String[] allSlots = getAllCollectionSlotsInCollection(allCollection);
if (allSlots == null || allSlots.length <= 0) {
continue;
}
boolean startedNotFinished = false;
for (String allSlot1 : allSlots) {
if (getCollectionSlotValue(player, allSlot1) > 0) {
startedNotFinished = true;
break;
}
}
if (startedNotFinished) {
returnString += "\t\t" + allCollection + "\r\n";
hasCollectionDataForBook = true;
for (String allSlot : allSlots) {
returnString += "\t\t\t" + allSlot + ": " + getCollectionSlotValue(player, allSlot) + "\r\n";
}
}
}
if (!hasCollectionDataForBook) {
returnString += "\t\tNone\r\n";
}
}
return returnString;
}
}
Reference in New Issue View Git Blame Copy Permalink