cubesystem.java

一个java写的魔方游戏

// FrontEnd Plus GUI for JAD
// DeCompiled : CubeSystem.class

import java.awt.Graphics;

class CubeSystem
{

    static final String PlaneName[] = {
        "Plane0", "Plane1", "Plane2"
    };
    static final int XPlane = 0;
    static final int YPlane = 1;
    static final int ZPlane = 2;
    CubeMap Map;
    Object3D Cube;
    CubePlane PlaneTable[][];
    Model3D ModelPlane[];
    CubeModel ModelCube;
    private boolean InSpin;
    private int CurAxis;
    private int CurPlane;
    private boolean CurCounterclock;
    private static final int SpinTable[][] = {
        {
            500, 202, 201, 200, 400, 410, 420, 300, 301, 302, 
            520, 510, 500
        }, {
            501, 212, 211, 210, 401, 411, 421, 310, 311, 312, 
            521, 511, 501
        }, {
            502, 222, 221, 220, 402, 412, 422, 320, 321, 322, 
            522, 512, 502
        }, {
            502, 120, 110, 100, 402, 401, 400, 0, 10, 20, 
            500, 501, 502
        }, {
            512, 121, 111, 101, 412, 411, 410, 1, 11, 21, 
            510, 511, 512
        }, {
            522, 122, 112, 102, 422, 421, 420, 2, 12, 22, 
            520, 521, 522
        }, {
            100, 101, 102, 320, 310, 300, 2, 1, 0, 200, 
            210, 220, 100
        }, {
            110, 111, 112, 321, 311, 301, 12, 11, 10, 201, 
            211, 221, 110
        }, {
            120, 121, 122, 322, 312, 302, 22, 21, 20, 202, 
            212, 222, 120
        }
    };

    CubeSystem(Vertex vertex)
    {
        Map = new CubeMap();
        Cube = WholeCube();
        InSpin = false;
        ModelCube = new CubeModel(vertex);
        ModelPlane = new Model3D[3];
        for(int i = 0; i <= 2; i++)
            ModelPlane[i] = new Model3D(ModelCube.GetView());

        PlaneTable = new CubePlane[3][3];
        for(int j = 0; j <= 2; j++)
        {
            for(int k = 0; k < 3; k++)
            {
                PlaneTable[j][k] = new CubePlane(j, k);
                ModelPlane[j].AddObject(PlaneName[k], PlaneTable[j][k]);
            }

        }

        for(int l = 0; l < 6; l++)
            ((CubeFace)Cube.Faces[l]).SetMap(Map.ColorMap[l]);

        ModelCube.AddObject("Cube", Cube);
    }

    void DefineBound(int i, int j)
    {
        ModelCube.DefineBound(i, j);
    }

    void XRotateView(double d)
    {
        ModelCube.XRotateView(d);
    }

    void YRotateView(double d)
    {
        ModelCube.YRotateView(d);
    }

    void ZRotateView(double d)
    {
        ModelCube.ZRotateView(d);
    }

    public synchronized void Paint(Graphics g, int i, int j)
    {
        if(InSpin)
        {
            ModelPlane[CurAxis].Paint(g, i, j);
            return;
        } else
        {
            ModelCube.Paint(g, i, j);
            return;
        }
    }

    public void SpinMap(int i, int j, boolean flag)
    {
        Map.Spin(i, j, flag);
    }

    public void SetCubeMap()
    {
        for(int i = 0; i < 6; i++)
            ((CubeFace)Cube.Faces[i]).SetMap(Map.ColorMap[i]);

    }

    public synchronized void SpinBegin(int i, int j, boolean flag)
    {
        while(InSpin) 
            try
            {
                wait();
            }
            catch(InterruptedException _ex) { }
        InSpin = true;
        for(int k = 0; k < 3; k++)
            PlaneTable[i][k].SetMap(Map.ColorMap);

        CurAxis = i;
        CurPlane = j;
        CurCounterclock = flag;
    }

    public synchronized void Spin(int i)
    {
        if(!InSpin)
            return;
        double d = ((double)((CurCounterclock ? 15 : -15) * i) * 3.1415926535897931D) / 180D;
        switch(CurAxis)
        {
        case 0: // '\0'
            ModelPlane[0].XRotate(PlaneName[CurPlane], d);
            break;

        case 1: // '\001'
            ModelPlane[1].YRotate(PlaneName[CurPlane], d);
            break;

        case 2: // '\002'
            ModelPlane[2].ZRotate(PlaneName[CurPlane], d);
            break;
        }
        ModelPlane[CurAxis].Transform(PlaneName[CurPlane]);
    }

    public synchronized void SpinEnd()
    {
        if(!InSpin)
        {
            return;
        } else
        {
            ModelPlane[CurAxis].Unify(PlaneName[CurPlane]);
            ModelPlane[CurAxis].Transform(PlaneName[CurPlane]);
            SpinMap(CurAxis, CurPlane, CurCounterclock);
            SetCubeMap();
            InSpin = false;
            notify();
            return;
        }
    }

    public Vertex Unproject(float f, float f1)
    {
        return ModelCube.Unproject(f, f1);
    }

    public static int SelectFace(Vertex vertex)
    {
        if(vertex == null)
            return -1;
        if(vertex.x == -3F)
            return 0;
        if(vertex.x == 3F)
            return 1;
        if(vertex.y == -3F)
            return 2;
        if(vertex.y == 3F)
            return 3;
        if(vertex.z == -3F)
            return 4;
        return vertex.z != 3F ? -1 : 5;
    }

    public static int SelectHor(Vertex vertex)
    {
        if(vertex == null)
            return -1;
        int i = -1;
        if(vertex.x == -3F || vertex.x == 3F)
            i = (int)((vertex.y + 3F) / 2.0F);
        if(vertex.y == -3F || vertex.y == 3F)
            i = (int)((vertex.z + 3F) / 2.0F);
        if(vertex.z == -3F || vertex.z == 3F)
            i = (int)((vertex.x + 3F) / 2.0F);
        if(i < 3)
            return i;
        else
            return 2;
    }

    public static int SelectVer(Vertex vertex)
    {
        if(vertex == null)
            return -1;
        int i = -1;
        if(vertex.x == -3F || vertex.x == 3F)
            i = (int)((vertex.z + 3F) / 2.0F);
        if(vertex.y == -3F || vertex.y == 3F)
            i = (int)((vertex.x + 3F) / 2.0F);
        if(vertex.z == -3F || vertex.z == 3F)
            i = (int)((vertex.y + 3F) / 2.0F);
        if(i < 3)
            return i;
        else
            return 2;
    }

    public static int ComputeSpin(Vertex vertex, Vertex vertex1)
    {
        int i = SelectFace(vertex);
        int j = SelectVer(vertex);
        int k = SelectHor(vertex);
        int l = i * 100 + j * 10 + k;
        if(i == -1 || j == -1 || k == -1)
            return 9999;
        int i1 = SelectFace(vertex1);
        int j1 = SelectVer(vertex1);
        int k1 = SelectHor(vertex1);
        int l1 = i1 * 100 + j1 * 10 + k1;
        if(i1 == -1 || j1 == -1 || k1 == -1)
            return 9999;
        for(int i2 = 0; i2 < 9; i2++)
        {
            for(int j2 = 0; j2 <= 11; j2++)
            {
                if(SpinTable[i2][j2] == l && SpinTable[i2][j2 + 1] == l1)
                    return i2 + 1;
                if(SpinTable[i2][j2] == l1 && SpinTable[i2][j2 + 1] == l)
                    return -(i2 + 1);
            }

        }

        return 9999;
    }

    private Object3D WholeCube()
    {
        Vertex avertex[] = new Vertex[8];
        CubeFace acubeface[] = new CubeFace[6];
        avertex[0] = new Vertex(-3F, -3F, -3F);
        avertex[1] = new Vertex(3F, -3F, -3F);
        avertex[2] = new Vertex(3F, 3F, -3F);
        avertex[3] = new Vertex(-3F, 3F, -3F);
        avertex[4] = new Vertex(-3F, -3F, 3F);
        avertex[5] = new Vertex(3F, -3F, 3F);
        avertex[6] = new Vertex(3F, 3F, 3F);
        avertex[7] = new Vertex(-3F, 3F, 3F);
        for(int i = 0; i < 6; i++)
            acubeface[i] = new CubeFace(3, 3);

        ((Face) (acubeface[0])).Vertices[0] = avertex[0];
        ((Face) (acubeface[0])).Vertices[1] = avertex[3];
        ((Face) (acubeface[0])).Vertices[2] = avertex[7];
        ((Face) (acubeface[0])).Vertices[3] = avertex[4];
        ((Face) (acubeface[1])).Vertices[0] = avertex[1];
        ((Face) (acubeface[1])).Vertices[1] = avertex[2];
        ((Face) (acubeface[1])).Vertices[2] = avertex[6];
        ((Face) (acubeface[1])).Vertices[3] = avertex[5];
        ((Face) (acubeface[2])).Vertices[0] = avertex[0];
        ((Face) (acubeface[2])).Vertices[1] = avertex[4];
        ((Face) (acubeface[2])).Vertices[2] = avertex[5];
        ((Face) (acubeface[2])).Vertices[3] = avertex[1];
        ((Face) (acubeface[3])).Vertices[0] = avertex[3];
        ((Face) (acubeface[3])).Vertices[1] = avertex[7];
        ((Face) (acubeface[3])).Vertices[2] = avertex[6];
        ((Face) (acubeface[3])).Vertices[3] = avertex[2];
        ((Face) (acubeface[4])).Vertices[0] = avertex[0];
        ((Face) (acubeface[4])).Vertices[1] = avertex[1];
        ((Face) (acubeface[4])).Vertices[2] = avertex[2];
        ((Face) (acubeface[4])).Vertices[3] = avertex[3];
        ((Face) (acubeface[5])).Vertices[0] = avertex[4];
        ((Face) (acubeface[5])).Vertices[1] = avertex[5];
        ((Face) (acubeface[5])).Vertices[2] = avertex[6];
        ((Face) (acubeface[5])).Vertices[3] = avertex[7];
        Object3D object3d = new Object3D();
        object3d.Define(avertex, 8, acubeface, 6);
        return object3d;
    }

    public void NewGame()
    {
        Map.Reset();
        SetCubeMap();
    }

}