Как бы вы изменили несколько переменных на false, если их индивидуальные значения равны нулю?

Question

Контекст:

Я работаю над игрой в Unity, и у меня есть фрагмент кода, который вы можете сделать, чтобы уничтожить объект после того, как он достигнет или пройдет определенную точку воси X или Y или через определенное количество времени.В этом сценарии у меня есть несколько мер предосторожности для неправильного заполнения значений времени, координат x и y, в которых вы хотите уничтожить объект.

Словарь быстрых данных:

killPosX, число с плавающей запятой

killPosY, число с плавающей запятой

killPosT, число с плавающей запятой

killX, логическое значение

killY, логическое

killT, логическое

Код:

Я хотел бы сделать мой код немного более компактным.Вот оригинал.

if (killPosX != 0) //x position you would like the object to be destroyed at
{
    killX = true; //make sure the value is set to true
}

if (killPosY != 0) //y position you would like the object to be destroyed at
{
    killY = true; //make sure the value is set to true
}

if (killPosT != 0) //position in time you would like the object to be destroyed at
{
    killT = true; //make sure the value is set to true
}

Есть ли какой-нибудь способ в C # превратить этот кусок кода во что-то, что может выглядеть так:

if ([killPosX, killPosY, killPosT] != 0)
{
    [killPosX, killPosY, killPosT] = true;
}

Где код будет проверять, если каждыйзначение в массиве [killPosX, killPosY, killPosT] не было равно 0 отдельно (или что-то, что выполняло бы ту же работу)?

Answer 1

if (killPosX != 0)
{
    killX = true;
}

Можно перевести следующим образом:

killX = (killPosX != 0) ? true : killX;

Или проще:

killX |= killPosX != 0;

---

if (killPosX != 0)
{
    killX = true;
}
else
{
    killX = false;
}

Можно перевести следующим образом

killX = (killPosX != 0) ? true : false;

Или, проще говоря,

killX = killPosX != 0;

---

Но поскольку сравнение значений с плавающей запятой с использованием == или != не рекомендуется, я бы выбрал:

killX |= !Mathf.Approximately( killPosX, 0 );
killY |= !Mathf.Approximately( killPosY, 0 );
killT |= !Mathf.Approximately( killPosT, 0 );

---

AFAIK , нет встроенного синтаксиса, подобного тому, что вы написали для достижения того, что вы хотите.

Answer 2

Я не могу придумать способ сделать это так, как вы предлагаете, но он может быть немного аккуратнее и компактнее, если использовать вариант подхода, предложенный гелием:

public void fnc(ref bool t1, float t2) { t1 |= !Mathf.Approximately( t2, 0 ); }

fnc(ref KillX, KillPosX);
fnc(ref KillY, KillPosY);
fnc(ref KillT, KillPosT);

Конечно, вы можете обернуть его в метод, который использует массивы в качестве параметров, но если вам не нужен универсальный способ сделать это для массивов переменного размера, стоимость установки будет больше, чем просто использование дискретных вызовов.

Answer 3

Я не уверен, относится ли это к тому, над чем вы работаете (и в Unity может быть лучший способ), но мне кажется, что один из способов сделать это - сделать свойства KillNрассчитывается по значению их соответствующего KillPosN свойства:

public class SomeClass
{
    public float KillPosX { get; set; }
    public float KillPosY { get; set; }
    public float KillPosT { get; set; }

    // Values are based on the related property values and cannot be set directly
    public bool KillX => !IsRoughlyZero(KillPosX);
    public bool KillY => !IsRoughlyZero(KillPosY);
    public bool KillT => !IsRoughlyZero(KillPosT);

    private static bool IsRoughlyZero(float input)
    {
        // Use a tolerance for comparing floating point numbers to 0
        return Math.Abs(input) < .0000001;
    }
}