C/C++李峋同款跳动的爱心代码

分类:热门推荐日期:2024-06-19浏览:1评论:0

一、写在前面

在编程的世界里，代码不仅仅是冷冰冰的命令，它也可以成为表达情感、传递浪漫的工具。今天，就让小编带着大家用C++语言打造出李峋同款跳动的爱心吧！

首先，我们需要知道C++作为一种高级编程语言，拥有强大的功能和灵活的语法，非常适合用来制作各种有趣的动画效果。而跳动的爱心，正是一种既简单又富有创意的动画效果，非常适合用来作为编程初学者的练习项目。要实现这个效果，我们需要用到C++的图形库和定时器功能。图形库可以帮助我们在控制台或窗口中绘制出爱心的形状，而定时器则可以让爱心以一定的频率跳动起来。

环境需求

环境：C/C++

软件：Visual Studio 2022

安装教程：https://want595.blog.csdn.net/article/details/134608094

EasyX是什么

EasyX是一个专为C++初学者和爱好者设计的图形库。该库以简洁易用、功能实用为宗旨，通过封装Windows GDI接口，极大降低了C++编程中图形界面设计的复杂度，使得用户能够快速上手并实现各类图形图像处理任务。

EasyX提供了一系列丰富的API函数，涵盖了绘制基本图形（如线段、圆形、矩形等）、填充图形、显示文本、加载与保存图片、颜色设置以及鼠标键盘事件处理等功能。通过简单的函数调用，开发者可以高效地进行2D图形绘制和交互式程序设计。

总的来说，EasyX以其友好的学习曲线和高效的图形处理能力，极大地激发了C++初学者对计算机图形学的兴趣，是广大编程入门者和教育领域广泛采用的一款图形库工具。

下载安装EasyX

1.进入EasyX官网，点击下载按钮开始下载

2.下载完成后进入下载目录，双击.exe文件无脑安装即可

二、跳动的爱心

接下来，让我们一步步来实现这个跳动的爱心。首先，我们需要通过一系列的数学公式来定义爱心的形状，比如使用参数方程来描述爱心的轮廓。然后，我们可以使用C++的图形库来绘制出这个形状。当绘制好爱心后，就要想办法让它跳动起来了，这里我们可以使用C++的定时器功能，设置一个合适的时间间隔，让爱心在每个时间间隔内改变位置或大小，从而产生跳动的效果。

完整代码

#include #include #include #include #include struct Point {
    double x, y;
    COLORREF color;
};
const int MAX_POINTS = 256;
const COLORREF colors[MAX_POINTS] = {
    RGB(255, 192, 203), // 浅粉色 (Light Pink)
    RGB(255, 182, 193), // 淡粉红 (LightPink)
    RGB(255, 105, 180), // 热粉红 (HotPink)
    RGB(255, 20, 147),  // 深粉色 (DeepPink)
    RGB(219, 112, 147), // 浓粉红 (PaleVioletRed)
    RGB(255, 174, 185), // 浅玫瑰红 (LightPink)
    RGB(255, 0, 144)    // 紫红色 (Crimson)
};
const int xScreen = GetSystemMetrics(SM_CXSCREEN);
const int yScreen = GetSystemMetrics(SM_CYSCREEN) - 100;
const double PI = 3.14159265359;
const double E = 2.71828;
const double AVG_DISTANCE = 0.162;
const int NUM_ORIGIN_POINTS = 506;
const int NUM_CIRCLES = 210;
const int NUM_FRAMES = 20;
const int COLOR_RANGE = 6;
Point origin_points[NUM_ORIGIN_POINTS];
Point points[NUM_CIRCLES * NUM_ORIGIN_POINTS];
IMAGE images[NUM_FRAMES];
int create_random(int min, int max) {
    return rand() % (max - min + 1) + min;
}
void create_data() {
    int index = 0;
    double x1 = 0, y1 = 0, x2 = 0, y2 = 0;
    // Generate origin points
    for (double radian = 0.1; radian <= 2 * PI; radian += 0.005) {
        x2 = 16 * pow(sin(radian), 3);
        y2 = 13 * cos(radian) - 5 * cos(2 * radian) - 2 * cos(3 * radian) - cos(4 * radian);
        double distance = sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2));
        if (distance > AVG_DISTANCE) {
            x1 = x2, y1 = y2;
            origin_points[index].x = x2;
            origin_points[index++].y = y2;
        }
    }
    // Generate points
    index = 0;
    for (double size = 0.1, lightness = 1.5; size <= 20; size += 0.1) {
        double success_p = 1 / (1 + pow(E, 8 - size / 2));
        if (lightness > 1) lightness -= 0.0025;
        for (int i = 0; i < NUM_ORIGIN_POINTS; ++i) {
            if (success_p > create_random(0, 100) / 100.0) {
                COLORREF color = colors[create_random(0, COLOR_RANGE)];
                points[index].color = RGB(GetRValue(color) / lightness, GetGValue(color) / lightness, GetBValue(color) / lightness);
                points[index].x = size * origin_points[i].x + create_random(-4, 4);
                points[index++].y = size * origin_points[i].y + create_random(-4, 4);
            }
        }
    }
    int points_size = index;
    // Generate images
    for (int frame = 0; frame < NUM_FRAMES; ++frame) {
        images[frame] = IMAGE(xScreen, yScreen);
        SetWorkingImage(&images[frame]);
        setorigin(xScreen / 2, yScreen / 2);
        setaspectratio(1, -1);
        for (index = 0; index < points_size; ++index) {
            double x = points[index].x, y = points[index].y;
            double distance = sqrt(pow(x, 2) + pow(y, 2));
            double distance_increase = -0.0009 * distance * distance + 0.35714 * distance + 5;
            double x_increase = distance_increase * x / distance / NUM_FRAMES;
            double y_increase = distance_increase * y / distance / NUM_FRAMES;
            points[index].x += x_increase;
            points[index].y += y_increase;
            setfillcolor(points[index].color);
            solidcircle(points[index].x, points[index].y, 1);
        }
        for (double size = 17; size < 23; size += 0.3) {
            for (index = 0; index < NUM_ORIGIN_POINTS; ++index) {
                if ((create_random(0, 100) / 100.0 > 0.6 && size >= 20) || (size < 20 && create_random(0, 100) / 100.0 > 0.95)) {
                    double x, y;
                    if (size >= 20) {
                        x = origin_points[index].x * size + create_random(-frame * frame / 5 - 15, frame * frame / 5 + 15);
                        y = origin_points[index].y * size + create_random(-frame * frame / 5 - 15, frame * frame / 5 + 15);
                    }
                    else {
                        x = origin_points[index].x * size + create_random(-5, 5);
                        y = origin_points[index].y * size + create_random(-5, 5);
                    }
                    setfillcolor(colors[create_random(0, COLOR_RANGE)]);
                    solidcircle(x, y, 1);
                }
            }
        }
        setaspectratio(1, 1);
        settextstyle(100, 0, _T("宋体"));
        settextcolor(RGB(255, 182, 193));
        outtextxy(-150, -50, _T("我爱你"));
        saveimage(_T("爱心.png"), &images[frame]);
        setorigin(0, 0);
        setaspectratio(1, 1);
        loadimage(&images[frame], _T("爱心.png"));
    }
    SetWorkingImage();
}
void init_graphics() {
    HWND hwnd = initgraph(xScreen, yScreen);
    RECT rect;
    SystemParametersInfo(SPI_GETWORKAREA, 0, &rect, 0);
    ShowWindow(hwnd, SW_MAXIMIZE);
    SetWindowPos(hwnd, HWND_TOP, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, SWP_SHOWWINDOW);
    BeginBatchDraw();
    setorigin(xScreen / 2, yScreen / 2);
    setaspectratio(1, -1);
    srand(static_cast(time(0)));
}
int main() {
    init_graphics();
    create_data();
    graphdefaults();
    bool extend = true, shrink = false;
    for (int frame = 0; !_kbhit();) {
        putimage(0, 0, &images[frame]);
        FlushBatchDraw();
        Sleep(20);
        cleardevice();
        if (extend)
            frame == 19 ? (shrink = true, extend = false) : ++frame;
        else
            frame == 0 ? (shrink = false, extend = true) : --frame;
    }
    EndBatchDraw();
    closegraph();
    return 0;
}

完成这些步骤后，我们就成功打造出了一个李峋同款跳动的爱心（在代码的第112行可以修改文字哦）。每当你运行这段代码时，这个爱心就会在屏幕上跳动起来，为你的编程之旅增添一份浪漫和乐趣。

代码分析

这段代码使用C语言和Turbo C++图形库来创建一个动态的心形图案动画。

1. 定义结构体和常量

  • Point 结构体包含点的坐标（x 和 y）以及颜色值（COLORREF）。
  • 预定义的颜色数组 colors[]，包括多种粉红色调。
  • 屏幕尺寸 xScreen 和 yScreen 通过系统函数获取。
  • 数学常数 PI 和 E。
  • 其他常量如 MAX_POINTS，AVG_DISTANCE 等，用于控制生成点的数量和分布。

    2. 随机数生成函数 create_random()

    • 返回指定范围内的随机整数。

      3. 数据生成函数 create_data()

      • 生成 origin_points[]：这些点用于描绘心形的基本轮廓，通过参数方程计算得到。
      • 生成 points[]：这些点基于 origin_points[] 生成，通过缩放和随机偏移来形成心形的纹理。
      • 生成 images[]：这是一系列帧，每一帧都是在前一帧的基础上对点的位置进行微调，并添加新的点，最终保存为图像文件。

        4. 图形初始化函数 init_graphics()

        • 初始化图形窗口，设置屏幕尺寸，并准备绘图环境。

          5. 主函数 main()

          • 调用 init_graphics() 准备图形环境。
          • 调用 create_data() 生成动画数据。
          • 在循环中按顺序显示每一帧，实现动画效果，直到检测到键盘输入为止。

            6. 动画的具体实现

            • 心形图案通过调整点的位置和大小随时间变化来产生脉动效果。
            • 随机添加新点以增强视觉效果。
            • 每一帧被保存为图像文件 ("爱心.png")，然后加载并显示，形成连续动画

              由于代码中涉及到大量图形库特定的函数和概念，理解它们需要一定的图形编程基础，尤其是Turbo C++图形库。如果您对此不熟悉，我建议可以先从基本的图形编程概念入手，逐步学习和理解。

              通过这个项目，我们不仅学会了如何使用C++语言制作动画效果，还学会了如何将情感融入到代码中。这让我们更加深刻地认识到，编程不仅仅是一种技能，更是一种表达自我、传递情感的方式。所以，无论你是编程初学者还是资深开发者，都不妨尝试一下用C++打造一款跳动的爱心吧！相信在这个过程中，你会收获到很多的乐趣。

              运行效果

              三、系列文章

              序号目录直达链接
              1爱心代码https://want595.blog.csdn.net/article/details/136360684
              2李峋同款跳动的爱心https://want595.blog.csdn.net/article/details/139722249
              3满屏飘字代码https://want595.blog.csdn.net/article/details/136342476
              4大雪纷飞代码
              5新春烟花代码
              6《黑客帝国》代码雨

              四、写在后面

              感谢小伙伴们的支持，更多精彩内容等你发现喔~

相关推荐

关于我们常见问题广告服务免责声明联系我们
Powered By Z-BlogPHP 1.7.3 Theme By 优美主题
Copyright Your WebSite.Some Rights Reserved. 浙ICP备2023018783号