俄罗斯方块

最新推荐文章于 2022-10-13 09:01:14 发布
最新推荐文章于 2022-10-13 09:01:14 发布
阅读量353 收藏
点赞数
分类专栏： c语言小游戏 文章标签： 俄罗斯方块 c语言小游戏 linux小游戏 ncurses
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixiaoyiri/article/details/50273541
版权

代码

/*
 * 玩法：w变形，asd方向，空格暂停，q退出
 */
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <sys/time.h>
#include <curses.h>

#define ROW_NUM             11
#define COLUMN_NUM          10
#define BOUNDARY_LEFT       ( START_COLUMN + COL(0) )
#define BOUNDARY_RIGHT      ( START_COLUMN + COL(COLUMN_NUM-1) )
#define BOUNDARY_BOTTOM     ( START_ROW + ROW(ROW_NUM-1) )

#define DIR_LEFT            1
#define DIR_RIGHT           2
#define WEIYI_ADD           1
#define WEIYI_MINUS         2

#define COL(x)              ((x) * DIST + 1)
#define ROW(y)              ((y) * DIST + 1)

#define SQUARE_TYPE_NUM     6
#define SQUARE_NO_NUM       4
#define POINT_PER_SQUARE    4
#define ROTATE_NUM          4
#define PER_POINT_DISTANCE  2
#define DIST                PER_POINT_DISTANCE
#define ROTATE_POINT        1

#define START_ROW           0
#define START_COLUMN        10
#define X0                  ( START_COLUMN + COL(COLUMN_NUM/2-1) )
#define Y0                  ( START_ROW + ROW(0) )
#define Y1                  ( START_ROW + ROW(1) )
#define Y2                  ( START_ROW + ROW(2) )
#define START_NEXT_X        (BOUNDARY_RIGHT + 1 + 5)
#define START_NEXT_Y        (START_ROW + 0)

#define CHAR_SQUARE         'O'
#define CHAR_BLANK          ' '
#define CHAR_NEXT_1         "---------"
#define CHAR_NEXT_2         "| | | | |"
#define CHAR_ROW_1          "---------------------"
#define CHAR_ROW_2          "| | | | | | | | | | |"

void speed_up();
void key_ctl();
int is_horizon(int flag, int idx);
int out_horizon(int dir_horizon);
void move_horizon(int flag);
int is_recovery(int idx);
int is_bottom(int idx);
void remove_row(int row);
int out_bottom();
int is_full_row(int row);
void update_background();
void move_down(int sig);
void weiyi_compute(int compute);
int out_change();
void change();
void generate_next();
void draw_next();
void draw_map();
void draw_square();
void clear_square();
void next_to_current();
void new_square();
int is_current_fail();
void init_square();
void init();
void game_over();
int set_ticker(int n_msec);

struct point {
    int x, y;
};

struct square {
    int type;
    int no;
    struct point p[POINT_PER_SQUARE];
};

struct point init_point[SQUARE_TYPE_NUM][ROTATE_NUM] = {
    {X0,Y0,     X0,Y0,      X0,Y0,      X0,Y0},
    {X0,Y0,     X0,Y1,      X0,Y0,      X0,Y2},
    {X0,Y0,     X0,Y1,      X0,Y1,      X0,Y1},
    {X0,Y0,     X0,Y1,      X0,Y1,      X0,Y1},
    {X0,Y1,     X0,Y2,      X0,Y0,      X0,Y0},
    {X0,Y1,     X0,Y0,      X0,Y0,      X0,Y2}
};

struct point weiyi[SQUARE_TYPE_NUM][ROTATE_NUM][POINT_PER_SQUARE] = 
{
    {
        {-2,0,      0,0,        -2,2,       0,2},
        {-2,0,      0,0,        -2,2,       0,2},
        {-2,0,      0,0,        -2,2,       0,2},
        {-2,0,      0,0,        -2,2,       0,2},
    },
    {
        {-2,0,      0,0,        2,0,        4,0},
        {0,-2,      0,0,        0,2,        0,4},
        {2,0,       0,0,        -2,0,       -4,0},
        {0,2,       0,0,        0,-2,       0,-4}
    },
    {
        {-2,0,      0,0,        0,2,        2,2},
        {0,-2,      0,0,        -2,0,       -2,2},
        {2,0,       0,0,        0,-2,       -2,-2},
        {0,2,       0,0,        2,0,        2,-2}
    },
    {
        {2,0,       0,0,        0,2,        -2,2},
        {0,2,       0,0,        -2,0,       -2,-2},
        {-2,0,      0,0,        0,-2,       2,-2},
        {0,-2,      0,0,        2,0,        2,2}
    },
    {
        {0,-2,      0,0,        -2,0,       -4,0},
        {2,0,       0,0,        0,-2,       0,-4},
        {0,2,       0,0,        2,0,        4,0},
        {-2,0,      0,0,        0,2,        0,4}
    },
    {
        {0,-2,      0,0,        2,0,        4,0},
        {2,0,       0,0,        0,2,        0,4},
        {0,2,       0,0,        -2,0,       -4,0},
        {-2,0,      0,0,        0,-2,       0,-4}
    }
};

struct square current, next;
int on_speed = 0;

int main()
{
    init();
    while(1) {
        key_ctl();
    }
    return 0;
}

void speed_up()
{
    on_speed = 1;
    set_ticker(50);
    while(on_speed);
    set_ticker(500);
}

void key_ctl()
{
    int ch = getch();
    switch (ch) {
        case 'W':
        case 'w':
            change();
            break;
        case 'A':
        case 'a':
            move_horizon(DIR_LEFT);
            break;
        case 'D':
        case 'd':
            move_horizon(DIR_RIGHT);
            break;
        case 'S':
        case 's':
            speed_up();
            break;
        case ' ':
            set_ticker(0);
            while( (ch = getch()) != ' ');
            set_ticker(500);
            break;
        case 'q':
        case 'Q':
            game_over();
            break;
        default:
            break;
    }
}


int is_horizon(int flag, int idx)
{
    int i;

    if (DIR_LEFT == flag) {
        if (current.p[idx].x < BOUNDARY_LEFT)
            return 1;
    }
    else if (DIR_RIGHT == flag) {
        if (current.p[idx].x > BOUNDARY_RIGHT)
            return 1;
    }
    return 0;
}


int out_horizon(int dir_horizon)
{
    int i;

    for (i = 0; i < POINT_PER_SQUARE; i++) {
        if (is_horizon(dir_horizon, i) || is_recovery(i))
            return 1;
    }
    return 0;
}

void move_horizon(int flag)
{
    int i;

    if (DIR_LEFT == flag) {
        clear_square();
        for (i = 0; i < POINT_PER_SQUARE; i ++) {
            current.p[i].x -= DIST;
        }

        if (!out_horizon(DIR_LEFT)) {
            draw_square();
        }
        else {
            for (i = 0; i < POINT_PER_SQUARE; i ++) {
                current.p[i].x += DIST;
            }
            draw_square();
        }
    }
    else if (DIR_RIGHT == flag) {
        clear_square();
        for (i = 0; i < POINT_PER_SQUARE; i ++) {
            current.p[i].x += DIST;
        }

        if (!out_horizon(DIR_RIGHT)) {
            draw_square();
        }
        else {
            for (i = 0; i < POINT_PER_SQUARE; i ++) {
                current.p[i].x -= DIST;
            }
            draw_square();
        }
    }
}

int is_recovery(int idx)
{
    move(current.p[idx].y, current.p[idx].x);
    if ((char)inch() == CHAR_SQUARE) 
        return 1;
    else 
        return 0;
}

int is_bottom(int idx)
{
    if (current.p[idx].y > BOUNDARY_BOTTOM) 
        return 1;
    else 
        return 0;
}

int out_bottom()
{
    int i;

    for (i = 0; i < POINT_PER_SQUARE; i++) {
        if (is_bottom(i) || is_recovery(i)) {
            return 1;
        }
    }
    return 0;
}

void remove_row(int row)
{
    int x, y;
    char c;

    for (y = row; y > START_ROW; y -= DIST) {
        for (x = BOUNDARY_LEFT; x <= BOUNDARY_RIGHT; x += DIST) {
            move(y-DIST, x);
            c = (char)inch();
            move(y, x);
            addch(c);
        }
    }
    for (x = BOUNDARY_LEFT; x <= BOUNDARY_RIGHT; x += DIST) {
        move(START_ROW, x);
        addch(CHAR_BLANK);
    }
    refresh();
}

int is_full_row(int row)
{
    int x;

    for (x = BOUNDARY_LEFT; x <= BOUNDARY_RIGHT; x += DIST) {
        move(row, x);
        if ((char)inch() != CHAR_SQUARE)
            return 0;
    }
    return 1;
}

void update_background()
{
    int i, j, x, y;
    int max_row = -1;

    for (i = 0; i < POINT_PER_SQUARE; i ++) {
        if (is_full_row(current.p[i].y)) {
            if (current.p[i].y > max_row)
                max_row = current.p[i].y;
        }
    }
    if (max_row != -1)
        remove_row(max_row);
}

void move_down(int sig)
{
    int i;

    clear_square();
    for (i = 0; i < POINT_PER_SQUARE; i ++) {
        current.p[i].y += DIST;
    }

    if (!out_bottom()) {
        draw_square();
    }
    else {
        for (i = 0; i < POINT_PER_SQUARE; i ++) {
            current.p[i].y -= DIST;
        }
        draw_square();

        if (on_speed)
            on_speed = 0;
        update_background();
        new_square();
        draw_square();
    }
}

void weiyi_compute(int flag)
{
    int i;

    if (WEIYI_ADD == flag) {
        current.no = (current.no+1) % ROTATE_NUM;
        for (i = 0; i < POINT_PER_SQUARE; i ++) {
            current.p[i].x = current.p[ROTATE_POINT].x + 
                weiyi[current.type][current.no][i].x;
            current.p[i].y = current.p[ROTATE_POINT].y + 
                weiyi[current.type][current.no][i].y;
        }
    }
    else if (WEIYI_MINUS == flag) {
        current.no = (current.no-1) % ROTATE_NUM;
        for (i = 0; i < POINT_PER_SQUARE; i ++) {
            current.p[i].x = current.p[ROTATE_POINT].x + 
                weiyi[current.type][current.no][i].x;
            current.p[i].y = current.p[ROTATE_POINT].y + 
                weiyi[current.type][current.no][i].y;
        }
    }
}

int out_change() 
{
    int i;

    for (i = 0; i < POINT_PER_SQUARE; i ++) {
        if (out_bottom() || out_horizon(DIR_LEFT) || 
                out_horizon(DIR_RIGHT))
            return 1;
    }
    return 0;
}

void change()
{
    int i;

    clear_square();
    weiyi_compute(WEIYI_ADD);
    if (out_change()) {
        weiyi_compute(WEIYI_MINUS);
    }
    draw_square();
}

void game_over()
{
    set_ticker(0);
    sleep(1);
    endwin();
    exit(0);
}

void generate_next()
{
    int i, j, k;

    i = rand() % SQUARE_TYPE_NUM;
    j = rand() % SQUARE_NO_NUM;
    next = (struct square){i, j, 0,0, init_point[i][j], 0,0, 0,0};

    for (k = 0; k < POINT_PER_SQUARE; k++) {
        next.p[k].x = next.p[ROTATE_POINT].x + 
            weiyi[next.type][next.no][k].x;
        next.p[k].y = next.p[ROTATE_POINT].y + 
            weiyi[next.type][next.no][k].y;

    }
}

void draw_map()
{
    int i;

    move(START_ROW, START_COLUMN);
    printw(CHAR_ROW_1);
    for (i = START_ROW+1; i <= (START_ROW+ROW_NUM*DIST); i += 2) {
        move(START_ROW+i, START_COLUMN);
        printw(CHAR_ROW_2);
        move(START_ROW+i+1, START_COLUMN);
        printw(CHAR_ROW_1);
    }
    refresh();
}

void draw_next()
{
    int i, min_x, offset_x;

    move(START_NEXT_Y, START_NEXT_X);
    printw(CHAR_NEXT_1);
    for (i = START_NEXT_Y+1; i <= (START_NEXT_Y+4*DIST); i += 2) {
        move(i, START_NEXT_X);
        printw(CHAR_NEXT_2);
        move(i+1, START_NEXT_X);
        printw(CHAR_NEXT_1);
    }

    min_x = next.p[0].x;
    for (i = 1; i < POINT_PER_SQUARE; i ++) {
        if (min_x > next.p[i].x)
            min_x = next.p[i].x;
    }
    offset_x = START_NEXT_X + 1 - min_x;

    for (i = 0; i < POINT_PER_SQUARE; i ++) {
        move(next.p[i].y, next.p[i].x+offset_x);
        addch(CHAR_SQUARE);
    }

    refresh();
}

void draw_square()
{
    int i;
    for (i = 0; i < POINT_PER_SQUARE; i++) {
        move(current.p[i].y, current.p[i].x);
        addch(CHAR_SQUARE);
    }
    refresh();
}

void clear_square()
{
    int i;
    for (i = 0; i < POINT_PER_SQUARE; i++) {
        move(current.p[i].y, current.p[i].x);
        addch(CHAR_BLANK);
    }
    refresh();
}

void next_to_current()
{
    memcpy(&current, &next, sizeof(struct square));
}

int is_current_fail()
{
    int i;

    for (i = 0; i < POINT_PER_SQUARE; i ++) {
        move(current.p[i].y, current.p[i].x);
        if ((char)inch() == CHAR_SQUARE) {
            return 1;
        }
    }
    return 0;
}

void new_square()
{
    next_to_current();
    if (is_current_fail())
        game_over();
    generate_next();
    draw_next();
}

void init_square()
{
    generate_next();
    new_square();
}

void init()
{
    initscr();
    clear();
    cbreak();
    noecho();
    curs_set(0);
    srand(time(0));

    draw_map();
    init_square();
    draw_square();
    signal(SIGALRM, move_down);
    set_ticker(500);
}

int set_ticker(int n_msec)
{
    struct itimerval timeset;
    long n_sec, n_usec;

    n_sec = n_msec / 1000;
    n_usec = (n_msec % 1000) * 1000L;

    timeset.it_interval.tv_sec = n_sec;
    timeset.it_interval.tv_usec = n_usec;

    timeset.it_value.tv_sec = n_sec;
    timeset.it_value.tv_usec = n_usec;

    return setitimer(ITIMER_REAL, &timeset, NULL);
}

结果

这里写图片描述

视频

c语言小游戏

weixiaoyiri
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
俄罗斯方块PYTHON完整源码
07-24
国外网站上看到的俄罗斯方块PYTHON+pyqt实现 http://zetcode.com/tutorials/pyqt4/thetetrisgame/
Python课程设计之俄罗斯方块
热门推荐
满天星的博客
06-27 1万+
Python课程设计之俄罗斯方块 软件需求：Python环境 压缩包内含：源代码、打包好的可执行文件、文档报告
Python俄罗斯方块及文档
05-19
有Python俄罗斯方块源码和对应的文档。有Python俄罗斯方块源码和对应的文档。
俄罗斯方块python源码
12-19
俄罗斯方块 python 源码
俄罗斯方块游戏设计与实现（Python）
最新发布
毕业作品网站
10-13 4877
目录第一章 绪论 11.1 任务概述 11.1.1 软件功能 11.1.2 运行环境 11.2 需求分析 31.2.1 游戏界面 31.2.2 菜单操作 31.2.3 游戏操作 31.3 设计目的 4第二章 相关技术及开发工具 52.1 python介绍 52.2 python发展历史 62.3 python特点 62.4 python开发环境构建 7第三章 概要设计 83.1 程序流程 93.1.1 程序主流程 9。
LABVIEW俄罗斯方块
12-02
《 LABVIEW俄罗斯方块：深入理解与学习指南》 LabVIEW，全称为Laboratory Virtual Instrument Engineering Workbench（实验室虚拟仪器工程工作台），是一款由美国国家仪器（National Instruments, NI）公司开发的...
俄罗斯方块C++源代码
09-18
《俄罗斯方块C++源代码解析》 在编程领域，经典游戏俄罗斯方块是一个极好的学习案例，它涉及到了基础的图形界面设计、事件处理、数据结构和算法等多个知识点。本篇文章将对“俄罗斯方块C++源代码”进行深入剖析，...
俄罗斯方块大全
04-09
《俄罗斯方块大全》 俄罗斯方块，这款经典的电子游戏自1984年诞生以来，就以其简单易上手的操作和无尽的挑战性吸引了全球无数玩家。它由俄罗斯的阿列克谢·帕基特诺夫设计，因此得名“俄罗斯方块”。在深入探讨这款...
俄罗斯方块C语言报告
07-26
### 俄罗斯方块C语言程序设计报告 #### 一、问题描述 俄罗斯方块（俄文：Тетрис）是一款经典的益智类游戏，最初由苏联程序员阿列克谢·帕基特诺夫于1984年开发。游戏的目标是通过移动、旋转屏幕上的方块，...
全新版vue.js俄罗斯方块
03-07
在这个"全新版vue.js俄罗斯方块"项目中，开发者利用Vue.js的强大功能，结合算法，创建了一个完整的俄罗斯方块游戏。让我们深入探讨这个项目中的关键知识点。 1. **Vue.js组件化开发**： - Vue.js的核心理念是组件...
3D俄罗斯方块
11-03
"3D俄罗斯方块"是一款将经典游戏俄罗斯方块与三维空间相结合的创新游戏。它在传统的二维游戏基础上增加了第三个维度，为玩家带来全新的视觉体验和挑战。在这款游戏中，不同形状的方块不再仅仅从屏幕顶部垂直下落，...
python实现俄罗斯方块游戏
01-20
在公司实习。公司推崇Python和Django框架，所以也得跟着学点。 简单瞅了下Tkinter，和Canvas配合在一起，还算是简洁的界面开发API。threading.Thread创建新的线程，其多线程机制也算是方便。 只是canvas.create_...
俄罗斯方块小程序源码
04-04
C#实现俄罗斯方块：实现方法： 1. 把每个砖块当成一个对象。每个砖块都有共同的行为，就是可以左移、 右移、下移和变形。既然这是他们共同的行为（方法），那么可以定义一个虚基类Brick，然后在该基类中声明这些行为...
PSP俄罗斯方块.iso
10-14
PSP俄罗斯方块.iso
用Python做一个俄罗斯方块
u010212352的博客
02-05 3164
全部组件 俄罗斯方块python小程序（免费） 学习前的准备 python编译器 pygame库和random库 清醒的头脑 一双能三连实践的双手 让我们开始吧 导入 import pygame from pygame import locals import random pygame.init() # 初始化 pygame库可以做一些小游戏，如果报这个错的话(见#1)就打开cmd，输入(见#2)就可以解决了。 #1： ModuleNotFoundError: No mo
使用Python写俄罗斯方块，以游戏的方式学习编程
小杰玩编程
10-12 2844
本文将用Python写一个终端版俄罗斯方块，用游戏的方式学习编程。
2021-01-28
linhfrty的博客
01-28 315
python编写俄罗斯方块 代码： import tkinter as tk from tkinter import messagebox import random R = 20 C = 12 cell_size = 30 height = R * cell_size width = C * cell_size FPS = 200 # 刷新页面的毫秒间隔为0.2秒 #定义各种形状 SHAPES = { “O”: [(-1, -1), (0, -1), (-1, 0), (0, 0)], “S”: [(-
python写俄罗斯方块
NBDR_YL的博客
06-01 3306
#coding=utf-8 from tkinter import * from random import * import threading from tkinter.messagebox import showinfo from tkinter.messagebox import askquestion import threading from time import sleep ...
C++实现俄罗斯方块
"C++制作俄罗斯方块" 本文将详细介绍如何使用C++语言编写经典的俄罗斯方块游戏。俄罗斯方块是一种流行的电子游戏，通过编程实现它能帮助开发者深化对游戏逻辑、数据结构和算法的理解。在这个过程中，我们将探讨以下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值