释放技能(有限状态和动画)

最新推荐文章于 2024-05-05 21:25:09 发布
最新推荐文章于 2024-05-05 21:25:09 发布
阅读量678 收藏 2
点赞数 1
分类专栏： 泰斗英雄联盟
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35647121/article/details/93812657
版权

 动画组建

英雄配置表，对应英雄动画      技能编号对应技能表中技能

先理一下结构

角色身上绑定的 Entity  实物脚本

	public enum EntityType
    {
		Monster = 1,
		Soldier,
		Building,
		Player,
        AltarSoldier,
	}

Awake的时候找到技能释放触发点位置

Start的时候  添加上所有的动画

Update的时候更新    状态以及每次发生变化的所有属性 

 Ientity  为实物的接口类  ，人物的属性以及调用的方法都调用这个类里面的

 

 每一帧都会调用状态机中的  Execute  函数

然后根据对应的状态再去调用  Iselfplayer   和Iplayer  中对应的方法

技能面板为 SkillWindow

选中目标按下普攻

请求自动战斗

释放技能通知OnNetMsg_NotifyReleaseSkill，

 

 

释放的普通技能 

 //释放技能
        public virtual void OnEntityReleaseSkill()
        {
            SkillManagerConfig skillManagerConfig = ConfigReader.GetSkillManagerCfg(EntitySkillID);
            if (skillManagerConfig == null)
            {
                return;
            }
            //吸附技能
            if (skillManagerConfig.isAbsorb == 1)
            {
                //删除已有的相同特效
                foreach (Transform child in RealEntity.objAttackPoint)
                {
                    if (child.name.Contains(skillManagerConfig.absorbRes))
                    {
                        int offset = child.name.IndexOf('_');
                        if (offset != 0)
                        {
                            string name = child.name.Substring(offset + 1);
                            int id = Convert.ToInt32(name);
                            EffectManager.Instance.DestroyEffect(id);
                        }
                    }
                }

                //创建吸附技能效果
                string absortActPath = "effect/soul_act/" + skillManagerConfig.absorbRes;
                NormalEffect absortSkillEffect = EffectManager.Instance.CreateNormalEffect(absortActPath, RealEntity.objAttackPoint.gameObject);
                if (absortSkillEffect != null)
                {
                    Quaternion rt = Quaternion.LookRotation(EntityFSMDirection);
                    //absortSkillEffect.obj.transform.rotation = rt;
                }
                objTransform.rotation = Quaternion.LookRotation(EntityFSMDirection);
            }
            else
            {
                //普通技能
                if (skillManagerConfig.isNormalAttack == 1)
                {
                    //播放攻击动画动画
                    RealEntity.PlayeAttackAnimation();
                }
                else
                {
                    {
                        //释放技能动画
                        RealEntity.PlayerAnimation(skillManagerConfig.rAnimation);

                        if (RealEntity.GetComponent<Animation>()[skillManagerConfig.rAnimation] != null && RealEntity.GetComponent<Animation>()[skillManagerConfig.rAnimation].wrapMode != WrapMode.Loop)
                        {
                            //动画融合
                            RealEntity.CrossFadeSqu("free");
                        }
                        //播放特效
                        Game.Effect.EffectManager.playSkillReleaseSound(this, EntitySkillID);
                    }
                }
                float distance = GetDistanceToPos(EntityFSMPosition);
                if (entityType != EntityType.Building)
                {
                    objTransform.rotation = Quaternion.LookRotation(EntityFSMDirection);
                }
            }
        }

 

技能信息通知OnNetMsg_NotifySkillInfo冷却，

 public override void OnSkillInfoChange(int skillID, float time, float maxTime, int slot)
        {
            SkillType skillType = SkillType.SKILL_NULL;
            if (skillID == SkillIdDic[SkillType.SKILL_TYPE1])
            {
                skillType = SkillType.SKILL_TYPE1;
            }
            else if (skillID == SkillIdDic[SkillType.SKILL_TYPE3])
            {
                skillType = SkillType.SKILL_TYPE3;
            }
            else if (skillID == SkillIdDic[SkillType.SKILL_TYPE2])
            {
                skillType = SkillType.SKILL_TYPE2;
            }
            else if (skillID == SkillIdDic[SkillType.SKILL_TYPE4])
            {
                skillType = SkillType.SKILL_TYPE4;
            }
            else if (skillID == SkillIdDic[SkillType.SKILL_TYPEABSORB1])
            {
                skillType = SkillType.SKILL_TYPEABSORB1;
            }
            else if (skillID == SkillIdDic[SkillType.SKILL_TYPEABSORB2])
            {
                skillType = SkillType.SKILL_TYPEABSORB2;
            }
            else
            {
                return;
            }
            SetBaseSkillType(skillType, skillID);
            if (time > 0)
            {
                bPlaySkill = false;
            }

            EventCenter.Broadcast<SkillType, float, float>(EGameEvent.eGameEvent_LocalPlayerSkillCD, skillType, maxTime, time);
        }

普通技能return回去了；

 

通知释放技能，怪物释放技能OnNetMsg_NotifyReleaseSkill   执行上面逻辑

 死亡通知OnNetMsg_NotifyGameObjectDeadState

 

Int32 OnNetMsg_NotifyGameObjectDeadState(Stream stream)
    {
        GSToGC.DeadState pMsg;
        if (!ProtoDes(out pMsg, stream))
        {
            return PROTO_DESERIALIZE_ERROR;
        }
        UInt64 deadID;
        deadID = pMsg.objguid;
        Vector3 pos = this.ConvertPosToVector3(pMsg.pos);
        Vector3 dir = this.ConvertDirToVector3(pMsg.dir);
        Ientity entity;
        if (EntityManager.AllEntitys.TryGetValue(deadID, out entity))
        {
            pos.y = entity.realObject.transform.position.y;
            entity.deadSpot = pMsg.spot;
            entity.EntityFSMChangeDataOnDead(pos, dir);

            //主基地延时处理
            if (entity.NPCCateChild != ENPCCateChild.eNPCChild_BUILD_Base)
            {
                entity.OnFSMStateChange(EntityDeadFSM.Instance);
            }
        }
        return (Int32)EErrorCode.eNormal;
    }

 

 /// <summary>
        /// Entity死亡
        /// </summary>
        public virtual void OnEnterDead()
        {
            //目标死亡主角相关处理
            Iselfplayer player = PlayerManager.Instance.LocalPlayer;
            if (player != null && player.SyncLockTarget != null && GameObjGUID == player.SyncLockTarget.GameObjGUID)
            {
                player.SetSyncLockTarget(null);
            }

            //播放死亡声音
            Vector3 pos = PlayerManager.Instance.LocalPlayer.RealEntity.transform.position;
            if (GetDistanceToPos(pos) <= 30)
            {
                this.PlayDeadSound();
            }

            //建筑物更换模型和播表现特效
            if (this.entityType == EntityType.Building && this.NPCCateChild != ENPCCateChild.eNPCChild_BUILD_Base)
            {
                if (!EntityManager.GetHomeBaseList().Contains(this))
                {
                    GameMethod.SetLoadJianTaBaoZha(this);

                    int ret = EntityManager.HandleDelectEntity(this.GameObjGUID);
                    if (ret != 0)
                    {
                        Debug.LogError("OnEnterDead HandleDelectEntity:" + GameObjGUID + "failed");
                    }
                }
                EventCenter.Broadcast<Ientity>(EGameEvent.eGameEvent_NotifyBuildingDes, this);
                return;
            }

            //非建筑物播死亡动画和清理血条等状态
            this.DoEntityDead();
            RealEntity.PlayerDeadAnimation();
        }

 

//播放死亡动画 

 

技能攻击

上面为注册的事件

 

按下技能OnSkillBtnFunc 

        private void OnSkillBtnFunc(int ie, bool isDown)
        {
            if (mIsShowDes)
            {
                mIsShowDes = false;
                return;
            }
            mIsShowDes = false;

            GamePlayCtrl.Instance.showaudiotimeold = System.DateTime.Now;
            if (PlayerManager.Instance.LocalPlayer.FSM == null ||
                PlayerManager.Instance.LocalPlayer.FSM.State == Game.FSM.FsmState.FSM_STATE_DEAD ||
                Game.Skill.BuffManager.Instance.isSelfHaveBuffType(1017))
            {
                return;
            }
            //发送技能
            SendSkill(ie);
        }

SendPreparePlaySkill 

 释放技能通知释

 //释放技能
    Int32 OnNetMsg_NotifyReleaseSkill(Stream stream)
    {
        GSToGC.ReleasingSkillState pMsg;
        if (!ProtoDes(out pMsg, stream))
        {
            return PROTO_DESERIALIZE_ERROR;
        }
        Vector3 pos = this.ConvertPosToVector3(pMsg.pos);
        Vector3 dir = this.ConvertDirToVector3(pMsg.dir);
        dir.y = 0.0f;
        UInt64 targetID;
        targetID = pMsg.targuid;
        UInt64 sGUID;
        sGUID = pMsg.objguid;
        Ientity target;
        EntityManager.AllEntitys.TryGetValue(targetID, out target);
        Ientity entity;
        if (EntityManager.AllEntitys.TryGetValue(sGUID, out entity))
        {
            pos.y = entity.realObject.transform.position.y;
            
            //准备技能
            entity.EntityFSMChangeDataOnPrepareSkill(pos, dir, pMsg.skillid, target);
            //有限状态机去改变
            entity.OnFSMStateChange(EntityReleaseSkillFSM.Instance);
        }
        return (Int32)EErrorCode.eNormal;
    }

 //释放技能
        public virtual void OnEntityReleaseSkill()
        {
            SkillManagerConfig skillManagerConfig = ConfigReader.GetSkillManagerCfg(EntitySkillID);
            if (skillManagerConfig == null)
            {
                return;
            }
            //吸附技能
            if (skillManagerConfig.isAbsorb == 1)
            {
                //删除已有的相同特效
                foreach (Transform child in RealEntity.objAttackPoint)
                {
                    if (child.name.Contains(skillManagerConfig.absorbRes))
                    {
                        int offset = child.name.IndexOf('_');
                        if (offset != 0)
                        {
                            string name = child.name.Substring(offset + 1);
                            int id = Convert.ToInt32(name);
                            EffectManager.Instance.DestroyEffect(id);
                        }
                    }
                }

                //创建吸附技能效果
                string absortActPath = "effect/soul_act/" + skillManagerConfig.absorbRes;
                NormalEffect absortSkillEffect = EffectManager.Instance.CreateNormalEffect(absortActPath, RealEntity.objAttackPoint.gameObject);
                if (absortSkillEffect != null)
                {
                    Quaternion rt = Quaternion.LookRotation(EntityFSMDirection);
                    //absortSkillEffect.obj.transform.rotation = rt;
                }
                objTransform.rotation = Quaternion.LookRotation(EntityFSMDirection);
            }
            else
            {
                //普通技能
                if (skillManagerConfig.isNormalAttack == 1)
                {
                    //播放攻击动画动画
                    RealEntity.PlayeAttackAnimation();
                }
                else
                {
                    {
                        //释放技能动画
                        RealEntity.PlayerAnimation(skillManagerConfig.rAnimation);

                        if (RealEntity.GetComponent<Animation>()[skillManagerConfig.rAnimation] != null && RealEntity.GetComponent<Animation>()[skillManagerConfig.rAnimation].wrapMode != WrapMode.Loop)
                        {
                            //动画融合
                            RealEntity.CrossFadeSqu("free");
                        }
                        //播放特效
                        Game.Effect.EffectManager.playSkillReleaseSound(this, EntitySkillID);
                    }
                }
                float distance = GetDistanceToPos(EntityFSMPosition);
                if (entityType != EntityType.Building)
                {
                    objTransform.rotation = Quaternion.LookRotation(EntityFSMDirection);
                }
            }
        }

 

放技能动画 RealEntity.PlayerAnimatio，

通知技能信息

OnNetMsg_NotifySkillInfo技能冷却 

   OnSkillInfoChange 

 

  public override void OnSkillInfoChange(int skillID, float time, float maxTime, int slot)
        {
            SkillType skillType = SkillType.SKILL_NULL;
            if (skillID == SkillIdDic[SkillType.SKILL_TYPE1])
            {
                skillType = SkillType.SKILL_TYPE1;
            }
            else if (skillID == SkillIdDic[SkillType.SKILL_TYPE3])
            {
                skillType = SkillType.SKILL_TYPE3;
            }
            else if (skillID == SkillIdDic[SkillType.SKILL_TYPE2])
            {
                skillType = SkillType.SKILL_TYPE2;
            }
            else if (skillID == SkillIdDic[SkillType.SKILL_TYPE4])
            {
                skillType = SkillType.SKILL_TYPE4;
            }
            else if (skillID == SkillIdDic[SkillType.SKILL_TYPEABSORB1])
            {
                skillType = SkillType.SKILL_TYPEABSORB1;
            }
            else if (skillID == SkillIdDic[SkillType.SKILL_TYPEABSORB2])
            {
                skillType = SkillType.SKILL_TYPEABSORB2;
            }
            else
            {
                return;
            }
            SetBaseSkillType(skillType, skillID);
            if (time > 0)
            {
                bPlaySkill = false;
            }

            EventCenter.Broadcast<SkillType, float, float>(EGameEvent.eGameEvent_LocalPlayerSkillCD, skillType, maxTime, time);
        }

收到通知

 

  //显示有效的可以在使用中的技能
        public void ShowValideUseSkillBtn(ShortCutBarBtn btnType, bool visiable)
        {
            Iselfplayer player = PlayerManager.Instance.LocalPlayer;
            if (null == player)
            {
                return;
            }
            int index = (int)btnType;
            int skillId = 0;
            SkillManagerConfig info = null;
            switch (btnType)
            {
                case ShortCutBarBtn.BTN_SKILL_1:
                case ShortCutBarBtn.BTN_SKILL_2:
                case ShortCutBarBtn.BTN_SKILL_3:
                case ShortCutBarBtn.BTN_SKILL_4:
                    break;
                case ShortCutBarBtn.BTN_SKILL_5:
                    if (player != null && player.BaseSkillIdDic.ContainsKey(SkillType.SKILL_TYPEABSORB1))
                    {
                        skillId = player.BaseSkillIdDic[SkillType.SKILL_TYPEABSORB1];
                    }
                    info = ConfigReader.GetSkillManagerCfg(skillId);
                    if (skillId == 0 || info == null)
                    {
                        visiable = false;
                    }
                    break;
                case ShortCutBarBtn.BTN_SKILL_6:
                    if (player != null && player.BaseSkillIdDic.ContainsKey(SkillType.SKILL_TYPEABSORB2))
                    {
                        skillId = player.BaseSkillIdDic[SkillType.SKILL_TYPEABSORB2];
                    }
                    info = ConfigReader.GetSkillManagerCfg(skillId);
                    if (skillId == 0 || info == null)
                    {
                        visiable = false;
                    }
                    break;
                default:
                    return;
            }
            if (!visiable)
            {
                ShowCdEndEffect(btnType, false);
            }
        }

 

//显示按下技能特效
        public void ShowPressEffect(ShortCutBarBtn btnType)
        {
            if (IsSkillInCd(btnType) || mPressBtnEffect.ContainsKey(btnType))
            {
                return;
            }

            ResourceUnit objUnit = ResourcesManager.Instance.loadImmediate(GameConstDefine.PressBtnEffect, ResourceType.PREFAB);
            GameObject obj = GameObject.Instantiate(objUnit.Asset) as GameObject;

            int index = (int)btnType;
            obj.transform.parent = mBtnArray[index].transform;
            obj.transform.localPosition = Vector3.zero;
            obj.transform.localScale = Vector3.one;
            mPressBtnEffect.Add(btnType, obj);
            mPressBtnEffectTime.Add(btnType, 1.5f);
        }
   public void StartCdCountDown(float time, float last)
    {
        if (canCountCd)
            return;
        timeLimit = time;

        start = time - last;

        SetCdShow(true);
        StartCountTime = DateTime.Now;
        canCountCd = true;
    }

 

接受  OnNetMsg_NotifyLastingSkill     

 Int32 OnNetMsg_NotifyLastingSkill(Stream stream)
    {
        GSToGC.LastingSkillState pMsg;
        if (!ProtoDes(out pMsg, stream))
        {
            return PROTO_DESERIALIZE_ERROR;
        }
        Vector3 pos = this.ConvertPosToVector3(pMsg.pos);
        Vector3 dir = this.ConvertDirToVector3(pMsg.dir);
        dir.y = 0.0f;
        UInt64 targetID;
        targetID = pMsg.targuid;
        UInt64 sGUID;
        sGUID = pMsg.objguid;
        Ientity target;
        EntityManager.AllEntitys.TryGetValue(targetID, out target);
        Ientity entity;
        if (EntityManager.AllEntitys.TryGetValue(sGUID, out entity))
        {
            pos.y = entity.realObject.transform.position.y;
            entity.EntityFSMChangeDataOnPrepareSkill(pos, dir, pMsg.skillid, target);
            entity.OnFSMStateChange(EntityLastingFSM.Instance);
        }
        return (Int32)EErrorCode.eNormal;
    }

怪物 OnNetMsg_NotifyReleaseSkill   释放技能

OnNetMsg_NotifyGameObjectDeadState

 

OnNetMsg_NotifySkillInfo  return

玩家技能信息，冷却结束

qq_2385708623
关注
专栏目录
RPG2.0战斗框架学习4之技能释放过程
加蛋加蛋
08-12 2469
前言 这篇，主要分析角色接收到技能释放的信号，执行技能释放的动作 步骤 1 角色的行为由状态机来划分，不同状态下，会执行不同操作，攻击敌人这一行为，是由等待状态-》发现目标状态-》攻击状态， 当达到目标附近后，切换成为攻击状态，接到攻击指令，执行攻击操作 public virtual void ActionAttack() { //进行
状态同步，帧同步下的技能处理
折戟
03-21 1569
非帧同步,mmo类型的游戏技能系统(基于技能模板) ActorSystem(单位系统，管理场景中的Actor) ActorEntity(单位实体):持有BuffEntitys,SkillEntitys 监听ui层技能按钮的点击，点击后回调CasterId(释放者Id)和SkillId(技能id)到SkillValid(客户端本地的技能释放验证), 通过后表现层先播放前摇动画，且发释放技能的消息到服...
实现LOL游戏中英雄技能的释放
qq_39727276的博客
09-10 2703
今天我们要实现的是LOL中英雄技能的释放，当鼠标点击该技能或者按下代表该技能的按键时，出现技能的攻击范围圈，以及只能指示（线性指示或者范围圈指示等），在这里演示的为非指定向技能，也就是可以在范围内随意释放，不必对着敌方英雄释放的技能，用法一样，难点就是如何在一个脚本中区分各个按键的释放，在这里使用的是一个 bool开关，详细代码参照如下： public GameObject AttackCi
第四十节实现主人公的技能释放功能（一）
最新发布
zhaoyang314的博客
05-05 597
我准备用三节来完成主人公释放技能的功能。新建Area2D场景，命名为projectile，为根节点添加AnimatedSprite2D子节点，表示技能动画（例如水球、火攻等等）；VisibleOnScreenEnabler2D子节点（用于结点超出屏幕显示范围后消除该节点）；CollisionShape2D子节点表示碰撞检测。将此场景保存到场景目录中。
基于有限状态机实现角色逻辑控制与动画控制相统一（待机，移动，攻击）
ysn11111的博客
01-27 510
基于有限状态机实现的2D角色的控制器，实现逻辑控制与动画表现相统一
Entity Framework 实体状态
喵叔
07-28 1061
从今天开始我们开始讲解EF中的实体状态和数据操作，这篇文章先讲解实体状态。 我们通过前面的学习，知道EF通过上下位负责跟踪实体的状态，实体状态的位置是在命名空间 System.Dat.Entity 里的 EntityState，具体状态有如下5种： Detached Unchanged Added Deleted Modified 下面我们分辨来讲解一下 零、Detached 有时候我们只需...
cocoscreator3D防王者荣耀demo，已实现模型控制与技能释放
07-17
此外，角色的动画状态也需要与控制动作同步，例如奔跑、攻击、防御等，这通常需要用到骨骼动画和动画控制器。 技能释放是RPG游戏中的核心玩法之一。在这个demo中，开发者已经实现了这一功能，意味着玩家可以通过...
C# WPF游戏原型 能跑动能释放技能
04-25
WPF是.NET框架的一部分，它提供了丰富的用户界面（UI）功能，包括图形、动画和多媒体支持，非常适合创建交互式应用程序，如游戏。 ### C# WPF基础 C#是一种面向对象的编程语言，与WPF结合，可以构建高效且用户友好...
在游戏中实现和优化主人公的技能释放系统
状态机有助于管理角色的行为逻辑和动画播放。 3. 技能释放逻辑：编写代码来判断玩家的输入，并在输入有效时执行技能释放。这可能涉及到角色动画的播放、声音的播放、技能效果的计算等。 4. 技能栏UI：设计并实现...
unity 新手引导
海涛高软
12-27 2505
case (int)GSToGC.MsgID.eMsgToGCFromGS_GuideResp: print ("eMsgToGCFromGS_GuideResp"); OnNetMsg_NotifyGuideResp(stream); break; Int32 OnNetMsg_NotifyGuideRe
ProtoBuf与网络通信
qq_35647121的博客
07-08 1104
1，protobuf全称Protocol Buffers，是一种二进制的数据格式，具有更高的传输，打包和解包效率 2，protobuf的IDL都是保存为*.proto的文件中 3，proto文件中数据类型可以分为两大类：复合数据类型和标准数据类型。复合数据类型包括：枚举和message类型，标准数 数据类型包含：整型，浮点，字符串等 最常用的数据格式就是message，messa...
Unity3D新手引导开发手记
alteken5150的博客
07-15 1584
最近开始接手新手引导的开发，记录下这块相关的心得 首先客户端是Unity，在接手前，前面的同学已经初步完成了新手引导框架的搭建，这套框架比较简单，有优点也有缺点，稍后一一点评 我们的新手引导是由一个个强引导组成的，每个强引导都有一系列的步骤，这套框架实现的功能就是： 1.组织一个强引导（任务）所需的步骤，并可以一步一步前进 2.实现蒙版，遮罩以及高亮引导区 ...
消息的接收和处理
海涛高软
12-13 1269
上面代码，session接到数据后，找handle，下面就看看session中的handle是怎么赋值的其它的session中，handle的赋值也是按照这个套路来的#include "stdafx.h" #include "GSKernel.h" #include <iostream> #include <fstream> #include "GSSSInfo.h"using namespace
深入理解shortcut
蓝鲸_007的博客
04-04 2万+
概述 shortcut(或shortpath，中文“直连”或“捷径”)是CNN模型发展中出现的一种非常有效的结构，本文将从Highway networks到ResNet再到DenseNet概述shortcut的发展。 前言 自2012年Alex Krizhevsky利用深度卷积神经网络（CNN）（AlexNet ）取得ImageNet比赛冠军起，CNN在计算机视觉方面的应用引起了大家广泛地讨...
shortcut详解
热门推荐
qq_38859786的博客
07-03 3万+
一，阐述 Shortcuts功能跟随着 Android7.1 Nougat 一起诞生， 其主要目：在于用户可以定义一些常用的操作路径，以快捷方式的形式存在。 这些快捷方式展示在可以支持的设备上，帮助用户快速启动常用或者推荐的页面和行为。 二，展示方式 1,一种通过长按应用 icon，此时会弹出列表弹窗.(对于没有配置快捷方式的应用,一般都是手机厂商给的默认功能) ...
Unity3D---技能释放的效果
nuovocinemaparadiso的博客
04-09 3111
脚本挂在 image中 using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.UI; public class ImageScript : MonoBehaviour {     //定义变量，存储image主件     Image ima;
Unity3D开发（五）：Unity3D 4.x 使用Mecanim实现连击
huang9012的专栏
07-04 1032
Unity3D 4.x 版本之后提供了一种新的动画机制Mecanim，虽然目前还支持之前的Animation，但看到Unity3D 4.3 预览版里Sprite的动画也是基于Animator的，可知Mecanim将会是以后动画播放的趋势！ Mecanim是一种基于状态机的结构，不同的状态表示一个动作（或者多个动作融合，或者一个子状态机），状态之间使用一种称为Transition的组件关联，T
我竟然用它搞懂了王者荣耀的技能释放机制！【C#委托】
累计发表博客60余万字，CSDN 博客专家、Java 领域优质创作者、华为云享专家、阿里云专家博主。专注分享 Java 优质文章，毕设实战项目开发，全网粉丝10W+
06-20 5148
目录 什么是委托？ 如何定义和使用委托？ 1、声明委托类型 2、实例化委托对象 3、调用委托方法 Hello！大家好！我是努力赚钱买生发水的灰小猿。 “欢迎来到王者荣耀之C#专场” 最近在用C#的委托做开发时，发现委托这个东西实在在深奥，不了解的小伙伴觉得它没有卵用，然而了解的小伙伴却觉得它大有用途，所以今天大灰狼就借助王者荣耀的英雄技能释放机制和大家聊一聊C#中委托的神秘含义... “干货还有三秒到达战场！” 什么是委托？ 委托是C#中的一种构造，比如在C++中有函数指针的概念.
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值