private Vector3 GetAllowedRandomPosition(Transform tf, SpawnOptions options)
{
if (options.allow.Count > 0)
{
Collider allowed = options.allow[Random.Range(0, options.allow.Count)];
if (options.avoid.Count == 0)
{
tf.position = RandomPointWithinBounds(allowed.bounds);
return(tf.position);
}
int maxAttempts = 25;
bool success = false;
for (var attempt = 0; attempt < maxAttempts; attempt++)
{
int forbiddenCollisions = 0;
if (success)
{
break;
}
tf.position = RandomPointWithinBounds(allowed.bounds);
Collider[] collisions = Physics.OverlapBox(
tf.position,
tf.lossyScale,
tf.rotation
);
foreach (var forbidden in options.avoid)
{
foreach (var collision in collisions)
{
if (collision.Equals(forbidden))
{
forbiddenCollisions++;
}
}
}
if (forbiddenCollisions.Equals(0))
{
success = true;
break;
}
}
if (!success)
{
tf.gameObject.SetActive(false);
}
}
return(tf.position);
}
private Transform SetTransform(Transform tf, SpawnOptions options)
{
tf.rotation = tf.rotation.Randomize(options.rotationRange);
tf.localScale = RandomScale(
tf.localScale,
options.minScale,
options.maxScale,
options.scaleMethod
);
tf.position = GetAllowedRandomPosition(tf, options);
return(tf);
}
private void RandomizePoolObject(GameObject obj, SpawnOptions options)
{
SetTransform(obj.transform, options);
// TODO: Move mass setup to initialization method and only run on start-up (or preferably on object added)
if (!options.isStatic)
{
var rb = obj.GetComponent <Rigidbody>();
if (rb != null)
{
rb.mass *= obj.transform.localScale.sqrMagnitude;
}
}
}
private Transform SetTransform(Transform tf, SpawnOptions options, Bounds?bounds = null)
{
Quaternion randomRotation = tf.rotation.Randomize(options.rotationRange);
Vector3 randomScale = RandomScale(
tf.localScale,
options.minScale,
options.maxScale,
options.scaleMethod
);
tf.rotation = randomRotation;
tf.localScale = randomScale;
tf.position = GetAllowedRandomPosition(tf, options, bounds);
return(tf);
}
public void Create()
{
var options = SpawnOptions.Create();
Assert.That(options.Arguments.Count, Is.Zero);
Assert.That(options.WorkingDirectory, Is.EqualTo(Environment.CurrentDirectory));
var env = Environment.GetEnvironmentVariables();
Assert.That(options.Environment.Length, Is.EqualTo(env.Count));
foreach (var e in options.Environment)
{
Assert.That(env[e.Key], Is.EqualTo(e.Value));
}
Assert.That(options.CreateNoWindow, Is.False);
}
public void Update()
{
var psi = new ProcessStartInfo();
Assert.That(psi.WorkingDirectory, Is.Empty);
Assert.That(psi.ArgumentList, Is.Empty);
var options = SpawnOptions.Create().AddArgument("foo", "bar", "baz");
options.Update(psi);
Assert.That(psi.WorkingDirectory, Is.EqualTo(options.WorkingDirectory));
Assert.That(psi.ArgumentList, Is.EqualTo(options.Arguments));
var env = psi.Environment;
Assert.That(env.Count, Is.EqualTo(options.Environment.Length));
foreach (var e in options.Environment)
{
Assert.That(env[e.Key], Is.EqualTo(e.Value));
}
}
TestSpawn <T>(SpawnOptions options,
ICollection <Notification <T> > notifications,
Func <string, T>?stdoutSelector,
Func <string, T>?stderrSelector,
params Action <TestProcess>[] processModifiers)
{
var observer =
Observer.Create((T data) => notifications.Add(Notification.CreateOnNext(data)),
e => notifications.Add(Notification.CreateOnError <T>(e)),
() => notifications.Add(Notification.CreateOnCompleted <T>()));
TestProcess?process = null;
var subscription =
Spawn("dummy", ProgramArguments.Empty, stdoutSelector,
stderrSelector)
.WithOptions(options.WithProcessFactory(psi =>
{
process = new TestProcess(psi)
{
Id = 123,
StandardInput = System.IO.StreamWriter.Null,
StartException = null,
BeginErrorReadLineException = null,
BeginOutputReadLineException = null,
KillException = null,
};
foreach (var modifier in processModifiers)
{
modifier(process);
}
return(process);
}))
.Subscribe(observer);
Debug.Assert(process is {});
private Vector3 GetAllowedRandomPosition(Transform tf, SpawnOptions options, Bounds?bounds = null)
{
if (options.allow.Count > 0)
{
var allowed = options.allow[Random.Range(0, options.allow.Count)];
if (options.avoid.Count == 0)
{
tf.position = RandomPointWithinBounds(allowed.bounds);
return(tf.position);
}
var maxAttempts = 25;
var success = false;
Collider[] colliders = { };
List <Collider> forbiddenColliders = new List <Collider>();
for (var attempt = 0; attempt < maxAttempts; attempt++)
{
forbiddenColliders = new List <Collider>();
var forbiddenCollisions = 0;
if (success)
{
break;
}
tf.position = RandomPointWithinBounds(allowed.bounds);
if (bounds != null)
{
colliders = Physics.OverlapBox(
tf.position,
((Bounds)bounds).extents / 2
);
}
else
{
colliders = Physics.OverlapBox(
tf.position,
tf.lossyScale / 2f,
tf.rotation
);
}
foreach (var forbidden in options.avoid)
{
foreach (var collider in colliders)
{
if (collider.Equals(forbidden))
{
forbiddenCollisions++;
forbiddenColliders.Add(collider);
}
}
}
if (forbiddenCollisions.Equals(0))
{
success = true;
break;
}
}
if (!success)
{
var errorMessage = "Couldn't spawn object"
+ "\nPosition: " + tf.position.ToString()
+ "\nLossy Scale: " + tf.lossyScale.ToString()
+ "\nLossy Scale: " + tf.rotation.ToString()
+ "\nForbidden collisions: ";
foreach (var collider in forbiddenColliders)
{
errorMessage +=
"\n\t" + collider.name
+ "\nCenter: " + collider.bounds.center.ToString()
+ "\nExtents: " + collider.bounds.extents.ToString()
;
}
Debug.LogError(errorMessage, tf.gameObject);
tf.gameObject.SetActive(false);
}
;
}
return(tf.position);
}
public static void SpawnSosigWithTemplate(SosigEnemyTemplate template, SpawnOptions spawnOptions, Vector3 position,
Vector3 forward)
{
var sosigPrefab = template.SosigPrefabs[Random.Range(0, template.SosigPrefabs.Count)];
var configTemplate = template.ConfigTemplates[Random.Range(0, template.ConfigTemplates.Count)];
var outfitConfig = template.OutfitConfig[Random.Range(0, template.OutfitConfig.Count)];
var sosig = SpawnSosigAndConfigureSosig(sosigPrefab.GetGameObject(), position,
Quaternion.LookRotation(forward, Vector3.up), configTemplate, outfitConfig);
sosig.InitHands();
sosig.Inventory.Init();
if (template.WeaponOptions.Count > 0)
{
var weapon = SpawnWeapon(template.WeaponOptions);
weapon.SetAutoDestroy(true);
sosig.ForceEquip(weapon);
if (weapon.Type == SosigWeapon.SosigWeaponType.Gun && spawnOptions.SpawnWithFullAmmo)
{
sosig.Inventory.FillAmmoWithType(weapon.AmmoType);
}
}
var spawnWithSecondaryWeapon = spawnOptions.EquipmentMode == 0 || spawnOptions.EquipmentMode == 2 ||
spawnOptions.EquipmentMode == 3 &&
Random.Range(0.0f, 1f) >= template.SecondaryChance;
if (template.WeaponOptions_Secondary.Count > 0 && spawnWithSecondaryWeapon)
{
var weapon = SpawnWeapon(template.WeaponOptions_Secondary);
weapon.SetAutoDestroy(true);
sosig.ForceEquip(weapon);
if (weapon.Type == SosigWeapon.SosigWeaponType.Gun && spawnOptions.SpawnWithFullAmmo)
{
sosig.Inventory.FillAmmoWithType(weapon.AmmoType);
}
}
var spawnWithTertiaryWeapon = spawnOptions.EquipmentMode == 0 ||
spawnOptions.EquipmentMode == 3 &&
Random.Range(0.0f, 1f) >= template.TertiaryChance;
if (template.WeaponOptions_Tertiary.Count > 0 && spawnWithTertiaryWeapon)
{
var w2 = SpawnWeapon(template.WeaponOptions_Tertiary);
w2.SetAutoDestroy(true);
sosig.ForceEquip(w2);
if (w2.Type == SosigWeapon.SosigWeaponType.Gun && spawnOptions.SpawnWithFullAmmo)
{
sosig.Inventory.FillAmmoWithType(w2.AmmoType);
}
}
var sosigIFF = spawnOptions.IFF;
if (sosigIFF >= 5)
{
sosigIFF = Random.Range(6, 10000);
}
sosig.E.IFFCode = sosigIFF;
sosig.CurrentOrder = Sosig.SosigOrder.Disabled;
switch (spawnOptions.SpawnState)
{
case 0:
sosig.FallbackOrder = Sosig.SosigOrder.Disabled;
break;
case 1:
sosig.FallbackOrder = Sosig.SosigOrder.GuardPoint;
break;
case 2:
sosig.FallbackOrder = Sosig.SosigOrder.Wander;
break;
case 3:
sosig.FallbackOrder = Sosig.SosigOrder.Assault;
break;
}
var targetPos = spawnOptions.SosigTargetPosition;
var targetRot = spawnOptions.SosigTargetRotation;
sosig.UpdateGuardPoint(targetPos);
sosig.SetDominantGuardDirection(targetRot);
sosig.UpdateAssaultPoint(targetPos);
if (!spawnOptions.SpawnActivated)
{
return;
}
sosig.SetCurrentOrder(sosig.FallbackOrder);
}
