maze.c

Many C samples. It is a good sample for students to learn C language.

  int *wall;
  int *x_max;
  int *y_max;
  int *fatal_error;
    {
      int             finished;
      int             delta_index_1;
      int             delta_index_2;
      int             digit;
      int             digit_num;
      int             recurse;
      int             r_n_index_1;
      int             r_n_index_2;
      stack_2_rec_ptr stack_head;
      stack_2_rec_ptr stack_ptr;
      int             sum;
      int             tem_int;
      int             x;
      int             x_next;
      int             x_out;
      int             y;
      int             y_next;
      int             y_out;

      setcolor(*path);
      setfillstyle((unsigned int) SOLID_FILL,(unsigned int) *path);
      bar(0,0,*x_max,*y_max);
      if (*path != *wall)
        {
          setcolor((unsigned int) *wall);
          x_out=0;
          while (x_out <= *x_max)
            {
              line(x_out,0,x_out,*y_max);
              x_out+=(*twice_magnitude_delta_x);
            }
          y_out=0;
          while (y_out <= *y_max)
            {
              line(0,y_out,*x_max,y_out);
              y_out+=(*twice_magnitude_delta_y);
            }
        }
      sum=0;
      for (digit_num=1; digit_num <= 3; digit_num++)
        {
          digit=*r_n;
          r_n_index_1=0;
          for (r_n_index_2=1; r_n_index_2 < 8; r_n_index_2++)
            {
              tem_int=*(r_n+r_n_index_2);
              *(r_n+r_n_index_1)=tem_int;
              r_n_index_1++;
              digit+=tem_int;
              if (digit >= 29)
                digit-=29;
            }
          *(r_n+7)=digit;
          sum=29*sum+digit;
        }
      x=(2*(sum%(*num_columns))+1)*(*magnitude_delta_x);
      sum=0;
      for (digit_num=1; digit_num <= 3; digit_num++)
        {
          digit=*r_n;
          r_n_index_1=0;
          for (r_n_index_2=1; r_n_index_2 < 8; r_n_index_2++)
            {
              tem_int=*(r_n+r_n_index_2);
              *(r_n+r_n_index_1)=tem_int;
              r_n_index_1++;
              digit+=tem_int;
              if (digit >= 29)
                digit-=29;
            }
          *(r_n+7)=digit;
          sum=29*sum+digit;
        }
      y=(2*(sum%(*num_rows))+1)*(*magnitude_delta_y);
      setcolor((unsigned int) *passage);
      setfillstyle((unsigned int) SOLID_FILL,(unsigned int) *passage);
      finished=FALSE;
      recurse=TRUE;
      stack_head=NULL;
      while ((! finished) && (! *fatal_error))
        {
          if (recurse)
            {
              bar(x-(*magnitude_delta_x)+1,y-(*magnitude_delta_y)+1,
               x+(*magnitude_delta_x)-1,y+(*magnitude_delta_y)-1);
              delta_index_1=0;
              do
                {
                  delta_index_2=*r_n;
                  r_n_index_1=0;
                  for (r_n_index_2=1; r_n_index_2 < 8; r_n_index_2++)
                    {
                      tem_int=*(r_n+r_n_index_2);
                      *(r_n+r_n_index_1)=tem_int;
                      r_n_index_1++;
                      delta_index_2+=tem_int;
                      if (delta_index_2 >= 29)
                        delta_index_2-=29;
                    }
                  *(r_n+7)=delta_index_2;
                }
              while (delta_index_2 >= 24);
              recurse=FALSE;
            }
            while ((delta_index_1 < 4)
            &&     (! recurse)
            &&     (! *fatal_error))
              {
                x_next=x+2*(*(delta_x+(24*delta_index_1+delta_index_2)));
                if ((x_next <= 0) || (x_next >= *x_max))
                  delta_index_1++;
                else
                  {
                    y_next
                     =y+2*(*(delta_y+(24*delta_index_1+delta_index_2)));
                    if ((y_next <= 0) || (y_next >= *y_max))
                      delta_index_1++;
                    else
                      if (getpixel(x_next,y_next)
                       == (unsigned int)*path)
                        {
                          if (x == x_next)
                            {
                              y_out=(y+y_next)/2;
                              line(x-(*magnitude_delta_x)+1,y_out,
                               x+(*magnitude_delta_x)-1,y_out);
                            }
                          else
                            {
                              x_out=(x+x_next)/2;
                              line(x_out,y-(*magnitude_delta_y)+1,
                               x_out,y+(*magnitude_delta_y)-1);
                            }
                          x=x_next;
                          y=y_next;
                          if ((stack_ptr=(struct stack_2_rec *) malloc(
                           (unsigned) sizeof(struct stack_2_rec)))
                           == NULL)
                            {
                              *fatal_error=TRUE;
                              closegraph();
                              printf("? out of memory\n");
                            }
                          else
                            {
                              stack_ptr->next_ptr=stack_head;
                              stack_head=stack_ptr;
                              stack_head->index_1
                               =(unsigned char) delta_index_1;
                              stack_head->index_2
                               =(unsigned char) delta_index_2;
                              recurse=TRUE;
                            }
                        }
                      else
                        delta_index_1++;
                  }
              }
            if ((! recurse) && (! *fatal_error))
              {
                delta_index_1=(int) stack_head->index_1;
                delta_index_2=(int) stack_head->index_2;
                stack_ptr=stack_head;
                stack_head=stack_head->next_ptr;
                free((char *) stack_ptr);
                if (stack_head == NULL)
                  finished=TRUE;
                else
                  {
                    x-=
                     (2*(*(delta_x+(24*delta_index_1+delta_index_2))));
                    y-=
                     (2*(*(delta_y+(24*delta_index_1+delta_index_2))));
                  }
              }
        }
      if (! *fatal_error)
        {
          line(1,0,(*twice_magnitude_delta_x)-1,0);
          line(*x_max-(*twice_magnitude_delta_x)+1,*y_max,
           *x_max,*y_max);
          sound(1000);
          delay(333);
          nosound();
        }
      return;
    }

static void remove_rejected_attempts(delta_x,delta_y,erase,passage,
 stack_head,stack_ptr,x,x_next,y,y_next,fatal_error)
  int             *delta_x;
  int             *delta_y;
  int             *erase;
  int             *passage;
  stack_1_rec_ptr *stack_head;
  stack_1_rec_ptr *stack_ptr;
  int             *x;
  int             *x_next;
  int             *y;
  int             *y_next;
  int             *fatal_error;
    {
      int             delta_index_1;
      int             finished;
      int             recurse;
      stack_1_rec_ptr stack_start;

      stack_start=*stack_head;
      if (*erase != *passage)
        {
          recurse=TRUE;
          finished=FALSE;
          while ((! finished) && (! *fatal_error))
            {
              if (recurse)
                {
                  delta_index_1=0;
                  recurse=FALSE;
                }
              while ((delta_index_1 <= 3)
              &&     (! recurse))
                if (*stack_head == NULL)
                  {
                    *x_next=(*x)+(*(delta_x+(24*delta_index_1)));
                    *y_next=(*y)+(*(delta_y+(24*delta_index_1)));
                    if (getpixel(*x_next,*y_next)
                     == (unsigned int) *erase)
                      {
                        *x_next+=(*(delta_x+(24*delta_index_1)));
                        *y_next+=(*(delta_y+(24*delta_index_1)));
                        *x=(*x_next);
                        *y=(*y_next);
                        if ((*stack_ptr=(struct stack_1_rec *) malloc(
                         (unsigned) sizeof(struct stack_1_rec)))
                         == NULL)
                          {
                            *fatal_error=TRUE;
                            closegraph();
                            printf("? out of memory\n");
                          }
                        else
                          {
                            (*stack_ptr)->next_ptr=*stack_head;
                            *stack_head=(*stack_ptr);
                            (*stack_head)->index_1
                             =(unsigned char) delta_index_1;
                            recurse=TRUE;
                          }
                      }
                    else
                      delta_index_1++;
                  }
                else
                  if ((delta_index_1 + 2) % 4
                   == (int) (*stack_head)->index_1)
                    delta_index_1++;
                  else
                    {
                      *x_next=(*x)+(*(delta_x+(24*delta_index_1)));
                      *y_next=(*y)+(*(delta_y+(24*delta_index_1)));
                      if (getpixel(*x_next,*y_next)
                       == (unsigned int) *erase)
                        {
                          *x_next+=(*(delta_x+(24*delta_index_1)));
                          *y_next+=(*(delta_y+(24*delta_index_1)));
                          *x=(*x_next);
                          *y=(*y_next);
                          if ((*stack_ptr=(struct stack_1_rec *) malloc(
                           (unsigned) sizeof(struct stack_1_rec)))
                           == NULL)
                            {
                              *fatal_error=TRUE;
                              closegraph();
                              printf("? out of memory\n");
                            }
                          else
                            {
                              (*stack_ptr)->next_ptr=(*stack_head);
                              *stack_head=(*stack_ptr);
                              (*stack_head)->index_1
                               =(unsigned char) delta_index_1;
                              recurse=TRUE;
                            }
                        }
                      else
                        delta_index_1++;
                    }
              if ((delta_index_1 > 3) && (! *fatal_error))
                {
                  if (stack_start == *stack_head)
                    finished=TRUE;
                  else
                    {
                      setcolor((unsigned int) *passage);
                      *x_next=(*x);
                      *y_next=(*y);
                      delta_index_1=(int) ((*stack_head)->index_1);
                      *stack_ptr=(*stack_head);
                      (*stack_head)=(*stack_head)->next_ptr;
                      free((char *) *stack_ptr);
                      *x-=(2*(*(delta_x+(24*delta_index_1))));
                      *y-=(2*(*(delta_y+(24*delta_index_1))));
                      line(*x,*y,*x_next,*y_next);
                      delta_index_1++;
                    }
                }
            }
        }
      return;
    }

static void let_user_try_to_solve(delta_x,delta_y,erase,key_pressed,
 magnitude_delta_x,magnitude_delta_y,passage,path,wall,y_max,
 fatal_error)
  int *delta_x;
  int *delta_y;
  int *erase;
  int *key_pressed;
  int *magnitude_delta_x;
  int *magnitude_delta_y;
  int *passage;
  int *path;
  int *wall;
  int *y_max;
  int *fatal_error;
    {
      int             color;
      int             delta_index_1;
      int             frequency;
      int             passage_found;
      stack_1_rec_ptr stack_head;
      stack_1_rec_ptr stack_ptr;
      int             x;
      int             x_next;
      int             y;
      int             y_next;

      stack_head=NULL;
      x=*magnitude_delta_x;
      y=*magnitude_delta_y;
      y_next=0;
      setcolor((unsigned int) *path);
      line(x,0,x,y);
      do
        {
          do
            {
              passage_found=TRUE;
              *key_pressed=getch();
              if ((*key_pressed != (int) 'Q')
              &&  (*key_pressed != (int) 'q')
              &&  (*key_pressed != (int) 'S')
              &&  (*key_pressed != (int) 's'))
                {
                  if (*key_pressed == 0)
                    {
                      *key_pressed=getch();
                      switch (*key_pressed)