public static T PickOne <T>(this IEnumerable <T> col)
{
return(col.ToArray()[Random.Range(0, col.Count())]);
}
/// <summary>Returns a random element from the array.</summary>
public static T RandomElement <T>(this T[] array) where T : class
{
int index = Random.Range(0, array.Length);
return(array[index]);
}
public static void Crossover(this CrossoverFunction crossoverFunction, NeuralNetwork child,
GenerationEvaluation evaluation, SelectionFunction selectionFunction, float fitnessPower)
{
var(b, w) = evaluation.pool.Select(selectionFunction, fitnessPower);
var(better, worse) = (b.Genes, w.Genes);
var genes = child.genes;
var count = genes.Length;
var halfCount = genes.Length / 2;
switch (crossoverFunction)
{
case CrossoverFunction.HalfWorstBest:
for (var i = 0; i < halfCount; i++)
{
child.genes[i] = better[i];
}
for (var i = halfCount; i < count; i++)
{
child.genes[i] = worse[i];
}
break;
case CrossoverFunction.HalfBestWorse:
for (var i = 0; i < halfCount; i++)
{
child.genes[i] = worse[i];
}
for (var i = halfCount; i < count; i++)
{
child.genes[i] = better[i];
}
break;
case CrossoverFunction.HalfRandomShift:
var shift = Random.Range(0, count - 1);
var overlaps = shift + halfCount > count - 1;
for (var i = 0; i < count; i++)
{
child.genes[i] = (!overlaps && i > shift && i < shift + halfCount || overlaps && !(i > shift && i < shift + halfCount) ? better : worse)[i];
}
break;
case CrossoverFunction.Step:
for (var i = 0; i < count; i++)
{
genes[i] = (i % 2 == 0 ? better : worse)[i];
}
break;
case CrossoverFunction.StepRandom:
for (var i = 0; i < count; i++)
{
genes[i] = (Random.value > .5f ? better : worse)[i];
}
break;
case CrossoverFunction.FractionRandom: {
for (var i = 0; i < count; i++)
{
var fraction = Random.value;
genes[i] = better[i] * fraction + worse[i] * (1f - fraction);
}
break;
}
case CrossoverFunction.FractionByFitness: {
var fraction = b.Fitness / (b.Fitness + w.Fitness);
for (var i = 0; i < count; i++)
{
genes[i] = better[i] * fraction + worse[i] * (1f - fraction);
}
break;
}
case CrossoverFunction.Average:
default:
for (var i = 0; i < count; i++)
{
genes[i] = (better[i] + worse[i]) * .5f;
}
break;
}
}
public TerrainProfile SelectProfile()
{
return(Profiles[Random.Range(0, Profiles.Length - 1)]);
}
internal static void ApplyPanicStatus(AbstractActor __instance, PanicStatus panicStatus, bool worsened)
{
var actor = __instance;
int Uid() => Random.Range(1, int.MaxValue);
var effectManager = UnityGameInstance.BattleTechGame.Combat.EffectManager;
// remove all PanicSystem effects first
ClearPanicEffects(actor, effectManager);
// re-apply effects
var messageNature = worsened ? FloatieMessage.MessageNature.Debuff : FloatieMessage.MessageNature.Buff;
var verb = worsened ? modSettings.PanicWorsenedString : modSettings.PanicImprovedString;
// account for the space, append it when the verb is defined
if (!string.IsNullOrEmpty(verb))
{
verb += " ";
}
var message = actor.Combat.MessageCenter;
var dummyWeapon = new WeaponHitInfo();
switch (panicStatus)
{
case PanicStatus.Unsettled:
LogReport($"{actor.DisplayName} {verb}{modSettings.PanicStates[1]}");
message.PublishMessage(new AddSequenceToStackMessage(
new ShowActorInfoSequence(actor,
$"{verb}{modSettings.PanicStates[1]}",
messageNature,
false)));
effectManager.CreateEffect(StatusEffect.UnsettledToHit, "PanicSystemToHit", Uid(), actor, actor, dummyWeapon, 0);
break;
case PanicStatus.Stressed:
LogReport($"{actor.DisplayName} {verb}{modSettings.PanicStates[2]}");
message.PublishMessage(new AddSequenceToStackMessage(
new ShowActorInfoSequence(actor,
$"{verb}{modSettings.PanicStates[2]}",
messageNature,
false)));
effectManager.CreateEffect(StatusEffect.StressedToHit, "PanicSystemToHit", Uid(), actor, actor, dummyWeapon, 0);
effectManager.CreateEffect(StatusEffect.StressedToBeHit, "PanicSystemToBeHit", Uid(), actor, actor, dummyWeapon, 0);
break;
case PanicStatus.Panicked:
LogReport($"{actor.DisplayName} {verb}{modSettings.PanicStates[3]}");
message.PublishMessage(new AddSequenceToStackMessage(
new ShowActorInfoSequence(actor,
$"{verb}{modSettings.PanicStates[3]}",
messageNature,
false)));
effectManager.CreateEffect(StatusEffect.PanickedToHit, "PanicSystemToHit", Uid(), actor, actor, dummyWeapon, 0);
effectManager.CreateEffect(StatusEffect.PanickedToBeHit, "PanicSystemToBeHit", Uid(), actor, actor, dummyWeapon, 0);
break;
default:
LogReport($"{actor.DisplayName} {verb}{modSettings.PanicStates[0]}");
message.PublishMessage(new AddSequenceToStackMessage(
new ShowActorInfoSequence(actor,
$"{verb}{modSettings.PanicStates[0]}",
messageNature,
false)));
break;
}
}
public static int RangeBetweenInclusive(int v1, int v2) => Random.Range(Math.Min(v1, v2), Math.Max(v1, v2) - 1);
// might be re-used for worlds/players
internal static async Task ProcessTextFile(string filePath)
{
var database = FavCatMod.Database;
if (database == null)
{
MelonLogger.Msg("Database does not exist, can't import");
return;
}
var fileName = Path.GetFileName(filePath);
MelonLogger.Msg($"Started avatar import process for file {fileName}");
var toAddUsers = new List <string>();
var toAddWorlds = new List <string>();
{ // file access block
using var file = new FileStream(filePath, FileMode.Open, FileAccess.Read);
using var reader = new StreamReader(file);
string line;
while ((line = await reader.ReadLineAsync().ConfigureAwait(false)) != null)
{
foreach (Match match in ourUserIdRegex.Matches(line))
{
toAddUsers.Add(match.Value);
}
foreach (Match match in ourWorldIdRegex.Matches(line))
{
toAddWorlds.Add(match.Value);
}
}
}
for (var i = 0; i < toAddUsers.Count; i++)
{
ImportStatusInner = $"Fetching user {i + 1}/{toAddUsers.Count}";
var userId = toAddUsers[i];
if (database.myStoredPlayers.FindById(userId) == null)
{
await TaskUtilities.YieldToMainThread();
new APIUser {
id = userId
}.Fetch(); // it will get intercepted and stored
await Task.Delay(TimeSpan.FromSeconds(5f + Random.Range(0f, 5f))).ConfigureAwait(false);
}
}
for (var i = 0; i < toAddWorlds.Count; i++)
{
ImportStatusInner = $"Fetching world {i + 1}/{toAddWorlds.Count}";
var worldId = toAddWorlds[i];
if (database.myStoredWorlds.FindById(worldId) == null)
{
await TaskUtilities.YieldToMainThread();
new ApiWorld {
id = worldId
}.Fetch(); // it will get intercepted and stored
await Task.Delay(TimeSpan.FromSeconds(5f + Random.Range(0f, 5f))).ConfigureAwait(false);
}
}
ImportStatusInner = "Creating favorites list";
await TaskUtilities.YieldToMainThread();
var categoryName = $"Imported from {fileName}";
void DoAddCategories <T>(List <string> ids, DatabaseFavoriteHandler <T> favs, ExtendedFavoritesModuleBase <T>?module, ILiteCollection <T> rawStore) where T : class, INamedStoredObject
public ULongProtected(ulong value = 0)
{
_offset = (byte)Random.Range(0, 255);
_value = value ^ _offset;
}
/// <summary>
/// Select random element of array.
/// </summary>
public static T GetRandom <T>(this T[] collection)
{
var rng = Random.Range(0, collection.Length);
return(collection[rng]);
}
private EnemyTypes GetRandomEnemyType()
{
var enemyValue = Random.Range(0, 2); // Its exclusive on max, ask unity...
return((EnemyTypes)enemyValue);
}
private static T?PickRandomOf <T>(IList <T> collection) where T : struct =>
collection.Count > 0
? collection[Random.Range(0, collection.Count)]
: (T?)null;
public Question[] GetQuestions(int amount)
{
_allQuestions.Sort((a, b) => Random.Range(0, 2) == 0 ? 1 : -1);
return(_allQuestions.GetRange(0, amount).ToArray());
}
public static void CreateStarPlanetsRework(GalaxyData galaxy, StarData star, GameDesc gameDesc, PlanetGeneratorSettings genSettings)
{
star.name = SystemsNames.systems[star.index];
Patch.Debug("System " + star.name + " - " + star.type + " - " + star.spectr, LogLevel.Debug,
Patch.DebugStarGen);
// Random Generators Inits
UnityRandom.InitState(star.seed);
var mainSeed = new Random(star.seed);
var annexSeed = new Random(mainSeed.Next());
// InnerCount for the System
var planetsToGenerate = new List <PlanetForGenerator>();
// settings from the config
PatchForStarSystemGeneration.StarSystemSetting currentSettings;
if (star.type == EStarType.BlackHole || star.type == EStarType.GiantStar ||
star.type == EStarType.NeutronStar || star.type == EStarType.WhiteDwarf)
{
currentSettings = Patch.GeneratorSpecialsSystemConfig[star.type];
}
else
{
currentSettings = Patch.GeneratorMainSystemConfig[star.spectr];
}
//Debugging configs
Patch.Debug("*************************** : \n" +
"ChanceMoonGasGiant : " + currentSettings.ChanceGasGiantMoon + "\n" +
"ChanceMoonTelluric : " + currentSettings.ChanceMoonTelluric + "\n" +
"ChancePlanetTelluric : " + currentSettings.ChanceTelluricPlanet + "\n" +
"ChancePlanetGasGiant : " + currentSettings.ChanceGasGiant + "\n" +
"MaxMoonTelluricNb : " + currentSettings.MaxMoonTelluricNb + "\n" +
"MaxMoonGasGiantNb : " + currentSettings.MaxMoonGasGiantNb + "\n" +
"MaxTelluricNb : " + currentSettings.MaxTelluricNb + "\n" +
"MaxGasGiantNb : " + currentSettings.MaxGasGiantNb + "\n" +
"ChanceJumpOrbitMoons : " + currentSettings.ChanceJumpOrbitMoons + "\n" +
"ChanceJumpOrbitPlanets : " + currentSettings.ChanceJumpOrbitPlanets + "\n" +
"*************************** ", LogLevel.Debug, Patch.DebugStarGenDeep);
Patch.Debug("Definition of Nb of planets In the system :", LogLevel.Debug, Patch.DebugStarGenDeep);
DefineNumberOfBodies(currentSettings, annexSeed, genSettings);
if (star.IsStartingStar())
{
// check if minimum number of planet is met
genSettings.nbOfTelluricPlanets = genSettings.nbOfTelluricPlanets < Patch.StartingSystemMinPlanetTelluricNb.Value ? Patch.StartingSystemMinPlanetTelluricNb.Value : genSettings.nbOfTelluricPlanets;
genSettings.nbOfMoonsTelluric = genSettings.nbOfMoonsTelluric < Patch.StartingSystemMinTelluricMoonNb.Value ? Patch.StartingSystemMinTelluricMoonNb.Value : genSettings.nbOfMoonsTelluric;
genSettings.nbOfGasGiantPlanets = genSettings.nbOfGasGiantPlanets < Patch.StartingSystemMinGasGiantNb.Value ? Patch.StartingSystemMinGasGiantNb.Value : genSettings.nbOfGasGiantPlanets;
genSettings.nbOfMoonsGasGiant = genSettings.nbOfMoonsGasGiant < Patch.StartingSystemMinGasGiantMoonNb.Value ? Patch.StartingSystemMinGasGiantMoonNb.Value : genSettings.nbOfMoonsGasGiant;
genSettings.nbOfMoons = genSettings.nbOfMoonsTelluric + genSettings.nbOfMoonsGasGiant;
genSettings.nbOfPlanets = genSettings.nbOfTelluricPlanets + genSettings.nbOfGasGiantPlanets;
genSettings.nbOfStellarBodies = genSettings.nbOfPlanets + genSettings.nbOfMoons;
}
star.planets = new PlanetData[genSettings.nbOfStellarBodies];
Patch.Debug("*************************** :", LogLevel.Debug, Patch.DebugStarGen);
Patch.Debug("\nSystem Presets : ", LogLevel.Debug, Patch.DebugStarGen);
var preset =
"nbOfPlanets : " + genSettings.nbOfPlanets + "\n" +
"nbOfTelluricPlanets : " + genSettings.nbOfTelluricPlanets + "\n" +
"nbOfGasGiantPlanets : " + genSettings.nbOfGasGiantPlanets + "\n" +
"nbOfMoons : " + genSettings.nbOfMoons + "\n" +
"nbOfMoonsTelluric : " + genSettings.nbOfMoonsTelluric + "\n" +
"nbOfMoonsGasGiant : " + genSettings.nbOfMoonsGasGiant + "\n\n";
Patch.Debug(preset, LogLevel.Debug, Patch.DebugStarGen);
PreGenerateAllBodies(star, planetsToGenerate, annexSeed, genSettings, currentSettings);
GenerateAllPlanets(galaxy, star, gameDesc, planetsToGenerate);
if (star.IsStartingStar())
{
Patch.Debug(star.name + " --recap-- : ", LogLevel.Debug, Patch.DebugStarGen);
var nbOfHabitablePlanets = 0;
foreach (var planet in star.planets)
{
if (planet.orbitAround != 0)
{
Patch.Debug("moon type : " + planet.type, LogLevel.Debug, Patch.DebugStarGen);
}
else
{
Patch.Debug("planet type : " + planet.type, LogLevel.Debug, Patch.DebugStarGen);
}
if (planet.type == EPlanetType.Ocean)
{
nbOfHabitablePlanets++;
}
}
if (nbOfHabitablePlanets == 0)
{
Patch.Debug("Nb of habitable == 0 --> Override one planet ", LogLevel.Debug, Patch.DebugStarGen);
var @override = true;
while (@override)
{
var indexStartingPlanet = UnityRandom.Range(0, star.planets.Length - 1);
if (star.planets[indexStartingPlanet].type != EPlanetType.Gas)
{
star.planets[indexStartingPlanet].ShouldBeHabitable();
galaxy.birthPlanetId = star.planets[indexStartingPlanet].id;
@override = false;
}
}
Patch.Debug(" galaxy.birthPlanetId --> " + galaxy.birthPlanetId, LogLevel.Debug, Patch.DebugStarGen);
}
}
// Apply themes
foreach (var planet in star.planets)
{
PlanetGen.SetPlanetTheme(planet, star, gameDesc, 0, 0, mainSeed.NextDouble(), mainSeed.NextDouble(), mainSeed.NextDouble(), mainSeed.NextDouble(), mainSeed.Next());
Patch.Debug("planet.algoId --> " + planet.algoId, LogLevel.Debug, Patch.DebugStarGen);
}
star.planetCount = star.planets.Length;
}
public static void PreGenerateAllBodies(StarData star, List <PlanetForGenerator> planetsToGenerate, Random annexSeed, PlanetGeneratorSettings genSettings, PatchForStarSystemGeneration.StarSystemSetting currentSettings)
{
//
//preparation of the planet creation :
Patch.Debug("Define the belts for whatever they are for :", LogLevel.Debug, Patch.DebugStarGenDeep);
//Define where the 2 asteroids belts are ( maybe not implemented )
var asterBelt1OrbitIndex = UnityRandom.Range(1, genSettings.nbOfPlanets - 1);
var asterBelt2OrbitIndex = UnityRandom.Range(asterBelt1OrbitIndex + 1, genSettings.nbOfPlanets);
Patch.Debug("asterBelt1OrbitIndex :" + asterBelt1OrbitIndex, LogLevel.Debug, Patch.DebugStarGenDeep);
Patch.Debug("asterBelt2OrbitIndex :" + asterBelt2OrbitIndex, LogLevel.Debug, Patch.DebugStarGenDeep);
//Attach the information to the star
star.asterBelt1OrbitIndex = asterBelt1OrbitIndex;
star.asterBelt2OrbitIndex = asterBelt2OrbitIndex;
star.asterBelt1Radius = Patch.OrbitRadiusPlanetArray[asterBelt1OrbitIndex];
star.asterBelt2Radius = Patch.OrbitRadiusPlanetArray[asterBelt2OrbitIndex];
int infoSeed;
int genSeed;
// planets pre-generation
var nbOfBodiesPreGenerated = 0;
var nbOfPlanetsPreGenerated = 0;
var planetsPreGeneratedNumber = 1;
var nbOfMoonsPreGenerated = 0;
var currentOrbitPlanetIndex = 1;
var previousOrbitPlanetIndex = 0;
int currentOrbitMoonIndex;
var beltGenerated = 0;
int jumpOrbitMargin;
for (var i = 0; i < genSettings.nbOfStellarBodies; i++)
{
infoSeed = annexSeed.Next();
genSeed = annexSeed.Next();
var planetInfoSeed = 0 + infoSeed;
var planetGenSeed = 0 + genSeed;
Patch.Debug("bodies generated !" + nbOfBodiesPreGenerated, LogLevel.Debug, Patch.DebugStarGenDeep);
Patch.Debug("genSettings.nbOfPlanets + genSettings.nbOfMoons !" + (genSettings.nbOfPlanets + genSettings.nbOfMoons), LogLevel.Debug, Patch.DebugStarGenDeep);
bool isGasGiant;
var orbitAround = 0;
if (asterBelt1OrbitIndex == currentOrbitPlanetIndex)
{
Patch.Debug("Jump Belt 1 Orbit :", LogLevel.Debug, Patch.DebugStarGenDeep);
currentOrbitPlanetIndex++;
nbOfBodiesPreGenerated++;
beltGenerated++;
}
if (asterBelt2OrbitIndex == currentOrbitPlanetIndex)
{
Patch.Debug("Jump Belt 2 Orbit :", LogLevel.Debug, Patch.DebugStarGenDeep);
currentOrbitPlanetIndex++;
nbOfBodiesPreGenerated++;
beltGenerated++;
}
Patch.Debug("nbOfPlanetsPreGenerated : " + nbOfPlanetsPreGenerated, LogLevel.Debug, Patch.DebugStarGenDeep);
Patch.Debug("nbOfPlanets : " + genSettings.nbOfPlanets, LogLevel.Debug, Patch.DebugStarGenDeep);
if (nbOfPlanetsPreGenerated < genSettings.nbOfPlanets)
{
//planets
// jumporbit planet
jumpOrbitMargin = Patch.OrbitRadiusArrayPlanetNb.Value - (genSettings.nbOfPlanets - nbOfPlanetsPreGenerated);
if (currentOrbitPlanetIndex < jumpOrbitMargin && jumpOrbitMargin < currentSettings.JumpOrbitPlanetMax)
{
if (annexSeed.NextDouble() < currentSettings.ChanceJumpOrbitPlanets)// can jump orbit up to JumpOrbitPlanetIndex
{
currentOrbitPlanetIndex = UnityRandom.Range(currentOrbitPlanetIndex, currentOrbitPlanetIndex + currentSettings.JumpOrbitPlanetMax);
}
}
previousOrbitPlanetIndex = currentOrbitPlanetIndex;
orbitAround = 0;
if (nbOfBodiesPreGenerated < genSettings.nbOfTelluricPlanets + beltGenerated)//telluric
{
isGasGiant = false;
}
else//gasgiant
{
isGasGiant = true;
}
planetsToGenerate.Add(new PlanetForGenerator(nbOfBodiesPreGenerated - beltGenerated, orbitAround, currentOrbitPlanetIndex, planetsPreGeneratedNumber, isGasGiant, planetInfoSeed, planetGenSeed, null));
Patch.Debug("planetsToGenerate --> \n" + planetsToGenerate[nbOfPlanetsPreGenerated].ToStringDebug(), LogLevel.Debug, Patch.DebugStarGen);
nbOfPlanetsPreGenerated++;
planetsPreGeneratedNumber++;
currentOrbitPlanetIndex++;
if (isGasGiant)
{
Patch.Debug("gas Giant generated !", LogLevel.Debug, Patch.DebugStarGen);
}
else
{
Patch.Debug("planet generated !", LogLevel.Debug, Patch.DebugStarGen);
}
}
else if (nbOfBodiesPreGenerated < genSettings.nbOfPlanets + genSettings.nbOfMoons + beltGenerated)
{
Patch.Debug("Moon in generation!", LogLevel.Debug, Patch.DebugStarGen);
isGasGiant = false;
if (genSettings.nbOfTelluricPlanets != 0 && nbOfBodiesPreGenerated < genSettings.nbOfPlanets + genSettings.nbOfMoonsTelluric + beltGenerated)
{
// telluric moon
orbitAround = UnityRandom.Range(1, genSettings.nbOfTelluricPlanets);
Patch.Debug("telluric moon! orbit around : " + orbitAround, LogLevel.Debug, Patch.DebugStarGenDeep);
}
else
{
if (genSettings.nbOfGasGiantPlanets != 0)
{
//gasgiant moon
orbitAround = UnityRandom.Range(genSettings.nbOfTelluricPlanets + 1, genSettings.nbOfTelluricPlanets + genSettings.nbOfGasGiantPlanets);
Patch.Debug("gas moon! orbit around : " + orbitAround, LogLevel.Debug, Patch.DebugStarGenDeep);
}
}
if (orbitAround <= 0)
{
Patch.Debug("Issue in moon generation : " + orbitAround, LogLevel.Debug, Patch.DebugStarGen);
}
jumpOrbitMargin = Patch.OrbitRadiusArrayMoonsNb.Value - (genSettings.nbOfMoons - nbOfMoonsPreGenerated);
Patch.Debug("orbitAround - 1 : " + (orbitAround - 1), LogLevel.Debug, Patch.DebugStarGenDeep);
Patch.Debug("planetsToGenerate.Count :" + planetsToGenerate.Count, LogLevel.Debug, Patch.DebugStarGenDeep);
Patch.Debug("planetsToGenerate[orbitAround - 1] :" + planetsToGenerate[orbitAround - 1].orbitIndex, LogLevel.Debug, Patch.DebugStarGenDeep);
int currentPlanetMoonsNb;
var currentPlanet = planetsToGenerate[orbitAround - 1];
Patch.Debug("planetsToGenerate nb :" + planetsToGenerate.Count, LogLevel.Debug, Patch.DebugStarGenDeep);
currentPlanetMoonsNb = currentPlanet.moons.Count;
Patch.Debug("currentPlanetMoonsNb :" + currentPlanetMoonsNb, LogLevel.Debug, Patch.DebugStarGenDeep);
if (currentPlanetMoonsNb != 0)
{
currentOrbitMoonIndex = currentPlanet.moons[currentPlanetMoonsNb - 1].orbitIndex + 1;
}
else
{
currentOrbitMoonIndex = 0;
}
Patch.Debug("currentOrbitMoonIndex : " + currentOrbitMoonIndex, LogLevel.Debug, Patch.DebugStarGenDeep);
if (currentOrbitMoonIndex < jumpOrbitMargin && jumpOrbitMargin < currentSettings.JumpOrbitMoonMax)
{
if (annexSeed.NextDouble() < currentSettings.ChanceJumpOrbitMoons)
{
// can jump orbit up to JumpOrbitPlanetIndex
var oldOrbitIndex = currentOrbitMoonIndex;
currentOrbitMoonIndex += UnityRandom.Range(currentOrbitMoonIndex, currentOrbitMoonIndex + currentSettings.JumpOrbitMoonMax);
}
}
currentPlanet.AddMoonInOrbit(nbOfBodiesPreGenerated, currentOrbitMoonIndex, planetGenSeed, planetInfoSeed);
nbOfMoonsPreGenerated++;
Patch.Debug("moonToGenerate --> +" + genSettings.nbOfMoons + " --> nbOfMoonsPreGenerated : " + nbOfMoonsPreGenerated, LogLevel.Debug, Patch.DebugStarGenDeep);
}
nbOfBodiesPreGenerated++;
}
}
protected override NodeState OnRunning(ExecutionContext context)
{
Output.Set(Random.Range(Min, Max));
return(NodeState.Success);
}
/// <summary>
/// Select random element of list
/// </summary>
public static T GetRandom <T>(this List <T> collection)
{
var rng = Random.Range(0, collection.Count);
return(collection[rng]);
}
public static T TakeRandom <T>(this IEnumerable <T> e) => e.ElementAt(Random.Range(0, e.Count()));
public static T GetRandomElement <T>(this List <T> list)
{
return(list.Count > 0 ? list[Random.Range(0, list.Count)] : default(T));
}
public void TestManyBoxes()
{
// Random boxes in a 3d space
var tree = new NativeBVHTree(64, Allocator.Persistent);
for (int i = 0; i < 20; i++)
{
var lower = new float3(Random.Range(0, 30), Random.Range(0, 30), Random.Range(0, 30));
var upper = lower + new float3(Random.Range(5, 20), Random.Range(5, 20), Random.Range(5, 20));
tree.InsertLeaf(BoxCollider.Create(lower, upper));
}
// Debug
NativeBVHDebugDrawer.LastTree = tree;
}
public static float GetSavingThrow(AbstractActor defender, AbstractActor attacker)
{
var pilot = defender.GetPilot();
var weapons = defender.Weapons;
var gutsAndTacticsSum = defender.SkillGuts * modSettings.GutsEjectionResistPerPoint +
defender.SkillTactics * modSettings.TacticsEjectionResistPerPoint;
float totalMultiplier = 0;
DrawHeader();
LogReport($"{$"Unit health {ActorHealth(defender):F2}%",-20} | {"",10} |");
if (defender is Mech defendingMech)
{
try
{
if (modSettings.QuirksEnabled &&
attacker is Mech mech &&
mech.MechDef.Chassis.ChassisTags.Contains("mech_quirk_distracting"))
{
totalMultiplier += modSettings.DistractingModifier;
LogReport($"{"Distracting mech",-20} | {modSettings.DistractingModifier,10:F3} | {totalMultiplier,10:F3}");
}
if (modSettings.HeatDamageFactor > 0)
{
totalMultiplier += modSettings.HeatDamageFactor * Mech_AddExternalHeat_Patch.heatDamage;
LogReport($"{$"Heat damage {Mech_AddExternalHeat_Patch.heatDamage}",-20} | {modSettings.HeatDamageFactor * Mech_AddExternalHeat_Patch.heatDamage,10:F3} | {totalMultiplier,10:F3}");
}
float percentPilot = PercentPilot(pilot);
if (percentPilot < 1)
{
totalMultiplier += modSettings.PilotHealthMaxModifier * percentPilot;
LogReport($"{"Pilot injuries",-20} | {modSettings.PilotHealthMaxModifier * percentPilot,10:F3} | {totalMultiplier,10:F3}");
}
if (defendingMech.IsUnsteady)
{
totalMultiplier += modSettings.UnsteadyModifier;
LogReport($"{"Unsteady",-20} | {modSettings.UnsteadyModifier,10} | {totalMultiplier,10:F3}");
}
if (defendingMech.IsFlaggedForKnockdown)
{
totalMultiplier += modSettings.UnsteadyModifier;
LogReport($"{"Knockdown",-20} | {modSettings.UnsteadyModifier,10} | {totalMultiplier,10:F3}");
}
if (modSettings.OverheatedModifier > 0 && defendingMech.OverheatLevel < defendingMech.CurrentHeat)
{
totalMultiplier += modSettings.OverheatedModifier;
LogReport($"{"Heat",-20} | {modSettings.OverheatedModifier,10:F3} | {totalMultiplier,10:F3}");
}
if (modSettings.ShutdownModifier > 0 && defendingMech.IsShutDown)
{
totalMultiplier += modSettings.ShutdownModifier;
LogReport($"{"Shutdown",-20} | {modSettings.ShutdownModifier,10:F3} | {totalMultiplier,10:F3}");
}
float percentHead = PercentHead(defendingMech);
if (percentHead < 1)
{
totalMultiplier += modSettings.HeadMaxModifier * (1 - percentHead);
LogReport($"{"Head",-20} | {modSettings.HeadMaxModifier * (1 - percentHead),10:F3} | {totalMultiplier,10:F3}");
}
float percentCenterTorso = PercentCenterTorso(defendingMech);
if (percentCenterTorso < 1)
{
totalMultiplier += modSettings.CenterTorsoMaxModifier * (1 - percentCenterTorso);
LogReport($"{"CT",-20} | {modSettings.CenterTorsoMaxModifier * (1 - percentCenterTorso),10:F3} | {totalMultiplier,10:F3}");
}
float percentLeftTorso = PercentLeftTorso(defendingMech);
if (percentLeftTorso < 1)
{
totalMultiplier += modSettings.SideTorsoMaxModifier * (1 - percentLeftTorso);
LogReport($"{"LT",-20} | {modSettings.SideTorsoMaxModifier * (1 - percentLeftTorso),10:F3} | {totalMultiplier,10:F3}");
}
float percentRightTorso = PercentRightTorso(defendingMech);
if (percentRightTorso < 1)
{
totalMultiplier += modSettings.SideTorsoMaxModifier * (1 - percentRightTorso);
LogReport($"{"RT",-20} | {modSettings.SideTorsoMaxModifier * (1 - percentRightTorso),10:F3} | {totalMultiplier,10:F3}");
}
float percentLeftLeg = PercentLeftLeg(defendingMech);
if (percentLeftLeg < 1)
{
totalMultiplier += modSettings.LeggedMaxModifier * (1 - percentLeftLeg);
LogReport($"{"LL",-20} | {modSettings.LeggedMaxModifier * (1 - percentLeftLeg),10:F3} | {totalMultiplier,10:F3}");
}
float percentRightLeg = PercentRightLeg(defendingMech);
if (percentRightLeg < 1)
{
totalMultiplier += modSettings.LeggedMaxModifier * (1 - percentRightLeg);
LogReport($"{"RL",-20} | {modSettings.LeggedMaxModifier * (1 - percentRightLeg),10:F3} | {totalMultiplier,10:F3}");
}
// alone
if (defendingMech.Combat.GetAllAlliesOf(defendingMech).TrueForAll(m => m.IsDead || m == defendingMech))
{
if (Random.Range(1, 5) == 0) // 20% chance of appearing
{
SaySpamFloatie(defendingMech, $"{modSettings.PanicSpamAloneString}");
}
totalMultiplier += modSettings.AloneModifier;
LogReport($"{"Alone",-20} | {modSettings.AloneModifier,10} | {totalMultiplier,10:F3}");
}
}
catch (Exception ex)
{
// BOMB
LogReport(ex);
return(-1f);
}
}
// weaponless
if (weapons.TrueForAll(w => w.DamageLevel != ComponentDamageLevel.Functional || !w.HasAmmo)) // only fully unusable
{
if (Random.Range(1, 5) == 1) // 20% chance of appearing
{
SaySpamFloatie(defender, $"{modSettings.PanicSpamNoWeaponsString}");
}
totalMultiplier += modSettings.WeaponlessModifier;
LogReport($"{"Weaponless",-20} | {modSettings.WeaponlessModifier,10} | {totalMultiplier,10:F3}");
}
// directly override the multiplier for vehicles
if (modSettings.VehiclesCanPanic &&
defender is Vehicle defendingVehicle)
{
float percentArmor = (defendingVehicle.SummaryArmorCurrent / defendingVehicle.SummaryArmorMax);
float percentStructure = (defendingVehicle.SummaryStructureCurrent / defendingVehicle.SummaryStructureMax);
float percentCur = percentStructure;
if (percentStructure > percentArmor)
{
percentCur += percentArmor;
percentCur /= 2;
}
totalMultiplier += ((1 - percentCur) * modSettings.VehicleDamageFactor);
LogReport($"{"Vehicle percents",-20} | {percentArmor * 100,10} | {percentStructure * 100,10:F3}");
LogReport($"{"Vehicle state",-20} | {modSettings.VehicleDamageFactor,10} | {totalMultiplier,10:F3}");
}
var resolveModifier = modSettings.ResolveMaxModifier *
(defender.Combat.LocalPlayerTeam.Morale - modSettings.MedianResolve) / modSettings.MedianResolve;
if (modSettings.VehiclesCanPanic &&
defender is Vehicle)
{
resolveModifier *= modSettings.VehicleResolveFactor;
}
totalMultiplier -= resolveModifier;
LogReport($"{$"Resolve {defender.Combat.LocalPlayerTeam.Morale}",-20} | {resolveModifier * -1,10:F3} | {totalMultiplier,10:F3}");
if (modSettings.VehiclesCanPanic &&
defender is Vehicle)
{
gutsAndTacticsSum *= modSettings.VehicleGutAndTacticsFactor;
}
totalMultiplier -= gutsAndTacticsSum;
LogReport($"{"Guts and Tactics",-20} | {$"-{gutsAndTacticsSum}",10} | {totalMultiplier,10:F3}");
return(totalMultiplier);
}
public void Generate(GameMap map)
{
while (Qty >= 0)
{
var x = Random.Range(0, map.MapWidth);
var y = Random.Range(0, map.MapHeight);
var dir = Random.Range(0, 4);
var type = map.Map[x, y].Type;
var decorators = map.Map[x, y].Decorators.ToArray();
switch (dir)
{
case 0: //right
if (x + 1 >= map.MapWidth)
{
continue;
}
map.Map[x + 1, y].Type = type;
map.Map[x + 1, y].Decorators.Clear();
map.Map[x + 1, y].Decorators.AddRange(decorators);
break;
case 1: //left
if (x - 1 < 0)
{
continue;
}
map.Map[x - 1, y].Type = type;
map.Map[x - 1, y].Decorators.Clear();
map.Map[x - 1, y].Decorators.AddRange(decorators);
break;
case 2: //up
if (y + 1 >= map.MapWidth)
{
continue;
}
map.Map[x, y + 1].Type = type;
map.Map[x, y + 1].Decorators.Clear();
map.Map[x, y + 1].Decorators.AddRange(decorators);
break;
case 3: //down
if (y - 1 < 0)
{
continue;
}
map.Map[x, y - 1].Type = type;
map.Map[x, y - 1].Decorators.Clear();
map.Map[x, y - 1].Decorators.AddRange(decorators);
break;
}
Qty--;
}
}
public static bool SavedVsPanic(AbstractActor actor, float savingThrow)
{
try
{
AbstractActor defender = null;
if (actor is Vehicle vehicle)
{
if (!modSettings.VehiclesCanPanic)
{
return(true);
}
defender = vehicle;
}
else if (actor is Mech mech)
{
defender = mech;
}
if (defender == null)
{
LogDebug($"defender null, passing save. actor {actor} is type {actor.GetType()}");
return(true);
}
if (modSettings.QuirksEnabled)
{
if (defender is Mech m)
{
if (m.pilot.pilotDef.PilotTags.Contains("pilot_brave"))
{
savingThrow -= modSettings.BraveModifier;
LogReport($"{"Bravery",-20} | {modSettings.BraveModifier,10} | {savingThrow,10:F3}");
}
}
}
var index = GetActorIndex(defender);
float panicModifier = GetPanicModifier(TrackedActors[index].PanicStatus);
savingThrow *= panicModifier;
LogReport($"{"Panic multiplier",-20} | {panicModifier,10} | {savingThrow,10:F3}");
savingThrow = (float)Math.Max(0f, Math.Round(savingThrow));
if (savingThrow < 1)
{
LogReport(new string('-', 46));
LogReport("Negative saving throw| skipping");
return(true);
}
var roll = Random.Range(1, 100);
LogReport(new string('-', 46));
LogReport($"{"Saving throw",-20} | {savingThrow,-5}{roll,5} | {"Roll",10}");
LogReport(new string('-', 46));
SaySpamFloatie(defender, $"{$"{modSettings.PanicSpamSaveString}:{savingThrow}",-6} {$"{modSettings.PanicSpamRollString}:{roll}!",3}");
// lower panic level on crit success
if (roll == 100)
{
LogReport("Critical success");
SaySpamFloatie(defender, $"{modSettings.PanicSpamCritSaveString}");
TrackedActors[index].PanicStatus--;
// just in case the status went down then back up on a crit save in the same round
TrackedActors[index].PanicWorsenedRecently = false;
return(true);
}
if (!modSettings.AlwaysPanic &&
roll >= savingThrow)
{
LogReport("Successful panic save");
SaySpamFloatie(defender, $"{modSettings.PanicSpamSaveString}!");
return(true);
}
LogReport("Failed panic save");
SaySpamFloatie(defender, $"{modSettings.PanicSpamFailString}!");
var originalStatus = TrackedActors[index].PanicStatus;
if (defender is Vehicle)
{
TrackedActors[index].PanicStatus = PanicStatus.Panicked;
}
else
{
TrackedActors[index].PanicStatus++;
}
TrackedActors[index].PanicWorsenedRecently = true;
// check for panic crit
if (roll == 1 ||
ActorHealth(defender) <= modSettings.MechHealthForCrit &&
roll < Convert.ToInt32(savingThrow) - modSettings.CritOver)
{
LogReport("Critical failure on panic save");
defender.Combat.MessageCenter.PublishMessage(
new AddSequenceToStackMessage(
new ShowActorInfoSequence(defender, modSettings.PanicCritFailString, FloatieMessage.MessageNature.CriticalHit, true)));
// ejection can only occur from a stressed or panicked state where panicked requirement is achieved regardless
// no crit going from confident to panicked then ejection
TrackedActors[index].PanicStatus = PanicStatus.Panicked;
}
TrackedActors[index].PreventEjection = originalStatus < PanicStatus.Stressed;
}
catch (Exception ex)
{
LogDebug(ex);
}
return(false);
}
/// <summary>
/// Type에 해당하는 enum을 랜덤으로 1개 리턴함.
/// </summary>
public static Enum ReturnRandomEnum(Type p_type)
{
var temp_array = Enum.GetValues(p_type);
return((Enum)temp_array.GetValue(Random.Range(0, temp_array.Length)));
}
// false is punchin' out
public static bool SavedVsEject(AbstractActor actor, float savingThrow)
{
LogReport("Panic save failure requires eject save");
var pilotTracker = TrackedActors.First(tracker => tracker.Guid == actor.GUID);
if (pilotTracker.PreventEjection)
{
LogReport("Ejection forbidden after crit unless already stressed or panicked");
pilotTracker.PreventEjection = false;
return(true);
}
DrawHeader();
if (actor is Mech mech && modSettings.QuirksEnabled)
{
if (mech.pilot.pilotDef.PilotTags.Contains("pilot_dependable"))
{
savingThrow -= modSettings.DependableModifier;
LogReport($"{"Dependable",-20} | {modSettings.DependableModifier,10} | {savingThrow,10:F3}");
}
}
// calculate result
if (modSettings.VehiclesCanPanic &&
actor is Vehicle)
{
savingThrow = Math.Max(0f, savingThrow - modSettings.BaseVehicleEjectionResist);
LogReport($"{"Base ejection resist",-20} | {modSettings.BaseVehicleEjectionResist,10} | {savingThrow,10:F3}");
}
else if (actor is Mech)
{
savingThrow = Math.Max(0f, savingThrow - modSettings.BaseEjectionResist);
LogReport($"{"Base ejection resist",-20} | {modSettings.BaseEjectionResist,10} | {savingThrow,10:F3}");
}
savingThrow = (float)Math.Round(savingThrow);
LogReport($"{"Eject multiplier",-20} | {modSettings.EjectChanceFactor,10} | {savingThrow,10:F3}");
var roll = Random.Range(1, 100);
LogReport(new string('-', 46));
LogReport($"{"Saving throw",-20} | {savingThrow,-5:###}{roll,5} | {"Roll",10}");
LogReport(new string('-', 46));
if (!modSettings.AlwaysPanic &&
savingThrow < 1)
{
LogReport("Negative saving throw| skipping");
SaySpamFloatie(actor, $"{modSettings.PanicSpamEjectResistString}");
return(true);
}
// cap the saving throw by the setting
savingThrow = (int)Math.Min(savingThrow, modSettings.MaxEjectChance);
SaySpamFloatie(actor, $"{modSettings.PanicSpamSaveString}:{savingThrow} {modSettings.PanicSpamRollString}:{roll}!");
if (!modSettings.AlwaysPanic &&
roll >= savingThrow)
{
LogReport("Successful ejection save");
SaySpamFloatie(actor, $"{modSettings.PanicSpamSaveString}! {ActorHealth(actor):#.#}%");
return(true);
}
// TODO can it be written if (mech != null) ? I don't know and testing it is a PITA!
if (actor is Mech m)
{
if (modSettings.QuirksEnabled && m.MechDef.Chassis.ChassisTags.Contains("mech_quirk_noeject"))
{
LogReport("This mech can't eject (quirk)");
actor.Combat.MessageCenter.PublishMessage(
new AddSequenceToStackMessage(
new ShowActorInfoSequence(actor, "Mech quirk: Can't eject", FloatieMessage.MessageNature.PilotInjury, true)));
return(true);
}
if (modSettings.QuirksEnabled && m.pilot.pilotDef.PilotTags.Contains("pilot_drunk") &&
m.pilot.pilotDef.TimeoutRemaining > 0)
{
LogReport("Drunkard - not ejecting");
actor.Combat.MessageCenter.PublishMessage(
new AddSequenceToStackMessage(
new ShowActorInfoSequence(actor, "Pilot quirk: Drunkard won't eject", FloatieMessage.MessageNature.PilotInjury, true)));
return(true);
}
}
LogReport("Failed ejection save: Punchin\' Out!!");
return(false);
}
internal static async Task ProcessTextFile(string filePath)
{
var fileName = Path.GetFileName(filePath);
MelonLogger.Log($"Started avatar import process for file {fileName}");
var toAdd = new List <string>();
{ // file access block
using var file = new FileStream(filePath, FileMode.Open, FileAccess.Read);
using var reader = new StreamReader(file);
string line;
while ((line = await reader.ReadLineAsync().ConfigureAwait(false)) != null)
{
var matches = AvatarIdRegex.Matches(line);
foreach (Match match in matches)
{
var avatarId = match.Value;
toAdd.Add(avatarId);
}
}
}
for (var i = 0; i < toAdd.Count; i++)
{
ImportStatusInner = $"Fetching avatar {i + 1}/{toAdd.Count}";
var avatarId = toAdd[i];
if (FavCatMod.Database.myStoredAvatars.FindById(avatarId) == null)
{
await FavCatMod.YieldToMainThread();
new ApiAvatar {
id = avatarId
}.Fetch(); // it will get intercepted and stored
await Task.Delay(TimeSpan.FromSeconds(5f + Random.Range(0f, 5f))).ConfigureAwait(false);
}
}
ImportStatusInner = "Creating favorites list";
await FavCatMod.YieldToMainThread();
var userId = APIUser.CurrentUser.id;
var categoryName = $"Imported from {fileName}";
var existingCategory = FavCatMod.Database.AvatarFavorites.GetCategory(categoryName);
foreach (var avatarId in toAdd)
{
if (FavCatMod.Database.AvatarFavorites.IsFavorite(avatarId, categoryName))
{
continue;
}
var storedAvatar = FavCatMod.Database.myStoredAvatars.FindById(avatarId);
if (storedAvatar == null || storedAvatar.ReleaseStatus != "public" && storedAvatar.AuthorId != userId)
{
continue;
}
FavCatMod.Database.AvatarFavorites.AddFavorite(avatarId, categoryName);
}
if (existingCategory == null)
{
existingCategory = new StoredCategory {
CategoryName = categoryName, SortType = "!added"
};
FavCatMod.Database.AvatarFavorites.UpdateCategory(existingCategory);
var avatarModule = FavCatMod.Instance.AvatarModule !;
avatarModule.CreateList(existingCategory);
avatarModule.ReorderLists();
avatarModule.RefreshFavButtons();
}
MelonLogger.Log($"Done importing {fileName}");
File.Delete(filePath);
}
public static ExitPosition GetRandomPostion()
{
int randomNumber = Random.Range(0, 3);
return((ExitPosition)randomNumber);
}
public static Option <int> randomIndex <A>(this IList <A> list) => list.Count == 0 ? F.none <int>() : F.some(Random.Range(0, list.Count));
/// <summary>
/// Select random element of collection with specified range. Can have out param with RNG index
/// </summary>
public static T GetRandom <T>(this IList <T> collection, out int rng, int min = 0, int max = 0)
{
rng = Random.Range(min, max == 0 ? collection.Count : max);
return(collection[rng]);
}
public static T GetRandom <T>(this T[] arr)
{
return(arr[URandom.Range(0, arr.Length)]);
}
protected virtual float RandomCurveTime(ref AnimationCurve curve)
{
return(Random.Range(CurveMinTime(ref curve), CurveMaxTime(ref curve)));
}
