public async Task BaseMonster_GetDamageTotalString_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 = 300, Id = "PrimaryHand", Damage = 1 });
var data = new BaseMonster();
data.Level = 1;
// Add the first item
data.AddItem(ItemLocationEnum.PrimaryHand, (await ItemIndexViewModel.Instance.ReadAsync("PrimaryHand")).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.GetDamageTotalString;
// Reset
Game.Helpers.DiceHelper.DisableForcedRolls();
// Assert
Assert.AreEqual("1 + 1D 1", result);
}
public void UnsubscribeActiveMonster(BaseMonster monster)
{
if (activeMonsters.Contains(monster))
{
activeMonsters.Remove(monster);
}
}
public void TurnEngine_TurnAsAttack_Character_Attacks_Monster_Levels_Up_Should_Pass()
{
// Arrange
var Monster = new BaseMonster();
var MonsterPlayer = new PlayerInfoModel(Monster);
Engine.MonsterList.Add(MonsterPlayer);
var Character = new BaseCharacter();
//Character.//ExperienceTotal = 300; // Enough for next level
var CharacterPlayer = new PlayerInfoModel(Character);
Engine.CharacterList.Add(CharacterPlayer);
// Forece a Miss
DiceHelper.EnableForcedRolls();
DiceHelper.SetForcedRollValue(20);
// Act
var result = Engine.TurnAsAttack(CharacterPlayer, MonsterPlayer);
// Reset
DiceHelper.DisableForcedRolls();
// Assert
Assert.AreEqual(true, result);
Assert.AreEqual(2, CharacterPlayer.Level);
}
public async Task MonsterModel_DropAllItems_Default_Should_Pass()
{
await ItemIndexViewModel.Instance.CreateAsync(new ItemModel { Attribute = AttributeEnum.Attack, Value = 1, Id = "head" });
var item = ItemIndexViewModel.Instance.Dataset.FirstOrDefault();
// Arrange
var data = new BaseMonster
{
Head = item.Id,
Necklass = item.Id,
PrimaryHand = item.Id,
OffHand = item.Id,
RightFinger = item.Id,
LeftFinger = item.Id,
Feet = item.Id,
};
// Act
var result = data.DropAllItems();
// Reset
// Assert
Assert.IsNotNull(result);
}
//[Test]
public void RoundEngine_Monsters_Buffed_Ten_Should_Return_True()
{
//Arrange
Engine.BattleScore.RoundCount = 101;
Engine.MonsterList.Clear();
var Monster = new BaseMonster
{
Speed = 10,
CurrHealth = 10,
MaxHealth = 10,
Attack = 10,
Defense = 10,
Name = "A",
};
var MonsterPlayer = new PlayerInfoModel(Monster);
Engine.MonsterList.Add(MonsterPlayer);
Engine.MaxNumberPartyMonsters = 1;
//Act
Engine.AddMonstersToRound();
var result = Engine.MonsterList;
//Reset
Engine.EndRound();
//Assert
Assert.AreEqual(true, result[0].Attack == 100);
}
public async Task BaseMonster_AddItem_Default_Replace_Should_Pass()
{
// Arrange
var data = new BaseMonster();
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" });
var itemOld = ItemIndexViewModel.Instance.Dataset.FirstOrDefault();
var itemNew = ItemIndexViewModel.Instance.Dataset.LastOrDefault();
// Add the first item
data.AddItem(ItemLocationEnum.Head, itemOld.Id);
// Act
// Add the second item, this will return the first item as the one replaced
var result = data.AddItem(ItemLocationEnum.Head, itemNew.Id);
// Reset
// Assert
Assert.AreEqual(itemOld.Id, result.Id);
}
public void Model_BaseMonster_Update_With_Valid_Data_Should_Pass()
{
var myDataDefault = DefaultModels.MonsterDefault();
var myData = new BaseMonster();
myData.Update(myDataDefault);
// Validate the new BaseMonster has the expected fields.
// All fields should match.
// The attirbute string is what is unique about creating from BaseBaseMonster, and should be passed down...
Assert.AreEqual(myData.UniqueItem, myDataDefault.UniqueItem, "UniqueItem " + TestContext.CurrentContext.Test.Name);
Assert.AreEqual(myData.Alive, myDataDefault.Alive, "Alive " + TestContext.CurrentContext.Test.Name);
Assert.AreEqual(myData.Name, myDataDefault.Name, "Name " + TestContext.CurrentContext.Test.Name);
Assert.AreEqual(myData.Description, myDataDefault.Description, "Description " + TestContext.CurrentContext.Test.Name);
Assert.AreEqual(myData.Level, myDataDefault.Level, "Level " + TestContext.CurrentContext.Test.Name);
Assert.AreEqual(myData.ExperienceTotal, myDataDefault.ExperienceTotal, "ExperienceTotal " + TestContext.CurrentContext.Test.Name);
Assert.AreEqual(myData.ImageURI, myDataDefault.ImageURI, "ImageURI " + TestContext.CurrentContext.Test.Name);
Assert.AreEqual(myData.Head, myDataDefault.Head, "Head " + TestContext.CurrentContext.Test.Name);
Assert.AreEqual(myData.Feet, myDataDefault.Feet, "Feet " + TestContext.CurrentContext.Test.Name);
Assert.AreEqual(myData.Necklass, myDataDefault.Necklass, "Necklass " + TestContext.CurrentContext.Test.Name);
Assert.AreEqual(myData.RightFinger, myDataDefault.RightFinger, "RightFinger " + TestContext.CurrentContext.Test.Name);
Assert.AreEqual(myData.LeftFinger, myDataDefault.LeftFinger, "LeftFinger " + TestContext.CurrentContext.Test.Name);
Assert.AreEqual(myData.Feet, myDataDefault.Feet, "Feet " + TestContext.CurrentContext.Test.Name);
// Validate the Attributes
Assert.AreEqual(myData.AttributeString, myDataDefault.AttributeString, "AttributeString " + TestContext.CurrentContext.Test.Name);
Assert.AreEqual(myData.Damage, myDataDefault.Damage, "AttributeString " + TestContext.CurrentContext.Test.Name);
}
public void TurnEngine_TurnAsAttack_Monster_Attacks_Character_Hit_Should_Pass()
{
// Arrange
var Monster = new BaseMonster();
var MonsterPlayer = new PlayerInfoModel(Monster);
Engine.MonsterList.Add(MonsterPlayer);
var Character = new BaseCharacter();
var CharacterPlayer = new PlayerInfoModel(Character);
Engine.CharacterList.Add(CharacterPlayer);
// Forece a Miss
DiceHelper.EnableForcedRolls();
DiceHelper.SetForcedRollValue(20);
// Act
var result = Engine.TurnAsAttack(MonsterPlayer, CharacterPlayer);
// Reset
DiceHelper.DisableForcedRolls();
// Assert
Assert.AreEqual(true, result);
}
public MoveAction(BaseMonster owner, Vector3 trg,Action<EndCause> callback)
: base(owner, callback)
{
this.trg = new Vector3(trg.x, owner.transform.position.y, trg.z);
//GameObject.Instantiate(DataBaseController.Instance.debugCube, this.trg, Quaternion.identity);
owner.Control.MoveTo(trg);
}
IEnumerator KnockBackOfSpawnBoss(BaseMonster monster)
{
if (monster.attackType != MonsterAttackType.Boss)
{
yield break;
}
var charactersNearbyTower = characterDisplayList.list.Where(x => Mathf.Abs(x.transform.position.x - spawningPoint.position.x) <= bossSpawnKnockBackRange).ToList();
if (!charactersNearbyTower.Any())
{
yield break;
}
charactersNearbyTower.ForEach(x => x.StopMove());
var targetPos = charactersNearbyTower.Select(x => new Vector2(x.transform.position.x - bossSpawnKnockBackRange, x.transform.position.y)).ToList();
var originPos = charactersNearbyTower.Select(x => x.transform.position).ToList();
var percent = 0f;
while (percent <= 1f)
{
var step = Time.deltaTime * _settings.deltaMoveStep * 12f;
percent += step;
for (var i = 0; i < charactersNearbyTower.Count; i++)
{
var character = charactersNearbyTower[i];
character.transform.position = Vector2.Lerp(originPos[i], targetPos[i], percent);
}
yield return(null);
}
charactersNearbyTower.ForEach(x => x.CanMove());
}
/// <summary>
/// 스킬을 사용합니다.
/// </summary>
/// <param name="attacker">스킬 시전자</param>
/// <param name="target">스킬을 맞는 대상</param>
/// <param name="setCool">true일 경우 스킬의 쿨타임이 생깁니다.</param>
public void Use(BaseMonster attacker, BaseMonster target, CancellationToken cancellation, bool setCool = true)
{
if (Cooldown > 0)
{
return;
}
try
{
Logic(attacker, target, cancellation);
Debug.Log($"스킬 종료");
}
catch (AggregateException e) when(e.InnerException is TaskCanceledException)
{
Debug.Log($"스킬 중단함");
return;
}
finally
{
if (setCool)
{
SetCooldownToDefault();
Task.Run(() => DecreaseCooldownAsync(cancellation));
}
Debug.Log($"set cooldown: {Cooldown}");
}
}
public override void ButtonBehavior1()
{
BaseMonster BM = MonsterFactory.CreateBaseMonster(Session.CurrentPlayer.Level, true);
Session.CurrentLocation.AddCharacter(BM);
Session.ReplaceDisplayText(BM.Name + " has appeared!");
}
private void Do(BaseMonster monster)
{
if (!isActivated)
{
isActivated = true;
StartCoroutine(WaitForAction());
}
}
public AttackAction(BaseMonster owner, Unit target ,Action<EndCause> endCallback)
: base(owner, endCallback)
{
this.target = target;
lastTargetScanPos = target.transform.position;
lastTargetScanPos = new Vector3(lastTargetScanPos.x, owner.transform.position.y, lastTargetScanPos.z);
rangeAttackSqr = owner.curWeapon.Parameters.range * owner.curWeapon.Parameters.range;
}
public void UpdateStatus()
{
rightPartnerData = rightPartner.GetComponent <BaseMonster>();
leftPartnerData = leftPartner.GetComponent <BaseMonster>();
if (!PlayerPrefs.HasKey("Hunger1"))
{
Debug.Log("no hunger key");
rightPartnerData._hunger = 100;
leftPartnerData._hunger = 100;
PlayerPrefs.SetFloat("Hunger1", rightPartnerData._hunger);
PlayerPrefs.SetFloat("Hunger2", leftPartnerData._hunger);
}
else
{
Debug.Log("you have a hunger key");
Debug.Log("you hunger1 is " + PlayerPrefs.GetFloat("Hunger1"));
rightPartnerData._hunger = PlayerPrefs.GetFloat("Hunger1");
leftPartnerData._hunger = PlayerPrefs.GetFloat("Hunger2");
}
if (!PlayerPrefs.HasKey("Happy1"))
{
Debug.Log("no happy key");
rightPartnerData._happiness = 100;
leftPartnerData._happiness = 100;
PlayerPrefs.SetFloat("Happy1", rightPartnerData._happiness);
PlayerPrefs.SetFloat("Happy2", leftPartnerData._happiness);
}
else
{
Debug.Log("your happy1 key is " + PlayerPrefs.GetFloat("Happy1"));
rightPartnerData._happiness = PlayerPrefs.GetFloat("Happy1");
leftPartnerData._happiness = PlayerPrefs.GetFloat("Happy2");
}
if (!PlayerPrefs.HasKey("then"))
{
PlayerPrefs.SetString("then", getStringTime());
}
//TimeSpan ts = getTimeSpan();
HungerPassTime();
HappyPassTime();
Debug.Log(getTimeSpan().ToString());
Debug.Log(getTimeSpan().TotalHours);
if (_serverTime)
{
updateServer();
}
else
{
InvokeRepeating("updateDevice", 0f, 30f);
}
}
public StayAction(BaseMonster owner, Action<EndCause> endCallback)
: base(owner, endCallback)
{
timer = MainController.Instance.TimerManager.MakeTimer(TimeSpan.FromSeconds(UnityEngine.Random.Range(2, 10)));
timer.OnTimer += () =>
{
endCallback(EndCause.no);
};
}
void onCollisionStayHero(BaseMonster monster, Hero hero)
{
var damage = monster.Attack(hero.transform.position);
if (damage > 0)
{
hero.ReceiveDamage(damage);
}
}
MonsterDisplay InstanceMonster(BaseMonster baseMonster)
{
var z = Random.Range(-1f, 1f);
var spawningPosition = spawningPoint.position + Vector3.forward * z;
var instance = Instantiate <MonsterDisplay> (baseMonster.displayPrefab, spawningPosition, Quaternion.identity);
instance.baseObject = baseMonster;
return(instance);
}
/// <summary>
/// Create Random Character for the battle
/// </summary>
/// <param name="MaxLevel"></param>
/// <returns></returns>
public static BaseMonster GetRandomMonster(int MaxLevel)
{
// If there are no Monsters in the system, return a default one
if (MonsterViewModel.Instance.Dataset.Count == 0)
{
return(new BaseMonster());
}
var rnd = DiceHelper.RollDice(1, MonsterViewModel.Instance.Dataset.Count);
var result = new BaseMonster(MonsterViewModel.Instance.Dataset.ElementAt(rnd - 1))
{
Level = DiceHelper.RollDice(1, MaxLevel),
// Randomize Name
Name = GetMonsterName(),
Description = GetMonsterDescription(),
// Randomize the Attributes
Attack = GetAbilityValue(),
Speed = GetAbilityValue(),
Defense = GetAbilityValue(),
ImageURI = GetMonsterImage(),
Difficulty = GetMonsterDifficultyValue()
};
// Adjust values based on Difficulty
result.Attack = result.Difficulty.ToModifier(result.Attack);
result.Defense = result.Difficulty.ToModifier(result.Defense);
result.Speed = result.Difficulty.ToModifier(result.Speed);
result.Level = result.Difficulty.ToModifier(result.Level);
// Get the new Max Health
result.MaxHealth = DiceHelper.RollDice(result.Level, 10);
// Adjust the health, If the new Max Health is above the rule for the level, use the original
var MaxHealthAdjusted = result.Difficulty.ToModifier(result.MaxHealth);
if (MaxHealthAdjusted < result.Level * 10)
{
result.MaxHealth = MaxHealthAdjusted;
}
// Level up to the new level
result.LevelUpToValue(result.Level);
// Set ExperienceRemaining so Monsters can both use this method
result.ExperienceRemaining = LevelTableHelper.Instance.LevelDetailsList[result.Level + 1].Experience;
// Enter Battle at full health
result.CurrHealth = result.MaxHealth;
return(result);
}
public BattleInstance(GameSession session, PlayerCharacter player, BaseMonster monster)
{
CurrentSession = session;
CurrentSession.ButtonContext = new BattleButtonContext(CurrentSession, this);
CurrentPlayer = player;
CurrentMonster = monster;
DiceRoller = new Roller();
}
public FreezEffet(Unit targetUnit, float totalTime)
: base(targetUnit, totalTime)
{
EffectType = EffectType.freez;
monster = targetUnit as BaseMonster;
if (monster != null)
{
monster.Disable();
}
}
public void BaseMonster_Set_Get_Default_Should_Pass()
{
// Arrange
var result = new BaseMonster();
// Act
result.Id = "bogus";
result.ImageURI = "uri";
result.PlayerType = PlayerTypeEnum.Monster;
result.Alive = false;
result.Order = 100;
result.Guid = "guid";
result.ListOrder = 200;
result.Speed = 300;
result.Level = 400;
result.ExperienceRemaining = 500;
result.CurrHealth = 600;
result.MaxHealth = 700;
result.Experience = 800;
result.Defense = 900;
result.Attack = 123;
result.Head = "head";
result.Feet = "feet";
result.Necklass = "necklass";
result.PrimaryHand = "primaryhand";
result.OffHand = "offhand";
result.RightFinger = "rightfinger";
result.LeftFinger = "leftfinger";
// Reset
// Assert
Assert.AreEqual("bogus", result.Id);
Assert.AreEqual("uri", result.ImageURI);
Assert.AreEqual(PlayerTypeEnum.Monster, result.PlayerType);
Assert.AreEqual(false, result.Alive);
Assert.AreEqual(100, result.Order);
Assert.AreEqual("guid", result.Guid);
Assert.AreEqual(200, result.ListOrder);
Assert.AreEqual(300, result.Speed);
Assert.AreEqual(400, result.Level);
Assert.AreEqual(500, result.ExperienceRemaining);
Assert.AreEqual(600, result.CurrHealth);
Assert.AreEqual(700, result.MaxHealth);
Assert.AreEqual(800, result.Experience);
Assert.AreEqual(900, result.Defense);
Assert.AreEqual(123, result.Attack);
Assert.AreEqual("head", result.Head);
Assert.AreEqual("feet", result.Feet);
Assert.AreEqual("necklass", result.Necklass);
Assert.AreEqual("primaryhand", result.PrimaryHand);
Assert.AreEqual("offhand", result.OffHand);
Assert.AreEqual("rightfinger", result.RightFinger);
Assert.AreEqual("leftfinger", result.LeftFinger);
}
public async Task <bool> UpdateAsync_Monster(Monster data)
{
var dataBase = new BaseMonster(data);
var result = await App.Database.UpdateAsync(dataBase);
if (result == 1)
{
return(true);
}
return(false);
}
public void BaseMonster_Constructor_Default_Should_Pass()
{
// Arrange
// Act
var result = new BaseMonster();
// Reset
// Assert
Assert.IsNotNull(result);
}
public void BaseMonster_GetHealthMax_Default_Should_Pass()
{
// Arrange
var data = new BaseMonster();
// Act
var result = data.GetMaxHealthTotal;
// Reset
// Assert
Assert.AreEqual(1, result);
}
public void BaseMonster_GetItemByLocation_LeftFinger_Default_Should_Pass()
{
// Arrange
var data = new BaseMonster();
// Act
var result = data.GetItemByLocation(ItemLocationEnum.LeftFinger);
// Reset
// Assert
Assert.AreEqual(null, result);
}
public void clicked(GameObject click)
{
clickedGameObject = click;
Debug.Log("asdafwf" + clickedGameObject.GetComponent <BaseMonster>().getHP());
monsterSelected = clickedGameObject.GetComponent <BaseMonster>();
select1.SetActive(false);
select2.SetActive(false);
select3.SetActive(false);
monsterSelected.transform.parent.gameObject.transform.GetChild(0).gameObject.SetActive(true);
Debug.Log("parent child " + monsterSelected.transform.parent.gameObject.transform.GetChild(0));
msg.text = characterList[currentSelection].getPName() + " attacking " + monsterSelected.getPName();
}
public void PlayerInfoModel_Constructor_Monster_Default_Should_Pass()
{
// Arrange
var data = new BaseMonster();
// Act
var result = new PlayerInfoModel(data);
// Reset
// Assert
Assert.IsNotNull(result);
}
public void BaseMonster_AddExperience_Default_Should_Pass()
{
// Arrange
var data = new BaseMonster();
// Act
var result = data.AddExperience(0);
// Reset
// Assert
Assert.AreEqual(false, result);
}
public void BaseMonster_GetItem_Default_Should_Pass()
{
// Arrange
var data = new BaseMonster();
// Act
var result = data.GetItem("test");
// Reset
// Assert
Assert.AreEqual(null, result);
}
public void BaseMonster_GetSpeed_Default_Should_Pass()
{
// Arrange
var data = new BaseMonster();
// Act
var result = data.GetSpeed();
// Reset
// Assert
Assert.AreEqual(1, result);
}
public void BaseMontser_FormatOutput_Default_Should_Pass()
{
// Arrange
var data = new BaseMonster();
// Act
var result = data.FormatOutput();
// Reset
// Assert
Assert.AreEqual(true, result.Contains("MIKE"));
}
public void BaseMonster_CauseDeath_Default_Should_Pass()
{
// Arrange
var data = new BaseMonster();
// Act
var result = data.CauseDeath();
// Reset
// Assert
Assert.AreEqual(false, result);
}
public void BaseMonster_AddItem_Unknown_Should_Fail()
{
// Arrange
var data = new BaseMonster();
// Act
var result = data.AddItem(ItemLocationEnum.Unknown, "bogus");
// Reset
// Assert
Assert.AreEqual(null, result);
}
public void BaseMonster_CalculateExperienceEarned_Default_Should_Pass()
{
// Arrange
var data = new BaseMonster();
// Act
var result = data.CalculateExperienceEarned(0);
// Reset
// Assert
Assert.AreEqual(0, result);
}
private void OnMonsterGetHit(BaseMonster obj)
{
MonsterSliderHP.gameObject.SetActive(true);
if (animator != null && !isOpen)
{
animator.SetTrigger(KEY_OPEN);
// Debug.Log("SetTrigger(KEY_OPEN)");
isOpen = true;
}
MonsterSliderHP.value = obj.CurHp / obj.Parameters[ParamType.Heath];
if (timer != null)
{
timer.Stop();
}
timer = MainController.Instance.TimerManager.MakeTimer(span);
timer.OnTimer += OnTimer;
}
public AttackCloseCombat(BaseMonster owner, Unit target, Action<EndCause> endCallback,bool byHit)
: base(owner, target, endCallback)
{
if (!byHit && UnityEngine.Random.Range(0, 100) < 50)
{
isActivated = false;
var dir = target.transform.position - owner.transform.position;
owner.Control.ThisByQuaterhnion.SetLookDir(dir);
var waitTime = UnityEngine.Random.Range(1.5f, 3f);
activateTime = Time.time + waitTime;
// Debug.Log("tupiiim:" + waitTime);
}
else
{
isActivated = true;
}
}
public AttackCloseCombat(BaseMonster owner, Unit target, Action endCallback)
: base(owner, target, endCallback)
{
}
public AttackDistance(BaseMonster owner, Unit target, Action<EndCause> endCallback,bool byHit)
: base(owner, target, endCallback)
{
}
private void Attack(BaseMonster monster)
{
var bullet = DataBaseController.GetItem<Bullet>(bulletPrefab);
bullet.Init(monster, talic, transform.position);
}
private bool CanAttackMonster(BaseMonster monster)
{
var delta = DateTime.Now - monstersInside[monster];
return (delta > deltaSpan);
}
public AttackDistance(BaseMonster owner, Unit target, Action endCallback)
: base(owner, target, endCallback)
{
}
public AttackHitAndRun(BaseMonster owner, Unit target, Action endCallback) : base(owner, target, endCallback)
{
}
public BaseAction(BaseMonster owner,Action<EndCause> endCallback)
{
this.endCallback = endCallback;
this.owner = owner;
}
