// помечаем readonly, чтобы позволить JIT-компилятору больше оптимизаций
readonly unsafe struct V256
{
    // желательно проверять, что мы поддерживаем AVX2
    static V256() { if (!Avx2.IsSupported) throw new NotSupportedException("AVX2"); }

    // здесь мы воспользовались неявным приведением байта к нашему типу, см. ниже
    public static readonly V256 ZERO = 0;

    // собственно данные. JIT-оптимизатор может их вообще в памяти не хранить,
    // а только держать в одном из шестнадцати специальных 256-битных 
    // регистров процессора YMM0 - YMM15
    private readonly Vector256<byte> _data;

    // можно загрузить 32 байта напрямую из памяти
    public V256(byte* b) { _data = Avx2.LoadVector256(b); }

    // или задать от одного до 32 байт в конструкторе
    public V256(params byte[] buffer)
    {
        if (buffer.Length < 32) Array.Resize(ref buffer, 32);
        fixed (byte* p = buffer) _data = Avx2.LoadVector256(p);
    }

    // А можно загрузить массив произвольного типа. Обратите внимание
    // на ключевое слово unmanaged, которое позволяет обращаться с типом T
    // как с массивом байт. Все целочисленные типы (int, uint, long, ulong,
    // и т.д.) удовлетворяют этому условию
    public static V256 Load<T>(params T[] buffer) where T : unmanaged
    {
        fixed (T* p = buffer) return new V256((byte*)p);
    }

    public void Store<T>(T[] buffer) where T : unmanaged
    {
        fixed (T* p = buffer) Avx2.Store((byte*)p, _data);
    }

    public T[] ToArray<T>() where T : unmanaged
    {
        T[] array = new T[32 / sizeof(T)];
        fixed (T* ptr = array) Avx2.Store((byte*)ptr, _data);
        return array;
    }

    // Специальная инструкуция broadcast повторяет параметр необходимое число раз
    // то есть, результатом будет 32 одинаковых байта b
    public static V256 FromByte(byte b) =>
        Avx2.BroadcastScalarToVector256(&b);
    // или 16 одинаковых short-а s
    public static V256 FromShort(short s) =>
        Avx2.BroadcastScalarToVector256(&s).AsByte();
    // также можно поступать с любыми типами
    public static V256 FromULong(ulong ul) =>
        Avx2.BroadcastScalarToVector256(&ul).AsByte();

    // невявное приведение от байта: теперь можно писать V256 x = 42;
    public static implicit operator V256(byte b) => FromByte(b);

    // Особые возможности AVX2
    // берется минимум по каждому байту, аналогично result[i] = 
    // Math.Min(this[i], other[i]), i=0..31, только в 100 раз быстрее
    public V256 Min(V256 other) => Avx2.Min(_data, other._data);
    // аналог table lookup: result[i] = this[data[i]], i = 0..31
    public V256 Shuffle(V256 mask) => Avx2.Shuffle(_data, mask._data);
    // аналог result[i] = this[i] == other[i] ? 0xFF : 0x00;
    public V256 CompareEqual(V256 other) => Avx2.CompareEqual(_data, other._data);
    
    // Перегрузка операторов позволяет писать x & y, x | y и т.п. 
    public static V256 operator &(V256 x, V256 y) => Avx2.And(x._data, y._data);
    public static V256 operator |(V256 x, V256 y) => Avx2.Or(x._data, y._data);
    public static V256 operator +(V256 x, V256 y) => Avx2.Add(x._data, y._data);
    public static V256 operator -(V256 x, V256 y) => Avx2.Subtract(x._data, y._data);
    public static V256 operator -(V256 x) => Avx2.Subtract(ZERO._data, x._data);

    // а сравнить просто так два 256-битных числа не получится.
    // Рано или поздно на замену AVX2 придет AVX512, где будет специальная
    // инструкция для этого, но пока только так:
    public static bool operator ==(V256 x, V256 y) =>
        -1 == Avx2.MoveMask(Avx2.CompareEqual(x._data, y._data));

    // Но самое хитрое - это сдвиг. К сожалению, невозможно сдвинуть значение как
    // одно 256-битное число (а вот в AVX512, по слухам, будет можно!), поэтому
    // извращаемся:
    public static V256 operator >>(V256 x, int count)
    {
        // сдвинем данные, как 4 независимых 8-байтных слова
        Vector256<ulong> data = Avx2.ShiftRightLogical( 
            x._data.AsUInt64(), (byte)count);
        // а эти биты мы потеряли в предыдущем сдвиге
        Vector256<ulong> carry = Avx2.ShiftLeftLogical(
            x._data.AsUInt64(), (byte)(64 - count));
        // взболтать...
        carry = Avx2.Permute4x64(carry, 0x39);
        // но не смешивать!
        carry = Avx2.Blend(ZERO._data.AsUInt32(), carry.AsUInt32(), 0x3F).AsUInt64();
        data = Avx2.Or(data, carry);
        return data.AsByte();
    }

    // Распечатываем значение вектора, в том числе, для дебага.
    // обратите внимание на аллокацию массива на стеке: в данном методе
    // это не обязательно, так как производительность не критична,
    // но иногда это может спасти нас.
    public override string ToString()
    {
        byte* buffer = stackalloc byte[32];
        Avx2.Store(buffer, _data);
        return string.Join(" ", Enumerable.Range(0, 32).Select(i => buffer[i].ToString("X2")));
    }
}

[TestClass]
public class V256Tests
{
    [TestMethod]
    public void V256_ToString()
    {
        Assert.AreEqual(
            "05 05 05 05 05 05 05 05 05 05 05 05 05 05 05 05 " +
            "05 05 05 05 05 05 05 05 05 05 05 05 05 05 05 05",
            ((V256)5).ToString());
    }

    [TestMethod] public void V256_And() => 
        Assert.AreEqual((V256)4, (V256)5 & (V256)6);

    [TestMethod]
    public void V256_ShiftRight()
    {
        V256 y = new V256(
            0xF1, 0x18, 0x80, 0x01, 0x18, 0x80, 0x01, 0x18,
            0x80, 0x01, 0x18, 0x80, 0x01, 0x18, 0x80, 0x01,
            0x18, 0x80, 0x01, 0x18, 0x80, 0x01, 0x18, 0x80,
            0x01, 0x18, 0x80, 0x01, 0x18, 0x80, 0xFF, 0x0F);
        Assert.AreEqual(
            "01 18 80 01 18 80 01 18 80 01 18 80 01 18 80 01 " +
            "18 80 01 18 80 01 18 80 01 18 80 01 F8 FF 00 00",
            (y >> 12).ToString());
    }

    // Все варианты поворота фигурки одновременно падают вниз.
    // Когда игрок поворачивает фигурку,
    // меняем индекс текущего вращения, если получившаяся фигурка 
    // не пересекается с содержимым поля.
    V256[] fallingPiece = new V256[4];
    // от 1 до 4
    int rotationsCount;
    // текущий индекс поворота. Изначально равен нулю
    int fallingPieceRotation;
    // текущий вариант поворота текущей фигурки
    V256 FallingPiece => fallingPiece[fallingPieceRotation % rotationsCount];

    // Последовательность выпадения фигурок случайна, но всегда одинакова ;-)
    Random rand = new Random(12345);
    // новая случайная фигурка появляется сверху!
    void SelectNextPiece() => SelectPiece(rand.Next(0, PIECES.Length));
    // копируем все повороты этой фигурки из базы фигурок
    void SelectPiece(int index)
    {
        fallingPieceRotation = 0;
        rotationsCount = PIECES[index].Length;
        Array.Copy(PIECES[index], fallingPiece, rotationsCount);
    }

    // крутим и вертим
    void RotateLeft() => Rotate(1);
    void RotateRight() => Rotate(-1);
    bool MoveDown() => ShiftLeft(width);
    bool MoveRight() => ShiftLeft(1);
    bool MoveLeft() => ShiftRight(-1);

    bool Rotate(int count)
    {
        // поворачиваем в нужную сторону, выбирая нужный 
        // вариант из массива
        fallingPieceRotation += count;
        // скоро узнаем, как это делается
        if (!Intersects(bord, FallingPiece)) return true;
        // не удалось повернуть, поворачиваем обратно!
        fallingPieceRotation -= count;
        return false;
    }

    bool ShiftLeft(int count)
    {
        // сначала проверим, не мешает ли нам чего
        if (Intersects(board, ShiftLeft(FallingPiece, count)) return false;
        // все варианты поворота сдвигаются одновременно!
        for (int i = 0; i < rotationsCount; i++) 
            fallingPiece[i] = ShiftLeft(fallingPiece[i], count);
    }
}

V256 fullLine = new V256(0, 0, 0, ..., 0, 0, 255, 15);
V256 emptyLine = new V256(1, 8);

void RemoveFullLines(ref V256 board)
{
    // начинаем маску с нижней линии
    V256 lineMask = fullLine >> width;
    // маска части поля под этой линией
    V256 underLineMask = fullLine;
    while (lineMask != 0)
    {
        // это проверка, что линия заполнена
        while ((board & lineMask) == lineMask)
        {
            // вырезаем заполненную линию из поля и склеиваем остаток
            board = (board & underLineMask) | 
                        ((board & ~underLineMask & ~lineMask) << width) | 
                        emptyLine;
        }
        // сдвигаем маску на одну линию вверх
        underLineMask |= lineMask;
        lineMask >>= width;
    }
}

    void PlayGame()
    {
        SelectNextPiece();

        while (!Intersects(FallingPiece))
        {
            DisplayField();

            for (int i = 0; i < 10; i++)
            {
                Control();
                Thread.Sleep(100);
            }

            if (!MoveDown())
            {
                AddPieceToBoard();
                RemoveFullLines();
                SelectNextPiece();
                continue;
            }
        }
        DisplayField();
    }

    void Control()
    {
        if (Console.KeyAvailable)
        {
            ConsoleKeyInfo key = Console.ReadKey(false);
            if (key.Key == ConsoleKey.UpArrow) RotateLeft();
            else if (key.Key == ConsoleKey.DownArrow) RotateRight();
            else if (key.Key == ConsoleKey.LeftArrow) MoveLeft();
            else if (key.Key == ConsoleKey.RightArrow) MoveRight();
            else if (key.Key == ConsoleKey.Spacebar) while (MoveDown()) ;
            while (Console.KeyAvailable) Console.ReadKey();
            DisplayField();
        }
    }

dotnet run -c Release -p Tetriss -replay "0:0 0:0 0:0 0:0 0:0 0:0 0:0 0:0 0:0 0:-3 0:3 0:-3 0:-2 0:3 0:-4 0:4 0:3 0:3 0:0 0:3 0:1 0:-3 0:3 0:-2 2:-3 0:-1 3:-4 2:-2 1:4 0:1 0:2 0:-4 1:4 0:2 0:-2 0:0 0:-3 0:-3 1:0 1:4 3:-4 1:4 1:2 0:0 0:-2 0:1 1:-4 0:0 0:-2 0:-4 0:4 1:2 1:4 1:4 1:-5 0:0 0:4 1:-4 0:-2 0:1 1:4 0:1 0:-1 1:3 2:2 0:0 1:-4 3:-1 2:4 1:-2 0:1 3:3 0:-3 1:1 3:-4 3:0 1:4 1:2 1:1 1:-4 1:-4 0:-2 0:1 1:4 3:-1 0:2 1:3 1:-5 1:4 0:1 1:-4 0:-2 1:4 1:2 0:2 1:4 1:0 0:-2 0:2 0:1 1:-4 0:1 0:1 1:4 1:-2 1:-2 0:-2 0:-3 1:3 1:4 1:2 3:0"