大一暑假结果-俄罗斯方块

于 2019-09-12 16:03:14 发布
阅读量107 收藏
点赞数
分类专栏： C++ 文章标签： 代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42898615/article/details/100775140
版权

//记得用多字符
#include<iostream>
#include<conio.h>
#include<time.h>
#include<string>
#include<windows.h>
#include<mmreg.h>
#include<mmsystem.h>
#include<stdlib.h>
using namespace std;

#define IDB_ONE    
#define Width  20             
#define High  26             
#define YIGE 20              
#define E_NEWBLOCK   WM_USER+1  
#define E_DRAW       WM_USER+2  
#define E_NEXTBLOCK  WM_USER+3 
#pragma comment(lib,"winmm.lib") 
static int Top, sel, Fg, sel1;
static int state = 0, b = 1;
//static int b = 1;
HWND  hwnd;
HDC mdc, hdc;
int score; int len; int n = 1;
char ch[256];
static int ShowKUAI[4][2], KUAI[4][2], SNextKUAI[4][2], NextKUAI[4][2];
static bool pauseFlag = false;
static int key = 1;
void HiGame(HWND);
void StopGame(HWND);
void StartP(HDC);
void Sweep(HWND);
HDC m_hdc;
HFONT hfont;
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance,
    HINSTANCE hPrevInstance,
    PSTR  szCmdLine,
    int  iCmdShow)
{
    static char AppName[] = "Tetris俄罗斯方块";

    MSG   msg;
    msg.message = 0;

    WNDCLASSEX wndclass;

    int   iScreenWide;

    wndclass.cbSize = sizeof(wndclass);

    wndclass.style = CS_HREDRAW | CS_VREDRAW;

    wndclass.lpfnWndProc = WndProc;

    wndclass.cbClsExtra = 0;

    wndclass.cbWndExtra = 0;

    wndclass.hInstance = hInstance;

    wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);

    wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);

    wndclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);

    wndclass.lpszMenuName = NULL;

    wndclass.lpszClassName = AppName;

    wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);


    if (!RegisterClassEx(&wndclass))
    {
        MessageBeep(0);

        return FALSE;
    }

    iScreenWide = GetSystemMetrics(SM_CXFULLSCREEN);


    hwnd = CreateWindow(
        AppName,
        "俄罗斯方块",
        WS_MINIMIZEBOX | WS_SYSMENU,
        0,
        0,
        600,
        520,
        NULL,
        NULL,
        hInstance,
        NULL
    );

    if (!hwnd)
        return FALSE;


    ShowWindow(hwnd, iCmdShow);

    UpdateWindow(hwnd);

    SendMessage(hwnd, E_NEWBLOCK, 0, 0);

    SetTimer(hwnd, 1, 300, NULL);

    while (msg.message != WM_QUIT)
    {
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        else
        {
            if (!state)
            {
                hdc = GetDC(hwnd);
                m_hdc = CreateCompatibleDC(hdc);
                state = 1;
                Sleep(200);
            }
            else if (state == 1)
            {

                if (b)
                {
                    Sweep(hwnd);
                    InvalidateRect(hwnd, NULL, TRUE);
                    KillTimer(hwnd, 1);
                    b = 0;
                }
            }
        }
    }


    return msg.wParam;
}


void DrawRect(HDC hdc, int l, int t, int r, int b)
{
    MoveToEx(hdc, l, t, NULL);
    LineTo(hdc, r, t);
    LineTo(hdc, r, b);
    LineTo(hdc, l, b);
    LineTo(hdc, l, t);
}

class Colour
{
public:
    Colour(int, int, int);

    HBRUSH hhBru;
    HBRUSH visithhBru()
    {

        return hhBru;

    };
private:
    int a1, b1, c1;

};

Colour::Colour(int a, int b, int c)
{
    a1 = a; b1 = b; c1 = c;
    hhBru = CreateSolidBrush(RGB(a1, b1, c1));
}

void DrawCell(HDC hdc, int l, int t, int r, int b)
{
    Colour B1(255, 2, 255), B2(8, 92, 255), B3(96, 113, 223), B4(34, 126, 255), B5(172, 108, 2);
    HBRUSH hBru, hBru1, hBru2, hBru3, hBru4;

    hBru = B1.visithhBru();
    hBru1 = B2.visithhBru();
    hBru2 = B3.visithhBru();
    hBru3 = B4.visithhBru();
    hBru4 = B5.visithhBru();

    //hBru = CreateSolidBrush(RGB(255, 2, 255));    //紫色
    //hBru1 = CreateSolidBrush(RGB(8, 92, 255));
    //hBru2 = CreateSolidBrush(RGB(96, 113, 223));
    //hBru3 = CreateSolidBrush(RGB(34, 126, 255));
    //hBru4 = CreateSolidBrush(RGB(172, 108, 2));   //zongse
    switch (sel1)
    {
    case 0:
        SelectObject(hdc, hBru);
        Rectangle(hdc, l, t, r, b);
        break;
    case 1:
        SelectObject(hdc, hBru1);
        Rectangle(hdc, l, t, r, b);
        break;
    case 2:
        SelectObject(hdc, hBru2);
        Rectangle(hdc, l, t, r, b);
        break;
    case 3:
        SelectObject(hdc, hBru2);
        Rectangle(hdc, l, t, r, b);
        break;
    case 4:
        SelectObject(hdc, hBru3);
        Rectangle(hdc, l, t, r, b);
        break;
    case 5:
        SelectObject(hdc, hBru3);
        Rectangle(hdc, l, t, r, b);
        break;
    case 6:
        SelectObject(hdc, hBru4);
        Rectangle(hdc, l, t, r, b);
        break;
    }
    DeleteObject(hBru);

    DeleteObject(hBru1);

    DeleteObject(hBru2);

    DeleteObject(hBru3);

    DeleteObject(hBru4);

}


void DrawGamePlace(HDC hdc)
{
    if (key)
    {
        StartP(hdc);
    }
    else {
        int i, j;
        HPEN hpen1;
        hpen1 = CreatePen(PS_SOLID, 1, RGB(0, 255, 0));
        MoveToEx(hdc, (Width - 8) * YIGE, 0, NULL);
        LineTo(hdc, (Width - 8) * YIGE, (High - 2) * YIGE);

        SelectObject(hdc, hpen1);

        for (i = 1; i < High - 1; i++)
            for (j = 1; j <= Width - 8; j++)
                DrawRect(hdc, (j - 1) * YIGE, (i - 1) * YIGE, j * YIGE, i * YIGE);

        for (i = 5; i < 9; i++)
            for (j = Width - 5; j < Width - 1; j++)
                DrawRect(hdc, (j - 1) * YIGE, (i - 1) * YIGE, j * YIGE, i * YIGE);
        DeleteObject(hpen1);

    }
}


void DrawBlock(HDC hdc, int block[4][2])
{
    int i;

    for (i = 0; i < 4; i++)
        DrawCell(hdc, (block[i][0] - 1) * YIGE, (block[i][1] - 1) * YIGE, block[i][0] * YIGE, block[i][1] * YIGE);

}

void Cover(HDC hdc, int Zhanshi[4][2])
{

    int i;
    HBRUSH hBru;

    DrawGamePlace(hdc);


    hBru = (HBRUSH)GetStockObject(BLACK_BRUSH);
    SelectObject(hdc, hBru);


    for (i = 0; i < 4; i++)
        Rectangle(hdc, (Zhanshi[i][0] - 1) * YIGE, (Zhanshi[i][1] - 1) * YIGE, Zhanshi[i][0] * YIGE, Zhanshi[i][1] * YIGE);

    DeleteObject(hBru);


}


void StopGame(HWND hwnd)
{

    KillTimer(hwnd, 1);
    MessageBox(hwnd, " 游戏暂停\n\n 再次按下空格开始", "提示", MB_OK);

}


void HiGame(HWND hwnd)
{
    if (score <= 500)
        SetTimer(hwnd, 1, 300, NULL);
    else if (score <= 1000)
        SetTimer(hwnd, 1, 200, NULL);
    else
        SetTimer(hwnd, 1, 50, NULL);
}


void Sweep(HWND hwnd)
{
    ReleaseDC(hwnd, hdc);
    DeleteObject(hfont);
    DeleteObject(m_hdc);
}


void StartP(HDC hdc)
{

    TextOut(hdc, 240, 200, "俄罗斯方块", lstrlen("俄罗斯方块"));
    TextOut(hdc, 230, 230, "按下Enter进入游戏", lstrlen("按下Enter进入游戏"));

}


LRESULT CALLBACK WndProc(HWND  hwnd,
    UINT  iMsg,
    WPARAM wParam,
    LPARAM lParam)
{

    int   i, j, k, lines, r;

    static int CLS[Width - 7][High];

    HPEN  hpen;
    PAINTSTRUCT ps;

    switch (iMsg)
    {

    case WM_CREATE:

        Top = High - 1;


        for (i = 0; i < High; i++)
        {
            CLS[0][i] = 1;
            CLS[Width - 7][i] = 1;
        }

        for (i = 0; i < Width - 7; i++)
        {
            CLS[i][High - 1] = 1;
        }


        for (i = 1; i <= Width - 8; i++)
        {
            for (j = 0; j < High - 1; j++)
                CLS[i][j] = 0;
        }


        return 0;

    case E_NEWBLOCK:

        Fg = 0;

        if (score >= 500)
        {
            KillTimer(hwnd, 1);
            SetTimer(hwnd, 1, 200, NULL);
        }

        if (score >= 1000)
        {
            KillTimer(hwnd, 1);
            SetTimer(hwnd, 1, 100, NULL);
        }


        for (i = Top; i < High - 1; i++)
        {
            lines = 1;


            for (j = 1; j <= Width - 7; j++)

                if (!CLS[j][i])
                {
                    lines = 0;

                    break;
                }

            if (lines)
            {
                score += 100;
                for (j = 1; j < Width - 7; j++)

                    for (k = i; k > 0; k--)
                    {
                        CLS[j][k] = CLS[j][k - 1];

                    }
                Top++;

                InvalidateRect(hwnd, NULL, TRUE);


            }


        }

        if (n)
        {
            sel1 = 0;
            n = 0;
            ShowKUAI[0][0] = KUAI[0][0] = 5; ShowKUAI[0][1] = KUAI[0][1] = 0;
            ShowKUAI[1][0] = KUAI[1][0] = 6; ShowKUAI[1][1] = KUAI[1][1] = 0;
            ShowKUAI[2][0] = KUAI[2][0] = 5; ShowKUAI[2][1] = KUAI[2][1] = 1;
            ShowKUAI[3][0] = KUAI[3][0] = 6; ShowKUAI[3][1] = KUAI[3][1] = 1;
        }
        else
        {
            sel1 = sel;
            ShowKUAI[0][0] = KUAI[0][0] = NextKUAI[0][0]; ShowKUAI[0][1] = KUAI[0][1] = NextKUAI[0][1];
            ShowKUAI[1][0] = KUAI[1][0] = NextKUAI[1][0]; ShowKUAI[1][1] = KUAI[1][1] = NextKUAI[1][1];
            ShowKUAI[2][0] = KUAI[2][0] = NextKUAI[2][0]; ShowKUAI[2][1] = KUAI[2][1] = NextKUAI[2][1];
            ShowKUAI[3][0] = KUAI[3][0] = NextKUAI[3][0]; ShowKUAI[3][1] = KUAI[3][1] = NextKUAI[3][1];
        }

        srand((unsigned)time(NULL));
        sel = rand() % 7;

        switch (sel)
        {

        case 0:

            // 田字
            NextKUAI[0][0] = 5; NextKUAI[0][1] = 0;
            NextKUAI[1][0] = 6; NextKUAI[1][1] = 0;
            NextKUAI[2][0] = 5; NextKUAI[2][1] = 1;
            NextKUAI[3][0] = 6; NextKUAI[3][1] = 1;

            for (i = 0; i < 4; i++)
            {
                SNextKUAI[i][0] = NextKUAI[i][0] + 11;
                SNextKUAI[i][1] = NextKUAI[i][1] + 5;
            }
            break;

        case 1:

            //横杆
            NextKUAI[0][0] = 4; NextKUAI[0][1] = 0;
            NextKUAI[1][0] = 5; NextKUAI[1][1] = 0;
            NextKUAI[2][0] = 6; NextKUAI[2][1] = 0;
            NextKUAI[3][0] = 7; NextKUAI[3][1] = 0;

            for (i = 0; i < 4; i++)
            {
                SNextKUAI[i][0] = NextKUAI[i][0] + 11;
                SNextKUAI[i][1] = NextKUAI[i][1] + 5;
            }

            break;

        case 2:

            //左上右下
            NextKUAI[0][0] = 5; NextKUAI[0][1] = 0;
            NextKUAI[1][0] = 5; NextKUAI[1][1] = 1;
            NextKUAI[2][0] = 6; NextKUAI[2][1] = 1;
            NextKUAI[3][0] = 6; NextKUAI[3][1] = 2;

            for (i = 0; i < 4; i++)
            {
                SNextKUAI[i][0] = NextKUAI[i][0] + 11;
                SNextKUAI[i][1] = NextKUAI[i][1] + 5;
            }

            break;

        case 3:

            //  右上左下
            NextKUAI[0][0] = 6; NextKUAI[0][1] = 0;
            NextKUAI[1][0] = 6; NextKUAI[1][1] = 1;
            NextKUAI[2][0] = 5; NextKUAI[2][1] = 1;
            NextKUAI[3][0] = 5; NextKUAI[3][1] = 2;

            for (i = 0; i < 4; i++)
            {
                SNextKUAI[i][0] = NextKUAI[i][0] + 11;
                SNextKUAI[i][1] = NextKUAI[i][1] + 5;
            }
            break;

        case 4:

            //向右朝向的L

            NextKUAI[0][0] = 5; NextKUAI[0][1] = 0;
            NextKUAI[1][0] = 5; NextKUAI[1][1] = 1;
            NextKUAI[2][0] = 5; NextKUAI[2][1] = 2;
            NextKUAI[3][0] = 6; NextKUAI[3][1] = 2;

            for (i = 0; i < 4; i++)
            {
                SNextKUAI[i][0] = NextKUAI[i][0] + 11;
                SNextKUAI[i][1] = NextKUAI[i][1] + 5;
            }
            break;

        case 5:

            // 向左朝向的L
            NextKUAI[0][0] = 5; NextKUAI[0][1] = 0;
            NextKUAI[1][0] = 5; NextKUAI[1][1] = 1;
            NextKUAI[2][0] = 5; NextKUAI[2][1] = 2;
            NextKUAI[3][0] = 4; NextKUAI[3][1] = 2;

            for (i = 0; i < 4; i++)
            {
                SNextKUAI[i][0] = NextKUAI[i][0] + 11;
                SNextKUAI[i][1] = NextKUAI[i][1] + 5;
            }
            break;

        case 6:

            //  土字
            NextKUAI[0][0] = 5; NextKUAI[0][1] = 0;
            NextKUAI[1][0] = 4; NextKUAI[1][1] = 1;
            NextKUAI[2][0] = 5; NextKUAI[2][1] = 1;
            NextKUAI[3][0] = 6; NextKUAI[3][1] = 1;

            for (i = 0; i < 4; i++)
            {
                SNextKUAI[i][0] = NextKUAI[i][0] + 11;
                SNextKUAI[i][1] = NextKUAI[i][1] + 5;
            }


            SendMessage(hwnd, E_NEXTBLOCK, 0, 0);

            break;

        default:

            SendMessage(hwnd, E_NEWBLOCK, 0, 0);
            SendMessage(hwnd, E_NEXTBLOCK, 0, 0);

            break;
        }

        return 0;

    case WM_TIMER:

        if (!state)
            break;
        for (i = 0; i < 4; i++)
            KUAI[i][1]++;

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

            if (CLS[KUAI[i][0]][KUAI[i][1]])
            {
                SendMessage(hwnd, E_NEXTBLOCK, 0, 0);

                for (i = 0; i < 4; i++)
                    CLS[ShowKUAI[i][0]][ShowKUAI[i][1]] = 1;

                if (Top > ShowKUAI[0][1] - 2)
                    Top = ShowKUAI[0][1] - 2;

                if (Top < 0)
                {
                    PlaySound(NULL, NULL, SND_ASYNC | SND_FILENAME);
                    KillTimer(hwnd, 1);
                    MessageBox(hwnd, "游戏结束", "退出", MB_OK);
                    PostQuitMessage(0);
                }


                SendMessage(hwnd, E_NEWBLOCK, 0, 0);

                return 0;
            }


        SendMessage(hwnd, E_DRAW, 0, 0);

        return 0;


    case WM_KEYDOWN:
        r = 0;


        switch ((int)wParam)
        {

        case VK_LEFT:
            if (pauseFlag)
                break;

            for (i = 0; i < 4; i++)
                KUAI[i][0]--;

            break;

        case VK_RIGHT:
            if (pauseFlag)
                break;

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

            break;


        case VK_DOWN:
            if (pauseFlag)
                break;

            for (i = 0; i < 4; i++)
                KUAI[i][1]++;

            break;

        case VK_SPACE:
            pauseFlag = !pauseFlag;

            if (pauseFlag == true)
            {
                StopGame(hwnd);
                break;
            }

            else {
                HiGame(hwnd);
                break;
            }


        case VK_ESCAPE:
        {
            PlaySound(NULL, NULL, SND_ASYNC | SND_FILENAME);
            KillTimer(hwnd, 1);
            MessageBox(hwnd, "游戏结束", "退出", MB_OK);
            PostQuitMessage(0);
        }

        case VK_RETURN:
            key = 0;
            InvalidateRect(hwnd, NULL, TRUE);
            SetTimer(hwnd, 1, 300, NULL);


        case VK_UP:
            if (pauseFlag)
                break;

            r = 1;
            Fg++;

            switch (sel1)
            {

            case 0:
                break;


                //横变成竖 
            case 1:
                Fg = Fg % 2;

                for (i = 0; i < 4; i++)
                {
                    KUAI[i][(Fg + 1) % 2] = ShowKUAI[2][(Fg + 1) % 2];
                    KUAI[i][Fg] = ShowKUAI[2][Fg] - 2 + i;
                }

                break;

                //左上右下顺时针90°


            case 2:
                Fg = Fg % 2;

                if (Fg)
                {
                    KUAI[0][1] += 2; KUAI[3][0] -= 2;
                }

                else
                {
                    KUAI[0][1] -= 2; KUAI[3][0] += 2;
                }

                break;

                // 左下右上顺时针90°


            case 3:
                Fg = Fg % 2;

                if (Fg)
                {
                    KUAI[0][1] += 2; KUAI[3][0] += 2;
                }

                else
                {
                    KUAI[0][1] -= 2; KUAI[3][0] -= 2;
                }

                break;

                //        L顺时针旋转      
            case 4:
                Fg = Fg % 4;

                switch (Fg)
                {

                case 0:
                    KUAI[2][0] += 2; KUAI[3][0] += 2;
                    KUAI[2][1] += 1; KUAI[3][1] += 1;

                    break;

                case 1:
                    KUAI[2][0] += 1; KUAI[3][0] += 1;
                    KUAI[2][1] -= 2; KUAI[3][1] -= 2;

                    break;

                case 2:
                    KUAI[2][0] -= 2; KUAI[3][0] -= 2;
                    KUAI[2][1] -= 1; KUAI[3][1] -= 1;

                    break;

                case 3:
                    KUAI[2][0] -= 1; KUAI[3][0] -= 1;
                    KUAI[2][1] += 2; KUAI[3][1] += 2;

                    break;
                }

                break;


                // 左L顺时针旋转
            case 5:
                Fg = Fg % 4;

                switch (Fg)
                {

                case 0:
                    KUAI[2][0] += 1; KUAI[3][0] += 1;
                    KUAI[2][1] += 2; KUAI[3][1] += 2;

                    break;

                case 1:
                    KUAI[2][0] += 2; KUAI[3][0] += 2;
                    KUAI[2][1] -= 1; KUAI[3][1] -= 1;

                    break;

                case 2:
                    KUAI[2][0] -= 1; KUAI[3][0] -= 1;
                    KUAI[2][1] -= 2; KUAI[3][1] -= 2;

                    break;

                case 3:
                    KUAI[2][0] -= 2; KUAI[3][0] -= 2;
                    KUAI[2][1] += 1; KUAI[3][1] += 1;

                    break;
                }

                break;

            case 6:
                // 土顺时针旋转90°
                Fg = Fg % 4;

                switch (Fg)
                {

                case 0:
                    KUAI[0][0]++; KUAI[0][1]--;
                    KUAI[1][0]--; KUAI[1][1]--;
                    KUAI[3][0]++; KUAI[3][1]++;

                    break;

                case 1:
                    KUAI[1][0]++; KUAI[1][1]++; break;

                case 2:
                    KUAI[0][0]--; KUAI[0][1]++; break;

                case 3:
                    KUAI[3][0]--; KUAI[3][1]--; break;
                }
                break;
            }
            break;
        }

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

            if (CLS[KUAI[i][0]][KUAI[i][1]])
            {

                if (r) Fg += 3;
                {
                    for (i = 0; i < 4; i++)
                    {
                        for (j = 0; j < 2; j++)
                            KUAI[i][j] = ShowKUAI[i][j];
                    }
                }
                return 0;
            }
        SendMessage(hwnd, E_DRAW, 0, 0);;

        return 0;

    case E_NEXTBLOCK:

        hdc = GetDC(hwnd);
        Cover(hdc, SNextKUAI);
        return 0;

    case E_DRAW:
        hdc = GetDC(hwnd);
        Cover(hdc, ShowKUAI);
        DrawBlock(hdc, SNextKUAI);
        for (i = 0; i < 4; i++)
        {
            for (j = 0; j < 2; j++)
            {

                ShowKUAI[i][j] = KUAI[i][j];
            }
        }
        DrawBlock(hdc, ShowKUAI);
        ReleaseDC(hwnd, hdc);
        return 0;

    case WM_PAINT:

        len = wsprintf(ch, "Score：%d", score);
        hdc = BeginPaint(hwnd, &ps);
        DrawGamePlace(hdc);
        if (key != 1)
        {
            //TextOut(hdc, 15 * YIGE, 12 * YIGE, "Score", lstrlen("Score"));
            TextOut(hdc, 15 * YIGE, 13 * YIGE, ch, len);
            TextOut(hdc, 15 * YIGE, 15 * YIGE, "Level: ", lstrlen("Level: "));

            if (score <= 500)
                TextOut(hdc, 18 * YIGE, 15 * YIGE, "简单", lstrlen("简单"));
            else if (score <= 1000)
                TextOut(hdc, 18 * YIGE, 15 * YIGE, "中等", lstrlen("中等"));
            else
                TextOut(hdc, 18 * YIGE, 15 * YIGE, "困难", lstrlen("困难"));
        }
        hpen = CreatePen(PS_SOLID, 1, RGB(0, 255, 0));
        SelectObject(hdc, hpen);

        for (i = 0; i < High - 1; i++)
        {
            for (j = 1; j <= Width - 8; j++)
            {
                if (CLS[j][i])
                    DrawCell(hdc, (j - 1) * YIGE, (i - 1) * YIGE, j * YIGE, i * YIGE);

            }

        }
        DeleteObject(hpen);
        EndPaint(hwnd, &ps);

        return 0;

    case WM_DESTROY:

        Sweep(hwnd);
        KillTimer(hwnd, 1);
        PostQuitMessage(0);

        return 0;
    }
    return DefWindowProc(hwnd, iMsg, wParam, lParam);
}

可持续乖巧
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
shell脚本案例-俄罗斯方块
03-01
该脚本需要在Linux-centos系统中运行，需要安装格式转换工具 dos2unix； 改脚本对于shell初学者来说是不错案例选择，仅用619行脚本代码，写出了有趣的小游戏； 环境：Centos7.x 1.dos2unix安装 ...
大一写的俄罗斯方块游戏
CozyCabin@GameDesign
06-23 954
主要模块实现方法1.开始动画：通过随机在屏幕上画点来模拟雪的效果。2.方块移动：画好新的方块后，用背景色在原位置画个相同方块，以此实现方块的移动。3.方块有节奏下落：通过调用系统时间，来实现在一定时间段内反复执行一段程序。4.玩家键盘控制：通过获得系统键盘码来实现。代码如下5.最高分纪录：通过对score.dat文件的读写，纪录最高分。。程序中的方块结构和时钟控制是参考了其他人的代码，
经典小游戏 - 俄罗斯方块完整源码
05-12
【俄罗斯方块】是一款历史悠久且深受全球玩家喜爱的经典电子游戏，其简单易上手的玩法和无穷无尽的挑战性使其成为了游戏史上的一个标志性作品。在这个“经典小游戏 - 俄罗斯方块完整源码”中，我们将深入探讨游戏的...
java实现游戏-俄罗斯方块
07-30
这是一个使用java实现的简单小游戏，俄罗斯方块（曾经风靡世界近半世纪的经典小游戏）。 ———————————————————————————————————————— 功能尚不完善，但是可以作为基础参考，...
Python+pygame制作小游戏-俄罗斯方块
06-18
Python+pygame制作小游戏--俄罗斯方块，注释极其详尽，有博客文章参考。 https://blog.csdn.net/cxhold/article/details/139760663 https://blog.csdn.net/cxhold/article/details/139767676 ...
Python小游戏源码-俄罗斯方块游戏源码
02-27
【Python小游戏源码-俄罗斯方块游戏源码】 在编程世界中，开发一款经典的小游戏是学习新语言或提升编程技巧的良好实践。Python作为一种高级、易读且功能强大的编程语言，常常被用作开发小游戏的首选。这个"Python小...
【独家首发】基于蜣螂优化算法DBO-GMDH的风电数据回归预测研究Matlab实现.rar
最新发布
08-14
【独家首发】基于蜣螂优化算法DBO-GMDH的风电数据回归预测研究Matlab实现.rar
深度探索：神经网络在图像识别中的革命性应用
08-14
神经网络是一种受人脑结构启发的数学模型，它由大量的节点（或称为“神经元”）相互连接构成。这些节点通常组织成层，包括输入层、隐藏层和输出层。每个神经元可以接收来自前一层的输入，通过某种激活函数处理这些输入，然后将结果传递给下一层的神经元。 神经网络能够通过学习大量的数据来识别模式和特征，这使得它们在图像识别、语音识别、自然语言处理等领域有着广泛的应用。它们也可以用于预测、分类和回归等任务。 训练神经网络通常涉及到一个称为“反向传播”的过程，通过这个过程，网络可以调整其内部参数（权重和偏置），以便更好地完成特定的任务。这个过程通常需要大量的计算资源，并且伴随着梯度下降或其他优化算法来最小化损失函数，从而提高模型的性能。 随着深度学习技术的发展，神经网络变得更加复杂和强大，出现了各种类型的网络结构，比如卷积神经网络（CNNs）用于图像处理，循环神经网络（RNNs）用于序列数据，以及长短期记忆网络（LSTMs）等。
基础会计教学课件第十一章财务会计报告.pptx
08-14
基础会计教学课件第十一章财务会计报告.pptx
基于Android网络聊天软件APP设计与实现.docx
08-14
基于Android网络聊天软件APP设计与实现.docx
基于Android音乐播放器设计与实现2.docx
08-14
基于Android音乐播放器设计与实现2.docx
深度学习基础：理解神经网络及其应用.md
08-14
深度学习基础中的神经网络原理及其广泛应用。文章首先介绍了神经网络的基本构造、激活函数、反向传播等核心概念，详细讲解了卷积神经网络（CNN）、循环神经网络（RNN）等常见神经网络模型的特点及应用场景。接着，文章展示了神经网络在语音识别、图像识别、自动驾驶、医疗影像分析、金融分析、推荐系统等领域的成功案例。此外，还讨论了深度学习的发展趋势，如更深层次的网络、自监督学习、模型压缩、多模态学习及其在实际应用中的挑战与局限性。文章特别提到神经网络对数据的高度依赖、训练中的计算成本、模型的可解释性问题以及泛化能力不足等技术难点。总体上，本文为读者提供了一个从基础到应用、从原理到前沿发展的全景视角，强调了深度学习在推动人工智能技术发展的重要性。
员工关系中的法律问题.pptx
08-14
员工关系中的法律问题.pptx
高效记录与整理编程学习笔记工具
08-14
Obsidian 是一个以 Markdown 为基础的笔记软件，支持双向链接和知识图谱，非常适合建立个人知识网络。Obsidian 的社区中有很多中文用户，而且可以下载中文插件实现中文界面。
螺旋矩阵算法.txt 基于一维数组与vector完成二级索引优化
08-14
00 01 02 03 04 05 06 07 08 09 00 01 02 03 04 05 06 07 08 09 35 00 00 00 00 00 00 00 00 10 35 36 37 38 39 40 41 42 43 10 34 00 00 00 00 00 00 00 00 11 34 63 64 65 66 67 68 69 44 11 33 00 00 00 00 00 00 00 00 12 33 62 83 84 85 86 87 70 45 12 32 00 00 00 00 00 00 00 00 13 32 61 82 95 96 97 88 71 46 13 31 00 00 00 00 00 00 00 00 14 ...... 31 60 81 94 99 9
openvswitch
08-14
openvswitch
ssm_126_mysql_实习支教中小学学校信息管理系统_.zip
08-14
本系统的后台语言使用的是JSP，JSP是一种动态编程语言，可以对数据进行增删改查等操作。在JSP、ASP、PHP等动态语言出现之前，很多网站就只能用静态的HTML语言宣传自己的网站，但这种网站不具备数据的存储操作功能，因为无法连接数据库，本系统使用的JSP语言可以与HTML语言有效的结合起来，不仅可以将各类素材展现在页面上，还可以将数据保存在数据库中。 选择JSP技术开发主要因为其有以下几个优点： （1）首先就是因为JSP的结构清晰、易于理解，而且JSP是面向对象的编程语言，可以使用封装、继承和多态等技术，可以使用类和对象的思想解决很多问题，可以极大的提高编码效率。 （2）选择JSP的第二个原因就是它在浏览器中的响应速度较快，可以提高本系统运行的速度。 （3）选择JSP作为本系统开发技术的第三个原因就是它具备较为稳定的连接数据库的方法，可以使数据稳定地进行存储和更新。
通用的C++数据结构代码实现，使用模板 代码完整，注释齐全，可直接运行，可使用doxygen生成网页和PDF文档
08-14
通用于各类数据结构与算法(C++语言)教材，适用于自学、课程设计/毕业设计和考研复习等。完整的代码实现，可直接运行调试，使用模板，方便灵活。代码注释完整，可生成网页版/PDF文档，效果丰富
MultiVideoDemo.rar
08-14
MultiVideoDemo.rar 博客地址：https://lw112190.blog.csdn.net/article/details/141200926
Eclipse小游戏-俄罗斯方块
05-21
好的，我可以为您提供一些关于Eclipse小游戏-俄罗斯方块的指导。 首先，您需要安装Eclipse开发环境以及Java开发工具包。然后，您需要根据游戏规则和界面设计开发游戏。 以下是一些可能有用的指导： 1. 游戏规则 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值