public static void Feed(object obj, int graphic, int amount = 1, int hue = -1)
{
int serial = AliasCommands.ResolveSerial(obj);
if (serial == 0)
{
UOC.SystemMessage(Strings.Invalid_or_unknown_object_id);
return;
}
if (Engine.Player?.Backpack == null)
{
UOC.SystemMessage(Strings.Error__Cannot_find_player_backpack);
return;
}
Item foodItem =
Engine.Player.Backpack?.Container.SelectEntity(i => i.ID == graphic && (hue == -1 || i.Hue == hue));
if (foodItem == null)
{
UOC.SystemMessage(Strings.Cannot_find_item___);
return;
}
ActionPacketQueue.EnqueueDragDrop(foodItem.Serial, amount, serial);
}
public void Cleanup()
{
ActionPacketQueue.Clear();
Engine.InternalPacketSentEvent -= OnInternalPacketSentEvent;
Engine.Player = null;
Engine.Items.Clear();
}
public static void ClearHands(string hand = "both")
{
hand = hand.ToLower();
List <Layer> unequipLayers = new List <Layer>();
switch (hand)
{
case "left":
unequipLayers.Add(Layer.OneHanded);
break;
case "right":
unequipLayers.Add(Layer.TwoHanded);
break;
case "both":
unequipLayers.Add(Layer.OneHanded);
unequipLayers.Add(Layer.TwoHanded);
break;
default:
throw new ArgumentOutOfRangeException(nameof(hand));
}
PlayerMobile player = Engine.Player;
List <int> serials = unequipLayers.Select(unequipLayer => Engine.Player.GetLayer(unequipLayer))
.Where(serial => serial != 0).ToList();
foreach (int serial in serials)
{
ActionPacketQueue.EnqueueDragDrop(serial, 1, player.Backpack?.Serial ?? 0);
}
}
public static void MoveItem(object item, object destination, int amount = -1, int x = -1, int y = -1)
{
int itemSerial = AliasCommands.ResolveSerial(item);
if (itemSerial == 0)
{
UOC.SystemMessage(Strings.Invalid_or_unknown_object_id);
return;
}
Item itemObj = Engine.Items.GetItem(itemSerial);
if (itemObj == null)
{
UOC.SystemMessage(Strings.Invalid_or_unknown_object_id);
return;
}
if (amount == -1)
{
amount = itemObj.Count;
}
int containerSerial = AliasCommands.ResolveSerial(destination);
if (containerSerial == 0)
{
//TODO
UOC.SystemMessage(Strings.Invalid_or_unknown_object_id);
return;
}
ActionPacketQueue.EnqueueDragDrop(itemSerial, amount, containerSerial, QueuePriority.Low, true, x, y);
}
public static Task EquipItem(Item item, Layer layer)
{
int containerSerial = Engine.Player?.Serial ?? 0;
if (containerSerial == 0 || containerSerial == -1)
{
return(Task.CompletedTask);
}
if (layer == Layer.Invalid)
{
StaticTile tileData = TileData.GetStaticTile(item.ID);
layer = (Layer)tileData.Quality;
}
if (layer == Layer.Invalid)
{
throw new ArgumentException("EquipItem: Layer is invalid");
}
return(ActionPacketQueue.EnqueueActionPackets(
new BasePacket[]
{
new DragItem(item.Serial, 1), new EquipRequest(item.Serial, layer, containerSerial)
}, QueuePriority.Medium));
}
public static void UseObject(object obj, bool skipQueue = false)
{
int serial = AliasCommands.ResolveSerial(obj);
if (serial == 0)
{
UOC.SystemMessage(Strings.Invalid_or_unknown_object_id);
return;
}
ActionPacketQueue.EnqueueActionPacket(new UseObject(serial),
skipQueue ? QueuePriority.Immediate : QueuePriority.Low);
}
public static Task EquipType(int id, Layer layer)
{
if (id <= -1)
{
SystemMessage(Strings.Invalid_type___);
return(Task.CompletedTask);
}
int containerSerial = Engine.Player?.Serial ?? 0;
if (containerSerial == 0 || containerSerial == -1)
{
return(Task.CompletedTask);
}
Item backpack = Engine.Player?.Backpack;
Item item = backpack?.Container?.SelectEntity(i => i.ID == id);
if (item == null)
{
return(Task.CompletedTask);
}
if (layer == Layer.Invalid)
{
StaticTile tileData = TileData.GetStaticTile(item.ID);
layer = (Layer)tileData.Quality;
}
if (layer == Layer.Invalid)
{
throw new ArgumentException("EquipItem: Layer is invalid");
}
return(ActionPacketQueue.EnqueueAction(item, i =>
{
Engine.SendPacketToServer(new DragItem(item.Serial, 1));
Thread.Sleep(50);
Engine.SendPacketToServer(new EquipRequest(item.Serial, layer, containerSerial));
return true;
}, QueuePriority.Medium));
}
public override void Execute()
{
PlayerMobile player = Engine.Player;
if (player == null)
{
return;
}
Layer[] layerPriority =
{
Layer.Shirt, Layer.Shoes, Layer.Pants, Layer.Helm, Layer.Gloves, Layer.Ring, Layer.Neck,
Layer.Waist, Layer.InnerTorso, Layer.Bracelet, Layer.MiddleTorso, Layer.Earrings, Layer.Arms,
Layer.Cloak, Layer.OuterTorso, Layer.OuterLegs, Layer.InnerLegs, Layer.TwoHanded, Layer.OneHanded
};
Layer selectedLayer = Layer.Invalid;
int serial = 0;
foreach (Layer layer in layerPriority)
{
serial = player.GetLayer(layer);
if (serial == 0)
{
continue;
}
selectedLayer = layer;
break;
}
if (selectedLayer == Layer.Invalid)
{
return;
}
ActionPacketQueue.EnqueueActionPackets(
new BasePacket[]
{
new DragItem(serial, 1), new EquipRequest(serial, selectedLayer, player.Serial)
}, QueuePriority.High);
}
public static void UseType(object type, int hue = -1, object container = null, bool skipQueue = false)
{
int serial = AliasCommands.ResolveSerial(type);
if (serial == 0)
{
UOC.SystemMessage(Strings.Invalid_or_unknown_object_id);
return;
}
if (container == null)
{
container = Engine.Player?.Backpack?.Serial;
}
int containerSerial = AliasCommands.ResolveSerial(container);
if (!Engine.Items.GetItem(containerSerial, out Item containerItem))
{
UOC.SystemMessage(Strings.Cannot_find_container___);
return;
}
Item useItem = hue == -1
? containerItem.Container?.SelectEntity(i => i.ID == serial)
: containerItem.Container?.SelectEntity(i => i.ID == serial && i.Hue == hue);
if (useItem == null)
{
UOC.SystemMessage(Strings.Cannot_find_item___);
return;
}
if (!AbilitiesManager.GetInstance().CheckHands(useItem.Serial))
{
ActionPacketQueue.EnqueuePacket(new UseObject(useItem.Serial),
skipQueue ? QueuePriority.Immediate : QueuePriority.Medium);
}
}
public static bool MoveTypeOffset(int id, object findLocation, int xOffset, int yOffset, int zOffset,
int amount = -1)
{
if (findLocation == null ||
((string)findLocation).Equals("ground", StringComparison.InvariantCultureIgnoreCase))
{
UOC.SystemMessage(Strings.Invalid_container___);
return(false);
}
int owner = AliasCommands.ResolveSerial(findLocation);
bool Predicate(Item i)
{
return(i.ID == id && i.IsDescendantOf(owner));
}
Item entity = Engine.Items.SelectEntities(Predicate)?.FirstOrDefault();
if (entity == null)
{
return(false);
}
PlayerMobile player = Engine.Player;
if (player == null)
{
return(false);
}
int x = player.X + xOffset;
int y = player.Y + yOffset;
int z = player.Z + zOffset;
ActionPacketQueue.EnqueueDragDropGround(entity.Serial, amount, x, y, z);
return(true);
}
public static Task EquipItem(int serial, Layer layer, QueuePriority queuePriority = QueuePriority.Medium)
{
int containerSerial = Engine.Player?.Serial ?? 0;
if (containerSerial == 0 || containerSerial == -1)
{
return(Task.CompletedTask);
}
if (layer == Layer.Invalid)
{
SystemMessage(Strings.Invalid_layer_value___, (int)SystemMessageHues.Red);
return(Task.CompletedTask);
}
return(ActionPacketQueue.EnqueueAction(serial, i =>
{
Engine.SendPacketToServer(new DragItem(i, 1));
Thread.Sleep(50);
Engine.SendPacketToServer(new EquipRequest(i, layer, containerSerial));
return true;
}, queuePriority));
}
public static void MoveItemOffset(object obj, int xOffset, int yOffset, int zOffset, int amount = -1)
{
int serial = AliasCommands.ResolveSerial(obj);
if (serial == 0)
{
UOC.SystemMessage(Strings.Invalid_or_unknown_object_id);
return;
}
PlayerMobile player = Engine.Player;
if (player == null)
{
return;
}
int x = player.X + xOffset;
int y = player.Y + yOffset;
int z = player.Z + zOffset;
ActionPacketQueue.EnqueueDragDropGround(serial, amount, x, y, z);
}
public void Cleanup()
{
ActionPacketQueue.Clear();
}
public static void MoveType(int id, object sourceContainer, object destinationContainer, int x = -1,
int y = -1, int z = 0, int hue = -1, int amount = -1)
{
int sourceSerial = AliasCommands.ResolveSerial(sourceContainer);
if (sourceSerial == -1)
{
UOC.SystemMessage(Strings.Invalid_source_container___);
return;
}
int destinationSerial;
if (destinationContainer is int destSerial)
{
destinationSerial = destSerial;
}
else
{
destinationSerial = AliasCommands.ResolveSerial(destinationContainer);
}
Item sourceItem = Engine.Items.GetItem(sourceSerial);
if (sourceItem == null)
{
UOC.SystemMessage(Strings.Cannot_find_item___);
return;
}
if (sourceItem.Container == null)
{
UOC.SystemMessage(Strings.Invalid_container___);
return;
}
Item entity = sourceItem.Container.SelectEntities(i => i.ID == id && (hue == -1 || i.Hue == hue))
.FirstOrDefault();
if (entity == null)
{
return;
}
if (amount == -1)
{
amount = entity.Count;
}
if (amount > entity.Count)
{
amount = entity.Count;
}
if (destinationSerial == -1)
{
ActionPacketQueue.EnqueueDragDropGround(entity.Serial, amount, x, y, z);
}
else
{
ActionPacketQueue.EnqueueDragDrop(entity.Serial, amount, destinationSerial);
}
}
public bool CheckHands(int serial)
{
if (!Options.CurrentOptions.CheckHandsPotions)
{
return(false);
}
Item item = Engine.Items?.GetItem(serial);
if (item == null || !_potionTypes.Contains(item.ID))
{
return(false);
}
// Explosion / Conflagaration pot doesn't need hand free
if (item.ID == 0xf0d && item.Hue == 0 || item.ID == 0xf06 && item.Hue == 1161)
{
return(false);
}
if (_checkHandsInProgress)
{
UOC.SystemMessage(Strings.Arm___Disarm_already_in_progress___, (int)UOC.SystemMessageHues.Red);
return(false);
}
_checkHandsInProgress = true;
Item leftHand = Engine.Player?.Equipment.FirstOrDefault(i => i.Layer == Layer.TwoHanded);
Item rightHand = Engine.Player?.Equipment.FirstOrDefault(i => i.Layer == Layer.OneHanded);
if (leftHand == null && rightHand != null)
{
//OSI crossbow in OneHanded layer??
leftHand = rightHand;
rightHand = null;
}
WeaponData leftHandWD = null;
if (leftHand != null)
{
leftHandWD = GetWeaponData(leftHand.ID);
}
if ((!(leftHandWD?.Twohanded ?? false) && leftHand?.Properties != null &&
!(leftHand.Properties?.Any(p => p.Cliloc == 1061171 /* Two-Handed Weapon */) ?? false) ||
leftHand?.Properties != null &&
!(leftHand.Properties?.All(p => p.Cliloc != 1072792 /* Balanced */) ?? false)) &&
(rightHand == null || leftHand == null))
{
_checkHandsInProgress = false;
return(false);
}
if (leftHand == null)
{
_checkHandsInProgress = false;
return(false);
}
ActionPacketQueue.EnqueueDragDrop(leftHand.Serial, 1, Engine.Player.GetLayer(Layer.Backpack),
QueuePriority.High);
ActionPacketQueue.EnqueuePackets(
new BasePacket[]
{
new UseObject(serial), new DragItem(leftHand.Serial, 1),
new EquipRequest(leftHand.Serial, leftHand.Layer, (int)Engine.Player?.Serial)
}, QueuePriority.High).ContinueWith(t => _checkHandsInProgress = false);
return(true);
}
public override void Execute()
{
ActionPacketQueue.Clear();
}
