魔方

import java.awt.*; 

import java.applet.Applet; 



public final class rubik extends Applet { 

  int i; 



  int j; 



  int k; 



  int n; 



  int o; 



  int p; 



  int q; 



  int lastX; 



  int lastY; 



  int dx; 



  int dy; 



  int rectX[]; 



  int rectY[]; 



  Color colList[]; 



  Color bgcolor; 



  final double sideVec[] = { 0.0, 0.0, 1.0, 0.0, 0.0, -1, 0.0, -1, 0.0, 1.0, 

      0.0, 0.0, 0.0, 1.0, 0.0, -1, 0.0, 0.0 }; 



  final double corners[] = { -1, -1, -1, 1.0, -1, -1, 1.0, 1.0, -1, -1, 1.0, 

      -1, -1, -1, 1.0, 1.0, -1, 1.0, 1.0, 1.0, 1.0, -1, 1.0, 1.0 }; 



  double topCorners[]; 



  double botCorners[]; 



  final int sides[] = { 4, 5, 6, 7, 3, 2, 1, 0, 0, 1, 5, 4, 1, 2, 6, 5, 2, 3, 

      7, 6, 0, 4, 7, 3 }; 



  final int nextSide[] = { 2, 3, 4, 5, 4, 3, 2, 5, 1, 3, 0, 5, 1, 4, 0, 2, 1, 

      5, 0, 3, 2, 0, 4, 1 }; 



  final int mainBlocks[] = { 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 

      3, 0, 3, 0, 3, 0, 3 }; 



  final int twistDir[] = { -1, 1, -1, 1, -1, 1, -1, 1, 1, 1, 1, 1, 1, -1, 1, 

      -1, 1, 1, 1, 1, -1, 1, -1, 1 }; 



  final int colDir[] = { -1, -1, 1, -1, 1, -1 }; 



  final int circleOrder[] = { 0, 1, 2, 5, 8, 7, 6, 3 }; 



  int topBlocks[]; 



  int botBlocks[]; 



  int sideCols[]; 



  int sideW; 



  int sideH; 



  int dragReg; 



  int twistSide; 



  int nearSide[]; 



  int buffer[]; 



  double dragCorn[]; 



  double dragDir[]; 



  double eye[] = { 0.3651, 0.1826, -0.9129 }; 



  double eX[] = { 0.9309, -0.0716, 0.3581 }; 



  double eY[]; 



  double Teye[]; 



  double TeX[]; 



  double TeY[]; 



  double light[]; 



  double temp[] = { 0.0, 0.0, 0.0 }; 



  double temp2[] = { 0.0, 0.0, 0.0 }; 



  double newCoord[]; 



  double sx; 



  double sy; 



  double sdxh; 



  double sdyh; 



  double sdxv; 



  double sdyv; 



  double d; 



  double t1; 



  double t2; 



  double t3; 



  double t4; 



  double t5; 



  double t6; 



  double phi; 



  double phibase; 



  double Cphi; 



  double Sphi; 



  double currDragDir[]; 



  boolean naturalState; 



  boolean twisting; 



  boolean OKtoDrag; 



  double local0; 



  Math m; 



  Graphics offGraphics; 



  Image offImage; 



  public void init() { 

    offImage = createImage(120, 120); 

    offGraphics = offImage.getGraphics(); 

    rectX = new int[4]; 

    rectY = new int[4]; 

    newCoord = new double[16]; 

    dragDir = new double[24]; 

    dragCorn = new double[96]; 

    topCorners = new double[24]; 

    botCorners = new double[24]; 

    topBlocks = new int[24]; 

    botBlocks = new int[24]; 

    buffer = new int[12]; 

    nearSide = new int[12]; 

    light = new double[3]; 

    Teye = new double[3]; 

    TeX = new double[3]; 

    TeY = new double[3]; 

    currDragDir = new double[2]; 

    eY = new double[3]; 

    vecProd(eye, 0, eX, 0, eY, 0); 

    normalize(eY, 0); 

    colList = new Color[120]; 

    for (i = 0; i < 20; i++) { 

      colList[i] = new Color(103 + i * 8, 103 + i * 8, 103 + i * 8); 

      colList[i + 20] = new Color(i * 6, i * 6, 84 + i * 9); 

      colList[i + 40] = new Color(84 + i * 9, i * 5, i * 5); 

      colList[i + 60] = new Color(i * 6, 84 + i * 9, i * 6); 

      colList[i + 80] = new Color(84 + i * 9, 84 + i * 9, i * 6); 

      colList[i + 100] = new Color(84 + i * 9, 55 + i * 8, i * 3); 

    } 

    sideCols = new int[54]; 

    for (i = 0; i < 54; i++) 

      sideCols[i] = i / 9; 

    bgcolor = findBGColor(); 

    resize(125, 125); 

    repaint(); 

  } 



  public Color findBGColor() { 

    Color color; 

    String string2 = "0123456789abcdef"; 

    int an[] = new int[6]; 

    String string1 = getParameter("bgcolor"); 

    if (string1 != null && string1.length() == 6) { 

      for (i = 0; i < 6; i++) 

        for (j = 0; j < 16; j++) 

          if (string1.charAt(i) == string2.charAt(j)) an[i] = j; 

      color = new Color(an[0] * 16 + an[1], an[2] * 16 + an[3], an[4] * 16 

          + an[5]); 

    } else color = Color.lightGray; 

    return color; 

  } 



  public double scalProd(double ad1[], int i, double ad2[], int j) { 

    return ad1[i] * ad2[j] + ad1[i + 1] * ad2[j + 1] + ad1[i + 2] * ad2[j + 2]; 

  } 



  public double vNorm(double ad[], int i) { 

    return Math.sqrt(ad[i] * ad[i] + ad[i + 1] * ad[i + 1] + ad[i + 2] 

        * ad[i + 2]); 

  } 



  public double cosAng(double ad1[], int i, double ad2[], int j) { 

    return scalProd(ad1, i, ad2, j) / (vNorm(ad1, i) * vNorm(ad2, j)); 

  } 



  public void normalize(double ad[], int i) { 

    local0 = vNorm(ad, i); 

    ad[i] = ad[i] / local0; 

    ad[i + 1] = ad[i + 1] / local0; 

    ad[i + 2] = ad[i + 2] / local0;  

  } 



  public void scalMult(double ad[], int i, double d) { 

    ad[i] = ad[i] * d; 

    ad[i + 1] = ad[i + 1] * d; 

    ad[i + 2] = ad[i + 2] * d; 

  } 



  public void addVec(double ad1[], int i, double ad2[], int j) { 

    ad2[j] += ad1[i]; 

    ad2[j + 1] += ad1[i + 1]; 

    ad2[j + 2] += ad1[i + 2]; 

  } 



  public void subVec(double ad1[], int i, double ad2[], int j) { 

    ad2[j] -= ad1[i]; 

    ad2[j + 1] -= ad1[i + 1]; 

    ad2[j + 2] -= ad1[i + 2]; 

  } 



  public void copyVec(double ad1[], int i, double ad2[], int j) { 

    ad2[j] = ad1[i]; 

    ad2[j + 1] = ad1[i + 1]; 

    ad2[j + 2] = ad1[i + 2]; 

  } 



  public void vecProd(double ad1[], int i, double ad2[], int j, double ad3[], 

      int k) { 

    ad3[k] = ad1[i + 1] * ad2[j + 2] - ad1[i + 2] * ad2[j + 1]; 

    ad3[k + 1] = ad1[i + 2] * ad2[j] - ad1[i] * ad2[j + 2]; 

    ad3[k + 2] = ad1[i] * ad2[j + 1] - ad1[i + 1] * ad2[j]; 

  } 



  public void cutUpCube() { 

    for (i = 0; i < 24; i++) { 

      topCorners[i] = corners[i]; 

      botCorners[i] = corners[i]; 

    } 

    copyVec(sideVec, 3 * twistSide, temp, 0); 

    copyVec(temp, 0, temp2, 0); 

    scalMult(temp, 0, 1.3333); 

    scalMult(temp2, 0, 0.6667); 

    for (i = 0; i < 8; i++) { 

      boolean flag = false; 

      for (j = 0; j < 4; j++) 

        if (i == sides[twistSide * 4 + j]) flag = true; 

      if (flag) subVec(temp2, 0, botCorners, i * 3); 

      else addVec(temp, 0, topCorners, i * 3); 

    } 

    for (i = 0; i < 24; i++) { 

      topBlocks[i] = mainBlocks[i]; 

      botBlocks[i] = mainBlocks[i]; 

    } 

    for (i = 0; i < 6; i++) { 

      if (i == twistSide) { 

        botBlocks[i * 4 + 1] = 0; 

        botBlocks[i * 4 + 3] = 0; 

      } else { 

        k = -1; 

        for (j = 0; j < 4; j++) 

          if (nextSide[i * 4 + j] == twistSide) k = j; 

        switch (k) { 

          case 0: 

            topBlocks[i * 4 + 3] = 1; 

            botBlocks[i * 4 + 2] = 1; 

          break; 



          case 1: 

            topBlocks[i * 4] = 2; 

            botBlocks[i * 4 + 1] = 2; 

          break; 



          case 2: 

            topBlocks[i * 4 + 2] = 2; 

            botBlocks[i * 4 + 3] = 2; 

          break; 



          case 3: 

            topBlocks[i * 4 + 1] = 1; 

            botBlocks[i * 4] = 1; 

          break; 



          case -1: 

            topBlocks[i * 4 + 1] = 0; 

            topBlocks[i * 4 + 3] = 0; 

          break; 

        } 

      } 

    } 

  } 



  public boolean keyDown(Event event, int i) { 

    if (i == 114) { 

      twisting = false; 

      naturalState = true; 

      for (this.i = 0; this.i < 54; this.i++) 

        sideCols[this.i] = this.i / 9; 

      repaint(); 

    } else if (i == 115) { 

      twisting = false; 

      naturalState = true; 

      for (this.i = 0; this.i < 20; this.i++) 

        colorTwist((int) (Math.random() * 6), (int) (Math.random() * 3 + 1.0)); 

      repaint(); 

    } 

    return false; 

  } 



  public boolean mouseDrag(Event event, int i, int j) { 

    if (!twisting && OKtoDrag) { 

      OKtoDrag = false; 

      boolean flag = false; 

      for (this.i = 0; this.i < dragReg; this.i++) { 

        double d1 = dragCorn[this.i * 8 + 1] - dragCorn[this.i * 8]; 

        double d2 = dragCorn[this.i * 8 + 5] - dragCorn[this.i * 8 + 4]; 

        double d3 = dragCorn[this.i * 8 + 3] - dragCorn[this.i * 8]; 

        double d4 = dragCorn[this.i * 8 + 7] - dragCorn[this.i * 8 + 4]; 

        double d5 = (d4 * ((double) lastX - dragCorn[this.i * 8]) - d3 

            * ((double) lastY - dragCorn[this.i * 8 + 4])) 

            / (d1 * d4 - d3 * d2); 

        double d6 = (-d2 * ((double) lastX - dragCorn[this.i * 8]) + d1 

            * ((double) lastY - dragCorn[this.i * 8 + 4])) 

            / (d1 * d4 - d3 * d2); 

        if (d5 > 0.0 && d5 < 1.0 && d6 > 0.0 && d6 < 1.0) { 

          currDragDir[0] = dragDir[this.i * 2]; 

          currDragDir[1] = dragDir[this.i * 2 + 1]; 

          d = currDragDir[0] * (i - lastX) + currDragDir[1] * (j - lastY); 

          d = d 

              * d 

              / ((currDragDir[0] * currDragDir[0] + currDragDir[1] 

                  * currDragDir[1]) * ((i - lastX) * (i - lastX) + (j - lastY) 

                  * (j - lastY))); 

          if (d > 0.6) { 

            flag = true; 

            twistSide = nearSide[this.i]; 

            this.i = 100; 

          } 

        } 

      } 

      if (flag) { 

        if (naturalState) { 

          cutUpCube(); 

          naturalState = false; 

        } 

        twisting = true; 

        phi = 0.02 

            * (currDragDir[0] * (i - lastX) + currDragDir[1] * (j - lastY)) 

            / Math.sqrt(currDragDir[0] * currDragDir[0] + currDragDir[1] 

                * currDragDir[1]); 

        repaint(); 

        return false; 

      } 

    } 

    OKtoDrag = false; 

    if (!twisting) { 

      dx = lastX - i; 

      copyVec(eX, 0, temp, 0); 

      scalMult(temp, 0, (double) dx * 0.016); 

      addVec(temp, 0, eye, 0); 

      vecProd(eY, 0, eye, 0, eX, 0); 

      normalize(eX, 0); 

      normalize(eye, 0); 

      dy = j - lastY; 

      copyVec(eY, 0, temp, 0); 

      scalMult(temp, 0, (double) dy * 0.016); 

      addVec(temp, 0, eye, 0); 

      vecProd(eye, 0, eX, 0, eY, 0); 

      normalize(eY, 0); 

      normalize(eye, 0); 

      lastX = i; 

      lastY = j; 

      repaint(); 

    } else { 

      phi = 0.02 

          * (currDragDir[0] * (i - lastX) + currDragDir[1] * (j - lastY)) 

          / Math.sqrt(currDragDir[0] * currDragDir[0] + currDragDir[1] 

              * currDragDir[1]); 

      repaint(); 

    } 

    return false; 

  } 



  public boolean mouseDown(Event event, int i, int j) { 

    lastX = i; 

    lastY = j; 

    OKtoDrag = true; 

    return false; 

  } 



  public boolean mouseUp(Event event, int i, int j) { 

    if (twisting) { 

      double d; 

      twisting = false; 

      phibase += phi; 

      phi = 0.0; 

      for (d = phibase; d < 0.0; d += 125.662) /* null body */; 

      int k = (int) (d * 3.183); 

      if (k % 5 == 0 || k % 5 == 4) { 

        k = (k + 1) / 5 % 4; 

        if (colDir[twistSide] < 0) k = (4 - k) % 4; 

        phibase = 0.0; 

        naturalState = true; 

        colorTwist(twistSide, k); 

      } 

      repaint(); 

    } 

    return false; 

  } 



  public void colorTwist(int i1, int j1) { 

    int k4 = 0; 

    int j4 = j1 * 2; 

    for (int k1 = 0; k1 < 8; k1++) { 

      buffer[j4] = sideCols[i1 * 9 + circleOrder[k1]]; 

      j4 = (j4 + 1) % 8; 

    } 

    for (int i2 = 0; i2 < 8; i2++) 

      sideCols[i1 * 9 + circleOrder[i2]] = buffer[i2]; 

    j4 = j1 * 3; 

    for (int j2 = 0; j2 < 4; j2++) { 

      for (int i3 = 0; i3 < 4; i3++) 

        if (nextSide[nextSide[i1 * 4 + j2] * 4 + i3] == i1) k4 = i3; 

      for (int j3 = 0; j3 < 3; j3++) { 

        switch (k4) { 

          case 0: 

            buffer[j4] = sideCols[nextSide[i1 * 4 + j2] * 9 + j3]; 

          break; 



          case 1: 

            buffer[j4] = sideCols[nextSide[i1 * 4 + j2] * 9 + 2 + 3 * j3]; 

          break; 



          case 2: 

            buffer[j4] = sideCols[nextSide[i1 * 4 + j2] * 9 + 8 - j3]; 

          break; 



          case 3: 

            buffer[j4] = sideCols[nextSide[i1 * 4 + j2] * 9 + 6 - 3 * j3]; 

          break; 

        } 

        j4 = (j4 + 1) % 12; 

      } 

    } 

    j4 = 0; 

    for (int k2 = 0; k2 < 4; k2++) { 

      for (int k3 = 0; k3 < 4; k3++) 

        if (nextSide[nextSide[i1 * 4 + k2] * 4 + k3] == i1) k4 = k3; 

      for (int i4 = 0; i4 < 3; i4++) { 

        switch (k4) { 

          case 0: 

            sideCols[nextSide[i1 * 4 + k2] * 9 + i4] = buffer[j4]; 

          break; 



          case 1: 

            sideCols[nextSide[i1 * 4 + k2] * 9 + 2 + 3 * i4] = buffer[j4]; 

          break; 



          case 2: 

            sideCols[nextSide[i1 * 4 + k2] * 9 + 8 - i4] = buffer[j4]; 

          break; 



          case 3: 

            sideCols[nextSide[i1 * 4 + k2] * 9 + 6 - 3 * i4] = buffer[j4]; 

          break; 

        } 

        j4++; 

      } 

    } 

  } 



  public void paint(Graphics g) { 

    dragReg = 0; 

    offGraphics.setColor(bgcolor); 

    offGraphics.fillRect(0, 0, 120, 120); 

    if (naturalState) fixBlock(eye, eX, eY, corners, mainBlocks, 0); 

    else { 

      copyVec(eye, 0, Teye, 0); 

      copyVec(eX, 0, TeX, 0); 

      Cphi = Math.cos(phi + phibase); 

      Sphi = -Math.sin(phi + phibase); 

      switch (twistSide) { 

        case 0: 

          Teye[0] = Cphi * eye[0] + Sphi * eye[1]; 

          TeX[0] = Cphi * eX[0] + Sphi * eX[1]; 

          Teye[1] = -Sphi * eye[0] + Cphi * eye[1]; 

          TeX[1] = -Sphi * eX[0] + Cphi * eX[1]; 

        break; 



        case 1: 

          Teye[0] = Cphi * eye[0] - Sphi * eye[1]; 

          TeX[0] = Cphi * eX[0] - Sphi * eX[1]; 

          Teye[1] = Sphi * eye[0] + Cphi * eye[1]; 

          TeX[1] = Sphi * eX[0] + Cphi * eX[1]; 

        break; 



        case 2: 

          Teye[0] = Cphi * eye[0] - Sphi * eye[2]; 

          TeX[0] = Cphi * eX[0] - Sphi * eX[2]; 

          Teye[2] = Sphi * eye[0] + Cphi * eye[2]; 

          TeX[2] = Sphi * eX[0] + Cphi * eX[2]; 

        break; 



        case 3: 

          Teye[1] = Cphi * eye[1] + Sphi * eye[2]; 

          TeX[1] = Cphi * eX[1] + Sphi * eX[2]; 

          Teye[2] = -Sphi * eye[1] + Cphi * eye[2]; 

          TeX[2] = -Sphi * eX[1] + Cphi * eX[2]; 

        break; 



        case 4: 

          Teye[0] = Cphi * eye[0] + Sphi * eye[2]; 

          TeX[0] = Cphi * eX[0] + Sphi * eX[2]; 

          Teye[2] = -Sphi * eye[0] + Cphi * eye[2]; 

          TeX[2] = -Sphi * eX[0] + Cphi * eX[2]; 

        break; 



        case 5: 

          Teye[1] = Cphi * eye[1] - Sphi * eye[2]; 

          TeX[1] = Cphi * eX[1] - Sphi * eX[2]; 

          Teye[2] = Sphi * eye[1] + Cphi * eye[2]; 

          TeX[2] = Sphi * eX[1] + Cphi * eX[2]; 

        break; 

      } 

      vecProd(Teye, 0, TeX, 0, TeY, 0); 

      if (scalProd(eye, 0, sideVec, twistSide * 3) < 0.0) { 

        fixBlock(Teye, TeX, TeY, topCorners, topBlocks, 2); 

        fixBlock(eye, eX, eY, botCorners, botBlocks, 1); 

      } else { 

        fixBlock(eye, eX, eY, botCorners, botBlocks, 1); 

        fixBlock(Teye, TeX, TeY, topCorners, topBlocks, 2); 

      } 

    } 

    g.drawImage(offImage, 0, 0, this); 

  } 



  public void update(Graphics g) { 

    paint(g); 

  } 



  public void fixBlock(double ad1[], double ad2[], double ad3[], double ad4[], 

      int an[], int i) { 

    copyVec(ad1, 0, light, 0); 

    scalMult(light, 0, -3); 

    addVec(ad2, 0, light, 0); 

    subVec(ad3, 0, light, 0); 

    for (this.i = 0; this.i < 8; this.i++) { 

      newCoord[this.i * 2] = 60 + 35.1 * scalProd(ad4, this.i * 3, ad2, 0); 

      newCoord[this.i * 2 + 1] = 60 - 35.1 * scalProd(ad4, this.i * 3, ad3, 0); 

    } 

    for (this.i = 0; this.i < 6; this.i++) { 

      if (scalProd(ad1, 0, sideVec, 3 * this.i) > 0.001) { 

        k = (int) (9.6 * (1.0 - cosAng(light, 0, sideVec, 3 * this.i))); 

        offGraphics.setColor(Color.black); 

        for (j = 0; j < 4; j++) { 

          rectX[j] = (int) newCoord[2 * sides[this.i * 4 + j]]; 

          rectY[j] = (int) newCoord[2 * sides[this.i * 4 + j] + 1]; 

        } 

        offGraphics.fillPolygon(rectX, rectY, 4); 

        sideW = an[this.i * 4 + 1] - an[this.i * 4]; 

        sideH = an[this.i * 4 + 3] - an[this.i * 4 + 2]; 

        if (sideW > 0) { 

          sx = newCoord[2 * sides[this.i * 4]]; 

          sy = newCoord[2 * sides[this.i * 4] + 1]; 

          sdxh = (newCoord[2 * sides[this.i * 4 + 1]] - sx) / sideW; 

          sdxv = (newCoord[2 * sides[this.i * 4 + 3]] - sx) / sideH; 

          sdyh = (newCoord[2 * sides[this.i * 4 + 1] + 1] - sy) / sideW; 

          sdyv = (newCoord[2 * sides[this.i * 4 + 3] + 1] - sy) / sideH; 

          p = an[this.i * 4 + 2]; 

          for (n = 0; n < sideH; n++) { 

            q = an[this.i * 4]; 

            for (o = 0; o < sideW; o++) { 

              rectX[0] = (int) (sx + ((double) o + 0.1) * sdxh + ((double) n + 0.1) 

                  * sdxv); 

              rectX[1] = (int) (sx + ((double) o + 0.9) * sdxh + ((double) n + 0.1) 

                  * sdxv); 

              rectX[2] = (int) (sx + ((double) o + 0.9) * sdxh + ((double) n + 0.9) 

                  * sdxv); 

              rectX[3] = (int) (sx + ((double) o + 0.1) * sdxh + ((double) n + 0.9) 

                  * sdxv); 

              rectY[0] = (int) (sy + ((double) o + 0.1) * sdyh + ((double) n + 0.1) 

                  * sdyv); 

              rectY[1] = (int) (sy + ((double) o + 0.9) * sdyh + ((double) n + 0.1) 

                  * sdyv); 

              rectY[2] = (int) (sy + ((double) o + 0.9) * sdyh + ((double) n + 0.9) 

                  * sdyv); 

              rectY[3] = (int) (sy + ((double) o + 0.1) * sdyh + ((double) n + 0.9) 

                  * sdyv); 

              offGraphics.setColor(colList[20 

                  * sideCols[this.i * 9 + p * 3 + q] + k]); 

              offGraphics.fillPolygon(rectX, rectY, 4); 

              q++; 

            } 

            p++; 

          } 

        } 

        switch (i) { 

          case 0: 

            t1 = sx; 

            t2 = sy; 

            t3 = sdxh; 

            t4 = sdyh; 

            t5 = sdxv; 

            t6 = sdyv; 

            for (j = 0; j < 4; j++) { 

              dragCorn[8 * dragReg] = t1; 

              dragCorn[8 * dragReg + 4] = t2; 

              dragCorn[8 * dragReg + 3] = t1 + t5; 

              dragCorn[8 * dragReg + 7] = t2 + t6; 

              t1 = t1 + t3 * 3; 

              t2 = t2 + t4 * 3; 

              dragCorn[8 * dragReg + 1] = t1; 

              dragCorn[8 * dragReg + 5] = t2; 

              dragCorn[8 * dragReg + 2] = t1 + t5; 

              dragCorn[8 * dragReg + 6] = t2 + t6; 

              dragDir[dragReg * 2] = t3 * twistDir[this.i * 4 + j]; 

              dragDir[dragReg * 2 + 1] = t4 * twistDir[this.i * 4 + j]; 

              d = t3; 

              t3 = t5; 

              t5 = -d; 

              d = t4; 

              t4 = t6; 

              t6 = -d; 

              nearSide[dragReg] = nextSide[this.i * 4 + j]; 

              dragReg++; 

            } 

          break; 



          case 2: 

            if (this.i != twistSide && sideW > 0) { 

              if (sideW == 3) { 

                if (an[this.i * 4 + 2] == 0) { 

                  dragDir[dragReg * 2] = sdxh * twistDir[this.i * 4]; 

                  dragDir[dragReg * 2 + 1] = sdyh * twistDir[this.i * 4]; 

                } else { 

                  dragDir[dragReg * 2] = -sdxh * twistDir[this.i * 4 + 2]; 

                  dragDir[dragReg * 2 + 1] = -sdyh * twistDir[this.i * 4 + 2]; 

                } 

              } else if (an[this.i * 4] == 0) { 

                dragDir[dragReg * 2] = -sdxv * twistDir[this.i * 4 + 3]; 

                dragDir[dragReg * 2 + 1] = -sdyv * twistDir[this.i * 4 + 3]; 

              } else { 

                dragDir[dragReg * 2] = sdxv * twistDir[this.i * 4 + 1]; 

                dragDir[dragReg * 2 + 1] = sdyv * twistDir[this.i * 4 + 1]; 

              } 

              for (j = 0; j < 4; j++) { 

                dragCorn[dragReg * 8 + j] = newCoord[2 * sides[this.i * 4 + j]]; 

                dragCorn[dragReg * 8 + 4 + j] = newCoord[2 * sides[this.i * 4 

                    + j] + 1]; 

              } 

              nearSide[dragReg] = twistSide; 

              dragReg++; 

            } 

          break; 

        } 

      } 

    } 

  } 



  public rubik() { 

    twistSide = -1; 

    //eye = { 0.3651, 0.1826, -0.9129 }; 

    //eX = { 0.9309, -0.0716, 0.3581 }; 

    //temp = { 0.0, 0.0, 0.0 }; 

    //temp2 = { 0.0, 0.0, 0.0 }; 

    naturalState = true; 

    twisting = false; 

    OKtoDrag = false; 

  } 

}