简单实现原神抽卡机制

最新推荐文章于 2023-11-30 02:42:39 发布
最新推荐文章于 2023-11-30 02:42:39 发布
阅读量308 收藏
点赞数 2
分类专栏： 杂项 文章标签： 游戏程序 游戏 建造者模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62389241/article/details/131534502
版权

简单实现原神抽卡机制


实现原理与公式可以参考这篇文章: 原神抽卡全机制总结

  1. 星级决定机制
namespace GenshinGacha
{
    public enum LevelType
    {
        R,
        SR,
        SSR
    }

    public class LevelBuilder
    {
        public Dictionary<LevelType, int> initWeight = new ictionary<LevelType, int>();
        //记录从哪一抽开始增加权重   
        public Dictionary<LevelType, int> AddRange = new Dictionary<LevelType, int>();
        //每次增加权重大小
        public Dictionary<LevelType, int> AddWeight = new Dictionary<LevelType, int>();

        public LevelBuilder()
        {
            foreach (LevelType level in Enum.GetValues(typeof(LevelType)))
            {
                initWeight[level] = 0;
                AddWeight[level] = 0;
            }

            initWeight[LevelType.R] = 5000;
            initWeight[LevelType.SR] = 3000;
            initWeight[LevelType.SSR] = 1000;
            //十连抽从第9抽增加概率
            AddRange[LevelType.SR] = 9;
            //限定池保底
            AddRange[LevelType.SSR] = 74;
        }

        public LevelBuilder SetRWeight(int weight)
        {
            initWeight[LevelType.R] = weight;
            return this;
        }

        public LevelBuilder SetSRWeight(int weight)
        {
            initWeight[LevelType.SR] = weight;
            return this;
        }

        public LevelBuilder SetSSRWeight(int weight)
        {
            initWeight[LevelType.SSR] = weight;
            return this;
        }

        public LevelBuilder SetSRAddRange(int range)
        {
            AddRange[LevelType.SR] = range;
            return this;
        }

        public LevelBuilder SetSSRAddRange(int range)
        {
            AddRange[LevelType.SSR] = range;
            return this;
        }

        public LevelBuilder SetAddWeight(LevelType level, int weight)
        {
            AddWeight[level] = weight;
            return this;
        }
    }

    //决定当前单抽的星级
    public class LevelDecision
    {
        public LevelBuilder builder;

        public LevelDecision(LevelBuilder builder)
        {
            this.builder = builder;
            //按星级降序，实现类似 10连最后一发五星，那第11发为四星的效果
            levelTypeWeight.Add(LevelType.SSR, this.builder.initWeight[LevelType.SSR]);
            levelTypeWeight.Add(LevelType.SR, this.builder.initWeight[LevelType.SR]);
            levelTypeWeight.Add(LevelType.R, this.builder.initWeight[LevelType.R]);

            levelCounter[LevelType.SR] = 1;
            levelCounter[LevelType.SSR] = 1;
        }

        //星级 --- >权值
        public Dictionary<LevelType, int> levelTypeWeight = new Dictionary<LevelType, int>();

        //5,4星计数器(分别计数)
        public Dictionary<LevelType, int> levelCounter = new Dictionary<LevelType, int>();

        //总抽数
        public int totalCount = 0;

        public (LevelType, int) Decide()
        {
            totalCount++;
            int ran = new Random(Guid.NewGuid().GetHashCode()).Next(0, 10000);
            int end = 0, count = 0;
            LevelType currentLevel = LevelType.R;

            //假设抽卡为转轮盘，那落在哪个扇区
            foreach (KeyValuePair<LevelType, int> t in levelTypeWeight)
            {
                end += t.Value;
                if (ran < end)
                {
                    currentLevel = t.Key;
                    break;
                }
            }

            switch (currentLevel)
            {
                case LevelType.R:
                    GetR(ref count);
                    break;
                case LevelType.SR:
                    GetSR(ref count);
                    break;
                case LevelType.SSR:
                    GetSSR(ref count);
                    break;
            }

            return (currentLevel, count);
        }

        public void GetR(ref int count)
        {
            count = totalCount;

            levelCounter[LevelType.SR]++;
            levelCounter[LevelType.SSR]++;
            //连续73抽没有5星，下一抽开始增加概率，90抽必出
            if (levelCounter[LevelType.SSR] >= this.builder.AddRange[LevelType.SSR])
                levelTypeWeight[LevelType.SSR] += builder.AddWeight[LevelType.SSR];
            //10连必有4星，从第9发增加概率,10抽后必出4星
            if (levelCounter[LevelType.SR] >= this.builder.AddRange[LevelType.SR])
                levelTypeWeight[LevelType.SR] += builder.AddWeight[LevelType.SR];
        }

        public void GetSR(ref int count)
        {
            count = levelCounter[LevelType.SR];

            levelCounter[LevelType.SR] = 1;
            levelCounter[LevelType.SSR]++;

            levelTypeWeight[LevelType.SR] = builder.initWeight[LevelType.SR];
            if (levelCounter[LevelType.SSR] >= builder.AddRange[LevelType.SSR])
                levelTypeWeight[LevelType.SSR] += builder.AddWeight[LevelType.SSR];
        }

        public void GetSSR(ref int count)
        {
            count = levelCounter[LevelType.SSR];

            levelCounter[LevelType.SR]++;
            levelCounter[LevelType.SSR] = 1;

            levelTypeWeight[LevelType.SSR] = builder.initWeight[LevelType.SSR];
            if (levelCounter[LevelType.SR] >= builder.AddRange[LevelType.SR])
                levelTypeWeight[LevelType.SR] += builder.AddWeight[LevelType.SR];
        }
    }
}
  1. 物品种类决定机制
namespace GenshinGacha
{
    public enum ItemType
    {
        RWeapon,
        SRRole,
        SRWeapon,
        SSRRole,
        SSRWeapon,
        SSRRole_Up
    }

    public class ItemTypeDecisionBuilder
    {
        public Dictionary<ItemType, int> itemInitWeight = new Dictionary<ItemType, int>();

        //相隔一段时间没有抽到该类物品，则增加该类的权重
        public Dictionary<ItemType, int> itemSmoothRange = new Dictionary<ItemType, int>();

        //增加权值大小 
        //eg. 146抽没有五星角色，那么从147抽每抽开始增加概率，到180抽时5星角色概率为99.83%，270发的保底5星必定为5星角色。这样270发必有5星武器或者角色
        public Dictionary<ItemType, int> itemSmoothAddWeight = new Dictionary<ItemType, int>();

        public ItemTypeDecisionBuilder()
        {
            foreach (ItemType itemType in Enum.GetValues(typeof(ItemType)))
            {
                itemInitWeight[itemType] = 0;
                itemSmoothRange[itemType] = 0;
                itemSmoothAddWeight[itemType] = 0;
            }
        }

        public ItemTypeDecisionBuilder SetSRRoleWeight(int weight)
        {
            itemInitWeight[ItemType.SRRole] = weight;
            itemInitWeight[ItemType.SRWeapon] = 10000 - itemInitWeight[ItemType.SRRole];
            return this;
        }

        public ItemTypeDecisionBuilder SetSSRRoleWeight(int weight, bool isUp = true)
        {
            itemInitWeight[ItemType.SSRRole] = weight;
            if (isUp)
                itemInitWeight[ItemType.SSRRole_Up] = 10000 - itemInitWeight[ItemType.SSRRole];
            else
                itemInitWeight[ItemType.SSRWeapon] = 10000 - itemInitWeight[ItemType.SSRRole];
            return this;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="itemType"></param>
        /// <param name="start">超过多少发没有抽中该类物品后触发平稳机制</param>
        /// <param name="addWeight">每抽增加权值大小</param>
        /// <returns></returns>
        public ItemTypeDecisionBuilder SetSmooth(ItemType itemType, int start, int addWeight)
        {
            itemSmoothRange[itemType] = start;
            itemSmoothAddWeight[itemType] = addWeight;
            return this;
        }
    }

    public class ItemTypeDecision
    {
        public ItemTypeDecisionBuilder builder;
        public SmoothMechanism sm;
        
        public int SSRCount = 0; //限定池大保底

        public ItemTypeDecision(ItemTypeDecisionBuilder builder)
        {
            this.builder = builder;
            sm = new SmoothMechanism(this.builder);
        }

        /// <summary>
        /// 决定物品种类
        /// </summary>
        /// <param name="levelType">星级</param>
        /// <param name="count">当前抽数</param>
        /// <returns></returns>
        public ItemType Decide(LevelType levelType, int count)
        {
            ItemType itemType = ItemType.RWeapon;
            int ran = new Random(Guid.NewGuid().GetHashCode()).Next(0, 10000);
            switch (levelType)
            {
                case LevelType.R:
                    itemType = ItemType.RWeapon;
                    break;
                case LevelType.SR:
                    if (ran < builder.itemInitWeight[ItemType.SRRole])
                        itemType = ItemType.SRRole;
                    else
                        itemType = ItemType.SRWeapon;
                    break;
                case LevelType.SSR:
                    //当前抽出来了常驻5星，那么下一5星必定为限定
                    if (SSRCount == 0 && ran < builder.itemInitWeight[ItemType.SSRRole])
                    {
                        SSRCount++;
                        itemType = ItemType.SSRRole;
                    }
                    else
                    {
                        SSRCount = 0;
                        itemType = ItemType.SSRRole_Up;
                    }
                    break;
            }
            return itemType;
        }

        public ItemType Decide_Changzhu(LevelType levelType,int count)
        {
            ItemType itemType = ItemType.RWeapon;
            int ran = new Random(Guid.NewGuid().GetHashCode()).Next(0, 10000);
            switch (levelType)
            {
                case LevelType.R:
                    itemType = ItemType.RWeapon;
                    break;
                case LevelType.SR:
                    if (ran < sm.itemWeight[ItemType.SRWeapon])
                        itemType = ItemType.SRWeapon;
                    else
                        itemType = ItemType.SRRole;
                    break;
                case LevelType.SSR:
                    if (ran < sm.itemWeight[ItemType.SSRWeapon])
                        itemType = ItemType.SSRWeapon;
                    else
                        itemType = ItemType.SSRRole;
                    break;
            }
            sm.CheckCount(itemType,levelType);
            return itemType;
        }
    }
}
  1. 平稳机制
namespace GenshinGacha
{
    public class SmoothMechanism
    {
        public Dictionary<ItemType, int> itemCounter = new Dictionary<ItemType, int>();
        public ItemTypeDecisionBuilder builder;
        public Dictionary<ItemType, int> itemWeight = new Dictionary<ItemType, int>();

        public SmoothMechanism(ItemTypeDecisionBuilder builder)
        {
            this.builder = builder;
            //初始化
            foreach (ItemType itemType in Enum.GetValues(typeof(ItemType)))
                itemCounter[itemType] = 0;
            foreach (KeyValuePair<ItemType, int> kv in this.builder.itemInitWeight)
                itemWeight[kv.Key] = builder.itemInitWeight[kv.Key];
        }

        /// <summary>
        /// 当前抽数是否满足平稳机制要求并触发相关事件 
        /// </summary>
        /// <param name="itemType">当前决策的物品类型(需判断是否应该改成同星级其他物品)</param>
        public void CheckCount(ItemType itemType, LevelType level)
        {
            itemCounter[itemType] = 0;
            //先重置权值
            if (level == LevelType.SR)
            {
                itemWeight[ItemType.SRWeapon] = builder.itemInitWeight[ItemType.SRWeapon];
                itemWeight[ItemType.SRRole] = builder.itemInitWeight[ItemType.SRRole];
            }
            else if (level == LevelType.SSR)
            {
                itemWeight[ItemType.SSRRole] = builder.itemInitWeight[ItemType.SSRRole];
                itemWeight[ItemType.SSRWeapon] = builder.itemInitWeight[ItemType.SSRWeapon];
                itemWeight[ItemType.SSRRole_Up] = builder.itemInitWeight[ItemType.SSRRole_Up];
            }
            else
            {
                itemWeight[itemType] = builder.itemInitWeight[itemType];
            }

            foreach (KeyValuePair<ItemType, int> item in itemCounter)
            {
                //跳过当前抽中的物品
                if (item.Key == itemType) continue;

                itemCounter[item.Key]++;

                int start = builder.itemSmoothRange[item.Key];
                int addWeight = builder.itemSmoothAddWeight[item.Key];
                int initWeight = builder.itemInitWeight[item.Key];
                int leftWeight = 0;

                if (item.Value >= start)
                {
                    itemWeight[item.Key] = initWeight + (item.Value - start) * addWeight;

                    leftWeight = 10000 - itemWeight[item.Key] >= 0 ? 10000 - itemWeight[item.Key] : 0;

                    //每次抽中物品，都要根据计数结果重新计算概率
                    switch (item.Key)
                    {
                        case ItemType.SRWeapon:
                            itemWeight[ItemType.SRRole] = leftWeight;
                            break;
                        case ItemType.SRRole:
                            itemWeight[ItemType.SRWeapon] = leftWeight;
                            break;
                        case ItemType.SSRRole:
                            itemWeight[ItemType.SSRWeapon] = leftWeight;
                            break;
                        case ItemType.SSRWeapon:
                            itemWeight[ItemType.SSRRole] = leftWeight;
                            break;
                    }
                }
            }

            foreach (KeyValuePair<ItemType, int> item in itemCounter)
            {
                //跳过当前抽中的物品
                if (item.Key == itemType) continue;

                itemCounter[item.Key]++;

                int start = builder.itemSmoothRange[item.Key];
                int addWeight = builder.itemSmoothAddWeight[item.Key];
                int initWeight = builder.itemInitWeight[item.Key];
                int leftWeight = 0;

                if (item.Value >= start)
                {
                    itemWeight[item.Key] = initWeight + (item.Value - start) * addWeight;

                    leftWeight = 10000 - itemWeight[item.Key] >= 0 ? 10000 - itemWeight[item.Key] : 0;

                    //每次抽中物品，都要根据计数结果重新计算概率
                    switch (item.Key)
                    {
                        case ItemType.SRWeapon:
                            itemWeight[ItemType.SRRole] = leftWeight;
                            break;
                        case ItemType.SRRole:
                            itemWeight[ItemType.SRWeapon] = leftWeight;
                            break;
                        case ItemType.SSRRole:
                            itemWeight[ItemType.SSRWeapon] = leftWeight;
                            break;
                        case ItemType.SSRWeapon:
                            itemWeight[ItemType.SSRRole] = leftWeight;
                            break;
                    }
                }
            }
        }
    }
}
  1. 测试
    模拟限定池
 public static void Test1()
        {
            List<int> SRCountList = new List<int>();
            List<int> SSRCountList = new List<int>();
            //基础出率: R(94.3%) SR(5.1%) SSR(0.6%)
            LevelDecision LD = new LevelDecision(new LevelBuilder()
                .SetRWeight(9430).SetSRWeight(510).SetSSRWeight(60)
                .SetAddWeight(LevelType.SR, 5100).SetAddWeight(LevelType.SSR, 600)
                .SetSRAddRange(9).SetSSRAddRange(74));

            ItemTypeDecision ITD = new ItemTypeDecision(new ItemTypeDecisionBuilder()
                .SetSRRoleWeight(5000)  
                .SetSSRRoleWeight(5000, true));
            int i = 0;
            while (i++ < 500000)
            {
                //决定星级 ---> 决定物品类型
                (LevelType level, int count) = LD.Decide();
                ItemType itemType = ITD.Decide(level, count);
                // Console.WriteLine(itemType+" "+count);
                if (level == LevelType.SR)
                    SRCountList.Add(count);
                else if (level == LevelType.SSR)
                    SSRCountList.Add(count);
            }

            Console.WriteLine("四星平均抽数" + CountAverage(SRCountList));
            Console.WriteLine("五星平均抽数" + CountAverage(SSRCountList));
        }

//综合出率为平均抽出该星级所需抽数的倒数.
//四星综合出率为13%,5星为1.6%。与计算结果相近.
四星平均抽数7.6416225
五星平均抽数62.26865

模拟常驻角色池

    public static void Test2()
        {
            LevelDecision LD = new LevelDecision(new LevelBuilder()
                .SetRWeight(9430).SetSRWeight(510).SetSSRWeight(60)
                .SetAddWeight(LevelType.SR, 5100).SetAddWeight(LevelType.SSR, 600)
                .SetSRAddRange(9).SetSSRAddRange(74));
            //模拟常驻池
            ItemTypeDecision ITD_Changzhu = new ItemTypeDecision(new ItemTypeDecisionBuilder()
                .SetSRRoleWeight(10000).SetSSRRoleWeight(10000, false) //假设4，5星角色的概率为100%，那么抽出武器一定是平稳机制导致的
                .SetSmooth(ItemType.SRWeapon, 18, 1250).SetSmooth(ItemType.SRRole, 18, 1250)
                .SetSmooth(ItemType.SSRRole, 147, 151).SetSmooth(ItemType.SSRWeapon, 147, 151));

            int i = 0;
            int preSR = 0, curSR = 0, preSSR = 0, curSSR = 0;
            int cntSR = 0, cntSSR = 0;
            while (i++ < 500000)
            {
                (LevelType level, int count) = LD.Decide();
                ItemType itemType = ITD_Changzhu.Decide_Changzhu(level, count);
                // Console.WriteLine(itemType+" "+count);
                if (itemType == ItemType.SRWeapon)
                {
                    curSR = i;
                    cntSR = Math.Max(cntSR, (curSR - preSR));
                    preSR = i;
                }

                if (itemType == ItemType.SSRWeapon)
                {
                    curSSR = i;
                    cntSSR = Math.Max(cntSSR, (curSSR - preSSR));
                    preSSR = i;
                }
            }

            Console.WriteLine($"最多{cntSR}发没有四星武器");
            Console.WriteLine($"最多{cntSSR}发没有五星武器");
        }

最多25发没有四星武器
最多184发没有五星武器

下一篇中我将结合ET写一个抽卡功能的demo。

hutian2501
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
vue模拟原神祈愿（核心算法）
tiffany1105的博客
11-18 450
首先需要了解原神的抽卡规则： up池90发小保底：指至多90发必出无相角色（包含常驻角色） up池180发大保底：指至多180发必出当期up角色 如果小保底出当期up角色，则重新计算小保底
抽奖池算法的实现
nkc的博客
08-26 901
抽奖池算法的实现
原神助手 一款支持祈愿分析、查看便签状态和获取游戏详细数据的开源工具。
qq_50594742的博客
11-14 1082
打开 Windows PowerShell，接着复制下方的脚本并粘贴到 PowerShell 里执行。进入原神助手的祈愿分析页，点击读取链接按钮，顺利的话，会自动填充祈愿链接。打开 Windows 的 “开始” 菜单，搜索 PowerShell。打开原神，进入祈愿页面，点击历史记录，并往后翻几页等待数据加载完。「原神助手」支持祈愿分析、查看便签状态和获取游戏详细数据等。资源获取及详细内容可查看。
二：原神本地服务器（sifu）搭建环境配置教程第二篇
yujinjinui的博客
11-01 1万+
二：原神本地服务器（sifu）搭建环境配置教程第二篇 环境搭建
【拾枝杂谈】从游戏开发的角度来谈谈原神4.0更新
君兮_的博客
08-30 2588
拾枝杂谈，结合自己的实机游玩体验谈谈原神的近况和4.0的更新
C语言大作业实现 原神 小小小游戏界面
spark的博客
04-26 1697
2.查找怪物：在不同的地图下可以查找到不同的怪物，输入怪物序号可以攻击它（我没有在所有地图设置怪物，主要在第一行有）建议用终端直接运行，因为有的编译器不会弹出控制台比如Clion（悲）；会出现一个根据自己血量和怪物血量动态的战斗过程：​​​​​​​。4.纪行：这个没有实现，总不能把收款码放上让你们氪金吧（狗头）1.自我欣赏：可以查看玩家现在的状态，配备的武器，拥有的队伍。3.祈愿：我写的是我做的时候卡池up的角色，可自行更改。主要运用控制台界面，首先可以查看当前所在的地图位置。5.背包：查看现在的装备。
原神服务端搭建架设教程win系统(附客户端+服务端+环境配置)
V13807970340的博客
05-15 5180
大家好，我是艾西原神一款开放世界冒险3D游戏以七种元素（分别为风、雷、岩、火、水、草、冰）交汇的幻想世界“提瓦特”创造的游戏世界，以角色扮演的RPG游戏还是有非常多的玩家热爱，以二次元以及那卡哇伊的画风不管是小哥哥还是小姐姐都深受喜爱。我是艾西，以上就是原神服务端的搭建架设方法，有服务端的直接看后半段，没有服务端就在GIT下载，配置的环境以及工具都是一样的可以根据自己习惯的方式来。魔神任务即主线任务和活动任务，传说任务是角色剧情任务，委托任务是每日四个委托，世界任务是在野外偶尔触发的任务。
原神私人服务器部署教程(Win)
热门推荐
qq2153074711的博客
10-21 13万+
原神私人服务器部署教程(Win/Linux)
基于Vue实现原神抽卡简易代码算法（纯金光率）
天命既定，水中幻月
02-18 4450
狠人话不多，直接上代码就完事了，代码中有详细说明… <template> <div id="container"> <button @click="clickGoodLuck(1)">祈愿1次</button> <button @click="clickGoodLuck(10)">祈愿10次</button> </div> </template> <script> export def
在原神里钓鱼，有人竟用上了深度强化学习，还把它开源了
m0_46163918的博客
05-11 1051
还愁在《原神》里钓不到鱼吗？这有一份迟到的提瓦特钓鱼指南。
python16行代码获取原神全角色+全语音
weixin_62853513的博客
03-03 3856
大家早好、午好、晚好吖 ❤ ~欢迎光临本文章本来是不玩原神的，但是实在是经不住双重诱惑呀~毕竟谁能拒绝角色风景超级好看又可以爬树、炸鱼、壶里造房子、抓小动物、躲猫猫的游戏捏~今天点进官网~角色得配音让我沉陷其中，于是我决定把他们爬下来~嘿嘿嘿，下面给大家分享一下我的成果更多精彩内容、资源皆可点击文章下方名片获取此处跳转。
让 web 再次伟大：用 CanvasKit 实现超级丝滑的原神地图（已开源）！！！
程序员成长指北
10-29 724
大厂技术高级前端Node进阶点击上方程序员成长指北，关注公众号回复1，加入高级Node交流群哈喽,大家好 我是考拉????。今天给大家分享一个用canvaskit实现超级丝滑的原神地图,文末附源码地址。首先给大家送上预览地址：官网地址：https://webstatic.mihoyo.com/ys/app/interactive-map/index.htmlcanvaskit地址：http:/...
原神-系统分析总览
We3502的博客
08-26 376
本文介绍原神产品整体系统构建目的，基础数值，交互情况，包装方式为后续产品分析提供方向。
C++实现简化版原神游戏
yaosichengalpha的博客
07-24 2571
C++实现简化版原神游戏
如何用python设计原神启动
最新发布
qq_33601171的博客
11-30 1157
Hi,朋友们，经常听说过一个词叫做 原神-启动，今天从官网上爬出来一些素材，整理了一下，刚好可以做一个原神-启动我们来解析这个程序了解了原理，那么采用什么工具呢?当然是opencv啦于是我们开始了解我们的代码我们的逻辑是读入图片，自然会用到imread，接下来用来处理图片，我们可以设置窗口大小和属性，最后延迟一段时间保持活动素材准备代码展示。
胡桃工具箱, 基于 .NET 开源的多功能原神工具箱
zls365365的博客
05-20 562
你好，这里是 Dotnet 工具箱，定期分享 Dotnet 有趣，实用的工具和组件，希望对您有用！胡桃工具箱胡桃工具箱是一个 Windows 平台的开源的原神工具箱，旨在帮助玩家获得更好的游戏体验；它是对官方移动端工具的一种非破坏性功能扩展，为不习惯在移动端进行原神游戏的 PC 玩家提供一个在 Windows 平台下获得接近移动端功能权利的途径。功能列表•1.1 成就管理•1.2 属性统计•...
原神系统分析-任务剧情系统
We3502的博客
09-13 647
本文分析原神任务剧情系统的剧情结构，定位；并结合市面优质的任务产品，为原神的任务剧情系统提出优化建议。
原神服务器服务端多人联机教程
V13807970340的博客
05-15 2279
将所有的zhengs都放入下列存储 浏览并选择受信任的根zhengs颁发JG其余步骤直接默认点击下一步即可一个IP一个zhengs！访问 mitm.it 点击并下载 Get mitmproxy-ca-cert.p12 在下载文件夹双击该文件安装zhengs安装zhengs时请修改zhengs存储目录。设置 > 网络和 Internet > DAIL > 手动设置 > 使用DAIL服务器[设置]设置>安全>更多安全设置>加密与凭据>安装zhengs>CA zhengs。
JavaScript练手小技巧：我破解了原神官网全屏滚动的秘密
九天翔龙的技术博客
11-21 2685
最近居家教学上网课。除了上课，实在不想做学校安排的其它任务，太烦了。果然在家没的工作动力啊~ 但是学习、coding、追番的动力还是有的。今天来做一个模仿原神官网的全屏滚动效果页面。
实现一个原神抽卡模拟器
04-04
1. 确定游戏规则：原神抽卡有不同的池子，每个池子中都有不同的角色和武器，不同的池子有不同的概率，需要确定每个池子的概率和抽卡机制。 2. 设计界面：需要设计一个用户界面，包括抽卡按钮、展示已抽卡片的区域等...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值