Unity实现杀戮尖塔出牌效果（ 三. 贝塞尔曲线引导箭头绘制，卡牌使用效果制作）

已于 2024-03-06 10:43:09 修改
阅读量1.8k 收藏 26
点赞数 13
文章标签： unity 游戏引擎 算法 c#
于 2024-03-05 20:07:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33894287/article/details/136487400
版权

三. 卡牌使用效果,塞贝尔曲线引导箭头绘制

1. 攻击类型卡牌

①拖拽超过一定高度之后卡牌会移动到手牌中心位置
②出现攻击引导箭头 (塞贝尔曲线)
③成功指向目标怪物后打出

2. 技能能力类型卡牌

①可自由拖动
②脱离手牌高度后打出

核心代码展示

这里只展示此效果核心代码内容，重复代码不做赘述，上期（二.鼠标指向卡牌时，卡牌强调动画）完整版传送门

1.绘制贝塞尔曲线引导箭头（此脚本可作为独立通用脚本使用，制作其他贝塞尔曲线也可引用）
在这里插入图片描述
完整版本代码

public class ArrowEffectManager : MonoBehaviour  
{  
    public GameObject reticleBlock;  
    public GameObject reticleArrow;  
    public int MaxCount = 18;  
    public Vector3 startPoint; // 起始点  
    private Vector3 controlPoint1; // 控制点1  
    private Vector3 controlPoint2; // 控制点2  
    private Vector3 endPoint; // 结束点  
    private List<GameObject> ArrowItemList;  
    private List<SpriteRenderer> RendererItemList;  
    private Animator Arrow_anim;  
    private bool isSelect;  
  
    public bool IsSelect  
    {  
        get => isSelect;  
        set  
        {  
            if (isSelect != value)  
            {        
                isSelect = value;  
                if (value==true)  
                {
                      PlayAnim();  
                }         
            }       
         }   
     }  
    private void Awake()  
    {        InitData();  
    }  
    private void InitData()  
    {  
        ArrowItemList = new List<GameObject>();  
        RendererItemList = new List<SpriteRenderer>();  
        for (int i = 0; i < MaxCount; i++)  
        { 
            GameObject Arrow = (i == MaxCount - 1) ? reticleArrow : reticleBlock;  
            GameObject temp = Instantiate(Arrow, this.transform);  
            if (i == MaxCount - 1)  
            {    
                Arrow_anim = temp.GetComponent<Animator>();  
            }  
            ArrowItemList.Add(temp);  
            SpriteRenderer re = temp.transform.GetChild(0).GetComponent<SpriteRenderer>();  
            if (re != null)  
            {    
                  RendererItemList.Add(re);  
            }       
         }    
    }  
    public void Update()  
    {       
        Move();  
        DrawBezierCurve();  
    }  
    private void DrawBezierCurve()  
    {        
        for (int i = 0; i < ArrowItemList.Count; i++)  
        {            
            float t = i / (float) (ArrowItemList.Count - 1); // 参数 t 在 0 到 1 之间  
            Vector3 position =CalculateBezierPoint(t, startPoint, controlPoint1, controlPoint2, endPoint);  
            ArrowItemList[i].gameObject.SetActive(i != ArrowItemList.Count - 2);  
            ArrowItemList[i].transform.position = position;  
            ArrowItemList[i].transform.localScale = Vector3.one * (t / 2f) + Vector3.one * 0.3f;  
            if (i > 0)  
            {                
                float SignedAngle = Vector2.SignedAngle(Vector2.up,  
                ArrowItemList[i].transform.position - ArrowItemList[i - 1].transform.position);  
                Vector3 euler = new Vector3(0, 0, SignedAngle);  
                ArrowItemList[i].transform.rotation = Quaternion.Euler(euler);  
            }        
        }    
    }  
    private void OnDrawGizmos()  
    {        
     // Gizmos.color = Color.yellow;        
     // Gizmos.DrawLine(startPoint, controlPoint1);       
     // Gizmos.DrawSphere(startPoint, 0.1f);        
     // Gizmos.DrawSphere(controlPoint1, 0.1f);        
     // Gizmos.DrawLine(endPoint, controlPoint2);        
     // Gizmos.DrawSphere(endPoint, 0.1f);        
     // Gizmos.DrawSphere(controlPoint2, 0.1f);    
     }  
    public void Move()  
    {        
        Vector3 mousePosition = Input.mousePosition; // 获取鼠标位置  
        mousePosition.z = Camera.main.nearClipPlane; // 设置z坐标为摄像机近裁剪平面的位置  
        Vector3 worldPosition = Camera.main.ScreenToWorldPoint(mousePosition);  
        worldPosition.z = 2f;  
        endPoint = worldPosition;  
  
        controlPoint1 = (Vector2) startPoint + (worldPosition - startPoint) * new Vector2(-0.28f, 0.8f);  
        controlPoint2 = (Vector2) startPoint + (worldPosition - startPoint) * new Vector2(0.12f, 1.4f);  
        controlPoint1.z = startPoint.z;  
        controlPoint2.z = startPoint.z;  
    }  
    /// <summary>  
    /// 设置起始位置  
    /// </summary>  
    public void SetStartPos(Vector3 pos)  
    {        
       startPoint = pos;  
    }  
    /// <summary>  
    /// 设置颜色  
    /// </summary>  
    public void SetColor(Color color)  
    {        
        if (RendererItemList == null)  
        {            
            return;  
        }  
        for (int i = 0; i < RendererItemList.Count; i++)  
        {            
            RendererItemList[i].color = color;  
        }    
        }  
    /// <summary>  
    /// 设置颜色  
    /// </summary>  
    /// <param name="isSelect"></param>    
    public void SetColor(bool isSelect)  
    {        
        IsSelect = isSelect;  
        if (isSelect)  
        {            
           SetColor(Color.red);  
        }        
        else  
        {  
            SetColor(Color.white);  
        }    
        }  
    private void PlayAnim()  
    {        
       if (Arrow_anim == null)  
        {            
           return;  
        }        
        Arrow_anim.SetTrigger("select");  
    }          
/// <summary>  
    /// 获取贝塞尔曲线中间点  
    /// </summary>  
    /// <param name="t">参数 t 在 0 到 1 之间</param>  
    /// <param name="startPoint">起始点</param>  
    /// <param name="controlPoint1">起点控制点</param>  
    /// <param name="controlPoint2">终点控制点</param>  
    /// <param name="endPoint">终点</param>  
    /// <returns></returns>    
    public static Vector3 CalculateBezierPoint(float t, Vector3 startPoint, Vector3 controlPoint1, Vector3 controlPoint2, Vector3 endPoint)  
    {        
        float u = 1 - t;  
        float tt = t * t;  
        float uu = u * u;  
        float uuu = uu * u;  
        float ttt = tt * t;  
  
        Vector3 point = uuu * startPoint; // (1-t)^3 * P0  
        point += 3 * uu * t * controlPoint1; // 3 * (1-t)^2 * t * P1  
        point += 3 * u * tt * controlPoint2; // 3 * (1-t) * t^2 * P2  
        point += ttt * endPoint; // t^3 * P3  
  
        return point;  
    }}

出牌整体效果实现：

1. 选中卡牌拖拽后卡牌本体暂时隐藏（gameObject.SetActive(false)）
2. 展示此卡牌的克隆体，克隆体鼠标跟随
3. 非攻击类型卡牌：拖拽中无位置限制，拖拽结束超过基础高度视为打出，出牌成功后隐藏克隆卡牌，销毁卡牌本体，执行使用成功指令。拖拽结束如果没有超过基础高度，隐藏克隆卡牌，卡牌本体隐藏状态解除
4. 攻击类型卡牌：拖拽超过基础高度克隆体位移至手牌居中位置，生成塞贝尔曲线引导箭头，箭头指向目标后，箭头变色，播放选中动画。如果选中目标隐藏克隆卡牌，销毁卡牌本体，执行使用成功指令。否则，隐藏克隆卡牌，卡牌本体隐藏状态解除
在这里插入图片描述

【核心代码片段】

//class CardManager

 /// <summary>
 /// 设置卡牌使用特效
 /// </summary>
 public void CardUseEffect()
 {
     //如果当前没有选中卡牌，隐藏所有效果，并返回
     if (nowTaskItem == null)
     {
         temporaryCard.gameObject.SetActive(false);
         lineEffect.gameObject.SetActive(false);
         return;
     }

     temporaryCard.gameObject.SetActive(true);
     // 获取鼠标位置
     Vector3 mousePosition = Input.mousePosition;
     // 设置z坐标为摄像机近裁剪平面的位置
     mousePosition.z = Camera.main.nearClipPlane;
     //将屏幕上的鼠标位置转换为世界坐标系中的位置。
     Vector3 worldPosition = Camera.main.ScreenToWorldPoint(mousePosition);
     worldPosition.z = 5f;
     Vector3 centPos = new Vector3(0, -2.9f, 4);
     bool isWaitAttack = false;
     if (nowTaskItem.attackType == ECardAttackType.Single)
     {
         if (worldPosition.y > -2.4f)
         {
             //攻击类型卡牌，拖拽超过基础高度标记为等待攻击 
             isWaitAttack = true;
         }
     }

     //如果是等待攻击状态将克隆卡牌移动至centPos否则跟随鼠标移动
     temporaryCard.gameObject.transform.position = Vector3.Lerp(temporaryCard.gameObject.transform.position,
         isWaitAttack ? centPos : worldPosition, Time.deltaTime * 15);
     //设置塞贝尔曲线起始点
     lineEffect.SetStartPos(isWaitAttack ? centPos : worldPosition);
     //设置攻击引导箭头颜色
     lineEffect.SetColor(nowSelectPlayer != null);
     //攻击引导箭头显示隐藏控制
     lineEffect.gameObject.SetActive(isWaitAttack);
 }

新增枚举

public enum ECardAttackType
{
    Skill,
    Single,
    Power
}

CardManager 当前阶段完整版本代码

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

public class CardManager : MonoBehaviour
{
    /// <summary>
    /// 卡牌起始位置
    /// </summary>
    public Vector3 rootPos = new Vector3(0, -33.5f, 20);

    /// <summary>
    /// 卡牌对象
    /// </summary>
    public GameObject cardItem;

    /// <summary>
    /// 扇形半径
    /// </summary>
    public float size = 30f;

    /// <summary>
    /// 卡牌出现最大位置
    /// </summary>
    private float minPos = 1.415f;

    /// <summary>
    /// 卡牌出现最小位置
    /// </summary>
    private float maxPos = 1.73f;

    /// <summary>
    /// 手牌列表
    /// </summary>
    private List<CardItem> cardList;

    /// <summary>
    /// 偶数手牌位置列表
    /// </summary>
    private List<float> rotPos_EvenNumber;
    /// <summary>
    /// 奇数手牌位置列表
    /// </summary>
    private List<float> rotPos_OddNumber;

    /// <summary>
    /// 最大手牌数量
    /// </summary>
    private int CardMaxCount = 8;

    private CardItem nowSelectItem;

    /// <summary>
    /// 当前鼠标指向的卡牌
    /// </summary>
    public CardItem NowSelectItem
    {
        get => nowSelectItem;
        set
        {
            if (nowSelectItem != value)
            {
                nowSelectItem = value;
                RefreshSelectItem(nowSelectItem);
            }
        }
    }

    public GameObject temporaryCard;

    /// <summary>
    /// 当前点击选中的卡牌
    /// </summary>
    private CardItem nowTaskItem;

    public ArrowEffectManager lineEffect;

    /// <summary>
    /// 当前选中敌人
    /// </summary>
    private GameObject nowSelectPlayer;

    private Vector3 temporaryCardStartPos;


    void Start()
    {
        InitCard();
    }

    /// <summary>
    /// 数据初始化
    /// </summary>
    public void InitCard()
    {
        int EvenNumber = CardMaxCount % 2 == 0 ? CardMaxCount : CardMaxCount - 1;
        int OddNumber = CardMaxCount % 2 == 0 ? CardMaxCount-1 : CardMaxCount;
        rotPos_EvenNumber=InitRotPos(EvenNumber);
        rotPos_OddNumber=InitRotPos(OddNumber);
    }

    /// <summary>
    /// 初始化位置
    /// </summary>
    /// <param name="count"></param>
    /// <param name="interval"></param>
    /// <returns></returns>
    public List<float> InitRotPos(int count)
    {
        List<float> rotPos = new List<float>();
        float interval = (maxPos - minPos) / count;
        for (int i = 0; i < count; i++)
        {
            float nowPos = maxPos - interval * i;
            rotPos.Add(nowPos);
        }

        return rotPos;
    }

    // Update is called once per frame
    void Update()
    {
        TaskItemDetection();
        RefereshCard();
        SelectItemDetection();
        CardUseEffect();
    }

    /// <summary>
    /// 添加卡牌
    /// </summary>
    public void AddCard()
    {
        if (cardList == null)
        {
            cardList = new List<CardItem>();
        }

        if (cardList.Count >= CardMaxCount)
        {
            Debug.Log("手牌数量上限");
            return;
        }

        GameObject item = Instantiate(cardItem, this.transform);
        CardItem text = item.GetComponent<CardItem>();
        text.RefreshData(rootPos, 0, 0, 0);
        cardList.Add(text);
    }

    /// <summary>
    /// 手牌状态刷新
    /// </summary>
    public void RefereshCard()
    {
        if (cardList == null)
        {
            return;
        }

        int TaskIndex = 0;
        //得到当前选中的卡牌下标
        bool isTaskIndex = GetTaskIndex(out TaskIndex);

        List<float> rotPos;
        int strtCount = 0;
        float interval;
        if (cardList.Count%2==0)
        {
            rotPos = rotPos_EvenNumber;
            strtCount= rotPos_EvenNumber.Count / 2 - cardList.Count / 2;
        }
        else
        {
            rotPos = rotPos_OddNumber;
            strtCount= (rotPos_OddNumber.Count+1) / 2 - (cardList.Count+1) / 2;
        }
        for (int i = 0; i < cardList.Count; i++)
        {
            float shifting = 0;
            float indexNowNumber = 0.0042f;
            float Difference = TaskIndex - i;
            float absDifference = Difference > 0 ? 4 - Difference : 4 + Difference;
            if (absDifference < 0)
            {
                absDifference = 0;
            }

            if (isTaskIndex && TaskIndex != i)
            {
                shifting = (TaskIndex > i) ? indexNowNumber * absDifference : -indexNowNumber * absDifference;
            }

            cardList[i].RefreshData(rootPos, rotPos[strtCount+i] + shifting, size, i);
        }
    }

    /// <summary>
    /// 销毁卡牌
    /// </summary>
    public void RemoveCard()
    {
        if (cardList == null)
        {
            return;
        }

        CardItem item = cardList[cardList.Count - 1];
        cardList.Remove(item);
        Destroy(item.gameObject);
    }

    /// <summary>
    /// 销毁卡牌
    /// </summary>
    /// <param name="item"></param>
    public void RemoveCard(CardItem item)
    {
        if (cardList == null)
        {
            return;
        }

        cardList.Remove(item);
        Destroy(item.gameObject);
    }

    private Vector3 oldmousePosition;


    /// <summary>
    /// 玩家操作检测
    /// </summary>
    public void TaskItemDetection()
    {
        if (Input.GetKeyDown(KeyCode.A))
        {
            AddCard();
        }

        if (Input.GetMouseButtonDown(0))
        {
            if (nowTaskItem != null)
            {
                nowTaskItem.gameObject.SetActive(true);
                nowTaskItem = null;
            }

            temporaryCardStartPos = temporaryCard.transform.position;
            SelectCard();
        }

        if (Input.GetMouseButton(0))
        {
            SelectEnemy();
        }

        if (Input.GetMouseButtonUp(0))
        {
            if (nowTaskItem != null)
            {
                if (IsDestoryCard())
                {
                    RemoveCard(nowTaskItem);
                }
                else
                {
                    nowTaskItem.gameObject.SetActive(true);
                    nowTaskItem = null;
                }

                nowSelectPlayer = null;
            }
        }
    }

    /// <summary>
    /// 是否需要销毁卡牌
    /// </summary>
    /// <returns></returns>
    public bool IsDestoryCard()
    {
        if (nowSelectPlayer != null)
        {
            return true;
        }

        float dis = temporaryCardStartPos.y - temporaryCard.transform.position.y;
        float absDis = dis > 0 ? dis : -dis;
        return absDis > 2.6f;
    }


    /// <summary>
    /// 选中卡牌检测
    /// </summary>
    public void SelectItemDetection()
    {
        if (oldmousePosition == Input.mousePosition)
        {
            return;
        }

        oldmousePosition = Input.mousePosition;
        // 从鼠标位置创建一条射线
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        RaycastHit hit;
        LayerMask layerMask = LayerMask.GetMask("Card");
        // 检测射线是否与物体相交
        if (Physics.Raycast(ray, out hit, 1000, layerMask))
        {
            if (hit.collider.gameObject != null)
            {
                NowSelectItem = hit.collider.gameObject.GetComponent<CardItem>();

                return;
            }
        }

        NowSelectItem = null;
    }

    /// <summary>
    /// 刷新当前选中的卡牌
    /// </summary>
    /// <param name="selectItem"></param>
    public void RefreshSelectItem(CardItem selectItem)
    {
        if (cardList == null)
        {
            return;
        }

        for (int i = 0; i < cardList.Count; i++)
        {
            cardList[i].isSelect = cardList[i] == selectItem;
            if (cardList[i] == selectItem)
            {
                temporaryCard.gameObject.transform.position = cardList[i].gameObject.transform.position;
            }
        }
    }

    /// <summary>
    /// 得到当前选中的卡牌下标
    /// </summary>
    /// <param name="index"></param>
    /// <returns></returns>
    public bool GetTaskIndex(out int index)
    {
        index = 0;
        for (int i = 0; i < cardList.Count; i++)
        {
            if (cardList[i].isSelect)
            {
                index = i;
                return true;
            }
        }

        return false;
    }


    /// <summary>
    /// 选中卡牌
    /// </summary>
    public void SelectCard()
    {
        // 从鼠标位置创建一条射线
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        RaycastHit hit;
        LayerMask layerMask = LayerMask.GetMask("Card");
        // 检测射线是否与物体相交
        if (Physics.Raycast(ray, out hit, 1000, layerMask))
        {
            if (hit.collider.gameObject != null)
            {
                nowTaskItem = hit.collider.gameObject.GetComponent<CardItem>();
                nowTaskItem.gameObject.SetActive(false);
            }
        }
    }

    /// <summary>
    /// 获取当前选中的对象
    /// </summary>
    /// <param name="layerName"></param>
    /// <returns></returns>
    public GameObject GetSelectPlayer(string layerName)
    {
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        RaycastHit hit;
        LayerMask layerMask = LayerMask.GetMask(layerName);
        // 检测射线是否与物体相交
        if (Physics.Raycast(ray, out hit, 1000, layerMask))
        {
            if (hit.collider.gameObject != null)
            {
                return hit.collider.gameObject;
            }
        }

        return null;
    }

    /// <summary>
    /// 选中对象
    /// </summary>
    public void SelectEnemy()
    {
        if (nowTaskItem == null)
        {
            nowSelectPlayer = null;
            return;
        }


        ECardAttackType etype = nowTaskItem.attackType;
        switch (etype)
        {
            case ECardAttackType.Power:
                break;
            case ECardAttackType.Single:
                nowSelectPlayer = GetSelectPlayer("Enemy");
                break;
            case ECardAttackType.Skill:
                break;
        }
    }

    /// <summary>
    /// 设置卡牌使用特效
    /// </summary>
    public void CardUseEffect()
    {
        //如果当前没有选中卡牌，隐藏所有效果，并返回
        if (nowTaskItem == null)
        {
            temporaryCard.gameObject.SetActive(false);
            lineEffect.gameObject.SetActive(false);
            return;
        }

        temporaryCard.gameObject.SetActive(true);
        // 获取鼠标位置
        Vector3 mousePosition = Input.mousePosition;
        // 设置z坐标为摄像机近裁剪平面的位置
        mousePosition.z = Camera.main.nearClipPlane;
        //将屏幕上的鼠标位置转换为世界坐标系中的位置。
        Vector3 worldPosition = Camera.main.ScreenToWorldPoint(mousePosition);
        worldPosition.z = 5f;
        Vector3 centPos = new Vector3(0, -2.9f, 4);
        bool isWaitAttack = false;
        if (nowTaskItem.attackType == ECardAttackType.Single)
        {
            if (worldPosition.y > -2.4f)
            {
                //攻击类型卡牌，拖拽超过基础高度标记为等待攻击 
                isWaitAttack = true;
            }
        }

        //如果是等待攻击状态将克隆卡牌移动至centPos否则跟随鼠标移动
        temporaryCard.gameObject.transform.position = Vector3.Lerp(temporaryCard.gameObject.transform.position,
            isWaitAttack ? centPos : worldPosition, Time.deltaTime * 15);
        //设置塞贝尔曲线起始点
        lineEffect.SetStartPos(isWaitAttack ? centPos : worldPosition);
        //设置攻击引导箭头颜色
        lineEffect.SetColor(nowSelectPlayer != null);
        //攻击引导箭头显示隐藏控制
        lineEffect.gameObject.SetActive(isWaitAttack);
    }
}

附件箭头素材
在这里插入图片描述
在这里插入图片描述

永兮
关注
【用unity实现100个游戏之7】实现一个类《杀戮尖塔》的卡牌回合制游戏（附项目源码）
向宇
09-01 1万+
【用unity实现100个游戏之7】实现一个类《杀戮尖塔》的卡牌回合制游戏（附项目源码）
【unity小技巧】使用贝塞尔曲线实现导弹随机攻击敌人，也可以用于平滑拾取物品
向宇
06-03 1920
可以用来收集金币，收集经验，导弹攻击敌人的平滑运动过渡效果
[Unity教程]仿杀戮尖塔卡牌游戏教程
CStudio
12-07 1128
使用unity，C#语言开发仿杀戮尖塔的卡牌游戏，其中实现了配置表设计，UIManager，敌人ai，状态切换等逻辑。
Unity类杀戮尖塔卡牌游戏开发笔记2
weixin_69716909的博客
07-12 782
作用：为提供一个自定义的编辑器界面，可能包括显示当前监听者的信息。实现继承自。使用方法来绘制自定义的Inspector界面。使用反射或其他方法来获取委托中已注册的监听者信息，并在Inspector中显示。
Unity类杀戮尖塔卡牌游戏开发笔记
weixin_69716909的博客
07-11 1312
地图制作
【Unity】类杀戮尖塔手牌系统实现（初始卡组、随机抽牌、卡牌绘制）
weixin_42680627的博客
01-27 4716
制作初始卡组 在DontDestroyOnLoad 的物体下挂不会被销毁的Global脚本，用于跨场景调用玩家当前手牌 制作ScriptableObject类型的卡资源，这样策划可以直接在Unity编辑器中填写数据来制作多个卡牌 public enum CardClass {Attack,Armor,Thron,Special } [CreateAssetMenu(menuName = "Create CardAsset ")] public class CardAsset : ScriptableOb
【Unity】用Lerp()实现类杀戮尖塔手牌变化
weixin_42680627的博客
11-07 1669
Lerp的种类 math类里的Lerp函数可以对很多种数据类型进行插值，这里主要用的是Vector3的，因为变换position、scale都要用 这里的难点是rotation，我试了用Quaternion.Lerp但是放弃了，因为参数必须也是Quaternion类型的（注意大写）， `public static Quaternion Lerp(Quaternion a, Quaternion b, float t);` 所以transform.rotation是不能作为参数的，quaternion.
Unity拖拽箭头
mastergzw的博客
06-04 1532
实现拖拽箭头
贝塞尔曲线绘制原理& unity 3d实现绘制贝塞尔曲线
sinat_23079759的博客
12-14 9763
贝塞尔曲线是一种绘制曲线的方法，它的原理很简单： 以二阶贝塞尔曲线为例 如图，在p0,p1之间移动着一个点，我们先称之为a0，同样在p1,p2之间移动着一个点，我们称之为a1。他们需要满足的条件是这样的，在移动中，保证线段p0a0：p0p1=p1a1：p1p2=X ，这个比值X是从0到1逐渐变化的。 然后我们连接a0，a1，在线段a0a1上有一点b0，我们同样保证a0b0：a0a1
【Unity3D小功能】Unity3D中实现箭头指向目标点的效果
热门推荐
CSDN博客专家，Unity3D高级软件工程师，《Unity 3D从入门到实战》作者。
03-29 1万+
推荐阅读 CSDN主页 GitHub开源地址 Unity3D插件分享 简书地址 我的个人博客 QQ群：1040082875 大家好，我是佛系工程师☆恬静的小魔龙☆，不定时更新Unity开发技巧，觉得有用记得一键三连哦。 一、前言 最近开发的时候遇到了箭头指向的需求，本来想用我这篇文章中的代码来着： 【Unity3D日常开发】Unity中实现箭头指向效果实现 但是想到这个代码是在Update里面运行，对效率影响比较大，正好看到这个同学给我留言： 我看了一下他这个是通过Shader和MeshRende.
[Unity教程]仿杀戮尖塔卡牌游戏教程的工程文件
最新发布
08-19
[Unity教程]仿杀戮尖塔卡牌游戏教程（完结） 我是看了B站的一个UP主，跟着学习，最后照着他的做出来的。 Unity版本：Unity 2022.3.15f1c1 代码编写工具：Visual Studio 2022 视频链接：【[Unity教程]仿杀戮尖塔卡牌游戏教程（完结）】 https://www.bilibili.com/video/BV1eF41177hu/?share_source=copy_web&vd_source=5561fd4227f5e74d1492abc20ea46239
Unity3D搓牌效果支持4个方向
05-30
该资源基于Book-curl修改，谢谢原创的思路。 该文件可直接运行，支持4个方向的搓牌。
Unity实现卡牌翻动效果
08-26
主要为大家详细介绍了Unity实现卡牌翻动效果，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Unity杀戮尖塔地图算法实现Demo
04-10
Unity杀戮尖塔地图算法实现 项目引擎：Unity 语言：C# 主要实现逻辑 一. 地图房间生成规则 ①房间数量规则 起点层：房间数量动态配置 中间层：房间数量 :{最小值：2 ，最大值起点数量*2-1} boss 层：房间数量=1 ②房间位置 X: 房间在该层平铺后+随机横向偏移 Y：当前层数 * 每层高度+随机纵向偏移 二. 路线生成规则 ①获取当前房间最近的上层房间，将该房间存入当前房间上层对象列表中 ②断路检索：如果下层房间没有任何对象将当前层设置到上层对象列表中，下层距离此层距离最近的对象将此层添加上层对象列表 ③链接当前层和上层对象列表中的对象
Unity3D实现攻击范围检测
12-20
本文实例为大家分享了Unity3D实现攻击范围检测的具体代码，供大家参考，具体内容如下 一、扇形攻击范围检测 using UnityEngine; using System.Collections; public class AttackCHeck : MonoBehaviour { //要攻击的目标 public Transform Target; //扇形距离 攻击距离 扇形的半径 private float SkillDistance = 5; //扇形的角度 也就是攻击的角度 private float SkillJiaodu = 60; private void Up
[Godot]用GDScript实现《杀戮尖塔》的指向施法箭头（贝塞尔曲线）
WuYiWoYi的博客
03-08 1905
三界贝塞尔曲线实现《杀戮尖塔》的施法效果。
Unity实现杀戮尖塔出牌效果（二.鼠标指向卡牌时，卡牌强调动画）
qq_33894287的博客
03-04 1246
鼠标指向卡牌时，卡牌强调动画设计与制作
Unity用Dotween实现翻牌效果
gzwd博客
07-08 2436
Dotween练习，常用的几个API都有使用，平时使用的话是足够的 导出下载在这里 效果图： 由于CSDN积分问题我就不上资源了 ，上代码吧，预制体什么点自己预设一下吧 using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.UI; using D...
Unity杀戮尖塔地图算法实现
qq_33894287的博客
04-11 1516
一. 地图房间生成规则 ①房间数量规则 ②房间位置 二. 路线生成规则 ①获取当前房间最近的上层房间 ②断路检索
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值