public System.Collections.IEnumerator CreateNewObjectWhenPoolEmpty()
{
const int limit = 3;
var objectToSpawn = TestEnemy.Create(0);
Spawner spawner = Spawner.Create(
typeof(Crasher), limit, 0, 0, 10, 0);
Spawnable.Pool <Crasher> .Instance.Populate(objectToSpawn, limit);
spawner.StartSpawning();
yield return(new UnityEngine.WaitWhile(() => spawner.IsSpawning));
spawner.StartSpawning(typeof(Crasher), 1, 0, 0, 0, 10);
yield return(new UnityEngine.WaitWhile(() => spawner.IsSpawning));
int expectedValue = limit + 1;
/* Normal Destroy does not destroy the object before the assertion happens.
* Using DestroyImmediate instead. */
UnityEngine.Object.DestroyImmediate(objectToSpawn.gameObject);
int actualValue = UnityEngine.Object.FindObjectsOfType <TestEnemy>().Length;
Assert.AreEqual(expectedValue, actualValue,
$"Expected {expectedValue} spawned objects but got {actualValue}.");
}
public IEnumerator ObjectsAreSpawnedInsideTheDesignatedArea()
{
/* This test is based on luck, making it pretty much unreliable.
* I feel confident enough that things workout, though.*/
var prefab = TestEnemy.Create();
Spawner spawner = Spawner.Create(prefab, 20, 0f, 0f, 5f, 3f);
spawner.StartSpawning();
yield return(new WaitWhile(() => spawner.IsSpawning));
Object.Destroy(prefab.gameObject);
Enemy[] enemies = Object.FindObjectsOfType <Enemy>();
foreach (var enemy in enemies)
{
if (enemy == spawner.ObjectToSpawn)
{
continue;
}
var distance = enemy.transform.position.magnitude;
Assert.GreaterOrEqual(distance, spawner.MinDistanceToSpawn,
"Objects should not be spawned below the minimum distance.");
Assert.LessOrEqual(distance, spawner.MaxDistanceToSpawn,
"Objects should not be spawned past the maximum distance.");
}
}
public IEnumerator SpawnersHaveAGlobalSpawningLimit()
{
int limit = 100; // Should be used only for the following check
// and assigning spawnLimit.
Assert.Less(Spawnable.GLOBAL_SPAWN_LIMIT, limit,
$"Test is not set up correctly:\n" +
$"The spawner's limit ({limit}) is lower than the " +
$"global spawn limit ({Spawnable.GLOBAL_SPAWN_LIMIT})."
);
Spawner spawner = Spawner.Create(
objectToSpawn: TestEnemy.Create(),
spawnLimit: limit,
initialDelay: 0f,
spawnRate: 0f,
maxDistanceToSpawn: 100f,
minDistanceToSpawn: 0f
);
spawner.StartSpawning();
yield return(new WaitUntil(
() => spawner.SpawnCount == Spawnable.GLOBAL_SPAWN_LIMIT));
yield return(new WaitForSecondsRealtime(.5f));
Assert.That(spawner.IsSpawning, "Spawner should not stop spawning.");
Assert.LessOrEqual(spawner.SpawnCount, Spawnable.GLOBAL_SPAWN_LIMIT,
"Spawners must respect the global spawn limit."
);
}
public IEnumerator UseLastShotToKillLastEnemy()
{
GameState gameState = GameState.Create(0);
Camera camera = new GameObject("Camera").AddComponent <Camera>();
Player player = Player.Create(
health: Player.MAXIMUM_HEALTH,
camera: camera,
bullet: Bullet.Create(100f),
ammo: 1,
gameState: gameState);
TestEnemy enemy = TestEnemy.Create(0, 0, 0, 10, 10, 10, gameState);
GameManager.Create(player, gameState);
yield return(null); //without this, firedBullet will be null
camera.transform.LookAt(enemy.transform);
var firedBullet = player.Shoot();
firedBullet.gameObject.SetActive(true);
yield return(new WaitUntil(() => gameState.RoundWon));
Assert.False(gameState.GameOver,
"The game must not end if the last enemy dies by the last bullet.");
Assert.True(gameState.RoundWon,
"The round should be won when the last enemy dies by the last bullet.");
}
public void ObjectReturnsToPool()
{
Spawnable.Pool <Crasher> .Instance.Populate(TestEnemy.Create(0), 1);
TestEnemy testObject = Spawnable.Pool <Crasher> .Instance.RequestObject() as TestEnemy;
testObject.ReturnToPool <Crasher>();
Assert.AreEqual(1, Spawnable.Pool <Crasher> .Instance.Count,
"No object available in the pool.");
Assert.IsNotNull(Spawnable.Pool <Crasher> .Instance.RequestObject(),
"No object available to return.");
}
public IEnumerator SpawnerStopsSpawningAtGameOver()
{
GameState gameState = GameState.Create(0);
Spawner spawner = Spawner.Create(TestEnemy.Create(), 99, 0f, 1f, 5f, 3f, gameState);
spawner.StartSpawning();
yield return(new WaitUntil(() => spawner.SpawnCount == 3));
gameState.GameOver = true;
yield return(new WaitWhile(() => spawner.IsSpawning));
Assert.AreEqual(3, spawner.SpawnCount,
"Spawner should stop spawning at game over.");
}
public void NoAvailableObjectToFetch()
{
const int limit = 3;
Spawnable.Pool <Crasher> .Instance.Populate(TestEnemy.Create(0), limit);
for (int i = 0; i < limit; i++)
{
Spawnable.Pool <Crasher> .Instance.RequestObject();
}
Assert.IsNull(Spawnable.Pool <Crasher> .Instance.RequestObject(),
"A null reference should have been returned.");
}
public IEnumerator MoveFromPointAToPointB()
{
TestEnemy hamster = TestEnemy.Create(2f);
hamster.AiEnabled = false;
hamster.gameObject.SetActive(true);
MovementTestPoint testPoint = MovementTestPoint.Create(new Vector3(10f, 10f, 10f));
hamster.MoveTo(testPoint.transform.position);
yield return(new WaitWhile(() => hamster.IsMoving));
Assert.That(testPoint.reached,
"Test object must move to the designated test point.");
}
public IEnumerator MoveAroundPlayer()
{
TestEnemy hamster = TestEnemy.Create(5f, 0, 0, -5f);
hamster.AiEnabled = false;
hamster.gameObject.SetActive(true);
Player.Create();
MovementTestPoint endPoint = MovementTestPoint.Create(-hamster.transform.position);
hamster.MoveTo(endPoint.transform.position);
yield return(new WaitWhile(() => hamster.IsMoving));
Assert.True(endPoint.reached);
}
public IEnumerator SpawnerStopsWhenLimitReached()
{
Spawner spawner = Spawner.Create(
objectToSpawn: TestEnemy.Create(),
spawnLimit: 5,
spawnRate: 1,
maxDistanceToSpawn: 10f,
minDistanceToSpawn: 3f,
initialDelay: 0f
);
spawner.StartSpawning();
yield return(new WaitUntil(() => spawner.SpawnCount == spawner.SpawnLimit));
Assert.That(!spawner.IsSpawning,
"Spawner should stop spawining when the spawn limit is reached.");
}
public IEnumerator MoveToPointBSkippingA()
{
MovementTestPoint pointA = MovementTestPoint.Create(new Vector3(5f, 5f, 5f));
MovementTestPoint pointB = MovementTestPoint.Create(2 * pointA.transform.position);
TestEnemy hamster = TestEnemy.Create(5f);
hamster.AiEnabled = false;
hamster.gameObject.SetActive(true);
hamster.MoveTo(pointA.transform.position);
hamster.MoveTo(pointB.transform.position);
yield return(new WaitWhile(() => hamster.IsMoving));
Assert.True(pointA.reached, "Object did not pass through point A");
Assert.True(pointB.reached, "Object did not reach the end.");
}
public IEnumerator EveryoneMovesToTheSameSpot()
{
TestEnemy[] hamsters = new TestEnemy[15];
hamsters[0] = TestEnemy.Create(3f, 0, 0, -4f, 0f, 5f);
hamsters[1] = TestEnemy.Create(3f, 0, 0, -2f, 0f, 5f);
hamsters[2] = TestEnemy.Create(3f, 0, 0, 0f, 0f, 5f);
hamsters[3] = TestEnemy.Create(3f, 0, 0, 2f, 0f, 5f);
hamsters[4] = TestEnemy.Create(3f, 0, 0, 4f, 0f, 5f);
hamsters[5] = TestEnemy.Create(3f, 0, 0, -4f, 2f, 5f);
hamsters[6] = TestEnemy.Create(3f, 0, 0, -2f, 2f, 5f);
hamsters[7] = TestEnemy.Create(3f, 0, 0, 0f, 2f, 5f);
hamsters[8] = TestEnemy.Create(3f, 0, 0, 2f, 2f, 5f);
hamsters[9] = TestEnemy.Create(3f, 0, 0, 4f, 2f, 5f);
hamsters[10] = TestEnemy.Create(3f, 0, 0, -4f, 4f, 5f);
hamsters[11] = TestEnemy.Create(3f, 0, 0, -2f, 4f, 5f);
hamsters[12] = TestEnemy.Create(3f, 0, 0, 0f, 4f, 5f);
hamsters[13] = TestEnemy.Create(3f, 0, 0, 2f, 4f, 5f);
hamsters[14] = TestEnemy.Create(3f, 0, 0, 4f, 4f, 5f);
MovementTestPoint gatheringPoint = MovementTestPoint.Create();
foreach (var hamster in hamsters)
{
hamster.gameObject.SetActive(true);
hamster.AiEnabled = false;
hamster.MoveTo(gatheringPoint.transform.position);
}
yield return(new WaitForSecondsRealtime(3f));
bool allMovementStoped;
do
{
allMovementStoped = false;
foreach (var hamster in hamsters)
{
if (hamster.IsMoving)
{
allMovementStoped = true;
break;
}
}
yield return(new WaitForFixedUpdate());
} while (allMovementStoped && gatheringPoint.reached);
}
public IEnumerator SpawnerSpawnsTheCorrectNumberOfObjects()
{
Spawner spawner = Spawner.Create(
objectToSpawn: TestEnemy.Create(),
spawnLimit: 5,
spawnRate: 1,
maxDistanceToSpawn: 10f,
minDistanceToSpawn: 3f,
initialDelay: 0f
);
spawner.StartSpawning();
yield return(new WaitWhile(() => spawner.IsSpawning));
int numberOfSpawned = Object.FindObjectsOfType <TestEnemy>().Length - 1;
Assert.AreEqual(5, numberOfSpawned, "Should spawn 5 objects.");
}
public IEnumerator SpawnerCanStopSpawning()
{
Spawnable.Pool <Crasher> .Instance.Populate(TestEnemy.Create());
Spawner spawner = Spawner.Create(typeof(Crasher),
spawnLimit: 5, spawnRate: 1, initialDelay: 0f,
maxDistanceToSpawn: 10f, minDistanceToSpawn: 3f);
const int testLimit = 3; //the # of spawns after which spawning will stop
spawner.StartSpawning();
yield return(new WaitWhile(() => spawner.SpawnCount < testLimit));
spawner.StopSpawning();
int numberOfSpawned = Object.FindObjectsOfType <TestEnemy>().Length;
Assert.AreEqual(testLimit, numberOfSpawned,
$"Spawning should be interrupted after spawning {testLimit} objects.");
}
public IEnumerator SpawnerShouldNotBeRestartedWhileRunning()
{
Spawner spawner = Spawner.Create(
TestEnemy.Create(), 100, 100f, 100f, 100f, 1f);
UnityException error = null;
yield return(null);
try {
spawner.StartSpawning();
spawner.StartSpawning();
} catch (UnityException e) {
error = e;
}
Assert.IsNotNull(error,
"Should not be able to restart a spawner while it is" +
" currently spawning"
);
}
public IEnumerator MoveToBTurningBeforeA()
{
MovementTestPoint pointA = MovementTestPoint.Create(new Vector3(5f, 0f, 5f));
MovementTestPoint pointB = MovementTestPoint.Create(new Vector3(10f, 10f, 10f));
TestEnemy hamster = TestEnemy.Create(5f);
hamster.AiEnabled = false;
hamster.gameObject.SetActive(true);
hamster.MoveTo(pointA.transform.position);
yield return(new WaitUntil(
() => hamster.transform.position.magnitude > pointA.transform.position.magnitude / 2));
hamster.MoveTo(pointB.transform.position);
yield return(new WaitWhile(() => hamster.IsMoving));
Assert.True(pointB.reached, "Object did not reach the end.");
Assert.False(pointA.reached, "Object must not pass through point A");
}
public IEnumerator IgnoreBumpOnOtherEnemy()
{
TestEnemy hamster = TestEnemy.Create(5f);
hamster.AiEnabled = false;
hamster.gameObject.SetActive(true);
TestEnemy e = TestEnemy.Create(0f, 0, 0, 0f, 0f, 5f); // enemy blocking the path
e.AiEnabled = false;
e.gameObject.SetActive(true);
Vector3 initialPosition = e.transform.position;
MovementTestPoint endPoint = MovementTestPoint.Create(new Vector3(0f, 0f, 10f));
hamster.MoveTo(endPoint.transform.position);
yield return(new WaitWhile(() => hamster.IsMoving));
Assert.True(endPoint.reached);
// Also assert that the other enemy was not bounced:
Assert.That(Equals(initialPosition, e.transform.position));
}
