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