public static FloatArray2D Random(int w, int h, float factor) { var arr = new FloatArray2D(w, h); for (var x = 0; x < w; x++) { for (var y = 0; y < h; y++) { arr[x, y] = th.NextFloat() * factor; } } return(arr); }
public static Vector3 MakeRandomColor(float totalColor) { List <float> colorComponents = new List <float>(); // 1 float val = ThreadSafeRandom.NextFloat(0, totalColor); totalColor -= val; colorComponents.Add(val); // 2 val = ThreadSafeRandom.NextFloat(0, totalColor); totalColor -= val; colorComponents.Add(val); // 3 colorComponents.Add(totalColor); //what's left // Build color with no respect to a single channel (pick random channels) Vector3 color = new Vector3(); var componentIdx = colorComponents.RandomIndex(); color.X = colorComponents[componentIdx]; colorComponents.RemoveAt(componentIdx); componentIdx = colorComponents.RandomIndex(); color.Y = colorComponents[componentIdx]; colorComponents.RemoveAt(componentIdx); componentIdx = colorComponents.RandomIndex(); color.Z = colorComponents[componentIdx]; colorComponents.RemoveAt(componentIdx); return(color); }
public static bool RandomizeExport(ExportEntry export, RandomizationOption option) { if (!CanRandomize(export)) { return(false); } var boneDefinitions = export.GetProperty <ArrayProperty <StructProperty> >(export.ClassName == @"BioLookAtDefinition" ? "BoneDefinitions" : "m_aLookBoneDefs"); if (boneDefinitions != null) { //Log.Information($"Randomizing BioLookAtDefinition {export.UIndex}"); foreach (var item in boneDefinitions) { //if (item.GetProp<NameProperty>("m_nBoneName").Value.Name.StartsWith("Eye")) //{ // item.GetProp<FloatProperty>("m_fLimit").Value = ThreadSafeRandom.Next(1, 5); // item.GetProp<FloatProperty>("m_fUpDownLimit").Value = ThreadSafeRandom.Next(1, 5); //} //else //{ item.GetProp <FloatProperty>(@"m_fDelay").Value = ThreadSafeRandom.NextFloat(0, 5); item.GetProp <FloatProperty>("m_fLimit").Value = ThreadSafeRandom.NextFloat(1, 170); item.GetProp <FloatProperty>("m_fUpDownLimit").Value = ThreadSafeRandom.NextFloat(70, 170); //} } export.WriteProperty(boneDefinitions); return(true); } return(false); }
public static bool PerformRandomization(RandomizationOption option) { var ini = CoalescedHandler.GetIniFile("BioGame.ini"); var section = ini.GetOrAddSection("SFXGame.SFXVehicleHover"); section.SetSingleEntry("JumpForce", GenerateRandomVectorStruct(-400, 400, 0, 0, 1200, 4000)); section.SetSingleEntry("OnGroundJumpMultiplier", ThreadSafeRandom.NextFloat(.5, 2)); section.SetSingleEntry("MaxThrustJuice", ThreadSafeRandom.NextFloat(0.5, 1)); section.SetSingleEntry("BoostForce", GenerateRandomVectorStruct(600, 2000, 0, 0, -200, 50)); section.SetSingleEntry("ThrustRegenerationFactor", ThreadSafeRandom.NextFloat(0.45, 0.7)); section.SetSingleEntry("SelfRepairRate", ThreadSafeRandom.NextFloat(50, 150)); section.SetSingleEntry("SelfRepairDelay", ThreadSafeRandom.NextFloat(3, 8)); section.SetSingleEntry("OffGroundForce", GenerateRandomVectorStruct(0, 0, 0, 0, -2200, -10)); section.SetSingleEntry("ThrustRegenerationDelay", ThreadSafeRandom.NextFloat(0.2, 1)); section.SetSingleEntry("VerticalThrustBurnRate", ThreadSafeRandom.NextFloat(0.5, 1.5)); section.SetSingleEntry("BurnOutPercentage", ThreadSafeRandom.NextFloat(0.1, 0.3)); section.SetSingleEntry("MaxPitchAngle", ThreadSafeRandom.NextFloat(25, 55)); ini = CoalescedHandler.GetIniFile("BioWeapon.ini"); section = ini.GetOrAddSection("SFXGameContent_Inventory.SFXHeavyWeapon_VehicleMissileLauncher"); section.SetSingleEntry("Damage", ThreadSafeRandom.NextFloat(200, 500)); section.SetSingleEntry("RateOfFire", ThreadSafeRandom.NextFloat(100, 300)); return(true); }
/// <summary> /// Randomizes a tint. /// </summary> /// <param name="tint">A LinearColor struct (floatproperty values)</param> /// <param name="randomizeAlpha"></param> public static void RandomizeTint(StructProperty tint, bool randomizeAlpha, bool randomizeZeroValues = true) { var a = tint.GetProp <FloatProperty>("A"); var r = tint.GetProp <FloatProperty>("R"); var g = tint.GetProp <FloatProperty>("G"); var b = tint.GetProp <FloatProperty>("B"); float totalTintValue = r + g + b; if (!randomizeZeroValues && totalTintValue == 0) { return; // Don't randomize } //Randomizing hte pick order will ensure we get a random more-dominant first color (but only sometimes). //e.g. if e went in R G B order red would always have a chance at a higher value than the last picked item List <FloatProperty> randomOrderChooser = new List <FloatProperty>(); randomOrderChooser.Add(r); randomOrderChooser.Add(g); randomOrderChooser.Add(b); randomOrderChooser.Shuffle(); randomOrderChooser[0].Value = ThreadSafeRandom.NextFloat(0, totalTintValue); totalTintValue -= randomOrderChooser[0].Value; randomOrderChooser[1].Value = ThreadSafeRandom.NextFloat(0, totalTintValue); totalTintValue -= randomOrderChooser[1].Value; randomOrderChooser[2].Value = totalTintValue; if (randomizeAlpha) { a.Value = ThreadSafeRandom.NextFloat(0, 1); } }
public static void RandomizeTint(CFVector4 linearColor, bool randomizeAlpha) { //Randomizing hte pick order will ensure we get a random more-dominant first color (but only sometimes). //e.g. if e went in R G B order red would always have a chance at a higher value than the last picked item List <float> randomOrderChooser = new List <float>(3); randomOrderChooser.Add(linearColor.W); randomOrderChooser.Add(linearColor.X); randomOrderChooser.Add(linearColor.Y); float totalTintValue = randomOrderChooser.Sum(); if (totalTintValue > 0) { randomOrderChooser.Shuffle(); randomOrderChooser[0] = ThreadSafeRandom.NextFloat(0, totalTintValue); totalTintValue -= randomOrderChooser[0]; randomOrderChooser[1] = ThreadSafeRandom.NextFloat(0, totalTintValue); totalTintValue -= randomOrderChooser[1]; randomOrderChooser[2] = totalTintValue; linearColor.W = randomOrderChooser.PullFirstItem(); linearColor.X = randomOrderChooser.PullFirstItem(); linearColor.Y = randomOrderChooser.PullFirstItem(); if (randomizeAlpha) { linearColor.Z = ThreadSafeRandom.NextFloat(0, 1); } } }
public static bool RandomizeExport(ExportEntry export, RandomizationOption option) { if (!CanRandomize(export)) { return(false); } var properties = export.GetProperties(); var lightColor = properties.GetProp <StructProperty>("LightColor"); if (lightColor != null) { lightColor.GetProp <ByteProperty>("R").Value = (byte)ThreadSafeRandom.Next(256); lightColor.GetProp <ByteProperty>("G").Value = (byte)ThreadSafeRandom.Next(256); lightColor.GetProp <ByteProperty>("B").Value = (byte)ThreadSafeRandom.Next(256); var density = properties.GetProp <FloatProperty>("Density"); if (density != null) { var thicknessRandomizer = ThreadSafeRandom.NextFloat(-density * .03, density * 1.15); density.Value = density + thicknessRandomizer; } //Debug.WriteLine($"Updating fog {export.InstancedFullPath} in {export.FileRef.FilePath}"); export.WriteProperties(properties); return(true); } return(false); }
private static int AddNewRandomizedMovementSpeed(ExportEntry bio_appr_character) { ImportEntry sfxMovementData = bio_appr_character.FileRef.FindImport("SFXGame.SFXMovementData"); if (sfxMovementData == null) { // Import needs added // ME2 SPECIFIC! sfxMovementData = EntryImporter.GetOrAddCrossImportOrPackageFromGlobalFile("SFXMovementData", MEPackageHandler.OpenMEPackage(MERFileSystem.GetPackageFile("SFXGame.pcc")), bio_appr_character.FileRef) as ImportEntry; } PropertyCollection props = new PropertyCollection(); props.Add(new FloatProperty(ThreadSafeRandom.NextFloat(70, 210) + (ThreadSafeRandom.Next(10) == 0 ? 100 : 0), "WalkSpeed")); props.Add(new FloatProperty(ThreadSafeRandom.NextFloat(200, 700) + (ThreadSafeRandom.Next(10) == 0 ? 100 : 0), "GroundSpeed")); props.Add(new FloatProperty(ThreadSafeRandom.NextFloat(50, 900) + (ThreadSafeRandom.Next(10) == 0 ? 100 : 0), "TurnSpeed")); props.Add(new FloatProperty(ThreadSafeRandom.NextFloat(100, 320) + (ThreadSafeRandom.Next(10) == 0 ? 100 : 0), "CombatWalkSpeed")); props.Add(new FloatProperty(ThreadSafeRandom.NextFloat(10, 470) + (ThreadSafeRandom.Next(10) == 0 ? 100 : 0), "CombatGroundSpeed")); props.Add(new FloatProperty(ThreadSafeRandom.NextFloat(100, 380) + (ThreadSafeRandom.Next(10) == 0 ? 100 : 0), "CoverGroundSpeed")); props.Add(new FloatProperty(ThreadSafeRandom.NextFloat(60, 180) + (ThreadSafeRandom.Next(10) == 0 ? 100 : 0), "CoverCrouchGroundSpeed")); props.Add(new FloatProperty(ThreadSafeRandom.NextFloat(300, 900) + (ThreadSafeRandom.Next(10) == 0 ? 100 : 0), "StormSpeed")); props.Add(new FloatProperty(ThreadSafeRandom.NextFloat(25, 75) + (ThreadSafeRandom.Next(10) == 0 ? 20 : 0), "StormTurnSpeed")); props.Add(new FloatProperty(ThreadSafeRandom.NextFloat(250, 1250) + (ThreadSafeRandom.Next(10) == 0 ? 100 : 0), "AccelRate")); var export = new ExportEntry(bio_appr_character.FileRef, null, new NameReference("ME2RMovementData", ThreadSafeRandom.Next(200000)), properties: props) { Class = sfxMovementData, idxLink = bio_appr_character.FileRef.Exports.First(x => x.ClassName == "Package").UIndex, }; bio_appr_character.FileRef.AddExport(export); return(export.UIndex); }
private static string GenerateRandomRangeStruct(float min1, float max1, float min2, float max2) { var x = ThreadSafeRandom.NextFloat(min1, max1); var y = ThreadSafeRandom.NextFloat(min2, max2); return($"(X={x},Y={y})"); }
public static bool RandomizeExport(ExportEntry export, RandomizationOption option) { if (!CanRandomize(export)) { return(false); } var location = Location.GetLocation(export); if (location != null) { var locS = location; if (ThreadSafeRandom.Next(10) == 0) { locS.X = ThreadSafeRandom.NextFloat(-100000, 100000); locS.Y = ThreadSafeRandom.NextFloat(-100000, 100000); locS.Z = ThreadSafeRandom.NextFloat(-100000, 100000); } else { // Fuzz it locS.X *= ThreadSafeRandom.NextFloat(.25, 1.75); locS.Y *= ThreadSafeRandom.NextFloat(.25, 1.75); locS.Z *= ThreadSafeRandom.NextFloat(.25, 1.75); } Location.SetLocation(export, locS); return(true); } return(false); }
private static string GenerateRandomVectorStruct(float min1, float max1, float min2, float max2, float min3, float max3) { var x = ThreadSafeRandom.NextFloat(min1, max1); var y = ThreadSafeRandom.NextFloat(min2, max2); var z = ThreadSafeRandom.NextFloat(min3, max3); return($"(X={x},Y={y},Z={z})"); }
public virtual void RandomValues(float start = 0, float end = 1) { for (var i = 0; i < this.valueMap.Count; ++i) { var n = this.valueMap[i].Item1; this.valueMap[i] = new Tuple <X, float>(n, math.lerp(start, end, ThreadSafeRandom.NextFloat())); } }
public override Vector <float> Generate(Vector <float> x) { var p = new Vector <float>(2); p[0] = ThreadSafeRandom.NextFloat(); p[1] = ThreadSafeRandom.NextFloat(); return(p); }
public Vector <float> Generate(Vector <float> input) { this.currentx = new float2(ThreadSafeRandom.NextFloat(), ThreadSafeRandom.NextFloat()); //make random value to cover the range of min //see for detail: https://en.wikipedia.org/wiki/Himmelblau%27s_function this.currentx = (this.currentx - 0.5f) * 2 * 10; return(input); }
/// <summary> /// Randomizes the RGBA values starting at the listed offset. Returns the data /// </summary> /// <param name="data"></param> /// <param name="p1"></param> /// <param name="p2"></param> public static Vector4 RandomizeRGBA(byte[] data, int startingOffset, bool randomizeAlpha) { float totalColor = 0; totalColor += BitConverter.ToSingle(data, startingOffset); totalColor += BitConverter.ToSingle(data, startingOffset + 4); totalColor += BitConverter.ToSingle(data, startingOffset + 8); // Randomize the color orders to help ensure we get a more random distribution List <int> randomOrderChooser = new List <int>(); randomOrderChooser.Add(startingOffset); randomOrderChooser.Add(startingOffset + 4); randomOrderChooser.Add(startingOffset + 8); randomOrderChooser.Shuffle(); byte[] colord = new byte[16]; for (int i = 0; i < randomOrderChooser.Count; i++) { float amt; if (i == randomOrderChooser.Count - 1) { amt = totalColor; } else { amt = ThreadSafeRandom.NextFloat(0, totalColor); } data.OverwriteRange(randomOrderChooser[i], BitConverter.GetBytes(amt)); colord.OverwriteRange(randomOrderChooser[i] - startingOffset, BitConverter.GetBytes(amt)); totalColor -= amt; } if (randomizeAlpha) { var amt = ThreadSafeRandom.NextFloat(0, 1); data.OverwriteRange(startingOffset + 12, BitConverter.GetBytes(amt)); colord.OverwriteRange(12, BitConverter.GetBytes(amt)); } else { colord.OverwriteRange(12, data.Slice(startingOffset + 12, 4)); } return(new Vector4() { W = BitConverter.ToSingle(colord, 0), X = BitConverter.ToSingle(colord, 4), Y = BitConverter.ToSingle(colord, 8), Z = BitConverter.ToSingle(colord, 12), }); }
public static bool RandomizeExport(ExportEntry material, RandomizationOption option) { if (!CanRandomize(material)) { return(false); } var props = material.GetProperties(); { var vectors = props.GetProp <ArrayProperty <StructProperty> >("VectorParameterValues"); if (vectors != null) { foreach (var vector in vectors) { var pc = vector.GetProp <StructProperty>("ParameterValue"); if (pc != null) { RStructs.RandomizeTint(pc, false); } } } var scalars = props.GetProp <ArrayProperty <StructProperty> >("ScalarParameterValues"); if (scalars != null) { for (int i = 0; i < scalars.Count; i++) { var scalar = scalars[i]; var parameter = scalar.GetProp <NameProperty>("ParameterName"); var currentValue = scalar.GetProp <FloatProperty>("ParameterValue"); if (currentValue > 1) { scalar.GetProp <FloatProperty>("ParameterValue").Value = ThreadSafeRandom.NextFloat(0, currentValue * 1.3); } else { //Debug.WriteLine("Randomizing parameter " + scalar.GetProp<NameProperty>("ParameterName")); scalar.GetProp <FloatProperty>("ParameterValue").Value = ThreadSafeRandom.NextFloat(0, 1); } } //foreach (var scalar in vectors) //{ // var paramValue = vector.GetProp<StructProperty>("ParameterValue"); // RandomizeTint( paramValue, false); //} } } material.WriteProperties(props); return(true); }
public static void RandFloat(PropertyCollection props, string propname, float min, float max, bool createIfMissing) { var prop = props.GetProp <FloatProperty>(propname); if (prop == null && createIfMissing) { prop = new FloatProperty(0, propname); props.Add(prop); } if (prop != null) { prop.Value = ThreadSafeRandom.NextFloat(min, max); } }
private static void SlightlyRandomizeMovementData(ExportEntry export) { var props = export.GetProperties(); foreach (var prop in props) { if (prop is FloatProperty fp) { // We try to make sure it weights more towards faster not slower fp.Value = ThreadSafeRandom.NextFloat(fp.Value - (fp * .35), fp.Value + (fp * .75)); } } export.WriteProperties(props); }
public static void RandomizeSubMatInst(ExportEntry childMat, Dictionary <string, CFVector4> vectorValues, Dictionary <string, float> scalarValues) { // VECTOR PARAMETERS //Debug.WriteLine($"Randomizing matinst {childMat.InstancedFullPath}"); var vectorParameterValues = VectorParameter.GetVectorParameters(childMat); if (vectorParameterValues != null) { foreach (var vpv in vectorParameterValues) { CFVector4 color; if (!vectorValues.TryGetValue(vpv.ParameterName, out color)) { color = vpv.ParameterValue; RStructs.RandomizeTint(color, false); vectorValues[vpv.ParameterName] = color; } else { vpv.ParameterValue = color; } } //Debug.WriteLine(childMat.InstancedFullPath); VectorParameter.WriteVectorParameters(childMat, vectorParameterValues); } // SCALAR PARAMETERS var scalarParameterValues = ScalarParameter.GetScalarParameters(childMat); if (scalarParameterValues != null) { foreach (var vpv in scalarParameterValues) { if (!scalarValues.TryGetValue(vpv.ParameterName, out float scalarVal)) { // Write new vpv.ParameterValue *= ThreadSafeRandom.NextFloat(0.75, 1.25); scalarValues[vpv.ParameterName] = vpv.ParameterValue; } else { // Write existing vpv.ParameterValue = scalarVal; } } //Debug.WriteLine(childMat.InstancedFullPath); ScalarParameter.WriteScalarParameters(childMat, scalarParameterValues); } }
private static void ForwardTest([NotNull] INeuralNetwork n1, [NotNull] INeuralNetwork n2) { float[,] x = new float[257, n1.InputInfo.Size]; for (int i = 0; i < 257; i++) { for (int j = 0; j < n1.InputInfo.Size; j++) { x[i, j] = ThreadSafeRandom.NextFloat(); } } float[,] y1 = n1.Forward(x), y2 = n2.Forward(x); Assert.IsTrue(y1.ContentEquals(y2)); }
public static bool RandomizeExport(ExportEntry export, RandomizationOption option) { if (!CanRandomize(export)) { return(false); } var props = export.GetProperties(); if (export.ObjectName.Name.Contains("SFXPower")) { props.AddOrReplaceProp(new BoolProperty(true, "bCustomDroneColor")); props.AddOrReplaceProp(new BoolProperty(true, "bCustomDroneColor2")); } else { //sfxpawn props.AddOrReplaceProp(new BoolProperty(true, "bCustomColor")); props.AddOrReplaceProp(new BoolProperty(true, "bCustomColor2")); } PropertyCollection randColors = new PropertyCollection(); randColors.AddOrReplaceProp(new FloatProperty(ThreadSafeRandom.NextFloat(0, 60), "X")); randColors.AddOrReplaceProp(new FloatProperty(ThreadSafeRandom.NextFloat(0, 60), "Y")); randColors.AddOrReplaceProp(new FloatProperty(ThreadSafeRandom.NextFloat(0, 60), "Z")); PropertyCollection randColors2 = new PropertyCollection(); randColors2.AddOrReplaceProp(new FloatProperty(ThreadSafeRandom.NextFloat(0, 128), "X")); randColors2.AddOrReplaceProp(new FloatProperty(ThreadSafeRandom.NextFloat(0, 128), "Y")); randColors2.AddOrReplaceProp(new FloatProperty(ThreadSafeRandom.NextFloat(0, 128), "Z")); if (export.ObjectName.Name.Contains("SFXPower")) { props.AddOrReplaceProp(new StructProperty("Vector", randColors, "CustomDroneColor", true)); props.AddOrReplaceProp(new StructProperty("Vector", randColors2, "CustomDroneColor2", true)); } else { //sfxpawn props.AddOrReplaceProp(new StructProperty("Vector", randColors, "DroneColor", true)); props.AddOrReplaceProp(new StructProperty("Vector", randColors2, "DroneColor2", true)); } export.WriteProperties(props); return(true); }
private static void InstallPlatformAutomation(ExportEntry seqActivated, ExportEntry delayToClone, ExportEntry finishSeq, int platIdx) { var seq = seqActivated.GetProperty <ObjectProperty>("ParentSequence").ResolveToEntry(seqActivated.FileRef) as ExportEntry; // Clone a delay object, set timer on it var delay = delayToClone.Clone(); seqActivated.FileRef.AddExport(delay); KismetHelper.AddObjectToSequence(delay, seq, true); delay.WriteProperty(new FloatProperty(ThreadSafeRandom.NextFloat(3f, 10f - platIdx), "Duration")); // Point start to delay KismetHelper.CreateOutputLink(seqActivated, "Out", delay); // Point delay to finish KismetHelper.CreateOutputLink(delay, "Finished", finishSeq); }
public static bool RandomizePawnSize(ExportEntry export, RandomizationOption option) { if (!CanRandomize(export)) { return(false); } MERLog.Information($"[{Path.GetFileNameWithoutExtension(export.FileRef.FilePath)}] Randomizing pawn size for " + export.UIndex + ": " + export.InstancedFullPath); var existingSize = export.GetProperty <StructProperty>("DrawScale3D"); CFVector3 d3d = existingSize == null ? new CFVector3() { X = 1, Y = 1, Z = 1 } : CFVector3.FromStructProperty(existingSize, "X", "Y", "Z"); d3d.X *= ThreadSafeRandom.NextFloat(1 - option.SliderValue, 1 + option.SliderValue); d3d.Y *= ThreadSafeRandom.NextFloat(1 - option.SliderValue, 1 + option.SliderValue); d3d.Z *= ThreadSafeRandom.NextFloat(1 - option.SliderValue, 1 + option.SliderValue); export.WriteProperty(d3d.ToStructProperty("X", "Y", "Z", "DrawScale3D", true)); return(true); }
private static void TestR(ExportEntry export) { if (/*export.UIndex == 36224 && */ export.ClassName == "Material") { var obj = ObjectBinary.From <Material>(export); foreach (var v in obj.SM3MaterialResource.UniformPixelVectorExpressions) { if (v is MaterialUniformExpressionVectorParameter vp) { vp.DefaultA = ThreadSafeRandom.NextFloat(0, 1); vp.DefaultR = ThreadSafeRandom.NextFloat(); vp.DefaultG = ThreadSafeRandom.NextFloat(); vp.DefaultB = ThreadSafeRandom.NextFloat(); } else if (v is MaterialUniformExpressionAppendVector av) { } } foreach (var v in obj.SM3MaterialResource.UniformPixelVectorExpressions) { } export.WriteBinary(obj); } if (export.UIndex == 37354 || export.UIndex == 37355) { var vParms = VectorParameter.GetVectorParameters(export); if (vParms != null) { foreach (var vParm in vParms) { CFVector4 nv = new CFVector4(); nv.W = ThreadSafeRandom.NextFloat(2000); nv.X = ThreadSafeRandom.NextFloat(2000); nv.Y = ThreadSafeRandom.NextFloat(2000); nv.Z = ThreadSafeRandom.NextFloat(2000); vParm.ParameterValue = nv; } } } }
protected Intension GenerateNewIntension(Perception perception, Habits habits, MentalState mental, PhysicalState ps, float t) { Intension intension = default; var H = mental.hunger; var L = mental.libido; if (this.r < math.max(H, L)) { if (H == L) { if (ThreadSafeRandom.NextFloat() > 0.5f) { intension = new EatIntension(); } else { intension = new MateIntension(); } } else { if (H > L) { intension = new EatIntension(); } else { intension = new MateIntension(); } } } else { //perception.temperatureSensor; //perception.visionSensor; //generate wonder or leave intension = new WanderIntension(); } return(intension); }
// Tries to process a random batch through the network (this method should just not crash) private static void ValidateGraph([NotNull] INeuralNetwork network) { float[,] x = new float[200, network.InputInfo.Size], y = new float[200, network.OutputInfo.Size]; for (int i = 0; i < 200; i++) { for (int j = 0; j < x.GetLength(1); j++) { x[i, j] = ThreadSafeRandom.NextFloat(); } y[i, ThreadSafeRandom.NextInt(max: y.GetLength(1))] = 1; } _ = network.Forward(x); SamplesBatch batch = new SamplesBatch(x, y); ComputationGraphNetwork graph = network.To <INeuralNetwork, ComputationGraphNetwork>(); graph.Backpropagate(batch, 0.5f, WeightsUpdaters.AdaDelta(TrainingAlgorithms.AdaDelta(), graph)); _ = network.ExtractDeepFeatures(x); }
public static T RandomElementByWeight <T>(this IEnumerable <T> sequence, Func <T, float> weightSelector) { float totalWeight = sequence.Sum(weightSelector); // The weight we are after... float itemWeightIndex = ThreadSafeRandom.NextFloat() * totalWeight; float currentWeightIndex = 0; foreach (var item in from weightedItem in sequence select new { Value = weightedItem, Weight = weightSelector(weightedItem) }) { currentWeightIndex += item.Weight; // If we've hit or passed the weight we are after for this item then it's the one we want.... if (currentWeightIndex >= itemWeightIndex) { return(item.Value); } } return(default(T)); }
public static void RandVector(PropertyCollection props, string propname, float min, float max, bool createIfMissing) { var prop = props.GetProp <StructProperty>(propname); if (prop == null && createIfMissing) { var propCollection = new PropertyCollection(); propCollection.Add(new FloatProperty(0, "X")); propCollection.Add(new FloatProperty(0, "Y")); propCollection.Add(new FloatProperty(0, "Z")); prop = new StructProperty("Vector", propCollection, propname, true); props.Add(prop); } if (prop != null) { prop.GetProp <FloatProperty>("X").Value = ThreadSafeRandom.NextFloat(min, max); prop.GetProp <FloatProperty>("Y").Value = ThreadSafeRandom.NextFloat(min, max); prop.GetProp <FloatProperty>("Z").Value = ThreadSafeRandom.NextFloat(min, max); } }
private static void randomizeBaseHead(StructProperty basehead, ExportEntry frontEnd, Dictionary <string, StructProperty> sliders) { var bhSettings = basehead.GetProp <ArrayProperty <StructProperty> >("m_fBaseHeadSettings"); foreach (var baseSlider in bhSettings) { var sliderName = baseSlider.GetProp <StrProperty>("m_sSliderName"); //is slider stepped? if (sliderName.Value == "Scar") { baseSlider.GetProp <FloatProperty>("m_fValue").Value = 1; continue; } var slider = sliders[sliderName.Value]; var notched = slider.GetProp <BoolProperty>("m_bNotched"); var val = baseSlider.GetProp <FloatProperty>("m_fValue"); if (notched) { //it's indexed var maxIndex = slider.GetProp <IntProperty>("m_iSteps"); val.Value = ThreadSafeRandom.Next(maxIndex); } else { //it's variable, we have to look up the m_fRange in the SliderMorph. var sliderDatas = slider.GetProp <ArrayProperty <ObjectProperty> >("m_aoSliderData"); if (sliderDatas.Count == 1) { var slDataExport = frontEnd.FileRef.GetUExport(sliderDatas[0].Value); var range = slDataExport.GetProperty <FloatProperty>("m_fRange"); val.Value = ThreadSafeRandom.NextFloat(0, range * 100); } else { // This is just a guess val.Value = ThreadSafeRandom.NextFloat(0, 1f); } } } }
public static bool RandomizePlayerMovementSpeed(RandomizationOption option) { var femaleFile = MERFileSystem.GetPackageFile("BIOG_Female_Player_C.pcc"); var maleFile = MERFileSystem.GetPackageFile("BIOG_Male_Player_C.pcc"); var femalepackage = MEPackageHandler.OpenMEPackage(femaleFile); var malepackage = MEPackageHandler.OpenMEPackage(maleFile); SlightlyRandomizeMovementData(femalepackage.GetUExport(2917)); SlightlyRandomizeMovementData(malepackage.GetUExport(2672)); MERFileSystem.SavePackage(femalepackage); MERFileSystem.SavePackage(malepackage); var biogame = CoalescedHandler.GetIniFile("BIOGame.ini"); var sfxgame = biogame.GetOrAddSection("SFXGame.SFXGame"); sfxgame.SetSingleEntry("StormStamina", ThreadSafeRandom.NextFloat(1.5f, 12)); sfxgame.SetSingleEntry("StormRegen", ThreadSafeRandom.NextFloat(0.3f, 1.5f)); sfxgame.SetSingleEntry("StormStaminaNonCombat", ThreadSafeRandom.NextFloat(1.5f, 8)); sfxgame.SetSingleEntry("StormRegenNonCombat", ThreadSafeRandom.NextFloat(0.1f, 0.8f)); return(true); }