html--彩虹马

文章目录

  • html
    • js
    • css
  • 效果

html

<!DOCTYPE html>
<html lang="en" >
<head>
<meta charset="UTF-8">
<title>Rainbow Space Unicorn</title>
<link rel="stylesheet" href="css/style.css">
</head>
<body>
<img src="img/unicorn.png" alt="unicorn" id="unicorn" hidden>
<script  src="js/index.js"></script>
</body>
</html>

js

var __extends = (this && this.__extends) || (function () {
    var extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
window.addEventListener('DOMContentLoaded', init);
//#region classes
var Vector = /** @class */ (function () {
    function Vector() {
        this.x = 0;
        this.y = 0;
        this.vx = 0;
        this.vy = 0;
        this.angle = 0;
        this.va = 0.05;
    }
    return Vector;
}());
var Particle = /** @class */ (function (_super) {
    __extends(Particle, _super);
    function Particle() {
        var _this = _super !== null && _super.apply(this, arguments) || this;
        _this.id = Math.random().toString();
        _this.color = randomColor();
        _this.radius = 8;
        _this.opacity = 1;
        return _this;
    }
    return Particle;
}(Vector));
var Unicorn = /** @class */ (function (_super) {
    __extends(Unicorn, _super);
    function Unicorn(image) {
        var _this = _super.call(this) || this;
        _this.image = image;
        return _this;
    }
    return Unicorn;
}(Vector));
var Tile = /** @class */ (function (_super) {
    __extends(Tile, _super);
    function Tile() {
        var _this = _super !== null && _super.apply(this, arguments) || this;
        _this.color = randomColor();
        _this.width = 30;
        _this.height = 10;
        _this.opacity = 1;
        return _this;
    }
    return Tile;
}(Vector));
var ParticleFactory = /** @class */ (function () {
    function ParticleFactory() {
    }
    ParticleFactory.archive = function (p) {
        ParticleFactory.particleArchive[p.id] = Object.assign({}, p);
    };
    ParticleFactory.retrieve = function (p) {
        if (p.id in ParticleFactory.particleArchive) {
            return ParticleFactory.particleArchive[p.id];
        }
        return null;
    };
    ParticleFactory.create = function (options) {
        var p = new Particle();
        Object.assign(p, options);
        ParticleFactory.archive(p);
        return p;
    };
    ParticleFactory.reset = function (p) {
        var archivedVersion = ParticleFactory.retrieve(p);
        if (archivedVersion) {
            ;
            Object.assign(p, archivedVersion);
        }
    };
    ParticleFactory.particleArchive = {};
    return ParticleFactory;
}());
var Renderer = /** @class */ (function () {
    function Renderer($) {
        var _this = this;
        this.$ = $;
        this.renderParticle = function (p) {
            var $ = _this.$;
            var x = p.x, y = p.y, radius = p.radius, color = p.color, opacity = p.opacity;
            $.save();
            $.globalAlpha = opacity;
            $.fillStyle = color;
            $.translate(x, y);
            $.beginPath();
            $.arc(0, 0, radius, 0, PI2);
            $.fill();
            $.stroke();
            $.restore();
        };
        this.renderStar = function (p) {
            var $ = _this.$;
            var radius = p.radius, color = p.color, x = p.x, y = p.y, opacity = p.opacity;
            $.save();
            $.translate(x, y);
            $.fillStyle = color;
            $.globalAlpha = opacity;
            $.beginPath();
            for (var i = 5; i--;) {
                $.lineTo(0, radius);
                $.translate(0, radius);
                $.rotate(PI2 / 10);
                $.lineTo(0, -radius);
                $.translate(0, -radius);
                $.rotate(-((Math.PI * 6) / 10));
            }
            $.lineTo(0, radius);
            $.fill();
            $.stroke();
            $.restore();
        };
        this.renderTile = function (t) {
            var $ = _this.$;
            var x = t.x, y = t.y, width = t.width, height = t.height, color = t.color, opacity = t.opacity;
            $.save();
            $.globalAlpha = opacity;
            $.fillStyle = color;
            $.translate(x, y);
            $.beginPath();
            $.rect(0, 0, width, height);
            $.fill();
            $.stroke();
            $.restore();
        };
    }
    Renderer.prototype.clearScreen = function () {
        var $ = this.$;
        $.clearRect(0, 0, $.canvas.width, $.canvas.height);
    };
    Renderer.prototype.renderImage = function (img, x, y) {
        var $ = this.$;
        $.save();
        $.drawImage(img, x, y);
        $.restore();
    };
    Renderer.prototype.renderUnicorn = function (u) {
        this.renderImage(u.image, u.x, u.y);
    };
    return Renderer;
}());
//#endregion
//#region globals
var CANVAS = document.createElement('canvas');
var CTX = CANVAS.getContext('2d');
var WIDTH = (CANVAS.width = window.innerWidth);
var HEIGHT = (CANVAS.height = window.innerHeight);
var PI2 = 2 * Math.PI;
var GRAVITY = 0.125;
var COLOR_FADE = 0.01;
var COLORS = [
    '#9400D3',
    '#4B0082',
    '#0000FF',
    '#00FF00',
    '#FFFF00',
    '#FF7F00',
    '#FF0000'
];
var RENDERER = new Renderer(CTX);
var TILES = [];
var PARTICLES = [];
var PARTICLE_COUNT = 40;
var UNICORN_IMAGE = document.getElementById('unicorn');
var UNICORN = new Unicorn(UNICORN_IMAGE);
//#endregion
//#region utils
function randomColor() {
    return sample(COLORS);
}
function randomNumber(min, max) {
    return Math.random() * (max - min) + min;
}
function randomBoolean() {
    return Math.random() > 0.5;
}
function sample(a) {
    return a[Math.floor(Math.random() * a.length)];
}
function outsideScreen(p) {
    var diameter = p.radius * 2;
    var yExceeded = p.y - diameter > HEIGHT || p.y + diameter < 0;
    var xExceeded = p.x - diameter > WIDTH || p.x + diameter < 0;
    return yExceeded || xExceeded;
}
//#endregion
//#region animation
function updateParticle(p) {
    p.vy += GRAVITY;
    p.y += p.vy;
    p.x += p.vx;
    if (p.opacity > COLOR_FADE) {
        p.opacity -= COLOR_FADE;
    }
    if (outsideScreen(p)) {
        ParticleFactory.reset(p);
    }
}
function updateUnicorn(unicorn) {
    var image = unicorn.image;
    var centerX = WIDTH / 2 - image.width / 2;
    var centerY = HEIGHT / 2 - image.height / 2 - 50;
    var radiusX = 20;
    var radiusY = 8;
    unicorn.x = centerX + Math.cos(unicorn.angle) * radiusX;
    unicorn.y = centerY + Math.sin(unicorn.angle) * radiusY;
    unicorn.angle += unicorn.va;
}
function animation() {
    requestAnimationFrame(animation);
    RENDERER.clearScreen();
    TILES.forEach(updateTile);
    TILES.forEach(RENDERER.renderTile);
    PARTICLES.forEach(updateParticle);
    PARTICLES.forEach(RENDERER.renderStar);
    if (UNICORN_IMAGE.complete) {
        updateUnicorn(UNICORN);
        RENDERER.renderUnicorn(UNICORN);
    }
}
function createParticles() {
    for (var i = PARTICLE_COUNT; i > 0; --i) {
        var p = ParticleFactory.create({
            x: WIDTH / 2,
            y: HEIGHT / 2,
            vx: randomNumber(-14, -3),
            vy: randomNumber(-8, 2)
        });
        var i_1 = Math.floor(randomNumber(0, 60)) + 1;
        while (i_1--) {
            updateParticle(p);
        }
        PARTICLES.push(p);
    }
}
function updateTile(t) {
    t.vx -= GRAVITY;
    t.x += t.vx;
    t.y += t.vy;
    if (t.x + t.width < 0) {
        t.x = randomNumber(0, WIDTH) + WIDTH;
        t.vx = 0;
    }
}
function createTiles() {
    var tileCount = HEIGHT / 10;
    for (var i = tileCount; i > 0; --i) {
        var tileWidth = randomNumber(60, 120);
        var t = new Tile();
        t.opacity = randomNumber(0.1, 0.6);
        t.width = tileWidth;
        t.x = tileWidth * (i - 1);
        t.y = t.height * (i - 1);
        var ii = Math.floor(randomNumber(0, 260)) + 1;
        while (ii--) {
            updateTile(t);
        }
        TILES.push(t);
    }
}
function setup() {
    document.body.appendChild(CANVAS);
    var unicornX = WIDTH / 2 - UNICORN.image.width / 2;
    var unicornY = HEIGHT / 2 - UNICORN.image.height / 2;
    UNICORN.x = unicornX;
    UNICORN.y = unicornY;
    createTiles();
    createParticles();
}
function init() {
    setup();
    animation();
}
//#endregion

css

body {
    background: linear-gradient(180deg, #FF7F0022, white, #9400D322);
    box-sizing: border-box;
    margin: 0;
    overflow: hidden;
    text-align: center;
}

.made-by {
    position: absolute;
    bottom: 16px;
    right: 16px;
    padding: 8px 16px;
    background: white;
    color: hotpink;
    font-family: monospace;
    font-size: 12px;
}

效果

在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/445592.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

TCP/IP 七层架构模型

传输控制协议&#xff08;TCP&#xff0c;Transmission Control Protocol&#xff09;是一种面向连接的、可靠的、基于字节流的传输层通信协议。 套接字&#xff08;socket&#xff09;是一个抽象层&#xff0c;应用程序可以通过它发送或接收数据&#xff0c;可对其进行像对文…

【Linux】常用操作命令

目录 基本命令关机和重启帮助命令 用户管理命令添加用户&#xff1a;useradd 命令修改密码&#xff1a;passwd 命令查看登录用户&#xff1a;who 命令查看登录用户详细信息 :w切换用户 目录操作命令cdpwd命令目录查看 ls [-al] 目录操作【增&#xff0c;删&#xff0c;改&#…

NUMA(Non-Uniform Memory Access)架构的介绍

1. NUMA由来 最早的CPU是以下面这种形式访问内存的&#xff1a; 在这种架构中&#xff0c;所有的CPU都是通过一条总线来访问内存&#xff0c;我们把这种架构叫做SMP架构&#xff08;Symmetric Multi-Processor&#xff09;&#xff0c;也就是对称多处理器结构。可以看出来&…

Uniapp开发模板unibest

&#x1f3e0;简介 unibest 是一个集成了多种工具和技术的 uniapp 开发模板&#xff0c;由 uniapp Vue3 Ts Vite4 UnoCss uv-ui VSCode 构建&#xff0c;模板具有代码提示、自动格式化、统一配置、代码片段等功能&#xff0c;并内置了许多常用的基本组件和基本功能&#…

【PowerMockito:编写单元测试过程中原方法使用@Value注解注入的属性出现空指针】

错误场景 执行到Value的属性时会出现空指针&#xff0c;因为Value的属性为null 解决方法 在测试类调用被测试方法前&#xff0c;提前设置属性值&#xff0c;属性可以先自己定义好 ReflectionTestUtils.setField(endpointConnectionService, "exportUdpList", lis…

Linux 之七:Linux 防火墙 和进程管理

防火墙 查看防火墙 查看 Centos7 的防火墙的状态 sudo systemctl status firewalld。 查看后&#xff0c;看到active(running)就意味着防火墙打开了。 关闭防火墙&#xff0c;命令为&#xff1a; sudo systemctl stop firewalld。 关闭后查看是否关闭成功&#xff0c;如果…

【机器学习】一文掌握逻辑回归全部核心点(上)。

逻辑回归核心点-上 1、引言2、逻辑回归核心点2.1 定义与目的2.2 模型原理2.2.1 定义解析2.2.2 公式2.2.3 代码示例 2.3 损失函数与优化2.3.1 定义解析2.3.2 公式2.3.3 代码示例 2.4 正则化2.4.1 分类2.4.2 L1正则化2.4.3 L2正则化2.4.4 代码示例 3、总结 1、引言 小屌丝&#…

从空白镜像创建Docker hello world

文章目录 写在前面基础知识方法一&#xff1a;使用echo工具方法二&#xff0c;使用c语言程序方法三&#xff0c;使用汇编语言小结 写在前面 尝试搞了下docker&#xff0c;网上的教程大多是让下载一个ubuntu这种完整镜像&#xff0c;寥寥几篇从空白镜像开始创建的&#xff0c;也…

Oracle VM VirtualBox安装Ubuntu桌面版

背景&#xff1a;学习Docker操作 虚拟机软件&#xff1a;Oracle VM VirtualBox 7.0 系统镜像&#xff1a;ubuntu-20.04.6-desktop-amd64.iso 在Oracle VM VirtualBox新建一个虚拟电脑 选择好安装的目录和选择系统环境镜像 设置好自定义的用户名、密码、主机名 选择一下运行内…

执行除法运算返回浮点数结果operator.truediv()返回商的整数部分operator.floordiv()

【小白从小学Python、C、Java】 【计算机等考500强证书考研】 【Python-数据分析】 执行除法运算 返回浮点数结果 operator.truediv() 返回商的整数部分 operator.floordiv() 下列选项可以执行除法运算并得到浮点数结果的是&#xff08;&#xff09; import operator print(&…

凌鲨微应用架构

微应用是静态网页加上凌鲨提供的扩展能力而形成的一种应用&#xff0c;主要特点是开发便捷&#xff0c;安全。 微应用架构 组件说明 名称 说明 微应用 webview窗口&#xff0c;显示web服务器上的页面 接口过滤器 根据权限配置,屏蔽非授权接口访问 接口提供者 tauri注入…

文件操作上(c语言)

目录 1. 文件的作用2. 什么是文件2.1 程序文件2.2 数据文件2.3 文件名 3. 二进制文件和文本文件4. 文件的打开和关闭4.1 流和标准流4.1.1 流4.1.2 标准流 4.2 文件指针4.3 文件的打开与关闭4.3.1 文件的打开模式4.3.2 实例代码 1. 文件的作用 使用文件可以将数据进行持久化的保…

P1958 上学路线

难度&#xff1a;普及- 题目描述 你所在城市的街道好像一个棋盘&#xff0c;有 a 条南北方向的街道和 b 条东西方向的街道。南北方向的 a 条街道从西到东依次编号为 1 到 a&#xff0c;而东西方向的 b 条街道从南到北依次编号为 1 到 b&#xff0c;南北方向的街道 i 和东西方…

【期刊】ACM Transactions on Privacy and Security

首页截图 subject areas 混合模式 根据官网介绍&#xff0c;本期刊不在金OA行列&#xff0c;可以自主选择出版模式。 出版方向 Topics of interest include 发文量 季刊&#xff0c;发文量很小 图像安全领域 未在今年发表图像安全领域论文。

ARM基础----STM32处理器操作模式

STM32处理器操作模式 Cortex-M处理器操作模式、特权等级和栈指针操作模式栈指针CONTROL寄存器异常压栈时的SP指针 Cortex-A 处理器运行模型寄存器组 Cortex-M处理器操作模式、特权等级和栈指针 操作模式 处理模式&#xff1a;执行中断服务程序等异常处理&#xff0c;处理器具有…

SpringBoot自定义banner,自定义logo

SpringBoot自定义banner&#xff0c;自定义logo 在线网站 http://www.network-science.de/ascii/?spma2c6h.12873639.article-detail.9.7acc2c9aSTnQdW https://www.bootschool.net/ascii?spma2c6h.12873639.article-detail.8.7acc2c9aSTnQdW https://patorjk.com/softwa…

继承杂谈。

内容一览 前言继承的概念及定义继承的意义继承关系及访问限定符父类和子类对象之间的转化继承后的作用域继承与有元继承与静态成员多继承继承和组合的区别&#xff1a;继承的总结和反思 前言 面向对象的三大特性&#xff1a;封装继承和多态&#xff0c;这三种特性优者很紧密地联…

基于神经网络的偏微分方程求解器再度取得突破,北大字节的研究成果入选Nature子刊

目录 一.引言:神经网络与偏微分方程 二.如何基于神经网络求解偏微分方程 1.简要概述 2.基于神经网络求解偏微分方程的三大方向 2.1数据驱动 基于CNN 基于其他网络 2.2物理约束 PINN 基于 PINN 可测量标签数据 2.3物理驱动(纯物理约束) 全连接神经网路(FC-NN) CN…

C++特殊类设计【特殊类 || 单例对象 || 饿汉模式 || 懒汉模式】

目录 一&#xff0c;特殊类设计 1. 只在堆上创建的类 2. 只允许在栈上创建的类 3. 不能被继承的类 4. 不能被拷贝的类 5. 设计一个类&#xff0c;只能创建一个对象&#xff08;单例对象&#xff09; 饿汉模式 懒汉模式 C11静态成员初始化多线程安全问题 二&#xff…

Android14 Handle机制

Handle是进程内部, 线程之间的通信机制. handle主要接受子线程发送的数据, 并用此数据配合主线程更新UI handle可以分发Message对象和Runnable对象到主线程中, 每个handle实例, 都会绑定到创建他的线程中, 它有两个作用,: (1) 安排消息在某个主线程中某个地方执行 (2) 安排…