public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
NWPlayer player = user.Object;
var effectiveStats = _playerStat.GetPlayerItemEffectiveStats(player);
int skillRank = _skill.GetPCSkillRank(player, SkillType.Medicine);
int perkLevel = _perk.GetPCPerkLevel(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);
}
baseHeal = (int)(baseHeal * effectivenessPercent);
Player dbPlayer = _data.Single <Player>(x => x.ID == user.GlobalID);
int hpRecover = (int)(target.MaxHP * (0.01f * baseHeal));
int fpRecover = (int)(dbPlayer.MaxFP * (0.01f * baseHeal));
_.ApplyEffectToObject(DURATION_TYPE_INSTANT, _.EffectResurrection(), target);
_.ApplyEffectToObject(DURATION_TYPE_INSTANT, _.EffectHeal(hpRecover), target);
dbPlayer.CurrentFP = fpRecover;
_data.SubmitDataChange(dbPlayer, DatabaseActionType.Update);
player.SendMessage("You successfully resuscitate " + target.Name + "!");
if (target.IsPlayer)
{
int xp = (int)_skill.CalculateRegisteredSkillLevelAdjustedXP(600, item.RecommendedLevel, skillRank);
_skill.GiveSkillXP(player, SkillType.Medicine, xp);
}
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
_customEffect.RemovePCCustomEffect(target.Object, CustomEffectType.Poison);
foreach (Effect effect in target.Effects)
{
if (_.GetIsEffectValid(effect) == TRUE)
{
int effectType = _.GetEffectType(effect);
if (effectType == EFFECT_TYPE_POISON || effectType == EFFECT_TYPE_DISEASE)
{
_.RemoveEffect(target.Object, effect);
}
}
}
user.SendMessage("You successfully treat " + target.Name + "'s infection.");
int rank = _skill.GetPCSkillRank(user.Object, SkillType.Medicine);
if (target.IsPlayer)
{
int xp = (int)_skill.CalculateRegisteredSkillLevelAdjustedXP(300, item.RecommendedLevel, rank);
_skill.GiveSkillXP(user.Object, SkillType.Medicine, xp);
}
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
NWPlayer player = user.Object;
int ability = item.GetLocalInt("ABILITY_TYPE");
int amount = item.GetLocalInt("AMOUNT") + item.MedicineBonus;
int rank = player.IsPlayer ? _skill.GetPCSkillRank(player, SkillType.Medicine) : 0;
int recommendedLevel = item.RecommendedLevel;
float duration = 30.0f;
int perkLevel = player.IsPlayer ? _perk.GetPCPerkLevel(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(NWScript.DURATION_TYPE_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)_skill.CalculateRegisteredSkillLevelAdjustedXP(300, item.RecommendedLevel, rank);
_skill.GiveSkillXP(player, SkillType.Medicine, xp);
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
NWPlayer player = NWPlayer.Wrap(user.Object);
target.RemoveEffect(EFFECT_TYPE_REGENERATE);
PCSkill skill = _skill.GetPCSkill(player, SkillType.FirstAid);
int luck = _perk.GetPCPerkLevel(player, PerkType.Lucky);
int perkDurationBonus = _perk.GetPCPerkLevel(player, PerkType.HealingKitExpert) * 6 + (luck * 2);
float duration = 30.0f + (skill.Rank * 0.4f) + perkDurationBonus;
int restoreAmount = 1 + item.GetLocalInt("HEALING_BONUS") + player.EffectiveFirstAidBonus;
int perkBlastBonus = _perk.GetPCPerkLevel(player, PerkType.ImmediateImprovement);
if (perkBlastBonus > 0)
{
int blastHeal = restoreAmount * perkBlastBonus;
if (_random.Random(100) + 1 <= luck / 2)
{
blastHeal *= 2;
}
_.ApplyEffectToObject(DURATION_TYPE_INSTANT, _.EffectHeal(blastHeal), target.Object);
}
Effect regeneration = _.EffectRegenerate(restoreAmount, 6.0f);
_.ApplyEffectToObject(DURATION_TYPE_TEMPORARY, regeneration, target.Object, duration);
player.SendMessage("You successfully treat " + target.Name + "'s wounds.");
int xp = (int)_skill.CalculateRegisteredSkillLevelAdjustedXP(100, item.RecommendedLevel, skill.Rank);
_skill.GiveSkillXP(player, SkillType.FirstAid, xp);
}
private void RunCreateItem(NWPlayer oPC, NWPlaceable device)
{
var model = GetPlayerCraftingData(oPC);
CraftBlueprint blueprint = _db.CraftBlueprints.Single(x => x.CraftBlueprintID == model.BlueprintID);
PCSkill pcSkill = _db.PCSkills.Single(x => x.PlayerID == oPC.GlobalID && x.SkillID == blueprint.SkillID);
int pcEffectiveLevel = CalculatePCEffectiveLevel(oPC, device, pcSkill.Rank);
float chance = CalculateBaseChanceToAddProperty(pcEffectiveLevel, model.AdjustedLevel);
float equipmentBonus = CalculateEquipmentBonus(oPC, (SkillType)blueprint.SkillID);
var craftedItems = new List <NWItem>();
NWItem craftedItem = NWItem.Wrap(_.CreateItemOnObject(blueprint.ItemResref, oPC.Object, blueprint.Quantity));
craftedItem.IsIdentified = true;
craftedItems.Add(craftedItem);
// If item isn't stackable, loop through and create as many as necessary.
if (craftedItem.StackSize < blueprint.Quantity)
{
for (int x = 2; x <= blueprint.Quantity; x++)
{
craftedItem = NWItem.Wrap(_.CreateItemOnObject(blueprint.ItemResref, oPC.Object));
craftedItem.IsIdentified = true;
craftedItems.Add(craftedItem);
}
}
foreach (var component in model.MainComponents)
{
ComponentBonusType bonus = ComponentBonusType.Unknown;
foreach (var ip in component.ItemProperties)
{
if (_.GetItemPropertyType(ip) == (int)CustomItemPropertyType.ComponentBonus)
{
bonus = (ComponentBonusType)_.GetItemPropertyCostTableValue(ip);
}
}
if (bonus == ComponentBonusType.Unknown)
{
continue;
}
if (_random.RandomFloat() * 100.0f + equipmentBonus <= chance)
{
foreach (var item in craftedItems)
{
ApplyComponentBonus(item, bonus);
}
}
}
oPC.SendMessage("You created " + blueprint.Quantity + "x " + blueprint.ItemName + "!");
float xp = _skill.CalculateRegisteredSkillLevelAdjustedXP(250, model.AdjustedLevel, pcSkill.Rank);
_skill.GiveSkillXP(oPC, blueprint.SkillID, (int)xp);
ClearPlayerCraftingData(oPC);
}
public bool Run(params object[] args)
{
NWPlayer player = (NWPlayer)args[0];
string oreResref = (string)args[1];
List <ItemProperty> itemProperties = (List <ItemProperty>)args[2];
player.IsBusy = false;
int rank = _skill.GetPCSkillRank(player, SkillType.Engineering);
int level = _craft.GetIngotLevel(oreResref);
string ingotResref = _craft.GetIngotResref(oreResref);
if (level < 0 || string.IsNullOrWhiteSpace(ingotResref))
{
return(false);
}
int delta = rank - level;
int count = 2;
if (delta > 2)
{
count = delta;
}
if (count > 4)
{
count = 4;
}
if (_random.Random(100) + 1 <= _perk.GetPCPerkLevel(player, PerkType.Lucky))
{
count++;
}
if (_random.Random(100) + 1 <= _perk.GetPCPerkLevel(player, PerkType.ProcessingEfficiency) * 10)
{
count++;
}
for (int x = 1; x <= count; x++)
{
var item = (_.CreateItemOnObject(ingotResref, player.Object));
foreach (var ip in itemProperties)
{
_biowareXP2.IPSafeAddItemProperty(item, ip, 0.0f, AddItemPropertyPolicy.IgnoreExisting, true, true);
}
}
var effectiveStats = _playerStat.GetPlayerItemEffectiveStats(player);
int stronidiumAmount = 2 + effectiveStats.Harvesting;
_.CreateItemOnObject("stronidium", player.Object, stronidiumAmount);
int xp = (int)_skill.CalculateRegisteredSkillLevelAdjustedXP(100, level, rank);
_skill.GiveSkillXP(player, SkillType.Engineering, xp);
return(true);
}
public bool Run(params object[] args)
{
NWPlayer player = NWPlayer.Wrap(Object.OBJECT_SELF);
NWPlaceable forge = NWPlaceable.Wrap(player.GetLocalObject("FORGE"));
string resref = forge.GetLocalString("FORGE_ORE");
forge.DeleteLocalObject("FORGE_USER");
player.DeleteLocalObject("FORGE");
forge.DeleteLocalString("FORGE_ORE");
player.IsBusy = false;
PCSkill pcSkill = _skill.GetPCSkill(player, SkillType.Engineering);
int level = _craft.GetIngotLevel(resref);
string ingotResref = _craft.GetIngotResref(resref);
if (pcSkill == null || level < 0 || string.IsNullOrWhiteSpace(ingotResref))
{
return(false);
}
int delta = pcSkill.Rank - level;
int count = 2;
if (delta > 2)
{
count = delta;
}
if (count > 6)
{
count = 6;
}
if (_random.Random(100) + 1 <= _perk.GetPCPerkLevel(player, PerkType.Lucky))
{
count++;
}
if (_random.Random(100) + 1 <= _perk.GetPCPerkLevel(player, PerkType.ProcessingEfficiency) * 10)
{
count++;
}
for (int x = 1; x <= count; x++)
{
_.CreateItemOnObject(ingotResref, player.Object);
}
int xp = (int)_skill.CalculateRegisteredSkillLevelAdjustedXP(100, level, pcSkill.Rank);
_skill.GiveSkillXP(player, SkillType.Engineering, xp);
if (_random.Random(100) + 1 <= 3)
{
_food.DecreaseHungerLevel(player, 1);
}
return(true);
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
int growingPlantID = target.GetLocalInt("GROWING_PLANT_ID");
if (growingPlantID <= 0)
{
user.SendMessage("Water jugs can only target growing plants.");
return;
}
GrowingPlant growingPlant = _db.GrowingPlants.Single(x => x.GrowingPlantID == growingPlantID);
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;
}
PlayerCharacter pcEntity = _db.PlayerCharacters.Single(x => x.PlayerID == user.GlobalID);
// Farmers get a 5% chance to not expend a charge.
if (pcEntity.BackgroundID != (int)BackgroundType.Farmer || _random.Random(100) + 1 > 5)
{
item.Charges--;
}
int remainingTicks = growingPlant.RemainingTicks;
if (growingPlant.WaterStatus > 1)
{
remainingTicks = remainingTicks / 2;
}
growingPlant.WaterStatus = 0;
growingPlant.RemainingTicks = remainingTicks;
_db.SaveChanges();
user.SendMessage("You water the plant.");
PCSkill pcSkill = _skill.GetPCSkill((NWPlayer)user, SkillType.Farming);
if (pcSkill == null)
{
return;
}
int xp = (int)_skill.CalculateRegisteredSkillLevelAdjustedXP(100, growingPlant.Plant.Level, pcSkill.Rank);
_skill.GiveSkillXP((NWPlayer)user, SkillType.Farming, xp);
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
NWPlayer player = (user.Object);
var effectiveStats = _playerStat.GetPlayerItemEffectiveStats(player);
target.RemoveEffect(EFFECT_TYPE_REGENERATE);
int rank = _skill.GetPCSkillRank(player, SkillType.Medicine);
int luck = _perk.GetPCPerkLevel(player, PerkType.Lucky);
int perkDurationBonus = _perk.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 = _perk.GetPCPerkLevel(player, PerkType.ImmediateImprovement);
if (perkBlastBonus > 0)
{
int blastHeal = restoreAmount * perkBlastBonus;
if (_random.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;
}
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)_skill.CalculateRegisteredSkillLevelAdjustedXP(300, item.RecommendedLevel, rank);
_skill.GiveSkillXP(player, SkillType.Medicine, xp);
}
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
NWPlayer player = (user.Object);
var effectiveStats = _playerStat.GetPlayerItemEffectiveStats(player);
int rank = _skill.GetPCSkillRank(player, SkillType.Medicine);
int luck = _perk.GetPCPerkLevel(player, PerkType.Lucky);
int perkDurationBonus = _perk.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 = _perk.GetPCPerkLevel(player, PerkType.ImmediateForcePack);
if (perkBlastBonus > 0)
{
int blastHeal = restoreAmount * perkBlastBonus;
if (_random.Random(100) + 1 <= luck / 2)
{
blastHeal *= 2;
}
_ability.RestoreFP(target.Object, blastHeal);
}
float interval = 6.0f;
BackgroundType background = (BackgroundType)player.Class1;
if (background == BackgroundType.Medic)
{
interval *= 0.5f;
}
string data = (int)interval + ", " + restoreAmount;
_customEffect.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)_skill.CalculateRegisteredSkillLevelAdjustedXP(300, item.RecommendedLevel, rank);
_skill.GiveSkillXP(player, SkillType.Medicine, xp);
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
NWPlayer player = NWPlayer.Wrap(user.Object);
_customEffect.RemovePCCustomEffect((NWPlayer)target, CustomEffectType.Bleeding);
_.ApplyEffectToObject(DURATION_TYPE_INSTANT, _.EffectHeal(2 + player.EffectiveFirstAidBonus / 2), target.Object);
player.SendMessage("You finish bandaging " + target.Name + "'s wounds.");
PCSkill skill = _skill.GetPCSkill(player, SkillType.FirstAid);
int xp = (int)_skill.CalculateRegisteredSkillLevelAdjustedXP(100, item.RecommendedLevel, skill.Rank);
_skill.GiveSkillXP(player, SkillType.FirstAid, xp);
}
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 = _data.Single <GrowingPlant>(x => x.ID == new Guid(growingPlantID));
var plant = _data.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;
_data.SubmitDataChange(growingPlant, DatabaseActionType.Update);
user.SendMessage("You water the plant.");
int rank = _skill.GetPCSkillRank((NWPlayer)user, SkillType.Farming);
int xp = (int)_skill.CalculateRegisteredSkillLevelAdjustedXP(100, plant.Level, rank);
_skill.GiveSkillXP((NWPlayer)user, SkillType.Farming, xp);
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
NWPlayer player = (user.Object);
var effectiveStats = _playerStat.GetPlayerItemEffectiveStats(player);
_customEffect.RemovePCCustomEffect(target.Object, CustomEffectType.Bleeding);
player.SendMessage("You finish bandaging " + target.Name + "'s wounds.");
int rank = _skill.GetPCSkillRank(player, SkillType.Medicine);
int healAmount = 2 + effectiveStats.Medicine / 2;
healAmount += item.MedicineBonus;
if (rank >= item.RecommendedLevel && item.MedicineBonus > 0)
{
_.ApplyEffectToObject(DURATION_TYPE_INSTANT, _.EffectHeal(healAmount), target);
}
int xp = (int)_skill.CalculateRegisteredSkillLevelAdjustedXP(100, item.RecommendedLevel, rank);
_skill.GiveSkillXP(player, SkillType.Medicine, xp);
}
private void RunCreateItem(NWPlayer player)
{
var model = _craft.GetPlayerCraftingData(player);
CraftBlueprint blueprint = _data.Single <CraftBlueprint>(x => x.ID == model.BlueprintID);
BaseStructure baseStructure = blueprint.BaseStructureID == null ? null : _data.Get <BaseStructure>(blueprint.BaseStructureID);
PCSkill pcSkill = _skill.GetPCSkill(player, blueprint.SkillID);
int pcEffectiveLevel = _craft.CalculatePCEffectiveLevel(player, pcSkill.Rank, (SkillType)blueprint.SkillID);
int itemLevel = model.AdjustedLevel;
float chance = CalculateBaseChanceToAddProperty(pcEffectiveLevel, itemLevel);
float equipmentBonus = CalculateEquipmentBonus(player, (SkillType)blueprint.SkillID);
if (chance <= 1.0f)
{
player.FloatingText(_color.Red("Critical failure! You don't have enough skill to create that item. All components were lost."));
_craft.ClearPlayerCraftingData(player, true);
return;
}
int luckyBonus = _perk.GetPCPerkLevel(player, PerkType.Lucky);
var craftedItems = new List <NWItem>();
NWItem craftedItem = (_.CreateItemOnObject(blueprint.ItemResref, player.Object, blueprint.Quantity));
craftedItem.IsIdentified = true;
craftedItems.Add(craftedItem);
// If item isn't stackable, loop through and create as many as necessary.
if (craftedItem.StackSize < blueprint.Quantity)
{
for (int x = 2; x <= blueprint.Quantity; x++)
{
craftedItem = (_.CreateItemOnObject(blueprint.ItemResref, player.Object));
craftedItem.IsIdentified = true;
craftedItems.Add(craftedItem);
}
}
// Recommended level gets set regardless if all item properties make it on the final product.
// Also mark who crafted the item. This is later used for display on the item's examination event.
foreach (var item in craftedItems)
{
item.RecommendedLevel = itemLevel < 0 ? 0 : itemLevel;
item.SetLocalString("CRAFTER_PLAYER_ID", player.GlobalID.ToString());
_base.ApplyCraftedItemLocalVariables(item, baseStructure);
}
if (_random.Random(1, 100) <= luckyBonus)
{
chance += _random.Random(1, luckyBonus);
}
int successAmount = 0;
foreach (var component in model.MainComponents)
{
var result = RunComponentBonusAttempt(player, component, equipmentBonus, chance, craftedItems);
successAmount += result.Item1;
chance = result.Item2;
}
foreach (var component in model.SecondaryComponents)
{
var result = RunComponentBonusAttempt(player, component, equipmentBonus, chance, craftedItems);
successAmount += result.Item1;
chance = result.Item2;
}
foreach (var component in model.TertiaryComponents)
{
var result = RunComponentBonusAttempt(player, component, equipmentBonus, chance, craftedItems);
successAmount += result.Item1;
chance = result.Item2;
}
foreach (var component in model.EnhancementComponents)
{
var result = RunComponentBonusAttempt(player, component, equipmentBonus, chance, craftedItems);
successAmount += result.Item1;
chance = result.Item2;
}
// Structures gain increased durability based on the blueprint
if (baseStructure != null)
{
foreach (var item in craftedItems)
{
var maxDur = _durability.GetMaxDurability(item);
maxDur += (float)baseStructure.Durability;
_durability.SetMaxDurability(item, maxDur);
_durability.SetDurability(item, maxDur);
}
}
player.SendMessage("You created " + blueprint.Quantity + "x " + blueprint.ItemName + "!");
int baseXP = 250 + successAmount * _random.Random(1, 50);
float xp = _skill.CalculateRegisteredSkillLevelAdjustedXP(baseXP, model.AdjustedLevel, pcSkill.Rank);
var pcCraftedBlueprint = _data.SingleOrDefault <PCCraftedBlueprint>(x => x.PlayerID == player.GlobalID && x.CraftBlueprintID == blueprint.ID);
if (pcCraftedBlueprint == null)
{
xp = xp * 1.25f;
player.SendMessage("You receive an XP bonus for crafting this item for the first time.");
pcCraftedBlueprint = new PCCraftedBlueprint
{
CraftBlueprintID = blueprint.ID,
DateFirstCrafted = DateTime.UtcNow,
PlayerID = player.GlobalID
};
_data.SubmitDataChange(pcCraftedBlueprint, DatabaseActionType.Insert);
}
_skill.GiveSkillXP(player, blueprint.SkillID, (int)xp);
_craft.ClearPlayerCraftingData(player, true);
}
public void ApplyEffects(NWCreature user, NWItem modItem, NWObject target, Location targetLocation, CustomData customData)
{
NWPlayer player = (user.Object);
NWItem targetItem = (target.Object);
ModSlots slots = _mod.GetModSlots(targetItem);
CustomItemPropertyType modType = _mod.GetModType(modItem);
int modID = modItem.GetLocalInt("RUNE_ID");
string[] modArgs = modItem.GetLocalString("RUNE_VALUE").Split(',');
int modLevel = modItem.RecommendedLevel;
int levelIncrease = modItem.LevelIncrease;
var dbMod = _data.Single <Data.Entity.Mod>(x => x.ID == modID && x.IsActive);
App.ResolveByInterface <IMod>("Mod." + dbMod.Script, mod =>
{
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 " + _color.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 " + _color.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 " + _color.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 " + _color.Yellow("yellow") + " slot #" + (slots.FilledYellowSlots + 1));
}
else
{
usePrismatic = true;
}
break;
}
if (usePrismatic)
{
string prismaticText = _mod.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 (ItemService.ArmorBaseItemTypes.Contains(targetItem.BaseItemType))
{
skillType = SkillType.Armorsmith;
}
else if (ItemService.WeaponBaseItemTypes.Contains(targetItem.BaseItemType))
{
skillType = SkillType.Weaponsmith;
}
else
{
return;
}
int rank = _skill.GetPCSkillRank(player, skillType);
int xp = (int)_skill.CalculateRegisteredSkillLevelAdjustedXP(400, modLevel, rank);
_skill.GiveSkillXP(player, skillType, xp);
});
}
public bool Run(params object[] args)
{
NWPlaceable point = NWPlaceable.Wrap(Object.OBJECT_SELF);
const int baseChanceToFullyHarvest = 50;
bool alwaysDestroys = point.GetLocalInt("FORAGE_POINT_ALWAYS_DESTROYS") == 1;
NWPlayer oPC = NWPlayer.Wrap(_.GetLastOpenedBy());
bool hasBeenSearched = point.GetLocalInt("FORAGE_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("FORAGE_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);
}
PCSkill pcSkill = _skill.GetPCSkill(oPC, SkillType.Forage);
if (pcSkill == null)
{
return(false);
}
int lootTableID = point.GetLocalInt("FORAGE_POINT_LOOT_TABLE_ID");
int level = point.GetLocalInt("FORAGE_POINT_LEVEL");
int rank = pcSkill.Rank;
int delta = level - rank;
if (delta > 8)
{
oPC.SendMessage("You aren't skilled enough to forage 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 = _perk.GetPCPerkLevel(oPC, PerkType.Lucky) + oPC.EffectiveLuckBonus;
if (_random.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 = _random.Random(20) + 1;
if (roll >= dc)
{
oPC.FloatingText(_color.SkillCheck("Search: *success*: (" + roll + " vs. DC: " + dc + ")"));
ItemVO spawnItem = _loot.PickRandomItemFromLootTable(lootTableID);
if (spawnItem == null)
{
return(false);
}
if (!string.IsNullOrWhiteSpace(spawnItem.Resref) && spawnItem.Quantity > 0)
{
_.CreateItemOnObject(spawnItem.Resref, point.Object, spawnItem.Quantity);
}
float xp = _skill.CalculateRegisteredSkillLevelAdjustedXP(50, level, rank);
_skill.GiveSkillXP(oPC, SkillType.Forage, (int)xp);
}
else
{
oPC.FloatingText(_color.SkillCheck("Search: *failure*: (" + roll + " vs. DC: " + dc + ")"));
float xp = _skill.CalculateRegisteredSkillLevelAdjustedXP(10, level, rank);
_skill.GiveSkillXP(oPC, SkillType.Forage, (int)xp);
}
dc += _random.Random(3) + 1;
}
if (_random.Random(100) + 1 <= 3)
{
_food.DecreaseHungerLevel(oPC, 1);
}
// Chance to destroy the forage point.
int chanceToFullyHarvest = baseChanceToFullyHarvest - (_perk.GetPCPerkLevel(oPC, PerkType.CarefulForager) * 5);
int growingPlantID = point.GetLocalInt("GROWING_PLANT_ID");
if (growingPlantID > 0)
{
Data.Entities.GrowingPlant growingPlant = _farming.GetGrowingPlantByID(growingPlantID);
chanceToFullyHarvest = chanceToFullyHarvest - (growingPlant.LongevityBonus);
}
if (chanceToFullyHarvest <= 5)
{
chanceToFullyHarvest = 5;
}
if (alwaysDestroys || _random.Random(100) + 1 <= chanceToFullyHarvest)
{
point.SetLocalInt("FORAGE_POINT_FULLY_HARVESTED", 1);
oPC.SendMessage("This resource has been fully harvested...");
}
// Otherwise the forage point will be refilled in 10-20 minutes.
else
{
point.SetLocalInt("FORAGE_POINT_REFILL_TICKS", 100 + _random.Random(100));
}
point.SetLocalInt("FORAGE_POINT_DESPAWN_TICKS", 30);
return(true);
}
public void ApplyEffects(NWCreature user, NWItem runeItem, NWObject target, Location targetLocation, CustomData customData)
{
NWPlayer player = NWPlayer.Wrap(user.Object);
NWItem targetItem = NWItem.Wrap(target.Object);
RuneSlots slots = _rune.GetRuneSlots(targetItem);
CustomItemPropertyType runeType = _rune.GetRuneType(runeItem);
int runeID = runeItem.GetLocalInt("RUNE_ID");
string[] runeArgs = runeItem.GetLocalString("RUNE_VALUE").Split(',');
int runeLevel = runeItem.RecommendedLevel;
int levelIncrease = runeItem.LevelIncrease;
var dbRune = _db.Runes.Single(x => x.RuneID == runeID && x.IsActive);
IRune rune = App.ResolveByInterface <IRune>("Rune." + dbRune.Script);
rune.Apply(player, targetItem, runeArgs);
string description = rune.Description(player, targetItem, runeArgs);
bool usePrismatic = false;
switch (runeType)
{
case CustomItemPropertyType.RedRune:
if (slots.FilledRedSlots < slots.RedSlots)
{
targetItem.SetLocalInt("RUNIC_SLOT_RED_" + (slots.FilledRedSlots + 1), runeID);
targetItem.SetLocalString("RUNIC_SLOT_RED_DESC_" + (slots.FilledRedSlots + 1), description);
player.SendMessage("Rune installed into " + _color.Red("red") + " slot #" + (slots.FilledRedSlots + 1));
}
else
{
usePrismatic = true;
}
break;
case CustomItemPropertyType.BlueRune:
if (slots.FilledBlueSlots < slots.BlueSlots)
{
targetItem.SetLocalInt("RUNIC_SLOT_BLUE_" + (slots.FilledBlueSlots + 1), runeID);
targetItem.SetLocalString("RUNIC_SLOT_BLUE_DESC_" + (slots.FilledBlueSlots + 1), description);
player.SendMessage("Rune installed into " + _color.Blue("blue") + " slot #" + (slots.FilledBlueSlots + 1));
}
else
{
usePrismatic = true;
}
break;
case CustomItemPropertyType.GreenRune:
if (slots.FilledBlueSlots < slots.GreenSlots)
{
targetItem.SetLocalInt("RUNIC_SLOT_GREEN_" + (slots.FilledGreenSlots + 1), runeID);
targetItem.SetLocalString("RUNIC_SLOT_GREEN_DESC_" + (slots.FilledGreenSlots + 1), description);
player.SendMessage("Rune installed into " + _color.Green("green") + " slot #" + (slots.FilledGreenSlots + 1));
}
else
{
usePrismatic = true;
}
break;
case CustomItemPropertyType.YellowRune:
if (slots.FilledBlueSlots < slots.YellowSlots)
{
targetItem.SetLocalInt("RUNIC_SLOT_YELLOW_" + (slots.FilledYellowSlots + 1), runeID);
targetItem.SetLocalString("RUNIC_SLOT_YELLOW_DESC_" + (slots.FilledYellowSlots + 1), description);
player.SendMessage("Rune installed into " + _color.Yellow("yellow") + " slot #" + (slots.FilledYellowSlots + 1));
}
else
{
usePrismatic = true;
}
break;
}
if (usePrismatic)
{
string prismaticText = _rune.PrismaticString();
targetItem.SetLocalInt("RUNIC_SLOT_PRISMATIC_" + (slots.FilledPrismaticSlots + 1), runeID);
targetItem.SetLocalString("RUNIC_SLOT_PRISMATIC_DESC_" + (slots.FilledPrismaticSlots + 1), description);
player.SendMessage("Rune installed into " + prismaticText + " slot #" + (slots.FilledPrismaticSlots + 1));
}
targetItem.RecommendedLevel += levelIncrease;
runeItem.Destroy();
SkillType skillType;
if (_item.ArmorBaseItemTypes.Contains(targetItem.BaseItemType))
{
skillType = SkillType.Armorsmith;
}
else if (_item.WeaponBaseItemTypes.Contains(targetItem.BaseItemType))
{
skillType = SkillType.Weaponsmith;
}
else
{
return;
}
PCSkill pcSkill = _skill.GetPCSkill(player, skillType);
int xp = (int)_skill.CalculateRegisteredSkillLevelAdjustedXP(400, runeLevel, pcSkill.Rank);
_skill.GiveSkillXP(player, skillType, xp);
}
public bool Run(params object[] args)
{
NWPlaceable container = NWPlaceable.Wrap(Object.OBJECT_SELF);
NWPlayer oPC = NWPlayer.Wrap(_.GetLastDisturbed());
int type = _.GetInventoryDisturbType();
NWItem item = NWItem.Wrap(_.GetInventoryDisturbItem());
if (type != INVENTORY_DISTURB_TYPE_ADDED)
{
return(false);
}
int plantID = item.GetLocalInt("PLANT_ID");
if (plantID <= 0)
{
_item.ReturnItem(oPC, item);
oPC.SendMessage("You cannot plant that item.");
return(true);
}
Plant plant = _farming.GetPlantByID(plantID);
if (plant == null)
{
_item.ReturnItem(oPC, item);
oPC.SendMessage("You cannot plant that item.");
return(true);
}
PCSkill pcSkill = _skill.GetPCSkill(oPC, SkillType.Farming);
int rank = 0;
if (pcSkill != null)
{
rank = pcSkill.Rank;
}
if (rank + 2 < plant.Level)
{
_item.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 = _perk.GetPCPerkLevel(oPC, PerkType.FarmingEfficiency) * 2;
int ticks = (int)(plant.BaseTicks - ((_perk.GetPCPerkLevel(oPC, PerkType.ExpertFarmer) * 0.05f)) * plant.BaseTicks);
Data.Entities.GrowingPlant growingPlant = new Data.Entities.GrowingPlant();
growingPlant.PlantID = plant.PlantID;
growingPlant.RemainingTicks = ticks;
growingPlant.LocationAreaTag = areaTag;
growingPlant.LocationOrientation = _.GetFacingFromLocation(plantLocation);
growingPlant.LocationX = _.GetPositionFromLocation(plantLocation).m_X;
growingPlant.LocationY = _.GetPositionFromLocation(plantLocation).m_Y;
growingPlant.LocationZ = _.GetPositionFromLocation(plantLocation).m_Z;
growingPlant.IsActive = true;
growingPlant.DateCreated = DateTime.UtcNow;
growingPlant.LongevityBonus = perkBonus;
_db.GrowingPlants.Add(growingPlant);
_db.SaveChanges();
NWPlaceable hole = NWPlaceable.Wrap(container.GetLocalObject("FARM_SMALL_HOLE"));
NWPlaceable plantPlc = NWPlaceable.Wrap(_.CreateObject(OBJECT_TYPE_PLACEABLE, "growing_plant", hole.Location));
plantPlc.SetLocalInt("GROWING_PLANT_ID", growingPlant.GrowingPlantID);
plantPlc.Name = "Growing Plant (" + plant.Name + ")";
container.Destroy();
hole.Destroy();
int xp = (int)_skill.CalculateRegisteredSkillLevelAdjustedXP(200, plant.Level, rank);
if (_random.Random(100) + 1 <= _perk.GetPCPerkLevel(oPC, PerkType.Lucky) + oPC.EffectiveLuckBonus)
{
xp *= 2;
}
_skill.GiveSkillXP(oPC, SkillType.Farming, xp);
return(true);
}
public bool Run(params object[] args)
{
NWPlaceable container = (Object.OBJECT_SELF);
NWPlayer oPC = (_.GetLastDisturbed());
int type = _.GetInventoryDisturbType();
NWItem item = (_.GetInventoryDisturbItem());
var effectiveStats = _playerStat.GetPlayerItemEffectiveStats(oPC);
if (type != NWScript.INVENTORY_DISTURB_TYPE_ADDED)
{
return(false);
}
int plantID = item.GetLocalInt("PLANT_ID");
if (plantID <= 0)
{
_item.ReturnItem(oPC, item);
oPC.SendMessage("You cannot plant that item.");
return(true);
}
Plant plant = _farming.GetPlantByID(plantID);
if (plant == null)
{
_item.ReturnItem(oPC, item);
oPC.SendMessage("You cannot plant that item.");
return(true);
}
int rank = _skill.GetPCSkillRank(oPC, SkillType.Farming);
if (rank + 2 < plant.Level)
{
_item.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 = _perk.GetPCPerkLevel(oPC, PerkType.FarmingEfficiency) * 2;
int ticks = (int)(plant.BaseTicks - ((_perk.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
};
_data.SubmitDataChange(growingPlant, DatabaseActionType.Insert);
NWPlaceable hole = (container.GetLocalObject("FARM_SMALL_HOLE"));
NWPlaceable plantPlc = (_.CreateObject(NWScript.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)_skill.CalculateRegisteredSkillLevelAdjustedXP(200, plant.Level, rank);
if (_random.Random(100) + 1 <= _perk.GetPCPerkLevel(oPC, PerkType.Lucky) + effectiveStats.Luck)
{
xp *= 2;
}
_skill.GiveSkillXP(oPC, SkillType.Farming, xp);
return(true);
}
public bool Run(params object[] args)
{
NWPlaceable oSite = NWPlaceable.Wrap(Object.OBJECT_SELF);
NWPlayer oPC = NWPlayer.Wrap(_.GetLastAttacker(oSite.Object));
int constructionSiteID = _structure.GetConstructionSiteID(oSite);
if (constructionSiteID <= 0)
{
oPC.FloatingText("You must select a blueprint before you can build.");
oPC.ClearAllActions();
return(true);
}
NWItem weapon = NWItem.Wrap(_.GetLastWeaponUsed(oPC.Object));
int weaponType = weapon.BaseItemType;
if (weaponType != BASE_ITEM_LIGHTHAMMER)
{
oPC.FloatingText("A hammer must be equipped to build this structure.");
oPC.ClearAllActions();
return(true);
}
// Offhand weapons don't contribute to building.
if (weapon.Equals(oPC.LeftHand))
{
return(true);
}
if (!_structure.IsConstructionSiteValid(oSite))
{
oPC.FloatingText("Construction site is invalid. Please click the construction site to find out more.");
oPC.ClearAllActions();
return(true);
}
Data.Entities.ConstructionSite entity = _structure.GetConstructionSiteByID(constructionSiteID);
if (weapon.CraftTierLevel < entity.StructureBlueprint.CraftTierLevel)
{
oPC.FloatingText("Your hammer cannot be used with this blueprint. (Required Tool Level: " + entity.StructureBlueprint.CraftTierLevel + ")");
oPC.ClearAllActions();
return(true);
}
int rank = _skill.GetPCSkill(oPC, SkillType.Construction).Rank;
int mangleChance = CalculateMangleChance(oPC, entity.StructureBlueprint.Level, rank);
bool isMangle = _random.Random(100) + 1 <= mangleChance;
bool foundResource = false;
string updateMessage = "You lack the necessary resources...";
int totalAmount = 0;
foreach (ConstructionSiteComponent comp in entity.ConstructionSiteComponents)
{
if (comp.Quantity > 0 && !foundResource)
{
NWItem item = NWItem.Wrap(_.GetItemPossessedBy(oPC.Object, comp.StructureComponent.Resref));
if (item.IsValid)
{
int reuseChance = isMangle ? 0 : _perk.GetPCPerkLevel(oPC, PerkType.ConservativeConstruction) * 2 + _perk.GetPCPerkLevel(oPC, PerkType.Lucky) + oPC.EffectiveLuckBonus;
if (_random.Random(100) + 1 <= reuseChance)
{
oPC.SendMessage("You conserve a resource...");
}
else
{
item.ReduceItemStack();
}
if (isMangle)
{
oPC.SendMessage(_color.Red("You mangle a resource due to your lack of skill..."));
return(true);
}
string name = _item.GetNameByResref(comp.StructureComponent.Resref);
comp.Quantity--;
updateMessage = "You need " + comp.Quantity + " " + name + " to complete this project.";
foundResource = true;
}
}
totalAmount += comp.Quantity;
}
oPC.DelayCommand(() => oPC.SendMessage(updateMessage), 0.75f);
if (totalAmount <= 0)
{
_structure.CompleteStructure(oSite);
}
else if (foundResource)
{
_structure.SaveChanges();
_durability.RunItemDecay(oPC, weapon);
if (entity.StructureBlueprint.GivesSkillXP)
{
int xp = (int)_skill.CalculateRegisteredSkillLevelAdjustedXP(100, 0, rank);
_skill.GiveSkillXP(oPC, SkillType.Construction, xp);
}
// Speedy Builder - Grants haste for 8 seconds
int hasteChance = _perk.GetPCPerkLevel(oPC, PerkType.SpeedyBuilder) * 10;
if (hasteChance > 0)
{
hasteChance += _perk.GetPCPerkLevel(oPC, PerkType.Lucky) * 2 + oPC.EffectiveLuckBonus;
}
PlayerCharacter pcEntity = _player.GetPlayerEntity(oPC);
if (pcEntity.BackgroundID == (int)BackgroundType.ConstructionBuilder)
{
hasteChance += 10;
}
if (_random.Random(100) + 1 <= hasteChance)
{
_.ApplyEffectToObject(DURATION_TYPE_TEMPORARY, _.EffectHaste(), oPC.Object, 8.0f);
}
}
else
{
oPC.ClearAllActions();
}
return(true);
}
public bool Run(params object[] args)
{
NWPlaceable resource = NWPlaceable.Wrap(Object.OBJECT_SELF);
NWPlayer oPC = NWPlayer.Wrap(_.GetLastDamager(resource.Object));
if (oPC.GetLocalInt("NOT_USING_CORRECT_WEAPON") == 1)
{
oPC.DeleteLocalInt("NOT_USING_CORRECT_WEAPON");
return(true);
}
PlayerCharacter pcEntity = _db.PlayerCharacters.Single(x => x.PlayerID == oPC.GlobalID);
NWItem oWeapon = NWItem.Wrap(_.GetLastWeaponUsed(oPC.Object));
Location location = oPC.Location;
string resourceItemResref = resource.GetLocalString("RESOURCE_RESREF");
int activityID = resource.GetLocalInt("RESOURCE_ACTIVITY");
string resourceName = resource.GetLocalString("RESOURCE_NAME");
int resourceCount = resource.GetLocalInt("RESOURCE_COUNT");
int difficultyRating = resource.GetLocalInt("RESOURCE_DIFFICULTY_RATING");
int weaponChanceBonus;
SkillType skillType;
int perkChanceBonus;
int secondResourceChance;
int durabilityChanceReduction = 0;
int hasteChance;
int lucky = _perk.GetPCPerkLevel(oPC, PerkType.Lucky) + oPC.EffectiveLuckBonus;
bool hasBaggerPerk;
if (activityID == 1) // 1 = Logging
{
weaponChanceBonus = oWeapon.LoggingBonus;
if (weaponChanceBonus > 0)
{
weaponChanceBonus += _perk.GetPCPerkLevel(oPC, PerkType.LoggingAxeExpert) * 5;
durabilityChanceReduction = _perk.GetPCPerkLevel(oPC, PerkType.LoggingAxeExpert) * 10 + lucky;
}
skillType = SkillType.Logging;
perkChanceBonus = _perk.GetPCPerkLevel(oPC, PerkType.Lumberjack) * 5 + lucky;
secondResourceChance = _perk.GetPCPerkLevel(oPC, PerkType.PrecisionLogging) * 10;
hasteChance = _perk.GetPCPerkLevel(oPC, PerkType.SpeedyLogger) * 10 + lucky;
if (pcEntity.BackgroundID == (int)BackgroundType.Lumberjack)
{
hasteChance += 10;
}
hasBaggerPerk = _perk.GetPCPerkLevel(oPC, PerkType.WoodBagger) > 0;
}
else if (activityID == 2) // Mining
{
weaponChanceBonus = oWeapon.MiningBonus;
if (weaponChanceBonus > 0)
{
weaponChanceBonus += _perk.GetPCPerkLevel(oPC, PerkType.PickaxeExpert) * 5;
durabilityChanceReduction = _perk.GetPCPerkLevel(oPC, PerkType.PickaxeExpert) * 10 + lucky;
}
skillType = SkillType.Mining;
perkChanceBonus = _perk.GetPCPerkLevel(oPC, PerkType.Miner) * 5 + lucky;
secondResourceChance = _perk.GetPCPerkLevel(oPC, PerkType.PrecisionMining) * 10;
hasteChance = _perk.GetPCPerkLevel(oPC, PerkType.SpeedyMiner) * 10 + lucky;
if (pcEntity.BackgroundID == (int)BackgroundType.Miner)
{
hasteChance += 10;
}
hasBaggerPerk = _perk.GetPCPerkLevel(oPC, PerkType.OreBagger) > 0;
}
else
{
return(false);
}
PCSkill skill = _skill.GetPCSkillByID(oPC.GlobalID, (int)skillType);
int durabilityLossChance = 100 - durabilityChanceReduction;
if (_random.Random(100) <= durabilityLossChance)
{
_durability.RunItemDecay(oPC, oWeapon);
}
int baseChance = 10;
int chance = baseChance + weaponChanceBonus;
chance += CalculateSuccessChanceDeltaModifier(difficultyRating, skill.Rank);
chance += perkChanceBonus;
bool givePityItem = false;
if (chance > 0)
{
if (_random.Random(100) + 1 <= hasteChance)
{
_.ApplyEffectToObject(DURATION_TYPE_TEMPORARY, _.EffectHaste(), oPC.Object, 8.0f);
}
// Give an item if the player hasn't gotten anything after 6-8 attempts.
int attemptFailureCount = oPC.GetLocalInt("RESOURCE_ATTEMPT_FAILURE_COUNT") + 1;
NWObject failureResource = NWObject.Wrap(oPC.GetLocalObject("RESOURCE_ATTEMPT_FAILURE_OBJECT"));
if (!failureResource.IsValid || !Equals(failureResource, resource))
{
failureResource = resource;
attemptFailureCount = 1;
}
int pityItemChance = 0;
if (attemptFailureCount == 6)
{
pityItemChance = 60;
}
else if (attemptFailureCount == 7)
{
pityItemChance = 80;
}
else if (attemptFailureCount >= 8)
{
pityItemChance = 100;
}
if (_random.Random(100) + 1 <= pityItemChance)
{
givePityItem = true;
attemptFailureCount = 0;
}
oPC.SetLocalInt("RESOURCE_ATTEMPT_FAILURE_COUNT", attemptFailureCount);
oPC.SetLocalObject("RESOURCE_ATTEMPT_FAILURE_OBJECT", failureResource.Object);
}
if (chance <= 0)
{
oPC.FloatingText("You do not have enough skill to harvest this resource...");
}
else if (_random.Random(100) <= chance || givePityItem)
{
if (hasBaggerPerk)
{
_.CreateItemOnObject(resourceItemResref, oPC.Object);
}
else
{
_.CreateObject(OBJECT_TYPE_ITEM, resourceItemResref, location);
}
oPC.FloatingText("You break off some " + resourceName + ".");
resource.SetLocalInt("RESOURCE_COUNT", --resourceCount);
_.ApplyEffectToObject(DURATION_TYPE_INSTANT, _.EffectHeal(10000), resource.Object);
if (_random.Random(100) + 1 <= secondResourceChance)
{
oPC.FloatingText("You break off a second piece.");
if (hasBaggerPerk)
{
_.CreateItemOnObject(resourceItemResref, oPC.Object);
}
else
{
_.CreateObject(OBJECT_TYPE_ITEM, resourceItemResref, location);
}
}
float deltaModifier = CalculateXPDeltaModifier(difficultyRating, skill.Rank);
float baseXP = (100 + _random.Random(20)) * deltaModifier;
int xp = (int)_skill.CalculateRegisteredSkillLevelAdjustedXP(baseXP, oWeapon.RecommendedLevel, skill.Rank);
_skill.GiveSkillXP(oPC, skillType, xp);
oPC.DeleteLocalInt("RESOURCE_ATTEMPT_FAILURE_COUNT");
oPC.DeleteLocalObject("RESOURCE_ATTEMPT_FAILURE_OBJECT");
}
if (resourceCount <= 0)
{
SpawnSeed(resource, oPC);
NWObject prop = NWObject.Wrap(resource.GetLocalObject("RESOURCE_PROP_OBJ"));
if (prop.IsValid)
{
prop.Destroy();
}
resource.Destroy();
}
return(true);
}