/// <summary>
/// Determines whether oItem has nProperty.
/// - oItem
/// - nProperty: ITEM_PROPERTY_*
/// * Returns FALSE if oItem is not a valid item, or if oItem does not have
/// nProperty.
/// </summary>
public static int GetItemHasItemProperty(uint oItem, ItemPropertyType nProperty)
{
Internal.NativeFunctions.StackPushInteger((int)nProperty);
Internal.NativeFunctions.StackPushObject(oItem);
Internal.NativeFunctions.CallBuiltIn(398);
return(Internal.NativeFunctions.StackPopInteger());
}
/// <summary>
/// Determines whether oItem has nProperty.
/// - oItem
/// - nProperty: ITEM_PROPERTY_*
/// * Returns FALSE if oItem is not a valid item, or if oItem does not have
/// nProperty.
/// </summary>
public static bool GetItemHasItemProperty(uint oItem, ItemPropertyType nProperty)
{
Internal.NativeFunctions.StackPushInteger(nProperty.InternalValue);
Internal.NativeFunctions.StackPushObject(oItem);
Internal.NativeFunctions.CallBuiltIn(398);
return(Internal.NativeFunctions.StackPopInteger() == 1);
}
private ItemProperty_Template CreateTemplate(string line)
{
string typeID = string.Empty;
ItemPropertyType itemPropertyType = ItemPropertyType.None;
string itemPropertyName = string.Empty;
Sprite icon = null;
string[] entries = line.Split(',');
for (int i = 0; i < entries.Length; i++)
{
string entry = entries[i];
switch (entry)
{
case INST_SET_Type:
typeID = entries[++i];
itemPropertyType = ConvertType.CheckItemProperty(typeID);
break;
case INST_SET_Name:
itemPropertyName = entries[++i];
break;
case INST_SET_Icon:
icon = Resources.Load <Sprite>(entries[++i]);
break;
}
}
return(new ItemProperty_Template(typeID, itemPropertyType, itemPropertyName, icon));
}
/// <summary>
/// // ----------------------------------------------------------------------------
/// Removes all itemproperties with matching nItemPropertyType and
/// nItemPropertyDuration (a DURATION_TYPE_* constant)
/// ----------------------------------------------------------------------------
/// </summary>
/// <param name="oItem"></param>
/// <param name="nItemPropertyType"></param>
/// <param name="nItemPropertyDuration"></param>
/// <param name="nItemPropertySubType"></param>
public static void IPRemoveMatchingItemProperties(uint oItem, ItemPropertyType nItemPropertyType, DurationType nItemPropertyDuration, int nItemPropertySubType)
{
for (var prop = GetFirstItemProperty(oItem); GetIsItemPropertyValid(prop); prop = GetNextItemProperty(oItem))
{
// same property type?
if (GetItemPropertyType(prop) == nItemPropertyType)
{
// same duration or duration ignored?
if (GetItemPropertyDurationType(prop) == nItemPropertyDuration || nItemPropertyDuration == DurationType.Invalid)
{
// same subtype or subtype ignored
if (GetItemPropertySubType(prop) == nItemPropertySubType || nItemPropertySubType == -1)
{
// Put a warning into the logfile if someone tries to remove a permanent ip with a temporary one!
/*if (nItemPropertyDuration == DurationType.Temporary && GetItemPropertyDurationType(ip) == DurationType.Permanent)
* {
* WriteTimestampedLogEntry("x2_inc_itemprop:: IPRemoveMatchingItemProperties() - WARNING: Permanent item property removed by temporary on "+GetTag(oItem));
* }
*/
RemoveItemProperty(oItem, prop);
}
}
}
}
}
private Sprite GetItempropertyIcon(ItemPropertyType type)
{
if (type != ItemPropertyType.None)
{
return(itemTemplateController.ItemPropertyDic[type].Icon);
}
else
{
return(null);
}
}
private string GetItempropertyName(ItemPropertyType type)
{
if (type != ItemPropertyType.None)
{
return(itemTemplateController.ItemPropertyDic[type].ItemPropertyName);
}
else
{
return("บางอย่างที่ลึกลับ");
}
}
// Token: 0x06001C60 RID: 7264 RVA: 0x0008FDFC File Offset: 0x0008DFFC
private float CalculateBoost(ItemPropertyType propType)
{
float num = 0f;
foreach (InventoryItem inventoryItem in Singleton <InventoryManager> .Instance.InventoryItems)
{
if (inventoryItem.IsValid)
{
Dictionary <ItemPropertyType, int> itemProperties = inventoryItem.Item.View.ItemProperties;
if (itemProperties != null && itemProperties.ContainsKey(propType))
{
num = Mathf.Max(num, (float)inventoryItem.Item.View.ItemProperties[propType] / 100f);
}
}
}
return(num);
}
public static ItemPropertyType GetModType(NWItem item)
{
ItemPropertyType ipType = ItemPropertyType.Invalid;
foreach (var ip in item.ItemProperties)
{
var type = _.GetItemPropertyType(ip);
if (type == ItemPropertyType.RedMod ||
type == ItemPropertyType.BlueMod ||
type == ItemPropertyType.GreenMod ||
type == ItemPropertyType.YellowMod)
{
ipType = (ItemPropertyType)type;
break;
}
}
return(ipType);
}
/// <summary>
/// Parses a string value from an XML file to an object of the appropriate type.
/// </summary>
/// <param name="stringValue"></param>
/// <param name="type"></param>
/// <returns></returns>
private static object Parse(string stringValue, ItemPropertyType type)
{
switch (type)
{
case ItemPropertyType.Boolean:
return(bool.Parse(stringValue));
case ItemPropertyType.Text:
return(stringValue);
case ItemPropertyType.Image:
return(new BitmapImage(new Uri("pack://siteOfOrigin:,,,/" + stringValue)));
case ItemPropertyType.Price:
return(stringValue);
default:
return(null);
}
}
private void CreateValue(ItemPropertyAmount itemProperty)
{
ActiveProperties(true);
float amount = itemProperty.Amount;
ItemPropertyType type = itemProperty.PropertyType;
GameObject copy;
copy = Instantiate(_itemReceivePropertyTemplatePrefab, transform);
copy.transform.GetChild(0).GetComponent <Image>().sprite = GetItempropertyIcon(type); //property icon
copy.transform.GetChild(1).GetComponent <TMP_Text>().text = GetItempropertyName(type); //property name
TMP_Text value = copy.transform.GetChild(2).GetComponent <TMP_Text>(); //property value
if (CheckAmountIsFloat(amount))
{
value.text = string.Format("{0:p2}", amount);
}
else
{
value.text = string.Format("{0:n0}", amount);
}
}
/// <summary>
/// Constructor. Builds the item from raw XML data.
/// </summary>
/// <param name="xmlProperty"></param>
internal ItemProperty(XmlItemSerialization.ItemProperty xmlProperty)
{
name = xmlProperty.Name;
propertyType = xmlProperty.PropertyType;
}
/// <summary>
/// "Mapping" the item
/// </summary>
/// <param name="item"></param>
/// <param name="propertyType"></param>
/// <returns></returns>
private string GetItemDataByItemPropertyType(ItemDto item, ItemPropertyType propertyType)
{
switch (propertyType)
{
case ItemPropertyType.InventoryNumber:
return(item.InventoryNumber);
case ItemPropertyType.OldInventoryNumber:
return(item.OldInventoryNumber);
case ItemPropertyType.SerialNumber:
return(item.SerialNumber);
case ItemPropertyType.AccreditationNumber:
return(item.AccreditationNumber);
case ItemPropertyType.YellowNumber:
return(item.YellowNumber?.ToString());
case ItemPropertyType.ItemName:
return(item.ItemName);
case ItemPropertyType.ManufacturerModelType:
return(item.ManufacTurerModelType);
case ItemPropertyType.ItemNature:
return(item.ItemNature?.Name);
case ItemPropertyType.ItemType:
return(item.ItemType?.Name);
case ItemPropertyType.ProductionYear:
return(item.ProductionYear?.ToShortDateString());
case ItemPropertyType.Department:
return(item.Department?.Name);
case ItemPropertyType.Section:
return(item.Section?.Name);
case ItemPropertyType.Employee:
return(item.Employee?.Name);
case ItemPropertyType.Building:
return(item.Building?.Name);
case ItemPropertyType.Floor:
return(item.Floor?.Name);
case ItemPropertyType.Room:
return(item.Room);
case ItemPropertyType.ItemState:
return(item.ItemState?.Name);
case ItemPropertyType.DateOfCreation:
return(item.DateOfCreation?.ToShortDateString());
case ItemPropertyType.BruttoPrice:
return(item.BruttoPrice?.ToString());
case ItemPropertyType.Comment:
return(item.Comment);
case ItemPropertyType.DateOfScrap:
return(item.DateOfScrap?.ToShortDateString());
default:
return(null);
}
}
public void Unequip()
{
List <ItemPropertyAmount> properties = new List <ItemPropertyAmount>();
properties = itemDefinition.ItemProperties;
int count = properties.Count;
if (count > 0)
{
for (int i = 0; i < count; i++)
{
ItemPropertyType type = properties[i].PropertyType;
float value = properties[i].Amount;
switch (type)
{
case ItemPropertyType.Charm:
otherBonusController.ReduceCharm(value);
break;
case ItemPropertyType.BonusProject:
otherBonusController.ReduceReduceBugChance(value);
break;
case ItemPropertyType.BonusProjectGoldenTime:
otherBonusController.ReduceBootupProjectInGoldenTime(value);
break;
case ItemPropertyType.BonusMotivation:
otherBonusController.ReduceBootupMotivation(value);
break;
case ItemPropertyType.BonusMotivationGoldenTime:
otherBonusController.ReduceBootupMotivationInGoldenTime(value);
break;
case ItemPropertyType.ReduceEnergyConsume:
otherBonusController.ReduceEnergyConsume(value);
break;
case ItemPropertyType.ReduceEnergyConsumeGoldenTime:
otherBonusController.ReduceEnergyConsumeInGoldenTime(value);
break;
case ItemPropertyType.ReduceChanceBug:
otherBonusController.ReduceReduceBugChance(value);
break;
case ItemPropertyType.ReduceCourseTime:
otherBonusController.ReduceReduceTimeCourse(value);
break;
case ItemPropertyType.ReduceTransportTime:
otherBonusController.ReduceReduceTimeTransport(value);
break;
case ItemPropertyType.IncreaseDropRate:
otherBonusController.ReduceDropRate(value);
break;
case ItemPropertyType.MaxEnergy:
otherBonusController.ReduceMaxEnergy((int)value);
break;
case ItemPropertyType.Coding:
otherBonusController.ReduceCodingStatus((int)value);
break;
case ItemPropertyType.Design:
otherBonusController.ReduceDesignStatus((int)value);
break;
case ItemPropertyType.Testing:
otherBonusController.ReduceTestingStatus((int)value);
break;
case ItemPropertyType.Art:
otherBonusController.ReduceArtStatus((int)value);
break;
case ItemPropertyType.Sound:
otherBonusController.ReduceSoundStatus((int)value);
break;
}
}
}
}
/// <summary>
/// Parses a string value from an XML file to an object of the appropriate type.
/// </summary>
/// <param name="stringValue"></param>
/// <param name="type"></param>
/// <returns></returns>
private static object Parse(string stringValue, ItemPropertyType type)
{
switch (type)
{
case ItemPropertyType.Boolean:
return bool.Parse(stringValue);
case ItemPropertyType.Text:
return stringValue;
case ItemPropertyType.Image:
return new BitmapImage(new Uri("pack://siteOfOrigin:,,,/" + stringValue));
case ItemPropertyType.Price:
return stringValue;
default:
return null;
}
}
public static ItemPropertyType CheckItemProperty(string text)
{
ItemPropertyType temp = ItemPropertyType.None;
switch (text)
{
case INST_Itemproperty_Charm:
temp = ItemPropertyType.Charm;
break;
case INST_Itemproperty_BonusProject:
temp = ItemPropertyType.BonusProject;
break;
case INST_Itemproperty_BonusProjectGoldenTime:
temp = ItemPropertyType.BonusProjectGoldenTime;
break;
case INST_Itemproperty_BonusMotivation:
temp = ItemPropertyType.BonusMotivation;
break;
case INST_Itemproperty_BonusMotivationGoldenTime:
temp = ItemPropertyType.BonusMotivationGoldenTime;
break;
case INST_Itemproperty_ReduceEnergyConsume:
temp = ItemPropertyType.ReduceEnergyConsume;
break;
case INST_Itemproperty_ReduceEnergyConsumeGoldenTime:
temp = ItemPropertyType.ReduceEnergyConsumeGoldenTime;
break;
case INST_Itemproperty_ReduceChanceBug:
temp = ItemPropertyType.ReduceChanceBug;
break;
case INST_Itemproperty_ReduceCourseTime:
temp = ItemPropertyType.ReduceCourseTime;
break;
case INST_Itemproperty_ReduceTransportTime:
temp = ItemPropertyType.ReduceTransportTime;
break;
case INST_Itemproperty_IncreaseDropRate:
temp = ItemPropertyType.IncreaseDropRate;
break;
case INST_Itemproperty_Energy:
temp = ItemPropertyType.Energy;
break;
case INST_Itemproperty_MaxEnergy:
temp = ItemPropertyType.MaxEnergy;
break;
case INST_Itemproperty_Motivation:
temp = ItemPropertyType.Motivation;
break;
case INST_Itemproperty_Coding:
temp = ItemPropertyType.Coding;
break;
case INST_Itemproperty_Design:
temp = ItemPropertyType.Design;
break;
case INST_Itemproperty_Testing:
temp = ItemPropertyType.Testing;
break;
case INST_Itemproperty_Art:
temp = ItemPropertyType.Art;
break;
case INST_Itemproperty_Sound:
temp = ItemPropertyType.Sound;
break;
case INST_Itemproperty_StatusPoint:
temp = ItemPropertyType.StatusPoint;
break;
case INST_Itemproperty_SoftSkillPoint:
temp = ItemPropertyType.SoftSkillPoint;
break;
case INST_Itemproperty_CharacterExp:
temp = ItemPropertyType.CharacterExp;
break;
case INST_Itemproperty_HSMathExp:
temp = ItemPropertyType.HSMathExp;
break;
case INST_Itemproperty_HSProgramingExp:
temp = ItemPropertyType.HSProgramingExp;
break;
case INST_Itemproperty_HSEngineExp:
temp = ItemPropertyType.HSEngineExp;
break;
case INST_Itemproperty_HSNetworkExp:
temp = ItemPropertyType.HSNetworkExp;
break;
case INST_Itemproperty_HSAiExp:
temp = ItemPropertyType.HSAiExp;
break;
case INST_Itemproperty_HSDesignExp:
temp = ItemPropertyType.HSDesignExp;
break;
case INST_Itemproperty_HSTesting:
temp = ItemPropertyType.HSTesting;
break;
case INST_Itemproperty_HSArtExp:
temp = ItemPropertyType.HSArtExp;
break;
case INST_Itemproperty_HSSoundExp:
temp = ItemPropertyType.HSSoundExp;
break;
}
return(temp);
}
public void UseItem()
{
List <ItemPropertyAmount> properties = new List <ItemPropertyAmount>();
properties = itemDefinition.ItemProperties;
int count = properties.Count;
if (count > 0)
{
for (int i = 0; i < count; i++)
{
ItemPropertyType type = properties[i].PropertyType;
float value = properties[i].Amount;
switch (type)
{
case ItemPropertyType.Energy:
characterStatusController.IncreaseCurrentEnergy(value);
break;
case ItemPropertyType.Motivation:
characterStatusController.IncreaseCurrentMotivation(value);
break;
case ItemPropertyType.StatusPoint:
characterStatusController.IncreaseStatusPoints((int)value);
break;
case ItemPropertyType.SoftSkillPoint:
characterStatusController.IncreaseSoftSkillPoints((int)value);
break;
case ItemPropertyType.CharacterExp:
characterStatusController.IncreaseEXP((int)value);
break;
case ItemPropertyType.HSMathExp:
hardSkillsController.IncreaseEXP(hardSkillsController.INST_Math_Id, (int)value);
break;
case ItemPropertyType.HSProgramingExp:
hardSkillsController.IncreaseEXP(hardSkillsController.INST_Programming_Id, (int)value);
break;
case ItemPropertyType.HSEngineExp:
hardSkillsController.IncreaseEXP(hardSkillsController.INST_Engine_Id, (int)value);
break;
case ItemPropertyType.HSNetworkExp:
hardSkillsController.IncreaseEXP(hardSkillsController.INST_Network_Id, (int)value);
break;
case ItemPropertyType.HSAiExp:
hardSkillsController.IncreaseEXP(hardSkillsController.INST_Ai_Id, (int)value);
break;
case ItemPropertyType.HSDesignExp:
hardSkillsController.IncreaseEXP(hardSkillsController.INST_Design_Id, (int)value);
break;
case ItemPropertyType.HSTesting:
hardSkillsController.IncreaseEXP(hardSkillsController.INST_Testing_Id, (int)value);
break;
case ItemPropertyType.HSArtExp:
hardSkillsController.IncreaseEXP(hardSkillsController.INST_Art_Id, (int)value);
break;
case ItemPropertyType.HSSoundExp:
hardSkillsController.IncreaseEXP(hardSkillsController.INST_Sound_Id, (int)value);
break;
}
}
}
DestroyItemPickUp();
}
public string IsValidTarget(NWCreature user, NWItem mod, NWObject target, Location targetLocation)
{
if (target.ObjectType != ObjectType.Item)
{
return("Only items may be targeted by mods.");
}
if (!user.IsPlayer && !user.IsDM)
{
return("Only players may use mods.");
}
NWPlayer player = (user.Object);
NWItem targetItem = (target.Object);
int modLevel = mod.RecommendedLevel;
int itemLevel = targetItem.RecommendedLevel;
int requiredPerkLevel = modLevel / 5;
if (requiredPerkLevel <= 0)
{
requiredPerkLevel = 1;
}
int perkLevel = 0;
ItemPropertyType modType = ModService.GetModType(mod);
ModSlots modSlots = ModService.GetModSlots(targetItem);
int modID = mod.GetLocalInt("RUNE_ID");
string[] modArgs = mod.GetLocalString("RUNE_VALUE").Split(',');
// Check for a misconfigured mod item.
if (modType == ItemPropertyType.Invalid)
{
return("Mod color couldn't be found. Notify an admin that this mod item is not set up properly.");
}
if (modID <= 0)
{
return("Mod ID couldn't be found. Notify an admin that this mod item is not set up properly.");
}
if (modArgs.Length <= 0)
{
return("Mod value couldn't be found. Notify an admin that this mod item is not set up properly.");
}
// No available slots on target item
if (modType == ItemPropertyType.RedMod && !modSlots.CanRedModBeAdded)
{
return("That item has no available red mod slots.");
}
if (modType == ItemPropertyType.BlueMod && !modSlots.CanBlueModBeAdded)
{
return("That item has no available blue mod slots.");
}
if (modType == ItemPropertyType.GreenMod && !modSlots.CanGreenModBeAdded)
{
return("That item has no available green mod slots.");
}
if (modType == ItemPropertyType.YellowMod && !modSlots.CanYellowModBeAdded)
{
return("That item has no available yellow mod slots.");
}
// Get the perk level based on target item type and mod type.
if (GetLocalBool(targetItem, "LIGHTSABER") == false && WeaponsmithBaseItemTypes.Contains(targetItem.BaseItemType))
{
perkLevel = PerkService.GetCreaturePerkLevel(player, PerkType.WeaponModInstallation);
}
else if (ArmorBaseItemTypes.Contains(targetItem.BaseItemType))
{
perkLevel = PerkService.GetCreaturePerkLevel(player, PerkType.ArmorModInstallation);
}
else if (GetLocalBool(targetItem, "LIGHTSABER") == true || EngineeringBaseItemTypes.Contains(targetItem.BaseItemType))
{
perkLevel = PerkService.GetCreaturePerkLevel(player, PerkType.EngineeringModInstallation);
}
// Ensure item isn't equipped.
for (int slot = 0; slot < NumberOfInventorySlots; slot++)
{
if (_.GetItemInSlot((InventorySlot)slot, user.Object) == targetItem.Object)
{
return("Targeted item must be unequipped before installing a mod.");
}
}
// Check for perk level requirement
if (perkLevel < requiredPerkLevel && !player.IsDM)
{
return("You do not have the necessary perk rank required. (Required: " + requiredPerkLevel + ", Your level: " + perkLevel + ")");
}
// Can't modify items above perk level * 10
if (itemLevel > perkLevel * 10 && !player.IsDM)
{
return("Your current perks allow you to add mods to items up to level " + perkLevel * 10 + ". This item is level " + itemLevel + " so you can't install a mod into it.");
}
// Item must be in the user's inventory.
if (!targetItem.Possessor.Equals(player))
{
return("Targeted item must be in your inventory.");
}
// It's possible that this mod is no longer usable. Notify the player if we can't find one registered.
if (!ModService.IsModHandlerRegistered(modID))
{
return("Unfortunately, this mod can no longer be used.");
}
var handler = ModService.GetModHandler(modID);
// Run the individual mod's rules for application. Will return the error message or a null.
return(handler.CanApply(player, targetItem, modArgs));
}
/// <summary>
/// Constructor. Builds the item from raw XML data.
/// </summary>
/// <param name="xmlProperty"></param>
internal ItemProperty(XmlItemSerialization.ItemProperty xmlProperty)
{
brand = xmlProperty.Brand;
name = xmlProperty.Name;
propertyType = xmlProperty.PropertyType;
}
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);
ItemPropertyType 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 ItemPropertyType.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 ItemPropertyType.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 ItemPropertyType.GreenMod:
if (slots.FilledGreenSlots < 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 ItemPropertyType.YellowMod:
if (slots.FilledYellowSlots < 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 (GetLocalBool(targetItem, "LIGHTSABER") == true)
{
skillType = SkillType.Engineering;
}
else 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);
}
