unity随机生成未知符号教程

news2025/6/7 18:09:01

目录

  • 前言
  • 方法1
  • 方法2
  • 脚本
  • 后言
  • 示例代码

前言

在某些游戏中，有一些让人感到意味不明的未知符号，例如在游戏《巴别塔圣歌》中，就有这样一些能让人在初次就看不懂的未知符号。

在这里插入图片描述

或者在其他时候，这些未知符号如果跟粒子系统结合在一起的话，也可以当作是一种特效，可以增加游戏的神秘感。

而现在，如果你想学的话，那么现在就可以开始学了。

方法1

首先讲最简单的方法，最简单的就先随机地显示Wingdings字体的字符，然后在随机显示字符后等待一小会即可，这个对于很多人来说都容易去理解，但是，这个方法主要的难点是如何将TextMeshPro中的字体设为Wingdings字体，因此，接下来就要详细的讲一下如何更改TextMeshPro组件的字体。

  1. 打开文件资源管理器；

  2. 转到C:\Windows\Fonts，选取里面的Wingdings 常规；

  1. 将Wingdings 常规拖到unity的项目栏里，并右键选中拖过来的字体，创建TextMeshPro的Wingdings字体资产。

  1. 将TextMeshPro组件的字体属性(Font Asset)设为刚才得到的Wingdings字体资产，TextMeshPro组件的字体也更改好了。

其他只要你学过unity，实现起来就简单，这里就直接上方法了(想用这个方法得需要TextMeshPro组件)。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Unity.Collections;
using Unity.VisualScripting;
using System.Runtime.CompilerServices;
using TMPro;

public class randomSymbolSummon : MonoBehaviour
{
    public float waitTime = 0.1f;
    private bool isEnd = true;
    private char[] chars;
    IEnumerator write()
    {
        isEnd = false;
        GetComponent<TextMeshPro>().text = chars[Random.Range(0, chars.Length)].ToString();
        yield return new WaitForSeconds(waitTime);
        isEnd = true;
    }

    void Start()
    {
        chars = new char[127 - 33];
        char ch = (char)33;
        for (; ch < 127; ch++)
        {
            chars[ch - 33] = ch;
        }
        write();
    }

    void Update()
    {
        if (isEnd)
        {
            StartCoroutine(write());
        }
    }
}

下面就是最简单的方法的效果。

方法2

然后来讲难一点的方法，难一点的方法呢，它的核心就是一个可以当作是用于写符号的笔的指针在点上随机移动。

首先，我们要定义一些公有的成员变量。就如点离点的距离，“画板”的长与宽，是否只显示一次符号，线的渲染，线的宽度及等待时间。然后，新建一个summon方法，这将是我们生成方法2中的符号的核心方法。

public float space = 0.809f;
public uint a = 2;
public uint b = 3;
public Material lineMaterial;
public float lineWidth = 0.1f;
public float waitTime = 0.1f;
private bool isEnd = true;

private void summon()
{

}

然后，我们在Start方法里调用一下summon方法，这将使对象一开始就能生成未知符号，并在Update函数里面设置执行summon方法的条件，只有能显示多次符号，并且等会实现的write协程已经执行完毕，那么就才能执行write协程。

write协程，我们要让它能等待，就需要yield return和新定义的isEnd变量，因此，刚才就需要什么方法就很明了了。顺带一提醒，就是Start方法及Update等方法都不能是协程，这点unity萌新一定要注意！

void Start()
{
    summon();
}

void Update()
{
    if (!summonOneShot && isEnd)
    {
        StartCoroutine(write());
    }
}

接着，就要实现主要的summon方法了，首先根据“画板”的长与宽和点离点的距离，我们定义一个数组，数组大小为 ( a + 1 ) ( b + 1 ) (a+1)(b+1) (a+1)(b+1)。为了省事，可以在Start方法内让a和b各自增1。并通过指针来一个个的设置点的位置。

private void summon()
{
        Vector3[] dots = new Vector3[a * b];
        for (int doti = 0; doti < dots.Length; ++doti)
        {
            dots[doti] = new Vector3(doti % a * space, doti / a * -space, 0);
        }
}

void Start()
{
    a++;
    b++;
    summon();
}

之后定义一个Vector3的paths可变数组，一个有8个bool的canMove数组，和一个有8个int的modeMove数组，初始化modeMove数组时，将modeMove数组第3项和第4项分别设为-1和1。

随后，我们知道，在二维数组中，指针移动二维数组的长度位，就是将指针以垂直方向移动。因此，就可以用变量a来设置modeMove数组。

private void summon()
{
        Vector3[] dots = new Vector3[a * b];
        for (int doti = 0; doti < dots.Length; ++doti)
        {
            dots[doti] = new Vector3(doti % a * space, doti / a * -space, 0);
        }
        List<Vector3> paths = new List<Vector3>(); 
        bool[] canMove = new bool[8]; 
        int[] modeMove = { 0, 0, 0, -1, 1, 0, 0, 0 }; 
        for (int modei = 0, step = (int)a + 1; modei < 3; ++modei) { 
            modeMove[modei] = -step; 
            modeMove[modeMove.Length - 1 - modei] = step--; 
        }
}

我们需要设定一个绘制符号的结束条件，结束条件呢，就是这个“笔”移到了“画板”每一行及每一列的点，因此，我们就定义一个bool类型的大小为 a + b a+b a+b的dotMove数组，如果dotMove数组全是真，那么等于“笔”移到了第 1 ∼ a 1\sim a 1∼a列的所有点和第 1 ∼ b 1\sim b 1∼b行的所有点了。就需要一个check方法来检测dotMove是否全是真。

且结束条件为真时，由于“笔”可能还有一次画的操作，但是“笔”不能回头，所以就也要定义lastDraw的变量和mode变量了。

private bool check(bool[] dotMove)
{
    foreach (bool b in dotMove)
    {
        if (!b)
        {
            return false;
        }
    }
    return true;
}

private void summon()
{
        Vector3[] dots = new Vector3[a * b];
        for (int doti = 0; doti < dots.Length; ++doti)
        {
            dots[doti] = new Vector3(doti % a * space, doti / a * -space, 0);
        }
        List<Vector3> paths = new List<Vector3>(); 
        bool[] canMove = new bool[8]; 
        int[] modeMove = { 0, 0, 0, -1, 1, 0, 0, 0 }; 
        for (int modei = 0, step = (int)a + 1; modei < 3; ++modei) { 
            modeMove[modei] = -step; 
            modeMove[modeMove.Length - 1 - modei] = step--; 
        }
        bool[] dotMove = new bool[a + b];
        int mode = 0;
        bool LastDraw = 1 == Random.Range(0, 2);
        while (check(dotMove) || LastDraw)
        {
            
            if (check(dotMove))
            {
                canMove[7 - mode] = false;
                LastDraw = false;
            }
        }
}

而在summon方法中，我们要对“笔”移动到的点检测一下，假如dots是一个长为 a + 1 a+1 a+1，宽为 b + 1 b+1 b+1的二维数组，就要让pos指针分别去通过运算符%和/与 a + 1 a+1 a+1进行运算，从而得到pos在dots二维数组中的坐标，就可以设置dots数组项的值。

private bool check(bool[] dotMove)
{
    foreach (bool b in dotMove)
    {
        if (!b)
        {
            return false;
        }
    }
    return true;
}

private void summon()
{
        Vector3[] dots = new Vector3[a * b];
        for (int doti = 0; doti < dots.Length; ++doti)
        {
            dots[doti] = new Vector3(doti % a * space, doti / a * -space, 0);
        }
        List<Vector3> paths = new List<Vector3>(); 
        bool[] canMove = new bool[8]; 
        int[] modeMove = { 0, 0, 0, -1, 1, 0, 0, 0 }; 
        for (int modei = 0, step = (int)a + 1; modei < 3; ++modei) { 
            modeMove[modei] = -step; 
            modeMove[modeMove.Length - 1 - modei] = step--; 
        }
        bool[] dotMove = new bool[a + b];
        bool LastDraw = 1 == Random.Range(0, 2);
        while (check(dotMove) || LastDraw)
        {
            
            if (check(dotMove))
            {
                canMove[7 - mode] = false;
                LastDraw = false;
            }
            dotMove[pos % a] = true;
            dotMove[a + pos / a] = true;
        }
}

之后，我们定义一个pos变量，将他的值设为0到 a b − 1 ab-1 ab−1内的随机值，这代表了“笔”的位置，并将这个位置传到paths数组里，作为方法2中符号的起点。再接着，我们就设置“笔”要移动的方向。

“笔”方向有8种，“↖↑↗←→↙↓↘”这些全都是(分别代表了0~7的数字，这以后会用到)。因此，刚才定义的canMove和modeMove数组大小都为8个，并且，假设有一个方向 x x x，因为 x + x 反 = 7 x+x_反=7 x+x反​=7，那么它的反方向就是 7 − x 7-x 7−x，因此，刚才就将canMove[7 - mode]设为假，就不让他回头了。

转到正题，要设置“笔”要移动的方向，就要检测这8个方向中可以移动的方向，就要用到canMove数组中的每一项作标记。

如果某个方向不能移动，那么就说明到了dots数组的边界旁，假如让一个指针分别去通过运算符%和/与二维数组的长进行运算，那么可以获得二维数组的坐标，我们就可以设置canMove数组。

private bool check(bool[] dotMove)
{
    foreach (bool b in dotMove)
    {
        if (!b)
        {
            return false;
        }
    }
    return true;
}

private void summon()
{
        Vector3[] dots = new Vector3[a * b];
        for (int doti = 0; doti < dots.Length; ++doti)
        {
            dots[doti] = new Vector3(doti % a * space, doti / a * -space, 0);
        }
        List<Vector3> paths = new List<Vector3>(); 
        bool[] canMove = new bool[8]; 
        int[] modeMove = { 0, 0, 0, -1, 1, 0, 0, 0 }; 
        for (int modei = 0, step = (int)a + 1; modei < 3; ++modei) { 
            modeMove[modei] = -step; 
            modeMove[modeMove.Length - 1 - modei] = step--; 
        }
        bool[] dotMove = new bool[a + b];
        bool LastDraw = 1 == Random.Range(0, 2);
        while (check(dotMove) || LastDraw)
        {
            canMove[1] = (0 != pos / a); 
            canMove[3] = (0 != pos % a); 
            canMove[4] = ((a - 1) != pos % a); 
            canMove[6] = ((b - 1) != pos / a); 
            canMove[0] = (canMove[1] && canMove[3]); 
            canMove[2] = (canMove[1] && canMove[4]); 
            canMove[5] = (canMove[6] && canMove[3]); 
            canMove[7] = (canMove[6] && canMove[4]);
            if (check(dotMove))
            {
                canMove[7 - mode] = false;
                LastDraw = false;
            }
            dotMove[pos % a] = true;
            dotMove[a + pos / a] = true;
        }
}

那么，我们就因此定义一个mode变量来从这些可以移动的方向中选取其中的一个让pos移动了，在pos移动之后，我们就将pos移动到的点添加进paths数组里，一次pos移动的操作就完成了。以此往复下去，一个完全随机的paths数组生成了。

private bool check(bool[] dotMove)
{
    foreach (bool b in dotMove)
    {
        if (!b)
        {
            return false;
        }
    }
    return true;
}

private void summon()
{
        Vector3[] dots = new Vector3[a * b];
        for (int doti = 0; doti < dots.Length; ++doti)
        {
            dots[doti] = new Vector3(doti % a * space, doti / a * -space, 0);
        }
        List<Vector3> paths = new List<Vector3>(); 
        bool[] canMove = new bool[8]; 
        int[] modeMove = { 0, 0, 0, -1, 1, 0, 0, 0 }; 
        for (int modei = 0, step = (int)a + 1; modei < 3; ++modei) { 
            modeMove[modei] = -step; 
            modeMove[modeMove.Length - 1 - modei] = step--; 
        }
        bool[] dotMove = new bool[a + b];
        int mode = 0;
        bool LastDraw = 1 == Random.Range(0, 2);
        while (check(dotMove) || LastDraw)
        {
            canMove[1] = (0 != pos / a); 
            canMove[3] = (0 != pos % a); 
            canMove[4] = ((a - 1) != pos % a); 
            canMove[6] = ((b - 1) != pos / a); 
            canMove[0] = (canMove[1] && canMove[3]); 
            canMove[2] = (canMove[1] && canMove[4]); 
            canMove[5] = (canMove[6] && canMove[3]); 
            canMove[7] = (canMove[6] && canMove[4]);
            if (check(dotMove))
            {
                canMove[7 - mode] = false;
                LastDraw = false;
            }
            dotMove[pos % a] = true;
            dotMove[a + pos / a] = true;
            mode = Random.Range(0, 8);
            while (!canMove[mode])
            {
                mode = Random.Range(0, 8);
            }
            pos += modeMove[mode];
            paths.Add(dots[pos]);
        }
}

此时，就可以用这个paths数组来设置Unity组件LineRenderer的线条了，不过要设置线条，得先设置线条端点的数量，后设置线条，由于pos移动的路径就是线条，用paths数组设置线条就很合适。

private bool check(bool[] dotMove)
{
    foreach (bool b in dotMove)
    {
        if (!b)
        {
            return false;
        }
    }
    return true;
}

private void summon()
{
        Vector3[] dots = new Vector3[a * b];
        for (int doti = 0; doti < dots.Length; ++doti)
        {
            dots[doti] = new Vector3(doti % a * space, doti / a * -space, 0);
        }
        List<Vector3> paths = new List<Vector3>(); 
        bool[] canMove = new bool[8]; 
        int[] modeMove = { 0, 0, 0, -1, 1, 0, 0, 0 }; 
        for (int modei = 0, step = (int)a + 1; modei < 3; ++modei) { 
            modeMove[modei] = -step; 
            modeMove[modeMove.Length - 1 - modei] = step--; 
        }
        bool[] dotMove = new bool[a + b];
        int mode = 0;
        bool LastDraw = 1 == Random.Range(0, 2);
        while (check(dotMove) || LastDraw)
        {
            canMove[1] = (0 != pos / a); 
            canMove[3] = (0 != pos % a); 
            canMove[4] = ((a - 1) != pos % a); 
            canMove[6] = ((b - 1) != pos / a); 
            canMove[0] = (canMove[1] && canMove[3]); 
            canMove[2] = (canMove[1] && canMove[4]); 
            canMove[5] = (canMove[6] && canMove[3]); 
            canMove[7] = (canMove[6] && canMove[4]);
            if (check(dotMove))
            {
                canMove[7 - mode] = false;
                LastDraw = false;
            }
            dotMove[pos % a] = true;
            dotMove[a + pos / a] = true;
            mode = Random.Range(0, 8);
            while (!canMove[mode])
            {
                mode = Random.Range(0, 8);
            }
            pos += modeMove[mode];
            paths.Add(dots[pos]);
        }
        GetComponent<LineRenderer>().positionCount = paths.Count;
        GetComponent<LineRenderer>().SetPositions(paths.ToArray());
}

做到这里，还有几个问题没有解决。

  1. 变量a或b不能为0，space不能为0。

解决方法：只需要在Start方法一开始判断a，b或space为0即可，如果条件达成，就将它们设为默认值。

void Start()
{
    a = (0 == a ? 2 : a + 1);
    b = (0 == a ? 3 : b + 1);
    space = (0 == space ? 0.809f : space);
    summon();
}
  1. 有时对象并没有LineRenderer组件，却仍要获取对象的LineRenderer组件，并且必须将LineRenderer使用世界空间的开关关掉。

解决方法：如果没有LineRenderer组件，就为它进行初始化，并强制将组件的useWorldSpace给设为假，让符号一直在物体上。

void Start()
{
    a = (0 == a ? 2 : a + 1);
    b = (0 == a ? 3 : b + 1);
    space = (0 == space ? 0.809f : space);
    if (null == GetComponent<LineRenderer>())
    {
        transform.AddComponent<LineRenderer>();
        GetComponent<LineRenderer>().material = lineMaterial;
        GetComponent<LineRenderer>().startWidth = GetComponent<LineRenderer>().endWidth = lineWidth;
    }
    GetComponent<LineRenderer>().useWorldSpace = false;
    summon();
}

这些解决方法弄完之后，也就可以开始看方法2中生成的符号是什么样了。下面就是方法2的效果。

脚本

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Unity.Collections;
using Unity.VisualScripting;
using System.Runtime.CompilerServices;

public class randomSymbolSummon : MonoBehaviour
{
    public float space = 0.809f;
    public uint a = 2;
    public uint b = 3;
    public Material lineMaterial;
    public float lineWidth = 0.1f;
    public float waitTime = 0.1f;
    private bool isEnd = true;
    public bool summonOneShot = false;
    
    private bool check(bool[] dotMove)
    {
        foreach (bool b in dotMove)
        {
            if (!b)
            {
                return false;
            }
        }
        return true;
    }
    private void summon()
    {
        Vector3[] dots = new Vector3[a * b];
        for (int doti = 0; doti < dots.Length; ++doti)
        {
            dots[doti] = new Vector3(doti % a * space, doti / a * -space, 0);
        }
        List<Vector3> paths = new List<Vector3>();
        bool[] canMove = new bool[8];
        int[] modeMove = { 0, 0, 0, -1, 1, 0, 0, 0 };
        for (int modei = 0, step = (int)a + 1; modei < 3; ++modei)
        {
            modeMove[modei] = -step;
            modeMove[modeMove.Length - 1 - modei] = step--;
        }
        bool[] dotMove = new bool[a + b];
        int pos = Random.Range(0, (int)(a * b));
        int mode = 0;
        bool LastDraw = 1 == Random.Range(0, 2);
        paths.Add(dots[pos]);
        while (!check(dotMove) || LastDraw)
        {
            canMove[1] = (0 != pos / a);
            canMove[3] = (0 != pos % a);
            canMove[4] = ((a - 1) != pos % a);
            canMove[6] = ((b - 1) != pos / a);
            canMove[0] = (canMove[1] && canMove[3]);
            canMove[2] = (canMove[1] && canMove[4]);
            canMove[5] = (canMove[6] && canMove[3]);
            canMove[7] = (canMove[6] && canMove[4]);
            if (check(dotMove))
            {
                canMove[7 - mode] = false;
                LastDraw = false;
            }
            dotMove[pos % a] = true;
            dotMove[a + pos / a] = true;
            mode = Random.Range(0, 8);
            while (!canMove[mode])
            {
                mode = Random.Range(0, 8);
            }
            pos += modeMove[mode];
            paths.Add(dots[pos]);
        }
        GetComponent<LineRenderer>().positionCount = paths.Count;
        GetComponent<LineRenderer>().SetPositions(paths.ToArray());
    }
    IEnumerator write()
    {
        isEnd = false;
        yield return new WaitForSeconds(waitTime);
        summon();
        isEnd = true;
    }
    // Start is called before the first frame update
    void Start()
    {
        a = (0 == a ? 2 : a + 1);
        b = (0 == a ? 3 : b + 1);
        space = (0 == space ? 0.809f : space);
        if (null == GetComponent<LineRenderer>())
        {
            transform.AddComponent<LineRenderer>();
            GetComponent<LineRenderer>().material = lineMaterial;
            GetComponent<LineRenderer>().startWidth = GetComponent<LineRenderer>().endWidth = lineWidth;
        }
        GetComponent<LineRenderer>().useWorldSpace = false;
        summon();
    }

    void Update()
    {
        if (!summonOneShot && isEnd)
        {
            StartCoroutine(write());
        }
    }
}

后言

刚才看到的这些符号，如果用粒子系统搭配的话，使你的游戏就能更好。但是，实际上，你却很难在unity原生的粒子系统上实现这个事情。因此，就得要一个自创的粒子系统，下篇博文教你如何自创粒子系统。

示例代码

  • 方法1

  • 方法2

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

基于RK3576+FPGA+AI工业控制器的工地防护检测装备解决方案

基于RK3576+FPGA+AI工业控制器的工地防护检测装备解决方案

1.2.1 工地防护检测技术研究现状 在建筑施工的过程中&#xff0c;工人被要求暴露在危险的环境中作业 [2]。因此&#xff0c;防护装备 对于工人的安全与健康具有非常重要的意义[3]。工地工人必须佩戴适当的防护装备&#xff0c; 以降低意外伤害的风险。在过去的几十年里&#x…
阅读更多...
推荐一款PDF压缩的工具

推荐一款PDF压缩的工具

今天一位小伙伴找来&#xff0c;问我有没有办法将PDF变小的办法。 详细了解了一下使用场景&#xff1a; 小伙伴要在某系统上传一个PDF文件&#xff0c;原文件是11.6MB&#xff0c;但是上传时系统做了限制&#xff0c;只能上传小于10MB的文件&#xff0c;如图&#xff1a; 我听…
阅读更多...
混沌映射（Chaotic Map）

混沌映射（Chaotic Map）

一.定义 混沌映射是指一类具有混沌行为的离散时间非线性动力系统&#xff0c;通常由递推公式定义。其数学形式为 &#xff0c;其中 f 是非线性函数&#xff0c;θ 为参数。它们以简单的数学规则生成复杂的、看似随机的轨迹&#xff0c;是非线性动力学和混沌理论的重要研究对象…
阅读更多...
《PyTorch Hub：解锁深度学习模型的百宝箱》

《PyTorch Hub：解锁深度学习模型的百宝箱》

走进 PyTorch Hub 在当今的深度学习领域，模型的复用和共享已成为推动技术飞速发展的关键力量。随着深度学习在计算机视觉、自然语言处理、语音识别等众多领域取得突破性进展，研究人员和开发者们不断探索更高效、更强大的模型架构。然而，从头开始训练一个深度学习模型往往需要…
阅读更多...
数据结构 堆与优先级队列

数据结构 堆与优先级队列

文章目录 &#x1f4d5;1. 堆(Heap)✏️1.1 堆的概念✏️1.2 堆的存储方式✏️1.3 堆的创建✏️1.4 堆的插入✏️1.5 堆的删除 &#x1f4d5;2. 优先级队列(PriorityQueue)✏️2.1 堆与优先级队列的关系✏️2.2 优先级队列的构造方法✏️2.3 优先级队列的常用方法 3. Java对象的…
阅读更多...
用好 ImageFX，解锁游戏素材生成新姿势：从入门到进阶

用好 ImageFX，解锁游戏素材生成新姿势：从入门到进阶

用好 ImageFX&#xff0c;解锁游戏素材生成新姿势&#xff1a;从入门到进阶 (备注)大陆ip无法访问到imagefx 地址:https://labs.google/fx/zh/tools/image-fx 对于独立游戏开发者和小型团队而言&#xff0c;美术资源往往是项目推进中的一大痛点。预算有限、专业美术人员缺乏…
阅读更多...
01-Redis介绍与安装

01-Redis介绍与安装

01-Redis介绍与安装 SQL与NoSQL SQLNoSQL数据结构结构化非结构化数据关联关联的非关联的查询方式SQL查询非SQL事务特性ACIDBASE存储方式磁盘内存拓展性垂直水平使用场景1、数据结构固定2、相关业务对数据安全性、一致性要求较高1、数据结构不固定2、对安全性、一致性要求不高…
阅读更多...
VR博物馆推动现代数字化科技博物馆

VR博物馆推动现代数字化科技博物馆

VR博物馆&#xff1a;推动现代数字化科博馆新篇章 随着科技的飞速发展&#xff0c;虚拟现实&#xff08;Virtual Reality, VR&#xff09;技术已经逐渐渗透到我们生活的方方面面&#xff0c;其中&#xff0c;VR博物馆作为现代数字化科博馆的重要形式之一&#xff0c;以独特的优…
阅读更多...
Python爬虫之数据提取

Python爬虫之数据提取

本章节主要会去学习在爬虫中的如何去解析数据的方法&#xff0c;要学习的内容有&#xff1a; 响应数据的分类结构化数据如何提取非结构化数据如何提取正则表达式的语法以及使用jsonpath解析嵌套层次比较复杂的json数据XPath语法在Python代码中借助lxml模块使用XPath语法提取非…
阅读更多...
第2讲、Odoo深度介绍：开源ERP的领先者

第2讲、Odoo深度介绍：开源ERP的领先者

一、Odoo深度介绍&#xff1a;开源ERP的领先者 Odoo&#xff0c;其前身为OpenERP&#xff0c;是一款在全球范围内广受欢迎的开源企业管理软件套件。它不仅仅是一个ERP系统&#xff0c;更是一个集成了客户关系管理&#xff08;CRM&#xff09;、电子商务、网站构建、项目管理、…
阅读更多...
【TCP/IP和OSI模型以及区别——理论汇总】

【TCP/IP和OSI模型以及区别——理论汇总】

参考小林code和卡尔哥&#xff0c;感恩&#xff01; 网络基础篇 面试官您好&#xff01;OSI和TCP/IP是网络通信中两个关键模型&#xff0c;本质都是分层处理数据传输&#xff0c;但设计理念和应用场景差异很大。 OSI模型是理论上的七层架构&#xff0c;从下到上依次是物理层…
阅读更多...
STM32 I2C通信外设

STM32 I2C通信外设

1、外设简介 可变多主机 7位/10位寻址 10位寻址&#xff1a;起始之后的两个字节都作为寻址&#xff0c;第一个字节前5位是11110作为10位寻址的标志位 SMBus&#xff1a;系统管理总线&#xff0c;主要用于电源管理&#xff0c;与I2C类似 2、外设结构框图 比较器、自身地址寄…
阅读更多...
13. springCloud AlibabaSeata处理分布式事务

13. springCloud AlibabaSeata处理分布式事务

目录 一、分布式事务面试题 1.多个数据库之间如何处理分布式事务&#xff1f; 2.若拿出如下场景&#xff0c;阁下将如何应对? 3.阿里巴巴的Seata-AT模式如何做到对业务的无侵入? 4.对于分布式事务问题&#xff0c;你知道的解决方案有哪些?请你谈谈? 二、分布式事务问题…
阅读更多...
MySQL 表的内连和外连

MySQL 表的内连和外连

一、内连接 内连接实际上就是利用 where 子句对两种表形成的笛卡儿积进行筛选&#xff0c;前面学习的查询都是内连接&#xff0c;也是在开发过程中使用的最多的连接查询。 select 字段 from 表1 inner join 表2 on 连接条件 and 其他条件; 注意&#xff1a;前面学习的都是内连…
阅读更多...
VR线上展厅特点分析与优势

VR线上展厅特点分析与优势

VR线上展厅&#xff1a;特点、优势与实际应用 VR线上展厅&#xff0c;作为虚拟现实&#xff08;VR&#xff09;技术在展示行业的创新应用&#xff0c;正逐步改变着传统的展览方式。通过模拟真实的物理环境&#xff0c;为参观者提供身临其境的展览体验&#xff0c;成为展示行业…
阅读更多...
Python基于SVM技术的手写数字识别问题项目实战

Python基于SVM技术的手写数字识别问题项目实战

说明&#xff1a;这是一个机器学习实战项目&#xff08;附带数据代码文档&#xff09;&#xff0c;如需数据代码文档可以直接到文章最后关注获取。 1.项目背景 在当今数字化转型加速的时代&#xff0c;手写数字识别作为图像处理与机器学习领域的一个经典问题&#xff0c;具有广…
阅读更多...
2024年数维杯国际大学生数学建模挑战赛A题飞行器激光测速中的频率估计问题解题全过程论文及程序

2024年数维杯国际大学生数学建模挑战赛A题飞行器激光测速中的频率估计问题解题全过程论文及程序

2024年数维杯国际大学生数学建模挑战赛 A题 复合直升机的建模与优化控制问题 原题再现&#xff1a; &#xff08;一&#xff09; 问题的背景   空速&#xff0c;即飞机相对于空气的速度&#xff0c;是飞行期间需要监控的关键参数。空速与飞行状态密切相关&#xff0c;如迎角…
阅读更多...
DeepSeek+SpringAI实现流式对话

DeepSeek+SpringAI实现流式对话

大模型的响应速度通常是很慢的&#xff0c;为了避免用户用户能够耐心等待输出的结果&#xff0c;我们通常会使用流式输出一点点将结果输出给用户。 那么问题来了&#xff0c;想要实现流式结果输出&#xff0c;后端和前端要如何配合&#xff1f;后端要使用什么技术实现流式输出呢…
阅读更多...
【Spark征服之路-2.1-安装部署Spark（一）】

【Spark征服之路-2.1-安装部署Spark（一）】

实验目标&#xff1a; 本节课实验将完成Spark 4种部署模式的其中2种&#xff0c;分别是Local、Standalone模式。 实验准备工作&#xff1a; 三台linux虚拟机spark的压缩包 实验步骤&#xff1a; Spark-local Spark的Local模式仅需要单个虚拟机节点即可&#xff0c;无需启…
阅读更多...
VS代码生成工具ReSharper v2025.1——支持.NET 10和C# 14预览功能

VS代码生成工具ReSharper v2025.1——支持.NET 10和C# 14预览功能

实质上&#xff0c;ReSharper特征可用于C#&#xff0c;VB.net&#xff0c;XML&#xff0c;Asp.net&#xff0c;XAML和构建脚本。 使用ReSharper&#xff0c;你可以进行深度代码分析&#xff0c;智能代码协助&#xff0c;实时错误代码高亮显示&#xff0c;解决方案范围内代码分析…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023