【Unity教程】从0编程制作类银河恶魔城游戏_哔哩哔哩_bilibili

教程源地址：https://www.udemy.com/course/2d-rpg-alexdev/

为黑洞技能增加了额外的特效

BlackHole_Skill_Controller.cs

功能概要：

1. 黑洞技能的初始化与配置

• SetupBlackhole: 设置黑洞技能的基本参数，包括最大尺寸、增长速度、缩小速度、攻击次数、冷却时间以及黑洞持续时间。
• 参数支持不同技能效果的灵活调整，比如通过判断是否使用水晶代替克隆来调整技能逻辑。

2. 黑洞的增长与缩小逻辑

• 黑洞在激活时可以逐渐变大（canGrow），达到最大尺寸。
• 在技能结束时，黑洞会逐渐缩小（canShrink），直至被销毁。

3. 敌人交互

• 敌人冻结： 当敌人进入黑洞范围时，通过 OnTriggerEnter2D 冻结敌人（调用 FreezeTime(true)）。
• 敌人释放： 当敌人离开黑洞范围时，通过 OnTriggerExit2D 解除冻结（调用 FreezeTime(false)）。
• 将进入范围的敌人存储在 targets 列表中，方便后续逻辑处理。

4. 克隆攻击逻辑

• 当技能释放时，黑洞可以执行克隆攻击：
  • RealseCloneAttack: 执行一次克隆攻击，消耗目标列表中的一个敌人。
  • 随机选择目标： 每次攻击从目标列表中随机选择一个敌人进行攻击。
  • 冷却机制： 每次攻击需要冷却（cloneAttackCooldown），直到攻击次数耗尽。
  • 多种攻击方式： 根据配置选择用克隆体还是水晶进行攻击。

5. 热键机制

• 在黑洞范围内，每个敌人会生成一个 热键图标，按下对应按键可以释放攻击。
• 热键生成与管理：
  • CreatHotKey: 为每个敌人生成一个热键并与敌人绑定。
  • 热键清理： 在技能结束或特定逻辑中，调用 DestroyHotKeys 销毁所有热键。

6. 技能结束

• FinishBlackHoleAbility: 技能结束时清理热键、允许玩家退出状态、启动黑洞缩小逻辑，并重置相关标志。

using System.Collections.Generic;
using UnityEngine;



//2024年10月22日
public class BlackHole_Skill_Controller : MonoBehaviour
{
    [SerializeField] private GameObject hotkeyPrefab;
    [SerializeField] private List<KeyCode> keyCodeList;

    private float maxSize;
    private float growSpeed;
    private float shrinkSpeed;
    private float blackholeTimer;


    private bool canGrow = true;//换成private进行传递
    private bool canShrink;//= false保险起见我自己添加的
    private bool canCreateHotkeys = true;
    private bool cloneAttackReleased;
    private bool playerCanDisapear = true;//产生黑洞玩家默认消失


    private int amountOfAttacks = 4;
    private float cloneAttackCooldown = .3f;
    private float cloneAttackTimer;


    private List<Transform> targets = new List<Transform>();
    private List<GameObject> createdHotKey = new List<GameObject>();

    public bool playerCanExitState { get; private set; }

    public void SetupBlackhole(float _maxSize, float _growSpeed, float _shrinkSpeed, int _amountOfAttacks, float _cloneAttackCooldown, float _blackholeDuration)
    {
        maxSize = _maxSize;
        growSpeed = _growSpeed;
        shrinkSpeed = _shrinkSpeed;
        amountOfAttacks = _amountOfAttacks;
        cloneAttackCooldown = _cloneAttackCooldown;

        blackholeTimer = _blackholeDuration;

        if (SkillManager.instance.clone.crystalInsteadOfClone)
            playerCanDisapear = false;
    }


    private void Update()
    {
        cloneAttackTimer -= Time.deltaTime;// 修正了这里的时间减少方式
        blackholeTimer -= Time.deltaTime;

        if (blackholeTimer < 0)
        {
            blackholeTimer = Mathf.Infinity;

            if (targets.Count > 0)
                RealseCloneAttack();
            else
                FinishBlackHoleAbility();

        }



        if (Input.GetKeyDown(KeyCode.R))
        {
            RealseCloneAttack();
        }

        CloneAttackLogic();

        if (canGrow && !canShrink)//变大函数
        {
            transform.localScale = Vector2.Lerp(transform.localScale, new Vector2(maxSize, maxSize), growSpeed * Time.deltaTime);//Vector2.Lerp 是 Unity 中的一个插值函数，用于在两个 Vector2 之间进行线性插值。
        }

        if (canShrink)
        {
            transform.localScale = Vector2.Lerp(transform.localScale, new Vector2(-1, 1), shrinkSpeed * Time.deltaTime);

            if (transform.localScale.x < 0)
                Destroy(gameObject);
        }
    }


    private void RealseCloneAttack()
    {
        if (targets.Count <= 0)
            return;

        DestroyHotKeys();
        cloneAttackReleased = true;
        canCreateHotkeys = false;

        if (playerCanDisapear)
        {
            playerCanDisapear = false;
            PlayerManager.instance.player.fx.MakeTransprent(true);
        }
    }

    private void CloneAttackLogic()
    {
        if (cloneAttackTimer < 0 && cloneAttackReleased && amountOfAttacks > 0)//如果时间小于0并且克隆攻击释放并且攻击次数大于0
        {
            cloneAttackTimer = cloneAttackCooldown;

            int randomIndex = Random.Range(0, targets.Count);//随机选择一个敌人

            float xOffset;//随机选择一个偏移量

            if (Random.Range(0, 100) > 50)
                xOffset = 2;
            else
                xOffset = -2;


            if (SkillManager.instance.clone.crystalInsteadOfClone)//如果选择了水晶代替克隆
            {
                SkillManager.instance.crystal.CreateCrystal();
                SkillManager.instance.crystal.CurrentCrystalChooseRandomTarget();//随机选择敌人
            }
            else
            {
                SkillManager.instance.clone.CreateClone(targets[randomIndex], new Vector3(xOffset, 0, 0));
            }

            amountOfAttacks--;

            if (amountOfAttacks <= 0)
            {
                Invoke("FinishBlackHoleAbility", .5f);//延时调用
            }
        }
    }

    private void FinishBlackHoleAbility()
    {
        DestroyHotKeys();
        playerCanExitState = true;
        canShrink = true;
        cloneAttackReleased = false;
    }



    private void OnTriggerEnter2D(Collider2D collision)//碰到敌人把他们加入到targets中
    {
        if (collision.GetComponent<Enemy>() != null)
        {
            collision.GetComponent<Enemy>().FreezeTime(true);

            CreatHotKey(collision);

        }
    }

    private void OnTriggerExit2D(Collider2D collision)//private void ontriggerexit2d(collider2d collision) => collision.getcomponent<enemy>()?.freezetime(false);
    {
        if (collision.GetComponent<Enemy>() != null)
            collision.GetComponent<Enemy>().FreezeTime(false);
    }




    private void CreatHotKey(Collider2D collision)
    {
        if (keyCodeList.Count <= 0)
        {
            Debug.LogWarning("Not enough hot keys");
            return;
        }

        if (!canCreateHotkeys)
            return;

        GameObject newHotKey = Instantiate(hotkeyPrefab, collision.transform.position + new Vector3(0, 2), Quaternion.identity);
        createdHotKey.Add(newHotKey);

        //随机KeyCode传给HotKey，并且传过去一个毁掉一个
        KeyCode choosenKey = keyCodeList[Random.Range(0, keyCodeList.Count)];

        keyCodeList.Remove(choosenKey);


        Blackhole_HotKey_Controller newHotKeyScript = newHotKey.GetComponent<Blackhole_HotKey_Controller>();


        newHotKeyScript.SetupHotKey(choosenKey, collision.transform, this);
    }

    public void AddEnemyToList(Transform _enemyTransform) => targets.Add(_enemyTransform);

    private void DestroyHotKeys()
    {
        if (createdHotKey.Count <= 0)
            return;

        for (int i = 0; i < createdHotKey.Count; i++)
        {
            Destroy(createdHotKey[i]);
        }
    }
}

Blackhole_Skill.cs

功能概要

1. 技能解锁

• UnlockBlackHole:
  • 通过检测技能树按钮 blackHoleUnlockButton 是否解锁，设置黑洞技能的可用状态（blackHoleUnlocked）。
  • 绑定按钮点击事件（在 Start 中实现）。

2. 技能使用

• UseSkill:
  • 判断技能是否可用，继承自基类的 CanUseSkill 逻辑。
  • 生成一个新的黑洞实例 currentBlackhole，并在玩家位置初始化。
  • 调用 SetupBlackhole 配置新生成黑洞的参数（如尺寸、持续时间、攻击次数等）。
  • 播放音效（通过 AudioManager 调用）。

3. 技能完成状态检测

• SkillCompeleted:
  • 检查当前黑洞是否结束：
    • 如果黑洞存在并允许玩家退出状态（playerCanExitState），则表示技能已完成。
    • 清理引用 currentBlackhole，返回完成状态。

using UnityEngine;
using UnityEngine.UI;

public class Blackhole_Skill : Skill
{

    [SerializeField] private UI_SkillTreeSlot blackHoleUnlockButton;
    public bool blackHoleUnlocked { get; private set; }
    [SerializeField] private int amountOfAttacks;
    [SerializeField] private float cloneCooldown;
    [SerializeField] private float blackholeDuration;
    [Space]
    [SerializeField] private GameObject blackHolePrefab;
    [SerializeField] private float maxSize;
    [SerializeField] private float growSpeed;
    [SerializeField] private float shrinkSpeed;

    BlackHole_Skill_Controller currentBlackhole;//当前的黑洞

  


    private void UnlockBlackHole()
    {
        if (blackHoleUnlockButton.unlocked)
            blackHoleUnlocked =true;
    }

    public override bool CanUseSkill()
    {
        return base.CanUseSkill();
    }


    public override void UseSkill()
    {
        base.UseSkill();//调用了基类 Skill中的 UseSkill 方法

        GameObject newBlackHole = Instantiate(blackHolePrefab, player.transform.position, Quaternion.identity); //这行代码使用 Instantiate 方法在玩家当前位置生成一个新的黑洞对象

        currentBlackhole = newBlackHole.GetComponent<BlackHole_Skill_Controller>();

        currentBlackhole.SetupBlackhole(maxSize, growSpeed, shrinkSpeed, amountOfAttacks, cloneCooldown,blackholeDuration);//调用SetupBlackhole，传递一系列参数来配置黑洞的行为，包括最大尺寸、增长速度、缩小速度、攻击次数和克隆冷却时间

        AudioManager.instance.PlaySFX(3, player.transform);
        AudioManager.instance.PlaySFX(6, player.transform);

    }

    protected override void Start()
    {
        base.Start();

        blackHoleUnlockButton.GetComponent<Button>().onClick.AddListener(UnlockBlackHole);
    }

    protected override void Update()
    {
        base.Update();
    }

    public bool SkillCompeleted()
    {
        if(!currentBlackhole)
        {
            return false;
        }

        if (currentBlackhole.playerCanExitState)
        {
            currentBlackhole = null;
            return true;
        }

        return false;
    }

    public float GetBlackholeRadius()//解决水晶黑洞的攻击范围问题
    {
        return maxSize / 2;
    }

    protected override void CheckUnlock()
    {
        base.CheckUnlock();

        UnlockBlackHole();  
    }
}