如何使用 Boolean 比较动作<int></int>

Question

我有一个方法如下

public void RequestTPCost(Action<int> callback, Action<int> enemyCallback)
 {
        if (OnTPSelectionNeeded == null)
        {
            callback?.Invoke(0);
            enemyCallback?.Invoke(0);
            return;
        }
        if (TurnSystem.Instance.IsPlayerTurn())
        {
            //Player turn use shooting unit is selected and target is enemy
            OnTPSelectionNeeded?.Invoke(this, new TPSelectionInfo()
            {
                callback = callback,
                enemyCallback = enemyCallback,
                TPAvailable = selectedUnit.GetTacticalPoints(),
                enemyTPAvailable = targetUnit.GetTacticalPoints(),
            });
        }
        else
        {
            OnTPSelectionNeeded?.Invoke(this, new TPSelectionInfo()
            {
                callback = callback,
                enemyCallback = enemyCallback,
                TPAvailable = targetUnit.GetTacticalPoints(),
                enemyTPAvailable = selectedUnit.GetTacticalPoints()
            });
        }
    }

我像这样在其他地方使用它

private void UnitActionSystem_OnTPSelectionNeeded(object sender, UnitActionSystem.TPSelectionInfo e)
    {
        maxTP = e.TPAvailable;
        maxEnemyTP = e.enemyTPAvailable;
        callback = e.callback;
        enemyCallback = e.enemyCallback;
        TPAmount = 1;
        enemyTPAmount = 0;
    }

public void TPConfirm()
    {
        callback?.Invoke(TPAmount);
        UnitActionSystem.Instance.GetSelectedUnit().
                SpendTacticalPoints(TPAmount);
        enemyTPAmount = Random.Range(0, (maxEnemyTP + 1));
        enemyCallback?.Invoke(enemyTPAmount);
        UnitActionSystem.Instance.GetTargetUnit().
                SpendTacticalPoints(enemyTPAmount);
    }

private void NextState()
{
    switch (state)
    {
        case State.Aiming:
            state = State.Choosing;
            stateTimer = 0.1f;
            UnitActionSystem.Instance.RequestTPCost(ConfirmTPCost, 
            ConfirmEnemyTPCost);
            break;
        case State.Choosing:
            state = State.Shooting;
            float shootingStateTime = 0.1f; //Not a frame
            stateTimer = shootingStateTime;
            break;
        case State.Shooting:
            state = State.Cooloff;
            float coolOffStateTime = 0.5f;
            stateTimer = coolOffStateTime;
            Debug.Log("Shooting");
            break;
        case State.Cooloff:
            ActionComplete();
            break;
    }
}

private void ConfirmTPCost(int value)
{
    Debug.Log($"TP = {value}");

    NextState();
}

private void ConfirmEnemyTPCost(int value)
{
    Debug.Log($"EnemyTP = {value}");

    //NextState();
}

现在我想检查是否ConfirmTPCost < ConfirmEnemyTPCost但我不确定如何简单地做到这一点。

我有一种迂回的方式使用事件和更多UnityActionSystem函数来调用实例并完成它，但它看起来非常笨重并且容易损坏。 有没有更好的方法来获取这些值并检查哪个更多？

Answer 1

var cost = 0;
var enemyCost = 0;
UnitActionSystem.Instance.RequestTPCost(i => cost = i, i => enemyCost = i);
Debug.Log($"TP = {cost}");
Debug.Log($"EnemyTP = {enemyCost}");
if (cost < enemyCost)
{
    //Do your stuff here
}

Answer 2

如前所述，听起来实际上涉及一些异步部分。

因此，您要么想要正确地实现async和await模式，要么等待这两个值都可用。

或者，您可以使用例如可空值和本地 function ike 在某种程度上伪造该行为

int? cost = null;
int? enemyCost = null;

UnitActionSystem.Instance.RequestTPCost(i => 
{
    cost = i;
    if(enemyCost != null)
    {
        Validate();
    }
}, i =>
{
    enemyCost = i;
    if(cost != null)
    {
        Validate();
    }
});

// Can be a local function 
// otherwise pass in the two int values via parameters  
void Validate()
{
    Debug.Log($"TP = {cost.Value}");
    Debug.Log($"EnemyTP = {enemyCost.Value}");
    if (cost.Value < enemyCost.Value)
    {
        //Do your stuff here
    }
}

这里的想法：无论两个回调中的哪个先触发，它都会被忽略，只有第二个回调的两个值都已经可用并且可以调用实际的处理程序方法