API tools faq
paste
Vulpes

cell auto

Vulpes
Mar 20th, 2011
271
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 15.00 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <time.h>
  5. #define MAX_METH 6
  6. #define STR_NTR 10
  7.  
  8. int ascii_char_num(char q[], int l) {
  9.     //printf("ascii_char_num(char q[],int l==%d)\n",l);
  10.     int n[l];
  11.     int i;
  12.     int b;
  13.     int r=0;
  14.     for (i=0;i<l;i++) {
  15.         if (q[i]=='\0') {
  16.             //printf("NULL at %d\n",i);
  17.             b=i;
  18.             break;
  19.         }
  20.     }
  21.     for (i=0;i<l;i++) {
  22.         n[i]=(int)q[i];
  23.         //printf("n[%d](%d)=q[i](%c)\n",i,n[i],q[i]);
  24.     }
  25.     for (i=0;i<b;i++) {
  26.         if (n[i]>=48 && n[i]<58) {
  27.             //printf("Entered Digit.\n");
  28.             r=r*10+(n[i]-48);
  29.         }
  30.         else {
  31.             //printf("Entered %c\n",q[i]);
  32.             //getchar();
  33.             return -1;
  34.         }
  35.     }
  36.     //getchar();
  37.     return r;
  38. }
  39. float floor_1(float a) {
  40.     //printf("floor_1(float %.2f)\n",a);
  41.     int b=a;
  42.     return (float) b;
  43. }
  44. void disp_line(int xsize, int ctr, int t){
  45.     int i;
  46.     //int l1=(int)floor_1((float)xsize/2);
  47.     //int l2=xsize%2;
  48.     for (i=0;i<(xsize-2+t);i++) {
  49.         printf("-");
  50.     }
  51.     printf("%.4X",ctr);
  52.     for (i=0;i<(xsize-2+t);i++) {
  53.         printf("-");
  54.     }
  55.     printf("\n");
  56. }
  57. void disp_grid(int *g, int type, int y, int x, char c1, char c2, int ctr) {
  58.     //printf("disp_grid(int g[])\n");
  59.     srand(time(NULL));
  60.     int i1,i2;
  61.     char c3;
  62.     disp_line(x,ctr,type);
  63.     switch (type) {
  64.         case 0: {
  65.             for (i1=0;i1<y;i1++) {
  66.                 for (i2=0;i2<x;i2++) {
  67.                     printf("%d ",g[i1*x+i2]);
  68.                 }
  69.                 printf("\n");
  70.             }
  71.             break;
  72.         }
  73.         case 1: {
  74.             for (i1=0;i1<y;i1++) {
  75.                 printf("|");
  76.                 for (i2=0;i2<x;i2++) {
  77.                     if (g[i1*x+i2]==0) {
  78.                         printf("%c ",c1);
  79.                     }
  80.                     else if (g[i1*x+i2]==1) {
  81.                         printf("%c ",c2);
  82.                     }
  83.                     else {
  84.                         printf("error disp_grid 2[i1 i2][%d %d]=%d\n",i1,i2,g[i1*x+i2]);
  85.                     }          
  86.                 }
  87.                 printf("|\n");
  88.             }
  89.             break;
  90.         }
  91.         case 2: {
  92.             for (i1=0;i1<y;i1++) {
  93.                 for (i2=0;i2<x;i2++) {
  94.                     if (g[i1*x+i2]==1) {
  95.                         printf("%.3d ",i1*x+i2);
  96.                     }
  97.                     else {
  98.                         printf("   ");
  99.                     }
  100.                 }
  101.                 printf("\n");
  102.             }
  103.             break;
  104.         }
  105.         case 3: {
  106.             c3=(char)(rand()%93+33);
  107.             for (i1=0;i1<y;i1++) {
  108.                 for (i2=0;i2<x;i2++) {
  109.                     if (g[i1*x+i2]==0) {
  110.                         printf("  ");
  111.                     }
  112.                     else if (g[i1*x+i2]==1) {
  113.                         printf("%c ",c3);
  114.                     }
  115.                     else {
  116.                         printf("error disp_grid 2[i1 i2][%d %d]=%d\n",i1,i2,g[i1*x+i2]);
  117.                     }          
  118.                 }
  119.                 printf("\n");
  120.             }
  121.             break;
  122.         }
  123.         case 4: {
  124.             for (i1=0;i1<y;i1++) {
  125.                 for (i2=0;i2<x;i2++) {
  126.                     if (g[i1*x+i2]==0) {
  127.                         printf("  ");
  128.                     }
  129.                     else if (g[i1*x+i2]==1) {
  130.                         c3=(char)(rand()%93+33);
  131.                         printf("%c ",c3);
  132.                     }
  133.                     else {
  134.                         printf("error disp_grid 2[i1 i2][%d %d]=%d\n",i1,i2,g[i1*x+i2]);
  135.                     }          
  136.                 }
  137.                 printf("\n");
  138.             }
  139.             break;
  140.         }
  141.         default: {
  142.             printf("error switch: %d disp_grid\n",type);
  143.             break;
  144.         }
  145.     }
  146.     //printf("\n");
  147. }
  148. void n_locate(int *m, int y, int x, int type, int magn, int ysize, int xsize){
  149.     /*
  150.      0 E
  151.      1 N
  152.      2 S
  153.      3 W
  154.      
  155.      4 NE
  156.      5 NW
  157.      6 SW
  158.      7 SE
  159.      
  160.      8  ENE
  161.      9  NNE
  162.      10 NNW
  163.      11 WNW
  164.      12 WSW
  165.      13 SSW
  166.      14 SSE
  167.      15 ESE
  168.      
  169.      */
  170.     int yalt=ysize-magn;
  171.     int xalt=xsize-magn;
  172.     if (magn<0 || type>3) {
  173.         printf("error n_locate type:%d magnitude:%d\n",type,magn);
  174.         return;
  175.     }
  176.     while (yalt<0) {
  177.         yalt=yalt+ysize;
  178.     }
  179.     while (xalt<0) {
  180.         xalt=xalt+xsize;
  181.     }
  182.     /*
  183.      2 5 3 5 1 5 3 5 2
  184.      5 2 4 4 1 4 4 2 5
  185.      3 4 2 3 1 3 2 4 3
  186.      5 4 3 2 1 2 3 4 5
  187.      1 1 1 1 0 1 1 1 1
  188.      5 4 3 2 1 2 3 4 5
  189.      3 4 2 3 1 3 2 4 3
  190.      5 2 4 4 1 4 4 2 5   
  191.      2 5 3 5 1 5 3 5 2
  192.      
  193.      2_4 5_1 3_2 5_1 1_4 5_1 3_2 5_1 2_4
  194.      5_1 2_3 4_1 4_1 1_3 4_1 4_1 2_3 5_1
  195.      3_2 4_1 2_2 3_1 1_2 3_1 2_2 4_1 3_2
  196.      5_1 4_1 3_1 2_1 1_1 2_1 3_1 4_1 5_1
  197.      1_4 1_3 1_2 1_1 0_0 1_1 1_2 1_3 1_4
  198.      5_1 4_1 3_1 2_1 1_1 2_1 3_1 4_1 5_1
  199.      3_2 4_1 2_2 3_1 1_2 3_1 2_2 4_1 3_2
  200.      5_1 2_3 4_1 4_1 1_3 4_1 4_1 2_3 5_1     
  201.      2_4 5_1 3_2 5_1 1_4 5_1 3_2 5_1 2_4
  202.      
  203.      4 1 2 1 4 1 2 1 4
  204.      1 3 1 1 3 1 1 3 1
  205.      2 1 2 1 2 1 2 1 2
  206.      1 1 1 1 1 1 1 1 1
  207.      4 3 2 1 0 1 2 3 4
  208.      1 1 1 1 1 1 1 1 1
  209.      2 1 2 1 2 1 2 1 2
  210.      1 3 1 1 3 1 1 3 1   
  211.      4 1 2 1 4 1 2 1 4
  212.      
  213.      */
  214.    
  215.     switch (type) {
  216.         case 0: {
  217.             m[0]=y*xsize+x;
  218.             printf("NULL\n");
  219.             break;
  220.         }
  221.         case 1: {
  222.             m[0]=y*xsize+(x+magn)%xsize;
  223.             m[1]=((y+magn)%ysize)*xsize+x;
  224.             m[2]=y*xsize+(x+xalt)%xsize;
  225.             m[3]=((y+yalt)%ysize)*xsize+x;
  226.             break;
  227.         }
  228.         case 2: {
  229.             m[0]=((y+1*magn)%ysize)*xsize+(x+1*magn)%xsize;
  230.             m[1]=((y+1*magn)%ysize)*xsize+(x+1*xalt)%xsize;
  231.             m[2]=((y+1*yalt)%ysize)*xsize+(x+1*xalt)%xsize;
  232.             m[3]=((y+1*yalt)%ysize)*xsize+(x+1*magn)%xsize;
  233.             break;
  234.         }
  235.         case 3: {
  236.             m[0]=((y+1*magn)%ysize)*xsize+(x+2*magn)%xsize;//2 right, 1 up
  237.             m[1]=((y+2*magn)%ysize)*xsize+(x+1*magn)%xsize;//2 up,    1 right
  238.             m[2]=((y+2*magn)%ysize)*xsize+(x+1*xalt)%xsize;//2 up,    1 left
  239.             m[3]=((y+1*magn)%ysize)*xsize+(x+2*xalt)%xsize;//2 left,  1 up
  240.             m[4]=((y+1*yalt)%ysize)*xsize+(x+2*xalt)%xsize;//2 left,  1 down
  241.             m[5]=((y+2*yalt)%ysize)*xsize+(x+1*xalt)%xsize;//2 down,  1 left (to go)
  242.             m[6]=((y+2*yalt)%ysize)*xsize+(x+1*magn)%xsize;//2 down,  1 right
  243.             m[7]=((y+1*yalt)%ysize)*xsize+(x+2*magn)%xsize;//2 right, 1 down
  244.             break;
  245.         }
  246.         case 4: {
  247.             printf("THIS IS SUICIDE\n");
  248.             m[0]=((y+1*magn)%ysize)*xsize+(x+3*magn)%xsize;//3 right, 1 up
  249.             m[1]=((y+2*magn)%ysize)*xsize+(x+3*magn)%xsize;//3 right, 2 up
  250.             m[2]=((y+3*magn)%ysize)*xsize+(x+2*magn)%xsize;//3 up,    2 right
  251.             m[3]=((y+3*magn)%ysize)*xsize+(x+1*magn)%xsize;//3 up,    1 right
  252.             m[4]=((y+3*magn)%ysize)*xsize+(x+1*xalt)%xsize;//3 up,    1 left
  253.             m[5]=((y+3*magn)%ysize)*xsize+(x+3*xalt)%xsize;//3 up,    2 left
  254.             m[6]=((y+2*magn)%ysize)*xsize+(x+3*xalt)%xsize;//3 left,  2 up
  255.             m[7]=((y+1*magn)%ysize)*xsize+(x+3*xalt)%xsize;//3 left,  1 up
  256.             m[8]=((y+1*yalt)%ysize)*xsize+(x+3*xalt)%xsize;//3 left,  1 down
  257.             m[9]=((y+2*yalt)%ysize)*xsize+(x+3*xalt)%xsize;//3 left,  2 down
  258.             m[10]=((y+3*yalt)%ysize)*xsize+(x+2*xalt)%xsize;//3 down,  2 left (to go)
  259.             m[11]=((y+3*yalt)%ysize)*xsize+(x+1*xalt)%xsize;//3 down,  1 left (to go)
  260.             m[12]=((y+3*yalt)%ysize)*xsize+(x+1*magn)%xsize;//3 down,  1 right
  261.             m[13]=((y+3*yalt)%ysize)*xsize+(x+2*magn)%xsize;//3 down,  2 right
  262.             m[14]=((y+2*yalt)%ysize)*xsize+(x+3*magn)%xsize;//3 right, 2 down
  263.             m[15]=((y+1*yalt)%ysize)*xsize+(x+3*magn)%xsize;//3 right, 1 down
  264.             break;
  265.         }
  266.         case 5: {
  267.             printf("ULTRA UBER SUICIDE\n");
  268.             m[0]=((y+1*magn)%ysize)*xsize+(x+3*magn)%xsize;//5 right, 1 up
  269.             m[1]=((y+2*magn)%ysize)*xsize+(x+3*magn)%xsize;//5 right, 4 up
  270.             m[2]=((y+3*magn)%ysize)*xsize+(x+2*magn)%xsize;//5 up,    4 right
  271.             m[3]=((y+3*magn)%ysize)*xsize+(x+1*magn)%xsize;//5 up,    1 right
  272.             m[4]=((y+3*magn)%ysize)*xsize+(x+1*xalt)%xsize;//5 up,    1 left
  273.             m[5]=((y+3*magn)%ysize)*xsize+(x+3*xalt)%xsize;//5 up,    4 left
  274.             m[6]=((y+2*magn)%ysize)*xsize+(x+3*xalt)%xsize;//5 left,  4 up
  275.             m[7]=((y+1*magn)%ysize)*xsize+(x+3*xalt)%xsize;//5 left,  1 up
  276.             m[8]=((y+1*yalt)%ysize)*xsize+(x+3*xalt)%xsize;//5 left,  1 down
  277.             m[9]=((y+2*yalt)%ysize)*xsize+(x+3*xalt)%xsize;//5 left,  4 down
  278.             m[10]=((y+3*yalt)%ysize)*xsize+(x+2*xalt)%xsize;//5 down,  4 left (to go)
  279.             m[11]=((y+3*yalt)%ysize)*xsize+(x+1*xalt)%xsize;//5 down,  1 left (to go)
  280.             m[12]=((y+3*yalt)%ysize)*xsize+(x+1*magn)%xsize;//5 down,  1 right
  281.             m[13]=((y+3*yalt)%ysize)*xsize+(x+2*magn)%xsize;//5 down,  4 right
  282.             m[14]=((y+2*yalt)%ysize)*xsize+(x+3*magn)%xsize;//5 right, 4 down
  283.             m[15]=((y+1*yalt)%ysize)*xsize+(x+3*magn)%xsize;//5 right, 1 down
  284.             break;
  285.         }
  286.         default: {
  287.             printf("type=%d?!?1 ARE YOU NUTS1?!!???!?!1111111111111\n",type);
  288.             break;
  289.         }
  290.     }
  291. }
  292. int meth0(int g[], int y, int x, int xs, int ys) {
  293.     int m[4], v[4];
  294.     int i;
  295.     int sum=0;
  296.     n_locate(m,y,x,1,1,ys,xs);
  297.     for (i=0;i<4;i++) {
  298.         v[i]=g[m[i]];
  299.     }
  300.     for (i=0;i<4;i++) {
  301.         sum=sum+v[i];
  302.     }
  303.     if (sum==0||sum==4) {
  304.         return 0;
  305.     }
  306.     else {
  307.         return 1;
  308.     }
  309. }
  310. int meth1(int g[], int y, int x, int ys, int xs) {
  311.     int m[4], v[4];
  312.     int i;
  313.     int sum=0;
  314.     n_locate(m,y,x,1,1,ys,xs);
  315.     for (i=0;i<4;i++) {
  316.         v[i]=g[m[i]];
  317.     }
  318.     for (i=0;i<4;i++) {
  319.         sum=sum+v[i];
  320.     }
  321.     if (sum>1 && sum<4) {
  322.         return 1;
  323.     }
  324.     else {
  325.         return 0;
  326.     }  
  327. }
  328. int meth2(int g[], int y, int x, int ys, int xs) {
  329.     int m[4], v[4];//east0 north1 west2 south3
  330.     int i;
  331.     int sum=0;
  332.     n_locate(m,y,x,1,1,ys,xs);
  333.     for (i=0;i<4;i++) {
  334.         v[i]=g[m[i]];
  335.     }
  336.     for (i=0;i<4;i++) {
  337.         sum=sum+v[i];
  338.     }
  339.     return sum%2;
  340. }
  341. int meth3(int g[], int y, int x, int ys, int xs, int ctr) {
  342.     int m1[4],m2[4];
  343.     int v[8];
  344.     int i;
  345.     int c;
  346.     c=ctr%4;
  347.     n_locate(m1,y,x,1,1,ys,xs);
  348.     n_locate(m2,y,x,2,1,ys,xs);
  349.     for (i=0;i<4;i++) {
  350.         v[i*2]=g[m1[i]];
  351.         v[i*2+1]=g[m2[i]];
  352.     }  
  353.     if ((v[c]+v[4+c]==1)) {
  354.         return 1;
  355.     }
  356.     else {
  357.         return 0;
  358.     }  
  359. }
  360. int meth4(int g[], int y, int x, int ys, int xs, int ctr) {
  361.     int m1[4],m2[4];
  362.     int v[8];
  363.     int i;
  364.     int c;
  365.     c=ctr%4+2*(int)floor_1((float)(ctr%4)/2);
  366.     if ((c!=0)&&(c!=1)&&(c!=4)&&(c!=5)) {
  367.         printf("error c meth4 c=%d\n",c);
  368.     }
  369.     /*
  370.      switch (ctr%4) {
  371.      case 0:{
  372.      c=0;
  373.      break;
  374.      }
  375.      case 1:{
  376.      c=1;
  377.      break;
  378.      }
  379.      case 2:{
  380.      c=4;
  381.      break;
  382.      }
  383.      case 3:{
  384.      c=5;
  385.      break;
  386.      }
  387.      default:{
  388.      printf("error meth4switch\n");
  389.      c=0;
  390.      break;
  391.      }
  392.      }
  393.      */
  394.     n_locate(m1,y,x,1,1,ys,xs);
  395.     n_locate(m2,y,x,2,1,ys,xs);
  396.     for (i=0;i<4;i++) {
  397.         v[i]=g[m1[i]];
  398.         v[i+4]=g[m2[i]];
  399.     }
  400.     if ((v[c]+v[2+c]==1)) {
  401.         return 1;
  402.     }
  403.     else {
  404.         return 0;
  405.     }  
  406. }
  407. int meth5(int g[], int y, int x, int ys, int xs, int ctr , int o) {
  408.     //meth5 has capabilities of meth3&4 as well as more compatibility
  409.     int m1[4],m2[4];
  410.     int v[8];
  411.     int i;
  412.     n_locate(m1,y,x,1,1,ys,xs);
  413.     n_locate(m2,y,x,2,1,ys,xs);
  414.     for (i=0;i<4;i++) {
  415.         v[i*2]=g[m1[i]];
  416.         v[i*2+1]=g[m2[i]];
  417.     }  
  418.     if ((v[ctr%8]+v[(o+ctr)%8]==1)) {
  419.         return 1;
  420.     }
  421.     else {
  422.         return 0;
  423.     }  
  424. }
  425. int meth6(int g[], int y, int x, int ys, int xs) {
  426.     int m1[4],m2[4];
  427.     int v[8];
  428.     int i;
  429.     int sum=0;
  430.     n_locate(m1,y,x,1,1,ys,xs);
  431.     n_locate(m2,y,x,2,1,ys,xs);
  432.     for (i=0;i<4;i++) {
  433.         v[i]=g[m1[i]];
  434.         v[i+4]=g[m2[i]];
  435.     }
  436.     for (i=0;i<4;i++) {
  437.         sum=sum+2*v[i]+v[i+4];
  438.     }
  439.     if (sum>=4 && sum<=5) {
  440.         return 1;
  441.     }
  442.     return 0;
  443. }
  444. void step(int *g,int meth, int ysize, int xsize, int counter) {
  445.     //printf("step(int *g)\n");
  446.     int i1,i2;
  447.     int g_f[xsize*ysize];
  448.     switch (meth) {
  449.         case 0: {
  450.             for (i1=0;i1<ysize;i1++) {
  451.                 for (i2=0;i2<xsize;i2++) {
  452.                     g_f[i1*xsize+i2]=meth0(g,i1,i2,ysize,xsize);
  453.                 }
  454.             }
  455.             break;
  456.         }
  457.         case 1: {
  458.             for (i1=0;i1<ysize;i1++) {
  459.                 for (i2=0;i2<xsize;i2++) {
  460.                     g_f[i1*xsize+i2]=meth1(g,i1,i2,ysize,xsize);
  461.                 }
  462.             }
  463.             break;
  464.         }
  465.         case 2: {
  466.             for (i1=0;i1<ysize;i1++) {
  467.                 for (i2=0;i2<xsize;i2++) {
  468.                     g_f[i1*xsize+i2]=meth2(g,i1,i2,ysize,xsize);
  469.                 }
  470.             }
  471.             break;
  472.         }
  473.         case 3: {
  474.             for (i1=0;i1<ysize;i1++) {
  475.                 for (i2=0;i2<xsize;i2++) {
  476.                     g_f[i1*xsize+i2]=meth3(g,i1,i2,ysize,xsize,counter);
  477.                 }
  478.             }
  479.             break;
  480.         }
  481.         case 4: {
  482.             for (i1=0;i1<ysize;i1++) {
  483.                 for (i2=0;i2<xsize;i2++) {
  484.                     g_f[i1*xsize+i2]=meth4(g,i1,i2,ysize,xsize,counter);
  485.                 }
  486.             }
  487.             break;
  488.         }
  489.         case 5: {
  490.             for (i1=0;i1<ysize;i1++) {
  491.                 for (i2=0;i2<xsize;i2++) {
  492.                     g_f[i1*xsize+i2]=meth5(g,i1,i2,ysize,xsize,counter,2);
  493.                 }
  494.             }
  495.             break;
  496.         }
  497.         case 6: {
  498.             for (i1=0;i1<ysize;i1++) {
  499.                 for (i2=0;i2<xsize;i2++) {
  500.                     g_f[i1*xsize+i2]=meth6(g,i1,i2,ysize,xsize);
  501.                 }
  502.             }
  503.             break;
  504.         }
  505.         default:
  506.             printf("bad entry number, kill now\n");
  507.             break;
  508.     }
  509.     for (i1=0;i1<ysize;i1++) {
  510.         for (i2=0;i2<xsize;i2++) {
  511.             g[i1*xsize+i2]=g_f[i1*xsize+i2];
  512.         }
  513.     }
  514. }
  515. void zero_grid(int *g,int ysize,int xsize) {
  516.     //printf("zero_grid(int *g)\n");
  517.     int i1,i2;
  518.     for (i1=0;i1<ysize;i1++) {
  519.         for (i2=0;i2<xsize;i2++) {
  520.             g[i1*xsize+i2]=0;
  521.         }
  522.     }  
  523. }
  524. int* load_file (int *ysize,int *xsize,int sw1){
  525.     int i1,i2;
  526.     int *g;
  527.     FILE *f;
  528.     f=fopen("/Developer/XCode_Debugs/Cell_Auto/grid.txt","r");
  529.     fscanf(f,"%d %d",xsize,ysize);
  530.     switch (sw1) {
  531.         case 0: {
  532.             fclose (f);
  533.             break;
  534.         }
  535.         case 1: {
  536.             g=(int*)malloc(sizeof(int)*(*ysize * *xsize));
  537.             for(i1=0;i1<*ysize;i1++){
  538.                 for(i2=0;i2<*xsize;i2++){
  539.                     fscanf (f,"%d",&g[i1* *xsize+i2]);
  540.                 }
  541.             }
  542.             fclose (f);
  543.             return g;
  544.             break;
  545.         }
  546.         default: {
  547.             printf("switch error load_file\n");
  548.             fclose (f);
  549.             break;
  550.         }
  551.     }
  552.     return 0;
  553. }
  554. void write_file(int g[], int y, int x){
  555.     int i1,i2;
  556.     FILE *f;
  557.     f=fopen("/Developer/XCode_Debugs/Cell_Auto/grid.txt","w");
  558.     fprintf(f,"%d %d \n",x,y);
  559.     for (i1=0;i1<y;i1++) {
  560.         for (i2=0;i2<x;i2++) {
  561.             fprintf(f,"%d ",g[i1*x+i2]);
  562.         }
  563.         fprintf(f,"\n");
  564.     }
  565.     fclose (f);
  566. }                          
  567. void init_str(char *s,int l){
  568.     //printf("init_str(char *s,int l)\n");
  569.     int i;
  570.     for (i=0;i<l;i++) {
  571.         s[i]=0;
  572.     }
  573. }
  574. int ques1(){
  575.     //printf("ques1()\n");
  576.     char ans[STR_NTR];
  577.     int b;
  578.     while (1) {
  579.         printf("Continue entering switches? (1) yes   (2) no: ");
  580.         scanf("%s",ans);
  581.         b=ascii_char_num(ans,STR_NTR);
  582.         if (b<1 || b>2) {
  583.             printf("what? ");
  584.         }
  585.         else {return 2-b;}
  586.     }
  587.    
  588. }
  589. int ques2(int max_mth) {
  590.     int mth;
  591.     char entry[STR_NTR];
  592.     do {
  593.         printf("Select Method 0 - %d: ",max_mth);
  594.         scanf("%s",entry);
  595.         mth=ascii_char_num(entry,STR_NTR);
  596.         if (mth>max_mth || mth<0) {
  597.             printf("what? ");
  598.         }
  599.     } while (mth>max_mth || mth<0);
  600.     return mth;
  601. }
  602. int* init_grid(int *ys,int *xs,int *f,int sw1) {
  603.     //printf("init_grid(int *g)\n");
  604.     char s0[STR_NTR], s1[STR_NTR];
  605.     int b1=0;
  606.     int d1;
  607.     int *g;
  608.     //int xs1,ys1;
  609.     init_str(s0,STR_NTR);
  610.     init_str(s1,STR_NTR);
  611.     switch (sw1) {
  612.         case 0: {
  613.             while (1) {
  614.                 printf("(1) Load file or (2) manual: ");
  615.                 scanf("%s",s0);
  616.                 *f=ascii_char_num(s0,STR_NTR);
  617.                 if (*f==1) {
  618.                     load_file(ys,xs,0);
  619.                     break;
  620.                 }
  621.                 else if (*f==2) {
  622.                     printf("Please enter dimensions: X Y ");
  623.                     scanf("%d %d",xs,ys);
  624.                     break;
  625.                 }
  626.                 else {
  627.                     printf("what? ");
  628.                 }
  629.             }
  630.             return 0;
  631.             break;
  632.         }
  633.         case 1:{
  634.             while (1) {
  635.                 if (*f==1) {
  636.                     g=load_file(ys,xs,1);
  637.                     break;
  638.                 }
  639.                 else if (*f==2) {
  640.                     printf("Now creating blank matrix\n");
  641.                     g=(int*)malloc(sizeof (int)*((*xs)*(*ys)));                
  642.                     break;
  643.                 }
  644.                 else {
  645.                     printf("error switch 2\n ");
  646.                     break;
  647.                 }
  648.             }
  649.             do {
  650.                 disp_grid(g,0,*ys,*xs,' ','X',0);
  651.                 printf("Pick your starting switches\n");
  652.                 scanf("%s",s1);
  653.                
  654.                 d1=ascii_char_num(s1,STR_NTR);
  655.                 if (d1<0 || d1>=*xs* *ys) {
  656.                     b1=1-ques1();
  657.                 }
  658.                 else {
  659.                     g[d1]=(g[d1]+1)%2;
  660.                 }
  661.             }
  662.             while (b1==0);
  663.             init_str(s0,STR_NTR);
  664.             printf("Save Grid: (1) yes  (2) no: ");
  665.             getchar();
  666.             scanf("%c",s0);
  667.             if (ascii_char_num(s0,STR_NTR)==1) {
  668.                 write_file(g,*ys,*xs);
  669.             }
  670.             return g;
  671.             break;
  672.         }
  673.         default:
  674.             break;
  675.     }
  676.     printf("error init_grid\n");
  677.     return 0;
  678. }
  679. int main (int argc, const char * argv[]) {
  680.     int *grid;
  681.     //char entry[STR_NTR];
  682.     int method=2;
  683.     int c=0;
  684.     int ysize,xsize;
  685.     int file_f;
  686.    
  687.     init_grid(&ysize,&xsize,&file_f,0);
  688.     grid=(int*)malloc(sizeof (int)*((ysize)*(xsize)));                 
  689.     grid=init_grid(&ysize,&xsize,&file_f,1);
  690.     //disp_grid(grid,0,ysize,xsize,' ','X');
  691.     method=ques2(MAX_METH);
  692.     getchar();
  693.     //for (i1=0;i1<16;i1++) {
  694.     while (1) {
  695.         disp_grid(grid,1,ysize,xsize,' ','*',c);
  696.         getchar();
  697.         //sleep(1);
  698.         step(grid,method,ysize,xsize,c);
  699.         c++;
  700.     }
  701.     return 0;
  702. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!