某方块。。。

using System;
using System.Drawing;
using System.Windows.Forms;

internal class tetris : Form
{
    private static void Main()
    {
        Application.EnableVisualStyles();
        Application.Run(new tetris());
    }

    private const int dimension = 8;
    private const int maxwidth = 16;
    private const int maxheight = 32;
    private const int boardwidth = 8;
    private const int nextwidth = boardwidth - 2;
    private const int invalid = 255;

    private Timer timer;

    private byte[,] matrix;

    private tetris_object item;
    private tetris_object next;

    private bool start;
    private bool pause;
    private string message;
    private int score;
    private int ox;
    private int oy;

    private int offsetx
    {
        get
        {
            return ox;
        }
        set
        {
            if (0 != item.check(value, oy, matrix))
                ox = value;
        }
    }

    private int offsety
    {
        get
        {
            return oy;
        }
        set
        {
            int result = item.check(ox, value, matrix);

            if (0 == result)
            {
                item.shift(ox, oy, matrix);

                check();

                item = next;
                next = generate();

                ox = (maxwidth - 4) / 2;
                oy = -item.bottom;
            }
            else if (-1 == result)
            {
                lost("game over");
            }
            else
            {
                oy = value;
            }
        }
    }

    private tetris()
    {
        timer = new Timer();

        timer.Interval = 500;

        timer.Tick += timer_tick;

        DoubleBuffered = true;
        MaximizeBox = false;
        FormBorderStyle = FormBorderStyle.FixedDialog;
        StartPosition = FormStartPosition.CenterScreen;
        ClientSize = new Size(dimension * (maxwidth + boardwidth), dimension * maxheight);
        Font = new Font("Consolas", dimension);

        KeyPress += key_press;
        Paint += paint;

        pause = true;
    }

    private void timer_tick(object o, EventArgs e)
    {
        ++offsety;

        Refresh();
    }

    private void key_press(object o, KeyPressEventArgs e)
    {
        if (!pause)
            switch (e.KeyChar)
            {
                case 'a':
                case 'A': --offsetx; break;

                case 'd':
                case 'D': ++offsetx; break;

                case 's':
                case 'S': ++offsety; break;

                case 'w':
                case 'W': item.rotate(ox, oy, matrix); break;
            }

        if ('e' == e.KeyChar || 'E' == e.KeyChar)
        {
            if (!start)
                init();

            timer.Enabled = pause;

            pause = !pause;
        }
        else if ('r' == e.KeyChar || 'R' == e.KeyChar)
        {
            lost("");
        }

        Refresh();
    }

    private void paint(object o, PaintEventArgs e)
    {
        e.Graphics.FillRectangle(Brushes.WhiteSmoke, 0, 0, dimension * maxwidth, dimension * maxheight);
        e.Graphics.FillRectangle(Brushes.Gray, dimension * maxwidth, 0, dimension * boardwidth, dimension * maxheight);
        e.Graphics.FillRectangle(Brushes.LightGray, dimension * (maxwidth + (boardwidth - nextwidth) / 2), dimension * 1, dimension * nextwidth, dimension * nextwidth);

        e.Graphics.DrawString(string.Format("a:left
d:right
s:down
w:rotate
e:pause
r:reset"), Font, Brushes.Black, dimension * (maxwidth + (boardwidth - nextwidth) / 2), dimension * (nextwidth + 4));

        if (start)
        {
            if (pause)
                e.Graphics.DrawString("pause", Font, Brushes.Black, dimension * 1, dimension * (maxheight / 2));

            e.Graphics.DrawString(string.Format("{0:d7}", score), Font, Brushes.Black, dimension * (maxwidth + (boardwidth - nextwidth) / 2), dimension * (nextwidth + 2));

            for (int y = 0; y < maxheight; ++y)
                for (int x = 0; x < maxwidth; ++x)
                    if (invalid != matrix[x, y])
                        e.Graphics.FillRectangle(tetris_object.colors[matrix[x, y]], dimension * x, dimension * y, dimension - 1, dimension - 1);

            item.draw(ox, oy, e.Graphics);
            next.draw(maxwidth + (boardwidth - 4) / 2, 2, e.Graphics);
        }
        else
        {
            e.Graphics.DrawString(message, Font, Brushes.Black, dimension * 1, dimension * (maxheight / 2 - 2));
            e.Graphics.DrawString("press "e" to start", Font, Brushes.Black, dimension * 1, dimension * (maxheight / 2));
        }
    }

    private void init()
    {
        matrix = new byte[maxwidth, maxheight];

        for (int y = 0; y < maxheight; ++y)
            for (int x = 0; x < maxwidth; ++x)
                matrix[x, y] = invalid;

        item = generate();
        next = generate();

        start = true;
        pause = true;
        message = "";
        score = 0;
        ox = (maxwidth - 4) / 2;
        oy = -item.bottom;
    }

    private void lost(string text)
    {
        timer.Enabled = false;

        start = false;
        message = text;
    }

    private tetris_object generate()
    {
        tetris_object current = new tetris_object();

        return current;
    }

    private void check()
    {
        byte[,] target = new byte[maxwidth, maxheight];

        for (int y = 0; y < maxheight; ++y)
            for (int x = 0; x < maxwidth; ++x)
                target[x, y] = invalid;

        for (int y = maxheight, ty = maxheight; y-- > 0; )
            if (!check(y))
            {
                --ty;

                for (int x = 0; x < maxwidth; ++x)
                    target[x, ty] = matrix[x, y];
            }

        matrix = target;
    }

    private bool check(int y)
    {
        for (int x = 0; x < maxwidth; ++x)
            if (invalid == matrix[x, y])
                return false;

        score = score + 100;

        if (0 == score % 1000)
            if (100 < timer.Interval)
                timer.Interval = timer.Interval - 50;

        return true;
    }

    private void remove(int y)
    {
    }

    private class tetris_object
    {
        private static readonly byte[][][] objects =
        {
            new byte[][]
            {
                new byte[] { 8, 9, 10, 11, },
                new byte[] { 1, 5, 9, 13, },
            },
            new byte[][]
            {
                new byte[] { 9, 10, 13, 14, },
            },
            new byte[][]
            {
                new byte[] { 5, 8, 9, 10, },
                new byte[] { 5, 9, 10, 13, },
                new byte[] { 8, 9, 10, 13, },
                new byte[] { 5, 8, 9, 13, },
            },
            new byte[][]
            {
                new byte[] { 4, 8, 9, 10, },
                new byte[] { 5, 6, 9, 13, },
                new byte[] { 8, 9, 10, 14, },
                new byte[] { 5, 9, 12, 13, },
            },
            new byte[][]
            {
                new byte[] { 6, 8, 9, 10, },
                new byte[] { 5, 9, 13, 14, },
                new byte[] { 8, 9, 10, 12, },
                new byte[] { 4, 5, 9, 13, },
            },
            new byte[][]
            {
                new byte[] { 4, 5, 9, 10, },
                new byte[] { 6, 9, 10, 13, },
            },
            new byte[][]
            {
                new byte[] { 5, 6, 8, 9, },
                new byte[] { 5, 9, 10, 14, },
            },
        };
        private static readonly Brush[] brushes =
        {
            Brushes.Salmon,
            Brushes.Peru,
            Brushes.Teal,
            Brushes.Purple,
            Brushes.Indigo,
            Brushes.Olive,
            Brushes.Green,
        };

        private int column;
        private int row;

        internal static Brush[] colors
        {
            get
            {
                return brushes;
            }
        }

        internal int bottom
        {
            get
            {
                return objects[column][row][3] / 4 + 1;
            }
        }

        internal tetris_object()
        {
            Random random = new Random();

            column = random.Next() % objects.Length;
            row = random.Next() % objects[column].Length;
        }

        internal void rotate(int x, int y, byte[,] matrix)
        {
            int original = row;

            while (++original < objects[column].Length)
                if (0 != check(objects[column][original], x, y, matrix))
                    goto _rotate;

            for (original = 0; original < row; ++original)
                if (0 != check(objects[column][original], x, y, matrix))
                    goto _rotate;

            return;

        _rotate:
            row = original;
        }

        private int check(byte[] cubes, int x, int y, byte[,] matrix)
        {
            int minx = Math.Min(Math.Min(cubes[0] % 4, cubes[1] % 4), Math.Min(cubes[2] % 4, cubes[3] % 4));
            int maxx = Math.Max(Math.Max(cubes[0] % 4, cubes[1] % 4), Math.Max(cubes[2] % 4, cubes[3] % 4));

            if (-minx > x || maxwidth - maxx <= x)
                return 0;

            if (maxheight <= y + cubes[3] / 4)
                return 0;

            foreach (byte cube in cubes)
            {
                int l = x + cube % 4;
                int t = y + cube / 4;

                if (0 <= l && maxwidth > l && 0 <= t && maxheight > t)
                    if (invalid != matrix[l, t])
                        if (1 > y + cubes[0] / 4)
                            return -1;
                        else
                            return 0;
            }

            return 1;
        }

        internal int check(int x, int y, byte[,] matrix)
        {
            return check(objects[column][row], x, y, matrix);
        }

        internal void shift(int x, int y, byte[,] matrix)
        {
            foreach (byte cube in objects[column][row])
                matrix[x + cube % 4, y + cube / 4] = (byte)column;
        }

        internal void draw(int x, int y, Graphics graphics)
        {
            foreach (byte cube in objects[column][row])
                graphics.FillRectangle(brushes[column], dimension * (x + cube % 4), dimension * (y + cube / 4), dimension - 1, dimension - 1);
        }
    }
}