2. 程式人生 > >c++寫俄羅斯方塊小遊戲

c++寫俄羅斯方塊小遊戲

阿新 • • 發佈：2018-11-08

第二篇部落格
把我之前用c++寫的一個俄羅斯方塊也傳上來算了，這個程式是我學完c++後寫的，雖然有點長，看起來比較嚇人，但是程式碼絕對是你能夠找到的理解起來最簡單的俄羅斯方塊的程式碼，對於一些基礎不好的同學還是非常友好的。（歡迎批評指正）

#include<iostream>
#include<windows.h>
#include <conio.h>
#include<time.h>
using namespace std;
//地圖初始化
int map[20][18] =
{
    1, 1, 1, 1, 1, 1, 1, 1
 
, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 0, 0, 0, 0, 0, 0
 
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0
 
, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
};
char ch = '0';
//畫出地圖
void drawMap()
{
    for (int i = 0; i < 20; i++)
    {
        for (int j = 0; j < 18; j++)
            switch (map[i][j])
        {
            case 0:
                cout << "  ";
                break;
            case 1:
                cout << "□";
                break;
            case 2:
                cout << "■";
                break;
        }
        cout << endl;
    }
}
//形狀類
class Shape
{
public:
    int a0, a1, a2, a3, b0, b1, b2, b3;
    //初始化
    virtual void init()
    {
        map[a0][b0] = 2; map[a1][b1] = 2; map[a2][b2] = 2; map[a3][b3] = 2;
    }
    //清除形狀
    virtual void clean()
    {
        map[a0][b0] = 0; map[a1][b1] = 0; map[a2][b2] = 0; map[a3][b3] = 0;
    }

    //點選
    virtual void click(char ch){};
    //下落 
    virtual void fall(){};
    //判斷形狀是否到底
    virtual bool shape_is_botton_adjacent(){ return true; };
    //判斷形狀是否可向下移動
    bool fall_moveable();
    //判斷形狀是否可向左移動
    bool laft_moveable();
    //判斷形狀是否可向右移動
    bool right_moveable();
    //判斷方塊是否著陸
    bool is_block_adjacent(int a, int b)
    {
        if (map[a][b] != 0)
            return true;
        else return false;
    }
};
//“田”形狀類
class Tian :public Shape
{
public:
    Tian(int a_0 = 1, int a_1 = 1, int a_2 = 2, int a_3 = 2, int b_0 = 8, int b_1 = 9, int b_2 = 8, int b_3 = 9)
    {
        a0 = a_0, a1 = a_1, a2 = a_2, a3 = a_3, b0 = b_0, b1 = b_1, b2 = b_2, b3 = b_3;
    }
    void fall()
    {
        if (fall_moveable() == true)
        {
            clean();
            a0++; a1++; a2++; a3++;
        }
    }
    void click(char ch)
    {
        switch (ch)
        {
        case'a':
        {
                   if (laft_moveable() == true)
                   {
                       clean();
                       b0--; b1--; b2--; b3--;
                   }
                   break;
        }
        case'd':
        {
                   if (right_moveable() == true)
                   {
                       clean();
                       b0++; b1++; b2++; b3++;
                   }
                   break;
        }
        case's':
        {
                   if (fall_moveable() == true)
                   {
                       clean();
                       a0++; a1++; a2++; a3++;
                   }
                   break;
        }
        }
    }
    bool fall_moveable()
    {
        if (map[a2 + 1][b2] == 0 && map[a3 + 1][b3] == 0)
            return true;
        else return false;
    }
    bool laft_moveable()
    {
        if (map[a0][b0 - 1] == 0 && map[a2][b2 - 1] == 0)
            return true;
        else return false;
    }
    bool right_moveable()
    {
        if (map[a1][b1 + 1] == 0 && map[a3][b3 + 1] == 0)
            return true;
        else return false;
    }
    bool shape_is_botton_adjacent()
    {
        if (is_block_adjacent(a2, b2) || is_block_adjacent(a3, b3))
            return true;
        else return false;
    }

};
//“|”形狀類
class Shu :public Shape
{
public:
    Shu(int a_0 = 1, int a_1 = 2, int a_2 = 3, int a_3 = 4, int b_0 = 9, int b_1 = 9, int b_2 = 9, int b_3 = 9)
    {
        a0 = a_0, a1 = a_1, a2 = a_2, a3 = a_3, b0 = b_0, b1 = b_1, b2 = b_2, b3 = b_3;
    }
    void click(char ch)
    {
        switch (ch)
        {
        case'a':
        {
                   if (laft_moveable() == true)
                   {
                       clean();
                       b0--; b1--; b2--; b3--;
                   }
                   break;
        }
        case'd':
        {
                   if (right_moveable() == true)
                   {
                       clean();
                       b0++; b1++; b2++; b3++;
                   }
                   break;
        }
        case's':
        {
                   if (fall_moveable() == true)
                   {
                       clean();
                       a0++; a1++; a2++; a3++;
                   }
                   break;
        }
        }
    }
    void fall()
    {
        if (fall_moveable() == true)
        {
            clean();
            a0++; a1++; a2++; a3++;
        }
    }
    bool fall_moveable()
    {
        if (map[a3 + 1][b3] == 0)
            return true;
        else return false;
    }
    bool laft_moveable()
    {
        if (map[a0][b0 - 1] == 0 && map[a2][b2 - 1] == 0 && map[a1][b1 - 1] == 0 && map[a3][b3 - 1] == 0)
            return true;
        else return false;
    }
    bool right_moveable()
    {
        if (map[a1][b1 + 1] == 0 && map[a3][b3 + 1] == 0 && map[a0][b0 + 1] == 0 && map[a2][b2 + 1] == 0)
            return true;
        else return false;
    }
    bool shape_is_botton_adjacent()
    {
        if (is_block_adjacent(a3, b3))
            return true;
        else return false;
    }
};
//“——”形狀類
class Heng :public Shape
{
public:
    Heng(int a_0 = 1, int a_1 = 1, int a_2 = 1, int a_3 = 1, int b_0 = 7, int b_1 = 8, int b_2 = 9, int b_3 = 10)
    {
        a0 = a_0, a1 = a_1, a2 = a_2, a3 = a_3, b0 = b_0, b1 = b_1, b2 = b_2, b3 = b_3;
    }
    void click(char ch)
    {
        switch (ch)
        {
        case'a':
        {
                   if (laft_moveable() == true)
                   {
                       clean();
                       b0--; b1--; b2--; b3--;
                   }
                   break;
        }
        case'd':
        {
                   if (right_moveable() == true)
                   {
                       clean();
                       b0++; b1++; b2++; b3++;
                   }
                   break;
        }
        case's':
        {
                   if (fall_moveable() == true)
                   {
                       clean();
                       a0++; a1++; a2++; a3++;
                   }
                   break;
        }
        }
    }
    void fall()
    {
        if (fall_moveable() == true)
        {
            clean();
            a0++; a1++; a2++; a3++;
        }
    }
    bool fall_moveable()
    {
        if (map[a0 + 1][b0] == 0 && map[a2 + 1][b2] == 0 && map[a1 + 1][b1] == 0 && map[a3 + 1][b3] == 0)
            return true;
        else return false;
    }
    bool laft_moveable()
    {
        if (map[a0][b0 - 1] == 0)
            return true;
        else return false;
    }
    bool right_moveable()
    {
        if (map[a3][b3 + 1] == 0)
            return true;
        else return false;
    }
    bool shape_is_botton_adjacent()//判斷形狀是否可以移動
    {
        if (is_block_adjacent(a0, b0) || is_block_adjacent(a1, b1) || is_block_adjacent(a2, b2) || is_block_adjacent(a3, b3))
            return true;
        else return false;
    }

};
//遊戲類
class Game
{
public:
    void start()
    {
    lable:
        srand((unsigned)time(NULL));
        int random = rand() % 3;
        Shape *pt;
        Tian tian;
        Shu shu;
        Heng heng;
        switch (random)
        {
        case 0:pt = &tian; break;
        case 1:pt = &shu; break;
        case 2:pt = &heng; break;
        }
        while (1)
        {
            pt->init();
            drawMap();
            if (kbhit())
                ch = getche();
            if (ch == 'w')
            {
                pt->clean();
                switch (random)
                {
                case 0:break;
                case 1:
                    if (heng_shu_rotateable(pt->a1, pt->b1))
                    {
                        Heng heng2(pt->a1, pt->a1, pt->a1 , pt->a1, pt->b1-1, pt->b1, pt->b1+1, pt->b1+2);
                        pt = &heng2;
                        pt->init();
                        random = 2;
                    }
                    break;
                case 2:
                    if (heng_shu_rotateable(pt->a1, pt->b1))
                    {
                        Shu shu2(pt->a1-1, pt->a1, pt->a1+1, pt->a1+2, pt->b1, pt->b1, pt->b1, pt->b1);
                        pt = &shu2;
                        pt->init();
                        random = 1;
                    } 
                    break;
                }
            }
            else
            pt->click(ch);
            pt->fall();
            Sleep(400);
            system("cls");
            ch = '0';
            if (pt->shape_is_botton_adjacent())
            {
                for (int a = 0; a < 20; a++)
                {
                    if (is_full(a))
                        movedown(a);
                }
                goto lable;
            }
            system("cls");
            ch = '0';
        }
    }
    //判斷是否為滿行
    bool is_full(int a)
    {
        int j = 0;
        for (int i = 1; i < 17; i++)
        {
            if (map[a][i] == 2)j++;
        }
        if (j == 16)return true;
        else return false;
    }
    //下移
    void movedown(int a)
    {
        for (int i = a; i>1; i--)
            for (int j = 1; j < 17; j++)
                map[i][j] = map[i - 1][j];
        for (int i2 = 1; i2<17; i2++)
            map[1][i2] = 0;
    }
    //判斷橫豎是否可以旋轉
    bool heng_shu_rotateable(int a, int b)
    {
        int x = 0;
        for (int i = a - 1; i <= a + 2; i++)
        {
            for (int j = b - 1; j <= b + 2; j++)
            {
                if (map[i][j] != 0)x++;
            }
        }
        if (x == 0)return true;
        else return false;
    }
};
void main()
{
    Game game;
    game.start();
}

可能你會發現複製貼上過去後發現，這個遊戲只能往下掉兩種形狀。
不要驚訝，這是我故意弄的。
如果你願意去看我的程式碼，那剩下的形狀你絕對能夠自己寫出來；
如果你不願意看，那就花積分去下載吧，我上傳的是完整版的。
萬一有要轉載的朋友後面加上出處哦

相關推薦

c++寫俄羅斯方塊小遊戲

第二篇部落格 把我之前用c++寫的一個俄羅斯方塊也傳上來算了，這個程式是我學完c++後寫的，雖然有點長，看起來比較嚇人，但是程式碼絕對是你能夠找到的理解起來最簡單的俄羅斯方塊的程式碼，對於一些基礎不好的同學還是非常友好的。（歡迎批評指正） #include<iostream>

【新手入門】SDL+C語言編寫俄羅斯方塊小遊戲小經歷

基礎太差，現在重新學習了一遍C語言。因為訓練要求，要學習SDL庫的使用，編寫個SDL+俄羅斯方塊小遊戲。轉眼一週多，小白終於寫出來了。以下是一些體會。感覺還是好好學習，多擼程式碼才是正道。 一、遊戲規則 1.開啟遊戲，遊戲開始，方塊自由下落。 2.當按下左鍵，方塊對環境進行判斷，條件應許即進行

俄羅斯方塊小遊戲

俄羅斯方塊小遊戲 版權宣告：本文為博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/qq_26239525/article/details/82431921 研一時寫的俄羅斯方塊小遊戲，C++程式，程式碼還有很多值得優化的地方，歡迎交流。

C語言寫的2048小遊戲

基於"基於C_語言的2048演算法設計_顏冠鵬.pdf" 這一篇文獻提供的思路 在中國知網上能找到 就不貼具體內容了 [摘 要] 針對2048的遊戲規則，分析了該遊戲的演算法特點，對其相關的功能需求和演算法設計進行了簡單介紹，提出了一種 新的設計方案。解決了該設計在方陣資料結構、運動演算法和遊戲結束判斷方面的

用python 和pyqt5寫俄羅斯方塊遊戲

# 俄羅斯方塊遊戲效果展示本章我們要製作一個俄羅斯方塊遊戲。## Tetris> 譯註：稱呼：方塊是由四個小方格組成的俄羅斯方塊遊戲是世界上最流行的遊戲之一。是由一名叫Alexey Pajitnov的俄羅斯程式設計師在1985年製作的，從那時起，這個遊戲就風靡了各個遊戲

【python學習】使用python寫一個2048小遊戲

ast stc 遊戲 多少 wan nbsp 小遊戲 效果 參考 個人博客：jerwang.cn 沒有參考其他代碼,效果圖： 話不多少，源代碼： https://github.com/jerustc/Python/blob/master/2048.py【python學

C語 三子棋小遊戲

splay ret int def 選擇 種子 define tdi rand() 1 #include <stdio.h> 2 #include <Windows.h> 3 #include<time.h> 4 #de

詳解！C語言程式設計實現小遊戲“三子棋”

今天我們來程式設計實現一個充滿童趣的小遊戲“三子棋” 先來說一下三子棋的規則： 三子棋又叫九宮棋、圈圈叉叉、一條龍等。 將正方形對角線連起來，或相對兩邊依次擺上三個雙方棋子， 總之只要將自己的三個棋子走成一條線， 對方就算輸了。 不用再過多解釋了，相信大家一定都玩過！ 那麼，該

C語言實現經典小遊戲貪吃蛇

純c語言寫的小遊戲，本人才疏學淺，程式碼有很多不足，僅供給初學者參考。 實現功能： ↑ ↓ ← →分別用來控制上下左右四個方向 空格暫停 esc退出遊戲 f1加速， f2 減速 蛇的長度越長，速度越快（速度有上限） 食物顏色隨機

QT/c++ 簡易俄羅斯方塊

第一次用QT寫的小專案，一切為了實現效果不擇手段，沒注意優化演算法什麼，後期也懶得去改了，遊戲目前還有個小bug，消兩行只加一行的分數，懶鬼實在不想改了。 此文單純留作記錄。 另外樣式表內容參考《QT CREATOR快速入門第三版》,不得不說這本書對於萌新真的很友好。 大概介面

C語言實現一條龍小遊戲

一條龍小遊戲 一、程式碼構思 全部程式碼分為三個檔案：game.h, game.c, text.c(game.h用來申明所有用到的函式，game.c用來寫實現遊戲的程式碼，text.c用來除錯程式碼) 第一步將棋盤初始化為空格；第二步列印棋盤；第三步設計由玩家先走（在棋盤中放入X），然後電腦

【C語言】實現小遊戲掃雷

用C語言實現掃雷小遊戲，一共有三部分的程式碼 game.h #ifndef __GAME_H_ #define __GAME_H_ #include <stdio.h> #include <stdlib.h> #include <time.h> #def

【C語言】實現小遊戲三子棋

三子棋的規則：在九宮格棋盤中，只要橫、豎、對角線都能走成一條直線，就贏了。 我將實現三子棋遊戲的程式分為三個部分 第一部分：標頭檔案 game.h #ifndef _GAME_H_ #define _GAME_H_ #include <string.h> #include

使用C語言實現隨機小遊戲原始碼

#include"stdio.h" #include"stdlib.h" #include"windows.h" int print() {     printf("\n\n+++++++++++++你會看見的數字和運算子+++++++++++++\n");   &

C語言實現掃雷小遊戲

本文將從一行行程式碼中詳解掃雷小遊戲，對每一個模組都使用詳細的註釋，使這個掃雷小遊戲簡單易懂。 首先，簡單分析掃雷的玩法，掃雷就是在一個棋盤中佈置適當數量的雷數玩家通過對雷陣的排查，來找出雷的位置。如果玩家選擇的座標周圍無雷將自動展開這片區域，若有雷會顯示雷數。

C語言——俄羅斯方塊

最近朋友找到一個用c寫的俄羅斯方塊程式碼，試玩了一下，非常有趣。 #include<stdio.h> #include<stdlib.h> #include<time.h> #include<windows.h>

C程式碼實現掃雷小遊戲

分析 同三子棋小遊戲一樣，掃雷小遊戲也分為如下思路： 標頭檔案 #ifndef __GAME_H__ #define __GAME_H__ #include <stdlib.h> #include <time.h> #include <s

學習C#從俄羅斯方塊開始(一)概述

       前幾天和一個在讀的本科生聊天，他一直在抱怨學校學習的理論知識太多，實踐的機會太少。擔心自己因此畢業後可能難以找到工作。我認為一個人要是想投入開發，他總是可以找到專案的。與其把自己的時間浪費

用Java寫貪吃蛇小遊戲

1 package snake; 2 3 import java.awt.Color; 4 import java.awt.Font; 5 import java.awt.Graphics; 6 import java.awt.event.ActionEvent; 7 impor

C++控制檯貪吃蛇小遊戲詳細教程

遊戲截圖     開始動畫：    遊戲過程：  遊戲架構設計 該遊戲的玩法簡單，玩家通過鍵盤方向鍵控制蛇上下左右移動，吃到食物得分並增長，碰到牆或者自己的身體則死亡，遊戲結束。  整個遊戲其實就是一個無窮的迴圈，直到退出遊戲時退出迴圈