mirror of
https://github.com/SWG-Source/dsrc.git
synced 2026-07-28 22:15:54 -04:00
2631 lines
63 KiB
Plaintext
2631 lines
63 KiB
Plaintext
include library.chat;
|
|
include library.utils;
|
|
include library.sui;
|
|
include library.attrib;
|
|
include library.create;
|
|
include library.space_dungeon;
|
|
include library.space_transition;
|
|
include library.pclib;
|
|
include library.datatable;
|
|
include library.buff;
|
|
include library.trial;
|
|
include library.space_dungeon_data;
|
|
include library.badge;
|
|
include library.ai_lib;
|
|
include library.gcw;
|
|
include library.factions;
|
|
include library.faction_perk;
|
|
include library.respec;
|
|
include library.skill;
|
|
include library.static_item;
|
|
include library.stealth;
|
|
include library.space_crafting;
|
|
include library.vehicle;
|
|
include library.combat;
|
|
include library.instance;
|
|
|
|
string[] OPTIONS ={
|
|
"listScripts",
|
|
"clearScript",
|
|
"clearAllScripts",
|
|
"listObjVars",
|
|
"clearObjVar",
|
|
"listAllObjVar",
|
|
"doClientEffect EFFECT",
|
|
"spawn SPAWN"
|
|
};
|
|
|
|
const int listScripts = 0;
|
|
const int clearScript = 1;
|
|
const int clearAllScripts = 2;
|
|
const int listObjVars = 3;
|
|
const int clearObjVar = 4;
|
|
const int clearAllObjVars = 5;
|
|
const int doClientEffect = 6;
|
|
const int spawnCreature = 7;
|
|
|
|
trigger OnMoveMoving()
|
|
{
|
|
setState(self, STATE_STUNNED, false);
|
|
setState(self, STATE_FROZEN, false);
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
trigger OnLogin()
|
|
{
|
|
setState(self, STATE_STUNNED, false);
|
|
setState(self, STATE_FROZEN, false);
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
trigger OnSpeaking(string text)
|
|
{
|
|
|
|
if (text.equals("set"))
|
|
overrideDefaultAttack(self, "hoth_speeder_bolt");
|
|
|
|
if (text.equals("ping"))
|
|
{
|
|
obj_id record = utils.getObjIdScriptVar(self, "messageTo.recordObject");
|
|
if (!isIdValid(record))
|
|
{
|
|
record = instance.getAreaInstanceController(self);
|
|
}
|
|
|
|
dictionary dict = new dictionary();
|
|
dict.put("sender", self);
|
|
messageTo(record, "ping", dict, 0.0f, false);
|
|
}
|
|
|
|
if (text.equals("clear"))
|
|
setState(self, STATE_COVER, false);
|
|
|
|
if (!isGod(self))
|
|
return SCRIPT_CONTINUE;
|
|
|
|
string[] parse = split( text, ' ' );
|
|
|
|
if (parse[0].equals("showGodWindow"))
|
|
showGodWindow(self);
|
|
|
|
if (parse[0].equals("help"))
|
|
{
|
|
showHelp();
|
|
}
|
|
|
|
if (parse[0].equals("listScripts"))
|
|
{
|
|
listScripts(self);
|
|
}
|
|
|
|
if (parse[0].equals("clearScript"))
|
|
{
|
|
clearScript(self);
|
|
}
|
|
|
|
if (parse[0].equals("clearAllScripts"))
|
|
{
|
|
clearAllScripts(self);
|
|
}
|
|
|
|
if (parse[0].equals("doClientEffect"))
|
|
runDoClientEffect(self, parse);
|
|
|
|
if (parse[0].equals("spawn"))
|
|
runSpawnCreature(self, parse);
|
|
|
|
if (parse[0].equals("find"))
|
|
runFind(self, parse);
|
|
|
|
if (parse[0].equals("warpToFind"))
|
|
runWarpToFind(self, parse);
|
|
|
|
if (parse[0].equals("enterFind"))
|
|
runEnterFind(self, parse);
|
|
|
|
if (parse[0].equals("buildingWarp"))
|
|
runInteriorWarp(self, parse);
|
|
|
|
if (parse[0].equals("showTime"))
|
|
runShowTime(self, parse);
|
|
|
|
if (parse[0].equals("isScentMasked"))
|
|
runIsScentMasked(self, parse);
|
|
|
|
if (parse[0].equals("validateConceal"))
|
|
runValidateConceal(self, parse);
|
|
|
|
if (parse[0].equals("getBuildingScripts"))
|
|
runGetBuildingScripts(self, parse);
|
|
|
|
|
|
if (parse[0].equals("getBuildingObjVars"))
|
|
runGetBuildingObjVars(self, parse);
|
|
|
|
if (parse[0].equals("getLoc"))
|
|
runTargetLocation(self, parse);
|
|
|
|
if (parse[0].equals("getTop"))
|
|
runGetTopMostContainer(self, parse);
|
|
|
|
if (parse[0].equals("buildoutLoc"))
|
|
{
|
|
runBuildoutLoc(self, parse);
|
|
}
|
|
|
|
if (parse[0].equals("messageTo"))
|
|
{
|
|
sendMessageTo(self, parse);
|
|
}
|
|
|
|
if (parse[0].equals("recreate"))
|
|
{
|
|
runDestroyAndRecreate(self, parse);
|
|
}
|
|
|
|
if (parse[0].equals("buildingMessage"))
|
|
{
|
|
runMessageToBuilding(self, parse);
|
|
}
|
|
|
|
if (parse[0].equals("deathTouch"))
|
|
{
|
|
runDeathTouch(self, parse);
|
|
}
|
|
|
|
if (parse[0].equals("buffMe"))
|
|
{
|
|
runBuffMe(self, parse);
|
|
}
|
|
|
|
if (parse[0].equals("buffYou"))
|
|
runBuffYou(self, parse);
|
|
|
|
if (parse[0].equals("setRecordObject"))
|
|
{
|
|
runSetRecordObject(self, parse);
|
|
}
|
|
|
|
if (parse[0].equals("recordTo"))
|
|
{
|
|
runRecordTo(self, parse);
|
|
}
|
|
if (parse[0].equals("getCellId"))
|
|
runGetCellId(self, parse);
|
|
|
|
if (parse[0].equals("clearLockout"))
|
|
runClearAllLockoutTimers(self, parse);
|
|
|
|
if (parse[0].equals("applyBuff"))
|
|
runApplyBuff(self, parse);
|
|
|
|
if (parse[0].equals("doAnim"))
|
|
runDoAnim(self, parse);
|
|
|
|
if (parse[0].equals("recordLoc"))
|
|
runDoRecordBuildoutLoc(self, parse);
|
|
|
|
if (parse[0].equals("playMusic"))
|
|
runPlayMusic(self, parse);
|
|
|
|
if (parse[0].equals("doPrt"))
|
|
runDoPrt(self, parse);
|
|
if (parse[0].equals("spawnAk"))
|
|
runSpawnAkPrime(self, parse);
|
|
|
|
if (parse[0].equals("badge"))
|
|
runBadgeOperation(self, parse);
|
|
|
|
|
|
if (parse[0].equals("formation"))
|
|
runSetFollowInFormation(self, parse);
|
|
|
|
if (parse[0].equals("deleteObject"))
|
|
runDeleteObject(self, parse);
|
|
|
|
if (parse[0].equals("dumpArea"))
|
|
runRoriConversion(self, parse);
|
|
|
|
if (parse[0].equals("getModLoc"))
|
|
getModLoc(self);
|
|
|
|
if (parse[0].equals("calculateWarp"))
|
|
calculateWarp(self, parse);
|
|
|
|
if (parse[0].equals("getRecordDistance"))
|
|
calculateDistance(self, parse);
|
|
|
|
if (parse[0].equals("deleteRegion"))
|
|
deleteRegion(self, parse);
|
|
|
|
if (parse[0].equals("broadcastMessage"))
|
|
broadcastMessageTo(self, parse);
|
|
|
|
if (parse[0].equals("getSpaceLoc"))
|
|
get3dSpaceLoc(self, parse);
|
|
|
|
if (parse[0].equals("query"))
|
|
runQuery(self, parse);
|
|
|
|
if (parse[0].equals("getBaseCount"))
|
|
getBaseCount(self, parse);
|
|
|
|
if (parse[0].equals("getGameTime"))
|
|
calculateGameTime(self, parse);
|
|
|
|
if (parse[0].equals("testBatch"))
|
|
runTestBatch(self, parse);
|
|
|
|
if (parse[0].equals("makeSpaceOvert"))
|
|
runMakeSpaceOvert(self, parse);
|
|
|
|
if (parse[0].equals("getPlanetObject"))
|
|
runGetPlanetObject(self, parse);
|
|
|
|
if (parse[0].equals("respec"))
|
|
runRespec(self, parse);
|
|
|
|
|
|
if (parse[0].equals("getSkillTemplate"))
|
|
runGetSkillTemplate(self, parse);
|
|
|
|
if (parse[0].equals("queueCommand"))
|
|
runQueueCommand(self, parse);
|
|
|
|
if (parse[0].equals("setCooldown"))
|
|
runSetCooldown(self, parse);
|
|
|
|
if (parse[0].equals("getWeapon"))
|
|
runGetWeapon(self, parse);
|
|
|
|
if (parse[0].equals("validateInstance"))
|
|
runVerifySession(self, parse);
|
|
|
|
if (parse[0].equals("getHateList"))
|
|
runGetHateList(self, parse);
|
|
|
|
if (parse[0].equals("getRespect"))
|
|
runGetRespect(self, parse);
|
|
|
|
if (parse[0].equals("makeDecoy"))
|
|
runMakeDecoy(self, parse);
|
|
|
|
if (parse[0].equals("comm_link"))
|
|
runCommLink(self, parse);
|
|
|
|
if (parse[0].equals("prepCave"))
|
|
runPrepCave(self, parse);
|
|
|
|
if (parse[0].equals("swarmTarget"))
|
|
runSwarmTarget(self, parse);
|
|
|
|
if (parse[0].equals("setMaster"))
|
|
runSetMaster(self, parse);
|
|
|
|
if (parse[0].equals("convert"))
|
|
runConvert(self, parse);
|
|
|
|
if (parse[0].equals("dumpToTable"))
|
|
dumpToTable(self, parse);
|
|
|
|
if (parse[0].equals("recreateTable"))
|
|
recreateTable(self, parse);
|
|
|
|
if (parse[0].equals("getCommandList"))
|
|
runGetCommmandList(self, parse);
|
|
|
|
if(parse[0].equals("cell"))
|
|
{
|
|
// If no destination is stated, then get the cell list.
|
|
if(parse.length == 1)
|
|
{
|
|
string[] params = new string[2];
|
|
|
|
params[0] = "getCellList";
|
|
params[1] = "" + getTopMostContainer(self);
|
|
|
|
runGetCellList(self, params);
|
|
}
|
|
|
|
// If a destination cell is stated, then teleport to that cell.
|
|
if(parse.length == 2)
|
|
{
|
|
string[] params = new string[3];
|
|
|
|
params[0] = "enterNamedCell";
|
|
params[1] = "" + getTopMostContainer(self);
|
|
params[2] = parse[1]; // parse[1] has the cell name
|
|
|
|
runEnterCell(self, params);
|
|
}
|
|
}
|
|
|
|
if (parse[0].equals("getCellList"))
|
|
runGetCellList(self, parse);
|
|
|
|
if (parse[0].equals("enterNamedCell"))
|
|
runEnterCell(self, parse);
|
|
|
|
if (parse[0].equals("doIt"))
|
|
runIt(self, parse);
|
|
|
|
if (parse[0].equals("getBell"))
|
|
runGetBell(self, parse);
|
|
|
|
if (parse[0].equals("setHover"))
|
|
runSetHover(self, parse);
|
|
|
|
if (parse[0].equals("testSlope"))
|
|
runTestSlope(self, parse);
|
|
|
|
if (parse[0].equals("changeY"))
|
|
runAlterHeight(self, parse);
|
|
|
|
if (parse[0].equals("testBool"))
|
|
runTestBool(self, parse);
|
|
|
|
if (parse[0].equals("addAttrib"))
|
|
runAddAttrib(self, parse);
|
|
|
|
if (parse[0].equals("lit3"))
|
|
runLit3(self, parse);
|
|
|
|
if (parse[0].equals("shield"))
|
|
runShieldMe(self, parse);
|
|
|
|
if (parse[0].equals("clearStun"))
|
|
clearStunEffects(self, parse);
|
|
|
|
if (parse[0].equals("shazam"))
|
|
makeMeAGod(self, parse);
|
|
|
|
if (parse[0].equals("setSlopeMod"))
|
|
runSetSlope(self, parse);
|
|
|
|
if (parse[0].equals("setKillMeter"))
|
|
runSetKillMeter(self, parse);
|
|
|
|
if (parse[0].equals("setMind"))
|
|
runSetMind(self, parse);
|
|
|
|
if (parse[0].equals("getMind"))
|
|
runGetMind(self, parse);
|
|
|
|
if (parse[0].equals("snowspeeder"))
|
|
runSetupSnowspeeder(self, parse);
|
|
|
|
if (parse[0].equals("recordSet"))
|
|
runSetRecordObjectFromFind(self, parse);
|
|
|
|
if (parse[0].equals("shoot"))
|
|
runTestShoot(self, parse);
|
|
|
|
if (parse[0].equals("setLoc"))
|
|
runSetLoc(self, parse);
|
|
|
|
if (parse[0].equals("dda_set"))
|
|
runSetDda(self, parse);
|
|
|
|
if (parse[0].equals("dda_get"))
|
|
runGetDda(self, parse);
|
|
|
|
if (toLower(parse[0]).equals("staticitem"))
|
|
runStaticItemParse(self, parse);
|
|
|
|
if (toLower(parse[0]).equals("staticitemfind"))
|
|
runStaticItemFind(self, parse);
|
|
|
|
if (toLower(parse[0]).equals("staticitemcreate"))
|
|
runStaticItemCreate(self, parse);
|
|
|
|
if (toLower(parse[0]).equals("staticitemlist"))
|
|
runStaticItemShowList(self);
|
|
|
|
if (toLower(parse[0]).equals("staticitemclear"))
|
|
runStaticItemClearList(self);
|
|
|
|
if (parse[0].equals("init_vehicle"))
|
|
{
|
|
vehicle.initializeVehicle(getMountId(self));
|
|
}
|
|
|
|
if (parse[0].equals("playSound"))
|
|
runPlaySound(self, parse);
|
|
|
|
if (parse[0].equals("triggerId"))
|
|
runFireTrigger(self, parse);
|
|
|
|
if (parse[0].equals("setCellLabel"))
|
|
runSetCellLabel(self, parse);
|
|
|
|
if (parse[0].equals("setId"))
|
|
runSetIdOnInstance(self, parse);
|
|
|
|
if (parse[0].equals("clearWp"))
|
|
runClearWaypoints(self, parse);
|
|
|
|
if (parse[0].equals("hideFrom"))
|
|
runHideFromClient(self, parse);
|
|
return SCRIPT_CONTINUE;
|
|
|
|
}
|
|
|
|
void showHelp()
|
|
{
|
|
for (int i=0;i<OPTIONS.length;i++)
|
|
sendSystemMessageTestingOnly(getSelf(),OPTIONS[i]);
|
|
}
|
|
|
|
void listScripts(obj_id self)
|
|
{
|
|
obj_id target = getLookAtTarget(self);
|
|
string[] scriptList = getScriptList(target);
|
|
|
|
for(int i=0;i<scriptList.length;i++)
|
|
{
|
|
debugSpeakMsg(self, scriptList[i]);
|
|
}
|
|
}
|
|
|
|
void clearScript(obj_id self)
|
|
{
|
|
obj_id target = getLookAtTarget(self);
|
|
string[] scriptList = getScriptList(target);
|
|
}
|
|
|
|
void clearAllScripts(obj_id self)
|
|
{
|
|
obj_id target = getLookAtTarget(self);
|
|
detachAllScripts(target);
|
|
sendSystemMessageTestingOnly(self, "ALL SCRIPTS REMOVED");
|
|
}
|
|
|
|
messageHandler handleClearScript()
|
|
{
|
|
obj_id target = params.getObjId("target");
|
|
string script = params.getString("script");
|
|
detachScript(target, script);
|
|
sendSystemMessageTestingOnly(self, "Removing Script("+script+") From("+getName(target)+"/"+target+")");
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
void runDoClientEffect(obj_id self, string[] parse)
|
|
{
|
|
if (parse[1].equals("self"))
|
|
{
|
|
string effect = "clienteffect/"+parse[1]+".cef";
|
|
playClientEffectObj(self, effect, self, "", null, "tag");
|
|
messageTo(self, "clearEffect", null, 10, false);
|
|
}
|
|
else
|
|
{
|
|
|
|
location playLoc = utils.findLocInFrontOfTarget(self, 10.0f);
|
|
string effect = "clienteffect/"+parse[1]+".cef";
|
|
playClientEffectLoc(getIntendedTarget(self), effect, playLoc, 0.4f);
|
|
}
|
|
}
|
|
|
|
messageHandler clearEffect()
|
|
{
|
|
stopClientEffectObjByLabel(self, "tag");
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
void runSpawnCreature(obj_id self, string[] parse)
|
|
{
|
|
location spawnLoc = utils.findLocInFrontOfTarget(self, 30.0f);
|
|
|
|
if (parse[1].equals("single"))
|
|
{
|
|
if (parse.length == 4)
|
|
create.object(parse[2], spawnLoc, utils.stringToInt(parse[3]));
|
|
else
|
|
create.object(parse[2], spawnLoc);
|
|
}
|
|
if (parse[1].equals("group"))
|
|
{
|
|
int intRand = rand(2,4);
|
|
for (int i = 0;i<intRand;i++)
|
|
{
|
|
if (parse.length == 4)
|
|
create.object(parse[2], spawnLoc, utils.stringToInt(parse[3]));
|
|
else
|
|
create.object(parse[2], spawnLoc);
|
|
}
|
|
}
|
|
}
|
|
|
|
void showGodWindow(obj_id user)
|
|
{
|
|
int pid = sui.listbox(user, user, "Select GM Option", OPTIONS, "handleSelectGMCommand");
|
|
}
|
|
|
|
messageHandler handleSelectGMCommand()
|
|
{
|
|
obj_id player = sui.getPlayerId(params);
|
|
int idx = sui.getListboxSelectedRow(params);
|
|
|
|
if(idx == listScripts)
|
|
doScriptListSUI(player);
|
|
if(idx == clearScript){}
|
|
|
|
if(idx == clearAllScripts)
|
|
clearAllScripts(player);
|
|
|
|
if(idx == listObjVars){}
|
|
//handle listObjVars SUI
|
|
if(idx == clearObjVar){}
|
|
//handle clearObjVar SUI
|
|
if(idx == clearAllObjVars){}
|
|
//handle clearAllObjVars SUI
|
|
if(idx == doClientEffect){}
|
|
//handle doClientEffect SUI
|
|
if(idx == spawnCreature){}
|
|
//handle spawnCreature SUI
|
|
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
void doScriptListSUI(obj_id player)
|
|
{
|
|
obj_id target = getLookAtTarget(player);
|
|
string[] scriptList = getScriptList(target);
|
|
int pid = sui.listbox(player, player, "SCRIPTS ON TARGET", scriptList, "handleRecievedScriptList");
|
|
|
|
}
|
|
|
|
void runFind (obj_id self, string[] parse)
|
|
{
|
|
float distance = 32000.0f;
|
|
obj_id closest = null;
|
|
|
|
if (parse[1].equals("object"))
|
|
{
|
|
obj_id [] objects = getObjectsInRange(self, 32000);
|
|
for (int i=0 ;i< objects.length;i++)
|
|
{
|
|
if (getTemplateName(objects[i]).equals(parse[2]) && objects[i] != self)
|
|
{
|
|
float range = getDistance(self, objects[i]);
|
|
if (range < distance)
|
|
{
|
|
distance = range;
|
|
closest = objects[i];
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
location foundLoc = getLocation(closest);
|
|
utils.setScriptVar(self, "objectLoc", foundLoc);
|
|
utils.setScriptVar(self, "objectId", closest);
|
|
sendSystemMessageTestingOnly(self, "Object("+getTemplateName(closest)+"/"+closest+") found at: "+foundLoc);
|
|
return;
|
|
}
|
|
|
|
if (parse[1].equals("obj_id"))
|
|
{
|
|
obj_id [] objects = getObjectsInRange(self, 32000);
|
|
obj_id passedObject = utils.stringToObjId(parse[2]);
|
|
debugSpeakMsg(self, "Passed obj_id was: "+passedObject);
|
|
|
|
for (int i=0 ;i< objects.length;i++)
|
|
{
|
|
if (objects[i] == passedObject)
|
|
{
|
|
float range = getDistance(self, objects[i]);
|
|
if (range < distance)
|
|
{
|
|
distance = range;
|
|
closest = objects[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
location foundLoc = getLocation(closest);
|
|
utils.setScriptVar(self, "objectLoc", foundLoc);
|
|
utils.setScriptVar(self, "objectId", closest);
|
|
sendSystemMessageTestingOnly(self, "Object("+getTemplateName(closest)+"/"+closest+") found at: "+foundLoc);
|
|
return;
|
|
}
|
|
|
|
if (parse[1].equals("indexOf"))
|
|
{
|
|
obj_id[] objects = getObjectsInRange(self, 32000);
|
|
|
|
for (int i=0;i<objects.length;i++)
|
|
{
|
|
if (getTemplateName(objects[i]).indexOf(parse[2]) > -1 && objects[i] != self)
|
|
{
|
|
float range = getDistance(self, objects[i]);
|
|
if (range < distance)
|
|
{
|
|
distance = range;
|
|
closest = objects[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
location foundLoc = getLocation(closest);
|
|
utils.setScriptVar(self, "objectLoc", foundLoc);
|
|
utils.setScriptVar(self, "objectId", closest);
|
|
sendSystemMessageTestingOnly(self, "Object("+getTemplateName(closest)+"/"+closest+") found at: "+foundLoc);
|
|
return;
|
|
}
|
|
|
|
if(parse[1].equals("indexOfAll"))
|
|
{
|
|
obj_id[] objects = getObjectsInRange(self, 32000);
|
|
location foundLoc;
|
|
|
|
for (int i=0;i<objects.length;i++)
|
|
{
|
|
if (getTemplateName(objects[i]).indexOf(parse[2]) > -1 && objects[i] != self)
|
|
{
|
|
float range = getDistance(self, objects[i]);
|
|
foundLoc = getLocation(objects[i]);
|
|
|
|
sendSystemMessageTestingOnly(self, "Object("+getTemplateName(objects[i])+"/"+objects[i]+") found at: "+foundLoc);
|
|
|
|
if (range < distance)
|
|
{
|
|
distance = range;
|
|
closest = objects[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
foundLoc = getLocation(closest);
|
|
utils.setScriptVar(self, "objectLoc", foundLoc);
|
|
utils.setScriptVar(self, "objectId", closest);
|
|
sendSystemMessageTestingOnly(self, "Closest Object("+getTemplateName(closest)+"/"+closest+") found at: "+foundLoc);
|
|
return;
|
|
}
|
|
|
|
if(parse[1].equals("spawnId"))
|
|
{
|
|
obj_id instance_id = instance.getAreaInstanceController(self);
|
|
if ( !isIdValid(instance_id) )
|
|
{
|
|
sendSystemMessage(self, "Invalid instance_id.", "");
|
|
}
|
|
|
|
|
|
if ( parse.length < 3 )
|
|
{
|
|
sendSystemMessage(self, "No spawn id specified.", "");
|
|
return;
|
|
}
|
|
|
|
sendSystemMessage(self, "spawnId search = "+ parse[2], "");
|
|
|
|
location foundLoc;
|
|
obj_id[] spawnIdObjects = trial.getObjectsInInstanceBySpawnId(instance_id, parse[2]);
|
|
if ( spawnIdObjects != null && spawnIdObjects.length > 0 )
|
|
{
|
|
for ( int i = 0; i < spawnIdObjects.length; i++ )
|
|
{
|
|
float range = getDistance(self, spawnIdObjects[i]);
|
|
foundLoc = getLocation(spawnIdObjects[i]);
|
|
|
|
sendSystemMessage(self, "Object( "+getTemplateName(spawnIdObjects[i])+" / "+spawnIdObjects[i]+" ) found at: "+foundLoc, "");
|
|
|
|
if (range < distance)
|
|
{
|
|
distance = range;
|
|
closest = spawnIdObjects[i];
|
|
}
|
|
}
|
|
|
|
foundLoc = getLocation(closest);
|
|
utils.setScriptVar(self, "objectLoc", foundLoc);
|
|
utils.setScriptVar(self, "objectId", closest);
|
|
sendSystemMessageTestingOnly(self, "Closest Object( "+getTemplateName(closest)+" / "+closest+" ) found at: "+foundLoc);
|
|
return;
|
|
}
|
|
}
|
|
|
|
sendSystemMessageTestingOnly(self, "No objects of that type found");
|
|
return;
|
|
}
|
|
|
|
void runWarpToFind(obj_id self, string[] parse)
|
|
{
|
|
if (!utils.hasScriptVar(self, "objectLoc"))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "No found loc on self");
|
|
return;
|
|
}
|
|
|
|
obj_id toEnter = trial.getTop(utils.getObjIdScriptVar(self, "objectId"));
|
|
|
|
obj_id[] cells = getCellIds(toEnter);
|
|
boolean isPob = false;
|
|
if (cells != null && cells.length > 0)
|
|
isPob = true;
|
|
|
|
location objLoc = utils.getLocationScriptVar(self, "objectLoc");
|
|
|
|
|
|
if (!isPob)
|
|
{
|
|
location warpTo = utils.getLocationScriptVar(self, "objectLoc");
|
|
warpPlayer(self, warpTo.area, warpTo.x, warpTo.y, warpTo.z, null, warpTo.x, warpTo.y, warpTo.z);
|
|
}
|
|
else
|
|
{
|
|
obj_id cellId = objLoc.cell;
|
|
string cellName = getCellName(cellId);
|
|
location cellLoc = getGoodLocation(toEnter, cellName);
|
|
warpPlayer(self, cellLoc.area, cellLoc.x, cellLoc.y, cellLoc.z, toEnter, cellName, cellLoc.x, cellLoc.y, cellLoc.z, "nullCallback", false);
|
|
|
|
}
|
|
}
|
|
|
|
void runEnterFind(obj_id self, string[] parse)
|
|
{
|
|
if (!utils.hasScriptVar(self, "objectId"))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "No object id on self");
|
|
return;
|
|
}
|
|
|
|
obj_id toEnter = utils.getObjIdScriptVar(self, "objectId");
|
|
|
|
obj_id[] cells = getCellIds(toEnter);
|
|
if (cells == null || cells.length == 0)
|
|
{
|
|
sendSystemMessageTestingOnly(self, "There are no cells on this object");
|
|
return;
|
|
}
|
|
|
|
string cellName = getCellName(cells[0]);
|
|
location cellLoc = getGoodLocation(toEnter, cellName);
|
|
warpPlayer(self, cellLoc.area, cellLoc.x, cellLoc.y, cellLoc.z, toEnter, cellName, cellLoc.x, cellLoc.y, cellLoc.z, "nullCallback", false);
|
|
}
|
|
|
|
void runInteriorWarp(obj_id self, string[] parse)
|
|
{
|
|
if (getTopMostContainer(self) == null)
|
|
return;
|
|
|
|
location cellLoc = getGoodLocation(getTopMostContainer(self), parse[1]);
|
|
if (cellLoc == null)
|
|
{
|
|
sendSystemMessageTestingOnly(self, "No floor in target cell: "+parse[1]);
|
|
return;
|
|
}
|
|
warpPlayer(self, cellLoc.area, cellLoc.x, cellLoc.y, cellLoc.z, getTopMostContainer(self), parse[1], cellLoc.x, cellLoc.y, cellLoc.z, "nullCallback", false);
|
|
}
|
|
|
|
void runShowTime(obj_id self, string[] parse)
|
|
{
|
|
string time = utils.formatTime(getGameTime());
|
|
sendSystemMessageTestingOnly(self, time);
|
|
}
|
|
|
|
void runIsScentMasked(obj_id self, string[] parse)
|
|
{
|
|
if (getState(self, STATE_MASK_SCENT) == 1)
|
|
sendSystemMessageTestingOnly(self, "You are scent masked");
|
|
else
|
|
sendSystemMessageTestingOnly(self, "You are not scent masked");
|
|
}
|
|
|
|
void runValidateConceal(obj_id self, string[] parse)
|
|
{
|
|
if (utils.hasScriptVar(self, "scentmask.count"))
|
|
sendSystemMessageTestingOnly(self, "Count: "+utils.getIntScriptVar(self, "scentmask.count"));
|
|
|
|
if (utils.hasScriptVar(self, "scentmask.camokit"))
|
|
sendSystemMessageTestingOnly(self, "Planet: "+utils.getStringScriptVar(self, "scentmask.camokit"));
|
|
|
|
if (utils.hasScriptVar(self, "scentmask.camoquality"))
|
|
sendSystemMessageTestingOnly(self, "Quality: "+utils.getIntScriptVar(self, "scentmask.camoquality"));
|
|
|
|
if (utils.hasScriptVar(self, "scentmask.camoapply"))
|
|
sendSystemMessageTestingOnly(self, "Player: "+getName(utils.getObjIdScriptVar(self, "scentmask.camoapply")));
|
|
}
|
|
|
|
void runGetBuildingScripts(obj_id self, string[] parse)
|
|
{
|
|
obj_id top = getTopMostContainer(self);
|
|
|
|
if (isIdValid(top))
|
|
{
|
|
string[] scriptList = getScriptList(top);
|
|
int pid = sui.listbox(self, self, "SCRIPTS ON BUILDING", scriptList, "handleRecievedScriptList");
|
|
}
|
|
}
|
|
|
|
void runGetBuildingObjVars(obj_id player, string[] parse)
|
|
{
|
|
obj_id target = getTopMostContainer(player);
|
|
string[] scriptList = getScriptList(target);
|
|
int pid = sui.listbox(player, player, "SCRIPTS ON TARGET", scriptList, "handleRecievedScriptList");
|
|
}
|
|
|
|
void runTargetLocation(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = getIntendedTarget(self);
|
|
if (!isIdValid(target))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "You must target something first");
|
|
return;
|
|
}
|
|
|
|
location tarLoc = getLocation(target);
|
|
float yaw = getYaw(target);
|
|
|
|
if (!isIdValid(tarLoc.cell))
|
|
{
|
|
|
|
sendSystemMessageTestingOnly(self, "Location("+tarLoc.x+", "+tarLoc.y+", "+tarLoc.z+") yaw("+yaw+") cell("+tarLoc.cell+") on scene ("+tarLoc.area+")");
|
|
|
|
}
|
|
else
|
|
{
|
|
string cell = utils.getCellName(getTopMostContainer(self), tarLoc.cell);
|
|
sendSystemMessageTestingOnly(self, "Location("+tarLoc.x+", "+tarLoc.y+", "+tarLoc.z+") yaw("+yaw+") cell("+cell+") on scene ("+tarLoc.area+")");
|
|
}
|
|
}
|
|
|
|
void runBuildoutLoc(obj_id self, string[] parse)
|
|
{
|
|
if (!hasObjVar(self, "record_table"))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "You do not have the record_table objvar defined");
|
|
return;
|
|
}
|
|
|
|
obj_id target = getTarget(self);
|
|
|
|
if (!isIdValid(target))
|
|
{
|
|
if (parse.length < 2)
|
|
{
|
|
sendSystemMessageTestingOnly(self, "You must target something first");
|
|
return;
|
|
}
|
|
|
|
target = utils.stringToObjId(parse[1]);
|
|
if (!isIdValid(target))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Invalid Target Specified");
|
|
return;
|
|
}
|
|
}
|
|
|
|
string table = getStringObjVar(self, "record_table");
|
|
location tarLoc = getLocation(target);
|
|
string name = getTemplateName(target);
|
|
float yaw = getYaw(target);
|
|
string cell = utils.getCellName(getTopMostContainer(self), tarLoc.cell);
|
|
sendSystemMessageTestingOnly(self, "Location("+tarLoc.x+", "+tarLoc.y+", "+tarLoc.z+") yaw("+yaw+") cell("+cell+")");
|
|
|
|
dictionary dctRow = new dictionary ();
|
|
dctRow.put ("spawns", name);
|
|
dctRow.put ("loc_x", tarLoc.x);
|
|
dctRow.put ("loc_y", tarLoc.y);
|
|
dctRow.put ("loc_z", tarLoc.z);
|
|
dctRow.put ("room", cell);
|
|
dctRow.put ("yaw", yaw);
|
|
|
|
datatable.serverDataTableAddRow(table, dctRow);
|
|
|
|
}
|
|
|
|
void sendMessageTo(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = getTarget(self);
|
|
if (!isIdValid(target))
|
|
target = self;
|
|
|
|
string message = parse[1];
|
|
|
|
if (parse.length > 2)
|
|
{
|
|
dictionary dict = new dictionary();
|
|
|
|
for (int i=2;i<parse.length;i+=2)
|
|
{
|
|
int k = i+1;
|
|
dict.put(parse[i], parse[k]);
|
|
}
|
|
|
|
messageTo(target, message, dict, 0, false);
|
|
}
|
|
else
|
|
messageTo(target, message, null, 0, false);
|
|
}
|
|
|
|
void broadcastMessageTo(obj_id self, string[] parse)
|
|
{
|
|
obj_id[] objects = getObjectsInRange(self, 200.0f);
|
|
|
|
if (objects == null || objects.length == 0)
|
|
return;
|
|
|
|
for (int q=0;q<objects.length;q++)
|
|
{
|
|
if (!isIdValid(objects[q]))
|
|
continue;
|
|
|
|
obj_id target = objects[q];
|
|
string message = parse[1];
|
|
|
|
if (parse.length > 2)
|
|
{
|
|
dictionary dict = new dictionary();
|
|
|
|
for (int i=2;i<parse.length;i+=2)
|
|
{
|
|
int k = i+1;
|
|
dict.put(parse[i], parse[k]);
|
|
}
|
|
|
|
messageTo(target, message, dict, 0, false);
|
|
}
|
|
else
|
|
messageTo(target, message, null, 0, false);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void runDestroyAndRecreate(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = obj_id.NULL_ID;
|
|
|
|
if (parse.length > 1)
|
|
{
|
|
if (parse[1].equals("recordObject"))
|
|
target = utils.getObjIdScriptVar(self, "messageTo.recordObject");
|
|
}
|
|
else
|
|
target = getTopMostContainer(self);
|
|
|
|
if (!isIdValid(target) || target == self)
|
|
return;
|
|
|
|
string template = getTemplateName(target);
|
|
location tarLoc = getLocation(target);
|
|
|
|
if (template.startsWith("object"))
|
|
{
|
|
if (target == getTopMostContainer(self))
|
|
{
|
|
obj_id[] toDestroy = trial.getAllObjectsInDungeon(target);
|
|
trial.cleanupNpc(toDestroy);
|
|
location recordLoc = getLocation(target);
|
|
location selfLoc = getLocation(self);
|
|
string cell = getCellName(selfLoc.cell);
|
|
trial.cleanupObject(target);
|
|
obj_id newObject = createObject(template, tarLoc);
|
|
warpPlayer(self, recordLoc.area, recordLoc.x, recordLoc.y, recordLoc.z, newObject, cell, selfLoc.x, selfLoc.y, selfLoc.z, "");
|
|
}
|
|
}
|
|
}
|
|
|
|
void runMessageToBuilding(obj_id self, string[] parse)
|
|
{
|
|
obj_id top = getTopMostContainer(self);
|
|
|
|
string message = parse[1];
|
|
|
|
if (parse.length > 2)
|
|
{
|
|
dictionary dict = trial.getSessionDict(top);
|
|
|
|
for (int i=2;i<parse.length;i+=2)
|
|
{
|
|
int k = i+1;
|
|
dict.put(parse[i], parse[k]);
|
|
}
|
|
|
|
messageTo(top, message, dict, 0, false);
|
|
}
|
|
else
|
|
messageTo(top, message, null, 0, false);
|
|
|
|
}
|
|
|
|
void runDeathTouch(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = getTarget(self);
|
|
if (!isIdValid(target))
|
|
return;
|
|
|
|
trial.cleanupObject(target);
|
|
}
|
|
|
|
void runBuffMe(obj_id self, string[] parse)
|
|
{
|
|
buff.applyBuff(self, parse[1]);
|
|
}
|
|
|
|
void runBuffYou(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = getIntendedTarget(self);
|
|
|
|
buff.applyBuff(target, parse[1]);
|
|
}
|
|
|
|
void runSetRecordObject(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = getTarget(self);
|
|
if (isIdValid(target))
|
|
{
|
|
utils.setScriptVar(self, "messageTo.recordObject", target);
|
|
sendSystemMessageTestingOnly(self, "Record object set to: "+target);
|
|
}
|
|
else
|
|
{
|
|
obj_id top = trial.getTop(self);
|
|
utils.setScriptVar(self, "messageTo.recordObject", top);
|
|
sendSystemMessageTestingOnly(self, "Record object set to: "+top);
|
|
}
|
|
}
|
|
|
|
void runSetRecordObjectFromFind(obj_id self, string[] parse)
|
|
{
|
|
obj_id findObject = utils.getObjIdScriptVar(self, "objectId");
|
|
|
|
if (isIdValid(findObject))
|
|
{
|
|
utils.setScriptVar(self, "messageTo.recordObject", findObject);
|
|
sendSystemMessageTestingOnly(self, "Record object set to: "+findObject);
|
|
}
|
|
|
|
}
|
|
|
|
void runRecordTo(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = utils.getObjIdScriptVar(self, "messageTo.recordObject");
|
|
if (!isIdValid(target))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "You do not have a record object");
|
|
return;
|
|
}
|
|
string message = parse[1];
|
|
|
|
if (parse.length > 2)
|
|
{
|
|
dictionary dict = trial.getSessionDict(target);
|
|
|
|
for (int i=2;i<parse.length;i+=2)
|
|
{
|
|
int k = i+1;
|
|
dict.put(parse[i], parse[k]);
|
|
}
|
|
|
|
messageTo(target, message, dict, 0, false);
|
|
}
|
|
else
|
|
messageTo(target, message, null, 0, false);
|
|
|
|
}
|
|
|
|
void runGetCellId(obj_id self, string[] parse)
|
|
{
|
|
obj_id container = getContainedBy(self);
|
|
sendSystemMessageTestingOnly(self, "I am contained by ("+container+")");
|
|
}
|
|
|
|
|
|
void runClearAllLockoutTimers(obj_id self, string[] parse)
|
|
{
|
|
space_dungeon.clearAllDungeonLockoutTimers(self);
|
|
}
|
|
|
|
void runApplyBuff(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = getTarget(self);
|
|
if (!isIdValid(target))
|
|
target = self;
|
|
|
|
buff.applyBuff(target, parse[1]);
|
|
}
|
|
|
|
void runDoAnim(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = getLookAtTarget(self);
|
|
if (!isIdValid(target))
|
|
target = self;
|
|
|
|
doAnimationAction(target, parse[1]);
|
|
}
|
|
|
|
void runDoRecordBuildoutLoc(obj_id self, string[] parse)
|
|
{
|
|
if (!hasObjVar(self, "record_table"))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "You do not have the record_table objvar defined");
|
|
return;
|
|
}
|
|
|
|
obj_id target = getTarget(self);
|
|
|
|
if (!isIdValid(target))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "You must target something first");
|
|
return;
|
|
}
|
|
|
|
string table = getStringObjVar(self, "record_table");
|
|
location objLoc = getLocation(target);
|
|
// location recordLoc = getLocation(utils.getObjIdScriptVar(self, "messageTo.recordObject"));
|
|
float x = objLoc.x;
|
|
float y = objLoc.y;
|
|
float z = objLoc.z;
|
|
|
|
string name = getTemplateName(target);
|
|
float yaw = getYaw(target);
|
|
sendSystemMessageTestingOnly(self, "Location("+x+", "+y+", "+z+") yaw("+yaw+")");
|
|
|
|
dictionary dctRow = new dictionary ();
|
|
dctRow.put ("object", name);
|
|
dctRow.put ("phase", 0);
|
|
dctRow.put ("x_offset", x);
|
|
dctRow.put ("y_offset", y);
|
|
dctRow.put ("z_offset", z);
|
|
dctRow.put ("yaw", yaw);
|
|
|
|
datatable.serverDataTableAddRow(table, dctRow);
|
|
|
|
|
|
}
|
|
|
|
void runPlayMusic(obj_id self, string[] parse)
|
|
{
|
|
string sound = "sound/"+parse[1]+".snd";
|
|
playMusic(self, sound);
|
|
sendSystemMessageTestingOnly(self, "Tried to play sound: "+sound);
|
|
}
|
|
|
|
void runDoPrt(obj_id self, string[] parse)
|
|
{
|
|
string effect = "appearance/"+parse[1]+".prt";
|
|
location playLoc = utils.findLocInFrontOfTarget(self, 10.0f);
|
|
playClientEffectLoc(getIntendedTarget(self), effect, playLoc, 0.4f);
|
|
sendSystemMessageTestingOnly(self, "Attempting to do prt "+effect);
|
|
}
|
|
|
|
void runSpawnAkPrime(obj_id self, string[] parse)
|
|
{
|
|
obj_id ak = create.object("som_volcano_two_ak_prime", getLocation(self));
|
|
attachScript(ak, "theme_park.dungeon.mustafar_trials.volcano_battlefield.event_two_boss");
|
|
setInvulnerable(ak, false);
|
|
}
|
|
|
|
void runGetTopMostContainer(obj_id self, string[] parse)
|
|
{
|
|
obj_id top = getTopMostContainer(self);
|
|
sendSystemMessageTestingOnly(self, "Top most container is("+top+")");
|
|
}
|
|
|
|
void runBadgeOperation(obj_id self, string[] parse)
|
|
{
|
|
if (parse.length < 3)
|
|
return;
|
|
|
|
if (parse[1].equals("grant"))
|
|
badge.grantBadge(self, parse[2]);
|
|
if (parse[1].equals("revoke"))
|
|
badge.revokeBadge(self, parse[2], true);
|
|
}
|
|
|
|
void runSetFollowInFormation(obj_id self, string[] parse)
|
|
{
|
|
if (parse.length < 2)
|
|
return;
|
|
|
|
obj_id target = getTarget(self);
|
|
if (!isIdValid(target))
|
|
return;
|
|
|
|
stop(target);
|
|
ai_lib.setDefaultCalmBehavior(target, ai_lib.BEHAVIOR_SENTINEL);
|
|
|
|
int position = 0;
|
|
|
|
if (parse.length == 3)
|
|
position = utils.stringToInt(parse[2]);
|
|
|
|
|
|
if (parse[1].equals("column"))
|
|
ai_lib.followInFormation(target, self, ai_lib.FORMATION_COLUMN, position);
|
|
|
|
if (parse[1].equals("wedge"))
|
|
ai_lib.followInFormation(target, self, ai_lib.FORMATION_WEDGE, position);
|
|
|
|
|
|
if (parse[1].equals("line"))
|
|
ai_lib.followInFormation(target, self, ai_lib.FORMATION_LINE, position);
|
|
|
|
|
|
if (parse[1].equals("box"))
|
|
ai_lib.followInFormation(target, self, ai_lib.FORMATION_BOX, position);
|
|
|
|
|
|
return;
|
|
}
|
|
|
|
void runDeleteObject(obj_id self, string[] parse)
|
|
{
|
|
int length = parse.length;
|
|
|
|
switch (length)
|
|
{
|
|
case 0:
|
|
return;
|
|
case 1:
|
|
runDeathTouch(self, parse);
|
|
return;
|
|
case 2:
|
|
string deleteString = parse[1];
|
|
|
|
obj_id[] objects = getObjectsInRange(self, 200);
|
|
if (objects == null || objects.length == 0)
|
|
return;
|
|
|
|
for (int i=0;i<objects.length;i++)
|
|
{
|
|
if (getTemplateName(objects[i]).equals(deleteString))
|
|
trial.cleanupObject(objects[i]);
|
|
}
|
|
return;
|
|
case 3:
|
|
if (!parse[1].equals("indexOf"))
|
|
return;
|
|
|
|
objects = getObjectsInRange(self, 200);
|
|
if (objects == null || objects.length == 0)
|
|
return;
|
|
|
|
|
|
for (int j=0;j<objects.length;j++)
|
|
{
|
|
if (!isIdValid(objects[j]))
|
|
continue;
|
|
|
|
if (getTemplateName(objects[j]).indexOf(parse[2]) > -1)
|
|
trial.cleanupObject(objects[j]);
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
void runRoriConversion(obj_id self, string[] parse)
|
|
{
|
|
if (!hasObjVar(self, "record_table"))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "You do not have the record_table objvar defined");
|
|
return;
|
|
}
|
|
if (!utils.hasScriptVar(self, "messageTo.recordObject"))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "You do not have a recordTo defined");
|
|
return;
|
|
}
|
|
|
|
//string table = "datatables/spawning/npc_base_builder/restuss_event/rebel/barr_4.tab";
|
|
string table = getStringObjVar(self, "record_table");
|
|
|
|
string[] strHeaderTypes = { "s","s","f","f","f","f","s"};
|
|
string[] strHeaders = {"object","phase","x_offset","y_offset","z_offset","yaw","cell"};
|
|
boolean boolTest = datatable.createDataTable(table, strHeaders,strHeaderTypes);
|
|
if(!boolTest)
|
|
{
|
|
sendSystemMessageTestingOnly(self, "No dataTable made");
|
|
return;
|
|
|
|
}
|
|
|
|
location recordLoc = getLocation(utils.getObjIdScriptVar(self, "messageTo.recordObject"));
|
|
|
|
obj_id[] objects = getAllObjectsWithObjVar(recordLoc, 300.0f, "test");
|
|
|
|
if (objects == null || objects.length == 0)
|
|
return;
|
|
|
|
for (int i=0;i<objects.length;i++)
|
|
{
|
|
if (getTemplateName(objects[i]).indexOf("invis") < 1 && !isPlayer(objects[i]))
|
|
{
|
|
obj_id top = trial.getTop(objects[i]);
|
|
|
|
if (top == objects[i])
|
|
{
|
|
location objLoc = getLocation(objects[i]);
|
|
float x = objLoc.x - recordLoc.x;
|
|
float y = objLoc.y - recordLoc.y;
|
|
float z = objLoc.z - recordLoc.z;
|
|
string name = getTemplateName(objects[i]);
|
|
float yaw = getYaw(objects[i]);
|
|
sendSystemMessageTestingOnly(self, "Object("+name+") Location("+x+", "+y+", "+z+") yaw("+yaw+")");
|
|
|
|
dictionary dctRow = new dictionary ();
|
|
dctRow.put ("object", name);
|
|
dctRow.put ("phase", "0");
|
|
dctRow.put ("x_offset", x);
|
|
dctRow.put ("y_offset", y);
|
|
dctRow.put ("z_offset", z);
|
|
dctRow.put ("yaw", yaw);
|
|
datatable.serverDataTableAddRow(table, dctRow);
|
|
/**
|
|
obj_id[] cells = getCellIds(objects[i]);
|
|
if (cells != null && cells.length > 0)
|
|
{
|
|
obj_id[] contents = trial.getAllObjectsInDungeon(objects[i]);
|
|
if (contents != null && contents.length > 0)
|
|
{
|
|
for (int k=0;k<contents.length;k++)
|
|
{
|
|
location cLoc = getLocation(contents[k]);
|
|
yaw = getYaw(contents[k]);
|
|
name = getTemplateName(contents[k]);
|
|
dctRow.put("object", name);
|
|
dctRow.put("phase", "0");
|
|
dctRow.put("x_offset", cLoc.x);
|
|
dctRow.put("y_offset", cLoc.y);
|
|
dctRow.put("z_offset", cLoc.z);
|
|
dctRow.put("yaw", yaw);
|
|
dctRow.put("cell", getCellName(cLoc.cell));
|
|
sendSystemMessageTestingOnly(self, "Object("+name+") Location("+x+", "+y+", "+z+") yaw("+yaw+")");
|
|
datatable.serverDataTableAddRow(table, dctRow);
|
|
}
|
|
}
|
|
}
|
|
**/
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void getModLoc(obj_id self)
|
|
{
|
|
if (!utils.hasScriptVar(self, "messageTo.recordObject"))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "You do not have a record object");
|
|
return;
|
|
}
|
|
|
|
obj_id target = getIntendedTarget(self);
|
|
if (!isIdValid(target))
|
|
target = self;
|
|
|
|
location tLoc = getLocation(target);
|
|
float yaw = getYaw(target);
|
|
location rLoc = getLocation(utils.getObjIdScriptVar(self, "messageTo.recordObject"));
|
|
|
|
location modLoc = new location(tLoc.x-rLoc.x, tLoc.y-rLoc.y,tLoc.z-rLoc.z, rLoc.area);
|
|
sendSystemMessageTestingOnly(self, "Transform "+modLoc.x+" "+modLoc.y+" "+modLoc.z+ ", Yaw: "+yaw);
|
|
|
|
LOG("whereLog", "Where: x " + modLoc.x + " ");
|
|
LOG("whereLog", "Where: y " + modLoc.y + " ");
|
|
LOG("whereLog", "Where: z " + modLoc.z + " ");
|
|
LOG("whereLog", "Yaw====: " + yaw + " ");
|
|
}
|
|
|
|
void calculateWarp(obj_id self, string[] parse)
|
|
{
|
|
if (parse == null || parse.length < 3)
|
|
return;
|
|
|
|
float dist = 4096.0f;
|
|
|
|
float x = utils.stringToFloat(parse[1]);
|
|
float z = utils.stringToFloat(parse[2]);
|
|
|
|
x+=dist;
|
|
z+=dist;
|
|
|
|
warpPlayer(self, "rori", x, 0, z, null, x, 0, z);
|
|
|
|
|
|
}
|
|
|
|
void calculateDistance (obj_id self, string[] parse)
|
|
{
|
|
float distance = getDistance(getLocation(self), getLocation(utils.getObjIdScriptVar(self, "messageTo.recordObject")));
|
|
sendSystemMessageTestingOnly(self, "Distance to recordObject: "+distance);
|
|
}
|
|
|
|
void deleteRegion(obj_id self, string[] parse)
|
|
{
|
|
region r = getRegion(getLocation(self).area, parse[1]);
|
|
deleteRegion(r);
|
|
sendSystemMessageTestingOnly(self, "Deleted Region: "+r);
|
|
}
|
|
|
|
void get3dSpaceLoc(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = getTarget(self);
|
|
|
|
transform vctTest = getTransform_o2p(target);
|
|
vector vctJ = vctTest.getLocalFrameJ_p();
|
|
vector vctK = vctTest.getLocalFrameK_p();
|
|
vector vctP = vctTest.getPosition_p();
|
|
|
|
sendSystemMessageTestingOnly(self, "J = "+vctJ.x+", "+vctJ.y+", "+vctJ.z+", K = "+vctK.x+", "+vctK.y+", "+vctK.z+", Pos = "+vctP.x+", "+vctP.y+", "+vctP.z);
|
|
}
|
|
|
|
|
|
void runQuery(obj_id self, string[] parse)
|
|
{
|
|
string subject = parse[1];
|
|
string modifier = parse[2];
|
|
|
|
if (subject.equals("creature"))
|
|
{
|
|
string creatureTable = "datatables/mob/creatures.iff";
|
|
|
|
if (modifier.equals("name"))
|
|
{
|
|
int row = dataTableSearchColumnForString(parse[3], "creatureName", creatureTable);
|
|
if ( row > -1)
|
|
{
|
|
dictionary creatureDict = dataTableGetRow(creatureTable, row);
|
|
string[] data = convertCreatureQueryToStringArray(creatureDict);
|
|
populateListbox(self, data, "none");
|
|
}
|
|
else
|
|
{
|
|
string[] nameList = dataTableGetStringColumn(creatureTable, "creatureName");
|
|
resizeable string[] indexList = new string[0];
|
|
|
|
for (int i=0;i<nameList.length;i++)
|
|
{
|
|
if (nameList[i].indexOf(parse[3]) > -1)
|
|
{
|
|
utils.addElement(indexList, nameList[i]);
|
|
}
|
|
}
|
|
|
|
if (indexList == null || indexList.length == 0)
|
|
{
|
|
sendSystemMessageTestingOnly(self, "No matches could be found");
|
|
return;
|
|
}
|
|
|
|
nameList = indexList;
|
|
populateListbox(self, nameList, "creatureLookup");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void populateListbox(obj_id self, string[] data, string handler)
|
|
{
|
|
int pid = createSUIPage(sui.SUI_LISTBOX, self, self, handler);
|
|
if ( pid > -1 )
|
|
{
|
|
setSUIProperty(pid, sui.LISTBOX_TITLE, sui.PROP_TEXT, "Query Result");
|
|
setSUIProperty(pid, sui.LISTBOX_PROMPT, sui.PROP_TEXT, "Query Results");
|
|
|
|
sui.listboxButtonSetup(pid, 0);
|
|
|
|
if ( data != null && data.length > 0 )
|
|
{
|
|
clearSUIDataSource(pid, sui.LISTBOX_DATASOURCE);
|
|
|
|
for ( int i = 0; i < data.length; i++ )
|
|
{
|
|
sui.addSUIDataItem(pid, sui.LISTBOX_DATASOURCE, "" + i);
|
|
sui.setSUIProperty(pid, sui.LISTBOX_DATASOURCE + "." + i, sui.PROP_TEXT, data[i]);
|
|
}
|
|
}
|
|
utils.setScriptVar(self, "query.data", data);
|
|
|
|
sui.subscribeToSUIProperty(pid, sui.LISTBOX_LIST, sui.PROP_SELECTEDROW);
|
|
sui.subscribeToSUIProperty(pid, sui.LISTBOX_TITLE, sui.PROP_TEXT);
|
|
|
|
sui.showSUIPage(pid);
|
|
}
|
|
|
|
}
|
|
|
|
string[] convertCreatureQueryToStringArray(dictionary creatureDict)
|
|
{
|
|
string[] data = new string[18];
|
|
|
|
data[0] = "Name: "+creatureDict.getString("creatureName");
|
|
data[1] = "Level: "+creatureDict.getInt("BaseLevel");
|
|
data[2] = "Difficulty Class: "+creatureDict.getInt("difficultyClass");
|
|
data[3] = "Location: "+creatureDict.getString("where");
|
|
data[4] = "Social Group: "+creatureDict.getString("socialGroup");
|
|
data[5] = "PvP Faction: "+creatureDict.getString("pvpFaction");
|
|
data[6] = "Template: "+creatureDict.getString("template");
|
|
data[7] = "Loot Table: "+creatureDict.getString("lootTable");
|
|
data[8] = "Loot List: "+creatureDict.getString("lootList");
|
|
data[9] = "Niche: "+creatureDict.getInt("niche");
|
|
data[10] = "Scripts: "+creatureDict.getString("scripts");
|
|
data[11] = "Primary Weapon: "+creatureDict.getString("primary_weapon");
|
|
data[12] = "Primary Specials: "+creatureDict.getString("primary_weapon_specials");
|
|
data[13] = "Secondary Weapon: "+creatureDict.getString("secondary_weapon");
|
|
data[14] = "Secondary Specials: "+creatureDict.getString("secondary_weapon_specials");
|
|
data[15] = "Aggressive: "+creatureDict.getFloat("aggressive");
|
|
data[16] = "Assist: "+creatureDict.getFloat("assist");
|
|
data[17] = "Death Blow: "+creatureDict.getInt("death_blow");
|
|
|
|
return data;
|
|
}
|
|
|
|
messageHandler creatureLookup()
|
|
{
|
|
int btn = sui.getIntButtonPressed(params);
|
|
int idx = sui.getListboxSelectedRow(params);
|
|
|
|
if ( btn == sui.BP_CANCEL )
|
|
{
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
if ( idx == -1 )
|
|
{
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
string[] passedData = utils.getStringArrayScriptVar(self, "query.data");
|
|
|
|
string creatureTable = "datatables/mob/creatures.iff";
|
|
int row = dataTableSearchColumnForString(passedData[idx], "creatureName", creatureTable);
|
|
if ( row > -1)
|
|
{
|
|
dictionary creatureDict = dataTableGetRow(creatureTable, row);
|
|
string[] data = convertCreatureQueryToStringArray(creatureDict);
|
|
populateListbox(self, data, "none");
|
|
}
|
|
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
void getBaseCount(obj_id self, string[] parse)
|
|
{
|
|
obj_id planetId = getPlanetByName(getLocation(self).area);
|
|
obj_id planetRegister = utils.getObjIdScriptVar(planetId, gcw.GCW_BASE_MANAGER);
|
|
int rebel = gcw.getRebelBaseCount(planetId);
|
|
int imperial = gcw.getImperialBaseCount(planetId);
|
|
sendSystemMessageTestingOnly(self, "There are "+rebel+" Rebel Bases and "+imperial+" Imperial Bases in scene "+getLocation(self).area+" via manager "+planetRegister);
|
|
}
|
|
|
|
void calculateGameTime(obj_id self, string[] parse)
|
|
{
|
|
if (parse.length == 1)
|
|
sendSystemMessageTestingOnly(self, ""+getGameTime());
|
|
else
|
|
{
|
|
int passedTime = utils.stringToInt(parse[1]);
|
|
string verboseTime = utils.formatTimeVerbose(getGameTime() - passedTime);
|
|
sendSystemMessageTestingOnly(self, verboseTime);
|
|
}
|
|
}
|
|
|
|
void runTestBatch(obj_id self, string[] parse)
|
|
{
|
|
if (parse.length < 2)
|
|
return;
|
|
|
|
int[] toTheMax = new int[45];
|
|
|
|
for (int i=0;i<45;i++)
|
|
{
|
|
toTheMax[i] = i;
|
|
}
|
|
|
|
if (utils.hasIntBatchObjVar(self, parse[1]))
|
|
utils.removeBatchObjVar(self, parse[1]);
|
|
else
|
|
utils.setBatchObjVar(self, parse[1], toTheMax);
|
|
}
|
|
|
|
void runMakeSpaceOvert(obj_id self, string[] parse)
|
|
{
|
|
|
|
string faction = factions.getFaction(self);
|
|
|
|
if (faction == null)
|
|
return;
|
|
|
|
if (faction.equals("Rebel"))
|
|
space_transition.setPlayerOvert( self, ##"rebel" );
|
|
else
|
|
space_transition.setPlayerOvert( self, ##"imperial" );
|
|
|
|
|
|
}
|
|
|
|
void runGetPlanetObject(obj_id self, string[] parse)
|
|
{
|
|
sendSystemMessageTestingOnly(self, ""+getPlanetByName(getLocation(self).area));
|
|
}
|
|
|
|
|
|
void runRespec(obj_id self, string[] parse)
|
|
{
|
|
if (parse.length < 3)
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Not enough parameters");
|
|
return;
|
|
}
|
|
|
|
string newTemplate = parse[1];
|
|
float pctDone = utils.stringToFloat(parse[2]);
|
|
|
|
skill.revokeAllProfessionSkills(self);
|
|
|
|
setSkillTemplate(self, newTemplate);
|
|
respec.setPercentageCompletion(self, newTemplate, pctDone, false);
|
|
|
|
skill.recalcPlayerPools(self, true);
|
|
|
|
}
|
|
|
|
void runGetSkillTemplate (obj_id self, string[] parse)
|
|
{
|
|
sendSystemMessageTestingOnly(self, getSkillTemplate(self));
|
|
}
|
|
|
|
void runQueueCommand(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = getIntendedTarget(self);
|
|
|
|
//target = isIdValid(target) ? target : self;
|
|
|
|
queueCommand(self, getStringCrc(parse[1].toLowerCase()), target, "", COMMAND_PRIORITY_DEFAULT);
|
|
}
|
|
|
|
void runSetCooldown(obj_id self, string[] parse)
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Gathering Data for : "+parse[1]);
|
|
combat_data cd = combat_engine.getCombatData(parse[1]);
|
|
string cooldownGroup = cd.cooldownGroup;
|
|
sendSystemMessageTestingOnly(self, "Cooldown Group and Base: "+cd.cooldownGroup+", "+cd.cooldownTime);
|
|
|
|
int groupCrc = getStringCrc(cooldownGroup);
|
|
float baseCooldownTime = 1.0f;
|
|
|
|
if (parse.length > 2)
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Overriding base time with "+utils.stringToFloat(parse[2]));
|
|
|
|
baseCooldownTime = utils.stringToFloat(parse[2]);
|
|
}
|
|
else
|
|
baseCooldownTime = cd.cooldownTime;
|
|
|
|
sendSystemMessageTestingOnly(self, "Attempting to Set cooldown time on "+getName(self)+" to group "+cd.cooldownGroup+" at time "+baseCooldownTime);
|
|
sendCooldownGroupTimingOnly(self, groupCrc, baseCooldownTime);
|
|
}
|
|
|
|
void runGetWeapon(obj_id self, string[] parse)
|
|
{
|
|
obj_id weapon = getCurrentWeapon(self);
|
|
|
|
sendSystemMessageTestingOnly(self, "Current weapon is: "+weapon);
|
|
}
|
|
|
|
void runVerifySession(obj_id self, string[] parse)
|
|
{
|
|
space_dungeon.verifyPlayerSession(self);
|
|
}
|
|
|
|
void runGetHateList(obj_id self, string[] parse)
|
|
{
|
|
obj_id subject = getTarget(self);
|
|
|
|
obj_id primary_target = getHateTarget(subject);
|
|
float hate_value = getHate(subject, primary_target);
|
|
obj_id[] hated = getHateList(subject);
|
|
|
|
sendSystemMessageTestingOnly(self, "Primary Target: "+getName(primary_target)+" - "+hate_value);
|
|
if (hated.length < 2)
|
|
return;
|
|
|
|
sendSystemMessageTestingOnly(self, "Full List");
|
|
string[] detailed_list = new string[hated.length];
|
|
|
|
for (int i=0;i<hated.length;i++)
|
|
{
|
|
detailed_list[i] = ""+getName(hated[i])+" - "+getHate(subject, hated[i]);
|
|
sendSystemMessageTestingOnly(self, detailed_list[i]);
|
|
}
|
|
}
|
|
|
|
void runGetRespect(obj_id self, string[] parse)
|
|
{
|
|
obj_id subject = getTarget(self);
|
|
|
|
float respectRadius = aiGetRespectRadius(subject, self);
|
|
|
|
sendSystemMessageTestingOnly(self, "Respect Radius for "+getName(subject)+" to "+getName(self)+" is "+respectRadius);
|
|
}
|
|
|
|
void runMakeDecoy(obj_id self, string[] parse)
|
|
{
|
|
obj_id decoy = stealth.createDecoy(self);
|
|
|
|
if (!isIdValid(decoy))
|
|
return;
|
|
|
|
obj_id[] haters = getWhoIsTargetingMe(self);
|
|
|
|
if (haters == null || haters.length == 0)
|
|
{
|
|
int diversionLevel = getEnhancedSkillStatisticModifierUncapped(self, "expertise_improved_decoy");
|
|
|
|
if (diversionLevel < 2)
|
|
return;
|
|
|
|
buff.applyBuff(self, "invis_sp_diversion_stealth");
|
|
return;
|
|
}
|
|
|
|
for (int i=0;i<haters.length;i++)
|
|
{
|
|
obj_id[] hateList = getHateList(haters[i]);
|
|
|
|
if (hateList == null || hateList.length == 0)
|
|
continue;
|
|
|
|
for (int k=0;k<hateList.length;k++)
|
|
{
|
|
if (hateList[k] == self)
|
|
{
|
|
setHate(haters[i], decoy, getHate(haters[i], self) * 2);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
int diversionLevel = getEnhancedSkillStatisticModifierUncapped(self, "expertise_improved_decoy");
|
|
|
|
if (diversionLevel < 2)
|
|
return;
|
|
|
|
buff.applyBuff(self, "invis_sp_diversion_stealth");
|
|
|
|
//Profit
|
|
}
|
|
|
|
void runCommLink(obj_id self, string[] parse)
|
|
{
|
|
if (parse.length < 3)
|
|
return;
|
|
|
|
faction_perk.spawnTroopers(self, parse[1], utils.stringToInt(parse[2]));
|
|
}
|
|
void runPrepCave(obj_id self, string[] parse)
|
|
{
|
|
obj_id cave = trial.getTop(self);
|
|
|
|
if (!isIdValid(cave) || cave == self)
|
|
return;
|
|
|
|
detachAllScripts(cave);
|
|
removeAllObjVars(cave);
|
|
|
|
attachScript(cave, "theme_park.heroic.axkva_min.axkva_controller");
|
|
}
|
|
|
|
|
|
void runSwarmTarget(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = getIntendedTarget(self);
|
|
|
|
obj_id[] creatures = getCreaturesInRange(getLocation(self), 64.0f);
|
|
|
|
if (creatures == null || creatures.length == 0)
|
|
return;
|
|
|
|
for (int i=0;i<creatures.length;i++)
|
|
{
|
|
if (creatures[i] != target)
|
|
addHate(creatures[i], target, 1);
|
|
}
|
|
}
|
|
|
|
void runSetMaster(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = getIntendedTarget(self);
|
|
|
|
setMaster(self, null);
|
|
setMaster(target, self);
|
|
}
|
|
|
|
void runConvert(obj_id self, string[] parse)
|
|
{
|
|
int numRows = dataTableGetNumRows("datatables/spawning/heroic/heroic_axkva_min.iff");
|
|
|
|
for (int i=0;i<numRows;i++)
|
|
{
|
|
string triggerId = dataTableGetString("datatables/spawning/heroic/heroic_axkva_min.iff", i, "triggerId");
|
|
debugSpeakMsg(self, "Converted triggerId("+triggerId+") = "+utils.stringToInt(triggerId));
|
|
}
|
|
}
|
|
|
|
void dumpToTable(obj_id self, string[] parse)
|
|
{
|
|
if (!hasObjVar(self, "record_table"))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "You do not have the record_table objvar defined");
|
|
return;
|
|
}
|
|
if (!utils.hasScriptVar(self, "messageTo.recordObject"))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "You do not have a recordTo defined");
|
|
return;
|
|
}
|
|
|
|
string table = getStringObjVar(self, "record_table");
|
|
|
|
string[] strHeaderTypes = { "s","f","f","f","f"};
|
|
string[] strHeaders = {"object","x_offset","y_offset","z_offset","yaw"};
|
|
boolean boolTest = datatable.createDataTable(table, strHeaders,strHeaderTypes);
|
|
if(!boolTest)
|
|
{
|
|
sendSystemMessageTestingOnly(self, "No dataTable made");
|
|
return;
|
|
|
|
}
|
|
|
|
location recordLoc = getLocation(utils.getObjIdScriptVar(self, "messageTo.recordObject"));
|
|
|
|
obj_id[] objects = getObjectsInRange(recordLoc, 1000.0f);
|
|
|
|
if (objects == null || objects.length == 0)
|
|
return;
|
|
|
|
for (int i=0;i<objects.length;i++)
|
|
{
|
|
if (getTemplateName(objects[i]).indexOf("furniture") > -1)
|
|
{
|
|
obj_id top = trial.getTop(objects[i]);
|
|
|
|
if (top == objects[i])
|
|
{
|
|
location objLoc = getLocation(objects[i]);
|
|
float x = objLoc.x - recordLoc.x;
|
|
float y = objLoc.y - recordLoc.y;
|
|
float z = objLoc.z - recordLoc.z;
|
|
string name = getTemplateName(objects[i]);
|
|
float yaw = getYaw(objects[i]);
|
|
sendSystemMessageTestingOnly(self, "Object("+name+") Location("+x+", "+y+", "+z+") yaw("+yaw+")");
|
|
|
|
dictionary dctRow = new dictionary ();
|
|
dctRow.put ("object", name);
|
|
dctRow.put ("x_offset", x);
|
|
dctRow.put ("y_offset", y);
|
|
dctRow.put ("z_offset", z);
|
|
dctRow.put ("yaw", yaw);
|
|
datatable.serverDataTableAddRow(table, dctRow);
|
|
/**
|
|
obj_id[] cells = getCellIds(objects[i]);
|
|
if (cells != null && cells.length > 0)
|
|
{
|
|
obj_id[] contents = trial.getAllObjectsInDungeon(objects[i]);
|
|
if (contents != null && contents.length > 0)
|
|
{
|
|
for (int k=0;k<contents.length;k++)
|
|
{
|
|
location cLoc = getLocation(contents[k]);
|
|
yaw = getYaw(contents[k]);
|
|
name = getTemplateName(contents[k]);
|
|
dctRow.put("object", name);
|
|
dctRow.put("phase", "0");
|
|
dctRow.put("x_offset", cLoc.x);
|
|
dctRow.put("y_offset", cLoc.y);
|
|
dctRow.put("z_offset", cLoc.z);
|
|
dctRow.put("yaw", yaw);
|
|
dctRow.put("cell", getCellName(cLoc.cell));
|
|
sendSystemMessageTestingOnly(self, "Object("+name+") Location("+x+", "+y+", "+z+") yaw("+yaw+")");
|
|
datatable.serverDataTableAddRow(table, dctRow);
|
|
}
|
|
}
|
|
}
|
|
**/
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void recreateTable (obj_id self, string[] parse)
|
|
{
|
|
if (!hasObjVar(self, "record_table"))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "You do not have the record_table objvar defined");
|
|
return;
|
|
}
|
|
if (!utils.hasScriptVar(self, "messageTo.recordObject"))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "You do not have a recordTo defined");
|
|
return;
|
|
}
|
|
|
|
string table = getStringObjVar(self, "record_table");
|
|
obj_id recordObject = utils.getObjIdScriptVar(self, "messageTo.recordObject");
|
|
|
|
int rows = dataTableGetNumRows(table);
|
|
|
|
for (int i=0;i<rows;i++)
|
|
{
|
|
dictionary dict = dataTableGetRow(table, i);
|
|
|
|
string object = dict.getString("object");
|
|
float ox = dict.getFloat("x_offset");
|
|
float oy = dict.getFloat("y_offset");
|
|
float oz = dict.getFloat("z_offset");
|
|
float yaw = dict.getFloat("yaw");
|
|
|
|
location spawnLoc = getLocation(recordObject);
|
|
|
|
spawnLoc.x += ox;
|
|
spawnLoc.y += oy;
|
|
spawnLoc.z += oz;
|
|
|
|
obj_id newObject = createObject(object, spawnLoc);
|
|
|
|
if (isIdValid(newObject))
|
|
{
|
|
setYaw(newObject, yaw);
|
|
persistObject(newObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
void runGetCommmandList(obj_id self, string[] parse)
|
|
{
|
|
string[] commandList = getCommandListingForPlayer(self);
|
|
|
|
if (commandList == null || commandList.length == 0)
|
|
{
|
|
debugSpeakMsg(self, "Fail");
|
|
return;
|
|
}
|
|
|
|
for (int i=0;i<commandList.length;i++)
|
|
{
|
|
debugSpeakMsg(self, "Command: "+commandList[i]);
|
|
}
|
|
}
|
|
|
|
void runGetCellList(obj_id self, string[] parse)
|
|
{
|
|
obj_id pob = utils.stringToObjId(parse[1]);
|
|
|
|
string[] list = getCellNames(pob);
|
|
|
|
for (int i=0;i<list.length;i++)
|
|
debugSpeakMsg(self, ""+list[i]);
|
|
}
|
|
|
|
void runEnterCell(obj_id self, string[] parse)
|
|
{
|
|
obj_id pob = utils.stringToObjId(parse[1]);
|
|
|
|
location cellLoc = getGoodLocation(pob, parse[2]);
|
|
warpPlayer(self, cellLoc.area, cellLoc.x, cellLoc.y, cellLoc.z, pob, parse[2], cellLoc.x, cellLoc.y, cellLoc.z, "nullCallback", false);
|
|
|
|
}
|
|
|
|
void runIt(obj_id self, string[] parse)
|
|
{
|
|
|
|
attacker_results atkRslt = new attacker_results();
|
|
defender_results[] dfndRslt = new defender_results[0];
|
|
atkRslt.id = self;
|
|
atkRslt.endPosture = POSTURE_UPRIGHT;
|
|
string anim = parse[1];
|
|
dfndRslt[0].id = self;
|
|
|
|
doCombatResults(anim, atkRslt, dfndRslt);
|
|
}
|
|
|
|
void runGetBell(obj_id self, string[] parse)
|
|
{
|
|
if(utils.hasScriptVar(self, "bellpid"))
|
|
{
|
|
int bellpid = utils.getIntScriptVar(self, "bellpid");
|
|
sui.forceCloseSUIPage(bellpid);
|
|
}
|
|
float min = utils.stringToFloat(parse[1]);
|
|
float max = utils.stringToFloat(parse[2]);
|
|
int level = utils.stringToInt(parse[3]);
|
|
|
|
//debugSpeakMsg(self, "Value("+value+")/Avg("+avg+") returns = "+space_crafting.getBellValue(value, avg));
|
|
|
|
int pid = createSUIPage(sui.SUI_LISTBOX, self, self, "noHandler");
|
|
|
|
setSUIProperty(pid, "", "Size", "650,375");
|
|
setSUIProperty(pid, sui.LISTBOX_TITLE, sui.PROP_TEXT, "Distributed Random");
|
|
|
|
// Add buttons.
|
|
sui.listboxButtonSetup(pid, sui.OK_ONLY);
|
|
setSUIProperty(pid, sui.LISTBOX_BTN_OK, sui.PROP_TEXT, "@cancel");
|
|
int listSize = 1000;
|
|
float[] bigList = new float[listSize];
|
|
float average = 0.0f;
|
|
float high = 0.0f;
|
|
float low = 10.0f;
|
|
int in4 = 0;
|
|
int in5 = 0;
|
|
int in6 = 0;
|
|
int in7 = 0;
|
|
int in8 = 0;
|
|
int in9 = 0;
|
|
int in10 = 0;
|
|
|
|
for (int i=0;i<listSize;i++)
|
|
{
|
|
bigList[i] = distributedRand(min, max, level);
|
|
addSUIDataItem(pid, sui.LISTBOX_DATASOURCE, "" + i);
|
|
setSUIProperty(pid, sui.LISTBOX_DATASOURCE + "." + i, sui.PROP_TEXT, ""+bigList[i]);
|
|
average += bigList[i];
|
|
if (bigList[i] < low)
|
|
low = bigList[i];
|
|
|
|
if (bigList[i] > high)
|
|
high = bigList[i];
|
|
|
|
float num = bigList[i];
|
|
|
|
if (num >= 4.0f && num < 5.0f)
|
|
in4++;
|
|
if (num >= 5.0f && num < 6.0f)
|
|
in5++;
|
|
if (num >= 6.0f && num < 7.0f)
|
|
in6++;
|
|
if (num >= 7.0f && num < 8.0f)
|
|
in7++;
|
|
if (num >= 8.0f && num < 9.0f)
|
|
in8++;
|
|
if (num >= 9.0f && num < 10.0f)
|
|
in9++;
|
|
if (num >= 10.0f)
|
|
in10++;
|
|
|
|
}
|
|
|
|
average = average / listSize;
|
|
setSUIProperty(pid, sui.LISTBOX_PROMPT, sui.PROP_TEXT, "Average = "+average+", High = "+high+", Low = "+low+" \n 4 = "+in4+" \n 5 = "+in5+" \n 6 = "+in6+" \n 7 = "+in7+" \n 8 = "+in8+" \n 9 = "+in9+" \n 10 = "+in10);
|
|
|
|
subscribeToSUIEvent(pid, sui_event_type.SET_onGenericSelection, sui.LISTBOX_LIST, "noHandler");
|
|
subscribeToSUIPropertyForEvent(pid, sui_event_type.SET_onGenericSelection, sui.LISTBOX_LIST, sui.LISTBOX_LIST, sui.PROP_SELECTEDROW);
|
|
|
|
subscribeToSUIProperty(pid, sui.LISTBOX_LIST, sui.PROP_SELECTEDROW);
|
|
subscribeToSUIProperty(pid, sui.LISTBOX_TITLE, sui.PROP_TEXT);
|
|
|
|
showSUIPage(pid);
|
|
flushSUIPage(pid);
|
|
|
|
utils.setScriptVar(self, "bellpid", pid);
|
|
|
|
}
|
|
|
|
float distributedRand(float min, float max, int level)
|
|
{
|
|
const int levelMin = 0;
|
|
const int levelMax = 10;
|
|
|
|
boolean inverted = false;
|
|
float _min = min;
|
|
float _max = max;
|
|
|
|
if (min > max)
|
|
{
|
|
inverted = true;
|
|
min = _max;
|
|
max = _min;
|
|
}
|
|
|
|
//if (level < levelMin) level = levelMin;
|
|
//if (level > levelMax) level = levelMax;
|
|
|
|
float rank = (float)(level - levelMin) / (float)(levelMax - levelMin);
|
|
|
|
float mid = min + ((max - min) * rank);
|
|
|
|
if (mid < min) { max += (mid-min); mid = min; }
|
|
if (mid > max) { min += (mid-max); mid = max; }
|
|
|
|
float minRand = rand(min, mid);
|
|
float maxRand = rand(mid, max);
|
|
|
|
float randNum = rand(minRand, maxRand);
|
|
|
|
if (inverted)
|
|
randNum = _min + (_max - randNum);
|
|
|
|
return randNum;
|
|
}
|
|
|
|
|
|
void runSetHover(obj_id self, string[] parse)
|
|
{
|
|
float height = utils.stringToFloat(parse[1]);
|
|
|
|
vehicle.setHoverHeight(getIntendedTarget(self), height);
|
|
}
|
|
|
|
void runTestSlope(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = getIntendedTarget(self);
|
|
|
|
addSlowDownEffect(self, target, 10.0f, 180.0f, 85.0f, 10.0f);
|
|
}
|
|
|
|
void runAlterHeight(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = getIntendedTarget(self);
|
|
|
|
float change = utils.stringToFloat(parse[1]);
|
|
|
|
location loc = getLocation(target);
|
|
loc.y += change;
|
|
setLocation(target, loc);
|
|
}
|
|
|
|
void runTestBool(obj_id self, string[] parse)
|
|
{
|
|
boolean overall = false;
|
|
|
|
for (int i=0;i<6;i++)
|
|
{
|
|
boolean current = false;
|
|
|
|
if (i == 4)
|
|
{
|
|
current = true;
|
|
}
|
|
|
|
overall |= current;
|
|
|
|
debugSpeakMsg(self, "overall = "+overall+", current = "+current);
|
|
}
|
|
|
|
debugSpeakMsg(self, "overall = "+overall);
|
|
}
|
|
|
|
void runAddAttrib(obj_id self, string[] parse)
|
|
{
|
|
string attrib = parse[1];
|
|
int value = utils.stringToInt(parse[2]);
|
|
int time = utils.stringToInt(parse[3]);
|
|
|
|
addSkillModModifier(self, attrib+"_0", attrib, value, time, false, false);
|
|
|
|
}
|
|
void runLit3(obj_id self, string[] parse)
|
|
{
|
|
obj_id recordObject = utils.getObjIdScriptVar(self, "messageTo.recordObject");
|
|
obj_id target = getIntendedTarget(self);
|
|
chat.chat(self, "Can See: "+canSee(recordObject, target));
|
|
}
|
|
|
|
void runShieldMe(obj_id self, string[] parse)
|
|
{
|
|
for (int i=0;i<9;i++)
|
|
{
|
|
debugSpeakMsg(self, "attrib"+i+" = "+getAttrib(self, i));
|
|
}
|
|
}
|
|
|
|
void clearStunEffects(obj_id self, string[] parse)
|
|
{
|
|
setState(self, STATE_STUNNED, false);
|
|
setState(self, STATE_FROZEN, false);
|
|
}
|
|
|
|
void makeMeAGod(obj_id self, string[] parse)
|
|
{
|
|
buff.applyBuff(self, "kun_eight_sacrifice", 2400);
|
|
buff.applyBuff(self, "crystal_buff", 2400);
|
|
buff.applyBuff(self, "kun_minder_heal_buff", 2400);
|
|
}
|
|
|
|
void runSetSlope(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = getIntendedTarget(self);
|
|
addSlowDownEffect(self, target, 50.0f, 0.01f, 75.0f, 10.0f);
|
|
}
|
|
|
|
|
|
void runSetKillMeter(obj_id self, string[] parse)
|
|
{
|
|
int value = utils.stringToInt(parse[1]);
|
|
|
|
combat.setKillMeter(self, value);
|
|
}
|
|
|
|
void runSetMind(obj_id self, string[] parse)
|
|
{
|
|
setMind(self, utils.stringToInt(parse[1]));
|
|
}
|
|
|
|
void runGetMind(obj_id self, string[] parse)
|
|
{
|
|
int current = getMind(self);
|
|
int max = getMaxMind(self);
|
|
|
|
debugSpeakMsg(self, "Mind = "+current+" of "+max);
|
|
}
|
|
|
|
void runSetupSnowspeeder(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = getMountId(self);
|
|
setBeastmasterPet(self, target);
|
|
string[] abilities =
|
|
{
|
|
"hoth_speeder_shoot",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
""
|
|
};
|
|
|
|
setBeastmasterPetCommands(self, abilities);
|
|
}
|
|
|
|
void runTestShoot(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = getIntendedTarget(self);
|
|
float travelDistance = getDistance(target, self);
|
|
|
|
float speed = travelDistance / 2.0f;
|
|
location selfLoc = getLocation(self);
|
|
selfLoc.y += 10.0f;//vehicle.getHoverHeight(getMountId(self));
|
|
location tarLoc = getLocation(target);
|
|
|
|
createClientProjectile(self, "object/weapon/ranged/pistol/shared_pistol_green_bolt.iff", selfLoc, getLocation(target), speed, 2.0f, false, 32, 178, 170, 255);
|
|
|
|
}
|
|
|
|
void runSetLoc(obj_id self, string[] parse)
|
|
{
|
|
float locx = utils.stringToFloat(parse[1]);
|
|
float locy = utils.stringToFloat(parse[2]);
|
|
float locz = utils.stringToFloat(parse[3]);
|
|
|
|
location tarLoc = getLocation(getIntendedTarget(self));
|
|
|
|
location newLoc = new location(locx, locy, locz, tarLoc.area, tarLoc.cell);
|
|
|
|
setLocation(getIntendedTarget(self), newLoc);
|
|
}
|
|
|
|
const dictionary dict = new dictionary();
|
|
|
|
void runSetDda(obj_id self, string[] parse)
|
|
{
|
|
int fromRow = utils.stringToInt(parse[1]);
|
|
|
|
string[] testString = {"one", "two", "three", "four", "five", "six", "seven", "eight"};//, "nine", "ten"};
|
|
int[] testInt = {1,2,3,4,5,6,7,8};//,9,10};
|
|
string[] passString = new string[3];
|
|
int[] passInt = new int[3];
|
|
|
|
int q = 0;
|
|
for (int i = fromRow;i<fromRow+3;i++)
|
|
{
|
|
passString[q] = testString[i];
|
|
passInt[q] = testInt[i];
|
|
q++;
|
|
}
|
|
|
|
dict.put("testString", passString);
|
|
dict.put("testInt", passInt);
|
|
}
|
|
|
|
void runGetDda(obj_id self, string[] parse)
|
|
{
|
|
string[] testString = dict.getStringArray("testString");
|
|
int[] testInt = dict.getIntArray("testInt");
|
|
|
|
for (int i=0;i<testString.length;i++)
|
|
{
|
|
debugSpeakMsg(self, ""+testString[i]);
|
|
debugSpeakMsg(self, ""+testInt[i]);
|
|
}
|
|
}
|
|
|
|
void runStaticItemParse(obj_id self, string[] parse)
|
|
{
|
|
int parseLength = parse.length;
|
|
if ( parseLength >= 2 )
|
|
{
|
|
if ( toLower(parse[1]).equals("find") )
|
|
{
|
|
if ( parseLength < 3 )
|
|
{
|
|
sendSystemMessage(self, "Syntax: staticItem find [keyword] [optional sub-keyword]", "");
|
|
return;
|
|
}
|
|
string[] data = new string[parse.length-1];
|
|
int dataIndex = 0;
|
|
for ( int i = 0; i < parse.length; i++ )
|
|
{
|
|
if ( i != 1 )
|
|
{
|
|
data[dataIndex] = parse[i];
|
|
++dataIndex;
|
|
}
|
|
}
|
|
|
|
runStaticItemFind(self, data);
|
|
}
|
|
else if ( toLower(parse[1]).equals("create") )
|
|
{
|
|
if ( parseLength < 3 )
|
|
{
|
|
sendSystemMessage(self, "Syntax: staticItem create [list index or static item name]", "");
|
|
return;
|
|
}
|
|
string[] data = new string[parse.length-1];
|
|
int dataIndex = 0;
|
|
for ( int i = 0; i < parse.length; i++ )
|
|
{
|
|
if ( i != 1 )
|
|
{
|
|
data[dataIndex] = parse[i];
|
|
++dataIndex;
|
|
}
|
|
}
|
|
|
|
runStaticItemCreate(self, data);
|
|
}
|
|
else if ( toLower(parse[1]).equals("list") )
|
|
{
|
|
runStaticItemShowList(self);
|
|
}
|
|
else if ( toLower(parse[1]).equals("clear") )
|
|
{
|
|
runStaticItemClearList(self);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string helpMessage =
|
|
"staticItem Help: \n"+
|
|
"--------------- \n"+
|
|
"staticItem find [keyword] [optional sub-keyword] \n"+
|
|
"staticItem create [list index or static item name] \n"+
|
|
"staticItem list \n"+
|
|
"staticItem clear";
|
|
|
|
sendSystemMessage(self, helpMessage, "");
|
|
}
|
|
return;
|
|
}
|
|
|
|
void runStaticItemFind(obj_id self, string[] parse)
|
|
{
|
|
string staticItemWanted = "";
|
|
string subString = "";
|
|
|
|
int parseLength = parse.length;
|
|
if ( parseLength < 2 )
|
|
{
|
|
sendSystemMessage(self, "Syntax: staticItem find [keyword] [optional sub-keyword]", "");
|
|
return;
|
|
}
|
|
|
|
staticItemWanted = parse[1];
|
|
|
|
if ( parseLength >= 3 )
|
|
{
|
|
subString = parse[2];
|
|
}
|
|
|
|
resizeable string[] matchingStaticItems = new string[0];
|
|
string output = "";
|
|
int index = 0;
|
|
|
|
string[] allStaticItems = dataTableGetStringColumn(static_item.MASTER_ITEM_TABLE, "name");
|
|
for ( int i = 0; i < allStaticItems.length; i++ )
|
|
{
|
|
boolean matchFound = false;
|
|
|
|
string staticItemName = allStaticItems[i];
|
|
int stringCheck = staticItemName.indexOf(staticItemWanted);
|
|
if ( stringCheck > -1 )
|
|
{
|
|
if ( subString != null && subString.length() > 0 )
|
|
{
|
|
int subStringCheck = staticItemName.indexOf(subString);
|
|
if ( subStringCheck > -1 )
|
|
{
|
|
matchFound = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
matchFound = true;
|
|
}
|
|
|
|
if ( matchFound )
|
|
{
|
|
utils.addElement(matchingStaticItems, staticItemName);
|
|
output += index +" - "+staticItemName+" \n";
|
|
|
|
++index;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( matchingStaticItems.length < 1 )
|
|
{
|
|
output = "No matching static items found.";
|
|
}
|
|
else
|
|
{
|
|
utils.setScriptVar(self, "idiot_matchingStaticItems", matchingStaticItems);
|
|
}
|
|
|
|
sendSystemMessage(self, output, "\n");
|
|
return;
|
|
}
|
|
|
|
void runStaticItemCreate(obj_id self, string[] parse)
|
|
{
|
|
if ( parse.length < 2 )
|
|
{
|
|
sendSystemMessage(self, "Syntax: staticItem create [list index or static item name]", "");
|
|
return;
|
|
}
|
|
|
|
string staticItemString = parse[1];
|
|
int staticItemIndex = utils.stringToInt(staticItemString);
|
|
if (staticItemIndex > -1 && utils.hasScriptVar(self, "idiot_matchingStaticItems") )
|
|
{
|
|
resizeable string[] matchingStaticItems = utils.getResizeableStringArrayScriptVar(self, "idiot_matchingStaticItems");
|
|
if ( matchingStaticItems != null && matchingStaticItems.length > 0 )
|
|
{
|
|
if( staticItemIndex >= 0 && staticItemIndex < matchingStaticItems.length )
|
|
{
|
|
string staticItem = matchingStaticItems[staticItemIndex];
|
|
obj_id inv = getObjectInSlot(self, "inventory");
|
|
obj_id item = static_item.createNewItemFunction(staticItem, inv);
|
|
if ( isIdValid(item) )
|
|
{
|
|
sendSystemMessage(self, "Static Item " + staticItem + " created in your inventory.", "");
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessage(self, "Error creating static item with supplied NAME (" + staticItem + ").", "");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessage(self, "Invalid static item index.", "");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessage(self, "Empty or Null array returned from Scriptvar.", "");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// if the input data was -1 or if there is no static items list,
|
|
// then the string wasn't an index number and should be the name of a static item. Try creating it.
|
|
if ( static_item.createNewItemFunction(staticItemString, self) == null )
|
|
{
|
|
sendSystemMessage(self, "Error creating static item with supplied NAME (" + staticItemString + ").", "");
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessage(self, "Static Item " + staticItemString + " created in your inventory.", "");
|
|
return;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void runStaticItemShowList(obj_id self)
|
|
{
|
|
if ( utils.hasScriptVar(self, "idiot_matchingStaticItems") )
|
|
{
|
|
resizeable string[] matchingStaticItems = utils.getResizeableStringArrayScriptVar(self, "idiot_matchingStaticItems");
|
|
string output = "\n";
|
|
if ( matchingStaticItems != null && matchingStaticItems.length > 0 )
|
|
{
|
|
for ( int i = 0; i < matchingStaticItems.length; i++ )
|
|
{
|
|
output = output + i +" - "+matchingStaticItems[i]+" \n";
|
|
}
|
|
|
|
sendSystemMessage(self, output, "");
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessage(self, "Empty or Null array returned from Static Items List Scriptvar.", "");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessage(self, "Static Items List not found.", "");
|
|
}
|
|
return;
|
|
}
|
|
|
|
void runStaticItemClearList(obj_id self)
|
|
{
|
|
if ( utils.hasScriptVar(self, "idiot_matchingStaticItems") )
|
|
{
|
|
utils.removeScriptVar(self, "idiot_matchingStaticItems");
|
|
sendSystemMessage(self, "Static Items List removed.", "");
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessage(self, "Static Items List not found.", "");
|
|
}
|
|
return;
|
|
}
|
|
|
|
void runPlaySound(obj_id self, string[] parse)
|
|
{
|
|
debugSpeakMsg(self, "attempting to play: "+parse[1]);
|
|
play2dNonLoopingSound(self, "sound/"+parse[1]+".snd");
|
|
}
|
|
|
|
messageHandler instance_ping_response()
|
|
{
|
|
string message = params.getString("message");
|
|
sendConsoleMessage(self, message);
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
void runFireTrigger(obj_id self, string[] parse)
|
|
{
|
|
trial.sendSequenceTrigger(parse[1]);
|
|
}
|
|
|
|
void runSetCellLabel(obj_id self, string[] parse)
|
|
{
|
|
obj_id top = trial.getTop(self);
|
|
obj_id cellId = getCellId(top, parse[1]);
|
|
|
|
setCellLabel(cellId, parse[2]);
|
|
}
|
|
|
|
void runClearWaypoints(obj_id self, string[] parse)
|
|
{
|
|
obj_id[] waypoints = getWaypointsInDatapad(self);
|
|
if (waypoints != null && waypoints.length > 0)
|
|
{
|
|
for (int i=0;i<waypoints.length;i++)
|
|
{
|
|
destroyWaypointInDatapad(waypoints[i], self);
|
|
}
|
|
}
|
|
}
|
|
|
|
void runSetIdOnInstance(obj_id self, string[] parse)
|
|
{
|
|
obj_id instance_id = instance.getAreaInstanceController(self);
|
|
instance.addToPlayerIdList(instance_id, self);
|
|
}
|
|
|
|
void runHideFromClient(obj_id self, string[] parse)
|
|
{
|
|
obj_id target = getIntendedTarget(self);
|
|
if (parse[1] == "true")
|
|
hideFromClient(self, true);
|
|
|
|
if (parse[1] == "false")
|
|
hideFromClient(self, false);
|
|
} |