⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 c语言写的《泡泡堂》游戏.txt

📁 C语言写的《泡泡堂》游戏
💻 TXT
📖 第 1 页 / 共 3 页
字号:

                  if (map[m->y][m->x] == 'o')
                  {
                  DrawPao(m->x, m->y);
                  }


                  --(m->x);
                  DrawMan(*m);

                  switch (map[m->y][m->x])
                  {
                  case 'a':
                  case 'b':
                  m->can_move = CANNOT;
                  m->old_time = clock();
                  break;
                  case 'O':
                  ++(m->pao_num);
                  map[m->y][m->x] = ' ';
                  break;
                  case '-':
                  ++(m->len);
                  map[m->y][m->x] = ' ';
                  break;
                  default:
                  break;
                  }

                  if (m->x == p->x && m->y == p->y && p->can_move == CANNOT)
                  {
                  gotoxy(36, 3);
                  printf("Play%d Win!!", m->which);
                  return 0;
                  }

                  return 1;
                  }

                  /*人物m向右移动的函数*/
                  int MoveRight(man *m, man *p)
                  {
                  if (map[m->y][m->x + 1] == '#' || map[m->y][m->x + 1] == '@'
                  || map[m->y][m->x + 1] == 'o' || m->can_move == CANNOT)
                  {
                  return 1;
                  }

                  EraseMan(*m);

                  if (map[m->y][m->x] == 'o')
                  {
                  DrawPao(m->x, m->y);
                  }


                  ++(m->x);
                  DrawMan(*m);

                  switch (map[m->y][m->x])
                  {
                  case 'a':
                  case 'b':
                  m->can_move = CANNOT;
                  m->old_time = clock();
                  break;
                  case 'O':
                  ++(m->pao_num);
                  map[m->y][m->x] = ' ';
                  break;
                  case '-':
                  ++(m->len);
                  map[m->y][m->x] = ' ';
                  break;
                  default:
                  break;
                  }

                  if (m->x == p->x && m->y == p->y && p->can_move == CANNOT)
                  {
                  gotoxy(36, 3);
                  printf("Play%d Win!!", m->which);
                  return 0;
                  }

                  return 1; 
                  }

                  /*>>>>>>>>>>> paopao functions -- copyright wonderful and 
                  WangChengBo <<<<<<<<<<<<*/
                  /*泡泡的数据结构*/
                  typedef struct
                  {
                  int x;
                  int y;
                  int original_time;
                  int len;
                  which_play which;
                  }PAO;

                  /*--------------------------------------------------------------*/
                  /*以下为链表队列*/
                  typedef PAO QElemType;

                  typedef struct QNode
                  {
                  QElemType data;
                  struct QNode *next;
                  }QNode, *QueuePtr;

                  typedef struct
                  {
                  QueuePtr front; /*队头,最早出队列的一端*/
                  QueuePtr rear; /*队尾,允许插入的一端*/
                  }LinkQueue;

                  void InitalQueue(LinkQueue *Q)
                  {
                  Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));
                  Q->front->next = NULL;
                  }


                  int EnQueue(LinkQueue *Q, QElemType e)
                  {
                  QueuePtr p;
                  p = (QueuePtr)malloc(sizeof(QNode));

                  if (p == NULL)
                  {
                  return 0;
                  }

                  p->data = e;
                  p->next = NULL;
                  Q->rear->next = p;
                  Q->rear = p;
                  return 1;
                  }

                  int QueueHead(LinkQueue *Q, QElemType *e)
                  {
                  if (Q->front == Q->rear)
                  {
                  return 0;
                  }

                  *e = Q->front->next->data;
                  return 1;
                  }

                  int FindElemDelete(LinkQueue *Q, QElemType *e, int x, int y)
                  {
                  QueuePtr p, q = Q->front;

                  for (p = Q->front->next; p != 0; p = p->next)
                  {
                  if (p->data.x == x && p->data.y == y)
                  {
                  q->next = p->next;
                  *e = p->data;

                  if (p == Q->rear)
                  {
                  Q->rear = q;
                  }

                  free(p);
                  return 1;
                  }
                  else
                  {
                  q = p;
                  }
                  }
                  return 0;
                  }


                  int DeQueue(LinkQueue *Q)
                  {
                  QueuePtr p;

                  if (Q->front == Q->rear)
                  {
                  return 0;
                  }

                  p = Q->front->next;
                  Q->front->next = p->next;

                  if (Q->rear == p)
                  {
                  Q->rear = Q->front;
                  }
                  free(p);
                  return 1;
                  }


                  void DestroyQueue(LinkQueue *Q)
                  {
                  while (Q->front)
                  {
                  Q->rear = Q->front->next;
                  free(Q->front);
                  Q->front = Q->rear;
                  }
                  }

                  /*放泡泡的函数*/
                  void Paopao(man *m, LinkQueue *Q)
                  {
                  PAO pao;
                  if (m->can_move == CANNOT || m->pao_num == 0)
                  {
                  return;
                  }
                  DrawPaoMan(*m);
                  map[m->y][m->x] = 'o';
                  pao.x = m->x;
                  pao.y = m->y;
                  pao.original_time = clock();
                  pao.len = m->len;
                  pao.which = m->which;

                  --m->pao_num;

                  /*入队列 */
                  EnQueue(Q, pao);
                  }

                  /*泡泡爆炸的函数*/
                  void PaoBlast(PAO pao, man *p1, man *p2, LinkQueue *Q, 
                  LinkQueue *B)
                  {
                  int i = 1, end = 0;
                  PAO e;

                  switch (pao.which)
                  {
                  case PLAY1:
                  ++(p1->pao_num);
                  break;
                  case PLAY2:
                  ++(p2->pao_num);
                  break;
                  }

                  DrawBlast1(pao.x, pao.y);
                  map[pao.y][pao.x] = 'b';

                  if (p1->x == pao.x && p1->y == pao.y)
                  {
                  DrawPaoMan(*p1);
                  p1->can_move = CANNOT;
                  p1->old_time = clock();
                  }
                  else if (p2->x == pao.x && p2->y == pao.y)
                  {
                  DrawPaoMan(*p2);
                  p2->can_move = CANNOT;
                  p2->old_time = clock();
                  }

                  /*--------------------Up----------------------*/
                  for (; i <= pao.len; ++i)
                  {
                  end = 0;

                  switch (map[pao.y-i][pao.x])
                  {
                  case '#':
                  end = 1;
                  break;

                  case ' ':
                  DrawBlast1(pao.x, pao.y-i);
                  map[pao.y-i][pao.x] = 'b';
                  break;

                  case '@':
                  end = 1;
                  DrawBlast1(pao.x, pao.y-i);
                  map[pao.y-i][pao.x] = 'a';
                  break;

                  case 'o': 
                  if (FindElemDelete(Q, &e, pao.x, pao.y-i) == 1)
                  {
                  e.original_time = clock();
                  EnQueue(B, e);
                  PaoBlast(e, p1, p2, Q, B);
                  }
                  break;

                  default:
                  break;
                  }

                  if (p1->x == pao.x && p1->y == pao.y-i)
                  {
                  DrawPaoMan(*p1);
                  p1->can_move = CANNOT;
                  p1->old_time = clock();
                  }
                  else if (p2->x == pao.x && p2->y == pao.y-i)
                  {
                  DrawPaoMan(*p2);
                  p2->can_move = CANNOT;
                  p2->old_time = clock();
                  }

                  if (end == 1)
                  {
                  break;
                  }
                  }

                  /*----------------------Down------------------------*/
                  for (i=1; i <= pao.len; ++i)
                  {
                  end = 0;

                  switch (map[pao.y+i][pao.x])
                  {
                  case '#':
                  end = 1;
                  break;

                  case ' ':
                  DrawBlast1(pao.x, pao.y+i);
                  map[pao.y+i][pao.x] = 'b';
                  break; 

                  case '@':
                  end = 1;
                  DrawBlast1(pao.x, pao.y+i);
                  map[pao.y+i][pao.x] = 'a';
                  break;

                  case 'o':
                  if (FindElemDelete(Q, &e, pao.x, pao.y+i) == 1)
                  {
                  e.original_time = clock();
                  EnQueue(B, e);
                  PaoBlast(e, p1, p2, Q, B);
                  }
                  break;

                  default:
                  break;
                  }

                  if (p1->x == pao.x && p1->y == pao.y+i)
                  {
                  DrawPaoMan(*p1);
                  p1->can_move = CANNOT;
                  p1->old_time = clock();
                  }
                  else if (p2->x == pao.x && p2->y == pao.y+i)
                  {
                  DrawPaoMan(*p2);
                  p2->can_move = CANNOT;
                  p2->old_time = clock();
                  }


                  if (end == 1)
                  {
                  break;
                  }
                  }

                  /*---------------------Left-------------------------*/
                  for (i=1; i <= pao.len; ++i)
                  {

                  end = 0;
                  switch (map[pao.y][pao.x-i])
                  {
                  case '#':
                  end = 1;
                  break;

                  case ' ':
                  DrawBlast1(pao.x-i, pao.y);
                  map[pao.y][pao.x-i] = 'b';
                  break;

                  case '@':
                  end = 1;
                  DrawBlast1(pao.x-i, pao.y);
                  map[pao.y][pao.x-i] = 'a';
                  break;

                  case 'o':
                  if (FindElemDelete(Q, &e, pao.x-i, pao.y) == 1)
                  {
                  e.original_time = clock();
                  EnQueue(B, e);
                  PaoBlast(e, p1, p2, Q, B);
                  }
                  break;

                  default:
                  break;
                  }

                  if (p1->x == pao.x-i && p1->y == pao.y)
                  {
                  DrawPaoMan(*p1);
                  p1->can_move = CANNOT;
                  p1->old_time = clock();
                  }
                  else if (p2->x == pao.x-i && p2->y == pao.y)
                  {
                  DrawPaoMan(*p2);
                  p2->can_move = CANNOT;
                  p2->old_time = clock();
                  }

                  if (end == 1)
                  {
                  break;
                  }
                  }

                  /*----------------------Right-----------------------*/
                  for (i=1; i <= pao.len; ++i)
                  {

                  end = 0;
                  switch (map[pao.y][pao.x+i])
                  {
                  case '#':
                  end = 1;
                  break;

                  case ' ':
                  DrawBlast1(pao.x+i, pao.y);
                  map[pao.y][pao.x+i] = 'b';
                  break;

                  case '@':
                  end = 1;

                  DrawBlast1(pao.x+i, pao.y);
                  map[pao.y][pao.x+i] = 'a';
                  break;

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -