public void Initialize(BattleEntityComponent p_animatedTransform, BattleEntityComponent p_targetTransform, Anim_BattleAttack_Default_Conf p_animationConfiguration,
AttackDefinition p_attack)
{
this.AnimatedTransform = p_animatedTransform;
this.TargetTransform = p_targetTransform;
this.Attack = p_attack;
this.AnimatedTransform.AnimatorDispatcher.registerListener(this, Anim_BattleAttack_Default.OnAnimatorEvent);
this.Conf = p_animationConfiguration;
this.LastFrameDistace = Vector3.Distance(this.AnimatedTransform.transform.position, this.TargetTransform.transform.position);
this.State = (Anim_BattleAttack_Default_State)1;
// this.AnimatedTransform.AnimatorDispatcher.Animator.StartPlayback
this.AnimatedTransform.AnimatorDispatcher.Animator.Play(AnimatorStateConstants.Attack_Close_Prepare);
this.InitalAnimatedTransform_Position = this.AnimatedTransform.transform.position;
this.TargetPosition_MovingForward = this.AnimatedTransform.transform.position + ((this.LastFrameDistace - this.Conf.DistanceFromTarget) * Vector3.Normalize(this.TargetTransform.transform.position - this.AnimatedTransform.transform.position));
this.Movement_ForwardDirection = Vector3.Normalize(this.TargetPosition_MovingForward - this.AnimatedTransform.transform.position);
//Orient to transform to the target
this.InitalAnimatedTransform_Rotation = p_animatedTransform.transform.rotation;
p_animatedTransform.transform.rotation = Quaternion.LookRotation(this.Movement_ForwardDirection, Vector3.up);
}
public override void OnAttack(GameObject attacker, GameObject defender, AttackDefinition attackDefinition, Attack attack)
{
//var test = Instantiate(burningEfffect, defender.transform);
// test.initialize();
Debug.Log("Fire Effect");
}
public override void OnAttack(GameObject attacker, GameObject defender, AttackDefinition attackDefinition, Attack attack)
{
Rigidbody rb = defender.GetComponent <Rigidbody>();
Vector3 forceDir = (defender.transform.position - attacker.transform.position).normalized;
forceDir.y += 0.5f;
rb?.AddForce(forceDir * forceAmount);
}
public override void OnAttack(GameObject attacker, GameObject defender, AttackDefinition attackDefinition, Attack attack)
{
if (attack.IsCritical)
{
Debug.Log("CRITICAL DAMAGE!");
}
Debug.Log($"{attacker.name} attacked {defender.name} for {attackDefinition.name} - {attack.Damage} damage.");
}
public override void OnAttack(GameObject attacker, GameObject defender, AttackDefinition attackDefinition, Attack attack)
{
var text = attack.Damage.ToString();
var scrollingText = Instantiate(TextPrefab, defender.transform.position + Vector3.up * 2f, Quaternion.identity);
scrollingText.SetText(text);
scrollingText.SetColor(attack.IsCritical ? Color.red : Color.yellow);
}
protected virtual bool CheckCancelWindows(AttackDefinition currentAttack)
{
if (CheckEnemyStepWindows(currentAttack) ||
CheckJumpCancelWindows(currentAttack) ||
CheckLandCancelWindows(currentAttack))
{
return(true);
}
return(false);
}
public override void Initialize()
{
base.Initialize();
AttackDefinition currentAttack =
(TDAction.Combat.AttackDefinition)GetEntityManager().CombatManager.CurrentAttack.attackDefinition;
if (currentAttack.stateOverride > -1)
{
GetEntityManager().StateManager.ChangeState(currentAttack.stateOverride);
return;
}
charging = true;
}
public override void OnUpdate()
{
EntityManager entityManager = GetEntityManager();
AttackDefinition currentAttack =
(TDAction.Combat.AttackDefinition)entityManager.CombatManager.CurrentAttack.attackDefinition;
// Handle lifetime of box groups.
for (int i = 0; i < currentAttack.boxGroups.Count; i++)
{
HandleBoxGroup(i, currentAttack.boxGroups[i]);
}
// Check if we should cancel the attack with something else.
if (CheckCancelWindows(currentAttack))
{
entityManager.CombatManager.Cleanup();
return;
}
if (TryCommandAttackCancel(currentAttack))
{
return;
}
// Process events.
bool eventCancel = false;
for (int i = 0; i < currentAttack.events.Count; i++)
{
if (HandleEvents(currentAttack.events[i]))
{
// Event wants us to stall on the current frame.
eventCancel = true;
return;
}
}
if (CheckInterrupt())
{
return;
}
if (!eventCancel && !HandleChargeLevels(entityManager, currentAttack))
{
entityManager.StateManager.IncrementFrame();
}
}
private bool CheckEnemyStepWindows(AttackDefinition currentAttack)
{
EntityManager e = GetEntityManager();
for (int i = 0; i < currentAttack.enemyStepWindows.Count; i++)
{
if (e.StateManager.CurrentStateFrame >= currentAttack.enemyStepWindows[i].x &&
e.StateManager.CurrentStateFrame <= currentAttack.enemyStepWindows[i].y)
{
if (e.TryEnemyStep())
{
return(true);
}
}
}
return(false);
}
private bool CheckJumpCancelWindows(AttackDefinition currentAttack)
{
EntityManager entityManager = GetEntityManager();
for (int i = 0; i < currentAttack.jumpCancelWindows.Count; i++)
{
if (entityManager.StateManager.CurrentStateFrame >= currentAttack.jumpCancelWindows[i].x &&
entityManager.StateManager.CurrentStateFrame <= currentAttack.jumpCancelWindows[i].y)
{
if (entityManager.TryJump())
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Handles processing the charge levels of the current attack.
/// </summary>
/// <param name="entityManager">The entity itself.</param>
/// <param name="currentAttack">The current attack the entity is doing.</param>
/// <returns>If the frame should be held.</returns>
private bool HandleChargeLevels(EntityManager entityManager, AttackDefinition currentAttack)
{
EntityCombatManager cManager = (EntityCombatManager)entityManager.CombatManager;
if (!charging)
{
return(false);
}
if (!entityManager.InputManager.GetButton((int)EntityInputs.ATTACK).isDown)
{
charging = false;
return(false);
}
bool result = false;
for (int i = 0; i < currentAttack.chargeWindows.Count; i++)
{
// Not on the correct frame.
if (entityManager.StateManager.CurrentStateFrame != currentAttack.chargeWindows[i].frame)
{
continue;
}
// Still have charge levels to go through.
if (entityManager.CombatManager.CurrentChargeLevel < currentAttack.chargeWindows[i].chargeLevels.Count)
{
cManager.IncrementChargeLevelCharge();
// Charge completed, move on to the next level.
if (cManager.CurrentChargeLevelCharge == currentAttack.chargeWindows[i].chargeLevels[cManager.CurrentChargeLevel].maxChargeFrames)
{
cManager.SetChargeLevel(cManager.CurrentChargeLevel + 1);
cManager.SetChargeLevelCharge(0);
}
}
else if (currentAttack.chargeWindows[i].releaseOnCompletion)
{
charging = false;
}
result = true;
// Only one charge level can be handled per frame, ignore everything else.
break;
}
return(result);
}
/// <summary>
/// Tries to cancel into a command attack.
/// </summary>
/// <param name="currentAttack">The current attack's information.</param>
/// <returns>True if we attack canceled.</returns>
protected virtual bool TryCommandAttackCancel(AttackDefinition currentAttack)
{
EntityManager e = GetEntityManager();
for (int i = 0; i < currentAttack.commandAttackCancelWindows.Count; i++)
{
if (e.StateManager.CurrentStateFrame >= currentAttack.commandAttackCancelWindows[i].x &&
e.StateManager.CurrentStateFrame <= currentAttack.commandAttackCancelWindows[i].y)
{
CAF.Combat.MovesetAttackNode man = (CAF.Combat.MovesetAttackNode)e.CombatManager.TryCommandAttack();
if (man != null)
{
e.CombatManager.SetAttack(man);
e.StateManager.ChangeState((int)EntityStates.ATTACK);
return(true);
}
}
}
return(false);
}
public void OnHited(BattleUnit attacker, AttackDefinition attackData)
{
}
private static void decide_nextAction_default(BattleResolutionStep p_battle, BattleEntity p_actingEntity, AttackDefinition p_attack)
{
BattleEntity l_targettedEntity = null;
switch (p_actingEntity.Team)
{
case BattleEntity_Team.PLAYER:
{
l_targettedEntity = BattleDecision.Utils.find_battleEntity_ofTeam_random(p_battle, BattleEntity_Team.FOE);
}
break;
case BattleEntity_Team.FOE:
{
l_targettedEntity = BattleDecision.Utils.find_battleEntity_ofTeam_random(p_battle, BattleEntity_Team.PLAYER);
}
break;
}
if (l_targettedEntity != null)
{
BQE_Attack l_attackEvent = new BQE_Attack {
Attack = p_attack, Source = p_actingEntity, Target = l_targettedEntity
};
Battle_Singletons._battleResolutionStep.push_attack_event(p_actingEntity, l_attackEvent);
}
}
public abstract void OnAttack(GameObject attacker, GameObject defender, AttackDefinition attackDefinition, Attack attack);
return(new BaseDamageStep()
{
Source = p_source, Target = p_target, BaseAttack = p_baseAttack
});
