Unity 局域网 物体同步

最新推荐文章于 2023-09-20 16:30:26 发布
最新推荐文章于 2023-09-20 16:30:26 发布
阅读量853 收藏 9
点赞数 2
分类专栏： Unity 文章标签： unity socket 即时通信 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43925843/article/details/106196678
版权

Unity 局域网 物体同步

代码很简单没有难度，都有注解，随便 康一康 就会了。
老规矩，直接上代码：

目录

局域网 EXE控制

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 局域网控制
/// </summary>
public class LANControl_ZH : MonoBehaviour
{
    //开启次数
    public  int _LANControlInt = 0;


    public static LANControl_ZH _LANControl;


    private void Awake()
    {
        _LANControl = this;

        switch (PlayerPrefs.GetInt("_LANControlInt"))
        {
            case 0:
                GetComponent<LANServer_ZH>().enabled = true;
                GetComponent<LANClient_ZH>().enabled = false;
                break;

            default:
                GetComponent<LANServer_ZH>().enabled = false;
                GetComponent<LANClient_ZH>().enabled = true;
                break;
        }

        Debug.Log(PlayerPrefs.GetInt("_LANControlInt"));


        _LANControlInt = PlayerPrefs.GetInt("_LANControlInt");
        _LANControlInt += 1;
        PlayerPrefs.SetInt("_LANControlInt", _LANControlInt);

        //限制本地访问exe次数
        if (PlayerPrefs.GetInt("_LANControlInt") > 2)
        {
            _LANControlInt = 0;

            PlayerPrefs.SetInt("_LANControlInt", _LANControlInt);

            Application.Quit();

        }
    }
}

局域网 服务器

using System;
using System.Collections;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using UnityEngine;
using UnityEngine.UI;

public class LANServer_ZH : MonoBehaviour
{
    [Header("客户端地址")]
    public string _UDPClientIP;
    [Header("客户端端口")]
    public int _ConnectPort;
    [Header("发送字符")]
    public string _Send = "Maddie";
    [Header("接收字符")]
    private string _Receive;

    private Socket _Socket;
    private EndPoint _ClientEnd;
    private IPEndPoint _IpEnd;
    private string _SendStr;
    private byte[] _RecvData = new byte[1024];
    private byte[] _SendData = new byte[1024];
    private int _RecvLen;
    private Thread _ConnectThread;

    //可移动物体数组
    public List<GameObject> _ListTra;

    //可移动物体 坐标信息数据
    public List<string> _TraStr = new List<string>();

    // 接受客户端字符
    public Queue<string> _ClientTraStr = new Queue<string>();

    //移动物体名字
    private static string _StrTraMoveName = "";

    private void Start()
    {

        //在这里初始化 Server
        InitSocket();

        _ListTra.AddRange(GameObject.FindGameObjectsWithTag("移动"));
    }

    private void FixedUpdate()
    {
        //可选择 条件发送
        //SocketSend(_Send);
        if (Input.GetKeyDown(KeyCode.Space))
        {
            //向客户端发送信息
            StartCoroutine(SocketSendTra(_ListTra));
        }

        if (Input.GetKeyDown(KeyCode.Q))
        {
            //同步客户端 信息
            StartCoroutine(TraSynchronization(_ClientTraStr));
        }

        GameObject.Find("Text").GetComponent<Text>().text = "服务器： " + _Receive;
    }
    private void Update()
    {
        //向客户端发送信息
        StartCoroutine(SocketSendTra(_ListTra));
    }



    /// <summary>
    /// 初始化
    /// </summary>
    void InitSocket()
    {
        if (_UDPClientIP != null && _ConnectPort != 0)
        {
            _IpEnd = new IPEndPoint(IPAddress.Any, _ConnectPort);
            //  地址  端口
            //_IpEnd = new IPEndPoint(IPAddress.Parse(_UDPClientIP), _ConnectPort);

            //通信通道 设置
            _Socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            //绑定地址以及开放端口
            _Socket.Bind(_IpEnd);

            //定义客户端
            //IPEndPoint sender = new IPEndPoint(IPAddress.Any, 9631);
            IPEndPoint _Sender = new IPEndPoint(IPAddress.Parse(_UDPClientIP), _ConnectPort);
            _ClientEnd = _Sender;


            //开启一个线程连接
            _ConnectThread = new Thread(new ThreadStart(SocketReceive));
            _ConnectThread.Start();
        }
    }


    /// <summary>
    /// 服务器向客户端发送信息
    /// </summary>
    /// <param 可移动物体数组信息="_Tra"></param>
    private IEnumerator SocketSendTra(List<GameObject> _Tra)
    {
        //数组清空
        _TraStr.Clear();
        //移动物体 坐标添加
        for (int i = 0; i < _Tra.Count; i++)
        {
            //移动物体 位置  名字
            _TraStr.Add("(" + _Tra[i].transform.position.x.ToString() + "," + _Tra[i].transform.position.y + "," + _Tra[i].transform.position.z + ")" + "," + _Tra[i].name);

            //开辟内存空间
            _SendData = new byte[1024];
            // 字符转换
            _SendData = Encoding.UTF8.GetBytes(_TraStr[i]);
            //信息发送 客户端 
            _Socket.SendTo(_SendData, _SendData.Length, SocketFlags.None, _ClientEnd);

            Debug.Log("服务器：" + _TraStr[i]);
        }

        yield return 0;
    }

    /// <summary>
    /// 接收客户端信息
    /// </summary>
    void SocketReceive()
    {
        while (true)
        {
            //开发内存空间
            _RecvData = new byte[1024];
            try
            {
                //服务器消息接收
                _RecvLen = _Socket.ReceiveFrom(_RecvData, ref _ClientEnd);

                //判断接收到的信息 大于 0
                if (_RecvLen > 0)
                {
                    //数据转码
                    _Receive = Encoding.UTF8.GetString(_RecvData, 0, _RecvLen);
                    if (_Receive != "")
                    {
                        _ClientTraStr.Enqueue(_Receive);
                    }
                }
            }
            catch (Exception _Exception)
            {

            }
        }
    }


    /// <summary>
    /// 物体同步
    /// </summary>
    /// <param 传递坐标参数="_ClientTraStr"></param>
    private IEnumerator TraSynchronization(Queue<string> _ClientTraStr)
    {
        //判断传递字符是否为空
        if (GetRecvQueueStr() != null)
        {
            if (Parse(GetRecvQueueStr()) != null)
            {
                //移动物体 名字
                Debug.Log(_StrTraMoveName);

                for (int j = 0; j < _ListTra.Count; j++)
                {
                    //检测可移动数组传递名字是否在当前客户端数组里面
                    if (_StrTraMoveName == _ListTra[j].transform.name)
                    {
                        //解析传递字符 并更新位置
                        _ListTra[j].transform.position = Parse(GetRecvQueueStr());

                        //减去队列第一元素 
                        //_ClientTraStr.Dequeue();
                        continue;
                    }
                }
            }
        }

        //清除 传递字符串数组
        //_ClientTraStr.Clear();
        yield return 0;
    }


    /// <summary>
    /// 返回接收到的字符串
    /// </summary>
    /// <returns></returns>
    public string GetRecvQueueStr()
    {
        string _ReturnQueueStr;
        //加锁防止字符串被改
        lock (this)
        {
            if (_ClientTraStr.Count > 0)
            {//队列内有数据时，取出
                _ReturnQueueStr = _ClientTraStr.Dequeue();
                return _ReturnQueueStr;
            }
        }
        return null;
    }

    /// <summary>
    /// 字符串 转换 Vector3 
    /// </summary>
    /// <param 转接字符串="_Name"></param>
    /// <returns></returns>
    public static Vector3 Parse(string _Name)
    {
        _Name = _Name.Replace("(", "").Replace(")", "");
        string[] _Str = _Name.Split(',');
        _StrTraMoveName = _Str[3];
        return new Vector3(float.Parse(_Str[0]), float.Parse(_Str[1]), float.Parse(_Str[2]));
    }

    /// <summary>
    /// 连接关闭
    /// </summary>
    void SocketQuit()
    {
        //关闭线程
        if (_ConnectThread != null)
        {
            _ConnectThread.Interrupt();
            _ConnectThread.Abort();
        }
        //最后关闭socket
        if (_Socket != null)
        {
            _Socket.Close();
        }
        Debug.LogWarning("断开连接");
    }

    /// <summary>
    /// 在应用程序退出之前发送给所有游戏对象
    /// </summary>
    void OnApplicationQuit()
    {
        SocketQuit();
    }
}

局域网 客户端

using UnityEngine;
using System.Collections;
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using UnityEngine.UI;
using System.Collections.Generic;

/// <summary>
/// 局域网 客户端
/// </summary>
public class LANClient_ZH : MonoBehaviour
{
    [Header("服务器地址")]
    public string _UDPServerIP;
    [Header("服务器端口")]
    public int _ConnectPort;

    [Header("发送字符")]
    private string _Send;
    [Header("接受字符")]
    public string _Receive;



    private string _Str = "";
    private Socket _Socket;
    private EndPoint _ServerEnd;
    private IPEndPoint _IpEnd;

    private byte[] _RecvData = new byte[1024];
    private byte[] _SendData = new byte[1024];
    private int _RecvLen = 0;
    private Thread _ConnectThread;


    //需同步物体数组
    public List<GameObject> _ListTra;

    //服务器 接受字符
    public List<string> _ServerTraStr = new List<string>();

    //同步物体 坐标信息数据
    public List<string> _TraStr = new List<string>();

    //同步物体名字
    private static string _StrTraMoveName = "";


    void Start()
    {
        //_UDPClientIP = "192.168.1.106";//服务端的IP

        //删除字符串头部及尾部出现的空格
        _UDPServerIP = _UDPServerIP.Trim();

        _ListTra.AddRange(GameObject.FindGameObjectsWithTag("移动"));

        InitSocket();
    }
    private void FixedUpdate()
    {
        //if (Input.GetKeyDown(KeyCode.Space))
        {
            //接收服务器 信息
            StartCoroutine(TraSynchronization(_ServerTraStr));
        }
        if (Input.GetKeyDown(KeyCode.Q))
        {
            //向服务器发送信息
            StartCoroutine(ClientSendTra(_ListTra));
        }
        GameObject.Find("Text").GetComponent<Text>().text = "客户端： " + _Receive;
    }

    /// <summary>
    /// 初始化
    /// </summary>
    void InitSocket()
    {
        if (_UDPServerIP != null && _ConnectPort != 0)
        {
            //IP、端口赋予
            _IpEnd = new IPEndPoint(IPAddress.Parse(_UDPServerIP), _ConnectPort);
            //_IpEnd = new IPEndPoint(IPAddress.Any, _ConnectPort);

            //通信通道赋予
            _Socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);

            //客户端赋予
            //IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
            IPEndPoint _Sender = new IPEndPoint(IPAddress.Parse(_UDPServerIP), _ConnectPort);

            _ServerEnd = _Sender;

            print("等待连接");

            //字符串发送
            SocketSend(_Str);

            print("连接");
            //开启一个线程连接
            _ConnectThread = new Thread(new ThreadStart(SocketReceive));
            _ConnectThread.Start();
        }
    }

    /// <summary>
    /// 字符串发送到服务器  (握手)
    /// </summary>
    /// <param 需要发送的信息="_SendStr"></param>
    void SocketSend(string _SendStr)
    {
        //清空
        _SendData = new byte[1024];
        //数据转换
        _SendData = Encoding.UTF8.GetBytes(_SendStr);
        //发送给指定服务端
        _Socket.SendTo(_SendData, _SendData.Length, SocketFlags.None, _IpEnd);
    }

    /// <summary>
    /// 接收服务器信息
    /// </summary>
    void SocketReceive()
    {
        while (true)
        {

            _RecvData = new byte[1024];
            try
            {
                //服务器消息接收
                _RecvLen = _Socket.ReceiveFrom(_RecvData, ref _ServerEnd);

                //判断接收到的信息 大于 0
                if (_RecvLen > 0)
                {
                    //数据转码
                    _Receive = Encoding.UTF8.GetString(_RecvData, 0, _RecvLen);
                    if (_Receive != "")
                    {
                        _ServerTraStr.Add(_Receive);
                    }
                }
            }
            catch (Exception)
            {

            }
        }
    }

    /// <summary>
    /// 字符串发送到服务器
    /// </summary>
    /// <param 需要发送的信息="_Tra"></param>
    private IEnumerator ClientSendTra(List<GameObject> _Tra)
    {
        //数组清空
        _TraStr.Clear();
        //移动物体 坐标添加
        for (int i = 0; i < _Tra.Count; i++)
        {
            //移动物体 位置  名字
            _TraStr.Add("(" + _Tra[i].transform.position.x.ToString() + "," + _Tra[i].transform.position.y + "," + _Tra[i].transform.position.z + ")" + "," + _Tra[i].name);

            //开辟内存空间
            _SendData = new byte[1024];
            // 字符转换
            _SendData = Encoding.UTF8.GetBytes(_TraStr[i]);
            //信息发送 客户端 
            _Socket.SendTo(_SendData, _SendData.Length, SocketFlags.None, _IpEnd);
        }

        yield return 0;
    }

    /// <summary>
    /// 物体同步
    /// </summary>
    /// <param 传递坐标参数="_ClientTraStr"></param>
    private IEnumerator TraSynchronization(List<string> _ClientTraStr)
    {
        //循环检测 当前可移动数组
        for (int i = 0; i < _ClientTraStr.Count; i++)
        {
            //判断传递字符是否为空
            if (Parse(_ClientTraStr[i]) != null)
            {
                //移动物体 名字
                Debug.Log(_StrTraMoveName);

                for (int j = 0; j < _ListTra.Count; j++)
                {
                    //检测可移动数组传递名字是否在当前客户端数组里面
                    if (_StrTraMoveName == _ListTra[j].transform.name)
                    {
                        //解析传递字符 并更新位置
                        _ListTra[j].transform.position = Parse(_ClientTraStr[i]);
                        continue;
                    }
                }
            }
        }
        //清除 传递字符串数组
        _ClientTraStr.Clear();
        yield return 0;
    }



    /// <summary>
    /// 字符串 转换 Vector3 
    /// </summary>
    /// <param 转接字符串="_Name"></param>
    /// <returns></returns>
    public static Vector3 Parse(string _Name)
    {
        _Name = _Name.Replace("(", "").Replace(")", "");
        string[] _Str = _Name.Split(',');
        _StrTraMoveName = _Str[3];
        return new Vector3(float.Parse(_Str[0]), float.Parse(_Str[1]), float.Parse(_Str[2]));
    }

    /// <summary>
    /// 连接关闭
    /// </summary>
    void SocketQuit()
    {
        //关闭线程
        if (_ConnectThread != null)
        {
            _ConnectThread.Interrupt();
            _ConnectThread.Abort();
        }
        //最后关闭socket
        if (_Socket != null)
        {
            _Socket.Close();
        }
    }

    /// <summary>
    /// 在应用程序退出之前发送给所有游戏对象
    /// </summary>
    void OnApplicationQuit()
    {
        SocketQuit();
    }
}


最终效果：

在这里插入图片描述

组件搭载：

在这里插入图片描述

基础界面：

在这里插入图片描述

同步物体 Tag：

在这里插入图片描述

暂时先这样吧，如果实在看不明白就留言，看到我会回复的。
路长远兮，与君共勉。

Maddie_Mo
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
unity+mirror+语音通话（VoiceChat）
05-06
Mirror是一个专门为Unity设计的网络同步框架，它简化了在网络游戏中处理玩家行为和物体状态同步的过程。Mirror支持UDP和TCP协议，提供了一种快速、可靠的局域网通信方式。它具有易于理解和使用的API，使得开发者无需...
unity 局域网(Network)同步
qq_578147153的博客
02-02 3649
先附上Network常用方法和生命周期函数： Network.InitializeServer(int connettions,int Port,bool useNat)：该函数用于初始化服务器。Connections是最大连接数, Port是服务器监听的端口号,useNat表明是否使用Nat穿透。返回枚举类型NetworkConnectionError。返回NetworkConnectionE...
[Unity Mirror] Network Animator
unity尧明的博客
02-22 1650
  Network Animator 组件允许您同步网络对象的动画状态。它同步来自 Animator Controller 的状态和参数。   请注意，如果您在空游戏对象上创建 Network Animator 组件，Mirror 还会在该游戏对象上创建 Network Identity 组件和 Animator 组件。 Client Authority 启用它以更改从客户端发送到服务器的动画参数。 Animator 使用此字段来定义您希望 Network Animator 与之同步的 Animator
unity如何制作局域网游戏
lxy20011125的博客
04-26 2512
unity联机游戏 unity局域网连接
unity基于NetWork的局域网对战游戏制作
voidinit的专栏
08-21 5052
现在的游戏大体分为2种，要么就是单机游戏，要么就是联网游戏。像现在比较火的游戏，比如手机游戏王者荣耀，比如端游LOL，这些都是联网游戏。再比如求生之路系列，鬼泣系列，生化危机系列这些都是单机游戏。但是我们会发现一个点，求生之路可以和朋友一起开黑。那这到底算单机还是联网游戏呢？还有，这个和朋友一起玩是怎么做到的？那么这就是我们今天讨论的话题了：基于NetWork的局域网对战游戏制作。先上效果图： ...
【Unity】(Socket)TCP 实现同一局域网 一台主机控制多台主机
weixin_39348384的博客
05-24 3922
源文件链接：链接：https://pan.baidu.com/s/1pTwGj37ozMlq58OHcIJPIg。前几天博主接到一个任务：5台HTCVIVEPro设备，其中一台设备进行演示，另外四台设备画面同步。如果需要其它的一些TCP操作流程，请看这个博主大大的文章，很详细。PS:博主参考了其它博主大大的文章，感觉很有用！谨以此文记录博主自己的个人历程，希望对大家有所帮助。以下开始了博主操作的具体流程，希望对你有所帮助。下面是我最终的运行效果图​​​​​​​。--来自百度网盘超级会员V5的分享。
unity联网fps简单demo 源码+程序
03-23
4. **Object Synchronization**：游戏中的物体状态（位置、旋转、生命值等）需要在网络间同步。Unity的`SyncVar`和`NetworkTransform`组件用于实现这一目的。`SyncVar`标记的变量会在网络间自动同步，而`Network...
Unity3D中英文翻译API
03-02
7. **网络功能**：Unity支持多人在线游戏的开发，提供网络同步、客户端-服务器架构和对局域网或互联网游戏的支持。 8. **资源管理**：AssetBundle系统允许在运行时动态加载和卸载资源，优化游戏性能，减少初始加载...
Unity+3D游戏开发--官方文本(UNITY3D 3.x)教程
06-26
13. **网络功能**：Unity3D支持多人在线游戏开发，提供网络同步、客户端/服务器架构和局域网对战等功能。 14. **发布与优化**：Unity支持多平台发布，包括Windows、Mac、iOS、Android以及WebGL等，同时也需要对游戏...
Unity3D坦克大战 源代码（3D）游戏开发
03-01
Unity支持局域网和互联网的多人游戏，通过网络同步游戏状态，让多台设备上的玩家能够实时互动。 总的来说，Unity3D坦克大战的源代码提供了从基础到进阶的多种游戏开发技术实例，包括3D建模、动画、物理模拟、游戏...
【零基础教学】Unet局域网联机的实现——最基础的Unity联网实现方式（1）
热门推荐
PanQ
08-28 1万+
第一部分——Lobby场景的搭建 学习前说明： 项目源码：链接：https://pan.baidu.com/s/1g78L9QODXdRjoVcm-odRSg 密码：0pzo 源码引用自Siki老师的Unet基础系列教程，文章主要以解释为主，后期会添加一些Siki老师源码以外的新东西，敬请期待。 文中用红色显示的内容为我自己命名的关键名词，例如场景名、代码名、阐述代码或方法所实现的功...
unity实现游戏帧同步之确定性物理引擎
TxNet
01-12 7761
一.前言 近几年，市面上出现了越来越多IO游戏，Moba游戏，这些游戏有一个共同的特点，就是需要多人同时进行对战，做多人同步对战游戏，有两个技术点是绕不开的：1.实时网络同步技术，2.确定性物理引擎。首先网络的话，如果游戏要求是帧同步，为了保证网络传输的速度，那一定是udp首选，但是需要处理下丢包的问题。这个问题我们不在这里多说。我们今天主要说的时确定性物理引擎的问题。那么什么是确定性物理引擎呢？ 确定性物理引擎 这个要从普通的物理引擎来说起，比如Unity3D内置的NVIDIA出品的PhysX物理引擎和G
Unity使用Mirror制作局域网的同步
kuilaurence的博客
09-14 1438
3.新建Player的预制体,挂载NetworkIdentity,NetworkTransform(unreliable)的脚本,还有自己的自定义脚本,注意自定义脚本需要继承NetworkBehaviour,这个在编辑的时候需要改改.下面是主玩家的移动代码.2.设置玩家出生点,spawnPoint,设置好初始化的position的位置(*),挂载NetworkStartPosition的脚本。
Unity 基于Netcode for gameObjects实现局域网同步
blastospore的博客
02-19 3129
使用Unity实现局域网同步效果，需要将unity 升级到2021.3.18及以后的版本，使用官方提供的Network for GameObject 实现
UNet实战系列（一）
丢丢的博客
08-23 7420
Unity自5.1以后支持新版的网络系统Unet，Unet是什么，优缺点是什么，和以前的网络系统有什么区别，请自行去百度。本篇要实现的功能是创建网络游戏的Player主角，以及实现移动同步。本教程来源于爱奇艺上的Unet教程，由于是英文视频，so对于很多人来说......，所以就准备出一些对应的中文教程，来帮助初学者（偶也是初学者，若是分享的技术有误，还望指出）。废话不多说了，进入正题。
基础的unity局域网游戏框架（一）
qq_36633019的博客
03-13 2303
最近看了下关于unity的网络模块netwrok即将淘汰，思索了下准备自己用socket去封装个局域网的通讯插件 看了一下关于同步问题 https://www.jianshu.com/p/fbd8eda9df62 然后局域网游戏，外挂基本上靠的是玩家自觉，而且也不需要自己搞个服务器 房间系统:房主是服务器也是客户端 随机数的生成保持一至:统一的随机种子（并且要保持种子的调用次...
Unity + Mirror实现原创卡牌游戏局域网联机
jkkk_的博客
12-05 5371
局域网联机插件 Mirror：Mirror | 网络 | Unity Asset Store本地客户端测试多人游戏（不用打包）插件 ： ParrelSyncMirror官方文档：General - Mirror (gitbook.io)点击开始之后会看到如下界面，需要其中一台电脑作为Host，其他玩家点击Client就可以直接连接Mirror演示场景连接成功效果：首先需要注意的事情：该组件控制着游戏物体在网络中的独特ID，他的 选项表示是否确保物体只生成在服务端。在每一个运行过程中生成的预制体都需要添加该组
Unity之NetCode多人网络游戏联机对战教程(2)--简单实现联机
最新发布
NueXini的博客
09-20 2541
这个后续可以在创建一个角色，让每个Client可以选择角色加载。虽然两个角色重叠了在一起，但还是运行成功了。这边讲的很粗略，后面会慢慢更新教程。然后按Delete删除在场景中的。文件夹，把刚刚创建的物体拖进去。最后保存一下即可完成配置。键创建主机，另外一个按下。创建一个空物体，命名为。打开编译设置，添加场景。创建一个胶囊，命名为。
Unity中实现局域网—Multiplayer HLAPI
L的博客
10-19 2335
Multiplayer HLAPI在之前叫做UNet，可以开发联机网络游戏
unity 局域网实现
04-04
Unity局域网实现需要使用Unity的网络功能。以下是一些步骤： 1. 创建一个游戏场景并添加网络组件 在Unity中，创建一个新的场景并添加网络组件。您可以选择使用Unity自带的UNET或其他网络框架，例如Photon或Mirror...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Maddie_Mo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值