mirror of
https://github.com/SWG-Source/dsrc.git
synced 2026-07-28 22:15:54 -04:00
702 lines
19 KiB
Plaintext
702 lines
19 KiB
Plaintext
|
|
/**
|
|
* Copyright (c)2000-2002 Sony Online Entertainment Inc.
|
|
* All Rights Reserved
|
|
*
|
|
* Title: player_test_utility.script
|
|
* Description: Test script that does various useful stuff
|
|
* @author $Author: bhanson $
|
|
* @version $Revision:$
|
|
*/
|
|
|
|
|
|
/***** INCLUDES ********************************************************/
|
|
|
|
include library.utils;
|
|
include library.badge;
|
|
include library.resource;
|
|
include library.create;
|
|
include library.bio_engineer;
|
|
include library.features;
|
|
include ai.ai_combat;
|
|
include library.jedi;
|
|
include library.skill_template;
|
|
include library.pclib;
|
|
include library.sui;
|
|
include library.cloninglib;
|
|
|
|
/***** TRIGGERS ********************************************************/
|
|
|
|
trigger OnAttach()
|
|
{
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
trigger OnSpeaking(string text)
|
|
{
|
|
location loc = getLocation(self);
|
|
|
|
if (text.startsWith("getWorkingSkill"))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Working Skill = "+getWorkingSkill(self));
|
|
}
|
|
|
|
if (text.startsWith("getSkillTemplate"))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Skill Template = "+getSkillTemplate(self));
|
|
}
|
|
|
|
if (text.startsWith("setWorkingSkill"))
|
|
{
|
|
java.util.StringTokenizer st = new java.util.StringTokenizer(text);
|
|
string cmd = st.nextToken();
|
|
string arg = "";
|
|
|
|
if (st.hasMoreTokens())
|
|
arg = st.nextToken();
|
|
|
|
setWorkingSkill(self, arg);
|
|
sendSystemMessageTestingOnly(self, "Working Skill set to: "+arg);
|
|
}
|
|
|
|
if (text.startsWith("setSkillTemplate"))
|
|
{
|
|
java.util.StringTokenizer st = new java.util.StringTokenizer(text);
|
|
string cmd = st.nextToken();
|
|
string arg = "";
|
|
|
|
if (st.hasMoreTokens())
|
|
arg = st.nextToken();
|
|
|
|
string templateSkills = dataTableGetString(skill_template.TEMPLATE_TABLE, arg, "template");
|
|
if (arg != "" && (templateSkills == null || templateSkills.equals("")))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Not a Valid Skill Template");
|
|
}
|
|
else
|
|
{
|
|
setSkillTemplate(self, arg);
|
|
sendSystemMessageTestingOnly(self, "Skill Template set to: "+arg);
|
|
}
|
|
}
|
|
|
|
if (text.startsWith("killme"))
|
|
{
|
|
obj_id target = self;
|
|
|
|
int dam = -(getAttrib(target, HEALTH) + 50);
|
|
addAttribModifier(target, HEALTH, dam, 0f, 0f, MOD_POOL);
|
|
|
|
if (getPosture(target) != POSTURE_DEAD)
|
|
{
|
|
setPosture(target, POSTURE_DEAD);
|
|
}
|
|
|
|
if (!hasObjVar(target, pclib.VAR_BEEN_COUPDEGRACED))
|
|
{
|
|
setObjVar(target, pclib.VAR_DEATHBLOW_KILLER, target);
|
|
setObjVar(target, pclib.VAR_DEATHBLOW_STAMP, getGameTime());
|
|
}
|
|
|
|
pclib.playerDeath(target, target, false);
|
|
}
|
|
|
|
if (text.equals("clonewarp"))
|
|
{
|
|
createCloneWarpSui(self);
|
|
}
|
|
|
|
if (text.startsWith("createResource"))
|
|
{
|
|
java.util.StringTokenizer st = new java.util.StringTokenizer(text);
|
|
string arg = st.nextToken();
|
|
|
|
if ( st.countTokens() != 2 )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "[debugger] SYNTAX: createResource <resource> <amt>");
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
string type = st.nextToken();
|
|
string sAmt = st.nextToken();
|
|
int amt = utils.stringToInt(sAmt);
|
|
|
|
if ( amt < 1 )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "[debugger] SYNTAX: createResource <resource> <amt>");
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
obj_id pInv = utils.getInventoryContainer(self);
|
|
obj_id[] crates = resource.createRandom( type, amt, loc, pInv, self, 1 );
|
|
|
|
}
|
|
|
|
if (text.startsWith("createDNA"))
|
|
{
|
|
java.util.StringTokenizer st = new java.util.StringTokenizer(text);
|
|
string arg = st.nextToken();
|
|
|
|
if ( st.countTokens() != 1 )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "[debugger] SYNTAX: createDNA <creature>");
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
string creature = st.nextToken();
|
|
|
|
bio_engineer.quickHarvest(self, creature);
|
|
}
|
|
|
|
if (text.equals("attack"))
|
|
{
|
|
obj_id target = getLookAtTarget(self);
|
|
|
|
if (target != null && target != self)
|
|
{
|
|
startCombat (target, self);
|
|
}
|
|
}
|
|
|
|
if (text.equals("frenzy"))
|
|
{
|
|
obj_id target = getLookAtTarget(self);
|
|
|
|
if (target != null && target != self)
|
|
{
|
|
addToMentalStateToward(target, self, FEAR, 45.0f);
|
|
}
|
|
}
|
|
|
|
if ( text.startsWith("checkBadge") )
|
|
{
|
|
java.util.StringTokenizer st = new java.util.StringTokenizer(text);
|
|
string arg = st.nextToken();
|
|
string badgeName = st.nextToken();
|
|
|
|
obj_id target = getLookAtTarget(self);
|
|
|
|
sendSystemMessageTestingOnly(self, "[Badge] Has Badge " + badgeName + " = " + badge.hasBadge(target, badgeName));
|
|
}
|
|
|
|
if (text.equals("enableJedi"))
|
|
{
|
|
addJediSlot(self);
|
|
}
|
|
|
|
if (text.equals("runTest"))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "[test] Analyzing creatures level/stats...");
|
|
|
|
checkCreatures();
|
|
}
|
|
|
|
if (text.equals("resetPower"))
|
|
{
|
|
jedi.recalculateForcePower(self);
|
|
}
|
|
|
|
if ( text.startsWith("setScale") )
|
|
{
|
|
java.util.StringTokenizer st = new java.util.StringTokenizer(text);
|
|
string arg = st.nextToken();
|
|
float scale = utils.stringToFloat(st.nextToken());
|
|
|
|
obj_id target = getLookAtTarget(self);
|
|
|
|
float baseScale = 1.0f;
|
|
if (utils.hasScriptVar( target, "ai.baseScale" ) )
|
|
baseScale = utils.getFloatScriptVar( target, "ai.baseScale" );
|
|
|
|
float finalScale = baseScale * scale;
|
|
setScale(target, finalScale);
|
|
|
|
sendSystemMessageTestingOnly(self, "[test] Creature scale set to " + scale);
|
|
}
|
|
|
|
if(text.startsWith("getScriptVars"))
|
|
{
|
|
obj_id target = getLookAtTarget(self);
|
|
if (!isIdValid(target))
|
|
target = self;
|
|
|
|
deltadictionary dctScriptVars = target.getScriptVars();
|
|
sendSystemMessageTestingOnly(self, "Scriptvars are "+dctScriptVars.toString());
|
|
}
|
|
|
|
if(text.startsWith("getPlanetScriptVars"))
|
|
{
|
|
string planetName = getCurrentSceneName();
|
|
obj_id planet = getPlanetByName(planetName);
|
|
|
|
deltadictionary dctScriptVars = planet.getScriptVars();
|
|
sendSystemMessageTestingOnly(self, "Scriptvars are "+dctScriptVars.toString());
|
|
}
|
|
|
|
if (text.startsWith("getResourceId"))
|
|
{
|
|
java.util.StringTokenizer st = new java.util.StringTokenizer(text);
|
|
string arg = st.nextToken();
|
|
string resource = st.nextToken();
|
|
|
|
obj_id resId = getResourceTypeByName(resource);
|
|
|
|
sendSystemMessageTestingOnly(self, "[test] " + resource + " = " + resId);
|
|
}
|
|
|
|
if (text.startsWith("testGoggles"))
|
|
{
|
|
java.util.StringTokenizer st = new java.util.StringTokenizer(text);
|
|
string arg = st.nextToken();
|
|
string oidString = st.nextToken();
|
|
|
|
Long temp = new Long(Long.parseLong(oidString));
|
|
obj_id goggle = obj_id.getObjId(temp.longValue());
|
|
|
|
boolean validGoggles = true;
|
|
|
|
obj_id owner = getOwner(goggle);
|
|
LOG ("seGoggles", "Owner = " + owner);
|
|
if (!isIdValid(owner))
|
|
validGoggles = false;
|
|
else
|
|
{
|
|
obj_id inv = utils.getInventoryContainer(owner);
|
|
obj_id bank = utils.getPlayerBank(owner);
|
|
obj_id eyes = getObjectInSlot(owner, "eyes");
|
|
LOG ("seGoggles", "Inv = " + inv);
|
|
LOG ("seGoggles", "Bank = " + bank);
|
|
LOG ("seGoggles", "Eyes = " + eyes);
|
|
|
|
if ( !isIdValid(inv) || !isIdValid(bank) )
|
|
validGoggles = false;
|
|
|
|
if (!features.isCollectorEdition(owner))
|
|
validGoggles = false;
|
|
else
|
|
{
|
|
|
|
obj_id container = getContainedBy(goggle);
|
|
LOG ("seGoggles", "Container = " + container);
|
|
|
|
if (container == owner)
|
|
{
|
|
if (goggle != eyes)
|
|
validGoggles = false;
|
|
}
|
|
else if (!( container == inv || container == bank ))
|
|
validGoggles = false;
|
|
}
|
|
}
|
|
|
|
if (!validGoggles)
|
|
{
|
|
if (isIdValid(owner))
|
|
sendSystemMessage (owner, new string_id ("error_message", "destroy_goggle"));
|
|
|
|
destroyObject(goggle);
|
|
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
}
|
|
|
|
if (text.startsWith("saberStats"))
|
|
{
|
|
java.util.StringTokenizer st = new java.util.StringTokenizer(text);
|
|
string arg = st.nextToken();
|
|
string oidString = st.nextToken();
|
|
|
|
Long temp = new Long(Long.parseLong(oidString));
|
|
obj_id saber = obj_id.getObjId(temp.longValue());
|
|
|
|
int minDmg = getWeaponMinDamage(saber);
|
|
int maxDmg = getWeaponMaxDamage(saber);
|
|
float speed = getWeaponAttackSpeed(saber);
|
|
range_info ri = getWeaponRangeInfo(saber);
|
|
float wound = getWeaponWoundChance(saber);
|
|
float radius = getWeaponDamageRadius(saber);
|
|
//int[] ham = getWeaponAttribCost(saber);
|
|
|
|
//sendSystemMessageTestingOnly(self, "Saber Stats: Dam:"+minDmg+"-"+maxDmg+
|
|
// ", Spd:"+speed+
|
|
// ", Rng:0(+"+ri.minRangeMod+")/"+ri.midRange+"(+"+ri.midRangeMod+")/"+ri.maxRange+"(+"+ri.maxRangeMod+
|
|
// "), Wnd:"+wound+
|
|
// ", HAM:"+ham[0]+"/"+ham[1]+"/"+ham[2]);
|
|
}
|
|
|
|
if (text.startsWith("decaySaber"))
|
|
{
|
|
java.util.StringTokenizer st = new java.util.StringTokenizer(text);
|
|
string arg = st.nextToken();
|
|
string oidString = st.nextToken();
|
|
|
|
Long temp = new Long(Long.parseLong(oidString));
|
|
obj_id item = obj_id.getObjId(temp.longValue());
|
|
|
|
dictionary data = new dictionary();
|
|
data.put("amount", 100);
|
|
data.put("owner", self);
|
|
messageTo(item, "decaySaberCrystal", data, 0, false);
|
|
}
|
|
|
|
if (text.startsWith("decay "))
|
|
{
|
|
java.util.StringTokenizer st = new java.util.StringTokenizer(text);
|
|
string arg = st.nextToken();
|
|
string oidString = st.nextToken();
|
|
|
|
Long temp = new Long(Long.parseLong(oidString));
|
|
obj_id item = obj_id.getObjId(temp.longValue());
|
|
|
|
int hp = getHitpoints(item);
|
|
if (hp > 0)
|
|
{
|
|
hp -= rand(25, 75);
|
|
setInvulnerableHitpoints(item, hp);
|
|
}
|
|
}
|
|
|
|
if (text.startsWith("jediState"))
|
|
{
|
|
java.util.StringTokenizer st = new java.util.StringTokenizer(text);
|
|
string arg = st.nextToken();
|
|
string token = st.nextToken();
|
|
|
|
int state = Integer.parseInt(token);
|
|
|
|
switch (state)
|
|
{
|
|
case 0:
|
|
state = JEDI_STATE_NONE;
|
|
sendSystemMessageTestingOnly(self, "Setting Jedi State to JEDI_STATE_NONE");
|
|
break;
|
|
|
|
case 1:
|
|
state = JEDI_STATE_FORCE_SENSITIVE;
|
|
sendSystemMessageTestingOnly(self, "Setting Jedi State to JEDI_STATE_FORCE_SENSITIVE");
|
|
break;
|
|
|
|
case 2:
|
|
state = JEDI_STATE_JEDI;
|
|
sendSystemMessageTestingOnly(self, "Setting Jedi State to JEDI_STATE_JEDI");
|
|
break;
|
|
|
|
case 3:
|
|
state = JEDI_STATE_FORCE_RANKED_LIGHT;
|
|
sendSystemMessageTestingOnly(self, "Setting Jedi State to JEDI_STATE_FORCE_RANKED_LIGHT");
|
|
break;
|
|
|
|
case 4:
|
|
state = JEDI_STATE_FORCE_RANKED_DARK;
|
|
sendSystemMessageTestingOnly(self, "Setting Jedi State to JEDI_STATE_FORCE_RANKED_DARK");
|
|
break;
|
|
}
|
|
|
|
setJediState(self, state);
|
|
}
|
|
|
|
if (text.startsWith("test"))
|
|
{
|
|
java.util.StringTokenizer st = new java.util.StringTokenizer(text);
|
|
string arg = st.nextToken();
|
|
string lvlString = st.nextToken();
|
|
|
|
int level = Integer.parseInt(lvlString);
|
|
int count = 1;
|
|
|
|
if (st.hasMoreTokens())
|
|
{
|
|
string countString = st.nextToken();
|
|
count = Integer.parseInt(countString);
|
|
}
|
|
|
|
for (int i = 0; i < count; i++)
|
|
testTune(level);
|
|
}
|
|
|
|
if (text.startsWith("fullTest"))
|
|
{
|
|
string output = "\tlevel\tdamage\tspeed\twound\tforce\t";
|
|
LOG ("saber_test", output);
|
|
|
|
//for (int level = 10; level < 350; level += 10)
|
|
for (int i = 0; i < 65000; i++)
|
|
testTune(0);
|
|
}
|
|
|
|
if (text.startsWith("crystalTest"))
|
|
{
|
|
obj_id inv = utils.getInventoryContainer(self);
|
|
|
|
for (int i = 0; i < 32; i ++)
|
|
{
|
|
obj_id crystal = createObject("object/tangible/component/weapon/lightsaber/lightsaber_module_force_crystal.iff", inv, "");
|
|
|
|
custom_var myVar = getCustomVarByName(crystal, "private/index_color_1");
|
|
if (myVar.isPalColor())
|
|
{
|
|
palcolor_custom_var pcVar = (palcolor_custom_var)myVar;
|
|
pcVar.setValue(i);
|
|
}
|
|
|
|
setObjVar(crystal, jedi.VAR_CRYSTAL_STATS + "." + jedi.VAR_COLOR, i);
|
|
setObjVar(crystal, jedi.VAR_CRYSTAL_OWNER_ID, self);
|
|
setObjVar(crystal, jedi.VAR_CRYSTAL_OWNER_NAME, getName(self));
|
|
|
|
}
|
|
}
|
|
|
|
if (text.equals("fuck"))
|
|
{
|
|
utils.removeScriptVar(self, "armor_count");
|
|
}
|
|
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
int createCloneWarpSui(obj_id player)
|
|
{
|
|
location playerLoc = getLocation(player);
|
|
|
|
string planetName = playerLoc.area;
|
|
if ( planetName == null )
|
|
return -1;
|
|
|
|
obj_id planet = getPlanetByName(planetName);
|
|
if ( !isIdValid(planet) )
|
|
return -1;
|
|
|
|
resizeable string[] nameList = utils.getResizeableStringArrayScriptVar(planet, cloninglib.VAR_PLANET_CLONE_NAME);
|
|
resizeable string[] areaList = utils.getResizeableStringArrayScriptVar(planet, cloninglib.VAR_PLANET_CLONE_AREA);
|
|
resizeable location[] locList = utils.getResizeableLocationArrayScriptVar(planet, cloninglib.VAR_PLANET_CLONE_LOC);
|
|
|
|
resizeable string[] list = new string[0];
|
|
for (int i = 0; i < nameList.length; i++)
|
|
{
|
|
string entry = nameList[i];
|
|
entry += " \\>200 ";
|
|
entry += areaList[i];
|
|
entry += " ("+locList[i].x+","+locList[i].z+")";
|
|
|
|
list = utils.addElement(list, entry);
|
|
}
|
|
|
|
string title = "Clone Warp";
|
|
string prompt = "Choose a Clone Location";
|
|
|
|
int pid = createSUIPage(sui.SUI_LISTBOX, player, player, "handleCloneWarp");
|
|
|
|
setSUIProperty(pid, sui.LISTBOX_TITLE, sui.PROP_TEXT, title);
|
|
setSUIProperty(pid, sui.LISTBOX_PROMPT, sui.PROP_TEXT, prompt);
|
|
|
|
// Add buttons.
|
|
sui.listboxButtonSetup(pid, sui.OK_CANCEL);
|
|
|
|
clearSUIDataSource(pid, sui.LISTBOX_DATASOURCE);
|
|
|
|
for (int i = 0; i < list.length; i++)
|
|
{
|
|
addSUIDataItem(pid, sui.LISTBOX_DATASOURCE, "" + i);
|
|
setSUIProperty(pid, sui.LISTBOX_DATASOURCE + "." + i, sui.PROP_TEXT, list[i]);
|
|
}
|
|
|
|
subscribeToSUIProperty(pid, sui.LISTBOX_LIST, sui.PROP_SELECTEDROW);
|
|
subscribeToSUIProperty(pid, sui.LISTBOX_TITLE, sui.PROP_TEXT);
|
|
|
|
showSUIPage(pid);
|
|
flushSUIPage(pid);
|
|
|
|
return pid;
|
|
}
|
|
|
|
messageHandler handleCloneWarp()
|
|
{
|
|
if (params == null)
|
|
return SCRIPT_CONTINUE;
|
|
|
|
int idx = sui.getListboxSelectedRow( params );
|
|
int btn = sui.getIntButtonPressed( params );
|
|
if ( btn == sui.BP_CANCEL || idx == -1)
|
|
{
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
location playerLoc = getLocation(self);
|
|
|
|
string planetName = playerLoc.area;
|
|
if ( planetName == null )
|
|
return SCRIPT_CONTINUE;
|
|
|
|
obj_id planet = getPlanetByName(planetName);
|
|
if ( !isIdValid(planet) )
|
|
return SCRIPT_CONTINUE;
|
|
|
|
resizeable location[] locList = utils.getResizeableLocationArrayScriptVar(planet, cloninglib.VAR_PLANET_CLONE_LOC);
|
|
resizeable location[] respawnList = utils.getResizeableLocationArrayScriptVar(planet, cloninglib.VAR_PLANET_CLONE_RESPAWN);
|
|
|
|
boolean warped = pclib.sendToAnyLocation(self, locList[idx], respawnList[idx]);
|
|
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
void testTune(int level)
|
|
{
|
|
const string COMPONENT_DATATABLE = "datatables/jedi/saber_component_ranges.iff";
|
|
|
|
obj_id player = getSelf();
|
|
int quality = jedi.getCrystalQuality(level);
|
|
|
|
dictionary dctWeaponInfo = dataTableGetRow(COMPONENT_DATATABLE, 2);
|
|
|
|
int minDamage = (int)dctWeaponInfo.getFloat("fltMinDamage");
|
|
int maxDamage = (int)dctWeaponInfo.getFloat("fltMaxDamage");
|
|
float minSpeed = dctWeaponInfo.getFloat("fltMinSpeed");
|
|
float maxSpeed = dctWeaponInfo.getFloat("fltMaxSpeed");
|
|
float minForce = dctWeaponInfo.getFloat("fltMinForcePower");
|
|
float maxForce = dctWeaponInfo.getFloat("fltMaxForcePower");
|
|
float minWound = dctWeaponInfo.getFloat("fltMinWoundChance");
|
|
float maxWound = dctWeaponInfo.getFloat("fltMaxWoundChance");
|
|
|
|
string output = "";
|
|
|
|
for (level = 10; level < 350; level += 10)
|
|
{
|
|
int damage = distributedRand(minDamage, maxDamage, level);
|
|
float wound = distributedRand(minWound, maxWound, level);
|
|
float force = distributedRand(minForce, maxForce, level);
|
|
float speed = distributedRand(minSpeed, maxSpeed, level);
|
|
|
|
output += "\t"+level+
|
|
"\t"+damage+
|
|
"\t"+speed+
|
|
"\t"+wound+
|
|
"\t"+force+"\t";
|
|
}
|
|
|
|
//sendSystemMessageTestingOnly(player, output);
|
|
LOG ("saber_test", output);
|
|
}
|
|
|
|
int distributedRand(int min, int max, int level)
|
|
{
|
|
const int levelMin = 60;
|
|
const int levelMax = 280;
|
|
|
|
//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; }
|
|
|
|
int minRand = rand(min, (int)(mid+0.5f));
|
|
int maxRand = rand((int)(mid+0.5f), max);
|
|
|
|
int randNum = rand(minRand, maxRand);
|
|
|
|
/* LOG ("saber_test", "lvl = "+level+
|
|
"; \trank = "+round(rank, 2)+
|
|
"; \tdist = ("+round(min, 2)+", "+round(mid, 2)+", "+round(max, 2)+")"+
|
|
"; \trand ("+round(minRand, 2)+", "+round(maxRand, 2)+
|
|
") ; \tnum = "+round(randNum, 2)+"\t");
|
|
*/
|
|
return randNum;
|
|
}
|
|
|
|
float distributedRand(float min, float max, int level)
|
|
{
|
|
const int levelMin = 60;
|
|
const int levelMax = 280;
|
|
|
|
//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);
|
|
|
|
/* LOG ("saber_test", "lvl = "+level+
|
|
"; \trank = "+round(rank, 2)+
|
|
"; \tdist = ("+round(min, 2)+", "+round(mid, 2)+", "+round(max, 2)+")"+
|
|
"; \trand ("+round(minRand, 2)+", "+round(maxRand, 2)+
|
|
") ; \tnum = "+round(randNum, 2)+"\t");
|
|
*/
|
|
return randNum;
|
|
}
|
|
|
|
float round(float num, int decimal)
|
|
{
|
|
return ((int)(num*(10^decimal)))/(float)(10^decimal);
|
|
}
|
|
|
|
void checkCreatures()
|
|
{
|
|
string[] creatureList = dataTableGetStringColumn(create.CREATURE_TABLE, "creatureName");
|
|
|
|
for (int i = 0; i < creatureList.length; i++)
|
|
{
|
|
dictionary creatureDict = dataTableGetRow(create.CREATURE_TABLE, creatureList[i]);
|
|
int level = creatureDict.getInt("BaseLevel");
|
|
int statLevel = creatureDict.getInt("StatLevelModifier");
|
|
int dmgLevel = creatureDict.getInt("Damagelevelmodifier");
|
|
|
|
int newStatLevel = bio_engineer.calcStatLevel(creatureDict);
|
|
int newDmgLevel = bio_engineer.calcDmgLevel(creatureDict);
|
|
int newToHitLevel = bio_engineer.calcToHitLevel(creatureDict);
|
|
int newArmorLevel = bio_engineer.calcArmorLevel(creatureDict);
|
|
|
|
int oldToHitLevel = bio_engineer.calcOldToHitLevel(creatureDict);
|
|
int oldArmorLevel = bio_engineer.calcOldArmorLevel(creatureDict);
|
|
|
|
int newLevel = (int) ((((newStatLevel*2) + (newDmgLevel*2) + (newToHitLevel*2) + (newArmorLevel*4)) / 10) + 0.5f);
|
|
int newLevelOldArmor = (int) ((((newStatLevel*2) + (newDmgLevel*2) + (newToHitLevel*2) + (oldArmorLevel*4)) / 10) + 0.5f);
|
|
|
|
int levelDiff = newLevel - level;
|
|
|
|
string output = "";
|
|
|
|
// Creature Name
|
|
if (levelDiff > 5 || levelDiff < -5)
|
|
output = "**\t" + creatureList[i] + " - \t";
|
|
else
|
|
output = "\t" + creatureList[i] + " - \t";
|
|
|
|
// Balanced Level
|
|
output += "newLevel(newArmor) = " + newLevel + "; \t";
|
|
output += "newLevel(oldArmor) = " + newLevelOldArmor + "; \t";
|
|
|
|
// Defined Level
|
|
output += "oldLevel = " + level + "; \t";
|
|
|
|
// Stat Level
|
|
output += "newStatLevel = " + newStatLevel + "; \t";
|
|
output += "oldStatLevel = " + (level + statLevel) + "; \t";
|
|
|
|
// Dmg Level
|
|
output += "newDmgLevel = " + newDmgLevel + "; \t";
|
|
output += "oldDmgLevel = " + (level + dmgLevel) + "; \t";
|
|
|
|
// ToHit Level
|
|
output += "newToHit = " + newToHitLevel + "; \t";
|
|
output += "oldToHit = " + oldToHitLevel + "; \t";
|
|
|
|
// Armor Level
|
|
output += "newArmor = " + newArmorLevel + "; \t";
|
|
output += "oldArmor = " + oldArmorLevel + "; \t";
|
|
|
|
LOG ("creature_balance", output);
|
|
}
|
|
|
|
}
|