private static void HandleEvadeOrDeflectBlasterFire()
{
DamageEventData data = NWNXDamage.GetDamageEventData();
if (data.Total <= 0)
{
return;
}
NWCreature damager = data.Damager.Object;
NWCreature target = _.OBJECT_SELF;
NWItem damagerWeapon = _.GetLastWeaponUsed(damager);
NWItem targetWeapon = target.RightHand;
int perkLevel;
// Attacker isn't using a pistol or rifle. Return.
if (damagerWeapon.CustomItemType != CustomItemType.BlasterPistol &&
damagerWeapon.CustomItemType != CustomItemType.BlasterRifle)
{
return;
}
int modifier;
string action;
// Check target's equipped weapon, armor and perk.
if (targetWeapon.CustomItemType == CustomItemType.MartialArtWeapon ||
(!target.RightHand.IsValid && !target.LeftHand.IsValid))
{
// Martial Arts (weapon or unarmed) uses the Evade Blaster Fire perk which is primarily DEX based.
perkLevel = PerkService.GetCreaturePerkLevel(target.Object, PerkType.EvadeBlasterFire);
modifier = target.DexterityModifier;
action = "evade";
}
else if (targetWeapon.CustomItemType == CustomItemType.Lightsaber ||
targetWeapon.CustomItemType == CustomItemType.Saberstaff ||
GetLocalBool(targetWeapon, "LIGHTSABER"))
{
// Lightsabers (lightsaber or saberstaff) uses the Deflect Blaster Fire perk which is primarily CHA based.
perkLevel = PerkService.GetCreaturePerkLevel(target.Object, PerkType.DeflectBlasterFire);
modifier = target.CharismaModifier;
action = "deflect";
}
else
{
return;
}
// Don't have the perk. Return.
if (perkLevel <= 0)
{
return;
}
// Check attacker's DEX against the primary stat of the perk.
int delta = modifier - damager.DexterityModifier;
if (delta <= 0)
{
return;
}
// Has the delay between block/evade attempts past?
DateTime cooldown = DateTime.UtcNow;
string lastAttemptVar = target.GetLocalString("EVADE_OR_DEFLECT_BLASTER_FIRE_COOLDOWN");
if (!string.IsNullOrWhiteSpace(lastAttemptVar))
{
cooldown = DateTime.Parse(lastAttemptVar);
}
// Cooldown hasn't expired yet. Not ready to attempt a deflect.
if (cooldown >= DateTime.UtcNow)
{
return;
}
// Ready to attempt a deflect. Adjust chance based on the delta of attacker DEX versus primary stat of defender.
int chanceToDeflect = 5 * delta;
if (chanceToDeflect > 80)
{
chanceToDeflect = 80;
}
int delay; // Seconds delay between deflect attempts.
switch (perkLevel)
{
case 1:
delay = 18;
break;
case 2:
delay = 12;
break;
case 3:
delay = 6;
break;
default: throw new Exception("HandleEvadeOrDeflectBlasterFire -> Perk Level " + perkLevel + " unsupported.");
}
cooldown = DateTime.UtcNow.AddSeconds(delay);
target.SetLocalString("EVADE_OR_DEFLECT_BLASTER_FIRE_COOLDOWN", cooldown.ToString(CultureInfo.InvariantCulture));
int roll = RandomService.D100(1);
if (roll <= chanceToDeflect)
{
target.SendMessage(ColorTokenService.Gray("You " + action + " a blaster shot."));
data.AdjustAllByPercent(-1);
NWNXDamage.SetDamageEventData(data);
}
else
{
target.SendMessage(ColorTokenService.Gray("You fail to " + action + " a blaster shot. (" + roll + " vs " + chanceToDeflect + ")"));
}
}
public static void OnChestOpen(NWPlaceable oChest)
{
NWPlayer oPC = (_.GetLastOpenedBy());
if (!oPC.IsPlayer)
{
return;
}
if (_.GetActionMode(oPC.Object, _.ACTION_MODE_STEALTH) == _.TRUE)
{
_.SetActionMode(oPC.Object, _.ACTION_MODE_STEALTH, _.FALSE);
}
string resref = oChest.Resref;
int chestID = oChest.GetLocalInt(SearchSiteIDVariableName);
int skillRank = _.GetSkillRank(_.SKILL_SEARCH, oPC.Object);
int numberOfSearches = (skillRank / ExtraSearchPerNumberLevels) + 1;
PCSearchSite searchEntity = DataService.SingleOrDefault <PCSearchSite>(x => x.PlayerID == oPC.GlobalID && x.SearchSiteID == chestID);
DateTime timeLock = DateTime.UtcNow;
if (numberOfSearches <= 0)
{
numberOfSearches = 1;
}
if (searchEntity != null)
{
timeLock = searchEntity.UnlockDateTime;
}
if (resref == SearchSiteCopyResref)
{
oChest.IsUseable = false;
}
QuestService.SpawnQuestItems(oChest, oPC);
if (timeLock < DateTime.UtcNow || searchEntity == null)
{
int dc = oChest.GetLocalInt(SearchSiteDCVariableName);
for (int search = 1; search <= numberOfSearches; search++)
{
RunSearchCycle(oPC, oChest, dc);
dc += RandomService.Random(3) + 1;
}
SaveChestInventory(oPC, oChest, false);
}
else
{
var searchItems = DataService.Where <PCSearchSiteItem>(x => x.PlayerID == oPC.GlobalID && x.SearchSiteID == searchEntity.SearchSiteID).ToList();
foreach (PCSearchSiteItem item in searchItems)
{
NWItem oItem = SerializationService.DeserializeItem(item.SearchItem, oChest);
// Prevent item duplication in containers
if (oItem.HasInventory)
{
foreach (NWItem containerItem in oItem.InventoryItems)
{
containerItem.Destroy();
}
}
}
}
}
/// <summary>
/// Calculates ability resistance for an ability.
/// The attacker and defender's skills, ability modifiers, and balance affinity will be
/// used to make this determination.
/// </summary>
/// <param name="attacker">The creature using the ability.</param>
/// <param name="defender">The creature being targeted by the ability.</param>
/// <param name="skill">The skill used for this ability.</param>
/// <param name="balanceType">The force balance type to use for this ability.</param>
/// <param name="sendRollMessage">If true, the roll message will be sent. Otherwise it won't be.</param>
/// <returns>Data regarding the ability resistance roll</returns>
public static AbilityResistanceResult CalculateAbilityResistance(NWCreature attacker, NWCreature defender, SkillType skill, ForceBalanceType balanceType, bool sendRollMessage = true)
{
AbilityType abilityScoreType;
switch (skill)
{
case SkillType.ForceAlter:
abilityScoreType = AbilityType.Intelligence;
break;
case SkillType.ForceControl:
abilityScoreType = AbilityType.Wisdom;
break;
case SkillType.ForceSense:
abilityScoreType = AbilityType.Charisma;
break;
default:
throw new ArgumentException("Invalid skill type called for " + nameof(CalculateAbilityResistance) + ", value '" + skill + "' not supported.");
}
AbilityResistanceResult result = new AbilityResistanceResult();
int attackerSkill = SkillService.GetPCSkillRank(attacker.Object, skill);
int attackerAbility = _.GetAbilityModifier(abilityScoreType, attacker);
int defenderSkill = SkillService.GetPCSkillRank(defender.Object, skill);
int defenderAbility = _.GetAbilityModifier(abilityScoreType, defender);
// If the defender is equipped with a lightsaber, we check their lightsaber skill
if (defender.RightHand.CustomItemType == CustomItemType.Lightsaber ||
defender.LeftHand.CustomItemType == CustomItemType.Lightsaber)
{
int lightsaberSkill = SkillService.GetPCSkillRank(defender.Object, SkillType.Lightsaber);
if (lightsaberSkill > defenderSkill)
{
defenderSkill = lightsaberSkill;
}
}
// If the defender's martial arts skill is greater than the current skill they're using, we'll use that instead.
int defenderMASkill = SkillService.GetPCSkillRank(defender.Object, SkillType.MartialArts);
if (defenderMASkill > defenderSkill)
{
defenderSkill = defenderMASkill;
}
int attackerAffinity = 0;
int defenderAffinity = 0;
// Only check affinity if ability has a force balance type.
if (balanceType == ForceBalanceType.Dark || balanceType == ForceBalanceType.Light)
{
attackerAffinity = GetBalanceAffinity(attacker.Object, balanceType);
defenderAffinity = GetBalanceAffinity(defender.Object, balanceType);
}
float attackerCR = attacker.IsPlayer ? 0f : attacker.ChallengeRating * 5f;
float defenderCR = defender.IsPlayer ? 0f : defender.ChallengeRating * 5f;
float attackerTotal = attackerSkill + attackerAbility + attackerAffinity + attackerCR;
float defenderTotal = defenderSkill + defenderAbility + defenderAffinity + defenderCR;
float divisor = attackerTotal + defenderTotal + 1; // +1 to prevent division by zero.
//Console.WriteLine("attackerCR = " + attackerCR);
//Console.WriteLine("defenderCR = " + defenderCR);
//Console.WriteLine("attackerSkill = " + attackerSkill);
//Console.WriteLine("attackerAbility = " + attackerAbility);
//Console.WriteLine("attackerAffinity = " + attackerAffinity);
//Console.WriteLine("defenderSkill = " + defenderSkill);
//Console.WriteLine("defenderAbility = " + defenderAbility);
//Console.WriteLine("defenderAffinity = " + defenderAffinity);
//Console.WriteLine("attackerTotal = " + attackerTotal);
//Console.WriteLine("defenderTotal = " + defenderTotal);
//Console.WriteLine("divisor = " + divisor);
result.DC = (int)(defenderTotal / divisor * 100);
result.Roll = RandomService.D100(1);
if (sendRollMessage)
{
string resisted = result.IsResisted ? ColorTokenService.Red(" [RESISTED " + Math.Abs(result.Delta) + "%]") : string.Empty;
string message = ColorTokenService.SavingThrow("Roll: " + result.Roll + " VS " + result.DC + " DC") + resisted;
attacker.SendMessage(message);
defender.SendMessage(message);
}
return(result);
}
public static string TranslateSnippetForListener(NWObject speaker, NWObject listener, SkillType language, string snippet)
{
Dictionary <SkillType, Type> map = new Dictionary <SkillType, Type>
{
{ SkillType.Bothese, typeof(TranslatorBothese) },
{ SkillType.Catharese, typeof(TranslatorCatharese) },
{ SkillType.Cheunh, typeof(TranslatorCheunh) },
{ SkillType.Dosh, typeof(TranslatorDosh) },
{ SkillType.Droidspeak, typeof(TranslatorDroidspeak) },
{ SkillType.Huttese, typeof(TranslatorHuttese) },
{ SkillType.Mandoa, typeof(TranslatorMandoa) },
{ SkillType.Shyriiwook, typeof(TranslatorShyriiwook) },
{ SkillType.Twileki, typeof(TranslatorTwileki) },
{ SkillType.Zabraki, typeof(TranslatorZabraki) },
{ SkillType.Mirialan, typeof(TranslatorMirialan) },
{ SkillType.MonCalamarian, typeof(TranslatorMonCalamarian) },
{ SkillType.Ugnaught, typeof(TranslatorUgnaught) },
{ SkillType.Togruti, typeof(TranslatorTogruti) },
{ SkillType.Rodese, typeof(TranslatorRodese) },
{ SkillType.KelDor, typeof(TranslatorKelDor) }
};
Type type = typeof(TranslatorGeneric);
map.TryGetValue(language, out type);
ITranslator translator = (ITranslator)Activator.CreateInstance(type);
if (speaker.IsPC && !speaker.IsDM)
{
// Get the rank and max rank for the speaker, and garble their English text based on it.
NWPlayer speakerAsPlayer = speaker.Object;
int speakerSkillRank = SkillService.GetPCSkillRank(speakerAsPlayer, language);
int speakerSkillMaxRank = SkillService.GetSkill(language).MaxRank;
if (speakerSkillRank != speakerSkillMaxRank)
{
int garbledChance = 100 - (int)(((float)speakerSkillRank / (float)speakerSkillMaxRank) * 100);
string[] split = snippet.Split(' ');
for (int i = 0; i < split.Length; ++i)
{
if (RandomService.Random(100) <= garbledChance)
{
split[i] = new string(split[i].ToCharArray().OrderBy(s => (RandomService.Random(2) % 2) == 0).ToArray());
}
}
snippet = split.Aggregate((a, b) => a + " " + b);
}
}
if (!listener.IsPC || listener.IsDM)
{
// Short circuit for a DM or NPC - they will always understand the text.
return(snippet);
}
// Let's grab the max rank for the listener skill, and then we roll for a successful translate based on that.
NWPlayer listenerAsPlayer = listener.Object;
int rank = SkillService.GetPCSkillRank(listenerAsPlayer, language);
int maxRank = SkillService.GetSkill(language).MaxRank;
// Check for the Comprehend Speech concentration ability.
Player dbPlayer = DataService.Player.GetByID(listenerAsPlayer.GlobalID);
bool grantSenseXP = false;
if (dbPlayer.ActiveConcentrationPerkID == (int)PerkType.ComprehendSpeech)
{
int bonus = 5 * dbPlayer.ActiveConcentrationTier;
rank += bonus;
grantSenseXP = true;
}
// Ensure we don't go over the maximum.
if (rank > maxRank)
{
rank = maxRank;
}
if (rank == maxRank || speaker == listener)
{
// Guaranteed success - return original.
return(snippet);
}
string textAsForeignLanguage = translator.Translate(snippet);
if (rank != 0)
{
int englishChance = (int)(((float)rank / (float)maxRank) * 100);
string[] originalSplit = snippet.Split(' ');
string[] foreignSplit = textAsForeignLanguage.Split(' ');
StringBuilder endResult = new StringBuilder();
// WARNING: We're making the assumption that originalSplit.Length == foreignSplit.Length.
// If this assumption changes, the below logic needs to change too.
for (int i = 0; i < originalSplit.Length; ++i)
{
if (RandomService.Random(100) <= englishChance)
{
endResult.Append(originalSplit[i]);
}
else
{
endResult.Append(foreignSplit[i]);
}
endResult.Append(" ");
}
textAsForeignLanguage = endResult.ToString();
}
long now = DateTime.Now.Ticks;
int lastSkillUpLow = listenerAsPlayer.GetLocalInt("LAST_LANGUAGE_SKILL_INCREASE_LOW");
int lastSkillUpHigh = listenerAsPlayer.GetLocalInt("LAST_LANGUAGE_SKILL_INCREASE_HIGH");
long lastSkillUp = lastSkillUpHigh;
lastSkillUp = (lastSkillUp << 32) | (uint)lastSkillUpLow;
long differenceInSeconds = (now - lastSkillUp) / 10000000;
if (differenceInSeconds / 60 >= 2)
{
int amount = Math.Max(10, Math.Min(150, snippet.Length) / 3);
// Reward exp towards the language - we scale this with character count, maxing at 50 exp for 150 characters.
SkillService.GiveSkillXP(listenerAsPlayer, language, amount);
// Grant Sense XP if player is concentrating Comprehend Speech.
if (grantSenseXP)
{
SkillService.GiveSkillXP(listenerAsPlayer, SkillType.ForceSense, amount * 10);
}
listenerAsPlayer.SetLocalInt("LAST_LANGUAGE_SKILL_INCREASE_LOW", (int)(now & 0xFFFFFFFF));
listenerAsPlayer.SetLocalInt("LAST_LANGUAGE_SKILL_INCREASE_HIGH", (int)((now >> 32) & 0xFFFFFFFF));
}
return(textAsForeignLanguage);
}
private static void InitializeAreaSpawns(NWArea area)
{
var areaSpawn = new AreaSpawn();
// Check for manually placed spawns
NWObject obj = GetFirstObjectInArea(area.Object);
while (obj.IsValid)
{
bool isSpawn = obj.ObjectType == ObjectType.Waypoint && obj.GetLocalBool("IS_SPAWN") == true;
if (isSpawn)
{
var spawnType = (ObjectType)obj.GetLocalInt("SPAWN_TYPE");
var objectType = spawnType == 0 || spawnType == ObjectType.Creature ? ObjectType.Creature : spawnType;
int spawnTableID = obj.GetLocalInt("SPAWN_TABLE_ID");
int npcGroupID = obj.GetLocalInt("SPAWN_NPC_GROUP_ID");
string behaviourScript = obj.GetLocalString("SPAWN_BEHAVIOUR_SCRIPT");
if (string.IsNullOrWhiteSpace(behaviourScript))
{
behaviourScript = obj.GetLocalString("SPAWN_BEHAVIOUR");
}
string spawnResref = obj.GetLocalString("SPAWN_RESREF");
float respawnTime = obj.GetLocalFloat("SPAWN_RESPAWN_SECONDS");
string spawnRule = obj.GetLocalString("SPAWN_RULE");
int deathVFXID = obj.GetLocalInt("SPAWN_DEATH_VFX");
AIFlags aiFlags = (AIFlags)obj.GetLocalInt("SPAWN_AI_FLAGS");
bool useResref = true;
// No resref specified but a table was, look in the database for a random record.
if (string.IsNullOrWhiteSpace(spawnResref) && spawnTableID > 0)
{
// Pick a random record.
var spawnObjects = DataService.SpawnObject.GetAllBySpawnTableID(spawnTableID).ToList();
int count = spawnObjects.Count;
int index = count <= 0 ? 0 : RandomService.Random(count);
var dbSpawn = spawnObjects[index];
if (dbSpawn != null)
{
spawnResref = dbSpawn.Resref;
useResref = false;
if (dbSpawn.NPCGroupID != null && dbSpawn.NPCGroupID > 0)
{
npcGroupID = Convert.ToInt32(dbSpawn.NPCGroupID);
}
if (!string.IsNullOrWhiteSpace(dbSpawn.BehaviourScript))
{
behaviourScript = dbSpawn.BehaviourScript;
}
if (!string.IsNullOrWhiteSpace(dbSpawn.SpawnRule))
{
spawnRule = dbSpawn.SpawnRule;
}
if (deathVFXID <= 0)
{
deathVFXID = dbSpawn.DeathVFXID;
}
if (aiFlags == AIFlags.None)
{
aiFlags = dbSpawn.AIFlags;
}
}
}
// If we found a resref, spawn the object and add it to the cache.
if (!string.IsNullOrWhiteSpace(spawnResref))
{
// Delay the creation so that the iteration through the area doesn't get thrown off by new entries.
Location location = obj.Location;
bool isInstance = area.IsInstance;
ObjectSpawn newSpawn;
if (useResref)
{
newSpawn = new ObjectSpawn(location, true, spawnResref, respawnTime);
}
else
{
newSpawn = new ObjectSpawn(location, true, spawnTableID, respawnTime);
}
if (npcGroupID > 0)
{
newSpawn.NPCGroupID = npcGroupID;
}
if (deathVFXID > 0)
{
newSpawn.DeathVFXID = deathVFXID;
}
if (!string.IsNullOrWhiteSpace(behaviourScript))
{
newSpawn.BehaviourScript = behaviourScript;
}
if (!string.IsNullOrWhiteSpace(spawnRule))
{
newSpawn.SpawnRule = spawnRule;
}
if (aiFlags == AIFlags.None)
{
newSpawn.AIFlags = aiFlags;
}
// Instance spawns are one-shot.
if (isInstance)
{
newSpawn.Respawns = false;
}
if (objectType == ObjectType.Creature)
{
areaSpawn.Creatures.Add(newSpawn);
}
else if (objectType == ObjectType.Placeable)
{
areaSpawn.Placeables.Add(newSpawn);
}
}
}
obj = GetNextObjectInArea(area.Object);
}
AreaSpawns.Add(area, areaSpawn);
DelayCommand(1.0f, () =>
{
SpawnResources(area, areaSpawn);
});
}
private static void SpawnResources(NWArea area, AreaSpawn areaSpawn)
{
var dbArea = DataService.Area.GetByResref(area.Resref);
if (dbArea.ResourceSpawnTableID <= 0 ||
!dbArea.AutoSpawnResources)
{
return;
}
var possibleSpawns = DataService.SpawnObject.GetAllBySpawnTableID(dbArea.ResourceSpawnTableID).ToList();
// 1024 size = 32x32
// 256 size = 16x16
// 64 size = 8x8
int size = area.Width * area.Height;
int maxSpawns = 0;
if (size <= 12)
{
maxSpawns = 2;
}
else if (size <= 32)
{
maxSpawns = 6;
}
else if (size <= 64)
{
maxSpawns = 10;
}
else if (size <= 256)
{
maxSpawns = 25;
}
else if (size <= 512)
{
maxSpawns = 40;
}
else if (size <= 1024)
{
maxSpawns = 50;
}
int[] weights = new int[possibleSpawns.Count()];
for (int x = 0; x < possibleSpawns.Count(); x++)
{
weights[x] = possibleSpawns.ElementAt(x).Weight;
}
for (int x = 1; x <= maxSpawns; x++)
{
int index = RandomService.GetRandomWeightedIndex(weights);
var dbSpawn = possibleSpawns.ElementAt(index);
Location location = GetRandomSpawnPoint(area);
NWPlaceable plc = (CreateObject(ObjectType.Placeable, dbSpawn.Resref, location));
ObjectSpawn spawn = new ObjectSpawn(location, false, dbArea.ResourceSpawnTableID, 600.0f);
spawn.Spawn = plc;
ObjectVisibilityService.ApplyVisibilityForObject(plc);
if (dbSpawn.NPCGroupID != null && dbSpawn.NPCGroupID > 0)
{
plc.SetLocalInt("NPC_GROUP", Convert.ToInt32(dbSpawn.NPCGroupID));
spawn.NPCGroupID = Convert.ToInt32(dbSpawn.NPCGroupID);
}
if (!string.IsNullOrWhiteSpace(dbSpawn.BehaviourScript) &&
string.IsNullOrWhiteSpace(plc.GetLocalString("BEHAVIOUR")))
{
plc.SetLocalString("BEHAVIOUR", dbSpawn.BehaviourScript);
spawn.BehaviourScript = dbSpawn.BehaviourScript;
}
if (!string.IsNullOrWhiteSpace(dbSpawn.SpawnRule))
{
var rule = GetSpawnRule(dbSpawn.SpawnRule);
rule.Run(plc);
}
areaSpawn.Placeables.Add(spawn);
}
}
public static void HandlePlasmaCellPerk(NWPlayer player, NWObject target)
{
if (!player.IsPlayer)
{
return;
}
if (!_.GetHasFeat(Feat.PlasmaCell, player))
{
return; // Check if player has the perk
}
if (player.RightHand.CustomItemType != CustomItemType.BlasterPistol &&
player.RightHand.CustomItemType != CustomItemType.BlasterRifle)
{
return; // Check if player has the right weapons
}
if (GetLocalBool(target, "TRANQUILIZER_EFFECT_FIRST_RUN") == true)
{
return; // Check if Tranquilizer is on to avoid conflict
}
if (GetLocalBool(player, "PLASMA_CELL_TOGGLE_OFF") == true)
{
return; // Check if Plasma Cell toggle is on or off
}
if (GetLocalBool(target, "TRANQUILIZER_EFFECT_FIRST_RUN") == true)
{
return;
}
int perkLevel = PerkService.GetCreaturePerkLevel(player, PerkType.PlasmaCell);
int chance;
CustomEffectType[] damageTypes;
switch (perkLevel)
{
case 1:
chance = 10;
damageTypes = new[] { CustomEffectType.FireCell };
break;
case 2:
chance = 10;
damageTypes = new[] { CustomEffectType.FireCell, CustomEffectType.ElectricCell };
break;
case 3:
chance = 20;
damageTypes = new[] { CustomEffectType.FireCell, CustomEffectType.ElectricCell };
break;
case 4:
chance = 20;
damageTypes = new[] { CustomEffectType.FireCell, CustomEffectType.ElectricCell, CustomEffectType.SonicCell };
break;
case 5:
chance = 30;
damageTypes = new[] { CustomEffectType.FireCell, CustomEffectType.ElectricCell, CustomEffectType.SonicCell };
break;
case 6:
chance = 30;
damageTypes = new[] { CustomEffectType.FireCell, CustomEffectType.ElectricCell, CustomEffectType.SonicCell, CustomEffectType.AcidCell };
break;
case 7:
chance = 40;
damageTypes = new[] { CustomEffectType.FireCell, CustomEffectType.ElectricCell, CustomEffectType.SonicCell, CustomEffectType.AcidCell };
break;
case 8:
chance = 40;
damageTypes = new[] { CustomEffectType.FireCell, CustomEffectType.ElectricCell, CustomEffectType.SonicCell, CustomEffectType.AcidCell, CustomEffectType.IceCell };
break;
case 9:
chance = 50;
damageTypes = new[] { CustomEffectType.FireCell, CustomEffectType.ElectricCell, CustomEffectType.SonicCell, CustomEffectType.AcidCell, CustomEffectType.IceCell };
break;
case 10:
chance = 50;
damageTypes = new[] { CustomEffectType.FireCell, CustomEffectType.ElectricCell, CustomEffectType.SonicCell, CustomEffectType.AcidCell, CustomEffectType.IceCell, CustomEffectType.DivineCell };
break;
default: return;
}
foreach (var effect in damageTypes)
{
if (RandomService.D100(1) <= chance)
{
CustomEffectService.ApplyCustomEffect(player, target.Object, effect, RandomService.D6(1), perkLevel, null);
}
}
}
public static Tuple <ItemProperty, int> GetRandomComponentBonusIP(ResourceQuality quality)
{
string[] normalIP =
{
"compbon_arm1", // Armorsmith 1
"compbon_cspd1", // Cooldown Recovery 1
"compbon_charges1", // Charges 1
//"compbon_cooking1", // Cooking 1
"compbon_dmg1", // Damage 1
"compbon_eng1", // Engineering 1
"compbon_enmdown1", // Enmity Down 1
"compbon_harv1", // Harvesting 1
"compbon_wpn1", // Weaponsmith 1
"compbon_hp2", // Hit Points 2
"compbon_fp2", // Force Points 2
"compbon_enmup1", // Enmity Up 1
"compbon_med1", // Meditate 1
"compbon_faid1", // Medicine 1
"compbon_fab1", // Fabrication 1
"compbon_scanup1", // Scanning 1
"compbon_rest1", // Rest 1
"compbon_ab1" // Attack Bonus 1
};
string[] highIP =
{
"compbon_arm2", // Armorsmith 2
"compbon_cspd2", // Cooldown Recovery 2
"compbon_charges2", // Charges 2
//"compbon_cooking2", // Cooking 2
"compbon_dmg2", // Damage 2
"compbon_eng2", // Engineering 2
"compbon_enmdown2", // Enmity Down 2
"compbon_harv2", // Harvesting 2
"compbon_wpn2", // Weaponsmith 2
"compbon_hp4", // Hit Points 4
"compbon_fp4", // Force Points 4
"compbon_enmup2", // Enmity Up 2
"compbon_luck1", // Luck 1
"compbon_med2", // Meditate 2
"compbon_faid2", // Medicine 2
"compbon_hpregen1", // HP Regen 1
"compbon_fpregen1", // FP Regen 1
"compbon_snkatk1", // Sneak Attack 1
"compbon_fab2", // Fabrication 2
"compbon_scanup2", // Scanning 2
"compbon_rest2", // Rest 2
"compbon_str1", // Strength 1
"compbon_dex1", // Dexterity 1
"compbon_con1", // Constitution 1
"compbon_wis1", // Wisdom 1
"compbon_int1", // Intelligence 1
"compbon_cha1", // Charisma 1
"compbon_ab2", // Attack Bonus 2
"compbon_scavup1" // Scavenging 1
};
string[] veryHighIP =
{
"compbon_arm3", // Armorsmith 3
"compbon_cspd3", // Cooldown Recovery 3
//"compbon_cooking3", // Cooking 3
"compbon_charges3", // Charges 3
"compbon_dmg3", // Damage 3
"compbon_eng3", // Engineering 3
"compbon_enmdown3", // Enmity Down 3
"compbon_harv3", // Harvesting 3
"compbon_wpn3", // Weaponsmith 3
"compbon_hp6", // Hit Points 6
"compbon_fp6", // Force Points 6
"compbon_enmup3", // Enmity Up 3
"compbon_luck2", // Luck 2
"compbon_med3", // Meditate 3
"compbon_faid3", // Medicine 3
"compbon_hpregen2", // HP Regen 2
"compbon_fpregen2", // FP Regen 2
"compbon_snkatk2", // Sneak Attack 2
"compbon_fab3", // Fabrication 3
"compbon_scanup3", // Scanning 3
"compbon_rest3", // Rest 3
"compbon_str2", // Strength 2
"compbon_dex2", // Dexterity 2
"compbon_con2", // Constitution 2
"compbon_wis2", // Wisdom 2
"compbon_int2", // Intelligence 2
"compbon_cha2", // Charisma 2
"compbon_ab3", // Attack Bonus 3
"compbon_scavup2" // Scavenging 2
};
string[] setToUse;
switch (quality)
{
case ResourceQuality.Low:
case ResourceQuality.Normal:
setToUse = normalIP;
break;
case ResourceQuality.High:
setToUse = highIP;
break;
case ResourceQuality.VeryHigh:
setToUse = veryHighIP;
break;
default:
throw new ArgumentOutOfRangeException(nameof(quality), quality, null);
}
int index = RandomService.Random(0, setToUse.Length - 1);
string itemTag = setToUse[index];
return(new Tuple <ItemProperty, int>(ItemService.GetCustomItemPropertyByItemTag(itemTag), Colorize(itemTag)));
}
