俄罗斯方块

最新推荐文章于 2024-04-23 21:50:54 发布
最新推荐文章于 2024-04-23 21:50:54 发布
阅读量103 收藏
点赞数
文章标签： J# C C++ C# Qt
一共三个文件

实现得很恶心,很多代码没效率


SCR.c 


#include "SCR.h"

typedef enum mode_t {
  CHARACTER = 3,
  BACKGROUND = 4
} mode_t;

static struct termios orig;
static unsigned int term_init = 0;

void clear(void)
{
  fprintf(stderr, "\033[2J");
}

int start_iaction(int sec, int usec, void (*action)(int))
{
  struct itimerval itimer;
  struct sigaction sa;
  int ret;

  sa.sa_handler = action;
  sigemptyset(&(sa.sa_mask));
  sa.sa_flags = 0;
  ret = sigaction(SIGALRM, &sa, NULL);
  if (ret != 0) {
    perror("sigaction");
    return -1;
  }

  itimer.it_value.tv_sec = sec;
  itimer.it_value.tv_usec = usec;
  itimer.it_interval.tv_sec = sec;
  itimer.it_interval.tv_usec = usec;
  ret = setitimer(ITIMER_REAL, &itimer, NULL);
  if (ret != 0) {
    perror("setitimer");
    sa.sa_handler = SIG_DFL;
    sigemptyset(&(sa.sa_mask));
    sa.sa_flags = 0;
    sigaction(SIGALRM, &sa, NULL);
    return -1;
  }

  return 0;
}

int stop_iaction(void)
{
  struct itimerval itimer;
  struct sigaction sa;
  int ret;

  memset(&itimer, '\0', sizeof(struct itimerval));
  ret = setitimer(ITIMER_REAL, &itimer, NULL);
  if (ret != 0) {
    perror("setitimer");
    return -1;
  }
  sa.sa_handler = SIG_DFL;
  sigemptyset(&(sa.sa_mask));
  sa.sa_flags = 0;
  ret = sigaction(SIGALRM, &sa, NULL);
  if (ret != 0) {
    perror("sigaction");
  }

  return ret;
}

int get_winsz(int *row, int *col)
{
  struct winsize win;
  int ret;

  ret = ioctl(STDOUT_FILENO, TIOCGWINSZ, &win);
  if (ret != 0) {
    perror("ioctl");
    return -1;
  }
  *row = win.ws_row;
  *col = win.ws_col;

  return 0;
}

int stty(void)
{
  struct termios ttystat;
  int ret;

  ret = tcgetattr(STDIN_FILENO, &ttystat);
  if (ret != 0) {
    perror("tcgetattr");
    return -1;
  }
  if (term_init == 0) {
    memcpy(&orig, &ttystat, sizeof(struct termios));
    term_init = 1;
  }
  ttystat.c_lflag &= ~(ECHO | ICANON);
  ttystat.c_cc[VMIN] = 1;
  ret = tcsetattr(STDIN_FILENO, TCSANOW, &ttystat);
  if (ret != 0) {
    perror("tcsetattr");
    return -1;
  }
  printf("\033[?25l\033[?1c");

  return 0;
}

int rtty(void)
{
  int ret;

  if (term_init == 0) {
    return 0;
  }
  ret = tcsetattr(STDIN_FILENO, TCSANOW, &orig);
  if (ret != 0) {
    perror("tcsetattr");
    return -1;
  }
  printf("\033[?25h\033[?0c");

  return 0;
}

int get_input(int expected)
{
  char seq[8] = {0};
  int ret;

  while (1) {
    ret = read(STDIN_FILENO, seq, 8);
    if (ret < 0 && errno != EINTR) {
      perror("read");
      return -1;
    }
    if ((expected & UP) && ret == 3 &&
        seq[0] == '\033' && seq[1] == '[' && seq[2] == 'A') {
      return UP;
    }
    if ((expected & DOWN) && ret == 3 &&
        seq[0] == '\033' && seq[1] == '[' && seq[2] == 'B') {
      return DOWN;
    }
    if ((expected & RIGHT) && ret == 3 &&
        seq[0] == '\033' && seq[1] == '[' && seq[2] == 'C') {
      return RIGHT;
    }
    if ((expected & LEFT) && ret == 3 &&
        seq[0] == '\033' && seq[1] == '[' && seq[2] == 'D') {
      return LEFT;
    }
    if ((expected & ESC) && ret == 1 && seq[0] == '\033') {
      return ESC;
    }
    if ((expected & ENTER) && ret == 1 && seq[0] == '\n') {
      return ENTER;
    }
    if ((expected & KEY_Q) && ret == 1 &&
        (seq[0] == 'q' || seq[0] == 'Q')) {
      return KEY_Q;
    }
    if ((expected & KEY_S) && ret == 1 &&
        (seq[0] == 's' || seq[0] == 'S')) {
      return KEY_S;
    }
    if ((expected & KEY_H) && ret == 1 &&
        (seq[0] == 'h' || seq[0] == 'H')) {
      return KEY_H;
    }
    if ((expected & KEY_J) && ret == 1 &&
        (seq[0] == 'j' || seq[0] == 'J')) {
      return KEY_J;
    }
    if ((expected & KEY_K) && ret == 1 &&
        (seq[0] == 'k' || seq[0] == 'K')) {
      return KEY_K;
    }
    if ((expected & KEY_L) && ret == 1 &&
        (seq[0] == 'l' || seq[0] == 'L')) {
      return KEY_L;
    }
  }

  return 0;
}

void move_curs(int x, int y)
{
  printf("\033[%d;%dH", y, x);
}

void draw_rec(rec_t *rec)
{
  int i, j;

  printf("\033[%d%d;%d%dm",
         BACKGROUND, rec->background, CHARACTER, rec->foreground);
  for (i = 0; i < rec->h; ++i) {
    printf("\033[%d;%dH", rec->y + i, rec->x);
    for (j = 0; j < rec->w; ++j) {
      printf("%c", rec->ch);
    }
  }
  printf("\033[0m");
  fflush(NULL);
  return;
}


SCR.h 


#ifndef _SCR_H_
#define _SCR_H_


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/time.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <termios.h>
#include <errno.h>
#include <math.h>


typedef enum ch_t {
  UP       = 0x00000001,
  DOWN     = 0x00000002,
  RIGHT    = 0x00000004,
  LEFT     = 0x00000008,
  ESC      = 0x00000010,
  ENTER    = 0x00000020,
  KEY_Q    = 0x00000040,
  KEY_S    = 0x00000080,
  KEY_H    = 0x00000100,
  KEY_J    = 0x00000200,
  KEY_K    = 0x00000400,
  KEY_L    = 0x00000800
} ch_t;

typedef enum color_t {
  COLOR_MIN = 0,
  BLACK = 0,
  RED,
  GREEN,
  YELLOW,
  BLUE,
  MAGENTA,
  CYAN,
  WHITE,
  COLOR_MAX = WHITE
} color_t;


typedef struct rec_t {
  int x;
  int y;
  int w;
  int h;
  char ch;
  color_t background;
  color_t foreground;
} rec_t;

void clear(void);

int stty(void);

int rtty(void);

int start_iaction(int sec, int usec, void (*)(int));

int stop_iaction(void);

int get_winsz(int *row, int *col);

int get_input(int expected);

void move_curs(int x, int y);

void draw_rec(rec_t *);

#endif


TETRIS.c 

#include "SCR.h"

enum {
  SEC = 0,
  USEC = 500000
};

int A[4][4]={{0,0,0,0},
             {0,1,1,0},
             {0,1,1,0},
             {0,0,0,0}};

int B[4][4]={{0,0,1,0},
             {0,0,1,0},
             {0,0,1,0},
             {0,0,1,0}};

int C[4][4]={{0,1,0,0},
             {0,1,1,0},
             {0,1,0,0},
             {0,0,0,0}};

int D[4][4]={{0,0,0,0},
             {0,1,1,0},
             {0,0,1,1},
             {0,0,0,0}};

int E[4][4]={{0,0,0,0},
             {0,0,1,1},
             {0,1,1,0},
             {0,0,0,0}};

int F[4][4]={{0,0,0,0},
             {0,1,1,0},
             {0,0,1,0},
             {0,0,1,0}};

int G[4][4]={{0,0,0,0},
             {0,1,1,0},
             {0,1,0,0},
             {0,1,0,0}};


int w_col;
int w_row;

#define up      2
#define down   23
#define right  22
#define left    4


int N,top=0;
int tmp_k;
int x,y;
int matrix[10][20];
int __rec_tmp[4][4];
int color[10][20];

rec_t bg;
rec_t __rec[4];


void ___draw_frame(int x,int y){

  rec_t __frame;

  __frame.x=x;
  __frame.y=y+1;
  __frame.w = 2;
  __frame.h = 20;
  __frame.ch = ' ';
  __frame.background = RED;
  __frame.foreground = RED;
  draw_rec(&__frame);

  __frame.x=x;
  __frame.y=y;
  __frame.w = 24;
  __frame.h = 1;
  __frame.ch = ' ';
  __frame.background = RED;
  __frame.foreground = RED;
  draw_rec(&__frame);

  __frame.x=x+22;
  __frame.y=y+1;
  __frame.w = 2;
  __frame.h = 20;
  __frame.ch = ' ';
  __frame.background = RED;
  __frame.foreground = RED;
  draw_rec(&__frame);

  __frame.x=x;
  __frame.y=y+21;
  __frame.w = 24;
  __frame.h = 1;
  __frame.ch = ' ';
  __frame.background = RED;
  __frame.foreground = RED;
  draw_rec(&__frame);


}

void ___draw_bg(){


  int i=0;
  int j=0;
  rec_t tmp;

  for(i=0;i<20;i++){
    for(j=0;j<10;j++){
      tmp.x=(j+2)*2;
      tmp.y=i+3;
      tmp.w = 2;
      tmp.h = 1;
      tmp.ch = ' ';
      tmp.background = color[j][i];
      tmp.foreground = color[j][i];
      draw_rec(&tmp);
    }
  }
  ___draw_frame(2,2);

}

void ___draw_square(int square[4][4]){

  int i,j,k=0;

  tmp_k=4;

  k=0;

  for(i=0;i<4;i++){
    for(j=0;j<4;j++){
      if(square[i][j]==1){
        __rec[k].x=(i+4)*2;
        __rec[k].y=(j+2)*1;
        __rec[k].w = 2;
        __rec[k].h = 1;
        __rec[k].ch = ' ';
        __rec[k].background = N;
        __rec[k].foreground = N;
        k++;
      }
    }
  }
  x=4;
  y=2;

  for(i=0;i<4;i++)
    for(j=0;j<4;j++)
      __rec_tmp[i][j]=square[i][j];


  for(i=0;i<4;i++){
    if(matrix[(__rec[i].x-4)/2][__rec[i].y-3]==1){
      top=1;
    }
  }
}

int MAX_Y(rec_t __rec[],int count){

  int max=0,i;
  for(i=0;i<count;i++){
    if(__rec[i].y >= max)
      max=__rec[i].y;
  }
  return max;
}

int MAX_X(rec_t __rec[],int count){

  int max=0,i;
  for(i=0;i<count;i++){
    if(__rec[i].x >= max)
      max=__rec[i].x;
  }
  return max;
}

int MIN_X(rec_t __rec[],int count){

  int min=__rec[0].x;
  int i;
  for(i=0;i<count;i++){
    if(__rec[i].x <= min)
      min=__rec[i].x;
  }
  return min;
}

int MIN_Y(rec_t __rec[],int count){

  int min=__rec[0].y;
  int i;
  for(i=0;i<count;i++){
    if(__rec[i].y <= min)
      min=__rec[i].y;
  }
  return min;
}

int GameOver(){

  int i,j,tmp1=0,tmp2=0;

  for(i=0;i<20;i++){
    for(j=0;j<10;j++){
      tmp1 += matrix[j][i];
    }
    if(tmp1>0){
      tmp2++;
    }
    if(tmp2==20 || top==1){
      fprintf(stderr,"\n\tGame Over\n");
      stop_iaction();
      rtty();
      exit(1);
    }
    tmp1=0;
  }

  return 0;
}

void Delete(){

  int i,j,m,n,tmp;

  for(i=0;i<20;i++){
    for(j=0;j<10;j++){
      tmp += matrix[j][i];
    }
    if(tmp==10){
      for(n=i;n>0;n--){
        for(m=0;m<10;m++){
          matrix[m][n]=matrix[m][n-1];
          color[m][n]=color[m][n-1];
        }
      }
    }
    tmp=0;
  }

}

void Change(int arr[][4]){

	int i=4,j=4;
	int acc[4][4];

	for(i=0;i<4;i++)
		for(j=0;j<4;j++)
			acc[i][j]=arr[i][j];

	for(i=0;i<4;i++)
		for(j=0;j<4;j++)
      arr[i][j]=acc[j][3-i];
}

int Limit_D(rec_t __rec[],int tmp_k){

  int i,j,status=0;
  int max;
  int flag=0;

  for(i=0;i<tmp_k;i++){
    flag=0;

    for(j=0;j<tmp_k;j++){
      if(__rec[i].x==__rec[j].x){
        max=(__rec[i].y >= __rec[j].y ? __rec[i].y : __rec[j].y);
        flag=1;
      }
    }

    if(flag==1){
      if(matrix[(__rec[i].x-4)/2][max-2]==1)
        status=1;
    }

    if(flag==0){
      if(matrix[(__rec[i].x-4)/2][__rec[i].y-2]==1)
        status=1;
    }

  }

  return status;
}

int Limit_R(rec_t __rec[],int tmp_k){

  int i,j,status=0;
  int max=0;
  int flag=0;


  for(i=0;i<tmp_k;i++){

    flag=0;
    max=0;

    for(j=0;j<tmp_k;j++){
      if(__rec[i].y==__rec[j].y){
        max=(__rec[i].x > __rec[j].x ? __rec[i].x : __rec[j].x);
        flag=1;
      }
    }
    if(flag==1){
      if(matrix[(max-4)/2+1][__rec[i].y-3]==1)
        status=1;
    }

    if(flag==0){
      if(matrix[(__rec[i].x-4)/2+1][__rec[i].y-3]==1)
        status=1;
    }

  }

  return status;
}

int Limit_L(rec_t __rec[],int tmp_k){

  int i,j,status=0;
  int min;
  int flag=0;

  for(i=0;i<tmp_k;i++){

    min=MAX_X(__rec,tmp_k);
    flag=0;

    for(j=0;j<tmp_k;j++){
      if(__rec[i].y==__rec[j].y && min >= __rec[j].x){
        min=__rec[j].x;
        flag=1;
      }
    }

    if(flag==1){
      if(matrix[(min-4)/2-1][__rec[i].y-3]==1)
        return 1;
    }

    if(flag==0){
      if(matrix[(__rec[i].x-4)/2-1][__rec[i].y-3]==1)
        return 1;
    }

  }

  return status;
}

void Transform(){

  int i,j,k;
  rec_t tmp[4];
  int tmp_m[4][4];

  for(i=0;i<4;i++)
    for(j=0;j<4;j++)
      tmp_m[i][j]=__rec_tmp[i][j];

  for(i=0;i<tmp_k;i++)
    matrix[(__rec[i].x-4)/2][__rec[i].y-3]=0;

  for(i=0;i<tmp_k;i++)
    color[(__rec[i].x-4)/2][__rec[i].y-3]=WHITE;

  Change(tmp_m);

  k=0;
  for(i=0;i<4;i++){
    for(j=0;j<4;j++){
      if(tmp_m[i][j]==1){
        tmp[k].x=(i+x)*2;
        tmp[k].y=(j+y)*1;
        tmp[k].w = 2;
        tmp[k].h = 1;
        tmp[k].ch = ' ';
        tmp[k].background = N;
        tmp[k].foreground = N;
        k++;
      }
    }
  }

  if(Limit_D(tmp,4)==0 && Limit_R(tmp,4)==0 &&          \
     Limit_L(tmp,4)==0 && MIN_X(tmp,4)>left &&          \
     MAX_X(tmp,4)<right && MAX_Y(tmp,4)<down &&         \
     MIN_Y(tmp,4)>up){

    for(i=0;i<4;i++)
      __rec[i]=tmp[i];

    for(i=0;i<4;i++)
      for(j=0;j<4;j++)
        __rec_tmp[i][j]=tmp_m[i][j];
  }

  for(i=0;i<tmp_k;i++)
    matrix[(__rec[i].x-4)/2][__rec[i].y-3]=1;

  for(i=0;i<tmp_k;i++)
    color[(__rec[i].x-4)/2][__rec[i].y-3]=N;

}

void CALL_GATE(int sig){

  int i=0;

  if((Limit_D(__rec,4)==0)&&(MAX_Y(__rec,tmp_k)<22)){
    for(i=0;i<tmp_k;i++)
      matrix[(__rec[i].x-4)/2][__rec[i].y-3]=0;
    for(i=0;i<tmp_k;i++)
      color[(__rec[i].x-4)/2][__rec[i].y-3]=WHITE;
    for(i=0;i<tmp_k;i++)
      __rec[i].y++;
    for(i=0;i<tmp_k;i++)
      matrix[(__rec[i].x-4)/2][__rec[i].y-3]=1;
    for(i=0;i<tmp_k;i++)
      color[(__rec[i].x-4)/2][__rec[i].y-3]=N;
    y++;
    ___draw_bg();

  }else if(GameOver()==0){

    Delete();
    N=random()%7;

    switch(N){
    case 0:
      ___draw_square(A);
      break;
    case 1:
      ___draw_square(B);
      break;
    case 2:
      ___draw_square(C);
      break;
    case 3:
      ___draw_square(D);
      break;
    case 4:
      ___draw_square(E);
      break;
    case 5:
      ___draw_square(F);
      break;
    case 6:
      ___draw_square(G);
      break;
    default:
      break;
    }
    if(GameOver()==0&&top==0){
      ___draw_bg();
    }
  }
}

void Init(void){

  int i=0;
  int j=0;
  int ret;

  for(i=0;i<10;i++)
    for(j=0;j<20;j++)
      matrix[i][j]=0;
  for(i=0;i<10;i++)
    for(j=0;j<20;j++)
      color[i][j]=WHITE;

  ret = get_winsz(&w_row, &w_col);
  if(ret!=0){

    fprintf(stderr,"ERROR\n");
    exit(1);
  }

  clear();
  bg.x = 1;
  bg.y = 1;
  bg.w = w_col;
  bg.h = w_row;
  bg.ch = ' ';
  bg.background = WHITE;
  bg.foreground = WHITE;
  draw_rec(&bg);

  N=4;
  ___draw_square(E);
  ___draw_frame(2,2);

  for(i=0;i<tmp_k;i++)
    draw_rec(&__rec[i]);

  return;
}

void Response(void){

  int out=0;
  int ret=0;

  int i=0;

  while (out != 1) {
    ret = get_input(UP | DOWN | LEFT | RIGHT | ESC);
    if (ret == -1) {
      printf("get input error!\n");
      break;
    }

    switch (ret) {
    case LEFT:
      if (MIN_X(__rec,tmp_k) > left && Limit_L(__rec,4)==0) {
        for(i=0;i<tmp_k;i++)
          color[(__rec[i].x-4)/2][__rec[i].y-3]=WHITE;
        for(i=0;i<tmp_k;i++)
          matrix[(__rec[i].x-4)/2][__rec[i].y-3]=0;
        for(i=0;i<tmp_k;i++)
          __rec[i].x -= 2;
        for(i=0;i<tmp_k;i++)
          color[(__rec[i].x-4)/2][__rec[i].y-3]=N;
        for(i=0;i<tmp_k;i++)
          matrix[(__rec[i].x-4)/2][__rec[i].y-3]=1;
        x--;
      }
      break;
    case DOWN:
      if (MAX_Y(__rec,tmp_k) + __rec[0].h < down && Limit_D(__rec,4)==0){
        for(i=0;i<tmp_k;i++)
          color[(__rec[i].x-4)/2][__rec[i].y-3]=WHITE;
        for(i=0;i<tmp_k;i++)
          matrix[(__rec[i].x-4)/2][__rec[i].y-3]=0;
        for(i=0;i<tmp_k;i++)
          __rec[i].y += 1;
        for(i=0;i<tmp_k;i++)
          color[(__rec[i].x-4)/2][__rec[i].y-3]=N;
        for(i=0;i<tmp_k;i++)
          matrix[(__rec[i].x-4)/2][__rec[i].y-3]=1;
        y++;
      }
      break;
    case UP:
      Transform();
      break;
    case RIGHT:
      if (MAX_X(__rec,tmp_k) + __rec[0].w <= right && Limit_R(__rec,4)==0){
        for(i=0;i<tmp_k;i++)
          color[(__rec[i].x-4)/2][__rec[i].y-3]=WHITE;
        for(i=0;i<tmp_k;i++)
          matrix[(__rec[i].x-4)/2][__rec[i].y-3]=0;
        for(i=0;i<tmp_k;i++)
          __rec[i].x += 2;
        for(i=0;i<tmp_k;i++)
          color[(__rec[i].x-4)/2][__rec[i].y-3]=N;
        for(i=0;i<tmp_k;i++)
          matrix[(__rec[i].x-4)/2][__rec[i].y-3]=1;
        x++;
      }
      break;
    case ESC:
      out = 1;
      break;
    default:
      break;
    }
    ___draw_bg();
  }

  return;
}

int main(void){


  Init();

  stty();
  start_iaction(SEC, USEC, CALL_GATE);

  Response();

  stop_iaction();
  rtty();
  move_curs(1, 1);
  clear();

  return 0;
}



编译输入 gcc TETRIS.c SCR.c -o TETRIS

这程序是终端下运行的 写这程序时 还不会QT
label_3162073
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java俄罗斯方块，老程序员花了一个周末，连接中学年代！
编程界明世隐的博客
06-08 45万+
引言： 俄罗斯方块，相信很多80、90后的小伙伴都玩过，也是当年非常火的游戏，当年读中学的时候，有一个同学有这个游戏机，大家都很喜欢玩，这个游戏给当时的我们带来了很多欢乐，时光飞逝，感慨颇多！ 人终归是要长大的，回忆再美好，日子也一去不复返了，以前我们只会玩游戏，心里想自己能做一个出来多牛逼啊，长大后，成为程序员的我们有能力自己写游戏玩，我想这就是成长吧！ 玩过这个游戏机的小伙伴看到这个图，应该对这个机器多少有些感情，毕竟带给了我们很多的欢乐！ 这次利用周末的时间，去写了一个俄罗斯方块Java版本，感觉碰
前端技术搭建俄罗斯方块（内含源码）
官方推荐
06-05 2万+
通过前端基础HTML、CSS、JS来搭建一个俄罗斯方块小游戏，内附源码直接拷贝即可运行！
arduino/Mixly RGB全彩点阵
moshanghuaw的博客
01-09 1141
一、显示图片 代码 #include <PxMatrix.h> #include <TetrisMatrixDraw.h> #include <ezTime.h> // ----- Wiring ------- #define P_LAT 22 #define P_A 19 #define P_B 23 #define P_C 18 #define P_D 5 #define P_E 15 //#define P_OE 26 //TinyPICO //#define
**Visual Studio 2019, Win10,matrix.h和mex.h找不到，编译出错**
qq_43169909的博客
12-02 1478
Visual Studio 2019, Win10,matrix.h和mex.h找不到，编译出错 这两个头文件是matlab中的，可以通过添加外部依赖项的方法将matlab中的头文件的文件路径添加进来（原答案的链接在文末）。 具体操作： 项目—属性—C/C+±–常规----附加包含目录（这里输入matlab的路径） 例如：D:\MATLAB2019b\extern\include 这个文件夹中包含了两个头文件，该问题得以解决 原答案链接: http://bbs.csdn.net/topics/3907609
俄罗斯方块（C语言实现）
热门推荐
2021dragon的博客
08-14 17万+
文章目录游戏说明游戏效果展示游戏代码游戏代码详解游戏框架构建隐藏光标光标跳转初始化界面初始化方块信息颜色设置画出方块空格覆盖合法性判断游戏主体逻辑函数判断得分与结束主函数 游戏说明 俄罗斯方块相信大家都知道，这里就不再介绍什么游戏背景了，我这里对本代码实现的俄罗斯方块作一些说明： 按方向键的左右键可实现方块的左右移动。 按方向键的下键可实现方块的加速下落。 按空格键可实现方块的顺时针旋转。 按Esc键可退出游戏。 按S键可暂停游戏，暂停游戏后按任意键继续游戏。 按R键可重新开始游戏。 除此之外，本游戏还
C语言实现俄罗斯方块
qq_54169998的博客
02-13 6万+
使用C语言完成俄罗斯方块。《俄罗斯方块》的基本规则是移动、旋转和摆放游戏自动输出的各种方块，使之排列成完整的一行或多行并且消除得分。由小方块组成的不同形状的板块陆续从屏幕上方落下来，玩家通过调整板块的位置和方向，使它们在屏幕底部拼出完整的一条或几条。这些完整的横条会随即消失，给新落下来的板块腾出空间，与此同时，玩家得到分数奖励。没有被消除掉的方块不断堆积起来，一旦堆到屏幕顶端，玩家便告输，游戏结束。顾名思义，俄罗斯方块自然是俄罗斯人发明的。
c语言——俄罗斯方块
zhoubancheng的博客
11-23 6178
（因为'L'型，在变换时容易与边界发生碰撞，若此时将方块位置记录在pos[60][30]的大数组中，导致跳出该循环，进行下一个方块判断，导致该方块悬浮在半空的BUG）1)用大数组pos[60][30],从下往上判断是否满行，如果满行，则将将该行以上全部下移一格，这样就达到消行的目的。《俄罗斯方块》的基本规则是移动、旋转和摆放游戏自动输出的各种方块，使之排列成完整的一行或多行并且消除得分。俄罗斯方块是久负盛名的游戏，它也和贪吃蛇，扫雷等游戏位列经典游戏的⾏列。搭配在一起后，获得了巨大的成功。
python制作俄罗斯方块
jakelihua
02-05 1万+
python制作俄罗斯方块
Unity 俄罗斯方块
最新发布
m0_61789764的博客
04-23 418
俄罗斯有许多受欢迎的小游戏，其中一些包括：1. Tetris（俄罗斯方块）：这是一款经典的俄罗斯益智游戏，玩家需要旋转和移动不同形状的方块，以填满水平线并清除它们。2. Doodle Jump（涂鸦跳跃）：这是一款简单而有趣的游戏，玩家控制一个涂鸦飞行员，通过跳跃到不同平台上，尽可能高地跳跃。3. Cut the Rope（剪绳子）：这是一款物理学谜题游戏，玩家需要通过剪断绳子，使糖果顺利送到小怪兽的嘴里。
俄罗斯方块C++源代码
09-18
《俄罗斯方块C++源代码解析》 在编程领域，经典游戏俄罗斯方块是一个极好的学习案例，它涉及到了基础的图形界面设计、事件处理、数据结构和算法等多个知识点。本篇文章将对“俄罗斯方块C++源代码”进行深入剖析，...
LABVIEW俄罗斯方块
12-02
《 LABVIEW俄罗斯方块：深入理解与学习指南》 LabVIEW，全称为Laboratory Virtual Instrument Engineering Workbench（实验室虚拟仪器工程工作台），是一款由美国国家仪器（National Instruments, NI）公司开发的...
verilog设计俄罗斯方块_俄罗斯方块_VHDL-FPGA-Verilog_
10-02
《基于FPGA的Verilog实现俄罗斯方块游戏详解》 在现代数字系统设计中，FPGA（Field-Programmable Gate Array）因其可重构性和高速处理能力被广泛应用。结合高级硬件描述语言如Verilog，我们可以实现复杂的功能，...
python基于pygame的俄罗斯方块小游戏源码.zip
06-02
python基于pygame的俄罗斯方块小游戏源码。python基于pygame的俄罗斯方块小游戏源码。python基于pygame的俄罗斯方块小游戏源码。python基于pygame的俄罗斯方块小游戏源码。python基于pygame的俄罗斯方块小游戏源码。...
俄罗斯方块游戏源码-Java
03-05
【经典再现，Java俄罗斯方块游戏源码】 踏上编码之旅，揭开经典游戏的神秘面纱！我们的Java版俄罗斯方块源码项目是您深入理解游戏开发、算法设计和面向对象编程的完美起点！ 核心特色与优势 跨平台兼容：基于强大...
Unity 【Content Size Fitter】- 聊天气泡自动适配Text文本框大小
当代野生程序猿
02-25 5731
通常在展示人物对话的时候文本的长度是不定的，因此会需要动态的调整对话内容文本框的背景图片的大小，这里以如下这种气泡框的对话为例： 实现该需求涉及到的内容包括Content Size Fitter组件的使用、2D Sprite工具包的使用。 Content Size Fitter组件用于Text文本框，如图所示，我们将Horzontal Fit设为Preferred Size，当我们调整Text文本框中的内容时，其大小会自动进行调整。 注意Rect Transform中Pivot轴心点的设置
新唐NUC972 Linux（一）：USB烧写linux出厂镜像
小破孩的博客
02-20 3333
USB烧写出厂镜像 文章目录USB烧写出厂镜像前言一、硬件连接二、安装驱动三、烧写linux程序四、运行程序 前言 今天开始进军linux，学了那么久单片机，也摸得七七八八，至少点个灯还是会的。本人之所以买酷客的linux开发板主要是便宜，资料也算齐全，虽然没有原子那么好，不过也够了，找那么多借口，其实就是qiong。今天先从USB烧录官方提供的linux相关程序到芯片开始吧。 一、硬件连接 1、连接电源线 2、RS232转USB，需要安装CH340驱动，用于在电脑串口超级终端中查看调试信息。 3、U
WeChall CTF Writeup（一）
weixin_43211186的博客
02-25 1449
以下题目标题组成： [Score] [Title] [Author] 文章目录0x01 1 Training: Get Sourced by Gizmore0x02 1 Training: Stegano I by Gizmore0x03 1 Training: Crypto - Caesar I by Gizmore0x04 1 Training: WWW-Robots by Gizmore0x05 1 Training: ASCII by Gizmore 0x01 1 Training: Get Sou
C语言每日一练——第126天：佩奇借书问题
Edison's 小宇宙
02-25 2万+
史上最强借书方案问题讲解（代码详解+思路分析+动图演示+特性总结）
VB编程实现俄罗斯方块游戏
"VB俄罗斯方块代码是一款使用Visual Basic (VB) 编程语言实现的经典游戏——俄罗斯方块的程序。这个资源适合学习VB编程和游戏开发的初学者参考，通过阅读和理解代码，可以增进对VB语法和游戏逻辑的理解。" 在VB中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值