public static void Init(AttackDefinition attack)
{
AttackDefinitionEditorWindow window =
(AttackDefinitionEditorWindow)EditorWindow.GetWindow(typeof(AttackDefinitionEditorWindow));
window.attack = attack;
window.Show();
}
public override void OnInterrupted()
{
AttackDefinition currentAttack = (TUF.Combat.AttackDefinition)CombatManager.CurrentAttack.attackDefinition;
if (currentAttack)
{
//PhysicsManager.GravityScale += currentAttack.gravityScaleAdded;
}
}
protected virtual bool CheckCancelWindows(AttackDefinition currentAttack)
{
if (CheckEnemyStepWindows(currentAttack) ||
CheckDashCancelWindows(currentAttack) ||
CheckJumpCancelWindows(currentAttack) ||
CheckLandCancelWindows(currentAttack) ||
CheckFloatCancelWindows(currentAttack))
{
return(true);
}
return(false);
}
protected virtual bool CheckFloatCancelWindows(AttackDefinition currentAttack)
{
for (int i = 0; i < currentAttack.floatCancelFrames.Count; i++)
{
if (StateManager.CurrentStateFrame >= currentAttack.floatCancelFrames[i].x &&
StateManager.CurrentStateFrame <= currentAttack.floatCancelFrames[i].y)
{
if (controller.TryFloat())
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Check if we should jump cancel on the current frame.
/// </summary>
/// <param name="currentAttack">The current attack's information.</param>
/// <returns>True if we jump canceled</returns>
protected virtual bool CheckEnemyStepWindows(AttackDefinition currentAttack)
{
for (int i = 0; i < currentAttack.enemyStepWindows.Count; i++)
{
if (StateManager.CurrentStateFrame >= currentAttack.enemyStepWindows[i].x &&
StateManager.CurrentStateFrame <= currentAttack.enemyStepWindows[i].y)
{
if (controller.TryEnemyStep())
{
return(true);
}
}
}
return(false);
}
public override void Initialize()
{
base.Initialize();
if (!controller.LockedOn)
{
controller.PickSoftlockTarget();
}
AttackDefinition currentAttack = (TUF.Combat.AttackDefinition)CombatManager.CurrentAttack.attackDefinition;
if (currentAttack.stateOverride > -1)
{
StateManager.ChangeState(currentAttack.stateOverride);
return;
}
charging = true;
}
/// <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(currentAttack.chargeWindows[i].chargeLevels[cManager.CurrentChargeLevel].maxChargeFrames);
// 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>
///
/// </summary>
/// <param name="currentAttack"></param>
/// <returns></returns>
protected virtual bool TrySpecialCancel(AttackDefinition currentAttack)
{
for (int i = 0; i < currentAttack.specialCancelFrames.Count; i++)
{
if (StateManager.CurrentStateFrame >= currentAttack.specialCancelFrames[i].x &&
StateManager.CurrentStateFrame <= currentAttack.specialCancelFrames[i].y)
{
MovesetAttackNode man = ((EntityCombatManager)CombatManager).TrySpecial();
if (man != null)
{
CombatManager.SetAttack(man);
StateManager.ChangeState((int)EntityStates.ATTACK);
return(true);
}
}
}
return(false);
}
/// <summary>
/// Check if we should dash cancel on the current frame.
/// </summary>
/// <param name="currentAttack">The current attack's information.</param>
/// <returns>True if we dash canceled.</returns>
protected virtual bool CheckDashCancelWindows(AttackDefinition currentAttack)
{
for (int i = 0; i < currentAttack.dashCancelableFrames.Count; i++)
{
if (StateManager.CurrentStateFrame >= currentAttack.dashCancelableFrames[i].x &&
StateManager.CurrentStateFrame <= currentAttack.dashCancelableFrames[i].y)
{
if (InputManager.GetButton((int)EntityInputs.Dash, 0, true).firstPress)
{
if (controller.TryDash())
{
return(true);
}
}
}
}
return(false);
}
protected override void DrawWindowsMenu()
{
base.DrawWindowsMenu();
AttackDefinition atk = (AttackDefinition)attack;
if (cancelWindowsFoldout)
{
EditorGUI.indentLevel++;
EditorGUI.BeginChangeCheck();
List <Vector2Int> floatCancelWindows = new List <Vector2Int>(atk.floatCancelFrames);
DrawCancelWindow("Float Cancel Windows", ref floatCancelWindowsFoldout, ref floatCancelWindows, 180);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(atk, "Changed Cancel Window.");
atk.floatCancelFrames = floatCancelWindows;
}
EditorGUI.indentLevel--;
}
}
public override void OnUpdate()
{
AttackDefinition currentAttack = (TUF.Combat.AttackDefinition)CombatManager.CurrentAttack.attackDefinition;
// Rotate towards target.
for (int i = 0; i < currentAttack.faceLockonTargetWindows.Count; i++)
{
if (StateManager.CurrentStateFrame >= currentAttack.faceLockonTargetWindows[i].startFrame &&
StateManager.CurrentStateFrame <= currentAttack.faceLockonTargetWindows[i].endFrame)
{
Vector3 mov = controller.InputManager.GetAxis2D((int)EntityInputs.Movement);
Vector3 forwardDir = controller.visualTransform.forward;
// We're currently locked on to something.
if (controller.LockedOn)
{
forwardDir = controller.LockonForward;
}
// Movement is neutral, so Soft Target.
else if (mov.magnitude < InputConstants.movementMagnitude)
{
if (controller.LockonTarget)
{
forwardDir = (controller.LockonTarget.transform.position - controller.transform.position);
forwardDir.y = 0;
forwardDir.Normalize();
}
}
// Movement is pointing in a direction, so face that direction.
else
{
forwardDir = controller.GetMovementVector(mov.x, mov.y);
}
controller.RotateVisual(forwardDir, currentAttack.faceLockonTargetWindows[i].amount);
}
}
// Create hitbox grou ps.
for (int i = 0; i < currentAttack.boxGroups.Count; i++)
{
HandleBoxGroup(i, (BoxGroup)currentAttack.boxGroups[i]);
}
// Check if this move was canceled with another action.
if (CheckCancelWindows(currentAttack))
{
CombatManager.Cleanup();
return;
}
// Check if we can special or command attack cancel.
if (TrySpecialCancel(currentAttack) ||
TryCommandAttackCancel(currentAttack))
{
return;
}
// Execute events.
bool eventCancel = false;
for (int i = 0; i < currentAttack.events.Count; i++)
{
if (HandleEvents(currentAttack.events[i]))
{
eventCancel = true;
return;
}
}
// Only increment the frame if the event didn't stop it.
if (!eventCancel && !HandleChargeLevels((TUF.Entities.EntityManager)Manager, currentAttack))
{
controller.StateManager.IncrementFrame();
}
CheckInterrupt();
}
