ca_shell.c

细胞自动机的一个源代码

#include "main.h"


void dfa_test() {
  int i, j, k;
  int ns, a;


  for (i=0; i<g_ca->wlen; i++) {

    g_dfa->cur = 0;

    for (j=0; j<g_ca->fd; j++) {
      dfa_step(g_dfa, g_ca->ca[i][j], &a);
      g_dc->g[j + (i*(g_ca->fd))] = a;
    }
  }


}




void cas_display(cas_t *cas) {
  int i, j, k, b, e;


  glColor3f(cas->r, cas->g, cas->b);
  glRasterPos3f(cas->x, cas->y, cas->z);


  b = (((cas->by - cas->wh)>0) ? (cas->by - cas->wh) : 0);
  e = b + cas->wh;
  k=0;


  for (i=b; i<e; i++) {
    glRasterPos3f(cas->x,
		  cas->y - ((float)k*(cas->cnl)),
		  cas->z);
    k++;
    for (j=0; j<cas->ww; j++) {
      //glBitmap(cas->cw, cas->ch, 0.0, 0.0, cas->cspace,
      //       0.0, cas->a[cas->buf[i][j]]);

      //glutBitmapCharacter(GLUT_BITMAP_9_BY_15, cas->buf[i][j]);
      glutBitmapCharacter(GLUT_BITMAP_9_BY_15, cas->buf[i][j]);


    }
    //glBitmap(0, 0, 0.0, 0.0,
    //     -(cas->cspace*((float)cas->ww)),
    //     -cas->cnl, NULL);
  }

}

void cas_slide(cas_t *cas) {
  int i, j, k;

  for (i=1; i<cas->bh; i++) {
    for (j=0; j<cas->bw; j++) {
      cas->buf[i-1][j] = cas->buf[i][j];
    }
  }

  i--;
  for (j=0; j<cas->bw; j++) {
    cas->buf[i][j]=0;
  }

}

void cas_addch(cas_t *cas, int ch) {
  int i, j, k;

  if (ch==XK_Return) {
    cas->buf[cas->by][cas->bx] = (char)' ';
    cas_runcmd(cas);
    cas->bx = 0;
    cas->by++;
    if (cas->by >= cas->bh) {
      cas->by--;
      cas_slide(cas);
    }
    cas->buf[cas->by][cas->bx] = (char)'$';
    return;
  }

  if (ch==XK_BackSpace) {

    cas->buf[cas->by][cas->bx] = (char)(' ');
    cas->bx -= ((cas->bx<=0) ? 0 : 1);
    cas->buf[cas->by][cas->bx] = (char)('$');
    return;

  }

  cas->buf[cas->by][cas->bx] = (char)ch;
  cas->bx++;
  cas->buf[cas->by][cas->bx] = (char)'$';


  if (cas->bx >= cas->bw) {

    cas->bx = 0;
    cas->by++;
    if (cas->by >= cas->bh) {
      cas_slide(cas);
      cas->by--;
    }

  }

}

static char **cas_parsecmd(char *cmd) {
  static char **com = NULL;
  char *c;
  int i, j, k, n;
  int cur=0, p=0;

  if (!com) {
    com = (char **)malloc(sizeof(char *)*5);
    for (i=0; i<5; i++) {
      com[i] = (char *)malloc(sizeof(char)*200);
    }
  }

  for (i=0; i<5; i++) {
    for (j=0; j<200; j++) {
      com[i][j] = '\0';
    }
  }

  n = strlen(cmd);
  i=0;
  while (cmd[i]) {

    //printf("cmd %i: %c\n", i, cmd[i]);

    if (cmd[i]==' ') {

      com[cur][p] = '\0';
      i++;
      cur++;
      p=0;
    }

    if (!cmd[i]) break;

    com[cur][p] = cmd[i];
    p++;
    i++;
  }

  cur++;
  com[cur][0] = '\0';
  
  return(com);
}

void cas_runcmd(cas_t *cas) {
  int i, j, k;
  char cmd[200];
  char com[100];
  char opts[4][100];
  char **cmda;
  char *p, *q;
  int ps[3] = {0,0,0}, pe[3] = {99,99,99};
  int tp[3], tq[3];
  int n;
  int poi[3] = {0,0,0};
  float f;
  FILE *fp;

  for (i=0; i < cas->bx; i++) {
    cmd[i] = cas->buf[cas->by][i];
  }
  cmd[i] = '\0';

  cmda = cas_parsecmd(cmd);


  for (i=0; cmda[i][0]; i++) {
    printf(",%s,", cmda[i]);
  }

  printf("\n");

  /* quit */
  if (strcmp(cmda[0], "quit")==0) {

    exit(1);

  }
  /* s(eries) <0/1>  */
  else if (strcmp(cmda[0], "s")==0) {

    n = atoi(cmda[1]);
    if (n) {
      g_ca->slen = g_ca->wlen;
    } else {
      g_ca->slen = 1;
    }

  }
  /* r(un) <# steps> */
  else if (strcmp(cmda[0], "r")==0) {

    n = atoi(cmda[1]);
    for (i=0; i<n; i++) {
      (*ca_update_func)(g_ca, 0, g_ca->fd-1);
    }

  }
  /* p(oint) <x> ... <z> */
  else if (strcmp(cmda[0], "p")==0) {

    for (i=0; i<g_ca->dim; i++) {
      poi[i] = atoi(cmda[i+1]);
    }
    g_ca->ca[g_ca->cur][ca_point(g_ca, poi)] = 1;

  }
  /* u(pdate) */
  else if (strcmp(cmda[0], "u")==0) {
    (*ca_update_func)(g_ca, 0, g_ca->fd-1);
  }
  /* g(o) <0/1> */
  else if (strcmp(cmda[0], "g")==0) {

    g_ca->go = atoi(cmda[1]);

    printf("go %i\n", atoi(cmda[1]));

  }
  /* random [0..1] */
  else if (strcmp(cmda[0], "random")==0) {

    f = atof(cmda[1]);
    for (i=0; i<(g_ca->fd); i++) {
      if ( ((float)(1.0*rand()/(RAND_MAX+1.0))) < f ) {
	g_ca->ca[g_ca->cur][i] = 1;
      } else {
	g_ca->ca[g_ca->cur][i] = 0;
      }
    }
  }
  /* reset */
  else if (strcmp(cmda[0], "reset")==0) {
    for (i=0; i<(g_ca->fd); i++) {
      g_ca->ca[g_ca->cur][i] = 0;
    }
  }
  /* ca_config <file> */
  else if (strcmp(cmda[0], "ca_config")==0) {
  }
  /* disp_config <file> */
  else if (strcmp(cmda[0], "disp_config")==0) {
  }
  /* diff <1/0> <diff> */
  else if (strcmp(cmda[0], "diff")==0) {

    if (atoi(cmda[1])==1) {
      g_ca->diff = atoi(cmda[2]);
      gwin.g_disp = displayfunc_diff;
    } else {
      gwin.g_disp = displayfunc;
    }

  }
  /* config <file> */
  else if (strcmp(cmda[0], "config")==0) {

    if (!(fp = fopen(cmda[1], "r"))) {
      printf("BAD CONFIG READ");
      return;
    }

    ca_free(g_ca);
    g_ca = (ca_t *)malloc(sizeof(ca_t));
    ca_file_config(g_ca, fp);
    fclose(fp);

    ca_print(g_ca);

  }
  /* dfa <0/1> */
  else if (strcmp(cmda[0], "dfa")==0) {
    if (atoi(cmda[1])==1) {
      dfa_test();
      gwin.g_disp = displayfunc_dfa;
    } else {
      gwin.g_disp = displayfunc;
    }
  }

}

void cas_init(cas_t *cas, int h, int w, char **a, int ch, int cw) {
  int i, j;
  char **alpha, **buf;

  //alpha = (char **)malloc(sizeof(char *)*256);
  //for (i=0; i<256; i++) {
  //alpha[i] = (char *)malloc(sizeof(char)*ch*cw);
  //memcpy(alpha[i], a[i], sizeof(char)*ch*cw);
  //}

  buf = (char **)malloc(sizeof(char *)*h);
  for (i=0; i<h; i++) {
    buf[i] = (char *)calloc(w, sizeof(char));
  }

  for (i=0; i<h; i++) {
    for (j=0; j<w; j++) {
      buf[i][j] = ' ';
    }
  }
  cas->buf = buf;

  cas->r = 0.0;
  cas->g = 1.0;
  cas->b = 0.0;

  cas->cspace = (float)(cw+1);
  cas->cnl = 0.1; //(float)(ch+1);

  cas->wh = h;
  cas->ww = w;

  cas->bx = 0;
  cas->by = 0;

  cas->bh = h;
  cas->bw = w;

  cas->x = -1.0;
  cas->y = -0.5;
  cas->z = -1.1;


}