public int GetBestGroupAmount(Type[] types, bool recurse, CheckItemGroup grouper)
{
if (grouper == null)
{
throw new ArgumentNullException();
}
int best = 0;
Item[] typedItems = FindItemsByType(types, 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);
}
for (int j = 0; j < groups.Count; ++j)
{
Item[] items = (Item[])(((ArrayList)groups[j]).ToArray(typeof(Item)));
int total = 0;
for (int k = 0; k < items.Length; ++k)
{
total += items[k].Amount;
}
if (total >= best)
{
best = total;
}
}
return(best);
}
public int GetAmountCompared(Type[] types, CheckItemGroup grouper, Item compareTo, bool recurse)
{
Item[] items = FindItemsByType(types, recurse);
int amount = 0;
for (int i = 0; i < items.Length; ++i)
{
if (compareTo == null)
{
compareTo = items[i];
amount += items[i].Amount;
}
else if (grouper(compareTo, items[i]) == 0)
{
amount += items[i].Amount;
}
}
return(amount);
}
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 GroupComparer(CheckItemGroup grouper)
{
m_Grouper = grouper;
}
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 GroupComparer( CheckItemGroup grouper )
{
m_Grouper = grouper;
}
public int GetBestGroupAmount( Type[][] types, bool recurse, CheckItemGroup grouper )
{
if ( grouper == null )
throw new ArgumentNullException();
int best = 0;
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 );
}
for ( int j = 0; j < groups.Count; ++j )
{
Item[] items = (Item[])(((ArrayList)groups[j]).ToArray( typeof( Item ) ));
int total = 0;
for ( int k = 0; k < items.Length; ++k )
total += items[k].Amount;
if ( total >= best )
best = total;
}
}
return best;
}
public int GetComparedGroupAmount( Type[] types, bool recurse, CheckItemGroup grouper, Item compareTo )
{
if( grouper == null )
throw new ArgumentNullException();
Item[] typedItems = FindItemsByType( types, recurse );
bool hasComparer = false;
if ( compareTo != null )
{
for ( int i = 0; i < types.Length; ++i )
{
if ( compareTo.GetType() == types[i] )
{
hasComparer = true;
break;
}
}
}
List<List<Item>> groups = new List<List<Item>>();
int idx = 0;
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 );
}
int total = 0;
for( int j = 0; j < groups.Count; ++j )
{
Item[] items = groups[j].ToArray();
for( int k = 0; k < items.Length; ++k )
total += items[k].Amount;
}
return total;
}
public int GetAmountCompared( Type[] types, CheckItemGroup grouper, Item compareTo, bool recurse )
{
Item[] items = FindItemsByType( types, recurse );
int amount = 0;
for ( int i = 0; i < items.Length; ++i )
{
if ( compareTo == null )
{
compareTo = items[i];
amount += items[i].Amount;
}
else if ( grouper( compareTo, items[i] ) == 0 )
amount += items[i].Amount;
}
return amount;
}
public int GetAmountCompared( Type[] types, CheckItemGroup grouper, Item compareTo )
{
return GetAmountCompared( types, grouper, compareTo, true );
}
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 GetAmountCompared(Type[] types, CheckItemGroup grouper, Item compareTo)
{
return(GetAmountCompared(types, grouper, compareTo, true));
}
public int GetComparedGroupAmount(Type[] types, bool recurse, CheckItemGroup grouper, Item compareTo)
{
if (grouper == null)
{
throw new ArgumentNullException();
}
Item[] typedItems = FindItemsByType(types, recurse);
bool hasComparer = false;
if (compareTo != null)
{
for (int i = 0; i < types.Length; ++i)
{
if (compareTo.GetType() == types[i])
{
hasComparer = true;
break;
}
}
}
List <List <Item> > groups = new List <List <Item> >();
int idx = 0;
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);
}
int total = 0;
for (int j = 0; j < groups.Count; ++j)
{
Item[] items = groups[j].ToArray();
for (int k = 0; k < items.Length; ++k)
{
total += items[k].Amount;
}
}
return(total);
}
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);
}
