private void ConsumeNeeded(ref int need, Item item, OnItemConsumed callback)
{
int theirAmount = item.Amount;
if (theirAmount < need)
{
if (callback != null)
{
callback(item, theirAmount);
}
item.Delete();
need -= theirAmount;
}
else
{
if (callback != null)
{
callback(item, need);
}
item.Consume(need);
need = 0;
}
}
public int ConsumeTotal(Type[] types, int[] amounts, bool recurse, OnItemConsumed callback)
{
if (types.Length != amounts.Length)
{
throw new ArgumentException();
}
Item[][] items = new Item[types.Length][];
int[] totals = new int[types.Length];
for (int i = 0; i < types.Length; ++i)
{
items[i] = FindItemsByType(types[i], recurse);
for (int j = 0; j < items[i].Length; ++j)
{
totals[i] += items[i][j].Amount;
}
if (totals[i] < amounts[i])
{
return(i);
}
}
for (int i = 0; i < types.Length; ++i)
{
int need = amounts[i];
for (int j = 0; j < items[i].Length; ++j)
{
Item item = items[i][j];
int theirAmount = item.Amount;
if (theirAmount < need)
{
if (callback != null)
{
callback(item, theirAmount);
}
item.Delete();
need -= theirAmount;
}
else
{
if (callback != null)
{
callback(item, need);
}
item.Consume(need);
break;
}
}
}
return(-1);
}
public bool ConsumeTotal(Type type, int amount, bool recurse, OnItemConsumed callback)
{
Item[] items = FindItemsByType(type, recurse);
// First pass, compute total
int total = 0;
for (int i = 0; i < items.Length; ++i)
{
total += items[i].Amount;
}
if (total >= amount)
{
// We've enough, so consume it
int need = amount;
for (int i = 0; i < items.Length; ++i)
{
Item item = items[i];
int theirAmount = item.Amount;
if (theirAmount < need)
{
if (callback != null)
{
callback(item, theirAmount);
}
item.Delete();
need -= theirAmount;
}
else
{
if (callback != null)
{
callback(item, need);
}
item.Consume(need);
return(true);
}
}
}
return(false);
}
public int ConsumeTotalGrouped(Type[][] types, int[] amounts, bool recurse, OnItemConsumed callback, CheckItemGroup grouper)
{
if (types.Length != amounts.Length)
{
throw new ArgumentException();
}
else if (grouper == null)
{
throw new ArgumentNullException();
}
Item[][][] items = new Item[types.Length][][];
int[][] totals = new int[types.Length][];
for (int i = 0; i < types.Length; ++i)
{
Item[] typedItems = FindItemsByType(types[i], recurse);
ArrayList groups = new ArrayList();
int idx = 0;
while (idx < typedItems.Length)
{
Item a = typedItems[idx++];
ArrayList group = new ArrayList();
group.Add(a);
while (idx < typedItems.Length)
{
Item b = typedItems[idx];
int v = grouper(a, b);
if (v == 0)
{
group.Add(b);
}
else
{
break;
}
++idx;
}
groups.Add(group);
}
items[i] = new Item[groups.Count][];
totals[i] = new int[groups.Count];
bool hasEnough = false;
for (int j = 0; j < groups.Count; ++j)
{
items[i][j] = (Item[])(((ArrayList)groups[j]).ToArray(typeof(Item)));
for (int k = 0; k < items[i][j].Length; ++k)
{
totals[i][j] += items[i][j][k].Amount;
}
if (totals[i][j] >= amounts[i])
{
hasEnough = true;
}
}
if (!hasEnough)
{
return(i);
}
}
for (int i = 0; i < items.Length; ++i)
{
for (int j = 0; j < items[i].Length; ++j)
{
if (totals[i][j] >= amounts[i])
{
int need = amounts[i];
for (int k = 0; k < items[i][j].Length; ++k)
{
Item item = items[i][j][k];
int theirAmount = item.Amount;
if (theirAmount < need)
{
if (callback != null)
{
callback(item, theirAmount);
}
item.Delete();
need -= theirAmount;
}
else
{
if (callback != null)
{
callback(item, need);
}
item.Consume(need);
break;
}
}
break;
}
}
}
return(-1);
}
public int ConsumeTotalGrouped( Type[][] types, int[] amounts, bool recurse, OnItemConsumed callback, CheckItemGroup grouper )
{
if ( types.Length != amounts.Length )
throw new ArgumentException();
else if ( grouper == null )
throw new ArgumentNullException();
Item[][][] items = new Item[types.Length][][];
int[][] totals = new int[types.Length][];
for ( int i = 0; i < types.Length; ++i )
{
Item[] typedItems = FindItemsByType( types[i], recurse );
ArrayList groups = new ArrayList();
int idx = 0;
while ( idx < typedItems.Length )
{
Item a = typedItems[idx++];
ArrayList group = new ArrayList();
group.Add( a );
while ( idx < typedItems.Length )
{
Item b = typedItems[idx];
int v = grouper( a, b );
if ( v == 0 )
group.Add( b );
else
break;
++idx;
}
groups.Add( group );
}
items[i] = new Item[groups.Count][];
totals[i] = new int[groups.Count];
bool hasEnough = false;
for ( int j = 0; j < groups.Count; ++j )
{
items[i][j] = (Item[])(((ArrayList)groups[j]).ToArray( typeof( Item ) ));
for ( int k = 0; k < items[i][j].Length; ++k )
totals[i][j] += items[i][j][k].Amount;
if ( totals[i][j] >= amounts[i] )
hasEnough = true;
}
if ( !hasEnough )
return i;
}
for ( int i = 0; i < items.Length; ++i )
{
for ( int j = 0; j < items[i].Length; ++j )
{
if ( totals[i][j] >= amounts[i] )
{
int need = amounts[i];
for ( int k = 0; k < items[i][j].Length; ++k )
{
Item item = items[i][j][k];
int theirAmount = item.Amount;
if ( theirAmount < need )
{
if ( callback != null )
callback( item, theirAmount );
item.Delete();
need -= theirAmount;
}
else
{
if ( callback != null )
callback( item, need );
item.Consume( need );
break;
}
}
break;
}
}
}
return -1;
}
public bool ConsumeTotal( Type type, int amount, bool recurse, OnItemConsumed callback )
{
Item[] items = FindItemsByType( type, recurse );
// First pass, compute total
int total = 0;
for ( int i = 0; i < items.Length; ++i )
total += items[i].Amount;
if ( total >= amount )
{
// We've enough, so consume it
int need = amount;
for ( int i = 0; i < items.Length; ++i )
{
Item item = items[i];
int theirAmount = item.Amount;
if ( theirAmount < need )
{
if ( callback != null )
callback( item, theirAmount );
item.Delete();
need -= theirAmount;
}
else
{
if ( callback != null )
callback( item, need );
item.Consume( need );
return true;
}
}
}
return false;
}
public int ConsumeTotal( Type[] types, int[] amounts, bool recurse, OnItemConsumed callback )
{
if ( types.Length != amounts.Length )
throw new ArgumentException();
Item[][] items = new Item[types.Length][];
int[] totals = new int[types.Length];
for ( int i = 0; i < types.Length; ++i )
{
items[i] = FindItemsByType( types[i], recurse );
for ( int j = 0; j < items[i].Length; ++j )
totals[i] += items[i][j].Amount;
if ( totals[i] < amounts[i] )
return i;
}
for ( int i = 0; i < types.Length; ++i )
{
int need = amounts[i];
for ( int j = 0; j < items[i].Length; ++j )
{
Item item = items[i][j];
int theirAmount = item.Amount;
if ( theirAmount < need )
{
if ( callback != null )
callback( item, theirAmount );
item.Delete();
need -= theirAmount;
}
else
{
if ( callback != null )
callback( item, need );
item.Consume( need );
break;
}
}
}
return -1;
}
private void ConsumeNeeded( ref int need, Item item, OnItemConsumed callback )
{
int theirAmount = item.Amount;
if ( theirAmount < need )
{
if ( callback != null )
callback( item, theirAmount );
item.Delete();
need -= theirAmount;
}
else
{
if ( callback != null )
callback( item, need );
item.Consume( need );
need = 0;
}
}
public int ConsumeTotalGroupedCompared( Type[][] types, int[] amounts, bool recurse, OnItemConsumed callback, CheckItemGroup grouper, Item compareTo )
{
if ( types.Length != amounts.Length )
throw new ArgumentException();
else if ( grouper == null )
throw new ArgumentNullException();
Item[][][] items = new Item[types.Length][][];
int[] totals = new int[types.Length];
bool hasComparer = false;
Item originalComparer = compareTo;
int comparerType = -1;
for ( int i = 0; i < types.Length; ++i )
{
Item[] typedItems = FindItemsByType( types[i], recurse );
List<List<Item>> groups = new List<List<Item>>();
int idx = 0;
if ( originalComparer != null )
{
for ( int j = 0; j < types[i].Length; ++j )
{
if ( originalComparer.GetType() == types[i][j] )
{
hasComparer = true;
compareTo = originalComparer;
comparerType = i;
break;
}
}
}
while( idx < typedItems.Length )
{
Item a = typedItems[idx++];
List<Item> group = new List<Item>();
if ( !hasComparer )
{
compareTo = a;
group.Add( a );
}
else if ( grouper( compareTo, a ) == 0 )
group.Add( a );
while( idx < typedItems.Length )
{
Item b = typedItems[idx];
int v = grouper( compareTo, b );
if( v == 0 )
group.Add( b );
else
break;
++idx;
}
groups.Add( group );
}
compareTo = originalComparer;
hasComparer = false;
items[i] = new Item[groups.Count][];
bool hasEnough = false;
for ( int j = 0; j < groups.Count; ++j )
{
items[i][j] = groups[j].ToArray();
for ( int k = 0; k < items[i][j].Length; ++k )
totals[i] += items[i][j][k].Amount;
}
if ( totals[i] >= amounts[i] )
hasEnough = true;
if ( !hasEnough )
return i;
}
for ( int i = 0; i < items.Length; ++i )
{
int need = amounts[i];
if ( originalComparer != null && comparerType == i )
{
object parent = originalComparer.RootParent;
if ( parent is Mobile )
{
Mobile m = (Mobile)parent;
if ( this.RootParent is Mobile && m == (Mobile)this.RootParent )
ConsumeNeeded( ref need, originalComparer, callback );
}
}
for ( int j = 0; j < items[i].Length && need > 0; ++j )
{
if ( totals[i] >= amounts[i] )
{
for ( int k = 0; k < items[i][j].Length && need > 0; ++k )
{
Item item = items[i][j][k];
if ( !item.Deleted )
ConsumeNeeded( ref need, item, callback );
}
}
}
}
return -1;
}
public int ConsumeTotalGroupedCompared(Type[][] types, int[] amounts, bool recurse, OnItemConsumed callback, CheckItemGroup grouper, Item compareTo)
{
if (types.Length != amounts.Length)
{
throw new ArgumentException();
}
else if (grouper == null)
{
throw new ArgumentNullException();
}
Item[][][] items = new Item[types.Length][][];
int[] totals = new int[types.Length];
bool hasComparer = false;
Item originalComparer = compareTo;
int comparerType = -1;
for (int i = 0; i < types.Length; ++i)
{
Item[] typedItems = FindItemsByType(types[i], recurse);
List <List <Item> > groups = new List <List <Item> >();
int idx = 0;
if (originalComparer != null)
{
for (int j = 0; j < types[i].Length; ++j)
{
if (originalComparer.GetType() == types[i][j])
{
hasComparer = true;
compareTo = originalComparer;
comparerType = i;
break;
}
}
}
while (idx < typedItems.Length)
{
Item a = typedItems[idx++];
List <Item> group = new List <Item>();
if (!hasComparer)
{
compareTo = a;
group.Add(a);
}
else if (grouper(compareTo, a) == 0)
{
group.Add(a);
}
while (idx < typedItems.Length)
{
Item b = typedItems[idx];
int v = grouper(compareTo, b);
if (v == 0)
{
group.Add(b);
}
else
{
break;
}
++idx;
}
groups.Add(group);
}
compareTo = originalComparer;
hasComparer = false;
items[i] = new Item[groups.Count][];
bool hasEnough = false;
for (int j = 0; j < groups.Count; ++j)
{
items[i][j] = groups[j].ToArray();
for (int k = 0; k < items[i][j].Length; ++k)
{
totals[i] += items[i][j][k].Amount;
}
}
if (totals[i] >= amounts[i])
{
hasEnough = true;
}
if (!hasEnough)
{
return(i);
}
}
for (int i = 0; i < items.Length; ++i)
{
int need = amounts[i];
if (originalComparer != null && comparerType == i)
{
object parent = originalComparer.RootParent;
if (parent is Mobile)
{
Mobile m = (Mobile)parent;
if (this.RootParent is Mobile && m == (Mobile)this.RootParent)
{
ConsumeNeeded(ref need, originalComparer, callback);
}
}
}
for (int j = 0; j < items[i].Length && need > 0; ++j)
{
if (totals[i] >= amounts[i])
{
for (int k = 0; k < items[i][j].Length && need > 0; ++k)
{
Item item = items[i][j][k];
if (!item.Deleted)
{
ConsumeNeeded(ref need, item, callback);
}
}
}
}
}
return(-1);
}
