internal void ResolveLoot(ItemSlot slot, InventoryBase inventory, IWorldAccessor worldForResolve)
{
double diceRoll = worldForResolve.Rand.NextDouble();
ItemStack ownstack = slot.Itemstack;
slot.Itemstack = null;
IAttribute[] vals = ownstack.Attributes.Values;
vals.Shuffle(worldForResolve.Rand);
foreach (var val in vals)
{
if (!(val is TreeAttribute))
{
continue;
}
TreeAttribute subtree = val as TreeAttribute;
float chance = subtree.GetFloat("chance") / 100f;
if (chance > diceRoll)
{
ItemStack cstack = subtree.GetItemstack("stack");
cstack.ResolveBlockOrItem(worldForResolve);
slot.Itemstack = cstack;
return;
}
diceRoll -= chance;
}
}
void Awake()
{
coords = new int[2];
lastCoords = new int[2];
canSee = new List<Player> ();
m_AttackAxisInUse = false;
tr = transform;
CombatMode = false;
pos = transform.position;
currentPath = new List<Vector2> ();
controller = GetComponent<PlayerController>();
workingAI = new AIBase (this);
lastInput = Vector3.one;
playerStats = new PlayerStats ();
currentState = CharacterState.Still;
controller.SetSpeed (playerStats.GetSpeed());
isStuck = 0;
canAttack = "Enemy";
coolDownLimit = playerStats.GetAttackCooldown();
currentAttackCoolDown = 0;
inventory = GetComponent<InventoryBase>();
weaponController = GetComponentInChildren<WeaponController> ();
anim = GetComponent<Animator>();
spriteRen = GetComponent<SpriteRenderer> ();
//seeker = GetComponent<Seeker> ();
}
public virtual void AddToInventory(InventoryBase inventory)
{
bool addNewSlot = true;;
for (int i = 0; i < inventory.ItemsInInventory.Count; i++)
{
ItemSlot itemInInventory = inventory.ItemsInInventory[i];
if (Stackable && itemInInventory.Item.ItemID == ItemID && itemInInventory.Count < 99)
{
itemInInventory.Count++;
addNewSlot = false;
}
inventory.ItemsInInventory[i] = itemInInventory;
}
if (inventory.OpenSlot && addNewSlot)
{
inventory.ItemsInInventory.Add(
new ItemSlot()
{
Item = this,
Count = 1
});
}
}
/// <inheritdoc />
public CraftingTableDialog(InventoryBase inventory, Inventory playerInventory) : base(
inventory, GuiTextures.InventoryCraftingTable, 175, 165)
{
//7, 17
//Add chest slots
foreach (var slot in AddSlots(30, 17, 3, 9, 0, inventory.InventoryId))
{
slot.Item = inventory[slot.InventoryIndex];
}
var outputSlot = AddSlot(120, 31, 10, inventory.InventoryId);
outputSlot.Width = 24;
outputSlot.Height = 24;
//7 139
foreach (var slot in AddSlots(8, 84, 9, 27, 9, playerInventory.InventoryId))
{
slot.Item = playerInventory[slot.InventoryIndex];
}
//7, 197
foreach (var slot in AddSlots(8, 142, 9, 9, 0, playerInventory.InventoryId))
{
slot.Item = playerInventory[slot.InventoryIndex];
}
}
private void DeleteItem(TreeNode node)
{
if (node == null)
{
return;
}
InventoryBase io = (InventoryBase)node.Tag;
if (io is InventoryFolder)
{
InventoryFolder folder = (InventoryFolder)io;
//treeLookup.Remove(folder.UUID);
client.Inventory.RemoveFolder(folder.UUID);
folder = null;
}
else if (io is InventoryItem)
{
InventoryItem item = (InventoryItem)io;
//treeLookup.Remove(item.UUID);
client.Inventory.RemoveItem(item.UUID);
item = null;
}
io = null;
node.Remove();
node = null;
}
private void treeView1_DoubleClick(object sender, EventArgs e)
{
if (treeView1.SelectedNode.Tag is InventoryItem)
{
InventoryBase io = (InventoryBase)treeView1.SelectedNode.Tag;
InventoryItem item = (InventoryItem)io;
if (item.InventoryType != InventoryType.Landmark)
{
return;
}
UUID landmark = new UUID();
if (!UUID.TryParse(io.UUID.ToString(), out landmark))
{
MessageBox.Show("Invalid TP LLUID", "Teleport", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
////if (client.Self.Teleport(landmark))
if (client.Self.Teleport(item.AssetUUID))
{
MessageBox.Show("Teleport successful", "Teleport", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MessageBox.Show("Teleport failed", "Teleport", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
}
public InventoryBase(InventoryBase item)
{
ID = item.ID;
ParentID = item.ParentID;
Name = item.Name;
OwnerID = item.OwnerID;
ExtraData = item.ExtraData; // FIXME: Copy by value, not reference
}
/// <summary>
/// Updates the state of the InventoryNode and inventory data structure that
/// is responsible for the InventoryObject. If the item was previously not added to inventory,
/// it adds the item, and updates structure accordingly. If it was, it updates the
/// InventoryNode, changing the parent node if <code>item.parentUUID</code> does
/// not match <code>node.Parent.Data.UUID</code>.
///
/// You can not set the inventory root folder using this method
/// </summary>
/// <param name="item">The InventoryObject to store</param>
public void UpdateNodeFor(InventoryBase item)
{
lock (Items)
{
InventoryNode itemParent = null;
if (item.ParentUUID != UUID.Zero && !Items.TryGetValue(item.ParentUUID, out itemParent))
{
// OK, we have no data on the parent, let's create a fake one.
InventoryFolder fakeParent = new InventoryFolder(item.ParentUUID);
fakeParent.DescendentCount = 1; // Dear god, please forgive me.
itemParent = new InventoryNode(fakeParent);
Items[item.ParentUUID] = itemParent;
// Unfortunately, this breaks the nice unified tree
// while we're waiting for the parent's data to come in.
// As soon as we get the parent, the tree repairs itself.
Console.WriteLine("Attempting to update inventory child of " +
item.ParentUUID.ToString() + " when we have no local reference to that folder");
if (true)
{
// Fetch the parent
List<UUID> fetchreq = new List<UUID>(1);
fetchreq.Add(item.ParentUUID);
//Manager.FetchInventory(fetchreq); // we cant fetch folder data! :-O
}
}
InventoryNode itemNode;
if (Items.TryGetValue(item.UUID, out itemNode)) // We're updating.
{
InventoryNode oldParent = itemNode.Parent;
// Handle parent change
if (oldParent == null || itemParent == null || itemParent.Data.UUID != oldParent.Data.UUID)
{
if (oldParent != null)
{
lock (oldParent.Nodes.SyncRoot)
oldParent.Nodes.Remove(item.UUID);
}
if (itemParent != null)
{
lock (itemParent.Nodes.SyncRoot)
itemParent.Nodes[item.UUID] = itemNode;
}
}
itemNode.Parent = itemParent;
itemNode.Data = item;
}
else // We're adding.
{
itemNode = new InventoryNode(item, itemParent);
Items.Add(item.UUID, itemNode);
}
}
}
/// <summary>
/// Removes the InventoryObject and all related node data from Inventory.
/// </summary>
/// <param name="item">The InventoryObject to remove.</param>
public void RemoveNodeFor(InventoryBase item)
{
lock (Items)
{
InventoryNode node;
if (Items.TryGetValue(item.UUID, out node))
{
if (node.Parent != null)
lock (node.Parent.Nodes.SyncRoot)
node.Parent.Nodes.Remove(item.UUID);
Items.Remove(item.UUID);
}
// In case there's a new parent:
InventoryNode newParent;
if (Items.TryGetValue(item.ParentUUID, out newParent))
{
lock (newParent.Nodes.SyncRoot)
newParent.Nodes.Remove(item.UUID);
}
}
}
public bool Contains(InventoryBase obj)
{
return Contains(obj.UUID);
}
