Unity MOBA类型游戏的战争迷雾效果

最新推荐文章于 2024-05-21 09:57:40 发布
最新推荐文章于 2024-05-21 09:57:40 发布
阅读量3k 收藏 41
点赞数 8
分类专栏： Unity 文章标签： unity3d unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/li1214661543/article/details/112475945
版权

基于视野（FOV）的战争迷雾，例如LOL的视野：鼠标右键点击地板，目标移动，同时显示角色周围视野，鼠标滚轮可以调节远近。

Unity版本：2019.4.1f1   

1.新建工程---右键3D Object---Terrain，随便刷一个地形，尽量高低错落，设置地形大小为100*100

2.导入文件，在Camera上添加Fog Of War Effect脚本，脚本会自动添加<Flare Layer>组件，Unity 2018之前的版本需要添加<GUI Layer>组件，2019以后版本被舍弃，无需添加

 3.右键创建一个胶囊，模拟玩家，添加NavMeshAgent组件，添加Fog Of War Explorer脚本

using UnityEngine;
using UnityEngine.AI;

/// <summary>
/// 视野数据-由于计算fov是在子线程操作，通过将视野数据以object类型参数传入，
/// 使用简单数据类型或结构体会产生装箱操作，因此将视野封装成类
/// </summary>
public class FOWFieldData
{
    public float radiusSquare;
    public Vector3 position;
    public float radius;

    public FOWFieldData(Vector3 position, float radius)
    {
        this.position = position;
        this.radius = radius;
        this.radiusSquare = radius * radius;
    }
}

/// <summary>
/// Player
/// </summary>
public class FogOfWarExplorer : MonoBehaviour
{
    [Range(10, 25)] public float radius = 15;//视野半径

    private Vector3 m_OriginPosition;
    private FOWMapPos m_FowMapPos;
    private FOWFieldData m_FieldData;
    private bool m_IsInitialized;

    private float distance = 24;//摄像机高度
    private float angle = 45;//摄像机偏移角度
    private Vector3 m_CameraPosition;
    private NavMeshAgent m_Agent;

    void Start()
    {
        m_FieldData = new FOWFieldData(transform.position, radius);

        m_Agent = gameObject.GetComponent<NavMeshAgent>();
        Camera.main.transform.rotation = Quaternion.Euler(angle, 0, 0);
        Camera.main.transform.position = transform.position - Camera.main.transform.forward * distance;
    }

    void Update()
    {
        if (radius <= 0)
            return;
        if (m_OriginPosition != transform.position)
        {
            m_OriginPosition = transform.position;
            var pos = FogOfWarEffect.WorldPositionToFOW(transform.position);
            if (m_FowMapPos.x != pos.x || m_FowMapPos.y != pos.y || !m_IsInitialized)
            {
                m_FowMapPos = pos;
                m_IsInitialized = true;
                m_FieldData.position = transform.position;
                m_FieldData.radius = radius;
                //FogOfWarEffect.SetVisibleAtPosition(m_FieldData);
                FogOfWarEffect.UpdateFOWFieldData(m_FieldData);
            }
        }

        m_CameraPosition = transform.position - Camera.main.transform.forward * distance;
        Camera.main.transform.position = Vector3.Lerp(Camera.main.transform.position, m_CameraPosition, Time.deltaTime * 3f);
        BasicOperation();
    }

    void OnDestroy()
    {
        if (m_FieldData != null)
            FogOfWarEffect.ReleaseFOWFieldData(m_FieldData);
        m_FieldData = null;
    }

    void OnDrawGizmosSelected()
    {
        Gizmos.color = Color.blue;
        Gizmos.DrawWireSphere(transform.position, radius);
    }


    void BasicOperation() 
    {
        if (Input.GetMouseButtonDown(1))//鼠标右键点击地板
        {
            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            RaycastHit hit;
            if (Physics.Raycast(ray, out hit))
            {
                m_Agent.SetDestination(hit.point);
            }
        }

        if (Input.GetAxis("Mouse ScrollWheel") > 0)
        {
            if (distance >= 7)
                distance -= 2;
        }

        if (Input.GetAxis("Mouse ScrollWheel") < 0)
        {
            if (distance <= 35)
                distance += 2;
        }

    }

}

 4.Scene视角切换成俯视视角，方便调整参数。调整战争迷雾蒙版类型、宽度、高度、战争迷雾中心位置，将特效shader、模糊shader、小地图shader拖入Main Camera上的Fog Of War Effect上

using ASL.FogOfWar;
using System.Collections.Generic;
using UnityEngine;

public struct FOWMapPos
{
    public int x;
    public int y;

    public FOWMapPos(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}

/// <summary>
/// 屏幕空间战争迷雾
/// </summary>
[RequireComponent(typeof(FlareLayer))]
public class FogOfWarEffect : MonoBehaviour
{

    //迷雾蒙版类型
    public enum FogMaskType
    {
        /// <summary>
        /// 精确计算的FOV
        /// </summary>
        AccurateFOV,
        /// <summary>
        /// 基础FOV
        /// </summary>
        BasicFOV,
        /// <summary>
        /// 简单圆形
        /// </summary>
        Circular,
    }

    //实例化
    public static FogOfWarEffect Instance
    {
        get
        {
            if (instance == null)
                instance = FindObjectOfType<FogOfWarEffect>();
            return instance;
        }
    }

    private static FogOfWarEffect instance;

    /// <summary>
    /// 迷雾蒙版类型
    /// </summary>
    public FogMaskType fogMaskType { get { return m_FogMaskType; } }

    /// <summary>
    /// 战争迷雾颜色(RGB迷雾颜色，Alpha已探索区域透明度)
    /// </summary>
    public Color fogColor { get { return m_FogColor; } }

    /// <summary>
    /// 迷雾区域宽度
    /// </summary>
    public float xSize { get { return m_XSize; } }

    /// <summary>
    /// 迷雾区域高度
    /// </summary>
    public float zSize { get { return m_ZSize; } }

    /// <summary>
    /// 迷雾贴图宽度
    /// </summary>
    public int texWidth { get { return m_TexWidth; } }

    /// <summary>
    /// 迷雾贴图高度
    /// </summary>
    public int texHeight { get { return m_TexHeight; } }

    /// <summary>
    /// 迷雾区域中心坐标
    /// </summary>
    public Vector3 centerPosition { get { return m_CenterPosition; } }

    public float heightRange { get { return m_HeightRange; } }

    public Texture2D fowMaskTexture
    {
        get
        {
            if (m_Map != null)
                return m_Map.GetFOWTexture();
            return null;
        }
    }

    public RenderTexture minimapMask
    {
        get
        {
            if (!m_GenerateMinimapMask)
                return null;
            return m_Renderer.GetMimiMapMask();
        }
    }

    [Header("战争迷雾蒙版类型")]
    [SerializeField]
    private FogMaskType m_FogMaskType;
    [Header("战争迷雾颜色")]
    [SerializeField]
    private Color m_FogColor = Color.black;
    [Header("战争迷雾宽度")]
    [SerializeField]
    private float m_XSize = 77f;
    [Header("战争迷雾高度")]
    [SerializeField]
    private float m_ZSize = 77f;
    [Header("战争迷雾贴图宽度")]
    [SerializeField]
    private int m_TexWidth = 66;
    [Header("战争迷雾贴图高度")]
    [SerializeField]
    private int m_TexHeight = 66;
    [Header("战争迷雾中心位置")]
    [SerializeField]
    private Vector3 m_CenterPosition;
    [Header("高度随机值")]
    [SerializeField]
    private float m_HeightRange = 1.23f;
    /// <summary>
    /// 模糊偏移量
    /// 
    /// </summary>
    [Header("模糊偏移量")]
    [SerializeField]
    private float m_BlurOffset = 0.003f;
    /// <summary>
    /// 模糊迭代次数
    /// </summary>
    [Header("模糊迭代次数")]
    [SerializeField]
    private int m_BlurInteration = 2;
    /// <summary>
    /// 是否生成小地图蒙版
    /// </summary>
    private bool m_GenerateMinimapMask;
    /// <summary>
    /// 迷雾特效shader
    /// </summary>
    [Header("战争特效Shader")] public Shader effectShader;
    /// <summary>
    /// 模糊shader
    /// </summary>
    [Header("模糊Shader")] public Shader blurShader;
    /// <summary>
    /// 小地图蒙版渲染shader
    /// </summary>
    [Header("小地图蒙版渲染Shader")] public Shader minimapRenderShader;
    [Header("更新周期")][Range(0.0f,1.0f)]public float UpdateTime = 1.0f;



    /// <summary>
    /// 预生成的地图FOV数据（如果为空则使用实时计算FOV）
    /// </summary>
    //public FOWPregenerationFOVMapData pregenerationFOVMapData;

    /// <summary>
    /// 战争迷雾地图对象
    /// </summary>
    private FOWMap m_Map;
    /// <summary>
    /// 战争迷雾渲染器
    /// </summary>
    private FOWRenderer m_Renderer;

    private bool m_IsInitialized;

    private float m_MixTime = 0.0f;
    private float m_RefreshTime = 0.0f;

    private float m_DeltaX;
    private float m_DeltaZ;
    private float m_InvDeltaX;
    private float m_InvDeltaZ;

    private Camera m_Camera;

    private const float kDispearSpeed = 3f;
    private const float kRefreshTextureSpeed = 4.0f;

    private Vector3 m_BeginPos;

    private List<FOWFieldData> m_FieldDatas;

    private bool m_IsFieldDatasUpdated;

    void Awake()
    {
        m_IsInitialized = Init();

    }

    void OnDestroy()
    {
        if (m_Renderer != null)
            m_Renderer.Release();
        if (m_Map != null)
            m_Map.Release();
        if (m_FieldDatas != null)
            m_FieldDatas.Clear();
        m_FieldDatas = null;
        m_Renderer = null;
        m_Map = null;
        instance = null;
    }

    void FixedUpdate()
    {
        /*
        更新迷雾纹理
        */
        if (m_MixTime >= UpdateTime)
        {
            if (m_RefreshTime >= UpdateTime)
            {
                m_RefreshTime = 0.0f;
                if (m_Map.RefreshFOWTexture())
                {

                    m_Renderer.SetFogFade(0);
                    m_MixTime = 0;
                    m_IsFieldDatasUpdated = false;
                    //m_Renderer.SetFogTexture(m_Map.GetFOWTexture());
                }
            }
            else
            {
                m_RefreshTime += Time.deltaTime * kRefreshTextureSpeed;
            }
        }
        else
        {
            m_MixTime += Time.deltaTime * kDispearSpeed;
            m_Renderer.SetFogFade(m_MixTime);
        }
    }

    private bool Init()
    {
        if (m_XSize <= 0 || m_ZSize <= 0 || m_TexWidth <= 0 || m_TexHeight <= 0)
            return false;
        if (effectShader == null || !effectShader.isSupported)
            return false;
        m_Camera = gameObject.GetComponent<Camera>();
        if (m_Camera == null)
            return false;
        m_Camera.depthTextureMode |= DepthTextureMode.Depth;
        m_DeltaX = m_XSize / m_TexWidth;
        m_DeltaZ = m_ZSize / m_TexHeight;
        m_InvDeltaX = 1.0f / m_DeltaX;
        m_InvDeltaZ = 1.0f / m_DeltaZ;
        m_BeginPos = m_CenterPosition - new Vector3(m_XSize * 0.5f, 0, m_ZSize * 0.5f);
        m_Renderer = new FOWRenderer(effectShader, blurShader, minimapRenderShader, m_CenterPosition, m_XSize, m_ZSize, m_FogColor, m_BlurOffset, m_BlurInteration);
        m_Map = new FOWMap(m_FogMaskType, m_BeginPos, m_XSize, m_ZSize, m_TexWidth, m_TexHeight, m_HeightRange);
        IFOWMapData md = gameObject.GetComponent<IFOWMapData>();
        if (md != null)
            m_Map.SetMapData(md);
        else
        {
            m_Map.SetMapData(new FOWMapData(m_TexHeight, m_TexHeight));
            m_Map.GenerateMapData(m_HeightRange);
        }
        if (minimapRenderShader != null)
            m_GenerateMinimapMask = true;
        return true;
    }

    /// <summary>
    /// 世界坐标转战争迷雾坐标
    /// </summary>
    /// <param name="position"></param>
    /// <returns></returns>
    public static FOWMapPos WorldPositionToFOW(Vector3 position)
    {
        if (!Instance)
            return default(FOWMapPos);
        if (!Instance.m_IsInitialized)
            return default(FOWMapPos);

        int x = Mathf.FloorToInt((position.x - Instance.m_BeginPos.x) * Instance.m_InvDeltaX);
        int z = Mathf.FloorToInt((position.z - Instance.m_BeginPos.z) * Instance.m_InvDeltaZ);

        return new FOWMapPos(x, z);
    }

    public static Vector2 WorldPositionTo2DLocal(Vector3 position)
    {
        if (!Instance)
            return default(Vector2);
        if (!Instance.m_IsInitialized)
            return default(Vector2);

        Vector2 pos = default(Vector2);
        pos.x = (position.x - Instance.m_BeginPos.x) / Instance.m_XSize;
        pos.y = (position.z - Instance.m_BeginPos.z) / Instance.m_ZSize;

        return pos;
    }

    / <summary>
    / 将指定位置设置为可见
    / </summary>
    / <param name="fieldData">视野</param>
    //public static void SetVisibleAtPosition(FOWFieldData fieldData)
    //{
    //    if (!Instance)
    //        return;
    //    if (!Instance.m_IsInitialized)
    //        return;
    //    if (fieldData == null)
    //        return;

    //    Instance.m_Map.SetVisible(fieldData);

    //}

    public static void UpdateFOWFieldData(FOWFieldData data)
    {
        if (!Instance)
            return;
        if (!Instance.m_IsInitialized)
            return;
        if (Instance.m_FieldDatas == null)
            Instance.m_FieldDatas = new List<FOWFieldData>();
        if (!Instance.m_FieldDatas.Contains(data))
        {
            Instance.m_FieldDatas.Add(data);
        }
        if (!Instance.m_IsFieldDatasUpdated)
        {
            //lock (Instance.m_FieldDatas)
            {
                Instance.m_Map.SetVisible(Instance.m_FieldDatas);
                Instance.m_IsFieldDatasUpdated = true;
            }
        }
    }

    public static void ReleaseFOWFieldData(FOWFieldData data)
    {
        if (!instance)
            return;
        if (!instance.m_IsInitialized)
            return;
        //lock (instance.m_FieldDatas)
        {
            if (instance.m_FieldDatas != null && instance.m_FieldDatas.Contains(data))
                instance.m_FieldDatas.Remove(data);
        }
    }

    /// <summary>
    /// 是否在地图中可见
    /// </summary>
    /// <param name="position"></param>
    /// <returns></returns>
    public static bool IsVisibleInMap(Vector3 position)
    {
        if (!Instance)
            return true;
        if (!Instance.m_IsInitialized)
            return true;
        int x = Mathf.FloorToInt((position.x - Instance.m_BeginPos.x) * Instance.m_InvDeltaX);
        int z = Mathf.FloorToInt((position.z - Instance.m_BeginPos.z) * Instance.m_InvDeltaZ);

        return Instance.m_Map.IsVisibleInMap(x, z);

    }

    void OnRenderImage(RenderTexture src, RenderTexture dst)
    {
        if (!m_IsInitialized)
            Graphics.Blit(src, dst);
        else
        {
            m_Renderer.RenderFogOfWar(m_Camera, m_Map.GetFOWTexture(), src, dst);
        }
    }

    void OnDrawGizmosSelected()
    {
        FOWUtils.DrawFogOfWarGizmos(m_CenterPosition, m_XSize, m_ZSize, m_TexWidth, m_TexHeight, m_HeightRange);
    }
}

 5.单击Terrain 右上角勾选静态Static,Windows----AI---Navigation，Bake---Bake

6.运行即可查看效果，你还可以添加小地图和右键点击动画等效果。

  如果你的场景和我的不一样，那也没关系，我改了光照设置，不改也没问题，我的光照设置如下：

资源下载：点击下载

网盘下载：访问码:2oeb

参考资料：GitHub

 

Liam_Lsc
关注
  • 8
    点赞
  • 踩
  • 41
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
Unity3D游戏高性能战争迷雾系统实现
weixin_30667301的博客
11-23 1711
一　　效果图 　　先上效果图吧，这是为了吸引到你们的ヽ(｡◕‿◕｡)ﾉﾟ 战争迷雾效果演示图 战争迷雾调试界面演示图 　　由于是gif录制，为了压缩图片，帧率有点低，实际运行时，参数调整好是不会像这样一卡一顿的。 二　　战争迷雾概述 　　战争迷雾一般用于Startcraft等RTS类型游戏，还有就是War3等Moba类型游戏，主要包括三个概念：未探...
Unity shader 笔记之迷雾效果
elegentbeauty的博客
03-29 1313
先看效果图： Shader "Unlit/FogOfWar" { Properties { _MainTex ("Texture", 2D) = "white" {} } CGINCLUDE #include "UnityCG.cginc" struct appdata { float4 vertex : POSITION; float2 uv : TEXCOORD0; }; struct v2f { float2 uv : TEXCOORD0; UNITY_
Unity3D战争迷雾效果
阿赵的博客
08-02 3152
战争迷雾demo视频 这次做了一个战争迷雾的效果： 战争迷雾大家应该很熟悉了，一开始地图全部都是黑的，只有主角的一定范围内能看得到。随着主角的移动，未探索的区域变成了可见。 我这个demo还做了视角切换的功能，可以看看切换摄像机视角之后的迷雾是什么效果的。 在场景里面有很多隐藏的物体（这里是一些Cube），走近了，可以渐渐的出现。 主角可视的范围是可以调节的，这里是把...
推荐开源项目：FogOfWar - Unity中的战争迷雾渲染利器
最新发布
gitblog_00019的博客
05-21 511
推荐开源项目：FogOfWar - Unity中的战争迷雾渲染利器 项目地址:https://gitcode.com/AsehesL/FogOfWar 1. 项目介绍 FogOfWar 是一个专为Unity引擎设计的开源插件，它能帮助你在游戏中实现引人入胜的战争迷雾效果。这种视觉元素常见于策略游戏和角色扮演游戏中，增加了战场的真实感和探索的乐趣。通过实时渲染可见区域，FogOfWar能隐藏未被探索...
在Unity中为即时战略游戏实现战争迷雾（上）
wangchewen的博客
09-15 3163
https://www.fgba.net/sitemap.xml
Unity Shader unity文档学习笔记(十一)：战争迷雾核心算法
qq_43204246的博客
09-30 1096
核心算法 非常简单 主要就是把一个点的世界坐标转换到贴图的UV坐标 给整个场景一个大的plane 加上写的shader 摄像机位置调成plane的正上方 Shader "Unlit/FogRender" { Properties { _MainTex ("Texture", 2D) = "white" {} } SubShader { Tags{ "Queue" = "Transparent+151" "IgnoreProjector" = "True" "RenderType" =
【Unity3D Shader编程】之八 Unity5新版Shader模板源码解析&径向模糊屏幕特效的实现
热门推荐
【浅墨的游戏编程Blog】毛星云（浅墨）的专栏
10-25 4万+
概要：本文对Unity5中全新的三种Shader模板的源码进行了解析，然后还讲解了运动模糊屏幕特效的实现方法。 Unity5和之前的书写模式有了一定的改变。Unity5时代的Shader Reference官方文档也进一步地变得丰满。主要需要了解到的是，在原来的Unity中，若想要新建一个Shader源文件，不考虑compute shader的话，仅有一种Shader模板供选择。而自从Unity5.1起（好像是Unity5.1）
MOBA类型游戏的战争迷雾效果
01-11
类似于MOBA类型游戏的战争迷雾效果，如LOL等，基于FOV原理
Unity多人竞技类游戏源码uMOBA v1.34.zip
11-11
uMOBA v1.34是基于Unity的多人在线战术竞技（MOBA）游戏源码，它为开发者提供了一套完整的框架，用于构建类似DOTA、魔兽争霸、梦三国或英雄联盟等类型的竞技游戏。 一、Unity游戏开发基础 在深入理解uMOBA源码之前...
Unity3D游戏高性能战争迷雾系统.zip
03-13
"Unity3D游戏高性能战争迷雾系统"着重于优化迷雾系统的性能，这对于大型游戏世界和多人在线游戏尤其重要。性能优化通常包括减少计算量、优化内存使用以及提升渲染效率等方面。 首先，我们讨论Unity3D中的迷雾实现...
UnityMoba：使用Unity的Moba手机游戏
02-06
Unity3D，作为一个强大的跨平台游戏开发引擎，已经成为制作各种类型游戏的首选工具，其中包括深受玩家喜爱的多人在线战斗竞技游戏（MOBA）。本篇文章将深入探讨如何使用Unity来创建一款Moba手机游戏，主要涉及的技术...
插件 FogOfWord.one 插件使用说明文档
08-13
插件 FogOfWord.one 插件使用说明文档
战争迷雾(V1.15) Unity插件.rar
08-13
最终的战争迷雾包使您能够迷惑您的 2D 或 3D 游戏，向玩家隐藏秘密元素。 FogOfWar 是高度模块化、可定制和快速发光的，可以满足任何需要在其周围笼罩上一层厚厚薄雾的 RTS、MOBA 或冒险游戏的需求。
uinty fog of war
08-24
uinty 实用战争迷雾
Unity3d类似皇室战争游戏项目源码英雄竞技场Heroes Arena
01-19
Unity3d类似皇室战争游戏项目源码英雄竞技场Heroes Arena 支持unity3d版本5.4.6f3及以上 在这场激动人心的冒险中，您可以与您的朋友和传奇战士一起进行真正的 MOBA 战斗。解锁竞技场并征服强大的卡牌以增强您的游戏...
unity3d 更换sprite renderer中sprite的图片
战争迷雾的专栏
09-29 4万+
unity3d 更换sprite renderer中sprite的图片  所更换图片尺寸与原图片相同
2D游戏平滑的迷雾战争效果
弃天笑的程序世界
03-08 9168
最近刚好有做2D游戏的点光源效果，然后就扩展一下，研究了一下战争迷雾的效果。主要是想实现类似魔兽争霸那种人物走动，然后黑色的战争迷雾随着人物的移动渐渐打开的效果。使用具有渐变透明图片作为光源来使得战争迷雾呈现出平滑的效果。本文后面介绍了两个简单的实现方法，效果有细微的差别，有兴趣的同学可以分别研究。最后也有完整展示代码和提供例子下载。一、常见的战争迷雾效果早期的红警的战争迷雾大家应该也比较熟悉，不过
UnityShader 实现2D游戏迷雾
Emmmwzh
01-07 6269
先看效果吧。 我使用的是屏幕后处理效果，首先先去Photoshop做一张图片如下，用画笔点一个点就可以了，使用它来对摄像机截取的图片进行处理。 在摄像机上添加脚本文件 using System.Collections; using System.Collections.Generic; using UnityEngine; public class TestSc
Unity Shader实现动态雾效果
weixin_42565127的博客
01-03 971
先将相机近裁面四个角向量传给shader，再通过观察空间下的深度值和相机位置算出像素在世界坐标系的位置，通过世界空间高度值来设定雾的范围和浓度，然后通过噪声和uv偏移实现扰动效果。得到了类似寂静岭或恶灵附身1的效果。
unity 实现战争迷雾效果
04-02
在Unity中实现战争迷雾效果，可以使用以下步骤： 1. 创建一个空白的平面，作为地图。 2. 在地图上添加一个黑色材质，作为初始迷雾。 3. 创建一个空白的相机，作为迷雾的视角。 4. 给相机添加一个Render Texture，用于渲染迷雾。 5. 将迷雾的Render Texture设置为相机的Target Texture，以便将迷雾渲染到相机上。 6. 将相机的Clear Flags设置为Solid Color，将背景颜色设置为黑色，以遮盖地图上的所有内容。 7. 给相机添加一个Culling Mask，只渲染地图和迷雾。 8. 创建一个脚本，用于控制迷雾的显示和隐藏。在脚本中，可以使用Raycast来检测相机和地图之间的障碍物，然后在Render Texture上绘制白色的圆形，以表示相机周围的区域已经被探索。 9. 在游戏中，当玩家探索新区域时，调用脚本的方法来显示迷雾。 10. 当玩家离开区域时，再次调用脚本的方法来隐藏迷雾。 以上就是在Unity中实现战争迷雾效果的步骤。
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值