public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
target.RemoveEffect(EFFECT_TYPE_REGENERATE);
PCSkill skill = _skill.GetPCSkill((NWPlayer)user, SkillType.FirstAid);
int luck = _perk.GetPCPerkLevel((NWPlayer)user, PerkType.Lucky);
int perkDurationBonus = _perk.GetPCPerkLevel((NWPlayer)user, PerkType.HealingKitExpert) * 6 + (luck * 2);
float duration = 30.0f + (skill.Rank * 0.4f) + perkDurationBonus;
int restoreAmount = 1 + item.GetLocalInt("HEALING_BONUS");
int perkBlastBonus = _perk.GetPCPerkLevel((NWPlayer)user, 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);
user.SendMessage("You successfully treat " + target.Name + "'s wounds.");
int xp = (int)_skill.CalculateSkillAdjustedXP(100, item.RecommendedLevel, skill.Rank);
_skill.GiveSkillXP((NWPlayer)user, SkillType.FirstAid, xp);
}
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.Metalworking);
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.SmeltingMastery) * 10)
{
count++;
}
for (int x = 1; x <= count; x++)
{
_.CreateItemOnObject(ingotResref, player.Object);
}
int xp = (int)_skill.CalculateSkillAdjustedXP(100, level, pcSkill.Rank);
_skill.GiveSkillXP(player, SkillType.Metalworking, 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.CalculateSkillAdjustedXP(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)
{
_customEffect.RemovePCCustomEffect((NWPlayer)target, CustomEffectType.Bleeding);
_.ApplyEffectToObject(DURATION_TYPE_INSTANT, _.EffectHeal(2), target.Object);
user.SendMessage("You finish bandaging " + target.Name + "'s wounds.");
PCSkill skill = _skill.GetPCSkill((NWPlayer)user, SkillType.FirstAid);
int xp = (int)_skill.CalculateSkillAdjustedXP(100, item.RecommendedLevel, skill.Rank);
_skill.GiveSkillXP((NWPlayer)user, SkillType.FirstAid, xp);
}
public void ApplyEffects(NWCreature user, NWItem item, NWObject target, Location targetLocation, CustomData customData)
{
_customEffect.RemovePCCustomEffect((NWPlayer)target, 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.");
PCSkill skill = _skill.GetPCSkill((NWPlayer)user, SkillType.FirstAid);
int xp = (int)_skill.CalculateSkillAdjustedXP(100, item.RecommendedLevel, skill.Rank);
_skill.GiveSkillXP((NWPlayer)user, SkillType.FirstAid, xp);
}
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);
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.CalculateSkillAdjustedXP(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;
}
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 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);
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.CalculateSkillAdjustedXP(50, level, rank);
_skill.GiveSkillXP(oPC, SkillType.Forage, (int)xp);
}
else
{
oPC.FloatingText(_color.SkillCheck("Search: *failure*: (" + roll + " vs. DC: " + dc + ")"));
float xp = _skill.CalculateSkillAdjustedXP(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);
}
private void RunCreateItem(NWPlayer oPC, NWPlaceable device, int blueprintID)
{
NWPlaceable tempStorage = NWPlaceable.Wrap(device.GetLocalObject("CRAFT_TEMP_STORAGE"));
NWItem tools = NWItem.Wrap(device.GetLocalObject("CRAFT_DEVICE_TOOLS"));
CraftBlueprint blueprint = _db.CraftBlueprints.Single(x => x.CraftBlueprintID == blueprintID);
PCSkill pcSkill = _db.PCSkills.Single(x => x.PlayerID == oPC.GlobalID && x.SkillID == blueprint.SkillID);
int pcEffectiveLevel = CalculatePCEffectiveLevel(oPC, device, pcSkill.Rank);
float chance = CalculateChanceToCreateItem(pcEffectiveLevel, blueprint.Level);
float roll = _random.RandomFloat() * 100.0f;
float xpModifier;
if (roll <= chance)
{
// Success!
foreach (NWItem item in tempStorage.InventoryItems)
{
item.Destroy();
}
NWItem craftedItem = NWItem.Wrap(_.CreateItemOnObject(blueprint.ItemResref, oPC.Object, blueprint.Quantity));
craftedItem.IsIdentified = true;
// 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;
}
}
oPC.SendMessage("You created " + blueprint.Quantity + "x " + blueprint.ItemName + "!");
xpModifier = 1.0f;
}
else
{
// Failure...
int chanceToLoseItems = 20;
foreach (NWItem item in tempStorage.InventoryItems)
{
if (_random.Random(100) > chanceToLoseItems)
{
_.CopyItem(item.Object, device.Object, TRUE);
}
item.Destroy();
}
oPC.SendMessage("You failed to create that item...");
xpModifier = 0.2f;
}
float xp = _skill.CalculateSkillAdjustedXP(250, blueprint.Level, pcSkill.Rank) * xpModifier;
tempStorage.Destroy();
_skill.GiveSkillXP(oPC, blueprint.SkillID, (int)xp);
if (tools.IsValid)
{
float min = 0.05f;
float max = 0.1f;
float reduceDurability = min + _random.RandomFloat() * (max - min);
_durability.RunItemDecay(oPC, tools, reduceDurability);
}
if (_random.Random(100) + 1 <= 3)
{
_food.DecreaseHungerLevel(oPC, 1);
}
}
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);
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.CalculateSkillAdjustedXP(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);
}
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.CalculateSkillAdjustedXP(200, plant.Level, rank);
if (_random.Random(100) + 1 <= _perk.GetPCPerkLevel(oPC, PerkType.Lucky))
{
xp *= 2;
}
_skill.GiveSkillXP(oPC, SkillType.Farming, xp);
return(true);
}
