/**
* Add the given item to the slot
*/
public void AddItem(Pickable pickable)
{
_pickable = pickable;
_currentItem = _pickable.GetScriptableItem();
_icon.sprite = _pickable.GetScriptableItem().GetRegularIcon();
_icon.enabled = true;
_itemButton.interactable = true;
if (_removeButton != null && _pickable is Ingestible)
{
_removeButton.interactable = true;
}
if (pickable is Weapon)
{
Color color = _itemButton.image.color;
color.a = _WEAPON_SLOT_FILLED_ALPHA;
_itemButton.image.color = color;
if (((Weapon)pickable).IsCurrent())
{
MarkAsCurrent();
}
else
{
UnmarkAsCurrent();
}
}
}
public bool Add(List <ContainerItem> itemsToAdd)
{
if (!CanAdd(itemsToAdd))
{
return(false);
}
foreach (var addItem in itemsToAdd)
{
ScriptableItem key = addItem.Key;
// Add to existing stack
if (!addItem.item.IsUnique && Items.ContainsKey(key))
{
ContainerItem cItem;
Items.TryGetValue(key, out cItem);
cItem.count += addItem.count;
Items[key] = cItem;
}
else
{ // Add a new stack
Items.Add(addItem.Key, addItem);
}
}
return(true);
}
private void OnPillsGrab(ScriptableItem item)
{
if (inventory.Bag.Contains(item) && item.ID == ListOfItems.PillBottle)
{
Victory();
}
}
public static void CreateItems()
{
string[] languages = { "deu", "eng", "fra", "ita", "rus", "spa" };
string[] xItems = Directory.GetFiles("Assets/Xml/deu/items", "*.xml");
Sprite[] sprites = AssetDatabase.LoadAllAssetsAtPath("Assets/Sprites/objects.png").OfType <Sprite>().ToArray();
for (int i = 0; i < xItems.Length; i++)
{
ScriptableItem newItem = new ScriptableItem();
// ID
newItem.ID = Path.GetFileNameWithoutExtension(xItems[i]);
// Sprite and SpriteViewer
for (int j = 0; j < sprites.Length; j++)
{
//Sprite
if (sprites[j].name == newItem.ID)
{
newItem.sprite = sprites[j];
}
//SpriteViewer
if (sprites[j].name == (newItem.ID + "_v"))
{
newItem.spriteViewer = sprites[j];
}
}
// Names and Descriptions
for (int j = 0; j < languages.Length; j++)
{
string[] xLanguageItems = Directory.GetFiles("Assets/Xml/" + languages[j] + "/items", "*.xml");
XmlDocument xData = new XmlDocument();
xData.Load(xLanguageItems[i]);
// Name
XmlNode xObject = xData.SelectSingleNode("object");
newItem.names.Add(xObject.Attributes["name"].Value);
// Description
string description = "";
XmlNodeList xDescriptions = xData.SelectNodes("object/description/command");
foreach (XmlNode xCommand in xDescriptions)
{
string[] commandTokens = xCommand.InnerText.Split('"');
if (commandTokens[0] == "text ")
{
description += (commandTokens[1] + " ");
}
}
newItem.descriptions.Add(description);
}
AssetDatabase.CreateAsset(newItem, "Assets/Resources/ScriptableObjects/" + newItem.ID + ".asset");
AssetDatabase.Refresh();
}
}
public void Equip(ScriptableItem itemToEquip)
{
// Instantiate graphic
equippedItemGameObject = GameObject.Instantiate(itemToEquip.graphic);
// Attach to parent bone
equippedItemGameObject.transform.SetParent(m_boneReference);
// Apply local position, rotation and scale
equippedItemGameObject.transform.localPosition = itemToEquip.instantiatedPosition;
equippedItemGameObject.transform.localEulerAngles = new Vector3(
itemToEquip.instantiatedRotation.x,
itemToEquip.instantiatedRotation.y,
itemToEquip.instantiatedRotation.z
);
equippedItemGameObject.transform.localScale = itemToEquip.instantiatedScale;
equippedItem = itemToEquip;
// @ If equipment is a weapon, update Weapon_ID parameter
ScriptableWeapon weapon = (ScriptableWeapon)equippedItem;
if (weapon != null && weapon.weaponType != null)
{
m_owner.GetComponent <Animator>().SetInteger(Constants.WEAPON_ID, (int)weapon.weaponType);
}
}
public bool Remove(List <ContainerItem> itemsToRemove)
{
if (!CanRemove(itemsToRemove))
{
return(false);
}
foreach (var removeItem in itemsToRemove)
{
ScriptableItem key = removeItem.Key;
ContainerItem cItem;
Items.TryGetValue(key, out cItem);
cItem.count -= removeItem.count;
if (cItem.count == 0)
{
Items.Remove(key);
}
else
{
Items[key] = cItem;
}
}
return(true);
}
// Set our rarity outline color from scriptable item.
private void SetRarityColor(ScriptableItem slot)
{
switch (slot.rarity)
{
case ScriptableItem.ItemRarity.Poor:
raritySlot.rarityOutline.color = Color.grey;
break;
case ScriptableItem.ItemRarity.Common:
raritySlot.rarityOutline.color = Color.white;
break;
case ScriptableItem.ItemRarity.Uncommon:
raritySlot.rarityOutline.color = Color.green;
break;
case ScriptableItem.ItemRarity.Rare:
raritySlot.rarityOutline.color = Color.blue;
break;
case ScriptableItem.ItemRarity.Epic:
raritySlot.rarityOutline.color = Color.magenta;
break;
case ScriptableItem.ItemRarity.Legendary:
raritySlot.rarityOutline.color = Color.yellow;
break;
}
}
/// <summary>
/// Atributes the necessary properties to the item to be examined and
/// positions it relatively to the camera that will render it
/// </summary>
/// <param name="item">Item to be examined</param>
/// <param name="examineCamera">Camera that will render the item</param>
private void SetExamineItem(ScriptableItem item, Camera examineCamera)
{
// Instantiates the item that player will interact with
itemObject = MonoBehaviour.Instantiate(item.Prefab);
itemObject.name = "Item In Examine";
// Sets the object and its children to the layer that must be
// rendered by the camera
RecursivelySetLayer(itemObject, 12);
// Puts the item in front of the camera
// The item's Z axis point towards the camera
itemObject.transform.position = examineCamera.transform.position +
examineCamera.transform.forward;
parent = new GameObject();
parent.name = "Examine Set";
itemTransform = itemObject.transform;
// Makes the item parent position the same as the item position
parent.transform.position = itemTransform.position;
itemTransform.parent = parent.transform;
light.transform.parent = parent.transform;
// Points parent to the camera
itemTransform.parent.LookAt(examineCamera.transform);
light.transform.position = itemTransform.position;
light.transform.position += itemTransform.parent.forward * 5;
light.transform.position += itemTransform.parent.up * -4;
light.transform.LookAt(itemTransform);
}
public void Cmd_UCE_Admin_GiveItem(string adminTargets, string adminTargetName, int adminValue, string adminItemName)
{
if (player.UCE_adminLevel <= 0)
{
return;
}
ScriptableItem item = getItem(adminItemName);
if (item == null)
{
return;
}
List <Player> players = new List <Player>();
players = getPlayerTargets(adminTargets, adminTargetName);
foreach (Player plyr in players)
{
if (plyr.InventoryCanAdd(new Item(item), adminValue) &&
plyr.InventoryAdd(new Item(item), adminValue))
{
plyr.UCE_TargetAddMessage("[Admin] You just received " + item.name + " x" + adminValue.ToString());
}
}
}
void Update()
{
Player player = Player.localPlayer;
// use collider point(s) to also work with big entities
if (player != null &&
player.target != null &&
player.target is Npc npc &&
Utils.ClosestDistance(player, player.target) <= player.interactionRange)
{
// instantiate/destroy enough slots
List <ScriptableQuest> questsAvailable = npc.quests.QuestsVisibleFor(player);
UIUtils.BalancePrefabs(slotPrefab.gameObject, questsAvailable.Count, content);
// refresh all
for (int i = 0; i < questsAvailable.Count; ++i)
{
ScriptableQuest npcQuest = questsAvailable[i];
UINpcQuestSlot slot = content.GetChild(i).GetComponent <UINpcQuestSlot>();
// find quest index in original npc quest list (unfiltered)
int npcIndex = npc.quests.GetIndexByName(questsAvailable[i].name);
// find quest index in player quest list
int questIndex = player.quests.GetIndexByName(npcQuest.name);
if (questIndex != -1)
{
// running quest: shows description with current progress
// instead of static one
Quest quest = player.quests.quests[questIndex];
ScriptableItem reward = npcQuest.rewardItem;
bool hasSpace = reward == null || player.inventory.CanAdd(new Item(reward), 1);
// description + not enough space warning (if needed)
slot.descriptionText.text = quest.ToolTip(player);
if (!hasSpace)
{
slot.descriptionText.text += "\n<color=red>Not enough inventory space!</color>";
}
slot.actionButton.interactable = player.quests.CanComplete(quest.name);
slot.actionButton.GetComponentInChildren <Text>().text = "Complete";
slot.actionButton.onClick.SetListener(() => {
player.quests.CmdComplete(npcIndex);
panel.SetActive(false);
});
}
else
{
// new quest
slot.descriptionText.text = new Quest(npcQuest).ToolTip(player);
slot.actionButton.interactable = true;
slot.actionButton.GetComponentInChildren <Text>().text = "Accept";
slot.actionButton.onClick.SetListener(() => {
player.quests.CmdAccept(npcIndex);
});
}
}
}
// -----------------------------------------------------------------------------------
// UCE_checkHasItem
// -----------------------------------------------------------------------------------
public bool UCE_checkHasItem(Player player, ScriptableItem item)
{
if (item == null)
{
return(true);
}
return(player.inventory.Count(new Item(item)) >= 1);
}
public long summonedExperience; // stored in item while summonable unsummoned
// constructors
public Item(ScriptableItem data)
{
hash = data.name.GetStableHashCode();
summoned = null;
summonedHealth = data is SummonableItem ? ((SummonableItem)data).summonPrefab.healthMax : 0;
summonedLevel = data is SummonableItem ? 1 : 0;
summonedExperience = 0;
}
/// <summary>
/// Coroutine that shows an image of an obtained item
/// </summary>
/// <param name="item">Item to display the image</param>
/// <returns>Returns a new waitforseconds</returns>
private IEnumerator ShowImageCoroutine(ScriptableItem item)
{
image.sprite = item.Icon;
canvas.SetActive(true);
yield return(new WaitForSeconds(2f));
canvas.SetActive(false);
}
public long petExperience; // stored in item while pet unsummoned
// constructors
public Item(ScriptableItem data)
{
hash = data.name.GetStableHashCode();
petSummoned = null;
petHealth = data is PetItem ? ((PetItem)data).petPrefab.healthMax : 0;
petLevel = data is PetItem ? 1 : 0;
petExperience = 0;
}
// -----------------------------------------------------------------------------------
// UCE_checkHasItem
// -----------------------------------------------------------------------------------
public bool UCE_checkHasItem(ScriptableItem item)
{
if (item == null)
{
return(true);
}
return(InventoryCount(new Item(item)) >= 1);
}
public long summonedExperience; // stored in item while summonable unsummoned
// constructors
public Item(ScriptableItem data)
{
hash = data.name.GetStableHashCode();
durability = data.maxDurability;
summoned = null;
summonedHealth = data is SummonableItem summonable ? summonable.summonPrefab.health.max : 0;
summonedLevel = data is SummonableItem ? 1 : 0;
summonedExperience = 0;
}
// -----------------------------------------------------------------------------------
// MaxBuyAmount
// -----------------------------------------------------------------------------------
private int MaxBuyAmount(Player player, ScriptableItem item)
{
if (item.maxStack == 1)
{
return(1);
}
return(Mathf.Min((int)(player.gold / item.buyPrice), item.maxStack));
}
/// <summary>
/// Constructor, that creates a new instance of ItemExaminer and
/// initializes its fields
/// </summary>
/// <param name="speed">Speen of rotation of the object</param>
/// <param name="item">Object to be examined</param>
/// <param name="examineCamera">Camera used to render the object</param>
public ItemExaminer(float speed, ScriptableItem item, Camera examineCamera)
{
SetLights();
SetExamineItem(item, examineCamera);
// Set the speed rotation value
this.speed = speed;
verticalRotation = 0f;
horizontalRotation = 0f;
}
public void Equip(EquipmentSlotType slotType, ScriptableItem itemToEquip)
{
GetSlot(slotType).equipmentSlot.Equip(itemToEquip);
// @ Animator Updates
GetComponent <Animator>().SetBool(Constants.IS_DUAL_WIELDING, IsDualWielding());
// @ Notify subscribed scripts
EquipEvent.Invoke();
}
void OnEquipmentChanged(SyncListItemSlot.Operation op, int index, ItemSlot oldSlot, ItemSlot newSlot)
{
ScriptableItem oldItem = oldSlot.amount > 0 ? oldSlot.item.data : null;
ScriptableItem newItem = newSlot.amount > 0 ? newSlot.item.data : null;
if (oldItem != newItem)
{
RefreshLocation(index);
}
}
private void Start()
{
for (int i = 0; i < itemList.Count - 1; i++)
{
scriptable = (ScriptableItem)AssetDatabase.LoadAssetAtPath("Assets/Resources/ScriptableObjects/" + itemList[i] + ".asset", typeof(ScriptableItem));
GameObject item = new GameObject();
item.name = itemList[i];
item.AddComponent <SpriteRenderer>().sprite = scriptable.sprite;
item.transform.SetParent(this.transform);
}
}
public static void Open(Object obj)
{
if (window != null)
{
window.Close();
}
window = null;
scriptable = new ScriptableItem(AssetDatabase.GetAssetPath(obj));
window = GetWindow <EditorNodeCanvas>(obj.name);
}
// -----------------------------------------------------------------------------------
// UCE_getTotalItemCount
// -----------------------------------------------------------------------------------
public int UCE_getTotalItemCount(ScriptableItem itemT)
{
int totalCount = 0;
for (int i = 0; i < inventory.Count; ++i)
{
if (inventory[i].amount > 0 && inventory[i].item.data == itemT)
{
totalCount += inventory[i].amount;
}
}
return(totalCount);
}
private void AddWeaponIfExists(EquipmentSlotType slotType)
{
ScriptableItem item = equipmentManager.GetEquippedItem(slotType);
if (item is ScriptableWeapon)
{
weapons.Add(new Weapon(
this.gameObject,
(ScriptableWeapon)item,
equipmentManager.GetEquippedItemGameObject(slotType)
));
}
}
// -----------------------------------------------------------------------------------
// UCE_getTotalItemCount
// -----------------------------------------------------------------------------------
public int UCE_getTotalItemCount(Player player, ScriptableItem itemT)
{
int totalCount = 0;
for (int i = 0; i < player.inventory.slots.Count; ++i)
{
if (player.inventory.slots[i].amount > 0 && player.inventory.slots[i].item.data == itemT)
{
totalCount += player.inventory.slots[i].amount;
}
}
return(totalCount);
}
// -----------------------------------------------------------------------------------
// UCE_removeEquipment
// Delete a equipped item, just like a inventory item can be deleted by default
// -----------------------------------------------------------------------------------
public void UCE_removeEquipment(ScriptableItem item)
{
for (int i = 0; i < equipment.slots.Count; ++i)
{
ItemSlot slot = equipment.slots[i];
if (slot.amount > 0 && slot.item.data == item)
{
slot.amount--;
equipment.slots[i] = slot;
return;
}
}
}
static void Edit()
{
if (window != null)
{
window.Close();
}
window = null;
Object asset = Selection.activeObject;
scriptable = new ScriptableItem(AssetDatabase.GetAssetPath(asset));
window = GetWindow <EditorNodeCanvas>(asset.name);
}
// -----------------------------------------------------------------------------------
// UCE_checkHasEquipment
// -----------------------------------------------------------------------------------
public bool UCE_checkHasEquipment(ScriptableItem item)
{
if (item == null)
{
return(true);
}
foreach (ItemSlot slot in equipment)
{
if (slot.amount > 0 && slot.item.data == item)
{
return(true);
}
}
return(false);
}
// -----------------------------------------------------------------------------------
// UCE_checkDepletableEquipment
// -----------------------------------------------------------------------------------
public bool UCE_checkDepletableEquipment(ScriptableItem item, int amount = 1)
{
if (item == null)
{
return(true);
}
foreach (ItemSlot slot in equipment.slots)
{
if (slot.amount > 0 && slot.item.data.maxStack > 1 && slot.amount >= amount && slot.item.data == item)
{
return(true);
}
}
return(false);
}
// -----------------------------------------------------------------------------------
// Cmd_UCE_Admin_GiveItem
// @Client -> @Server
// -----------------------------------------------------------------------------------
public void UCE_Admin_GiveItem(string[] parsedArgs)
{
string adminTargets = parsedArgs[0];
string adminTargetName = parsedArgs[1];
int adminValue = int.Parse(parsedArgs[2]);
string adminItemName = parsedArgs[3];
ScriptableItem item = getItem(adminItemName);
if (item == null)
{
return;
}
Cmd_UCE_Admin_GiveItem(adminTargets, adminTargetName, adminValue, adminItemName);
player.UCE_AddMessage("[Sys] Target(s) received " + item.name + " x" + adminValue.ToString());
}
