设为首页收藏本站
切换到窄版

 找回密码
 立即注册
搜索
热搜: 活动 交友 discuz
CZLJ»论坛 › 编程 › 图形化 › 【Raylib&C++教程01期】介绍+环境搭建+官网开源学习 ...
返回列表 发新帖
查看: 415|回复: 6

【Raylib&C++教程01期】介绍+环境搭建+官网开源学习

[复制链接]
Nixx0328

8

主题

39

回帖

852

积分

管理员

积分
852
发表于 2024-7-18 13:01:06 | 显示全部楼层 |阅读模式
（emm.....没想到我研究CTF几天不在CZLJ，一下子涌进来这么多用户，看来不发点干(hen)货(huo)不行了——）

Part 1:什么是Raylib
在讲Raylib之前，你需要知道森么是OpenGL。
      OpenGL（英语：Open Graphics Library，译名：开放图形库或者“开放式图形库”）是用于渲染2D、3D矢量图形的跨语言、跨平台的应用程序编程接口（API）。这个接口由近350个不同的函数调用组成，用来绘制从简单的图形到比较复杂的三维景象。OpenGL常用于CAD、虚拟现实、科学可视化程序和电子游戏开发。OpenGL的高效实现（利用了图形加速硬件）存在于Windows，部分UNIX平台和Mac OS。
        当今，OpenGL是视频行业领域中用于处理2D/3D图形的最为广泛接纳的API，在此基础上，为了用于计算机视觉技术的研究，从而催生了各种计算机平台上的应用功能以及设备上的许多应用程序。其是独立于Windows操作系统以及操作系统平台，可以进行多种不同领域的开发和内容创作，简而言之，其帮助研发人员能够实现PC、工作站、超级计算机以及各种工控机等硬件设备上实现高性能、对于视觉要求极高的高视觉图形处理软件的开发。——摘自  百度百科


是不是听上去很库？OpenGL兼容了众多主流操作系统，且有多个编程语言的应用接口(API)，是当今主流两个图形渲染库之一（另一个是仅用于Microsoft Windows上的Direct3D）。


（注：本系列基本使用C++语言经行开发。）


不过，作者个人觉得OpenGL的函数非常奀友好。举个例子，下面是用OpenGL绘制一个立方体的部分程序源代码：
    glClearColor(1.0, 1.0, 1.0, 1.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glColor3f(1.0, 0.0, 0.0);
    gluLookAt(0.0, 0.0, -10.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0);
    glBegin(GL_QUADS);
    {
        glVertex3f(0.5, 0.5, 0.5);
        glVertex3f(-0.5, 0.5, 0.5);
        glVertex3f(-0.5, -0.5, 0.5);
        glVertex3f(0.5, -0.5, 0.5);
    }
    glEnd();
    //左面
    glBegin(GL_QUADS);
    {
        glVertex3f(-0.5, 0.5, 0.5);
        glVertex3f(-0.5, 0.5, -0.5);
        glVertex3f(-0.5, -0.5, -0.5);
        glVertex3f(-0.5, -0.5, 0.5);
    }
    glEnd();
    //下面
    glBegin(GL_QUADS);
    {
        glVertex3f(-0.5, -0.5, -0.5);
        glVertex3f(-0.5, -0.5, 0.5);
        glVertex3f(0.5, -0.5, 0.5);
        glVertex3f(0.5, -0.5, -0.5);
    }
    glEnd();
    //右面
    glBegin(GL_QUADS);
    {
        glVertex3f(0.5, -0.5, -0.5);
        glVertex3f(0.5, -0.5, 0.5);
        glVertex3f(0.5, 0.5, 0.5);
        glVertex3f(0.5, 0.5, -0.5);
    }
    glEnd();
    //前面
    glBegin(GL_QUADS);
    {
        glVertex3f(-0.5, 0.5, 0.5);
        glVertex3f(0.5, 0.5, 0.5);
        glVertex3f(0.5, -0.5, 0.5);
        glVertex3f(-0.5, -0.5, 0.5);
    }
    glEnd();
    //后面
    glBegin(GL_QUADS);
    {
        glVertex3f(-0.5, 0.5, -0.5);
        glVertex3f(0.5, 0.5, -0.5);
        glVertex3f(0.5, -0.5, -0.5);
        glVertex3f(-0.5, -0.5, -0.5);
    }
    glEnd();
    glFlush();

再看看用Raylib的函数画立方体：DrawCube((Vector3){0.0,0.0,0.0},1,1,1,SKYBLUE);
其实自己封装一个OpenGL画Cube的函数也可以，只要计算出Cube的八个点再用glVertex3fv传参挨个填过去就可以了。但是Raylib已经封装了大量图形绘制的函数，不用自己再麻烦了。
OpenGL的函数是最原始的“设定一个点，再设定一个点，再连线”地绘图，用它画一个立方体需要36+行代码，没有那种封装好可以直接调用的画图函数，而Raylib则是对OpenGL做了大量封装，内置有绘制各种2D/3D图形的函数，只需要设定图形的大小、位置这样的参数就能完成。
这就好比OpenGL是你摘抄时一笔一划写，而Raylib是你把文章剪下来贴在摘抄本上一样AwA
Raylib(直译为雷利卜)是一个简洁轻量的2D/3D图形库。他涵盖了OpenGL的多个库，包括

  • glut.h
  • glfw.h
  • glew.h
  • glad.h
  • std_image.h
  • ...
且可以做到轻松绘制图形、创建窗口、加载贴图、加载声音、鼠标键盘交互等等，是一个为开发游戏而生的库！
Part 2:配置Raylib环境
Raylib的环境配置不难，只要一个编辑器就可以。他就是我们的国产之光——小熊猫C++


小熊猫C++
相比于传统的Dev-C++,小熊猫C++的功能做了大改动：

操作简便
小熊猫C++无需复杂的安装和配置，打开即可直接编辑程序文件；无需创建项目，点击工具栏上按钮即可编译、运行和调试程序。


轻量高效
小熊猫C++基于QT和C++语言开发，使用内置的轻量级代码分析器进行智能语法分析，运行时无需大量的内存和CPU资源，在低配置机器上也能获得流畅的运行体验。


多平台支持
小熊猫C++支持Windows 7/8/10、Linux等操作系统。在各种操作系统下都能获得相同的高质量编程体验。



生产力提升
通过集成自动缩进、智能代码补全、智能语法高亮和实时语法检查等功能，小熊猫C++提供了流畅的代码编辑体验，可以大幅度提升代码编写的效率。


调试
小熊猫C++提供完善的调试功能，包括控制程序执行、断点、监视变量和表达式、表达式求值、查看本地变量、查看和切换调用栈、查看和修改内存、查看CPU寄存器和反编译信息等。小熊猫C++甚至还可以重定向被调试程序的输入！


多屏幕
小熊猫C++提供了完善的高分辨率和多显示器支持，能够在多个不同DPI设置的显示器间自由切换，同时提供完善的显示效果，便于教学和展示。



试题集和OJ
针对C/C++教学和竞赛需求，小熊猫C++专门提供了试题集和OJ功能：可以方便的组织管理、运行和测试C/C++练习程序；可以导入或者从OJ网站下载试题和配套的测试数据。


GIT版本管理
小熊猫C++内置git支持，可以方便对项目或工作文件夹进行版本管理（需额外安装git程序）






没错就是这个功能！
| |
||
👇





整合多种学习用库
Windows版小熊猫C++在自带gcc中整合了ege、海龟作图、raylib、freeglut、GLFW和GLEW等适合编程或者游戏开发入门者使用的库和项目模板，无需复杂的安装配置即可直接使用。



支持汇编语言
小熊猫C++支持编译C/C++程序生成对应的汇编语言程序；可以在调试时进行反汇编；支持编译、运行和调试GNU汇编语言程序；提供汇编程序的语法高亮、实时语法检查和关键字输入提示。利用这些功能，用户可以更加深入的学习操作系统和计算机硬件编程知识。



可以看出，小熊猫C++(RedPandaIDE)编辑器的优势丝毫不亚于Visual studio Code。小熊猫C++目前已升级至3.1版本。3.1版的小熊猫C++配置的Raylib为最新版的5.0版，小熊猫以前版本的Raylib均为4.5版，手感上有所差异，所以建议大家下载最新版。


注意：在官网下载时，不要下载网盘里分享的带有NoCompiler字样的安装包，要下载带有MinGW32或64的安装包，否则没法编译。下载时浏览器可能会提醒文件存在风险，请放心点保留。

下载完成后双击运行安装包，根据自己的需要安装。基本只要点“下一步”。

安装完成后运行它，选择默认语言为C++。新建一个文件，把下面的代码拷进去试一下按F11编译运行。如果没有问题会出现一个小的俄罗斯方块的游戏，那么你的Raylib开发环境已经配置完成了！

  1. /*******************************************************************************************
  2. *
  3. *   raylib - classic game: tetris
  4. *
  5. *   Sample game developed by Marc Palau and Ramon Santamaria
  6. *
  7. *   This game has been created using raylib v1.3 (www.raylib.com)
  8. *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
  9. *
  10. *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
  11. *
  12. ********************************************************************************************/

  14. #include "raylib.h"

  16. #include <stdio.h>
  17. #include <stdlib.h>
  18. #include <time.h>
  19. #include <math.h>

  21. #if defined(PLATFORM_WEB)
  22.     #include <emscripten/emscripten.h>
  23. #endif

  25. //----------------------------------------------------------------------------------
  26. // Some Defines
  27. //----------------------------------------------------------------------------------
  28. #define SQUARE_SIZE             20

  30. #define GRID_HORIZONTAL_SIZE    12
  31. #define GRID_VERTICAL_SIZE      20

  33. #define LATERAL_SPEED           10
  34. #define TURNING_SPEED           12
  35. #define FAST_FALL_AWAIT_COUNTER 30

  37. #define FADING_TIME             33

  39. //----------------------------------------------------------------------------------
  40. // Types and Structures Definition
  41. //----------------------------------------------------------------------------------
  42. typedef enum GridSquare { EMPTY, MOVING, FULL, BLOCK, FADING } GridSquare;

  44. //------------------------------------------------------------------------------------
  45. // Global Variables Declaration
  46. //------------------------------------------------------------------------------------
  47. static const int screenWidth = 800;
  48. static const int screenHeight = 450;

  50. static bool gameOver = false;
  51. static bool pause = false;

  53. // Matrices
  54. static GridSquare grid [GRID_HORIZONTAL_SIZE][GRID_VERTICAL_SIZE];
  55. static GridSquare piece [4][4];
  56. static GridSquare incomingPiece [4][4];

  58. // Theese variables keep track of the active piece position
  59. static int piecePositionX = 0;
  60. static int piecePositionY = 0;

  62. // Game parameters
  63. static Color fadingColor;
  64. //static int fallingSpeed;           // In frames

  66. static bool beginPlay = true;      // This var is only true at the begining of the game, used for the first matrix creations
  67. static bool pieceActive = false;
  68. static bool detection = false;
  69. static bool lineToDelete = false;

  71. // Statistics
  72. static int level = 1;
  73. static int lines = 0;

  75. // Counters
  76. static int gravityMovementCounter = 0;
  77. static int lateralMovementCounter = 0;
  78. static int turnMovementCounter = 0;
  79. static int fastFallMovementCounter = 0;

  81. static int fadeLineCounter = 0;

  83. // Based on level
  84. static int gravitySpeed = 30;

  86. //------------------------------------------------------------------------------------
  87. // Module Functions Declaration (local)
  88. //------------------------------------------------------------------------------------
  89. static void InitGame(void);         // Initialize game
  90. static void UpdateGame(void);       // Update game (one frame)
  91. static void DrawGame(void);         // Draw game (one frame)
  92. static void UnloadGame(void);       // Unload game
  93. static void UpdateDrawFrame(void);  // Update and Draw (one frame)

  95. // Additional module functions
  96. static bool Createpiece();
  97. static void GetRandompiece();
  98. static void ResolveFallingMovement(bool *detection, bool *pieceActive);
  99. static bool ResolveLateralMovement();
  100. static bool ResolveTurnMovement();
  101. static void CheckDetection(bool *detection);
  102. static void CheckCompletion(bool *lineToDelete);
  103. static void DeleteCompleteLines();

  105. //------------------------------------------------------------------------------------
  106. // Program main entry point
  107. //------------------------------------------------------------------------------------
  108. int main(void)
  109. {
  110.     // Initialization (Note windowTitle is unused on Android)
  111.     //---------------------------------------------------------
  112.     InitWindow(screenWidth, screenHeight, "classic game: tetris");

  114.     InitGame();

  116. #if defined(PLATFORM_WEB)
  117.     emscripten_set_main_loop(UpdateDrawFrame, 60, 1);
  118. #else
  119.     SetTargetFPS(60);
  120.     //--------------------------------------------------------------------------------------

  122.     // Main game loop
  123.     while (!WindowShouldClose())    // Detect window close button or ESC key
  124.     {
  125.         // Update and Draw
  126.         //----------------------------------------------------------------------------------
  127.         UpdateDrawFrame();
  128.         //----------------------------------------------------------------------------------
  129.     }
  130. #endif
  131.     // De-Initialization
  132.     //--------------------------------------------------------------------------------------
  133.     UnloadGame();         // Unload loaded data (textures, sounds, models...)

  135.     CloseWindow();        // Close window and OpenGL context
  136.     //--------------------------------------------------------------------------------------

  138.     return 0;
  139. }

  141. //--------------------------------------------------------------------------------------
  142. // Game Module Functions Definition
  143. //--------------------------------------------------------------------------------------

  145. // Initialize game variables
  146. void InitGame(void)
  147. {
  148.     // Initialize game statistics
  149.     level = 1;
  150.     lines = 0;

  152.     fadingColor = GRAY;

  154.     piecePositionX = 0;
  155.     piecePositionY = 0;

  157.     pause = false;

  159.     beginPlay = true;
  160.     pieceActive = false;
  161.     detection = false;
  162.     lineToDelete = false;

  164.     // Counters
  165.     gravityMovementCounter = 0;
  166.     lateralMovementCounter = 0;
  167.     turnMovementCounter = 0;
  168.     fastFallMovementCounter = 0;

  170.     fadeLineCounter = 0;
  171.     gravitySpeed = 30;

  173.     // Initialize grid matrices
  174.     for (int i = 0; i < GRID_HORIZONTAL_SIZE; i++)
  175.     {
  176.         for (int j = 0; j < GRID_VERTICAL_SIZE; j++)
  177.         {
  178.             if ((j == GRID_VERTICAL_SIZE - 1) || (i == 0) || (i == GRID_HORIZONTAL_SIZE - 1)) grid[i][j] = BLOCK;
  179.             else grid[i][j] = EMPTY;
  180.         }
  181.     }

  183.     // Initialize incoming piece matrices
  184.     for (int i = 0; i < 4; i++)
  185.     {
  186.         for (int j = 0; j< 4; j++)
  187.         {
  188.             incomingPiece[i][j] = EMPTY;
  189.         }
  190.     }
  191. }

  193. // Update game (one frame)
  194. void UpdateGame(void)
  195. {
  196.     if (!gameOver)
  197.     {
  198.         if (IsKeyPressed('P')) pause = !pause;

  200.         if (!pause)
  201.         {
  202.             if (!lineToDelete)
  203.             {
  204.                 if (!pieceActive)
  205.                 {
  206.                     // Get another piece
  207.                     pieceActive = Createpiece();

  209.                     // We leave a little time before starting the fast falling down
  210.                     fastFallMovementCounter = 0;
  211.                 }
  212.                 else    // Piece falling
  213.                 {
  214.                     // Counters update
  215.                     fastFallMovementCounter++;
  216.                     gravityMovementCounter++;
  217.                     lateralMovementCounter++;
  218.                     turnMovementCounter++;

  220.                     // We make sure to move if we've pressed the key this frame
  221.                     if (IsKeyPressed(KEY_LEFT) || IsKeyPressed(KEY_RIGHT)) lateralMovementCounter = LATERAL_SPEED;
  222.                     if (IsKeyPressed(KEY_UP)) turnMovementCounter = TURNING_SPEED;

  224.                     // Fall down
  225.                     if (IsKeyDown(KEY_DOWN) && (fastFallMovementCounter >= FAST_FALL_AWAIT_COUNTER))
  226.                     {
  227.                         // We make sure the piece is going to fall this frame
  228.                         gravityMovementCounter += gravitySpeed;
  229.                     }

  231.                     if (gravityMovementCounter >= gravitySpeed)
  232.                     {
  233.                         // Basic falling movement
  234.                         CheckDetection(&detection);

  236.                         // Check if the piece has collided with another piece or with the boundings
  237.                         ResolveFallingMovement(&detection, &pieceActive);

  239.                         // Check if we fullfilled a line and if so, erase the line and pull down the the lines above
  240.                         CheckCompletion(&lineToDelete);

  242.                         gravityMovementCounter = 0;
  243.                     }

  245.                     // Move laterally at player's will
  246.                     if (lateralMovementCounter >= LATERAL_SPEED)
  247.                     {
  248.                         // Update the lateral movement and if success, reset the lateral counter
  249.                         if (!ResolveLateralMovement()) lateralMovementCounter = 0;
  250.                     }

  252.                     // Turn the piece at player's will
  253.                     if (turnMovementCounter >= TURNING_SPEED)
  254.                     {
  255.                         // Update the turning movement and reset the turning counter
  256.                         if (ResolveTurnMovement()) turnMovementCounter = 0;
  257.                     }
  258.                 }

  260.                 // Game over logic
  261.                 for (int j = 0; j < 2; j++)
  262.                 {
  263.                     for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
  264.                     {
  265.                         if (grid[i][j] == FULL)
  266.                         {
  267.                             gameOver = true;
  268.                         }
  269.                     }
  270.                 }
  271.             }
  272.             else
  273.             {
  274.                 // Animation when deleting lines
  275.                 fadeLineCounter++;

  277.                 if (fadeLineCounter%8 < 4) fadingColor = MAROON;
  278.                 else fadingColor = GRAY;

  280.                 if (fadeLineCounter >= FADING_TIME)
  281.                 {
  282.                     DeleteCompleteLines();
  283.                     fadeLineCounter = 0;
  284.                     lineToDelete = false;

  286.                     lines++;
  287.                 }
  288.             }
  289.         }
  290.     }
  291.     else
  292.     {
  293.         if (IsKeyPressed(KEY_ENTER))
  294.         {
  295.             InitGame();
  296.             gameOver = false;
  297.         }
  298.     }
  299. }

  301. // Draw game (one frame)
  302. void DrawGame(void)
  303. {
  304.     BeginDrawing();

  306.         ClearBackground(RAYWHITE);

  308.         if (!gameOver)
  309.         {
  310.             // Draw gameplay area
  311.             Vector2 offset;
  312.             offset.x = screenWidth/2 - (GRID_HORIZONTAL_SIZE*SQUARE_SIZE/2) - 50;
  313.             offset.y = screenHeight/2 - ((GRID_VERTICAL_SIZE - 1)*SQUARE_SIZE/2) + SQUARE_SIZE*2;

  315.             offset.y -= 50;     // NOTE: Harcoded position!

  317.             int controller = offset.x;

  319.             for (int j = 0; j < GRID_VERTICAL_SIZE; j++)
  320.             {
  321.                 for (int i = 0; i < GRID_HORIZONTAL_SIZE; i++)
  322.                 {
  323.                     // Draw each square of the grid
  324.                     if (grid[i][j] == EMPTY)
  325.                     {
  326.                         DrawLine(offset.x, offset.y, offset.x + SQUARE_SIZE, offset.y, LIGHTGRAY );
  327.                         DrawLine(offset.x, offset.y, offset.x, offset.y + SQUARE_SIZE, LIGHTGRAY );
  328.                         DrawLine(offset.x + SQUARE_SIZE, offset.y, offset.x + SQUARE_SIZE, offset.y + SQUARE_SIZE, LIGHTGRAY );
  329.                         DrawLine(offset.x, offset.y + SQUARE_SIZE, offset.x + SQUARE_SIZE, offset.y + SQUARE_SIZE, LIGHTGRAY );
  330.                         offset.x += SQUARE_SIZE;
  331.                     }
  332.                     else if (grid[i][j] == FULL)
  333.                     {
  334.                         DrawRectangle(offset.x, offset.y, SQUARE_SIZE, SQUARE_SIZE, GRAY);
  335.                         offset.x += SQUARE_SIZE;
  336.                     }
  337.                     else if (grid[i][j] == MOVING)
  338.                     {
  339.                         DrawRectangle(offset.x, offset.y, SQUARE_SIZE, SQUARE_SIZE, DARKGRAY);
  340.                         offset.x += SQUARE_SIZE;
  341.                     }
  342.                     else if (grid[i][j] == BLOCK)
  343.                     {
  344.                         DrawRectangle(offset.x, offset.y, SQUARE_SIZE, SQUARE_SIZE, LIGHTGRAY);
  345.                         offset.x += SQUARE_SIZE;
  346.                     }
  347.                     else if (grid[i][j] == FADING)
  348.                     {
  349.                         DrawRectangle(offset.x, offset.y, SQUARE_SIZE, SQUARE_SIZE, fadingColor);
  350.                         offset.x += SQUARE_SIZE;
  351.                     }
  352.                 }

  354.                 offset.x = controller;
  355.                 offset.y += SQUARE_SIZE;
  356.             }

  358.             // Draw incoming piece (hardcoded)
  359.             offset.x = 500;
  360.             offset.y = 45;

  362.             int controler = offset.x;

  364.             for (int j = 0; j < 4; j++)
  365.             {
  366.                 for (int i = 0; i < 4; i++)
  367.                 {
  368.                     if (incomingPiece[i][j] == EMPTY)
  369.                     {
  370.                         DrawLine(offset.x, offset.y, offset.x + SQUARE_SIZE, offset.y, LIGHTGRAY );
  371.                         DrawLine(offset.x, offset.y, offset.x, offset.y + SQUARE_SIZE, LIGHTGRAY );
  372.                         DrawLine(offset.x + SQUARE_SIZE, offset.y, offset.x + SQUARE_SIZE, offset.y + SQUARE_SIZE, LIGHTGRAY );
  373.                         DrawLine(offset.x, offset.y + SQUARE_SIZE, offset.x + SQUARE_SIZE, offset.y + SQUARE_SIZE, LIGHTGRAY );
  374.                         offset.x += SQUARE_SIZE;
  375.                     }
  376.                     else if (incomingPiece[i][j] == MOVING)
  377.                     {
  378.                         DrawRectangle(offset.x, offset.y, SQUARE_SIZE, SQUARE_SIZE, GRAY);
  379.                         offset.x += SQUARE_SIZE;
  380.                     }
  381.                 }

  383.                 offset.x = controler;
  384.                 offset.y += SQUARE_SIZE;
  385.             }

  387.             DrawText("INCOMING:", offset.x, offset.y - 100, 10, GRAY);
  388.             DrawText(TextFormat("LINES:      %04i", lines), offset.x, offset.y + 20, 10, GRAY);

  390.             if (pause) DrawText("GAME PAUSED", screenWidth/2 - MeasureText("GAME PAUSED", 40)/2, screenHeight/2 - 40, 40, GRAY);
  391.         }
  392.         else DrawText("PRESS [ENTER] TO PLAY AGAIN", GetScreenWidth()/2 - MeasureText("PRESS [ENTER] TO PLAY AGAIN", 20)/2, GetScreenHeight()/2 - 50, 20, GRAY);

  394.     EndDrawing();
  395. }

  397. // Unload game variables
  398. void UnloadGame(void)
  399. {
  400.     // TODO: Unload all dynamic loaded data (textures, sounds, models...)
  401. }

  403. // Update and Draw (one frame)
  404. void UpdateDrawFrame(void)
  405. {
  406.     UpdateGame();
  407.     DrawGame();
  408. }

  410. //--------------------------------------------------------------------------------------
  411. // Additional module functions
  412. //--------------------------------------------------------------------------------------
  413. static bool Createpiece()
  414. {
  415.     piecePositionX = (int)((GRID_HORIZONTAL_SIZE - 4)/2);
  416.     piecePositionY = 0;

  418.     // If the game is starting and you are going to create the first piece, we create an extra one
  419.     if (beginPlay)
  420.     {
  421.         GetRandompiece();
  422.         beginPlay = false;
  423.     }

  425.     // We assign the incoming piece to the actual piece
  426.     for (int i = 0; i < 4; i++)
  427.     {
  428.         for (int j = 0; j< 4; j++)
  429.         {
  430.             piece[i][j] = incomingPiece[i][j];
  431.         }
  432.     }

  434.     // We assign a random piece to the incoming one
  435.     GetRandompiece();

  437.     // Assign the piece to the grid
  438.     for (int i = piecePositionX; i < piecePositionX + 4; i++)
  439.     {
  440.         for (int j = 0; j < 4; j++)
  441.         {
  442.             if (piece[i - (int)piecePositionX][j] == MOVING) grid[i][j] = MOVING;
  443.         }
  444.     }

  446.     return true;
  447. }

  449. static void GetRandompiece()
  450. {
  451.     int random = GetRandomValue(0, 6);

  453.     for (int i = 0; i < 4; i++)
  454.     {
  455.         for (int j = 0; j < 4; j++)
  456.         {
  457.             incomingPiece[i][j] = EMPTY;
  458.         }
  459.     }

  461.     switch (random)
  462.     {
  463.         case 0: { incomingPiece[1][1] = MOVING; incomingPiece[2][1] = MOVING; incomingPiece[1][2] = MOVING; incomingPiece[2][2] = MOVING; } break;    //Cube
  464.         case 1: { incomingPiece[1][0] = MOVING; incomingPiece[1][1] = MOVING; incomingPiece[1][2] = MOVING; incomingPiece[2][2] = MOVING; } break;    //L
  465.         case 2: { incomingPiece[1][2] = MOVING; incomingPiece[2][0] = MOVING; incomingPiece[2][1] = MOVING; incomingPiece[2][2] = MOVING; } break;    //L inversa
  466.         case 3: { incomingPiece[0][1] = MOVING; incomingPiece[1][1] = MOVING; incomingPiece[2][1] = MOVING; incomingPiece[3][1] = MOVING; } break;    //Recta
  467.         case 4: { incomingPiece[1][0] = MOVING; incomingPiece[1][1] = MOVING; incomingPiece[1][2] = MOVING; incomingPiece[2][1] = MOVING; } break;    //Creu tallada
  468.         case 5: { incomingPiece[1][1] = MOVING; incomingPiece[2][1] = MOVING; incomingPiece[2][2] = MOVING; incomingPiece[3][2] = MOVING; } break;    //S
  469.         case 6: { incomingPiece[1][2] = MOVING; incomingPiece[2][2] = MOVING; incomingPiece[2][1] = MOVING; incomingPiece[3][1] = MOVING; } break;    //S inversa
  470.     }
  471. }

  473. static void ResolveFallingMovement(bool *detection, bool *pieceActive)
  474. {
  475.     // If we finished moving this piece, we stop it
  476.     if (*detection)
  477.     {
  478.         for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
  479.         {
  480.             for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
  481.             {
  482.                 if (grid[i][j] == MOVING)
  483.                 {
  484.                     grid[i][j] = FULL;
  485.                     *detection = false;
  486.                     *pieceActive = false;
  487.                 }
  488.             }
  489.         }
  490.     }
  491.     else    // We move down the piece
  492.     {
  493.         for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
  494.         {
  495.             for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
  496.             {
  497.                 if (grid[i][j] == MOVING)
  498.                 {
  499.                     grid[i][j+1] = MOVING;
  500.                     grid[i][j] = EMPTY;
  501.                 }
  502.             }
  503.         }

  505.         piecePositionY++;
  506.     }
  507. }

  509. static bool ResolveLateralMovement()
  510. {
  511.     bool collision = false;

  513.     // Piece movement
  514.     if (IsKeyDown(KEY_LEFT))        // Move left
  515.     {
  516.         // Check if is possible to move to left
  517.         for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
  518.         {
  519.             for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
  520.             {
  521.                 if (grid[i][j] == MOVING)
  522.                 {
  523.                     // Check if we are touching the left wall or we have a full square at the left
  524.                     if ((i-1 == 0) || (grid[i-1][j] == FULL)) collision = true;
  525.                 }
  526.             }
  527.         }

  529.         // If able, move left
  530.         if (!collision)
  531.         {
  532.             for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
  533.             {
  534.                 for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)             // We check the matrix from left to right
  535.                 {
  536.                     // Move everything to the left
  537.                     if (grid[i][j] == MOVING)
  538.                     {
  539.                         grid[i-1][j] = MOVING;
  540.                         grid[i][j] = EMPTY;
  541.                     }
  542.                 }
  543.             }

  545.             piecePositionX--;
  546.         }
  547.     }
  548.     else if (IsKeyDown(KEY_RIGHT))  // Move right
  549.     {
  550.         // Check if is possible to move to right
  551.         for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
  552.         {
  553.             for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
  554.             {
  555.                 if (grid[i][j] == MOVING)
  556.                 {
  557.                     // Check if we are touching the right wall or we have a full square at the right
  558.                     if ((i+1 == GRID_HORIZONTAL_SIZE - 1) || (grid[i+1][j] == FULL))
  559.                     {
  560.                         collision = true;

  562.                     }
  563.                 }
  564.             }
  565.         }

  567.         // If able move right
  568.         if (!collision)
  569.         {
  570.             for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
  571.             {
  572.                 for (int i = GRID_HORIZONTAL_SIZE - 1; i >= 1; i--)             // We check the matrix from right to left
  573.                 {
  574.                     // Move everything to the right
  575.                     if (grid[i][j] == MOVING)
  576.                     {
  577.                         grid[i+1][j] = MOVING;
  578.                         grid[i][j] = EMPTY;
  579.                     }
  580.                 }
  581.             }

  583.             piecePositionX++;
  584.         }
  585.     }

  587.     return collision;
  588. }

  590. static bool ResolveTurnMovement()
  591. {
  592.     // Input for turning the piece
  593.     if (IsKeyDown(KEY_UP))
  594.     {
  595.         GridSquare aux;
  596.         bool checker = false;

  598.         // Check all turning possibilities
  599.         if ((grid[piecePositionX + 3][piecePositionY] == MOVING) &&
  600.             (grid[piecePositionX][piecePositionY] != EMPTY) &&
  601.             (grid[piecePositionX][piecePositionY] != MOVING)) checker = true;

  603.         if ((grid[piecePositionX + 3][piecePositionY + 3] == MOVING) &&
  604.             (grid[piecePositionX + 3][piecePositionY] != EMPTY) &&
  605.             (grid[piecePositionX + 3][piecePositionY] != MOVING)) checker = true;

  607.         if ((grid[piecePositionX][piecePositionY + 3] == MOVING) &&
  608.             (grid[piecePositionX + 3][piecePositionY + 3] != EMPTY) &&
  609.             (grid[piecePositionX + 3][piecePositionY + 3] != MOVING)) checker = true;

  611.         if ((grid[piecePositionX][piecePositionY] == MOVING) &&
  612.             (grid[piecePositionX][piecePositionY + 3] != EMPTY) &&
  613.             (grid[piecePositionX][piecePositionY + 3] != MOVING)) checker = true;

  615.         if ((grid[piecePositionX + 1][piecePositionY] == MOVING) &&
  616.             (grid[piecePositionX][piecePositionY + 2] != EMPTY) &&
  617.             (grid[piecePositionX][piecePositionY + 2] != MOVING)) checker = true;

  619.         if ((grid[piecePositionX + 3][piecePositionY + 1] == MOVING) &&
  620.             (grid[piecePositionX + 1][piecePositionY] != EMPTY) &&
  621.             (grid[piecePositionX + 1][piecePositionY] != MOVING)) checker = true;

  623.         if ((grid[piecePositionX + 2][piecePositionY + 3] == MOVING) &&
  624.             (grid[piecePositionX + 3][piecePositionY + 1] != EMPTY) &&
  625.             (grid[piecePositionX + 3][piecePositionY + 1] != MOVING)) checker = true;

  627.         if ((grid[piecePositionX][piecePositionY + 2] == MOVING) &&
  628.             (grid[piecePositionX + 2][piecePositionY + 3] != EMPTY) &&
  629.             (grid[piecePositionX + 2][piecePositionY + 3] != MOVING)) checker = true;

  631.         if ((grid[piecePositionX + 2][piecePositionY] == MOVING) &&
  632.             (grid[piecePositionX][piecePositionY + 1] != EMPTY) &&
  633.             (grid[piecePositionX][piecePositionY + 1] != MOVING)) checker = true;

  635.         if ((grid[piecePositionX + 3][piecePositionY + 2] == MOVING) &&
  636.             (grid[piecePositionX + 2][piecePositionY] != EMPTY) &&
  637.             (grid[piecePositionX + 2][piecePositionY] != MOVING)) checker = true;

  639.         if ((grid[piecePositionX + 1][piecePositionY + 3] == MOVING) &&
  640.             (grid[piecePositionX + 3][piecePositionY + 2] != EMPTY) &&
  641.             (grid[piecePositionX + 3][piecePositionY + 2] != MOVING)) checker = true;

  643.         if ((grid[piecePositionX][piecePositionY + 1] == MOVING) &&
  644.             (grid[piecePositionX + 1][piecePositionY + 3] != EMPTY) &&
  645.             (grid[piecePositionX + 1][piecePositionY + 3] != MOVING)) checker = true;

  647.         if ((grid[piecePositionX + 1][piecePositionY + 1] == MOVING) &&
  648.             (grid[piecePositionX + 1][piecePositionY + 2] != EMPTY) &&
  649.             (grid[piecePositionX + 1][piecePositionY + 2] != MOVING)) checker = true;

  651.         if ((grid[piecePositionX + 2][piecePositionY + 1] == MOVING) &&
  652.             (grid[piecePositionX + 1][piecePositionY + 1] != EMPTY) &&
  653.             (grid[piecePositionX + 1][piecePositionY + 1] != MOVING)) checker = true;

  655.         if ((grid[piecePositionX + 2][piecePositionY + 2] == MOVING) &&
  656.             (grid[piecePositionX + 2][piecePositionY + 1] != EMPTY) &&
  657.             (grid[piecePositionX + 2][piecePositionY + 1] != MOVING)) checker = true;

  659.         if ((grid[piecePositionX + 1][piecePositionY + 2] == MOVING) &&
  660.             (grid[piecePositionX + 2][piecePositionY + 2] != EMPTY) &&
  661.             (grid[piecePositionX + 2][piecePositionY + 2] != MOVING)) checker = true;

  663.         if (!checker)
  664.         {
  665.             aux = piece[0][0];
  666.             piece[0][0] = piece[3][0];
  667.             piece[3][0] = piece[3][3];
  668.             piece[3][3] = piece[0][3];
  669.             piece[0][3] = aux;

  671.             aux = piece[1][0];
  672.             piece[1][0] = piece[3][1];
  673.             piece[3][1] = piece[2][3];
  674.             piece[2][3] = piece[0][2];
  675.             piece[0][2] = aux;

  677.             aux = piece[2][0];
  678.             piece[2][0] = piece[3][2];
  679.             piece[3][2] = piece[1][3];
  680.             piece[1][3] = piece[0][1];
  681.             piece[0][1] = aux;

  683.             aux = piece[1][1];
  684.             piece[1][1] = piece[2][1];
  685.             piece[2][1] = piece[2][2];
  686.             piece[2][2] = piece[1][2];
  687.             piece[1][2] = aux;
  688.         }

  690.         for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
  691.         {
  692.             for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
  693.             {
  694.                 if (grid[i][j] == MOVING)
  695.                 {
  696.                     grid[i][j] = EMPTY;
  697.                 }
  698.             }
  699.         }

  701.         for (int i = piecePositionX; i < piecePositionX + 4; i++)
  702.         {
  703.             for (int j = piecePositionY; j < piecePositionY + 4; j++)
  704.             {
  705.                 if (piece[i - piecePositionX][j - piecePositionY] == MOVING)
  706.                 {
  707.                     grid[i][j] = MOVING;
  708.                 }
  709.             }
  710.         }

  712.         return true;
  713.     }

  715.     return false;
  716. }

  718. static void CheckDetection(bool *detection)
  719. {
  720.     for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
  721.     {
  722.         for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
  723.         {
  724.             if ((grid[i][j] == MOVING) && ((grid[i][j+1] == FULL) || (grid[i][j+1] == BLOCK))) *detection = true;
  725.         }
  726.     }
  727. }

  729. static void CheckCompletion(bool *lineToDelete)
  730. {
  731.     int calculator = 0;

  733.     for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
  734.     {
  735.         calculator = 0;
  736.         for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
  737.         {
  738.             // Count each square of the line
  739.             if (grid[i][j] == FULL)
  740.             {
  741.                 calculator++;
  742.             }

  744.             // Check if we completed the whole line
  745.             if (calculator == GRID_HORIZONTAL_SIZE - 2)
  746.             {
  747.                 *lineToDelete = true;
  748.                 calculator = 0;
  749.                 // points++;

  751.                 // Mark the completed line
  752.                 for (int z = 1; z < GRID_HORIZONTAL_SIZE - 1; z++)
  753.                 {
  754.                     grid[z][j] = FADING;
  755.                 }
  756.             }
  757.         }
  758.     }
  759. }

  761. static void DeleteCompleteLines()
  762. {
  763.     // Erase the completed line
  764.     for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
  765.     {
  766.         while (grid[1][j] == FADING)
  767.         {
  768.             for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
  769.             {
  770.                 grid[i][j] = EMPTY;
  771.             }

  773.             for (int j2 = j-1; j2 >= 0; j2--)
  774.             {
  775.                 for (int i2 = 1; i2 < GRID_HORIZONTAL_SIZE - 1; i2++)
  776.                 {
  777.                     if (grid[i2][j2] == FULL)
  778.                     {
  779.                         grid[i2][j2+1] = FULL;
  780.                         grid[i2][j2] = EMPTY;
  781.                     }
  782.                     else if (grid[i2][j2] == FADING)
  783.                     {
  784.                         grid[i2][j2+1] = FADING;
  785.                         grid[i2][j2] = EMPTY;
  786.                     }
  787.                 }
  788.             }
  789.         }
  790.     }
  791. }
复制代码
效果如图：


如有需要，可以在此下载exe文件：



Part 3:官网安装包学习

Raylib官网有一个安装包，内含有一个配置好了Raylib5.0的MinGw64，一个Notepad++,还有一大堆官网上有的示例程序源代码。就像官网上说的那样：raylib 不提供典型的 API 文档或大量教程。该库被设计为简约主义，只需从包含所有必需功能的备忘单和大量示例中学习，即可了解如何使用该功能。学习编码的最好方法是阅读代码。安装包下载时还有一个坑：英文页面上有显示让你付钱的字，不要害怕，开了翻译才发现只是说可以自愿捐款。如果仔细看会发现网站建设者狡猾地写了一个非常小的链接说：不，带我去下载。链接如下：安装包下载直达：安装包
安装包下载下来运行后是一个Raylib编的界面，但它可以下载文件，每次运行时窗口的背景颜色是随机的。额，用Raylib编的Raylib安装包会默认把上面Raylib的文件下载到C:\Raylib里面去。（好像改不了路径ToT）
下载时进度条上方还有一个小小的走迷宫的3D游戏,WSAD键操纵角色前后左右，↑↓←→键操纵视角，在迷宫的各个角落里有分散开的文件样的类似金币的东西要找，总共十个，在所有文件下载完成前在迷宫里找到这些文件就算赢。（我只找到3个就晕了）还是很有创意的设计。可以让你在安装时少些无聊。（就很银杏化AwA）
回归正题，安装完后找到C:\raylib文件夹里有README.txt的详细说明（暂且不管）。npp文件夹是Notepad++的目录，是个加强版编辑器（暂且不管）；进入C:\raylib\raylib文件夹，重点来了：
重点是examples文件夹：

双击运行两个批处理文件后需要耐心等待一下，打开上面的文件加就会看到每个源代码下方都有一个对应的可执行文件，全部在上面几个文件夹里。
下面展示各个示例代码编译后的效果（均为Raylib&c++编写）：

还有3D的Hello world!

学习编码的最好方法是阅读代码。你可以查看想学习的3D效果的源代码，看看他是怎么编出来的。不是很酷吗？
下一帖，我将教大家基础框架和绘图知识！(ง •_•)ง

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

×
回复

使用道具 举报

Nixx0328

8

主题

39

回帖

852

积分

管理员

积分
852
 楼主| 发表于 2024-7-18 13:03:18 | 显示全部楼层
哈哈哈哈哈哈哈哈哈哈上传附件给了190金钱+190经验+190贡献哈哈哈哈哈哈哈
回复

使用道具 举报

Nixx0328

8

主题

39

回帖

852

积分

管理员

积分
852
 楼主| 发表于 2024-7-18 13:06:58 | 显示全部楼层
好肝啊啊啊啊不知道下一期什么时候鉼出来
回复

使用道具 举报

Nixx0328

8

主题

39

回帖

852

积分

管理员

积分
852
 楼主| 发表于 2024-7-20 12:02:56 | 显示全部楼层
@_CX_ 看我新帖
回复

使用道具 举报

Nixx0328

8

主题

39

回帖

852

积分

管理员

积分
852
 楼主| 发表于 2024-11-27 22:32:46 | 显示全部楼层
@ZSJ20110121 see it

看中间那个俄罗斯方块，源码可以拿去参考和改价进
回复

使用道具 举报

Nixx0328

8

主题

39

回帖

852

积分

管理员

积分
852
 楼主| 发表于 2024-12-1 15:42:46 | 显示全部楼层
@ZSJ20110121
回复

使用道具 举报

Nixx0328

8

主题

39

回帖

852

积分

管理员

积分
852
 楼主| 发表于 2024-12-1 15:43:26 | 显示全部楼层
@ZSJ20110121
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

站点统计|Archiver|手机版|小黑屋|CZLJ

GMT+8, 2025-1-29 06:19 , Processed in 0.077905 second(s), 20 queries .

Powered by Discuz! X3.5

© 2001-2025 Discuz! Team.

快速回复 返回顶部 返回列表