public void LotsOfPotionsTest()
{
var des = EquipmentKind.Weapon.ToDescription();
var env = CreateTestEnv();
//GenerationInfo.DebugInfo.EachEnemyGivesPotion = true;
try
{
var lootInfo = new LootInfo(game, null);
ILootSource lootSrc = ActiveEnemies.First();//env.Game.Hero
for (int i = 0; i < 10; i++)
{
var pot = env.LootGenerator.GetRandomLoot(LootKind.Potion, 1);
var added = game.GameManager.AddLootReward(pot, lootSrc, false);
Assert.True(added);
var dist = pot.DistanceFrom(lootSrc.GetPoint());
Assert.Less(dist, 5);
Assert.True(dist < 4 || i > 5);
}
var newLootItems = lootInfo.GetDiff();
Assert.AreEqual(newLootItems.Count, 10);
}
catch (System.Exception)
{
//GenerationInfo.DebugInfo.EachEnemyGivesPotion = false;
}
}
public void DamageFromEnemiesVaries(AttackKind attackKind)
{
var game = CreateGame();
var hero = game.Hero;
Assert.Greater(ActiveEnemies.Count, 0);
var enemy = ActiveEnemies.First();
var emp = game.Level.GetEmptyTiles().Where(i => i.DistanceFrom(hero) < 6 && i.DistanceFrom(hero) > 1).First();
game.Level.SetTile(enemy, emp.point);
//PlaceCloseToHero(enemy);
if (attackKind == AttackKind.Unset)
{
DoDamage(enemy, game.Hero, (LivingEntity attacker, LivingEntity victim) => { victim.OnMelleeHitBy(attacker); });
}
else if (attackKind == AttackKind.PhysicalProjectile)
{
var en = enemy as Enemy;
var fi = en.AddFightItem(FightItemKind.ThrowingKnife);
fi.Count = 10;
en.ActiveFightItem = fi as ProjectileFightItem;
DoDamage(enemy, game.Hero, (LivingEntity attacker, LivingEntity victim) => CallDoDamagePhysicalProjectile(attacker, victim));
}
//else if (attackKind == AttackKind.WeaponElementalProjectile)
//{
// healthChanges = DoDamage(game.Hero, enemy, (LivingEntity attacker, LivingEntity en) => CallDoDamageWeaponElementalProjectile(attacker, en));
//}
else if (attackKind == AttackKind.SpellElementalProjectile)
{
enemy.ActiveManaPoweredSpellSource = new Scroll(SpellKind.FireBall);
enemy.Stats.SetNominal(EntityStatKind.Mana, 1000);
DoDamage(enemy, game.Hero, (LivingEntity attacker, LivingEntity victim) => CallDoDamageSpellElementalProjectile(attacker, victim));
}
}
public void StunnedEffectFromWeapon()
{
var game = CreateGame();
var hero = game.Hero;
hero.Stats.SetNominal(Roguelike.Attributes.EntityStatKind.ChanceToMeleeHit, 100);
var wpn = GenerateEquipment <Weapon>("hammer");
wpn.MakeMagic(EntityStatKind.ChanceToCauseStunning, 100);
wpn.Identify();
SetHeroEquipment(wpn);
var ccs = hero.GetCurrentValue(EntityStatKind.ChanceToCauseStunning);
Assert.AreEqual(ccs, 100);
var enemy = ActiveEnemies.First();
enemy.OnMelleeHitBy(hero);
Assert.True(enemy.LastingEffects.Any());
Assert.AreEqual(enemy.LastingEffects[0].Type, EffectType.Stunned);
Assert.AreEqual(enemy.LastingEffects[0].Description, "Stunned");
GotoNextHeroTurn();
Assert.AreEqual(enemy.LastingEffects[0].Type, EffectType.Stunned);
GotoNextHeroTurn();
Assert.AreEqual(enemy.LastingEffects[0].Type, EffectType.Stunned);
GotoNextHeroTurn();
Assert.False(enemy.LastingEffects.Any());
}
public void TestLastingEffectDescription()
{
var game = CreateGame();
var en = ActiveEnemies.First();
var le = game.Hero.LastingEffectsSet.EnsureEffect(EffectType.Bleeding, 10, en);
Assert.NotNull(le);
var expectedDesc = le.Type.ToDescription() + ", -10,00 Health (per turn)";///game.Hero.Stats.Defense
var desc = le.Description;
Assert.AreEqual(desc, expectedDesc);
CheckDesc(EffectType.IronSkin, EntityStatKind.Defense, '+');
//CheckDesc(EffectType.Rage, EntityStatKind.Attack, '+');
CheckDesc(EffectType.Inaccuracy, EntityStatKind.ChanceToMeleeHit, '-');
CheckDesc(EffectType.Weaken, EntityStatKind.Defense, '-');
CheckDesc(EffectType.ResistAll, EntityStatKind.Unset, '+');
//le = game.Hero.LastingEffectsSet.AddLastingEffectFromSpell(EffectType.ResistAll, 3, EntityStatKind.Unset, 10);
//Assert.NotNull(le);
//expectedDesc = le.Type.ToDescription() + " +" + le.EffectiveFactor.EffectiveFactor;
//Assert.AreEqual(le.Description, expectedDesc);
//var calculated = new LastingEffectCalcInfo(EffectType.Bleeding, 3, new LastingEffectFactor(10));
//le = game.Hero.AddLastingEffect(calculated);
//Assert.NotNull(le);
//expectedDesc = le.Type.ToDescription() + " -" + le.EffectAbsoluteValue.Factor;
//Assert.AreEqual(le.GetDescription(game.Hero), expectedDesc);
}
// Start is called before the first frame update
void Awake()
{
if (instance == null)
{
instance = this;
}
enemiesList = new List <BaseAI>();
}
public void RemoveEnemy(Enemy enemy)
{
ActiveEnemies.Remove(enemy);
if (!WaveActive && !gameOver)
{
waveBtn.SetActive(true);
}
}
public void TestBleedingProlong()
{
var game = CreateGame();
int actionCounter = 0;
game.GameManager.EventsManager.ActionAppended += (object sender, Roguelike.Events.GameEvent e) =>
{
if (e is LivingEntityAction)
{
var lea = e as LivingEntityAction;
if (lea.Kind == LivingEntityActionKind.ExperiencedEffect)
{
if (lea.Info.Contains(EffectType.Bleeding.ToDescription()))
{
actionCounter++;
}
}
}
};
var enemy = ActiveEnemies.First();
var healthStat = enemy.Stats.GetStat(EntityStatKind.Health);
healthStat.Value.Nominal = 150;
enemy.SetIsWounded(true);//make sure will bleed
var wpn = game.GameManager.LootGenerator.GetLootByTileName <Weapon>("rusty_sword");
SetHeroEquipment(wpn);
enemy.OnMelleeHitBy(game.Hero);
var le1 = enemy.LastingEffects.Where(i => i.Type == EffectType.Bleeding).SingleOrDefault();
Assert.NotNull(le1);
LastingEffect castedAgain = null;
var value = game.Hero.Stats.GetStat(EntityStatKind.Defense).Value;
var turns = le1.PendingTurns;
var enemyHealth = enemy.Stats.Health;
for (int i = 0; i < turns * 2; i++)//there will be prolong
{
castedAgain = enemy.LastingEffects.Where(le => le.Type == EffectType.Bleeding).SingleOrDefault();
Assert.AreEqual(castedAgain, le1);
game.GameManager.SkipHeroTurn();
GotoNextHeroTurn();
if (i == 0)
{
enemy.OnMelleeHitBy(game.Hero);
}
}
Assert.Greater(enemyHealth, enemy.Stats.Health);
Assert.AreEqual(actionCounter, 5);
}
/// <summary>
/// Cleans up the enemy (resets attributes)
/// </summary>
/// <param name="enemy"></param>
public void CleanUp(GameObject enemy)
{
enemy.Transform.Position = new Vector2(100, 100);
lock (GameWorld.colliderKey)
{
((Collider)enemy.GetComponent("Collider")).DoCollsionChecks = false;
GameWorld.Instance.Colliders.Remove((Collider)enemy.GetComponent("Collider"));
}
((Animator)enemy.GetComponent("Animator")).PlayAnimation("Idle");
foreach (var component in enemy.GetComponentList)
{
if (component is Enemy)
{
var tmp = component as Enemy;
tmp.IsAlive = true;
tmp.CanRelease = true;
if (component is BasicEnemy)
{
tmp.Health = Constant.basicEnemyHealth;
}
if (component is BasicEliteEnemy)
{
tmp.Health = Constant.basicEliteEnemyHealth;
}
if (component is SwarmerEnemy)
{
tmp.Health = Constant.swarmerEnemyHealth;
}
if (component is SiegebreakerEnemy)
{
tmp.Health = Constant.siegeBreakerEnemyHealth;
}
if (component is Spitter)
{
tmp.Health = Constant.spitterHealth;
}
}
}
lock (activeKey)
{
ActiveEnemies.Remove(enemy);
}
InActiveEnemies.Add(enemy);
}
private Enemy CheckEnemyHit(BulletBase bullet)
{
var hitEnemy =
ActiveEnemies.FirstOrDefault(
x =>
(bullet.Left >= x.Left &&
bullet.Left <= x.Left + GameConfigurations.EnemyWidth)
&&
(bullet.Top >= x.Top &&
bullet.Top <= x.Top + GameConfigurations.EnemyHeight));
return(hitEnemy);
}
public void StoneFightItemTest()
{
var game = CreateGame();
var hero = game.Hero;
var fi = ActivateFightItem(FightItemKind.Stone, hero);
var enemy = ActiveEnemies.First();
var enemyHealth = enemy.Stats.Health;
var mana = hero.Stats.Mana;
Assert.True(game.GameManager.HeroTurn);
UseFightItem(hero, enemy, fi);
Assert.Greater(enemyHealth, enemy.Stats.Health);
Assert.AreEqual(mana, hero.Stats.Mana);
Assert.False(game.GameManager.HeroTurn);
}
/// <summary>
/// Adds the enemy to the queue or to the game depending on how many is in game already
/// </summary>
/// <param name="tmp"></param>
private void AddEnemy(GameObject tmp)
{
lock (activeKey)
{
if (activeEnemies.Count < Constant.maxEnemyOnScreen)
{
ActiveEnemies.Add(tmp);
}
else
{
lock (GameWorld.colliderKey)
{
((Collider)tmp.GetComponent("Collider")).DoCollsionChecks = false;
GameWorld.Instance.Colliders.Remove((Collider)tmp.GetComponent("Collider"));
}
enemiesWaitingToBeSpawned.Enqueue(tmp);
}
}
}
public void WeaponImpactTest()
{
var game = CreateGame();
var hero = game.Hero;
Assert.Greater(ActiveEnemies.Count, 0);
var enemy = ActiveEnemies.First();
var enemyHealth = enemy.Stats.Health;
enemy.OnMelleeHitBy(hero);
Assert.Greater(enemyHealth, enemy.Stats.Health);
enemyHealth = enemy.Stats.Health;
var wpn = GenerateRandomEqOnLevelAndCollectIt <Weapon>();
enemy.OnMelleeHitBy(hero);
Assert.Greater(enemyHealth, enemy.Stats.Health);
}
public void GemsLevel()
{
var env = CreateTestEnv();
try
{
var lootInfo = new LootInfo(game, null);
ILootSource lootSrc = ActiveEnemies.First();
for (int i = 0; i < 10; i++)
{
var loot = env.LootGenerator.GetRandomLoot(LootKind.Gem, 1) as Gem;
Assert.AreEqual(loot.EnchanterSize, EnchanterSize.Small);
}
}
catch (System.Exception)
{
//GenerationInfo.DebugInfo.EachEnemyGivesPotion = false;
}
}
private async void Fire(Object sender)
{
var bullet = GetInactiveBullet(PlayerBulletList);
if (bullet == null)
{
return;
}
await Task.Run(() =>
{
_dispatcherFunction(() => bullet.Left = GetBulletLeft());
while (bullet.Top > ScreenConfigurations.TopCorner)
{
_dispatcherFunction(bullet.Move);
var hitEnemy = CheckEnemyHit(bullet);
if (hitEnemy != null)
{
_dispatcherFunction(() =>
{
hitEnemy.Destroy();
bullet.Reset();
});
UpdateScore();
if (!ActiveEnemies.Any())
{
FinishGame(true);
}
return;
}
Thread.Sleep(GameConfigurations.BulletSpeed);
}
_dispatcherFunction(bullet.Reset);
});
}
public void SimpleSpellSourceTest(bool scroll)
{
var game = CreateGame();
var hero = game.Hero;
//SpellSource spellSource = scroll ? new Scroll ?
var enemy = ActiveEnemies.First();
var enemyHealth = enemy.Stats.Health;
var mana = hero.Stats.Mana;
Assert.True(game.GameManager.HeroTurn);
UseFireBallSpellSource(hero, enemy, scroll);
Assert.Greater(enemyHealth, enemy.Stats.Health);
Assert.Greater(mana, hero.Stats.Mana);
Assert.False(game.GameManager.HeroTurn);
var diff = enemyHealth - enemy.Stats.Health;
}
public void ArrowFightItemTest()
{
var game = CreateGame();
var hero = game.Hero;
hero.UseAttackVariation = false;//other tests do it
var fi = ActivateFightItem(FightItemKind.PlainArrow, hero);
var enemy = ActiveEnemies.First();
var enemyHealth = enemy.Stats.Health;
enemy.Stats.SetNominal(Roguelike.Attributes.EntityStatKind.Defense, 10);
var mana = hero.Stats.Mana;
Assert.True(game.GameManager.HeroTurn);
var bow = GenerateEquipment <Weapon>("Bow");
Assert.True(SetHeroEquipment(bow));
var tile = game.GameManager.CurrentNode.GetClosestEmpty(hero);
game.GameManager.CurrentNode.SetTile(enemy, tile.point);
Assert.True(UseFightItem(hero, enemy, fi));
Assert.Greater(enemyHealth, enemy.Stats.Health);
Assert.AreEqual(mana, hero.Stats.Mana);
Assert.False(game.GameManager.HeroTurn);
var diffBow = enemyHealth - enemy.Stats.Health;
enemyHealth = enemy.Stats.Health;
GotoNextHeroTurn();
fi = ActivateFightItem(FightItemKind.ThrowingKnife, hero);
Assert.True(UseFightItem(hero, enemy, fi));
Assert.Greater(enemyHealth, enemy.Stats.Health);
var diffKnife = enemyHealth - enemy.Stats.Health;
Assert.Greater(diffBow, diffKnife);
}
/*
* void OnGUI() {
* string label;
* if(Delay > -1) label = "Wave " + (CurWave + 1) + " in : " + 0.1f*(float)((int)(Mathf.Max(Delay, 0)*10.0f)) ;
* else if( CurWave+1 <=Waves.Count ) {
* label = "Wave " + (CurWave + 1) + " Enemies remaining : " + (Pool.Count + ActiveEnemies) +" "+Elap;
* } else return;
*
*
* GUI.Label(new Rect(30, 30, 200, 50), label );
* } */
void Update()
{
text.text = ActiveEnemies.ToString() + " Enemy Monsters left";
Delay -= Time.deltaTime;
Elap += Time.deltaTime;
if (Delay > -1)
{
if (Delay < 0)
{
var col = Color.white; col.a = 1 + Delay; col.a *= col.a;
// WaveGui.color = col;
}
}
else
{
// WaveGui.enabled = false;
}
}
public void TestLastingEffectAction()
{
var game = CreateGame();
game.Hero.Name = "Edd";
var en = ActiveEnemies.First();
var le = game.Hero.LastingEffectsSet.EnsureEffect(EffectType.Bleeding, 10, en);
Assert.NotNull(le);
var expectedDesc = le.Type.ToDescription() + ", -10,00 Health (per turn)";
var desc = le.Description;
Assert.AreEqual(desc, expectedDesc);
CheckActionDesc(EffectType.IronSkin, EntityStatKind.Defense, '+', game.Hero);
//CheckActionDesc(EffectType.Rage, EntityStatKind.Attack, '+', game.Hero);
CheckActionDesc(EffectType.Inaccuracy, EntityStatKind.ChanceToMeleeHit, '-', game.Hero);
CheckActionDesc(EffectType.Weaken, EntityStatKind.Defense, '-', game.Hero);
CheckActionDesc(EffectType.ResistAll, EntityStatKind.Unset, '+', game.Hero);
}
public void KillEnemy()
{
var game = CreateGame();
//var hero = game.Hero;
var enemies = game.GameManager.EnemiesManager.AllEntities;
var initEnemyCount = enemies.Count;
Assert.Greater(initEnemyCount, 0);
Assert.AreEqual(initEnemyCount, CurrentNode.GetTiles <Enemy>().Count);
var enemy = ActiveEnemies.First();
while (enemy.Alive)
{
InteractHeroWith(enemy as Enemy);
}
var finalEnemyCount = enemies.Count;
Assert.AreEqual(finalEnemyCount, initEnemyCount - 1);
Assert.AreEqual(finalEnemyCount, CurrentNode.GetTiles <Enemy>().Count);
}
public void TestHealthPotionConsume()
{
var game = CreateGame();
var hero = game.Hero;
Assert.Greater(ActiveEnemies.Count, 0);
var heroHealth = hero.Stats.Health;
var halfHealth = heroHealth / 2;
while (hero.Stats.Health > halfHealth)
{
hero.OnMelleeHitBy(ActiveEnemies.First());
}
Assert.Greater(heroHealth, hero.Stats.Health);
heroHealth = hero.Stats.Health;
var hp = Helper.AddTile <Potion>();
hp.SetKind(PotionKind.Health);
AddItemToInv(hp);
hero.Consume(hp);
Assert.Greater(hero.Stats.Health, heroHealth);
}
private IEnumerator SpawnWave()
{
Random rand = new Random();
int intervalSoldier1 = 100;
int intervalSoldier2 = 0;
int intervalDogs = 0;
int intervalTanks = 0;
int intervalAirplanes = 0;
if (wave >= 5)
{
intervalSoldier2 = intervalSoldier1;
intervalSoldier1 -= 20;
if (wave >= 7)
{
intervalDogs = intervalSoldier2;
intervalSoldier1 -= 15;
intervalSoldier2 -= 15;
}
if (wave >= 15)
{
intervalTanks = intervalDogs;
intervalSoldier1 -= 10;
intervalSoldier2 -= 10;
intervalDogs -= 10;
}
if (wave >= 20)
{
intervalAirplanes = intervalTanks;
intervalSoldier1 -= 10;
intervalSoldier2 -= 10;
intervalDogs -= 10;
intervalTanks -= 10;
}
}
int total = wave + (wave / 5) + (wave / 7) + (wave / 10) + (wave / 15);
/*
* // figure out the total amount of enemies
* int numSoldiers1 = wave;
* int numSoldiers2 = wave / 5;
* int numDogs = wave / 7;
* int numTanks = wave / 10;
* int numAirplanes;
* if(wave < 20) {
* numAirplanes = 0;
* }
* else {
* numAirplanes = wave / 15;
* }
*
*
* int total;
* if(wave > 5) {
* total = numSoldiers1 + numSoldiers2 + numDogs + numTanks + numAirplanes;
* }
* else {
* total = numSoldiers1;
* }
*
* List<string> types = new List<string>();
* for(int i = 0; i < numSoldiers1; i++) {
* types.Add("soldier");
* }
* for(int i = 0; i < numSoldiers2; i++) {
* types.Add("soldier2");
* }
* for (int i = 0; i < numDogs; i++) {
* types.Add("Dog");
* }
* for (int i = 0; i < numTanks; i++) {
* // add variablilty between black and red
* float num = Random.Range(0, 2);
* if(num <= .5f) {
* types.Add("tankRed");
* }
* else {
* types.Add("tankBlack");
* }
*
* }
*
* for(int i = 0; i < numAirplanes; i++) {
* types.Add("airplane");
* }
*
* Shuffle(types);
*/
for (int i = 0; i < total; i++)
{
//string type = types[i];
string type = getTypeFromDistribution(intervalSoldier1, intervalSoldier2, intervalDogs, intervalTanks, intervalAirplanes);
// get an enemy from the pool
Debug.Log("Spawning: " + type);
Enemy monster = Pool.GetObject(type).GetComponent <Enemy>();
monster.Spawn(LevelManager.Instance.PortalSpawn, LevelManager.Instance.GoalSpawn);
ActiveEnemies.Add(monster);
yield return(new WaitForSeconds(timeBetweenEnemies));
}
}
