void Start()
{
if (GameCtr == null)
{
GameCtr = FindObjectOfType <GameController>();
}
if (stats == null)
{
stats = new EnemyStatsClass();
}
stats.SetUpEnemyStats(GameCtr);
if (healthBar != null)
{
healthBar.transform.parent.gameObject.SetActive(false);
}
if (turnTimeBar != null)
{
turnTimeBar.transform.parent.gameObject.SetActive(false);
}
if (stats.dodged != null)
{
stats.dodged.SetActive(false);
}
if (staticService == null) // only setup staticServe anew if it's not there already (a playmode test might have set a substitute object here that we don't want to replace)
{
staticService = new UnityStaticService();
}
}
public IEnumerator AttackBoosterCannotBeUsedIfBoostAlreadyActive()
{
Player player = CreatePlayer();
Enemy enemy = CreateEnemy(false);
InventoryUI inventoryUI = CreateInventoryUI();
GameController gameCtr = CreateGameController(player);
IUnityStaticService staticService = CreateUnityService(player.stats.TurnTime, 0, 0);
player.staticService = staticService;
yield return(new WaitForEndOfFrame());
inventoryUI.GameCtr = gameCtr;
Item item = ScriptableObject.CreateInstance <Item>();
item.type = ItemType.AttackBoost;
item.AddUses(1);
yield return(new WaitForEndOfFrame());
gameCtr.StartBattle(enemy);
player.inventory.CollectItem(item);
yield return(new WaitForEndOfFrame());
Button slotButton = inventoryUI.transform.GetChild(0).gameObject.GetComponent <Button>();
Assert.IsTrue(slotButton.IsInteractable(), "Slot button for boost item was not interactable even though there was no boost active!");
player.inventory.UseItem(0);
yield return(new WaitForEndOfFrame());
Assert.IsFalse(slotButton.IsInteractable(), "Slot button for boost item was interactable even though there was already a boost active!");
}
public IEnumerator Test_LightIncreasesIfChestOpened()
{
Player player = CreatePlayer();
TreasureChest chest = CreateChest();
IUnityStaticService staticService = CreateUnityService(0.1f, 0, 0);
chest.player = player;
chest.staticService = staticService;
player.transform.position = new Vector3(chest.openDistance, 0, 0);
yield return(new WaitForEndOfFrame());
Assert.Zero(chest.flareLight.intensity, "Flare light intensity was not 0 on start!");
chest.isOpen = true;
yield return(new WaitForEndOfFrame());
Assert.NotZero(chest.flareLight.intensity, "Flare light intensity was not increased!");
chest.flareLight.intensity = chest.maxLightIntensity;
yield return(new WaitForEndOfFrame());
Assert.AreEqual(chest.maxLightIntensity, chest.flareLight.intensity, "Flare light intensity was increased beyond max intensity!");
}
void Start()
{
if (player == null)
{
player = FindObjectOfType <Player>();
}
if (gameCtr == null)
{
gameCtr = FindObjectOfType <GameController>();
}
animator = GetComponent <Animator>();
flareLight = GetComponentInChildren <Light>();
if (flareLight != null)
{
flareLight.intensity = 0;
}
if (staticService == null) // only setup staticServe anew if it's not there already (a playmode test might have set a substitute object here that we don't want to replace)
{
staticService = new UnityStaticService();
}
}
public IEnumerator Test_AttacksIfFullyCharged()
{
Player player = CreatePlayer();
player.stats.DodgePropability = 0;
Enemy enemy = CreateEnemy();
IUnityStaticService staticService = CreateUnityService(enemy.stats.TurnTime, 0, 0);
enemy.staticService = staticService;
enemy.AttackProbability = 1;
enemy.stats.MaxAmountOfChargings = 1;
GameController gameCtr = CreateGameController(player);
enemy.GameCtr = gameCtr;
player.GameCtr = gameCtr;
float oldHealth = player.stats.GetCurrentHealth();
yield return(new WaitForEndOfFrame());
gameCtr.StartBattle(enemy);
yield return(new WaitForEndOfFrame());
yield return(new WaitForEndOfFrame());
Assert.AreNotEqual(player.stats.GetCurrentHealth(), oldHealth, "Enemy wasn't forced to attack after charging to max!");
}
public IEnumerator Test_TurnTimeIsResetAfterUsingAnItem()
{
Player player = CreatePlayer();
Enemy enemy = CreateEnemy();
GameController GameCtr = CreateGameController(player);
IUnityStaticService staticService = CreateUnityService(player.stats.TurnTime, 0, 0);
player.staticService = staticService;
Item item = ScriptableObject.CreateInstance <Item>();
item.type = ItemType.Healing;
player.inventory.CollectItem(item);
yield return(new WaitForEndOfFrame());
GameCtr.StartBattle(enemy);
yield return(new WaitForEndOfFrame());
Assert.IsTrue(player.stats.CanAct(), "Player wasn't allowed to act in the first place!");
player.inventory.UseItem(0);
Assert.IsFalse(player.stats.CanAct(), "Player turn time did not reset after using an item!");
}
public void Test_PlayerDoesntMoveWithoutInput()
{
PlayerStatsClass stats = new PlayerStatsClass();
IUnityStaticService staticService = CreateUnityService(1, 0, 0);
Vector3 calculatedMovement = stats.CalcMovement(staticService.GetInputAxis("Horizontal"), staticService.GetInputAxis("Vertical"), staticService.GetDeltaTime());
Assert.Zero(calculatedMovement.magnitude, "Player moved without input!");
}
// ------------------------------------ helper methods -------------------------------------------------
IUnityStaticService CreateUnityService(float deltaTimeReturn, float horizontalReturn, float verticalReturn)
{
IUnityStaticService s = Substitute.For <IUnityStaticService>();
s.GetDeltaTime().Returns(deltaTimeReturn);
s.GetInputAxis("Horizontal").Returns(horizontalReturn);
s.GetInputAxis("Vertical").Returns(verticalReturn);
return(s);
}
public IEnumerator Test_PlayerIsAffectedByGravity()
{
Player player = CreatePlayer();
player.gameObject.AddComponent <CharacterController>();
player.gravityValue = -1.0f;
IUnityStaticService staticService = CreateUnityService(1, 0, 0);
player.staticService = staticService;
yield return(new WaitForFixedUpdate());
Assert.AreEqual(-1, player.transform.position.y, 0.1f, "Player wasn't affected by gravity!");
}
public IEnumerator Test_TurnTimeIsResetAfterAttack()
{
Player player = CreatePlayer();
Enemy enemy = CreateEnemy();
IUnityStaticService staticService = CreateUnityService(enemy.stats.TurnTime, 0, 0);
enemy.staticService = staticService;
yield return(new WaitForEndOfFrame());
enemy.stats.AttackOpponent(player.stats, false, true);
Assert.IsFalse(enemy.stats.CanAct(), "Enemy turn time did not reset after their attack!");
}
void Start()
{
if (GameCtr == null)
{
GameCtr = FindObjectOfType <GameController>();
}
if (stats == null)
{
stats = new PlayerStatsClass();
}
stats.SetUpPlayerStats(this);
if (inventory == null)
{
inventory = new PlayerInventoryClass();
}
inventory.SetUpInventory(this);
if (staticService == null) // only setup staticServe anew if it's not there already (a playmode test might have set a substitute object here that we don't want to replace)
{
staticService = new UnityStaticService();
}
foreach (Item i in inventory.items)
{
if (i != null)
{
i.SetUpItem();
}
}
if (healthBar != null)
{
healthBar.transform.parent.gameObject.SetActive(false);
}
if (turnTimeBar != null)
{
turnTimeBar.transform.parent.gameObject.SetActive(false);
}
if (stats.dodged != null)
{
stats.dodged.SetActive(false);
}
if (charContr == null)
{
charContr = GetComponent <CharacterController>();
}
}
public void Test_PlayerCantMoveWhileInBattle()
{
PlayerStatsClass stats = new PlayerStatsClass();
IUnityStaticService staticService = CreateUnityService(1, 1, 1);
IGameController ctr = Substitute.For <IGameController>();
ctr.IsInBattle().Returns(true);
IPlayer mockPlayer = Substitute.For <IPlayer>();
mockPlayer.GetGameController().Returns(ctr);
stats.SetPlayerAddition(mockPlayer);
Vector3 calculatedMovement = stats.CalcMovement(staticService.GetInputAxis("Horizontal"), staticService.GetInputAxis("Vertical"), staticService.GetDeltaTime());
Assert.Zero(calculatedMovement.magnitude, "Player was able to move while in battle!");
}
public void Test_PlayerMovementIsCalculatedCorrectly()
{
PlayerStatsClass stats = new PlayerStatsClass();
IUnityStaticService staticService = CreateUnityService(1, 1, 1);
float expectedX = staticService.GetInputAxis("Horizontal") * stats.playerSpeed * staticService.GetDeltaTime();
float expectedY = 0;
float expectedZ = staticService.GetInputAxis("Vertical") * stats.playerSpeed * staticService.GetDeltaTime();
Vector3 calculatedMovement = stats.CalcMovement(staticService.GetInputAxis("Horizontal"), staticService.GetInputAxis("Vertical"), staticService.GetDeltaTime());
Assert.NotZero(calculatedMovement.magnitude, "Player movement calculation resulted in no movement!");
Assert.AreEqual(calculatedMovement.x, expectedX, "Player movement calculation did not return the expected x movement!");
Assert.AreEqual(calculatedMovement.y, expectedY, "Player movement calculation did not return the expected y movement!");
Assert.AreEqual(calculatedMovement.z, expectedZ, "Player movement calculation did not return the expected z movement!");
}
public IEnumerator Test_TurnTimeIsResetEvenIfOpponentDodged()
{
Player player = CreatePlayer();
Enemy enemy = CreateEnemy();
enemy.stats.DodgePropability = 1;
IUnityStaticService staticService = CreateUnityService(player.stats.TurnTime, 0, 0);
player.staticService = staticService;
yield return(null);
player.stats.AttackOpponent(enemy.stats, true, true);
Assert.AreEqual(enemy.stats.MaxHealth, enemy.stats.currentHealth, "Enemy did not dodge!");
Assert.IsFalse(player.stats.CanAct(), "Player turn time did ot reset after an unsuccessful attack!");
}
public IEnumerator Test_PlayerRotatesInLookDirection()
{
Player player = CreatePlayer();
player.gameObject.AddComponent <CharacterController>();
player.stats.playerSpeed = 1.0f;
yield return(new WaitForEndOfFrame());
IUnityStaticService staticService = CreateUnityService(1, 1, 1);
player.staticService = staticService;
yield return(new WaitForFixedUpdate());
Assert.AreEqual(-0.1f, player.transform.rotation.y, 0.02f, "Player did not rotate in view direction on y axis!");
}
public IEnumerator Test_PlayerCannotMoveWhenGameIsOver()
{
Player player = CreatePlayer();
player.gameObject.AddComponent <CharacterController>();
player.stats.playerSpeed = 1.0f;
IUnityStaticService staticService = CreateUnityService(1, 1, 1);
player.staticService = staticService;
GameController gameCtr = CreateGameController(player);
gameCtr.gameEnded = true;
yield return(new WaitForFixedUpdate());
Assert.AreEqual(new Vector3(0, 0, 0), player.transform.position, "Player moved even though game was already over!");
}
public IEnumerator Test_PlayerMovesAlongXAxisForVerticalInput()
{
Player player = CreatePlayer();
player.gameObject.AddComponent <CharacterController>();
player.stats.playerSpeed = 1.0f;
IUnityStaticService staticService = CreateUnityService(1, 0, 1);
player.staticService = staticService;
float expectedPos = player.transform.position.x - player.stats.playerSpeed;
float tolerance = 0.01f;
yield return(new WaitForFixedUpdate());
Assert.AreEqual(expectedPos, player.transform.position.x, tolerance, "Player didn't move on x axis after vertical input!");
}
void Start()
{
if (staticService == null) // only setup staticServe anew if it's not there already (a playmode test might have set a substitute object here that we don't want to replace)
{
staticService = new UnityStaticService();
}
source = GetComponent <AudioSource>();
if (source != null)
{
source.clip = normalBgMusic;
source.volume = normalMusicVolume;
source.loop = true;
StartCoroutine(StartGame());
}
}
public IEnumerator Test_CanActAfterWaitingTurnTime()
{
Player player = CreatePlayer();
Enemy enemy = CreateEnemy();
IUnityStaticService staticService = CreateUnityService(player.stats.TurnTime, 0, 0);
player.staticService = staticService;
GameController gameCtr = CreateGameController(player);
yield return(new WaitForEndOfFrame());
enemy.GameCtr = gameCtr;
player.GameCtr = gameCtr;
gameCtr.StartBattle(enemy);
yield return(new WaitForEndOfFrame());
Assert.IsTrue(player.stats.CanAct(),
"Player wasn't able to attack after waiting their turn time!");
}
public IEnumerator Test_TurnTimeIsResetAfterCharging()
{
Player player = CreatePlayer();
Enemy enemy = CreateEnemy();
GameController GameCtr = CreateGameController(player);
IUnityStaticService staticService = CreateUnityService(player.stats.TurnTime, 0, 0);
player.staticService = staticService;
yield return(new WaitForEndOfFrame());
GameCtr.StartBattle(enemy);
yield return(new WaitForEndOfFrame());
Assert.IsTrue(player.stats.CanAct(), "Player wasn't allowed to act in the first place!");
player.stats.UseChargeForDamageBoost();
Assert.IsFalse(player.stats.CanAct(), "Player turn time did not reset after charging!");
}
public IEnumerator Test_TurnTimeIsResetAfterAttack()
{
Player player = CreatePlayer();
Enemy enemy = CreateEnemy();
GameController GameCtr = CreateGameController(player);
IUnityStaticService staticService = CreateUnityService(player.stats.TurnTime, 0, 0);
player.staticService = staticService;
yield return(new WaitForEndOfFrame());
GameCtr.StartBattle(enemy);
yield return(new WaitForEndOfFrame());
Assert.IsTrue(player.stats.CanAct(), "Player wasn't allowed to act in the first place!");
player.stats.AttackOpponent(enemy.stats, false, false);
Assert.IsFalse(player.stats.CanAct(), "Player turn time did not reset after their attack!");
}
public IEnumerator Test_PlayerCannotMoveUntilIntroIsOver()
{
Player player = CreatePlayer();
player.gameObject.AddComponent <CharacterController>();
GameController gameCtr = CreateGameController(player);
IUnityStaticService staticService = CreateUnityService(1, 1, 1);
player.staticService = staticService;
gameCtr.introPlaying = true;
yield return(new WaitForFixedUpdate());
Assert.AreEqual(new Vector3(0, 0, 0), player.transform.position, "Player moved even though intro wasn't over!");
gameCtr.introPlaying = false;
yield return(new WaitForFixedUpdate());
Assert.AreNotEqual(player.transform.position, new Vector3(0, 0, 0), "Player wasn't able to move even though intro was over!");
}
public IEnumerator Test_TurnTimeIsResetAfterTryingToFlee()
{
Player player = CreatePlayer();
Enemy enemy = CreateEnemy();
enemy.playerCanFlee = true;
enemy.playerFleeProbability = 0;
GameController GameCtr = CreateGameController(player);
IUnityStaticService staticService = CreateUnityService(player.stats.TurnTime, 0, 0);
player.staticService = staticService;
yield return(new WaitForEndOfFrame());
GameCtr.StartBattle(enemy);
yield return(new WaitForEndOfFrame());
Assert.IsTrue(player.stats.CanAct(), "Player wasn't allowed to act in the first place!");
GameCtr.PlayerTryFleeBattle();
Assert.IsFalse(player.stats.CanAct(), "Player turn time did not reset after their attack!");
}
