public void NetAddLootItem(Vector3 pos, int instanceId)
{
LootItemData data = new LootItemData();
data.id = instanceId;
data.position = pos;
data.dropTime = GameTime.Timer.Second;
AddLootItem(data, true);
}
private void buttonItemAdd_Click(object sender, EventArgs e)
{
short itemId;
if (short.TryParse(textBoxItemId.Text, out itemId) == false || itemId < 1)
{
this.logger.Error("Invalid ItemId");
return;
}
byte min;
if (byte.TryParse(textBoxItemMinCount.Text, out min) == false || min == 0)
{
this.logger.Error("Invalid Min Count");
return;
}
byte max;
if (byte.TryParse(textBoxItemMaxCount.Text, out max) == false || max == 0)
{
this.logger.Error("Invalid Max Count");
return;
}
if (max < min)
{
this.logger.Error("Min must be less than Max");
return;
}
float chance;
if (float.TryParse(textBoxItemDropChance.Text, out chance) == false || chance <= 0f || chance > 100f)
{
this.logger.Error("Invalid Drop Chance");
return;
}
var item = new LootItemData
{
ItemId = itemId,
MinCount = min,
MaxCount = max,
DropChance = chance,
};
if (listBoxLootItems.Items.Contains(item))
{
this.logger.Error("Loot item already added");
return;
}
this.listBoxLootItems.Items.Add(item);
}
public void PickUp(int networkId)
{
MessageBus.SendMessage(NetAddressedChannelMessage.Get(
Network.API.Messages.PICK_UP_LOOT_ITEM, UnityEngine.Networking.QosType.ReliableSequenced, networkId,
LootItemData.GetData(_lootData.LootType, _lootData.Amount, _lootData.Params)));
MessageBus.SendMessage(NetBroadcastChannelMessage.Get(
Network.API.Messages.DELETE_OBJECT, UnityEngine.Networking.QosType.ReliableSequenced, Channel.ChannelIds[SubscribeType.Network]));
Destroy(gameObject);
}
void AddLootItem(LootItemData data, bool generateImmediately = false)
{
m_Datas [data.id] = data;
if (generateImmediately)
{
CreatSceneItem(data, true);
}
else
{
m_NotGeneratedItems.Add(data);
}
}
public void SetData(LootItemData data)
{
m_Data = data;
if (m_Data == null || m_Data.itemObj == null || m_Data.itemObj.protoData.icon == null)
{
return;
}
m_Icon.spriteName = m_Data.itemObj.protoData.icon[0];
transform.position = m_Data.position;
transform.rotation = Quaternion.AngleAxis(UnityEngine.Random.Range(0f, 360f), Vector3.up);
m_Icon.alpha = 0;
m_LineRoot.localScale = new Vector3(m_LineRoot.localScale.x, UnityEngine.Random.Range(0.4f, 0.65f), m_LineRoot.localScale.z);
UpdateColor();
}
bool CheckItemRemove(LootItemData data)
{
ItemObject itemobj = data.itemObj;
if (Time.time > data.checkItemExistTime)
{
if (null == ItemMgr.Instance.Get(data.id))
{
return(true);
}
else
{
data.checkItemExistTime = Time.time + Random.Range(5f, 10f);
}
}
if (null != data.itemObj && itemobj.protoData.category != "Quest Item")
{
return(GameTime.Timer.Second - data.dropTime > RemoveTime);
}
return(false);
}
public void BuildLootResponse(LootResponse packet, Player viewer, PermissionTypes permission)
{
if (permission == PermissionTypes.None)
{
return;
}
packet.Coins = gold;
switch (permission)
{
case PermissionTypes.Group:
case PermissionTypes.Master:
case PermissionTypes.Restricted:
{
// if you are not the round-robin group looter, you can only see
// blocked rolled items and quest items, and !ffa items
for (byte i = 0; i < items.Count; ++i)
{
if (!items[i].is_looted && !items[i].freeforall && items[i].conditions.Empty() && items[i].AllowedForPlayer(viewer))
{
LootSlotType slot_type;
if (items[i].is_blocked) // for ML & restricted is_blocked = !is_underthreshold
{
switch (permission)
{
case PermissionTypes.Group:
slot_type = LootSlotType.RollOngoing;
break;
case PermissionTypes.Master:
{
if (viewer.GetGroup() && viewer.GetGroup().GetMasterLooterGuid() == viewer.GetGUID())
{
slot_type = LootSlotType.Master;
}
else
{
slot_type = LootSlotType.Locked;
}
break;
}
case PermissionTypes.Restricted:
slot_type = LootSlotType.Locked;
break;
default:
continue;
}
}
else if (roundRobinPlayer.IsEmpty() || viewer.GetGUID() == roundRobinPlayer || !items[i].is_underthreshold)
{
// no round robin owner or he has released the loot
// or it IS the round robin group owner
// => item is lootable
slot_type = LootSlotType.AllowLoot;
}
else if (!items[i].rollWinnerGUID.IsEmpty())
{
if (items[i].rollWinnerGUID == viewer.GetGUID())
{
slot_type = LootSlotType.Owner;
}
else
{
continue;
}
}
else
{
// item shall not be displayed.
continue;
}
LootItemData lootItem = new LootItemData();
lootItem.LootListID = (byte)(i + 1);
lootItem.UIType = slot_type;
lootItem.Quantity = items[i].count;
lootItem.Loot = new ItemInstance(items[i]);
packet.Items.Add(lootItem);
}
}
break;
}
case PermissionTypes.All:
case PermissionTypes.Owner:
{
for (byte i = 0; i < items.Count; ++i)
{
if (!items[i].is_looted && !items[i].freeforall && items[i].conditions.Empty() && items[i].AllowedForPlayer(viewer))
{
LootItemData lootItem = new LootItemData();
lootItem.LootListID = (byte)(i + 1);
lootItem.UIType = (permission == PermissionTypes.Owner ? LootSlotType.Owner : LootSlotType.AllowLoot);
lootItem.Quantity = items[i].count;
lootItem.Loot = new ItemInstance(items[i]);
packet.Items.Add(lootItem);
}
}
break;
}
default:
return;
}
LootSlotType slotType = permission == PermissionTypes.Owner ? LootSlotType.Owner : LootSlotType.AllowLoot;
var lootPlayerQuestItems = GetPlayerQuestItems();
var q_list = lootPlayerQuestItems.LookupByKey(viewer.GetGUID());
if (!q_list.Empty())
{
for (var i = 0; i < q_list.Count; ++i)
{
NotNormalLootItem qi = q_list[i];
LootItem item = quest_items[qi.index];
if (!qi.is_looted && !item.is_looted)
{
LootItemData lootItem = new LootItemData();
lootItem.LootListID = (byte)(items.Count + i + 1);
lootItem.Quantity = item.count;
lootItem.Loot = new ItemInstance(item);
switch (permission)
{
case PermissionTypes.Master:
lootItem.UIType = LootSlotType.Master;
break;
case PermissionTypes.Restricted:
lootItem.UIType = item.is_blocked ? LootSlotType.Locked : LootSlotType.AllowLoot;
break;
case PermissionTypes.Group:
if (!item.is_blocked)
{
lootItem.UIType = LootSlotType.AllowLoot;
}
else
{
lootItem.UIType = LootSlotType.RollOngoing;
}
break;
default:
lootItem.UIType = slotType;
break;
}
packet.Items.Add(lootItem);
}
}
}
var lootPlayerFFAItems = GetPlayerFFAItems();
var ffa_list = lootPlayerFFAItems.LookupByKey(viewer.GetGUID());
if (!ffa_list.Empty())
{
foreach (var fi in ffa_list)
{
LootItem item = items[fi.index];
if (!fi.is_looted && !item.is_looted)
{
LootItemData lootItem = new LootItemData();
lootItem.LootListID = (byte)(fi.index + 1);
lootItem.UIType = slotType;
lootItem.Quantity = item.count;
lootItem.Loot = new ItemInstance(item);
packet.Items.Add(lootItem);
}
}
}
var lootPlayerNonQuestNonFFAConditionalItems = GetPlayerNonQuestNonFFAConditionalItems();
var conditional_list = lootPlayerNonQuestNonFFAConditionalItems.LookupByKey(viewer.GetGUID());
if (!conditional_list.Empty())
{
foreach (var ci in conditional_list)
{
LootItem item = items[ci.index];
if (!ci.is_looted && !item.is_looted)
{
LootItemData lootItem = new LootItemData();
lootItem.LootListID = (byte)(ci.index + 1);
lootItem.Quantity = item.count;
lootItem.Loot = new ItemInstance(item);
if (item.follow_loot_rules)
{
switch (permission)
{
case PermissionTypes.Master:
lootItem.UIType = LootSlotType.Master;
break;
case PermissionTypes.Restricted:
lootItem.UIType = item.is_blocked ? LootSlotType.Locked : LootSlotType.AllowLoot;
break;
case PermissionTypes.Group:
if (!item.is_blocked)
{
lootItem.UIType = LootSlotType.AllowLoot;
}
else
{
lootItem.UIType = LootSlotType.RollOngoing;
}
break;
default:
lootItem.UIType = slotType;
break;
}
}
else
{
lootItem.UIType = slotType;
}
packet.Items.Add(lootItem);
}
}
}
}
public RandomizerItemValue(Item value, LootItemData data)
: base(value, data.Probability, data.Unique, data.Guaranteed, data.Enabled)
{
this.data = data;
}
/// <summary>
/// Creates a <see cref="LootItem"/> from a <see cref="LootItem"/>.
/// </summary>
public LootItem(LootItemData lootItemInfo)
{
this.ItemId = lootItemInfo.ItemId;
this.CountOrGold = (byte)Utils.Rnd.Next(lootItemInfo.MinCount, lootItemInfo.MaxCount);
this.IsLooted = false;
}
private IRandomizerObject CreateItem(LootItemData data)
{
return(new RandomizerItemValue(this.itemRepository.FindOrFail(data.ItemId), data));
}
private IRandomizerObject CreateRandom(LootItemData data)
{
return(new RandomizerRandomItemValue(data, this.itemRepository, this.itemCategoryRepository));
}
