/***************************************************************************
 * DRAWTILING.C                                                            *
 * version 2.0                                                             *
 * Written by Matthew Blum  4-23-97                                        *
 * Updated by Matthew Blum  2-19-98                                        *
 *                                                                         *
 * drawtiling creates vax files of any many different types of matchings,  *
 *   and of any size.                                                      *
 *                                                                         *
 * A sample use would be (to make an order 10 fortress):                   *
 * athena% drawtiling -fortress 10 | vaxrandom                             *
 *                                                                         *
 **************************************************************************/

#include<stdio.h>

/* all the matching types */
#define AZTEC    0
#define SQUARE   1
#define HEXAGON  2
#define FORTRESS 3
#define AZDUN    4
#define DUNGEON  5
#define DRAGON   6
#define THIRD    7
#define BATH     8
#define KITE     9
#define PILLOW   10
#define UNKNOWN  99

#define TRUE     1
#define FALSE    0

/* procedures to draw tilings... each tiling procedure takes in a size and
   a flag telling it whether or not to draw a vax file or a sample file */
void drawaztec    (int size);
void drawsquare   (int size);
void drawfortress (int size);
void drawhexagon  (int size);
void drawazdun    (int size);
void drawdungeon  (int size);
void drawdragon   (int size);
void drawthird    (int size);
void drawbath     (int size);
void draw192      (int size);
void drawkite     (int size);
void drawpillow   (int size);

/* prints out a listing of all the command line arguments */
void printerror(void);

void main(int argc, char **argv) {
  int order = 0, type = UNKNOWN, count;
  
  /* process command line arguments */
  if (argc < 2) 
    printerror();
  
  for (count = 1; count < argc; count ++) {

    if (!strcmp(argv[count],"-aztec"))
      type = AZTEC;
    else if (!strcmp(argv[count],"-square"))
      type = SQUARE;
    else if (!strcmp(argv[count],"-fortress"))
      type = FORTRESS;
    else if (!strcmp(argv[count],"-hexagon"))
      type = HEXAGON;
    else if (!strcmp(argv[count],"-azdun"))
      type = AZDUN;
    else if (!strcmp(argv[count],"-dungeon"))
      type = DUNGEON;
    else if (!strcmp(argv[count],"-dragon"))
      type = DRAGON;
    else if (!strcmp(argv[count],"-third"))
      type = THIRD;
    else if (!strcmp(argv[count],"-bath"))
      type = BATH;
    else if (!strcmp(argv[count],"-192"))
      type = 192;
    else if (!strcmp(argv[count],"-kite"))
      type = KITE;
    else if (!strcmp(argv[count],"-pillow"))
      type = PILLOW;

    else if (!strcmp(argv[count],"-help"))
      printerror();
    else {
      if (order > 0) {
	printf("Unknown command line argument %s.\n",argv[count]);
	exit(1);
      }
      sscanf(argv[count],"%d",&order);
      if (order < 0 || order > 10000) {
	printf("Unknown command line argument %s.\n",argv[count]);
	exit(1);
      }
    }
  }
  if (type == UNKNOWN) {
    printf("No legal tiling type specified.\n");
    printerror();
  }
  if (order == 0) {
    printf("No legal size specified.\n");
    printerror();
  }

  /* print basic header information */
  printf("#Creator: drawtiling.c\n");
  printf("#Vax file\n");
      
  /* print the tiling */
  if (type == AZTEC)
    drawaztec(order);
  if (type == SQUARE)
    drawsquare(order);
  if (type == HEXAGON)
    drawhexagon(order);
  if (type == FORTRESS)
    drawfortress(order);
  if (type == AZDUN)
    drawazdun(order);
  if (type == DUNGEON)
    drawdungeon(order);
  if (type == DRAGON)
    drawdragon(order);
  if (type == THIRD)
    drawthird(order);
  if (type == BATH)
    drawbath(order);
  if (type == 192)
    draw192(order);
  if (type == KITE)
    drawkite(order);
  if (type == PILLOW)
    drawpillow(order);
  
  /* clean exit */
  exit(0);
}

/***************************************************************************
  AZTEC DIAMONDS
  **************************************************************************/
void drawaztec(int order) {
  int row, col;
  
  printf("#Title: Aztec diamond of order %d\n", order);

  printf("%d %d\n",order * 2, order * 2);

  for (row = 0; row < 2 * order; row ++) {
    for (col = 0; col < 2 * order; col ++) 
      if (row + col > order - 2 &&
	  col - row < order + 1 &&
	  row + col < 3 * order &&
	  row - col < order + 1)
	printf("X");
      else
	printf(" ");
    printf("\n");
  }
}

/***************************************************************************
  SQUARES
  **************************************************************************/
void drawsquare(int order) {
  int row, col;
  printf("#Title: %d by %d square\n", 2*order, 2*order);
  printf("%d %d\n", order * 2, order * 2);
  
  for (row = 0; row < order * 2; row ++) {
    for (col = 0; col < order; col ++)
      printf("XX");
    printf("\n");
  }
}

/***************************************************************************
  HEXAGONS
  **************************************************************************/
void drawhexagon(int order) {
  int row, col;
  printf("#Title: Hexagon of order %d\n", order);
  printf("%d %d\n", order * 2, order * 4 - 1);
  
  /* top half */
  for (row = 0; row < order; row ++) {
    for (col = 0; col < order - row - 1; col ++)
      printf(" ");
    for (col = 0; col < order; col ++)
      printf("AV");
    for (col = 0; col < row; col ++)
      printf("AV");
    printf("A\n");
  }
  /* bottom half */
  for (row = order - 1; row >= 0; row --) {
    for (col = 0; col < order - row - 1; col ++)
      printf(" ");
    for (col = 0; col < order; col ++)
      printf("VA");
    for (col = 0; col < row; col ++)
      printf("VA");
    printf("V\n");
  }
}
 

/***************************************************************************
  FORTRESSES
  **************************************************************************/
void drawfortress(int order) {
  int row, col, even = (1- order % 2);
  printf("#Title: Fortress of order %d\n", order);
  order -= 2;
  printf("%d %d\n",2 * order + 2, 4 * order + 4 + 2 * even);
  for (row = 0; row < 2 * order + 2; row ++) {
    for (col = 0; col < 4 * order + 4 + 2 * even; col ++) 
      if (row / 2 * 2 + row + col > order * 2 - 2 + even &&
	  row / 2 * 2 + row + col < 6 * order + 6 + even &&
	  row / 2 * 2 + row - col < 2 * order + 3 - even &&
	  col - row / 2 * 2 - row < 2 * order + 5 + even)
	if ((row + ((col + 3 - even) / 2) + order) % 2)
	  printf("A");
	else
	  printf("V");
      else 
	printf(" ");
    printf("\n");
  }
}

/***************************************************************************
  AZTEC DUNGEONS
  **************************************************************************/
void drawazdun(int order) {
  int size, row, col, relcol, relrow;
  char repeat[4][8] = {" XAXXAX ", "VXXVX  X","",""};

  size = 4 * order;
  printf("#Title: Aztec dungeon of order %d\n", order);

  printf("%d %d\n",size, 2 * size);
  for (row = 0; row < size; row ++) {
    for (col = 0; col < 2 * size; col ++) {
      if ((row * 2 + col > 4 * order - 4 + row % 2) && 
          (row * 2 + col < 12 * order + row % 2) &&
          (col - row * 2 < 3 + 4 * order - row % 2) && 
          (row * 2 - col < 1 + 4 * order + row % 2)) {
        relrow = row % 2;
        relcol = (col + row * 2 + 4 * ((order - 1) % 2)) % 8;
        printf("%c",repeat[relrow][relcol]);
      } else
        printf(" ");
    }
    printf("\n");
  }
}

/***************************************************************************
  DUNGEONS
  **************************************************************************/
void drawdungeon(int order) { 
  int size, parity, row, col, r, c;
  char repeat[4][12] = {"VX  XVXX", "AX  XAXX", "XVXXVX  ", "XAXXAX  "};

  size = 8 * order - 2;
  parity = order % 2;
  printf("#Title: Dungeon of order %d\n", order);
  printf("%d %d\n",size - 1, size);

  for (row = 0; row < size - 1; row ++) {
    for (col = 0; col < size; col ++) {
      r = (row + 2 * parity) % 4; c = col % 8;
      if ((row * 2 + col - row % 2 > size / 2 - 2) &&
          (col - row * 2 + row % 2 < size / 2 + 1) &&
          (row * 2 + col + row % 2 < 5 * size / 2 - 1) &&
          (col - row * 2 - row % 2 > - 3 * size / 2) &&
          (((row + 2*parity) % 4 != 0) || (col !=0 && col != size - 1)))
	printf("%c",repeat[r][c]);
      else
        printf(" ");
    }
    printf("\n");
  }
}


/***************************************************************************
  DRAGONS
  **************************************************************************/

void drawdragon(int order) {
  int size, row, col;
  char repeat[4][4] = {"XXXX","XAXV","XXXX","XVXA"};
  
  size = order * 2;
  printf("#Title: Dragon of order %d\n", order);
  printf("#Creator: drawtiling.c\n");
  
  printf("%d %d\n",size - 1, size);
  
  for (row = 0; row < size - 1; row ++) {
    for (col = 0; col < size; col ++) {
      if ((row + col > order - 2) &&
	  (row + col < 3 * order) &&
	  (col - row <= order) &&
	  (row - col <= order) &&
	  (row <= order || row - col < order - 1))
	printf("%c",repeat[row % 4][(col + 3 * order) % 4]);
      else
	printf(" ");
    }
    printf("\n");
  }
}

/***************************************************************************
  THIRD DIAGONAL REGIONS
  **************************************************************************/
void drawthird(int order) {
  int row, col;
  char repeat[4] = "VAXX";
  char a,b,c,d;

  a = repeat[0];
  b = repeat[1];
  c = repeat[2];
  d = repeat[3];

  /* print header information */
  printf("#Title: Third diagonal hexagon of order %d\n", order);

  printf("%d %d\n",order * 4, order * 6 - 1);

  for (row = 0; row < order; row ++) {
    for (col = 0; col < order - row - 1; col ++)
      printf(" ");
    for (col = 0; col < row; col ++)
      printf("%c%c%c%c",b,c,d,a);
    printf("%c%c\n",b,c);
  }

  for (row = 0; row < order; row ++) {
    for (col = 0; col < 2 * row; col ++)
      printf(" ");
    for (col = 0; col < order; col ++)
      printf("%c%c%c%c",c,d,a,b);
    printf("\n");
    for (col = 0; col < 2 * row + 1; col ++)
      printf(" ");
    for (col = 0; col < order; col ++)
      printf("%c%c%c%c",a,b,c,d);
    printf("\n");
  }
  for (row = order - 1; row >= 0; row --) {
    for (col = 0; col < 5 * order - 3 * row - 2; col ++)
      printf(" ");
    for (col = 0; col < row; col ++)
      printf("%c%c%c%c",d,a,b,c);
    printf("%c%c\n",d,a);
  }
}

/***************************************************************************
  BATH REGIONS
  **************************************************************************/
void drawbath(int order) {
  int shift = 0, size, row, col;
  char repeat[12] = "<VXA><VXA>";
  
  size = 4 * order - 2;

  printf("#Title: Bath region of order %d\n", order);

  printf("%d %d\n",size, size);
  for (row = 0; row < size; row ++) {
    for (col = 0; col < size; col ++) {
      if ((row * 3 - col > -1 -order) &&
          (col * 3 + row > 3 * order - 4 ) &&
          (row * 3 - col < 9 * order - 5) &&
          (col * 3 + row < 13 * order - 8))
        printf("%c",repeat[(7 * row + col + 114 - order + shift) % 10]);
      else
        printf(" ");
    }
    printf("\n");
  }
}
  
/***************************************************************************
  192-REGIONS
  **************************************************************************/
void draw192(int order) {
  int row, col, size, parity;

  order = order * 3 - 2;
  size = 2 * order;

  printf("#Title: 192-region of order %d\n", order);
  printf("%d %d\n",size, size);

  for (row = 0; row < order * 2; row ++) {
    parity = 0;
    for (col = 0; col < order * 2; col ++) {
      if ((row + col > order - 2) &&
          (col - row < order + 1) &&
          (row - col < order + 1) &&
          (row + col < 3 * order) &&
          (row % 3 !=0 || col % 3 !=2))
	printf("X");
      else
        printf(" ");
    }
    printf("\n");
  }
}

/***************************************************************************
  KITES
  **************************************************************************/
void drawkite(int order) {
  int vert, horiz;

  printf("#Title: kite of order %d\n", order);
  printf("%d %d\n",2 * order, 4 * order);

  for (vert = 1; vert <= order; vert ++) {
    for (horiz = 0; horiz < order - vert; horiz ++) 
      printf("   ");
    for (horiz = 0; horiz < vert; horiz ++) 
      printf("XXXX");
    printf("\n");
  }  
  for (vert = order; vert > 0; vert --) {
    for (horiz = 0; horiz < order - vert; horiz ++) 
      printf("   ");
    for (horiz = 0; horiz < vert; horiz ++) 
      printf("XXXX");
    printf("\n");
  }  
}

/***************************************************************************
  PILLOWS
  **************************************************************************/
void drawpillow(int order) {
  int vert, horiz;
  printf("#Title: pillow of order %d\n", order);
  printf("%d %d\n",2 * order, 4 * order);

  for (vert = 1; vert <= order; vert ++) {
    for (horiz = 0; horiz < order - vert; horiz ++) 
      printf("   ");
    for (horiz = 0; horiz < vert; horiz ++) 
      printf("XXXX");
    printf("\n");
  }  
  for (vert = order; vert > 0; vert --) {
    for (horiz = 0; horiz < order - vert; horiz ++) 
      printf(" ");
    for (horiz = 0; horiz < vert; horiz ++) 
      printf("XXXX");
    printf("\n");
  }  
}  
  
/***************************************************************************
  PRINT ERROR MESSAGE
  **************************************************************************/
void printerror(void) {
  printf("Usage for drawtiling: drawtiling order type\n");
  printf("Type is:\n");
  printf("   -aztec        draw an aztec diamond\n");
  printf("   -square       draw an 2n by 2n square\n");
  printf("   -fortress     draw a fortress (blunt version)\n");
  printf("   -azdun        draw a aztec dungeon\n");
  printf("   -dungeon      draw a hexagonal dungeon\n");
  printf("   -dragon       draw a dragon (triangles, squares, hexagons)\n");
  printf("   -third        draw a third-diagonal region\n");
  printf("   -bath         draw a bath region\n");
  printf("   -192          draw a 192-region (perfect powers of 192)\n");
  printf("   -kite         draw a kite (1,3 version)\n");
  printf("   -pillow       draw a pillow (1,3 version)\n");
  exit(1);
}