分享一个蛋疼的俄罗斯方块小游戏

最新推荐文章于 2020-11-23 14:51:38 发布
最新推荐文章于 2020-11-23 14:51:38 发布
阅读量422 收藏
点赞数
分类专栏： c linux
linux 同时被 2 个专栏收录
95 篇文章 0 订阅
订阅专栏
c
57 篇文章 0 订阅
订阅专栏

分享一个蛋疼的俄罗斯方块小游戏

  • 空间

转载请注明出处。http://www.cnblogs.com/dave_cn/ 

我在Ubuntu 10.04下测试过，可以正常运行。不过界面让人蛋疼。

代码用到了NCURSES库。编译的时候链一下ncurses库就可以了，如：
cc -Wall -O2 -o c01 file.c -lncurses

sudo apt-get install libncurses5-dev  ubuntu安装ncurses库

/***************************************

 *

 * TETRIS

 *

 * author: dave

 * date  : 2010/07/28

 *

 ***************************************/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <sys/select.h>

#include <sys/time.h>

#include <sys/types.h>

#include <unistd.h>

#include <ncurses.h>

 

#define TETRADS_LEN   4

#define GAMEWIN_YLEN  20

#define GAMEWIN_XLEN  10

#define GAMEWIN_Y     1

#define GAMEWIN_X     2

#define INFOWIN_YLEN  10

#define INFOWIN_XLEN  10

#define INFOWIN_Y     GAMEWIN_Y

#define INFOWIN_X     (GAMEWIN_X + GAMEWIN_XLEN*2 + 5)

#define PIC_BLOCK     '#'

#define PIC_NULL      ' '

 

#define _X(x)         ((x)*2)

 

#define BASEWIN \

    WINDOW *win; \

    void   (*init)(); \

    void   (*show)();

 

#define EXCHANGE_XY(_pos) \

    do { \

        (_pos).x = (_pos).y + (_pos).x; \

        (_pos).y = (_pos).x - (_pos).y; \

        (_pos).x -= (_pos).y; \

    } while (0)

 

#define EXCHANGE_2Y(_pos) \

        (_pos).y = 2 - (_pos).y

 

#define COPY_TETRADS(_dest, _src) \

    memcpy(&(_dest), &(_src), sizeof(Tetrads))

 

#define TETRISNEW(_p, _t) \

    do { \

        (_p) = (_t*)malloc(sizeof(_t)); \

        (_p)->init = init##_t; \

        (_p)->show = show##_t; \

    } while (0)

 

#define TETRISDEL(_p) \

    do { \

        delwin(_p->win); \

        free(_p); \

    } while (0)

 

/* 俄罗斯方块的7种方块(Tetromino) */

typedef enum {

    TETRADS_S = 0,

    TETRADS_Z,

    TETRADS_L,

    TETRADS_J,

    TETRADS_O,

    TETRADS_T,

    TETRADS_I,

     

    TETRADS_MAX

} ETetrads;

 

typedef enum {

    DIR_UP = 0,

    DIR_DOWN,

    DIR_LEFT,

    DIR_RIGHT,

     

    DIR_MAX

} EDirction;

 

typedef enum {

    TETRIS_STATE_NEW,

    TETRIS_STATE_MOVE,

    TETRIS_STATE_STOP,

     

    TETRIS_STATE_MAX,

} ETetrisState;

 

typedef struct {

    int y;

    int x;

} Point;

 

typedef struct {

    ETetrads type;

    Point    blocks[TETRADS_LEN];

} Tetrads;

 

/*** BEGIN : 界面显示 ***/ /* 将界面显示与数据处理分离 */

typedef struct _BaseWin {

    /**

     * WINDOW *win;

     * void   (*init)();

     * void   (*show)();

     */

    BASEWIN

} BaseWin;

 

typedef struct _GameWin {

    /**

     * WINDOW *win;

     * void   (*init)();

     * void   (*show)();

     */

    BASEWIN

 

    char    background[GAMEWIN_YLEN][GAMEWIN_XLEN];

    char    matrix[GAMEWIN_YLEN][GAMEWIN_XLEN];

    int     level;

    Point   pos;

    Tetrads curTetrads;

} GameWin;

 

typedef struct _InfoWin {

    /**

     * WINDOW *win;

     * void   (*init)();

     * void   (*show)();

     */

    BASEWIN

 

    int     score;

    int     level;

    Tetrads nextTetrads;

} InfoWin;

 

void tetrisPrint(WINDOW *win, Point pos, Point block, char chr);

 

void initGameWin(GameWin* _self)

{

    _self->win = newwin(GAMEWIN_YLEN + 2, _X(GAMEWIN_XLEN) + 1, GAMEWIN_Y, GAMEWIN_X);

    box(_self->win, 0, 0);

    mvwprintw(_self->win, 0, (_X(GAMEWIN_XLEN) + 2)/2 - 3, "TETRIS");

    wrefresh(_self->win);

 

    memset(_self->background, PIC_NULL, GAMEWIN_YLEN * GAMEWIN_XLEN);

    memset(_self->matrix, PIC_NULL, GAMEWIN_YLEN * GAMEWIN_XLEN);

 

    _self->pos = (Point){1, GAMEWIN_XLEN/2};

    _self->level = 0;

}

 

void initInfoWin(InfoWin* _self)

{

    _self->win = newwin(INFOWIN_YLEN, _X(GAMEWIN_XLEN), INFOWIN_Y, INFOWIN_X);

    box(_self->win, 0, 0);

    mvwprintw(_self->win, 0, _X(GAMEWIN_XLEN)/2 - 2, "INFO");

    mvwprintw(_self->win, 7, 2, "SCORE: 0");

    mvwprintw(_self->win, 8, 2, "LEVEL: 0");

    wrefresh(_self->win);

 

    _self->score = 0;

    _self->level = 0;

}

 

void showGameWin(GameWin* _self)

{

    int y = 0;

    int x = 0;

 

    for (y = 0; y < GAMEWIN_YLEN; ++y)

        for (x = 0; x < GAMEWIN_XLEN; ++x)

            tetrisPrint(_self->win, (Point){0, 0}, (Point){y, x}, (_self->background)[y][x]);

 

    for (y = 0; y < GAMEWIN_YLEN; ++y)

        for (x = 0; x < GAMEWIN_XLEN; ++x)

            tetrisPrint(_self->win, (Point){0, 0}, (Point){y, x}, (_self->matrix)[y][x]);

 

    for (x = 0; x < TETRADS_LEN; ++x)

        tetrisPrint(_self->win, (Point){(_self->pos).y, (_self->pos).x}, (_self->curTetrads).blocks[x], PIC_BLOCK);

 

    wrefresh(_self->win);

}

 

void showInfoWin(InfoWin* _self)

{

    int i = 0;

     

    mvwprintw(_self->win, 2, _X(INFOWIN_XLEN/2 - 2), "        ");

    mvwprintw(_self->win, 3, _X(INFOWIN_XLEN/2 - 2), "        ");

    mvwprintw(_self->win, 4, _X(INFOWIN_XLEN/2 - 2), "        ");

    mvwprintw(_self->win, 5, _X(INFOWIN_XLEN/2 - 2), "        ");

    mvwprintw(_self->win, 6, _X(INFOWIN_XLEN/2 - 2), "        ");

 

    for (i = 0; i < TETRADS_LEN; ++i)

        tetrisPrint(_self->win, (Point){2, INFOWIN_XLEN/2 - 2}, _self->nextTetrads.blocks[i], PIC_BLOCK);

     

    mvwprintw(_self->win, INFOWIN_YLEN - 3, 2, "SCORE: %d", _self->score);

    mvwprintw(_self->win, INFOWIN_YLEN - 2, 2, "LEVEL: %d", _self->level);

 

    wrefresh(_self->win);

}

/*** END   : 界面显示 ***/

 

/*** 函数声明 ***/

void newTetrads(Tetrads *tetrads);

void initTetrads(Tetrads *tetrads);

void spinTetrads(Tetrads *tetrads);

int  runTetris(GameWin *gwin);

int  checkBorder(GameWin *gwin);

int  checkStop(GameWin *gwin);

int  checkOver(GameWin *gwin);

int  checkClean(GameWin *gwin);

void refreshMatrix(GameWin *gwin);

int  genRandom(int max);

 

int main()

{

    /* init ncurses screen */

    initscr();

    raw();

    noecho();

    keypad(stdscr, TRUE);

    curs_set(0);

    refresh();

 

    /* 初始化界面 */

    GameWin *gwin;

    InfoWin *iwin;

 

    TETRISNEW(gwin, GameWin);

    TETRISNEW(iwin, InfoWin);

     

    gwin->init(gwin);

    iwin->init(iwin);

 

    /* Tetris的处理使用简单的状态机实现 */

    int f_end = 0;

    int state = TETRIS_STATE_NEW;

 

    newTetrads(&(iwin->nextTetrads));

     

    while (!f_end) {

        switch (state) {

        case TETRIS_STATE_NEW:

            COPY_TETRADS(gwin->curTetrads, iwin->nextTetrads);

            gwin->pos = (Point){1, 4};

            newTetrads(&(iwin->nextTetrads));

 

            iwin->show(iwin);

             

            state = TETRIS_STATE_MOVE;

            break;

         

        case TETRIS_STATE_MOVE:

            gwin->show(gwin);

             

            switch (runTetris(gwin)) {

            case -1:

                goto END;

                break;

            case 0:

                break;

            case 1:

                state = TETRIS_STATE_STOP;

                break;

            default:

                break;

            }

             

            break;

         

        case TETRIS_STATE_STOP:

            refreshMatrix(gwin);

            iwin->score = checkClean(gwin);

            state = TETRIS_STATE_NEW;

            break;

         

        default :

            f_end = 1;

            break;

        }

    }

 

END:

    mvwprintw(gwin->win, GAMEWIN_YLEN/2 - 2, 5, "GAME OVER!!!");

    mvwprintw(gwin->win, GAMEWIN_YLEN/2,     4, "Press any key");

    mvwprintw(gwin->win, GAMEWIN_YLEN/2 + 1, 6, "to quit...");

    wrefresh(gwin->win);

     

    getch();

 

    TETRISDEL(iwin);

    TETRISDEL(gwin);

    endwin();

     

    return 0;

}

 

void tetrisPrint(WINDOW *win, Point pos, Point block, char chr)

{

    mvwaddch(win, pos.y + block.y + 1, (pos.x + block.x) * 2 + 1, chr);

}

 

void newTetrads(Tetrads *tetrads)

{

    tetrads->type = genRandom(TETRADS_MAX);

     

    initTetrads(tetrads);

 

     

    int spin = genRandom(DIR_MAX);

    int i = 0;

    for (; i <= spin; ++i) {

        spinTetrads(tetrads);

    }

}

 

void initTetrads(Tetrads *tetrads)

{

    switch (tetrads->type) {

    case TETRADS_S:

        tetrads->blocks[0] = (Point){2, 0};

        tetrads->blocks[1] = (Point){2, 1};

        tetrads->blocks[2] = (Point){1, 1};

        tetrads->blocks[3] = (Point){1, 2};

        break;

 

    case TETRADS_Z:

        tetrads->blocks[0] = (Point){1, 0};

        tetrads->blocks[1] = (Point){1, 1};

        tetrads->blocks[2] = (Point){2, 1};

        tetrads->blocks[3] = (Point){2, 2};

        break;

 

    case TETRADS_L:

        tetrads->blocks[0] = (Point){2, 0};

        tetrads->blocks[1] = (Point){2, 1};

        tetrads->blocks[2] = (Point){1, 1};

        tetrads->blocks[3] = (Point){0, 1};

        break;

 

    case TETRADS_J:

        tetrads->blocks[0] = (Point){0, 0};

        tetrads->blocks[1] = (Point){1, 0};

        tetrads->blocks[2] = (Point){1, 1};

        tetrads->blocks[3] = (Point){1, 2};

        break;

 

    case TETRADS_O:

        tetrads->blocks[0] = (Point){0, 0};

        tetrads->blocks[1] = (Point){0, 1};

        tetrads->blocks[2] = (Point){1, 0};

        tetrads->blocks[3] = (Point){1, 1};

        break;

 

    case TETRADS_T:

        tetrads->blocks[0] = (Point){0, 1};

        tetrads->blocks[1] = (Point){1, 0};

        tetrads->blocks[2] = (Point){1, 1};

        tetrads->blocks[3] = (Point){1, 2};

        break;

 

    case TETRADS_I:

        tetrads->blocks[0] = (Point){0, 1};

        tetrads->blocks[1] = (Point){1, 1};

        tetrads->blocks[2] = (Point){2, 1};

        tetrads->blocks[3] = (Point){3, 1};

        break;

 

    default:

        break;

    }

}

 

/**

 * 旋转Tetrads

 */

void spinTetrads(Tetrads *tetrads)

{

    int i = 0;

     

    switch (tetrads->type) {

    case TETRADS_O:

        break;

 

    case TETRADS_I:

        /* x,y互换 */

        for (i = 0; i < TETRADS_LEN; ++i)

            EXCHANGE_XY(tetrads->blocks[i]);

        break;

 

    default:

        for (i = 0; i < TETRADS_LEN; ++i)

            EXCHANGE_XY(tetrads->blocks[i]);

 

        for (i = 0; i < TETRADS_LEN; ++i)

            EXCHANGE_2Y(tetrads->blocks[i]);

 

        break;

    }

}

 

/**

 * Return:

 *   -1    game over

 *    0    continue

 *    1    stop

 */

int runTetris(GameWin *gwin)

{

    int ret = 0;

 

    fd_set fset;

     

    FD_ZERO(&fset);

    FD_SET(0, &fset);

     

    struct timeval timeout;

    timeout.tv_sec  = 0;

    timeout.tv_usec = 500000 - 10000 * gwin->level;

     

    int fd = -1;

    if ((fd = select(1, &fset, NULL, NULL, &timeout)) <= 0) {

        ++((gwin->pos).y);

        while (checkStop(gwin) != 0) {

            --((gwin->pos).y);

            ret = 1;

        }

 

        if (ret == 1) {

            if (checkOver(gwin))

                return -1;

 

            return 1;

        }

 

        return 0;

    }

 

    Tetrads tmptetrads;

    char ch;

    int  n = 0;

    switch (ch = getch()) {

    case 'w':

        COPY_TETRADS(tmptetrads, gwin->curTetrads);

        spinTetrads(&gwin->curTetrads);

 

        while ((n = checkBorder(gwin)) != 0)

            (gwin->pos).x += n;

 

        while (checkStop(gwin) != 0) {

            --((gwin->pos).y);

            ret = 1;

        }

 

        return ret;

 

    case 's':

        ++((gwin->pos).y);

        while (checkStop(gwin) != 0) {

            --((gwin->pos).y);

            ret = 1;

        }

 

        if (ret == 1) {

            if (checkOver(gwin))

                return -1;

 

            return 1;

        }

 

        return 0;

 

    case 'a':

        --((gwin->pos).x);

        while ((n = checkBorder(gwin)) != 0)

            (gwin->pos).x += n;

             

        while (checkStop(gwin) != 0) {

            ++((gwin->pos).x);

            ret = 1;

        }

         

        break;

 

    case 'd':

        ++((gwin->pos).x);

        while ((n = checkBorder(gwin)) != 0)

            (gwin->pos).x += n;

         

        while (checkStop(gwin) != 0) {

            --((gwin->pos).x);

            ret = 1;

        }

         

        break;

 

    default:

        break;

    }

 

    return 0;

}

 

/**

 * 检查是否达到边线

 */

int checkBorder(GameWin *gwin)

{

    int i = 0;

    int n = 0;

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

        if ((n = ((gwin->pos).x + (gwin->curTetrads).blocks[i].x)) < 0)

            return -n;

 

        if ((n = ((gwin->pos).x + (gwin->curTetrads).blocks[i].x)) > GAMEWIN_XLEN - 1)

            return GAMEWIN_XLEN - 1 - n;

    }

 

    return 0;

}

 

/**

 * 检查是否停止

 */

int checkStop(GameWin *gwin)

{

    int i = 0;

    for (i = 0; i < TETRADS_LEN; ++i)

        if (gwin->matrix[(gwin->pos).y + (gwin->curTetrads).blocks[i].y][(gwin->pos).x + (gwin->curTetrads).blocks[i].x] == PIC_BLOCK

            || ((gwin->pos).y + (gwin->curTetrads).blocks[i].y) >= GAMEWIN_YLEN)

            return 1;

 

    return 0;

}

 

/**

 * 检查是否游戏结束

 */

int checkOver(GameWin *gwin)

{

    int i = 0;

    for (i = 0; i < TETRADS_LEN; ++i)

        if ((gwin->pos).y <= 0)

            return 1;

 

    return 0;

}

 

/**

 * 检查是否需要清楚一行

 */

int checkClean(GameWin *gwin)

{

    char bline[GAMEWIN_XLEN];

    memset(bline, PIC_BLOCK, GAMEWIN_XLEN);

     

    int i     = 0;

    int num   = 0;

    int score = 0;

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

        num = (gwin->pos).y + (gwin->curTetrads).blocks[i].y;

        if (strncmp(gwin->matrix[num], bline, GAMEWIN_XLEN) == 0) {

            score += 10;

            for (; num > 0; --num) 

                memcpy(gwin->matrix[num], gwin->matrix[num-1], GAMEWIN_XLEN);

        }

    }

     

    return score;

}

 

void refreshMatrix(GameWin *gwin)

{

    int i = 0;

    for (i = 0; i < TETRADS_LEN; ++i)

        gwin->matrix[(gwin->pos).y + (gwin->curTetrads).blocks[i].y][(gwin->pos).x + (gwin->curTetrads).blocks[i].x] = PIC_BLOCK;

}

 

/**

 * 返回0~max-1的一个随机数

 */

int genRandom(int max)

{

    srandom((int)time(NULL));

    return (random() % max);

}


xp5xp6
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
js实现俄罗斯方块小游戏分享
10-26
主要介绍了js实现俄罗斯方块小游戏分享,,需要的朋友可以参考下
c/c++ 实现俄罗斯方块小游戏（附全部源码）
热门推荐
q841447739的博客
08-11 2万+
使用easyX库，基于c/c++，实现俄罗斯方块小游戏。（附全部源码）
C语言写的俄罗斯方块
Freewind的专栏
06-28 1936
/************************************名 称：俄罗斯方块 Tetris作 者：freewind版 本：v2.0时 间：2006-08Email：freewind22@163.com*************************************///头文件 tetris.h /************************** Const *******
Qt-俄罗斯方块
Zetaa的博客
12-22 1万+
声明： 仅个人小记   1.前言   2.效果展示   3.主要代码   4.开发日志   5.小结1.前言整个程序的完成花了我不少时间， 有许多知识细节不够清楚，边学边做，断断续续完成的。之前有用C++
迟到的儿童节礼物——小游戏三件套：扫雷，俄罗斯方块，数独
andangdi6153的博客
06-08 200
人的事情要么是饿出来了要么就是吃饱了撑出来的 其实写完刚好是在儿童节前两天，本打算作为儿童节礼物送给大家，结果新账号要3天才能发文章到主页，于是拖到了现在。。。事情是这样开始的：有一天，闲得蛋疼，看见同事在玩扫雷，然后就想着自己做一个，于是花了三天时间写了一个自己的扫雷。。。写完扫雷感觉不过瘾，于是接着又写了俄罗斯方块，一晃又是三天。。。写完俄罗斯方块之后，觉得事不过三，再来一个，然后...
python游戏开发框架_用Python和Pygame写游戏-从入门到精通（实战二：恶搞俄罗斯方块1）...
weixin_39940688的博客
11-23 85
游戏是为了什么而存在的？Bingo，是为了娱乐~ 在这个最高主题之前，技术啥的什么都无所谓！前一段时间，有位姓刘的网友用Pygame写了个俄罗斯方块，在用py2exe打包的时候遇到一些问题，和我交流了一下。有兴趣的可以在这里下载，除了代码，打包后的exe文件也一并提供了。受他启发，这次我们就以俄罗斯方块为主题做一个游戏吧，但是，咱不能走寻常路啊，得把它整的非常有趣才行。记得曾经在网上看到一个搞笑俄...
俄罗斯方块Windows版本的实现！
weixin_33896069的博客
09-21 65
2019独角兽企业重金招聘Python工程师标准>>> ...
用Python和Pygame写游戏-从入门到精通（实战二：恶搞俄罗斯方块1）
专注IT
08-14 1361
用Python和Pygame写游戏-从入门到精通（实战二：恶搞俄罗斯方块1） 游戏是为了什么而存在的？Bingo，是为了娱乐~ 在这个最高主题之前，技术啥的什么都无所谓！ 前一段时间，有位姓刘的网友用Pygame写了个俄罗斯方块，在用py2exe打包的时候遇到一些问题，和我交流了一下。有兴趣的可以在这里下载，除了代码，打包后的exe文件也一并提供了。 受他启发，这次我们就以俄罗斯方块为主
Swift 实现俄罗斯方块详细思路解析（附完整项目）
weixin_30664539的博客
05-12 210
一：写在开发前 俄罗斯方块，是一款我们小时候都玩过的小游戏，我自己也是看着书上的思路，学着用 Swift 来写这个小游戏，在写这个游戏的过程中，除了一些位置的计算，数据模型和理解 Swift 语言之外，最好知道UIKIt框架中的Quartz2D这个知识点。是我在简书上面找的，是关于Quartz2D这个知识点的，看它我觉得也就够学习。经过这两天的整理，充分觉得在写这些之前，一定要理...
我的抗争：一个中年编外程序员的挣扎
neweast0183的博客
04-20 438
    前言：我也不知道为什么要这样倔强。可能我拼命努力的结果就是可以达到你们随便做做的程度。但内心的热爱使我仍然执着于眼前的每一行代码。对于编程的爱或者说是瘾让我疯狂。曾经经常出差，工作是不需要电脑的但我仍然背着笔记本，夜晚一个人挑灯奋战。为了一个编译失败，为了一个功能一不小心就天亮了。出差没人管，我能尽情的挥霍夜晚的时光。我知道我离程序员很远。但我从来没有停下脚步。    从我最后一次立下要写...
基于C++的俄罗斯方块小游戏设计源码
04-05
本资源提供了一套基于C++的俄罗斯方块小游戏的设计源码，包含25个文件，其中包括10个头文件，7个C++源代码文件...这些文件详细展示了如何使用C++构建一个俄罗斯方块小游戏，非常适合用于个人学习和参考C++项目的开发。
俄罗斯方块-微信小游戏-项目源码
05-11
这是一个微信小游戏项目源码，是经典怀旧的俄罗斯方块游戏，适合新手入门参考学习，下面还有↓ 使用微信开发工具选择小游戏导入即可打开，可编译运行，请放心下载， 相关指导教程请看作者发表的以下文章： ① 微信...
基于STM32设计的俄罗斯方块小游戏.zip
08-04
这是基于STM32设计的俄罗斯方块小游戏的全部源码。 兼容正点原子开发板，下载即可运行。 代码采用寄存器风格编写，注释齐全。 俄罗斯方块游戏代码全部自己通过画点绘制出来的，没有使用框架，刷屏运行非常流畅。 ...
ASP外观专利图像检索平台(源代码+论文).rar
07-21
ASP外观专利图像检索平台(源代码+论文)
C++课程设计：电煤气管理系统【源码+文档】
07-21
C++课程设计：电煤气管理系统【源码+文档】 本程序是一个水电气管理信息系统，能够对高校的水电气费用进行管理, 包括了成员的基本信息，如学号、编号、姓名、成员水电气的用量等。程序的用途包括缴纳水电气费、查询一个同学水电气费用量、查看所有同学的缴费情况、增加学生信息、删除学生信息、退出系统等。在设计时也考虑到学生和教师在用水电气时的不同，学生可以免费使用一定额度的水电气，超过这个额度的以后必须付费，且付费部分水电气费的价格要高于教工的收费标准，该措施的实行是为了鼓励同学们节约资源，以免造成不必要的资源浪费。该软件主要是为了学校的管理人员提供便捷，以更快的完成水电气费用的收缴。该软件本着简洁明了，实用稳定为一体进行设计。 系统将实现以下功能： （1）实现对用户信息的录入； （2）实现水电煤气数据的录入； （3）实现计算并查询用户应缴费用，查询未缴纳费用的名单； （4）实现对人员的删除和添加；
ASP+ACCESS网上动态同学录系统（源代码+论文+系统说明+答辩PPT）.rar
07-21
ASP+ACCESS网上动态同学录系统（源代码+论文+系统说明+答辩PPT）
avaloniassification-mas笔记
最新发布
07-21
avalonia
ASP+ACCESS学生排课管理系统毕业设计(源代码+论文).rar
07-21
ASP+ACCESS学生排课管理系统毕业设计(源代码+论文)
Python写一个俄罗斯方块小游戏
04-04
抱歉，作为AI语言模型，我不能编写代码。...3. Python俄罗斯方块游戏教程：这是一个YouTube视频教程，它演示了如何使用Python编写俄罗斯方块游戏。 希望这些资源能帮助你开始编写俄罗斯方块游戏！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值