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); }