home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 417.lha / Rubik / source / rotate.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-09-02  |  4.6 KB  |  206 lines
  1. /*    rotate.c    for rubik.c    M.J.R.    Boxing Day 1989    */
  2.  
  3. extern struct points point;
  4. extern struct one_square square[56];
  5. extern int twistlist[21];
  6. int biglist [126] =
  7.     {
  8.      0, 1, 2, 3, 4, 5, 6, 7, 8,18,19,20,27,28,29,36,39,42,45,48,51,
  9.      9,10,11,12,13,14,15,16,17,24,25,26,33,34,35,38,41,44,47,50,53,
  10.      0, 1, 2, 9,10,11,18,19,20,21,22,23,24,25,26,36,37,38,45,46,47,
  11.      6, 7, 8,15,16,17,27,28,29,30,31,32,33,34,35,42,43,44,51,52,53,
  12.      0, 3, 6, 9,12,15,18,21,24,27,30,33,36,37,38,39,40,41,42,43,44,
  13.      2, 5, 8,11,14,17,20,23,26,29,32,35,45,46,47,48,49,50,51,52,53
  14.     };
  15.  
  16. extern short mysin(int);
  17. extern short mycos(int);
  18. extern short hypot(short, short);
  19. extern short angle(short, short, short);
  20. extern unsigned short size;
  21. extern void rotate (short *a, short *b, short ang);
  22.  
  23. void fb (short layer, short ang)    /* twist front or back layer    */
  24.     {
  25.     /*    layer = 0 for front, 1 for back    */
  26.  
  27.     int i,j,k,*p,*q;
  28.  
  29.     /*    define extra 2 squares    */
  30.     if (layer)
  31.         {
  32.         i = 55;
  33.         j = 54;
  34.         }
  35.     else
  36.         {
  37.         i = 54;
  38.         j = 55;
  39.         }
  40.  
  41.     (square[i]).corner[0] = &(point.xyz  [0] [0] [k = layer + layer + 1]);
  42.     (square[i]).corner[1] = &(point.xyz  [5] [0] [k]);
  43.     (square[i]).corner[2] = &(point.xyz  [5] [5] [k]);
  44.     (square[i]).corner[3] = &(point.xyz  [0] [5] [k]);
  45.     (square[j]).corner[0] = &(point.xyz  [0] [0] [++k]);
  46.     (square[j]).corner[1] = &(point.xyz  [0] [5] [k]);
  47.     (square[j]).corner[2] = &(point.xyz  [5] [5] [k]);
  48.     (square[j]).corner[3] = &(point.xyz  [5] [0] [k]);
  49.  
  50.     for (k=4*layer; k < (4*layer+2); k++)
  51.         for (i=0; i<6; i++)
  52.             for (j=0; j<6; j++)
  53.                 if (i==0 || i==5 || j==0 || j==5 || k==0 || k==5)
  54.                     rotate
  55.                         (
  56.                         &((point.xyz [i] [j] [k]).x),
  57.                         &((point.xyz [i] [j] [k]).y),
  58.                         ang
  59.                         );
  60.  
  61.     p = &(twistlist[0]);
  62.     q = &(biglist[layer * 21]);
  63.     
  64.     for (i=0; i<21; i++)
  65.         *p++ = *q++;
  66.     }
  67.  
  68. void bt (short layer, short ang)    /* twist bottom or top layer    */
  69.     {
  70.     /*    layer = 0 for bottom, 1 for top    */
  71.  
  72.     int i,j,k,*p,*q;
  73.  
  74.     /*    define extra 2 squares    */
  75.     if (layer)
  76.         {
  77.         i = 55;
  78.         j = 54;
  79.         }
  80.     else
  81.         {
  82.         i = 54;
  83.         j = 55;
  84.         }
  85.  
  86.     (square[i]).corner[0] = &(point.xyz  [0] [k = layer + layer + 1] [0]);
  87.     (square[i]).corner[1] = &(point.xyz  [0] [k] [5]);
  88.     (square[i]).corner[2] = &(point.xyz  [5] [k] [5]);
  89.     (square[i]).corner[3] = &(point.xyz  [5] [k] [0]);
  90.     (square[j]).corner[0] = &(point.xyz  [0] [++k] [0]);
  91.     (square[j]).corner[1] = &(point.xyz  [5] [k] [0]);
  92.     (square[j]).corner[2] = &(point.xyz  [5] [k] [5]);
  93.     (square[j]).corner[3] = &(point.xyz  [0] [k] [5]);
  94.  
  95.     for (k=4*layer; k < (4*layer+2); k++)
  96.         for (i=0; i<6; i++)
  97.             for (j=0; j<6; j++)
  98.                 if (i==0 || i==5 || j==0 || j==5 || k==0 || k==5)
  99.                     rotate
  100.                         (
  101.                         &((point.xyz [i] [k] [j]).x),
  102.                         &((point.xyz [i] [k] [j]).z),
  103.                         ang
  104.                         );
  105.  
  106.     p = &(twistlist[0]);
  107.     q = &(biglist[42 + layer * 21]);
  108.     
  109.     for (i=0; i<21; i++)
  110.         *p++ = *q++;
  111.     }
  112.  
  113. void lr (short layer, short ang)    /* twist left or right layer    */
  114.     {
  115.     /*    layer = 0 for left, 1 for right    */
  116.  
  117.     int i,j,k,*p,*q;
  118.  
  119.     /*    define extra 2 squares    */
  120.     if (layer)
  121.         {
  122.         i = 55;
  123.         j = 54;
  124.         }
  125.     else
  126.         {
  127.         i = 54;
  128.         j = 55;
  129.         }
  130.  
  131.     (square[i]).corner[0] = &(point.xyz [k = layer + layer + 1] [0] [0]);
  132.     (square[i]).corner[1] = &(point.xyz [k] [5] [0]);
  133.     (square[i]).corner[2] = &(point.xyz [k] [5] [5]);
  134.     (square[i]).corner[3] = &(point.xyz [k] [0] [5]);
  135.     (square[j]).corner[0] = &(point.xyz [++k] [0] [0]);
  136.     (square[j]).corner[1] = &(point.xyz [k] [0] [5]);
  137.     (square[j]).corner[2] = &(point.xyz [k] [5] [5]);
  138.     (square[j]).corner[3] = &(point.xyz [k] [5] [0]);
  139.  
  140.     for (k=4*layer; k < (4*layer+2); k++)
  141.         for (i=0; i<6; i++)
  142.             for (j=0; j<6; j++)
  143.                 if (i==0 || i==5 || j==0 || j==5 || k==0 || k==5)
  144.                     rotate
  145.                         (
  146.                         &((point.xyz [k] [j] [i]).z),
  147.                         &((point.xyz [k] [j] [i]).y),
  148.                         ang
  149.                         );
  150.  
  151.  
  152.     p = &(twistlist[0]);
  153.     q = &(biglist[84 + layer * 21]);
  154.     
  155.     for (i=0; i<21; i++)
  156.         *p++ = *q++;
  157.     }
  158.  
  159. void roll (short ang)    /*    roll whole cube through (ang)    */
  160.     {
  161.     int i,j,k;
  162.     
  163.     for (i=0; i<6; i++)
  164.         for (j=0; j<6; j++)
  165.             for (k=0; k<6; k++)
  166.                 if (i==0 || i==5 || j==0 || j==5 || k==0 || k==5)
  167.                     rotate
  168.                         (
  169.                         &((point.xyz [i] [j] [k]).x),
  170.                         &((point.xyz [i] [j] [k]).y),
  171.                         ang
  172.                         );
  173.     }
  174.  
  175. void yaw (short ang)    /*    yaw whole cube through (ang)    */
  176.     {
  177.     int i,j,k;
  178.     
  179.     for (i=0; i<6; i++)
  180.         for (j=0; j<6; j++)
  181.             for (k=0; k<6; k++)
  182.                 if (i==0 || i==5 || j==0 || j==5 || k==0 || k==5)
  183.                     rotate
  184.                         (
  185.                         &((point.xyz [i] [j] [k]).x),
  186.                         &((point.xyz [i] [j] [k]).z),
  187.                         ang
  188.                         );
  189.     }
  190.  
  191. void pitch (short ang)    /*    pitch whole cube through (ang)    */
  192.     {
  193.     int i,j,k;
  194.     
  195.     for (i=0; i<6; i++)
  196.         for (j=0; j<6; j++)
  197.             for (k=0; k<6; k++)
  198.                 if (i==0 || i==5 || j==0 || j==5 || k==0 || k==5)
  199.                     rotate
  200.                         (
  201.                         &((point.xyz [i] [j] [k]).y),
  202.                         &((point.xyz [i] [j] [k]).z),
  203.                         ang
  204.                         );
  205.     }
  206.