private bool IsPrime(EntityInfoModel Attacker) { int number = Attacker.GetAttackTotal + Attacker.GetDefenseTotal + Attacker.GetMaxHealthTotal + Attacker.GetSpeedTotal; if (number <= 1) { return(false); } if (number == 2) { return(true); } if (number % 2 == 0) { return(false); } var boundary = (int)Math.Floor(Math.Sqrt(number)); for (int i = 3; i <= boundary; i += 2) { if (number % i == 0) { return(false); } } return(true); }
public int CharacterDropItem(EntityInfoModel Target) { var DroppedMessage = "\nItems Dropped : \n"; // Drop Items to ItemModel Pool var myItemList = Target.DropAllItems(); // Add to ScoreModel foreach (var ItemModel in myItemList) { BattleScore.ItemsDroppedList += ItemModel.FormatOutput() + "\n"; DroppedMessage += ItemModel.Name + "\n"; } ItemPool.AddRange(myItemList); if (myItemList.Count == 0) { DroppedMessage = " Nothing dropped. "; } BattleMessageModel.DroppedMessage = DroppedMessage; BattleScore.ItemModelDropList.AddRange(myItemList); return(myItemList.Count()); }
//Sleeping Turn for Hackthon Scenario 7 public bool FallAsleep(EntityInfoModel Attacker) { Debug.WriteLine(string.Format(Attacker.Name, " is sleeping")); BattleMessageModel.ClearMessages(); BattleMessageModel.TurnMessage = Attacker.Name + " is sleeping"; return(true); }
/// <summary> /// Use the Ability /// </summary> /// <param name="Attacker"></param> /// <returns></returns> public bool UseAbility(EntityInfoModel Attacker) { BattleMessageModel.ClearMessages(); BattleMessageModel.TurnMessageSpecial = " Used Ability"; BattleMessageModel.TurnMessage = Attacker.Name + BattleMessageModel.TurnMessageSpecial; Debug.WriteLine(BattleMessageModel.TurnMessage); return(true); }
/// <summary> /// If Dead process Target Died /// </summary> /// <param name="Target"></param> public bool RemoveIfDead(EntityInfoModel Target) { //Check if dead if (Target.Alive == false) { TargetDied(Target); return(true); } return(false); }
/// <summary> /// Decide which to attack /// </summary> /// <param name="data"></param> /// <returns></returns> public EntityInfoModel AttackChoice(EntityInfoModel data) { switch (data.PlayerType) { case PlayerTypeEnum.Monster: return(SelectCharacterToAttack()); case PlayerTypeEnum.Character: default: return(SelectMonsterToAttack()); } }
/// <summary> /// Update defender info on the page /// </summary> /// <param name="sender"></param> /// <param name="e"></param> public void UpdateDefender(EntityInfoModel player) { if (player == null) { DefenderImage.Source = "question_mark.png"; DefenderLabel.Text = ""; return; } var defender = EngineViewModel.Engine.CurrentDefender; DefenderImage.Source = defender.ImageURI; DefenderLabel.Text = defender.GetCurrentHealthTotal.ToString() + " / " + defender.GetMaxHealthTotal.ToString(); }
/// <summary> /// Update attacker info on the page /// </summary> /// <param name="sender"></param> /// <param name="e"></param> public void UpdateAttacker(EntityInfoModel player) { if (player == null) { AttackerImage.Source = "question_mark.png"; AttackerLabel.Text = ""; return; } var attacker = EngineViewModel.Engine.CurrentAttacker; AttackerImage.Source = attacker.ImageURI; AttackerLabel.Text = attacker.GetCurrentHealthTotal.ToString() + " / " + attacker.GetMaxHealthTotal.ToString(); }
public async Task AutoBattleEngine_RunAutoBattle_Character_Level_Up_Should_Pass() { /* * Test to force leveling up of a character during the battle * * 1 Character, Experience set at next level mark * * 6 Monsters * * Character Should Level UP 1 level * */ //Arrange // Add Characters Engine.MaxNumberPartyCharacters = 1; CharacterIndexViewModel.Instance.Dataset.Clear(); // To See Level UP happening, a character needs to be close to the next level var Character = new CharacterModel { Experience = 300, // Enough for next level Name = "Mike Level Example", Speed = 100, // Go first }; // Remember Start Level var StartLevel = Character.Level; var CharacterPlayer = new EntityInfoModel(Character); Engine.CharacterList.Add(CharacterPlayer); // Add Monsters //Act var result = await Engine.RunAutoBattle(); //Reset //Assert Assert.AreEqual(true, result); Assert.AreEqual(true, Engine.BattleScore.CharacterAtDeathList.Contains("Mike Level Example")); // Assert.AreEqual(StartLevel+1, Engine.BattleScore.CharacterModelDeathList.Where(m=>m.Guid.Equals(Character.Guid)).First().Level); }
/// <summary> /// Roll dice to determine if the unique Item Drop /// </summary> /// <param name="round"></param> /// <returns></returns> public bool IsUniqueDrop(EntityInfoModel Target) { if (Target.PlayerType == PlayerTypeEnum.Character) { return(false); } int rate = (int)(10 * Target.DropRate); int dice = DiceHelper.RollDice(1, 10); if (dice > rate) { return(false); } return(true); }
/// <summary> /// Pickup Items Dropped /// </summary> /// <param name="character"></param> public bool PickupItemsFromPool(EntityInfoModel character) { { // Have the character, walk the items in the pool, and decide if any are better than current one. GetItemFromPoolIfBetter(character, ItemLocationEnum.Head); GetItemFromPoolIfBetter(character, ItemLocationEnum.Necklass); GetItemFromPoolIfBetter(character, ItemLocationEnum.PrimaryHand); GetItemFromPoolIfBetter(character, ItemLocationEnum.OffHand); GetItemFromPoolIfBetter(character, ItemLocationEnum.RightFinger); GetItemFromPoolIfBetter(character, ItemLocationEnum.LeftFinger); GetItemFromPoolIfBetter(character, ItemLocationEnum.Feet); } return(true); }
/// <summary> /// Drop Item /// </summary> /// <param name="Target"></param> /// <returns></returns> public int DropItems(EntityInfoModel Target) { // Depends on Target Player Type, // It will generate different Drop Methods var result = 0; if (Target.PlayerType == PlayerTypeEnum.Character) { result = CharacterDropItem(Target); } if (Target.PlayerType == PlayerTypeEnum.Monster) { result = MonsterDropItem(Target); } return(result); }
/// <summary> /// Update PlayerList after Character was attacked. Because it didn't update the Character stored in PlayerList /// </summary> /// <param name="Target"></param> private void UpdatePlayerList(EntityInfoModel Target) { for (int i = 0; i < PlayerList.Count; i++) { if (PlayerList[i].PlayerType == PlayerTypeEnum.Character) { if (PlayerList[i].Guid == Target.Guid) { PlayerList[i].CurrentHealth = Target.CurrentHealth; if (PlayerList[i].Level != Target.Level) { PlayerList[i].LevelUpToValue(Target.Level); } } } } }
/// </summary> /// <param name="Attacker"></param> /// <returns></returns> public bool Attack(EntityInfoModel Attacker) { if (BattleScore.AutoBattle) { // For attack, choose who CurrentDefender = AttackChoice(Attacker); if (CurrentDefender == null) { return(false); } } TurnAsAttack(Attacker, CurrentDefender); return(true); }
/// <summary> /// Target Died /// /// Process for death... /// /// Returns the count of items dropped at death /// </summary> /// <param name="Target"></param> public bool TargetDied(EntityInfoModel Target) { bool found; // Mark Status in output BattleMessageModel.TurnMessageSpecial = " and causes death. "; // Removing the MapModel.RemovePlayerFromMap(Target); // INFO: Teams, Hookup your Boss if you have one... // Using a switch so in the future additional PlayerTypes can be added (Boss...) switch (Target.PlayerType) { case PlayerTypeEnum.Character: // Add the Character to the killed list BattleScore.CharacterAtDeathList += Target.FormatOutput() + "\n"; BattleScore.CharacterModelDeathList.Add(Target); DropItems(Target); found = CharacterList.Remove(CharacterList.Find(m => m.Guid.Equals(Target.Guid))); found = PlayerList.Remove(PlayerList.Find(m => m.Guid.Equals(Target.Guid))); return(true); case PlayerTypeEnum.Monster: default: // Add one to the monsters killed count... BattleScore.MonsterSlainNumber++; // Add the MonsterModel to the killed list BattleScore.MonstersKilledList += Target.FormatOutput() + "\n"; BattleScore.MonsterModelDeathList.Add(Target); DropItems(Target); found = MonsterList.Remove(MonsterList.Find(m => m.Guid.Equals(Target.Guid))); found = PlayerList.Remove(PlayerList.Find(m => m.Guid.Equals(Target.Guid))); return(true); } }
public async Task AutoBattleEngine_RunAutoBattle_GameOver_Round_1_Should_Pass() { /* * * 1 Character, Speed slowest, only 1 HP * * 6 Monsters * * Should end in the first round * */ //Arrange // Add Characters Engine.MaxNumberPartyCharacters = 1; var CharacterPlayer = new EntityInfoModel( new CharacterModel { Speed = -1, // Will go last... Level = 10, CurrentHealth = 1, Experience = 1, ExperienceRemaining = 1, ListOrder = 1, }); Engine.CharacterList.Add(CharacterPlayer); // Add Monsters Engine.MaxNumberPartyMonsters = 6; //Act var result = await Engine.RunAutoBattle(); //Reset //Assert Assert.AreEqual(true, result); }
/// <summary> /// Monster Drop Item /// </summary> /// <param name="Target"></param> /// <returns></returns> public int MonsterDropItem(EntityInfoModel Target) { // Monster will only drop unique Item // The unique item will drop based on droprate var DroppedMessage = "\nItems Dropped : \n"; if (string.IsNullOrEmpty(Target.UniqueItemId)) { var data = GetRandomMonsterItemDrops(); BattleScore.ItemsDroppedList += data.FormatOutput() + "\n"; DroppedMessage += data.Name + "\n"; ItemPool.Add(data); BattleMessageModel.DroppedMessage = DroppedMessage; BattleScore.ItemModelDropList.Add(data); return(1); } if (!IsUniqueDrop(Target)) { DroppedMessage = " Nothing dropped. "; BattleMessageModel.DroppedMessage = DroppedMessage; return(0); } var ItemModel = ItemIndexViewModel.Instance.GetItem(Target.UniqueItemId); BattleScore.ItemsDroppedList += ItemModel.FormatOutput() + "\n"; DroppedMessage += ItemModel.Name + "\n"; ItemPool.Add(ItemModel); BattleMessageModel.DroppedMessage = DroppedMessage; BattleScore.ItemModelDropList.Add(ItemModel); return(1); }
/// <summary> /// Return a stack layout for the Characters /// </summary> /// <param name="data"></param> /// <returns></returns> public StackLayout CreateCharacterDisplayBox(EntityInfoModel data) { if (data == null) { data = new EntityInfoModel(); } // Hookup the image var PlayerImage = new Image { Style = (Style)Application.Current.Resources["ImageBattleMediumStyle"], Source = data.ImageURI }; // Add the Level var PlayerLevelLabel = new Label { Text = "Level : " + data.Level, Style = (Style)Application.Current.Resources["ValueStyleMicro"], HorizontalOptions = LayoutOptions.Center, HorizontalTextAlignment = TextAlignment.Center, Padding = 0, LineBreakMode = LineBreakMode.TailTruncation, CharacterSpacing = 1, LineHeight = 1, MaxLines = 1, }; // Put the Image Button and Text inside a layout var PlayerStack = new StackLayout { Style = (Style)Application.Current.Resources["ScoreCharacterInfoBox"], HorizontalOptions = LayoutOptions.Center, Padding = 0, Spacing = 0, Children = { PlayerImage, PlayerLevelLabel, }, }; return(PlayerStack); }
/// <summary> /// Calculate Experience /// Level up if needed /// </summary> /// <param name="Attacker"></param> /// <param name="Target"></param> public bool CalculateExperience(EntityInfoModel Attacker, EntityInfoModel Target) { if (Attacker.PlayerType == PlayerTypeEnum.Character) { var experienceEarned = Target.CalculateExperienceEarned(BattleMessageModel.DamageAmount); BattleMessageModel.ExperienceEarned = " Earned " + experienceEarned + " points"; var levelup = Attacker.AddExperience(experienceEarned); if (levelup) { BattleMessageModel.LevelUpMessage = Attacker.Name + " is now Level " + Attacker.Level + " With Health Max of " + Attacker.GetMaxHealthTotal; Debug.WriteLine(BattleMessageModel.LevelUpMessage); } // Add Experinece to the Score BattleScore.ExperienceGainedTotal += experienceEarned; } return(true); }
/// <summary> /// Swap the Item the character has for one from the pool /// /// Drop the current item back into the Pool /// /// </summary> /// <param name="character"></param> /// <param name="setLocation"></param> /// <param name="PoolItem"></param> /// <returns></returns> private ItemModel SwapCharacterItem(EntityInfoModel character, ItemLocationEnum setLocation, ItemModel PoolItem) { // Put on the new ItemModel, which drops the one back to the pool var droppedItem = character.AddItem(setLocation, PoolItem.Id); // Add the PoolItem to the list of selected items BattleScore.ItemModelSelectList.Add(PoolItem); // Remove the ItemModel just put on from the pool ItemPool.Remove(PoolItem); if (droppedItem != null) { // Add the dropped ItemModel to the pool ItemPool.Add(droppedItem); } return(droppedItem); }
public ActionResult GetEntityInfo(string place, string type, string name) { var vModel = new EntityInfoModel(); IEntity entity = null; switch (type.ToLower()) { case "thing": entity = _dataCache.GetByName <IThing>(name); break; case "persona": entity = _dataCache.GetByName <IPersona>(name); break; case "place": entity = _dataCache.GetByName <IPlace>(name); break; } if (entity == null) { vModel.Errors = "Invalid parameters."; } else { vModel.Entity = entity; if (type.Equals("place", StringComparison.InvariantCultureIgnoreCase)) { var thisPlace = (IPlace)entity; vModel.Things = thisPlace.GetThings().Select(thing => thing.Name); vModel.Personas = thisPlace.GetPersonas().Select(thing => thing.Name); } vModel.Actions = entity.FullContext.Where(ctx => ctx.GetType() == typeof(Verb)).Select(ctx => ctx.Name); vModel.Adjectives = entity.FullContext.Where(ctx => ctx.GetType() == typeof(Descriptor)).Select(ctx => ctx.Name); } return(View(@"~/Views/Existence/EntityInfo.cshtml", vModel)); }
/// <summary> /// Calculate the Attack, return if it hit or missed. /// </summary> /// <param name="Attacker"></param> /// <param name="Target"></param> /// <returns></returns> public HitStatusEnum CalculateAttackStatus(EntityInfoModel Attacker, EntityInfoModel Target) { // Remember Current Player BattleMessageModel.PlayerType = PlayerTypeEnum.Monster; BattleMessageModel.TargetName = Target.Name; BattleMessageModel.AttackerName = Attacker.Name; //if(Attacker.PlayerType == PlayerTypeEnum.Monster) //{ // BattleMessageModel.HitStatus = HitStatusEnum.Hit; // BattleMessageModel.AttackStatus = " Hit hit "; // return BattleMessageModel.HitStatus; //} //Set Attack and Defense var AttackScore = Attacker.Level + Attacker.GetAttackTotal; var DefenseScore = Target.Level + Target.GetDefenseTotal; BattleMessageModel.HitStatus = RollToHitTarget(AttackScore, DefenseScore); //BattleMessageModel.HitStatus = HitStatusEnum.Miss; //BattleMessageModel.AttackStatus = "Miss"; return(BattleMessageModel.HitStatus); }
public async Task AutoBattleEngine_RunAutoBattle_Monsters_1_Should_Pass() { //Arrange // Add Characters Engine.MaxNumberPartyCharacters = 1; var CharacterPlayerMike = new EntityInfoModel( new CharacterModel { Speed = -1, Level = 10, CurrentHealth = 11, Experience = 1, ExperienceRemaining = 1, Name = "Mike", ListOrder = 1, }); Engine.CharacterList.Add(CharacterPlayerMike); // Add Monsters // Need to set the Monster count to 1, so the battle goes to Next Round Faster Engine.MaxNumberPartyMonsters = 1; //Act var result = await Engine.RunAutoBattle(); //Reset //Assert Assert.AreEqual(true, result); }
/// <summary> /// Apply the Damage to the Target /// </summary> /// <param name="Target"></param> private void ApplyDamage(EntityInfoModel Target) { Target.TakeDamage(BattleMessageModel.DamageAmount); BattleMessageModel.CurrentHealth = Target.GetCurrentHealthTotal; }
/// <summary> /// Swap out the item if it is better /// /// Uses Value to determine /// </summary> /// <param name="character"></param> /// <param name="setLocation"></param> public bool GetItemFromPoolIfBetter(EntityInfoModel character, ItemLocationEnum setLocation) { // We planning to assign item depending on CharacterClass // We have four Class, Each Class has their outstanding attributes // So item attribute will be considered var myList = ItemPool.Where(a => a.Location == setLocation) .OrderByDescending(a => a.Value) .ToList(); // This will be complete later, after we complete Character Class //if(setLocation != ItemLocationEnum.OffHand || setLocation != ItemLocationEnum.PrimaryHand) //{ // var Attribute = AttributeEnum.Unknown; // switch (character.CharacterClass) // { // case (CharacterClassEnum.Fighter): // Attribute = AttributeEnum.Attack; // break; // case (CharacterClassEnum.Cleric): // Attribute = AttributeEnum.Defense; // break; // case (CharacterClassEnum.Unknown): // default: // break; // } // if (Attribute == AttributeEnum.Unknown) // { // return false; // } // myList = ItemPool.Where(a => a.Location == setLocation && a.Attribute == Attribute) // .OrderByDescending(a => a.Value) // .ToList(); //} // If no items in the list, return... if (!myList.Any()) { return(false); } var CharacterItem = character.GetItemByLocation(setLocation); if (CharacterItem == null) { SwapCharacterItem(character, setLocation, myList.FirstOrDefault()); return(true); } foreach (var PoolItem in myList) { if (PoolItem.Value > CharacterItem.Value) { SwapCharacterItem(character, setLocation, PoolItem); return(true); } } return(true); }
public void HackathonScenario_Scenario_14_If_Confusion_Turn_Character_Should_Skip() { /* * Scenario Number: * 14 * * Description: * Confusion, have % chance to occuring each round. * If happens, then confusion occurs for each monster and character for that round * Each party member rolls a chance of being confused. * * Changes Required (Classes, Methods etc.) List Files, Methods, and Describe Changes: * Change to Turn Engine, Take Turn method, added switch check and dice roll * Changed BaseEngine, added boolean switch for enabling confusion, and is confusion turn or not. * Check for Experience gained is 0 * * Test Algrorithm: * Create Character named Bob * Create Monster * Call TakeTurn * * Test Conditions: * Test with Character of Named ConfusionCharacter * * Validation: * Verify Experience gained is 0 * */ //Arrange DiceHelper.EnableForcedRolls(); DiceHelper.SetForcedRollValue(0); // Set Character Conditions BattleEngine.MaxNumberPartyCharacters = 1; var TestSword = ItemViewModel.Dataset.Where(a => a.Location == ItemLocationEnum.PrimaryHand).FirstOrDefault(); var CharacterPlayer = new EntityInfoModel( new CharacterModel { Level = 10, CurrentHealth = 200, MaxHealth = 200, //TestDamage = 123, Experience = 100, Name = "Confused Character", }); CharacterPlayer.Attack = 25; CharacterPlayer.Speed = 20; CharacterPlayer.Defense = 25; CharacterPlayer.AddItem(ItemLocationEnum.PrimaryHand, TestSword.Id); BattleEngine.CharacterList.Add(CharacterPlayer); // Set Monster Conditions // Add a monster to attack BattleEngine.MaxNumberPartyCharacters = 1; var MonsterPlayer = new EntityInfoModel( new MonsterModel { Speed = 10, Level = 10, CurrentHealth = 100, Experience = 100, Name = "Monster", }); BattleEngine.CharacterList.Add(MonsterPlayer); // Have dice roll to 20 DiceHelper.EnableForcedRolls(); DiceHelper.SetForcedRollValue(20); // EnableConfusionRounds BattleEngine.EnableConfusionRound = true; BattleEngine.NewRound(); //Act var result = BattleEngine.TakeTurn(CharacterPlayer); //Reset DiceHelper.DisableForcedRolls(); BattleEngine.EnableConfusionRound = false; //Assert Assert.AreEqual(true, result); Assert.AreEqual(AutoBattleEngine.BattleScore.ExperienceGainedTotal, 0); }
public void HackathonScenario_Scenario_7_If_Sleep_Monster_Should_Sleep() { /* * Scenario Number: * 7 * * Description: * The n Character can sleep monsters at (n-1)*2 + 1 Round * * Changes Required (Classes, Methods etc.) List Files, Methods, and Describe Changes: * Change to Turn Engine, Take Turn method, added switch check * Changed BaseEngine, added boolean switch for enabling Sleep, Added Awake to check if Monster is asleep * * Test Algrorithm: * Create Character * Call TakeTurn * * Test Conditions: * Test with Character Sleep Character * * Validation: * Verify Awake is false * */ //Arrange DiceHelper.EnableForcedRolls(); DiceHelper.SetForcedRollValue(0); // Set Character Conditions BattleEngine.MaxNumberPartyCharacters = 1; var TestSword = ItemViewModel.Dataset.Where(a => a.Location == ItemLocationEnum.PrimaryHand).FirstOrDefault(); var CharacterPlayer = new EntityInfoModel( new CharacterModel { Level = 10, CurrentHealth = 200, MaxHealth = 200, //TestDamage = 123, Experience = 100, Name = "Sleep Character", }); BattleEngine.CharacterList.Add(CharacterPlayer); // Set Monster Conditions // Add a monster to attack BattleEngine.MaxNumberPartyCharacters = 1; var MonsterPlayer = new EntityInfoModel( new MonsterModel { Speed = 1, Level = 10, CurrentHealth = 100, Experience = 100, Name = "Monster", }); BattleEngine.MonsterList.Add(MonsterPlayer); BattleEngine.SLEEPINGTEST = true; // Have dice roll to 20 DiceHelper.EnableForcedRolls(); DiceHelper.SetForcedRollValue(20); // EnableConfusionRounds BattleEngine.EnableConfusionRound = false; //BattleEngine.NewRound(); //Act var sleep = BattleEngine.TakeTurn(CharacterPlayer); //var result = BattleEngine.TakeTurn(MonsterPlayer); //Reset DiceHelper.DisableForcedRolls(); //Assert Assert.AreEqual(true, sleep); //Assert.IsTrue(BattleEngine.EnableConfusionRound); Assert.IsFalse(BattleEngine.Awake); }
/// <summary> /// Find a Desired Target /// Move close to them /// Get to move the number of Speed /// </summary> /// <param name="Attacker"></param> /// <returns></returns> public bool MoveAsTurn(EntityInfoModel Attacker, MapModelLocation targetLocation = null) { /* * TODO: TEAMS Work out your own move logic if you are implementing move * * Mike's Logic * The monster or charcter will move to a different square if one is open * Find the Desired Target * Jump to the closest space near the target that is open * * If no open spaces, return false * */ if (Attacker.PlayerType == PlayerTypeEnum.Monster) { // For Attack, Choose Who CurrentDefender = AttackChoice(Attacker); if (CurrentDefender == null) { return(false); } // Get X, Y for Defender var locationDefender = MapModel.GetLocationForPlayer(CurrentDefender); if (locationDefender == null) { return(false); } var locationAttacker = MapModel.GetLocationForPlayer(Attacker); if (locationAttacker == null) { return(false); } // Find Location Nearest to Defender that is Open. // Get the Open Locations var openSquare = MapModel.ReturnClosestEmptyLocation(locationDefender); Debug.WriteLine(string.Format("{0} moves from {1},{2} to {3},{4}", locationAttacker.Player.Name, locationAttacker.Column, locationAttacker.Row, openSquare.Column, openSquare.Row)); BattleMessageModel.TurnMessage = Attacker.Name + " moves closer to " + CurrentDefender.Name; return(MapModel.MovePlayerOnMap(locationAttacker, openSquare)); } else if (Attacker.PlayerType == PlayerTypeEnum.Character) { var locationAttacker = MapModel.GetLocationForPlayer(Attacker); if (locationAttacker == null) { return(false); } var openSquare = TargetLocation; Debug.WriteLine(string.Format("{0} moves from {1},{2} to {3},{4}", locationAttacker.Player.Name, locationAttacker.Column, locationAttacker.Row, openSquare.Column, openSquare.Row)); BattleMessageModel.TurnMessage = Attacker.Name + " moves to row: " + openSquare.Row + 1 + " column: " + openSquare.Column; return(MapModel.MovePlayerOnMap(locationAttacker, openSquare)); } return(true); }
/// <summary> /// Attack Action Deatil /// </summary> /// <param name="Attacker"></param> /// <param name="Target"></param> /// <returns></returns> public bool TurnAsAttack(EntityInfoModel Attacker, EntityInfoModel Target) { if (Attacker == null) { return(false); } if (Target == null) { return(false); } BattleMessageModel.ClearMessages(); CalculateAttackStatus(Attacker, Target); // Hackathon // Hackathon Scenario 2, Bob alwasys misses if (Attacker.Name.Equals("Bob")) { BattleMessageModel.HitStatus = HitStatusEnum.Miss; BattleMessageModel.TurnMessage = "Bob always Misses"; Debug.WriteLine(BattleMessageModel.TurnMessage); return(true); } if (PrimeNumber) { if (Attacker.PlayerType == PlayerTypeEnum.Character && IsPrime(Attacker)) { BattleMessageModel.HitStatus = HitStatusEnum.Hit; BattleMessageModel.TurnMessage = "Prime always Hit"; //Debug.WriteLine(Attacker.TestDamage); BattleMessageModel.DamageAmount = Attacker.GetDamageTotal; Debug.WriteLine(BattleMessageModel.TurnMessage); return(true); } } switch (BattleMessageModel.HitStatus) { case HitStatusEnum.Miss: // It's a Miss break; case HitStatusEnum.Hit: // It's a Hit BattleMessageModel.DamageAmount = Attacker.GetDamageRollValue(); ApplyDamage(Target); BattleMessageModel.TurnMessageSpecial = BattleMessageModel.GetCurrentHealthMessage(); // Check if the target dead. If dead, remove it RemoveIfDead(Target); // If Attacker is a Character, it should gain experience from Monster CalculateExperience(Attacker, Target); break; } BattleMessageModel.TurnMessage = Attacker.Name + BattleMessageModel.AttackStatus + Target.Name + BattleMessageModel.TurnMessageSpecial + BattleMessageModel.ExperienceEarned; Debug.WriteLine(BattleMessageModel.TurnMessage); if (Target.PlayerType == PlayerTypeEnum.Character) { UpdatePlayerList(Target); } return(true); }
// Attack or Move // Roll To Hit // Decide Hit or Miss // Decide Damage // Death // Drop Items // Turn Over #endregion Algrorithm /// <summary> /// CharacterModel Attacks... /// </summary> /// <param name="Attacker"></param> /// <returns></returns> public bool TakeTurn(EntityInfoModel Attacker) { // Choose Action. Such as Move, Attack etc. // INFO: Teams, if you have other actions they would go here. bool result = false; // Check for confusion round or not, if it is confusion round and rolled confusion, skip turn if (EnableConfusionRound && IsConfusionRound && DiceHelper.RollDice(1, 20) - Attacker.Level > 0) { BattleMessageModel.TurnMessage = Attacker.Name + " is confused."; Debug.WriteLine(BattleMessageModel.TurnMessage); return(true); } if (Attacker.PlayerType == PlayerTypeEnum.Monster) { if (BattleScore.TurnCount >= PlayerList.Count) { Awake = true; } /* * Order of Priority * If can attack Then Attack * Next use Ability or Move */ // Assume Move if nothing else happens CurrentAction = ActionEnum.Move; Debug.WriteLine(BattleScore.TurnCount); if (!Awake) { CurrentAction = ActionEnum.Sleep; } // See if Desired Target is within Range, and if so attack away else if (MapModel.IsTargetInRange(Attacker, AttackChoice(Attacker))) { CurrentAction = ActionEnum.Attack; } } else { if (SLEEPINGTEST) { int listNo = Attacker.ListOrder; if ((listNo * 2 + 1) == BattleScore.RoundCount) { foreach (var player in PlayerList) { if (player.PlayerType == PlayerTypeEnum.Monster) { player.FallAsleep(); } } Awake = false; } } if (false) { if (BattleScore.AutoBattle) { /* * Order of Priority * If can attack Then Attack * Next use Ability or Move */ // Assume Move if nothing else happens CurrentAction = ActionEnum.Move; // See if Desired Target is within Range, and if so attack away if (MapModel.IsTargetInRange(Attacker, AttackChoice(Attacker))) { CurrentAction = ActionEnum.Attack; } // Simple Logic is Roll to Try Ability. 50% says try else if (DiceHelper.RollDice(1, 10) > 5) { CurrentAction = ActionEnum.Ability; } } } } switch (CurrentAction) { case ActionEnum.Unknown: case ActionEnum.Attack: result = Attack(Attacker); break; case ActionEnum.Ability: result = UseAbility(Attacker); break; case ActionEnum.Sleep: result = FallAsleep(Attacker); break; case ActionEnum.Move: result = MoveAsTurn(Attacker, TargetLocation); break; } BattleScore.TurnCount++; return(result); //return result; }