private void Select(GameObject _selectedPawn)
{
m_Cursor.transform.position = GetCursorPosition(_selectedPawn);
GameMaster.GetInstance().TurnHistory_RemoveHighlightedEnemies();
GameMaster.GetInstance().TurnHistory_HighlightEnemy(_selectedPawn);
ActionRunner runner = GameMaster.GetInstance().GetSelectedAction();
if (runner != null && runner.ActionDescription != null)
{
ISpecificActionDescription desc = runner.ActionDescription;
if (desc.m_ShowHistoryPreview)
{
//preview the damages
PawnStatistics targetStats = new PawnStatistics(_selectedPawn.GetComponent <PawnStatistics>());
PawnStatistics sourceStats = new PawnStatistics(GameTurnManager.GetInstance().GetCurrentPawnStatistics());
ResolveResult result = new ResolveResult();
desc.m_Power.Resolve(sourceStats, targetStats, result);
//preview turn history
List <GameObject> preview = GameTurnManager.GetInstance().Preview(_selectedPawn, targetStats, 10);
GameMaster.GetInstance().m_UITurnHistory.ShowPreview(preview.ToArray());
}
}
}
private void ResolveHP(PawnStatistics _src, PawnStatistics _target, ResolveResult _result)
{
float weaponBonus = 0;
if (_src.m_EquippedWeapon != null)
{
Weapon wpn = _src.m_EquippedWeapon;
weaponBonus = wpn.m_Atk + UnityEngine.Random.Range(-wpn.m_AtkR, wpn.m_AtkR);
}
float dmg = (_src.m_Atk * m_DamageFactor) + weaponBonus - _target.m_Def;
if (dmg < 0)
{
dmg = 0;
}
int realDamage = (int)dmg;
_result.m_Damage = realDamage;
_target.m_HP -= realDamage;
if (_target.m_HP <= 0)
{
_target.m_HP = 0;
PawnBehavior behavior = _target.GetComponent <PawnBehavior>();
behavior.SetDeadState();
}
}
private void UpdateUIState()
{
GameTurnManager turnMng = GameTurnManager.GetInstance();
int playerPawnCount = turnMng.m_PlayerPawns.Count;
for (int i = 0; i < playerPawnCount; ++i)
{
GameObject pawn = turnMng.m_PlayerPawns[i];
PawnUI pawnUIComponent = pawn.GetComponent <PawnUI>();
if (pawnUIComponent == null)
{
Debug.LogError("The pawn " + pawn.name + " has no PawnUI component.");
return;
}
PawnStatistics stat = pawn.GetComponent <PawnStatistics>();
if (stat == null)
{
Debug.LogError("The pawn " + pawn.name + " has no PawnStatistics component.");
return;
}
m_Behavior.m_UIPawnState[i].SetHP(stat.m_HP, stat.m_MaxHP);
m_Behavior.m_UIPawnState[i].SetMP(stat.m_MP, stat.m_MaxMP);
}
}
public void Resolve(ResolveResult _result)
{
PawnStatistics pawnStats = m_Pawn.GetComponent <PawnStatistics>();
PawnStatistics targetStats = m_Target.GetComponent <PawnStatistics>();
float weaponBonus = 0;
if (pawnStats.m_EquippedWeapon != null)
{
Weapon wpn = pawnStats.m_EquippedWeapon;
weaponBonus = wpn.m_Atk + Random.Range(-wpn.m_AtkR, wpn.m_AtkR);
}
float dmg = pawnStats.m_Atk + weaponBonus - targetStats.m_Def;
if (dmg < 0)
{
dmg = 0;
}
int realDamage = (int)dmg;
targetStats.m_HP -= realDamage;
if (targetStats.m_HP <= 0)
{
targetStats.m_HP = 0;
PawnBehavior behavior = m_Target.GetComponent <PawnBehavior>();
behavior.SetDeadState();
}
_result.m_Damage = realDamage;
}
private void ApplyPriorityRestore()
{
foreach (GameObject obj in m_OrderedPawns)
{
PawnStatistics stats = obj.GetComponent <PawnStatistics>();
stats.m_Priority += stats.m_PriorityIncrease;
}
}
public void NextTurn()
{
PawnStatistics stats = GetCurrentPawnStatistics();
stats.m_Priority -= 1;
Update();
}
public void InitializeMagicList(MagicId[] _availableMagic)
{
m_ListContainer.SetActive(true);
m_SelectedMagic.gameObject.SetActive(false);
m_SelectedMagic.onCancel.RemoveAllListeners();
m_SelectedMagic.onCancel.AddListener(() => { ShowMagicList(); });
int btnId = 0;
foreach (MagicId id in _availableMagic)
{
if (btnId == m_BtnMagic.Length)
{
break;
}
MagicDescription desc = MagicManager.GetInstance().GetDescription(id);
if (desc == null)
{
Debug.LogError(string.Format("Can't find magic description with id {0}", id));
continue;
}
CustomButton btn = m_BtnMagic[btnId];
btn.GetComponentInChildren <Text>().text = desc.m_DisplayName;
btn.onCancel.RemoveAllListeners();
btn.onCancel.AddListener(() => { Close(); });
MagicId capturedId = id; //necessary for the lambda to work
btn.onClick.RemoveAllListeners();
btn.onClick.AddListener(() => { Clicked(capturedId); });
btn.gameObject.SetActive(true);
PawnStatistics stats = GameTurnManager.GetInstance().GetCurrentPawnStatistics();
if (desc.m_Power.CanBeUsed(stats))
{
btn.IsUnselectable = false;
}
else
{
btn.IsUnselectable = true;
}
btn.Send(WidgetEvent.Unselect);
++btnId;
}
for (int i = btnId; i < m_BtnMagic.Length; ++i)
{
m_BtnMagic[i].gameObject.SetActive(false);
}
m_BtnMagic[0].Send(WidgetEvent.Select);
}
private void InitializePawnStatistics(GameObject _pawn)
{
GameTurnManager turnMng = GameTurnManager.GetInstance();
PawnBehavior bhv = _pawn.GetComponent <PawnBehavior>();
Character savedCharacter = GameStateManager.GetInstance().GetCharacter(bhv.m_CharacterId);
PawnStatistics stats = _pawn.GetComponent <PawnStatistics>();
savedCharacter.LoadTo(stats);
}
public override void OnEnter()
{
//compute turns history
GameTurnManager turnMng = GameTurnManager.GetInstance();
turnMng.Init(m_Behavior.m_Pawns);
m_Behavior.m_UITurnHistory.UpdateTurnHistory(turnMng);
//init ui state
int playerPawnCount = turnMng.m_PlayerPawns.Count;
for (int i = 0; i < playerPawnCount; ++i)
{
GameObject pawn = turnMng.m_PlayerPawns[i];
PawnUI pawnUIComponent = pawn.GetComponent <PawnUI>();
if (pawnUIComponent == null)
{
Debug.LogError("The pawn " + pawn.name + " has no PawnUI component.");
return;
}
PawnStatistics stat = pawn.GetComponent <PawnStatistics>();
if (stat == null)
{
Debug.LogError("The pawn " + pawn.name + " has no PawnStatistics component.");
return;
}
InitializePawnStatistics(pawn);
m_Behavior.m_UIPawnState[i].gameObject.SetActive(true);
m_Behavior.m_UIPawnState[i].SetAvatar(pawnUIComponent.m_TurnSprite);
m_Behavior.m_UIPawnState[i].SetHP(stat.m_HP, stat.m_MaxHP);
m_Behavior.m_UIPawnState[i].SetMP(stat.m_MP, stat.m_MaxMP);
m_Behavior.m_UIPawnState[i].SetName(stat.m_PawnName);
}
//hide unused state ui.
int UIStateCount = m_Behavior.m_UIPawnState.Length;
for (int i = playerPawnCount; i < UIStateCount; ++i)
{
m_Behavior.m_UIPawnState[i].gameObject.SetActive(false);
}
m_Behavior.m_ActionsMenu.Hide();
m_FadeWidget.gameObject.SetActive(true);
m_FadeWidget.color = m_InitColor;
m_Runner.SetCurrentState((int)GameMasterState.PlayIntro, "Init state over");
AnimationEventLibrary.InitEventLibrary();
}
private bool AreAllPlayerPawnsDead()
{
foreach (GameObject obj in m_TurnManager.m_PlayerPawns)
{
PawnStatistics stat = obj.GetComponent <PawnStatistics>();
if (stat.m_HP > 0)
{
return(false);
}
}
return(true);
}
public void SaveFrom(PawnStatistics _stats)
{
m_Statistics.m_Atk = _stats.m_Atk;
m_Statistics.m_Def = _stats.m_Def;
m_Statistics.m_HP = _stats.m_HP;
m_Statistics.m_MaxHP = _stats.m_MaxHP;
m_Statistics.m_MP = _stats.m_MP;
m_Statistics.m_MaxMP = _stats.m_MaxMP;
m_Statistics.m_MGAtk = _stats.m_MGAtk;
m_Statistics.m_MGDef = _stats.m_MGDef;
m_Statistics.m_Priority = _stats.m_Priority;
m_Statistics.m_PriorityIncrease = _stats.m_PriorityIncrease;
}
public void LoadTo(PawnStatistics _stats)
{
_stats.m_Atk = m_Statistics.m_Atk;
_stats.m_Def = m_Statistics.m_Def;
_stats.m_HP = m_Statistics.m_HP;
_stats.m_MaxHP = m_Statistics.m_MaxHP;
_stats.m_MP = m_Statistics.m_MP;
_stats.m_MaxMP = m_Statistics.m_MaxMP;
_stats.m_MGAtk = m_Statistics.m_MGAtk;
_stats.m_MGDef = m_Statistics.m_MGDef;
_stats.m_Priority = m_Statistics.m_Priority;
_stats.m_PriorityIncrease = m_Statistics.m_PriorityIncrease;
}
public override void OnEnter()
{
foreach (GameObject obj in GameTurnManager.GetInstance().m_PlayerPawns)
{
PawnBehavior bhv = obj.GetComponent <PawnBehavior>();
PawnStatistics stats = obj.GetComponent <PawnStatistics>();
GameStateManager.GetInstance().GetCharacter(bhv.m_CharacterId).SaveFrom(stats);
}
GameSceneManager.GetInstance().Pop(true);
LevelMaster.GetInstance().ComeBackFromBattle();
}
public void ApplyCost(PawnStatistics _pawn)
{
switch (m_CostTarget)
{
case PawnTag.HP:
{
_pawn.m_HP -= m_Cost;
if (_pawn.m_HP < 0)
{
_pawn.m_HP = 0;
}
}
break;
case PawnTag.MP:
{
_pawn.m_MP -= m_Cost;
if (_pawn.m_MP < 0)
{
_pawn.m_MP = 0;
}
}
break;
case PawnTag.PriorityIncrease:
{
_pawn.m_PriorityIncrease -= m_Cost;
if (_pawn.m_PriorityIncrease < 0)
{
_pawn.m_PriorityIncrease = 0;
}
}
break;
case PawnTag.Priority:
{
_pawn.m_Priority -= m_Cost;
if (_pawn.m_Priority < 0)
{
_pawn.m_Priority = 0;
}
}
break;
default:
break;
}
}
public void Resolve(PawnStatistics _src, PawnStatistics _target, ResolveResult _result)
{
switch (m_DamageTarget)
{
case PawnTag.HP:
ResolveHP(_src, _target, _result);
break;
case PawnTag.PriorityIncrease:
ResolvePriorityIncrease(_src, _target, _result);
break;
default:
Debug.LogError(string.Format("Can't resolve damage target {0}", m_DamageTarget));
break;
}
}
public List <GameObject> Preview(GameObject _previewPawn, PawnStatistics _previewStatistics, int _count)
{
Dictionary <GameObject, PawnStatistics> statistics = new Dictionary <GameObject, PawnStatistics>();
foreach (GameObject obj in m_OrderedPawns)
{
if (obj == _previewPawn)
{
statistics.Add(obj, _previewStatistics);
}
else
{
statistics.Add(obj, obj.GetComponent <PawnStatistics>());
}
}
List <GameObject> ret = new List <GameObject>();
List <float> priorityBase = new List <float>();
foreach (GameObject obj in m_OrderedPawns)
{
priorityBase.Add(statistics[obj].m_Priority);
}
int turnCount = 0;
while (turnCount < _count)
{
GameIteration iter = ComputeIteration(0, priorityBase);
for (int i = 0; i < iter.GetCount(); ++i)
{
ret.Add(iter.GetPawn(i));
}
turnCount += iter.GetCount();
for (int i = 0; i < m_OrderedPawns.Count; ++i)
{
priorityBase[i] += statistics[m_OrderedPawns[i]].m_PriorityIncrease;
}
}
return(ret);
}
public override void OnEnter()
{
GameTurnManager turnMng = GameTurnManager.GetInstance();
m_Behavior.m_UITurnHistory.UpdateTurnHistory(turnMng);
GameObject obj = turnMng.GetCurrentPawn();
PawnStatistics stat = obj.GetComponent <PawnStatistics>();
if (stat.m_IsControlledByPlayer)
{
m_Runner.SetCurrentState((int)RunSingleTurnState.PlayerTurn, "Player turn");
}
else
{
m_Runner.SetCurrentState((int)RunSingleTurnState.AITurn, "Enemy turn");
}
}
public override void OnEnter()
{
//compute damage
ActionRunner act = m_Behavior.GetRunSingleTurnState().GetSelectedAction();
PawnStatistics src = act.m_Pawn.GetComponent <PawnStatistics>();
PawnStatistics target = act.m_Target.GetComponent <PawnStatistics>();
ResolveResult result = new ResolveResult();
act.ActionDescription.m_Power.Resolve(src, target, result);
if (act.ActionDescription.m_Power.m_DamageTarget == PawnTag.HP)
{
Vector3 effectPosition = Camera.main.WorldToScreenPoint(act.m_Target.transform.position);
m_Behavior.m_UIEffects.StartDamageEffect(effectPosition, result.m_Damage.ToString());
}
else
{
m_Runner.SetCurrentState((int)RunSingleTurnState.Over, "resolve over");
}
}
public PawnStatistics(PawnStatistics _original)
{
m_PawnName = _original.m_PawnName;
m_Atk = _original.m_Atk;
m_Def = _original.m_Def;
m_MaxHP = _original.m_MaxHP;
m_HP = _original.m_HP;
m_MaxMP = _original.m_MaxMP;
m_MP = _original.m_MP;
m_MGAtk = _original.m_MGAtk;
m_MGDef = _original.m_MGDef;
m_WepAtk = _original.m_WepAtk;
m_WepAtkCritic = _original.m_WepAtkCritic;
m_WepDef = _original.m_WepDef;
m_WepDefCritic = _original.m_WepDefCritic;
m_WepMGAtk = _original.m_WepMGAtk;
m_WepMGAtkCritic = _original.m_WepMGAtkCritic;
m_WepMGDef = _original.m_WepMGDef;
m_WepMGDefCritic = _original.m_WepMGDefCritic;
m_Priority = _original.m_Priority;
m_PriorityIncrease = _original.m_PriorityIncrease;
m_IsControlledByPlayer = _original.m_IsControlledByPlayer;
m_EquippedWeapon = _original.m_EquippedWeapon;
}
public bool CanBeUsed(PawnStatistics _pawn)
{
switch (m_CostTarget)
{
case PawnTag.HP:
return(_pawn.m_HP >= m_Cost);
case PawnTag.MP:
return(_pawn.m_MP >= m_Cost);
case PawnTag.Priority:
return(_pawn.m_Priority >= m_Cost);
case PawnTag.PriorityIncrease:
return(_pawn.m_PriorityIncrease >= m_Cost);
case PawnTag.None:
return(true);
default:
Debug.LogError(string.Format("Unknown PawnTag {0}", m_CostTarget));
return(false);
}
}
private void ResolvePriorityIncrease(PawnStatistics _src, PawnStatistics _target, ResolveResult _result)
{
_target.m_PriorityIncrease = _target.m_PriorityIncrease * m_DamageFactor;
}
