public void OnFocusMonsterChanged(MonsterModel model)
{
if (model == null)
{
return;
}
var text = this.GetComponent<Text> ();
text.text = "000" + model.monsterId;
}
public void OnFocusMonsterChanged(MonsterModel model)
{
if (model == null)
{
return;
}
var renderer = this.GetComponent<Renderer> ();
renderer.material.color = model.materialColor;
}
public void MonsterModel_DropItemBasedOnCharacterType_Default_Should_Pass()
{
// Arrange
var data = new MonsterModel();
// Act
// Create ItemModel based on Default SpecificMonsterType, which is Teaching Assistant
var result = data.DropItemBasedOnCharacterType(data.SpecificMonsterTypeEnum);
// Reset
// Assert
Assert.AreEqual(ItemTypeEnum.IndexCards, result.ItemType);
}
public void MonsterModel_FormatOutput_Default_Should_Pass()
{
// Arrange
var data = new MonsterModel();
// Act
var result = data.FormatOutput();
// Reset
// Assert
Assert.AreEqual(true, result.Contains(data.Name + " , " + data.Description + " , Difficulty : "
+ data.Difficulty.ToString() + " , Total Experience : " + data.ExperienceTotal +
" , Items : " + data.ItemSlotsFormatOutput() + " , Damage : " + data.GetDamageTotalString));
}
/// <summary>
/// Redirect to the read page for the clicked Monster.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public async void ReadMonster_Clicked(object sender, EventArgs args)
{
var button = sender as ImageButton;
String monsterId = button.CommandParameter as String;
MonsterModel data = ViewModel.Dataset.FirstOrDefault(itm => itm.Id == monsterId);
if (data == null)
{
return;
}
// Open the Read Page
await Navigation.PushAsync(new MonsterReadPage(new GenericViewModel <MonsterModel>(data)));
}
public async Task MonsterIndexViewModel_Update_Invalid_Bogus_Should_Fail()
{
// Arrange
// Update only updates what is in the list, so update on something that does not exist will fail
var newData = new MonsterModel();
// Act
var result = await ViewModel.UpdateAsync(newData);
// Reset
// Assert
Assert.AreEqual(false, result); // Update returned fail
}
public void PlayerInfoModel_Constructor_Monster_Max_Level_Should_Pass()
{
// Arrange
var data = new MonsterModel();
data.Level = 50;
// Act
var result = new PlayerInfoModel(data);
// Reset
// Assert
Assert.IsNotNull(result);
}
/// <summary>
/// The row selected from the list
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
async void OnItemSelected(object sender, SelectedItemChangedEventArgs args)
{
MonsterModel data = args.SelectedItem as MonsterModel;
if (data == null)
{
return;
}
// Open the Read Page
await Navigation.PushAsync(new MonsterReadPage(new GenericViewModel <MonsterModel>(data)));
// Manually deselect item.
MonsterListView.SelectedItem = null;
}
public IActionResult Create([FromBody] MonsterModel monster)
{
if (monster == null)
{
return(BadRequest());
}
var serializer = new JsonSerializerSettings();
serializer.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
var retorno = new JsonResult(_monsterBusiness.Create(monster), serializer);
retorno.StatusCode = 201;
return(retorno);
}
public void MonsterModel_Update_InValid_Null_Should_Fail()
{
// Arrange
var dataOriginal = new MonsterModel();
dataOriginal.Attack = 2;
// Act
var result = dataOriginal.Update(null);
// Reset
// Assert
Assert.AreEqual(2, dataOriginal.Attack);
}
/// <summary>
/// The row selected from the list
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
async void OnMonSelected(object sender, SelectedItemChangedEventArgs args)
{
MonsterModel Mon = args.SelectedItem as MonsterModel;
if (Mon == null)
{
return;
}
// Open the Read Page
await Navigation.PushAsync(new MonReadPage(new MonsterViewModel(Mon)));
// Manually deselect item.
MonListView.SelectedItem = null;
}
public void MonsterModel_Get_Default_Should_Pass()
{
// Arrange
// Act
var result = new MonsterModel();
// Reset
// Assert
Assert.IsNotNull(result.Range);
Assert.IsNotNull(result.Speed);
Assert.IsNotNull(result.Defense);
Assert.IsNotNull(result.Level);
}
public void RoundEngine_OrderPlayerListByTurnOrder_Valid_Experience_Higher_Should_Be_Z()
{
// Arrange
var Monster = new MonsterModel
{
Speed = 20,
Level = 1,
CurrentHealth = 100,
ExperienceTotal = 1,
Name = "Z",
ListOrder = 1,
};
var MonsterPlayer = new PlayerInfoModel(Monster);
Engine.EngineSettings.MonsterList.Clear();
Engine.EngineSettings.MonsterList.Add(MonsterPlayer);
var Character = new CharacterModel
{
Speed = 20,
Level = 1,
CurrentHealth = 2,
ExperienceTotal = 1,
Name = "C",
ListOrder = 10,
};
var CharacterPlayer = new PlayerInfoModel(Character);
Engine.EngineSettings.CharacterList.Clear();
Engine.EngineSettings.CharacterList.Add(CharacterPlayer);
// Make the List
Engine.EngineSettings.PlayerList = Engine.Round.MakePlayerList();
// Sort the list by Current Health, so it has to be resorted.
Engine.EngineSettings.PlayerList = Engine.EngineSettings.PlayerList.OrderBy(m => m.CurrentHealth).ToList();
// Act
var result = Engine.Round.OrderPlayerListByTurnOrder();
// Reset
// Assert
Assert.AreEqual("Z", result[0].Name);
}
public void RoundEngine_OrderPlayerListByTurnOrder_Level_Higher_Should_Pass()
{
// Arrange
var Monster = new MonsterModel
{
Speed = 20,
Level = 20,
CurrentHealth = 100,
ExperienceTotal = 1000,
Name = "Z",
ListOrder = 1,
Guid = "me"
};
var MonsterPlayer = new PlayerInfoModel(Monster);
Engine.MonsterList.Clear();
Engine.MonsterList.Add(MonsterPlayer);
var Character = new CharacterModel
{
Speed = 20,
Level = 1,
CurrentHealth = 2,
ExperienceTotal = 1,
Name = "C",
ListOrder = 10
};
var CharacterPlayer = new PlayerInfoModel(Character);
Engine.CharacterList.Clear();
Engine.CharacterList.Add(CharacterPlayer);
// Make the List
Engine.PlayerList = Engine.MakePlayerList();
// Sort the list by Current Health, so it has to be resorted.
Engine.PlayerList = Engine.PlayerList.OrderBy(m => m.CurrentHealth).ToList();
// Act
var result = Engine.OrderPlayerListByTurnOrder(1);
// Reset
// Assert
Assert.AreEqual("me", result[0].Guid);
}
public HttpResponseMessage PostCreateMonster(
MonsterModel model,
[ValueProvider(typeof(HeaderValueProviderFactory <string>))] string sessionKey)
{
var responseMsg = this.PerformOperationAndHandleExceptions(
() =>
{
if (model.Name == null)
{
throw new ArgumentNullException("name", "The name cannot be null!");
}
var context = new StoreContext();
using (context)
{
var admin = context.Admins.FirstOrDefault(adm => adm.SessionKey == sessionKey);
if (admin == null)
{
throw new InvalidOperationException("You are not admin!");
}
var monster = new Monster()
{
Name = model.Name,
MeleAttack = model.MeleAttack,
MagicAttack = model.MagicAttack,
MagicDefense = model.MagicDefense,
MeleDefense = model.MeleDefense,
HP = model.HP
};
context.Monsters.Add(monster);
context.SaveChanges();
var createdMonsterModel = new CreatedMonsterModel()
{
Monsterid = monster.MonsterId,
Name = monster.Name
};
var response =
this.Request.CreateResponse(HttpStatusCode.Created, createdMonsterModel);
return(response);
}
});
return(responseMsg);
}
//method for updating a monster
public async Task <bool> Update(MonsterModel data)
{
var record = await Read(data.Id);
if (record == null)
{
return(false);
}
record.Update(data);
var result = await DataStore.UpdateAsync(record);
await ExecuteLoadDataCommand();
return(result);
}
public void TurnEngine_SelectMonsterToAttack_InValid_Empty_List_Should_Fail()
{
// Arrange
var MonsterModel = new MonsterModel();
Engine.MonsterList = new List <MonsterModel>();
// Act
var result = Engine.SelectMonsterToAttack();
// Reset
Engine.StartBattle(false); // Clear the Engine
// Assert
Assert.AreEqual(null, result);
}
public void MonsterIndexViewModel_Create_Sync_Valid_Update_Should_Pass()
{
// Arrange
var data = new MonsterModel
{
Name = "New Item"
};
// Act
var result = ViewModel.Create_Sync(data);
// Reset
// Assert
Assert.AreEqual(true, result); // Update returned Pass
}
public void MonsterModel_Constructor_New_Item_Should_Copy()
{
// Arrange
var dataNew = new MonsterModel();
dataNew.Attack = 2;
dataNew.Id = "oldID";
// Act
var result = new MonsterModel(dataNew);
// Reset
// Assert
Assert.AreNotEqual("oldID", result.Id);
}
public async Task MonsterIndexViewModel_Delete_Invalid_Should_Fail()
{
// Arrange
var data = new MonsterModel
{
Id = "bogus"
};
// Act
var result = await ViewModel.DeleteAsync(data);
// Reset
// Assert
Assert.AreEqual(false, result); // Delete returned fail
}
/// <summary>
/// Constructor that takes and existing monster item
/// </summary>
public MonsterUpdatePage(GenericViewModel <MonsterModel> data)
{
InitializeComponent();
BindingContext = this.ViewModel = data;
this.ViewModel.Title = "Update " + data.Title;
// Make a copy of the monster for cancel to restore
DataCopy = new MonsterModel(data.Data);
// Default difficulty level to current difficulty level
DifficultyLevelPicker.SelectedItem = ViewModel.Data.Difficulty.ToMessage();
AddUniqueDropItemToDisplay();
}
public void MonsterModel_Default_GetAttackValue_Should_Pass()
{
// Arrange
var data = new MonsterModel();
// Act
DiceHelper.ForceConstantRoll = true;
DiceHelper.SetForcedDiceRollValue(1);
var result = data.GetAttackValue(); // roll + level
// Reset
DiceHelper.ForceConstantRoll = false;
// Assert
Assert.AreEqual(2, result);
}
public void MonsterIndexPage_OnImageClicked_Clicked_Not_Null_Should_Pass()
{
// Arrange
ImageButton img = new ImageButton();
MonsterModel cm = new MonsterModel();
img.BindingContext = cm;
// Act
page.OnImageClicked(img, null);
//Reset
// Assert
Assert.IsTrue(true);
}
public void SetFocustMonster(MonsterModel model)
{
if (model == focusMonster.Value)
{
if (!selectedMosnters.Contains (model)) {
selectedMosnters.Add (model);
} else {
selectedMosnters.Remove (model);
}
return;
}
int index = monsters.IndexOf (model);
this.focusMonster.Value = monsters[index];
}
public void MonsterIndexPage_OnMonsterSelected_Clicked_Default_Should_Pass()
{
// Arrange
var selectedMonster = new MonsterModel();
var selectedMonsterChangedEventArgs = new SelectedItemChangedEventArgs(selectedMonster, 0);
// Act
page.OnItemSelected(null, selectedMonsterChangedEventArgs);
// Reset
// Assert
Assert.IsTrue(true); // Got to here, so it happened...
}
/// <summary>
/// Gets monster xp
/// </summary>
public int GetMonsterXP(MonsterModel monsterModel)
{
int xp = 0;
string xpString = _stringService.CRXPString(monsterModel.CR);
if (!String.IsNullOrWhiteSpace(xpString))
{
if (Int32.TryParse(xpString.Replace(",", ""), out int parsedXP))
{
xp = parsedXP;
}
}
return(xp);
}
public void TurnEngine_TakeTurn_Empty_Attacker_Should_Not_Pass()
{
// Arrange
Engine.Attacker = null;
var MonsterInfo = new MonsterModel();
Engine.Target = new DungeonFighterModel(MonsterInfo);
// Act
var result = Engine.TakeTurn();
// Reset
// Assert
Assert.AreEqual(false, result);
}
public Monster(MonsterModel model, int grade)
{
Model = model;
Level = grade;
if (model.Levels.Any(x => x.Level == grade))
{
MonsterLevel = model.Levels.First(x => x.Level == grade);
}
else
{
MonsterLevel = model.Levels[0];
}
Life = MonsterLevel.Life;
}
public async Task MonsterModel_GetDamageRollAttack_Default_Speed_Should_Pass()
{
// Arrange
// Add each model here to warm up and load it.
Game.Helpers.DataSetsHelper.WarmUp();
await ItemIndexViewModel.Instance.CreateAsync(new ItemModel { Attribute = AttributeEnum.Attack, Value = 1, Id = "head" });
await ItemIndexViewModel.Instance.CreateAsync(new ItemModel { Attribute = AttributeEnum.Attack, Value = 20, Id = "necklass" });
await ItemIndexViewModel.Instance.CreateAsync(new ItemModel { Attribute = AttributeEnum.Attack, Value = 300, Id = "PrimaryHand" });
await ItemIndexViewModel.Instance.CreateAsync(new ItemModel { Attribute = AttributeEnum.Attack, Value = 4000, Id = "OffHand" });
await ItemIndexViewModel.Instance.CreateAsync(new ItemModel { Attribute = AttributeEnum.Attack, Value = 50000, Id = "RightFinger" });
await ItemIndexViewModel.Instance.CreateAsync(new ItemModel { Attribute = AttributeEnum.Attack, Value = 600000, Id = "LeftFinger" });
await ItemIndexViewModel.Instance.CreateAsync(new ItemModel { Attribute = AttributeEnum.Attack, Value = 7000000, Id = "feet" });
var data = new MonsterModel();
data.Level = 1;
// Add the first item
data.AddItem(ItemLocationEnum.Head, (await ItemIndexViewModel.Instance.ReadAsync("head")).Id);
data.AddItem(ItemLocationEnum.Necklass, (await ItemIndexViewModel.Instance.ReadAsync("necklass")).Id);
data.AddItem(ItemLocationEnum.PrimaryHand, (await ItemIndexViewModel.Instance.ReadAsync("PrimaryHand")).Id);
data.AddItem(ItemLocationEnum.OffHand, (await ItemIndexViewModel.Instance.ReadAsync("OffHand")).Id);
data.AddItem(ItemLocationEnum.RightFinger, (await ItemIndexViewModel.Instance.ReadAsync("RightFinger")).Id);
data.AddItem(ItemLocationEnum.LeftFinger, (await ItemIndexViewModel.Instance.ReadAsync("LeftFinger")).Id);
data.AddItem(ItemLocationEnum.Feet, (await ItemIndexViewModel.Instance.ReadAsync("feet")).Id);
Game.Helpers.DiceHelper.EnableForcedRolls();
Game.Helpers.DiceHelper.SetForcedRollValue(1);
// Act
// Add the second item, this will return the first item as the one replaced
var result = data.GetDamageRollValue();
// Reset
Game.Helpers.DiceHelper.DisableForcedRolls();
// Assert
Assert.AreEqual(2, result);
}
public void RoundEngine_RoundNextTurn_Characters_Monsters_Should_Return_NewRound()
{
Engine.MonsterList.Clear();
// Arrange
var Character = new CharacterModel
{
Speed = 20,
Level = 1,
CurrentHealth = 1,
ExperienceTotal = 1,
Name = "Characer",
ListOrder = 1,
};
var Monster = new MonsterModel
{
Speed = 20,
Level = 1,
CurrentHealth = 1,
ExperienceTotal = 1,
Name = "Monster",
ListOrder = 1,
};
// Add each model here to warm up and load it.
Game.Helpers.DataSetsHelper.WarmUp();
var CharacterPlayer = new PlayerInfoModel(Character);
Engine.CharacterList.Clear();
Engine.CharacterList.Add(new PlayerInfoModel(Character));
Engine.MonsterList.Add(new PlayerInfoModel(Character));
// Make the List
Engine.PlayerList = Engine.MakePlayerList();
// Act
var result = Engine.RoundNextTurn();
// Reset
// Assert
Assert.AreEqual(RoundEnum.NextTurn, result);
}
public void TurnEngine_TargedDied_Valid_Monseter_Should_Pass()
{
// Arrange
var player = new MonsterModel();
var PlayerInfo = new PlayerInfoModel(player);
Engine.EngineSettings.CharacterList.Add(PlayerInfo);
// Act
var result = Engine.Round.Turn.TargetDied(PlayerInfo);
// Reset
// Assert
Assert.AreEqual(true, result);
}
public async Task MonsterModel_GetItemByLocation_Unknown_Default_Should_Pass()
{
// Arrange
var data = new MonsterModel();
await ItemIndexViewModel.Instance.CreateAsync(new ItemModel { Attribute = AttributeEnum.Attack, Value = 1, Id = "head" });
await ItemIndexViewModel.Instance.CreateAsync(new ItemModel { Attribute = AttributeEnum.Attack, Value = 20, Id = "necklass" });
// Act
var result = data.GetItemByLocation(ItemLocationEnum.Unknown);
// Reset
// Assert
Assert.AreEqual(null, result);
}
public void TurnEngine_CalculateAttackStatus_Valid_Character_Student_Should_Pass()
{
// Arrange
CharacterModel attacker = new CharacterModel {
PlayerType = PlayerTypeEnum.Character,
CharacterTypeEnum = CharacterTypeEnum.Student,
};
MonsterModel defender = new MonsterModel();
// Act
var result = ((TurnEngine)Engine.Round.Turn).CalculateAttackStatus(new PlayerInfoModel(attacker), new PlayerInfoModel(defender));
// Reset
// Assert
Assert.IsNotNull(result);
}
/// <summary>
/// Initializes the view.
/// </summary>
/// <param name="mosnter">Mosnter.</param>
public void InitializeView(MonsterModel mosnter)
{
_text = this.transform.FindChild ("Text").GetComponent<Text>();
_text.text = "000" + mosnter.monsterId;
}
