private void DoSummon(BattleSummonVO _vo, Action _del)
{
CreateMoneyTf();
Hero hero = battle.heroMapDic [_vo.pos];
HeroBattle heroBattle = AddHeroToMap(hero);
heroBattle.transform.localScale = Vector3.zero;
Action <float> toDel = delegate(float obj) {
float scale = heroScale * obj;
heroBattle.transform.localScale = new Vector3(scale, scale, scale);
};
Action endDel = delegate() {
SuperTween.Instance.DelayCall(0.5f, _del);
};
SuperTween.Instance.To(10, 1, 0.5f, toDel, endDel);
ClearCards();
CreateCards();
}
public void AddToInventory(HeroBattle hero, string itemName)
{
if (itemName == null)
{
throw new CannotUseNullAsAnItemException();
}
var item = ItemResource.GetItemByName(itemName);
if (item == null)
{
throw new CannotFindItemException(itemName);
}
if (!CanBeUsedBy(hero, item))
{
throw new ItemCannotBeUsedByThisClassException();
}
var inventory = hero.Inventory.ToList();
inventory.Add(item);
hero.Inventory = inventory.ToArray();
Save(hero.Name, hero.Inventory);
}
private void Save(HeroBattle hero, string skillName, string skillKnowledge)
{
var sks = GetSkillsFrom(hero.Name);
var sk = new SkillKnowledge()
{
skill = skillName,
knowledge = skillKnowledge
};
var skill = sks.Find(s => s.skill.Equals(skillName));
if (skill == null)
{
sks.Add(sk);
}
else
{
skill.skill = sk.skill;
skill.knowledge = sk.knowledge;
}
SkillResource.Save(hero.Name, new SkillKnowledgeContainer()
{
skills = sks
});
}
public static void Attack(HeroBattle hero, Enemy enemy)
{
var item = hero.Inventory.FirstOrDefault(it => it.type.Equals(ItemType.Weapon) && it.isEquipped);
if (item == null)
{
throw new CannotFindEquippedItemException();
}
var precision = CalculatePrecision(hero, item);
var dodge = CalculateDodge(enemy);
if (precision <= dodge)
{
return;
}
int attackValue;
if (item.effect.Contains('-'))
{
var effect = item.effect.Split('-');
var min = int.Parse(effect[0]);
var max = int.Parse(effect[1]);
attackValue = new Random().Next(min, max) + hero.Level;
}
else
{
int.TryParse(item.effect, out attackValue);
}
enemy.currentHp -= (attackValue - enemy.armor);
}
private static int CalculatePrecision(HeroBattle hero, Item item)
{
var skillPrecision = 0;
foreach (var skill in hero.Skills)
{
if (skill.effect.precision == null)
{
continue;
}
int.TryParse(skill.effect.precision, out var aux);
skillPrecision += aux;
}
int weaponPrecision;
if (item.precision != null)
{
int.TryParse(item.precision, out weaponPrecision);
}
else
{
weaponPrecision = 0;
}
var minPrecision = hero.Level;
var maxPrecision = hero.Level + weaponPrecision;
return(new Random().Next(minPrecision, maxPrecision) + skillPrecision);
}
public async Task SetWinner(int winnerId, int battleId)
{
HeroBattle heroBattle = _context.HeroBattles
.Where(hb => hb.Hero.Id == winnerId && hb.Battle.Id == battleId).FirstOrDefault();
heroBattle.HasWon = true;
await _context.SaveChangesAsync();
}
public void Save(HeroBattle hero)
{
var data = GetStatusFrom(hero.Name);
data.currentHp = hero.CurrentHp;
data.xp = hero.Xp;
StatusResource.Save(hero.Name, data);
}
private void AddHeroToMapReal(HeroBattle _heroCard, int _pos)
{
MapUnit mapUnit = mapUnitDic [_pos];
_heroCard.SetFrameVisible(false);
_heroCard.transform.SetParent(heroContainer, false);
_heroCard.transform.localPosition = mapUnit.transform.localPosition;
_heroCard.transform.localScale = new Vector3(heroScale, heroScale, heroScale);
}
private void DoRush(BattleRushVO _vo, Action _del)
{
List <HeroBattle> attackers = new List <HeroBattle> ();
HeroBattle stander = heroDic [_vo.stander];
for (int i = 0; i < _vo.attackers.Count; i++)
{
attackers.Add(heroDic[_vo.attackers[i]]);
}
BattleControl.Instance.Rush(attackers, stander, _vo.damage, _del);
}
private HeroBattle AddHeroToMap(Hero _hero)
{
GameObject go = GameObject.Instantiate <GameObject>(Resources.Load <GameObject>("HeroBattle"));
HeroBattle hero = go.GetComponent <HeroBattle>();
heroDic.Add(_hero.pos, hero);
hero.Init(_hero);
AddHeroToMapReal(hero, _hero.pos);
return(hero);
}
private void SetNowChooseHero(HeroBattle _value, bool _canAction)
{
if (_value == null)
{
heroDetail.Hide(m_nowChooseHero);
}
else
{
heroDetail.Show(_value);
}
m_nowChooseHero = _value;
nowChooseHeroCanAction = _canAction;
}
private void DoPowerChange(BattlePowerChangeVO _vo, Action _del)
{
for (int i = 0; i < _vo.pos.Count; i++)
{
int pos = _vo.pos[i];
int powerChange = _vo.powerChange[i];
bool isDizz = _vo.isDizz[i];
HeroBattle hero = heroDic[pos];
hero.RefreshPower();
string str;
Color color;
if (powerChange > 0)
{
str = "+" + ((int)(powerChange / 100)).ToString();
color = Color.blue;
}
else
{
if (isDizz)
{
str = ((int)(powerChange / 100)).ToString() + " 混乱";
}
else
{
str = ((int)(powerChange / 100)).ToString();
}
color = Color.yellow;
}
if (i == 0)
{
hero.ShowHud(str, color, _del);
}
else
{
hero.ShowHud(str, color, null);
}
}
}
public void Rush(List <HeroBattle> _attackers, HeroBattle _stander, int _damage, Action _callBack)
{
bool getHit = false;
Action <float> moveToDel = delegate(float obj) {
float value = attackCurve.Evaluate(obj);
for (int i = 0; i < _attackers.Count; i++)
{
HeroBattle attacker = _attackers[i];
attacker.moveTrans.position = Vector3.LerpUnclamped(attacker.transform.position, _stander.transform.position, value);
}
if (!getHit && obj > hitPercent)
{
getHit = true;
if (_damage < 0)
{
List <Vector3> vList = new List <Vector3>();
for (int m = 0; m < _attackers.Count; m++)
{
vList.Add(_attackers[m].transform.position);
}
_stander.Shock(vList, shockCurve, shockDis, _damage);
}
}
};
SuperTween.Instance.To(0, 1, 1, moveToDel, null);
if (_damage < 0)
{
SuperTween.Instance.DelayCall(2.5f, _callBack);
}
else
{
SuperTween.Instance.DelayCall(2.0f, _callBack);
}
}
private static int CalculateDodge(HeroBattle hero)
{
var dodge = 0;
foreach (var skill in hero.Skills)
{
if (skill.effect.dodge == null)
{
continue;
}
int.TryParse(skill.effect.dodge, out var aux);
dodge += aux;
}
var minDodge = hero.Level;
var maxDodge = hero.Level * 2;
return(new Random().Next(minDodge, maxDodge) + dodge);
}
private HeroBattle AddCardToMap(int _cardUid, int _pos)
{
int cardID = (battle.clientIsMine ? battle.mHandCards : battle.oHandCards) [_cardUid];
GameObject go = GameObject.Instantiate <GameObject>(Resources.Load <GameObject>("HeroBattle"));
HeroBattle hero = go.GetComponent <HeroBattle>();
summonHeroDic.Add(_pos, hero);
HeroSDS sds = StaticData.GetData <HeroSDS> (cardID);
hero.Init(cardID);
hero.cardUid = _cardUid;
AddHeroToMapReal(hero, _pos);
return(hero);
}
private void DoDie(BattleDeathVO _vo, Action _del)
{
for (int i = 0; i < _vo.deads.Count; i++)
{
int pos = _vo.deads[i];
HeroBattle hero = heroDic[pos];
heroDic.Remove(pos);
if (i == 0)
{
hero.Die(_del);
}
else
{
hero.Die(null);
}
}
}
public static void Attack(HeroBattle hero, Enemy enemy)
{
var precision = CalculatePrecision(enemy);
var dodge = CalculateDodge(hero);
if (precision <= dodge)
{
return;
}
int attackValue;
if (enemy.effect.Contains("-"))
{
var effect = enemy.effect.Split('-');
var min = int.Parse(effect[0]);
var max = int.Parse(effect[1]);
attackValue = new Random().Next(min, max) + enemy.level;
}
else
{
int.TryParse(enemy.effect, out attackValue);
}
var armor = 0;
foreach (var skill in hero.Skills)
{
if (skill.effect.armor == null)
{
continue;
}
int.TryParse(skill.effect.armor, out var aux);
armor += aux;
}
hero.CurrentHp -= (attackValue - armor);
}
private void DoHpChange(BattleHpChangeVO _vo, Action _del)
{
for (int i = 0; i < _vo.pos.Count; i++)
{
int pos = _vo.pos[i];
int hpChange = _vo.hpChange[i];
HeroBattle hero = heroDic[pos];
hero.RefreshHp();
string str;
Color color;
if (hpChange > 0)
{
str = "+" + hpChange.ToString();
color = Color.green;
}
else
{
str = hpChange.ToString();
color = Color.red;
}
if (i == 0)
{
hero.ShowHud(str, color, _del);
}
else
{
hero.ShowHud(str, color, null);
}
}
}
public void AddSkill(HeroBattle hero, string skillName, string knowledgeLevel)
{
// Verifica se herói tem experiência disponível para adquirir a skill.
KnowledgeLevel level = null;
if (knowledgeLevel == null)
{
throw new CannotUseNullAsKnowledge();
}
if (skillName == null)
{
throw new CannotUseNullAsSkillException();
}
if (KnowledgeLevel.Assimilate.Name.Equals(knowledgeLevel.ToLower()))
{
level = KnowledgeLevel.Assimilate;
}
else if (KnowledgeLevel.Learn.Name.Equals(knowledgeLevel.ToLower()))
{
level = KnowledgeLevel.Learn;
}
else
{
throw new CannotFindKnowledgeException();
}
if (StatusService.GetPoints(hero.Name) < level.NecessaryPoints)
{
throw new NecessaryPointsIsNotEnoughException();
}
// Verifica se a skill existe e pode ser usada pela classe do herói.
var skill = GetSkillByName(skillName);
if (skill == null)
{
throw new CannotFindSkillException(skillName);
}
if (!CanBeUsedBy(hero, skill))
{
throw new ItemCannotBeUsedByThisClassException();
}
// Verifica se o herói já possui a skill
var skillKnowledge = GetSkillsFrom(hero.Name).FirstOrDefault(sk => sk.skill.Equals(skillName));
if (skillKnowledge != null)
{
if (knowledgeLevel.Equals(skillKnowledge.knowledge))
{
throw new SkillAlreadyLearnedException();
}
// não permite assimilar uma skill já aprendida.
var alreadyLearnedTheSkill = skillKnowledge.knowledge.Equals(KnowledgeLevel.Learn.Name);
if (alreadyLearnedTheSkill)
{
throw new CannotAddSkillWithLessKnowledgeLevelException();
}
}
// Não permite adicionar a nova skill se não cumprir os requisitos.
if (skill.requirements != null &&
hero.Skills.All(s => s.name?.ToLower().Equals(skill.requirements[0]?.ToLower()) == null))
{
throw new CannotFindRequiredSkillToAdd(skillName, skill.requirements[0]);
}
// Adiciona a skill ao herói.
var skills = hero.Skills.ToList();
skills.Add(skill);
hero.Skills = skills.ToArray();
StatusService.ConsumeTheNecessaryPoints(hero.Name, level);
Save(hero, skillName, knowledgeLevel);
}
private static bool CanBeUsedBy(HeroBattle hero, Skill skill)
{
return(skill.usedBy.Any(usedBy => usedBy.Equals(hero.Class.name)));
}
public void Attack(List <HeroBattle> _attackers, Vector3 _targetPos, HeroBattle _defender, List <HeroBattle> _supporters, int _defenderDamage, List <int> _supportersDamage, List <int> _attackersDamage, Action _callBack)
{
Action resetDel;
if (_supporters.Count > 0)
{
Vector3[] supportPos = new Vector3[_supporters.Count];
for (int i = 0; i < _supporters.Count; i++)
{
supportPos[i] = _supporters[i].transform.position;
}
Action <float> supportToDel = delegate(float obj) {
for (int i = 0; i < _supporters.Count; i++)
{
_supporters[i].transform.position = Vector3.Lerp(supportPos[i], _targetPos, obj);
}
};
SuperTween.Instance.To(0, 0.5f, 0.5f, supportToDel, null);
Action <float> resetToDel = delegate(float obj) {
for (int i = 0; i < _supporters.Count; i++)
{
_supporters[i].transform.position = Vector3.Lerp(_targetPos, supportPos[i], obj);
}
};
resetDel = delegate() {
SuperTween.Instance.To(0.5f, 1, 0.5f, resetToDel, null);
SuperTween.Instance.DelayCall(2, _callBack);
};
}
else
{
resetDel = delegate() {
SuperTween.Instance.DelayCall(1.5f, _callBack);
};
}
List <Vector3> vList = new List <Vector3>();
for (int m = 0; m < _attackers.Count; m++)
{
vList.Add(_attackers[m].transform.position);
}
bool getHit = false;
Action <float> moveToDel = delegate(float obj) {
float value = attackCurve.Evaluate(obj);
for (int i = 0; i < _attackers.Count; i++)
{
HeroBattle attacker = _attackers[i];
attacker.moveTrans.position = Vector3.LerpUnclamped(attacker.transform.position, _targetPos, value);
}
if (!getHit && obj > hitPercent)
{
getHit = true;
if (_defender != null && _defenderDamage < 0)
{
_defender.Shock(vList, shockCurve, shockDis, _defenderDamage);
}
for (int i = 0; i < _attackers.Count; i++)
{
if (_attackersDamage[i] < 0)
{
_attackers[i].Shock(new List <Vector3>()
{
_targetPos
}, shockCurve, shockDis, _attackersDamage[i]);
}
}
for (int i = 0; i < _supporters.Count; i++)
{
if (_supportersDamage[i] < 0)
{
_supporters[i].Shock(vList, shockCurve, shockDis, _supportersDamage[i]);
}
}
}
};
SuperTween.Instance.To(0, 1, 1, moveToDel, resetDel);
}
private static bool CanBeUsedBy(HeroBattle hero, Item item)
{
return(item.usedBy.Any(usedBy => usedBy.Equals(hero.Class.name)));
}
public void AddPlayer(UInt64 sGUID, int temp, BattleDataType type, int index = 0, int goodsID = 0)
{
HeroBattleInfo HeroBattle = null;
Dictionary <UInt64, HeroBattleInfo> heroBattleDic = GetCamp(sGUID);
if (heroBattleDic == null)
{
return;
}
if (!heroBattleDic.TryGetValue(sGUID, out HeroBattle))
{
HeroBattle = new HeroBattleInfo();
SetDic(sGUID, HeroBattle);
}
if (!EntityManager.AllEntitys.ContainsKey(sGUID))
{
return;
}
IEntity sEntity = EntityManager.AllEntitys[sGUID];
switch (type)
{
case BattleDataType.Cp:
HeroBattle.Cp = temp;
break;
case BattleDataType.LastHit:
HeroBattle.LastHit = temp;
break;
case BattleDataType.HeadIcon:
int id = (int)sEntity.ObjTypeID;
HeroSelectConfigInfo info = ConfigReader.GetHeroSelectInfo(id);
HeroBattle.HeadIcon = info.HeroSelectHead;
break;
case BattleDataType.NickName:
HeroBattle.HeroName = temp.ToString();
break;
case BattleDataType.Level:
HeroBattle.Level = temp;
break;
case BattleDataType.Kills:
HeroBattle.Kills = temp;
break;
case BattleDataType.Deaths:
HeroBattle.Deaths = temp;
break;
case BattleDataType.Assist:
HeroBattle.Assist = temp;
break;
case BattleDataType.Goods:
//if (goodsID != 0)
HeroBattle.AddGoodItem(index, goodsID);
//else
// HeroBattle.DelGoodsItem(index);
break;
}
heroBattleDic[sGUID] = HeroBattle;
}
public void Shoot(List <HeroBattle> _shooters, HeroBattle _stander, int _damage, Action _callBack)
{
GameObject[] arrows = new GameObject[_shooters.Count];
float[] angles = new float[_shooters.Count];
for (int i = 0; i < _shooters.Count; i++)
{
HeroBattle shooter = _shooters [i];
float angle = Mathf.Atan2(_stander.transform.position.y - shooter.transform.position.y, _stander.transform.position.x - shooter.transform.position.x);
angle += Mathf.PI * 0.5f;
GameObject arrow = GameObject.Instantiate <GameObject> (arrowResources);
arrow.transform.SetParent(shooter.transform.parent, false);
arrow.transform.position = shooter.transform.position;
arrow.SetActive(false);
arrows[i] = arrow;
angles[i] = angle;
}
Action <float> shootToDel = delegate(float obj) {
float v = shootCurve.Evaluate(obj);
for (int i = 0; i < arrows.Length; i++)
{
GameObject arrow = arrows[i];
float angle = angles[i];
if (!arrow.activeSelf)
{
arrow.SetActive(true);
}
Vector3 targetPos = Vector3.Lerp(_shooters[i].transform.position, _stander.transform.position, obj);
targetPos += new Vector3(Mathf.Cos(angle) * v * shootFix, Mathf.Sin(angle) * v * shootFix, 0);
(arrow.transform as RectTransform).localEulerAngles = new Vector3(0, 0, Mathf.Atan2(targetPos.y - arrow.transform.position.y, targetPos.x - arrow.transform.position.x) * 180 / Mathf.PI);
arrow.transform.position = targetPos;
}
};
Action shootOverDel = delegate() {
for (int i = 0; i < arrows.Length; i++)
{
GameObject.Destroy(arrows[i]);
}
if (_damage < 0)
{
List <Vector3> vList = new List <Vector3>();
for (int m = 0; m < _shooters.Count; m++)
{
vList.Add(_shooters[m].transform.position);
}
_stander.Shock(vList, shockCurve, shockDis, _damage);
}
};
SuperTween.Instance.To(0, 1, 1, shootToDel, shootOverDel);
if (_damage < 0)
{
SuperTween.Instance.DelayCall(3f, _callBack);
}
else
{
SuperTween.Instance.DelayCall(2f, _callBack);
}
}
private void DoMove(BattleMoveVO _vo, Action _del)
{
if (_vo.moves.Count > 0)
{
List <KeyValuePair <int, int> > tmpList = new List <KeyValuePair <int, int> >();
List <KeyValuePair <int, int> > tmpList2 = new List <KeyValuePair <int, int> >();
Dictionary <int, int> .Enumerator enumerator = _vo.moves.GetEnumerator();
enumerator.MoveNext();
tmpList.Add(enumerator.Current);
while (tmpList.Count > 0)
{
KeyValuePair <int, int> pair = tmpList[0];
_vo.moves.Remove(pair.Key);
tmpList.RemoveAt(0);
tmpList2.Add(pair);
if (_vo.moves.ContainsKey(pair.Value))
{
tmpList.Add(new KeyValuePair <int, int>(pair.Value, _vo.moves[pair.Value]));
}
if (_vo.moves.ContainsValue(pair.Key))
{
enumerator = _vo.moves.GetEnumerator();
while (enumerator.MoveNext())
{
if (enumerator.Current.Value == pair.Key)
{
tmpList.Add(enumerator.Current);
break;
}
}
}
}
Dictionary <int, HeroBattle> tmpDic = new Dictionary <int, HeroBattle>();
for (int i = 0; i < tmpList2.Count; i++)
{
KeyValuePair <int, int> pair = tmpList2[i];
HeroBattle hero = heroDic[pair.Key];
tmpDic.Add(pair.Key, hero);
heroDic.Remove(pair.Key);
Vector3 startPos = mapUnitDic[pair.Key].transform.position;
Vector3 endPos = mapUnitDic[pair.Value].transform.position;
Action <float> toDel = delegate(float obj) {
hero.transform.position = Vector3.Lerp(startPos, endPos, obj);
};
if (i == 0)
{
Action del = delegate() {
for (int l = 0; l < tmpList2.Count; l++)
{
pair = tmpList2[l];
heroDic.Add(pair.Value, tmpDic[pair.Key]);
int index = pair.Value;
MapUnit unit = mapUnitDic[index];
SetMapUnitColor(unit);
}
DoMove(_vo, _del);
};
SuperTween.Instance.To(0, 1, 1, toDel, del);
}
else
{
SuperTween.Instance.To(0, 1, 1, toDel, null);
}
}
}
else
{
_del();
}
}
private IEnumerator HeroAttack()
{
// definir inimigo
var index = SelectedEnemyIndex;
var enemy = _enemies[index];
// executar regra pré ataque
ExecuteRule(RuleType.BeforeHeroAttack);
// definir quem ataca
var heroes = _heroes.FindAll(h => h.IsPresent);
var hero = heroes[_currentHeroIndex];
// atacar
var previousHp = enemy.currentHp;
BattleService.Attack(hero, enemy);
var currentHp = enemy.currentHp;
// verificar se causou dano
var enemyDisplay = EnemyDisplay.Get(_enemies.Count - 1);
var tagName = enemyDisplay.ContainerNames[index] + "_" + _enemies.Count;
var attackValue = previousHp - currentHp;
if (_strongestAttack < attackValue)
{
_strongestAttack = attackValue;
HeroWhoGaveTheStrongestAttack = hero;
}
if (previousHp != currentHp)
{
for (var i = 0; i < 5; i++)
{
yield return(new WaitForSeconds(0.1f));
SetColorToGameObject(Color.red, tagName);
yield return(new WaitForSeconds(0.1f));
SetColorToGameObject(Color.white, tagName);
}
}
// alterar status da vida
if (currentHp <= 0)
{
enemy.isPresent = false;
SetColorToGameObject(Color.black, tagName);
}
// verificar se existem inimigos vivos
var thereAreEnemiesAlive = _enemies.Any(e => e.isPresent);
if (!thereAreEnemiesAlive)
{
//TODO: Verificar se toda a equipe ganha xp, mesmo se tiver morrido.
HeroBattleCalculator.CalculateTheExperienceGained(heroes, _enemies);
SkillsViewerService.GetInstance().Heroes = _heroes.ConvertAll(h => h.Name).ToArray();
SceneManager.LoadScene(_currentBattle.whereToGoWhenTheBattleIsOver);
}
// executar regra pos ataque
ExecuteRule(RuleType.AfterHeroAttack);
var count = heroes.FindAll(h => h.IsPresent).Count;
// se Existir aliados continuar ataque
if (_currentHeroIndex + 1 < count)
{
_currentHeroIndex++;
DrawAttackMenu();
yield break;
}
// ir para a próxima fase da batalha
_currentHeroIndex = 0;
DrawDefenseMenu();
}
// public void MapUnitUp(MapUnit _mapUnit){
//
// if (movingHeroPos != -1) {
//
// movingHeroPos = -1;
// }
// }
public void MapUnitUpAsButton(MapUnit _mapUnit)
{
if (mouseHasExited)
{
return;
}
if (battle.summon.ContainsValue(_mapUnit.index))
{
HeroBattle summonHero = summonHeroDic [_mapUnit.index];
if (GetNowChooseHero() == null)
{
SetNowChooseHero(summonHero, false);
GetNowChooseHero().SetFrameVisible(true);
}
else
{
if (GetNowChooseHero() == summonHero)
{
ClearNowChooseHero();
UnsummonHero(summonHero.cardUid);
}
else
{
ClearNowChooseHero();
SetNowChooseHero(summonHero, false);
GetNowChooseHero().SetFrameVisible(true);
}
}
}
else if (battle.heroMapDic.ContainsKey(_mapUnit.index))
{
HeroBattle nowHero = heroDic [_mapUnit.index];
if (GetNowChooseHero() == null)
{
SetNowChooseHero(nowHero, nowHero.isMine == battle.clientIsMine);
GetNowChooseHero().SetFrameVisible(true);
}
else
{
if (GetNowChooseHero() != nowHero)
{
ClearNowChooseHero();
SetNowChooseHero(nowHero, nowHero.isMine == battle.clientIsMine);
GetNowChooseHero().SetFrameVisible(true);
}
}
}
else if (GetNowChooseCard() != null)
{
if (battle.GetPosIsMine(_mapUnit.index) == battle.clientIsMine && GetNowChooseCard().sds.cost <= GetMoney())
{
SummonHero(GetNowChooseCard().cardUid, _mapUnit.index);
}
}
else
{
ClearNowChooseHero();
}
ClearNowChooseCard();
}
public void Attack(HeroBattle hero, Enemy enemy)
{
HeroBattleCalculator.Attack(hero, enemy);
}
