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
master
dsrc/sku.0/sys.server/compiled/game/script/systems/spawning/spawn_player.java
T
TekaohandGitHub 5c2e112349 Java 11.0.2 migration (#32) 
* Code compiles - execution NOT tested

* updating gitignore

* Removed intellij settings files

* Removed more intellij files

* Added exclusion for JDK classes.

* Fixed purchasing script for vendors that have listed coin types.

* Updated script to not kick off until the entire preload is complete.

* adds static name entry for Solo movie poster and tcg9 vendor entry

* clean up empty and orphaned object templates

* adds placeholder black market (static) spawns

* corrects entries for the video game table to correctly set it in tcg series 2 and remove series 1 console errors

* Updated gitignore and removed intellij project files

* Fixed appearance reference for thranta payroll and kashyyyk door, added skipLosCheck objvar due to cannit see issue. Requires updated src

* Fixed appearance and template for terminal (#2)

* Fixed appearance and template for terminal (#3)

* Fixed appearance and template for terminal (#4)

* Deleted another faulty/orphaned object template

* Fixed gcw ranks option on frog. Only issue is that it doesn't award the officer commands or badges.

* Fixed some unneeded java 11 changes
2019-04-18 18:31:52 -05:00

1165 lines
54 KiB
Java
Executable File
Raw Permalink Blame History

package script.systems.spawning;
import script.*;
import script.library.*;
import java.util.Vector;
public class spawn_player extends script.systems.spawning.spawn_base
{
public spawn_player()
{
}
public int OnInitialize(obj_id self) throws InterruptedException
{
removeObjVar(self, "spawning.verboseMode");
return SCRIPT_CONTINUE;
}
public int showSpawnRegion(obj_id self, obj_id target, String params, float defaultTime) throws InterruptedException
{
region[] rgnRegionList = getRegionsWithSpawnableAtPoint(getLocation(self), regions.SPAWN_TRUE);
if (rgnRegionList == null)
{
rgnRegionList = getRegionsWithSpawnableAtPoint(getLocation(self), regions.SPAWN_DEFAULT);
}
if (rgnRegionList == null)
{
sendSystemMessageTestingOnly(self, "Catastrophic failure, no spawn region at this point");
return SCRIPT_CONTINUE;
}
region rgnOverloadRegion = null;
region[] rgnOverloadRegions = getRegionsWithGeographicalAtPoint(getLocation(self), regions.GEO_OVERLOAD);
if ((rgnOverloadRegions != null) && (rgnOverloadRegions.length > 0))
{
rgnOverloadRegion = rgnOverloadRegions[rand(0, rgnOverloadRegions.length - 1)];
}
region rgnSpawnRegion = locations.getSmallestRegion(rgnRegionList);
if (rgnOverloadRegion != null)
{
sendSystemMessageTestingOnly(self, "Multiple Spawn Regions found : ");
sendSystemMessageTestingOnly(self, "Overload region is " + rgnOverloadRegion.getName());
}
else
{
sendSystemMessageTestingOnly(self, "Spawn Region:");
}
sendSystemMessageTestingOnly(self, "Region: " + rgnSpawnRegion.getName());
return SCRIPT_CONTINUE;
}
public int secretSpawnSpam(obj_id self, obj_id target, String params, float defaultTime) throws InterruptedException
{
if (hasObjVar(self, "spawning.verboseMode"))
{
removeObjVar(self, "spawning.verboseMode");
sendSystemMessageTestingOnly(self, "Verbose spawn checks disabled");
}
else
{
setObjVar(self, "spawning.verboseMode", 1);
sendSystemMessageTestingOnly(self, "Verbose spawning checks enabled");
}
return SCRIPT_CONTINUE;
}
public int OnAddedToWorld(obj_id self) throws InterruptedException
{
messageTo(self, "checkStationCells", null, 2, false);
return SCRIPT_CONTINUE;
}
public int OnAttach(obj_id self) throws InterruptedException
{
return SCRIPT_CONTINUE;
}
public int createSpawningElement(obj_id self, obj_id target, String params, float defaultTime) throws InterruptedException
{
if (params.equals(""))
{
sendSystemMessageTestingOnly(self, "You must provide a datatable and an index for this to work properly");
return SCRIPT_CONTINUE;
}
int intIndex = params.indexOf(" ");
String strTable = params.substring(0, intIndex);
strTable = "datatables/spawning/spawn_lists/" + strTable + ".iff";
debugSpeakMsg(self, "strTable is " + strTable);
String strNumber = params.substring(intIndex + 1, params.length());
debugSpeakMsg(self, "strNumber is " + strNumber);
if (!dataTableOpen(strTable))
{
sendSystemMessageTestingOnly(self, strTable + " is not a valid dataTable");
return SCRIPT_CONTINUE;
}
Integer intTestIndex;
try
{
intTestIndex = Integer.valueOf(strNumber);
}
catch(NumberFormatException err)
{
sendSystemMessageTestingOnly(self, strNumber + " is not a valid index");
return SCRIPT_CONTINUE;
}
intIndex = intTestIndex;
dictionary dctRow = dataTableGetRow(strTable, intIndex);
if (dctRow == null)
{
sendSystemMessageTestingOnly(self, "Not a valid combination of data");
return SCRIPT_CONTINUE;
}
int intMinDifficulty = dctRow.getInt("intMinDifficulty");
int intMaxDifficulty = dctRow.getInt("intMaxDifficulty");
int intPlayerDifficulty = rand(intMinDifficulty, intMaxDifficulty);
String strTemplate = dctRow.getString("strTemplate");
String strLairType = dctRow.getString("strLairType");
String strBuildingType = dctRow.getString("strBuildingType");
obj_id objCreatedTemplate = createObject(strTemplate, getLocation(self));
if (!(objCreatedTemplate == null))
{
if (group.isGrouped(self))
{
obj_id objGroup = getGroupObject(self);
if (objGroup != null)
{
int intGroupSize = getGroupSize(objGroup);
setObjVar(objCreatedTemplate, "spawning.intGroupSize", intGroupSize);
}
}
setObjVar(objCreatedTemplate, "spawning.intDifficultyLevel", intPlayerDifficulty);
String strDifficulty = create.getLairDifficulty(intMinDifficulty, intMaxDifficulty, intPlayerDifficulty);
setObjVar(objCreatedTemplate, "spawning.lairDifficulty", strDifficulty);
setObjVar(objCreatedTemplate, "spawning.lairType", strLairType);
setObjVar(objCreatedTemplate, "spawning.buildingTrackingType", strBuildingType);
if (!strBuildingType.equals(""))
{
setObjVar(objCreatedTemplate, "spawning.buildingType", strBuildingType);
}
}
else
{
debugSpeakMsg(self, "I made a null object");
debugSpeakMsg(self, "row was " + dctRow.toString());
}
return SCRIPT_CONTINUE;
}
public int createSpawningElementWithDifficulty(obj_id self, obj_id target, String params, float defaultTime) throws InterruptedException
{
if (params.equals(""))
{
sendSystemMessageTestingOnly(self, "You must provide a datatable, difficulty and an index for this to work properly");
return SCRIPT_CONTINUE;
}
int intIndex = params.indexOf(" ");
String strTable = params.substring(0, intIndex);
strTable = "datatables/spawning/spawn_lists/" + strTable + ".iff";
String strRemainingString = params.substring(intIndex + 1, params.length());
int intNextIndex = strRemainingString.indexOf(" ");
String strNumber = strRemainingString.substring(0, intNextIndex);
String strDifficultyInt = strRemainingString.substring(intNextIndex + 1, strRemainingString.length());
if (!dataTableOpen(strTable))
{
sendSystemMessageTestingOnly(self, strTable + " is not a valid dataTable");
return SCRIPT_CONTINUE;
}
Integer intTestIndex;
try
{
intTestIndex = Integer.valueOf(strNumber);
}
catch(NumberFormatException err)
{
sendSystemMessageTestingOnly(self, strNumber + " is not a valid index");
return SCRIPT_CONTINUE;
}
intIndex = intTestIndex;
try
{
intTestIndex = Integer.valueOf(strDifficultyInt);
}
catch(NumberFormatException err)
{
sendSystemMessageTestingOnly(self, strDifficultyInt + " is not a valid index");
return SCRIPT_CONTINUE;
}
int intLevel = intTestIndex;
dictionary dctRow = dataTableGetRow(strTable, intIndex);
if (dctRow == null)
{
sendSystemMessageTestingOnly(self, "Not a valid combination of data");
return SCRIPT_CONTINUE;
}
int intMinDifficulty = dctRow.getInt("intMinDifficulty");
int intMaxDifficulty = dctRow.getInt("intMaxDifficulty");
String strTemplate = dctRow.getString("strTemplate");
String strLairType = dctRow.getString("strLairType");
String strBuildingType = dctRow.getString("strBuildingType");
obj_id objCreatedTemplate = createObject(strTemplate, getLocation(self));
if (!(objCreatedTemplate == null))
{
if (group.isGrouped(self))
{
obj_id objGroup = getGroupObject(self);
if (objGroup != null)
{
int intGroupSize = getGroupSize(objGroup);
setObjVar(objCreatedTemplate, "spawning.intGroupSize", intGroupSize);
}
}
setObjVar(objCreatedTemplate, "spawning.intDifficultyLevel", intLevel);
String strDifficulty = create.getLairDifficulty(intMinDifficulty, intMaxDifficulty, intLevel);
setObjVar(objCreatedTemplate, "spawning.lairDifficulty", strDifficulty);
setObjVar(objCreatedTemplate, "spawning.lairType", strLairType);
setObjVar(objCreatedTemplate, "spawning.buildingTrackingType", strBuildingType);
if (!strBuildingType.equals(""))
{
setObjVar(objCreatedTemplate, "spawning.buildingType", strBuildingType);
}
}
else
{
debugSpeakMsg(self, "I made a null object");
debugSpeakMsg(self, "row was " + dctRow.toString());
}
return SCRIPT_CONTINUE;
}
public int startSpawner(obj_id self, obj_id target, String params, float defaultTime) throws InterruptedException
{
obj_id objMasterSpawner = getPlanetByName(getLocation(self).area);
if (objMasterSpawner == null)
{
return SCRIPT_CONTINUE;
}
if (!hasScript(objMasterSpawner, "systems.spawning.spawn_master"))
{
attachScript(objMasterSpawner, "systems.spawning.spawn_master");
}
if (!hasObjVar(objMasterSpawner, "boolSpawnerIsOn"))
{
sendSystemMessageTestingOnly(self, "The masterspawner is not setup correctly. Resetting it to off.");
setObjVar(objMasterSpawner, "boolSpawnerIsOn", false);
return SCRIPT_OVERRIDE;
}
else
{
if (!getBooleanObjVar(objMasterSpawner, "boolSpawnerIsOn"))
{
setObjVar(objMasterSpawner, "boolSpawnerIsOn", true);
sendSystemMessageTestingOnly(self, "The master spawner is now on!");
return SCRIPT_OVERRIDE;
}
else
{
sendSystemMessageTestingOnly(self, "The master spawner is already on!");
return SCRIPT_OVERRIDE;
}
}
}
public int OnLogin(obj_id self) throws InterruptedException
{
messageTo(self, "checkStationCells", null, 2, false);
removeObjVar(self, "spawning.locSpawnLocation");
return SCRIPT_CONTINUE;
}
public int spawn_Trigger(obj_id self, dictionary params) throws InterruptedException
{
if (!isIdValid(self))
{
return SCRIPT_CONTINUE;
}
location locTest = getLocation(self);
if (utils.checkConfigFlag("ScriptFlags", "newSpawnSystem_" + locTest.area))
{
spawning.activateSpawnerHack(self);
return SCRIPT_CONTINUE;
}
location locCurrentLocation = getLocation(self);
if (locCurrentLocation == null)
{
return SCRIPT_CONTINUE;
}
if (canSpawn(self, locCurrentLocation, false, null))
{
region rgnSpawnRegion = getSpawnRegion(self);
if (rgnSpawnRegion == null)
{
return SCRIPT_CONTINUE;
}
String strRegionName = rgnSpawnRegion.getName();
String strPlanet = rgnSpawnRegion.getPlanetName();
String strTestPlanet = locCurrentLocation.area;
if (!strPlanet.equals(strTestPlanet))
{
LOG("DESIGNER_FATAL", "For region " + strRegionName + " planet is " + strPlanet);
LOG("DESIGNER_FATAL", "But planet name for player is " + strTestPlanet);
}
int intLevel = locations.normalizeDifficultyForRegion(skill.getGroupLevel(self), locCurrentLocation);
dictionary dctSpawnParams = new dictionary();
dctSpawnParams.put("intDifficulty", intLevel);
dctSpawnParams.put("objPlayer", self);
if (strRegionName != null)
{
dctSpawnParams.put("strRegionName", strRegionName);
}
dctSpawnParams.put("strPlanet", strPlanet);
boolean boolTheatersAllowed = false;
int intNumRules = getNumRunTimeRules();
if (intNumRules > 0)
{
if (intNumRules < MAXIMUM_SPAWNING_RUN_TIME_RULES)
{
boolTheatersAllowed = true;
}
}
dctSpawnParams.put("boolTheatersAllowed", boolTheatersAllowed);
doSpawnEvent(dctSpawnParams);
}
return SCRIPT_CONTINUE;
}
public int OnSpeaking(obj_id self, String strText) throws InterruptedException
{
if (!isGod(self))
{
return SCRIPT_CONTINUE;
}
String[] strCommands = split(strText, ' ');
if (strCommands[0].equals("makeGroundSpawner"))
{
int pid = sui.inputbox(self, self, "Should this spawner be named?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerName", null);
if (utils.hasScriptVar(self, "previousName"))
{
String defaultText = utils.getStringScriptVar(self, "previousName");
if (defaultText != null && defaultText.length() > 0)
{
setSUIProperty(pid, sui.INPUTBOX_INPUT, sui.PROP_TEXT, defaultText);
}
}
sui.showSUIPage(pid);
return SCRIPT_CONTINUE;
}
if (strCommands[0].equals("dumpBuildout"))
{
String strDataTable;
if (strCommands.length > 1)
{
strDataTable = "datatables/spawning/ground_spawning/buildouts/" + strCommands[1] + ".tab";
}
else
{
sendSystemMessageTestingOnly(self, "You must provide a filename. Syntax: dumpBuildout <fileName>");
return SCRIPT_CONTINUE;
}
location locTest = getLocation(self);
obj_id objCell = locTest.cell;
boolean boolInBuilding = isIdValid(objCell);
obj_id objBuilding = null;
if (boolInBuilding)
{
objBuilding = getContainedBy(objCell);
}
String[] strHeaderTypes =
{
"s",
"f",
"f",
"f",
"f",
"f",
"f",
"f",
"f",
"f",
"p",
"s",
"s"
};
String[] strHeaders =
{
"strTemplate",
"fltJX",
"fltJY",
"fltJZ",
"fltKX",
"fltKY",
"fltKZ",
"fltPX",
"fltPY",
"fltPZ",
"strObjVars",
"strScripts",
"strCellName"
};
if (!datatable.createDataTable(strDataTable, strHeaders, strHeaderTypes))
{
sendSystemMessageTestingOnly(self, "No datatable made");
return SCRIPT_CONTINUE;
}
obj_id[] objObjects;
if (boolInBuilding)
{
objObjects = spawning.getAllContents(objBuilding);
}
else
{
objObjects = getAllObjectsWithObjVar(getLocation(self), 15000, "intSpawnLocation");
}
sendSystemMessageTestingOnly(self, "dumping contents of " + objBuilding);
dictionary dctRow;
for (obj_id objObject : objObjects) {
if (hasObjVar(objObject, "intSpawnLocation")) {
dctRow = new dictionary();
locTest = getLocation(objObject);
dctRow.put("strCellName",(boolInBuilding ? space_utils.getCellName(objBuilding, locTest.cell) : ""));
transform vctTest = getTransform_o2p(objObject);
vector vctJ = vctTest.getLocalFrameJ_p();
vector vctK = vctTest.getLocalFrameK_p();
vector vctP = vctTest.getPosition_p();
dctRow.put("fltJX", vctJ.x);
dctRow.put("fltJY", vctJ.y);
dctRow.put("fltJZ", vctJ.z);
dctRow.put("fltKX", vctK.x);
dctRow.put("fltKY", vctK.y);
dctRow.put("fltKZ", vctK.z);
dctRow.put("fltPX", vctP.x);
dctRow.put("fltPY", vctP.y);
dctRow.put("fltPZ", vctP.z);
dctRow.put("strTemplate", getTemplateName(objObject));
String strObjVars = getPackedObjvars(objObject);
dctRow.put("strObjVars", strObjVars);
String strScripts = utils.getPackedScripts(objObject);
dctRow.put("strScripts", strScripts);
datatable.serverDataTableAddRow(strDataTable, dctRow);
}
}
return SCRIPT_CONTINUE;
}
if (strCommands[0].equals("addSpawnLocation"))
{
obj_id objSpawner = createObject("object/tangible/space/content_infrastructure/generic_egg_small.iff", getTransform_o2p(self), getLocation(self).cell);
setObjVar(objSpawner, "intSpawnLocation", 1);
setName(objSpawner, "SPAWN LOCATION!");
sendSystemMessageTestingOnly(self, "Made spawn location");
}
if (strCommands[0].equals("createMineField"))
{
handleMineFieldCreation();
}
if (strCommands[0].equals("spawnTrigger"))
{
messageTo(self, "spawn_Trigger", null, 0, false);
}
return SCRIPT_CONTINUE;
}
public int specifyGroundSpawnerName(obj_id self, dictionary params) throws InterruptedException
{
int intButton = sui.getIntButtonPressed(params);
if (intButton == sui.BP_CANCEL)
{
sendSystemMessageTestingOnly(self, "Cancelling spawner creation");
clearSpawnerScriptVar(self, false);
return SCRIPT_CONTINUE;
}
String strName = sui.getInputBoxText(params);
if (strName.equals(""))
{
sui.inputbox(self, self, "INVALID Name! Should this spawner be named?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerName", null);
return SCRIPT_CONTINUE;
}
utils.setScriptVar(self, "strName", strName);
utils.setScriptVar(self, "previousName", strName);
if (canDuplicateLastSpawner(self))
{
String strSpawnerType = utils.getStringScriptVar(self, "strType");
float fltSpawnerRadius = utils.getFloatScriptVar(self, "fltRadius");
int intSpawnerCount = utils.getIntScriptVar(self, "intSpawnCount");
String strSpawnerSpawns = utils.getStringScriptVar(self, "strSpawns");
float fltSpawnerMinTime = utils.getFloatScriptVar(self, "fltMinSpawnTime");
float fltSpawnerMaxTime = utils.getFloatScriptVar(self, "fltMaxSpawnTime");
int intSpawnerBehavior = utils.getIntScriptVar(self, "intDefaultBehavior");
String[] behaviors =
{
"wander",
"sentinel",
"loiter",
"stop"
};
String strSpawnerBehavior = behaviors[intSpawnerBehavior];
String title = "Test";
String prompt = "Current Spawn Data \n \\#pcontrast1 Type: \\#. " + strSpawnerType + " \n \\#pcontrast1 Spawn: \\#. " + strSpawnerSpawns + " \n \\#pcontrast1 Default Behavior: \\#. " + strSpawnerBehavior + " \n \\#pcontrast1 Radius: \\#. " + fltSpawnerRadius + " \n \\#pcontrast1 Count: \\#. " + intSpawnerCount + " \n \\#pcontrast1 Respawn (Min - Max): \\#. " + fltSpawnerMinTime + " - " + fltSpawnerMaxTime;
int pid = sui.createSUIPage(sui.SUI_MSGBOX, self, self, "duplicateLastSpawner");
setSUIProperty(pid, sui.MSGBOX_TITLE, sui.PROP_TEXT, title);
setSUIProperty(pid, sui.MSGBOX_PROMPT, sui.PROP_TEXT, prompt);
sui.msgboxButtonSetup(pid, sui.YES_NO_CANCEL);
String revertButton = "Change to area";
if (strSpawnerType.equals("area"))
{
revertButton = "Change to patrol";
}
setSUIProperty(pid, sui.MSGBOX_BTN_REVERT, sui.PROP_TEXT, revertButton);
setSUIProperty(pid, sui.MSGBOX_BTN_CANCEL, sui.PROP_TEXT, "Enter new data");
setSUIProperty(pid, sui.MSGBOX_BTN_OK, sui.PROP_TEXT, "Use this data");
setSUIProperty(pid, sui.MSGBOX_BTN_REVERT, "OnPress", "RevertWasPressed=1\r\nparent.btnOk.press=t");
subscribeToSUIProperty(pid, sui.MSGBOX_BTN_REVERT, "RevertWasPressed");
sui.showSUIPage(pid);
return SCRIPT_CONTINUE;
}
clearSpawnerScriptVar(self, false);
utils.setScriptVar(self, "strName", strName);
sui.inputbox(self, self, "What type of spawner? Valid types are : area, patrol", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerType", null);
return SCRIPT_CONTINUE;
}
public int duplicateLastSpawner(obj_id self, dictionary params) throws InterruptedException
{
int intButton = sui.getIntButtonPressed(params);
String revert = params.getString(sui.MSGBOX_BTN_REVERT + ".RevertWasPressed");
if (intButton == sui.BP_CANCEL)
{
String strName = utils.getStringScriptVar(self, "strName");
clearSpawnerScriptVar(self, false);
utils.setScriptVar(self, "strName", strName);
sui.inputbox(self, self, "What type of spawner? Valid types are : area, patrol", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerType", null);
}
if (intButton == sui.BP_OK)
{
String strSpawnerType = utils.getStringScriptVar(self, "strType");
if (revert != null && !revert.equals(""))
{
if (strSpawnerType.equals("patrol"))
{
strSpawnerType = "area";
}
else
{
strSpawnerType = "patrol";
}
utils.setScriptVar(self, "strType", strSpawnerType);
}
if (strSpawnerType.equals("patrol"))
{
sui.inputbox(self, self, "What is the Patrol Path Type: Cycle or Oscillate", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "handlePatrolPathType", null);
}
else
{
int intSpawnerBehavior = utils.getIntScriptVar(self, "intDefaultBehavior");
if (intSpawnerBehavior == 3)
{
intSpawnerBehavior = 1;
utils.setScriptVar(self, "intDefaultBehavior", intSpawnerBehavior);
}
writeSpawner(self);
}
return SCRIPT_CONTINUE;
}
return SCRIPT_CONTINUE;
}
public int specifyGroundSpawnerType(obj_id self, dictionary params) throws InterruptedException
{
int intButton = sui.getIntButtonPressed(params);
if (intButton == sui.BP_CANCEL)
{
sendSystemMessageTestingOnly(self, "Cancelling spawner creation");
clearSpawnerScriptVar(self, true);
return SCRIPT_CONTINUE;
}
String strType = sui.getInputBoxText(params);
if (!isValidSpawnerType(strType))
{
sui.inputbox(self, self, "INVALID SPAWN TYPE " + strType + ". What type of spawner? Valid types are : area, patrol, location ", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerType", null);
return SCRIPT_CONTINUE;
}
else
{
utils.setScriptVar(self, "strType", strType);
sui.inputbox(self, self, "What type of spawns should this spawner use?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerSpawns", null);
}
return SCRIPT_CONTINUE;
}
public int specifyGroundSpawnerSpawns(obj_id self, dictionary params) throws InterruptedException
{
int intButton = sui.getIntButtonPressed(params);
if (intButton == sui.BP_CANCEL)
{
sendSystemMessageTestingOnly(self, "Cancelling spawner creation");
clearSpawnerScriptVar(self, true);
return SCRIPT_CONTINUE;
}
String strSpawns = sui.getInputBoxText(params);
if (strSpawns.equals(""))
{
sui.inputbox(self, self, "INVALID SPAWNS! What type of spawns should this spawner use?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerSpawns", null);
return SCRIPT_CONTINUE;
}
else
{
String strFileName = "datatables/spawning/ground_spawning/types/" + strSpawns + ".iff";
String creatureTable = "datatables/mob/creatures.iff";
dictionary creatureDict = null;
int stringCheck = strSpawns.indexOf("/");
if (stringCheck < 0)
{
creatureDict = dataTableGetRow(creatureTable, strSpawns);
}
if (!dataTableOpen(strFileName) && creatureDict == null)
{
sui.inputbox(self, self, "Unable to open type " + strFileName + " or find " + strSpawns + " in creatures.tab! What type of spawns should this spawner use?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerSpawns", null);
return SCRIPT_CONTINUE;
}
}
utils.setScriptVar(self, "strSpawns", strSpawns);
if ((utils.getStringScriptVar(self, "strType")).equals("patrol"))
{
sui.inputbox(self, self, "SCALE: Meters \nWhat is this spawner's spawn radius?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerRadius", null);
utils.setScriptVar(self, "intDefaultBehavior", isValidBehavior("stop"));
utils.setScriptVar(self, "intGoodLocationSpawner", 0);
}
else
{
sui.inputbox(self, self, "What default behavior do you wish your creatures to have? Valid Behaviors are : wander, loiter, stop, sentinel", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerDefaultBehavior", null);
}
return SCRIPT_CONTINUE;
}
public int specifyGroundSpawnerDefaultBehavior(obj_id self, dictionary params) throws InterruptedException
{
int intButton = sui.getIntButtonPressed(params);
if (intButton == sui.BP_CANCEL)
{
sendSystemMessageTestingOnly(self, "Cancelling spawner creation");
clearSpawnerScriptVar(self, true);
return SCRIPT_CONTINUE;
}
String strBehavior = sui.getInputBoxText(params);
int intBehavior = isValidBehavior(strBehavior);
if ((strBehavior.equals("")) || (intBehavior < 0))
{
sui.inputbox(self, self, "INVALID BEHAVIOR : What default behavior do you wish your creatures to have? Valid Behaviors are : wander, loiter, stop, sentinel", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerDefaultBehavior", null);
return SCRIPT_CONTINUE;
}
utils.setScriptVar(self, "intDefaultBehavior", intBehavior);
sui.inputbox(self, self, "Do you want to use getgoodlocation for this spawner? Valid answers are : yes, no", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerGoodLocationType", null);
return SCRIPT_CONTINUE;
}
public int isValidBehavior(String strBehavior) throws InterruptedException
{
final String[] BEHAVIORS =
{
"wander",
"sentinel",
"loiter",
"stop"
};
int intIndex = utils.getElementPositionInArray(BEHAVIORS, strBehavior);
sendSystemMessageTestingOnly(getSelf(), "For behavior " + strBehavior + " intIndex is " + intIndex);
return intIndex;
}
public int specifyGroundSpawnerGoodLocationType(obj_id self, dictionary params) throws InterruptedException
{
int intButton = sui.getIntButtonPressed(params);
if (intButton == sui.BP_CANCEL)
{
sendSystemMessageTestingOnly(self, "Cancelling spawner creation");
clearSpawnerScriptVar(self, true);
return SCRIPT_CONTINUE;
}
String strGoodLocationType = sui.getInputBoxText(params);
if (!strGoodLocationType.equals("yes") && (!strGoodLocationType.equals("no")))
{
sui.inputbox(self, self, "INVALID ANSWER : Do you want to use getgoodlocation for this spawner? Valid answers are : yes, no", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerGoodLocationType", null);
return SCRIPT_CONTINUE;
}
if (strGoodLocationType.equals("yes"))
{
utils.setScriptVar(self, "intGoodLocationSpawner", 1);
}
else
{
utils.setScriptVar(self, "intGoodLocationSpawner", 0);
}
String strType = utils.getStringScriptVar(self, "strType");
if (strType.equals("location"))
{
sui.inputbox(self, self, "What spawner location file do you want to use for this spawner?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerLocations", null);
}
else
{
sui.inputbox(self, self, "SCALE: Meters \nWhat is this spawner's spawn radius?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerRadius", null);
}
return SCRIPT_CONTINUE;
}
public int specifyGroundSpawnerLocations(obj_id self, dictionary params) throws InterruptedException
{
int intButton = sui.getIntButtonPressed(params);
if (intButton == sui.BP_CANCEL)
{
sendSystemMessageTestingOnly(self, "Cancelling spawner creation");
clearSpawnerScriptVar(self, true);
return SCRIPT_CONTINUE;
}
String strSpawnLocations = sui.getInputBoxText(params);
if (strSpawnLocations.equals(""))
{
sui.inputbox(self, self, "INVALID LOCATIONS FILE. What spawner location file do you want to use for this spawner?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerLocations", null);
return SCRIPT_CONTINUE;
}
else
{
String strFileName = "datatables/spawning/ground_spawning/buildouts/" + strSpawnLocations + ".iff";
if (!dataTableOpen(strFileName))
{
sui.inputbox(self, self, "UNABLE TO OPEN LOCATION FINE " + strFileName + ". What spawner location file do you want to use for this spawner?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerLocations", null);
return SCRIPT_CONTINUE;
}
}
utils.setScriptVar(self, "strSpawnLocations", strSpawnLocations);
sui.inputbox(self, self, "What is the spawn count for this spawner?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerSpawnCount", null);
return SCRIPT_CONTINUE;
}
public int specifyGroundSpawnerRadius(obj_id self, dictionary params) throws InterruptedException
{
int intButton = sui.getIntButtonPressed(params);
if (intButton == sui.BP_CANCEL)
{
sendSystemMessageTestingOnly(self, "Cancelling spawner creation");
clearSpawnerScriptVar(self, true);
return SCRIPT_CONTINUE;
}
String strRadius = sui.getInputBoxText(params);
float fltRadius = utils.stringToFloat(strRadius);
if (fltRadius == Float.NEGATIVE_INFINITY)
{
sui.inputbox(self, self, "INVALID NUMBER, PLEASE USE A NUMBER\n SCALE: Meters \nWhat is this spawner's spawn radius?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerMinSpawnDistance", null);
return SCRIPT_CONTINUE;
}
utils.setScriptVar(self, "fltRadius", fltRadius);
sui.inputbox(self, self, "What is the spawn count for this spawner?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerSpawnCount", null);
return SCRIPT_CONTINUE;
}
public int specifyGroundSpawnerSpawnCount(obj_id self, dictionary params) throws InterruptedException
{
int intButton = sui.getIntButtonPressed(params);
if (intButton == sui.BP_CANCEL)
{
sendSystemMessageTestingOnly(self, "Cancelling spawner creation");
clearSpawnerScriptVar(self, true);
return SCRIPT_CONTINUE;
}
String strSpawnCount = sui.getInputBoxText(params);
int intSpawnCount = utils.stringToInt(strSpawnCount);
if (intSpawnCount == -1)
{
sui.inputbox(self, self, "INVALID NUMBER, PLEASE USE A NUMBER\n SCALE: Mobs \nWhat is this spawner's maximum population ?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerSpawnCount", null);
return SCRIPT_CONTINUE;
}
utils.setScriptVar(self, "intSpawnCount", intSpawnCount);
sui.inputbox(self, self, "SCALE: Seconds \nWhat is this spawner's minimum spawn time?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerMinSpawnTime", null);
return SCRIPT_CONTINUE;
}
public int specifyGroundSpawnerMinSpawnTime(obj_id self, dictionary params) throws InterruptedException
{
int intButton = sui.getIntButtonPressed(params);
if (intButton == sui.BP_CANCEL)
{
sendSystemMessageTestingOnly(self, "Cancelling spawner creation");
clearSpawnerScriptVar(self, true);
return SCRIPT_CONTINUE;
}
String strMinSpawnTime = sui.getInputBoxText(params);
float fltMinSpawnTime = utils.stringToFloat(strMinSpawnTime);
if (fltMinSpawnTime == Float.NEGATIVE_INFINITY)
{
sui.inputbox(self, self, "INVALID NUMBER, PLEASE USE A NUMBER\n SCALE: Seconds \nWhat is this spawner's minimum spawn time?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerMinSpawnTime", null);
return SCRIPT_CONTINUE;
}
utils.setScriptVar(self, "fltMinSpawnTime", fltMinSpawnTime);
sui.inputbox(self, self, "Min Spawn Time :" + fltMinSpawnTime + "\n SCALE: Seconds \nWhat is this spawner's maximum spawn recycle time?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerMaxSpawnTime", null);
return SCRIPT_CONTINUE;
}
public int specifyGroundSpawnerMaxSpawnTime(obj_id self, dictionary params) throws InterruptedException
{
int intButton = sui.getIntButtonPressed(params);
if (intButton == sui.BP_CANCEL)
{
sendSystemMessageTestingOnly(self, "Cancelling spawner creation");
clearSpawnerScriptVar(self, true);
return SCRIPT_CONTINUE;
}
float fltMinSpawnTime = utils.getFloatScriptVar(self, "fltMinSpawnTime");
String strMaxSpawnTime = sui.getInputBoxText(params);
float fltMaxSpawnTime = utils.stringToFloat(strMaxSpawnTime);
if (fltMaxSpawnTime == Float.NEGATIVE_INFINITY)
{
sui.inputbox(self, self, "INVALID NUMBER, PLEASE USE A NUMBER\n SCALE: Seconds \nWhat is this spawner's maximum spawn time?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerMaxSpawnTime", null);
return SCRIPT_CONTINUE;
}
if (fltMaxSpawnTime <= fltMinSpawnTime)
{
sui.inputbox(self, self, "MAXSPAWN TIME MUST BE GREATER THAN MIN SPAWN TIME, MIN SPAWN TIME IS:" + fltMinSpawnTime + "\n SCALE: Seconds \nWhat is this spawner's maximum spawn time?", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "specifyGroundSpawnerMaxSpawnTime", null);
return SCRIPT_CONTINUE;
}
utils.setScriptVar(self, "fltMaxSpawnTime", fltMaxSpawnTime);
if ((utils.getStringScriptVar(self, "strType")).equals("patrol"))
{
sui.inputbox(self, self, "What is the Patrol Path Type: Cycle or Oscillate", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "handlePatrolPathType", null);
}
else
{
writeSpawner(self);
}
return SCRIPT_CONTINUE;
}
public int handlePatrolPathType(obj_id self, dictionary params) throws InterruptedException
{
int intButton = sui.getIntButtonPressed(params);
if (intButton == sui.BP_CANCEL)
{
sendSystemMessageTestingOnly(self, "Cancelling spawner creation");
clearSpawnerScriptVar(self, true);
return SCRIPT_CONTINUE;
}
String patrolType = sui.getInputBoxText(params);
if (!(patrolType.equals("cycle") || patrolType.equals("oscillate")))
{
sui.inputbox(self, self, "INVALID ENTRY: What is the Patrol Path Type: cycle or oscillate", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "handlePatrolPathType", null);
return SCRIPT_CONTINUE;
}
utils.setScriptVar(self, "strPatrolPathType", patrolType);
Vector patrolPoints = new Vector();
patrolPoints.setSize(0);
patrolPoints = utils.addElement(patrolPoints, createObject("object/tangible/ground_spawning/patrol_spawner.iff", getLocation(self)));
utils.setScriptVar(self, "objPatrolPoints", patrolPoints);
String title = "Place Patrol Waypoint";
String prompt = "Choose WAYPOINT to set a new waypoint or END to write path to the spawner";
int pid = sui.msgbox(self, self, prompt, sui.YES_NO, title, "handlePlaceNewPatrolPoint");
setSUIProperty(pid, sui.LISTBOX_BTN_CANCEL, sui.PROP_TEXT, "END POINT");
setSUIProperty(pid, sui.LISTBOX_BTN_OK, sui.PROP_TEXT, "WAYPOINT");
showSUIPage(pid);
return SCRIPT_CONTINUE;
}
public int handlePlaceNewPatrolPoint(obj_id self, dictionary params) throws InterruptedException
{
int intButton = sui.getIntButtonPressed(params);
Vector waypointArray = utils.getResizeableObjIdArrayScriptVar(self, "objPatrolPoints");
obj_id patrolPoint;
for (int q = 0; q < waypointArray.size(); q++)
{
doLogging("handlePlaceNewPatrolPoint", "waypointArray.length = " + q);
}
if (intButton == sui.BP_CANCEL)
{
if (!utils.hasScriptVar(self, "objPatrolPoints"))
{
sendSystemMessageTestingOnly(self, "Attempted to create patrol route with no waypoints");
sendSystemMessageTestingOnly(self, "Cancelling spawner creation.");
clearSpawnerScriptVar(self, true);
return SCRIPT_CONTINUE;
}
patrolPoint = createObject("object/tangible/ground_spawning/patrol_waypoint.iff", getLocation(self));
waypointArray = utils.addElement(waypointArray, patrolPoint);
utils.setScriptVar(self, "objPatrolPoints", waypointArray);
if (waypointArray == null || waypointArray.size() < 2)
{
sendSystemMessageTestingOnly(self, "Location Array was NULL or only contained the base waypoint");
clearSpawnerScriptVar(self, true);
return SCRIPT_CONTINUE;
}
writeSpawner(self);
}
if (intButton == sui.BP_OK)
{
doLogging("handlePlaceNewPatrolPoint", "WAYPOINT button pressed");
patrolPoint = createObject("object/tangible/ground_spawning/patrol_waypoint.iff", getLocation(self));
waypointArray = utils.addElement(waypointArray, patrolPoint);
utils.setScriptVar(self, "objPatrolPoints", waypointArray);
String title = "Place Patrol Waypoint";
String prompt = "Choose WAYPOINT to set a new waypoint or END to write path to the spawner";
int pid = sui.msgbox(self, self, prompt, sui.YES_NO, title, "handlePlaceNewPatrolPoint");
setSUIProperty(pid, sui.LISTBOX_BTN_CANCEL, sui.PROP_TEXT, "END POINT");
setSUIProperty(pid, sui.LISTBOX_BTN_OK, sui.PROP_TEXT, "WAYPOINT");
showSUIPage(pid);
}
return SCRIPT_CONTINUE;
}
public boolean canDuplicateLastSpawner(obj_id self) throws InterruptedException
{
if (!utils.hasScriptVar(self, "strType"))
{
return false;
}
String strSpawnerType = utils.getStringScriptVar(self, "strType");
if (strSpawnerType.equals("location"))
{
return false;
}
if (!utils.hasScriptVar(self, "fltRadius"))
{
return false;
}
if (!utils.hasScriptVar(self, "strName"))
{
return false;
}
if (!utils.hasScriptVar(self, "intSpawnCount"))
{
return false;
}
if (!utils.hasScriptVar(self, "strSpawns"))
{
return false;
}
if (!utils.hasScriptVar(self, "fltMaxSpawnTime"))
{
return false;
}
if (!utils.hasScriptVar(self, "fltMinSpawnTime"))
{
return false;
}
if (!utils.hasScriptVar(self, "intDefaultBehavior"))
{
return false;
}
if (!utils.hasScriptVar(self, "intGoodLocationSpawner"))
{
return false;
}
return true;
}
public void clearSpawnerScriptVar(obj_id self, boolean boolDestroySpawners) throws InterruptedException
{
utils.removeScriptVar(self, "strType");
utils.removeScriptVar(self, "fltRadius");
utils.removeScriptVar(self, "strName");
utils.removeScriptVar(self, "intSpawnCount");
utils.removeScriptVar(self, "strSpawns");
utils.removeScriptVar(self, "fltMaxSpawnTime");
utils.removeScriptVar(self, "fltMinSpawnTime");
utils.removeScriptVar(self, "strSpawnLocations");
utils.removeScriptVar(self, "intDefaultBehavior");
utils.removeScriptVar(self, "intGoodLocationSpawner");
utils.removeScriptVar(self, "strPatrolPathType");
if (boolDestroySpawners)
{
Vector objPatrolPoints = utils.getResizeableObjIdArrayScriptVar(self, "objPatrolPoints");
if (objPatrolPoints != null)
{
for (Object objPatrolPoint : objPatrolPoints) {
destroyObject(((obj_id) objPatrolPoint));
}
}
}
utils.removeScriptVar(self, "objPatrolPoints");
}
public void writeSpawner(obj_id self) throws InterruptedException
{
sendSystemMessageTestingOnly(self, "Writing spawner");
String strSpawnerType = utils.getStringScriptVar(self, "strType");
Vector patrolPoints = new Vector();
patrolPoints.setSize(0);
obj_id objSpawner;
if (strSpawnerType.equals("area") || strSpawnerType.equals("location"))
{
transform trTest = getTransform_o2p(self);
location locTest = getLocation(self);
objSpawner = createObject("object/tangible/ground_spawning/area_spawner.iff", trTest, locTest.cell);
persistObject(objSpawner);
}
else
{
patrolPoints = utils.getResizeableObjIdArrayScriptVar(self, "objPatrolPoints");
String strPatrolPathType = utils.getStringScriptVar(self, "strPatrolPathType");
objSpawner = ((obj_id)patrolPoints.get(0));
persistObject(objSpawner);
setObjVar(objSpawner, "patrolPathType", strPatrolPathType);
}
setObjVar(objSpawner, "strSpawnerType", strSpawnerType);
setObjVar(objSpawner, "intSpawnSystem", 1);
String strSpawnerName = utils.getStringScriptVar(self, "strName");
setObjVar(objSpawner, "strName", strSpawnerName);
setName(objSpawner, strSpawnerName);
int intSpawnCount = utils.getIntScriptVar(self, "intSpawnCount");
setObjVar(objSpawner, "intSpawnCount", intSpawnCount);
float fltMaxSpawnTime = utils.getFloatScriptVar(self, "fltMaxSpawnTime");
setObjVar(objSpawner, "fltMaxSpawnTime", fltMaxSpawnTime);
float fltMinSpawnTime = utils.getFloatScriptVar(self, "fltMinSpawnTime");
setObjVar(objSpawner, "fltMinSpawnTime", fltMinSpawnTime);
String strSpawns = utils.getStringScriptVar(self, "strSpawns");
setObjVar(objSpawner, "strSpawns", strSpawns);
if (strSpawnerType.equals("patrol"))
{
String[] patrolPointNames = new String[patrolPoints.size() - 1];
patrolPointNames[0] = strSpawnerName;
int k = 0;
for (int i = 1; i < patrolPoints.size(); i++)
{
setName(((obj_id)patrolPoints.get(i)), strSpawnerName + "_" + objSpawner + "_" + i);
patrolPointNames[k] = strSpawnerName + "_" + objSpawner + "_" + i;
setObjVar(((obj_id)patrolPoints.get(i)), "pointName", strSpawnerName + "_" + objSpawner + "_" + i);
persistObject(((obj_id)patrolPoints.get(i)));
attachScript(((obj_id)patrolPoints.get(i)), "systems.spawning.patrol_point_setup");
k++;
}
setObjVar(objSpawner, "strPatrolPointNames", patrolPointNames);
float fltRadius = utils.getFloatScriptVar(self, "fltRadius");
setObjVar(objSpawner, "fltRadius", fltRadius);
attachScript(objSpawner, "systems.spawning.spawner_patrol");
}
if (strSpawnerType.equals("area"))
{
float fltRadius = utils.getFloatScriptVar(self, "fltRadius");
setObjVar(objSpawner, "fltRadius", fltRadius);
attachScript(objSpawner, "systems.spawning.spawner_area");
}
else if (strSpawnerType.equals("location"))
{
String strSpawnLocations = utils.getStringScriptVar(self, "strSpawnLocations");
setObjVar(objSpawner, "strSpawnLocations", strSpawnLocations);
attachScript(objSpawner, "systems.spawning.spawner_location");
}
int intDefaultBehavior = utils.getIntScriptVar(self, "intDefaultBehavior");
setObjVar(objSpawner, "intDefaultBehavior", intDefaultBehavior);
int intGoodLocationSpawner = utils.getIntScriptVar(self, "intGoodLocationSpawner");
setObjVar(objSpawner, "intGoodLocationSpawner", intGoodLocationSpawner);
}
public boolean isValidSpawnerType(String strText) throws InterruptedException
{
return strText.equals("area") || strText.equals("patrol");
}
public void handleMineFieldCreation() throws InterruptedException
{
String datatable = "datatables/combat/npc_landmines.iff";
String[] validMineTypes = dataTableGetStringColumn(datatable, "mineType");
float[] detonateRange = dataTableGetFloatColumn(datatable, "detonateRange");
float[] blastRadius = dataTableGetFloatColumn(datatable, "blastRadius");
int[] minDamage = dataTableGetIntColumn(datatable, "minDamage");
int[] maxDamage = dataTableGetIntColumn(datatable, "maxDamage");
String[] damageType = dataTableGetStringColumn(datatable, "damageType");
obj_id user = getSelf();
String[] packedMineStrings = new String[validMineTypes.length];
for (int i = 0; i < validMineTypes.length; i++)
{
packedMineStrings[i] = validMineTypes[i] + " DR[" + detonateRange[i] + "] BR[" + blastRadius[i] + "] MinD[" + minDamage[i] + "] MaxD[" + maxDamage[i] + "] DT [" + damageType[i] + "]";
}
if (validMineTypes.length > 0)
{
int pid = sui.listbox(user, user, "Select Mine Type", packedMineStrings, "handleSelectMineType");
if (pid > -1)
{
showSUIPage(pid);
}
}
}
public int handleSelectMineType(obj_id self, dictionary params) throws InterruptedException
{
obj_id player = sui.getPlayerId(params);
int idx = sui.getListboxSelectedRow(params);
if (idx < 0)
{
return SCRIPT_CONTINUE;
}
utils.setScriptVar(player, "mineCreation.mineType", idx);
sui.inputbox(player, player, "What is the Radius of this field", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "handleSetFieldRadius", null);
return SCRIPT_CONTINUE;
}
public int handleSetFieldRadius(obj_id self, dictionary params) throws InterruptedException
{
int button = sui.getIntButtonPressed(params);
if (button == sui.BP_CANCEL)
{
sendSystemMessageTestingOnly(self, "Cancelling mine field creation");
clearMineScriptVar(self);
return SCRIPT_CONTINUE;
}
String stringFieldRadius = sui.getInputBoxText(params);
float floatFieldRadius = utils.stringToFloat(stringFieldRadius);
utils.setScriptVar(self, "mineCreation.fieldRadius", floatFieldRadius);
sui.inputbox(self, self, "What is the Mine Count of this field", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "handleSetMineCount", null);
return SCRIPT_CONTINUE;
}
public int handleSetMineCount(obj_id self, dictionary params) throws InterruptedException
{
int button = sui.getIntButtonPressed(params);
if (button == sui.BP_CANCEL)
{
sendSystemMessageTestingOnly(self, "Cancelling mine field creation");
clearMineScriptVar(self);
return SCRIPT_CONTINUE;
}
String stringMineCount = sui.getInputBoxText(params);
int intMineCount = utils.stringToInt(stringMineCount);
utils.setScriptVar(self, "mineCreation.mineCount", intMineCount);
sui.inputbox(self, self, "What is the respawn time of this field", sui.OK_CANCEL, "Test", sui.INPUT_NORMAL, null, "handleSetMineRespawn", null);
return SCRIPT_CONTINUE;
}
public int handleSetMineRespawn(obj_id self, dictionary params) throws InterruptedException
{
int button = sui.getIntButtonPressed(params);
if (button == sui.BP_CANCEL)
{
sendSystemMessageTestingOnly(self, "Cancelling mine field creation");
clearMineScriptVar(self);
return SCRIPT_CONTINUE;
}
String stringMineRespawn = sui.getInputBoxText(params);
int intMineRespawn = utils.stringToInt(stringMineRespawn);
utils.setScriptVar(self, "mineCreation.mineRespawn", intMineRespawn);
doLogging("handleMineRespawn", "Call generateMineField");
generateMineField();
return SCRIPT_CONTINUE;
}
public void generateMineField() throws InterruptedException
{
obj_id player = getSelf();
transform tranx = getTransform_o2p(player);
location fieldLoc = getLocation(player);
obj_id mineFieldController = createObject("object/tangible/ground_spawning/minefield_spawner.iff", tranx, fieldLoc.cell);
doLogging("generateMineField", "mineFieldController isIdValid? " + isIdValid(mineFieldController));
persistObject(mineFieldController);
int intMineType = utils.getIntScriptVar(player, "mineCreation.mineType");
String stringMineType = dataTableGetString("datatables/combat/npc_landmines.iff", intMineType, "mineType");
setObjVar(mineFieldController, "mineField.mineType", stringMineType);
float fieldRadius = utils.getFloatScriptVar(player, "mineCreation.fieldRadius");
setObjVar(mineFieldController, "mineField.fieldRadius", fieldRadius);
int mineCount = utils.getIntScriptVar(player, "mineCreation.mineCount");
setObjVar(mineFieldController, "mineField.mineCount", mineCount);
int mineRespawn = utils.getIntScriptVar(player, "mineCreation.mineRespawn");
setObjVar(mineFieldController, "mineField.mineRespawn", mineRespawn);
attachScript(mineFieldController, "systems.combat.combat_mine_spawner");
clearMineScriptVar(player);
}
public void clearMineScriptVar(obj_id player) throws InterruptedException
{
utils.removeScriptVar(player, "mineCreation");
}
public void doLogging(String section, String message) throws InterruptedException
{
}
public int checkStationCells(obj_id self, dictionary params) throws InterruptedException
{
if (isInWorldCell(self))
{
return SCRIPT_CONTINUE;
}
obj_id cell = getContainedBy(self);
if (!isIdValid(cell) || !exists(cell))
{
return SCRIPT_CONTINUE;
}
if (utils.hasScriptVar(cell, craftinglib.SCRIPTVAR_CELL_STATIONS))
{
obj_id[] stations = utils.getObjIdArrayScriptVar(cell, craftinglib.SCRIPTVAR_CELL_STATIONS);
if (stations == null || stations.length <= 0)
{
return SCRIPT_CONTINUE;
}
String buffName;
for (obj_id station : stations) {
if (!isIdValid(station)) {
continue;
}
int craftingType = getIntObjVar(station, craftinglib.OBJVAR_CRAFTING_TYPE);
buffName = craftinglib.getCraftingStationBuffName(craftingType);
if (buffName == null || buffName.equals("")) {
continue;
}
buff.applyBuff(self, station, buffName);
}
}
return SCRIPT_CONTINUE;
}
}
Reference in New Issue View Git Blame Copy Permalink