public void PoisonBiteAbilityUnitTest() { Player player = new Player("test", PlayerClassType.Mage) { HitPoints = 100, MaxHitPoints = 100 }; OutputHelper.Display.ClearUserOutput(); Monster monster = new Monster(3, MonsterType.Spider) { HitPoints = 50, MaxHitPoints = 100 }; MonsterBuilder.BuildMonster(monster); int abilityIndex = monster.Abilities.FindIndex( f => f.AbilityCategory == Ability.PoisonBite); foreach (IItem item in player.Inventory.Where(item => item is IEquipment eItem && eItem.Equipped)) { IEquipment eItem = item as IEquipment; eItem.Equipped = false; } monster.Abilities[abilityIndex].UseOffenseDamageAbility(monster, player, abilityIndex); int abilityCost = monster.Abilities[abilityIndex].EnergyCost; Assert.AreEqual(monster.MaxEnergyPoints - abilityCost, monster.EnergyPoints); int abilityDamage = monster.Abilities[abilityIndex].Offensive.Amount; int abilityDamageOverTime = monster.Abilities[abilityIndex].Offensive.AmountOverTime; int abilityCurRounds = monster.Abilities[abilityIndex].Offensive.AmountCurRounds; int abilityMaxRounds = monster.Abilities[abilityIndex].Offensive.AmountMaxRounds; string attackString = $"The {monster.Name} tries to bite you!"; Assert.AreEqual(attackString, OutputHelper.Display.Output[0][2]); string attackSuccessString = $"The {monster.Name} bites you for {abilityDamage} physical damage."; Assert.AreEqual(attackSuccessString, OutputHelper.Display.Output[1][2]); string bleedString = $"You are bleeding from {monster.Name}'s attack!"; Assert.AreEqual(bleedString, OutputHelper.Display.Output[2][2]); Assert.AreEqual(true, player.Effects[0] is BleedingEffect); Assert.AreEqual(player.MaxHitPoints - abilityDamage, player.HitPoints); Assert.AreEqual(abilityCurRounds, player.Effects[0].CurrentRound); Assert.AreEqual(abilityMaxRounds, player.Effects[0].MaxRound); OutputHelper.Display.ClearUserOutput(); BleedingEffect bleedEffect = player.Effects[0] as BleedingEffect; for (int i = 2; i < 5; i++) { bleedEffect.ProcessRound(); int bleedAmount = bleedEffect.BleedDamageOverTime; string bleedRoundString = $"You bleed for {bleedAmount} physical damage."; Assert.AreEqual(bleedRoundString, OutputHelper.Display.Output[i - 2][2]); Assert.AreEqual(i, player.Effects[0].CurrentRound); GameHelper.RemovedExpiredEffectsAsync(player); Thread.Sleep(1000); } Assert.AreEqual(false, player.Effects.Any()); Assert.AreEqual(player.MaxHitPoints - abilityDamage - (abilityDamageOverTime * abilityMaxRounds), player.HitPoints); }
public GameObject handleTowerCanvasGo;//处理塔的画布 private void Awake() { #if Game _instance = this; mGameManager = GameManager.Instance; mCurrentStage = mGameManager.CurrentStage; //normalModelPanel = mGameManager.uiManager.mUIFacade.currentScenePanelDict[StringManager.NormalModelPanel] as NormalModelPanel; mapMaker = GetComponent <MapMaker>(); mapMaker.InitMapMaker(); //mapMaker.LoadMap(mCurrentStage.mBigLevelID, mCurrentStage.mLevelID); mapMaker.LoadMap(1, 3); GameSpeed = 1; monsterBuilder = new MonsterBuilder(); mLevel = new Level(mapMaker.roundInfoList.Count, mapMaker.roundInfoList); mLevel.HandleRound(); AnimControllers = new RuntimeAnimatorController[12]; for (int i = 0; i < AnimControllers.Length; i++) { AnimControllers[i] = GetRuntimeAnimatorController("Monster/" + mapMaker.bigLevelID.ToString() + "/" + (i + 1).ToString()); } #endif }
public void TailWhipAbilityUnitTest() { Player player = new Player("test", PlayerClassType.Mage) { HitPoints = 200, MaxHitPoints = 200 }; OutputHelper.Display.ClearUserOutput(); Monster monster = new Monster(3, MonsterType.Dragon); MonsterBuilder.BuildMonster(monster); int abilityIndex = monster.Abilities.FindIndex( f => f.AbilityCategory == Ability.TailWhip); foreach (IItem item in player.Inventory.Where(item => item is IEquipment eItem && eItem.Equipped)) { IEquipment eItem = item as IEquipment; eItem.Equipped = false; } monster.Abilities[abilityIndex].UseOffenseDamageAbility(monster, player, abilityIndex); int abilityCost = monster.Abilities[abilityIndex].EnergyCost; Assert.AreEqual(monster.MaxEnergyPoints - abilityCost, monster.EnergyPoints); int attackDamage = monster.Abilities[abilityIndex].Offensive.Amount; Assert.AreEqual(player.MaxHitPoints - attackDamage, player.HitPoints); string attackString = $"The {monster.Name} swings its tail at you!"; Assert.AreEqual(attackString, OutputHelper.Display.Output[0][2]); string attackSuccessString = $"The {monster.Name} strikes you with its tail for {attackDamage} physical damage."; Assert.AreEqual(attackSuccessString, OutputHelper.Display.Output[1][2]); }
public void PlayerResistanceUnitTest() { Player player = new Player("test", PlayerClassType.Mage) { MaxManaPoints = 100, ManaPoints = 100 }; GearHelper.EquipInitialGear(player); OutputHelper.Display.ClearUserOutput(); Monster monster = new Monster(3, MonsterType.Elemental); while (monster.ElementalCategory != ElementalType.Air) { monster = new Monster(3, MonsterType.Elemental); } MonsterBuilder.BuildMonster(monster); foreach (IItem item in monster.MonsterItems.Where(item => item is IEquipment eItem && eItem.Equipped)) { IEquipment eItem = item as IEquipment; eItem.Equipped = false; } Assert.AreEqual(player.Level * 5, player.FireResistance); Assert.AreEqual(player.Level * 5, player.FrostResistance); Assert.AreEqual(player.Level * 5, player.ArcaneResistance); int arcaneResistance = player.ArcaneResistance; double resistanceMod = (100 - arcaneResistance) / 100.0; int spellIndex = monster.Spellbook.FindIndex( f => f.SpellCategory == SpellType.Lightning); monster.Spellbook[spellIndex].CastArcaneOffense(monster, player, spellIndex); int reducedDamage = (int)(monster.Spellbook[spellIndex].Offensive.Amount * resistanceMod); Assert.AreEqual(player.HitPoints, player.MaxHitPoints - reducedDamage); }
public void WarCryAbilityUnitTest() { OutputHelper.Display.ClearUserOutput(); Player player = new Player("test", PlayerClassType.Warrior) { MaxRagePoints = 100, RagePoints = 100, InCombat = true }; player.Abilities.Add(new PlayerAbility( "war cry", 50, 1, WarriorAbility.WarCry, 4)); Monster monster = new Monster(3, MonsterType.Demon) { HitPoints = 100, MaxHitPoints = 100 }; MonsterBuilder.BuildMonster(monster); int abilityIndex = player.Abilities.FindIndex( f => f.WarAbilityCategory == WarriorAbility.WarCry); string[] inputInfo = new[] { "ability", "war", "cry" }; PlayerHelper.AbilityInfo(player, inputInfo); Assert.AreEqual("War Cry", OutputHelper.Display.Output[0][2]); Assert.AreEqual("Rank: 1", OutputHelper.Display.Output[1][2]); Assert.AreEqual("Rage Cost: 50", OutputHelper.Display.Output[2][2]); Assert.AreEqual("War Cry Amount: 25", OutputHelper.Display.Output[3][2]); Assert.AreEqual("Opponent's attacks are decreased by 25 for 3 rounds.", OutputHelper.Display.Output[4][2]); string[] input = new[] { "use", "war", "cry" }; string abilityName = InputHelper.ParseInput(input); Assert.AreEqual("war cry", abilityName); player.UseAbility(input); int?rageCost = player.Abilities[abilityIndex].RageCost; Assert.AreEqual(player.MaxRagePoints - rageCost, player.RagePoints); Assert.AreEqual("You shout a War Cry, intimidating your opponent, and decreasing incoming damage.", OutputHelper.Display.Output[5][2]); OutputHelper.Display.ClearUserOutput(); Assert.AreEqual(true, player.Effects[0] is ChangeMonsterDamageEffect); ChangeMonsterDamageEffect changeMonsterDmgEffect = player.Effects[0] as ChangeMonsterDamageEffect; for (int i = 2; i < 5; i++) { int baseAttackDamageM = monster.UnarmedAttackDamage; int attackDamageM = baseAttackDamageM; int changeDamageAmount = changeMonsterDmgEffect.ChangeAmount < attackDamageM ? changeMonsterDmgEffect.ChangeAmount : attackDamageM; attackDamageM -= changeDamageAmount; Assert.AreEqual(baseAttackDamageM - changeDamageAmount, attackDamageM); changeMonsterDmgEffect.ProcessChangeMonsterDamageRound(player); string changeDmgString = $"Incoming damage is decreased by {-1 * changeMonsterDmgEffect.ChangeAmount}."; Assert.AreEqual(i, player.Effects[0].CurrentRound); Assert.AreEqual(changeDmgString, OutputHelper.Display.Output[i - 2][2]); } GameHelper.RemovedExpiredEffectsAsync(player); Thread.Sleep(1000); Assert.AreEqual(false, player.Effects.Any()); }
public void DoubleShotAbilityUnitTest() { Player player = new Player("test", PlayerClassType.Archer) { MaxComboPoints = 100, ComboPoints = 100, MaxHitPoints = 100, HitPoints = 10 }; GearHelper.EquipInitialGear(player); OutputHelper.Display.ClearUserOutput(); Monster monster = new Monster(3, MonsterType.Demon) { HitPoints = 100, MaxHitPoints = 100, InCombat = true }; MonsterBuilder.BuildMonster(monster); int abilityIndex = player.Abilities.FindIndex( f => f.ArcAbilityCategory == ArcherAbility.Double); string[] inputInfo = new[] { "ability", "double" }; PlayerHelper.AbilityInfo(player, inputInfo); Assert.AreEqual("Double Shot", OutputHelper.Display.Output[0][2]); Assert.AreEqual("Rank: 1", OutputHelper.Display.Output[1][2]); Assert.AreEqual("Combo Cost: 25", OutputHelper.Display.Output[2][2]); Assert.AreEqual("Instant Damage: 25", OutputHelper.Display.Output[3][2]); Assert.AreEqual( "Two arrows are fired which each cause instant damage. Cost and damage are per arrow.", OutputHelper.Display.Output[4][2]); string[] input = new[] { "use", "double" }; string abilityName = InputHelper.ParseInput(input); Assert.AreEqual("double", abilityName); int arrowCount = player.PlayerQuiver.Quantity; player.UseAbility(monster, input); Assert.AreEqual(arrowCount - 2, player.PlayerQuiver.Quantity); int?comboCost = player.Abilities[abilityIndex].ComboCost; int hitAmount = player.Abilities[abilityIndex].Offensive.Amount; Assert.AreEqual(monster.MaxHitPoints - (2 * hitAmount), monster.HitPoints); Assert.AreEqual(player.MaxComboPoints - (2 * comboCost), player.ComboPoints); string attackString = $"Your double shot hit the {monster.Name} for 25 physical damage."; Assert.AreEqual(attackString, OutputHelper.Display.Output[5][2]); Assert.AreEqual(attackString, OutputHelper.Display.Output[6][2]); player.MaxComboPoints = 25; player.ComboPoints = player.MaxComboPoints; monster.MaxHitPoints = 100; monster.HitPoints = monster.MaxHitPoints; arrowCount = player.PlayerQuiver.Quantity; player.UseAbility(monster, input); Assert.AreEqual(arrowCount - 1, player.PlayerQuiver.Quantity); Assert.AreEqual(player.MaxComboPoints - comboCost, player.ComboPoints); Assert.AreEqual(attackString, OutputHelper.Display.Output[7][2]); const string outOfComboString = "You didn't have enough combo points for the second shot!"; Assert.AreEqual(outOfComboString, OutputHelper.Display.Output[8][2]); }
public Form1() { InitializeComponent(); //instatiate required workers UIworker = new MonsterPrinter(); //List of picture boxs to print to outputImageBoxeList = new List<PictureBox>() { pbhead, pbbody, pbLegs }; //list of avaliable monsters to choose parts from comboBoxList = new List<string>() { "Fairy", "Frankenstein","Skeleton","Vampire","Werewolf","Witch" }; //Populate combo boxes populateComboBox(cbhead, comboBoxList); populateComboBox(cbbody, comboBoxList); populateComboBox(cblegs, comboBoxList); headWorker = new HeadFactory(); bodyWorker = new BodyFactory(); legsWorker = new Legfactory(); //Set initial monster on form monsterbuilderWorker = new MonsterBuilder(headWorker.requiredpart(cbhead.SelectedIndex),bodyWorker.requiredpart(cbbody.SelectedIndex),legsWorker.requiredpart(cblegs.SelectedIndex)); UIworker.printMonster(outputImageBoxeList, monsterbuilderWorker); }
public void FireballSpellUnitTest() { Player player = new Player("test", PlayerClassType.Mage) { MaxManaPoints = 100, ManaPoints = 100, InCombat = true }; GearHelper.EquipInitialGear(player); OutputHelper.Display.ClearUserOutput(); Monster monster = new Monster(3, MonsterType.Demon) { HitPoints = 50, MaxHitPoints = 100, FireResistance = 0 }; MonsterBuilder.BuildMonster(monster); player.PlayerWeapon.CritMultiplier = 1; // Remove crit chance to remove "noise" in test string[] inputInfo = new[] { "spell", "fireball" }; int spellIndex = player.Spellbook.FindIndex( f => f.SpellCategory == SpellType.Fireball); PlayerHelper.SpellInfo(player, inputInfo); Assert.AreEqual("Fireball", OutputHelper.Display.Output[0][2]); Assert.AreEqual("Rank: 1", OutputHelper.Display.Output[1][2]); Assert.AreEqual("Mana Cost: 35", OutputHelper.Display.Output[2][2]); Assert.AreEqual("Instant Damage: 25", OutputHelper.Display.Output[3][2]); Assert.AreEqual("Damage Over Time: 5", OutputHelper.Display.Output[4][2]); Assert.AreEqual("Fire damage over time will burn for 3 rounds.", OutputHelper.Display.Output[5][2]); OutputHelper.Display.ClearUserOutput(); string[] input = new[] { "cast", "fireball" }; string spellName = InputHelper.ParseInput(input); Assert.AreEqual("fireball", spellName); player.CastSpell(monster, spellName); Assert.AreEqual(player.MaxManaPoints - player.Spellbook[spellIndex].ManaCost, player.ManaPoints); Assert.AreEqual(25, monster.HitPoints); Assert.AreEqual(3, monster.Effects[0].MaxRound); Assert.AreEqual($"You hit the {monster.Name} for {player.Spellbook[spellIndex].Offensive.Amount} fire damage.", OutputHelper.Display.Output[0][2]); Assert.AreEqual($"The {monster.Name} bursts into flame!", OutputHelper.Display.Output[1][2]); BurningEffect burnEffect = monster.Effects[0] as BurningEffect; for (int i = 2; i < 5; i++) { burnEffect.ProcessRound(); Assert.AreEqual( $"The {monster.Name} burns for {burnEffect.FireDamageOverTime} fire damage.", OutputHelper.Display.Output[i][2]); Assert.AreEqual(i, monster.Effects[0].CurrentRound); GameHelper.RemovedExpiredEffectsAsync(monster); Thread.Sleep(1000); } Assert.AreEqual(false, monster.Effects.Any()); Assert.AreEqual(10, monster.HitPoints); }
public void FirebreathSpellUnitTest() { Player player = new Player("test", PlayerClassType.Mage) { HitPoints = 200, MaxHitPoints = 200, FireResistance = 0 }; OutputHelper.Display.ClearUserOutput(); Monster monster = new Monster(3, MonsterType.Dragon); MonsterBuilder.BuildMonster(monster); int spellIndex = monster.Spellbook.FindIndex( f => f.SpellCategory == SpellType.Fireball); foreach (IItem item in monster.MonsterItems.Where(item => item is IEquipment eItem && eItem.Equipped)) { IEquipment eItem = item as IEquipment; eItem.Equipped = false; } monster.MonsterWeapon.CritMultiplier = 1; // Remove crit chance to remove "noise" in test monster.Spellbook[spellIndex].CastFireOffense(monster, player, spellIndex); int spellCost = monster.Spellbook[spellIndex].EnergyCost; Assert.AreEqual(monster.MaxEnergyPoints - spellCost, monster.EnergyPoints); int spellDamage = monster.Spellbook[spellIndex].Offensive.Amount; Assert.AreEqual(player.MaxHitPoints - spellDamage, player.HitPoints); int spellMaxRounds = monster.Spellbook[spellIndex].Offensive.AmountMaxRounds; Assert.AreEqual(spellMaxRounds, player.Effects[0].MaxRound); string attackString = $"The {monster.Name} breathes a pillar of fire at you!"; Assert.AreEqual(attackString, OutputHelper.Display.Output[0][2]); string attackSuccessString = $"The {monster.Name} hits you for {spellDamage} fire damage."; Assert.AreEqual(attackSuccessString, OutputHelper.Display.Output[1][2]); const string onFireString = "You burst into flame!"; Assert.AreEqual(onFireString, OutputHelper.Display.Output[2][2]); Assert.AreEqual(true, player.Effects[0] is BurningEffect); int burnDamage = monster.Spellbook[spellIndex].Offensive.AmountOverTime; BurningEffect burnEffect = player.Effects[0] as BurningEffect; for (int i = 2; i < 5; i++) { burnEffect.ProcessRound(); string burnString = $"You burn for {burnDamage} fire damage."; Assert.AreEqual(burnString, OutputHelper.Display.Output[i + 1][2]); Assert.AreEqual(i, player.Effects[0].CurrentRound); GameHelper.RemovedExpiredEffectsAsync(player); Thread.Sleep(1000); } Assert.AreEqual(false, player.Effects.Any()); Assert.AreEqual(player.MaxHitPoints - spellDamage - (burnDamage * 3), player.HitPoints); }
public void OnslaughtAbilityUnitTest() { OutputHelper.Display.ClearUserOutput(); Player player = new Player("test", PlayerClassType.Warrior) { MaxRagePoints = 100, RagePoints = 100, InCombat = true }; player.Abilities.Add(new PlayerAbility( "onslaught", 25, 1, WarriorAbility.Onslaught, 8)); Monster monster = new Monster(3, MonsterType.Demon) { HitPoints = 100, MaxHitPoints = 100, InCombat = true }; MonsterBuilder.BuildMonster(monster); int abilityIndex = player.Abilities.FindIndex( f => f.WarAbilityCategory == WarriorAbility.Onslaught); string[] inputInfo = new[] { "ability", "onslaught" }; PlayerHelper.AbilityInfo(player, inputInfo); Assert.AreEqual("Onslaught", OutputHelper.Display.Output[0][2]); Assert.AreEqual("Rank: 1", OutputHelper.Display.Output[1][2]); Assert.AreEqual("Rage Cost: 25", OutputHelper.Display.Output[2][2]); Assert.AreEqual("Instant Damage: 25", OutputHelper.Display.Output[3][2]); Assert.AreEqual( "Two attacks are launched which each cause instant damage. Cost and damage are per attack.", OutputHelper.Display.Output[4][2]); string[] input = new[] { "use", "onslaught" }; string abilityName = InputHelper.ParseInput(input); Assert.AreEqual("onslaught", abilityName); player.UseAbility(monster, input); int?rageCost = player.Abilities[abilityIndex].RageCost; int hitAmount = player.Abilities[abilityIndex].Offensive.Amount; Assert.AreEqual(monster.MaxHitPoints - (2 * hitAmount), monster.HitPoints); Assert.AreEqual(player.MaxRagePoints - (2 * rageCost), player.RagePoints); string attackString = $"Your onslaught hit the {monster.Name} for 25 physical damage."; Assert.AreEqual(attackString, OutputHelper.Display.Output[5][2]); Assert.AreEqual(attackString, OutputHelper.Display.Output[6][2]); player.MaxRagePoints = 25; player.RagePoints = player.MaxRagePoints; monster.MaxHitPoints = 100; monster.HitPoints = monster.MaxHitPoints; player.UseAbility(monster, input); Assert.AreEqual(player.MaxRagePoints - rageCost, player.RagePoints); Assert.AreEqual(attackString, OutputHelper.Display.Output[7][2]); const string outOfRageString = "You didn't have enough rage points for the second attack!"; Assert.AreEqual(outOfRageString, OutputHelper.Display.Output[8][2]); }
private void Awake() { #if Game _instance = this; mGameManager = GameManager.Instance; //测试代码:currentStage = new Stage(1, 1,new int[]{ 1,2,3,4,5},5,0,10,true,false,false); currentStage = mGameManager.currentStage; normalModelPanel = mGameManager.uiManager.mUIFacade.currentScenePanelDict[StringManager.NormalModelPanel] as NormalModelPanel; normalModelPanel.EnterPanel(); mapMaker = GetComponent <MapMaker>(); mapMaker.InitMapMaker(); mapMaker.LoadMap(currentStage.mBigLevelID, currentStage.mLevelID); //为什么要这样写呢?因为可以在进来的时候把资源都加载一次放进数组里面,以后直接拿就好了,不要每次都问工厂要,加载要时间 controllers = new RuntimeAnimatorController[12]; //mapMaker.LoadMap(2, 1); //成员变量赋值 coin = 1000; gameSpeed = 1; monsterBuilder = new MonsterBuilder(); towerBuilder = new TowerBuilder(); //建塔列表的处理 for (int i = 0; i < currentStage.mTowerIDList.Length; i++) { GameObject itemGo = GameManager.Instance.GetGameObjectResource(FactoryType.UIFactory, "Btn_TowerBuild"); itemGo.GetComponent <ButtonTower>().towerID = currentStage.mTowerIDList[i];//把关卡可以建造的箭塔ID赋值过来 itemGo.transform.localPosition = transform.position; itemGo.transform.SetParent(towerListGo.transform); itemGo.transform.localScale = Vector3.one; } //箭塔价格标 towerPriceDict = new Dictionary <int, int> { { 1, 100 }, { 2, 120 }, { 3, 140 }, { 4, 160 }, { 5, 160 } }; //monsterBuilder.m_monsterID = 1; for (int i = 0; i < controllers.Length; i++) { controllers[i] = GetRuntimeAnimatorController("Monster/" + mapMaker.bigLevelID.ToString() + "/" + (i + 1).ToString()); } level = new Level(mapMaker.roundInfoList.Count, mapMaker.roundInfoList); normalModelPanel.topPage.UpdateCoinText(); normalModelPanel.topPage.UpdateRoundCount(); isPause = true; //level.HandleRound();//执行责任链方法,注释掉是因为要在倒计时完毕以后调用这个方法 #endif }
[HideInInspector] public int gameSpeed; // 游戏速度(一倍速,二倍速) private void Awake() { #if Game // 一些引用的赋值 Instance = this; mGameManager = GameManager.Instance; currentStage = mGameManager.CurrentStage; normalModelPanel = mGameManager.UIManager.mUIFacade.currentScenePanelDict[StringManager.P_NormalModelPanel] as NormalModelPanel; mapMaker = GetComponent <MapMaker>(); mapMaker.InitMapMaker(); mapMaker.Loadmap(currentStage.bigLevelID, currentStage.levelID); // 加载地图 level = new Level(mapMaker.roundInfoList.Count, mapMaker.roundInfoList); // 获取加载完地图中怪物波次的信息 monsterBuilder = new MonsterBuilder(); towerBuilder = new TowerBuilder(); // 玩家属性的赋值 gameSpeed = 1; Coin = 500; isPause = true; gameOver = false; normalModelPanel.EnterPanel(); // RuntimeAnimatorController资源的赋值 controllers = new RuntimeAnimatorController[12]; for (int i = 0; i < controllers.Length; i++) { controllers[i] = GetRuntimeAnimator("Monster/" + currentStage.bigLevelID.ToString() + "/" + (i + 1)); } // 建塔列表的赋值 for (int i = 0; i < currentStage.towerIDList.Length; i++) { GameObject item = mGameManager.GetItem(FactoryType.UI, "Btn_TowerBuilder"); item.GetComponent <ButtonTower>().towerID = currentStage.towerIDList[i]; item.transform.SetParent(towerListCanvas.transform); item.transform.localPosition = Vector3.zero; item.transform.localScale = Vector3.one; } // 建塔列表的价格赋值 towerPriceList = new Dictionary <int, int>() { { 1, 100 }, { 2, 120 }, { 3, 160 }, { 4, 160 }, { 5, 160 }, }; #endif }
public GameObject handleTowerCanvasGo; //处理塔升级与买卖的画布 private void Awake() { #if Game _instance = this; mGameManager = GameManager.Instance; //测试代码 //currentStage = new Stage(10,5,new int[] { 1,2,3,4,5},false,0,1,1,true,false); currentStage = mGameManager.currentStage; normalModelpanel = mGameManager.uiManager.mUIFacade.currentScenePanelDict[StringManager.NormalModelPanel] as NormalModelPanel; normalModelpanel.EnterPanel(); mapMaker = GetComponent <MapMaker>(); mapMaker.InitMapMaker(); mapMaker.LoadMap(currentStage.mBigLevelID, currentStage.mLevelID); //成员变量赋值 gameSpeed = 1; coin = 1000; monsterBuilder = new MonsterBuilder(); towerBuilder = new TowerBuilder(); //建塔列表的处理 for (int i = 0; i < currentStage.mTowerIDList.Length; i++) { GameObject itemGo = mGameManager.GetGameObjectResource(FactoryType.UIFactory, "Btn_TowerBuild"); itemGo.transform.GetComponent <ButtonTower>().towerID = currentStage.mTowerIDList[i]; itemGo.transform.SetParent(towerListGo.transform); itemGo.transform.localPosition = Vector3.zero; itemGo.transform.localScale = Vector3.one; } //建塔价格表 towerPriceDict = new Dictionary <int, int> { { 1, 100 }, { 2, 120 }, { 3, 140 }, { 4, 160 }, { 5, 160 } }; controllers = new RuntimeAnimatorController[12]; for (int i = 0; i < controllers.Length; i++) { controllers[i] = GetRuntimeAnimatorController("Monster/" + mapMaker.bigLevelID.ToString() + "/" + (i + 1).ToString()); } level = new Level(mapMaker.roundInfoList.Count, mapMaker.roundInfoList); normalModelpanel.topPage.UpdateCoinText(); normalModelpanel.topPage.UpdateRoundText(); //level.HandleRound(); isPause = true; #endif }
public void PreciseShotAbilityUnitTest() { Player player = new Player("test", PlayerClassType.Archer) { MaxComboPoints = 100, ComboPoints = 100, MaxHitPoints = 100, HitPoints = 10 }; GearHelper.EquipInitialGear(player); OutputHelper.Display.ClearUserOutput(); Monster monster = new Monster(3, MonsterType.Demon) { HitPoints = 100, MaxHitPoints = 100 }; MonsterBuilder.BuildMonster(monster); foreach (IItem item in monster.MonsterItems.Where(item => item is IEquipment eItem && eItem.Equipped)) { IEquipment eItem = item as IEquipment; eItem.Equipped = false; } string[] inputInfo = new[] { "ability", "precise" }; int abilityIndex = player.Abilities.FindIndex( f => f.ArcAbilityCategory == ArcherAbility.Precise); PlayerHelper.AbilityInfo(player, inputInfo); Assert.AreEqual("Precise Shot", OutputHelper.Display.Output[0][2]); Assert.AreEqual("Rank: 1", OutputHelper.Display.Output[1][2]); Assert.AreEqual("Combo Cost: 40", OutputHelper.Display.Output[2][2]); Assert.AreEqual("Instant Damage: 50", OutputHelper.Display.Output[3][2]); string[] input = new[] { "use", "precise" }; string abilityName = InputHelper.ParseInput(input); Assert.AreEqual("precise", abilityName); int arrowCount = player.PlayerQuiver.Quantity; player.UseAbility(monster, input); Assert.AreEqual(arrowCount - 1, player.PlayerQuiver.Quantity); int?comboCost = player.Abilities[abilityIndex].ComboCost; Assert.AreEqual(player.MaxComboPoints - comboCost, player.ComboPoints); int abilityDamage = player.Abilities[abilityIndex].Offensive.Amount; Assert.AreEqual(monster.HitPoints, monster.MaxHitPoints - abilityDamage); string abilitySuccessString = $"Your {player.Abilities[abilityIndex].Name} hit the {monster.Name} for {abilityDamage} physical damage."; Assert.AreEqual(abilitySuccessString, OutputHelper.Display.Output[4][2]); }
public void DisarmAbilityUnitTest() { Player player = new Player("test", PlayerClassType.Warrior) { MaxRagePoints = 100, RagePoints = 100, MaxHitPoints = 100, HitPoints = 100 }; GearHelper.EquipInitialGear(player); OutputHelper.Display.ClearUserOutput(); Monster monster = new Monster(3, MonsterType.Demon) { HitPoints = 100, MaxHitPoints = 100 }; MonsterBuilder.BuildMonster(monster); int abilityIndex = player.Abilities.FindIndex( f => f.WarAbilityCategory == WarriorAbility.Disarm); string[] inputInfo = new[] { "ability", "disarm" }; PlayerHelper.AbilityInfo(player, inputInfo); Assert.AreEqual("Disarm", OutputHelper.Display.Output[0][2]); Assert.AreEqual("Rank: 1", OutputHelper.Display.Output[1][2]); Assert.AreEqual("Rage Cost: 25", OutputHelper.Display.Output[2][2]); string abilityString = $"{player.Abilities[abilityIndex].Offensive.Amount}% chance to disarm opponent's weapon."; Assert.AreEqual(abilityString, OutputHelper.Display.Output[3][2]); player.Abilities[abilityIndex].Offensive.Amount = 0; // Set disarm success chance to 0% for test string[] input = new[] { "use", "disarm" }; string abilityName = InputHelper.ParseInput(input); Assert.AreEqual("disarm", abilityName); player.UseAbility(monster, input); int?rageCost = player.Abilities[abilityIndex].RageCost; Assert.AreEqual(player.MaxRagePoints - rageCost, player.RagePoints); Assert.AreEqual(true, monster.MonsterWeapon.Equipped); string disarmFailString = $"You tried to disarm {monster.Name} but failed!"; Assert.AreEqual(disarmFailString, OutputHelper.Display.Output[4][2]); player.Abilities[abilityIndex].Offensive.Amount = 100; // Set disarm success chance to 100% for test player.UseAbility(monster, input); Assert.AreEqual(player.MaxRagePoints - (rageCost * 2), player.RagePoints); Assert.AreEqual(false, monster.MonsterWeapon.Equipped); string disarmSuccessString = $"You successfully disarmed {monster.Name}!"; Assert.AreEqual(disarmSuccessString, OutputHelper.Display.Output[5][2]); }
public void ValueUnitTests() { // Test RoundNumber method in Helper class Assert.AreEqual(110, GameHelper.RoundNumber(107)); Assert.AreEqual(110, GameHelper.RoundNumber(105)); Assert.AreEqual(100, GameHelper.RoundNumber(104)); /* Test _Monster constructor HP and exp smoothing * if values smoothed correctly, % should be 0 */ Monster monster = new Monster(1, MonsterType.Skeleton); MonsterBuilder.BuildMonster(monster); Assert.AreEqual(0, monster.MaxHitPoints % 10); Assert.AreEqual(0, monster.ExperienceProvided % 10); }
public void DetermineAttackUnitTest() { Player player = new Player("test", PlayerClassType.Mage) { HitPoints = 100, MaxHitPoints = 100 }; Monster monster = new Monster(3, MonsterType.Dragon); MonsterBuilder.BuildMonster(monster); OutputHelper.Display.ClearUserOutput(); AttackOption attackChoice = monster.DetermineAttack(player, false); Assert.AreEqual(AttackType.Spell, attackChoice.AttackCategory); monster.EnergyPoints = 0; attackChoice = monster.DetermineAttack(player, false); Assert.AreEqual(AttackType.Physical, attackChoice.AttackCategory); }
public void AmbushAbilityUnitTest() { Player player = new Player("test", PlayerClassType.Archer) { MaxComboPoints = 100, ComboPoints = 100, MaxHitPoints = 100, HitPoints = 10 }; GearHelper.EquipInitialGear(player); OutputHelper.Display.ClearUserOutput(); Monster monster = new Monster(3, MonsterType.Demon) { HitPoints = 100, MaxHitPoints = 100 }; MonsterBuilder.BuildMonster(monster); player.Abilities.Add(new PlayerAbility( "ambush", 75, 1, ArcherAbility.Ambush, 4)); string[] inputInfo = new[] { "ability", "ambush" }; PlayerHelper.AbilityInfo(player, inputInfo); Assert.AreEqual("Ambush", OutputHelper.Display.Output[0][2]); Assert.AreEqual("Rank: 1", OutputHelper.Display.Output[1][2]); Assert.AreEqual("Combo Cost: 75", OutputHelper.Display.Output[2][2]); Assert.AreEqual("Instant Damage: 50", OutputHelper.Display.Output[3][2]); Assert.AreEqual("A surprise attack is launched, which initiates combat.", OutputHelper.Display.Output[4][2]); string[] input = new[] { "use", "ambush", monster.Name }; player.InCombat = true; int arrowCount = player.PlayerQuiver.Quantity; player.UseAbility(monster, input); Assert.AreEqual($"You can't ambush {monster.Name}, you're already in combat!", OutputHelper.Display.Output[5][2]); player.InCombat = false; player.UseAbility(monster, input); int index = player.Abilities.FindIndex( f => f.ArcAbilityCategory == ArcherAbility.Ambush); int abilityDamage = player.Abilities[index].Offensive.Amount; string attackString = "Your ambush hit the " + monster.Name + " for " + abilityDamage + " physical damage."; Assert.AreEqual(arrowCount - 1, player.PlayerQuiver.Quantity); Assert.AreEqual(attackString, OutputHelper.Display.Output[6][2]); Assert.AreEqual(monster.HitPoints, monster.MaxHitPoints - abilityDamage); }
public void LightningSpellUnitTest() { Player player = new Player("test", PlayerClassType.Mage) { MaxManaPoints = 100, ManaPoints = 100 }; GearHelper.EquipInitialGear(player); OutputHelper.Display.ClearUserOutput(); Monster monster = new Monster(3, MonsterType.Demon) { HitPoints = 100, MaxHitPoints = 100, ArcaneResistance = 0 }; MonsterBuilder.BuildMonster(monster); foreach (IItem item in monster.MonsterItems.Where(item => item is IEquipment eItem && eItem.Equipped)) { IEquipment eItem = item as IEquipment; eItem.Equipped = false; } string[] inputInfo = new[] { "spell", "lightning" }; int spellIndex = player.Spellbook.FindIndex( f => f.SpellCategory == SpellType.Lightning); PlayerHelper.SpellInfo(player, inputInfo); Assert.AreEqual("Lightning", OutputHelper.Display.Output[0][2]); Assert.AreEqual("Rank: 1", OutputHelper.Display.Output[1][2]); Assert.AreEqual("Mana Cost: 25", OutputHelper.Display.Output[2][2]); Assert.AreEqual("Instant Damage: 35", OutputHelper.Display.Output[3][2]); string[] input = new[] { "cast", "lightning" }; string spellName = InputHelper.ParseInput(input); Assert.AreEqual("lightning", spellName); player.PlayerWeapon.Durability = 100; player.CastSpell(monster, spellName); Assert.AreEqual(player.MaxManaPoints - player.Spellbook[spellIndex].ManaCost, player.ManaPoints); int arcaneSpellDamage = player.Spellbook[spellIndex].Offensive.Amount; Assert.AreEqual(monster.HitPoints, monster.MaxHitPoints - arcaneSpellDamage); string attackSuccessString = $"You hit the {monster.Name} for {arcaneSpellDamage} arcane damage."; Assert.AreEqual(attackSuccessString, OutputHelper.Display.Output[4][2]); }
public void SlashAbilityUnitTest() { Player player = new Player("test", PlayerClassType.Warrior) { MaxRagePoints = 100, RagePoints = 100 }; OutputHelper.Display.ClearUserOutput(); Monster monster = new Monster(3, MonsterType.Demon) { HitPoints = 100, MaxHitPoints = 100 }; MonsterBuilder.BuildMonster(monster); foreach (IItem item in monster.MonsterItems.Where(item => item is IEquipment eItem && eItem.Equipped)) { IEquipment eItem = item as IEquipment; eItem.Equipped = false; } string[] inputInfo = new[] { "ability", "slash" }; int abilityIndex = player.Abilities.FindIndex( f => f.WarAbilityCategory == WarriorAbility.Slash); PlayerHelper.AbilityInfo(player, inputInfo); Assert.AreEqual("Slash", OutputHelper.Display.Output[0][2]); Assert.AreEqual("Rank: 1", OutputHelper.Display.Output[1][2]); Assert.AreEqual("Rage Cost: 40", OutputHelper.Display.Output[2][2]); Assert.AreEqual("Instant Damage: 50", OutputHelper.Display.Output[3][2]); string[] input = new[] { "use", "slash" }; string abilityName = InputHelper.ParseInput(input); Assert.AreEqual("slash", abilityName); player.UseAbility(monster, input); Assert.AreEqual(player.MaxRagePoints - player.Abilities[abilityIndex].RageCost, player.RagePoints); int abilityDamage = player.Abilities[abilityIndex].Offensive.Amount; Assert.AreEqual(monster.HitPoints, monster.MaxHitPoints - abilityDamage); string abilitySuccessString = $"Your {player.Abilities[abilityIndex].Name} hit the {monster.Name} for {abilityDamage} physical damage."; Assert.AreEqual(abilitySuccessString, OutputHelper.Display.Output[4][2]); }
public void BloodLeechAbilityUnitTest() { Player player = new Player("test", PlayerClassType.Mage) { HitPoints = 100, MaxHitPoints = 100 }; OutputHelper.Display.ClearUserOutput(); Monster monster = new Monster(3, MonsterType.Vampire) { HitPoints = 10, MaxHitPoints = 100 }; MonsterBuilder.BuildMonster(monster); int abilityIndex = monster.Abilities.FindIndex( f => f.AbilityCategory == Ability.BloodLeech); foreach (IItem item in player.Inventory.Where(item => item is IEquipment eItem && eItem.Equipped)) { IEquipment eItem = item as IEquipment; eItem.Equipped = false; } int monsterHealthBase = monster.HitPoints; monster.Abilities[abilityIndex].UseBloodLeechAbility(monster, player, abilityIndex); int abilityCost = monster.Abilities[abilityIndex].EnergyCost; Assert.AreEqual(monster.MaxEnergyPoints - abilityCost, monster.EnergyPoints); int leechAmount = monster.Abilities[abilityIndex].Offensive.Amount; Assert.AreEqual(player.MaxHitPoints - leechAmount, player.HitPoints); Assert.AreEqual(monsterHealthBase + leechAmount, monster.HitPoints); string attackString = $"The {monster.Name} tries to sink its fangs into you and suck your blood!"; Assert.AreEqual(attackString, OutputHelper.Display.Output[0][2]); string attackSuccessString = $"The {monster.Name} leeches {leechAmount} life from you."; Assert.AreEqual(attackSuccessString, OutputHelper.Display.Output[1][2]); }
public GameObject handleTowerCanvasGo; // 处理塔升级与买卖的画布 private void Awake() { #if Game _instance = this; mGameManager = GameManager.Instance; currentStage = mGameManager.currentStage; // mUIFacade = mGameManager.uiManager.mUIFacade; //因为测试注销 // normalModelPanel = mUIFacade.currentScenePanels[StringManager.NormalModelPanel] as NormalModelPanel; //因为测试注销 mapMaker = transform.GetComponent <MapMaker>(); // 初始化地图 mapMaker.InitMapMaker(); // mapMaker.LoadMap(currentStage.mBigLevelID,currentStage.mLevelID); //因为测试注销 GetMonsterAnimator(); // 获得需要的动画控制器 // 属性赋值 gameSpeed = 1; monsterBuilder = new MonsterBuilder(); // test mapMaker.LoadMap(1, 1); level = new Level(mapMaker.roundInfoList.Count, mapMaker.roundInfoList); level.HandleRound(); // test #endif }
public void LightningSpellUnitTest() { Player player = new Player("test", PlayerClassType.Mage) { HitPoints = 200, MaxHitPoints = 200, ArcaneResistance = 0 }; OutputHelper.Display.ClearUserOutput(); Monster monster = new Monster(3, MonsterType.Elemental); while (monster.ElementalCategory != ElementalType.Air) { monster = new Monster(3, MonsterType.Elemental); } MonsterBuilder.BuildMonster(monster); int spellIndex = monster.Spellbook.FindIndex( f => f.SpellCategory == SpellType.Lightning); foreach (IItem item in player.Inventory.Where(item => item is IEquipment eItem && eItem.Equipped)) { IEquipment eItem = item as IEquipment; eItem.Equipped = false; } monster.Spellbook[spellIndex].CastArcaneOffense(monster, player, spellIndex); int spellCost = monster.Spellbook[spellIndex].EnergyCost; Assert.AreEqual(monster.MaxEnergyPoints - spellCost, monster.EnergyPoints); int spellDamage = monster.Spellbook[spellIndex].Offensive.Amount; Assert.AreEqual(player.MaxHitPoints - spellDamage, player.HitPoints); string attackString = $"The {monster.Name} casts a bolt of lightning at you!"; Assert.AreEqual(attackString, OutputHelper.Display.Output[0][2]); string attackSuccessString = $"The {monster.Name} hits you for {spellDamage} arcane damage."; Assert.AreEqual(attackSuccessString, OutputHelper.Display.Output[1][2]); }
public void MonsterResistanceUnitTest() { Player player = new Player("test", PlayerClassType.Mage) { MaxManaPoints = 100, ManaPoints = 100 }; GearHelper.EquipInitialGear(player); OutputHelper.Display.ClearUserOutput(); Monster monster = new Monster(3, MonsterType.Demon) { HitPoints = 100, MaxHitPoints = 100 }; MonsterBuilder.BuildMonster(monster); foreach (IItem item in monster.MonsterItems.Where(item => item is IEquipment eItem && eItem.Equipped)) { IEquipment eItem = item as IEquipment; eItem.Equipped = false; } Assert.AreEqual(monster.Level * 5, monster.FireResistance); Assert.AreEqual(monster.Level * 5, monster.FrostResistance); Assert.AreEqual(monster.Level * 5, monster.ArcaneResistance); int arcaneResistance = monster.ArcaneResistance; double resistanceMod = (100 - arcaneResistance) / 100.0; string[] input = new[] { "cast", "lightning" }; int spellIndex = player.Spellbook.FindIndex( f => f.SpellCategory == SpellType.Lightning); string spellName = InputHelper.ParseInput(input); player.CastSpell(monster, spellName); int reducedDamage = (int)(player.Spellbook[spellIndex].Offensive.Amount * resistanceMod); Assert.AreEqual(monster.HitPoints, monster.MaxHitPoints - reducedDamage); }
public void BerserkAbilityUnitTest() { Player player = new Player("test", PlayerClassType.Warrior) { MaxRagePoints = 100, RagePoints = 100, InCombat = true, MaxHitPoints = 100, HitPoints = 100, DodgeChance = 0 }; GearHelper.EquipInitialGear(player); OutputHelper.Display.ClearUserOutput(); Monster monster = new Monster(3, MonsterType.Demon) { HitPoints = 100, MaxHitPoints = 100, InCombat = true }; MonsterBuilder.BuildMonster(monster); foreach (IItem item in monster.MonsterItems.Where(item => item is IEquipment eItem && eItem.Equipped)) { IEquipment eItem = item as IEquipment; eItem.Equipped = false; } int abilityIndex = player.Abilities.FindIndex( f => f.WarAbilityCategory == WarriorAbility.Berserk); string[] inputInfo = new[] { "ability", "berserk" }; PlayerHelper.AbilityInfo(player, inputInfo); Assert.AreEqual("Berserk", OutputHelper.Display.Output[0][2]); Assert.AreEqual("Rank: 1", OutputHelper.Display.Output[1][2]); Assert.AreEqual("Rage Cost: 40", OutputHelper.Display.Output[2][2]); string dmgIncreaseString = $"Damage Increase: {player.Abilities[abilityIndex].Offensive.Amount}"; Assert.AreEqual(dmgIncreaseString, OutputHelper.Display.Output[3][2]); string armDecreaseString = $"Armor Decrease: {player.Abilities[abilityIndex].ChangeAmount.Amount}"; Assert.AreEqual(armDecreaseString, OutputHelper.Display.Output[4][2]); string dmgInfoString = $"Damage increased at cost of armor decrease for {player.Abilities[abilityIndex].ChangeAmount.ChangeMaxRound} rounds"; Assert.AreEqual(dmgInfoString, OutputHelper.Display.Output[5][2]); string[] input = new[] { "use", "berserk" }; string abilityName = InputHelper.ParseInput(input); Assert.AreEqual("berserk", abilityName); int baseArmorRating = GearHelper.CheckArmorRating(player); int baseDamage = player.PhysicalAttack(monster); player.UseAbility(monster, input); int?rageCost = player.Abilities[abilityIndex].RageCost; Assert.AreEqual(player.MaxRagePoints - rageCost, player.RagePoints); Assert.AreEqual(2, player.Effects.Count); Assert.AreEqual(true, player.Effects[0] is ChangePlayerDamageEffect); Assert.AreEqual(true, player.Effects[1] is ChangeArmorEffect); ChangePlayerDamageEffect changePlayerDmgEffect = player.Effects[0] as ChangePlayerDamageEffect; ChangeArmorEffect changeArmorEffect = player.Effects[1] as ChangeArmorEffect; const string berserkString = "You go into a berserk rage!"; Assert.AreEqual(berserkString, OutputHelper.Display.Output[6][2]); for (int i = 2; i < 6; i++) { OutputHelper.Display.ClearUserOutput(); int berserkArmorAmount = player.Abilities[abilityIndex].ChangeAmount.Amount; int berserkDamageAmount = player.Abilities[abilityIndex].Offensive.Amount; int berserkArmorRating = GearHelper.CheckArmorRating(player); int berserkDamage = player.PhysicalAttack(monster); Assert.AreEqual(berserkArmorRating, baseArmorRating + berserkArmorAmount); Assert.AreEqual(berserkDamage, baseDamage + berserkDamageAmount, 5); changePlayerDmgEffect.ProcessChangePlayerDamageRound(player); string changeDmgString = $"Your damage is increased by {berserkDamageAmount}."; Assert.AreEqual(changeDmgString, OutputHelper.Display.Output[0][2]); changeArmorEffect.ProcessChangeArmorRound(); string changeArmorString = $"Your armor is decreased by {berserkArmorAmount * -1}."; Assert.AreEqual(changeArmorString, OutputHelper.Display.Output[1][2]); GameHelper.RemovedExpiredEffectsAsync(player); Thread.Sleep(1000); } Assert.AreEqual(false, player.Effects.Any()); }
public void WeaponUnitTests() { // Test weapon creation values // Test case 1, weapon on level 1 skeleton based on possible weapon types // _Name check Monster skeletonLevelOne = new Monster(1, MonsterType.Skeleton); MonsterBuilder.BuildMonster(skeletonLevelOne); Weapon skeletonWeapon = skeletonLevelOne.MonsterWeapon; switch (skeletonWeapon.Quality) { case 1: switch (skeletonWeapon.WeaponGroup) { case WeaponType.Dagger: Assert.AreEqual("chipped dagger", skeletonWeapon.Name); break; case WeaponType.OneHandedSword: Assert.AreEqual("chipped sword (1H)", skeletonWeapon.Name); break; case WeaponType.TwoHandedSword: Assert.AreEqual("chipped sword (2H)", skeletonWeapon.Name); break; case WeaponType.Axe: case WeaponType.Bow: break; default: throw new ArgumentOutOfRangeException(); } break; case 2: switch (skeletonWeapon.WeaponGroup) { case WeaponType.Dagger: Assert.AreEqual("chipped sturdy dagger", skeletonWeapon.Name); break; case WeaponType.OneHandedSword: Assert.AreEqual("chipped sturdy sword (1H)", skeletonWeapon.Name); break; case WeaponType.TwoHandedSword: Assert.AreEqual("chipped sturdy sword (2H)", skeletonWeapon.Name); break; case WeaponType.Axe: case WeaponType.Bow: break; default: throw new ArgumentOutOfRangeException(); } break; case 3: switch (skeletonWeapon.WeaponGroup) { case WeaponType.Dagger: Assert.AreEqual("chipped fine dagger", skeletonWeapon.Name); break; case WeaponType.OneHandedSword: Assert.AreEqual("chipped fine sword (1H)", skeletonWeapon.Name); break; case WeaponType.TwoHandedSword: Assert.AreEqual("chipped fine sword (2H)", skeletonWeapon.Name); break; case WeaponType.Axe: case WeaponType.Bow: break; default: throw new ArgumentOutOfRangeException(); } break; } // Test case 2, weapon on level 1 spider based on possible weapon types // _Name check Monster spiderLevelOne = new Monster(1, MonsterType.Spider); MonsterBuilder.BuildMonster(spiderLevelOne); Weapon spiderWeapon = spiderLevelOne.MonsterWeapon; switch (spiderWeapon.Quality) { case 1: switch (spiderWeapon.WeaponGroup) { case WeaponType.Dagger: Assert.AreEqual("venomous fang", spiderWeapon.Name); break; case WeaponType.OneHandedSword: case WeaponType.TwoHandedSword: case WeaponType.Axe: case WeaponType.Bow: break; default: throw new ArgumentOutOfRangeException(); } break; case 2: switch (spiderWeapon.WeaponGroup) { case WeaponType.Dagger: Assert.AreEqual("sturdy venomous fang", spiderWeapon.Name); break; case WeaponType.OneHandedSword: case WeaponType.TwoHandedSword: case WeaponType.Axe: case WeaponType.Bow: break; default: throw new ArgumentOutOfRangeException(); } break; case 3: switch (spiderWeapon.WeaponGroup) { case WeaponType.Dagger: Assert.AreEqual("fine venomous fang", spiderWeapon.Name); break; case WeaponType.OneHandedSword: case WeaponType.TwoHandedSword: case WeaponType.Axe: case WeaponType.Bow: break; default: throw new ArgumentOutOfRangeException(); } break; } // Test case 3, weapon on level 3 zombie based on possible weapon types // _Name check Monster zombieLevelThree = new Monster(3, MonsterType.Zombie); MonsterBuilder.BuildMonster(zombieLevelThree); Weapon zombieWeapon = zombieLevelThree.MonsterWeapon; switch (zombieWeapon.Quality) { case 1: switch (zombieWeapon.WeaponGroup) { case WeaponType.Dagger: case WeaponType.OneHandedSword: case WeaponType.TwoHandedSword: case WeaponType.Bow: break; case WeaponType.Axe: Assert.AreEqual("worn axe", zombieWeapon.Name); break; default: throw new ArgumentOutOfRangeException(); } break; case 2: switch (zombieWeapon.WeaponGroup) { case WeaponType.Dagger: case WeaponType.OneHandedSword: case WeaponType.TwoHandedSword: case WeaponType.Bow: break; case WeaponType.Axe: Assert.AreEqual("worn sturdy axe", zombieWeapon.Name); break; default: throw new ArgumentOutOfRangeException(); } break; case 3: switch (zombieWeapon.WeaponGroup) { case WeaponType.Dagger: case WeaponType.OneHandedSword: case WeaponType.TwoHandedSword: case WeaponType.Bow: break; case WeaponType.Axe: Assert.AreEqual("worn fine axe", zombieWeapon.Name); break; default: throw new ArgumentOutOfRangeException(); } break; } // Test case 3, weapon on level 3 zombie based on possible weapon types // _Name check Monster demonLevelTwo = new Monster(2, MonsterType.Demon); MonsterBuilder.BuildMonster(demonLevelTwo); Weapon demonWeapon = demonLevelTwo.MonsterWeapon; switch (demonWeapon.Quality) { case 1: switch (demonWeapon.WeaponGroup) { case WeaponType.Dagger: case WeaponType.Bow: break; case WeaponType.OneHandedSword: Assert.AreEqual("dull sword (1H)", demonWeapon.Name); break; case WeaponType.TwoHandedSword: Assert.AreEqual("dull sword (2H)", demonWeapon.Name); break; case WeaponType.Axe: Assert.AreEqual("dull axe", demonWeapon.Name); break; default: throw new ArgumentOutOfRangeException(); } break; case 2: switch (demonWeapon.WeaponGroup) { case WeaponType.Dagger: case WeaponType.Bow: break; case WeaponType.OneHandedSword: Assert.AreEqual("dull sturdy sword (1H)", demonWeapon.Name); break; case WeaponType.TwoHandedSword: Assert.AreEqual("dull sturdy sword (2H)", demonWeapon.Name); break; case WeaponType.Axe: Assert.AreEqual("dull sturdy axe", demonWeapon.Name); break; default: throw new ArgumentOutOfRangeException(); } break; case 3: switch (demonWeapon.WeaponGroup) { case WeaponType.Dagger: case WeaponType.Bow: break; case WeaponType.OneHandedSword: Assert.AreEqual("dull fine sword (1H)", demonWeapon.Name); break; case WeaponType.TwoHandedSword: Assert.AreEqual("dull fine sword (2H)", demonWeapon.Name); break; case WeaponType.Axe: Assert.AreEqual("dull fine axe", demonWeapon.Name); break; default: throw new ArgumentOutOfRangeException(); } break; } }
//Print each part to picturbox public void printMonster(List<PictureBox> printBoxes, MonsterBuilder monster) { printBoxes[0].ImageLocation = monster.headpicture(); printBoxes[1].ImageLocation = monster.bodyPictur(); printBoxes[2].ImageLocation = monster.legPicture(); }
public override void CreateEntities(Mogwai mogwai, Shift shift) { mogwai.Reset(); mogwai.AdventureEntityId = NextId; Entities.Add(mogwai.AdventureEntityId, mogwai); var adjCr = GetChallengeRating(); //var monsterSet = Monsters.Instance.AllBuilders() // .Where(p => (p.EnvironmentTypes.Contains(EnvironmentType.Any) // || p.EnvironmentTypes.Contains(EnvironmentType.Undergrounds)) // && p.ChallengeRating <= adjCr).ToList(); // TODO work here again and replace it with a real algorithm or make it dungeon dependend. var monsterSet = new List <MonsterBuilder>() { IceCave.BunnyRat, IceCave.BearWarrior, IceCave.CrystalGuardian, IceCave.GoblinFrost, IceCave.GoblinMage, IceCave.GoblinTorch, IceCave.GoblinVenom, IceCave.ThreeTailedWolf, IceCave.SnowMonster }; var totXpAmount = 500 * Math.Pow(adjCr, 2); var allMonsters = new List <MonsterBuilder>(); for (var i = 0; i < 100 && totXpAmount > 0; i++) { MonsterBuilder mob = monsterSet[DungeonRandom.Next(monsterSet.Count)]; allMonsters.Add(mob); totXpAmount -= mob.Experience; } // make sure there are at least 7 mobs in the dungeon if (allMonsters.Count < 7) { var subMonsterSet = monsterSet.Where(p => p.ChallengeRating <= 0.5).ToList(); if (subMonsterSet.Count > 0) { for (var i = 0; i < 10; i++) { MonsterBuilder mob = subMonsterSet[DungeonRandom.Next(subMonsterSet.Count)]; allMonsters.Add(mob); } } } var maxCr = allMonsters.Max(p => p.ChallengeRating); var potentialBosses = allMonsters.Where(p => p.ChallengeRating == maxCr).ToList(); Monster boss = potentialBosses[DungeonRandom.Next(potentialBosses.Count)].Build(); boss.AdventureEntityId = NextId; boss.Initialize(new Dice(shift, 1)); Entities.Add(boss.AdventureEntityId, boss); BossKeys.Add(boss.AdventureEntityId); var monsterMod = 100; foreach (MonsterBuilder monsterBuilder in allMonsters) { Monster mob = monsterBuilder.Build(); mob.AdventureEntityId = NextId; mob.Initialize(new Dice(shift, monsterMod++)); Entities.Add(mob.AdventureEntityId, mob); } // exploration order _explorationOrder = EntitiesList.OrderBy(p => p.Intelligence).ThenBy(p => p.SizeType).ToList(); }
public void FrostboltSpellUnitTest() { Player player = new Player("test", PlayerClassType.Mage) { MaxManaPoints = 100, ManaPoints = 100 }; GearHelper.EquipInitialGear(player); OutputHelper.Display.ClearUserOutput(); Monster monster = new Monster(3, MonsterType.Demon) { HitPoints = 100, MaxHitPoints = 100, FrostResistance = 0 }; MonsterBuilder.BuildMonster(monster); foreach (IItem item in monster.MonsterItems.Where(item => item is IEquipment eItem && eItem.Equipped)) { IEquipment eItem = item as IEquipment; eItem.Equipped = false; } string[] inputInfo = new[] { "spell", "frostbolt" }; int spellIndex = player.Spellbook.FindIndex( f => f.SpellCategory == SpellType.Frostbolt); PlayerHelper.SpellInfo(player, inputInfo); Assert.AreEqual("Frostbolt", OutputHelper.Display.Output[0][2]); Assert.AreEqual("Rank: 1", OutputHelper.Display.Output[1][2]); Assert.AreEqual("Mana Cost: 25", OutputHelper.Display.Output[2][2]); Assert.AreEqual("Instant Damage: 15", OutputHelper.Display.Output[3][2]); Assert.AreEqual("Frost damage will freeze opponent for 2 rounds.", OutputHelper.Display.Output[4][2]); Assert.AreEqual("Frozen opponents take 1.5x physical, arcane and frost damage.", OutputHelper.Display.Output[5][2]); OutputHelper.Display.ClearUserOutput(); string[] input = new[] { "cast", "frostbolt" }; string spellName = InputHelper.ParseInput(input); Assert.AreEqual("frostbolt", spellName); player.PlayerWeapon.Durability = 100; double baseDamage = player.PhysicalAttack(monster); player.CastSpell(monster, spellName); Assert.AreEqual(player.MaxManaPoints - player.Spellbook[spellIndex].ManaCost, player.ManaPoints); Assert.AreEqual(85, monster.HitPoints); Assert.AreEqual(1, monster.Effects[0].CurrentRound); Assert.AreEqual(2, monster.Effects[0].MaxRound); string attackString = $"You hit the {monster.Name} for {player.Spellbook[spellIndex].Offensive.Amount} frost damage."; Assert.AreEqual(attackString, OutputHelper.Display.Output[0][2]); string frozenString = $"The {monster.Name} is frozen. Physical, frost and arcane damage to it will be increased by 50%!"; Assert.AreEqual(frozenString, OutputHelper.Display.Output[1][2]); FrozenEffect frozenEffect = monster.Effects[0] as FrozenEffect; int monsterHitPointsBefore = monster.HitPoints; double totalBaseDamage = 0.0; double totalFrozenDamage = 0.0; double multiplier = frozenEffect.EffectMultiplier; for (int i = 2; i < 4; i++) { frozenEffect.ProcessRound(); Assert.AreEqual(i, monster.Effects[0].CurrentRound); Assert.AreEqual(frozenString, OutputHelper.Display.Output[i][2]); player.PlayerWeapon.Durability = 100; double frozenDamage = player.PhysicalAttack(monster); monster.HitPoints -= (int)frozenDamage; totalBaseDamage += baseDamage; totalFrozenDamage += frozenDamage; } GameHelper.RemovedExpiredEffectsAsync(monster); Thread.Sleep(1000); Assert.AreEqual(false, monster.Effects.Any()); int finalBaseDamageWithMod = (int)(totalBaseDamage * multiplier); int finalTotalFrozenDamage = (int)totalFrozenDamage; Assert.AreEqual(finalTotalFrozenDamage, finalBaseDamageWithMod, 14); Assert.AreEqual(monster.HitPoints, monsterHitPointsBefore - (int)totalFrozenDamage); }
public void ReflectDamageSpellUnitTest() { OutputHelper.Display.ClearUserOutput(); Player player = new Player("test", PlayerClassType.Mage) { MaxManaPoints = 100, ManaPoints = 100 }; Monster monster = new Monster(3, MonsterType.Zombie) { HitPoints = 100, MaxHitPoints = 100 }; MonsterBuilder.BuildMonster(monster); foreach (IItem item in monster.MonsterItems.Where(item => item is IEquipment eItem && eItem.Equipped)) { IEquipment eItem = item as IEquipment; eItem.Equipped = false; } player.Spellbook.Add(new PlayerSpell( "reflect", 100, 1, SpellType.Reflect, 4)); string[] inputInfo = new[] { "spell", "reflect" }; int spellIndex = player.Spellbook.FindIndex( f => f.SpellCategory == SpellType.Reflect); PlayerHelper.SpellInfo(player, inputInfo); Assert.AreEqual("Reflect", OutputHelper.Display.Output[0][2]); Assert.AreEqual("Rank: 1", OutputHelper.Display.Output[1][2]); Assert.AreEqual("Mana Cost: 100", OutputHelper.Display.Output[2][2]); Assert.AreEqual("Reflect Damage Amount: 25", OutputHelper.Display.Output[3][2]); string reflectInfoString = $"Damage up to {player.Spellbook[spellIndex].ChangeAmount.Amount} will be reflected for " + $"{player.Spellbook[spellIndex].ChangeAmount.ChangeMaxRound} rounds."; Assert.AreEqual(reflectInfoString, OutputHelper.Display.Output[4][2]); string[] input = new[] { "cast", "reflect" }; string spellName = InputHelper.ParseInput(input); Assert.AreEqual("reflect", spellName); player.CastSpell(spellName); Assert.AreEqual(player.MaxManaPoints - player.Spellbook[spellIndex].ManaCost, player.ManaPoints); Assert.AreEqual("You create a shield around you that will reflect damage.", OutputHelper.Display.Output[5][2]); Assert.AreEqual(true, player.Effects.Any()); Assert.AreEqual(true, player.Effects[0] is ReflectDamageEffect); ReflectDamageEffect reflectDmgEffect = player.Effects[0] as ReflectDamageEffect; OutputHelper.Display.ClearUserOutput(); for (int i = 2; i < 5; i++) { int attackDamageM = monster.MonsterWeapon.Attack(); int reflectAmount = reflectDmgEffect.ReflectDamageAmount < attackDamageM ? reflectDmgEffect.ReflectDamageAmount : attackDamageM; Assert.AreEqual(true, reflectAmount <= reflectDmgEffect.ReflectDamageAmount); monster.HitPoints -= reflectAmount; Assert.AreEqual(monster.HitPoints, monster.MaxHitPoints - (reflectAmount * (i - 1))); reflectDmgEffect.ProcessChangeDamageRound(reflectAmount); Assert.AreEqual( $"You reflected {reflectAmount} damage back at your opponent!", OutputHelper.Display.Output[i - 2][2]); } GameHelper.RemovedExpiredEffectsAsync(player); Thread.Sleep(1000); Assert.AreEqual(false, player.Effects.Any()); }
public void BlockAbilityUnitTest() { Player player = new Player("test", PlayerClassType.Warrior) { MaxRagePoints = 100, RagePoints = 100, InCombat = true, MaxHitPoints = 100, HitPoints = 100, DodgeChance = 0, Level = 3 }; OutputHelper.Display.ClearUserOutput(); Monster monster = new Monster(3, MonsterType.Zombie) { HitPoints = 100, MaxHitPoints = 100, InCombat = true }; MonsterBuilder.BuildMonster(monster); monster.MonsterWeapon.CritMultiplier = 1; int abilityIndex = player.Abilities.FindIndex( f => f.WarAbilityCategory == WarriorAbility.Block); string[] inputInfo = new[] { "ability", "block" }; PlayerHelper.AbilityInfo(player, inputInfo); Assert.AreEqual("Block", OutputHelper.Display.Output[0][2]); Assert.AreEqual("Rank: 1", OutputHelper.Display.Output[1][2]); Assert.AreEqual("Rage Cost: 25", OutputHelper.Display.Output[2][2]); Assert.AreEqual("Block Damage: 50", OutputHelper.Display.Output[3][2]); const string blockInfoString = "Block damage will prevent incoming damage from opponent until block damage is used up."; Assert.AreEqual(blockInfoString, OutputHelper.Display.Output[4][2]); string[] input = new[] { "use", "block" }; string abilityName = InputHelper.ParseInput(input); Assert.AreEqual("block", abilityName); player.UseAbility(monster, input); int?rageCost = player.Abilities[abilityIndex].RageCost; Assert.AreEqual(player.MaxRagePoints - rageCost, player.RagePoints); int blockAmount = player.Abilities[abilityIndex].Defensive.BlockDamage; string blockString = $"You start blocking your opponent's attacks! You will block {blockAmount} damage."; Assert.AreEqual(blockString, OutputHelper.Display.Output[5][2]); OutputHelper.Display.ClearUserOutput(); Assert.AreEqual(true, player.Effects[0] is BlockDamageEffect); Assert.AreEqual(player.MaxHitPoints, player.HitPoints); BlockDamageEffect blockDmgEffect = player.Effects[0] as BlockDamageEffect; int blockAmountRemaining = blockDmgEffect.BlockAmount; Assert.AreEqual(blockAmount, blockAmountRemaining); int i = 0; while (blockAmountRemaining > 0) { monster.MonsterWeapon.Durability = 100; int blockAmountBefore = blockAmountRemaining; monster.Attack(player); blockAmountRemaining = player.Effects.Any() ? blockDmgEffect.BlockAmount : 0; if (blockAmountRemaining > 0) { Assert.AreEqual(player.MaxHitPoints, player.HitPoints); string blockRoundString = $"Your defensive move blocked {(blockAmountBefore - blockAmountRemaining)} damage!"; Assert.AreEqual(blockRoundString, OutputHelper.Display.Output[i + (i * 1)][2]); } else { GameHelper.RemovedExpiredEffectsAsync(player); int attackAmount = monster.MonsterWeapon.Attack() - blockAmountBefore; Assert.AreEqual(player.MaxHitPoints - attackAmount, player.HitPoints); const string blockEndString = "You are no longer blocking damage!"; Assert.AreEqual(blockEndString, OutputHelper.Display.Output[i + 3][2]); Thread.Sleep(1000); Assert.AreEqual(false, player.Effects.Any()); string hitString = $"The {monster.Name} hits you for {attackAmount} physical damage."; Assert.AreEqual(hitString, OutputHelper.Display.Output[i + 4][2]); } i++; } }
public void RendAbilityUnitTest() { Player player = new Player("test", PlayerClassType.Warrior) { MaxRagePoints = 100, RagePoints = 100 }; OutputHelper.Display.ClearUserOutput(); Monster monster = new Monster(3, MonsterType.Demon) { HitPoints = 100, MaxHitPoints = 100 }; MonsterBuilder.BuildMonster(monster); foreach (IItem item in monster.MonsterItems.Where(item => item is IEquipment eItem && eItem.Equipped)) { IEquipment eItem = item as IEquipment; eItem.Equipped = false; } int abilityIndex = player.Abilities.FindIndex( f => f.WarAbilityCategory == WarriorAbility.Rend); string[] inputInfo = new[] { "ability", "rend" }; PlayerHelper.AbilityInfo(player, inputInfo); Assert.AreEqual("Rend", OutputHelper.Display.Output[0][2]); Assert.AreEqual("Rank: 1", OutputHelper.Display.Output[1][2]); Assert.AreEqual("Rage Cost: 25", OutputHelper.Display.Output[2][2]); Assert.AreEqual("Instant Damage: 15", OutputHelper.Display.Output[3][2]); Assert.AreEqual("Damage Over Time: 5", OutputHelper.Display.Output[4][2]); string bleedOverTimeString = $"Bleeding damage over time for {player.Abilities[abilityIndex].Offensive.AmountMaxRounds} rounds."; Assert.AreEqual(bleedOverTimeString, OutputHelper.Display.Output[5][2]); string[] input = new[] { "use", "rend" }; string abilityName = InputHelper.ParseInput(input); Assert.AreEqual("rend", abilityName); player.UseAbility(monster, input); int?rageCost = player.Abilities[abilityIndex].RageCost; Assert.AreEqual(player.MaxRagePoints - rageCost, player.RagePoints); int abilityDamage = player.Abilities[abilityIndex].Offensive.Amount; int abilityDamageOverTime = player.Abilities[abilityIndex].Offensive.AmountOverTime; int abilityCurRounds = player.Abilities[abilityIndex].Offensive.AmountCurRounds; int abilityMaxRounds = player.Abilities[abilityIndex].Offensive.AmountMaxRounds; string abilitySuccessString = $"Your {player.Abilities[abilityIndex].Name} hit the {monster.Name} for {abilityDamage} physical damage."; Assert.AreEqual(abilitySuccessString, OutputHelper.Display.Output[6][2]); string bleedString = $"The {monster.Name} is bleeding!"; Assert.AreEqual(bleedString, OutputHelper.Display.Output[7][2]); Assert.AreEqual(true, monster.Effects[0] is BleedingEffect); Assert.AreEqual(monster.MaxHitPoints - abilityDamage, monster.HitPoints); Assert.AreEqual(abilityCurRounds, monster.Effects[0].CurrentRound); Assert.AreEqual(abilityMaxRounds, monster.Effects[0].MaxRound); BleedingEffect bleedEffect = monster.Effects[0] as BleedingEffect; OutputHelper.Display.ClearUserOutput(); for (int i = 2; i < 5; i++) { bleedEffect.ProcessRound(); int bleedAmount = bleedEffect.BleedDamageOverTime; string bleedRoundString = $"The {monster.Name} bleeds for {bleedAmount} physical damage."; Assert.AreEqual(bleedRoundString, OutputHelper.Display.Output[i - 2][2]); Assert.AreEqual(i, monster.Effects[0].CurrentRound); GameHelper.RemovedExpiredEffectsAsync(monster); Thread.Sleep(1000); } Assert.AreEqual(false, monster.Effects.Any()); Assert.AreEqual(monster.MaxHitPoints - abilityDamage - (abilityDamageOverTime * abilityMaxRounds), monster.HitPoints); }