public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
NWArea area = user.Area;
NWPlayer player = new NWPlayer(user);
string structureID = area.GetLocalString("PC_BASE_STRUCTURE_ID");
Guid structureGuid = new Guid(structureID);
PCBaseStructure pcbs = DataService.PCBaseStructure.GetByID(structureGuid);
BaseStructure structure = DataService.BaseStructure.GetByID(pcbs.BaseStructureID);
int repair = SkillService.GetPCSkillRank(player, SkillType.Piloting);
int maxRepair = (int)structure.Durability - (int)pcbs.Durability;
if (maxRepair < repair)
{
repair = maxRepair;
}
// TODO - add perks to make repairing faster/better/shinier/etc.
// Maybe a perk to allow repairing in space, with ground repairs only otherwise?
NWCreature ship = area.GetLocalObject("CREATURE");
if (ship.IsValid)
{
ship.SetLocalInt("HP", ship.GetLocalInt("HP") + repair);
ship.FloatingText("Hull repaired: " + ship.GetLocalInt("HP") + "/" + ship.MaxHP);
}
pcbs.Durability += repair;
DataService.SubmitDataChange(pcbs, DatabaseActionType.Update);
player.SendMessage("Ship repaired for " + repair + " points. (Hull points: " + pcbs.Durability + "/" + structure.Durability + ")");
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
CustomEffectService.RemovePCCustomEffect(target.Object, CustomEffectType.Poison);
foreach (Effect effect in target.Effects)
{
if (_.GetIsEffectValid(effect) == true)
{
var effectType = _.GetEffectType(effect);
if (effectType == EffectTypeScript.Poison || effectType == EffectTypeScript.Disease || effectType == EffectTypeScript.AbilityDecrease)
{
_.RemoveEffect(target.Object, effect);
}
}
}
user.SendMessage("You successfully treat " + target.Name + "'s infection.");
int rank = SkillService.GetPCSkillRank(user.Object, SkillType.Medicine);
if (target.IsPlayer)
{
int xp = (int)SkillService.CalculateRegisteredSkillLevelAdjustedXP(300, item.RecommendedLevel, rank);
SkillService.GiveSkillXP(user.Object, SkillType.Medicine, xp);
}
}
private void HandleBlueprintListPageResponse(int responseID)
{
DialogResponse response = GetResponseByID("BlueprintListPage", responseID);
int blueprintID = (int)response.CustomData;
if (blueprintID == -1)
{
ChangePage("CraftCategoriesPage");
return;
}
var model = CraftService.GetPlayerCraftingData(GetPC());
model.Blueprint = CraftService.GetBlueprintByID(blueprintID);
model.BlueprintID = blueprintID;
model.PlayerSkillRank = SkillService.GetPCSkillRank(GetPC(), model.Blueprint.SkillID);
model.MainMinimum = model.Blueprint.MainMinimum;
model.MainMaximum = model.Blueprint.MainMaximum;
model.SecondaryMinimum = model.Blueprint.SecondaryMinimum;
model.SecondaryMaximum = model.Blueprint.SecondaryMaximum;
model.TertiaryMinimum = model.Blueprint.TertiaryMinimum;
model.TertiaryMaximum = model.Blueprint.TertiaryMaximum;
string header = CraftService.BuildBlueprintHeader(GetPC(), blueprintID, false);
SetPageHeader("BlueprintDetailsPage", header);
ChangePage("BlueprintDetailsPage");
}
public string IsValidTarget(NWCreature user, NWItem item, NWObject target, Location targetLocation)
{
if (!target.IsValid)
{
return("Please select a target to harvest.");
}
int qualityID = target.GetLocalInt("RESOURCE_QUALITY");
if (qualityID <= 0)
{
return("You cannot harvest that object.");
}
NWPlayer player = (user.Object);
ResourceQuality quality = (ResourceQuality)qualityID;
int tier = target.GetLocalInt("RESOURCE_TIER");
int rank = SkillService.GetPCSkillRank(player, SkillType.Harvesting);
int difficulty = (tier - 1) * 10 + ResourceService.GetDifficultyAdjustment(quality);
int delta = difficulty - rank;
if (delta >= 5)
{
return("Your Harvesting skill rank is too low to harvest this resource.");
}
return(null);
}
public void OnImpact(NWPlayer player, NWObject target, int perkLevel, int spellFeatID)
{
var spread = CustomEffectService.GetForceSpreadDetails(player);
int skillRank = SkillService.GetPCSkillRank(player, SkillType.ForceSupport);
if (spread.Level <= 0)
{
HealTarget(player, target, perkLevel, skillRank, (CustomFeatType)spellFeatID);
}
else
{
var members = player.PartyMembers.Where(x => _.GetDistanceBetween(x, target) <= spread.Range ||
Equals(x, target));
spread.Uses--;
foreach (var member in members)
{
HealTarget(player, member, perkLevel, skillRank, (CustomFeatType)spellFeatID);
}
CustomEffectService.SetForceSpreadUses(player, spread.Uses);
SkillService.RegisterPCToAllCombatTargetsForSkill(player, SkillType.ForceUtility, null);
}
_.PlaySound("v_imp_heal");
SkillService.RegisterPCToAllCombatTargetsForSkill(player, SkillType.ForceSupport, target.Object);
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
NWPlayer player = user.Object;
var ability = (AbilityType)item.GetLocalInt("ABILITY_TYPE");
int amount = item.GetLocalInt("AMOUNT") + (item.MedicineBonus * 2);
int rank = player.IsPlayer ? SkillService.GetPCSkillRank(player, SkillType.Medicine) : 0;
int recommendedLevel = item.RecommendedLevel;
float duration = 30.0f * (rank / 10);
int perkLevel = player.IsPlayer ? PerkService.GetCreaturePerkLevel(player, PerkType.StimFiend) : 0;
float percentIncrease = perkLevel * 0.25f;
duration = duration + (duration * percentIncrease);
Effect effect = _.EffectAbilityIncrease(ability, amount);
effect = _.TagEffect(effect, "STIM_PACK_EFFECT");
_.ApplyEffectToObject(DurationType.Temporary, effect, target, duration);
user.SendMessage("You inject " + target.Name + " with a stim pack. The stim pack will expire in " + duration + " seconds.");
_.DelayCommand(duration + 0.5f, () => { player.SendMessage("The stim pack that you applied to " + target.Name + " has expired."); });
if (!Equals(user, target))
{
NWCreature targetCreature = target.Object;
targetCreature.SendMessage(user.Name + " injects you with a stim pack.");
}
int xp = (int)SkillService.CalculateRegisteredSkillLevelAdjustedXP(300, item.RecommendedLevel, rank);
SkillService.GiveSkillXP(player, SkillType.Medicine, xp);
}
private bool CheckValidity(NWPlaceable forge, NWPlayer pc, NWItem item)
{
if (pc.IsBusy)
{
ReturnItemToPC(pc, item, "You are too busy.");
return(false);
}
if (_.GetIsObjectValid(forge.GetLocalObject("FORGE_USER")) == _.TRUE)
{
ReturnItemToPC(pc, item, "This forge is currently in use. Please wait...");
return(false);
}
string[] allowed =
{
"power_core",
"raw_veldite",
"raw_scordspar",
"raw_plagionite",
"raw_keromber",
"raw_jasioclase",
"raw_hemorgite",
"raw_ochne",
"raw_croknor",
"raw_arkoxit",
"raw_bisteiss"
};
if (!allowed.Contains(item.Resref))
{
ReturnItemToPC(pc, item, "Only power cores and raw materials may be placed inside.");
return(false);
}
int level = CraftService.GetIngotLevel(item.Resref);
int rank = SkillService.GetPCSkillRank(pc, SkillType.Harvesting);
int delta = rank - level;
if (delta <= -4)
{
ReturnItemToPC(pc, item, "You do not have enough skill to refine this material.");
return(false);
}
int pcPerkLevel = PerkService.GetCreaturePerkLevel(pc, PerkType.Refining);
int orePerkLevel = CraftService.GetIngotPerkLevel(item.Resref);
if (pcPerkLevel < orePerkLevel)
{
ReturnItemToPC(pc, item, "You do not have the perk necessary to refine this material.");
return(false);
}
return(true);
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
NWPlayer player = (user.Object);
var effectiveStats = PlayerStatService.GetPlayerItemEffectiveStats(player);
target.RemoveEffect(EFFECT_TYPE_REGENERATE);
int rank = SkillService.GetPCSkillRank(player, SkillType.Medicine);
int luck = PerkService.GetPCPerkLevel(player, PerkType.Lucky);
int perkDurationBonus = PerkService.GetPCPerkLevel(player, PerkType.HealingKitExpert) * 6 + (luck * 2);
float duration = 30.0f + (rank * 0.4f) + perkDurationBonus;
int restoreAmount = 1 + item.GetLocalInt("HEALING_BONUS") + effectiveStats.Medicine + item.MedicineBonus;
int delta = item.RecommendedLevel - rank;
float effectivenessPercent = 1.0f;
if (delta > 0)
{
effectivenessPercent = effectivenessPercent - (delta * 0.1f);
}
restoreAmount = (int)(restoreAmount * effectivenessPercent);
int perkBlastBonus = PerkService.GetPCPerkLevel(player, PerkType.ImmediateImprovement);
if (perkBlastBonus > 0)
{
int blastHeal = restoreAmount * perkBlastBonus;
if (RandomService.Random(100) + 1 <= luck / 2)
{
blastHeal *= 2;
}
_.ApplyEffectToObject(DURATION_TYPE_INSTANT, _.EffectHeal(blastHeal), target.Object);
}
float interval = 6.0f;
BackgroundType background = (BackgroundType)player.Class1;
if (background == BackgroundType.Medic)
{
interval *= 0.5f;
}
_.PlaySound("use_bacta");
Effect regeneration = _.EffectRegenerate(restoreAmount, interval);
_.ApplyEffectToObject(DURATION_TYPE_TEMPORARY, regeneration, target.Object, duration);
player.SendMessage("You successfully treat " + target.Name + "'s wounds. The healing kit will expire in " + duration + " seconds.");
_.DelayCommand(duration + 0.5f, () => { player.SendMessage("The healing kit that you applied to " + target.Name + " has expired."); });
if (target.IsPlayer)
{
int xp = (int)SkillService.CalculateRegisteredSkillLevelAdjustedXP(300, item.RecommendedLevel, rank);
SkillService.GiveSkillXP(player, SkillType.Medicine, xp);
}
}
public float Seconds(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
if (RandomService.Random(100) + 1 <= PerkService.GetPCPerkLevel((NWPlayer)user, PerkType.SpeedyFirstAid) * 10)
{
return(0.1f);
}
int rank = SkillService.GetPCSkillRank((NWPlayer)user, SkillType.Medicine);
return(12.0f - (rank * 0.1f));
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
NWPlayer player = (user.Object);
var effectiveStats = PlayerStatService.GetPlayerItemEffectiveStats(player);
int rank = SkillService.GetPCSkillRank(player, SkillType.Medicine);
int luck = PerkService.GetCreaturePerkLevel(player, PerkType.Lucky);
int perkDurationBonus = PerkService.GetCreaturePerkLevel(player, PerkType.HealingKitExpert) * 6 + (luck * 2);
float duration = 30.0f + (rank * 0.4f) + perkDurationBonus + effectiveStats.Medicine;
int restoreAmount = 1 + item.GetLocalInt("HEALING_BONUS") + (rank / 10);
int delta = item.RecommendedLevel - rank;
float effectivenessPercent = 1.0f;
if (delta > 0)
{
effectivenessPercent = effectivenessPercent - (delta * 0.1f);
}
restoreAmount = (int)(restoreAmount * effectivenessPercent) + item.MedicineBonus;
int perkBlastBonus = PerkService.GetCreaturePerkLevel(player, PerkType.ImmediateForcePack);
if (perkBlastBonus > 0)
{
int blastHeal = restoreAmount * perkBlastBonus;
if (RandomService.Random(100) + 1 <= luck / 2)
{
blastHeal *= 2;
}
AbilityService.RestorePlayerFP(target.Object, blastHeal);
}
float interval = 6.0f;
BackgroundType background = (BackgroundType)player.Class1;
if (background == BackgroundType.Medic)
{
interval *= 0.5f;
}
string data = (int)interval + ", " + restoreAmount;
CustomEffectService.ApplyCustomEffect(user, target.Object, CustomEffectType.ForcePack, (int)duration, restoreAmount, data);
player.SendMessage("You successfully apply a force pack to " + target.Name + ". The force pack will expire in " + duration + " seconds.");
_.DelayCommand(duration + 0.5f, () => { player.SendMessage("The force pack that you applied to " + target.Name + " has expired."); });
int xp = (int)SkillService.CalculateRegisteredSkillLevelAdjustedXP(300, item.RecommendedLevel, rank);
SkillService.GiveSkillXP(player, SkillType.Medicine, xp);
}
public float Seconds(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
NWPlayer player = (user.Object);
var effectiveStats = PlayerStatService.GetPlayerItemEffectiveStats(player);
if (RandomService.Random(100) + 1 <= PerkService.GetCreaturePerkLevel(player, PerkType.SpeedyFirstAid) * 10)
{
return(0.1f);
}
int rank = SkillService.GetPCSkillRank(player, SkillType.Medicine);
return(12.0f - (rank + effectiveStats.Medicine / 2) * 0.1f);
}
public float Seconds(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
if (RandomService.Random(100) + 1 <= PerkService.GetCreaturePerkLevel(user.Object, PerkType.SpeedyFirstAid) * 10)
{
return(0.1f);
}
int rank = SkillService.GetPCSkillRank(user.Object, SkillType.Medicine);
float seconds = 6.0f - (rank * 0.2f);
if (seconds < 1.0f)
{
seconds = 1.0f;
}
return(seconds);
}
public static bool Check(int index, string method)
{
using (new Profiler(nameof(HasSkillRank)))
{
NWPlayer player = _.GetPCSpeaker();
NWObject talkTo = _.OBJECT_SELF;
int count = 1;
string varName = "SKILL_" + index + "_REQ_";
int skillID = talkTo.GetLocalInt(varName + count);
bool displayNode = true;
while (skillID > 0)
{
int requiredLevel = talkTo.GetLocalInt(varName + "LEVEL_" + count);
bool meetsRequirement = SkillService.GetPCSkillRank(player, skillID) >= requiredLevel;
// OR = Any one of the listed skills can be met and the node will appear.
if (method == "OR")
{
if (meetsRequirement)
{
return(true);
}
else
{
displayNode = false;
}
}
// AND = ALL listed skills must be met in order for the node to appear.
else
{
if (!meetsRequirement)
{
return(false);
}
}
count++;
skillID = talkTo.GetLocalInt(varName + count);
}
return(displayNode);
}
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
string growingPlantID = target.GetLocalString("GROWING_PLANT_ID");
if (string.IsNullOrWhiteSpace(growingPlantID))
{
user.SendMessage("Water jugs can only target growing plants.");
return;
}
GrowingPlant growingPlant = DataService.Single <GrowingPlant>(x => x.ID == new Guid(growingPlantID));
var plant = DataService.Get <Plant>(growingPlant.PlantID);
if (growingPlant.WaterStatus <= 0)
{
user.SendMessage("That plant doesn't need to be watered at this time.");
return;
}
if (item.Charges <= 0)
{
user.SendMessage("There's no water in that jug!");
return;
}
int remainingTicks = growingPlant.RemainingTicks;
if (growingPlant.WaterStatus > 1)
{
remainingTicks = remainingTicks / 2;
}
growingPlant.WaterStatus = 0;
growingPlant.RemainingTicks = remainingTicks;
DataService.SubmitDataChange(growingPlant, DatabaseActionType.Update);
user.SendMessage("You water the plant.");
int rank = SkillService.GetPCSkillRank((NWPlayer)user, SkillType.Farming);
int xp = (int)SkillService.CalculateRegisteredSkillLevelAdjustedXP(100, plant.Level, rank);
SkillService.GiveSkillXP((NWPlayer)user, SkillType.Farming, xp);
}
public string IsValidTarget(NWCreature user, NWItem item, NWObject target, Location targetLocation)
{
if (!target.IsCreature || target.IsDM)
{
return("Only creatures may be targeted with this item.");
}
if (target.CurrentHP >= 40)
{
return("Bandages cannot be used on targets with more than 40 HP.");
}
int rank = SkillService.GetPCSkillRank(user.Object, SkillType.Medicine);
if (rank < item.RecommendedLevel)
{
return("Your skill level is too low to use this item.");
}
return(null);
}
public string IsValidTarget(NWCreature user, NWItem item, NWObject target, Location targetLocation)
{
if (!target.IsCreature || target.IsDM)
{
return("Only creatures may be targeted with this item.");
}
bool hasEffect = false;
foreach (Effect effect in target.Effects)
{
if (_.GetIsEffectValid(effect) == true)
{
var effectType = _.GetEffectType(effect);
if (effectType == EffectTypeScript.Poison || effectType == EffectTypeScript.Disease || effectType == EffectTypeScript.AbilityDecrease)
{
hasEffect = true;
}
}
}
if (CustomEffectService.DoesPCHaveCustomEffect(target.Object, CustomEffectType.Poison))
{
hasEffect = true;
}
if (!hasEffect)
{
return("This player is not diseased or poisoned.");
}
int rank = SkillService.GetPCSkillRank(user.Object, SkillType.Medicine);
if (rank < item.RecommendedLevel)
{
return("Your skill level is too low to use this item.");
}
return(null);
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
NWPlayer player = (user.Object);
var effectiveStats = PlayerStatService.GetPlayerItemEffectiveStats(player);
CustomEffectService.RemovePCCustomEffect(target.Object, CustomEffectType.Bleeding);
player.SendMessage("You finish bandaging " + target.Name + "'s wounds.");
int rank = SkillService.GetPCSkillRank(player, SkillType.Medicine);
int healAmount = 2 + effectiveStats.Medicine / 2;
healAmount += item.MedicineBonus;
if (rank >= item.RecommendedLevel && item.MedicineBonus > 0)
{
_.ApplyEffectToObject(DurationType.Instant, _.EffectHeal(healAmount), target);
}
if (target.IsPlayer)
{
int xp = (int)SkillService.CalculateRegisteredSkillLevelAdjustedXP(100, item.RecommendedLevel, rank);
SkillService.GiveSkillXP(player, SkillType.Medicine, xp);
}
}
public bool Run(params object[] args)
{
NWPlaceable point = (Object.OBJECT_SELF);
NWPlayer oPC = (_.GetLastOpenedBy());
if (!oPC.IsPlayer)
{
return(false);
}
var effectiveStats = PlayerStatService.GetPlayerItemEffectiveStats(oPC);
const int baseChanceToFullyHarvest = 50;
bool alwaysDestroys = point.GetLocalInt("SCAVENGE_POINT_ALWAYS_DESTROYS") == 1;
bool hasBeenSearched = point.GetLocalInt("SCAVENGE_POINT_FULLY_HARVESTED") == 1;
if (hasBeenSearched)
{
oPC.SendMessage("There's nothing left to harvest here...");
return(true);
}
// Not fully harvested but the timer hasn't counted down yet.
int refillTick = point.GetLocalInt("SCAVENGE_POINT_REFILL_TICKS");
if (refillTick > 0)
{
oPC.SendMessage("You couldn't find anything new here. Check back later...");
return(true);
}
if (!oPC.IsPlayer && !oPC.IsDM)
{
return(false);
}
int rank = SkillService.GetPCSkillRank(oPC, SkillType.Scavenging);
int lootTableID = point.GetLocalInt("SCAVENGE_POINT_LOOT_TABLE_ID");
int level = point.GetLocalInt("SCAVENGE_POINT_LEVEL");
int delta = level - rank;
if (delta > 8)
{
oPC.SendMessage("You aren't skilled enough to scavenge through this. (Required Level: " + (level - 8) + ")");
oPC.AssignCommand(() => _.ActionInteractObject(point.Object));
return(true);
}
int dc = 6 + delta;
if (dc <= 4)
{
dc = 4;
}
int searchAttempts = 1 + CalculateSearchAttempts(oPC);
int luck = PerkService.GetCreaturePerkLevel(oPC, PerkType.Lucky) + effectiveStats.Luck;
if (RandomService.Random(100) + 1 <= luck / 2)
{
dc--;
}
oPC.AssignCommand(() => _.ActionPlayAnimation(_.ANIMATION_LOOPING_GET_LOW, 1.0f, 2.0f));
for (int attempt = 1; attempt <= searchAttempts; attempt++)
{
int roll = RandomService.Random(20) + 1;
if (roll >= dc)
{
oPC.FloatingText(ColorTokenService.SkillCheck("Search: *success*: (" + roll + " vs. DC: " + dc + ")"));
ItemVO spawnItem = LootService.PickRandomItemFromLootTable(lootTableID);
if (spawnItem == null)
{
return(false);
}
if (!string.IsNullOrWhiteSpace(spawnItem.Resref) && spawnItem.Quantity > 0)
{
_.CreateItemOnObject(spawnItem.Resref, point.Object, spawnItem.Quantity);
}
float xp = SkillService.CalculateRegisteredSkillLevelAdjustedXP(200, level, rank);
SkillService.GiveSkillXP(oPC, SkillType.Scavenging, (int)xp);
}
else
{
oPC.FloatingText(ColorTokenService.SkillCheck("Search: *failure*: (" + roll + " vs. DC: " + dc + ")"));
float xp = SkillService.CalculateRegisteredSkillLevelAdjustedXP(50, level, rank);
SkillService.GiveSkillXP(oPC, SkillType.Scavenging, (int)xp);
}
dc += RandomService.Random(3) + 1;
}
// Chance to destroy the scavenge point.
int chanceToFullyHarvest = baseChanceToFullyHarvest - (PerkService.GetCreaturePerkLevel(oPC, PerkType.CarefulScavenger) * 5);
string growingPlantID = point.GetLocalString("GROWING_PLANT_ID");
if (!string.IsNullOrWhiteSpace(growingPlantID))
{
Data.Entity.GrowingPlant growingPlant = FarmingService.GetGrowingPlantByID(new Guid(growingPlantID));
chanceToFullyHarvest = chanceToFullyHarvest - (growingPlant.LongevityBonus);
}
if (chanceToFullyHarvest <= 5)
{
chanceToFullyHarvest = 5;
}
if (alwaysDestroys || RandomService.Random(100) + 1 <= chanceToFullyHarvest)
{
point.SetLocalInt("SCAVENGE_POINT_FULLY_HARVESTED", 1);
oPC.SendMessage("This resource has been fully harvested...");
}
// Otherwise the scavenge point will be refilled in 10-20 minutes.
else
{
point.SetLocalInt("SCAVENGE_POINT_REFILL_TICKS", 100 + RandomService.Random(100));
}
point.SetLocalInt("SCAVENGE_POINT_DESPAWN_TICKS", 30);
return(true);
}
public bool Run(params object[] args)
{
NWPlaceable point = (Object.OBJECT_SELF);
NWPlayer oPC = (_.GetLastOpenedBy());
if (!oPC.IsPlayer)
{
return(false);
}
var effectiveStats = PlayerStatService.GetPlayerItemEffectiveStats(oPC);
const int baseChanceToFullyHarvest = 50;
bool alwaysDestroys = point.GetLocalInt("SCAVENGE_POINT_ALWAYS_DESTROYS") == 1;
bool hasBeenSearched = point.GetLocalInt("SCAVENGE_POINT_FULLY_HARVESTED") == 1;
if (hasBeenSearched)
{
oPC.SendMessage("There's nothing left to harvest here...");
return(true);
}
// Not fully harvested but the timer hasn't counted down yet.
int refillTick = point.GetLocalInt("SCAVENGE_POINT_REFILL_TICKS");
if (refillTick > 0)
{
oPC.SendMessage("You couldn't find anything new here. Check back later...");
return(true);
}
if (!oPC.IsPlayer && !oPC.IsDM)
{
return(false);
}
int rank = SkillService.GetPCSkillRank(oPC, SkillType.Scavenging);
int lootTableID = point.GetLocalInt("SCAVENGE_POINT_LOOT_TABLE_ID");
int level = point.GetLocalInt("SCAVENGE_POINT_LEVEL");
int delta = level - rank;
if (delta > 8)
{
oPC.SendMessage("You aren't skilled enough to scavenge through this. (Required Level: " + (level - 8) + ")");
oPC.AssignCommand(() => _.ActionInteractObject(point.Object));
return(true);
}
int dc = 6 + delta;
if (dc <= 4)
{
dc = 4;
}
int searchAttempts = 1 + CalculateSearchAttempts(oPC);
int luck = PerkService.GetPCPerkLevel(oPC, PerkType.Lucky) + effectiveStats.Luck;
if (RandomService.Random(100) + 1 <= luck / 2)
{
dc--;
}
oPC.AssignCommand(() => _.ActionPlayAnimation(_.ANIMATION_LOOPING_GET_LOW, 1.0f, 2.0f));
for (int attempt = 1; attempt <= searchAttempts; attempt++)
{
int roll = RandomService.Random(20) + 1;
if (roll >= dc)
{
oPC.FloatingText(ColorTokenService.SkillCheck("Search: *success*: (" + roll + " vs. DC: " + dc + ")"));
ItemVO spawnItem = LootService.PickRandomItemFromLootTable(lootTableID);
if (spawnItem == null)
{
return(false);
}
if (!string.IsNullOrWhiteSpace(spawnItem.Resref) && spawnItem.Quantity > 0)
{
NWItem resource = _.CreateItemOnObject(spawnItem.Resref, point.Object, spawnItem.Quantity);
var componentIP = resource.ItemProperties.FirstOrDefault(x => _.GetItemPropertyType(x) == (int)CustomItemPropertyType.ComponentType);
if (componentIP != null)
{
// Add properties to the item based on Scavenging skill. Similar logic to the resource harvester.
var chance = RandomService.Random(1, 100) + PerkService.GetPCPerkLevel(oPC, PerkType.Lucky) + effectiveStats.Luck;
ResourceQuality quality;
if (chance < 50)
{
quality = ResourceQuality.Low;
}
else if (chance < 75)
{
quality = ResourceQuality.Normal;
}
else if (chance < 95)
{
quality = ResourceQuality.High;
}
else
{
quality = ResourceQuality.VeryHigh;
}
int ipBonusChance = ResourceService.CalculateChanceForComponentBonus(oPC, (level / 10 + 1), quality, true);
if (RandomService.Random(1, 100) <= ipBonusChance)
{
var ip = ResourceService.GetRandomComponentBonusIP(ResourceQuality.Normal);
BiowareXP2.IPSafeAddItemProperty(resource, ip.Item1, 0.0f, AddItemPropertyPolicy.IgnoreExisting, true, true);
switch (ip.Item2)
{
case 0:
resource.Name = ColorTokenService.Green(resource.Name);
break;
case 1:
resource.Name = ColorTokenService.Blue(resource.Name);
break;
case 2:
resource.Name = ColorTokenService.Purple(resource.Name);
break;
case 3:
resource.Name = ColorTokenService.Orange(resource.Name);
break;
}
}
}
}
float xp = SkillService.CalculateRegisteredSkillLevelAdjustedXP(200, level, rank);
SkillService.GiveSkillXP(oPC, SkillType.Scavenging, (int)xp);
}
else
{
oPC.FloatingText(ColorTokenService.SkillCheck("Search: *failure*: (" + roll + " vs. DC: " + dc + ")"));
float xp = SkillService.CalculateRegisteredSkillLevelAdjustedXP(50, level, rank);
SkillService.GiveSkillXP(oPC, SkillType.Scavenging, (int)xp);
}
dc += RandomService.Random(3) + 1;
}
// Chance to destroy the scavenge point.
int chanceToFullyHarvest = baseChanceToFullyHarvest - (PerkService.GetPCPerkLevel(oPC, PerkType.CarefulScavenger) * 5);
string growingPlantID = point.GetLocalString("GROWING_PLANT_ID");
if (!string.IsNullOrWhiteSpace(growingPlantID))
{
Data.Entity.GrowingPlant growingPlant = FarmingService.GetGrowingPlantByID(new Guid(growingPlantID));
chanceToFullyHarvest = chanceToFullyHarvest - (growingPlant.LongevityBonus);
}
if (chanceToFullyHarvest <= 5)
{
chanceToFullyHarvest = 5;
}
if (alwaysDestroys || RandomService.Random(100) + 1 <= chanceToFullyHarvest)
{
point.SetLocalInt("SCAVENGE_POINT_FULLY_HARVESTED", 1);
oPC.SendMessage("This resource has been fully harvested...");
}
// Otherwise the scavenge point will be refilled in 10-20 minutes.
else
{
point.SetLocalInt("SCAVENGE_POINT_REFILL_TICKS", 100 + RandomService.Random(100));
}
point.SetLocalInt("SCAVENGE_POINT_DESPAWN_TICKS", 30);
return(true);
}
public override void Initialize()
{
ToggleBackButton(false);
var model = CraftService.GetPlayerCraftingData(GetPC());
var device = GetDevice();
// Entering the conversation for the first time from the blueprint selection menu.
if (!model.IsInitialized)
{
model.IsInitialized = true;
model.Blueprint = CraftService.GetBlueprintByID(model.BlueprintID);
model.PlayerSkillRank = SkillService.GetPCSkillRank(GetPC(), model.Blueprint.SkillID);
switch ((SkillType)model.Blueprint.SkillID)
{
case SkillType.Armorsmith:
model.PlayerPerkLevel = PerkService.GetCreaturePerkLevel(GetPC(), PerkType.ArmorBlueprints);
break;
case SkillType.Engineering:
model.PlayerPerkLevel = PerkService.GetCreaturePerkLevel(GetPC(), PerkType.EngineeringBlueprints);
break;
case SkillType.Weaponsmith:
model.PlayerPerkLevel = PerkService.GetCreaturePerkLevel(GetPC(), PerkType.WeaponBlueprints);
break;
case SkillType.Fabrication:
model.PlayerPerkLevel = PerkService.GetCreaturePerkLevel(GetPC(), PerkType.FabricationBlueprints);
break;
case SkillType.Medicine:
model.PlayerPerkLevel = PerkService.GetCreaturePerkLevel(GetPC(), PerkType.MedicalBlueprints);
break;
case SkillType.Lightsaber:
model.PlayerPerkLevel = PerkService.GetCreaturePerkLevel(GetPC(), PerkType.LightsaberBlueprints);
// Lightsabers do not have Optimisation or Efficiency perks.
break;
default:
model.PlayerPerkLevel = 0;
break;
}
GetDevice().IsLocked = true;
model.MainMinimum = model.Blueprint.MainMinimum;
model.SecondaryMinimum = model.Blueprint.SecondaryMinimum;
model.TertiaryMinimum = model.Blueprint.TertiaryMinimum;
model.MainMaximum = model.Blueprint.MainMaximum;
model.SecondaryMaximum = model.Blueprint.SecondaryMaximum > 0 ? model.Blueprint.SecondaryMaximum : 0;
model.TertiaryMaximum = model.Blueprint.TertiaryMaximum > 0 ? model.Blueprint.TertiaryMaximum : 0;
if (model.MainMinimum <= 0)
{
model.MainMinimum = 1;
}
if (model.SecondaryMinimum <= 0 && model.Blueprint.SecondaryMinimum > 0)
{
model.SecondaryMinimum = 1;
}
if (model.TertiaryMinimum <= 0 && model.Blueprint.TertiaryMinimum > 0)
{
model.TertiaryMinimum = 1;
}
}
// Otherwise returning from accessing the device's inventory.
else
{
model.Access = CraftingAccessType.None;
_.SetEventScript(device.Object, EVENT_SCRIPT_PLACEABLE_ON_USED, "script_1");
_.SetEventScript(device.Object, EVENT_SCRIPT_PLACEABLE_ON_OPEN, string.Empty);
_.SetEventScript(device.Object, EVENT_SCRIPT_PLACEABLE_ON_CLOSED, string.Empty);
_.SetEventScript(device.Object, EVENT_SCRIPT_PLACEABLE_ON_INVENTORYDISTURBED, string.Empty);
}
SetPageHeader("MainPage", CraftService.BuildBlueprintHeader(GetPC(), true));
BuildMainPageOptions();
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
NWPlayer player = user.Object;
ResourceQuality quality = (ResourceQuality)target.GetLocalInt("RESOURCE_QUALITY");
int tier = target.GetLocalInt("RESOURCE_TIER");
int remaining = target.GetLocalInt("RESOURCE_COUNT") - 1;
string itemResref = target.GetLocalString("RESOURCE_RESREF");
int gemChance = ResourceService.CalculateChanceForComponentBonus(player, tier, quality);
int roll = RandomService.Random(1, 100);
int rank = SkillService.GetPCSkillRank(player, SkillType.Harvesting);
if (item.RecommendedLevel < rank)
{
rank = item.RecommendedLevel;
}
int difficulty = (tier - 1) * 10 + ResourceService.GetDifficultyAdjustment(quality);
int delta = difficulty - rank;
int baseXP = 0;
if (delta >= 6)
{
baseXP = 400;
}
else if (delta == 5)
{
baseXP = 350;
}
else if (delta == 4)
{
baseXP = 325;
}
else if (delta == 3)
{
baseXP = 300;
}
else if (delta == 2)
{
baseXP = 250;
}
else if (delta == 1)
{
baseXP = 225;
}
else if (delta == 0)
{
baseXP = 200;
}
else if (delta == -1)
{
baseXP = 150;
}
else if (delta == -2)
{
baseXP = 100;
}
else if (delta == -3)
{
baseXP = 50;
}
else if (delta == -4)
{
baseXP = 25;
}
int itemHarvestBonus = item.HarvestingBonus;
int scanningBonus = user.GetLocalInt(target.GlobalID.ToString());
gemChance += itemHarvestBonus * 2 + scanningBonus * 2;
baseXP = baseXP + scanningBonus * 5;
// Spawn the normal resource.
NWItem resource = CreateItemOnObject(itemResref, player);
user.SendMessage("You harvest " + resource.Name + ".");
// If player meets the chance to acquire a gem, create one and modify its properties.
if (quality > ResourceQuality.Low && roll <= gemChance)
{
// Gemstone quality is determined by the quality of the vein.
switch (quality)
{
case ResourceQuality.Normal:
resource = CreateItemOnObject("flawed_gemstone", player);
break;
case ResourceQuality.High:
resource = CreateItemOnObject("gemstone", player);
break;
case ResourceQuality.VeryHigh:
resource = CreateItemOnObject("perfect_gemstone", player);
break;
}
var ip = ResourceService.GetRandomComponentBonusIP(quality);
BiowareXP2.IPSafeAddItemProperty(resource, ip.Item1, 0.0f, AddItemPropertyPolicy.IgnoreExisting, true, true);
switch (ip.Item2)
{
case 0:
resource.Name = ColorTokenService.Green(resource.Name);
break;
case 1:
resource.Name = ColorTokenService.Blue(resource.Name);
break;
case 2:
resource.Name = ColorTokenService.Purple(resource.Name);
break;
case 3:
resource.Name = ColorTokenService.Orange(resource.Name);
break;
case 4:
resource.Name = ColorTokenService.LightPurple(resource.Name);
break;
case 5:
resource.Name = ColorTokenService.Yellow(resource.Name);
break;
case 6:
resource.Name = ColorTokenService.Red(resource.Name);
break;
case 7:
resource.Name = ColorTokenService.Cyan(resource.Name);
break;
}
user.SendMessage("You harvest " + resource.Name + ".");
}
float decayMinimum = 0.03f;
float decayMaximum = 0.07f;
if (delta > 0)
{
decayMinimum += delta * 0.1f;
decayMaximum += delta * 0.1f;
}
DurabilityService.RunItemDecay(player, item, RandomService.RandomFloat(decayMinimum, decayMaximum));
int xp = baseXP;
SkillService.GiveSkillXP(player, SkillType.Harvesting, xp);
if (remaining <= 0)
{
NWPlaceable prop = target.GetLocalObject("RESOURCE_PROP_OBJ");
if (prop.IsValid)
{
prop.Destroy();
}
target.Destroy();
user.DeleteLocalInt(target.GlobalID.ToString());
}
else
{
target.SetLocalInt("RESOURCE_COUNT", remaining);
}
ApplyEffectAtLocation(DurationType.Instant, EffectVisualEffect(VisualEffect.Vfx_Fnf_Summon_Monster_3), target.Location);
}
public void Main()
{
NWPlaceable point = (_.OBJECT_SELF);
NWPlayer oPC = (_.GetLastOpenedBy());
if (!oPC.IsPlayer)
{
return;
}
var effectiveStats = PlayerStatService.GetPlayerItemEffectiveStats(oPC);
const int baseChanceToFullyHarvest = 50;
bool hasBeenSearched = point.GetLocalInt("SCAVENGE_POINT_FULLY_HARVESTED") == 1;
if (hasBeenSearched)
{
oPC.SendMessage("There's nothing left to harvest here...");
return;
}
if (!oPC.IsPlayer && !oPC.IsDM)
{
return;
}
int rank = SkillService.GetPCSkillRank(oPC, SkillType.Scavenging);
int lootTableID = point.GetLocalInt("SCAVENGE_POINT_LOOT_TABLE_ID");
int level = point.GetLocalInt("SCAVENGE_POINT_LEVEL");
int delta = level - rank;
if (delta > 8)
{
oPC.SendMessage("You aren't skilled enough to scavenge through this. (Required Level: " + (level - 8) + ")");
oPC.AssignCommand(() => _.ActionInteractObject(point.Object));
return;
}
int dc = 6 + delta;
if (dc <= 4)
{
dc = 4;
}
int searchAttempts = 1 + CalculateSearchAttempts(oPC);
int luck = PerkService.GetCreaturePerkLevel(oPC, PerkType.Lucky) + effectiveStats.Luck;
if (RandomService.Random(100) + 1 <= luck / 2)
{
dc--;
}
oPC.AssignCommand(() => _.ActionPlayAnimation(Animation.LoopingGetLow, 1.0f, 2.0f));
for (int attempt = 1; attempt <= searchAttempts; attempt++)
{
int roll = RandomService.Random(20) + 1;
if (roll >= dc)
{
oPC.FloatingText(ColorTokenService.SkillCheck("Search: *success*: (" + roll + " vs. DC: " + dc + ")"));
ItemVO spawnItem = LootService.PickRandomItemFromLootTable(lootTableID);
if (spawnItem == null)
{
return;
}
if (!string.IsNullOrWhiteSpace(spawnItem.Resref) && spawnItem.Quantity > 0)
{
_.CreateItemOnObject(spawnItem.Resref, point.Object, spawnItem.Quantity);
}
float xp = SkillService.CalculateRegisteredSkillLevelAdjustedXP(200, level, rank);
SkillService.GiveSkillXP(oPC, SkillType.Scavenging, (int)xp);
}
else
{
oPC.FloatingText(ColorTokenService.SkillCheck("Search: *failure*: (" + roll + " vs. DC: " + dc + ")"));
float xp = SkillService.CalculateRegisteredSkillLevelAdjustedXP(50, level, rank);
SkillService.GiveSkillXP(oPC, SkillType.Scavenging, (int)xp);
}
dc += RandomService.Random(3) + 1;
}
// Chance to destroy the scavenge point.
int chanceToFullyHarvest = baseChanceToFullyHarvest - (PerkService.GetCreaturePerkLevel(oPC, PerkType.CarefulScavenger) * 5);
if (chanceToFullyHarvest <= 5)
{
chanceToFullyHarvest = 5;
}
point.SetLocalInt("SCAVENGE_POINT_FULLY_HARVESTED", 1);
oPC.SendMessage("This resource has been fully harvested...");
point.SetLocalInt("SCAVENGE_POINT_DESPAWN_TICKS", 30);
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
SkillType skillType = GetSkillType(item);
NWItem targetitem = (target.Object);
int tech = item.GetLocalInt("TECH_LEVEL");
float maxDurabilityReductionPenalty = item.GetLocalFloat("MAX_DURABILITY_REDUCTION_PENALTY");
int repairAmount = tech * 2;
int skillRank;
int level = targetitem.RecommendedLevel;
int delta = 0;
int baseXP = 0;
if (skillType == SkillType.Armorsmith)
{
skillRank = (SkillService.GetPCSkillRank(user.Object, skillType));
repairAmount += item.CraftBonusArmorsmith + (PerkService.GetPCPerkLevel(user.Object, PerkType.ArmorRepair) * 2);
delta = level - skillRank;
}
else if (skillType == SkillType.Weaponsmith)
{
skillRank = (SkillService.GetPCSkillRank(user.Object, skillType));
repairAmount += item.CraftBonusWeaponsmith + (PerkService.GetPCPerkLevel(user.Object, PerkType.WeaponRepair) * 2);
delta = level - skillRank;
}
else if (skillType == SkillType.Engineering)
{
skillRank = (SkillService.GetPCSkillRank(user.Object, skillType));
repairAmount += item.CraftBonusEngineering + (PerkService.GetPCPerkLevel(user.Object, PerkType.ElectronicRepair) * 2);
delta = level - skillRank;
}
float minReduction = 0.05f * tech;
float maxReduction = 0.15f * tech;
float reductionAmount = RandomService.RandomFloat(minReduction, maxReduction);
if (delta >= 6)
{
baseXP = 400;
}
else if (delta == 5)
{
baseXP = 350;
}
else if (delta == 4)
{
baseXP = 325;
}
else if (delta == 3)
{
baseXP = 300;
}
else if (delta == 2)
{
baseXP = 250;
}
else if (delta == 1)
{
baseXP = 225;
}
else if (delta == 0)
{
baseXP = 200;
}
else if (delta == -1)
{
baseXP = 150;
}
else if (delta == -2)
{
baseXP = 100;
}
else if (delta == -3)
{
baseXP = 50;
}
else if (delta == -4)
{
baseXP = 25;
}
SkillService.GiveSkillXP(user.Object, skillType, baseXP);
DurabilityService.RunItemRepair(user.Object, target.Object, repairAmount, reductionAmount + maxDurabilityReductionPenalty);
}
public void ApplyEffects(NWCreature user, NWItem modItem, NWObject target, Location targetLocation, CustomData customData)
{
NWPlayer player = (user.Object);
NWItem targetItem = (target.Object);
ModSlots slots = ModService.GetModSlots(targetItem);
CustomItemPropertyType modType = ModService.GetModType(modItem);
int modID = modItem.GetLocalInt("RUNE_ID");
string[] modArgs = modItem.GetLocalString("RUNE_VALUE").Split(',');
int modLevel = modItem.RecommendedLevel;
int levelIncrease = modItem.LevelIncrease;
var mod = ModService.GetModHandler(modID);
mod.Apply(player, targetItem, modArgs);
string description = mod.Description(player, targetItem, modArgs);
bool usePrismatic = false;
switch (modType)
{
case CustomItemPropertyType.RedMod:
if (slots.FilledRedSlots < slots.RedSlots)
{
targetItem.SetLocalInt("MOD_SLOT_RED_" + (slots.FilledRedSlots + 1), modID);
targetItem.SetLocalString("MOD_SLOT_RED_DESC_" + (slots.FilledRedSlots + 1), description);
player.SendMessage("Mod installed into " + ColorTokenService.Red("red") + " slot #" + (slots.FilledRedSlots + 1));
}
else
{
usePrismatic = true;
}
break;
case CustomItemPropertyType.BlueMod:
if (slots.FilledBlueSlots < slots.BlueSlots)
{
targetItem.SetLocalInt("MOD_SLOT_BLUE_" + (slots.FilledBlueSlots + 1), modID);
targetItem.SetLocalString("MOD_SLOT_BLUE_DESC_" + (slots.FilledBlueSlots + 1), description);
player.SendMessage("Mod installed into " + ColorTokenService.Blue("blue") + " slot #" + (slots.FilledBlueSlots + 1));
}
else
{
usePrismatic = true;
}
break;
case CustomItemPropertyType.GreenMod:
if (slots.FilledBlueSlots < slots.GreenSlots)
{
targetItem.SetLocalInt("MOD_SLOT_GREEN_" + (slots.FilledGreenSlots + 1), modID);
targetItem.SetLocalString("MOD_SLOT_GREEN_DESC_" + (slots.FilledGreenSlots + 1), description);
player.SendMessage("Mod installed into " + ColorTokenService.Green("green") + " slot #" + (slots.FilledGreenSlots + 1));
}
else
{
usePrismatic = true;
}
break;
case CustomItemPropertyType.YellowMod:
if (slots.FilledBlueSlots < slots.YellowSlots)
{
targetItem.SetLocalInt("MOD_SLOT_YELLOW_" + (slots.FilledYellowSlots + 1), modID);
targetItem.SetLocalString("MOD_SLOT_YELLOW_DESC_" + (slots.FilledYellowSlots + 1), description);
player.SendMessage("Mod installed into " + ColorTokenService.Yellow("yellow") + " slot #" + (slots.FilledYellowSlots + 1));
}
else
{
usePrismatic = true;
}
break;
}
if (usePrismatic)
{
string prismaticText = ModService.PrismaticString();
targetItem.SetLocalInt("MOD_SLOT_PRISMATIC_" + (slots.FilledPrismaticSlots + 1), modID);
targetItem.SetLocalString("MOD_SLOT_PRISMATIC_DESC_" + (slots.FilledPrismaticSlots + 1), description);
player.SendMessage("Mod installed into " + prismaticText + " slot #" + (slots.FilledPrismaticSlots + 1));
}
targetItem.RecommendedLevel += levelIncrease;
modItem.Destroy();
SkillType skillType;
if (ArmorBaseItemTypes.Contains(targetItem.BaseItemType))
{
skillType = SkillType.Armorsmith;
}
else if (WeaponsmithBaseItemTypes.Contains(targetItem.BaseItemType))
{
skillType = SkillType.Weaponsmith;
}
else if (EngineeringBaseItemTypes.Contains(targetItem.BaseItemType))
{
skillType = SkillType.Engineering;
}
else
{
return;
}
int rank = SkillService.GetPCSkillRank(player, skillType);
int xp = (int)SkillService.CalculateRegisteredSkillLevelAdjustedXP(400, modLevel, rank);
SkillService.GiveSkillXP(player, skillType, xp);
}
private void OnCompleteSmelt(OnCompleteSmelt data)
{
NWPlayer player = data.Player;
string oreResref = data.OreResref;
List <ItemProperty> itemProperties = data.ItemProperties;
player.IsBusy = false;
int rank = SkillService.GetPCSkillRank(player, SkillType.Harvesting);
int level = CraftService.GetIngotLevel(oreResref);
string ingotResref = CraftService.GetIngotResref(oreResref);
if (level < 0 || string.IsNullOrWhiteSpace(ingotResref))
{
return;
}
int delta = rank - level;
int count = 2;
if (delta > 2)
{
count = delta;
}
if (count > 4)
{
count = 4;
}
if (RandomService.Random(100) + 1 <= PerkService.GetCreaturePerkLevel(player, PerkType.Lucky))
{
count++;
}
if (RandomService.Random(100) + 1 <= PerkService.GetCreaturePerkLevel(player, PerkType.ProcessingEfficiency) * 10)
{
count++;
}
for (int x = 1; x <= count; x++)
{
var item = (_.CreateItemOnObject(ingotResref, player.Object));
int chance;
switch (x)
{
case 1:
case 2:
chance = 100;
break;
case 3:
chance = 70;
break;
case 4:
chance = 60;
break;
case 5:
chance = 50;
break;
default:
chance = 30;
break;
}
foreach (var ip in itemProperties)
{
if (RandomService.D100(1) <= chance)
{
BiowareXP2.IPSafeAddItemProperty(item, ip, 0.0f, AddItemPropertyPolicy.IgnoreExisting, true, true);
}
}
}
var effectiveStats = PlayerStatService.GetPlayerItemEffectiveStats(player);
int harvestingSkill = SkillService.GetPCSkillRank(player, SkillType.Harvesting);
int perkBonus = PerkService.GetCreaturePerkLevel(player, PerkType.StronidiumRefining) + 1;
int stronidiumAmount = 10 + effectiveStats.Harvesting + harvestingSkill + RandomService.Random(1, 5);
stronidiumAmount *= perkBonus;
_.CreateItemOnObject("stronidium", player.Object, stronidiumAmount);
int xp = (int)SkillService.CalculateRegisteredSkillLevelAdjustedXP(100, level, rank);
SkillService.GiveSkillXP(player, SkillType.Harvesting, xp);
}
public void OnImpact(NWCreature creature, NWObject target, int perkLevel, int spellTier)
{
Effect effect;
float duration;
switch (spellTier)
{
case 1:
effect = _.EffectMovementSpeedIncrease(10);
effect = _.EffectLinkEffects(effect, _.EffectAbilityIncrease(AbilityType.Dexterity, 2));
duration = 60f;
break;
case 2:
effect = _.EffectMovementSpeedIncrease(20);
effect = _.EffectLinkEffects(effect, _.EffectAbilityIncrease(AbilityType.Dexterity, 4));
duration = 90f;
break;
case 3:
effect = _.EffectMovementSpeedIncrease(30);
effect = _.EffectLinkEffects(effect, _.EffectAbilityIncrease(AbilityType.Dexterity, 6));
effect = _.EffectLinkEffects(effect, _.EffectModifyAttacks(1));
duration = 120f;
break;
case 4:
effect = _.EffectMovementSpeedIncrease(40);
effect = _.EffectLinkEffects(effect, _.EffectAbilityIncrease(AbilityType.Dexterity, 8));
effect = _.EffectLinkEffects(effect, _.EffectModifyAttacks(1));
duration = 150f;
break;
case 5:
effect = _.EffectMovementSpeedIncrease(50);
effect = _.EffectLinkEffects(effect, _.EffectAbilityIncrease(AbilityType.Dexterity, 10));
effect = _.EffectLinkEffects(effect, _.EffectModifyAttacks(1));
duration = 180f;
break;
default:
throw new ArgumentException(nameof(perkLevel) + " invalid. Value " + perkLevel + " is unhandled.");
}
// Check lucky chance.
int luck = PerkService.GetCreaturePerkLevel(creature, PerkType.Lucky);
if (RandomService.D100(1) <= luck)
{
duration *= 2;
creature.SendMessage("Lucky Force Speed!");
}
_.ApplyEffectToObject(DurationType.Temporary, effect, target, duration);
_.ApplyEffectToObject(DurationType.Instant, _.EffectVisualEffect(VisualEffect.Vfx_Imp_Ac_Bonus), target);
if (creature.IsPlayer)
{
NWPlayer player = creature.Object;
int skillLevel = SkillService.GetPCSkillRank(player, SkillType.ForceControl);
int xp = skillLevel * 10 + 50;
SkillService.GiveSkillXP(player, SkillType.ForceControl, xp);
}
}
public bool Run(params object[] args)
{
NWPlaceable container = (Object.OBJECT_SELF);
NWPlayer oPC = (_.GetLastDisturbed());
int type = _.GetInventoryDisturbType();
NWItem item = (_.GetInventoryDisturbItem());
var effectiveStats = PlayerStatService.GetPlayerItemEffectiveStats(oPC);
if (type != _.INVENTORY_DISTURB_TYPE_ADDED)
{
return(false);
}
int plantID = item.GetLocalInt("PLANT_ID");
if (plantID <= 0)
{
ItemService.ReturnItem(oPC, item);
oPC.SendMessage("You cannot plant that item.");
return(true);
}
Plant plant = FarmingService.GetPlantByID(plantID);
if (plant == null)
{
ItemService.ReturnItem(oPC, item);
oPC.SendMessage("You cannot plant that item.");
return(true);
}
int rank = SkillService.GetPCSkillRank(oPC, SkillType.Farming);
if (rank + 2 < plant.Level)
{
ItemService.ReturnItem(oPC, item);
oPC.SendMessage("You do not have enough Farming skill to plant that seed. (Required: " + (plant.Level - 2) + ")");
return(true);
}
item.Destroy();
string areaTag = container.Area.Tag;
Location plantLocation = container.Location;
int perkBonus = PerkService.GetPCPerkLevel(oPC, PerkType.FarmingEfficiency) * 2;
int ticks = (int)(plant.BaseTicks - ((PerkService.GetPCPerkLevel(oPC, PerkType.ExpertFarmer) * 0.05f)) * plant.BaseTicks);
Data.Entity.GrowingPlant growingPlant = new Data.Entity.GrowingPlant
{
PlantID = plant.ID,
RemainingTicks = ticks,
LocationAreaTag = areaTag,
LocationOrientation = _.GetFacingFromLocation(plantLocation),
LocationX = _.GetPositionFromLocation(plantLocation).m_X,
LocationY = _.GetPositionFromLocation(plantLocation).m_Y,
LocationZ = _.GetPositionFromLocation(plantLocation).m_Z,
IsActive = true,
DateCreated = DateTime.UtcNow,
LongevityBonus = perkBonus
};
DataService.SubmitDataChange(growingPlant, DatabaseActionType.Insert);
NWPlaceable hole = (container.GetLocalObject("FARM_SMALL_HOLE"));
NWPlaceable plantPlc = (_.CreateObject(_.OBJECT_TYPE_PLACEABLE, "growing_plant", hole.Location));
plantPlc.SetLocalString("GROWING_PLANT_ID", growingPlant.ID.ToString());
plantPlc.Name = "Growing Plant (" + plant.Name + ")";
container.Destroy();
hole.Destroy();
int xp = (int)SkillService.CalculateRegisteredSkillLevelAdjustedXP(200, plant.Level, rank);
if (RandomService.Random(100) + 1 <= PerkService.GetPCPerkLevel(oPC, PerkType.Lucky) + effectiveStats.Luck)
{
xp *= 2;
}
SkillService.GiveSkillXP(oPC, SkillType.Farming, xp);
return(true);
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
NWPlayer player = user.Object;
var effectiveStats = PlayerStatService.GetPlayerItemEffectiveStats(player);
int skillRank = SkillService.GetPCSkillRank(player, SkillType.Medicine);
int perkLevel = PerkService.GetCreaturePerkLevel(player, PerkType.ResuscitationDevices);
int rank = item.GetLocalInt("RANK");
int baseHeal;
switch (rank)
{
case 1:
baseHeal = 1;
break;
case 2:
baseHeal = 11;
break;
case 3:
baseHeal = 31;
break;
case 4:
baseHeal = 51;
break;
default: return;
}
baseHeal += perkLevel * 2;
baseHeal += effectiveStats.Medicine / 2;
baseHeal += item.MedicineBonus / 2;
int delta = item.RecommendedLevel - skillRank;
float effectivenessPercent = 1.0f;
if (delta > 0)
{
effectivenessPercent = effectivenessPercent - (delta * 0.1f);
}
if (target.IsPlayer)
{
baseHeal = (int)(baseHeal * effectivenessPercent);
Player dbPlayer = DataService.Player.GetByID(target.GlobalID);
int fpRecover = (int)(dbPlayer.MaxFP * (0.01f * baseHeal));
int hpRecover = (int)(target.MaxHP * (0.01f * baseHeal));
_.PlaySound("use_bacta");
_.ApplyEffectToObject(DURATION_TYPE_INSTANT, _.EffectResurrection(), target);
_.ApplyEffectToObject(DURATION_TYPE_INSTANT, _.EffectHeal(hpRecover), target);
dbPlayer.CurrentFP = fpRecover;
DataService.SubmitDataChange(dbPlayer, DatabaseActionType.Update);
player.SendMessage("You successfully resuscitate " + target.Name + "!");
int xp = (int)SkillService.CalculateRegisteredSkillLevelAdjustedXP(600, item.RecommendedLevel, skillRank);
SkillService.GiveSkillXP(player, SkillType.Medicine, xp);
}
else
{
baseHeal = (int)(baseHeal * effectivenessPercent);
int hpRecover = (int)(target.MaxHP * (0.01f * baseHeal));
_.ApplyEffectToObject(DURATION_TYPE_INSTANT, _.EffectResurrection(), target);
_.ApplyEffectToObject(DURATION_TYPE_INSTANT, _.EffectHeal(hpRecover), target);
player.SendMessage("You successfully resuscitate " + target.Name + "!");
}
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
DateTime now = DateTime.UtcNow;
DateTime unlockDateTime = now;
if (string.IsNullOrWhiteSpace(GetLocalString(user, "GRENADE_UNLOCKTIME")))
{
unlockDateTime = unlockDateTime.AddSeconds(-1);
}
else
{
unlockDateTime = DateTime.ParseExact(GetLocalString(user, "GRENADE_UNLOCKTIME"), "yyyy-MM-dd hh:mm:ss", CultureInfo.InvariantCulture);
}
//Console.WriteLine("IsValidTarget - Current Time = " + now.ToString("yyyy-MM-dd hh:mm:ss", CultureInfo.InvariantCulture));
//Console.WriteLine("IsValidTarget - Unlocktime = " + unlockDateTime.ToString("yyyy-MM-dd hh:mm:ss", CultureInfo.InvariantCulture));
//Console.WriteLine("IsValidTarget - DateTime.Compare = " + DateTime.Compare(unlockDateTime, now));
// Check if we've passed the unlock date. Exit early if we have not.
if (DateTime.Compare(unlockDateTime, now) > 0 || unlockDateTime > now)
{
string timeToWait = TimeService.GetTimeToWaitLongIntervals(now, unlockDateTime, false);
//Console.WriteLine("IsValidTarget - That ability can be used in " + timeToWait + ".");
SendMessageToPC(user, "That ability can be used in " + timeToWait + ".");
return;
}
Effect impactEffect = null;
var spellId = Spell.Invalid;
string soundName = null;
int perkLevel = 1 + PerkService.GetCreaturePerkLevel(user, PerkType.GrenadeProficiency);
int skillLevel = 5 + SkillService.GetPCSkillRank((NWPlayer)user, SkillType.Throwing);
if (perkLevel == 0)
{
perkLevel += 1;
}
if (GetIsObjectValid(target) == true)
{
targetLocation = GetLocation(target);
}
string grenadeType = item.GetLocalString("TYPE");
//Console.WriteLine("Throwing " + grenadeType + " grenade at perk level " + perkLevel);
Location originalLocation = targetLocation;
int roll = RandomService.D100(1);
SendMessageToPC(user, roll + " vs. DC " + (100 - skillLevel));
if (roll < (100 - skillLevel))
{
if (RandomService.D20(1) == 1)
{
SendMessageToPC(user, "You threw... poorly.");
//targetLocation = VectorService.MoveLocation(targetLocation, GetFacing(user), (RandomService.D6(4) - 10) * 1.0f,
targetLocation = VectorService.MoveLocation(user.Location, RandomService.D100(1) + RandomService.D100(1) + RandomService.D100(1) + 60, RandomService.D4(2) * 1.0f,
RandomService.D100(1) + RandomService.D100(1) + RandomService.D100(1));
int count = 0;
while ((GetSurfaceMaterial(targetLocation) == 0 ||
LineOfSightVector(GetPositionFromLocation(targetLocation), GetPosition(user)) == false) &&
count < 10)
{
count += 1;
targetLocation = VectorService.MoveLocation(user.Location, RandomService.D100(1) + RandomService.D100(1) + RandomService.D100(1) + 60, RandomService.D4(2) * 1.0f,
RandomService.D100(1) + RandomService.D100(1) + RandomService.D100(1));
}
}
else
{
SendMessageToPC(user, "Your throw was a bit off the mark.");
//targetLocation = VectorService.MoveLocation(targetLocation, GetFacing(user), (RandomService.D6(4) - 10) * 1.0f,
targetLocation = VectorService.MoveLocation(targetLocation, RandomService.D100(1) + RandomService.D100(1) + RandomService.D100(1) + 60, RandomService.D4(2) /*(RandomService.D6(4) - 10) */ * 1.0f,
RandomService.D100(1) + RandomService.D100(1) + RandomService.D100(1));
int count = 0;
while ((GetSurfaceMaterial(targetLocation) == 0 ||
LineOfSightVector(GetPositionFromLocation(targetLocation), GetPosition(user)) == false) &&
count < 10)
{
count += 1;
targetLocation = VectorService.MoveLocation(targetLocation, RandomService.D100(1) + RandomService.D100(1) + RandomService.D100(1) + 60, RandomService.D4(2) /*(RandomService.D6(4) - 10) */ * 1.0f,
RandomService.D100(1) + RandomService.D100(1) + RandomService.D100(1));
}
}
if (GetSurfaceMaterial(targetLocation) == 0 ||
LineOfSightVector(GetPositionFromLocation(targetLocation), GetPosition(user)) == false)
{
targetLocation = originalLocation;
}
}
switch (grenadeType)
{
case "FRAG":
impactEffect = EffectVisualEffect(VisualEffect.Fnf_Fireball);
// force a specific spell id (for projectile model) for this grenade.
spellId = Spell.Grenade10;
soundName = "explosion2";
break;
case "CONCUSSION":
impactEffect = EffectVisualEffect(VisualEffect.Vfx_Fnf_Sound_Burst_Silent);
impactEffect = EffectLinkEffects(EffectVisualEffect(VisualEffect.Vfx_Fnf_Screen_Shake), impactEffect);
spellId = Spell.Grenade10;
soundName = "explosion1";
break;
case "FLASHBANG":
impactEffect = EffectVisualEffect(VisualEffect.Vfx_Fnf_Mystical_Explosion);
spellId = Spell.Grenade10;
soundName = "explosion1";
break;
case "ION":
impactEffect = EffectVisualEffect(VisualEffect.Vfx_Fnf_Electric_Explosion);
spellId = Spell.Grenade10;
soundName = "explosion1";
break;
case "BACTA":
impactEffect = EffectVisualEffect(VisualEffect.Vfx_Fnf_Gas_Explosion_Nature);
spellId = Spell.Grenade10;
//soundName = "explosion1";
break;
case "ADHESIVE":
impactEffect = EffectVisualEffect(VisualEffect.Fnf_Dispel_Greater);
spellId = Spell.Grenade10;
//soundName = "explosion1";
break;
case "SMOKE":
impactEffect = null;
spellId = Spell.Grenade10;
//soundName = "explosion1";
break;
case "BACTABOMB":
impactEffect = null;
spellId = Spell.Grenade10;
//soundName = "explosion1";
break;
case "INCENDIARY":
impactEffect = null;
spellId = Spell.Grenade10;
//soundName = "explosion1";
break;
case "GAS":
impactEffect = null;
spellId = Spell.Grenade10;
//soundName = "explosion1";
break;
default:
throw new ArgumentOutOfRangeException(nameof(grenadeType));
}
if (spellId == 0)
{
// start 974 through 979 in spells.2da for grenades
// lets randomly assign a projectile appearance for flavor?
spellId = (Spell)(RandomService.D6(1) + 973);
}
float delay = GetDistanceBetweenLocations(user.Location, targetLocation) / 18.0f + 0.75f;
delay += 0.4f; // added for animation
user.ClearAllActions();
//user.AssignCommand(() => _.ActionPlayAnimation(32));
//user.DelayAssignCommand(() => _.ActionPlayAnimation(32), 0.0f);
user.AssignCommand(() =>
{
ActionPlayAnimation(Animation.LoopingCustom12);
ActionCastSpellAtLocation(spellId, targetLocation, MetaMagic.Any, true, ProjectilePathType.Ballistic, true);
//ActionCastFakeSpellAtLocation(spellId, targetLocation, PROJECTILE_PATH_TYPE_BALLISTIC);
});
if (soundName != null)
{
user.DelayAssignCommand(() =>
{
PlaySound(soundName);
}, delay);
}
if (impactEffect != null)
{
user.DelayAssignCommand(() =>
{
ApplyEffectAtLocation(DurationType.Instant, impactEffect, targetLocation);
}, delay);
}
user.DelayAssignCommand(
() =>
{
DoImpact(user, item, targetLocation, grenadeType, perkLevel, RadiusSize.Large, ObjectType.Creature);
}, delay + 0.75f);
perkLevel = PerkService.GetCreaturePerkLevel(user, PerkType.GrenadeProficiency);
now = DateTime.UtcNow;
DateTime unlockTime = now;
if (perkLevel < 5)
{
unlockTime = unlockTime.AddSeconds(6);
}
else if (perkLevel < 10)
{
unlockTime = unlockTime.AddSeconds(3);
}
else
{
unlockTime = unlockTime.AddSeconds(2);
}
SetLocalString(user, "GRENADE_UNLOCKTIME", unlockTime.ToString("yyyy-MM-dd hh:mm:ss", CultureInfo.InvariantCulture));
//Console.WriteLine("StartUseItem - Current Time = " + now.ToString("yyyy-MM-dd hh:mm:ss", CultureInfo.InvariantCulture));
//Console.WriteLine("StartUseItem - Unlocktime Set To = " + unlockTime.ToString("yyyy-MM-dd hh:mm:ss", CultureInfo.InvariantCulture));
if (user.IsCreature)
{
DurabilityService.RunItemDecay((NWPlayer)user, item, 1.0f);
}
}
public void OnImpact(NWCreature creature, NWObject target, int perkLevel, int spellTier)
{
Effect effect;
float duration;
switch (spellTier)
{
case 1:
effect = _.EffectMovementSpeedIncrease(10);
effect = _.EffectLinkEffects(effect, _.EffectAbilityIncrease(_.ABILITY_DEXTERITY, 2));
duration = 60f;
break;
case 2:
effect = _.EffectMovementSpeedIncrease(20);
effect = _.EffectLinkEffects(effect, _.EffectAbilityIncrease(_.ABILITY_DEXTERITY, 4));
duration = 90f;
break;
case 3:
effect = _.EffectMovementSpeedIncrease(30);
effect = _.EffectLinkEffects(effect, _.EffectAbilityIncrease(_.ABILITY_DEXTERITY, 6));
effect = _.EffectLinkEffects(effect, _.EffectModifyAttacks(1));
duration = 120f;
break;
case 4:
effect = _.EffectMovementSpeedIncrease(40);
effect = _.EffectLinkEffects(effect, _.EffectAbilityIncrease(_.ABILITY_DEXTERITY, 8));
effect = _.EffectLinkEffects(effect, _.EffectModifyAttacks(1));
duration = 150f;
break;
case 5:
effect = _.EffectMovementSpeedIncrease(50);
effect = _.EffectLinkEffects(effect, _.EffectAbilityIncrease(_.ABILITY_DEXTERITY, 10));
effect = _.EffectLinkEffects(effect, _.EffectModifyAttacks(1));
duration = 180f;
break;
default:
throw new ArgumentException(nameof(perkLevel) + " invalid. Value " + perkLevel + " is unhandled.");
}
// Check lucky chance.
int luck = PerkService.GetCreaturePerkLevel(creature, PerkType.Lucky);
if (RandomService.D100(1) <= luck)
{
duration *= 2;
creature.SendMessage("Lucky Force Speed!");
}
_.ApplyEffectToObject(_.DURATION_TYPE_TEMPORARY, effect, target, duration);
_.ApplyEffectToObject(_.DURATION_TYPE_INSTANT, _.EffectVisualEffect(_.VFX_IMP_AC_BONUS), target);
if (creature.IsPlayer)
{
NWPlayer player = creature.Object;
int skillLevel = SkillService.GetPCSkillRank(player, SkillType.ForceControl);
int xp = skillLevel * 10 + 10;
SkillService.GiveSkillXP(player, SkillType.ForceControl, xp);
}
}
