fish/362_rubik/rotate.c

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