Сборка Кубика-Рубика

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Tao.FreeGlut;
using Tao.OpenGl;
 
// клас частин кубика, кубик-рубик складається з 27 маленьких кубиків.
class Small_Cube
{
    // шість граней - шість кольорів
    public int[] color = new int[6]; 
    // розмір ребра
    public float size;
 
    void Small_Cube() 
    {
        Gl.glColor3f(0,0,0);
        size = 0.0F;
    }
 
    // поворот на площині X0Y
    public void rotateZ()
    {
        int tmp= color[5];
        color[5] = color[3];
        color[3] = color[4];
        color[4] = color[2];
        color[2] = tmp;
    }
 
    // поворот на площині X0Z
    public void rotateY()
    {
        int tmp = color[2];
        color[2] = color[1];
        color[1] = color[3];
        color[3] = color[0];
        color[0] = tmp;
    }
 
    // поворот на площині Y0Z
    public void rotateX()
    {
        int tmp = color[0];
        color[0] = color[4];
        color[4] = color[1];
        color[1] = color[5];
        color[5] = tmp;
    }
 
    public void setColor(int i, int color)
    {
        this.color[i] = color;
    }
 
    public char[] at(int i)
    {
        // розбиваємо color[i] на 3 складові
        _color[0] = color[i] >> 16;
        _color[1] = color[i] >>  8;
        _color[2] = color[i]      ;
        return _color;
    }
 
    // малювання куба:
    public void draw()
    {
        Gl.glPushMatrix();
        Gl.glBegin(Gl.GL_QUADS);
 
        // верх
        Gl.glColor3ubv(at(0));
        Gl.glNormal3f(0, 0, 1);
        Gl.glVertex3f(size, size, size);          
        Gl.glVertex3f(0F, size, size);          
        Gl.glVertex3f(0, 0, size);          
        Gl.glVertex3f(size, 0, size);      
        
        // низ
        Gl.glColor3ubv(at(1));
        Gl.glNormal3f(0, 0, -1);
        Gl.glVertex3f(size, 0, 0);
        Gl.glVertex3f(0, 0, 0);   
        Gl.glVertex3f(0, size, 0);  
        Gl.glVertex3f(size, size, 0);
 
        // передня частина
        Gl.glColor3ubv(at(2));
        Gl.glNormal3f(0, -1, 0);
        Gl.glVertex3f(size, 0, size);
        Gl.glVertex3f(0, 0, size);   
        Gl.glVertex3f(0, 0, 0);      
        Gl.glVertex3f(size, 0, 0); 
 
        // задня частина
        Gl.glColor3ubv(at(3));
        Gl.glNormal3f(0, 1, 0);
        Gl.glVertex3f(size, size, 0);   
        Gl.glVertex3f(0, size, 0);      
        Gl.glVertex3f(0, size, size);   
        Gl.glVertex3f(size, size, size);
 
        // зліва
        Gl.glColor3ubv(at(4));
        Gl.glNormal3f(-1, 0, 0);
        Gl.glVertex3f(0, size, size);   
        Gl.glVertex3f(0, size, 0);      
        Gl.glVertex3f(0, 0, 0);         
        Gl.glVertex3f(0, 0, size);      
 
        // справа
        Gl.glColor3ubv(at(5));
        Gl.glNormal3f(1, 0, 0);
        Gl.glVertex3f(size, size, 0);
        Gl.glVertex3f(size, size, size);
        Gl.glVertex3f(size, 0, size);   
        Gl.glVertex3f(size, 0, 0);      
 
        Gl.glEnd();
        Gl.glPopMatrix();
    }
 
    // малювання куба зі зміщенням (x, y, z)
    public void draw(double x, double y, double z)
    {
        Gl.glPushMatrix();
        Gl.glTranslated(x, y, z);
        draw();
        Gl.glPopMatrix();
    }
 
private char[] _color= new char[4];
};
 
    class Cube
{
    // 27 частин
    Small_Cube[,,] a=new Small_Cube[3, 3, 3];
    // зберігаємо кут повороту кожної грані
    int[] rotate=new int[6];
    // розмір кубика-рубика
    double size;
    // кольори граней
     int[] color = new int[6];
 
    // зберігаємо номер грані, яка повертається або -1, якщо нічого не повертається
    public int current;
 
    public Cube()
    {
    }
 
    public Cube(float size, int[] color) 
    {
        clear(size, color);
    }
 
    public void clear(float size, int[] color) 
    {
        this.size = size;
        current = -1;
 
        int i, j, k;
        for(i = 0; i < 6; i++)
            this.color[i] = color[i];
 
        // верх
        for(i = 0; i < 3; i++)
            for(j = 0; j < 3; j++)
                a[i,j,2].setColor(0, color[0]);
 
        // низ
        for(i = 0; i < 3; i++)
            for(j = 0; j < 3; j++)
                a[i,j,0].setColor(1, color[1]);
 
        // спереду
        for(k = 0; k < 3; k++)
            for(j = 0; j < 3; j++)
                a[j,0,k].setColor(2, color[2]);
 
        // позаду
        for(k = 0; k < 3; k++)
            for(j = 0; j < 3; j++)
                a[j,2,k].setColor(3, color[3]);
 
        // зліва
        for(i = 0; i < 3; i++)
            for(k = 0; k < 3; k++)
                a[0,k,i].setColor(4, color[4]);
        // справа
        for(i = 0; i < 3; i++)
            for(k = 0; k < 3; k++)
                a[2,k,i].setColor(5, color[5]);
 
        for(i = 0; i < 3; i++)
            for(j = 0; j < 3; j++)
                for(k = 0; k < 3; k++)
                    a[i,j,k].size = (size / 3.0) * 0.95;
    }
 
    public void draw()
    {
        const double K = 0.65;
        // малюємо куб чорного кольору
        Gl.glPushMatrix();
        Gl.glColor3f(0, 0, 0);
        Gl.glTranslatef(((1.0 - K)/2)*size + K*size/2, ((1.0 - K)/2)*size + K*size/2, ((1.0 - K)/2)*size + K*size/2);
        Glut.glutSolidCube(size * K);
        Gl.glPopMatrix();
 
        memset(ok, true, sizeof(ok));
        if (current != -1)
        {
            Gl.glPushMatrix();
            int i, j, k;
 
            if (current == 0 || current == 1)
            {
                // 0 <= current <= 1 показує, що зараз крутиться грань на площині X0Y
                // current = 0 - нижня частина
                // current = 1 - верхня частина
                k = (current & 1) * 2;
                for(i = 0; i < 3; i++)
                    for(j = 0; j < 3; j++)
                        ok[i,j,k] = false;
                
                // теперь крутимо грань під номером current на кут rotate[current] відносно центра цієї грані
                Gl.glTranslated(size / 2, size / 2, 0);   // зсуваємось до центру
                Gl.glRotatef(rotate[current], 0, 0, 1);   // крутимо
                Gl.glTranslated(-size / 2, -size / 2, 0); // зсуваємось назад
                // малюємо
                for(i = 0; i < 3; i++)
                    for(j = 0; j < 3; j++)
                        a[i,j,k].draw(size / 3 * i, size / 3 * j, size / 3 * k);
            }
            // аналогічно з іншими гранями
            else if (current == 2 || current == 3)
            {
                j = (current & 1) * 2;
                for(i = 0; i < 3; i++)
                    for(k = 0; k < 3; k++)
                        ok[i,j,k] = false;
                
                Gl.glTranslated(size / 2, 0, size / 2);
                Gl.glRotatef(rotate[current], 0, 1, 0);
                Gl.glTranslated(-size / 2, 0, -size / 2);
                for(i = 0; i < 3; i++)
                    for(k = 0; k < 3; k++)
                        a[i,j,k].draw(size / 3 * i, size / 3 * j, size / 3 * k);
            }
            else if (current == 4 || current == 5)
            {
                i = (current & 1) * 2;
                for(j = 0; j < 3; j++)
                    for(k = 0; k < 3; k++)
                        ok[i,j,k] = false;
                
                Gl.glTranslated(0, size / 2, size / 2);
                Gl.glRotatef(rotate[current], 1, 0, 0);
                Gl.glTranslated(0, -size / 2, -size / 2);
                for(j = 0; j < 3; j++)
                    for(k = 0; k < 3; k++)
                        a[i,j,k].draw(size / 3 * i, size / 3 * j, size / 3 * k);
            }
            Gl.glPopMatrix();
        }
 
        for(int i = 0; i < 3; i++)
            for(int j = 0; j < 3; j++)
                for(int k = 0; k < 3; k++)
                    if (ok[i,j,k])
                        // тепер малюємо ті деталі, які не повертались вище,
                        // они відмічені ok[i][j][k] = true
                        a[i,j,k].draw(size / 3 * i, size / 3 * j, size / 3 * k);
    }
 
 
    public void rot90(int idx, int sign)
    {
        int i, j, k;
        // sign задається в залежності від напрямку
        // sign = -1, sign = 1
        // якщо sign = -1, крутимо 3 раза
        if (sign == -1)
            sign = 3;
        while(sign--!=0)
        {
            if (idx == 0 || idx == 1)
            {
                k = (idx & 1) * 2;
                // копіюємо повернуту на 90 градусів верхню/нижню грань
                // в масив tmp, потім грані присвоюємо tmp
                // і повертаємо кожну деталь цієї грані
                for(i = 0; i < 3; i++)
                    for(j = 0; j < 3; j++)
                        tmp[j,2 - i] = a[i,j,k];
                for(i = 0; i < 3; i++)
                    for(j = 0; j < 3; j++){
                        tmp[i,j].rotateZ();
                        a[i,j,k] = tmp[i,j];
                    }
            }
            // аналогічно з іншими 4 гранями
            else if (idx == 2 || idx == 3)
            {
                j = (idx & 1) * 2;
                for(i = 0; i < 3; i++)
                    for(k = 0; k < 3; k++)
                        tmp[k,2 - i] = a[i,j,k];
                for(i = 0; i < 3; i++)
                    for(k = 0; k < 3; k++){
                        tmp[i,k].rotateX();
                        a[i,j,k] = tmp[i,k];
                    }
            }
            else if (idx == 4 || idx == 5)
            {
                i = (idx & 1) * 2;
                for(j = 0; j < 3; j++)
                    for(k = 0; k < 3; k++)
                        tmp[k,2 - j] = a[i,j,k];
                for(j = 0; j < 3; j++)
                    for (k = 0; k < 3; k++)
                    {
                        tmp[j, k].rotateY();
                        a[i, j, k] = tmp[j, k];
                    }
            }
        }
    }
 
    // крутимо грань под номером idx на кут angle (в градусах)
    public void Rotate(int idx, int angle)
    {
        if (current == -1 || current == idx)
        {
            // обновляємо поворот
            rotate[idx] += angle;
 
            if (rotate[idx] % 90 != 0)
            {
                current = idx;
            }
            else
            {
                // якщо кут став кратним 90, то обертаємо
                if ((rotate[idx] < 0) ^ (current == 2 || current == 3))
                    rot90(idx, 1);
                else
                    rot90(idx, -1);
                rotate[idx] = 0;
                current = -1;
            }
        }
    }
    private int[] _angle=new int[4];
    private bool[ , , ] ok= new bool[4,4,4];
    private Small_Cube[,] tmp=new Small_Cube[4,4];
};
 
 
class EntryPoint{
 static int CUBE_SIZE=13;
static int TIMER=30;
// позначаємо кольори:
 static int[] c=new int[]{0xFFFFFF, 0xFFFF00, 0x0000FF, 0x00FF00, 0xFF0000,     0xCD853F};
 
// координати джерела світла
static float[] lightPos = new float[]{0, 100, 200, 0}; 
// проекції кута повороту на осі
static int xRot = 0, yRot = 0, zRot = 0;
static float translateZ = -32.0F;
// кубик-рубик
static Cube cube=new Cube();
static int timerOn = 0;
 
static void display()
{
    Gl.glPushMatrix();
    Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
    Gl.glColor3f(1, 0, 0);
    Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_POSITION, lightPos);
    Gl.glTranslatef(0, 0, translateZ);
    Gl.glRotatef(xRot, 1, 0, 0);
    Gl.glRotatef(yRot, 0, 1, 0);
    Gl.glTranslatef(CUBE_SIZE / -2.0F, CUBE_SIZE / -2.0F, CUBE_SIZE / -2.0F);
    cube.draw();
    Gl.glPopMatrix();
    Glut.glutSwapBuffers();
}
 
static void reshape(int w, int h)
{
    Gl.glViewport(0, 0, w, h);
    Gl.glMatrixMode(Gl.GL_PROJECTION);
    Gl.glLoadIdentity();
    float fAspect = (float)w/(float)h;
    Glu.gluPerspective(60, fAspect, 1, 1000.0);
    Gl.glMatrixMode(Gl.GL_MODELVIEW);
    Gl.glLoadIdentity();
}
 
static void init()
{
    Gl.glClearColor(0.0F, 0.0F, 0.0F, 0.0F);
    // освітлення
    float[] mat_specular=new float[]{0.3F, 0.3F, 0.3F, 0F};
    float[] diffuseLight =new float[]{0.2F, 0.2F, 0.2F, 1F};
    float[] ambientLight =new float[]{0.9F, 0.9F, 0.9F, 1.0F};
    Gl.glShadeModel(Gl.GL_SMOOTH);
    Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_SPECULAR, mat_specular);
    Gl.glMateriali(Gl.GL_FRONT, Gl.GL_SHININESS, 128);
    Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_DIFFUSE, diffuseLight);
    Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_AMBIENT, ambientLight);
    Gl.glEnable(Gl.GL_LIGHT0);
    Gl.glEnable(Gl.GL_COLOR_MATERIAL);
    Gl.glColorMaterial(Gl.GL_FRONT, Gl.GL_AMBIENT);
    Gl.glEnable(Gl.GL_DEPTH_TEST);
    Gl.glEnable(Gl.GL_LIGHTING);
 
    // иніціалізуємо куб
    cube.clear(CUBE_SIZE, c);
}
 
static void specialKeys(int key, int x, int y)
{
    // клавиші вліво/вправо обертають по Y
    // клавиши вгору/вниз обертають по X
    // F1 - повертає в початкове положення
    if (key == Glut.GLUT_KEY_DOWN)
    {
        xRot += 3;
        if (xRot >= 360)
            xRot -= 360;
        Glut.glutPostRedisplay();
    }
 
    if (key == Glut.GLUT_KEY_UP)
    {
        xRot -= 3;
        if (xRot < 0)
            xRot += 360;
        Glut.glutPostRedisplay();
    }
 
    if (key == Glut.GLUT_KEY_RIGHT)
    {
        yRot += 3;
        if (yRot >= 360)
            yRot -= 360;
        Glut.glutPostRedisplay();
    }
 
    if (key == Glut.GLUT_KEY_LEFT)
    {
        yRot -= 3;
        if (yRot < 0)
            yRot += 360;
        Glut.glutPostRedisplay();
    }
 
    if (key == Glut.GLUT_KEY_HOME)
    {
        translateZ += 5;
        Glut.glutPostRedisplay();
    }
 
    if (key == Glut.GLUT_KEY_END)
    {
        translateZ -= 5;
        Glut.glutPostRedisplay();
    }
 
    if (key == Glut.GLUT_KEY_F1)
    {
        cube.clear(CUBE_SIZE, c);
        Glut.glutPostRedisplay();
    }
}
 
static void keys(char key, int x, int y)
{
    // якщо натиснули кнопку від 0 до 5 - починаємо поворот на 3 градуса
    if (cube.current == -1 && key >= '0' && key < '6')
    {
        cube.Rotate(key - '0', 3);
        display();
    }
}
 
static void mouse(int key, int state, int x, int y)
{
    if (key == Glut.GLUT_RIGHT_BUTTON && state == Glut.GLUT_DOWN)
    {
        timerOn = 1 - timerOn;
    }
}
 
static void timer(int x)
{
    Glut.glutTimerFunc(TIMER, timer, 0);
    if (timerOn!=0)
    {
        if (cube.current == -1)
            keys(rand() % 6 + '0', 0, 0);
        else
            cube.Rotate(cube.current, 3);
    }
    else
    {
        if (cube.current != -1)
            cube.Rotate(cube.current, 3);
    }
    display();
}
 
static int Main()
{
    Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_RGB | Glut.GLUT_DEPTH);
    Glut.glutInitWindowSize(800, 700);
    Glut.glutInitWindowPosition(1, 1);
    Glut.glutCreateWindow("Cube");
    init();
    Glut.glutDisplayFunc(display);
    Glut.glutReshapeFunc(reshape);
    Glut.glutKeyboardFunc(keys);
    Glut.glutMouseFunc(mouse);
    Glut.glutTimerFunc(TIMER, timer, 0);
    Glut.glutSpecialFunc(specialKeys);
    Glut.glutMainLoop();
    return 0;
}
}