static List <WeightedItem <T> > GetCumulativeWeightedList <T>(IEnumerable <WeightedItem <T> > items)
{
var result = new List <WeightedItem <T> >();
var relevantItems = items
.Where(i => i.Weight > 0)
.ToArray();
if (relevantItems.Length > 0)
{
var total = Sum(relevantItems.Select(i => i.Weight));
uint threshold = 0;
foreach (var i in relevantItems.Take(relevantItems.Length - 1))
{
threshold += Scale(i.Weight, total);
result.Add(WeightedItem.Create(threshold, i.Item));
}
var lastItem = relevantItems[relevantItems.Length - 1].Item;
result.Add(WeightedItem.Create(uint.MaxValue, lastItem));
}
return(result);
}
internal List <T> Select(int count)
{
Validate(count);
//Create a shallow clone of the our items, because we're going to be removing
//items from the list in some cases, and we want to preserve the original.
var Items = new List <WeightedItem <T> >(WeightedSelector.Items);
var ResultList = new List <T>();
do
{
WeightedItem <T> Item = null;
if (WeightedSelector.Options.AllowDuplicates)
{
Item = ExecuteSelect(Items); //Use binary search if we can.
}
else
{
//Force linear search, since AllowDuplicates currently breaks binary search.
Item = ExecuteSelectWithLinearSearch(Items);
}
ResultList.Add(Item.Value);
if (!WeightedSelector.Options.AllowDuplicates)
{
Items.Remove(Item);
}
} while (ResultList.Count < count);
return(ResultList);
}
/*
* Returns a random object from our prefab list
*/
private GameObject randomPrefab()
{
//Finding some random object with probability of the weights
float sum_of_weights = 0;
//Summing all the weights
foreach (WeightedItem i in prefabs)
{
sum_of_weights += i.getWeight();
}
//Getting a random number between 0 and the sum of the weights
float rnd = Random.Range(0, sum_of_weights);
//Returning the random object
foreach (WeightedItem i in prefabs)
{
if (rnd < i.getWeight())
{
return(i.getObject());
}
rnd -= i.getWeight();
}
//If we don't pick anything, just return some random prefab
//We should never be here, this is just in case
WeightedItem item = prefabs[Random.Range(0, prefabs.Length)];
return(item.getObject());
}
public void CanEquipItemIntoEmptySlot()
{
var inventory = new Inventory();
var item = new WeightedItem { Weight = Weight.Heavy, Name = "hello" };
inventory.Add(item);
Assert.True(inventory.Equip(item));
Assert.Same(inventory.HeavySlotItem, item);
}
// This method is populating the ListView with WeightedItem objects
// that have been entered by the user
private void PopulateAssignments(WeightedItem item)
{
RetrieveAssignments();
if (item != null)
{
Assignments.Add(item);
}
AssignmentsList.DataSource = Assignments;
AssignmentsList.DataBind();
}
public void WeightedAverage_IEnumerableToScalar_FloatProperty_SourceCumulativePercentageToOverflow_NotInfinityReturned()
{
IEnumerable <WeightedItem <float> > source = new WeightedItem <float>[] {
new WeightedItem <float>(float.MaxValue, float.MaxValue),
new WeightedItem <float>(float.MaxValue, float.MaxValue)
};
var result = source.WeightedAverage(x => x.Value, x => x.Weight);
float.IsPositiveInfinity(result).Should().BeFalse();
}
public void CanEquipItemIntoTakenSlotIfAutoUnequip()
{
var inventory = new Inventory();
var item1 = new WeightedItem { Weight = Weight.Heavy, Name = "hello1" };
var item2 = new WeightedItem { Weight = Weight.Heavy, Name = "hello2" };
inventory.Add(item1);
inventory.Add(item2);
Assert.True(inventory.Equip(item1));
Assert.Same(inventory.HeavySlotItem, item1);
Assert.True(inventory.Equip(item2));
Assert.Same(inventory.HeavySlotItem, item2);
}
// This method handles the list view's OnItemInserting command.
// That command gets triggered by the linkbutton with the CommandName="Insert"
protected void AssignmentsList_ItemInserting(object sender, ListViewInsertEventArgs e)
{
// Grab the values that were inserted.
string name = e.Values[nameof(WeightedItem.AssignmentName)].ToString();
int weight = Convert.ToInt32(e.Values[nameof(WeightedItem.Weight)]);
var newItem = new WeightedItem {
AssignmentName = name, Weight = weight
};
// bind the listview with the added information
PopulateAssignments(newItem);
}
public Door GetFinishingDoorByTargetBuilding(Door selectedDoor, int targetBuildingId)
// TODO: Move this to DoorManager
{
List <WeightedItem <Door> > doorList = new List <WeightedItem <Door> >();
foreach (var possibleDoor in GetBuilding(targetBuildingId).Doors)
{
var distance = Vector3.Distance(selectedDoor.transform.position, possibleDoor.transform.position);
doorList.Add(new WeightedItem <Door>(possibleDoor, Mathf.Pow(1 / distance, 10)));
}
return(WeightedItem <Door> .Choose(doorList));
}
/// <summary>
/// Adds a new <see cref="WeightedItem{T}" /> to the selector
/// </summary>
/// <param name="item">The item to add</param>
public void Add(WeightedItem <T> item)
{
if (item.Weight <= 0)
{
if (_options.HasFlag(SelectorOptions.IgnoreZeroWeight))
{
return;
}
throw new InvalidOperationException("Scores must be >= 0");
}
_forceRecalculation = true;
_items.Add(item);
}
public void WeightedAverage_IEnumerableToScalar_DecimalProperty_SourceCumulativePercentageToOverflow_OverflowExceptionThrown()
{
IEnumerable <WeightedItem <decimal> > source = new WeightedItem <decimal>[] {
new WeightedItem <decimal>(decimal.MaxValue, decimal.MaxValue),
new WeightedItem <decimal>(decimal.MaxValue, decimal.MaxValue)
};
Action comparison = () =>
{
source.WeightedAverage(x => x.Value, x => x.Weight);
};
comparison.ShouldThrow <OverflowException>();
}
public static List<WeightedItem<string>> CreateInputs(int minInputs, int maxInputs, int minWeight, int maxWeight)
{
var Gen = new Random();
var InputCount = Gen.Next(minInputs, maxInputs);
var Result = new List<WeightedItem<String>>();
for (var i = 1; i <= InputCount; i++)
{
var Item = new WeightedItem<string>(GetInputName(),
Gen.Next(minWeight, maxWeight));
Result.Add(Item);
}
return Result;
}
public static List <WeightedItem <string> > CreateInputs(int minInputs, int maxInputs, int minWeight, int maxWeight)
{
var Gen = new Random();
var InputCount = Gen.Next(minInputs, maxInputs);
var Result = new List <WeightedItem <String> >();
for (var i = 1; i <= InputCount; i++)
{
var Item = new WeightedItem <string>(GetInputName(),
Gen.Next(minWeight, maxWeight));
Result.Add(Item);
}
return(Result);
}
public Door GetDoorByTargetBuilding(int startingBuildingId, int targetBuildingId)
// TODO: Move this to DoorManager
{
List <WeightedItem <Door> > doorList = new List <WeightedItem <Door> >();
foreach (var possibleDoor in GetBuilding(startingBuildingId).Doors)
{
var distance = Vector3.Distance(
GetBuilding(targetBuildingId).AveragePosition,
possibleDoor.transform.position
);
doorList.Add(new WeightedItem <Door>(possibleDoor, 1f / distance));
}
return(WeightedItem <Door> .Choose(doorList));
}
public T getItem()
{
int roll = Random.Range(0, _totalWeight);
int currentWeight = 0;
for (int i = 0; i < _contents.Count; i++)
{
WeightedItem <T> currentItem = _contents[i];
currentWeight += currentItem.getWeight();
if (roll < currentWeight)
{
return(currentItem.getItem());
}
}
return(default(T));
}
/// <summary>
/// dynamically return a list with the correct weighting for the sector
/// as determined by the game controller
///
/// https://dotnetcodr.com/2014/10/17/dynamically-finding-the-value-of-a-static-field-with-reflection-in-net-c/
/// </summary>
/// <param name="weighting">class of arrays of weightings for the different arrays above</param>
/// <param name="dataSet">which data set you wish to use: RelationType, Occupation,
/// Priors, and anyothers that need to be implemented(please replace when written) </param>
/// <returns></returns>
public static List <WeightedItem> InitilizeSystem(Weightings[] weighting, String dataSet)
{
List <WeightedItem> tempList = new List <WeightedItem>();
Debug.Log("Reflections DP string: " + dataSet);
Type this_class = Type.GetType("StoredData_DataPoints"); // using reflections to dynamically build a list for the
System.Reflection.FieldInfo stringtype = this_class.GetField(dataSet); //game controller for spawning npcs with data for the current sector
WeightedItem temp = new WeightedItem();
if (stringtype.FieldType == typeof(int[]))
{
int[] fieldFind = (int[])stringtype.GetValue(null);
for (int i = 0; i < fieldFind.Length; i++)
{
//Debug.Log("Potato 1C Rep || i: " + i + " | " + dataSet + " | curr: " + fieldFind[i]);
temp.weight.normal = weighting[i].normal;
temp.weight.redHerring = weighting[i].redHerring;
temp.weight.Target = weighting[i].Target;
temp.item = fieldFind[i].ToString();
tempList.Add(temp);
}
}
else
{
string[] fieldFind = (string[])stringtype.GetValue(null);
for (int i = 0; i < fieldFind.Length; i++)
{
Debug.Log("Potato 1C Rep || i: " + i + " | " + dataSet + " | curr: " + fieldFind[i]);
temp.weight.normal = weighting[i].normal;
temp.weight.redHerring = weighting[i].redHerring;
temp.weight.Target = weighting[i].Target;
temp.item = fieldFind[i];
tempList.Add(temp);
}
}
return(tempList);
}
public WeightedRandomPicker <T> Build()
{
if (this.weightedItems.Count == 0)
{
throw new InvalidOperationException("Must have at least one item.");
}
// sort the weighted items in increasing order by weight. if there's a *very* large
// gap in weights, I *think* that sorting them like this improves how closely we'll
// match the expected distribution for the low ones; if not, I apologize to your CPU
// (but I'm pretty sure that at least it won't be *worse*).
var weightedItemsArray = new WeightedItem[this.weightedItems.Count];
this.weightedItems.CopyTo(weightedItemsArray);
Array.Sort(weightedItemsArray, CompareWeightedItems);
var items = new T[weightedItemsArray.Length];
double[] newWeights = new double[items.Length];
// reweight, step 1: set each weight to the sum of itself and all weights before it.
double weightSoFar = 0;
for (int i = 0; i < weightedItemsArray.Length; ++i)
{
WeightedItem weightedItem = weightedItemsArray[i];
items[i] = weightedItem.Item;
newWeights[i] = weightSoFar += weightedItem.Weight;
}
// reweight, step 2: divide each weight by the sum total of all weights observed.
// the final entry's weight, therefore, should be 1.
for (int i = 0; i < newWeights.Length; ++i)
{
newWeights[i] /= weightSoFar;
}
Debug.Assert(newWeights[newWeights.Length - 1] == 1, "Any double value divided by itself should be 1...");
newWeights[newWeights.Length - 1] = 1;
return(new WeightedRandomPicker <T>(items, newWeights));
}
public static T Choose(List <WeightedItem <T> > items)
{
int cumulSum = 0;
int cnt = items.Count();
for (int slot = 0; slot < cnt; slot++)
{
cumulSum += items[slot].weight;
items[slot].cumulativeSum = cumulSum;
}
double divSpot = rndInst.NextDouble() * cumulSum;
WeightedItem <T> chosen = items.FirstOrDefault(i => i.cumulativeSum >= divSpot);
if (chosen == null)
{
throw new Exception("No item chosen - there seems to be a problem with the probability distribution.");
}
return(chosen.value);
}
private void RetrieveAssignments()
{
// Loop through all the items in the ListView, and add them back to
// our List<WeightedItem> field.
foreach (ListViewDataItem item in AssignmentsList.Items)
{
// Use the item to find the control that has the data we want
var nameLabel = item.FindControl("AssignmentTitle") as Label;
var weightLabel = item.FindControl("Weight") as Label;
if (nameLabel != null && weightLabel != null)
{
var existing = new WeightedItem
{
AssignmentName = nameLabel.Text,
Weight = int.Parse(weightLabel.Text)
};
Assignments.Add(existing);
}
}
}
public static SerializableTrigramStatistics Count(IEnumerable <string> wordlist)
{
var count = GetTrigramCount(wordlist);
var prefixWeights = count
.GroupBy(kv => Tuple.Create(kv.Key.Item1, kv.Key.Item2), kv => kv.Value)
.Select(g => WeightedItem.Create(Sum(g), g.Key))
.OrderBy(i => i.Item.Item1).ThenBy(i => i.Item.Item2);
return(new SerializableTrigramStatistics
{
PrefixWeights = GetCumulativeWeightedList(prefixWeights),
TrigramWeights = count
.GroupBy(
kv => Tuple.Create(kv.Key.Item1, kv.Key.Item2),
kv => Tuple.Create(kv.Key.Item3, kv.Value))
.ToDictionary(
g => g.Key,
g => GetCumulativeWeightedList(
g.Select(t => WeightedItem.Create(t.Item2, t.Item1)).OrderBy(i => i.Item))),
});
}
public void Mutate(ref IWeightedList <ConcreteSpecimen> population)
{
// Mutate
var numberOfMutableProperties = 1;
var totalNumberOfMutableProperties = population.Count * numberOfMutableProperties; // population size * number of mutable properties.
var indexes = Enumerable.Range(0, totalNumberOfMutableProperties)
.OrderBy(x => Guid.NewGuid())
.Take((int)Math.Floor(_mutationProbability * totalNumberOfMutableProperties));
iteration = (iteration + 1) % 10;
var strength = Math.Sin((iteration / 10.0d) * Math.PI);
var mutationFactorX = strength * (random.Next(0, 2) == 0 ? -1 : 1) * random.NextDouble() * 10d;
foreach (var idx in indexes)
{
var cellIndex = idx / numberOfMutableProperties;
var propertyIndex = idx % numberOfMutableProperties;
var specimen = population[cellIndex].Item;
var x = specimen.X;
switch (propertyIndex)
{
case 0: x = x + mutationFactorX; break;
default: throw new ArgumentOutOfRangeException(nameof(propertyIndex));
}
var mutatedSpecimen = new ConcreteSpecimen(x);
population[cellIndex] = new WeightedItem <ConcreteSpecimen>(mutatedSpecimen, 0);
}
}
void RandomEventRoom()
{
ClearParagraph();
WeightedItem <int> P50 = new WeightedItem <int>(1, 5);
WeightedItem <int> P20 = new WeightedItem <int>(2, 2);
WeightedItem <int> P10 = new WeightedItem <int>(3, 1);
WeightedItem <int> P1 = new WeightedItem <int>(4, 1);
var rerun = Room.CreateContainer("Rerun", () => RandomEventRoom());
List <WeightedItem <int> > myList = new List <WeightedItem <int> > {
P50, P20, P10, P1
};
int chosen = WeightedItem <int> .Choose(myList);
Run pick = new Run();
if (chosen == 1)
{
Player.HasKnot = true;
pick = Room.CreateRun($"It landed on one! {HasKnot("I will f**k you tonight")}");
}
else if (chosen == 2)
{
Player.HasKnot = false;
pick = Room.CreateRun($"It landed on two! {HasKnot("I will f**k you tonight")}");
}
else if (chosen == 3)
{
pick = Room.CreateRun("It landed on three!");
}
else if (chosen == 4)
{
pick = Room.CreateRun("It landed on four!");
}
Run stats = Room.CreateRun(GameStats());
AddInline(pick, rerun, "\n\n", stats);
}
public void CanNotEquipItemIntoTakenSlotIfNoAutoUnequip()
{
var inventory = new Inventory();
var item1 = new WeightedItem { Weight = Weight.Heavy, Name = "hello1" };
var item2 = new WeightedItem { Weight = Weight.Heavy, Name = "hello2" };
inventory.Add(item1);
inventory.Add(item2);
Assert.True(inventory.Equip(item1, false));
Assert.Same(inventory.HeavySlotItem, item1);
Assert.False(inventory.Equip(item2, false));
Assert.Same(inventory.HeavySlotItem, item1);
Assert.NotSame(inventory.HeavySlotItem, item2);
Assert.NotNull(inventory.HeavySlotItem);
}
public void NaturalSelection(ref IWeightedList <ConcreteSpecimen> population)
{
var originalPopulation = population.ToArray();
population.Clear();
var count = originalPopulation.Length;
var numberOfParents = 2;
var sumFitness = originalPopulation.Sum(x => x.Weight);
var random = new Random();
var acceptableSpecimens = new List <ConcreteSpecimen>();
/**************************************************************************************************
* Based on https://stackoverflow.com/questions/10765660/roulette-wheel-selection-procedure *
**************************************************************************************************
* *
* For all members of population *
* sum += fitness ( member ) *
* End for *
* *
* Loop until new population is full *
* Do this twice *
* Number = Random between 0 and sum *
* Currentfitness = 0.0 *
* For each member in population *
* Currentfitness += fitness(member) *
* if Number > Currentfitness then select member *
* End for *
* End *
* Create offspring *
* End loop *
* *
**************************************************************************************************/
for (var i = 0; i < count; i++)
{
var parents = new WeightedItem <ConcreteSpecimen> [2];
for (var j = 0; j < numberOfParents; j++)
{
while (parents[j] == null)
{
var number = random.NextDouble() * sumFitness;
var currentFitness = 0.0d;
foreach (var item in originalPopulation)
{
currentFitness += item.Weight;
if (number > currentFitness)
{
parents[j] = item;
}
}
}
}
double x;
switch (random.Next(4))
{
case 0:
case 1:
case 2:
x = (parents[0].Weight * parents[0].Item.X + parents[1].Weight * parents[1].Item.X) / (parents[0].Weight + parents[1].Weight);
break;
default:
// Default case: let's just randomly select which gene is coming from which parent...
x = parents[random.Next(0, 2)].Item.X;
break;
}
var offSpring = new ConcreteSpecimen(x);
population.Add(new WeightedItem <ConcreteSpecimen>(offSpring, 0));
}
}
public void CanNotEquipItemNotInInventory()
{
var inventory = new Inventory();
var item = new WeightedItem { Weight = Weight.Heavy, Name = "hello" };
Assert.False(inventory.Equip(item));
inventory.Add(item);
Assert.True(inventory.Equip(item));
}
public void CollectionBehaviourIsCorrect()
{
var inventory = new Inventory();
var item1 = new WeightedItem { Weight = Weight.Heavy, Name = "hello1" };
var item2 = new WeightedItem { Weight = Weight.Heavy, Name = "hello2" };
inventory.Add(item1);
inventory.Add(item2);
Assert.Contains(item1, inventory.AllItems);
Assert.Contains(item2, inventory.AllItems);
Assert.Contains(item1, inventory.UnequippedItems);
Assert.Contains(item2, inventory.UnequippedItems);
Assert.DoesNotContain(item1, inventory.EquippedItems);
Assert.DoesNotContain(item2, inventory.EquippedItems);
Assert.True(inventory.Equip(item1));
Assert.DoesNotContain(item1, inventory.UnequippedItems);
Assert.Contains(item2, inventory.UnequippedItems);
Assert.Contains(item1, inventory.EquippedItems);
Assert.DoesNotContain(item2, inventory.EquippedItems);
Assert.True(inventory.Equip(item2));
Assert.Contains(item1, inventory.UnequippedItems);
Assert.DoesNotContain(item2, inventory.UnequippedItems);
Assert.DoesNotContain(item1, inventory.EquippedItems);
Assert.Contains(item2, inventory.EquippedItems);
}
private static bool Prefix(TechType techType, int num = 1, bool noMessage = false, bool spawnIfCantAdd = true)
{
if (techType == TechType.Titanium && num == 2 && !noMessage && spawnIfCantAdd)
{
TechType scannedFragment = PDAScanner.scanTarget.techType;
#if !RELEASE
Logger.Log(Logger.Level.Debug, $"Intercepting scan of fragment {scannedFragment.ToString()}");
#endif
TechData recipe; // "Variable declaration can be inlined" says Visual Studio, but I'm not sure if it would remain in-scope further down the function if it is.
if (IngredientsFromScanning.Main.config.TryOverrideRecipe(scannedFragment, out recipe))
{
#if !RELEASE
Logger.Log(Logger.Level.Debug, $"Using OverrideRecipe: {JsonConvert.SerializeObject(recipe, Oculus.Newtonsoft.Json.Formatting.Indented)}");
#endif
}
else if ((int)scannedFragment > 1112 && (int)scannedFragment < 1117)
{
// TechTypes 1113 to 1116 are Cyclops fragments, which have no blueprint associated, so we need to process them specially.
recipe = new TechData();
/*CyclopsHullFragment = 1113,
* CyclopsBridgeFragment = 1114,
* CyclopsEngineFragment = 1115,
* CyclopsDockingBayFragment = 1116,*/
switch ((int)scannedFragment)
{
case 1113:
recipe.Ingredients.Add(new Ingredient(TechType.PlasteelIngot, 2));
recipe.Ingredients.Add(new Ingredient(TechType.Lead, 1));
break;
case 1114:
recipe.Ingredients.Add(new Ingredient(TechType.EnameledGlass, 3));
break;
case 1115:
recipe.Ingredients.Add(new Ingredient(TechType.Lubricant, 1));
recipe.Ingredients.Add(new Ingredient(TechType.AdvancedWiringKit, 1));
recipe.Ingredients.Add(new Ingredient(TechType.Lead, 1));
break;
case 1116:
recipe.Ingredients.Add(new Ingredient(TechType.PlasteelIngot, 2));
break;
}
recipe.Ingredients.Add(new Ingredient(TechType.Lead, 1));
recipe.Ingredients.Add(new Ingredient(TechType.PlasteelIngot, 1));
#if !RELEASE
Logger.Log(Logger.Level.Debug, $"Using recipe from manual override: {JsonConvert.SerializeObject(recipe, Oculus.Newtonsoft.Json.Formatting.Indented)}");
#endif
}
else
{
PDAScanner.EntryData entryData = PDAScanner.GetEntryData(scannedFragment);
if (entryData == null) // Sanity check; this should always be true
{
#if !RELEASE
Logger.Log(Logger.Level.Debug, $"Failed to find EntryData for fragment");
#endif
/*CraftData.AddToInventory(TechType.Titanium);
* CraftData.AddToInventory(TechType.Titanium); // Adding them one-by-one so as to prevent it being caught by this very routine.*/
return(true);
}
//Logger.Log(Logger.Level.Debug, $"Found entryData {entryData.ToString()}");
#if !RELEASE
Logger.Log(Logger.Level.Debug, $"Found entryData {JsonConvert.SerializeObject(entryData, Oculus.Newtonsoft.Json.Formatting.Indented)}");
#endif
//CraftData.AddToInventory(TechType.Titanium);
//CraftData.AddToInventory(TechType.Copper);
recipe = CraftDataHandler.GetTechData(entryData.blueprint);
if (recipe == null)
{
#if !RELEASE
Logger.Log(Logger.Level.Debug, $"Failed to find blueprint for EntryData");
#endif
/*CraftData.AddToInventory(TechType.Titanium);
* CraftData.AddToInventory(TechType.Titanium); // One-by-one again, as above.*/
return(true);
}
//Logger.Log(Logger.Level.Debug, $"Found recipe {recipe.ToString()}");
#if !RELEASE
Logger.Log(Logger.Level.Debug, $"Using recipe from EntryData: {JsonConvert.SerializeObject(recipe, Oculus.Newtonsoft.Json.Formatting.Indented)}");
#endif
}
for (int i = 0; i < recipe.Ingredients.Count; i++)
{
if (IngredientsFromScanning.Main.config.TrySubstituteIngredient(recipe.Ingredients[i].techType, out List <Ingredient> Substitutes))
{
foreach (Ingredient sub in Substitutes)
{
recipe.Ingredients.Add(sub);
}
recipe.Ingredients.RemoveAt(i); // Remove the current ingredient...
i--; // ...and make sure the loop continues at the item after this, not the one after that.
}
}
// I believe the easiest way to get a random item from the blueprint would be to make a list of techTypes; if an ingredient is used twice in the recipe, it will appear in the list twice.
// That way, we can generate a random number where 0<=rnd<list.count, and select that item.
List <TechType> bp = new List <TechType> {
};
for (int i = 0; i < recipe.Ingredients.Count; i++)
{
for (int j = 0; j < recipe.Ingredients[i].amount; j++)
{
bp.Add(recipe.Ingredients[i].techType);
}
}
// Now build up weights
List <WeightedItem> BlueprintPairs = new List <WeightedItem>();
float TotalWeight = 0f;
//Logger.Log(Logger.Level.Error, "Unidentified Vehicle Type!");
for (int i = 0; i < bp.Count; i++)
{
float thisWeight = IngredientsFromScanning.Main.config.GetWeightForTechType(bp[i]);
TotalWeight += thisWeight;
WeightedItem thisWeightedItem = new WeightedItem(TotalWeight, bp[i]);
#if !RELEASE
Logger.Log(Logger.Level.Debug, $"Adding item to drop list, TechType = {thisWeightedItem.tech.ToString()}, this weight = {thisWeight}, cumulative weight = {thisWeightedItem.Weight}");
#endif
BlueprintPairs.Add(thisWeightedItem);
}
// Now we should be able to pick a few random numbers between 0 and the list's total weight, and add those. We want to remove that entry afterwards, but that's not a big ask.
System.Random rng = new System.Random();
int numIngredients = Math.Min(IngredientsFromScanning.Main.config.GenerateGiftValue(), BlueprintPairs.Count);
#if !RELEASE
Logger.Log(Logger.Level.Debug, $"Generated a value for this scan of {numIngredients} components.");
#endif
int awards = 0;
double r;
for (int i = 0; i < numIngredients && BlueprintPairs.Count > 0; i++)
{
r = rng.NextDouble() * TotalWeight;
for (int j = 0; j < BlueprintPairs.Count; j++)
{
// This part is for sanity checking
// ___________________________|______________________________
// / \
if (r < BlueprintPairs[j].Weight || ((j + 1) == BlueprintPairs.Count && awards < numIngredients))
{
#if !RELEASE
Logger.Log(Logger.Level.Debug, $"With randomised weight of {r}, adding tech {BlueprintPairs[j].tech} to player inventory");
#endif
AddInventory(BlueprintPairs[j].tech, 1, false, true);
//CraftData.AddToInventory(BlueprintPairs[j].tech, 1, false, true);
awards++;
TotalWeight -= IngredientsFromScanning.Main.config.GetWeightForTechType(BlueprintPairs[j].tech);
BlueprintPairs.RemoveAt(j);
break;
}
}
}
return(false);
}
return(true);
}
public void addWeightedItem(WeightedItem <T> item)
{
_contents.Add(item);
_totalWeight += item.getWeight();
}
/// <summary>
/// Removes the specified <see cref="WeightedItem{T}" /> from the selector
/// </summary>
/// <param name="item">The item to remove</param>
public void Remove(WeightedItem <T> item)
{
_forceRecalculation = true;
_items.Remove(item);
}
